Cara mentafsir visualisasi shaded lightcone

Pakej ini menyediakan dua cara untuk melihat shaded lightcone:

• draw_shaded_lightcone melapiskan sempadan pada gambar rajah litar. Ini paling sesuai untuk litar pada rantai 1D qubit, di mana gambar rajah litar dan susun atur fizikal sepadan.

• animate_shaded_lightcone memproyeksikan sempadan pada peta gandingan QPU dan melangkah melalui litar lapisan demi lapisan. Ini paling sesuai apabila kesambungan qubit lebih daripada garis 1D, di mana gambar rajah litar tidak lagi menyampaikan qubit mana yang berjiran.

Kedua-dua visualisasi menunjukkan nombor asas yang sama. Panduan ini merangkumi maksud nombor tersebut, dan menerangkan butiran yang mudah disalah baca.

Persediaan

Gunakan litar Ising Trotter dan observabel yang sama seperti panduan permulaan pantas.

# 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, PauliLindbladMap, QubitSparsePauliList
from qiskit_addon_slc.bounds import (
    compute_backward_bounds,
    compute_forward_bounds,
    merge_bounds,
)
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
)
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)
)

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

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()
}
merged_bounds = merge_bounds(
    boxed_circuit, forward_bounds, backward_bounds, noise_rates
)
print(f"observable: Z on qubit {num_qubits // 2}")

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

observable: Z on qubit 5

draw_shaded_lightcone

Setiap kotak bising dilorekkan mengikut sempadan ralat yang berlaku di situ: cerah bermaksud sempadan besar, dan kotak yang pudar ke latar belakang bermaksud ralatnya mempunyai kesan kecil terhadap observabel. Kotak pudar itu ialah calon untuk digugurkan daripada model hingar yang dimitigasi.

from qiskit_addon_slc.visualization import draw_shaded_lightcone

draw_shaded_lightcone(
    boxed_circuit, merged_bounds, noise_model_paulis, fold=-1, scale=0.5
)

Nota penting

1. Setiap nombor ialah hasil tambah ke atas sebutan ralat yang berkongsi sokongan. Tanpa penapis, sempadan setiap sebutan ralat yang bertindak pada qubit yang sama, atau pada pasangan qubit yang sama, ditambah menjadi satu nilai: ketiga-tiga jenis Pauli pada satu qubit, dan kesemua sembilan pada satu pasangan. Itu mempunyai dua akibat. Nilai boleh melebihi 2.0, walaupun tiada sempadan sebutan tunggal yang boleh (kotak berlabel 4.5 ialah beberapa sebutan yang ditambah, bukan sempadan yang dilanggar). Rajah itu tidak dapat memberitahu anda sama ada nilai besar datang daripada satu jenis Pauli atau daripada beberapa jenis yang setanding; bahagian seterusnya menunjukkan cara memisahkannya.

2. Skala warna bermula pada 2.0 dan bertambah mengikut data. Skala berjalan daripada 0 hingga entri "max_bound" dalam metadata litar yang dilapiskan, iaitu yang lebih besar antara 2.0 dan nilai terbesar yang ditunjukkan. Hasil tambah tanpa penapis sering melebihi 2.0, jadi skala melebar untuk memuatkannya, dan warna yang sama boleh mewakili nilai yang berbeza dalam rajah yang berbeza. Apabila setiap nilai kecil, skala kekal pada 2.0 dan semuanya kelihatan gelap seragam (itu skala yang mencerminkan saiz mutlak, bukan kerosakan pemaparan).

Memisahkan jenis Pauli

Gunakan pauli_filter untuk melihat satu jenis pada satu masa. Integer memilih pemberat Pauli; rentetan memilih Pauli tertentu, dipadankan dengan setiap sebutan hingar dikurangkan kepada sokongan bukan identitinya sendiri. Jadi "X" memilih setiap ralat $X$ qubit tunggal, tidak kira qubit mana yang ditindaknya, dan "XX" memilih yang berpemberat 2 (label lebar penuh seperti "XII" tidak memadankan apa-apa).

from qiskit_addon_slc.visualization import accumulate_filtered_bounds

box_id = next(iter(merged_bounds))
print(f"single-qubit supports of box {box_id!r}:\n")
print(f"{'filter':>8}  bounds per qubit")
for pauli_filter in (None, 1, "X", "Y", "Z"):
    filtered = accumulate_filtered_bounds(
        boxed_circuit, merged_bounds, noise_model_paulis, pauli_filter
    )
    per_qubit = {
        support[0]: round(float(bound), 3)
        for support, bound in sorted(filtered[box_id].items())
        if len(support) == 1
    }
    print(f"{pauli_filter!s:>8}  {per_qubit}")

single-qubit supports of box 'm0':

  filter  bounds per qubit
    None  {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.312, 4: 1.355, 5: 5.111, 6: 1.506, 7: 0.124, 8: 0.019, 9: 0.0}
       1  {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.312, 4: 1.355, 5: 5.111, 6: 1.506, 7: 0.124, 8: 0.019, 9: 0.0}
       X  {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.153, 4: 0.577, 5: 2.0, 6: 0.702, 7: 0.056, 8: 0.01, 9: 0.0}
       Y  {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.148, 4: 0.607, 5: 2.0, 6: 0.631, 7: 0.057, 8: 0.01, 9: 0.0}
       Z  {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.011, 4: 0.172, 5: 1.111, 6: 0.172, 7: 0.011, 8: 0.0, 9: 0.0}

Baris tanpa penapis ialah hasil tambah ketiga-tiga jenis Pauli di bawahnya. Penapisan ialah satu-satunya cara untuk mengetahui sama ada nilai besar tanpa penapis datang daripada satu jenis ralat dominan atau beberapa yang setanding. Itu penting, kerana mitigasi bertindak mengikut sebutan, bukan mengikut tapak.

Memasukkan penapis yang sama kepada draw_shaded_lightcone merekodkannya dalam tajuk rajah, supaya rajah yang ditapis tidak boleh dikelirukan dengan yang tidak ditapis:

draw_shaded_lightcone(
    boxed_circuit,
    merged_bounds,
    noise_model_paulis,
    pauli_filter="X",
    fold=-1,
    scale=0.5,
)

Rajah ini kelihatan agak berbeza daripada yang tanpa penapis di atas, dan bukan hanya kerana ia menunjukkan lebih sedikit nilai. Setiap pemegang tempat dalam rajah ini mewakili satu sokongan: satu qubit, atau sepasang qubit. Tanpa penapis, kotak menunjukkan pemegang tempat pada setiap qubit dan pada setiap pasangan qubit berjiran, jadi ia merentasi beberapa lajur. Dengan "X", hanya sokongan qubit tunggal yang kekal, dan setiap kotak mengecut menjadi satu lajur.

Namun, kedua-dua gambar tidak menunjukkan apa yang sebenarnya digunakan oleh PEC. Pemegang tempat ialah cara untuk memaparkan sempadan, bukan gate anti-hingar. Semasa eksperimen, setiap kotak yang terma ralatnya dimitigasi diperlakukan sebagai satu lapisan gate dua-qubit, dan Pauli anti-hingar yang disampel untuk terma ralatnya digubah menjadi satu Pauli yang dikenakan pada lapisan itu secara keseluruhan.

animate_shaded_lightcone

Pada peranti yang kesambungannya bukan garis 1D, rajah litar tidak lagi menunjukkan qubit mana yang berjiran, jadi penyebaran ruang lightcone menjadi mustahil untuk dibaca. animate_shaded_lightcone sebaliknya melukis peta gandingan QPU dan menganimasikan sempadan merentasinya, satu kotak berhingar bagi setiap bingkai.

Ia memerlukan CouplingMap, yang disusun atur pada grid dengan membenamkan graf peranti, jadi ia menyokong kedua-dua kesambungan heavy-hex dan segi empat sama.

Nota: Dalam dokumentasi yang dirender ini, animasi adalah statik. Peluncur dan butang main hanya berfungsi apabila notebook dijalankan secara interaktif, contohnya dalam Jupyter.

from qiskit import transpile
from qiskit.transpiler import CouplingMap
from qiskit_addon_slc.visualization import animate_shaded_lightcone

# A small square-lattice device stands in for a real backend here.
coupling_map = CouplingMap.from_grid(3, 4)

# Lay the chain onto a connected path of physical qubits, snaking through the grid, so the
# transpiler inserts no SWAPs: a SWAP-laden circuit is far more expensive to bound and harder to
# read.
initial_layout = [0, 1, 2, 3, 7, 6, 5, 4, 8, 9]
device_circuit = transpile(
    circuit,
    coupling_map=coupling_map,
    initial_layout=initial_layout,
    optimization_level=0,
)
boxed_device_circuit = boxing_pass.run(device_circuit)
device_noise_paulis = generate_noise_model_paulis(
    find_unique_box_instructions(boxed_device_circuit),
    coupling_map=coupling_map,
    circuit=boxed_device_circuit,
)
# The same observable, on the physical qubit the middle of the chain was laid onto.
device_observable = Pauli("I" * device_circuit.num_qubits).compose(
    "Z", [initial_layout[num_qubits // 2]]
)
device_bounds = compute_forward_bounds(
    boxed_device_circuit, device_noise_paulis, device_observable
)

animate_shaded_lightcone(boxed_device_circuit, device_bounds, coupling_map)

Membaca animasi

Setiap qubit ialah carta pai, satu hirisan bagi setiap jenis Pauli. Penanda sesuatu qubit dibahagikan kepada tiga hirisan untuk ralat $X$, $Y$ dan $Z$nya, setiap satu dilorekkan mengikut sempadannya sendiri. Ini ialah penapisan daripada bahagian sebelumnya yang terbina dalam rajah (tiada pauli_filter diperlukan untuk membezakan jenis).

Tepi membawa sempadan ralat dua-qubit. Garisan antara dua qubit yang bergandingan dilorekkan mengikut sempadan ralat berpemberat-2 yang bertindak pada pasangan itu.

Kelabu cerah bermaksud tiada data, bukan sempadan yang kecil. Hirisan atau tepi dilukis kelabu cerah apabila model hingar kotak tidak mempunyai terma ralat untuknya, contohnya pada qubit yang tidak dikenakan tindakan oleh kotak. Ia dilukis kelabu dan bukan gelap supaya tidak dikelirukan dengan sempadan sifar. Kotak melebihi had max_num_boxes adalah berbeza: ia membawa sempadan remeh 2.0, jadi ia dilukis pada hujung skala yang terang.

Peluncur melangkah melalui kotak, bukan melalui masa secara seragam. Terdapat satu bingkai bagi setiap kotak berhingar, mengikut susunan litar (atau susunan terbalik dengan reverse=True, yang menjejak lightcone ke belakang dari observable). Menontonnya secara terbalik biasanya arah yang lebih intuitif: kon itu berkembang ke luar daripada qubit yang diukur. Setiap bingkai dilabel dengan pengecam kotaknya, kunci yang sama yang digunakan oleh kamus sempadan untuk menyimpan kotak itu, jadi peluncur juga boleh digunakan untuk melompat ke kotak tertentu dan mencari nombornya.

Nota: Susun atur qubit dipulihkan daripada graf peta gandingan dengan membenamkannya ke dalam kekisi segi empat sama. Peta gandingan yang tidak dapat dibenamkan (kerana terputus, atau terlalu padat bersambung untuk grid) menimbulkan ValueError dan bukannya melukis gambar yang mengelirukan.

Yang mana satu untuk digunakan

	draw_shaded_lightcone	animate_shaded_lightcone
geometri	rajah litar	peta gandingan QPU
terbaik untuk	rantai 1D	sebarang kesambungan
jenis Pauli	dijumlahkan, melainkan ditapis	sentiasa dipisahkan, sebagai hirisan pai
masa	semua lapisan serentak	satu lapisan setiap bingkai
output	rajah matplotlib	rajah plotly

Untuk rantai 1D, rajah statik lebih mudah ditangkap sepintas lalu dan boleh dihasilkan semula dalam kertas kerja. Di luar 1D, animasi ialah satu-satunya daripada kedua-duanya yang menunjukkan struktur ruang dengan setia.