Cara mengetatkan sempadan dengan had kelajuan

Maklumat dalam litar gate dua-qubit tidak boleh merebak dengan kelajuan sewenang-wenangnya. Ralat yang berlaku beberapa lapisan sebelum akhir, pada qubit yang jauh daripada sokongan observable, tidak mempunyai laluan untuk sampai kepadanya. tighten_with_speed_limit menukarkan hujah geometri itu (intuisi yang sama di sebalik sempadan Lieb-Robinson) kepada sempadan hadapan yang lebih ketat.

Langkah ini murah, tidak memerlukan apa-apa selain yang sedia diperlukan oleh sempadan hadapan, dan hanya boleh menjadikan sempadan lebih ketat. Tiada pertukaran ketepatan yang perlu ditimbang.

Soalan yang patut dijawab dahulu ialah "bilakah ia membantu?", kerana ia jarang membantu pada set sempadan hadapan yang telah menumpu sepenuhnya.

Persediaan

Gunakan litar Ising yang di-Trotter yang sama seperti panduan permulaan pantas, dengan observable pada satu qubit di tengah rantai. Geometri 1D memudahkan penaakulan tentang kesannya: sesuatu pengaruh perlu merentasi rantai satu ikatan bagi setiap lapisan.

# 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
from qiskit_addon_slc.bounds import (
    compute_forward_bounds,
    tighten_with_speed_limit,
)
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

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
)

# A single-qubit observable in the middle of the chain.
observable = Pauli("I" * num_qubits).compose("Z", [num_qubits // 2])

boxing_pass = generate_boxing_pass_manager(
    inject_noise_targets="all",
    inject_noise_strategy="individual_modification",
    inject_noise_site="after",
    twirling_strategy="active",
    remove_barriers="never",
)
boxed_circuit = boxing_pass.run(circuit)
noise_model_paulis = generate_noise_model_paulis(
    find_unique_box_instructions(boxed_circuit)
)

def compare(label, bounds):
    """Tightens a set of bounds and prints what changed."""
    tightened = tighten_with_speed_limit(
        bounds, boxed_circuit, noise_model_paulis, observable
    )
    before = np.concatenate([bound.rates for bound in bounds.values()])
    after = np.concatenate([bound.rates for bound in tightened.values()])
    print(
        f"{label:30} mean {before.mean():.4f} -> {after.mean():.4f}  "
        f"tightened {np.count_nonzero(after < before - 1e-12):4} of {len(before)}  "
        f"loosened {np.count_nonzero(after > before + 1e-12)}"
    )

print(
    f"observable: Z on qubit {num_qubits // 2}, circuit depth {circuit.depth()}"
)

observable: Z on qubit 5, circuit depth 12

Bilakah ia membantu, dan bilakah tidak

tighten_with_speed_limit mengambil sempadan yang sedia ada pada anda dan mengembalikan salinan yang diketatkan; sempadan asal anda tidak pernah diubah suai. Sejauh mana ia mendapat manfaat bergantung sepenuhnya pada betapa longgarnya input.

# 1. Fully computed forward bounds.
full_bounds = compute_forward_bounds(
    boxed_circuit, noise_model_paulis, observable
)
compare("fully computed", full_bounds)

# 2. Bounds where the eigenvalue step was skipped, leaving the looser triangle inequality.
loose_bounds = compute_forward_bounds(
    boxed_circuit, noise_model_paulis, observable, eigval_max_qubits=0
)
compare("triangle inequality only", loose_bounds)

# 3. Bounds computed only for the first few boxes, the rest left at the trivial bound of 2.0.
shallow_bounds = compute_forward_bounds(
    boxed_circuit, noise_model_paulis, observable, max_num_boxes=2
)
compare("max_num_boxes=2", shallow_bounds)

fully computed                 mean 0.3639 -> 0.3639  tightened    0 of 792  loosened 0
triangle inequality only       mean 0.5081 -> 0.4842  tightened  105 of 792  loosened 0
max_num_boxes=2                mean 1.5707 -> 0.5284  tightened  450 of 792  loosened 0

Baris pertama ialah yang perlu diberi perhatian. Pada sempadan hadapan yang dikira sepenuhnya, had kelajuan tidak mengubah apa-apa. Itu bukan kegagalan. Ia bermaksud sempadan sudah sekurang-kurangnya seketat yang dapat dibuktikan oleh hujah geometri, kerana evolusi operator telah menemui kon cahaya sendiri.

Peningkatan muncul di tempat sempadan tidak dikira sepenuhnya:

• eigval_max_qubits=0 memaksa penggunaan fallback ketaksamaan segi tiga, jadi sempadan tidak lagi mencerminkan norma spektrum sebenar komutator. Had kelajuan memulihkan sebahagian daripada kehilangan itu.

• max_num_boxes=2 membiarkan kebanyakan lapisan pada sempadan remeh 2.0 (sempadan yang tidak mengekodkan sebarang maklumat). Di sini, had kelajuan membantu, mengurangkan min kira-kira sebanyak tiga kali ganda.

Dalam setiap kes, lajur "dilonggarkan" ialah sifar. Tiada terma yang pernah dijadikan lebih teruk, iaitu jaminan yang menjadikan langkah ini selamat untuk digunakan tanpa syarat.

Apa yang diperoleh dalam overhed pensampelan

Sempadan yang lebih ketat bermakna lebih sedikit terma ralat yang perlu dimitigasi bagi sesuatu toleransi bias, iaitu nombor yang penting pada perkakasan.

from qiskit.quantum_info import PauliLindbladMap, QubitSparsePauliList
from qiskit_addon_slc.bounds import compute_local_scales

# Stand-in for rates that a noise-learning experiment would measure on hardware.
rng = np.random.default_rng(42)
noise_rates = {
    layer: PauliLindbladMap.from_components(
        rng.random(len(terms)) * 5e-3,
        QubitSparsePauliList.from_sparse_list(
            terms.to_sparse_list(), terms.num_qubits
        ),
    )
    for layer, terms in noise_model_paulis.items()
}

tightened_shallow = tighten_with_speed_limit(
    shallow_bounds, boxed_circuit, noise_model_paulis, observable
)

print(
    f"{'bounds':30} {'overhead':>9} {'mitigated':>10} {'residual bias':>14}"
)
for label, bounds in (
    ("max_num_boxes=2", shallow_bounds),
    ("max_num_boxes=2 + speed limit", tightened_shallow),
    ("fully computed", full_bounds),
):
    scales, cost, bias = compute_local_scales(
        boxed_circuit, bounds, noise_rates, bias_tolerance=0.05
    )
    mitigated = sum(int(np.count_nonzero(scale)) for scale in scales.values())
    total = sum(len(scale) for scale in scales.values())
    print(
        f"{label:30} {cost:9.4f} {f'{mitigated}/{total}':>10} {bias:>14.4f}"
    )

bounds                          overhead  mitigated  residual bias
max_num_boxes=2                 420.2823    617/792         0.0490
max_num_boxes=2 + speed limit     7.8511    226/792         0.0485
fully computed                    5.4031    188/792         0.0494

Bila hendak menggunakannya

Gunakannya pada sempadan hadapan setiap kali sempadan itu belum menumpu sepenuhnya (pada dasarnya, setiap kali anda telah menukar ketepatan dengan kelajuan dengan menggunakan mana-mana pilihan dalam panduan konfigurasi). Ia murah berbanding pengiraan sempadan, tidak boleh menjadikan apa-apa lebih teruk, dan memulihkan banyak perkara yang dilepaskan oleh had max_num_boxes atau eigval_max_qubits.

Pada sempadan yang dikira sepenuhnya ia tidak melakukan apa-apa, jadi tiada salahnya menggunakannya tanpa syarat.

Dua batasan:

• Ia hanya terpakai pada sempadan hadapan. Sempadan belakang berkaitan kesan ralat terhadap keadaan awal dan bukan terhadap observable, jadi hujah itu tidak berlanjutan.

• Observable mestilah satu terma Pauli. Untuk observable dengan beberapa terma, panggil ini sekali bagi setiap Pauli dan gabungkan hasilnya sendiri. Jika observable bukan satu terma Pauli, ia menimbulkan NotImplementedError.

Dalam aliran kerja standard, ia terletak antara pengiraan sempadan hadapan dan penggabungannya dengan sempadan belakang, seperti yang ditunjukkan oleh panduan permulaan pantas.