Parity Twine Optimizer: Eine Qiskit-Funktion von ParityQC

Siehe API-Referenz

Übersicht

Mit dem „Parity Twine Optimizer“ können Nutzer Optimierungsprobleme mithilfe von Quantencomputern unter Verwendung der Parity-Twine-Methode lösen. Dieser auf der Parity-Architektur basierende Ansatz nutzt den „ ParityQC “-Compiler, um die Anzahl der Gatter und die Schaltungstiefe, die für die Ausführung eines Quantenalgorithmus erforderlich sind, unter Berücksichtigung der Gerätekonnektivität zu minimieren.

Diese Ressourcenreduzierung ermöglicht die Lösung branchenrelevanter Optimierungsprobleme in einer Größenordnung, die mit herkömmlichen, SWAP-intensiven Transpilierungsverfahren nicht realisierbar ist. Der „Parity Twine Optimizer“ automatisiert die Transpilierungsschritte und lässt sich mit minimalem Benutzereingriff einsetzen.

Der „Parity Twine“-Ansatz übertrifft alle anderen Kompilierungsmethoden hinsichtlich der Reduzierung der Gatteranzahl und der Schaltungstiefe bei Quantenalgorithmen wie dem Quantenalgorithmus zur approximativen Optimierung (QAOA) und der Quanten-Fourier-Transformation (QFT). Durch die Abstraktion der Quanteninformation von den physikalischen Qubits lassen sich nichtlokale Wechselwirkungen ohne SWAP-Gatter realisieren. Stattdessen verteilen Parity-Twine-Ketten (Folgen von CNOT-Gattern) systematisch logische Paritätsinformationen auf die Qubits.

Der Optimierer nutzt den QAOA, um die Energie einer vorgegebenen Kostenfunktion zu minimieren. QAOA ist ein hybrider quanten-klassischer Variationsalgorithmus, der zur Lösung kombinatorischer Optimierungsprobleme entwickelt wurde, indem er den Grundzustand eines Kosten-Hamilton-Operators approximiert ( $H_C$ ). Ein Mischterm ( $H_B$ ) bewirkt Übergänge zwischen den Zuständen, um den Lösungsraum zu durchforsten. Eine abwechselnde Abfolge dieser Terme, die durch die Parameter $\gamma$ und $\beta$ gesteuert wird, definiert den unitären Operator $U(\gamma, \beta) = \Pi_{i=1}^p e^{-i \beta_i H_B} e^{-i \gamma_i H_C}$, der auf den Anfangszustand wirkt.

Die Kodierung des unitaren Problems exp( $-i \beta H_C)$ ) erfordert die Kodierung aller logischen $n$ -Körper-Rotationsoperatoren (exp( $-i \beta J_{i,j,...n}Z_iZ_j...Z_n$ )). Dies lässt sich mithilfe von $n$ -Körper-Generatoren (Parity-Twine-Netzwerke) erreichen, die die Schaltungstiefe des QAOA-Schaltkreises und die Anzahl der Zwei-Qubit-Gatter reduzieren.

Beschreibung

Die Eingabe für den „Parity Twine Optimizer“ besteht aus einem Optimierungsproblem, dem gewählten Namen der „ IBM Quantum “-Hardware sowie zusätzlichen optionalen Argumenten zur Anpassung der Einstellungen für die Transpilierung und die Ausführung auf der Hardware. Die Optimierer-Funktion leitet die Problemdefinition an den Parity-Twine-Compiler weiter. Abbildung 1 zeigt eine Übersicht über den Funktionsablauf.

Das Problem der Eingabeoptimierung wird zu einem (normierten) Hamilton-Operator vorverarbeitet. Der „ ParityQC “-Compiler erstellt daraufhin eine parametrisierte „Parity Twine“-Ansatzschaltung, die in einen logischen Ansatz transpiliert wird, der dem nativen Gatesatz der ausgewählten Hardware entspricht.

Die Parameter der QAOA-Schaltung werden klassischerweise mithilfe des „Efficient-Depth-One “-Ansatzes optimiert und der transpilierten Schaltung zugewiesen. Da eine Runde QAOA verwendet wird, werden die optimalen Parameter für „ $\gamma$ “ und „ $\beta$ “ mittels einer Rastersuche auf einer CPU ermittelt, ohne dass eine aufwendige iterative Optimierung über viele Schaltkreisaufrufe hinweg erforderlich ist. Dadurch wird die erforderliche QPU-Laufzeit des Optimierers erheblich reduziert. Die Ausführungszeit pro Schaltkreis wird hauptsächlich durch den konstanten Overhead bestimmt, der bei der Ausführung eines Jobs auf der QPU anfällt. Nachdem die Schaltungsparameter festgelegt wurden, wird der Auftrag an die angegebene QPU unter IBM® übermittelt.

Die Rohdaten werden anschließend nachbearbeitet. In diesem Schritt wird eine lokale gierige Suche verwendet, die zufällig durch die Lösungszeichenfolge durchläuft und Bitwerte umkehrt, sofern dies den Wert der Kostenfunktion verringert.

Benchmarks

Sherrington-Kirkpatrick-Modell

Abbildung 2 veranschaulicht die Wirksamkeit des Parity Twine Optimizers. Hier werden die mit dem Optimierer erzielten Ergebnisse mit denen einer Zufallsstichprobe für das Sherrington-Kirkpatrick-Modell bei steigender Anzahl von Qubits verglichen.

Die Nachbearbeitung sowohl der Zufallsergebnisse als auch der Optimierergebnisse führt zu exakten Grundzuständen, doch die von Twine QAOA gelieferten Rohwerte für die minimale Energie sind stets besser als Zufallswerte . Bei den größten betrachteten Qubit-Anzahlen (90 und 100) verschlechtert das Hardware-Rauschen das Ergebnis des Optimierers, sodass es auf Rohwerte zurückfällt, die denen einer Zufallsstichprobe entsprechen.

In diesem Tutorial finden Sie eine Einführung in das Sherrington-Kirkpatrick-Modell sowie Einzelheiten dazu, wie Sie es mit dem Parity Twine Optimizer lösen können.

Problem der Marktaufteilung

Tabelle 1 zeigt spezifische Leistungskennzahlen für den „Parity Twine Optimizer“, der auf verschiedene Fälle des Market-Split-Problems (MS) angewendet wurde. Diese wurden aus der QOBLIB – Quantum Optimization Benchmarking Library bezogen und entsprechen Beiträgen, die unter Verwendung des Parity Twine Optimizers an die Bibliothek übermittelt wurden.

Die MS-Verletzung ist eine Genauigkeitskennzahl, die misst, wie weit die Lösung davon entfernt ist, alle Nebenbedingungen zu erfüllen. Sie ist definiert als „ $\sum_i ((Ax - b)_i)^2$ “. Niedrigere Werte dieser Kennzahl weisen auf genauere Lösungen hin. Tabelle 1 enthält die gemittelten Werte für fünf Durchläufe jeder Instanz unter Verwendung des Parity Twine Optimizers mit dem Gerät ibm_boston als Backend und 100.000 Schüssen. Es wird der geringste MS-Verstoß angegeben, der aus den Durchläufen der jeweiligen Instanz ermittelt wurde.

Tabelle 1: Leistungskennzahlen für verschiedene Fälle des Marktaufteilungsproblems. Die Instanznamen beziehen sich auf die entsprechenden Beispiele in der QOBLIB -Aufgabenbibliothek. Wie bereits im Abschnitt „Beschreibung“ erwähnt, ist die QPU-Laufzeit minimal und nahezu konstant, da nur eine QAOA-Runde verwendet wird, wobei die optimalen Schaltungsparameter auf einer CPU ermittelt wurden.

In diesem Tutorial finden Sie eine Einführung in das Problem der Marktaufteilung sowie Einzelheiten dazu, wie Sie es mit dem Parity Twine Optimizer lösen können.

Das Problem der maximalen unabhängigen Menge

Abbildung 3 vergleicht die mit dem „Parity Twine“-Optimierer erzielten Ergebnisse mit denen einer Zufallsstichprobe für das Problem der maximalen unabhängigen Menge bei ausgewählten Instanzen, die aus der QOBLIB – Quantum Optimization Benchmarking Library stammen. Diese reichen von 18 (Interaktionen zwischen Säugetieren und Kängurus) bis zu 114 ( es60fst03 ) Qubits.

Bei kleinen Instanzen sind die vom Optimierer und durch Zufallsstichproben ermittelten Werte für die maximale Größe der unabhängigen Menge ähnlich, bei größeren Instanzen liefert der Optimierer jedoch weitaus bessere Ergebnisse. Die Nachbearbeitung sowohl der zufällig ausgewählten als auch der Optimierer-Ergebnisse führt erneut zu Mengengrößen, die mit den exakten Werten übereinstimmen.

Erste Schritte

Melden Sie sich mit Ihrem „ IBM Quantum Platform “-API-Token an und wählen Sie die Qiskit-Funktion wie folgt aus:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

# Authenticate and load the Qiskit Function
catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
)
function = catalog.load("parityqc/parity-twine-optimizer")

Beispiel

Der Parity-Twine-Optimierer lässt sich wie folgt auf ein einfaches QUBO-Beispiel anwenden. Das Problem wird zunächst mithilfe eines Wörterbuchs definiert:

problem = {"()": 3, "(0,)": 1, "(0, 1)": 2, "(1, 2)": -1}

Dann muss der Variablentyp wie folgt definiert werden: oder binary spin:

variable_type = "spin"

Damit wird die Zielfunktion definiert: $3 + s_0 + 2 s_0s_1 - s_1s_2$, wobei $s_i \in \{-1, 1\}$ gilt.

Wählen Sie ein Backend aus. Zum Beispiel:

backend_name = "ibm_phoenix"

Verwenden Sie, catalog.backends() um eine Liste der verfügbaren Backends des Benutzerkontos bzw. der Instanz anzuzeigen.

Wenn kein Backend angegeben wird, wird automatisch das am wenigsten ausgelastete Backend (das mit der geringsten Anzahl an ausstehenden Aufträgen) ausgewählt.

Sobald der Optimierer geladen ist (siehe oben), können Sie ihn mit den Standardoptionen auf das Problem anwenden:

function_job = function.run(
    problem=problem, variable_type=variable_type, backend_name=backend_name
)
print(f"Job ID: {function_job.job_id}")

Überprüfen Sie den Auftragsstatus wie folgt:

# Monitor the job status
function_job.status()

Rufen Sie die Ergebnisse wie folgt ab:

# Retrieve the job result if the status is DONE
result = function_job.result()

result

Die Ausgabe der Ergebnisse sieht wie folgt aus:

{
    'solution': {'0': -1, '1': 1, '2': 1},
    'objective_value': -1.0,
    'solution_bitstring': '100',
    'metadata': {
        'circuit_metrics': {
            'depth': 20,
            'gate_count': 198,
            'two_qubit_gate_depth': 4,
            'two_qubit_gate_count': 4,
            'num_qubits': 3,
            'operations': {'delay': 158, 'rz': 17, 'sx': 14, 'cz': 4, 'measure': 3, 'x': 2}
        },
        'solver_info': {
            'variable_mapping': {'0': 0, '1': 1, '2': 2},
            'bitstring_distributions': {
                'before_postprocessing': {'100': 71760, ... },
                'after_postprocessing': {'100': 88440, '011': 11560}
            },
            'best_parameters': {
                'beta': [-0.46259546391008877],
                'gamma': [0.6181957189727373]
            }
        },
        'resource_usage': {
            'RUNNING: MAPPING': {'CPU_TIME': 42.878},
            'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 0.094},
            'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 790.623},
            'RUNNING: EXECUTING_QPU': {'QPU_TIME': 28.0},
            'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.828}
        }
    }
}

Das Wörterbuch solution entspricht den in der Aufgabenstellung definierten Qubits ( $s_0, s_1$ und $s_2$ ) und gibt deren optimierte Spinwerte an.

Die objective_value ist die Kostenfunktion oder Energie des Optimierungsproblems. Es quantifiziert die Qualität solution .

metadata liefert Informationen zur Transpilation (Anzahl der Zwei-Qubit-Gates/Tiefe, verwendete Gates, aktive Qubits) sowie zu verschiedenen Laufzeiten sowohl für die Quanten- als auch für die klassische Rechenzeit.

Darüber hinaus bietet metadata es einen Einblick in die Funktionsweise des Algorithmus. Sie können die optimierten Variationsparameter (Beta und Gamma) einsehen und nachvollziehen, wie sich die Verteilung der gemessenen Bitstrings verbessert hat, nachdem die Rohdaten der Quantenergebnisse einer klassischen Nachbearbeitung unterzogen wurden.

Alle Bitfolgen in der Ergebnisausgabe können mithilfe von variable_mapping. den Problemvariablen zugeordnet werden. Beispielsweise kann man das 'solution_bitstring': '100' mit dem 'variable_mapping': {'0': 0, '1': 1, '2': 2} auf die binäre Lösung abbilden: {'0': 1, '1': 0, '2': 0}. Da Sie das Problem mit Hilfe von Spinvariablen lösen, müssen Sie die Transformation von Binärzahlen in Spins anwenden (0 → 1, 1 → ) -1 . Dadurch gelangen Sie zur endgültigen Lösung 'solution': {'0': -1, '1': 1, '2': 1}.

Ausführliche Informationen zu den Ein- und Ausgabedaten der Funktion „Parity Twine Optimizer“ finden Sie in der API-Referenz.

Änderungsprotokoll

[1.0.2] - 15.09.2026

Hinweise

Mit dieser Veröffentlichung wird die erste stabile Produktionsversion der Parity Twine Optimizer-Qiskit-Funktion vorgestellt. In zukünftigen Versionen werden voraussichtlich folgende Neuerungen eingeführt:

• Zusammenstellung von Problemen höherer Ordnung,
• weitere Optimierungsalgorithmen sowie
• Verbesserungen bei der Vor- und Nachbearbeitung.

Funktionen

• Lösen Sie spärliche und dichte QUBO-Probleme mit dem effizienten Parity-Twine-Compiler.

Dokumentation

• Benutzerhandbuch für den Einstieg.
• Anleitungen mit Beispielen zu Markt-Split- und Sherrington-Kirkpatrick-Problemen.
• API-Dokumentation.

Unterstützung anfordern

Bei Fragen oder Problemen wenden Sie sich bitte an ParityQC.

Nächste Schritte