title: "Avvio rapido" description: "Guida rapida all'add-on Shaded Lightcones per Qiskit (qiskit-addon-slc)"

Avvio rapido

Questa guida illustra un esempio minimale funzionante del pacchetto qiskit-addon-slc . Calcoliamo un cono di luce ombreggiato per ridurre il costo di campionamento della cancellazione probabilistica dell'errore (PEC).

Il PEC riduce il rumore di gate effettuando un campionamento a partire da una decomposizione in quasi-probabilità del canale di rumore inverso. Il costo del campionamento aumenta con ogni termine di errore che deve essere mitigato; tuttavia, non tutti gli errori incidono allo stesso modo sull’osservabile. Un errore al di fuori del cono di luce causale dell'osservabile non può influenzare in alcun modo il valore atteso misurato, e anche all'interno del cono di luce alcuni errori sono più dannosi di altri. Un cono di luce ombreggiato quantifica questo fenomeno delimitando l'effetto che ciascun termine di errore di Pauli ha sull'osservabile. Troncando i termini di errore con l'effetto minore si riduce il modello di rumore che il PEC deve mitigare, diminuendo il costo di campionamento in cambio di un bias piccolo e limitato.

Per scoprire come creare un flusso di lavoro realistico ed eseguirlo su hardware quantistico, consulta il tutorial “Probabilistic error cancellation with shaded lightcones” (Cancellazione probabilistica degli errori con coni di luce ombreggiati) su IBM Quantum Platform.

1. Preparare i dati di input per SLC

Qui realizziamo un circuito di Ising a campo trasversale con trotterizzazione a 6 qubit e scegliamo un osservabile di tipo “ $Z$ ” a singolo qubit sul qubit centrale.

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli


def trotter_ising_circuit(num_qubits, num_steps, rx_angle, rzz_angle):
    """Trotterized transverse-field Ising evolution on a 1D chain."""
    circuit = QuantumCircuit(num_qubits)
    for _ in range(num_steps):
        circuit.rx(rx_angle, range(num_qubits))
        circuit.barrier()
        for start in (0, 1):  # even then odd bonds
            for i in range(start, num_qubits - 1, 2):
                circuit.rzz(rzz_angle, i, i + 1)
        circuit.barrier()
    return circuit


num_qubits = 6
circuit = trotter_ising_circuit(
    num_qubits, num_steps=2, rx_angle=np.pi / 16, rzz_angle=-np.pi / 2
)

# Measure <Z> on the middle qubit
observable = Pauli("I" * num_qubits).compose("Z", [num_qubits // 2])

print(f"Observable: {observable}")
circuit.draw("mpl", fold=-1, scale=0.7)

Output:

Observable: IIZIII

SLC opera sui livelli rumorosi del circuito relativi alle porte a due qubit. In questo caso utilizziamo samplomatic per raggruppare i gate in riquadri annotati e assegniamo un'annotazione di iniezione di rumore a ciascun strato di due qubit. generate_noise_model_paulis quindi elenca i termini di errore di Pauli di ogni singolo strato soggetto a rumore.

from qiskit_addon_slc.utils import generate_noise_model_paulis
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic.utils import find_unique_box_instructions

# Group gates into boxes and annotate each two-qubit layer with a noise-injection point
boxing_pass = generate_boxing_pass_manager(
    inject_noise_targets="all",
    inject_noise_strategy="individual_modification",
    inject_noise_site="after",
    twirling_strategy="active",
    remove_barriers="never",
)
boxed_circuit = boxing_pass.run(circuit)

# Enumerate the 1- and 2-weight Pauli error terms of each unique noisy layer
noise_model_paulis = generate_noise_model_paulis(
    find_unique_box_instructions(boxed_circuit)
)

num_terms = sum(len(paulis) for paulis in noise_model_paulis.values())
print(f"Noisy layers: {len(noise_model_paulis)}")
print(f"Pauli error terms across all layers: {num_terms}")

Output:

Noisy layers: 2
Pauli error terms across all layers: 102

2. Calcolare il cono di luce ombreggiato

Il cono di luce ombreggiato viene costruito assegnando una scala a ciascun termine di errore di Pauli nel modello di rumore, in base all'entità del suo effetto sul valore atteso dell'osservabile. Queste scale sono ricavate dai limiti di errore in avanti e all'indietro di ciascun termine di errore (descritti di seguito), nonché dal relativo tasso di errore:

• compute_forward_bounds fa evolvere ciascun termine di errore in avanti fino alla fine del circuito per limitarne l'effetto sull'osservabile misurata in quel punto.
• compute_backward_bounds calcola a ritroso ciascun termine di errore fino all'inizio del circuito per limitare il suo effetto sullo stato iniziale.

merge_bounds combina i due in un unico termine di errore. Scale combinate, ciascuna vincolata dal tasso di errore del termine. Questi tassi derivano in genere da un esperimento di apprendimento del rumore (ad es. NoiseLearnerV3); Per semplicità, qui utilizziamo tassi casuali.

from qiskit.quantum_info import PauliLindbladMap, QubitSparsePauliList
from qiskit_addon_slc.bounds import (
    compute_backward_bounds,
    compute_forward_bounds,
    merge_bounds,
)

forward_bounds = compute_forward_bounds(
    boxed_circuit, noise_model_paulis, observable
)
backward_bounds = compute_backward_bounds(boxed_circuit, noise_model_paulis)

# Stand-in for rates that would be measured by a noise-learning experiment on hardware
rng = np.random.default_rng(42)
noise_rates = {
    layer_id: PauliLindbladMap.from_components(
        rng.random(len(paulis)) * 5e-3,
        QubitSparsePauliList.from_sparse_list(
            paulis.to_sparse_list(), paulis.num_qubits
        ),
    )
    for layer_id, paulis in noise_model_paulis.items()
}

merged_bounds = merge_bounds(
    boxed_circuit, forward_bounds, backward_bounds, noise_rates
)

Nella visualizzazione del cono di luce ombreggiato riportata di seguito, ogni riquadro è ombreggiato in base all’intensità con cui gli errori in quel punto possono influenzare la grandezza osservabile: i riquadri più luminosi indicano gli intervalli più ampi, mentre quelli che sfumano verso lo sfondo contengono termini di errore che hanno un effetto minimo sul calcolo; tali errori sono candidati naturali da escludere dal modello di rumore. I valori riportati nella visualizzazione qui sotto rappresentano la somma dei limiti di errore di tutti gli errori di Pauli in quel punto; ecco perché alcuni valori superano -- 2.0 il limite per un singolo errore di Pauli.

from qiskit_addon_slc.visualization import draw_shaded_lightcone

draw_shaded_lightcone(boxed_circuit, merged_bounds, noise_model_paulis)

Output:

3. Ridurre i costi di campionamento

compute_local_scales trasforma il cono di luce ombreggiato in una configurazione PEC concreta. Assegna una priorità ai termini di errore in base al loro effetto limitato sull’osservabile e troncano quelli con minore impatto fino a bias_tolerance raggiungere il valore richiesto. Restituisce dei coefficienti per ciascun termine di errore: 0.0 per i termini da ignorare durante la mitigazione e -1.0 per quelli che devono essere mitigati. La funzione restituisce inoltre il sovraccarico di campionamento risultante ( $\gamma^2$ ) e un limite massimo della distorsione residua causata dal troncamento.

L'impostazione bias_tolerance=0.0 mitiga ogni termine di errore all'interno del cono di luce causale dell'osservabile e fornisce un costo di campionamento di riferimento. Consentendo una leggera distorsione, SLC può tralasciare i termini a basso impatto e ridurre ulteriormente tale costo.

from qiskit_addon_slc.bounds import compute_local_scales

_, full_cost, full_bias = compute_local_scales(
    boxed_circuit, merged_bounds, noise_rates, bias_tolerance=0.0
)
local_scales, reduced_cost, reduced_bias = compute_local_scales(
    boxed_circuit, merged_bounds, noise_rates, bias_tolerance=0.05
)

print(
    f"Full PEC (bias_tolerance=0.0):  sampling cost {full_cost:.3f}, residual bias {full_bias:.3f}"
)
print(
    f"Shaded    (bias_tolerance=0.05): sampling cost {reduced_cost:.3f}, residual bias {reduced_bias:.3f}"
)
print(
    f"\nSampling-cost reduction: {(1 - reduced_cost / full_cost):.0%} for <= 0.05 bias"
)

Output:

Full PEC (bias_tolerance=0.0):  sampling cost 1.923, residual bias 0.000
Shaded    (bias_tolerance=0.05): sampling cost 1.441, residual bias 0.044

Sampling-cost reduction: 25% for <= 0.05 bias