Noise dan error

Lesson ini akan memperkenalkan quantum noise dan error, termasuk banyak sumbernya, serta menarik analogi dengan error klasik. Memahami jenis-jenis error yang bisa terjadi, dan kemampuan memodelkan noise menggunakan quantum channel, akan sangat penting untuk memahami lesson berikutnya. Bahkan, sebagian besar metode penanganan error mengharuskan kita mengetahui sesuatu tentang jenis noise atau error yang ingin kita kurangi atau koreksi.

Video ini memberikan ikhtisar tentang noise dan error serta menyoroti beberapa hasil komputasi. Teks di bawah menambahkan lebih banyak detail dan mengeksplorasi beberapa jenis error menggunakan Qiskit.

Penyebab

Noise dan error klasik

Untuk memahami quantum error dan noise, mari mulai dengan analog klasiknya. Error terjadi pada komputer klasik karena berbagai alasan, termasuk beberapa mekanisme akumulasi muatan yang tidak diinginkan, single-event upset, dan degradasi material yang lambat. Beberapa mekanisme ini (tidak semua) punya analog dalam quantum computing dan akan sangat membantu dalam memahami quantum error dan noise. Kita akan membahas sebentar beberapa di antaranya sebelum melanjutkan ke analog quantum-nya.

Kebisingan termal:

Saat komponen komputer memanas, gerakan termal atom dan pembawa muatan mengubah resistivitas material (biasanya meningkat). Ini berarti resistansi dalam circuit bisa bervariasi. Meski jarang, ini bisa menyebabkan transisi logika yang tidak diinginkan pada transistor. Meskipun variasi kecil tidak terhindarkan, pendinginan komponen yang tepat adalah kunci untuk menghindari efek ini.

Kerusakan dan degradasi termal:

Pemanasan dan pendinginan material yang berulang bisa menyebabkan migrasi elemen konduktif (logam) yang sangat lambat. Paling ringan, ini mengubah resistansi atau kapasitansi (atau keduanya) elemen circuit dan menyebabkan pewaktuan operasi circuit yang tidak presisi. Paling parah, ini menghasilkan korsleting atau kerusakan permanen. Sekali lagi, kontrol suhu yang tepat adalah kunci untuk mencegah jenis degradasi ini.

Efek akibat radiasi (single-event upset, SEU):

Terkadang, partikel berenergi tinggi bisa mengionisasi atom di dalam prosesor dan menyebabkan muatan yang tidak diinginkan. Jika terjadi di tempat dan waktu yang salah, ini bisa menyebabkan error logika. Sumber partikel berenergi tinggi ini (termasuk radiasi elektromagnetik dan neutron) biasanya adalah interaksi berenergi tinggi di atmosfer atas. Karena itu, upset semacam ini lebih umum terjadi di lingkungan dataran tinggi, termasuk di luar angkasa. Ini diatasi menggunakan kode error-correcting dan desain tahan radiasi.

Interferensi elektromagnetik:

Error juga bisa disebabkan oleh medan elektromagnetik (EM) eksternal dari switching pada saluran listrik, pemancar radio, atau komponen sistem lainnya. Ini berbeda dari radiasi berenergi tinggi pada fenomena sebelumnya. Di sini, medan EM yang bergantung waktu menyebabkan arus dan tegangan pada komponen komputasi (bukan mengionisasi satu atom tertentu dalam satu kejadian). Karena ketergantungan waktu medan adalah faktor penentu tegangan yang terinduksi, jenis interferensi ini sangat penting pada sistem frekuensi tinggi. Error semacam ini bisa diatasi melalui shielding dan grounding, di antara cara lainnya.

Crosstalk antar-interkoneksi:

Kopling kapasitif atau induktif antar konduktor yang berdekatan, terutama pada integrated circuit skala nano, bisa menyebabkan sinyal yang tidak diinginkan. Ini terkait dengan interferensi elektromagnetik, tapi berbeda karena sumber medan yang mengganggu adalah komponen lain di dalam circuit komputer itu sendiri. Bayangkan dua kabel yang sangat berdekatan. Jika kabel A mengalami transisi mendadak (perubahan tegangan), ini bisa menginduksi arus pada kabel B di sebelahnya. Arah dan besarnya tepatnya tergantung pada layout circuit; bisa berupa aliran muatan bersih yang koheren atau lebih mirip arus eddy muatan. Tapi dalam beberapa kasus ini bisa menyebabkan transisi logika yang tidak diinginkan. Efek crosstalk ini bisa dikurangi melalui jarak layout yang optimal, shielding, dan waktu naik sinyal yang terkontrol.

Ini bukan daftar lengkap, tapi cukup untuk membantu kita mulai melihat kesamaan dengan quantum computing. Perhatikan bahwa dalam semua jenis interaksi tidak diinginkan di atas, manifestasi noise sebagai error logika hanya bisa berupa 0 menjadi 1, atau 1 menjadi 0. Ini adalah satu-satunya kemungkinan dalam ruang state classical bit.

Noise dan error quantum

Dalam quantum computing, noise dan error sering dibahas bersamaan, tapi penting untuk mengenali perbedaannya. Quantum noise merujuk pada gangguan fisik mendasar yang memengaruhi qubit dan sistem quantum. Ini mencakup semua bentuk interaksi atau fluktuasi yang tidak diinginkan dari lingkungan, kontrol yang tidak sempurna, atau cacat hardware yang menyebabkan quantum state menyimpang dari kondisi ideal. Quantum error adalah penyimpangan atau kesalahan spesifik pada informasi quantum yang dihasilkan dari quantum noise. Quantum error adalah manifestasi terukur atau operasional dari noise, dan error mencakup bit-flip, phase-flip, amplitude damping, dan lainnya. Baik noise maupun error bisa terjadi secara kontinu. Misalnya, medan yang digunakan dalam quantum gate bisa meleset 0,1%, 0,15%, atau fraksi lainnya. Ini bisa menghasilkan fase pada qubit yang tidak tepat, juga dengan jumlah kontinu berapa pun. Tapi kamu akan melihat bahwa, dalam praktiknya dan terutama dalam error correction, umum untuk memperlakukan error seolah-olah diskrit: mengelompokkan efek yang terakumulasi menjadi bit flip diskrit atau satu rotasi fase. Ini berguna untuk mengoreksi error dan mengkarakterisasinya, tapi bukan berarti efek noise pada qubit hanyalah sekumpulan error diskrit.

Ada banyak jenis noise yang memengaruhi komputer quantum. Beberapa bisa menghasilkan berbagai jenis error, sementara yang lain berpasangan dengan manifestasi error tertentu. Daftar lengkap berada di luar tujuan lesson ini; berikut daftar sebagian yang relevan untuk sisa kursus ini, beberapa punya kesamaan dengan noise komputer klasik.

Thermal:

Dua computational basis state $|0\rangle$ dan $|1\rangle$ dari sebuah qubit dipisahkan oleh energi yang sangat kecil. Nilai tepatnya tentu bergantung pada hardware quantum. Untuk qubit solid-state (fixed-frequency transmon) seperti yang digunakan IBM Quantum®, celah energi antara state ini berada pada orde $10^{-24}$ J, atau beberapa mikroelektron volt. Skala energi ini bisa dikaitkan dengan frekuensi melalui $E=hf$ atau dengan suhu karakteristik. Karena suhu terkait dengan energi kinetik rata-rata partikel dalam sampel, kita bisa menggunakan konstanta Boltzmann untuk memperkirakan suhu di mana partikel rata-rata punya cukup energi untuk menyebabkan transisi:

$$E\approx k_BT \rightarrow T~E/k_B \approx 10^{-24}\text{ J } \times 1.381 \times 10^{−23}\text{ J/K}\approx 100 \text{mK}.$$

Untuk mengurangi kemungkinan interaksi termal menyebabkan transisi dari satu computational basis state qubit ke state lain, suhu qubit harus dijaga jauh di bawah 100 mK, idealnya mendekati 15-25 mK. Kenaikan suhu yang signifikan di atas ambang ini akan menyebabkan okupansi state yang benar-benar acak dan hilangnya informasi quantum sepenuhnya.

Ini serupa dengan error termal yang bisa terjadi pada komputer klasik, karena keduanya berasal dari termal — tapi skala suhunya jelas berbeda, begitu juga mekanisme hilangnya informasinya.

Crosstalk dan interferensi:

Crosstalk dalam quantum computing merujuk pada kopling atau interferensi tidak diinginkan antara qubit atau control line sedemikian rupa sehingga operasi atau sinyal yang ditujukan untuk satu qubit secara tidak sengaja memengaruhi qubit lain. Ini muncul sebagai error atau korelasi antar qubit yang seharusnya independen.

Pada arsitektur superconducting qubit seperti yang digunakan IBM®, crosstalk bisa muncul dari sinyal kontrol microwave yang bocor ke qubit tetangga, kopling tidak diinginkan antara readout resonator, atau flux crosstalk antar loop qubit.

Banyak pendekatan untuk meminimalkan crosstalk sudah dimasukkan ke dalam desain komputer quantum, seperti jarak antar qubit dan memastikan qubit yang berdekatan punya frekuensi operasi berbeda. Ada juga pendekatan software untuk mengurangi error crosstalk, yang akan dibahas di lesson berikutnya.

Operasi gate yang tidak sempurna:

Operasi pada qubit dilakukan menggunakan hardware yang punya presisi terbatas dan bisa terpengaruh noise atau sumber ketidakakuratan lainnya. Khususnya, pulsa microwave dengan durasi dan orientasi tertentu digunakan untuk mengimplementasikan rotation gate. Misalnya, sebuah pulsa microwave dimaksudkan untuk merotasi 0,30 radian di sekitar sumbu $X$. Ada presisi terbatas dalam orientasi, yang menyebabkan sedikit ketidaktepatan pada sumbu rotasi. Selain itu, selalu ada trade-off mendasar antara frekuensi pulsa dan durasinya. Pulsa yang sangat panjang bisa memiliki perilaku hampir sinusoidal dengan praktis satu frekuensi tunggal. Untuk membentuk paket pendek, dibutuhkan superposisi banyak frekuensi. Ini adalah trade-off yang sama yang mendasari energy-time uncertainty relation, meskipun presisi gate belum mendekati batas mendasar ini; masih ada ruang untuk perbaikan.

Noise yang melekat pada quantum:

Jenis noise terakhir ini cukup berbeda dari yang lain; ini bukan karena error, tapi karena sifat mekanika quantum. Misalkan sebuah qubit dalam quantum state $|\psi\rangle$ diukur dan runtuh ke eigenstate ($|0\rangle$ atau $|1\rangle$). Dalam sistem fixed-frequency transmon, qubit terkopel secara dispersif ke resonator microwave yang frekuensi resonansinya sedikit bergantung pada state qubit. Pulsa probe microwave dikirim melalui resonator, dan sinyal keluarannya memperoleh pergeseran fase dan perubahan amplitudo yang bergantung pada state. Sinyal ini kemudian diperkuat dan diukur menggunakan elektronika klasik.

Pada level quantum, sinyal pengukuran dibawa oleh medan microwave koheren dengan jumlah foton rata-rata yang terbatas. Karena sifat quantum dari medan elektromagnetik, quadrature medan menunjukkan fluktuasi intrinsik. Fluktuasi ini independen dari ketidaksempurnaan teknis dan muncul bahkan untuk coherent state ideal. Meningkatkan jumlah foton rata-rata $N$ meningkatkan sinyal pengukuran, tapi level noise fundamental tetap terbatas, sehingga keterbedaan antar outcome hanya membaik sebanding dengan $\sqrt{N}$.

Jadi, bahkan jika qubit disiapkan dengan sempurna dan rangkaian pengukuran ideal, sinyal readout yang sesuai dengan state qubit tertentu bukanlah nilai tetap tunggal melainkan sebuah distribusi yang membatasi seberapa baik outcome bisa dibedakan. Overlap ini merepresentasikan sumber ketidakpastian mendasar dalam proses pengukuran itu sendiri. Dalam praktiknya, meskipun noise teknis dari amplifier dan komponen lain sering mendominasi, quantum noise intrinsik ini menetapkan batas bawah pada readout fidelity.

Ketidakpastian bukan error:

Sumber-sumber noise ini semuanya berbeda dari ketidakpastian mendasar yang terkait dengan pengukuran quantum state. Sebagai perbandingan, misalkan kita punya qubit dalam quantum state:

$|\psi\rangle = \frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle.$

State ini punya peluang 64% untuk terukur dalam state $|0\rangle$ dan peluang 36% untuk terukur dalam state $|1\rangle$. Tapi satu pengukuran hanya akan menghasilkan $|0\rangle$ atau $|1\rangle$ — jadi satu pengukuran jarang memberi tahu banyak hal tentang state sebelum diukur. Diperlukan banyak pengukuran untuk mendapatkan informasi rinci tentang state tersebut. Dari sepuluh pengukuran, kita mungkin memperkirakan enam atau tujuh akan menghasilkan $|0\rangle$. Tapi tidak akan mengejutkan jika sepuluh pengukuran pertama kebetulan semuanya menghasilkan $|0\rangle$ (seperti melempar koin yang adil dan mendapat "kepala" sepuluh kali berturut-turut: jarang, tapi sepenuhnya masuk akal). Jika kita mengulang pengukuran 1000 kali dan selalu mendapat $|0\rangle$, itu memang akan mengejutkan.

Jadi ada ketidakpastian dalam pengetahuan kita tentang quantum state berdasarkan jumlah pengukuran yang terbatas berapa pun. Saat kita mengulang pengukuran, pengetahuan kita tentang quantum state sebelum diukur membaik, tapi tidak pernah sempurna. Seseorang mungkin secara santai mengatakan bahwa selalu ada semacam "error" mendasar dalam setiap hasil pengukuran quantum. Tapi ini adalah penggunaan istilah "error" yang berbeda dan lebih tepat digambarkan sebagai ketidakpastian statistik. Proses meningkatkan pengetahuan tentang quantum state melalui banyak pengukuran disebut quantum state tomography. Quantum state tomography tidak terbatas pada pengukuran sepanjang Z; secara umum ini merujuk pada pengukuran sepanjang sumbu ortogonal (seperti X, Y, dan Z) untuk menentukan amplitudo dan fase relatif. Untuk informasi lebih lanjut tentang proses ini, lihat bagian ini dalam kursus John Watrous tentang General Formulation of Quantum Information, atau untuk implementasi praktisnya, lihat lesson teleportasi ini dari kursus Utility-Scale Quantum Computing.

Mengamati error dan akumulasinya

Di bagian ini, kita akan menggunakan komputer quantum sungguhan untuk mengamati quantum error dan akumulasinya dalam berbagai kondisi. Dalam praktiknya, banyak sumber quantum error biasanya hadir secara bersamaan. Untuk mengamati berbagai jenis error secara agak terisolasi, kita perlu menggunakan circuit yang dirancang untuk isolasi tersebut. Circuit yang digunakan dalam aplikasi quantum computing akan terlihat jauh lebih rumit.

Mari mulai dengan energy relaxation error.

Energy relaxation ($T_1$) error

Ingat kembali dari pembahasan kita tentang thermal noise bahwa pada suhu berapa pun yang tidak nol, ada kemungkinan sistem quantum mengalami transisi antar energy eigenstate. Relaksasi ($|1\rangle \rightarrow |0\rangle$) mendominasi karena didorong oleh spontaneous emission (independen dari suhu), sementara suhu rendah menekan proses eksitasi yang bersaing. Semakin lama qubit dibiarkan idle, semakin banyak waktu yang dimilikinya untuk mengalami transisi semacam itu. Peluang bahwa qubit yang disiapkan dalam state $|1\rangle$ tetap berada di $|1\rangle$ setelah waktu $t$ diberikan oleh

$$p = e^{-t/T_1}$$

Di sini, waktu $T_1$ adalah waktu karakteristik yang ditentukan secara eksperimen, berbeda untuk setiap qubit, dan bahkan bisa sedikit berubah seiring waktu. Komputer quantum IBM® dibenchmark secara rutin, jadi waktu $T_1$ yang kamu temukan tercantum untuk qubit pada komputer quantum IBM seharusnya akurat dan terkini. Nilai $T_1$ yang besar berarti qubit tetap berada di state yang kamu siapkan lebih lama (rata-rata). Nilai $T_1$ tipikal berbeda-beda antar arsitektur; qubit di komputer quantum IBM sering punya waktu $T_1$ pada orde 200-300 $\mu s$, dan kamu bisa memeriksa nilai terbaru di halaman Compute resources.

Waktu karakteristik $T_2$ mengukur sesuatu yang berbeda: hilangnya informasi fase. Kita akan membahas ini nanti.

Untuk mengamati energy relaxation error, kita akan menyiapkan qubit dalam state $|1\rangle$, lalu sengaja membiarkannya idle untuk periode waktu yang lama. Ini adalah bagian buatannya. Dalam workflow quantum nyata, kamu mungkin punya beberapa qubit yang idle untuk periode lama sementara proses dijalankan pada qubit lain; jadi, beberapa contoh idle time semacam itu bukan buatan.

Mari mulai dengan mengimpor beberapa package dan memilih backend yang paling tidak sibuk.

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

_needed = {"cycler": "cycler", "matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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")

from qiskit_ibm_runtime import QiskitRuntimeService
import numpy as np
import matplotlib.pyplot as plt

# If your credentials are already saved locally
service = QiskitRuntimeService()

# To load an unsaved instance, uncomment the line below
# service = QiskitRuntimeService(channel = "ibm_quantum_platform", instance = "your crn here")

# To select the least-busy backend:
# backend = service.least_busy(simulator=False, operational=True)

# To specify the backend by name:
backend = service.backend("ibm_boston")

props = backend.properties()
print(backend)

<IBMBackend('ibm_boston')>

Sekarang kita akan memilih qubit untuk dikerjakan, dalam hal ini, qubit nol. Kita bisa langsung mengimpor properti qubit ini, termasuk $T_1$ dan $T_2$.

qubit_idx = 0
qubit_props = props.qubit_property(qubit_idx)

t1 = qubit_props["T1"][0]  # * 1e6  # Convert seconds to µs
t2 = qubit_props["T2"][0]  # * 1e6  # Convert seconds to µs

# print(f"Qubit {qubit_idx}: T1={t1} µs, T2={t2} µs")
print(f"Qubit {qubit_idx}: T1={t1} s, T2={t2} s")

Qubit 0: T1=0.0002737016180018049 s, T2=0.00042784777605680494 s

Mengetahui $T_1$ dalam satuan mikrodetik itu penting, tapi kamu mungkin belum punya gambaran intuitif tentang apa artinya. Bagaimanapun, operasi gate pada komputer quantum sangat cepat. Pertanyaan sebenarnya adalah: berapa banyak yang bisa kita lakukan pada komputer quantum dalam kurun waktu itu. Untuk itu, berguna untuk mengaitkan $T_1$ dengan skala waktu lain yang digunakan dalam quantum computing — khususnya dengan yang berikut:

• sampling time $dt$ - detak jam terkecil yang menjadi acuan proses kontrol dapat diimplementasikan pada komputer quantum.

• waktu single-qubit gate - waktu yang diperlukan untuk mengimplementasikan operasi gate pada satu qubit. Ini bukan nilai tunggal, melainkan rentang angka yang mungkin tergantung jenis gate-nya.

• waktu two-qubit gate - waktu yang diperlukan untuk mengimplementasikan operasi gate pada dua qubit yang berdekatan. Ini juga bisa memiliki rentang nilai, tapi biasanya sekitar satu orde magnitudo lebih lama dibanding single-qubit gate.

Mari periksa $dt$ untuk backend kita, dan tampilkan beberapa rentang masuk akal untuk waktu gate.

print(f"Using backend: {backend.name}")

# Access the backend target
target = backend.target

def get_gate_times(target, gate_name):
    results = []

    if gate_name not in target:
        return results  # gate not supported

    # target[gate_name] is a dict: {(qubits): InstructionProperties}
    for qubits, props in target[gate_name].items():
        if props.duration is not None:
            results.append({"qubits": qubits, "duration_ns": props.duration * 1e9})

    return results

# Query some gates
for gate in ["cz", "x"]:
    times = get_gate_times(target, gate)

    print(f"\nGate: {gate}")
    if times:
        for entry in times[:5]:
            print(f"  Qubits {entry['qubits']}: {entry['duration_ns']:.2f} ns")
    else:
        print("  Not available on this backend")

Using backend: ibm_boston

Gate: cz
  Qubits (0, 1): 68.00 ns
  Qubits (1, 0): 68.00 ns
  Qubits (1, 2): 68.00 ns
  Qubits (2, 1): 68.00 ns
  Qubits (2, 3): 88.00 ns

Gate: x
  Qubits (0,): 32.00 ns
  Qubits (1,): 32.00 ns
  Qubits (2,): 32.00 ns
  Qubits (3,): 32.00 ns
  Qubits (4,): 32.00 ns

Waktu gate ini akan bervariasi dari satu backend ke backend lain. Kita akan hard-code waktu two-qubit gate yang diambil dari ibm_boston sebesar 68 ns.

dt = backend.configuration().dt
two_q_gate_time = 68e-9
print("The sampling time is : ", dt)
print("dts per T_1 : ", t1 / dt)
print("2-qubit characteristic time : ", two_q_gate_time)
print("The sampling time intervals per two-qubit gate : ", two_q_gate_time / dt)
print("2-qubit gates per T_1 : ", t1 / two_q_gate_time)

The sampling time is :  4e-09
dts per T_1 :  68425.40450045122
2-qubit characteristic time :  6.8e-08
The sampling time intervals per two-qubit gate :  17.0
2-qubit gates per T_1 :  4025.0237941441897

Perlu diingat bahwa tidak ada sumber error lain maupun suppression atau mitigation-nya yang diperhitungkan di sini. Error $T_1$ bukan satu-satunya error yang bekerja dalam sistem quantum, jadi jangan terlalu khawatir dengan angka-angka ini. Ini hanya berarti, tanpa suppression apa pun, kita mungkin bisa mengimplementasikan sekitar ribuan two-qubit gate sebelum error $T_1$ mulai mendominasi. Error lain biasanya akan mendominasi pada depth yang jauh lebih rendah, dan sebaliknya error $T_1$ mungkin masih layak untuk disupresi pada waktu yang jauh lebih singkat dibanding yang dibutuhkan untuk menghilangkan sinyal sepenuhnya.

Kita akan mulai dengan menggunakan simulator dengan noise model, lalu membandingkan hasilnya dengan hardware sungguhan.

from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, thermal_relaxation_error
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_aer.primitives import EstimatorV2

pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

Mari definisikan time step untuk pengukuran kita yang sesuai dengan estimasi batas atas waktu two-qubit gate. Lalu kita akan membangun 50 circuit dengan kelipatan time step tersebut. Dengan cara ini, kita akan melihat apa yang terjadi pada skala waktu yang mirip dengan mengimplementasikan 80 two-qubit gate. Presisi di sini tidak krusial, jadi kita hanya akan menggunakan sedikit shot.

n_points = 50  # We will show 50 steps
delay_unit = 80  # The delay in units of two-qubit-time from above
shots = 100

Kita membangun noise model untuk simulator kita yang secara eksplisit menyertakan thermal relaxation error.

# Create noise model with thermal relaxation for delays
noise_model = NoiseModel()
error = thermal_relaxation_error(
    t1, t2, two_q_gate_time * delay_unit
)  # error model characterized by times in ns
noise_model.add_all_qubit_quantum_error(error, ["delay"])

sim = AerSimulator(noise_model=noise_model)

Sekarang kita membangun circuit dan observable kita. Ini sangat sederhana. Circuit-nya hanya akan terdiri dari menyiapkan qubit di $|1\rangle$ dan mengimplementasikan delay untuk periode waktu yang semakin lama, menggunakan waktu gate karakteristik dan $dt$ yang didefinisikan di atas. Observable-nya hanya akan berupa $Z$, karena yang ingin kita ketahui adalah apakah qubit tetap di $|1\rangle$ atau meluruh ke $|0\rangle$. Meskipun transpilasi tidak selalu diperlukan untuk simulator, kita tetap mentranspilasi circuit kita di sini untuk digunakan nanti pada backend sungguhan.

observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times_sim = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        for j in range(i):
            qc.delay(delay_unit * two_q_gate_time, 0, "s")
            j = j + 1
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times_sim.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

Kita menjalankan job kita menggunakan simulator.

pubs = list(zip(circuits, obs))

# Create AerSimulator with noise model as backend
simulator = AerSimulator(noise_model=noise_model)

# Create SamplerV2 from the AerSimulator backend
estimator = EstimatorV2.from_backend(simulator)

# Run the sampler on the circuit, specify shots
job = estimator.run(pubs)
result = job.result()

Terakhir kita plot outputnya.

# Optional: color palette similar to 'mpl', style = 'clifford'

from cycler import cycler

plt.rcParams["axes.prop_cycle"] = cycler(
    color=[
        "#4C78A8",  # muted blue
        "#72B7B2",  # teal
        "#54A24B",  # green
        "#9C89CC",  # purple
        "#B279A2",  # mauve
    ]
)

# Everything else stays at Matplotlib defaults

# Example data: assume result is a list of objects with structure result[i].data.evs.item()
# and delay_times is already defined as a list of floats.

# Extract y-values
y_sim_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_sim_values = delay_times_sim

# Create the plot
plt.figure(figsize=(8, 5))
plt.plot(x_sim_values, y_sim_values, marker="o", linestyle="-", label="EV Data")

plt.xlabel("Idle Time (s)")
plt.ylabel("Probability of measuring |1>")
plt.title("T1 Decay")
plt.grid(True)
plt.show()

Peluruhan eksponensialnya terlihat jelas, dan dalam waktu ini, meluruh hingga tepat di bawah peluang 40% untuk berada di $|1\rangle$. Perhatikan bahwa ini persis konsisten dengan model: $p = e^{-t/t_1}$ di mana kita telah memilih $t$ maksimum sekitar orde yang sama dengan $t_1$; ingat kita mengatakan $t_1$ mungkin sesuai dengan 60 gate (atau orde besaran itu), dan di sini $t$ sesuai dengan 60 gate. Jadi

$$p \rightarrow e^{-0.25 \text{ ms}/0.267\text{ ms}} \approx 0.392$$

Sekarang mari jalankan circuit yang sama pada komputer quantum sungguhan. Untuk mencakup durasi delay yang sama dengan lebih sedikit job, kita akan meningkatkan unit delay dan mengurangi jumlah titik.

# This took 27 s on ibm_boston

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same time parameters and shots
n_points = 10
delay_unit = 400
shots = 100

# Measure Pauli Z's as your observables
observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        qc.delay(delay_unit * two_q_gate_time * i, 0, "s")
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

pubs = list(zip(circuits, obs))
estimator = EstimatorV2(mode=backend)
job = estimator.run(pubs=pubs)
result = job.result()

# To print the job id for later retrieval of data
# job_id = job.job_id()
# print(f"Job ID: {job_id}")

Sekarang kita plot hasilnya.

fig, ax = plt.subplots()

# Convert from the expectation value of Z to the probability of a transition
y_real_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_real_values = delay_times

# Exponential decay to match theoretical model
t_smooth = np.linspace(0, x_sim_values[19], 100)  # Smooth x-range covering your data
y_decay = np.exp(-t_smooth / (t1))  # y = exp(-t/t1)
ax.plot(t_smooth, y_decay, "k--", linewidth=1, label=f"Perfect Decay (t1={t1:3f} s)")

# Add simulator values
ax.scatter(x_sim_values, y_sim_values, label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(x_real_values, y_real_values, label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Idle Time (s)")
ax.set_ylabel("Probability of measuring |1>")
ax.legend()
ax.set_title("T1 Decay")
ax.grid(True)

plt.show()

Seperti yang bisa kita lihat, peluruhan state $|1\rangle$ seiring waktu cocok dengan teori (dan definisi $T_1$). Selain itu, simulator ini cukup baik dalam mencocokkan perilaku komputer quantum sungguhan dalam kasus ini. Berikut beberapa hal yang perlu diingat tentang peluruhan state ini:

• Kita secara sengaja menunda pengukuran untuk jumlah waktu yang tidak realistis. Delay ini sesuai dengan skala waktu circuit yang sangat dalam yang bisa terdiri dari ribuan two-qubit gate. Ini dilakukan hanya untuk menunjukkan bahwa efek thermal noise memang ada. Dalam circuit nyata yang diterapkan pada masalah dunia nyata, operasi akan dilakukan pada qubit lain sementara beberapa qubit mungkin idle cukup lama sehingga energy relaxation error menjadi berarti — tapi error lain akan mendominasi sebelum mencapai $T_1$ penuh.
• Tidak ada teknik error mitigation atau suppression yang digunakan. Kita bisa mengubah kurva peluruhan ini dengan menggunakan teknik yang akan kita pelajari dalam kursus ini.
• Kita hanya menggunakan 100 shot di sini, yang tergolong sangat rendah karena kita hanya ingin menunjukkan bahwa efeknya memang ada. Kamu kemungkinan akan menggunakan lebih dari 1.000 shot dalam aplikasi.

Visualisasi error pertama ini hampir tidak memerlukan gate selain delay (dan satu X gate yang digunakan untuk menyiapkan $|1\rangle$). Sekarang mari kita lihat contoh lain yang berfokus pada gate error.

Gate error dan akumulasinya

Saat kita menerapkan sebuah quantum gate, katakanlah gate $X$, secara teoritis gate tersebut merotasi quantum state dengan sudut $\pi$ radian mengelilingi sumbu $X$ pada bola Bloch, memetakan $\alpha |0\rangle + \beta |1\rangle$ menjadi $\alpha |1\rangle + \beta |0\rangle$ melalui

$$\begin{aligned} X|\psi\rangle & = R_X(\pi) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta/2)} & -i \sin{(\theta/2)} \\ -i \sin{(\theta/2)} & \cos{(\theta/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \beta \\ \alpha \end{pmatrix}\\ \end{aligned}$$

Namun, gate yang sesungguhnya tidak sempurna. Gate tersebut mungkin berorientasi tidak sempurna (menyebabkan rotasi yang tidak benar-benar mengelilingi sumbu X) atau bisa menyebabkan rotasi yang sedikit lebih besar atau lebih kecil dari yang diinginkan. Mari kita modelkan error gate tersebut sebagai murni over/under rotation sebesar sudut kecil $\epsilon$.

$$\begin{aligned} X_\epsilon|\psi\rangle & = R_X(\pi+\epsilon) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta+\epsilon/2)} & -i \sin{(\theta+\epsilon/2)} \\ -i \sin{(\theta+\epsilon/2)} & \cos{(\theta+\epsilon/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & \approx \begin{pmatrix} \epsilon & 1-\epsilon^2/2 \\ 1-\epsilon^2/2 & \epsilon \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \epsilon \alpha+(1-\epsilon^2/2)\beta \\ (1-\epsilon^2/2)\alpha+\epsilon \beta \end{pmatrix}\\ \end{aligned}$$

Jika sebuah gate yang tidak sempurna diterapkan berkali-kali, error kecil $\epsilon$ dapat terakumulasi. Terkadang beberapa error ini bahkan menyebabkan keadaan bergeser ke arah yang sama setiap kalinya (sebuah fenomena yang disebut "akumulasi koheren", yang akan kita bahas lagi di bawah). Mari kita lihat apa yang terjadi saat kita menerapkan gate X yang sesungguhnya pada sebuah qubit berkali-kali.

# This took 78 s on penguino1

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same bit flips
max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2(mode=backend)
results = estimator.run(pubs=pubs).result()
real_expectations = [pub_res.data.evs for pub_res in results]

# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService()           # uses stored IBM Quantum account
# job_id = "d5immof67pic7386l8eg"

# job = service.job(job_id)                 # retrieve the job
# results = job.result()                        # this is your .result() object

# Convert from the expectation value of Z to the probability of a transition
# y_real_values = [(1-r.data.evs.item())/2 for r in results]

# Create the plot
plt.figure(figsize=(8, 5))
# plt.plot(range(max_depth + 1), y_real_values, 'o-')
# plt.plot(x_real_values, y_real_values, marker='o', linestyle='-', color='blue', label='EV Data')
plt.plot(
    range(max_depth + 1),
    real_expectations,
    marker="o",
    linestyle="-",
    color="blue",
    label="EV Data",
)

plt.xlabel("Number of Flip-Back Cycles")
plt.ylabel("Expectation ⟨Z⟩")
plt.title("Accumulated Gate Noise Effects on Flips")
plt.grid(True)
plt.show()

Nilai ekspektasi mulai sekitar 1.0 seperti yang diharapkan, dan meluruh, tetapi tidak hanya meluruh menjadi nol! Nilainya menjadi negatif. Jika ini adalah noise termal atau interaksi acak, hal itu tidak akan membuat $|1\rangle$ lebih mungkin terukur dibandingkan $|0\rangle$. Error ini jelas berbeda. Dan hal ini masuk akal dalam konteks pembahasan over/under-rotation kita. Jika setiap pasangan rotasi yang seharusnya saling meniadakan justru berakhir dengan rotasi sebesar sudut kecil, maka banyak pengulangan seperti itu akan perlahan-lahan membuat keadaan berotasi dari $|0\rangle$ menuju $|1\rangle$.

Akumulasi error yang ditunjukkan di sini kemungkinan tidak akan berlangsung serapi ini dalam alur kerja yang sesungguhnya. Salah satu alasannya, kita secara eksplisit mematikan mitigasi error dan menjalankan urutan gate berulang yang sama agar error dapat terakumulasi secara koheren. Hal ini dilakukan semata-mata untuk menunjukkan bahwa error tersebut memang ada. Ketika kita menggunakan teknik penanganan noise (misalnya, Pauli twirling), kita dapat memengaruhi bagaimana error terakumulasi, yang seringkali menghasilkan error keseluruhan yang lebih rendah.

Kita dapat memeriksa secara pasti seberapa baik model error ini cocok dengan data eksperimen dengan membangun model noise secara eksplisit dan menggunakan simulator. Pada model di bawah ini, kita secara eksplisit membangun error yang setara dengan 0.025 radian. Itu bukan angka ajaib; kita cukup menyetel error tersebut hingga secara wajar menggambarkan eksperimen.

from qiskit_aer.noise import NoiseModel, coherent_unitary_error
from qiskit_aer import AerSimulator
import numpy as np

# For your SINGLE-QUBIT test on qubit 0, just override X error specifically
noise_model = NoiseModel.from_backend(backend, gate_error=True, thermal_relaxation=True)

theta_error = 0.025  # model over-rotation error around 0.01-0.03 radians
U_over = np.array(
    [
        [np.cos(theta_error / 2), -1j * np.sin(theta_error / 2)],
        [-1j * np.sin(theta_error / 2), np.cos(theta_error / 2)],
    ]
)

unitary_error = coherent_unitary_error(U_over)
# Target ONLY qubit 0 (your circuit) - no warning!
noise_model.add_quantum_error(unitary_error, ["x"], [0])

simulator = AerSimulator(noise_model=noise_model)

WARNING: quantum error already exists for instruction "x" on qubits (0,) , appending additional error.

max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2.from_backend(simulator)
results = estimator.run(pubs).result()
expectations = [pub_res.data.evs for pub_res in results]  # no [0], use value directly

Sekarang kita dapat memplot kurva nyata dan kurva simulasi bersama-sama.

fig, ax = plt.subplots()

# Add simulator values
ax.scatter(range(max_depth + 1), expectations, c="blue", label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(range(max_depth + 1), real_expectations, c="red", label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Number of Flip-Back Cycles")
ax.set_ylabel("Expectation ⟨Z⟩")
ax.set_title("Accumulated Gate Noise Effects on Flips")
ax.legend()
ax.grid(True)

plt.show()

Error pada circuit yang sesungguhnya cukup baik digambarkan oleh model error over/under-rotation. Jelas bahwa jenis noise dan error yang berbeda akan terakumulasi secara berbeda dan menghasilkan efek yang sangat berbeda pada fidelity circuit kuantum kita. Oleh karena itu, menjadi sangat penting untuk mengklasifikasikan dan mengkarakterisasi error yang dapat terjadi secara lebih formal daripada yang telah kita lakukan sejauh ini.

Mengkarakterisasi error kuantum

Kita telah menjelaskan beberapa sumber noise kuantum, dan kita dapat mengategorikan error berdasarkan kategori noise yang menyebabkannya. Namun, bisa saja ada kategori error kuantum yang berbeda yang berguna dalam koreksi dan mitigasi error. Misalnya, kita perlu mengetahui pada titik mana error terjadi dan bagaimana error terakumulasi jika kita ingin mengoreksi atau memitigasinya. Dalam menentukan di mana (dalam proses apa) error terjadi, sebuah kategori penting yang umum adalah error persiapan keadaan dan pengukuran (atau disingkat error SPAM). Di sini, istilah “persiapan keadaan” tidak berarti segala sesuatu yang dilakukan pada suatu keadaan untuk mempersiapkannya bagi pengukuran. Sebaliknya, istilah ini mengacu pada inisialisasi qubit, “persiapan” qubit untuk eksekusi sebuah algoritma, sehingga kategori SPAM ini tidak mencakup hal-hal seperti error gate selama eksekusi algoritma.

Perbedaan penting lainnya adalah apakah error tersebut koheren atau tidak koheren. Untuk meringkas secara singkat (kita akan membahasnya lebih rinci di bawah), error koheren biasanya dimodelkan dengan operasi uniter dan mempertahankan purity keadaan. Error tidak koheren dimodelkan dengan quantum channel non-uniter dan umumnya mengurangi purity keadaan. Mudah untuk membayangkan error tidak koheren sebagai interaksi termal yang menyebabkan hilangnya informasi kuantum, tetapi sebenarnya error tersebut bisa disebabkan oleh keterkaitan acak apa pun dengan lingkungan. Sebagai contoh error koheren, misalkan ada ketidaksempurnaan dalam orientasi pulsa saat mengimplementasikan gate RY sehingga gate $RY(\theta)$ sebenarnya menyebabkan $RY(\theta) \cdot RX(\epsilon)$. Ketidaksempurnaan semacam itu akan selalu menyebabkan rotasi keliru mengelilingi X pada arah yang sama. Ini akan menjadi sebuah error koheren.

Perhatikan bahwa error SPAM mencakup campuran error koheren, seperti kesalahan kontrol sistematis, dan error tidak koheren, seperti kehilangan foton dan efek termal. Karena hal ini melibatkan beberapa tahap dan sumber error, error SPAM paling baik digambarkan sebagai kombinasi dari error koheren maupun tidak koheren.

Error SPAM

Seperti namanya, error SPAM muncul pada dua tahap berbeda dalam sebuah eksperimen kuantum: persiapan awal dan pembacaan/pengukuran. Error persiapan keadaan terjadi ketika perangkat keras gagal menginisialisasi qubit secara andal ke keadaan awal yang diinginkan ($|0\rangle$ untuk komputer kuantum IBM). Penyebabnya meliputi:

• eksitasi termal (qubit yang sesungguhnya tidak didinginkan secara sempurna dan terkadang bisa memulai di $|1\rangle$ alih-alih $|0\rangle$)
• foton sisa atau noise pada resonator dalam qubit superkonduktor
• pergeseran (drift) kalibrasi yang memengaruhi seberapa akurat qubit direset

Error pengukuran terjadi selama proses pembacaan, ketika perangkat pengukuran salah mengidentifikasi keadaan qubit. Sumbernya meliputi:

• noise amplifier pembacaan yang menyebabkan kebingungan antara $|0\rangle$ dan $|1\rangle$

• relaksasi qubit selama pembacaan (misalnya, sebuah qubit di $|1\rangle$ meluruh menjadi $|0\rangle$ tepat sebelum atau selama pengukuran)

• crosstalk antara jalur pembacaan: membaca satu qubit sedikit memengaruhi pembacaan pada qubit-qubit tetangganya

• Ambang batas diskriminasi yang tidak sempurna pada sistem pengukuran berbasis resonator IBM

Error SPAM sebagian besar bersifat tidak koheren. Error persiapan berperilaku seperti campuran acak dari keadaan tereksitasi dan keadaan dasar. Error pengukuran berperilaku seperti kebingungan klasik: dengan probabilitas $p$, $|0\rangle$ dilaporkan sebagai $|1\rangle$ atau sebaliknya. Hal ini berbeda dari error uniter koheren (seperti gate yang salah kalibrasi yang menyebabkan pergeseran fase sistematis). Sebaliknya, error SPAM menyerupai noise klasik acak, meskipun bias koheren yang jarang pada pembacaan bisa saja ada.

Error SPAM dapat menjadi masalah untuk randomized benchmarking atau untuk circuit dengan kedalaman pendek, di mana persiapan keadaan dan pengukuran mewakili sebagian besar dari total error. Error ini menjadi kurang bermasalah untuk circuit yang sangat dalam, terutama yang memiliki banyak two-qubit gate.

Secara matematis, error SPAM dapat digambarkan sebagai menghasilkan distribusi noisy $\vec{p}_\text{noisy}$ yang berkaitan dengan distribusi ideal $\vec{p}_\text{ideal}$ melalui sebuah matriks $A$:

$$\vec{p}_\text{noisy} = A \vec{p}_\text{ideal}$$

Di sini $p_i$ adalah probabilitas mengukur bitstring $i$, dan $A_{ij}$ adalah probabilitas memperoleh keadaan $j$ ketika keadaan seharusnya dipersiapkan dalam keadaan $i$. Bayangkan konteks bitstring yang disampel dari Sampler. Distribusi keadaan yang terukur akan terdiri dari banyak pengukuran yang akurat, tetapi juga beberapa pengukuran di mana instruksi untuk persiapan keadaan tidak cocok dengan keadaan yang teramati. Ini berarti probabilitasnya akan sedikit meleset.

Pada gambar di atas, bagian (a) menunjukkan distribusi ideal dari sebuah keadaan GHZ berwarna teal, dan pengukuran sesungguhnya berwarna ungu. Pada bagian (b) kita melihat contoh sebuah matriks $A$. Perhatikan bahwa matriks tersebut tidak simetris sempurna sepanjang diagonalnya, karena setiap qubit tidak harus sama-sama mungkin untuk secara keliru mengembalikan 0 dan secara keliru mengembalikan 1. Dalam praktiknya, seringkali sulit untuk memisahkan error persiapan dan pembacaan, sehingga keduanya sering digabungkan dalam satu penanganan (karenanya penggunaan umum istilah SPAM).

Salah satu cara untuk mengoreksi error SPAM ini adalah dengan menggunakan circuit sederhana yang hasil pengukuran idealnya sudah diketahui, lalu membandingkannya dengan hasil yang terukur dengan adanya error SPAM. Ini dapat digunakan untuk merekayasa balik (reverse-engineer) hasil ideal dari circuit yang lebih kompleks. Untuk keadaan dengan entropi tinggi secara umum, hal ini bisa membutuhkan pembangunan sebuah matriks dengan $2^N\times2^N$ probabilitas, tetapi dalam kasus yang tidak seekstrem itu, error ini dapat dimitigasi.

Error koheren versus error tidak koheren

Error koheren adalah rotasi-salah (mis-rotation) yang sistematis, deterministik, dan uniter pada quantum state. Error ini muncul dari operasi kuantum yang tidak sempurna yang menyimpang dengan cara yang dapat diprediksi. Contohnya termasuk error kecil dalam rotasi yang diterapkan oleh single-qubit rotation gate, termasuk yang disebabkan oleh drift kalibrasi yang secara konsisten melakukan over-rotation atau under-rotation. Secara matematis, kita bisa menuliskan bahwa sebuah rotation gate yang sesungguhnya, katakanlah $\tilde{R_X}(\theta)$, diberikan oleh rotation gate ideal ditambah beberapa error tambahan:

$$\tilde{R_X}(\theta) = R_X(\theta + \epsilon)$$

untuk suatu under-rotation atau over-rotation kecil $\epsilon$. Contoh lainnya termasuk sebuah two-qubit gate yang menambahkan pergeseran fase kecil yang tidak diinginkan dan pulsa kontrol yang secara sistematis menyimpang dari bentuk idealnya.

Sebuah karakteristik kunci dari error koheren adalah bahwa error tersebut deterministik dan dapat dimodelkan oleh unitary gate itu sendiri. Sejalan dengan itu, error ini mempertahankan purity quantum state: informasi kuantum tidak hilang, hanya saja diproses secara tidak sempurna. Hal penting lain yang perlu dicatat adalah bahwa error koheren yang berulang berinterferensi secara konstruktif dan terkadang tumbuh secara kuadratik seiring bertambahnya jumlah gate.

Error semacam ini terkadang dapat diprediksi dan karenanya dapat dihilangkan melalui kalibrasi hingga taraf tertentu. Namun, error koheren yang tersisa dapat terakumulasi dengan cepat, menyebabkan penyimpangan yang merepotkan dari keadaan ideal. Ini berarti bahwa terkadang menguntungkan untuk secara sengaja "meng-acak-kan" (randomize) error koheren. Prosedur ini dan kegunaannya akan dibahas dalam lesson tentang mitigasi error.

Mengapa error ini merepotkan

Error koheren dapat “menumpuk” dengan cara yang berbahaya, menghasilkan penyimpangan besar dari keadaan yang benar jika tidak di-acak-kan atau dikoreksi.

Error tidak koheren bersifat stokastik, acak, dan sering kali non-uniter. Error ini muncul dari interaksi dengan lingkungan atau sumber noise yang tidak terkontrol. Kita sudah melihat beberapa contohnya: relaksasi energi / peluruhan $T_1$ bersifat tidak koheren. Begitu pula dengan noise gate stokastik, noise termal, dan error pengukuran.

Ciri kunci dari error tidak koheren adalah bahwa error tersebut tidak sama setiap kali sebuah operasi dilakukan. Error ini non-uniter, sehingga tidak dapat dimodelkan oleh sebuah unitary quantum gate sederhana seperti halnya error koheren. Karena bersifat tidak koheren, error ini biasanya terakumulasi secara linear seperti noise acak, bukan seperti over-rotation yang konsisten.

Error tidak koheren menyebabkan qubit kehilangan informasi secara ireversibel (hilangnya purity dan informasi fase).

Jadi, mana yang lebih buruk? Seperti kebanyakan hal dalam komputasi kuantum, itu tergantung. Intinya adalah bahwa error koheren terakumulasi lebih cepat dan secara non-linear (yang buruk). Namun error ini bisa sebagian dihilangkan melalui kalibrasi dan informasi fasenya masih ada di dalam sistem kamu, jika kamu bisa mencari cara untuk mengekstraknya dengan benar. Error tidak koheren terakumulasi secara linear, yang baik karena dua alasan: lebih lambat dibandingkan akumulasi koheren, dan cukup mudah untuk melihat bagaimana efek error tidak koheren berskala untuk proses seperti zero-noise extrapolation (ZNE), yang akan dibahas dalam lesson tentang mitigasi error. Namun, ketika error tidak koheren terjadi, informasi kuantum benar-benar hilang, bukan sekadar tersamarkan.

Matriks densitas dan quantum channel

Pada bagian-bagian berikut, kita akan membahas lebih dalam beberapa jenis error koheren dan tidak koheren serta melihat bagaimana error tersebut dapat dimodelkan secara matematis menggunakan quantum channel. Pertama-tama, sebuah penyegaran singkat tentang matriks densitas dan quantum channel diperlukan. Untuk pembahasan yang lengkap dan mendalam mengenai hal ini, lihat kursus John Watrous General formulation of quantum information di IBM Quantum Learning. Pembahasan di sini akan lebih didorong oleh contoh dan kurang formal.

Quantum channel adalah cara paling umum untuk menggambarkan bagaimana sebuah sistem kuantum berevolusi, berinteraksi, dan mengalami noise. Jika kamu sudah terbiasa dengan pure state dan evolusi uniter, quantum channel adalah langkah lanjutan yang alami.

Dalam mekanika kuantum standar, sebuah keadaan "murni" (pure) ditulis sebagai $|\psi\rangle$. Di sini "murni" mengacu pada purity informasi atau pengetahuan tentang persiapan keadaan tersebut; ini tidak berarti sebuah eigenstate dari suatu sistem. Sebagai contoh qubit, $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ adalah sebuah pure state karena kita memiliki pengetahuan sempurna tentang amplitudo relatif dan fasenya. Evolusi waktu dari pure state semacam itu diatur oleh sebuah operator uniter $U$:

$$|\psi\rangle \rightarrow U|\psi\rangle$$

sesuai dengan persamaan Schr"odinger, di mana $U = e^{-iHt/\hbar}$, dengan $H$ adalah Hamiltonian sistem dan $\hbar$ adalah konstanta Planck tereduksi, yang sering "dianggap sama dengan satu" atau secara lebih ketat, diserap ke dalam Hamiltonian sehingga semua energi dinyatakan dalam satuan $\hbar$.

Evolusi uniter bersifat reversibel, deterministik, dan terisolasi. Namun hal ini tidak memadai untuk menggambarkan sistem kuantum yang sesungguhnya. Dalam sistem kuantum yang sesungguhnya:

• Kita melakukan pengukuran, yang meruntuhkan (collapse) quantum state menjadi sebuah eigenstate dari sistem. Ini jelas bersifat non-uniter.
• Sistem berinteraksi dengan sebuah lingkungan. Ini berarti sistem tidak benar-benar terisolasi, dan karena lingkungan tidak dapat dilacak hingga tak terhingga, hal ini setara dengan hilangnya informasi.
• Secara praktis: noise merusak keadaan tersebut. Dan masih banyak lagi.

Evolusi uniter saja tidak dapat menggambarkan proses-proses ini; oleh karena itu, kita memerlukan representasi keadaan dan proses kuantum yang lebih umum. Sebuah mixed state menggambarkan sebuah distribusi klasik dari quantum state. Artinya, kita sudah familier dengan fakta bahwa quantum state: $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ memiliki peluang 50% untuk terukur (runtuh menjadi informasi klasik) dalam keadaan $|0\rangle$ dan peluang 50% untuk terukur dalam keadaan $|1\rangle$. Namun klaimnya adalah bahwa quantum state awalnya persis $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ dengan probabilitas 100%. Sekarang kita ingin menambahkan, di atas probabilitas mekanika kuantum tersebut, sebuah probabilitas klasik, misalnya:

Quantum state awal dipersiapkan dalam $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ dengan probabilitas klasik 25%, dan dipersiapkan dalam $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle-i|1\rangle)$ dengan probabilitas klasik 75% (perhatikan fase relatif yang berbeda).

Terkadang hal ini bisa disebabkan oleh probabilitas klasik eksplisit dalam persiapan; di lain waktu bisa disebabkan oleh entanglement dengan bagian-bagian lingkungan yang kita abaikan. Bagaimanapun juga, kebutuhan akan sebuah alat untuk menggambarkan distribusi klasik dari keadaan-keadaan mekanika kuantum ini jelas terlihat. Pure state saja tidak dapat merepresentasikan kemungkinan-kemungkinan ini. Oleh karena itu, kita memperkenalkan matriks densitas.

Sebuah mixed state digambarkan oleh sebuah operator densitas:

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

Di sini, $|\psi_i\rangle$ adalah sebuah quantum state (tidak harus sebuah eigenstate dari operator tertentu mana pun) dan $p_i$ adalah probabilitas klasik bahwa sistem dipersiapkan dalam keadaan $|\psi_i\rangle$. Ini adalah resep yang baik untuk cara membangun sebuah matriks densitas dari distribusi klasik quantum state yang sudah diketahui. Di sisi lain, kita mungkin ingin mengetahui, dengan diberikan baik distribusi klasik quantum state maupun probabilitas mekanika kuantum dari berbagai hasil pengukuran, berapa probabilitas bahwa sebuah pengukuran menghasilkan sebuah keadaan tertentu (seperti $|0\rangle$, atau $|1\rangle$, atau keadaan lain saat lebih banyak qubit terlibat). Di sinilah matriks densitas sangat berguna. Kita juga dapat menuliskannya dalam sebuah basis $\{|i\rangle\}$ sebagai:

$$\rho = \sum_{i,j} \rho_{ij} |i\rangle\langle j|.$$

Di sini elemen-elemen diagonal $\rho_{ii}$​ adalah probabilitas:

• $\rho_{00}$​ = probabilitas qubit berada di $|0\rangle$

• $\rho_{11}$​ = probabilitas qubit berada di $|1\rangle$

Nilai-nilai ini bersifat real, non‑negatif, dan berjumlah 1.

Elemen-elemen off-diagonal $\rho_{ij}, i \neq j$ adalah koherensi: hubungan fase atau kemampuan interferensi, dan secara umum sesuai dengan seberapa banyak informasi mekanika kuantum yang ada dalam keadaan tersebut. Ini adalah pernyataan yang informal, tetapi mari kita lihat apa artinya dalam praktiknya.

Contoh

Perhatikan pure state $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. (a) Apa yang Anda ketahui tentang probabilitas pengukuran dan informasi fase tanpa melakukan perhitungan apa pun? (b) Bangun matriks densitasnya dan verifikasi intuisi Anda.

Solution:

(a) Karena ini adalah pure state, hanya ada satu kemungkinan fase antara $|0\rangle$ dan $|1\rangle$: +1. Ini adalah informasi fase yang sempurna, sehingga kita mengharapkan elemen-elemen off-diagonal dalam matriks densitas kita bernilai besar. Kamu mungkin memiliki intuisi lebih dari itu tentang elemen off-diagonal, tetapi itu sudah cukup untuk saat ini. Selanjutnya, amplitudo dari kedua basis state tersebut sama, sehingga kita mengharapkan probabilitas 50% untuk mengukur $|0\rangle$ ataupun $|1\rangle$. Jadi kita mengharapkan entri diagonalnya bernilai 1/2. (b) Menggunakan definisi di atas:

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ hanya untuk keadaan $|\psi\rangle$. Jadi kita dapat menuliskan

$$\begin{aligned} \rho & = 1 |\psi\rangle\langle\psi| \\ & = \frac{1}{2}(|0\rangle+|1\rangle)(\langle0|+\langle1|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}. \end{aligned}$$

Entri-entri diagonal masing-masing bernilai $1/2$ seperti yang diharapkan, dan elemen-elemen off-diagonal bernilai besar (berjumlah satu).

Sekarang mari kita lihat apa yang terjadi ketika kita tidak memiliki informasi fase yang baik.

Contoh

Perhatikan kasus yang serupa, tetapi sekarang dengan probabilitas klasik 50% berada dalam keadaan $|\psi_+\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ dan probabilitas klasik 50% berada dalam keadaan $|\psi_-\rangle = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$. Dua pertanyaan yang sama: (a) Apa yang kamu ketahui tentang probabilitas pengukuran dan informasi fase tanpa melakukan perhitungan apa pun? (b) Bangun matriks densitasnya dan verifikasi intuisimu.

Solution:

(a) Seperti sebelumnya, amplitudo dari kedua basis state tersebut sama, sehingga kita mengharapkan probabilitas 50% untuk mengukur $|0\rangle$ ataupun $|1\rangle$. Jadi kita mengharapkan entri diagonalnya bernilai 1/2. Namun kali ini ada dua kemungkinan fase yang berlawanan antara $|0\rangle$ dan $|1\rangle$: +1 dan -1, dan masing-masing sama-sama mungkin. Seseorang mungkin mengira bahwa dengan dua fase berlawanan yang sama-sama mungkin, hampir tidak ada informasi fase yang tersisa. Seseorang mungkin mengira entri-entri off-diagonal akan bernilai kecil. (b) Sekali lagi menggunakan definisi di atas

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ hanya untuk kedua keadaan $|\psi_+\rangle$ dan $|\psi_-\rangle$. Jadi kita dapat menuliskan

$$\begin{aligned} \rho & = \frac{1}{2} |\psi_+\rangle\langle\psi_+| + \frac{1}{2}|\psi_-\rangle\langle\psi_-| \\ & = \frac{1}{4}(|0\rangle+|1\rangle)(\langle0|+\langle1|)+\frac{1}{4}(|0\rangle-|1\rangle)(\langle0|-\langle1|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}+\frac{1}{4}\begin{pmatrix} 1 & -1 \\ -1 & 1\end{pmatrix}\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 \\ 0 & 1\end{pmatrix}. \end{aligned}$$

Entri-entri off-diagonal bernilai kecil, bahkan nol, seperti yang diharapkan. Elemen-elemen diagonal masih bernilai 50% masing-masing, yang masuk akal karena setiap keadaan dalam campuran tersebut memiliki $|0\rangle$ dan $|1\rangle$ dengan bobot yang sama.

Konstruksi ini menjadi lebih menarik seiring bertambahnya jumlah qubit. Jelajahi hal ini dalam pertanyaan-pertanyaan di bawah.

Uji pemahaman Anda

Tuliskan matriks densitas untuk pure Bell state $|\Phi_+\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$.

Jawaban

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ hanya untuk keadaan $|\Phi_+\rangle$. Jadi kita dapat menuliskan

$$\begin{aligned} \rho & = 1 |\Phi_+\rangle\langle\Phi_+| \\ & = \frac{1}{2}(|00\rangle+|11\rangle)(\langle00|+\langle11|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

Tuliskan matriks densitas untuk probabilitas klasik 25% dari $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ dan probabilitas klasik 75% dari $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$.

Jawaban

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ hanya untuk kedua keadaan $|\Phi_+\rangle$ dan $|\Psi_-\rangle$. Jadi kita dapat menuliskan

$$\begin{aligned} \rho & = \frac{1}{4} |\Phi_+\rangle\langle\Phi_+| + \frac{3}{4}|\Psi_-\rangle\langle\Psi_+| \\ & = \frac{1}{8}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{3}{8}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{3}{8}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 3 & -3 & 0 \\ 0 & -3 & 3 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

Modifikasi pekerjaan Anda dari pertanyaan sebelumnya untuk menuliskan matriks densitas untuk probabilitas klasik 50% dari $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ dan probabilitas klasik 50% dari $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$. Prediksi informasi fase apa yang seharusnya bertahan.

Jawaban

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ hanya untuk kedua keadaan $|\Phi_+\rangle$ dan $|\Psi_-\rangle$. Jadi kita dapat menuliskan

$$\begin{aligned} \rho & = \frac{1}{2} |\Phi_+\rangle\langle\Phi_+| + \frac{1}{2}|\Psi_-\rangle\langle\Psi_-| \\ & = \frac{1}{4}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{1}{4}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{1}{4}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

Suku-suku diagonal berjumlah 1, seperti yang seharusnya. Suku-suku off-diagonal di sini tidak saling meniadakan seperti pada contoh satu-qubit sebelumnya. Kamu dapat melihat alasannya dalam matematikanya, tetapi penjelasan singkatnya adalah bahwa sekarang ada lebih banyak keadaan dalam ruang Hilbert kita. Meskipun Bell state pertama memiliki fase relatif positif dan yang kedua memiliki fase negatif, fase-fase ini berada di antara basis state yang berbeda. Bell state pertama memiliki fase antara $|00\rangle$ dan $|11\rangle$, sementara yang kedua memiliki fase relatif antara $|01\rangle$ dan $|10\rangle$.

Quantum channel

Sebuah quantum channel adalah transformasi quantum state paling umum yang diperbolehkan secara fisis. Quantum channel ini membawa sebuah matriks densitas awal $\rho$ menjadi matriks densitas lainnya:

$$\rho \quad \longrightarrow \Phi(\rho)$$

Di sini $\Phi(\rho)$ berarti sebuah quantum channel $\Phi$ yang bekerja pada sebuah matriks densitas $\rho$, jangan sampai keliru dengan Bell state $|\Phi_+\rangle$ atau $|\Phi_-\rangle$.

Quantum channel bersifat sangat umum. Quantum channel dapat mencakup:

• Evolusi uniter $\Phi(\rho) = U\rho U^\dagger$

• Campuran probabilistik dari operator-operator uniter

• Measurements

• Decoherence

• Amplitude damping (kehilangan energi)

• Dephasing (hilangnya informasi fase)

• Interaksi dengan sebuah lingkungan Dan banyak hal lainnya.

Salah satu cara untuk memahami quantum channel adalah bahwa quantum channel bagi matriks densitas sama seperti operator uniter bagi pure state. Namun keumuman matriks densitas memungkinkan quantum channel yang bersesuaian menjadi jauh lebih umum dan karenanya lebih powerful.

Satu-satunya batasan pada sebuah quantum channel adalah bahwa quantum channel tersebut harus:

1. Linear Campuran keadaan harus berevolusi secara konsisten: $\Phi(p\rho_1 + (1-p)\rho_2) = p\Phi(\rho_1) + (1-p)\Phi(\rho_2)$
2. Completely positive Quantum channel tidak boleh menghasilkan probabilitas negatif, bahkan jika sistem kamu terentanglemen dengan sesuatu yang lain.
3. Trace-preserving Probabilitas harus berjumlah 1. Hal-hal ini terkadang dikumpulkan bersama dalam akronim CPTP: Completely Positive Trace-Preserving maps.

Ada berbagai representasi quantum channel, termasuk representasi Stinespring, Kraus, dan Choi. Hal ini dibahas secara rinci dalam pelajaran ini tentang quantum channel dalam General formulation of quantum information dan di sana juga ditunjukkan bahwa representasi-representasi tersebut ekuivalen. Kita tidak akan membahas representasi-representasi yang berbeda ini di sini. Cukup dikatakan bahwa representasi-representasi tersebut analog dengan menggambarkan vektor menggunakan tiga kerangka koordinat yang berbeda. Masing-masing mungkin menekankan aspek yang berbeda dan membangun intuisi dengan cara yang berbeda; tetapi semuanya memberi Anda jawaban yang benar. Representasi Kraus cocok untuk keperluan kita. Representasi ini menawarkan cara formulaik yang praktis untuk menyatakan aksi sebuah channel melalui perkalian dan penjumlahan matriks. Secara khusus, sebuah representasi Kraus adalah spesifikasi sebuah channel, $\Phi$, dalam bentuk berikut.

$$\Phi(\rho) = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}$$

Di sini, $A_0,\ldots,A_{N-1}$ adalah matriks-matriks yang semuanya memiliki dimensi yang sama: kolom-kolomnya bersesuaian dengan keadaan klasik dari sistem input, $\mathsf{X}$, dan baris-barisnya bersesuaian dengan keadaan klasik dari sistem output, baik itu $\mathsf{X}$ ataupun sistem lain $\mathsf{Y}$. Agar $\Phi$ menjadi sebuah channel yang valid, matriks-matriks ini harus memenuhi kondisi berikut.

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

Matriks-matriks ini disebut matriks Kraus. Formulasi ini berlaku tidak hanya untuk noise channel, tetapi juga untuk proses dan quantum channel secara umum, termasuk pengukuran. Mari kita lihat sebuah contoh bagaimana matriks-matriks ini dapat digunakan untuk membangun channel dalam konteks noise dan error.

Channel dephasing sepenuhnya

Perhatikan sebuah channel yang menghancurkan seluruh informasi fase dan sebut channel tersebut completely dephasing channel. Ini berarti channel tersebut harus mengubah matriks densitas apa pun dalam bentuk

$$\rho_i = \begin{pmatrix} \rho_{11} & \rho_{12} & \dots & \rho_{1n} \\ \rho_{21} & \rho_{22} & \ddots & \rho_{2n} \\ \vdots & \ddots & \ddots & \vdots \\ \rho_{n1} & \rho_{n2} & \dots & \rho_{nn} \end{pmatrix}$$

dan memetakannya menjadi

$$\rho_f = \Phi(\rho_i) = \begin{pmatrix} \rho_{11} & 0 & \dots & 0 \\ 0 & \rho_{22} & \ddots & 0 \\ \vdots & \ddots & \ddots & \vdots \\ 0 & 0 & \dots & \rho_{nn} \end{pmatrix}$$

Jika kita asumsikan bahwa matriks densitas tersebut sudah dituliskan dalam basis komputasi, kita dapat menyatakan $\rho_{ij}$ sebagai $\langle i|\rho|j\rangle$. Ini menyarankan sebuah himpunan matriks Kraus yang dapat mewujudkan aksi channel ini: $A_k = |k\rangle\langle k|$. Mari kita terapkan strategi ini pada sebuah contoh kasus satu qubit, dan lihat apakah ini bekerja sebagaimana yang kita perlukan:

Tetapkan $A_0 = \vert 0\rangle\langle 0\vert$ dan $A_1 = \vert 1\rangle\langle 1\vert$.

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger} & = \vert 0\rangle\langle 0 \vert \rho \vert 0\rangle\langle 0 \vert + \vert 1\rangle\langle 1 \vert \rho \vert 1\rangle\langle 1 \vert \end{aligned}$$

Karena $\langle 0 \vert \rho \vert 0\rangle$ adalah sebuah angka, kita cukup memindahkan vektor $\vert 0\rangle$ melewatinya. Hal ini berlaku juga untuk suku kedua. Kita memiliki:

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger}& = \langle 0 \vert \rho \vert 0\rangle \, \vert 0\rangle\langle 0 \vert + \langle 1 \vert \rho \vert 1\rangle \, \vert 1\rangle\langle 1 \vert \\[2mm] & = \begin{pmatrix} \langle 0 \vert \rho \vert 0 \rangle & 0 \\[1mm] 0 & \langle 1 \vert \rho \vert 1 \rangle \end{pmatrix} \end{aligned}$$

Perhatikan bahwa matriks-matriks ini memenuhi kondisi yang diperlukan:

$$\sum_{k = 0}^1 A_k^{\dagger} A_k = \vert 0\rangle\langle 0\vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert 1\rangle\langle 1\vert = \vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert = \mathbb{I}$$

Perlu dicatat bahwa pilihan matriks Kraus ini tidak unik.

Mengkarakterisasi noise sebagai channel

Pada bagian ini kita akan menggunakan model bola Bloch dan matematika quantum channel untuk lebih memahami berbagai jenis noise dan error.

Error tidak koheren

Mari kita kembali ke error tidak koheren dan secara khusus mengeksplorasi error relaksasi energi. Ingat kembali bahwa keadaan $|0\rangle$ adalah keadaan dasar (ground state) suatu qubit dan keadaan $|1\rangle$ memiliki energi yang sedikit lebih tinggi. Terkadang quantum state akan meluruh (decay) secara spontan dari tingkat energi yang lebih tinggi ke yang lebih rendah. Proses emisi spontan adalah topik yang kaya dan tidak dapat benar-benar dipahami tanpa penjelasan teori medan kuantum. Namun intuisinya sangat familier bagi kita semua: gangguan acak dapat menyebabkan sebuah batu menggelinding turun bukit; gangguan tersebut tidak akan menyebabkan batu menggelinding naik bukit. Berapa lama qubit tetap berada dalam keadaan energi yang lebih tinggi dikarakterisasi oleh suatu waktu $T_1$. Lebih spesifiknya, probabilitas bahwa qubit yang disiapkan dalam keadaan $|1\rangle$ tetap berada dalam keadaan tersebut setelah waktu $t$ adalah $e^{-t/T_1}$. Atau, secara ekuivalen, probabilitas $p$ dari error relaksasi energi setelah waktu $t$ adalah

$$p = 1-e^{-t/T_1}$$

Untuk mendeskripsikan hal ini dengan quantum channel dalam representasi Kraus, kita memerlukan matriks Kraus yang berkorespondensi dengan

• membiarkan keadaan $|0\rangle$ tidak berubah
• mengubah keadaan $|1\rangle$ menjadi $|0\rangle$ dengan probabilitas tertentu p.

Mari kita definisikan

$$\begin{aligned} A_0 & = 1|0\rangle\langle0| + \sqrt{1-p}|1\rangle\langle1|\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}|0\rangle\langle1|\\ & = \begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix} \end{aligned}$$

Pertama, mari kita periksa apakah ini memiliki efek yang diinginkan pada matriks densitas. Perhatikan suatu sistem yang berada dalam keadaan murni $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Kita telah melihat dalam contoh di atas bahwa matriks densitas untuk kasus ini adalah

$$\rho =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}.$$

Dengan menerapkan channel relaksasi energi menggunakan matriks Kraus, kita memperoleh matriks densitas baru yang telah dipetakan:

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^{\dagger} + A_1 \rho A_1^{\dagger}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}+\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\\ & = \frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix} \end{aligned}$$

Mari kita periksa hal ini dan bandingkan dengan intuisi kita:

Pertama, mari kita periksa limit saat $t$ mendekati nol. Kita memperoleh kembali matriks densitas awal kita, seperti seharusnya:

$$\Phi(\rho,t \rightarrow 0) = \lim_{p\rightarrow 0}{\frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix}} = {\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}}.$$

Seiring berjalannya waktu, kita akan berharap probabilitas mengukur keadaan $|0\rangle$ meningkat, dan probabilitas mengukur $|1\rangle$ menurun. Ini sekali lagi persis seperti yang kita lihat, karena

$$\begin{aligned} P_{|0\rangle} & = \langle 0 | \rho |0\rangle = \frac{1}{2}(1+p) = 1-\frac{1}{2}e^{-t/T_1}\\ P_{|1\rangle} & = \langle 1 | \rho |1\rangle = \frac{1}{2}(1-p) = \frac{1}{2}e^{-t/T_1} \end{aligned}$$

Kita juga dapat dengan mudah melihat bahwa probabilitas mengukur $|0\rangle$ dan $|1\rangle$ berjumlah 1, seperti seharusnya.

Penskalaan pasti dari suku-suku koherensi (off-diagonal) berada di luar cakupan pembahasan ini. Namun yang jelas adalah bahwa kita awalnya memiliki informasi fase yang sempurna, dan setelah waktu yang sangat lama tidak akan ada informasi fase sama sekali karena sistem telah sepenuhnya relaks ke keadaan $|0\rangle$. Oleh karena itu, suku-suku koherensi harus meluruh menjadi nol pada waktu yang sangat lama. Memang benar,

$$\lim_{p\rightarrow 1}{\sqrt{1-p}} = \lim_{t\rightarrow \infty}{\sqrt{e^{-t/T_1}}} = 0$$

Banyak batasan pada matriks Kraus kita secara implisit telah diperiksa melalui pertimbangan intuitif ini. Seseorang seharusnya memeriksa secara ketat bahwa batasan pada channel (dan pada matriks Kraus secara khusus) terpenuhi, tetapi kita serahkan hal itu sebagai latihan bagi pembaca.

Secara grafis, jenis channel ini dapat direpresentasikan menggunakan bola Bloch. Keadaan murni terletak pada permukaan bola Bloch. Keadaan campuran (mixed states) bergeser ke bagian dalam bola dan menyebar menjauh dari satu titik tunggal. Keterlibatan probabilitas klasik terlihat melalui berkurangnya jarak absolut dari titik asal ke salah satu keadaan dalam campuran tersebut, dan penyebaran dari satu titik menjadi suatu wilayah menunjukkan pencampuran beberapa kemungkinan keadaan. Dalam kasus khusus channel relaksasi energi, keadaan campuran (matriks densitas) setelah waktu yang tidak dapat diabaikan akan terlihat seperti gambar di bawah ini: sebuah wilayah di bagian dalam bola Bloch, bergeser ke atas menuju kutub $|0\rangle$, dan menyusut baik sepanjang sumbu $Z$, maupun sepanjang bidang $XY$, meskipun pada tingkat yang lebih kecil dibandingkan sepanjang $Z$.

Perhatikan bahwa wilayah tersebut bukanlah suatu "tutup" (cap) pada bola Bloch, seperti yang terkadang tampak dalam rendering perspektif. Seperti yang dapat dilihat dengan jelas pada video, bentuknya adalah spheroid oblate (bola pepat), yang menyusut dan bergeser menuju keadaan $|0\rangle$. Channel noise (dan channel secara umum) tentu saja berlaku untuk sistem dengan ukuran berapa pun. Namun merepresentasikannya secara visual (seperti dengan bola Bloch) menjadi sulit seiring bertambahnya jumlah keadaan yang saling ortogonal dalam ruang Hilbert.

Uji pemahaman Anda

Verifikasi bahwa matriks Kraus yang digunakan dalam channel relaksasi energi di atas memenuhi kondisi identitas:

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

Jawaban

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

Kita akan menyajikan dua jenis channel noise tidak koheren lagi, tetapi kita akan menyerahkan sebagian besar interpretasi dan verifikasinya sebagai latihan. Berikutnya adalah channel dephasing, yang mendeskripsikan hilangnya informasi fase, tetapi dengan tetap terjaganya amplitudo. Meskipun probabilitas klasik dan mekanika kuantum masih dapat terlibat dalam probabilitas pengukuran secara keseluruhan, hilangnya informasi fase sering dideskripsikan sebagai hilangnya informasi kuantum, atau sebagai sistem yang menjadi lebih klasik.

Dengan cara yang sama seperti relaksasi energi dideskripsikan dengan waktu karakteristik $T_1$, error dephasing dideskripsikan oleh parameter waktu kedua $T_2$. Probabilitas error dephasing setelah waktu $t$ diberikan oleh

$$p = 1-e^{-t/T_2}$$

Sekumpulan matriks Kraus untuk channel dephasing pada satu qubit, dalam bentuk probabilitas ini, adalah sebagai berikut:

$$\begin{aligned} A_0 & = \sqrt{1-p}\mathbb{I}\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}Z\\ & = \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\\ \end{aligned}$$

Hasil dari channel dephasing ini divisualisasikan menggunakan bola Bloch pada gambar di bawah ini.

Perhatikan bahwa amplitudo tidak berubah, sehingga keadaan mana pun yang berada tepat pada kutub ($|0\rangle$ atau $|1\rangle$) tidak terpengaruh dan tetap dipetakan ke permukaan bola pada wilayah yang diarsir. Namun informasi fase hilang, yang berkorespondensi dengan penyusutan wilayah yang diarsir di sepanjang bidang $XY$. Salah satu cara untuk memahami hal ini adalah: quantum state apa pun yang mungkin masih dapat memiliki fase yang terdefinisi dengan baik, tetapi karena ada probabilitas klasik untuk menemukan beberapa keadaan dengan fase terdefinisi dengan baik yang berbeda-beda, probabilitas keseluruhan untuk satu fase terdefinisi dengan baik tertentu berkurang.

Uji pemahaman Anda

Verifikasi bahwa matriks Kraus yang didefinisikan di atas untuk channel dephasing memenuhi kondisi identitas:

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

Jawaban

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \begin{pmatrix} 1-p & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} p & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

Mulailah dengan keadaan murni satu qubit pilihan kamu, dengan fase yang terdefinisi dengan baik antara $|0\rangle$ dan $|1\rangle$. Tuliskan sebagai matriks densitas. Terapkan channel dephasing menggunakan operator Kraus yang disarankan di atas. Interpretasikan matriks densitas hasil yang telah dipetakan.

Jawaban

Mari kita pilih keadaan $|\psi\rangle = \frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle$. Matriks densitas $\rho$ yang berkorespondensi adalah

$$\begin{aligned} \rho & = \sum_i p_i |\psi_i\rangle\langle\psi_i|\\ & = 1\left(\frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle\right) \left( \frac{4}{5}|0\langle +i\frac{3}{5} |1\langle\right)\\ & = \frac{16}{25}\begin{pmatrix} 1 & 0 \\ 0 & 0\end{pmatrix}+\frac{12i}{25}\begin{pmatrix} 0 & 1 \\ 0 & 0\end{pmatrix}-\frac{12i}{25}\begin{pmatrix} 0 & 0 \\ 1 & 0\end{pmatrix}+\frac{9}{25}\begin{pmatrix} 0 & 0 \\ 0 & 1\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \end{aligned}$$

Sekarang kita menerapkan channel dephasing pada matriks densitas ini menggunakan operator Kraus.

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^\dagger + A_1 \rho A_1^\dagger\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16(1-p) & 12i(1-p) \\ -12i(1-p) & 9(1-p)\end{pmatrix} + \frac{1}{25}\begin{pmatrix} 16p & -12ip \\ 12ip & 9p\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i(1-2p) \\ -12i(1-2p) & 9\end{pmatrix} \end{aligned}$$

Pertama, kita perhatikan bahwa jumlah elemen diagonal memang sama dengan satu, seperti yang seharusnya. Kedua, perhatikan bahwa elemen off-diagonal awalnya besar, dengan jumlah 24/25, yang menunjukkan koherensi yang kuat. Perhatikan bahwa seiring meningkatnya probabilitas error dephasing $p$, elemen-elemen off-diagonal ini menurun. Hal ini juga sesuai dengan ekspektasi kita. Satu kehalusan: perhatikan apa yang terjadi saat $p\rightarrow 1$. Koherensi kembali menjadi kuat! Hal ini pada awalnya tampak berlawanan dengan intuisi, karena probabilitas tinggi terjadinya error dephasing seharusnya mengacaukan fase kita, bukan? Kuncinya adalah jika kita 100% yakin bahwa error fase terjadi, maka kita kembali memiliki informasi yang kuat tentang fase tersebut; fase tersebut hanya terbalik. Dengan pemahaman ini, kita mungkin mengharapkan informasi fase terburuk berkorespondensi dengan peluang 50-50 terjadinya error fase, dan itu memang yang kita temukan.

Contoh terakhir kita dari channel noise yang mendeskripsikan error tidak koheren adalah channel noise Pauli. Channel ini mendeskripsikan terjadinya tiga jenis error dengan probabilitas independen:

• Error bit-flip (error X) dengan probabilitas $p_x$
• Error phase-flip (error Z) dengan probabilitas $p_z$
• Kombinasi X dan Z (error Y) dengan probabilitas $p_y$ Di sini, $0\leq p_j \leq 1$ untuk semua $j$. Sebagai akibatnya, probabilitas tidak terjadinya error adalah $p_I = 1-p_x-p_y-p_z$.

Operator Kraus untuk channel ini adalah:

$$\begin{aligned} A_0 & = \sqrt{p_I}I\\ A_1 & = \sqrt{p_X}X\\ A_2 & = \sqrt{p_Y}Y\\ A_3 & = \sqrt{p_Z}Z \end{aligned}$$

Dalam kasus channel noise Pauli, ada baiknya kita menuliskan channel itu sendiri:

$$\Phi(\rho) = p_I I\rho I + p_X X\rho X+p_Y Y \rho Y + p_Z Z \rho Z$$

Kita melihat dari bentuk ini bahwa channel noise Pauli menerapkan satu atau lebih error yang berkorespondensi dengan aksi matriks Pauli $P_j$, masing-masing dengan probabilitas $p_j$.

Berbagai kombinasi probabilitas flip akan menghasilkan visualisasi yang berbeda. Di sini kita memvisualisasikan kasus khusus di mana $p_X = p_Y = p_Z$, yang juga disebut channel depolarizing.

Memodelkan error koheren

Quantum channel dapat merepresentasikan baik error koheren maupun tidak koheren, tetapi dalam praktiknya channel tersebut terutama digunakan untuk error tidak koheren karena error koheren lebih baik dimodelkan sebagai miskalibrasi uniter atau diubah menjadi channel stokastik agar lebih mudah dianalisis. Pada bagian ini kita akan memperkenalkan pendekatan yang lebih cocok untuk error koheren.

Error koheren dapat dimodelkan dengan gate uniter yang tidak diinginkan. Beberapa contoh sederhana meliputi rotasi yang tidak sejajar (misaligned) atau rotasi kurang/lebih (under-/over-rotation). Pada gambar di bawah ini, kita menunjukkan rotasi yang tidak sejajar sebagai rotasi $Y$ tambahan sebesar $\epsilon$ yang kecil, selain rotasi $X$ yang diinginkan di sekitar sumbu $X$. Over-rotation dideskripsikan oleh rotasi $X$ yang diinginkan ditambah dengan sejumlah rotasi tambahan di sekitar sumbu yang sama $X_\epsilon$.

Error dua-qubit dan light cone yang diarsir

Gate satu-qubit merotasi qubit yang terisolasi. Gate dua-qubit menerapkan logika yang bergantung pada dua qubit, tetapi tidak dapat melakukan pengukuran langsung pada salah satu qubit; oleh karena itu, gate tersebut harus mengaktifkan suatu interaksi antar-qubit. Interaksi ini adalah alasan mengapa kita dapat membangun entanglement, dan ini juga sumber dari banyak noise, crosstalk, dan kesulitan kalibrasi. Interaksi antar-qubit ini juga memungkinkan error untuk menyebar. Jika satu qubit memiliki suatu error, dan qubit tersebut berfungsi sebagai qubit kontrol untuk qubit target lainnya, error tersebut dapat diteruskan ke target. Dalam pelajaran ini kita akan meninjau apa arti gate dua-qubit bagi laju error dan penyebarannya dalam suatu circuit.

Gate echoed cross-resonance

Arsitektur hardware dan keluarga gate yang berbeda merekayasa interaksi tersebut dengan cara yang berbeda-beda. Komputer kuantum IBM menerapkan gate dua-qubit abstrak seperti gate CZ atau CX menggunakan gate echoed cross-resonance (ECR) yang native terhadap hardware. Gate ECR menghasilkan interaksi $ZX$ efektif menggunakan drive microwave. Gate terkait seperti CNOT dibangun dari $ZX$ dengan menambahkan rotasi satu-qubit.

Qubit yang berbeda memiliki frekuensi resonansi yang berbeda-beda (frekuensi yang membuat mereka bereaksi kuat). Operasi standar mungkin menggunakan frekuensi resonansi tersebut untuk menginduksi transisi pada suatu qubit. Namun apa yang terjadi jika kamu men-drive qubit C pada frekuensi resonansi qubit T yang berdekatan? Qubit-qubit yang berdekatan dihubungkan oleh interaksi kapasitif tetap atau interaksi yang dimediasi resonator. Karena coupling ini, drive pada qubit C “bocor” ke dalam Hamiltonian qubit T. Kekuatan dan arah drive efektif ini bergantung pada keadaan qubit C ($|0\rangle$ atau $|1\rangle$). Di sini, qubit C adalah kontrol dan qubit T adalah target.

Hasilnya adalah rotasi qubit target efektif yang bersyarat pada keadaan qubit kontrol. Secara matematis:

$$H_{eff} \approx \Omega Z_C X_T +\text{suku lain}$$

Interaksi ZX ini adalah persis apa yang kamu butuhkan untuk membangun sebuah CNOT. Namun suku-suku lain mungkin mengandung beberapa error, dan hampir pasti mencakup coupling kapasitif antara qubit C dan T, yang berkorespondensi dengan suku ZZ.

$$H_\mathrm{CR} = \underbrace{\Omega \, Z_C X_T}_{\text{desired}} + \underbrace{\alpha\, I_C X_T + \beta\, Z_C I_T + \gamma\, I_C Z_T + \delta\, Z_C Z_T + \dots}_{\text{undesired}}.$$

Kita dapat memikirkan suku-suku tambahan ini dengan cara berikut:

• IX = target di-drive secara tidak sengaja

• ZI = qubit kontrol memperoleh rotasi Z yang tidak diinginkan

• IZ = qubit target memperoleh rotasi Z yang tidak diinginkan

• ZZ = pergeseran fase statis yang bergantung pada keadaan

• lainnya = interaksi kecil XY, XX, orde lebih tinggi

Gate ECR sederhananya adalah rotasi bersyarat ditambah pulsa echo yang dipilih dengan cermat pada qubit kontrol. Echo tersebut membalik tanda dari banyak suku yang tidak diinginkan sambil mempertahankan interaksi ZX. Proses ini membatalkan error IX dan ZI dengan cukup baik, dan terkadang beberapa suku orde lebih tinggi. Namun echoing tidak dapat membatalkan coupling ZZ yang statis karena coupling tersebut komut dengan pulsa echo. Ada interaksi lain yang tidak akan terbatalkan dalam proses ini: beberapa nonlinearitas residual dan efek qubit spectator, leakage dan kontaminasi drive jarak jauh, ditambah beberapa lainnya — tetapi suku ZZ sangat penting.

Proses ini sering memerlukan waktu drive yang satu orde magnitudo lebih lama dibandingkan gate satu-qubit. Kombinasi dari waktu drive yang lebih lama, suku ZZ yang persisten dalam Hamiltonian, dan ketidaksempurnaan dalam coupling membuat gate dua-qubit menjadi sumber dominan dari error gate. Perhatikan juga bahwa jika seseorang memerlukan interaksi dalam suatu circuit antara qubit yang tidak berdekatan, gate SWAP yang diperlukan juga jelas merupakan gate dua-qubit. Inilah sebabnya mengapa metrik terkait depth yang standar adalah: depth dua-qubit yang telah ditranspilasi (transpiled). Kita terutama peduli dengan gate dua-qubit karena gate tersebut mendominasi error gate, dan kita perlu melihat circuit yang telah ditranspilasi karena transpilasi sering memperkenalkan banyak gate dua-qubit tambahan dalam bentuk gate SWAP.

Uji pemahaman Anda

Jelaskan mengapa kita terutama peduli dengan depth dua-qubit yang telah ditranspilasi. Pastikan untuk mempertimbangkan batasan hardware, dan fakta bahwa depth gate satu-qubit mungkin jauh lebih besar.

Jawaban

Gate dua-qubit memiliki laju error yang jauh lebih tinggi dibandingkan gate satu-qubit. Gate satu-qubit tidaklah sempurna, sehingga ada kasus-kasus di mana mempertimbangkan depth satu-qubit juga berguna. Namun depth gate dua-qubit cenderung mendominasi perilaku error suatu circuit. Kita harus mempertimbangkan circuit yang telah ditranspilasi. Komputer kuantum modern tidak memiliki konektivitas qubit all-to-all. Komputer kuantum IBM menggunakan lattice persegi atau lattice "heavy hex", yang berarti qubit memiliki 2, 3, atau 4 tetangga terdekat yang dapat langsung digandengkan menggunakan satu gate dua-qubit. Entanglement apa pun dengan qubit lain yang tidak berdekatan memerlukan pemindahan informasi di sekitar komputer kuantum menggunakan gate SWAP dua-qubit. Oleh karena itu, transpilasi cenderung meningkatkan depth gate dua-qubit. Untuk circuit dengan entanglement yang tinggi, peningkatan ini bisa menjadi sangat besar.

Light cone yang diarsir

Anggaplah bahwa satu qubit terisolasi dengan baik dari semua qubit lain. Suatu error pada qubit tersebut tidak akan menyebabkan error apa pun pada qubit lain mana pun. Namun ketika suatu qubit berinteraksi dengan qubit lain, error dapat menjalar. Cara error menjalar bergantung pada cara qubit-qubit tersebut berinteraksi. Perhatikan circuit di bawah ini. Anggaplah bahwa qubit mana pun yang berdekatan dalam diagram circuit juga berdekatan pada chip kuantum (artinya, informasi tidak perlu ditukar (swap) ke qubit lain untuk memfasilitasi interaksi yang dideskripsikan).

Meskipun kamu mungkin belum memikirkannya dengan cara ini, ini adalah semacam diagram ruang-waktu (spacetime). Sumbu vertikal pada circuit kuantum merepresentasikan qubit yang berbeda-beda yang tersusun dalam ruang. Sumbu horizontal merepresentasikan waktu di mana suatu urutan gate diterapkan. Dengan meminjam istilah dari relativitas, sebuah light cone merepresentasikan wilayah ruang-waktu yang dapat dijangkau dari suatu titik melalui interaksi kausal.

Pada gambar di atas, jenis error belum ditentukan. Ternyata jenis error memengaruhi light cone karena beberapa error memengaruhi logika gate dua-qubit, sementara yang lain tidak. Kita akan kembali ke hal ini sebentar lagi. Untuk saat ini, anggaplah garis-garis kuning sebagai jalur potensi penyebaran suatu jenis error. Perhatikan, misalnya pada bagian (a) dari gambar, bahwa error satu-qubit pada gate RZ di qubit 4 hanya dapat menjalar maju dalam waktu pada satu qubit tersebut. Error tersebut tidak dapat menyebar ke qubit lain karena qubit 4 tidak ter-entangle dengan qubit lain mana pun. Ini adalah saat yang tepat untuk mencatat bahwa qubit 4 cukup tidak berguna dalam circuit ini, dan memang seluruh circuit dibangun hanya untuk tujuan pedagogis.

Namun, suatu error pada gate Z qubit 0 (tidak harus error-Z, hanya suatu error di lokasi tersebut) dapat menjalar ke qubit lain: qubit 1, melalui CNOT terakhir yang menggunakan qubit 0 sebagai kontrol dan qubit 1 sebagai target. Hal ini ditunjukkan pada bagian (b). Seperti yang mungkin kamu perkirakan, error yang lebih awal dalam circuit sering kali memiliki kesempatan untuk menjalar ke lebih banyak qubit. Bagian (c) menunjukkan bahwa error pada persiapan keadaan awal qubit 0 dapat menyebar ke semua qubit kecuali qubit 4, yang terisolasi.

Susunan ini menunjukkan bagaimana suatu error dapat menjalar maju dalam waktu untuk memengaruhi pengukuran. Namun Anda juga dapat memeriksa pertanyaan sebaliknya: untuk pengukuran satu-qubit tertentu, bagian mana dari circuit saya yang mungkin telah memberikan kontribusi error padanya? Dalam kasus itu, Anda cukup memulai dari pengukuran atau titik minat lainnya dan bekerja mundur (dalam waktu) melalui circuit, mengikuti circuit yang meng-entangle sebagaimana ditunjukkan pada bagian (d). Ditunjukkan juga beberapa titik yang dipilih secara acak untuk terjadinya error.

Pada gambar di atas, error menyebar antar-qubit melalui gate ECR, tetapi diskusi serupa dapat berlaku untuk gate dua-qubit lainnya. Gate-gate ini memiliki suatu kontrol dan suatu target. Jelas bahwa suatu error pada kontrol dapat memengaruhi logika gate dan dengan demikian dapat menghasilkan error pada target. Namun bagaimana dengan arah sebaliknya? Dapatkah suatu error pada target menjalar ke qubit kontrol? Ingat bahwa coupling antara kontrol dan target untuk gate ECR bukanlah murni jenis ZX yang ideal; coupling tersebut juga memiliki coupling ZZ yang tidak diinginkan.

Jika suatu error pada target komut dengan coupling ZZ, maka error tersebut tidak dapat menjalar ke qubit kontrol. Kita dapat melihat hal ini melalui mekanisme fisik yang bekerja. Cara cepat untuk melihatnya adalah bahwa jika suatu error $E$ komut dengan $ZZ$, maka urutan keduanya dapat ditukar tanpa memengaruhi hasil akhir. Namun, jika $E$ yang terjadi tepat sebelum coupling $ZZ$ sama dengan $E$ yang bekerja setelah coupling $ZZ$, maka error tersebut tidak dapat memengaruhi kontrol, karena dalam kasus yang terakhir, error tersebut harus bergerak mundur dalam waktu. Jika suatu error tidak komut dengan coupling ZZ, maka error tersebut memang mungkin menjalar dari target kembali ke kontrol. Dengan demikian, dalam kasus gate ECR, error Z tidak dapat menjalar dari target ke kontrol, tetapi error X atau Y dapat.

Uji pemahaman Anda

Pada bagian (d) dari gambar di atas, perhatikan garis-garis vertikal antara qubit 0 dan 1. Apakah benar bahwa beberapa error dapat menyebar melintasi garis-garis tersebut? Sekali lagi, hal ini dapat bergantung pada jenis error, dan kita belum membahasnya. Pertanyaannya adalah apakah ada error yang dapat menjalar seperti yang ditunjukkan oleh garis-garis vertikal tersebut. Jelaskan.

Jawaban

Ya, benar. Dalam menggambar light cone mundur dari pengukuran, mungkin terasa seperti Anda mengklaim bahwa sesuatu bergerak dari target ke kontrol. Namun, makna diagram tersebut sebenarnya adalah bahwa suatu error dapat bergerak dari kontrol (qubit 0) ke target (qubit 1) untuk menyebabkan suatu error pada titik yang diminati. Jika intuisi Anda mengatakan bahwa hal ini bergantung pada jenis error, Anda sepenuhnya benar. Hal ini dibahas sebagian pada bagian berikutnya.

Dimulai dengan versi bebas-error dari circuit-circuit dalam diagram di atas, telusuri potensi penyebaran suatu error pada gate Hadamard pertama yang bekerja pada qubit 2. Sebutkan semua qubit yang dapat terpengaruh pada akhir circuit jika error tersebut adalah (a) phase flip, dan (b) bit flip. Petunjuk: pikirkan bagaimana informasi pada setiap qubit digunakan.

Jawaban

(a) Qubit 3 dapat terpengaruh, begitu juga jelas qubit 2 itu sendiri. Tidak ada yang lain! Jika Anda menyebutkan qubit 0 dan 1, perhatikan bahwa qubit 2 adalah target dari ECR yang meng-entangle-nya dengan qubit 1. Tidak ada perubahan yang dilakukan pada qubit 1 dalam gate tersebut. (b) Qubit 0-3 dapat terpengaruh. Error bit flip atau jenis-X tidak komut dengan coupling ZZ dalam gate ECR dan dengan demikian dapat menjalar dari target ke kontrol.

Penjalaran error

Pada bagian sebelumnya kita membahas penjalaran error tanpa memberikan definisi formalnya. Mulai sekarang:

Untuk suatu error $E$ yang terjadi sebelum sebagian dari muatan logis (logical payload) suatu circuit $U$, penjalaran error berarti mencari operator ekuivalen $E'$ yang menghasilkan kembali hasil yang salah sama ketika diterapkan setelah $U$ alih-alih sebelumnya.

$$\boxed{ \text{An error } E \text{ propagates through a unitary } U \text{ as } E' = U E U^\dagger }$$ $$\boxed{ U\,E\,|\psi\rangle = E'\,U\,|\psi\rangle }$$

Gambaran penjalaran error pada bagian sebelumnya menunjukkan bahwa error dapat menyebar dari qubit kontrol ke qubit target melintasi gate CNOT. Salah satu cara untuk memeriksa kapan hal ini benar adalah dengan mempertimbangkan suatu error pada kontrol atau pada target sebelum entanglement, dan memeriksa apakah operator tersebut komut dengan gate CNOT. Jika kedua operator komut, maka tidak ada perbedaan jika Anda menerapkannya dalam urutan terbalik, artinya error tersebut cukup dapat "dilewatkan" melalui CNOT tanpa memiliki efek apa pun pada qubit lain. Ini adalah cara yang paling umum digunakan orang untuk mendekati penjalaran error, dan menghasilkan aturan-aturan berikut:

Misalkan kontrol adalah qubit 0 dan target adalah qubit 1. Perhatikan error X dan Z pada qubit kontrol dan target ($X_c$, $Z_c$, $X_t$, dan $Z_t$, masing-masing). Melewatkan error-error ini melalui $\text{CNOT}_{0\to1}$ menyebabkan error-error tersebut menjadi:

$$\begin{aligned} X_c &\to X_c X_t\\ Z_c &\to Z_c\\ X_t &\to X_t\\ Z_t &\to Z_c Z_t \end{aligned}$$

Kita menyatakan hal di atas tanpa bukti. Namun jika kamu seperti penulis lesson ini, dan lebih menyukai gambaran Schr"odinger (Schrödinger picture), kamu juga dapat menuliskan keadaan kontrol dan target sembarang, menerapkan error, kemudian CNOT, dan memeriksa keadaan akhir. Jika kamu membandingkan keadaan akhir tersebut dengan kasus bebas-error, kamu dapat melihat kombinasi error apa yang diterapkan setelah CNOT akan menghasilkan keadaan yang salah, dan secara khusus, kamu dapat melihat apakah operasi error tersebut telah menyebar dari satu qubit ke qubit lainnya.

Kontrol awal	Target awal	Error	Akhir	Ekuivalen error pasca-CNOT
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Tidak ada	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle +\beta\delta \vert 01\rangle$	Tidak berlaku
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X pada kontrol	$\alpha\gamma \vert 11\rangle+\alpha\delta \vert 01\rangle + \beta\gamma \vert 10\rangle +\beta\delta \vert 00\rangle$	$X_c X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z pada kontrol	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle - \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X pada target	$\alpha\gamma \vert 10\rangle+\alpha\delta \vert 00\rangle + \beta\gamma \vert 01\rangle +\beta\delta \vert 11\rangle$	$X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z pada target	$\alpha\gamma \vert 00\rangle-\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c Z_t$

Mungkin mengejutkan, suatu error Z pada target memang menyebabkan suatu error dijalarkan kembali ke kontrol!

Seperti yang dapat Anda bayangkan, melacak penjalaran operator error semacam itu maju melalui circuit (atau secara ekuivalen, menjalarkan mundur operator yang akan diukur) adalah rumit. Qiskit memiliki alat untuk memfasilitasi hal ini, yang akan kita pelajari pada pelajaran 6 tentang alur kerja modern.

Ada sebuah addon Qiskit bernama Shaded Lightcones. Addon shaded lightcones (SLC) ini menganalisis penjalaran error dalam circuit kuantum dengan menggunakan penjalaran Pauli untuk mengidentifikasi bagian mana dari suatu circuit yang benar-benar dapat memengaruhi suatu observable target. Addon ini dirancang terutama untuk membuat mitigasi error lebih efisien, khususnya untuk alur kerja probabilistic error cancellation (PEC). Kita hanya akan mengeksplorasi alat ini secara singkat di sini, dan menggunakannya lebih luas dalam konteks teknik mitigasi error pada lesson-lesson mendatang. Addon ini menggunakan penjalaran operator Pauli untuk memetakan penjalaran error dari berbagai jenis, menghasilkan light cone untuk error jenis X, Y, dan Z.

Shaded lightcones (SLC) melangkah lebih jauh, menggunakan simulasi klasik untuk membatasi sensitivitas terhadap error di seluruh circuit dengan lebih ketat. Ini menukar sedikit waktu QPU dengan waktu CPU dan mengurangi overhead sampling yang diperlukan untuk merenormalisasi bias. Alih-alih menggunakan batas keras, setiap potensi error dalam circuit diberi "shade" bertingkat yang membatasi atas kerentanan observable terhadap error tersebut. Karakterisasi yang lebih halus ini memungkinkan penerapan PEC yang lebih efisien dan tertarget dengan varians yang berkurang, sekaligus memberi pengguna kemampuan untuk mengatur bias dalam estimasi observable secara terkendali. Lihat Lightcone shading for classically accelerated quantum error mitigation untuk detail lebih lanjut.

Kita tidak akan menyajikan alur kerja lengkap di sini. Kita hanya menunjukkan secara diagram, bagaimana alur kerja ini mengambil sebuah circuit:

Alur kerja ini memisahkan circuit menjadi "boxes" yang berguna untuk mempelajari perilaku noise:

Terakhir, alur kerja ini menggunakan operator propagation dan noise learning untuk menghasilkan peta shaded kerentanan error di seluruh circuit:

Setiap kotak berwarna dalam output sesuai dengan qubit tertentu pada waktu tertentu. Kotak paling gelap (ungu) menunjukkan qubit dan layer di mana error tidak dapat merambat ke pengukuran yang diminati. Kotak paling terang (kuning) sesuai dengan qubit dan layer di mana error dapat memiliki pengaruh kuat terhadap pengukuran yang diminati.

Perhatikan area ungu di sebelah kanan setiap peta. Error pada layer yang sama dengan pengukuran, tetapi pada qubit yang berbeda, tidak dapat memengaruhi pengukuran melalui konektivitas circuit yang ditunjukkan. Demikian pula, error satu layer ke belakang dalam waktu (satu layer ke kiri) hanya dapat menjalar ke qubit yang berdekatan pada langkah berikutnya, karena struktur entangling layer, dan seterusnya. Jadi bentuk kerucut di sebelah kanan bersifat umum kapan pun relatif sedikit qubit yang terlibat dalam pengukuran yang diminati.

Uji pemahaman Anda

Menurut Anda, apakah lebih baik membuat peta shaded lightcone sebelum atau sesudah transpilasi? Mengapa?

Jawaban

Ini harus dilakukan setelah transpilasi. Agar peta-peta yang berbeda ini berguna, kita harus memastikan bahwa qubit yang berdekatan dalam circuit kita sesuai dengan qubit yang berdekatan pada chip kuantum kita. Jika tidak, gate entangling yang ditunjukkan bekerja pada qubit yang berdekatan dalam diagram circuit akan berakhir membutuhkan gate SWAP dan struktur circuit yang lebih rumit.