Guida rapida

---

title: Guida rapida description: Una guida rapida all'addon Qiskit Shaded lightcones (qiskit-addon-slc)

Questa guida mostra un esempio funzionante minimo del pacchetto qiskit-addon-slc. Calcola un shaded lightcone per ridurre il costo di campionamento della probabilistic error cancellation (PEC).

PEC mitiga il rumore dei gate campionando da una decomposizione in quasi-probabilità del canale di rumore inverso. Il suo costo di campionamento cresce con ogni termine di errore da mitigare; tuttavia, non tutti gli errori influenzano allo stesso modo l'osservabile. Un errore al di fuori del lightcone causale dell'osservabile non può influenzare il valore di aspettazione misurato, e anche all'interno del lightcone alcuni errori sono più dannosi di altri. Un shaded lightcone quantifica questo aspetto limitando l'effetto che ogni termine di errore di Pauli ha sull'osservabile. Troncare i termini di errore con l'effetto minore riduce il modello di rumore che PEC deve mitigare, abbassando il costo di campionamento in cambio di un piccolo bias limitato.

Per vedere come costruire un workflow realistico ed eseguirlo su hardware quantistico, consulta il tutorial Probabilistic error cancellation with shaded lightcones su IBM Quantum Platform.

1. Prepara gli input per SLC

Per prima cosa, costruisci un circuito di Ising a campo trasverso con Trotterizzazione su 10 qubit e scegli un'osservabile $Z$ a singolo qubit sul qubit centrale.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_addon_slc": "qiskit-addon-slc", "samplomatic": "samplomatic"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

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 = 10
circuit = trotter_ising_circuit(
    num_qubits, num_steps=4, rx_angle=np.pi / 16, rzz_angle=-np.pi / 3
)

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

Observable: IIIIZIIIII

SLC opera sui livelli rumorosi di gate a due qubit del circuito. Qui usiamo samplomatic per raggruppare i gate in box annotati e allegare un'annotazione di iniezione del rumore a ogni livello a due qubit. SLC richiede che ogni box rumoroso abbia un modifier_ref univoco, cosa che inject_noise_strategy="individual_modification" garantisce; con la strategia predefinita di samplomatic, i limiti risultano sbagliati oppure il loro calcolo non termina mai. generate_noise_model_paulis enumera poi i termini di errore di Pauli di ogni livello rumoroso univoco.

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",  # required: one modifier_ref per box
    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}")

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

2. Calcola il shaded lightcone

Il shaded lightcone viene assemblato assegnando una scala a ciascun termine di errore di Pauli nel modello di rumore in base a quanto influisce sul valore di aspettazione dell'osservabile. Queste scale derivano dai limiti di errore forward e backward di ciascun termine (descritti sotto), oltre che dal suo tasso di errore:

• compute_forward_bounds fa evolvere ogni termine di errore in avanti fino alla fine del circuito per limitare il suo effetto sull'osservabile misurata lì.

• compute_backward_bounds fa evolvere ogni termine di errore all'indietro fino all'inizio del circuito per limitare il suo effetto sullo stato iniziale.

merge_bounds combina i due in un unico limite per termine di errore. Ogni limite è scalato per il tasso di errore del termine. Questi tassi provengono tipicamente da un esperimento di apprendimento del rumore (come NoiseLearnerV3); questa guida usa tassi casuali per semplicità.

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
)

Optimal spacetime partitioning not implemented!Just partitioning list of noisy boxes.

Nella visualizzazione shaded lightcone qui sotto, ogni box è colorato in base a quanto fortemente gli errori in quel sito possono influenzare l'osservabile. I box luminosi portano i limiti maggiori, mentre i box che sfumano nello sfondo contengono termini di errore che hanno poco effetto sul calcolo -- questi errori sono candidati naturali da eliminare dal modello di rumore. I valori nella visualizzazione qui sotto rappresentano somme dei limiti di errore di tutti gli errori di Pauli in quel sito, per cui alcuni valori crescono oltre 2.0, il limite per qualsiasi singolo errore di Pauli.

from qiskit_addon_slc.visualization import draw_shaded_lightcone

draw_shaded_lightcone(
    boxed_circuit, merged_bounds, noise_model_paulis, fold=-1, scale=0.5
)

3. Riduci il costo di campionamento

compute_local_scales trasforma il shaded lightcone in una configurazione PEC concreta. Assegna priorità ai termini di errore in base al loro effetto limitato sull'osservabile e tronca quelli meno influenti finché non viene raggiunto il bias_tolerance richiesto. Restituisce le scale per ogni termine di errore: 0.0 per i termini da ignorare durante la mitigazione e -1.0 per i termini da mitigare. La funzione restituisce anche il conseguente overhead del costo di campionamento ($\gamma^2$) e un limite sul bias residuo causato dal troncamento.

Impostare bias_tolerance=0.0 mitiga ogni termine di errore all'interno del lightcone causale dell'osservabile e fornisce un costo di campionamento di riferimento. Ammettere un piccolo bias permette a SLC di scartare i termini a basso impatto e ridurre ulteriormente quel 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:6.3f}, residual bias {full_bias:5.3f}"
)
print(
    f"Shaded   (bias_tolerance=0.05): sampling cost {reduced_cost:6.3f}, residual bias {reduced_bias:5.3f}"
)
print(
    f"\nSampling-cost reduction: {(1 - reduced_cost / full_cost):.0%} for <= 0.05 bias"
)

Full PEC (bias_tolerance=0.0) : sampling cost 21.206, residual bias 0.000
Shaded   (bias_tolerance=0.05): sampling cost  5.403, residual bias 0.049

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