Pornire rapidă

---

title: Quickstart description: Un ghid quickstart pentru addon-ul Qiskit Shaded lightcones (qiskit-addon-slc)

Acest ghid demonstrează un exemplu minimal funcțional al pachetului qiskit-addon-slc. Calculează un con de lumină umbrit pentru a reduce costul de eșantionare al anulării probabilistice a erorilor (PEC).

PEC atenuează zgomotul porților eșantionând dintr-o descompunere în cvasiprobabilități a canalului de zgomot invers. Costul său de eșantionare crește cu fiecare termen de eroare pe care trebuie să-l atenueze; totuși, nu orice eroare afectează observabila în mod egal. O eroare din afara conului de lumină cauzal al observabilei nu poate influența valoarea de așteptare măsurată, iar chiar și în interiorul conului de lumină, unele erori sunt mai dăunătoare decât altele. Un con de lumină umbrit cuantifică acest lucru mărginind efectul pe care îl are fiecare termen de eroare Pauli asupra observabilei. Trunchierea termenilor de eroare cu cel mai mic efect micșorează modelul de zgomot pe care PEC trebuie să-l atenueze, reducând costul de eșantionare în schimbul unei mici părtiniri mărginite.

Pentru a vedea cum se construiește un flux de lucru realist și cum se rulează pe hardware cuantic, consultă tutorialul Probabilistic error cancellation with shaded lightcones de pe IBM Quantum Platform.

1. Pregătește intrările pentru SLC

Mai întâi, construiește un circuit Ising cu câmp transversal Trotterizat de 10 qubiți și alege o observabilă $Z$ pe un singur qubit, cel din mijloc.

# 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 operează asupra straturilor zgomotoase de porți cu doi qubiți ale circuitului. Aici folosim samplomatic pentru a grupa porțile în casete adnotate și a atașa o adnotare de injectare a zgomotului fiecărui strat cu doi qubiți. SLC cere ca fiecare casetă zgomotoasă să aibă un modifier_ref unic, ceea ce oferă inject_noise_strategy="individual_modification"; cu strategia implicită a lui samplomatic, limitele ies greșite sau calculul lor nu se termină niciodată. generate_noise_model_paulis enumeră apoi termenii de eroare Pauli ai fiecărui strat zgomotos unic.

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. Calculează conul de lumină umbrit

Conul de lumină umbrit se construiește atribuind o scală fiecărui termen de eroare Pauli din modelul de zgomot, în funcție de cât de mult efect are asupra valorii de așteptare a observabilei. Aceste scale sunt derivate din limitele de eroare înainte și înapoi ale fiecărui termen de eroare (descrise mai jos), precum și din rata sa de eroare:

• compute_forward_bounds evoluează fiecare termen de eroare înainte până la sfârșitul circuitului pentru a mărgini efectul său asupra observabilei măsurate acolo.

• compute_backward_bounds evoluează fiecare termen de eroare înapoi până la începutul circuitului pentru a mărgini efectul său asupra stării inițiale.

merge_bounds le combină pe cele două într-o singură limită pentru fiecare termen de eroare. Fiecare limită este scalată cu rata de eroare a termenului. Aceste rate provin de obicei dintr-un experiment de învățare a zgomotului (precum NoiseLearnerV3); acest ghid folosește rate aleatorii pentru simplitate.

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.

În vizualizarea conului de lumină umbrit de mai jos, fiecare casetă este umbrită după cât de puternic pot afecta erorile din acel loc observabila. Casetele luminoase au cele mai mari limite, iar casetele care se estompează în fundal conțin termeni de eroare cu efect redus asupra calculului -- aceste erori sunt candidați naturali pentru a fi eliminați din modelul de zgomot. Valorile din vizualizarea de mai jos reprezintă sume ale limitelor de eroare ale tuturor erorilor Pauli din acel loc, motiv pentru care unele valori cresc peste 2.0, limita pentru orice eroare Pauli singulară.

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. Reduce costul de eșantionare

compute_local_scales transformă conul de lumină umbrit într-o configurație PEC concretă. Prioritizează termenii de eroare după efectul lor mărginit asupra observabilei și îi trunchiază pe cei mai puțin influenți până când se atinge bias_tolerance solicitat. Returnează scale pentru fiecare termen de eroare: 0.0 pentru termenii de ignorat în timpul atenuării și -1.0 pentru termenii care trebuie atenuați. Funcția returnează și costul de eșantionare suplimentar rezultat ($\gamma^2$) și o limită a părtinirii reziduale introdusă de trunchiere.

Setarea bias_tolerance=0.0 atenuează fiecare termen de eroare din conul de lumină cauzal al observabilei și oferă un cost de eșantionare de referință. Permiterea unei mici părtiniri îi lasă pe SLC să elimine termenii cu impact redus și să reducă și mai mult acest cost.

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