Permulaan Pantas

---

title: Permulaan pantas description: Panduan permulaan pantas untuk addon Qiskit Shaded lightcones (qiskit-addon-slc)

Panduan ini menunjukkan contoh minimum yang berfungsi bagi pakej qiskit-addon-slc. Ia mengira shaded lightcone untuk mengurangkan kos pensampelan pembatalan ralat probabilistik (PEC).

PEC memitigasi hingar gate dengan mensampel daripada penguraian kuasi-kebarangkalian bagi saluran hingar songsang. Kos pensampelannya meningkat dengan setiap terma ralat yang perlu dimitigasi; namun, tidak semua ralat memberi kesan yang sama kepada observable. Ralat di luar lightcone kausal observable tidak dapat mempengaruhi nilai jangkaan yang diukur, dan walaupun di dalam lightcone, sesetengah ralat lebih memudaratkan daripada yang lain. Shaded lightcone mengkuantifikasikan ini dengan menyempadankan kesan setiap terma ralat Pauli terhadap observable. Memangkas terma ralat yang kesannya paling kecil akan mengecilkan model hingar yang perlu dimitigasi oleh PEC, mengurangkan kos pensampelan sebagai pertukaran kepada bias kecil yang bersempadan.

Untuk melihat cara membina aliran kerja yang realistik dan menjalankannya pada perkakasan kuantum, lihat tutorial Pembatalan ralat probabilistik dengan shaded lightcones di IBM Quantum Platform.

1. Sediakan input untuk SLC

Mula-mula, bina litar model Ising medan melintang 10-qubit yang di-Trotter dan pilih observable $Z$ qubit tunggal 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 lapisan gate dua-qubit yang berhingar bagi litar. Di sini kita menggunakan samplomatic untuk mengumpulkan gate ke dalam kotak beranotasi dan melampirkan anotasi suntikan hingar pada setiap lapisan dua-qubit. SLC memerlukan setiap kotak berhingar mempunyai modifier_ref yang unik, yang disediakan oleh inject_noise_strategy="individual_modification"; dengan strategi lalai samplomatic, sempadan yang diperoleh salah atau pengiraannya tidak pernah selesai. generate_noise_model_paulis kemudian menyenaraikan terma ralat Pauli bagi setiap lapisan berhingar 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. Kira shaded lightcone

Shaded lightcone dibina dengan menetapkan skala kepada setiap terma ralat Pauli dalam model hingar berdasarkan sejauh mana kesannya terhadap nilai jangkaan observable. Skala ini diperoleh daripada sempadan ralat hadapan dan belakang bagi setiap terma ralat (diterangkan di bawah), serta kadar ralatnya:

• compute_forward_bounds mengembangkan setiap terma ralat ke hadapan hingga akhir litar untuk menyempadankan kesannya terhadap observable yang diukur di situ.

• compute_backward_bounds mengembangkan setiap terma ralat ke belakang hingga permulaan litar untuk menyempadankan kesannya terhadap keadaan awal.

merge_bounds menggabungkan kedua-duanya menjadi satu sempadan bagi setiap terma ralat. Setiap sempadan diskalakan mengikut kadar ralat terma tersebut. Kadar ini lazimnya datang daripada eksperimen pembelajaran hingar (seperti NoiseLearnerV3); panduan ini menggunakan kadar rawak untuk kemudahan.

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.

Dalam visualisasi shaded lightcone di bawah, setiap kotak dilorekkan mengikut sejauh mana ralat pada tapak itu boleh menjejaskan observable. Kotak terang membawa sempadan terbesar, manakala kotak yang pudar ke latar belakang mengandungi terma ralat yang kesannya kecil terhadap pengiraan -- ralat ini calon semula jadi untuk digugurkan daripada model hingar. Nilai dalam visualisasi di bawah mewakili jumlah sempadan ralat bagi semua ralat Pauli pada tapak itu, sebab itulah sesetengah nilai menjadi lebih besar daripada 2.0, sempadan bagi sebarang ralat 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. Kurangkan kos pensampelan

compute_local_scales menukarkan shaded lightcone kepada konfigurasi PEC yang konkrit. Ia mengutamakan terma ralat mengikut kesannya yang bersempadan terhadap observable dan memangkas yang paling kurang berkesan sehingga bias_tolerance yang diminta dicapai. Ia mengembalikan skala bagi setiap terma ralat: 0.0 untuk terma yang diabaikan semasa mitigasi dan -1.0 untuk terma yang perlu dimitigasi. Fungsi ini juga mengembalikan overhed kos pensampelan ($\gamma^2$) yang terhasil dan sempadan bagi bias baki yang ditanggung akibat pemangkasan.

Menetapkan bias_tolerance=0.0 memitigasi setiap terma ralat dalam lightcone kausal observable dan memberikan kos pensampelan asas. Membenarkan bias kecil membolehkan SLC menggugurkan terma berkesan rendah dan mengurangkan kos itu dengan lebih lanjut.

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