Orbit – eine Qiskit-Funktion von Quantum Elements

Siehe API-Referenz

Übersicht

Die Quantenhardware entwickelt sich zwar weiter, doch Rauschen und Dekohärenz schränken nach wie vor die Tiefe und Zuverlässigkeit praktischer Quantenschaltungen ein. Unter den verfügbaren Ansätzen können drei sich ergänzende Techniken diese Einschränkungen erheblich mindern: dynamische Entkopplung (DD), optimierte Transpilierung und Messfehlerminderung (MEM). Eine optimierte Transpilation verringert die Schaltungstiefe und passt die Schaltungen besser an die Konnektivität der Zielhardware an, DD unterdrückt Leerlaufrauschen durch sorgfältig konzipierte Steuerungssequenzen, und MEM reduziert die Auswirkungen von Auslesefehlern und kann während der Nachbearbeitung angewendet werden.

Die Auswahl einer effektiven DD-Strategie ist besonders schwierig, da zahlreiche Sequenzfamilien zur Verfügung stehen und eine Sequenz, die bei einer bestimmten Schaltung oder in einer bestimmten Rauschumgebung gut funktioniert, bei einer anderen Schaltung oder in einer anderen Rauschumgebung möglicherweise nicht die gleiche Leistung erbringt. Die Vorteile von Transpilation, DD und MEM hängen von der jeweiligen Aufgabe, der Hardware und der Arbeitslast ab; einzeln oder in Kombination eingesetzt, können sie die Leistung verbessern, sind jedoch nicht in jeder Konfiguration von Vorteil.

Orbit, eine von Quantum Elements entwickelte Qiskit-Funktion, vereint alle drei Komponenten nahtlos in einem einheitlichen Arbeitsablauf und ermöglicht so deren einfache Nutzung zur Optimierung der Schaltkreisaufführung auf der „ IBM Quantum “-Hardware. In seiner Grundform wendet Orbit automatisch aktive Fehlerunterdrückungsstrategien an, die Quantenzustände während Leerlaufphasen schützen und dabei die ursprüngliche Schaltlogik beibehalten. Bemerkenswert ist, dass dies ohne zusätzlichen Zeitaufwand für die quanten- oder klassische Vorverarbeitung geschieht, wodurch unnötige Mehrkosten oder Wartezeiten innerhalb des Arbeitsablaufs vermieden werden.

Anstatt wie eine Blackbox zu funktionieren, ermöglicht Orbit den Nutzern, seine Optimierungskomponenten für ein bestimmtes Experiment zu bewerten und fein abzustimmen. Benutzer können die optimierte Transpilierung, DD und MEM eigenständig aktivieren oder deaktivieren, die automatische DD-Auswahl mit benutzerdefinierten Sequenzen vergleichen und mehrere Konfigurationen innerhalb desselben Workflows ausführen. Durch den Vergleich jeder Konfiguration mit der Ausgangsschaltung können Anwender ermitteln, welche Techniken messbare Vorteile für ihre Schaltung und ihr Backend bieten, Wechselwirkungen zwischen den verschiedenen Optimierungsmethoden identifizieren und die Konfiguration auswählen, die ihr Versuchsziel am besten unterstützt. Dieser Prozess hilft den Anwendern dabei, zu verstehen, woher Leistungssteigerungen stammen, und fundiertere Entscheidungen bei der Optimierung von Quantenschaltungen für eine bestimmte Arbeitslast zu treffen.

Beschreibung

Orbit wurde entwickelt, um die Ausführung von Quantenschaltungen auf Backends von „ IBM Quantum “ zu verbessern. Im automatisierten Modus können Anwender nahtlos robuste DD-Sequenzen höherer Ordnung anwenden, ohne diese manuell auswählen oder konfigurieren zu müssen. Erfahrene Anwender können stattdessen mit den verfügbaren Sequenzen höherer Ordnung experimentieren, um den Ansatz zu ermitteln und zu optimieren, der für eine bestimmte Schaltung die beste Leistung liefert.

Orbit liefert zudem sofortige MEM-Ergebnisse, ohne dass zusätzliche Aufträge erforderlich sind, die normalerweise für separate Kalibrierungs- und Korrektur-Workflows benötigt werden. Bei Workloads, bei denen die Transpilierung die Schaltungsstruktur nicht verändern soll – wie beispielsweise bei Quantenfehlerkorrekturschaltungen mit Messungen während des Laufs oder bei dynamischen Schaltungen –, kann Orbit DD und MEM anwenden, ohne die bestehende Transpilierungsstrategie des Benutzers zu beeinträchtigen. Für Anwender, die noch keine bevorzugte Vorgehensweise haben, enthält Orbit zudem einen integrierten Transpiler, der Schaltungen für die Zielhardware optimiert, bevor Techniken zur Fehlerunterdrückung und zur Minderung von Ausleseproblemen angewendet werden.

Im Gegensatz zu Ansätzen, die auf zusätzliche Schaltungsabtastung, Extrapolation oder aufwendige klassische Nachbearbeitung setzen, konzentriert sich Orbit darauf, Fehler bereits während der Ausführung zu unterdrücken. Die Funktion ist so konzipiert, dass sie nur einen geringen Overhead verursacht und gleichzeitig die ursprüngliche Schaltungslogik beibehält. Die Nutzer können die resultierende Schaltung überprüfen und die mit Orbit optimierten Ausführungen direkt mit den Standardausführungen vergleichen.

Ein praktischer Orbit-Workflow sieht wie folgt aus:

1. Definieren Sie eine Quantenschaltung und wählen Sie „Orbit“ über die „ Qiskit Functions Catalog “ aus.
2. Fügen Sie die Schaltung ohne Orbit im „Raw“-Modus ein, um eine Basislinie für die Rohschaltung zu erstellen.
3. Wählen Sie aus, welche Optimierungsstrategien angewendet werden sollen, darunter automatisierte oder vom Benutzer ausgewählte DD-Sequenzen, MEM und optimierte Transpilierung.
4. Aktivieren oder deaktivieren Sie einzelne Methoden oder übermitteln Sie mehrere Konfigurationen, um deren einzelne und kombinierte Auswirkungen zu bewerten.

Orbit ist besonders nützlich für Schaltkreise, die Leerlaufphasen oder Lücken im Ablaufplan enthalten, in denen die Qubits nicht aktiv an den Logikgattern beteiligt sind. Es unterstützt statische und dynamische Schaltungen, einschließlich Workflows mit Messungen während des Schaltungsbetriebs und fehlertolerante Quantencomputing-Experimente. Zu den typischen Anwendungsbereichen zählen Quantenfehlerkorrektur, Oberflächencode-Experimente auf quadratischen und schweren Hex-Gittern, Orakelalgorithmen wie Bernstein-Vazirani, Fourier-Transformationsschaltungen, variationale Quantenalgorithmen, Hamilton-Simulationen, Benchmarking-Experimente sowie hardwareorientierte Schaltungsoptimierung.

Mit Blick auf das Zeitalter der Fehlertoleranz ist Orbit zudem mit fehlertoleranten Quantencomputing-Workflows kompatibel, da es sich nahtlos mit der Quantenfehlerkorrektur kombinieren lässt. Langfristig sieht Orbit die dynamische Entkopplung auf logischer Ebene [1] als zukunftsweisenden Weg zum Schutz logischer Qubits an. Im folgenden Beispiel wurden zwei logische Qubits verschränkt, um unter Berücksichtigung der Quantenfehlererkennung einen logischen Bell-Zustand zu erzeugen. Durch die Quantenfehlererkennung allein sank die Treue des Bell-Zustands über einen Zeitraum von mehreren zehn Mikrosekunden auf etwa 44 %, während die Kombination aus QED und „Orbit“-ähnlichem Schutz die logische Treue des Bell-Zustands nahe dem oberen Ende der Skala hielt und im gleichen Zeitfenster etwa 95.3 % erreichte.

Benchmarks

Die folgenden Ergebnisse fassen repräsentative Orbit-Läufe auf der „ IBM Quantum “-Hardware zusammen. Wie bei anderen Hardware-Benchmarks hängen die Ergebnisse vom ausgewählten Gerät, dem Kalibrierungsstatus, der Schaltung und den Ausführungseinstellungen ab.

Metrikdefinitionen

• Bernstein–Vazirani-Treuefunktion für verborgene Bitfolgen: Wahrscheinlichkeit, die richtige verborgene Bitfolge zu messen. Diese Kennzahl gibt an, wie zuverlässig der Algorithmus die beabsichtigte Lösung auch bei zunehmender Schaltungsgröße ermittelt. Die Tabelle zeigt die drei größten versteckten Bitstrings, die unter drei verschiedenen Konfigurationen erfolgreich ausgewertet wurden: (i) Rohschaltungen ohne Orbit, die 26 Qubits erreichten; (ii) Schaltungen nur mit Transpilierung, die 60 Qubits erreichten; und (iii) Schaltungen unter Verwendung des vollständigen Orbit-Workflows, die 70 Qubits erreichten. Bei den Rohschaltungen (i) gibt der Verbesserungsfaktor den Leistungsgewinn an, den DD und MEM im Vergleich zu den unveränderten Schaltungen erzielen. Bei der reinen Transpilation-Konfiguration (ii) zeigt dies die Verbesserung, die durch Hinzufügen von DD und MEM zu den optimal transpilierten Schaltungen erzielt wurde. Für die vollständige Orbit-Konfiguration (iii) wird kein Basislinien-Verbesserungsfaktor angegeben, da eine von Null verschiedene Erfolgswahrscheinlichkeit nur dann erzielt wurde, wenn alle Orbit-Komponenten (Transpilation, DD und MEM) aktiviert waren. Im Folgenden wird ein anschauliches Beispiel aufgeführt.

• Fidelity der Quanten-Fourier-Transformation: Sowohl bei der unitaren als auch bei der dynamischen Schaltkreis-QFT-Implementierung [2] misst die Fidelity die Übereinstimmung zwischen der experimentell durchgeführten Transformation und dem idealen QFT-Prozess über 20 verschiedene Eingangszustände hinweg. Dynamische Schaltungen weisen aufgrund von Messungen während des Schaltungsablaufs und klassischer Vorwärtsregelung erhebliche Leerlaufzeiten auf, in denen eine dynamische Entkopplung die Dekohärenz unterdrücken kann. Bei der angegebenen Verbesserung wird die mit Orbit erzielte Genauigkeit mit der Rohgenauigkeit verglichen.

• Erzeugung eines Bell-Zustands über große Entfernungen: Erzeugung eines Bell-Zustands mithilfe dynamischer Schaltungen und Feedforward-Operationen zwischen zwei Qubits, die durch bis zu 60 Zwischenqubits voneinander getrennt sind, wodurch eine effiziente Verschränkung über große Entfernungen auf lokal verbundener Quantenhardware demonstriert wird [3]. Orbit ermittelt die optimale Qubit-Routierung, bewahrt die Qubits während der Feedforward-Messungen und wendet MEM an, um Auslesefehler zu minimieren.

• Wahrscheinlichkeit logischer Fehler bei Oberflächencodes: Für den „Heavy-Hex“-Oberflächencode [4] und den „Square-Lattice“-Oberflächencode [5] wurden Quantenspeicher-Experimente durchgeführt, bei denen ein kodierter logischer Zustand über mehrere aufeinanderfolgende Fehlerkorrekturrunden hinweg erhalten blieb. Die logische Fehlerwahrscheinlichkeit gibt an, mit welcher Wahrscheinlichkeit kumulierte Fehler dazu führen, dass die kodierte Information falsch wiederhergestellt wird (je geringer der Fehler, desto besser). Die gemeldete Verbesserung ergibt sich aus dem Vergleich der logischen Fehlerwahrscheinlichkeit von Rohschaltungen mit derjenigen, die mit Orbit ermittelt wurde.

• Absoluter VQE-Fehler: Verwendung von VQE mit einem optimierten unitären Coupled-Cluster-Ansatz zur Abschätzung der Grundzustandsenergie von LiH [6]. Die gemessene Energie wird mit der entsprechenden idealen Energie verglichen, die aus der rauschfreien Schaltung ermittelt wurde. Die Kennzahl entspricht der absoluten Differenz zwischen der gemessenen und der idealen Energie (niedrigere Werte sind besser). Die gemeldete Verbesserung lautet:

Werte größer als eins zeigen an, dass Orbit den Energiefehler im Vergleich zur Ausführung ohne dynamische Entkopplung verringert.

• QAOA-Erfolgswahrscheinlichkeit: Wahrscheinlichkeit, eine Bitfolge zu messen, die einer optimalen Lösung des auf dem Schmetterlingsgraphen definierten Optimierungsproblems entspricht. Die gemeldete Verbesserung vergleicht die mit Orbit erzielte Erfolgswahrscheinlichkeit mit derjenigen, die anhand der Rohschaltungen ermittelt wurde.

• Logische Genauigkeit: Im Experiment [1] zur logischen dynamischen Entkopplung [ [4,2,2] ] wurden zwei logische Qubits in vier physikalische Qubits kodiert und als verschränkter logischer Bell-Zustand präpariert. Die logische Genauigkeit misst die Übereinstimmung zwischen dem wiederhergestellten kodierten Zustand und dem angestrebten logischen Bell-Zustand. Die gemeldete Verbesserung vergleicht die durchschnittliche logische Genauigkeit, die mit Orbit und Fehlererkennung (Leistungsfähigkeit des Codes) erzielt wurde, mit derjenigen, die bei ausschließlicher Verwendung des Codes allein erzielt wurde.

Erste Schritte

Authentifizieren Sie sich mit Ihrem IBM Quantum Platform API-Schlüssel und wählen Sie die Orbit-Funktion wie folgt aus. In diesem Codeausschnitt wird davon ausgegangen, dass Sie Ihr Konto bereits in Ihrer lokalen Umgebung gespeichert haben.

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-dev),
 QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")
print("Orbit version:", orbit.version)

Output:

Orbit version: 0.3.23

Beispiel

Im folgenden Beispiel wird eine Bernstein-Vazirani-Schaltung erstellt und in einem Auftrag auf zwei verschiedene Arten an Orbit übermittelt: als Rohausführung und mit den Orbit-Standardeinstellungen.

Verwenden Sie dieses Muster, wenn Sie einen direkten Vergleich zwischen „raw“ und „Orbit“ durchführen möchten.

Skalierung von Bernstein-Vazirani auf größere Größen

Orbit kann dazu beitragen, die Erfolgswahrscheinlichkeit nach Bernstein-Vazirani auch bei zunehmender Breite der verborgenen Bitstrings aufrechtzuerhalten. Die folgenden repräsentativen Skalierungstests vergleichen die Rohausführung mit Orbit-Konfigurationen auf „ IBM Quantum “-Hardware. Bei einer Breite der verborgenen Bitfolge von 9 (insgesamt 10 Qubits) sinkt die reine Erfolgswahrscheinlichkeit unter 10 % ibm_miami, während Orbit weiterhin bei etwa 80–90 % liegt. Bei Breiten nahe 60 weist Orbit ibm_kingstonweiterhin eine nicht unerhebliche Erfolgswahrscheinlichkeit auf, darunter etwa 15 % bei der größten dargestellten Größe. Die genauen Ergebnisse hängen von der Kalibrierung des Backends, der Schaltung und den Ausführungseinstellungen ab.

Um QPU-Zeit zu sparen, wird in diesem Tutorial kein Größen-Sweep erneut durchgeführt. Stattdessen gibt das folgende ausführbare Beispiel die Anzahl der Schüsse für eine feste Breite der versteckten Bitfolge an ( N = 50 insgesamt 51 Qubits in dieser Schaltung) und vergleicht die Rohausführung mit den Orbit-Standardwerten in einem einzigen Job.

Eine Bernstein-Vazirani-Schaltung aufbauen

Wählen Sie die versteckte Bitfolge aus und bauen Sie die logische Schaltung auf. Das zusätzliche Qubit dient als Orakelziel, während die Eingangsqubits gemessen werden.

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

Bereiten Sie die Orbit-Workload vor

Erstellen Sie einen Sampler „ PUB “ und duplizieren Sie diesen anschließend für die beiden Vergleichsmodi. Orbit empfängt die logische Schaltung und ordnet sie während der Ausführung dem ausgewählten Backend zu.

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

Mit Standard-Einstellungen ausführen und Orbit-Standardeinstellungen verwenden

pub_options Weist dem ersten PUB den Raw-Modus zu, bei dem die Orbit-Optimierung, DD und MEM übersprungen werden, und weist dem zweiten PUB die Orbit-Standardeinstellungen zu, zu denen die optimierte Transpilierung, die automatische Einfügung von dynamischem Decoupling (DD) und die Minderung von Messfehlern (MEM) gehören.

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:

2c427a80-4190-404c-b98a-6bbeb53fafcd
QUEUED

Rufen Sie das Ergebnis ab und vergleichen Sie die Rohdaten und die mit Orbit optimierten Schaltkreise anhand der Zählwerte. Bei Sampler-Ergebnissen liefert das zurückgegebene klassische Register das Ausgabehistogramm. get_counts() Wenn MEM für die Orbit- PUB erfolgreich ist, ist dieses Histogramm bereits MEM-korrigiert; die unkorrigierten Zählwerte bleiben in den Orbit-Metadaten unter measurementErrorMitigation["rawCounts"]. verfügbar.

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': 370}, 'shots': 4096}

Führen Sie einen visuellen Vergleich zwischen den unbearbeiteten und den mit Orbit optimierten Schaltkreisen durch.

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:

Unterstützung anfordern

Wenden Sie sich an den Support von Quantum Elements: [email protected]

Bitte geben Sie unbedingt die folgenden Informationen an:

• Qiskit-Funktions-Job-ID (qiskit-ibm-catalog), job.job_id
• Name des Backends
• „Orbit“ pub_options wird für den „Raw“- und den „Orbit“-Modus verwendet
• Eine detaillierte Beschreibung des Problems
• Etwaige relevante Fehlermeldungen oder Fehlercodes
• Schritte zum Reproduzieren des Problems

Nächste Schritte

Referenzen

1. Fehlerunterdrückung auf logischer Ebene in Kombination mit Quantenfehlererkennung, Nature Communications (2026)
2. Quanten-Fourier-Transformation unter Verwendung dynamischer Schaltungen, Physical Review Letters (2024)
3. Effiziente Verschränkung über große Entfernungen mithilfe dynamischer Schaltkreise, PRX Quantum (2024)
4. Experimente zur Skalierung von Oberflächencodes auf „ IBM “ Heron mit „Heavy-Hex“-Konnektivität, arXiv:2510.18847
5. Surface-Code-Experimente zu „ IBM “ Nighthawk mit quadratischer Gitterkonnektivität, arXiv:2606.11496
6. VQE-Benchmark-Referenz, Nature Physics (2024)