Introdução ao transpilador com tecnologia de IA do Qiskit

Estimativa de tempo de uso: 5 minutos no Heron d IBM (OBSERVAÇÃO: trata-se apenas de uma estimativa.) (O tempo de execução pode variar.)

Resultados do aprendizado

Ao concluir este tutorial, os usuários deverão compreender:

Como usar o transpiler baseado em IA (generate_ai_pass_manager) como um substituto direto do transpiler padrão
Como o transpiler baseado em IA se compara ao transpiler padrão em termos de profundidade de dois qubits, número de portas e tempo de transpilagem
Como usar circuitos espelho para avaliar a qualidade da transpilagem por meio da execução em hardware

Pré-requisitos

Sugerimos que os usuários estejam familiarizados com os seguintes tópicos antes de seguir com este tutorial:

Segundo plano

O transpiler do Qiskit, equipado com inteligência artificial, introduz etapas de transpilagem baseadas em aprendizado de máquina que podem produzir circuitos mais curtos e mais eficientes em termos de hardware do que os métodos heurísticos tradicionais, como o SABRE. Circuitos mais curtos acumulam menos ruído, o que melhora diretamente a qualidade dos resultados em hardware quântico real.

Neste tutorial, comparamos duas estratégias de transpilagem:

Estratégia	API
Padrão	`generate_preset_pass_manager(optimization_level=3, ...)`
IA	`generate_ai_pass_manager(optimization_level=1, ai_optimization_level=3, ...)`

Medimos três métricas para cada estratégia: profundidade do portão de dois qubits, número total de portões e tempo de execução da transpilacão.

Tests de desempenho de transpiladores baseados em IA

Em testes comparativos, o transpiler baseado em IA produziu consistentemente circuitos mais simples e de melhor qualidade em comparação com o transpiler padrão do Qiskit. Para esses testes, utilizamos a estratégia padrão do gerenciador de passagens do Qiskit, configurada com generate_preset_pass_manager. Embora essa estratégia padrão seja frequentemente eficaz, ela pode apresentar dificuldades com circuitos maiores ou mais complexos. Em contrapartida, os passes baseados em IA alcançaram uma redução média de 24% no número de portas de dois qubits e uma redução de 36% na profundidade do circuito para circuitos grandes (mais de 100 qubits) ao serem transpilados para a topologia “heavy-hex” do hardware d IBM Quantum®. Para obter mais informações sobre esses benchmarks, consulte este blog.

Testes de desempenho de transpiladores baseados em IA

Este tutorial aborda os principais benefícios das etapas de IA e como elas se comparam aos métodos tradicionais.

Requisitos

Antes de iniciar este tutorial, certifique-se de ter os seguintes itens instalados:

Qiskit SDK v2.0 ou versão posterior, com suporte à visualização
Qiskit Runtime pip install qiskit-ibm-runtimev0.22 ou posterior
Transpilador do Qiskit IBM com modo local de IA (pip install 'qiskit-ibm-transpiler[ai-local-mode]')
Qiskit Aer (pip install qiskit-aer)

Instalação

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)

Exemplo de simulador em pequena escala

Passo 1: Mapear entradas clássicas para um problema quântico

Geramos 20 circuitos aleatórios com profundidade 4, nos quais o número de qubits varia de seis a 25. Esses circuitos servirão como nossos casos de teste para comparar estratégias de transpilagem.

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 "
    f"from {qubit_range_sim[0]} to {qubit_range_sim[-1]}"
)
circuits_sim[0].draw(output="mpl", fold=-1)

Output:

Created 20 circuits with qubit counts from 6 to 25

Etapa 2: Otimizar o problema para execução em hardware quântico

Criamos o gerenciador de passes padrão (SABRE) para o backend escolhido. Ambas as estratégias de transpilagem têm como alvo o mapa de acoplamento completo do backend. A simulação local continua sendo viável porque a etapa de simulação utiliza remap_to_contiguous para reclassificar cada circuito transpilado de modo a incluir apenas seus qubits ativos; assim, o Aer simula apenas esses qubits, em vez de todo o 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)

Output:

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%

A tabela resumida mostra a média e o desvio-padrão de cada métrica em todos os 20 circuitos, juntamente com a porcentagem média de melhoria do transpiler baseado em IA em relação ao padrão. Valores positivos indicam que o transpiler baseado em IA produziu melhores resultados; valores negativos indicam que o padrão foi melhor.

Nesse exemplo em pequena escala, o transpiler baseado em IA alcança, em média, uma profundidade de dois qubits cerca de 16% menor, mas ao custo de um aumento de aproximadamente 9% no número de portas. Isso destaca um compromisso fundamental na escolha entre as duas estratégias: o transpiler baseado em IA prioriza a redução da profundidade (menos camadas sequenciais de portas de dois qubits), enquanto o transpiler padrão (SABRE) prioriza a minimização do número total de portas (menos inserções de SWAP). Dependendo da sua aplicação, uma métrica pode ser mais importante do que a outra.

plot_metrics_and_pct(results_sim, "Small-Scale Random Circuits")

Output:

Profundidade de dois qubits: O transpiler baseado em IA geralmente produz circuitos com menor profundidade de dois qubits. A profundidade é uma das principais métricas para as quais o modelo de roteamento de IA foi treinado para otimizar, e a melhoria é visível na maioria dos tamanhos de circuitos, embora o SABRE consiga igualar ou superar esse desempenho em circuitos específicos.

Contagem de portas: Os resultados estão bastante equilibrados nessa escala, com a SABRE apresentando uma ligeira vantagem no geral. A heurística de roteamento do SABRE foi projetada para minimizar o número de portas SWAP inseridas, o que reduz diretamente o número de portas. Em circuitos de tamanho reduzido, a diferença é modesta.

Tempo de transpilação: o tempo de execução do SABRE é praticamente constante, independentemente do número de qubits; portanto, o tamanho do circuito tem pouco efeito sobre o tempo de transpilação nessa escala. A lógica central de roteamento do SABRE é altamente otimizada (implementada em grande parte em Rust). O transpiler baseado em IA leva um tempo visivelmente maior e sua duração varia de acordo com o tamanho do circuito, embora os tempos absolutos continuem razoáveis para uso interativo.

Passo 3: Execute usando Qiskit primitives

Para avaliar o impacto da transpilação na fidelidade do circuito, construa circuitos espelho a partir do caso de 10 qubits e execute-os no simulador Aer com um modelo simples de ruído. A saída esperada de um circuito espelho é sempre a sequência de bits composta inteiramente por zeros; portanto, a probabilidade de se medir um $|0\rangle^{\otimes n}$ a demonstra o grau de preservação da fidelidade por cada estratégia de transpilagem.

# 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()}")

Output:

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}  "
        f"({counts.get(all_zeros, 0)}/{shots})"
    )

Output:

Default   P(|00...0>) = 0.8460  (8460/10000)
AI        P(|00...0>) = 0.8121  (8121/10000)

Executamos ambos os circuitos de espelho no simulador Aer, utilizando um modelo simples de ruído despolarizante. A probabilidade de sobrevivência, definida como a fração de tentativas que retornam a sequência de bits composta inteiramente por zeros, quantifica a quantidade de ruído que cada estratégia de transpilação introduz.

Etapa 4: Pós-processamento e retorno do resultado no formato clássico desejado

Calculamos a probabilidade de se obter a sequência de bits composta inteiramente por zeros em ambas as execuções. Uma probabilidade de sobrevivência mais alta indica maior fidelidade, o que significa que a transpilacão introduziu menos ruído. O gráfico abaixo mostra o complemento, 1 - P(|0...0>), de modo que uma barra mais baixa indica maior fidelidade e pequenas diferenças no erro ficam mais fáceis de perceber.

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

Output:

Nesse caso, o transpiler padrão gerou um circuito mais simples e menor para essa instância específica de 10 qubits; portanto, espera-se que ele apresente maior fidelidade. Os resultados por circuito variam: como mostra a tabela resumida acima, a vantagem do transpiler baseado em IA está na menor profundidade média de dois qubits, e não em cada circuito individualmente. A estratégia que proporciona maior fidelidade depende da magnitude da diferença em cada métrica, das características de ruído do hardware e da estrutura do circuito. De acordo com um modelo uniforme de ruído despolarizante, o número total de portas costuma ter um impacto mais direto no erro acumulado do que apenas a profundidade.

Exemplo de hardware em grande escala

Etapas 1 a 4

Aqui, todos esses detalhes são reunidos em um fluxo de trabalho claro em escala maior, que é então executado em hardware quântico real.

O código abaixo gera 25 circuitos aleatórios com profundidade 8, nos quais o número de qubits varia de 26 a 50. Esses circuitos são então transpilados com ambas as estratégias, e as mesmas métricas são coletadas. Em seguida, construímos circuitos espelhados a partir do caso de 26 qubits e os enviamos para o backend real.

# -------------------------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 "
    f"from {qubit_range_hw[0]} to {qubit_range_hw[-1]}"
)

Output:

Created 25 circuits with qubit counts from 26 to 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)

Output:

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

Output:

# -------------------------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()}, "
    f"gates {mirror_default_hw.size()}"
)
print(
    f"Mirror circuit (AI):      depth {mirror_ai_hw.depth()}, "
    f"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()}")

Output:

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}  "
        f"({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()

Output:

Default   P(|00...0>) = 0.0005  (239/500000)
AI        P(|00...0>) = 0.0050  (2516/500000)

Análise dos resultados

Os resultados em grande escala reforçam as tendências observadas no exemplo em pequena escala, agora em uma escala mais exigente.

Profundidade de dois qubits: O transpiler baseado em IA continua a apresentar uma profundidade de dois qubits visivelmente menor em toda a gama de tamanhos de circuitos. A otimização da profundidade é um dos principais objetivos para os quais o modelo de roteamento baseado em IA foi treinado, e a vantagem é mais evidente em sistemas com um número maior de qubits, nos quais o problema de roteamento se torna mais complexo para os métodos heurísticos.

Número de portas: O transpiler padrão (SABRE) produz consistentemente circuitos com menos portas em todos os tamanhos de circuito nessa faixa. A heurística do SABRE foi projetada especificamente para minimizar o número de portas lógicas e, nessa escala, a vantagem é clara e uniforme.

Tempo de transpilação: A diferença no tempo de transpilação aumenta em escalas maiores. O SABRE permanece praticamente constante, enquanto o tempo de execução do transpiler baseado em IA cresce de forma mais acentuada. Apesar disso, o tempo de execução do transpiler baseado em IA continua sendo viável para a maioria dos fluxos de trabalho.

Fidelidade do circuito espelho: Ambos os métodos produzem probabilidades de sobrevivência bem abaixo de 1% nessa escala, deixando pouco sinal utilizável. Com um número total de portas em torno de 10.000 e profundidades de dois qubits superiores a 1.000, o ruído despolarizador acumulado ao longo do circuito de espelhos suprime a maior parte do sinal. Isso destaca uma limitação fundamental da abordagem do circuito espelho: embora seja simples e não exija simulação clássica, ela não se adapta bem a circuitos grandes ou profundos, nos quais ambos os métodos são levados para perto do nível de ruído e o pequeno sinal remanescente é dominado pelo erro acumulado.

Embora esses resultados ressaltem a eficácia do transpiler baseado em IA, é importante observar suas limitações. Atualmente, o método de síntese por IA está disponível apenas para determinados mapas de acoplamento, o que pode limitar sua aplicabilidade mais ampla. Essa restrição deve ser levada em conta ao avaliar seu uso em diferentes cenários.

Próximas etapas

Recomendações

Se você achou este trabalho interessante, talvez se interesse pelo material a seguir:

Esta página foi útil?

Relate um bug, erro de digitação ou solicite conteúdo no GitHub.