Orbit - una Qiskit Function di Quantum Elements

Consulta il riferimento API

Note

Le Qiskit Function sono una funzionalità sperimentale disponibile solo per gli utenti dei piani IBM Quantum® Premium Plan, Flex Plan e On-Prem (tramite IBM Quantum Platform API). Sono in stato di preview release e soggette a modifiche.

Panoramica

L'hardware quantistico continua a progredire, ma il rumore e la decoerenza continuano a limitare la profondità e l'affidabilità dei circuiti quantistici pratici. Tra gli approcci disponibili, tre tecniche complementari possono mitigare sostanzialmente queste limitazioni: il disaccoppiamento dinamico (DD), la transpilazione ottimizzata e la mitigazione degli errori di misurazione (MEM). La transpilazione ottimizzata riduce la profondità dei circuiti e allinea meglio i circuiti alla connettività dell'hardware di destinazione, il DD sopprime il rumore nei tempi di inattività attraverso sequenze di controllo progettate con cura, e il MEM riduce gli effetti degli errori di lettura e può essere applicato durante il post-elaborazione.

Selezionare una strategia DD efficace è particolarmente complesso perché sono disponibili numerose famiglie di sequenze, e una sequenza che funziona bene per un circuito o un ambiente di rumore potrebbe non funzionare bene per un altro. I benefici della transpilazione, del DD e del MEM dipendono dal problema, dall'hardware e dal carico di lavoro; usati singolarmente o in combinazione, possono migliorare le prestazioni, ma non sono universalmente vantaggiosi in ogni configurazione.

Orbit, una Qiskit Function sviluppata da Quantum Elements, combina in modo fluido tutti e tre i componenti in un flusso di lavoro unificato, rendendoli facili da usare per migliorare l'esecuzione dei circuiti sull'hardware IBM Quantum. Nella sua forma principale, Orbit applica automaticamente strategie attive di soppressione degli errori che proteggono gli stati quantistici durante i periodi di inattività, preservando la logica originale del circuito. In particolare, lo fa senza introdurre alcun tempo aggiuntivo di pre-elaborazione quantistica o classica, evitando così costi aggiuntivi non necessari o tempi di attesa all'interno del flusso di lavoro.

Invece di funzionare come una scatola nera, Orbit consente agli utenti di valutare e mettere a punto i suoi componenti di ottimizzazione per un esperimento specifico. Gli utenti possono abilitare o disabilitare in modo indipendente la transpilazione ottimizzata, il DD e il MEM; confrontare la selezione automatica del DD con sequenze specificate dall'utente; ed eseguire più configurazioni all'interno dello stesso flusso di lavoro. Confrontando ogni configurazione con il circuito grezzo, gli utenti possono determinare quali tecniche offrono benefici misurabili per il loro circuito e backend, identificare le interazioni tra i diversi metodi di ottimizzazione, e selezionare la configurazione che meglio supporta il loro obiettivo sperimentale. Questo processo guida gli utenti nel comprendere da dove derivano i miglioramenti delle prestazioni e nel prendere decisioni più informate quando ottimizzano i circuiti quantistici per un determinato carico di lavoro.

Descrizione

Orbit è progettato per migliorare l'esecuzione dei circuiti quantistici sui backend IBM Quantum. In modalità automatica, gli utenti possono applicare senza problemi sequenze DD robuste di ordine elevato senza doverle selezionare o configurare manualmente. Gli utenti avanzati possono invece sperimentare con le sequenze di ordine superiore disponibili per identificare e ottimizzare l'approccio che offre le migliori prestazioni per uno specifico circuito.

Orbit fornisce anche MEM istantaneo senza richiedere i job aggiuntivi tipicamente necessari per flussi di lavoro separati di calibrazione e mitigazione. Per i carichi di lavoro in cui la transpilazione non deve alterare la struttura del circuito, come i circuiti di correzione degli errori quantistici con misurazioni mid-circuit o i circuiti dinamici, Orbit può applicare DD e MEM senza interferire con la strategia di transpilazione già esistente dell'utente. Per gli utenti che non hanno già un approccio preferito, Orbit include anche un transpiler integrato per ottimizzare i circuiti per l'hardware di destinazione prima di applicare le tecniche di soppressione degli errori e mitigazione della lettura.

A differenza degli approcci che si basano su campionamenti aggiuntivi del circuito, estrapolazione o estesa post-elaborazione classica, Orbit si concentra sulla soppressione degli errori durante l'esecuzione. La funzione è progettata per introdurre un basso overhead preservando la logica originale del circuito. Gli utenti possono ispezionare il circuito risultante e confrontare direttamente le esecuzioni ottimizzate con Orbit con le esecuzioni standard.

Un flusso di lavoro pratico di Orbit è:

1. Definisci un circuito quantistico e seleziona Orbit tramite il Catalogo delle Qiskit Function.

2. Includi il circuito senza Orbit usando la modalità 'Raw' per stabilire una baseline con il circuito grezzo.

3. Scegli quali strategie di ottimizzazione applicare, comprese le sequenze DD automatiche o selezionate dall'utente, il MEM e la transpilazione ottimizzata.

4. Abilita o disabilita i singoli metodi, oppure invia più configurazioni, per valutarne gli effetti separati e combinati.

Orbit è particolarmente utile per i circuiti che contengono periodi di inattività o intervalli di pianificazione in cui i qubit non partecipano attivamente ai gate. Supporta circuiti statici e dinamici, inclusi i flussi di lavoro con misurazioni mid-circuit ed esperimenti di calcolo quantistico fault-tolerant. Le applicazioni tipiche includono la correzione degli errori quantistici, esperimenti di surface-code su reticoli quadrati ed heavy-hex, algoritmi oracolari come Bernstein-Vazirani, circuiti di trasformata di Fourier, algoritmi quantistici variazionali, simulazione hamiltoniana, esperimenti di benchmarking e ottimizzazione dei circuiti consapevole dell'hardware.

Guardando all'era della tolleranza ai guasti, Orbit è anche compatibile con i flussi di lavoro di calcolo quantistico fault-tolerant, poiché può essere combinato senza problemi con la correzione degli errori quantistici. Nel lungo termine, Orbit punta verso il disaccoppiamento dinamico a livello logico [1] come percorso orientato al futuro per proteggere i qubit logici. Nell'esempio seguente, due qubit logici sono stati messi in entanglement per creare uno stato di Bell logico sotto rilevazione di errori quantistici. La sola rilevazione di errori quantistici ha portato la fedeltà dello stato di Bell a decadere fino a circa il 44% nell'arco di decine di microsecondi, mentre il QED combinato con la protezione in stile Orbit ha mantenuto la fedeltà dello stato di Bell logico vicino alla parte superiore della scala, raggiungendo circa il 95,3% nella stessa finestra temporale.

Benchmark

I risultati seguenti riassumono esecuzioni rappresentative di Orbit su hardware IBM Quantum. Come per altri benchmark hardware, i risultati dipendono dal dispositivo selezionato, dallo stato di calibrazione, dal circuito e dalle impostazioni di esecuzione.

Esempio	Metrica	Qubit	QPU	Dettagli aggiuntivi	Miglioramento Orbit
Bernstein–Vazirani	Hidden-bitstring fidelity	26 60 70	Heron r3	Raw versus Full Orbit, Transpilation only versus Full Orbit, Full Orbit Only	75x 66x N/A
QFT (unitary)	Fidelity	10	Heron r2 Heron r3	Orbit versus raw: ~44% versus ~35% ~67% versus ~61%	1.26x 1.09x
QFT (dynamic circuits)	Fidelity	10 20	Heron r3	Orbit versus raw: ~55% versus ~2% ~10% versus ~0%	27.51x N/A
Long-range Bell state (dynamic circuits)	Fidelity	30 60	Heron r2	N/A	1.78x 1.11x
Surface code (square lattice)	Logical error probability	25	Nighthawk r1	1 round 5 rounds 10 rounds	1.01x 1.15x 1.12x
Surface code (heavy-hex)	Logical error probability	65	Heron r3	1 round 5 rounds 10 rounds	4.11x 2.04x 1.39x
VQE	Absolute error relative to the ideal energy	8	Heron r3	Orbit versus raw: 56mHa versus 1342 mHa	24x
QAOA	Success probability	5	Heron r2	N/A	1.46x
[[4,2,2]] code (logical-level error suppression)	Entangled Bell-state logical fidelity	4	Heron r2	Average fidelity over 55 μs	1.63x

Definizioni delle metriche

• Fedeltà della bitstring nascosta di Bernstein–Vazirani: Probabilità di misurare la bitstring nascosta corretta. Questa metrica indica quanto affidabilmente l'algoritmo recupera la soluzione prevista all'aumentare della dimensione del circuito. La tabella riporta le tre bitstring nascoste più grandi valutate con successo in tre diverse configurazioni: (i), circuiti grezzi senza Orbit, che hanno raggiunto 26 qubit; (ii), circuiti con sola transpilazione, che hanno raggiunto 60 qubit; e (iii), circuiti che usano il flusso di lavoro completo di Orbit, che hanno raggiunto 70 qubit. Per i circuiti grezzi (i), il fattore di miglioramento rappresenta il guadagno di prestazioni ottenuto da DD e MEM rispetto ai circuiti non modificati. Per la configurazione con sola transpilazione (ii), rappresenta il miglioramento ottenuto aggiungendo DD e MEM ai circuiti transpilati in modo ottimale. Per la configurazione Orbit completa (iii), non viene riportato alcun fattore di miglioramento di base perché una probabilità di successo diversa da zero è stata ottenuta solo quando tutti i componenti di Orbit (transpilazione, DD e MEM) erano abilitati. Di seguito viene fornito un esempio illustrativo.

• Fedeltà della trasformata di Fourier quantistica: Per entrambe le implementazioni QFT, unitaria e a circuiti dinamici [2], la fedeltà misura la corrispondenza tra la trasformazione implementata sperimentalmente e il processo QFT ideale su 20 diversi stati di input. I circuiti dinamici contengono una notevole quantità di tempo di inattività dovuta alle misurazioni mid-circuit e al feedforward classico, durante il quale il disaccoppiamento dinamico può sopprimere la decoerenza. Il miglioramento riportato confronta la fedeltà ottenuta con Orbit rispetto alla fedeltà grezza.

• Preparazione dello stato di Bell a lungo raggio: Creazione di uno stato di Bell usando circuiti dinamici e operazioni di feedforward tra due qubit separati da fino a 60 qubit intermedi, dimostrando così un entanglement efficiente a lungo raggio su hardware quantistico connesso localmente [3]. Orbit identifica il miglior instradamento dei qubit, preserva i qubit durante le misurazioni di feedforward e applica MEM per mitigare gli errori di lettura.

• Probabilità di errore logico del surface code: Per il surface code heavy-hex [4] e il surface code a reticolo quadrato [5], sono stati eseguiti esperimenti di memoria quantistica in cui uno stato logico codificato è stato preservato attraverso ripetuti round di correzione degli errori. La probabilità di errore logico misura la probabilità che gli errori accumulati causino un recupero errato dell'informazione codificata (un errore più basso è migliore). Il miglioramento riportato confronta la probabilità di errore logico dei circuiti grezzi con quella ottenuta con Orbit.

• Errore assoluto VQE: Usando VQE con un ansatz unitary coupled-cluster ottimizzato per stimare l'energia dello stato fondamentale di LiH [6]. L'energia misurata viene confrontata con la corrispondente energia ideale ottenuta dal circuito senza rumore. La metrica è la differenza assoluta tra le energie misurata e ideale (valori più bassi sono migliori). Il miglioramento riportato è:

$$\text{Improvement factor} = \frac{|E_{\mathrm{raw}}-E_{\mathrm{ideal}}|} {|E_{\mathrm{Orbit}}-E_{\mathrm{ideal}}|}.$$

Valori maggiori di uno indicano che Orbit riduce l'errore energetico rispetto all'esecuzione senza disaccoppiamento dinamico.

• Probabilità di successo QAOA: Probabilità di misurare una bitstring corrispondente a una soluzione ottimale del problema di ottimizzazione definito sul grafo a farfalla. Il miglioramento riportato confronta la probabilità di successo ottenuta con Orbit rispetto a quella ottenuta dai circuiti grezzi.

• Fedeltà logica: Nell'esperimento di disaccoppiamento dinamico logico [[4,2,2]] [1], due qubit logici sono stati codificati in quattro qubit fisici e preparati come stato di Bell logico in entanglement. La fedeltà logica misura la corrispondenza tra lo stato codificato recuperato e lo stato di Bell logico target. Il miglioramento riportato confronta la fedeltà logica media ottenuta con Orbit e la rilevazione degli errori (capacità del codice) con quella ottenuta usando solo il codice da solo.

Per iniziare

Autenticati usando la tua chiave API di IBM Quantum Platform, e seleziona la funzione Orbit come segue. Questo snippet presuppone che tu abbia già salvato il tuo account nel tuo ambiente locale.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib qiskit qiskit-ibm-catalog

from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit import QuantumCircuit

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Verify that you have access to the function.
catalog.list()

[QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")

Esempio

L'esempio seguente costruisce un circuito di Bernstein-Vazirani e lo invia a Orbit in due modi in un unico job: esecuzione grezza e impostazioni predefinite di Orbit.

Usa questo schema quando vuoi un confronto diretto tra grezzo e Orbit.

Costruire un circuito di Bernstein-Vazirani

Scegli la bitstring nascosta e costruisci il circuito logico. Il qubit extra è il target dell'oracolo, mentre i qubit di input vengono misurati.

def create_bv_circuit(hidden_bitstring: str) -> QuantumCircuit:
    width = len(hidden_bitstring)
    circuit = QuantumCircuit(width + 1, width)

    circuit.x(width)
    circuit.h(range(width + 1))

    for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
        if bit == "1":
            circuit.cx(input_qubit, width)

    circuit.barrier()
    circuit.h(range(width + 1))
    circuit.measure(range(width), range(width))
    return circuit

circuit_width = 50
hidden_bitstring = "1" * circuit_width
shots = 4096

bv_circuit = create_bv_circuit(hidden_bitstring)
bv_circuit.count_ops()

OrderedDict([('h', 102),
             ('cx', 50),
             ('measure', 50),
             ('x', 1),
             ('barrier', 1)])

Preparare il carico di lavoro Orbit

Crea un PUB Sampler, quindi duplicalo per le due modalità di confronto. Orbit riceve il circuito logico e lo mappa sul backend selezionato durante l'esecuzione.

base_pub = (bv_circuit, None, shots)
comparison_labels = ["raw", "orbit"]
pubs = [base_pub] * len(comparison_labels)

Eseguire grezzo e le impostazioni predefinite di Orbit

pub_options assegna il primo PUB alla modalità grezza, che salta l'ottimizzazione di Orbit, il DD e il MEM, e assegna il secondo PUB alle impostazioni predefinite di Orbit, che includono transpilazione ottimizzata, inserimento automatico del disaccoppiamento dinamico (DD) e mitigazione degli errori di misurazione (MEM).

backend_name = "ibm_kingston"

job = orbit.run(
    primitive="sampler",
    pubs=pubs,
    backend_name=backend_name,
    options={
        "pub_options": [
            {"mode": "raw"},
            {"mode": "orbit"},
        ],
        "save_backend_info": True,
    },
)

# Check the job ID and status
print(job.job_id)
print(job.status())

c0f1b99c-8dfa-4ebb-9560-d9a37c990acc
QUEUED

Recupera il risultato e confronta i circuiti grezzi e quelli migliorati con Orbit usando i conteggi. Per i risultati Sampler, get_counts() sul registro classico restituito fornisce l'istogramma di output. Quando il MEM ha successo per il PUB Orbit, questo istogramma è già corretto con MEM; i conteggi non mitigati restano disponibili nei metadati di Orbit sotto measurementErrorMitigation["rawCounts"].

def extract_counts(pub_result) -> dict[str, int]:
    data = getattr(pub_result, "data", None)
    if data is None:
        raise TypeError("pub_result.data is missing")

    for name in dir(data):
        if name.startswith("_"):
            continue
        register = getattr(data, name)
        get_counts = getattr(register, "get_counts", None)
        if callable(get_counts):
            counts = get_counts()
            if counts:
                return counts

    raise TypeError(
        "No classical register with get_counts() found in pub_result.data"
    )

result = job.result()
if len(result) != len(comparison_labels):
    raise RuntimeError(
        f"Expected {len(comparison_labels)} PUB results, received {len(result)}."
    )

comparison_counts = {
    label: extract_counts(pub_result)
    for label, pub_result in zip(comparison_labels, result, strict=True)
}
correct_counts = {
    label: counts.get(hidden_bitstring, 0)
    for label, counts in comparison_counts.items()
}

print(
    {
        "hidden_bitstring": hidden_bitstring,
        "correct_counts": correct_counts,
        "shots": shots,
    }
)

{'hidden_bitstring': '11111111111111111111111111111111111111111111111111', 'correct_counts': {'raw': 0, 'orbit': 184}, 'shots': 4096}

Fai un confronto visivo dei circuiti grezzi e di quelli migliorati con Orbit.

import matplotlib.pyplot as plt

labels = list(correct_counts)
values = list(correct_counts.values())
fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.bar(labels, values, width=0.55)
ax.bar_label(bars, labels=[f"{value:g}" for value in values], padding=3)
ax.set_xlabel("Circuit execution mode")
ax.set_ylabel("Correct hidden-bitstring count")
ax.set_title(f"{circuit_width}-qubit Bernstein-Vazirani on {backend_name}")
ax.set_ylim(0, max(1, 1.15 * max(values)))
ax.grid(axis="y", alpha=0.25)
fig.tight_layout()
plt.show()

Ottenere supporto

Contatta il supporto di Quantum Elements: info@quantumelements.ai

Assicurati di includere le seguenti informazioni:

• ID job della Qiskit Function (qiskit-ibm-catalog), job.job_id

• Nome del backend

• pub_options di Orbit usate per le modalità grezza e Orbit

• Una descrizione dettagliata del problema

• Eventuali messaggi o codici di errore rilevanti

• Passaggi per riprodurre il problema

Prossimi passi

Recommendations

• Prova un backend diverso, un numero di qubit diverso o un'altra bitstring nascosta.

• Leggi il nostro tutorial sulla trasformata di Fourier quantistica per scoprire come definire strategie DD personalizzate abilitate da Orbit, oltre ad applicare il DD ai circuiti dinamici con misurazioni mid-circuit e operazioni di feedforward.

• Visita il riferimento API per una descrizione dettagliata di tutte le opzioni di Orbit.

Riferimenti

1. Logical-level error suppression combined with Quantum Error Detection, Nature Communications (2026)

2. Quantum Fourier Transform Using Dynamic Circuits, Physical Review Letters (2024)

3. Efficient Long-Range Entanglement Using Dynamic Circuits, PRX Quantum (2024)

4. Surface code scaling experiments on IBM Heron with heavy-hex connectivity, arXiv:2510.18847

5. Surface code experiments on IBM Nighthawk with square-lattice connectivity, arXiv:2606.11496

6. VQE benchmark reference, Nature Physics (2024)