Introduzione al transpiler AI-powered di Qiskit
Stima di utilizzo: 5 minuti su IBM Heron (NOTA: Questa è solo una stima. Il tempo di esecuzione effettivo può variare.)
Obiettivi di apprendimento
Al termine di questo tutorial, gli utenti dovrebbero comprendere:
- Come utilizzare il transpiler AI-powered (
generate_ai_pass_manager) come sostituto diretto del transpiler standard - Come il transpiler AI-powered si confronta con il transpiler predefinito in termini di profondità a due qubit, conteggio dei gate e tempo di transpilazione
- Come utilizzare i mirror circuit per valutare la qualità della transpilazione tramite esecuzione su hardware
Prerequisiti
Suggeriamo che gli utenti abbiano familiarità con i seguenti argomenti prima di affrontare questo tutorial:
Contesto
Il transpiler AI-powered di Qiskit introduce pass di transpilazione basati su machine learning che possono produrre circuit più corti ed efficienti per l'hardware rispetto ai metodi euristici tradizionali come SABRE. I circuit più corti accumulano meno rumore, il che migliora direttamente la qualità dei risultati su hardware quantistico reale.
In questo tutorial confrontiamo due strategie di transpilazione:
| Strategia | API |
|---|---|
| Predefinita | generate_preset_pass_manager(optimization_level=3, ...) |
| AI | generate_ai_pass_manager(optimization_level=1, ai_optimization_level=3, ...) |
Misuriamo tre metriche per ciascuna strategia: profondità dei gate a due qubit, conteggio totale dei gate e tempo di esecuzione della transpilazione.
Benchmark del transpiler AI-powered
Nei test di benchmarking, il transpiler AI-powered ha prodotto costantemente circuit più superficiali e di qualità superiore rispetto al transpiler standard di Qiskit. Per questi test, abbiamo utilizzato la strategia predefinita del pass manager di Qiskit, configurata con generate_preset_pass_manager. Sebbene questa strategia predefinita sia spesso efficace, può avere difficoltà con circuit più grandi o più complessi. Al contrario, i pass AI-powered hanno ottenuto una riduzione media del 24% nel numero di gate a due qubit e una riduzione del 36% nella profondità del circuit per circuit di grandi dimensioni (100+ qubit) durante la transpilazione alla topologia heavy-hex dell'hardware IBM Quantum®. Per ulteriori informazioni su questi benchmark, consulta questo blog.
Questo tutorial esplora i principali vantaggi dei pass AI e come si confrontano con i metodi tradizionali.
Requisiti
Prima di iniziare questo tutorial, assicurati di avere installato quanto segue:
- Qiskit SDK v2.0 o successivo, con supporto per la visualizzazione
- Qiskit Runtime (
pip install qiskit-ibm-runtime) v0.22 o successivo - Qiskit IBM Transpiler con modalità locale AI (
pip install 'qiskit-ibm-transpiler[ai-local-mode]') - Qiskit Aer (
pip install qiskit-aer)
Configurazione
# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib qiskit qiskit-aer qiskit-ibm-runtime qiskit-ibm-transpiler
from qiskit import QuantumCircuit
from qiskit.circuit.random import random_circuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, depolarizing_error
import matplotlib.pyplot as plt
from statistics import mean, stdev
import time
import logging
seed = 42
def transpile_with_metrics(pass_manager, circuit):
"""Transpile a circuit and return the result along with key metrics."""
start = time.time()
qc_out = pass_manager.run(circuit)
elapsed = time.time() - start
depth_2q = qc_out.depth(lambda x: x.operation.num_qubits == 2)
gate_count = qc_out.size()
return qc_out, {
"depth_2q": depth_2q,
"gate_count": gate_count,
"time_s": round(elapsed, 3),
}
def remap_to_contiguous(tqc):
"""Remap a transpiled circuit to use contiguous qubit indices.
Transpiled circuits target specific physical qubits (e.g., qubit 45, 67)
on a large backend. This remaps them to 0, 1, 2, ... so Aer only
simulates the active qubits."""
active = sorted(
{tqc.find_bit(q).index for inst in tqc.data for q in inst.qubits}
)
qubit_map = {old: new for new, old in enumerate(active)}
new_qc = QuantumCircuit(len(active))
for inst in tqc.data:
old_indices = [tqc.find_bit(q).index for q in inst.qubits]
new_qc.append(inst.operation, [qubit_map[i] for i in old_indices])
return new_qc
def build_mirror_circuit(tqc, simulate=True):
"""Build a mirror circuit: U followed by U-dagger, with measurements.
The expected output is always |0...0>, so measuring the survival
probability reveals how much noise each transpilation strategy adds.
Args:
tqc: A transpiled circuit.
simulate: If True (default), remap to contiguous qubits so Aer
only simulates the active qubits. If False, keep the full
physical layout for hardware execution."""
if simulate:
tqc = remap_to_contiguous(tqc)
mirror = tqc.compose(tqc.inverse())
mirror.measure_all()
return mirror
def print_summary(results):
"""Print a summary of each metric as mean +/- stdev across all circuits,
along with the mean percentage improvement of AI over Default."""
metrics = [
("Depth 2Q", "Depth 2Q (Default)", "Depth 2Q (AI)"),
("Gate Count", "Gate Count (Default)", "Gate Count (AI)"),
("Time (s)", "Time (Default)", "Time (AI)"),
]
header = (
f"{'Metric':<12}{'Default (mean +/- std)':>24}"
f"{'AI (mean +/- std)':>22}{'AI % improvement':>22}"
)
print(header)
print("-" * len(header))
for label, col_def, col_ai in metrics:
defaults = [r[col_def] for r in results]
ais = [r[col_ai] for r in results]
pct = [(d - a) / d * 100 for d, a in zip(defaults, ais)]
default_str = f"{mean(defaults):.1f} +/- {stdev(defaults):.1f}"
ai_str = f"{mean(ais):.1f} +/- {stdev(ais):.1f}"
pct_str = f"{mean(pct):+.1f}% +/- {stdev(pct):.1f}%"
print(f"{label:<12}{default_str:>24}{ai_str:>22}{pct_str:>22}")
def plot_metrics_and_pct(results, title_prefix):
"""Plot metric comparisons and percentage improvement of AI over Default."""
qubits = [r["Qubits"] for r in results]
metrics = [
("Depth 2Q (Default)", "Depth 2Q (AI)", "Two-Qubit Depth"),
("Gate Count (Default)", "Gate Count (AI)", "Gate Count"),
("Time (Default)", "Time (AI)", "Transpilation Time"),
]
# Row 1: raw metric comparison
fig, axs = plt.subplots(1, 3, figsize=(21, 5))
fig.suptitle(
f"{title_prefix}: Metric Comparison",
fontsize=15,
fontweight="bold",
y=1.02,
)
for ax, (col_def, col_ai, label) in zip(axs, metrics):
ax.plot(qubits, [r[col_def] for r in results], "o-", label="Default")
ax.plot(qubits, [r[col_ai] for r in results], "s-", label="AI")
ax.set_title(label)
ax.set_xlabel("Number of Qubits")
ax.set_ylabel(label)
ax.legend()
plt.tight_layout()
plt.show()
# Row 2: percentage improvement
fig, axs = plt.subplots(1, 3, figsize=(21, 5))
fig.suptitle(
f"{title_prefix}: % Improvement of AI over Default",
fontsize=15,
fontweight="bold",
y=1.02,
)
for ax, (col_def, col_ai, label) in zip(axs, metrics):
pct = [(r[col_def] - r[col_ai]) / r[col_def] * 100 for r in results]
ax.axhline(
0, color="#1f77b4", linewidth=2, label="Default (baseline)"
)
ax.plot(qubits, pct, "s-", color="#ff7f0e", label="AI")
ax.fill_between(qubits, 0, pct, alpha=0.15, color="#ff7f0e")
ax.set_title(label)
ax.set_xlabel("Number of Qubits")
ax.set_ylabel("% Improvement")
ax.legend()
plt.tight_layout()
plt.show()
# Suppress verbose AI-powered transpiler logs
logging.getLogger(
"qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)
Esempio con simulatore su piccola scala
Passo 1: Mappare gli input classici in un problema quantistico
Generiamo 20 circuit casuali con profondità 4, dove il numero di qubit varia da sei a 25. Questi circuit serviranno come casi di test per confrontare le strategie di transpilazione.
num_circuits_sim = 20
depth_sim = 4
qubit_range_sim = list(range(6, 26))
circuits_sim = [
# We have only two qubit gates, as those test how well the transpiler can optimize the circuit.
random_circuit(
num_qubits=n,
depth=depth_sim,
max_operands=2,
num_operand_distribution={2: 1},
seed=seed + i,
)
for i, n in enumerate(qubit_range_sim)
]
print(
f"Created {len(circuits_sim)} circuits with qubit counts: {qubit_range_sim}"
)
circuits_sim[0].draw(output="mpl", fold=-1)
Created 20 circuits with qubit counts: [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
Passo 2: Ottimizzare il problema per l'esecuzione su hardware quantistico
Costruiamo il pass manager predefinito (SABRE) per il Backend scelto. Entrambe le strategie di transpilazione puntano alla mappa di accoppiamento completa del Backend. La simulazione locale rimane trattabile in seguito perché il passo di simulazione utilizza remap_to_contiguous per rinominare ciascun circuit transpilato usando solo i suoi qubit attivi, in modo che Aer simuli solo quei qubit invece dell'intero dispositivo.
service = QiskitRuntimeService()
backend = service.least_busy(
min_num_qubits=100, operational=True, simulator=False
)
pm_default_sim = generate_preset_pass_manager(
optimization_level=3,
backend=backend,
seed_transpiler=seed,
)
results_sim = []
for i, qc in enumerate(circuits_sim):
n = qubit_range_sim[i]
qc_default, m_default = transpile_with_metrics(pm_default_sim, qc)
# Create a fresh AI pass manager each iteration to avoid stale layout state
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai, m_ai = transpile_with_metrics(pm_ai, qc)
results_sim.append(
{
"Qubits": n,
"Depth 2Q (Default)": m_default["depth_2q"],
"Depth 2Q (AI)": m_ai["depth_2q"],
"Gate Count (Default)": m_default["gate_count"],
"Gate Count (AI)": m_ai["gate_count"],
"Time (Default)": m_default["time_s"],
"Time (AI)": m_ai["time_s"],
}
)
print_summary(results_sim)
Fetching 4 files: 0%| | 0/4 [00:00<?, ?it/s]
Metric Default (mean +/- std) AI (mean +/- std) AI % improvement
--------------------------------------------------------------------------------
Depth 2Q 33.0 +/- 12.9 26.4 +/- 8.0 +15.8% +/- 17.6%
Gate Count 522.0 +/- 266.0 560.5 +/- 279.1 -9.0% +/- 9.0%
Time (s) 0.0 +/- 0.0 0.2 +/- 0.1 -893.6% +/- 362.9%
La tabella di riepilogo mostra la media e la deviazione standard di ciascuna metrica su tutti i 20 circuit, insieme alla percentuale media di miglioramento del transpiler AI-powered rispetto a quello predefinito. I valori positivi indicano che il transpiler AI-powered ha prodotto risultati migliori; i valori negativi indicano che quello predefinito era migliore.
Per questo esempio su piccola scala, il transpiler AI-powered raggiunge una profondità a due qubit mediamente inferiore di circa il 16%, ma al costo di un conteggio dei gate circa il 9% più elevato. Questo evidenzia un compromesso fondamentale nella scelta tra le due strategie: il transpiler AI-powered privilegia la riduzione della profondità (meno livelli sequenziali di gate a due qubit), mentre il transpiler predefinito (SABRE) privilegia la minimizzazione del conteggio totale dei gate (meno inserimenti di SWAP). A seconda dell'applicazione, una metrica può essere più importante dell'altra.
plot_metrics_and_pct(results_sim, "Small-Scale Random Circuits")
Profondità a due qubit: Il transpiler AI-powered produce generalmente circuit con una profondità a due qubit inferiore. La profondità è una delle metriche primarie su cui il modello di routing AI è addestrato ad ottimizzare, e il miglioramento è visibile in gran parte delle dimensioni dei circuit, sebbene SABRE possa eguagliarlo o superarlo su circuit individuali.
Conteggio dei gate: I risultati sono molto simili a questa scala, con SABRE che mantiene un leggero vantaggio complessivo. L'euristica di routing di SABRE è progettata per minimizzare il numero di gate SWAP inseriti, il che riduce direttamente il conteggio dei gate. Per circuit di piccole dimensioni, la differenza è modesta.
Tempo di transpilazione: Il tempo di esecuzione di SABRE è quasi costante indipendentemente dal numero di qubit, quindi la dimensione del circuit ha scarso effetto sul suo tempo di transpilazione a questa scala. La logica di routing principale di SABRE è altamente ottimizzata (implementata in gran parte in Rust). Il transpiler AI-powered impiega notevolmente più tempo e scala con la dimensione del circuit, sebbene i tempi assoluti rimangano ragionevoli per l'uso interattivo.
Passo 3: Eseguire utilizzando le primitive di Qiskit
Per valutare l'impatto della transpilazione sulla fedeltà del circuit, costruiamo mirror circuit dal caso a 10 qubit e li eseguiamo sul simulatore Aer con un semplice modello di rumore. L'output atteso di un mirror circuit è sempre la stringa di bit tutti zeri, quindi la probabilità di misurare dimostra quanto bene ciascuna strategia di transpilazione preserva la fedeltà.
# Use the 10-qubit circuit (index where qubits == 10)
idx_10q = qubit_range_sim.index(10)
qc_10q = circuits_sim[idx_10q]
qc_default_10q, _ = transpile_with_metrics(pm_default_sim, qc_10q)
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai_10q, _ = transpile_with_metrics(pm_ai, qc_10q)
tqc_methods = {
"Default": qc_default_10q,
"AI": qc_ai_10q,
}
print(
f"Default: depth {qc_default_10q.depth()}, gates {qc_default_10q.size()}"
)
print(f"AI: depth {qc_ai_10q.depth()}, gates {qc_ai_10q.size()}")
Default: depth 84, gates 280
AI: depth 91, gates 343
# Build a simple depolarizing noise model
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(
depolarizing_error(0.001, 1),
["sx", "x", "rz"], # ~0.1% per 1Q gate
)
noise_model.add_all_qubit_quantum_error(
depolarizing_error(0.01, 2),
["cx", "ecr"], # ~1% per 2Q gate
)
aer_sim = AerSimulator(noise_model=noise_model)
shots = 10000
survival_probs = {}
for method, tqc in tqc_methods.items():
mirror = build_mirror_circuit(tqc, simulate=True)
sampler = SamplerV2(mode=aer_sim)
job = sampler.run([mirror], shots=shots)
counts = job.result()[0].data.meas.get_counts()
all_zeros = "0" * mirror.num_qubits
survival = counts.get(all_zeros, 0) / shots
survival_probs[method] = survival
print(
f"{method:8s} P(|00...0>) = {survival:.4f} ({counts.get(all_zeros, 0)}/{shots})"
)
Default P(|00...0>) = 0.8460 (8460/10000)
AI P(|00...0>) = 0.8121 (8121/10000)
Abbiamo eseguito entrambi i mirror circuit attraverso il simulatore Aer con un semplice modello di rumore depolarizzante. La probabilità di sopravvivenza, definita come la frazione di shot che restituiscono la stringa di bit tutti zeri, quantifica quanto rumore introduce ciascuna strategia di transpilazione.
Passo 4: Post-elaborare e restituire il risultato nel formato classico desiderato
Estraiamo la probabilità di misurare la stringa di bit tutti zeri da entrambe le esecuzioni. Una probabilità di sopravvivenza più elevata indica una migliore fedeltà, ovvero che la transpilazione ha introdotto meno rumore. Il grafico seguente mostra il complemento, 1 - P(|0...0>), in modo che una barra più bassa indichi una fedeltà migliore e le piccole differenze nell'errore siano più facili da vedere.
# Plot 1 - P(|0...0>), the probability of an erroneous (non-zero) outcome.
# A lower bar means the transpilation introduced less noise.
error_probs = {method: 1 - p for method, p in survival_probs.items()}
fig, ax = plt.subplots(figsize=(6, 4))
ax.bar(
error_probs.keys(),
error_probs.values(),
color=["steelblue", "coral"],
)
ax.set_ylabel("1 - P(|0...0>)")
ax.set_title("Mirror Circuit Error (10-qubit, Aer Simulator)")
ax.set_ylim(0, 1)
plt.tight_layout()
plt.show()
In questo caso, il transpiler predefinito ha prodotto un circuit sia più superficiale che più piccolo per questa particolare istanza a 10 qubit, quindi la sua maggiore fedeltà è prevista. I risultati per singolo circuit variano: come mostra la tabella di riepilogo sopra, il vantaggio del transpiler AI-powered risiede nella profondità a due qubit mediamente inferiore, non su ogni singolo circuit. Quale strategia produca una fedeltà maggiore dipende dall'entità della differenza in ciascuna metrica, dalle caratteristiche di rumore dell'hardware e dalla struttura del circuit. Con un modello di rumore depolarizzante uniforme, il conteggio totale dei gate ha spesso un impatto più diretto sull'errore accumulato rispetto alla sola profondità.
Esempio su hardware a grande scala
Passi 1-4
Qui tutti questi dettagli vengono riuniti in un flusso di lavoro chiaro a una scala più grande, che viene poi eseguito su hardware quantistico reale.
Il codice seguente genera 25 circuit casuali con profondità 8, dove il numero di qubit varia da 26 a 50. Questi circuit vengono poi transpilati con entrambe le strategie e vengono raccolte le stesse metriche. Quindi costruiamo mirror circuit dal caso a 26 qubit e li inviamo al Backend reale.
# -------------------------Step 1-------------------------
num_circuits_hw = 25
depth_hw = 8
qubit_range_hw = list(range(26, 51))
circuits_hw = [
# We have only two qubit gates, as those test how well the transpiler can optimize the circuit.
random_circuit(
num_qubits=n,
depth=depth_hw,
max_operands=2,
num_operand_distribution={2: 1},
seed=seed + i,
)
for i, n in enumerate(qubit_range_hw)
]
print(
f"Created {len(circuits_hw)} circuits with qubit counts: {qubit_range_hw}"
)
Created 25 circuits with qubit counts: [26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
# -------------------------Step 2-------------------------
pm_default = generate_preset_pass_manager(
optimization_level=3,
backend=backend,
seed_transpiler=seed,
)
results_hw = []
for i, qc in enumerate(circuits_hw):
n = qubit_range_hw[i]
qc_default, m_default = transpile_with_metrics(pm_default, qc)
# Create a fresh AI pass manager each iteration to avoid stale layout state
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai, m_ai = transpile_with_metrics(pm_ai, qc)
results_hw.append(
{
"Qubits": n,
"Depth 2Q (Default)": m_default["depth_2q"],
"Depth 2Q (AI)": m_ai["depth_2q"],
"Gate Count (Default)": m_default["gate_count"],
"Gate Count (AI)": m_ai["gate_count"],
"Time (Default)": m_default["time_s"],
"Time (AI)": m_ai["time_s"],
}
)
print_summary(results_hw)
Metric Default (mean +/- std) AI (mean +/- std) AI % improvement
--------------------------------------------------------------------------------
Depth 2Q 217.4 +/- 50.4 191.0 +/- 35.6 +10.9% +/- 10.7%
Gate Count 4513.3 +/- 1394.3 5227.1 +/- 1536.4 -16.4% +/- 5.8%
Time (s) 0.1 +/- 0.0 3.5 +/- 1.5 -3588.2% +/- 643.6%
plot_metrics_and_pct(results_hw, "Large-Scale Random Circuits")
# -------------------------Step 3-------------------------
# Build mirror circuits from the 26-qubit case
idx_26q = qubit_range_hw.index(26)
qc_26q = circuits_hw[idx_26q]
qc_default_26q, _ = transpile_with_metrics(pm_default, qc_26q)
pm_ai = generate_ai_pass_manager(
optimization_level=1,
ai_optimization_level=3,
backend=backend,
)
qc_ai_26q, _ = transpile_with_metrics(pm_ai, qc_26q)
mirror_default_hw = build_mirror_circuit(qc_default_26q, simulate=False)
mirror_ai_hw = build_mirror_circuit(qc_ai_26q, simulate=False)
# Re-transpile to basis gates (the inverse can introduce gates like sxdg)
pm_basis = generate_preset_pass_manager(
optimization_level=0,
backend=backend,
)
mirror_default_hw = pm_basis.run(mirror_default_hw)
mirror_ai_hw = pm_basis.run(mirror_ai_hw)
print(
f"Mirror circuit (Default): depth {mirror_default_hw.depth()}, gates {mirror_default_hw.size()}"
)
print(
f"Mirror circuit (AI): depth {mirror_ai_hw.depth()}, gates {mirror_ai_hw.size()}"
)
# Submit to real hardware
sampler_hw = SamplerV2(mode=backend)
sampler_hw.options.environment.job_tags = ["TUT_AITI"]
shots_hw = 500000
job_hw = sampler_hw.run([mirror_default_hw, mirror_ai_hw], shots=shots_hw)
print(f"Job submitted: {job_hw.job_id()}")
Mirror circuit (Default): depth 1577, gates 9672
Mirror circuit (AI): depth 1235, gates 11092
Job submitted: d8gt7vm6983c73dqbg0g
# -------------------------Step 4-------------------------
result_hw = job_hw.result()
survival_probs_hw = {}
for i, method in enumerate(["Default", "AI"]):
counts = result_hw[i].data.meas.get_counts()
mirror = [mirror_default_hw, mirror_ai_hw][i]
all_zeros = "0" * mirror.num_qubits
survival = counts.get(all_zeros, 0) / shots_hw
survival_probs_hw[method] = survival
print(
f"{method:8s} P(|00...0>) = {survival:.4f} ({counts.get(all_zeros, 0)}/{shots_hw})"
)
# Plot 1 - P(|0...0>), the probability of an erroneous (non-zero) outcome.
# A lower bar means the transpilation introduced less noise.
error_probs_hw = {method: 1 - p for method, p in survival_probs_hw.items()}
fig, ax = plt.subplots(figsize=(6, 4))
ax.bar(
error_probs_hw.keys(),
error_probs_hw.values(),
color=["steelblue", "coral"],
)
ax.set_ylabel("1 - P(|0...0>)")
ax.set_title(f"Mirror Circuit Error (26-qubit, {backend.name})")
ax.set_ylim(0, 1)
plt.tight_layout()
plt.show()
Default P(|00...0>) = 0.0005 (239/500000)
AI P(|00...0>) = 0.0050 (2516/500000)
Analisi dei risultati
I risultati su grande scala confermano le tendenze osservate nell'esempio su piccola scala, ora a una scala più impegnativa.
Profondità a due qubit: Il transpiler AI-powered continua a fornire una profondità a due qubit notevolmente inferiore sull'intera gamma di dimensioni dei circuit. L'ottimizzazione della profondità è uno degli obiettivi principali su cui il modello di routing AI è addestrato, e il vantaggio è più pronunciato per conteggi di qubit più elevati, dove il problema di routing diventa più difficile per i metodi euristici.
Conteggio dei gate: Il transpiler predefinito (SABRE) produce costantemente circuit con meno gate su tutte le dimensioni dei circuit in questo intervallo. L'euristica di SABRE è specificamente progettata per minimizzare il conteggio dei gate, e a questa scala il vantaggio è chiaro e uniforme.
Tempo di transpilazione: Il divario nel tempo di transpilazione si amplia a scale più grandi. SABRE rimane quasi costante, mentre il tempo di esecuzione del transpiler AI-powered cresce più ripidamente. Nonostante questo, il tempo di esecuzione del transpiler AI-powered rimane pratico per la maggior parte dei flussi di lavoro.
Fedeltà del mirror circuit: Entrambi i metodi producono probabilità di sopravvivenza ben al di sotto dell'1% a questa scala, lasciando poco segnale utilizzabile. Con conteggi totali di gate intorno a 10.000 e profondità a due qubit superiori a 1.000, il rumore depolarizzante accumulato nel mirror circuit sopraffà la maggior parte del segnale. Questo evidenzia una limitazione fondamentale dell'approccio con mirror circuit: sebbene sia semplice e non richieda simulazione classica, non scala bene a circuit grandi o profondi, dove entrambi i metodi vengono spinti vicino al piano di rumore e il piccolo segnale sopravvissuto è dominato dall'errore accumulato.
Sebbene questi risultati sottolineino l'efficacia del transpiler AI-powered, è importante notare le sue limitazioni. Il metodo di sintesi AI è attualmente disponibile solo per determinate mappe di accoppiamento, il che potrebbe limitarne l'applicabilità più ampia. Questo vincolo dovrebbe essere considerato nella valutazione del suo utilizzo in scenari diversi.
Prossimi passi
Se hai trovato questo lavoro interessante, potresti essere interessato al seguente materiale: