Panduan Cepat

---

title: Quickstart description: Panduan quickstart untuk addon Qiskit Shaded lightcones (qiskit-addon-slc)

Panduan ini menunjukkan contoh minimal yang berfungsi dari paket qiskit-addon-slc. Panduan ini menghitung shaded lightcone untuk mengurangi biaya sampling dari probabilistic error cancellation (PEC).

PEC memitigasi noise gate dengan mensampel dari dekomposisi kuasiprobabilitas dari kanal noise invers. Biaya sampling-nya naik seiring setiap suku error yang harus dimitigasi; namun, tidak semua error memengaruhi observable secara setara. Error di luar lightcone kausal observable tidak bisa memengaruhi nilai ekspektasi yang terukur, dan bahkan di dalam lightcone pun, sebagian error lebih merusak daripada yang lain. Shaded lightcone mengkuantifikasi hal ini dengan membatasi pengaruh setiap suku error Pauli terhadap observable. Memangkas suku error dengan pengaruh terkecil akan mengecilkan model noise yang harus dimitigasi PEC, sehingga biaya sampling berkurang dengan imbalan bias kecil yang terbatas.

Untuk melihat cara membangun alur kerja yang realistis dan menjalankannya di hardware kuantum, lihat tutorial Probabilistic error cancellation with shaded lightcones di IBM Quantum Platform.

1. Siapkan input untuk SLC

Pertama, bangun circuit Ising medan transversal dengan Trotterisasi 10 qubit dan pilih observable $Z$ satu qubit pada qubit tengah.

# 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 beroperasi pada layer gate dua qubit yang berisik dari circuit. Di sini kita memakai samplomatic untuk mengelompokkan gate ke dalam kotak beranotasi dan memasang anotasi injeksi noise pada setiap layer dua qubit. SLC mensyaratkan setiap noisy box punya modifier_ref yang unik, yang disediakan oleh inject_noise_strategy="individual_modification"; dengan strategi default samplomatic, bound yang dihasilkan salah atau perhitungannya tidak pernah selesai. generate_noise_model_paulis kemudian mengenumerasi suku error Pauli dari setiap layer berisik yang unik.

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. Hitung shaded lightcone

Shaded lightcone dirakit dengan memberikan skala pada setiap suku error Pauli dalam model noise berdasarkan seberapa besar pengaruhnya terhadap nilai ekspektasi observable. Skala ini diturunkan dari bound error maju dan mundur setiap suku error (dijelaskan di bawah), serta tingkat error-nya:

• compute_forward_bounds mengevolusikan setiap suku error maju sampai akhir circuit untuk membatasi pengaruhnya terhadap observable yang diukur di sana.

• compute_backward_bounds mengevolusikan setiap suku error mundur sampai awal circuit untuk membatasi pengaruhnya terhadap state awal.

merge_bounds menggabungkan keduanya menjadi satu bound per suku error. Setiap bound diskalakan dengan tingkat error suku tersebut. Tingkat ini biasanya berasal dari eksperimen pembelajaran noise (seperti NoiseLearnerV3); panduan ini memakai tingkat acak agar sederhana.

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.

Pada visualisasi shaded lightcone di bawah, setiap kotak diberi warna sesuai seberapa kuat error di situs itu bisa memengaruhi observable. Kotak yang terang membawa bound terbesar, sedangkan kotak yang memudar ke latar belakang berisi suku error yang pengaruhnya kecil terhadap perhitungan -- error ini kandidat alami untuk dibuang dari model noise. Nilai pada visualisasi di bawah mewakili jumlah bound error dari semua error Pauli di situs itu, itulah sebabnya beberapa nilai tumbuh lebih besar dari 2.0, yaitu bound untuk satu error Pauli tunggal.

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. Kurangi biaya sampling

compute_local_scales mengubah shaded lightcone menjadi konfigurasi PEC yang konkret. Fungsi ini memprioritaskan suku error berdasarkan pengaruhnya yang terbatas terhadap observable dan memangkas yang paling kecil dampaknya sampai bias_tolerance yang diminta tercapai. Fungsi ini mengembalikan skala untuk setiap suku error: 0.0 untuk suku yang diabaikan saat mitigasi dan -1.0 untuk suku yang harus dimitigasi. Fungsi ini juga mengembalikan overhead biaya sampling ($\gamma^2$) yang dihasilkan dan bound untuk bias residual akibat pemangkasan.

Menyetel bias_tolerance=0.0 memitigasi setiap suku error di dalam lightcone kausal observable dan memberikan biaya sampling baseline. Mengizinkan bias kecil membuat SLC bisa membuang suku berdampak rendah dan mengurangi biaya itu lebih jauh.

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