Crate logosq_hardware_integrator 

LogosQ Hardware Integrator

A Rust crate for integrating LogosQ with quantum hardware providers, enabling seamless transitions from simulation to real QPU execution.

Overview

This crate provides a unified, type-safe interface for submitting quantum circuits to various hardware backends including IBM Quantum, IonQ, Google Quantum AI, and Rigetti. It leverages Rust’s safety guarantees to prevent invalid circuit submissions at compile time and provides robust error handling for network and job queuing operations.

Key Benefits

• Compile-time verified circuits: Type system prevents invalid gate sequences
• Async support: Non-blocking job submission and result polling via Tokio
• Backend-agnostic design: Write once, run on any supported QPU
• Memory safety: No data races in concurrent job management

Comparison to Python SDKs

Feature	LogosQ-Hardware-Integrator	Qiskit
Type Safety	Compile-time	Runtime
Async Native	Yes (Tokio)	Limited
Memory Safety	Guaranteed	GC-dependent
Submission Latency	~50ms	~150ms

Installation

Add to your Cargo.toml:

[dependencies]
logosq-hardware-integrator = "0.1"
tokio = { version = "1.35", features = ["full"] }

Feature Flags

• ibm (default): IBM Quantum backend support
• ionq (default): IonQ backend support
• google: Google Quantum AI support
• rigetti: Rigetti QCS support
• full: All backends

Environment Setup

Set your API keys as environment variables:

export IBM_QUANTUM_TOKEN="your_ibm_token"
export IONQ_API_KEY="your_ionq_key"

Minimum Rust Version: 1.70

Quick Start

Submit a Bell state circuit to IBM Quantum:

use logosq_hardware_integrator::{IbmBackend, HardwareBackend, Circuit, JobStatus};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Authenticate with IBM Quantum
    let backend = IbmBackend::new_from_env().await?;
     
    // Build a Bell state circuit (type-checked at compile time)
    let circuit = Circuit::new(2)
        .h(0)        // Hadamard on qubit 0
        .cx(0, 1)    // CNOT from qubit 0 to 1
        .measure_all();
     
    // Submit job - invalid circuits won't compile
    let job = backend.submit_circuit(&circuit, 1024).await?;
    println!("Job ID: {}", job.id());
     
    // Poll for results with automatic retry
    let result = job.wait_for_result().await?;
    println!("Counts: {:?}", result.counts());
     
    Ok(())
}

Supported Hardware Providers

IBM Quantum

• Devices: ibm_brisbane, ibm_kyoto, ibm_osaka (127 qubits)
• Gate Set: CX, ID, RZ, SX, X
• Calibration: Auto-fetched daily; use backend.calibration() for live data
• Limitations: Max 100 circuits per job, 20,000 shots

IonQ

• Devices: Harmony (11 qubits), Aria (25 qubits)
• Gate Set: Native trapped-ion gates (MS, GPi, GPi2)
• All-to-all connectivity: No SWAP overhead

Google Quantum AI

• Devices: Sycamore (53 qubits)
• Gate Set: √iSWAP, Phased-XZ
• Requires: Google Cloud credentials

Error Handling

use logosq_hardware_integrator::{HardwareError, Circuit, Job};

// Handle different error types
fn handle_error(err: HardwareError) {
    match err {
        HardwareError::ConnectionFailed { .. } => println!("Connection failed"),
        HardwareError::AuthenticationFailed { .. } => println!("Auth failed"),
        _ => println!("Other error: {}", err),
    }
}

Performance Benchmarks

Operation	LogosQ	Qiskit	Speedup
Circuit Serialization	2.1ms	8.4ms	4.0x
Job Submission	48ms	156ms	3.3x
Result Parsing	0.8ms	3.2ms	4.0x

Benchmarks run on AMD Ryzen 9 5900X, 1Gbps connection.

Contributing

To add a new backend:

1. Implement the HardwareBackend trait
2. Add provider-specific error variants to HardwareError
3. Include integration tests in tests/
4. Document calibration handling and gate set limitations

Run tests: cargo test --all-features

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.

Changelog

v0.1.0

• Initial release with IBM Quantum and IonQ support
• Async job submission and polling
• Compile-time circuit validation

Structs

CalibrationData

Device calibration data including gate fidelities and coherence times.

Circuit

A quantum circuit with compile-time validated structure.

DeviceInfo

Information about a quantum device.

IbmBackend

IBM Quantum backend implementation.

IonqBackend

IonQ backend implementation.

Job

A handle to a submitted quantum job.

JobResult

Results from a completed quantum job.

QubitCalibration

Calibration data for a single qubit.

Enums

DeviceStatus

Device availability status.

Gate

Quantum gate operations.

HardwareError

Errors that can occur during hardware interactions.

JobStatus

Status of a quantum job.

Traits

HardwareBackend

Primary trait for quantum hardware backends.