Skip to main content

Multi-Supplier Support

QCOS SDK v2.1+ supports multiple quantum cloud providers through a unified API.

Available Suppliers​

  • Azure Quantum: IonQ, Rigetti, Quantinuum, PASQAL
  • IBM Quantum: IBM simulators and QPUs (up to 127 qubits)
  • AWS Braket: Amazon simulators, IonQ, Rigetti, OQC, IQM, QuEra (up to 256 qubits)

List Available Providers​

from softqcos_sdk import QCOSClient

client = QCOSClient(api_key="your-api-key")

# List Azure Quantum providers
azure_providers = client.list_providers("azure_quantum")
for provider in azure_providers:
    print(f"{provider.name}: {provider.num_qubits} qubits ({provider.type})")

# List IBM Quantum backends
ibm_backends = client.list_providers("ibm_quantum")
for backend in ibm_backends:
    print(f"{backend.name}: {backend.num_qubits} qubits")

# List AWS Braket devices
braket_devices = client.list_providers("braket")
for device in braket_devices:
    print(f"{device.name}: {device.num_qubits} qubits ({device.type})")

Execute on Specific Backend​

Azure Quantum​

from softqcos_sdk import QCOSClient

client = QCOSClient(api_key="your-api-key")

qasm = """
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q -> c;
"""

# Execute on IonQ simulator
result = client.execute_on_backend(
    qasm=qasm,
    backend="ionq.simulator",
    supplier="azure_quantum",
    shots=1024
)

print(result.counts)
# {'00': 512, '11': 512}

IBM Quantum​

# Execute on IBM simulator
result = client.execute_on_backend(
    qasm=qasm,
    backend="ibm_simulator",
    supplier="ibm_quantum",
    shots=1024
)

# Execute on IBM Kyoto (127 qubits QPU)
result = client.execute_on_backend(
    qasm=qasm,
    backend="ibm_kyoto",
    supplier="ibm_quantum",
    shots=1024
)

AWS Braket​

# Execute on SV1 simulator (up to 34 qubits)
result = client.execute_on_backend(
    qasm=qasm,
    backend="sv1",
    supplier="braket",
    shots=1024
)

# Execute on QuEra Aquila (256 qubits neutral atom QPU)
result = client.execute_on_backend(
    qasm=qasm,
    backend="Aquila",
    supplier="braket",
    shots=1024
)

Comparing Providers​

import time
from softqcos_sdk import QCOSClient

client = QCOSClient(api_key="your-api-key")

# Test circuit
qasm = """
OPENQASM 2.0;
include "qelib1.inc";
qreg q[3];
creg c[3];
h q[0];
cx q[0],q[1];
cx q[1],q[2];
measure q -> c;
"""

# Compare execution times across suppliers
suppliers = [
    ("azure_quantum", "ionq.simulator"),
    ("ibm_quantum", "ibm_simulator"),
    ("braket", "sv1")
]

for supplier, backend in suppliers:
    start = time.time()
    result = client.execute_on_backend(
        qasm=qasm,
        backend=backend,
        supplier=supplier,
        shots=1000
    )
    elapsed = time.time() - start
    
    print(f"{supplier}/{backend}:")
    print(f"  Time: {elapsed:.2f}s")
    print(f"  Counts: {result.counts}")
    print()

Provider Selection Strategy​

By Qubit Count​

def select_best_provider(num_qubits: int):
    """Select optimal provider based on qubit count."""
    
    if num_qubits <= 11:
        # Use free simulators or small QPUs
        return ("braket", "sv1")  # Free up to 34 qubits
    
    elif num_qubits <= 50:
        # Medium circuits
        return ("azure_quantum", "ionq.simulator")
    
    elif num_qubits <= 127:
        # Large circuits - use IBM QPUs
        return ("ibm_quantum", "ibm_kyoto")
    
    else:
        # Very large circuits - QuEra Aquila (256 qubits)
        return ("braket", "Aquila")

By Cost​

def select_cheapest_provider(num_qubits: int, shots: int):
    """Select most cost-effective provider."""
    
    # Simulators (free or low cost)
    if num_qubits <= 34:
        return ("braket", "sv1")  # AWS Braket SV1 simulator
    
    # For QPU access, AWS Braket often has lower rates
    return ("braket", "IonQ Aria")

By Performance​

def select_fastest_provider():
    """Select provider with lowest latency."""
    
    # Azure Quantum typically has lowest latency
    return ("azure_quantum", "ionq.simulator")

Best Practices​

  1. Use simulators for development: Test circuits on free simulators before QPU execution
  2. Monitor costs: QPU time can be expensive - estimate costs before execution
  3. Consider latency: Azure Quantum typically has lowest latency for simulators
  4. Maximize qubits: Use QuEra Aquila (256q) for largest circuits
  5. Fallback strategy: Implement retry logic with alternative suppliers

Error Handling​

from softqcos_sdk import QCOSClient, QCOSError

client = QCOSClient(api_key="your-api-key")

# Fallback strategy
suppliers = [
    ("azure_quantum", "ionq.simulator"),
    ("ibm_quantum", "ibm_simulator"),
    ("braket", "sv1")
]

for supplier, backend in suppliers:
    try:
        result = client.execute_on_backend(
            qasm=qasm,
            backend=backend,
            supplier=supplier,
            shots=1024
        )
        print(f"Success with {supplier}/{backend}")
        break
    except QCOSError as e:
        print(f"Failed {supplier}/{backend}: {e}")
        continue

Next Steps​