Orbit - una funzione Qiskit sviluppata da Quantum Elements

Consulta la guida alle API

Panoramica

L'hardware quantistico continua a progredire, ma il rumore e la decoerenza continuano a limitare la complessità e l'affidabilità dei circuiti quantistici applicabili nella pratica. Tra gli approcci disponibili, tre tecniche complementari possono mitigare in modo sostanziale tali 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 ne migliora l'allineamento con la connettività dell'hardware di destinazione; la tecnica DD sopprime il rumore da inattività grazie a sequenze di controllo progettate con cura, mentre la tecnica MEM riduce gli effetti degli errori di lettura e può essere applicata durante la post-elaborazione.

La scelta di una strategia di DD efficace è particolarmente complessa, poiché sono disponibili numerose famiglie di sequenze e una sequenza che funziona bene per un determinato circuito o ambiente di rumore potrebbe non dare buoni risultati in un altro contesto. I vantaggi della transpilation, del DD e del MEM dipendono dal problema, dall'hardware e dal carico di lavoro; utilizzati singolarmente o in combinazione, possono migliorare le prestazioni, ma non offrono benefici universali in ogni configurazione.

Orbit, una funzione Qiskit sviluppata da Quantum Elements, integra perfettamente tutte e tre le componenti in un flusso di lavoro unificato, rendendole di facile utilizzo per migliorare l'esecuzione dei circuiti sull'hardware dell' IBM Quantum. Nella sua forma base, Orbit applica automaticamente strategie di soppressione degli errori che proteggono gli stati quantistici durante i periodi di inattività, preservando al contempo la logica originale del circuito. In particolare, ciò avviene senza comportare alcun tempo aggiuntivo di pre-elaborazione, né quantistica né classica, evitando così costi aggiuntivi superflui o tempi di attesa nel flusso di lavoro.

Anziché 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 attivare o disattivare autonomamente la transpilazione ottimizzata, il DD e il MEM; confrontare la selezione automatica del DD con le sequenze specificate dall'utente; ed eseguire più configurazioni all'interno dello stesso flusso di lavoro. Confrontando ciascuna configurazione con il circuito grezzo, gli utenti possono determinare quali tecniche offrano vantaggi misurabili per il proprio circuito e il proprio backend, identificare le interazioni tra i diversi metodi di ottimizzazione e selezionare la configurazione che meglio supporti il proprio obiettivo sperimentale. Questo processo aiuta gli utenti a comprendere da dove derivano i miglioramenti delle prestazioni e a prendere decisioni più consapevoli nell'ottimizzazione dei circuiti quantistici per un determinato carico di lavoro.

Descrizione

Orbit è stato progettato per ottimizzare l'esecuzione dei circuiti quantistici su backend di tip IBM Quantum. In modalità automatica, gli utenti possono applicare senza soluzione di continuità sequenze DD robuste e di ordine elevato senza doverle selezionare o configurare manualmente. Gli utenti esperti possono invece sperimentare con le sequenze di ordine superiore disponibili per individuare e ottimizzare l'approccio che garantisce le migliori prestazioni per un circuito specifico.

Orbit fornisce inoltre il MEM istantaneo senza richiedere i processi aggiuntivi solitamente necessari per i 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 a metà circuito o i circuiti dinamici, Orbit può applicare le tecniche DD e MEM senza interferire con la strategia di transpilazione esistente dell'utente. Per gli utenti che non hanno ancora un approccio preferito, Orbit include anche un transpiler integrato che ottimizza i circuiti per l'hardware di destinazione prima di applicare le tecniche di soppressione degli errori e di mitigazione della lettura.

A differenza degli approcci che si basano su un campionamento aggiuntivo dei circuiti, sull’estrapolazione o su un’estesa post-elaborazione classica, Orbit punta a ridurre gli errori durante l’esecuzione. La funzione è stata progettata per ridurre al minimo l'overhead, preservando al contempo la logica originale del circuito. Gli utenti possono esaminare il circuito risultante e confrontare direttamente le esecuzioni ottimizzate con Orbit con quelle standard.

Ecco un esempio pratico di flusso di lavoro in Orbit:

1. Definire un circuito quantistico e selezionare Orbit tramite l’ Qiskit Functions Catalog (Strumento di simulazione di circuiti quantistici).
2. Includere il circuito senza Orbit utilizzando la modalità "Raw" per stabilire una linea di base del circuito grezzo.
3. Scegliere quali strategie di ottimizzazione applicare, tra cui sequenze DD automatiche o selezionate dall'utente, MEM e transpilazione ottimizzata.
4. Attivare o disattivare singoli metodi oppure inviare più configurazioni per valutarne gli effetti sia separatamente che in combinazione.

Orbit è particolarmente utile per i circuiti che presentano periodi di inattività o lacune nella programmazione in cui i qubit non partecipano attivamente alle operazioni logiche. Supporta circuiti statici e dinamici, compresi flussi di lavoro con misurazioni a metà circuito ed esperimenti di calcolo quantistico tolleranti ai guasti. Tra le applicazioni tipiche figurano la correzione degli errori quantistici, gli esperimenti sui codici di superficie su reticoli quadrati ed esagonali pesanti, algoritmi oracolari come quello di Bernstein-Vazirani, circuiti a trasformata di Fourier, algoritmi quantistici variazionali, simulazione hamiltoniana, esperimenti di benchmarking e ottimizzazione dei circuiti in funzione dell'hardware.

In vista dell’era della tolleranza ai guasti, Orbit è compatibile anche con i flussi di lavoro di calcolo quantistico tolleranti ai guasti, poiché può essere integrato senza soluzione di continuità con la correzione degli errori quantistici. A lungo termine, Orbit punta sul disaccoppiamento dinamico a livello logico [1] come percorso orientato al futuro per la protezione dei qubit logici. Nell'esempio riportato di seguito, due qubit logici sono stati intrecciati per creare uno stato logico di Bell nell'ambito del rilevamento degli errori quantistici. Il solo rilevamento quantistico degli errori ha determinato un decadimento della fedeltà dello stato di Bell fino a circa il 44% nell’arco di alcune decine di microsecondi, mentre la QED, combinata con la protezione di tipo Orbit, ha mantenuto la fedeltà logica dello stato di Bell ai massimi livelli, raggiungendo circa l’ 95.3 % nello stesso intervallo di tempo.

Benchmark

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

Definizioni di metriche

• Fedeltà della stringa di bit nascosta di Bernstein–Vazirani: probabilità di misurare la stringa di bit nascosta corretta. Questo indicatore misura l'affidabilità con cui l'algoritmo riesce a ricavare la soluzione desiderata all'aumentare delle dimensioni del circuito. La tabella riporta le tre stringhe di bit nascoste più grandi valutate con successo in tre diverse configurazioni: (i) circuiti grezzi senza Orbit, che hanno raggiunto i 26 qubit; (ii) circuiti con sola transpilazione, che hanno raggiunto i 60 qubit; e (iii) circuiti che utilizzano il flusso di lavoro completo di Orbit, che hanno raggiunto i 70 qubit. Per i circuiti grezzi (i), il fattore di miglioramento rappresenta il guadagno in termini di prestazioni ottenuto da DD e MEM rispetto ai circuiti non modificati. Per la configurazione (ii), che prevede esclusivamente la transpilazione, essa rappresenta il miglioramento ottenuto aggiungendo DD e MEM ai circuiti transpilati in modo ottimale. Per la configurazione completa di Orbit (iii), non viene riportato alcun fattore di miglioramento della linea di base, poiché è stata ottenuta una probabilità di successo diversa da zero solo quando tutte le componenti di Orbit (transpilation, DD e MEM) erano attivate. Di seguito viene fornito un esempio illustrativo.

• Fedeltà della trasformata di Fourier quantistica: sia per le implementazioni della QFT con circuiti unitari che con circuiti dinamici [2], la fedeltà misura la corrispondenza tra la trasformazione realizzata sperimentalmente e il processo QFT ideale su 20 diversi stati di ingresso. I circuiti dinamici presentano tempi di inattività significativi dovuti alle misurazioni effettuate a metà del circuito e al feedforward classico, durante i quali il disaccoppiamento dinamico può sopprimere la decoerenza. Il miglioramento riportato mette a confronto la fedeltà ottenuta con Orbit con quella grezza.

• Preparazione dello stato di Bell a lungo raggio: creazione di uno stato di Bell mediante circuiti dinamici e operazioni di feedforward tra due qubit separati da ben 60 qubit intermedi, dimostrando così l’esistenza di un entanglement efficiente a lungo raggio su hardware quantistico collegato localmente [3]. Orbit individua il percorso ottimale per i qubit, li preserva durante le misurazioni feedforward e applica la tecnica MEM per mitigare gli errori di lettura.

• Probabilità di errore logico nei codici di superficie: per il codice di superficie “heavy-hex” [4] e il codice di superficie a reticolo quadrato [5], sono stati condotti esperimenti con memorie quantistiche in cui uno stato logico codificato è stato preservato nel corso di ripetuti cicli di correzione degli errori. La probabilità di errore logico misura la probabilità che gli errori accumulati causino un recupero errato delle informazioni codificate (un valore più basso indica una migliore affidabilità). Il miglioramento riportato mette a confronto la probabilità di errore logico dei circuiti grezzi con quella ottenuta con Orbit.

• Errore assoluto del VQE: utilizzo del VQE con un ansatz unitario ottimizzato del metodo coupled-cluster per stimare l'energia dello stato fondamentale dell' LiH [6]. L'energia misurata viene confrontata con la corrispondente energia ideale ottenuta dal circuito privo di rumore. L'indicatore è dato dalla differenza assoluta tra l'energia misurata e quella ideale (i valori più bassi sono migliori). Il miglioramento segnalato è il seguente:

I valori superiori a uno indicano che Orbit riduce l'errore energetico rispetto all'esecuzione senza disaccoppiamento dinamico.

• Probabilità di successo del metodo QAOA: probabilità di ottenere una stringa di bit corrispondente a una soluzione ottimale del problema di ottimizzazione definito sul grafo a farfalla. Il miglioramento segnalato mette a confronto la probabilità di successo ottenuta con Orbit con quella ottenuta dai circuiti grezzi.

• Fedeltà logica: nell’esperimento [1] di disaccoppiamento dinamico logico [ [4,2,2] ], due qubit logici sono stati codificati in quattro qubit fisici e preparati come stato logico di Bell intrecciato. La fedeltà logica misura la corrispondenza tra lo stato codificato recuperato e lo stato logico di Bell di riferimento. Il miglioramento riportato mette a confronto la fedeltà logica media ottenuta con Orbit e il rilevamento degli errori (capacità del codice) con quella ottenuta utilizzando il solo codice.

Introduzione

Autenticati utilizzando la tua chiave API IBM Quantum Platform e seleziona la funzione Orbit come segue. Questo frammento di codice presuppone che tu abbia già salvato il tuo account nell'ambiente locale.

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()

Output:

[QiskitFunction(quantum-elements/orbit)]

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

Esempio

L'esempio seguente crea un circuito Bernstein-Vazirani e lo invia a Orbit in due modi diversi all'interno di un unico processo: esecuzione "raw" e impostazioni predefinite di Orbit.

Utilizza questo modello quando desideri effettuare un confronto diretto tra raw e Orbit.

Costruire un circuito di Bernstein-Vazirani

Scegli la stringa di bit nascosta e costruisci il circuito logico. Il qubit aggiuntivo funge da 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()

Output:

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

Preparare il carico di lavoro Orbit

Creare un “Sampler” PUB, quindi duplicarlo 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)

Esecuzione in modalità raw e impostazioni predefinite di Orbit

pub_options assegna al primo PUB la modalità raw, che esclude l’ottimizzazione Orbit, il DD e il MEM, mentre assegna al secondo PUB le impostazioni predefinite di Orbit, che includono la transpilazione ottimizzata, l’inserimento automatico del disaccoppiamento dinamico (DD) e la 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())

Output:

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

Recupera il risultato e confronta i circuiti grezzi e quelli ottimizzati con Orbit utilizzando i conteggi. Per i risultati del Sampler, get_counts() il registro classico restituito fornisce l'istogramma di output. Quando MEM viene applicato con successo all' PUB di Orbit, questo istogramma è già stato corretto con MEM; i conteggi non corretti rimangono disponibili nei metadati di Orbit alla voce 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,
    }
)

Output:

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

Effettua un confronto visivo tra i circuiti non elaborati e quelli ottimizzati 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()

Output:

Ottenere supporto

Contatta l'assistenza di Quantum Elements: [email protected]

Assicurati di includere le seguenti informazioni:

• ID lavoro della funzione Qiskit (qiskit-ibm-catalog), job.job_id
• Nome del backend
• Orbit pub_options utilizzato nelle modalità "raw" e "Orbit"
• Una descrizione dettagliata del problema
• Eventuali messaggi di errore o codici pertinenti
• Passi per riprodurre il problema

Passi successivi

Riferimenti

1. Soppressione degli errori a livello logico combinata con il rilevamento quantistico degli errori, Nature Communications (2026)
2. Trasformata di Fourier quantistica mediante circuiti dinamici, Physical Review Letters (2024)
3. Entanglement efficiente a lungo raggio mediante circuiti dinamici, PRX Quantum (2024)
4. Esperimenti di scalabilità del codice di superficie su un Heron dell’ IBM con connettività “heavy-hex”, arXiv:2510.18847
5. Esperimenti con il codice Surface su un Nighthawk dell’ IBM con connettività a reticolo quadrato, arXiv:2606.11496
6. Riferimento VQE, Nature Physics (2024)