PEC dengan SLC

Pembatalan ralat probabilistik (PEC) ialah teknik untuk mengurangkan hingar kuantum dalam pengiraan nilai jangkaan observable. Ia membolehkan anda mengira anggaran nilai jangkaan yang tidak berbias. Teknik ini berfungsi dengan melaksanakan satu ensemble litar berhingar yang disuntik dengan songsangan model hingar yang dipelajari. Model hingar itu kemudian dihampiri kepada saluran Pauli dengan menggunakan Pauli twirling (juga dikenali sebagai randomized compiling). Model hingar sedemikian boleh dipelajari dengan cekap dan boleh dimitigasi dengan menggunakan PEC (lihat Probabilistic error cancellation with sparse Pauli-Lindblad models on noisy quantum processors untuk maklumat lanjut).

PEC memerlukan overhed shot eksponen untuk mengira anggaran yang tidak berbias. Shaded Lightcones (SLC) ialah teknik yang menggunakan sumber klasik untuk menghadkan kepekaan terhadap ralat di seluruh litar. Dengan menggunakan had-had ini, pengguna boleh melaraskan bias dalam anggaran observable secara terkawal.

Panduan ini menunjukkan cara menggunakan PEC digabungkan dengan SLC untuk memitigasi hingar gate dengan overhed shot yang lebih rendah berbanding PEC asas.

Aliran kerjanya adalah seperti berikut:

1. Nyatakan litar dan observable.
2. Kira nilai jangkaan berhingar tanpa mitigasi.
3. Kira had hadapan dan belakang bagi bias.
4. Pelajari hingar lapisan berbelit dengan menggunakan qiskit-noise-learning.
5. Gunakan hingar yang dipelajari untuk menggabungkan had yang dikira ke dalam matriks skala setempat.
6. Pilih had bias yang dikehendaki berdasarkan pertukaran antara overhed shot dengan bias.
7. Sediakan atur cara PEC + SLC, laksanakan atur cara itu, dan lakukan pasca-pemprosesan.
8. Bandingkan nilai jangkaan yang dimitigasi dan overhed shot.

Nyatakan litar dan observable

Sediakan litar cermin bagi evolusi masa Trotter untuk Hamiltonian rantai Ising 1D pada lapan qubit. Cerminkan litar untuk membatalkan unitarinya dan membentuk litar identiti, supaya nilai jangkaan unggul setiap observable diketahui sebagai 1 tanpa perlu mengiranya. Selain itu, pencerminan menggandakan kedalaman litar, yang seterusnya menggandakan kesan hingar.

Gunakan sudut $\theta= \frac{\pi}{4}$ untuk menjadikan dinamik bukan Clifford.

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

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit", "qiskit_addon_slc": "qiskit-addon-slc", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "qiskit_mitigation": "qiskit-mitigation", "qiskit_noise_learning": "qiskit-noise-learning", "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 warnings

import numpy as np
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_mitigation.utils import get_measurement_bases

warnings.filterwarnings("ignore")

def construct_ising_circuit(
    num_qubits: int,
    num_trotter_steps: int,
    rx_angle: float,
) -> QuantumCircuit:
    circuit = QuantumCircuit(num_qubits)

    for _ in range(num_trotter_steps):
        circuit.rx(rx_angle, range(num_qubits))
        for first_qubit in (1, 2):
            for idx in range(first_qubit, num_qubits, 2):
                # equivalent to Rzz(-pi/2):
                circuit.sdg([idx - 1, idx])
                circuit.cz(idx - 1, idx)

    return circuit

def prepare_basis(
    circuit: QuantumCircuit, basis: list[int]
) -> QuantumCircuit:
    # basis is a list of integer values from 0 to 3. These map to the basis measurement as:
    # 0 = I; 1 = Z; 2 = X; 3 = Y
    assert len(basis) == circuit.num_qubits

    out_circ = circuit.copy_empty_like()
    for qb, bas in enumerate(basis):
        if bas == 2:
            out_circ.h(qb)
        elif bas == 3:
            out_circ.rx(-np.pi / 2, qb)

    out_circ.barrier()
    out_circ.compose(circuit, inplace=True)
    return out_circ

def mirror_circuit(circuit: QuantumCircuit) -> QuantumCircuit:
    mirror_circ = circuit.copy_empty_like()
    mirror_circ.compose(circuit.inverse(), inplace=True)
    mirror_circ.barrier()
    mirror_circ.compose(circuit, inplace=True)
    mirror_circ.measure_active()
    return mirror_circ

# define observables
num_qubits = 8  # Width of the Ising chain
# The observable to measure: one X component (on qubit 2) and one Z component (on qubit 5)
target_obs_sparse = [("XZ", [2, 5], 1.0)]
observable = SparsePauliOp.from_sparse_list(
    target_obs_sparse, num_qubits=num_qubits
)

# Determine the measurement basis each qubit requires for this observable.
bases, _ = get_measurement_bases(observable)

# Instantiate the mirrored circuit and prepend the basis-preparation gates
num_trotter_steps = 6
rx_angle = np.pi / 4
circuit = construct_ising_circuit(num_qubits, num_trotter_steps, rx_angle)
mirrored_circuit = mirror_circuit(circuit)
mirrored_circuit = prepare_basis(mirrored_circuit, bases[0])
print("Visualization of 1 mirrored Trotter step")
prepare_basis(
    mirror_circuit(construct_ising_circuit(num_qubits, 1, rx_angle)), bases[0]
).draw("mpl", scale=0.6, fold=-1)

Visualization of 1 mirrored Trotter step

Kira nilai jangkaan berhingar tanpa mitigasi

QuantumProgram mengandungi litar kuantum dan samplex dalam format yang sesuai untuk primitif Executor. MitigationTask.prepare membina QuantumProgram daripada litar, observable dan nilai parameter, serta membungkus litar dalam kotak dengan pilihan pengotakan yang diberikan. Tetapkan pilihan pengotakan measure_annotations kepada "change_basis" untuk memutar pengukuran ke dalam asas yang diperlukan, dan tambahkan add_tags: "unique_box" supaya simulator boleh memetakan model hingar ke atas kotak litar. Atur cara ini di-Pauli-twirl secara lalai, yang pada perkakasan menukarkan hingar koheren kepada hingar Pauli yang diandaikan oleh kaedah mitigasi. num_randomizations menetapkan bilangan instans twirled bagi setiap litar yang disampel dan shots_per_randomization menetapkan bilangan shot yang diterima setiap instans, jadi hasil darabnya ialah had shot bagi setiap litar.

Jika anda mempunyai akses QPU, anda boleh melaksanakan atur cara dengan Executor yang dibina daripada backend QiskitRuntimeService. Contoh ini menggunakan AerSimulator untuk menjalankan atur cara secara setempat. Pilihan simulator layer_noise_model miliknya menyuntik hingar daripada model hingar Pauli-Lindblad yang diberikan pada setiap lapisan gate berbelit. Di sini kami menjana model hingar Pauli-Lindblad rawak dengan ralat bagi setiap gate berlapis (EPLG) sebanyak 0.01, hampir satu magnitud lebih tinggi daripada QPU Heron semasa yang lazim, untuk membesarkan kesan penggunaan SLC walaupun pada masalah berskala kecil.

from qiskit.circuit import CircuitInstruction
from qiskit.quantum_info import PauliLindbladMap, pauli_basis
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Executor
from qiskit_mitigation import MitigationTask, find_combined_unique_layers
from samplomatic import Tag
from samplomatic.utils import get_annotation

def generate_random_pauli_lindblad_noise(
    layers,
    num_qubits: int,
    eplg: float = 3e-3,
    seed: int | None = None,
) -> list[tuple[CircuitInstruction, PauliLindbladMap]]:
    """Generate random Pauli-Lindblad noise over the full Pauli basis."""
    layer_noise_model = []
    for layer in layers:
        layer_instructions = layer.operation.params[0]
        contain_measurement = any(
            inst.name.startswith("measure") for inst in layer_instructions
        )
        if contain_measurement:  # do not add measurement noise
            layer_noise = PauliLindbladMap.identity(num_qubits)
        else:
            edges = [
                (inst.qubits[0]._index, inst.qubits[1]._index)
                for inst in layer_instructions
            ]  # extract the edges of the layer

            basis_paulis = [p for p in pauli_basis(2) if np.sum(p.x + p.z)]
            rng = np.random.default_rng(seed=seed)
            num_generators = len(basis_paulis)
            rates = rng.random(len(basis_paulis)) * eplg / num_generators

            layer_noise = PauliLindbladMap.from_sparse_list(
                [
                    (pauli.to_label(), edge, rate)
                    for pauli, rate in zip(basis_paulis, rates, strict=True)
                    for edge in edges
                ],
                num_qubits=num_qubits,
            )
        layer_noise_model.append((layer, layer_noise))
    return layer_noise_model

num_randomizations = 400
shots_per_randomization = 16

boxing_options = {"add_tags": "unique_box"}

# find the unique layers to generate the layered noise for
box_layers = find_combined_unique_layers(
    [mirrored_circuit], custom_boxing_options=boxing_options
)
layer_noise_model = generate_random_pauli_lindblad_noise(
    box_layers, num_qubits, eplg=1e-2, seed=42
)

# a local noisy simulator in place of a QPU backend
noisy_executor = Executor(
    AerSimulator(),
    options={"simulator": {"layer_noise_model": layer_noise_model}},
)

task = MitigationTask()
program = task.prepare(
    circuit=mirrored_circuit,
    observables=observable,
    parameters=None,
    num_randomizations=num_randomizations,
    shots_per_randomization=shots_per_randomization,
    custom_boxing_options=boxing_options,
)

program._semantic_role = "simulation"  # flag the program for the simulator
job_unmit_res = noisy_executor.run(program).result()
unmitigated_res = task.postprocess(job_unmit_res)

print(f"unmitigated result: {unmitigated_res.data.evs[0]}")

unmitigated result: 0.63125

Kira had hadapan dan belakang bagi bias

Sebelum menggunakan sebarang masa QPU untuk pembelajaran hingar, SLC menggunakan simulasi klasik untuk menghadkan sumbangan setiap ralat berpotensi kepada bias observable. Ini dilakukan dalam dua laluan yang saling melengkapi:

• Perambatan hadapan: setiap ralat Pauli dirambatkan ke hadapan melalui baki litar dan komutatornya dengan observable dinilai. Ralat yang anti-berkomut dengan observable ialah satu-satunya jenis yang boleh membiaskan keputusan, jadi laluan ini menghasilkan had atas bagi kesan hadapan setiap ralat.

• Perambatan belakang: setiap ralat dirambatkan ke belakang hingga permulaan litar dan komutatornya dengan keadaan awal dinilai. Oleh sebab litar bermula dalam keadaan semua-sifar, ralat yang berkomut dengannya tidak dapat menjejaskan hasil, sekali gus mengetatkan had dari arah yang satu lagi.

Kedua-dua had ini bersama-sama membentuk kurungan yang ketat di sekeliling sumbangan kes terburuk setiap ralat kepada bias. Pada langkah seterusnya, had-had ini digabungkan dengan kadar hingar yang dipelajari untuk menentukan ralat mana yang berbaloi dibetulkan dan mana yang boleh dibiarkan dengan selamat. Pilihan pengotakan inject_noise_strategy="individual_modification" diperlukan di sini supaya setiap anotasi InjectNoise dalam litar berkotak mempunyai identiti unik yang boleh dilampirkan dengan had SLC.

Bagi masalah berskala lebih besar, pengiraan ini mungkin memerlukan sumber pengiraan klasik yang banyak.

from qiskit_addon_slc.bounds import (
    compute_backward_bounds,
    compute_forward_bounds,
    tighten_with_speed_limit,
)
from qiskit_mitigation import PEC

slc_boxing_options = {
    "add_tags": "unique_box",
    "inject_noise_strategy": "individual_modification",
}

slc_pec_task = PEC()

boxed_circuit, noise_model_paulis = (
    slc_pec_task.generate_slc_bounds_computation_input(
        mirrored_circuit, custom_boxing_options=slc_boxing_options
    )
)

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

Pelajari hingar lapisan berbelit

Untuk mengira anggaran akhir tentang sejauh mana setiap ralat menjejaskan bias nilai jangkaan, serta betapa mahalnya untuk membetulkannya, kita mempelajari kadar hingar dan menerapkannya pada had hingar ramalan yang telah kita kira sebelum ini.

PEC (serta PEC+SLC) mengandaikan model hingar twirled bagi setiap lapisan gate berbelit dalam litar. Jika anda mengandaikan model hingar Markovian, kedalaman litar diandaikan tidak menjejaskan saluran hingar bagi sesuatu lapisan berbelit. Oleh itu, hanya model hingar bagi setiap lapisan gate berbelit yang unik perlu dipelajari. Litar yang digunakan dalam panduan ini boleh dipecahkan kepada dua lapisan unik. Mereka bentuk litar supaya mempunyai set lapisan berbelit unik yang minimum adalah penting jika anda ingin mempelajari model hingar, kerana lapisan unik mesti dipelajari secara berasingan. Jika litar anda mempunyai terlalu banyak lapisan unik, pembelajaran hingar boleh menjadi tidak praktikal disebabkan kos persampelan untuk mempelajari banyak lapisan.

qiskit-noise-learning digunakan untuk mempelajari hingar. Pembelajar mengulang setiap lapisan sebanyak fragment_depths kali dalam litar pembelajarannya, melakukan twirl pada setiap litar sebanyak num_randomizations kali, dan memadankan pereputan fidelity yang diukur kepada model Pauli-Lindblad. Parameter ini boleh menjejaskan ketepatan model yang dipelajari. Semakin tepat model hingar yang dipelajari, semakin tepat pembatalan hingar tersebut.

Kod berikut melukis model hingar yang dipelajari dengan kedua-dua lapisan digabungkan menjadi satu peta. Setiap qubit ialah carta pai bagi kadar X, Y dan Z berpemberat-1 yang dijumlahkan merentas kedua-dua lapisan, dan setiap sisi menunjukkan kadar berpemberat-2 yang dipelajari. Sebagai contoh, kadar 3e-4 bermaksud ralat itu berlaku pada kira-kira tiga daripada setiap 10,000 penggunaan lapisan tersebut.

from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.quantum_info import PauliList
from qiskit_ibm_runtime.results import LayerError, PauliLindbladError
from qiskit_ibm_runtime.visualization.embeddings import Embedding
from qiskit_noise_learning.aer_executor import AerExecutor
from qiskit_noise_learning.noise_learner import LearningOptions, NoiseLearner
from samplomatic import InjectNoise

line_coupling = [(i, i + 1) for i in range(num_qubits - 1)]
backend = GenericBackendV2(
    num_qubits=num_qubits,
    basis_gates=["id", "rz", "sx", "x", "cz"],
    coupling_map=line_coupling,
)

# first learn only the layers PEC will inject noise into, i.e. not the measurement layer
pec_layers = [
    layer
    for layer in slc_pec_task.find_unique_layers(
        mirrored_circuit, slc_boxing_options
    )
    if get_annotation(layer.operation, InjectNoise)
]
layers = slc_pec_task.find_unique_layers(mirrored_circuit, slc_boxing_options)

learning_options = LearningOptions(
    fragment_depths=[2, 4, 8, 16],
    num_randomizations=250,
    shots_per_randomizations=16,
)

# qiskit-noise-learning is not compatible with the Executor in local mode,
# and requires the simulator present in the package for running simulation
noise_dict = {
    get_annotation(layer.operation, Tag).ref: noise_layer
    for layer, noise_layer in layer_noise_model
}
noise_learner_simulator = AerExecutor(
    qasm_simulator=AerSimulator(), noise_dict=noise_dict
)
learner = NoiseLearner(
    backend, options=learning_options, executor=noise_learner_simulator
)
learned_noise = (
    learner.run(pec_layers).result().to_dict()
)  # keyed by InjectNoise reference

# Draw the learned model on the line, laid out as a line with the qubits in order.
# Composing the two layers' maps sums their rates, giving one map over all the edges.
embedding = Embedding(
    [(0, 0), (0, 2), (0, 4), (2, 4), (4, 4), (4, 2), (4, 0), (2, 0)],
    line_coupling,
)
first, second = learned_noise.values()
learned_model = first.compose(second).simplify()
error = PauliLindbladError(
    PauliList(
        learned_model.get_qubit_sparse_pauli_list_copy().to_pauli_list()
    ),
    learned_model.rates,
)
fig = LayerError(circuit, list(range(num_qubits)), error).draw_map(
    embedding, radius=0.4, height=460, width=620
)
fig.update_traces(
    marker={
        "cmin": 0,
        "cmax": max(learned_model.rates),
        "colorbar": {"tickformat": ".1e", "title": "rate"},
    },
    selector={"mode": "markers"},
)
fig.show()

Gunakan hingar yang dipelajari untuk menggabungkan had yang dikira ke dalam matriks skala setempat

Dengan kedua-dua had klasik (daripada langkah sebelumnya) dan kadar hingar yang dipelajari di tangan, kita kini boleh mengira matriks skala setempat — pemberat bagi setiap ralat yang menentukan sejauh mana agresif PEC patut membatalkan setiap sebutan hingar secara individu.

Idea utama SLC ialah bahawa tidak semua ralat perlu dibatalkan sepenuhnya. Ralat yang had hadapan dan had belakangnya kedua-duanya kecil mempunyai kesan yang boleh diabaikan terhadap observable tanpa mengira kadarnya, jadi ia boleh dibiarkan tidak dimitigasi sebahagian atau sepenuhnya. merge_bounds menggabungkan had klasik dengan kadar Pauli-Lindblad yang dipelajari, kemudian compute_local_scales memberikan setiap ralat satu skala antara 0 (diabaikan sepenuhnya) dengan 1 (dibatalkan sepenuhnya), tertakluk kepada bias_tolerance yang ditetapkan pengguna. Ralat dengan sumbangan bias anggaran yang besar menerima skala hampir 1 (rawatan PEC penuh), manakala ralat dengan sumbangan kecil menerima skala yang lebih rendah, sekali gus mengurangkan overhed persampelan yang dibawanya.

SLC menyediakan tombol berterusan antara dua kutub ekstrem — PEC asas (bias sifar, overhed tertinggi) dan tiada mitigasi langsung (overhed sifar, bias hingar penuh). Parameter bias_tolerance mengawal tombol ini: menetapkannya kepada 0 memulihkan PEC penuh, manakala nilai yang lebih besar membenarkan lebih banyak bias baki sebagai pertukaran untuk overhed persampelan γ² yang lebih rendah.

Langkah ini menyapu bias_tolerance merentas julat nilai dan mengira overhed persampelan yang terhasil bagi setiap nilai. Memplot titik-titik ini berbanding overhed PEC penuh membantu anda memilih titik kerja yang sesuai dengan bajet shot anda. Sebagai contoh, bertoleransi terhadap bias baki 5 % mungkin mengurangkan overhed persampelan sebanyak satu magnitud berbanding PEC penuh, menjadikan pengiraan itu boleh dilaksanakan pada QPU hari ini yang jika tidak, tidak mungkin dilakukan.

import matplotlib.pyplot as plt
from qiskit_addon_slc.bounds import compute_local_scales, merge_bounds

merged_bounds = merge_bounds(
    boxed_circuit,
    tighten_forward_bounds,
    backward_bounds,
    noise_rates=learned_noise,
)

biases = []
costs = []
for bias in [0.0, *np.arange(0.01, 0.11, 0.01).tolist()]:
    _, cost_, bias_ = compute_local_scales(
        boxed_circuit,
        merged_bounds,
        noise_rates=learned_noise,
        bias_tolerance=bias,
    )
    biases.append(bias_)
    costs.append(cost_)

# Compute tha full PEC overhead and compare it with the overhead and bias of different SLC configurations
vanilla_gamma = slc_pec_task.calculate_gamma(
    slc_pec_task.boxed_circuit, learned_noise, 1
)

xticks = np.arange(0, 11, 2)

fig, ax = plt.subplots()
ax.scatter(
    [0], [vanilla_gamma**2], marker="D", c="tab:orange", label="full PEC"
)
ax.plot(
    100 * np.array(biases),
    np.array(costs),
    "o-",
    c="tab:blue",
    label="PEC+SLC",
)
ax.set_xticks(xticks, [f"{x:.2f}" for x in xticks])

ax.set_xlabel("Remaining bias [%]")
ax.set_ylabel(r"Sampling overhead, $\gamma^2$")
ax.grid()
ax.legend()
fig.suptitle("PEC sampling overhead reduction due to SLC")

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

Text(0.5, 0.98, 'PEC sampling overhead reduction due to SLC')

Pilih had bias yang dikehendaki berdasarkan pertukaran antara overhed shot dengan bias

Dalam panduan ini kami memilih toleransi bias sebanyak 5%. Perhatikan bahawa pengiraan bias ini berdasarkan model hingar yang dipelajari, yang mungkin tidak selari sepenuhnya dengan hingar sebenar peranti.

chosen_bias_threshold = 0.05
local_scales, sampling_cost, bias = compute_local_scales(
    boxed_circuit, merged_bounds, learned_noise, bias_tolerance=bias
)
slc_pec_task.set_slc_local_scales(
    local_scales, float(np.sqrt(sampling_cost)), bias
)

Sediakan atur cara PEC + SLC, laksanakan atur cara itu, dan lakukan pasca-pemprosesan

Dengan skala setempat yang telah dipilih, kita boleh membina atur cara pelaksanaan PEC+SLC yang lengkap. Panggilan PEC.prepare membina QuantumProgram yang mengekod strategi suntikan anti-hingar ke dalam anotasi kotak litar. Menghantar noise_gain="slc_local_scales" mengarahkan executor menggunakan pemberat bagi setiap ralat yang ditetapkan oleh set_slc_local_scales, dan bukannya menerapkan gandaan hingar songsang penuh yang sama kepada setiap ralat seperti yang dilakukan PEC asas.

Untuk menghasilkan perbandingan yang adil, tugas PEC kedua disediakan dengan noise_gain=0, yang sepadan dengan pembatalan PEC penuh tanpa kelonggaran bias SLC. Kedua-dua atur cara ditambahkan ke dalam QuantumProgram yang sama supaya berkongsi satu job pelaksanaan — litar mereka diselang-seli dan dilaksanakan bersama, bermakna sebarang hanyutan perkakasan menjejaskan kedua-duanya secara sama rata.

Selepas job selesai, postprocess menukarkan rentetan bit pengukuran mentah kepada nilai jangkaan, dengan menerapkan faktor penskalaan semula PEC γ yang sesuai bagi setiap tugas.

program_pec = slc_pec_task.prepare(
    circuit=mirrored_circuit,
    observables=[observable],
    parameters=None,
    num_randomizations=num_randomizations,
    shots_per_randomization=shots_per_randomization,
    custom_boxing_options=slc_boxing_options,
    noise_maps=learned_noise,  # PEC option
    noise_gain="slc_local_scales",  # PEC option. Defines the usage of SLC
    max_sampling_overhead=100,  # PEC option
)

full_pec_task = PEC()
program_pec = full_pec_task.prepare(
    circuit=mirrored_circuit,
    observables=[observable],
    parameters=None,
    num_randomizations=num_randomizations,
    shots_per_randomization=shots_per_randomization,
    custom_boxing_options=boxing_options,
    quantum_program=program_pec,
    noise_maps=learned_noise,  # PEC option
    noise_gain=0,  # PEC option
    max_sampling_overhead=100,  # PEC option
)

# Execute
program_pec._semantic_role = (
    "simulation"  # flag the program for the simulator
)
job_pec_results = noisy_executor.run(program_pec).result()

# post-processing
pec_slc_res = slc_pec_task.postprocess(job_pec_results)
full_pec_res = full_pec_task.postprocess(job_pec_results)

Bandingkan nilai jangkaan yang dimitigasi dan overhed shot

Nilai jangkaan unggul bagi litar cermin ialah 1 mengikut binaan, jadi bias mana-mana anggaran ialah |1 - result| sahaja. Sel akhir ini mencetak bias dan jumlah bilangan shot bagi tiga senario secara bersebelahan:

• Tanpa mitigasi: nilai jangkaan berhingar mentah tanpa sebarang pembatalan ralat.

• PEC penuh: pembatalan ralat tanpa bias menggunakan model hingar songsang lengkap pada setiap lapisan, pada overhed persampelan γ² penuh.

• PEC+SLC: pembatalan ralat yang dipandu oleh skala setempat shaded-lightcone, dengan bertoleransi terhadap bias_tolerance yang dipilih sebagai pertukaran untuk bilangan shot yang jauh lebih rendah.

Membandingkan ketiga-tiga baris menunjukkan manfaat konkrit SLC: bias terimitigasi PEC+SLC kekal jauh di bawah bias tanpa mitigasi manakala jumlah bilangan shot jauh lebih kecil daripada yang diperlukan oleh PEC penuh.

print(
    f"Unmitigated result bias: {np.abs(1 - unmitigated_res.data.evs[0]) * 100:.2f}%, \
total shots ran: {job_unmit_res[0]['_meas'].shape[0] * job_unmit_res[0]['_meas'].shape[2]}"
)

print(
    f"Full PEC final result bias: {np.abs(1 - full_pec_res.data.evs[0]) * 100:.2f}%, \
total shots ran: {job_pec_results[1]['_meas'].shape[0] * job_pec_results[1]['_meas'].shape[2]}"
)

print(
    f"PEC+SLC final result bias: {np.abs(1 - pec_slc_res.data.evs[0]) * 100:.2f}%, \
total shots ran: {job_pec_results[0]['_meas'].shape[0] * job_pec_results[0]['_meas'].shape[2]}"
)

Unmitigated result bias: 36.88%, total shots ran: 6400
Full PEC final result bias: 0.97%, total shots ran: 48528
PEC+SLC final result bias: 1.46%, total shots ran: 24480