Kompilierungsmethode für Hamilton-Simulationsschaltunge
Gschätzte QPU-Nutzung: kei Ausführung isch in dem Tutorial gmacht wore, weil's sich uf dr Transpilationsprozess konzentriert.
Hintergrund
D' Quanteschaltungskompilierung isch en entscheidender Schritt im Quantencomputing-Workflow. Se umfasst d' Transformation vun emme hochrangige Quantenalgorithmus in e physische Quanteschaltung, wo de Einschränkunge vun dr Ziel-Quantehardware entspricht. Effektive Kompilierung ka d' Leischtig vun Quantenalgorithme erheblich beeinfluge, indem se d' Schaltungstiefe, d' Gate-Anzahl und d' Ausführungszeit reduziert. Des Tutorial untersuacht drei unterschiedliche Ansätz zur Quanteschaltungskompilierung in Qiskit und zeigt ihre Stärke und Anwendunge durch praktische Beispiel uf.
S Ziel vun dem Tutorial isch es, de Benutzer z lähre, wie se drei Kompilierungsmethode in Qiskit awende und bewerte: dr SABRE-Transpiler, dr AI-gstützte Transpiler und s Rustiq-Plugin. D' Benutzer werdet lerne, wie se jede Methode effektiv isetze und wie se d' Leischtig über verschiedene Quanteschaltunge hinnewäg benchmarke. Am End vun dem Tutorial werdet d' Benutzer in dr Lag sei, Kompilierungsstrategie basierend uf spezifische Optimierungszieler – wie d' Reduzierung vun dr Schaltungstiefe, d' Minimierung vun dr Gate-Anzahl oder d' Verbesserung vun dr Laufzeit – z wähle und azupasse.
Was mir lerne werdet
- Wie mir dr Qiskit-Transpiler mit SABRE für Layout- und Routing-Optimierung verwende.
- Wie mir dr AI-Transpiler für fortgschrittene, automatisierte Schaltungsoptimierung nutze.
- Wie mir s Rustiq-Plugin für Schaltunge isetze, wo e präzise Synthese vun Operatione erfordere, insbesondere bi Hamilton-Simulationsufgabe.
Des Tutorial verwändet drei Beispielschaltunge nach em Qiskit Patterns-Workflow, um d' Leischtig vun jedere Kompilierungsmethode z veranschauliche. Am End vun dem Tutorial werdet d' Benutzer in dr Lag sei, d' geeignete Kompilierungsstrategie basierend uf ihre spezifische Anfordrunge und Einschränkunge z wähle.
Überblick über Kompilierungsmethode
1. Qiskit-Transpiler mit SABRE
Dr Qiskit-Transpiler verwändet dr SABRE (SWAP-based BidiREctional heuristic search)-Algorithmus zur Optimierung vun Schaltungslayout und -routing. SABRE konzentriert sich uf d' Minimierung vun SWAP-Gates und derer Auswirkunge uf d' Schaltungstiefe, während Hardware-Konnektivitätsbeschränkunge eighalte werdet. Die Methode isch hoch vielseitig und für allgemeine Schaltungsoptimierung geeignet und bietet es Gleichgewicht zwische Leischtig und Rechezeit. Um d' neuschte Verbesserunge in SABRE z nutze, wo in [1] detailliert beschriebe sind, ka mr d' Anzahl vun de Versuach erhöhe (zum Beispiel layout_trials=400, swap_trials=400). Für d' Zweck vun dem Tutorial verwändet mir d' Standardwert für d' Anzahl vun de Versuach, um mit em Standard-Transpiler vun Qiskit z vergleicha. D' Vorteile und Parameter-Exploration vun SABRE werdet in emme separaten Deep-Dive-Tutorial behandelt.
2. AI-Transpiler
Dr AI-gstützte Transpiler in Qiskit verwändet maschinelles Lerne, um optimale Transpilationsstrategie vorherzusage, indem er Muster in dr Schaltungsstruktur und Hardware-Einschränkunge analysiert, um d' beste Sequenz vun Optimierunge für e gegebene Eingab uszuwähle. Die Methode isch besonders effektiv für groß agelegte Quanteschaltunge und bietet en hohes Maß an Automatisierung und Agpassungsfähigkeit an diverse Problemtyp. Zusätzlich zur allgemeine Schaltungsoptimierung ka dr AI-Transpiler mit em AIPauliNetworkSynthesis-Pass verwändet werre, wo Pauli-Netzwerkschaltunge – Blöck, wo us H-, S-, SX-, CX-, RX-, RY- und RZ-Gates besteht – anvisiert und en uf Reinforcement Learning basierende Syntheseansatz awändet. Weitere Informatione zum AI-Transpiler und sine Synthese-Strategie findet mr in [2] und [3].
3. Rustiq-Plugin
S Rustiq-Plugin führt fortgschrittene Synthesetechnike speziell für PauliEvolutionGate-Operatione i, wo Pauli-Rotatiône repräsentiert, wo häufig in trotterisierter Dynamik verwändet werdet. Des Plugin isch wertvoll für Schaltunge, wo Hamilton-Simulation implementiert, wie se in Quantenchemie- und Physikproblem verwändet werdet, bi dene genaue Pauli-Rotatiône für d' effektive Simulation vun Problem-Hamiltonians wesentlich sind. Rustiq bietet präzise, niedrig-tife Schaltungssynthese für die spezialisierten Operatione. Weitere Details zur Implementierung und Leischtig vun Rustiq findet mr in [4].
Durch d' eingehende Untersuchung vun dene Kompilierungsmethode bietet des Tutorial de Benutzern d' Werkzeug, um d' Leischtig vun ihre Quanteschaltunge z verbessere und dr Weg für effizientere und praktischere Quanteberechnunge z ebne.
Anfordrunge
Stellt vor em Beginn vun dem Tutorial sicher, dass folgendes installiert isch:
- Qiskit SDK v1.3 oder höher, mit Unterstützung für Visualisierung
- Qiskit Runtime v0.28 oder höher (
pip install qiskit-ibm-runtime) - Qiskit IBM Transpiler (
pip install qiskit-ibm-transpiler) - Qiskit AI Transpiler Lokalmodus (
pip install qiskit_ibm_ai_local_transpiler) - Networkx-Graphebibliothek (
pip install networkx)
Setup
# Added by doQumentation — installs packages not in the Binder environment
!pip install -q qiskit-ibm-transpiler
from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.circuit.library import (
efficient_su2,
PauliEvolutionGate,
)
from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
from collections import Counter
from IPython.display import display
import time
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import json
import requests
import logging
# Suppress noisy loggers
logging.getLogger(
"qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.ERROR)
seed = 42 # Seed for reproducibility
Teil 1: Efficient SU2-Schaltung
Schritt 1: Klassische Eingabe uf es Quanteproblem abbildet
In dem Abschnitt untersuacht mir d' efficient_su2-Schaltung, en hardwareeffizienten Ansatz, wo häufig in variationelle Quantenalgorithme (wie VQE) und Quantum-Machine-Learning-Ufgabe verwändet wird. D' Schaltung besteht us wechselnde Schichte vun Ein-Qubit-Rotatiône und verschränkende Gates, wo in emme kreisförmige Muster agordnet sind und dazu konzipiert sind, dr Quantezustandsraum effektiv z erkunde, während e überschaubare Tiefe beibehalte wird.
Mir fange mit dr Konstruktion vun ere efficient_su2-Schaltung a, um z demonstriere, wie verschiedene Kompilierungsmethode vergliche werdet. Nach Teil 1 werdet mir onsere Analyse uf en größere Satz vun Schaltunge erweitere, um en umfassende Benchmark zur Bewertig vun dr Leischtig verschiedener Kompilierungstechnike z ermögliche.
qubit_size = list(range(10, 101, 10))
qc_su2_list = [
efficient_su2(n, entanglement="circular", reps=1)
.decompose()
.copy(name=f"SU2_{n}")
for n in qubit_size
]
# Draw the first circuit
qc_su2_list[0].draw(output="mpl")
Schritt 2: Problem für d' Ausführung uf Quantehardware optimiere
Der Schritt isch dr Hauptfokus vun em Tutorial. Do weitet mir Quanteschaltunge für d' effiziente Ausführung uf echter Quantehardware optimiere. Onsers primäres Ziel isch es, d' Schaltungstiefe und d' Gate-Anzahl z reduzierd, wo Schlüsselfaktore zur Verbesserung vun dr Ausführungstreue und zur Mindrung vun Hardware-Rausche sind.
- SABRE-Transpiler: Verwändet dr Standard-Transpiler vun Qiskit mit em SABRE-Layout- und Routing-Algorithmus.
- AI-Transpiler (Lokalmodus): Dr Standard-AI-gstützte Transpiler mit lokaler Inferenz und dr Standard-Synthesestrategie.
- Rustiq-Plugin: En Transpiler-Plugin für niedrig-tife Kompilierung, des uf Hamilton-Simulationsufgabe zuegschnitten isch.
S Ziel vun dem Schritt isch es, d' Ergebniss vun dene Methode hinsichtlich Tiefe und Gate-Anzahl vun dr transpilierten Schaltung z vergleicha. E weitere wichtige Metrik, wo mir berücksichtige, isch d' Transpilationslaufzeit. Durch d' Analyse vun dene Metrike ka mr d' relativen Stärke vun jedere Methode bewerte und bestimme, welche d' effizienteste Schaltung für d' Ausführung uf dr usgwählte Hardware produziert.
Hinweis: Für s anfängliche SU2-Schaltungsbeispiel werdet mir nur dr SABRE-Transpiler mit em Standard-AI-Transpiler vergleicha. Im anschließende Benchmark mit Hamlib-Schaltunge werdet mir jedoch alle drei Transpilationsmethode vergleicha.
# QiskitRuntimeService.save_account(channel="ibm_quantum_platform", token="<YOUR-API-KEY>", overwrite=True, set_as_default=True)
service = QiskitRuntimeService(channel="ibm_quantum_platform")
backend = service.backend("ibm_torino")
print(f"Using backend: {backend}")
qiskit_runtime_service._get_crn_from_instance_name:WARNING:2025-07-30 21:46:30,843: Multiple instances found. Using all matching instances.
Using backend: <IBMBackend('ibm_torino')>
Qiskit-Transpiler mit SABRE:
pm_sabre = generate_preset_pass_manager(
optimization_level=3, backend=backend, seed_transpiler=seed
)
AI-Transpiler:
# Standard AI transpiler pass manager, using the local mode
pm_ai = generate_ai_pass_manager(
backend=backend, optimization_level=3, ai_optimization_level=3
)
Rustiq-Plugin:
hls_config = HLSConfig(
PauliEvolution=[
(
"rustiq",
{
"nshuffles": 400,
"upto_phase": True,
"fix_clifford": True,
"preserve_order": False,
"metric": "depth",
},
)
]
)
pm_rustiq = generate_preset_pass_manager(
optimization_level=3,
backend=backend,
hls_config=hls_config,
seed_transpiler=seed,
)
Transpiliere und Metrike erfasse
Um d' Leischtig vun de Kompilierungsmethode z vergleicha, definiere mir e Funktion, wo d' Eigabeschaltung transpiliert und relevante Metrike uf konsistente Weis erfasst. Des umfasst d' Gsamtschaltungstiefe, d' Gsamt-Gate-Anzahl und d' Transpilationszeit.
Zusätzlich zu dene Standardmetrike zeichne mir au d' 2-Qubit-Gate-Tiefe uf, wo e besonders wichtige Metrik zur Bewertig vun dr Ausführung uf Quantehardware isch. Im Gegasatz zur Gsamttiefe, wo alle Gates ischließt, spiegelt d' 2-Qubit-Tiefe d' tatsächliche Ausführungsdauer vun dr Schaltung uf Hardware genauer wider. Des liegt dra, dass 2-Qubit-Gates typischerweise s Zeit- und Fehlerbudget in de meischte Quantegeräte dominiert. Daher isch d' Minimierung vun dr 2-Qubit-Tiefe entscheidend für d' Verbesserung vun dr Fidelität und d' Reduzierung vun Dekohärenzeffekte während dr Ausführung.
Mir werdet die Funktion verwende, um d' Leischtig vun de verschiedene Kompilierungsmethode über mehrere Schaltunge hinnewäg z analysiere.
def capture_transpilation_metrics(
results, pass_manager, circuits, method_name
):
"""
Capture transpilation metrics for a list of circuits and stores the results in a DataFrame.
Args:
results (pd.DataFrame): DataFrame to store the results.
pass_manager: Pass manager used for transpilation.
circuits (list): List of quantum circuits to transpile.
method_name (str): Name of the transpilation method.
Returns:
list: List of transpiled circuits.
"""
transpiled_circuits = []
for i, qc in enumerate(circuits):
# Transpile the circuit
start_time = time.time()
transpiled_qc = pass_manager.run(qc)
end_time = time.time()
# Needed for AI transpiler to be consistent with other methods
transpiled_qc = transpiled_qc.decompose(gates_to_decompose=["swap"])
# Collect metrics
transpilation_time = end_time - start_time
circuit_depth = transpiled_qc.depth(
lambda x: x.operation.num_qubits == 2
)
circuit_size = transpiled_qc.size()
# Append results to DataFrame
results.loc[len(results)] = {
"method": method_name,
"qc_name": qc.name,
"qc_index": i,
"num_qubits": qc.num_qubits,
"ops": transpiled_qc.count_ops(),
"depth": circuit_depth,
"size": circuit_size,
"runtime": transpilation_time,
}
transpiled_circuits.append(transpiled_qc)
print(
f"Transpiled circuit index {i} ({qc.name}) in {transpilation_time:.2f} seconds with method {method_name}, "
f"depth {circuit_depth}, and size {circuit_size}."
)
return transpiled_circuits
results_su2 = pd.DataFrame(
columns=[
"method",
"qc_name",
"qc_index",
"num_qubits",
"ops",
"depth",
"size",
"runtime",
]
)
tqc_sabre = capture_transpilation_metrics(
results_su2, pm_sabre, qc_su2_list, "sabre"
)
tqc_ai = capture_transpilation_metrics(results_su2, pm_ai, qc_su2_list, "ai")
Transpiled circuit index 0 (SU2_10) in 0.06 seconds with method sabre, depth 13, and size 167.
Transpiled circuit index 1 (SU2_20) in 0.24 seconds with method sabre, depth 20, and size 299.
Transpiled circuit index 2 (SU2_30) in 10.72 seconds with method sabre, depth 72, and size 627.
Transpiled circuit index 3 (SU2_40) in 16.16 seconds with method sabre, depth 40, and size 599.
Transpiled circuit index 4 (SU2_50) in 76.89 seconds with method sabre, depth 77, and size 855.
Transpiled circuit index 5 (SU2_60) in 86.12 seconds with method sabre, depth 60, and size 899.
Transpiled circuit index 6 (SU2_70) in 94.46 seconds with method sabre, depth 79, and size 1085.
Transpiled circuit index 7 (SU2_80) in 69.05 seconds with method sabre, depth 80, and size 1199.
Transpiled circuit index 8 (SU2_90) in 88.25 seconds with method sabre, depth 105, and size 1420.
Transpiled circuit index 9 (SU2_100) in 83.80 seconds with method sabre, depth 100, and size 1499.
Transpiled circuit index 0 (SU2_10) in 0.17 seconds with method ai, depth 10, and size 168.
Transpiled circuit index 1 (SU2_20) in 0.29 seconds with method ai, depth 20, and size 299.
Transpiled circuit index 2 (SU2_30) in 13.56 seconds with method ai, depth 36, and size 548.
Transpiled circuit index 3 (SU2_40) in 15.95 seconds with method ai, depth 40, and size 599.
Transpiled circuit index 4 (SU2_50) in 80.70 seconds with method ai, depth 54, and size 823.
Transpiled circuit index 5 (SU2_60) in 75.99 seconds with method ai, depth 60, and size 899.
Transpiled circuit index 6 (SU2_70) in 64.96 seconds with method ai, depth 74, and size 1087.
Transpiled circuit index 7 (SU2_80) in 68.25 seconds with method ai, depth 80, and size 1199.
Transpiled circuit index 8 (SU2_90) in 75.07 seconds with method ai, depth 90, and size 1404.
Transpiled circuit index 9 (SU2_100) in 63.97 seconds with method ai, depth 100, and size 1499.
Zeigt d' transpilierten Ergebniss vun einer vun de Schaltunge a.
print("Sabre transpilation")
display(tqc_sabre[0].draw("mpl", fold=-1, idle_wires=False))
print("AI transpilation")
display(tqc_ai[0].draw("mpl", fold=-1, idle_wires=False))
Sabre transpilation
AI transpilation
Ergebnistabelle:
summary_su2 = (
results_su2.groupby("method")[["depth", "size", "runtime"]]
.mean()
.round(2)
)
print(summary_su2)
results_su2
depth size runtime
method
ai 56.4 852.5 45.89
sabre 64.6 864.9 52.57
method qc_name qc_index num_qubits ops \
0 sabre SU2_10 0 10 {'rz': 81, 'sx': 70, 'cz': 16}
1 sabre SU2_20 1 20 {'rz': 160, 'sx': 119, 'cz': 20}
2 sabre SU2_30 2 30 {'sx': 295, 'rz': 242, 'cz': 90}
3 sabre SU2_40 3 40 {'rz': 320, 'sx': 239, 'cz': 40}
4 sabre SU2_50 4 50 {'rz': 402, 'sx': 367, 'cz': 86}
5 sabre SU2_60 5 60 {'rz': 480, 'sx': 359, 'cz': 60}
6 sabre SU2_70 6 70 {'rz': 562, 'sx': 441, 'cz': 82}
7 sabre SU2_80 7 80 {'rz': 640, 'sx': 479, 'cz': 80}
8 sabre SU2_90 8 90 {'rz': 721, 'sx': 585, 'cz': 114}
9 sabre SU2_100 9 100 {'rz': 800, 'sx': 599, 'cz': 100}
10 ai SU2_10 0 10 {'rz': 81, 'sx': 71, 'cz': 16}
11 ai SU2_20 1 20 {'rz': 160, 'sx': 119, 'cz': 20}
12 ai SU2_30 2 30 {'sx': 243, 'rz': 242, 'cz': 63}
13 ai SU2_40 3 40 {'rz': 320, 'sx': 239, 'cz': 40}
14 ai SU2_50 4 50 {'rz': 403, 'sx': 346, 'cz': 74}
15 ai SU2_60 5 60 {'rz': 480, 'sx': 359, 'cz': 60}
16 ai SU2_70 6 70 {'rz': 563, 'sx': 442, 'cz': 82}
17 ai SU2_80 7 80 {'rz': 640, 'sx': 479, 'cz': 80}
18 ai SU2_90 8 90 {'rz': 721, 'sx': 575, 'cz': 108}
19 ai SU2_100 9 100 {'rz': 800, 'sx': 599, 'cz': 100}
depth size runtime
0 13 167 0.058845
1 20 299 0.238217
2 72 627 10.723922
3 40 599 16.159262
4 77 855 76.886604
5 60 899 86.118255
6 79 1085 94.458287
7 80 1199 69.048184
8 105 1420 88.254809
9 100 1499 83.795482
10 10 168 0.171532
11 20 299 0.291691
12 36 548 13.555931
13 40 599 15.952733
14 54 823 80.702141
15 60 899 75.993404
16 74 1087 64.960162
17 80 1199 68.253280
18 90 1404 75.072412
19 100 1499 63.967446
Ergebnisgraph
Weil mir e Funktion definiert hän, um Metrike konsistent z erfasse, werdet mir au eine definiere, um d' Metrike grafisch darzuschtelle. Do werdet mir d' Zwei-Qubit-Tiefe, d' Gate-Anzahl und d' Laufzeit für jede Kompilierungsmethode über d' Schaltunge hinnewäg darschtelle.
def plot_transpilation_metrics(results, overall_title, x_axis="qc_index"):
"""
Plots transpilation metrics (depth, size, runtime) for different transpilation methods.
Parameters:
results (DataFrame): Data containing columns ['num_qubits', 'method', 'depth', 'size', 'runtime']
overall_title (str): The title of the overall figure.
x_axis (str): The x-axis label, either 'num_qubits' or 'qc_index'.
"""
fig, axs = plt.subplots(1, 3, figsize=(24, 6))
metrics = ["depth", "size", "runtime"]
titles = ["Circuit Depth", "Circuit Size", "Transpilation Runtime"]
y_labels = ["Depth", "Size (Gate Count)", "Runtime (s)"]
methods = results["method"].unique()
colors = plt.colormaps["tab10"]
markers = ["o", "^", "s", "D", "P", "*", "X", "v"]
color_list = [colors(i % colors.N) for i in range(len(methods))]
color_map = {method: color_list[i] for i, method in enumerate(methods)}
marker_map = {
method: markers[i % len(markers)] for i, method in enumerate(methods)
}
jitter_factor = 0.1 # Small x-axis jitter for visibility
handles, labels = [], [] # Unique handles for legend
# Plot each metric
for i, metric in enumerate(metrics):
for method in methods:
method_data = results[results["method"] == method]
# Introduce slight jitter to avoid exact overlap
jitter = np.random.uniform(
-jitter_factor, jitter_factor, len(method_data)
)
scatter = axs[i].scatter(
method_data[x_axis] + jitter,
method_data[metric],
color=color_map[method],
label=method,
marker=marker_map[method],
alpha=0.7,
edgecolors="black",
s=80,
)
if method not in labels:
handles.append(scatter)
labels.append(method)
axs[i].set_title(titles[i])
axs[i].set_xlabel(x_axis)
axs[i].set_ylabel(y_labels[i])
axs[i].grid(axis="y", linestyle="--", alpha=0.7)
axs[i].tick_params(axis="x", rotation=45)
axs[i].set_xticks(sorted(results[x_axis].unique()))
fig.suptitle(overall_title, fontsize=16)
fig.legend(
handles=handles,
labels=labels,
loc="upper right",
bbox_to_anchor=(1.05, 1),
)
plt.tight_layout()
plt.show()
plot_transpilation_metrics(
results_su2, "Transpilation Metrics for SU2 Circuits", x_axis="num_qubits"
)
Analyse vun de SU2-Schaltungskompilierungsergebniss
In dem Experiment vergleicha mir zwei Transpilationsmethode – Qiskits SABRE-Transpiler und dr AI-gstützte Transpiler – a emme Satz vun efficient_su2-Schaltunge. Weil dene Schaltunge kei PauliEvolutionGate-Operatione hän, isch s Rustiq-Plugin in dem Vergleich nit enthalte.
Im Durchschnitt schneidet dr AI-Transpiler hinsichtlich dr Schaltungstiefe besser ab, mit ere Verbesserung vun mehr als 10% über d' gsamt Bandbreite vun de SU2-Schaltunge hinnewäg. Für d' Gate-Anzahl (Schaltungsgröße) und d' Transpilationslaufzeit erzielet beide Methode insgesamt ähnliche Ergebniss.
D' Inspektion vun de einzelne Datepunkte offenbart jedoch e tiefer Einsicht:
- Für d' meischte Qubit-Größe produziert sowohl SABRE als au AI nahezu identische Ergebniss, was druf hindeutet, dass beide Methode in vielen Fäll zu ähnlich effizienten Lösunge konvergiert.
- Für bestimmte Schaltungsgrößen, speziell bi 30, 50, 70 und 90 Qubits, findet dr AI-Transpiler deutlich flachere Schaltunge als SABRE. Des zeigt, dass dr lernbasierte Ansatz vun AI in dr Lag isch, optimalere Layouts oder Routing-Pfad in Fäll z entdecke, in dene d' SABRE-Heuristik des nit tuet.
Des Verhalte hebt e wichtige Erkenntnis hervor:
Während SABRE und AI oft vergleichbare Ergebniss produziert, ka dr AI-Transpiler gelegentlich viel bessere Lösunge entdecke, insbesondere hinsichtlich dr Tiefe, was zu deutlich verbesserter Leischtig uf Hardware führe ka.
Teil 2: Hamilton-Simulationsschaltung
Schritt 1: Untersuchung vun Schaltunge mit PauliEvolutionGate
In dem Abschnitt untersuacht mir Quanteschaltunge, wo unter Verwendung vun PauliEvolutionGate konstruiert wore sind, wo e effiziente Simulation vun Hamiltonians ermöglicht. Mir werdet analysiere, wie verschiedene Kompilierungsmethode dene Schaltunge über verschiedene Hamiltonians hinnewäg optimiert.
In dem Benchmark verwendete Hamiltonians
D' in dem Benchmark verwendete Hamiltonians beschreibet paarweise Interaktione zwische Qubits, ischließlich Terme wie , und . Dene Hamiltonians werdet häufig in Quantenchemie, Festkörperphysik und Materialwissenschaft verwändet, wo se Systeme vun interagierenden Teilche modelliert.
Als Referenz kenne Benutzer en breiterere Satz vun Hamiltonians in dem Paper erkunde: Efficient Hamiltonian Simulation on Noisy Quantum Devices.
Benchmark-Quelle: Hamlib und Benchpress
D' in dem Benchmark verwendete Schaltunge stammet us em Hamlib-Benchmark-Repository, wo realistische Hamilton-Simulations-Workloads enthält.
Dene gleiche Schaltunge sind zuvor mit Benchpress benchmarked wore, emme Open-Source-Framework zur Bewertig vun dr Quanten-Transpilationsleischtig. Durch d' Verwendung vun dem standardisierten Satz vun Schaltunge kenne mir d' Effektivität verschiedener Kompilierungsstrategie bi repräsentativen Simulationsproblem direkt vergleicha.
Hamilton-Simulation isch e grundlegende Ufgab im Quantencomputing mit Anwendunge in Molekülsimulatiône, Optimierungsproblem und Quanten-Vielteilchenphysik. S Verständnis, wie verschiedene Kompilierungsmethode dene Schaltunge optimiert, ka de Benutzern helfe, d' praktische Ausführung vun solche Schaltunge uf kurzfristige Quantegeräte z verbessere.
# Obtain the Hamiltonian JSON from the benchpress repository
url = "https://raw.githubusercontent.com/Qiskit/benchpress/e7b29ef7be4cc0d70237b8fdc03edbd698908eff/benchpress/hamiltonian/hamlib/100_representative.json"
response = requests.get(url)
response.raise_for_status() # Raise an error if download failed
ham_records = json.loads(response.text)
# Remove circuits that are too large for the backend
ham_records = [
h for h in ham_records if h["ham_qubits"] <= backend.num_qubits
]
# Remove the circuits that are large to save transpilation time
ham_records = sorted(ham_records, key=lambda x: x["ham_terms"])[:35]
qc_ham_list = []
for h in ham_records:
terms = h["ham_hamlib_hamiltonian_terms"]
coeff = h["ham_hamlib_hamiltonian_coefficients"]
num_qubits = h["ham_qubits"]
name = h["ham_problem"]
evo_gate = PauliEvolutionGate(SparsePauliOp(terms, coeff))
qc_ham = QuantumCircuit(num_qubits)
qc_ham.name = name
qc_ham.append(evo_gate, range(num_qubits))
qc_ham_list.append(qc_ham)
print(f"Number of Hamiltonian circuits: {len(qc_ham_list)}")
# Draw the first Hamiltonian circuit
qc_ham_list[0].draw("mpl", fold=-1)
Number of Hamiltonian circuits: 35
Schritt 2: Problem für d' Ausführung uf Quantehardware optimiere
Wie im vorherige Beispiel verwändete mir dasselbe Backend, um Konsistenz in onsere Vergleich sicherzuschaffe. Da d' Pass-Manager (pm_sabre, pm_ai und pm_rustiq) bereits initialisiert wore sind, kenne mir direkt mit dr Transpilation vun de Hamilton-Schaltunge mit jedere Methode fortfahre.
Der Schritt konzentriert sich ausschließlich uf d' Durchführung vun dr Transpilation und d' Ufzeichnung vun de resultierenden Schaltungsmetrike, ischließlich Tiefe, Gate-Anzahl und Transpilationslaufzeit. Durch d' Analyse vun dene Ergebniss weitet mir d' Effizienz vun jedere Transpilationsmethode für dene Schaltungstyp bestimme.
Transpiliere und Metrike erfasse:
results_ham = pd.DataFrame(
columns=[
"method",
"qc_name",
"qc_index",
"num_qubits",
"ops",
"depth",
"size",
"runtime",
]
)
tqc_sabre = capture_transpilation_metrics(
results_ham, pm_sabre, qc_ham_list, "sabre"
)
tqc_ai = capture_transpilation_metrics(results_ham, pm_ai, qc_ham_list, "ai")
tqc_rustiq = capture_transpilation_metrics(
results_ham, pm_rustiq, qc_ham_list, "rustiq"
)
Transpiled circuit index 0 (all-vib-o3) in 0.02 seconds with method sabre, depth 6, and size 58.
Transpiled circuit index 1 (all-vib-c2h) in 1.10 seconds with method sabre, depth 2, and size 39.
Transpiled circuit index 2 (all-vib-bh) in 0.01 seconds with method sabre, depth 3, and size 30.
Transpiled circuit index 3 (all-vib-c2h) in 0.03 seconds with method sabre, depth 18, and size 115.
Transpiled circuit index 4 (graph-gnp_k-2) in 0.02 seconds with method sabre, depth 24, and size 129.
Transpiled circuit index 5 (all-vib-fccf) in 0.05 seconds with method sabre, depth 14, and size 134.
Transpiled circuit index 6 (all-vib-hno) in 8.39 seconds with method sabre, depth 6, and size 174.
Transpiled circuit index 7 (all-vib-bhf2) in 3.92 seconds with method sabre, depth 22, and size 220.
Transpiled circuit index 8 (LiH) in 0.03 seconds with method sabre, depth 67, and size 290.
Transpiled circuit index 9 (uf20-ham) in 0.04 seconds with method sabre, depth 50, and size 340.
Transpiled circuit index 10 (all-vib-fccf) in 0.62 seconds with method sabre, depth 30, and size 286.
Transpiled circuit index 11 (all-vib-fccf) in 0.04 seconds with method sabre, depth 67, and size 339.
Transpiled circuit index 12 (all-vib-ch2) in 0.04 seconds with method sabre, depth 87, and size 421.
Transpiled circuit index 13 (tfim) in 0.05 seconds with method sabre, depth 36, and size 222.
Transpiled circuit index 14 (all-vib-cyclo_propene) in 9.51 seconds with method sabre, depth 22, and size 345.
Transpiled circuit index 15 (graph-gnp_k-4) in 0.05 seconds with method sabre, depth 128, and size 704.
Transpiled circuit index 16 (all-vib-hc3h2cn) in 13.83 seconds with method sabre, depth 2, and size 242.
Transpiled circuit index 17 (TSP_Ncity-4) in 0.05 seconds with method sabre, depth 106, and size 609.
Transpiled circuit index 18 (tfim) in 0.29 seconds with method sabre, depth 73, and size 399.
Transpiled circuit index 19 (all-vib-h2co) in 21.97 seconds with method sabre, depth 30, and size 572.
Transpiled circuit index 20 (Be2) in 0.09 seconds with method sabre, depth 324, and size 1555.
Transpiled circuit index 21 (graph-complete_bipart) in 0.12 seconds with method sabre, depth 250, and size 1394.
Transpiled circuit index 22 (all-vib-f2) in 0.07 seconds with method sabre, depth 215, and size 1027.
Transpiled circuit index 23 (all-vib-cyclo_propene) in 41.22 seconds with method sabre, depth 30, and size 1144.
Transpiled circuit index 24 (TSP_Ncity-5) in 1.89 seconds with method sabre, depth 175, and size 1933.
Transpiled circuit index 25 (H2) in 0.32 seconds with method sabre, depth 1237, and size 5502.
Transpiled circuit index 26 (uuf100-ham) in 0.20 seconds with method sabre, depth 385, and size 4303.
Transpiled circuit index 27 (ham-graph-gnp_k-5) in 0.20 seconds with method sabre, depth 311, and size 3654.
Transpiled circuit index 28 (tfim) in 0.15 seconds with method sabre, depth 276, and size 3213.
Transpiled circuit index 29 (uuf100-ham) in 0.21 seconds with method sabre, depth 520, and size 5250.
Transpiled circuit index 30 (flat100-ham) in 0.15 seconds with method sabre, depth 131, and size 3157.
Transpiled circuit index 31 (uf100-ham) in 0.24 seconds with method sabre, depth 624, and size 7378.
Transpiled circuit index 32 (OH) in 0.88 seconds with method sabre, depth 2175, and size 9808.
Transpiled circuit index 33 (HF) in 0.66 seconds with method sabre, depth 2206, and size 9417.
Transpiled circuit index 34 (BH) in 0.89 seconds with method sabre, depth 2177, and size 9802.
Transpiled circuit index 0 (all-vib-o3) in 0.02 seconds with method ai, depth 6, and size 58.
Transpiled circuit index 1 (all-vib-c2h) in 1.11 seconds with method ai, depth 2, and size 39.
Transpiled circuit index 2 (all-vib-bh) in 0.01 seconds with method ai, depth 3, and size 30.
Transpiled circuit index 3 (all-vib-c2h) in 0.11 seconds with method ai, depth 18, and size 94.
Transpiled circuit index 4 (graph-gnp_k-2) in 0.11 seconds with method ai, depth 22, and size 129.
Transpiled circuit index 5 (all-vib-fccf) in 0.06 seconds with method ai, depth 22, and size 177.
Transpiled circuit index 6 (all-vib-hno) in 8.62 seconds with method ai, depth 10, and size 198.
Transpiled circuit index 7 (all-vib-bhf2) in 3.71 seconds with method ai, depth 18, and size 195.
Transpiled circuit index 8 (LiH) in 0.19 seconds with method ai, depth 62, and size 267.
Transpiled circuit index 9 (uf20-ham) in 0.22 seconds with method ai, depth 47, and size 321.
Transpiled circuit index 10 (all-vib-fccf) in 0.71 seconds with method ai, depth 38, and size 369.
Transpiled circuit index 11 (all-vib-fccf) in 0.24 seconds with method ai, depth 65, and size 315.
Transpiled circuit index 12 (all-vib-ch2) in 0.24 seconds with method ai, depth 91, and size 430.
Transpiled circuit index 13 (tfim) in 0.15 seconds with method ai, depth 12, and size 251.
Transpiled circuit index 14 (all-vib-cyclo_propene) in 8.50 seconds with method ai, depth 18, and size 311.
Transpiled circuit index 15 (graph-gnp_k-4) in 0.25 seconds with method ai, depth 117, and size 659.
Transpiled circuit index 16 (all-vib-hc3h2cn) in 16.11 seconds with method ai, depth 2, and size 242.
Transpiled circuit index 17 (TSP_Ncity-4) in 0.39 seconds with method ai, depth 98, and size 564.
Transpiled circuit index 18 (tfim) in 0.38 seconds with method ai, depth 23, and size 437.
Transpiled circuit index 19 (all-vib-h2co) in 24.97 seconds with method ai, depth 38, and size 707.
Transpiled circuit index 20 (Be2) in 1.07 seconds with method ai, depth 293, and size 1392.
Transpiled circuit index 21 (graph-complete_bipart) in 0.61 seconds with method ai, depth 229, and size 1437.
Transpiled circuit index 22 (all-vib-f2) in 0.57 seconds with method ai, depth 178, and size 964.
Transpiled circuit index 23 (all-vib-cyclo_propene) in 50.89 seconds with method ai, depth 34, and size 1425.
Transpiled circuit index 24 (TSP_Ncity-5) in 1.61 seconds with method ai, depth 171, and size 2020.
Transpiled circuit index 25 (H2) in 6.39 seconds with method ai, depth 1148, and size 5208.
Transpiled circuit index 26 (uuf100-ham) in 3.97 seconds with method ai, depth 376, and size 5048.
Transpiled circuit index 27 (ham-graph-gnp_k-5) in 3.54 seconds with method ai, depth 357, and size 4451.
Transpiled circuit index 28 (tfim) in 1.72 seconds with method ai, depth 216, and size 3026.
Transpiled circuit index 29 (uuf100-ham) in 4.45 seconds with method ai, depth 426, and size 5399.
Transpiled circuit index 30 (flat100-ham) in 7.02 seconds with method ai, depth 86, and size 3108.
Transpiled circuit index 31 (uf100-ham) in 12.85 seconds with method ai, depth 623, and size 8354.
Transpiled circuit index 32 (OH) in 15.19 seconds with method ai, depth 2084, and size 9543.
Transpiled circuit index 33 (HF) in 17.51 seconds with method ai, depth 2063, and size 9446.
Transpiled circuit index 34 (BH) in 15.33 seconds with method ai, depth 2094, and size 9730.
Transpiled circuit index 0 (all-vib-o3) in 0.02 seconds with method rustiq, depth 13, and size 83.
Transpiled circuit index 1 (all-vib-c2h) in 1.11 seconds with method rustiq, depth 2, and size 39.
Transpiled circuit index 2 (all-vib-bh) in 0.01 seconds with method rustiq, depth 3, and size 30.
Transpiled circuit index 3 (all-vib-c2h) in 0.01 seconds with method rustiq, depth 13, and size 79.
Transpiled circuit index 4 (graph-gnp_k-2) in 0.02 seconds with method rustiq, depth 31, and size 131.
Transpiled circuit index 5 (all-vib-fccf) in 0.04 seconds with method rustiq, depth 50, and size 306.
Transpiled circuit index 6 (all-vib-hno) in 14.03 seconds with method rustiq, depth 22, and size 276.
Transpiled circuit index 7 (all-vib-bhf2) in 3.15 seconds with method rustiq, depth 13, and size 155.
Transpiled circuit index 8 (LiH) in 0.03 seconds with method rustiq, depth 54, and size 270.
Transpiled circuit index 9 (uf20-ham) in 0.04 seconds with method rustiq, depth 65, and size 398.
Transpiled circuit index 10 (all-vib-fccf) in 0.16 seconds with method rustiq, depth 41, and size 516.
Transpiled circuit index 11 (all-vib-fccf) in 0.02 seconds with method rustiq, depth 34, and size 189.
Transpiled circuit index 12 (all-vib-ch2) in 0.03 seconds with method rustiq, depth 49, and size 240.
Transpiled circuit index 13 (tfim) in 0.05 seconds with method rustiq, depth 20, and size 366.
Transpiled circuit index 14 (all-vib-cyclo_propene) in 9.08 seconds with method rustiq, depth 16, and size 277.
Transpiled circuit index 15 (graph-gnp_k-4) in 0.04 seconds with method rustiq, depth 116, and size 612.
Transpiled circuit index 16 (all-vib-hc3h2cn) in 13.89 seconds with method rustiq, depth 2, and size 257.
Transpiled circuit index 17 (TSP_Ncity-4) in 0.05 seconds with method rustiq, depth 133, and size 737.
Transpiled circuit index 18 (tfim) in 0.11 seconds with method rustiq, depth 25, and size 680.
Transpiled circuit index 19 (all-vib-h2co) in 27.19 seconds with method rustiq, depth 66, and size 983.
Transpiled circuit index 20 (Be2) in 0.07 seconds with method rustiq, depth 215, and size 1030.
Transpiled circuit index 21 (graph-complete_bipart) in 0.14 seconds with method rustiq, depth 328, and size 1918.
Transpiled circuit index 22 (all-vib-f2) in 0.05 seconds with method rustiq, depth 114, and size 692.
Transpiled circuit index 23 (all-vib-cyclo_propene) in 62.25 seconds with method rustiq, depth 74, and size 2348.
Transpiled circuit index 24 (TSP_Ncity-5) in 0.20 seconds with method rustiq, depth 436, and size 3605.
Transpiled circuit index 25 (H2) in 0.21 seconds with method rustiq, depth 643, and size 3476.
Transpiled circuit index 26 (uuf100-ham) in 0.24 seconds with method rustiq, depth 678, and size 6120.
Transpiled circuit index 27 (ham-graph-gnp_k-5) in 0.22 seconds with method rustiq, depth 588, and size 5241.
Transpiled circuit index 28 (tfim) in 0.34 seconds with method rustiq, depth 340, and size 5901.
Transpiled circuit index 29 (uuf100-ham) in 0.33 seconds with method rustiq, depth 881, and size 7667.
Transpiled circuit index 30 (flat100-ham) in 0.31 seconds with method rustiq, depth 279, and size 4910.
Transpiled circuit index 31 (uf100-ham) in 0.38 seconds with method rustiq, depth 1138, and size 10607.
Transpiled circuit index 32 (OH) in 0.38 seconds with method rustiq, depth 1148, and size 6512.
Transpiled circuit index 33 (HF) in 0.37 seconds with method rustiq, depth 1090, and size 6256.
Transpiled circuit index 34 (BH) in 0.37 seconds with method rustiq, depth 1148, and size 6501.
Ergebnistabelle (Visualisierung wird übersprunge, weil d' Ausgabeschaltunge sehr groß sind):
summary_ham = (
results_ham.groupby("method")[["depth", "size", "runtime"]]
.mean()
.round(2)
)
print(summary_ham)
results_ham
depth size runtime
method
ai 316.86 2181.26 5.97
rustiq 281.94 2268.80 3.86
sabre 337.97 2120.14 3.07
method qc_name qc_index num_qubits \
0 sabre all-vib-o3 0 4
1 sabre all-vib-c2h 1 4
2 sabre all-vib-bh 2 2
3 sabre all-vib-c2h 3 3
4 sabre graph-gnp_k-2 4 4
.. ... ... ... ...
100 rustiq flat100-ham 30 90
101 rustiq uf100-ham 31 46
102 rustiq OH 32 10
103 rustiq HF 33 10
104 rustiq BH 34 10
ops depth size runtime
0 {'rz': 28, 'sx': 24, 'cz': 6} 6 58 0.016597
1 {'rz': 17, 'sx': 16, 'cz': 4, 'x': 2} 2 39 1.102089
2 {'sx': 14, 'rz': 13, 'cz': 3} 3 30 0.011042
3 {'sx': 46, 'rz': 45, 'cz': 18, 'x': 6} 18 115 0.025816
4 {'sx': 49, 'rz': 47, 'cz': 24, 'x': 9} 24 129 0.023077
.. ... ... ... ...
100 {'sx': 2709, 'cz': 1379, 'rz': 817, 'x': 5} 279 4910 0.309448
101 {'sx': 6180, 'cz': 3120, 'rz': 1303, 'x': 4} 1138 10607 0.380977
102 {'sx': 3330, 'cz': 1704, 'rz': 1455, 'x': 23} 1148 6512 0.383564
103 {'sx': 3213, 'cz': 1620, 'rz': 1406, 'x': 17} 1090 6256 0.368578
104 {'sx': 3331, 'cz': 1704, 'rz': 1447, 'x': 19} 1148 6501 0.374822
[105 rows x 8 columns]
Visualisiert d' Leischtig basierend uf em Schaltungsindex:
plot_transpilation_metrics(
results_ham, "Transpilation Metrics for Hamiltonian Circuits"
)
Visualisiert dr Prozentsatz vun de Schaltunge, für die jede Methode am beschte abgschnitten hett.
def analyze_and_plot_best_methods(results, metric):
"""
Analyze the best-performing methods for a given metric and plot a pie chart.
Parameters:
results (DataFrame): The input DataFrame containing method performance data.
metric (str): The metric to evaluate ("depth" or "size").
"""
method_counts = Counter()
for qc_idx, group in results.groupby("qc_index"):
min_value = group[metric].min()
# Find all methods that achieved this minimum value
best_methods = group[group[metric] == min_value]["method"]
# Update counts for all best methods (handling ties)
method_counts.update(best_methods)
best_method_counts = dict(
sorted(method_counts.items(), key=lambda x: x[1], reverse=True)
)
# Print summary
print(f"Best-performing methods based on {metric}:")
for method, count in best_method_counts.items():
print(f" {method}: {count} circuit(s)")
# Plot pie chart
num_methods = len(best_method_counts)
colors = plt.cm.viridis_r(range(0, 256, 256 // num_methods))
plt.figure(figsize=(5, 5))
plt.pie(
best_method_counts.values(),
labels=best_method_counts.keys(),
autopct="%1.1f%%",
startangle=140,
wedgeprops={"edgecolor": "black"},
textprops={"fontsize": 10},
colors=colors,
)
plt.title(
f"Percentage of Circuits Method Performed Best for {metric.capitalize()}",
fontsize=12,
fontweight="bold",
)
plt.show()
analyze_and_plot_best_methods(results_ham, "depth")
analyze_and_plot_best_methods(results_ham, "size")
Best-performing methods based on depth:
ai: 16 circuit(s)
rustiq: 16 circuit(s)
sabre: 10 circuit(s)
Best-performing methods based on size:
sabre: 18 circuit(s)
rustiq: 14 circuit(s)
ai: 10 circuit(s)
Analyse vun de Hamilton-Schaltungskompilierungsergebniss
In dem Abschnitt evaluiere mir d' Leischtig vun drei Transpilationsmethode – SABRE, em AI-gstützten Transpiler und Rustiq – an Quanteschaltunge, wo mit PauliEvolutionGate konstruiert wore sind, wo häufig in Hamilton-Simulationsufgabe verwändet werdet.
Rustiq hett im Durchschnitt am beschte hinsichtlich dr Schaltungstiefe abgschnitten und hett e etwa 20% niedrigere Tiefe als SABRE erreicht. Des isch z erwarte, weil Rustiq speziell für d' Synthese vun PauliEvolutionGate-Operatione mit optimierten, niedrig-tife Zerlegungsstrategie entwickelt wore isch. Darüber hinaus zeigt s Tiefediagramm, dass Rustiq am effektivschte skaliert, wenn d' Schaltunge an Größe und Komplexität zunehmet, und e deutlich geringere Tiefe als sowohl AI als au SABRE bi größere Schaltunge beibehaltet.
Dr AI-Transpiler hett starke und konsistente Leischtig für d' Schaltungstiefe gzeigt und hett SABRE konsistent über d' meischte Schaltunge hinnewäg übertroffe. Er hett jedoch d' höchste Laufzeit verursacht, insbesondere bi größere Schaltunge, was sine Praktikabilität in zeitkritische Workloads einschränke ka. Sine Skalierbarkeit bi dr Laufzeit bleibt e Schlüsselbeschränkung, obwohl er solide Verbesserunge bi dr Tiefe bietet.
SABRE hett zwar d' höchste durchschnittliche Tiefe erzielt, aber d' niedrigste durchschnittliche Gate-Anzahl, dicht gefolgt vun em AI-Transpiler. Des isch im Einklang mit em Design vun dr SABRE-Heuristik, wo d' Minimierung vun dr Gate-Anzahl direkt priorisiert. Rustiq hett trotz sinere Stärke bi dr Senkung vun dr Tiefe d' höchste durchschnittliche Gate-Anzahl ghett, was en bemerkenswerte Kompromiss isch, den mr in Anwendunge berücksichtige sollt, bi dene d' Schaltungsgröße mehr zählt als d' Schaltungsdauer.
Zusammefassung
Während dr AI-Transpiler im Allgemeine bessere Ergebniss als SABRE liefert, insbesondere bi dr Schaltungstiefe, sollt d' Schlussfolgerung nit einfach "immer dr AI-Transpiler verwände" sei. Es git wichtige Nuancen z berücksichtige:
-
AI-Transpiler isch typischerweise zuverlässig und liefert tiefenoptimierte Schaltunge, bringt aber Kompromisse bi dr Laufzeit mit sich und hett au andere Einschränkunge, ischließlich unterstützter Coupling-Maps und Synthese-Fähigkeite. Dene sind in dr Qiskit Transpiler Service-Dokumentation detailliert beschriebe.
-
In manchen Fälle, insbesondere bi sehr große oder hardwarespezifische Schaltunge, isch dr AI-Transpiler möglicherweise nit so effektiv. In dene Fäll bleibt dr Standard-SABRE-Transpiler äußerst zuverlässig und ka durch Agpassung sinere Parameter weiter optimiert werre (gseet s SABRE-Optimierungs-Tutorial).
-
Es isch au wichtig, d' Schaltungsstruktur bi dr Wahl vun ere Methode z berücksichtige. Zum Beispiel isch
rustiqspeziell für Schaltunge mitPauliEvolutionGatekonzipiert und liefert oft d' beste Leischtig für Hamilton-Simulationsproblem.
Empfehlung:
Es git kei Einheitslösung für d' Transpilationsstrategie. D' Benutzer werdet ermuntert, d' Struktur vun ihrer Schaltung z versteh und mehrere Transpilationsmethode z teste – ischließlich AI, SABRE und spezialisierte Tools wie Rustiq – um d' effizienteste Lösung für ires spezifisches Problem und ihre Hardware-Einschränkunge z finde.
Schritt 3: Ausführung mit Qiskit Primitives
Weil sich des Tutorial uf Transpilation konzentriert, werdet kei Experimente uf emme Quantegerät ausgeführt. S Ziel isch es, d' Optimierunge us Schritt 2 z nutze, um e transpilierte Schaltung mit reduzierter Tiefe und Gate-Anzahl z erhalte.
Schritt 4: Nachbearbeitung und Rückgab vun em Ergebnis im gwünschte klassische Format
Da es kei Ausführung für des Notebook git, git es au kei Ergebniss zur Nachbearbeitung.
Referenze
[1] "LightSABRE: A Lightweight and Enhanced SABRE Algorithm". H. Zou, M. Treinish, K. Hartman, A. Ivrii, J. Lishman et al. https://arxiv.org/abs/2409.08368
[2] "Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning". D. Kremer, V. Villar, H. Paik, I. Duran, I. Faro, J. Cruz-Benito et al. https://arxiv.org/abs/2405.13196
[3] "Pauli Network Circuit Synthesis with Reinforcement Learning". A. Dubal, D. Kremer, S. Martiel, V. Villar, D. Wang, J. Cruz-Benito et al. https://arxiv.org/abs/2503.14448
[4] "Faster and shorter synthesis of Hamiltonian simulation circuits". T. Goubault de Brugière, S. Martiel et al. https://arxiv.org/abs/2404.03280