Noise at Errors

Ipapakilala ng lesson na ito ang quantum noise at errors, kabilang ang marami sa kanilang mga pinagmumulan, at paghahambing sa classical errors. Ang pag-unawa sa mga uri ng errors na maaaring mangyari, at ang kakayahang i-model ang noise gamit ang quantum channels, ay magiging mahalaga sa pag-unawa sa mga susunod na lesson. Sa katunayan, karamihan sa mga method ng error handling ay nangangailangan na alam natin ang kaunting bagay tungkol sa uri ng noise o errors na gusto nating bawasan o itama.

Nagbibigay ang video na ito ng pangkalahatang-ideya ng noise at errors at binabanggit ang ilang computational result. Ang teksto sa ibaba ay nagdaragdag ng mas maraming detalye at sinisiyasat ang ilang uri ng errors gamit ang Qiskit.

Mga Sanhi

Classical Noise at Errors

Upang maunawaan ang quantum errors at noise, magsimula tayo sa classical analog. Nagaganap ang mga error sa classical computers dahil sa iba't ibang dahilan, kabilang ang maraming mekanismo ng spurious charge accumulation, single-event upsets, at mabagal na material degradation. Ang ilan sa mga mekanismong ito (hindi lahat) ay may analog sa quantum computing at magiging mahalaga sa pag-unawa sa quantum errors at noise. Maikling suriin natin ang ilan sa mga ito at pagkatapos ay tumuloy sa quantum analogs.

Ingay na thermal:

Habang umiinit ang mga bahagi ng isang computer, binabago ng thermal motion ng mga atom at charge carrier ang resistivity ng material (kadalasang tumataas ito). Nangangahulugan ito na maaaring magbago-bago ang resistance sa circuit. Bagaman bihira, maaari itong magresulta sa isang spurious logic transition sa isang transistor. Bagaman hindi maiiwasan ang maliliit na pagbabago, ang tamang cooling ng mga bahagi ay susi sa pag-iwas sa mga epektong ito.

Thermal Damage at Degradation:

Ang paulit-ulit na pag-init at paglamig ng mga material ay maaaring magdulot ng napakabagal na paglipat ng mga conductive elements (metal). Sa pinakamainam na senaryo, binabago nito ang resistance o capacitance (o pareho) ng mga circuit elements at nagreresulta sa hindi tumpak na timing sa operasyon ng circuit. Sa pinakamasamang senaryo, nagreresulta ito sa isang short-circuit o hard fault. Muli, ang tamang temperature control ay susi sa pag-iwas sa ganitong uri ng degradation.

Mga Epektong Dulot ng Radiation (single-event upsets, SEUs):

Minsan, ang mga high-energy particle ay maaaring mag-ionize ng mga atom sa loob ng isang processor at humantong sa isang spurious charge. Kung mangyayari ito sa maling lugar at maling oras, maaari itong humantong sa mga logical error. Ang pinagmumulan ng mga high-energy particle na ito (kabilang ang electromagnetic radiation at neutrons) ay karaniwang mga high-energy interaction sa upper atmosphere. Kaya mas karaniwan ang mga upset na ito sa mga high-altitude na kapaligiran, kabilang ang outer space. Tinutugunan ang mga ito gamit ang error-correcting codes at radiation-hard design.

Electromagnetic Interference:

Ang mga error ay maaari ring dulot ng external electromagnetic (EM) fields mula sa switching power lines, radio transmitter, o iba pang system component. Ito ay iba sa high-energy radiation sa naunang phenomenon. Dito, ang stray time-dependent EM fields ay naghihimok ng current at voltage sa buong computing components (kumpara sa pag-ionize ng isang partikular na atom sa isang pangyayari). Dahil ang time-dependence ng fields ay isang determinant na factor sa induced voltages, ang ganitong uri ng interference ay lalong mahalaga sa high-frequency systems. Ang mga error na ito ay maaaring labanan sa pamamagitan ng shielding at grounding, bukod sa iba pang bagay.

Crosstalk sa Pagitan ng mga Interconnect:

Ang capacitive o inductive coupling sa pagitan ng magkalapit na conductor, lalo na sa nanoscale integrated circuits, ay maaaring humantong sa mga spurious signal. Ito ay may kaugnayan sa electromagnetic interference, ngunit iba ito dahil ang pinagmumulan ng nagkakasalang field ay isa pang component sa loob ng computer circuit. Isipin ang dalawang wire na napakalapit sa isa't isa. Kung ang wire A ay nakaranas ng biglaang transition (pagbabago sa voltage) maaari itong maghimok ng currents sa katabing wire B. Ang eksaktong direksyon at magnitude ay depende sa circuit layout; maaari itong isang coherent na net flow ng charge o isang bagay na mas malapit sa eddy currents ng charge. Ngunit sa ilang kaso, maaari itong humantong sa hindi kanais-nais na logical transitions. Ang mga epekto ng crosstalk na ito ay maaaring mapagaan sa pamamagitan ng optimal layout spacing, shielding, at controlled signal rise times.

Hindi ito isang kumpletong listahan, ngunit sapat na ito para simulan nating makita ang mga pagkakatulad sa quantum computing. Pansinin na sa lahat ng uri ng hindi kanais-nais na interaksyon sa itaas, ang pagpapakita ng noise bilang logical error ay maaari lamang magkaroon ng anyo ng isang 0 na naging 1, o isang 1 na naging 0. Ito lang ang pinapahintulutan sa state space ng classical bits.

Quantum Noise at Errors

Sa quantum computing, ang noise at errors ay kadalasang tinatalakay nang magkasabay, ngunit mahalagang makilala ang pagkakaiba. Ang quantum noise ay tumutukoy sa pangunahing physical disturbance na nakakaapekto sa qubits at quantum systems. Kasama rito ang lahat ng anyo ng hindi kanais-nais na interaksyon o fluctuation mula sa kapaligiran, imperfect na controls, o hardware defects na nagiging sanhi ng paglihis ng quantum state mula sa ideal. Ang quantum errors ay ang mga tiyak na deviation o fault sa quantum information na resulta ng quantum noise. Ang quantum errors ay ang measurable o operational na mga manipestasyon ng noise, at kabilang sa errors ang bit-flips, phase-flips, amplitude damping, at iba pa. Ang noise at errors ay pareho maaaring mangyari sa tuloy-tuloy na paraan. Halimbawa, ang field na ginagamit sa isang quantum gate ay maaaring magkamali ng 0.1%, 0.15%, o anumang ibang fraction. Maaari itong magresulta sa isang maling phase sa isang qubit, na maaari ring magkaiba ng anumang tuloy-tuloy na halaga. Ngunit makikita mo na, sa praktika at lalo na sa error correction, karaniwan nang tinatrato ang errors na para bang discrete: pinagsasama-sama ang mga naipong epekto sa isang discrete bit flip o iisang phase rotation. Kapaki-pakinabang ito para sa pagwawasto ng errors at pag-characterize sa kanila, ngunit hindi ito nangangahulugan na ang epekto ng noise sa isang qubit ay isang discrete set lamang ng errors.

Maraming uri ng noise ang nakakaapekto sa quantum computers. Ang ilan ay maaaring magresulta sa maraming uri ng errors, habang ang iba ay may kaakibat na tiyak na error manifestations. Ang kumpletong listahan ay lampas sa layunin ng lesson na ito; narito ang isang partial na listahan na may kaugnayan sa natitirang bahagi ng kursong ito, ang ilan ay may pagkakatulad sa classical computing noise.

Thermal:

Ang dalawang computational basis states na $|0\rangle$ at $|1\rangle$ ng isang qubit ay pinaghihiwalay ng napakaliit na halaga ng energy. Ang eksaktong halaga ay depende, siyempre, sa quantum hardware. Para sa solid-state (fixed-frequency transmon) na qubits tulad ng ginagamit ng IBM Quantum®, ang energy gap sa pagitan ng mga states na ito ay nasa order ng $10^{-24}$ J, o ilang microelectron volts. Ang energy scale na ito ay maaaring iugnay sa frequency sa pamamagitan ng $E=hf$ o sa isang characteristic temperature. Dahil ang temperature ay may kaugnayan sa average kinetic energy ng mga particle sa isang sample, maaari nating gamitin ang Boltzmann constant upang makakuha ng estimate ng temperature kung saan ang average na mga particle ay magkakaroon ng sapat na energy upang magdulot ng transition:

$$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}.$$

Upang bawasan ang tsansang magdulot ang thermal interactions ng transitions mula sa isang qubit computational basis state patungo sa isa pa, ang temperature ng mga qubit ay dapat panatilihing malayo sa ibaba ng 100 mK, mainam kung mas malapit sa 15-25 mK. Ang anumang malaking pagtaas ng temperature nang higit sa mga threshold na ito ay magreresulta sa ganap na random na state occupation at kumpletong pagkawala ng quantum information.

Ito ay katulad ng thermal errors na maaaring mangyari sa classical computers, dahil pareho silang thermal ang pinagmulan — ngunit malinaw na iba ang temperature scale, at gayundin ang mechanism para sa pagkawala ng information.

Crosstalk at Interference:

Ang crosstalk sa quantum computing ay tumutukoy sa anumang hindi kanais-nais na coupling o interference sa pagitan ng mga qubit o control lines kung saan ang isang operation o signal na nilaan para sa isang qubit ay hindi sinasadyang nakakaapekto sa iba. Ipinapakita ito bilang mga error o correlation sa pagitan ng mga qubit na dapat sana ay independent.

Sa superconducting qubit architectures tulad ng ginagamit ng IBM®, ang crosstalk ay maaaring bumangon mula sa pagtagas ng microwave control signals patungo sa mga karatig na qubit, hindi sinasadyang coupling sa pagitan ng readout resonators, o flux crosstalk sa pagitan ng qubit loops.

Marami sa mga approach para mabawasan ang crosstalk ay isinasama sa disenyo ng isang quantum computer, tulad ng spacing ng mga qubit at pagtiyak na ang magkatabing qubit ay may magkaibang operational frequencies. May mga software approach din para sa pagpapagaan ng crosstalk errors, na tatalakayin sa mga susunod na lesson.

Mga Imperfect na Gate Operation:

Ang mga operation sa mga qubit ay isinasagawa gamit ang hardware na may finite precision at maaaring maapektuhan ng noise o iba pang pinagmumulan ng inaccuracy. Partikular, ang mga microwave pulse na may tiyak na durasyon at may tiyak na orientation ay ginagamit upang ipatupad ang rotation gates. Halimbawa, sabihin nating ang isang microwave pulse ay iikot ng 0.30 radians sa paligid ng $X$ axis. May finite precision sa orientation, na nagreresulta sa kaunting imprecision sa axis ng rotation. Bukod dito, palaging may fundamental na tradeoff sa pagitan ng pulse frequency at ng durasyon nito. Ang isang napakahabang pulse ay maaaring magkaroon ng sinusoidal na kilos na may halos iisang frequency. Upang makabuo ng maikling packet, kailangan ng superposition ng maraming frequencies. Ito ang parehong tradeoff na nasa ugat ng energy-time uncertainty relation, bagaman hindi pa itinutulak ng gate precision ang mga fundamental limit na ito; may puwang pa para sa pagpapabuti.

Quantum-Inherent na Noise:

Ang huling uri ng noise na ito ay ibang-iba sa iba; hindi ito dulot ng errors, kundi dulot ng likas na katangian ng quantum mechanics. Ipagpalagay na ang isang qubit sa quantum state na $|\psi\rangle$ ay sinusukat at bumabagsak (collapse) sa isang eigenstate ($|0\rangle$ o $|1\rangle$). Sa isang fixed-frequency transmon system, ang qubit ay dispersively coupled sa isang microwave resonator na ang resonance frequency ay bahagyang nakadepende sa qubit state. Ang isang microwave probe pulse ay ipinapadala sa resonator, at ang papalabas na signal ay nakakakuha ng state-dependent na phase shift at pagbabago sa amplitude. Ang signal na ito ay pagkatapos ay ina-amplify at sinusukat gamit ang classical electronics.

Sa antas ng quantum, ang measurement signal ay dala ng isang coherent microwave field na may finite na average na bilang ng photons. Dahil sa quantum nature ng electromagnetic fields, ang field quadratures ay nagpapakita ng intrinsic na fluctuations. Ang mga fluctuations na ito ay independiyente sa technical imperfections at lumilitaw kahit para sa isang ideal na coherent state. Ang pagtaas ng average na photon number na $N$ ay nagpapataas ng measurement signal, ngunit ang fundamental noise level ay nananatiling finite, kaya ang distinguishability sa pagitan ng mga outcome ay bumubuti lamang bilang $\sqrt{N}$​.

Kaya, kahit na ang qubit ay perpektong inihanda at ang measurement chain ay ideal, ang readout signal na katugma sa isang ibinigay na qubit state ay hindi isang solong fixed value kundi isang distribution na naglilimita kung gaano kagaling ma-distinguish ang mga outcome. Ang overlap na ito ay kumakatawan sa isang fundamental na pinagmumulan ng uncertainty sa mismong measurement process. Sa praktika, habang ang technical noise mula sa amplifiers at iba pang components ay kadalasang nangingibabaw, ang intrinsic na quantum noise na ito ay nagtatakda ng lower bound sa readout fidelity.

Ang Uncertainty ay Hindi Error:

Ang mga pinagmumulang ito ng noise ay lahat ay iba sa fundamental uncertainty na kaugnay ng measurements ng quantum states. Bilang kontrast, ipagpalagay na mayroon tayong isang qubit sa isang quantum state:

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

Ang state na ito ay may 64% na tsansang masukat sa $|0\rangle$ state at 36% na tsansang masukat sa $|1\rangle$ state. Ngunit ang isang solong measurement ay magbibigay lamang ng $|0\rangle$ o $|1\rangle$ — kaya ang isang solong measurement ay bihirang magsabi sa atin ng marami tungkol sa state bago ang measurement. Kailangan ng maraming measurement upang makakuha ng detalyadong impormasyon tungkol sa state. Sa sampung measurement, maaari nating asahan na anim o pito ang magbibigay ng $|0\rangle$. Ngunit hindi magiging nakakagulat kung ang unang sampung measurement ay lahat nagkataong nagbigay ng $|0\rangle$ (tulad ng pagtapon ng isang patas na barya at pagkuha ng "heads" ng sampung beses nang sunud-sunod: hindi karaniwan, ngunit ganap na posible). Kung uulitin natin ang measurement ng 1000 beses at palaging nakukuha ang $|0\rangle$, iyon nga ay magiging nakakagulat.

Kaya may uncertainty sa ating kaalaman tungkol sa quantum state batay sa anumang finite na bilang ng measurements. Habang inuulit natin ang mga measurement, bumubuti ang ating kaalaman tungkol sa quantum state bago ang measurement, ngunit hindi ito kailanman perpekto. Maaaring sabihin ng iba nang kolokyal na palaging may ilang nakabaon na "error" sa anumang resulta ng quantum measurement. Ngunit ito ay ibang paggamit ng terminong "error" at mas tamang ilarawan ito bilang statistical uncertainty. Ang proseso ng pagpapataas ng kaalaman tungkol sa isang quantum state sa pamamagitan ng maraming measurement ay tinatawag na quantum state tomography. Gayunpaman, ang quantum state tomography ay hindi limitado sa mga measurement sa Z; sa pangkalahatan, tumutukoy ito sa mga measurement sa mga orthogonal axes (tulad ng X, Y, at Z) para sa pagtukoy ng amplitudes at relative phase. Para sa karagdagang impormasyon tungkol sa prosesong ito, tingnan ang seksyon na ito sa kurso ni John Watrous tungkol sa General Formulation of Quantum Information, o para sa isang praktikal na implementasyon, tingnan ang teleportation lesson na ito ng kurso tungkol sa Utility-Scale Quantum Computing.

Pagmamasid sa mga Error at ang kanilang Akumulasyon

Sa seksyong ito, gagamit tayo ng totoong quantum computers upang masdan ang quantum errors at ang kanilang akumulasyon sa ilalim ng iba't ibang kondisyon. Sa praktika, maraming pinagmumulan ng quantum errors ang karaniwang naroroon nang sabay-sabay. Upang masdan ang iba't ibang uri ng errors sa medyo isolated na paraan, kakailanganin nating gumamit ng mga circuit na dinisenyo para sa isolation na iyon. Ang mga circuit na ginagamit sa mga aplikasyon ng quantum computing ay mas magiging komplikado.

Simulan natin sa energy relaxation errors.

Mga Error sa Energy Relaxation ($T_1$)

Alalahanin mula sa ating talakayan tungkol sa thermal noise na sa anumang non-zero na temperature, may ilang probability na ang isang quantum system ay dumaan sa isang transition sa pagitan ng energy eigenstates. Ang relaxation ($|1\rangle \rightarrow |0\rangle$) ang nangingibabaw dahil ito ay dulot ng spontaneous emission (independiyente sa temperature), habang ang mababang temperature ay pumipigil sa kumpitensyang excitation process. Kung mas matagal na naka-idle ang isang qubit, mas maraming oras ito para dumaan sa ganitong transition. Ang probability na ang isang qubit na inihanda sa state na $|1\rangle$ ay mananatili sa $|1\rangle$ pagkatapos ng oras na $t$ ay ibinibigay ng

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

Dito, ang oras na $T_1$ ay isang experimentally-determined na characteristic time na iba para sa bawat qubit, at maaari pa itong bahagyang magbago sa paglipas ng panahon. Ang mga IBM® quantum computer ay regular na binebenchmark, kaya ang mga $T_1$ na oras na nakalista para sa mga qubit sa IBM quantum computers ay dapat tumpak at up-to-date. Ang malaking halaga ng $T_1$ ay nangangahulugan na ang qubit ay mas matagal na nananatili (sa average) sa state na inihanda mo. Ang tipikal na halaga ng $T_1$ ay nag-iiba sa iba't ibang architecture; ang mga qubit sa IBM quantum computers ay kadalasang may $T_1$ na oras na nasa order ng 200-300 $\mu s$, at maaari mong tingnan ang pinakabagong mga halaga sa pahina ng Compute resources.

Ang characteristic time na $T_2$ ay sumusukat ng ibang bagay: ang pagkawala ng phase information. Babalikan natin ito mamaya.

Upang masdan ang energy relaxation errors, ihahanda natin ang mga qubit sa $|1\rangle$ state, at pagkatapos ay sinasadyang iiwan silang naka-idle sa mahabang panahon. Ito ang artificial na bahagi. Sa totoong quantum workflows, maaaring mayroon kang ilang qubit na naka-idle sa mahabang panahon habang ang mga proseso ay isinasagawa sa ibang mga qubit; kaya, ang ilang instansya ng ganitong idle times ay hindi artificial.

Magsimula tayo sa pag-import ng ilang packages at pagpili ng least-busy backend.

# 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')>

Ngayon ay pipili tayo ng qubit na gagamitin, sa kasong ito, qubit zero. Direkta nating mai-import ang mga properties ng qubit na ito, kabilang ang $T_1$ at $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

Mahalagang malaman ang $T_1$ sa units ng microseconds, ngunit maaaring wala kang intuitive na pakiramdam kung ano ang ibig sabihin nito. Sa huli, ang mga gate operation sa quantum computers ay napakabilis. Ang tunay na tanong ay: gaano karami ang magagawa natin sa isang quantum computer sa dami ng oras na iyon. Para dito, kapaki-pakinabang na iugnay ang $T_1$ sa ibang time scales na ginagamit sa quantum computing — partikular sa mga sumusunod:

• sampling time na $dt$ - ang pinakamaliit na clock tick kung saan maaaring ipatupad ang mga control process sa quantum computer.

• single-qubit gate times - ang oras na kinakailangan upang ipatupad ang isang gate operation sa isang solong qubit. Hindi ito magiging iisang halaga, kundi isang range ng posibleng mga numero depende sa uri ng gate.

• two-qubit gate times - ang oras na kinakailangan upang ipatupad ang isang gate operation sa dalawang magkatabing qubit. Maaari rin itong magkaroon ng range ng mga halaga, ngunit karaniwang isang order of magnitude na mas mahaba kaysa sa single-qubit gate.

Tingnan natin ang $dt$ para sa ating backend, at ipakita ang ilang plausible na ranges para sa gate times.

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

Ang mga gate times na ito ay mag-iiba mula sa isang backend patungo sa isa pa. Mag-hahard-code tayo ng two-qubit gate time na kinuha mula sa ibm_boston na 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

Tandaan na walang ibang error sources o ang kanilang suppression o mitigation ang isinaalang-alang dito. Ang mga $T_1$ error ay hindi lang ang tanging errors na gumagana sa isang quantum system, kaya huwag masyadong mag-alala tungkol sa mga numerong ito. Nangangahulugan lamang ito na, sa kawalan ng anumang suppression, maaari nating maipatupad ang humigit-kumulang libu-libong two-qubit gates bago magsimulang mangibabaw ang $T_1$ errors. Karaniwang mangingibabaw ang ibang errors sa mas mababang depths, at sa kabaligtaran, maaaring sulit pa ring supilin ang $T_1$ errors sa mas maiikling oras kaysa sa kinakailangan para ganap na mawala ang signal.

Magsisimula tayo sa paggamit ng simulator na may noise model, at pagkatapos ay ihahambing natin ang mga resulta sa totoong hardware.

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)

Magtakda tayo ng time step para sa ating mga measurement na katugma sa high-end estimate para sa two-qubit gate time. Pagkatapos ay bubuo tayo ng 50 circuits sa mga increment ng time step na iyon. Sa ganitong paraan, makikita natin ang nangyayari sa isang time scale na katulad ng pagpapatupad ng 80 two-qubit gates. Hindi kritikal ang precision dito, kaya gagamit tayo lamang ng iilang shots.

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

Bumubuo tayo ng noise model para sa ating simulator na tahasang nagsasama ng thermal relaxation errors.

# 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)

Ngayon ay bubuo tayo ng ating mga circuit at observables. Napakasimple ng mga ito. Ang mga circuit ay binubuo lamang ng paghahanda ng qubit sa $|1\rangle$ at pagpapatupad ng delays para sa tumataas na yugto ng panahon, gamit ang characteristic gate times at $dt$ na tinukoy sa itaas. Ang observables ay magiging $Z$ lamang, dahil ang gusto nating malaman ay kung nanatili ba ang qubit sa $|1\rangle$ o dumecay patungo sa $|0\rangle$. Bagaman hindi laging kinakailangan ang transpilation para sa mga simulator, isasagawa pa rin natin ang transpilation ng ating mga circuit dito para magamit mamaya sa totoong backend.

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)

Pinapatakbo natin ang ating job gamit ang isang 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()

Sa wakas, i-plot natin ang mga output.

# 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()

Malinaw na nakikita ang exponential decay, at sa oras na ito, bumaba ito sa halos wala pang 40% na tsansang mapasa $|1\rangle$. Pansinin na ito ay eksaktong consistent sa model: $p = e^{-t/t_1}$ kung saan pinili natin ang maximum na $t$ na nasa parehong order gaya ng $t_1$; alalahanin na sinabi natin na ang $t_1$ ay maaaring katumbas ng 60 gates (o sa order of magnitude na iyon), at dito ang $t$ ay katumbas ng 60 gates. Kaya

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

Ngayon patakbuhin natin ang parehong mga circuit sa isang totoong quantum computer. Upang masaklaw ang parehong delay duration na may mas kaunting jobs, tataasan natin ang delay unit at babawasan ang bilang ng mga points.

# 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}")

Ngayon i-plot natin ang mga resulta.

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()

Tulad ng makikita natin, ang pagkadecay ng $|1\rangle$ state sa paglipas ng panahon ay tugma sa teorya (at sa depinisyon ng $T_1$). Bukod dito, medyo mahusay ang simulator sa pagtugma sa kilos ng totoong quantum computer sa kasong ito. Narito ang ilang bagay na dapat tandaan tungkol sa pagkadecay ng state na ito:

• Artipisyal nating pinatagal ang measurement para sa hindi realistikong dami ng oras. Ang mga delay na ito ay katumbas ng timescale ng napakalalim na mga circuit na maaaring binubuo ng libu-libong two-qubit gates. Ginawa ito upang lamang ipakita na umiiral ang mga epekto ng thermal noise. Sa totoong mga circuit na inilalapat sa mga real-world na problema, isasagawa ang mga operation sa ibang mga qubit habang ang ilan ay maaaring naka-idle nang sapat katagal para maging mahalaga ang energy relaxation errors — ngunit ang ibang errors ang mangingibabaw bago maabot ang buong $T_1$.
• Walang ginamit na error mitigation o suppression techniques. Maaari nating baguhin ang decay curve na ito sa pamamagitan ng paggamit ng mga technique na ating matututunan sa kursong ito.
• Gumamit lamang tayo ng 100 shots dito, na di-pangkaraniwang mababa dahil layunin lamang nating ipakita na umiiral ang epekto. Malamang na gagamit ka ng higit sa 1,000 shots sa mga aplikasyon.

Ang unang visualization na ito ng error ay halos hindi nangangailangan ng gates maliban sa delays (at ang solong X gate na ginamit upang ihanda ang $|1\rangle$). Tingnan naman natin ngayon ang isa pang halimbawa na nakatuon sa gate error.

Mga Gate Error at Akumulasyon

Kapag naglalapat tayo ng quantum gate, sabihin nating isang $X$ gate, sa teorya ang gate na iyon ay umiikot sa isang quantum state sa anggulong $\pi$ radians sa paligid ng $X$ axis sa Bloch sphere, na nagmamapa ng $\alpha |0\rangle + \beta |1\rangle$ patungong $\alpha |1\rangle + \beta |0\rangle$ sa pamamagitan ng

$$\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}$$

Gayunpaman, ang isang tunay na gate ay hindi perpekto. Maaaring hindi ito tama ang oryentasyon (na nagdudulot ng mga pag-ikot na hindi perpektong nasa paligid ng X axis) o maaari itong magdulot ng bahagyang mas malaki o mas maliit na pag-ikot kaysa sa inaasahan. Imodelo natin ang error ng gate bilang purong over/under rotation sa maliit na anggulong $\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}$$

Kung ang isang hindi perpektong gate ay inilalapat nang paulit-ulit, ang maliliit na error na $\epsilon$ ay maaaring mag-ipon. Minsan ang maramihang error na ito ay nagdudulot pa nga ng paglipat ng state sa parehong direksyon sa bawat pagkakataon (isang phenomenon na tinatawag na "coherent accumulation", na babalikan natin sa ibaba). Tingnan natin kung ano ang mangyayari kapag inilapat natin ang isang tunay na X gate sa isang qubit nang maraming beses.

# 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()

Nagsisimula ang expectation value sa paligid ng 1.0 gaya ng inaasahan, at humihina, pero hindi lang ito humihina hanggang zero! Nagiging negatibo ito. Kung ito ay thermal noise o random interactions, hindi nito gagawing mas malamang na masukat ang $|1\rangle$ kaysa sa $|0\rangle$. Malinaw na naiiba ang error na ito. At may saysay ito sa konteksto ng ating talakayan tungkol sa over/under-rotation. Kung ang bawat pares ng pag-ikot na dapat magkansela sa isa't isa ay aktwal na nagreresulta sa pag-ikot nang kaunti, kung gayon maraming ganitong pag-uulit ang unti-unting magbibigay-daan sa state na umikot mula sa $|0\rangle$ patungo sa $|1\rangle$.

Ang pag-ipon ng mga error na ipinakita rito ay malamang na hindi magpapatuloy nang kasinglinis sa isang tunay na workflow. Una sa lahat, sadya nating na-off ang error mitigation at ginawa ang parehong paulit-ulit na sequence ng gate upang payagan ang mga error na mag-ipon nang coherent. Ginawa ito nang eksklusibo upang ipakita na umiiral ang mga error na ito. Kapag gumamit tayo ng mga teknik sa paghawak ng noise (halimbawa, Pauli twirling), maiimpluwensyahan natin kung paano nag-iipon ang error, na kadalasang nagreresulta sa mas mababang kabuuang error.

Masusuri natin nang eksakto kung gaano kaayon ang ating modelo ng error na ito sa experimental data sa pamamagitan ng pagbuo ng isang noise model nang tuwiran at paggamit ng isang simulator. Sa modelong nasa ibaba, tuwiran nating binuo ang isang error na katumbas ng 0.025 radians. Hindi iyan isang magic number; maaari lang i-tune ng isa ang error hanggang makatwirang ilarawan nito ang eksperimento.

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

Ngayon maaari nating i-plot nang magkasama ang tunay at simulated na mga curve.

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()

Ang error sa tunay na circuit ay medyo mahusay na inilarawan ng over/under-rotation error model. Malinaw na iba't ibang uri ng noise at error ang mag-iipon sa magkakaibang paraan at magreresulta sa lubhang magkakaibang epekto sa fidelity ng ating mga quantum circuit. Kaya naman naging mahalaga ang pag-uri-uri at paglalarawan sa mga error na maaaring mangyari nang mas pormal kaysa sa ginawa natin sa ngayon.

Paglalarawan ng mga quantum error

Nailarawan na natin ang ilan sa mga pinagmumulan ng quantum noise, at maaari nating i-categorize ang mga error ayon sa mga kategorya ng noise na sanhi ng mga ito. Ngunit maaaring mayroong iba't ibang kategorya ng quantum error na kapaki-pakinabang sa error correction at mitigation. Halimbawa, kailangan nating malaman kung saang punto nangyayari ang mga error at kung paano nag-iipon ang mga error kung gusto nating iwasto o pagaanin ang mga ito. Sa pagtukoy kung saan (sa anong mga proseso) nangyayari ang mga error, isang karaniwan at mahalagang kategorya ay ang state preparation at measurement errors (o SPAM errors, sa maikli). Dito, ang terminong "state preparation" ay hindi nangangahulugan ng lahat ng ginagawa sa isang state upang ihanda ito para sa measurement. Sa halip, tumutukoy ito sa initialization ng mga qubit, ang "paghahanda" ng mga qubit para sa pagsasagawa ng isang algorithm, at kaya't hindi kasama sa kategoryang SPAM ang mga bagay tulad ng gate errors habang isinasagawa ang algorithm.

Isa pang mahalagang distinksyon ay kung ang mga error ay coherent o incoherent. Upang buod nang maikli (tatalakayin natin ito nang mas detalyado sa ibaba), ang mga coherent error ay karaniwang minomodelo ng unitary operations at pinapanatili ang purity ng state. Ang mga incoherent error naman ay minomodelo ng non-unitary quantum channels at karaniwang binabawasan ang purity ng state. Madaling i-visualize ang mga incoherent error bilang thermal interactions na nagdudulot ng pagkawala ng quantum information, ngunit sa totoo lang maaari itong sanhi ng kahit anong random na pagkakaugnay sa kapaligiran. Bilang halimbawa ng isang coherent error, ipagpalagay na may kapintasan sa oryentasyon ng pulse sa pagpapatupad ng isang RY gate kaya ang isang $RY(\theta)$ gate ay aktwal na nagdudulot ng $RY(\theta) \cdot RX(\epsilon)$. Ang ganitong kapintasan ay palaging magdudulot ng maling pag-ikot sa paligid ng X sa parehong direksyon. Ito ay magiging isang coherent error.

Tandaan na ang mga SPAM error ay may kasamang halo ng coherent errors, tulad ng systematic control faults, at incoherent errors, tulad ng photon loss at thermal effects. Dahil sangkot dito ang maraming hakbang at pinagmumulan ng error, ang mga SPAM error ay pinakamahusay na inilalarawan bilang kombinasyon ng parehong coherent at incoherent errors.

Mga SPAM error

Gaya ng ipinahihiwatig ng pangalan, ang mga SPAM error ay lumilitaw sa dalawang magkaibang yugto ng isang quantum experiment: paunang paghahanda at readout/measurement. Nangyayari ang state preparation errors kapag nabigo ang hardware na maaasahang i-initialize ang mga qubit sa nais na panimulang state ($|0\rangle$ para sa mga IBM quantum computer). Kabilang sa mga sanhi:

• thermal excitation (ang mga tunay na qubit ay hindi perpektong pinapalamig at maaaring paminsan-minsang magsimula sa $|1\rangle$ sa halip na $|0\rangle$)
• mga natitirang photon o noise sa mga resonator sa superconducting qubits
• mga drift sa calibration na nakakaapekto sa kung gaano kawasto ang pag-reset ng mga qubit

Nangyayari ang measurement errors sa panahon ng readout process, kapag ang measurement apparatus ay mali ang pagkakakilanlan sa state ng qubit. Kabilang sa mga pinagmumulan:

• readout amplifier noise na nagdudulot ng pagkalito sa pagitan ng $|0\rangle$ at $|1\rangle$

• qubit relaxation sa panahon ng readout (halimbawa, ang isang qubit na nasa $|1\rangle$ ay nabubulok patungo sa $|0\rangle$ bago pa man o habang sinusukat)

• crosstalk sa pagitan ng mga readout line: ang pagbasa sa isang qubit ay bahagyang nakakaimpluwensya sa mga pagbasa sa mga kalapit na qubit

• Hindi perpektong discrimination thresholds sa mga resonator-based measurement system ng IBM

Ang mga SPAM error ay pangunahing incoherent. Ang mga preparation error ay kumikilos tulad ng random na paghahalo ng excited at ground states. Ang mga measurement error naman ay kumikilos tulad ng classical confusion: may probability na $p$, ang $|0\rangle$ ay naiuulat bilang $|1\rangle$ o kabaliktaran. Naiiba ang mga ito sa coherent unitary errors (tulad ng mga miscalibrated na gate na nagdudulot ng systematic phase shifts). Sa halip, ang mga SPAM error ay kahawig ng random classical noise, bagaman maaaring magkaroon ng bihirang coherent bias sa readout.

Maaaring maging problema ang mga SPAM error para sa randomized benchmarking o para sa mga short-depth circuit kung saan ang state preparation at measurement ay kumakatawan sa malaking bahagi ng kabuuang error. Hindi gaanong isyu ang mga ito para sa napakalalim na mga circuit, lalo na ang mga may maraming two-qubit gates.

Sa matematika, maaaring ilarawan ang mga SPAM error bilang paglikha ng isang noisy distribution na $\vec{p}_\text{noisy}$ na kaugnay ng ideal distribution na $\vec{p}_\text{ideal}$ sa pamamagitan ng isang matrix na $A$:

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

Dito, ang $p_i$ ay ang probability na masukat ang bitstring na $i$, at ang $A_{ij}$ ay ang probability na makuha ang state na $j$ kung ang state ay dapat sanang inihanda sa state na $i$. Isipin ang konteksto ng mga sampled bitstring mula sa Sampler. Ang iyong nasukat na distribution ng mga state ay binubuo ng maraming tumpak na sukat, ngunit mayroon ding ilang sukat kung saan ang mga instruksyon para sa state preparation ay hindi tumutugma sa naobserbahang state. Nangangahulugan ito na ang mga probability ay magiging bahagyang mali.

Sa figure sa itaas, ipinapakita ng bahagi (a) ang ideal distribution ng isang GHZ state sa kulay teal, at ang aktwal na mga sukat sa kulay purple. Sa bahagi (b), makikita natin ang halimbawa ng isang $A$ matrix. Tandaan na ang matrix ay hindi perpektong simetriko sa kabuuan ng diagonal, dahil hindi kinakailangang pantay-pantay ang tsansa ng bawat qubit na maling magbalik ng 0 at maling magbalik ng 1. Sa praktika, kadalasang mahirap paghiwalayin ang preparation at readout errors, kaya't kadalasan itong pinagsasama sa iisang paglalapat (kaya karaniwang ginagamit ang SPAM).

Isang paraan ng pagwawasto sa mga SPAM error na ito ay ang paggamit ng simpleng mga circuit na may kilalang ideal na resulta ng measurement at ang paghahambing ng mga iyon sa nasukat na resulta sa presensya ng mga SPAM error. Magagamit ito upang i-reverse-engineer ang ideal na resulta ng mas komplikadong mga circuit. Para sa pangkalahatang high-entropy states, maaaring kailanganin nito ang pagbuo ng isang matrix na may $2^N\times2^N$ na mga probability, ngunit sa hindi masyadong sukdulang mga kaso, maaaring pagaanin ang mga error na ito.

Coherent errors laban sa incoherent errors

Ang coherent errors ay systematic, deterministic, at unitary na maling pag-ikot ng quantum state. Nagmumula ang mga ito sa hindi perpektong quantum operations na lumihis sa isang mahuhulaan na paraan. Kabilang sa mga halimbawa ang bahagyang error sa pag-ikot na inilapat ng single-qubit rotation gates, kasama ang mga sanhi ng calibration drift na palaging labis o kulang ang pag-ikot. Sa matematika, maaari nating isulat na ang isang tunay na rotation gate, sabihin nating $\tilde{R_X}(\theta)$, ay ibinibigay ng ideal na rotation gate kasama ang ilang karagdagang error:

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

para sa ilang maliit na under- o over-rotation na $\epsilon$. Kabilang sa iba pang halimbawa ang isang two-qubit gate na nagdadagdag ng maliit na hindi ninanais na phase shift at mga control pulse na systematic na lumihis mula sa ideal na hugis.

Isang mahalagang katangian ng coherent errors ay ang mga ito ay deterministic at maaaring i-modelo ng mismong unitary gates. Dahil dito, pinapanatili nito ang purity ng quantum state: hindi nawawala ang quantum information, ito lamang ay naproseso nang hindi perpekto. Isa pang mahalagang punto na dapat tandaan ay ang mga paulit-ulit na coherent error ay nag-iinterfere nang constructive at kung minsan ay lumalaki nang quadratic ayon sa bilang ng mga gate.

Ang mga error na ito ay minsan mahuhulaan at kaya maaaring i-calibrate palayo hanggang sa isang antas. Ngunit ang mga coherent error na natitira ay maaaring mag-ipon nang mabilis, na nagdudulot ng nakakabahalang paglihis mula sa mga ideal na state. Ibig sabihin, minsan mas mainam na sadyang "i-randomize" ang mga coherent error. Ang proseso at kapakinabangan nito ay tatalakayin sa aralin tungkol sa error mitigation.

Bakit ang mga ito ay nakakabahala

Maaaring "mag-ipon" ang mga coherent error sa mapanganib na paraan, na nagdudulot ng malalaking paglihis mula sa tamang state kung hindi ito na-randomize o naitama.

Ang incoherent errors ay stochastic, random, at kadalasang non-unitary. Nagmumula ang mga ito sa mga interaksyon sa kapaligiran o hindi nakokontrol na mga pinagmumulan ng noise. Nakita na natin ang ilang halimbawa: ang energy relaxation / $T_1$ decay ay incoherent. Ganoon din ang stochastic gate noise, thermal noise, at measurement error.

Ang pangunahing katangian ng incoherent errors ay hindi ito palaging pareho sa bawat pagkakataon na isasagawa ang isang operation. Ang mga ito ay non-unitary, kaya hindi ito maaaring i-modelo ng isang simpleng unitary quantum gate tulad ng magagawa sa coherent errors. Dahil incoherent ang mga ito, karaniwang nag-iipon ang mga ito sa linear na paraan tulad ng random noise, hindi tulad ng pare-parehong over-rotation.

Ang mga incoherent error ay nagdudulot ng hindi na maibabalik na pagkawala ng impormasyon ng mga qubit (pagkawala ng purity at phase information).

Kaya alin ang mas masama? Tulad ng karamihan sa mga bagay sa quantum computing, depende ito. Ang mahalagang punto ay ang mga coherent error ay nag-iipon nang mas mabilis at non-linear (na masama). Ngunit maaari itong bahagyang maalis sa pamamagitan ng calibration at nananatili pa rin ang phase information sa iyong sistema, kung malalaman mo kung paano ito wastong kunin. Ang mga incoherent error naman ay nag-iipon nang linear, na mabuti dahil sa dalawang dahilan: mas mabagal ito kaysa sa coherent accumulation at medyo madaling makita kung paano nag-iiba ang epekto ng mga incoherent error para sa mga proseso tulad ng zero-noise extrapolation (ZNE), na tatalakayin sa aralin tungkol sa error mitigation. Gayunpaman, kapag nangyari ang mga incoherent error, tunay na nawawala ang quantum information, hindi lang natatakpan.

Mga density matrix at quantum channel

Sa mga sumusunod na seksyon, susuriin natin nang mas malalim ang ilang uri ng coherent at incoherent errors at makikita kung paano ito maaaring i-modelo sa matematika gamit ang quantum channels. Una, kailangan muna ng maikling pag-aalala tungkol sa density matrices at quantum channels. Para sa isang kumpleto at mahigpit na paglalahad ng mga ito, tingnan ang kurso ni John Watrous na General formulation of quantum information sa IBM Quantum Learning. Ang paglalahad dito ay magiging example-driven at hindi masyadong pormal.

Ang quantum channels ay ang pinakapangkalahatang paraan upang ilarawan kung paano umuunlad, nakikipag-ugnayan, at dumadaan sa noise ang isang quantum system. Kung sanay ka na sa pure states at unitary evolution, ang quantum channels ang natural na susunod na hakbang.

Sa karaniwang quantum mechanics, ang isang "pure" state ay isinusulat bilang $|\psi\rangle$. Dito, ang "pure" ay tumutukoy sa purity ng impormasyon o kaalaman tungkol sa paghahanda ng state; hindi ito nangangahulugan ng eigenstate ng anumang sistema. Bilang halimbawa ng isang qubit, ang $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ ay isang pure state dahil mayroon tayong perpektong kaalaman sa relative amplitudes at phase. Ang ebolusyon sa oras ng ganitong pure state ay pinamamahalaan ng isang unitary operator na $U$:

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

ayon sa Schr"odinger equation, kung saan ang $U = e^{-iHt/\hbar}$, kung saan ang $H$ ay ang Hamiltonian ng sistema at ang $\hbar$ ay ang reduced Planck's constant, na kadalasang "itinatakdang katumbas ng isa" o mas mahigpit, isinasama sa Hamiltonian upang lahat ng enerhiya ay ibinibigay sa yunit ng $\hbar$.

Ang unitary evolution ay reversible, deterministic, at isolated. Ngunit hindi ito sapat upang ilarawan ang mga tunay na quantum system. Sa mga tunay na quantum system:

• Nagsasagawa tayo ng mga measurement, na nag-co-collapse sa quantum state patungo sa isang eigenstate ng sistema. Ito ay tuwirang non-unitary.
• Nakikipag-ugnayan ang sistema sa isang kapaligiran. Nangangahulugan ito na hindi talaga isolated ang sistema, at dahil hindi masusubaybayan ang kapaligiran nang walang hanggan, ito ay tumutugma sa pagkawala ng impormasyon.
• Sa praktikal na pananaw: sinisira ng noise ang state. At marami pang iba.

Hindi kayang ilarawan ng unitary evolution lamang ang mga prosesong ito; kaya naman, kailangan natin ng mas pangkalahatang representasyon ng mga quantum state at proseso. Ang isang mixed state ay naglalarawan ng isang classical distribution ng mga quantum state. Ibig sabihin, pamilyar na tayo sa katotohanan na ang quantum state: $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ ay may 50% na tsansang masukat (mag-collapse patungo sa classical information) sa state na $|0\rangle$ at 50% na tsansang masukat sa $|1\rangle$. Ngunit ang claim ay ang paunang quantum state ay eksaktong $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ na may 100% na probability. Ngayon, gusto nating idagdag sa ibabaw ng quantum mechanical probability ang isang classical probability, halimbawa:

Ang paunang quantum state ay inihahanda sa $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ na may 25% classical probability, at inihahanda sa $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle-i|1\rangle)$ na may 75% classical probability (pansinin ang magkaibang relative phases).

Minsan, maaari itong dahil sa tuwirang classical probabilities sa paghahanda; sa ibang pagkakataon, maaari itong dahil sa entanglement sa mga bahagi ng kapaligiran na ating hindi pinapansin. Sa alinmang paraan, malinaw ang pangangailangan para sa isang tool upang ilarawan ang classical distribution na ito ng mga quantum mechanical state. Hindi maaaring irepresenta ng pure states lamang ang mga posibilidad na ito. Kaya naman, ipinapakilala natin ang density matrix.

Ang isang mixed state ay inilalarawan ng isang density operator:

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

Dito, ang $|\psi_i\rangle$ ay isang quantum state (hindi kinakailangang eigenstate ng anumang partikular na operator) at ang $p_i$ ay ang classical probability na ang sistema ay inihanda sa state na $|\psi_i\rangle$. Ito ay isang magandang preskripsyon kung paano bumuo ng density matrix mula sa isang kilalang classical distribution ng mga quantum state. Sa kabilang banda, maaaring gusto nating malaman, gamit ang parehong classical distribution ng mga quantum state at ang quantum mechanical probability ng iba't ibang resulta ng measurement, kung ano ang probability na ang isang measurement ay magbubunga ng isang partikular na state (tulad ng $|0\rangle$, o $|1\rangle$, o iba pang state kapag mas maraming qubit ang kasangkot). Doon lalo na kapaki-pakinabang ang density matrix. Maaari rin natin itong isulat sa isang basis na $\{|i\rangle\}$ bilang:

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

Dito, ang mga diagonal elements na $\rho_{ii}$​ ay mga probability:

• $\rho_{00}$​ = probability na ang qubit ay nasa $|0\rangle$

• $\rho_{11}$​ = probability na ang qubit ay nasa $|1\rangle$

Ang mga ito ay real, non-negative, at ang kabuuan ay 1.

Ang mga off-diagonal elements na $\rho_{ij}, i \neq j$ ay mga coherences: mga phase relationship o kakayahan sa interference, at karaniwang tumutugma sa kung gaano karaming quantum mechanical information ang nasa state. Ito ay isang impormal na pahayag, ngunit tingnan natin kung ano ang ibig sabihin nito sa praktika.

Halimbawa

Isaalang-alang ang pure state na $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. (a) Ano ang alam mo tungkol sa mga probability ng measurement at phase information nang hindi gumagawa ng anumang matematika? (b) Buuin ang density matrix at patunayan ang iyong intuwisyon.

Solution:

(a) Dahil ito ay isang pure state, mayroon lamang isang posibleng phase sa pagitan ng $|0\rangle$ at $|1\rangle$: +1. Ito ay perpektong phase information, kaya inaasahan nating malaki ang mga off-diagonal elements sa ating density matrix. Maaaring mayroon kang mas malalim na intuwisyon tungkol sa mga off-diagonal kaysa dito, ngunit sapat na iyon sa ngayon. Bukod dito, ang mga amplitude ng dalawang basis state ay pantay, kaya inaasahan nating may 50% probability na masukat ang alinman sa $|0\rangle$ o $|1\rangle$. Kaya inaasahan nating ang mga diagonal entries ay 1/2. (b) Gamit ang depinisyon sa itaas:

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

$p_i \neq 0$ lamang para sa state na $|\psi\rangle$. Kaya maaari nating isulat

$$\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}$$

Ang mga diagonal entries ay bawat isa ay $1/2$ gaya ng inaasahan, at malaki ang mga off-diagonal elements (ang kabuuan ay isa).

Ngayon tingnan natin kung ano ang mangyayari kapag wala tayong magandang phase information.

Halimbawa

Isaalang-alang ang isang katulad na kaso, ngunit ngayon may 50% classical probability na nasa state na $|\psi_+\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ at 50% classical probability na nasa state na $|\psi_-\rangle = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$. Parehong dalawang tanong: (a) Ano ang alam mo tungkol sa mga probability ng measurement at phase information nang hindi gumagawa ng anumang matematika? (b) Buuin ang density matrix at patunayan ang iyong intuwisyon.

Solution:

(a) Tulad ng dati, ang mga amplitude ng dalawang basis state ay pantay, kaya inaasahan nating may 50% probability na masukat ang alinman sa $|0\rangle$ o $|1\rangle$. Kaya inaasahan nating ang mga diagonal entries ay 1/2. Ngunit sa pagkakataong ito, may dalawang magkasalungat na posibilidad para sa phase sa pagitan ng $|0\rangle$ at $|1\rangle$: +1 at -1, at pantay-pantay ang tsansa ng bawat isa. Maaaring asahan na sa dalawang pantay na malamang na magkasalungat na phase, kaunti hanggang wala talagang phase information ang mayroon. Maaaring asahan na maliit ang mga off-diagonal entries. (b) Muling gamit ang depinisyon sa itaas

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

$p_i \neq 0$ lamang para sa dalawang state na $|\psi_+\rangle$ at $|\psi_-\rangle$. Kaya maaari nating isulat

$$\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}$$

Ang mga off-diagonal entries ay maliit, zero pa nga, gaya ng inaasahan. Ang mga diagonal element ay 50% pa rin bawat isa, na may saysay dahil ang bawat isa sa mga state sa paghahalo ay may $|0\rangle$ at $|1\rangle$ na pantay ang timbang.

Ang construct na ito ay nagiging mas kawili-wili habang dumarami ang bilang ng mga qubit. Suriin ito sa mga tanong sa ibaba.

Suriin ang iyong pag-unawa

Isulat ang density matrix para sa pure Bell state na $|\Phi_+\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$.

Sagot

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

$p_i \neq 0$ lamang para sa state na $|\Phi_+\rangle$. Kaya maaari nating isulat

$$\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}$$

Isulat ang density matrix para sa 25% classical probability ng $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ at 75% classical probability ng $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$.

Sagot

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

$p_i \neq 0$ lamang para sa dalawang state na $|\Phi_+\rangle$ at $|\Psi_-\rangle$. Kaya maaari nating isulat

$$\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}$$

Baguhin ang iyong ginawa mula sa nakaraang tanong upang isulat ang density matrix para sa 50% classical probability ng $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ at 50% classical probability ng $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$. Hulaan kung anong phase information ang dapat manatili.

Sagot

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

$p_i \neq 0$ lamang para sa dalawang state na $|\Phi_+\rangle$ at $|\Psi_-\rangle$. Kaya maaari nating isulat

$$\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}$$

Ang mga diagonal term ay ang kabuuan ay 1, gaya ng dapat. Ang mga off-diagonal term ay hindi nagkakansela dito tulad ng nangyari sa naunang, one-qubit na halimbawa. Makikita mo kung bakit, sa matematika, ngunit ang maikling paliwanag ay mayroong mas maraming state ngayon sa ating Hilbert space. Bagama't ang unang Bell state ay may positibong relative phase at ang pangalawa ay may negatibo, ang mga phase na ito ay sa pagitan ng magkaibang basis states. Ang unang Bell state ay may phase sa pagitan ng $|00\rangle$ at $|11\rangle$, habang ang pangalawa ay may relative phase sa pagitan ng $|01\rangle$ at $|10\rangle$.

Mga quantum channel

Ang isang quantum channel ay ang pinakapangkalahatang pisikal na pinapayagang transpormasyon ng isang quantum state. Kinukuha nito ang isang paunang density matrix na $\rho$ patungo sa isa pang density matrix:

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

Dito, ang $\Phi(\rho)$ ay nangangahulugan ng isang quantum channel na $\Phi$ na kumikilos sa isang density matrix na $\rho$, na hindi dapat malito sa mga Bell state na $|\Phi_+\rangle$ o $|\Phi_-\rangle$.

Ang mga quantum channel ay lubhang pangkalahatan. Maaaring kabilang dito:

• Unitary evolution na $\Phi(\rho) = U\rho U^\dagger$

• Probabilistic na paghahalo ng mga unitary

• Measurements

• Decoherence

• Amplitude damping (pagkawala ng enerhiya)

• Dephasing (pagkawala ng phase information)

• Interaksyon sa isang kapaligiran At marami pang ibang bagay.

Isang paraan ng pag-iisip tungkol sa quantum channels ay ang mga ito ay para sa density matrices kung ano ang unitaries para sa pure states. Ngunit ang pangkalahatan ng density matrices ay nagpapahintulot sa kaukulang quantum channels na maging mas pangkalahatan at sa gayon ay mas makapangyarihan.

Ang mga tanging hadlang sa isang quantum channel ay dapat itong:

1. Linear Dapat umunlad nang pare-pareho ang mga paghahalo ng state: $\Phi(p\rho_1 + (1-p)\rho_2) = p\Phi(\rho_1) + (1-p)\Phi(\rho_2)$
2. Completely positive Hindi ito dapat magbunga ng negatibong probability, kahit na ang iyong sistema ay entangled sa ibang bagay.
3. Trace-preserving Dapat ang mga probability ay magdagdag hanggang 1. Minsan pinagsasama-sama ang mga ito sa acronym na CPTP: Completely Positive Trace-Preserving maps.

Mayroong iba't ibang representasyon ng quantum channels, kasama ang Stinespring, Kraus, at Choi representations. Tinatalakay ang mga ito nang detalyado sa aralin na ito tungkol sa quantum channels sa General formulation of quantum information at ipinapakita rin doon na pare-pareho ang mga ito. Hindi natin tatalakayin dito ang iba't ibang representasyong ito. Sapat nang sabihin na ang mga ito ay katulad ng paglalarawan ng mga vector gamit ang tatlong magkaibang coordinate frame. Maaaring bigyang-diin ng bawat isa ang magkaibang aspeto at bumuo ng intuwisyon sa magkaibang paraan; ngunit lahat ng ito ay magbibigay sa iyo ng tamang sagot. Kraus representations ay maginhawa para sa ating layunin. Nag-aalok ang mga ito ng maginhawang formulaic na paraan upang ipahayag ang galaw ng isang channel sa pamamagitan ng matrix multiplication at addition. Sa partikular, ang isang Kraus representation ay isang paglalahad ng isang channel, $\Phi$, sa sumusunod na anyo.

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

Dito, ang $A_0,\ldots,A_{N-1}$ ay mga matrix na may parehong dimensyon: ang mga column nito ay tumutugma sa mga classical state ng input system, $\mathsf{X}$, at ang mga row nito ay tumutugma sa mga classical state ng output system, maging ito ay $\mathsf{X}$ o iba pang sistemang $\mathsf{Y}$. Upang maging valid na channel ang $\Phi$, ang mga matrix na ito ay dapat sumunod sa sumusunod na kondisyon.

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

Ang mga matrix na ito ay tinatawag na Kraus matrices. Ang paglalahad na ito ay naaangkop hindi lamang sa noise channels, kundi sa pangkalahatang quantum processes at channels, kasama ang measurement. Tingnan natin ang isang halimbawa kung paano magagamit ang mga ito upang bumuo ng mga channel sa konteksto ng noise at mga error.

Ganap na dephasing channel

Isaalang-alang ang isang channel na sumisira sa lahat ng phase information at tawagin itong completely dephasing channel. Ibig sabihin, dapat kunin ng channel na ito ang anumang density matrix na may anyong

$$\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}$$

at imapa ito patungo sa

$$\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}$$

Kung ipagpalagay natin na naisulat na ang density matrix sa computational basis, maaari nating ipahayag ang $\rho_{ij}$ bilang $\langle i|\rho|j\rangle$. Iminumungkahi nito ang isang set ng Kraus matrices na maaaring magsagawa ng galaw ng channel na ito: $A_k = |k\rangle\langle k|$. Ilapat natin ang estratehiyang ito sa isang halimbawang kaso ng isang solong qubit, at tingnan kung gumagana ito ayon sa ating hinihingi:

Itakda ang $A_0 = \vert 0\rangle\langle 0\vert$ at $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}$$

Dahil ang $\langle 0 \vert \rho \vert 0\rangle$ ay isang numero, maaari lang nating ilipat ang vector na $\vert 0\rangle$ sa kabilang panig nito. Naaangkop din ito sa pangalawang termino. Mayroon tayong:

$$\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}$$

Tandaan na ang mga matrix na ito ay natutugunan ang kinakailangang kondisyon:

$$\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}$$

Mahalagang tandaan na ang pagpili na ito ng mga Kraus matrix ay hindi natatangi (unique).

Paglalarawan ng ingay bilang mga channel

Sa seksyong ito, gagamitin natin ang modelo ng Bloch sphere at ang matematika ng quantum channels upang mas maunawaan ang iba't ibang uri ng ingay at mga error.

Mga incoherent error

Bumalik tayo sa mga incoherent error at partikular na suriin ang mga energy relaxation error. Tandaan na ang state $|0\rangle$ ay ang ground state ng isang qubit at ang state $|1\rangle$ ay may bahagyang mas mataas na enerhiya. Minsan, ang mga quantum state ay basta na lang biglang nabubulok (decay) mula sa mas mataas na antas ng enerhiya patungo sa mas mababa. Ang proseso ng spontaneous emission ay isang mayamang paksa at hindi talaga mauunawaan nang walang paggamit ng quantum field theory. Pero ang intuwisyon ay pamilyar na sa ating lahat: ang mga random na pagkabagabag (perturbations) ay maaaring magdulot ng isang bato na gumulong pababa ng burol; hindi nito magagawang paakyatin ang bato. Kung gaano katagal mananatili ang isang qubit sa mas mataas na state ng enerhiya ay inilalarawan ng isang oras na $T_1$. Mas partikular, ang probability na ang isang qubit na inihanda sa state na $|1\rangle$ ay mananatili sa state na iyon pagkatapos ng oras na $t$ ay $e^{-t/T_1}$. O, katumbas nito, ang probability $p$ ng isang energy relaxation error pagkatapos ng oras na $t$ ay

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

Upang ilarawan ito gamit ang isang quantum channel sa Kraus representation, kailangan natin ng mga Kraus matrix na tumutugma sa

• pananatiling hindi nagbabago ng mga state ng $|0\rangle$
• pagpapalit ng mga state ng $|1\rangle$ tungo sa $|0\rangle$ na may probability na p.

Tukuyin natin

$$\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}$$

Una, tingnan natin kung mayroon itong nais na epekto sa isang density matrix. Isaalang-alang ang isang sistema na nasa purong estado $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Nakita natin sa isang halimbawa sa itaas na ang density matrix para sa kasong ito ay

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

Sa pamamagitan ng paglalapat ng energy relaxation channel gamit ang mga Kraus matrix, makukuha natin ang bagong, na-map na density matrix:

$$\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}$$

Suriin natin ito at ihambing sa ating intuwisyon:

Una, tingnan natin ang limitasyon habang papalapit ang $t$ sa zero. Nakukuha natin muli ang ating orihinal na density matrix, tulad ng inaasahan:

$$\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}}.$$

Habang tumatagal, inaasahan nating tataas ang probability na masukat ang state na $|0\rangle$, at bababa ang probability na masukat ang $|1\rangle$. Ito rin mismo ang nakikita natin, dahil

$$\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}$$

Madali rin nating makikita na ang mga probability ng pagsukat sa $|0\rangle$ at $|1\rangle$ ay kabuuang 1, gaya ng dapat.

Ang eksaktong pag-scale ng mga terminong coherence (off-diagonal) ay lampas sa saklaw ng talakayang ito. Pero malinaw na sa simula ay mayroon tayong perpektong impormasyon ng phase, at pagkatapos ng napakahabang panahon ay wala nang natitirang impormasyon ng phase dahil ganap nang na-relax ang sistema patungo sa state na $|0\rangle$. Kaya naman, kailangang mabulok patungo sa zero ang mga terminong coherence sa napakahabang panahon. Sa katunayan,

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

Marami sa mga hadlang (constraints) sa ating mga Kraus matrix ang hindi tuwirang nasusuri sa pamamagitan ng mga intuwitibong konsiderasyong ito. Dapat suriing mabuti kung natutugunan ang mga hadlang sa mga channel (at partikular sa mga Kraus matrix), pero iiwan natin ito bilang isang ehersisyo para sa mambabasa.

Sa graphical na paraan, ang ganitong uri ng channel ay maaaring ilarawan gamit ang isang Bloch sphere. Ang isang purong state ay nasa ibabaw ng isang Bloch sphere. Ang mga mixed state naman ay lumilipat sa loob ng sphere at kumakalat palayo mula sa iisang punto. Ang pagsasama ng classical probabilities ay makikita sa pagbawas ng absolutong distansya mula sa origin patungo sa alinman sa mga state sa halo, at ang pagkalat mula sa iisang punto patungo sa isang rehiyon ay nagpapahiwatig ng paghahalo ng maraming posibleng state. Sa espesyal na kaso ng isang energy relaxation channel, ang mixed state (density matrix) pagkatapos ng ilang makabuluhang panahon ay magmumukhang katulad ng larawan sa ibaba: isang rehiyon sa loob ng Bloch sphere, na lumipat pataas patungo sa polo ng $|0\rangle$, at umikli kapwa sa kahabaan ng axis na $Z$, gayundin sa kahabaan ng $XY$ plane, bagama't mas kaunti kumpara sa $Z$.

Tandaan na ang rehiyon ay hindi isang "cap" sa Bloch sphere, kahit na minsan ay ganito ang lumalabas sa isang perspective rendering. Tulad ng malinaw na makikita sa video, ito ay isang oblate spheroid, na umikli at lumipat patungo sa state na $|0\rangle$. Ang mga noise channel (at mga channel sa pangkalahatan) ay siyempre naaangkop sa mga sistema ng anumang laki. Pero ang paglalarawan sa kanila nang biswal (gaya ng gamit ang isang Bloch sphere) ay nagiging mahirap habang tumataas ang bilang ng mutually orthogonal na mga state sa Hilbert space.

Suriin ang iyong pag-unawa

Patunayan na ang mga Kraus matrix na ginamit sa energy relaxation channel sa itaas ay natutugunan ang kondisyon ng identity:

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

Sagot

$$\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}$$

Magpapakita tayo ng dalawa pang uri ng incoherent noise channel, pero iiwan natin ang karamihan sa interpretasyon at pagpapatunay bilang mga ehersisyo. Ang susunod ay ang dephasing channel, na naglalarawan ng pagkawala ng impormasyon ng phase, ngunit may pagpapanatili ng mga amplitude. Bagama't posible pa ring magkaroon ng kapwa classical at quantum mechanical na probabilities na kasangkot sa kabuuang probability ng pagsukat, ang pagkawala ng impormasyon ng phase ay kadalasang inilalarawan bilang isang pagkawala ng quantum na impormasyon, o bilang pagiging mas klasiko ng sistema.

Sa halos parehong paraan na inilarawan ang energy relaxation gamit ang katangiang oras na $T_1$, ang mga dephasing error ay inilalarawan ng isa pang parametrong oras na $T_2$. Ang probability ng isang dephasing error pagkatapos ng oras na $t$ ay ibinibigay ng

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

Ang isang set ng mga Kraus matrix para sa dephasing channel sa isang solong qubit, sa mga tuntunin ng probability na ito, ay ang mga sumusunod:

$$\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}$$

Ang resulta ng dephasing channel na ito ay biswal na ipinapakita gamit ang isang Bloch sphere sa larawan sa ibaba.

Tandaan na hindi nagbabago ang mga amplitude, kaya ang anumang state na eksaktong nahuhulog sa isang polo ($|0\rangle$ o $|1\rangle$) ay hindi apektado at nakamap pa rin sa ibabaw ng sphere sa shaded na rehiyon. Pero nawawala ang impormasyon ng phase, na tumutugma sa pag-ikli ng shaded na rehiyon sa buong $XY$ plane. Isang paraan para maunawaan ito: ang anumang posibleng quantum state ay maaari pa ring magkaroon ng malinaw na tinukoy na phase, pero dahil may classical probability na makahanap ng ilang state na may iba't ibang malinaw na phase, ang kabuuang probability ng anumang isang malinaw na phase ay nababawasan.

Suriin ang iyong pag-unawa

Patunayan na ang mga Kraus matrix na tinukoy sa itaas para sa dephasing channel ay natutugunan ang kondisyon ng identity:

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

Sagot

$$\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}$$

Magsimula sa isang purong estado ng iisang qubit na iyong pipiliin, na may malinaw na tinukoy na phase sa pagitan ng $|0\rangle$ at $|1\rangle$. Isulat ito bilang isang density matrix. Ilapat ang dephasing channel gamit ang mga Kraus operator na iminungkahi sa itaas. Bigyang-kahulugan ang resultang, na-map na density matrix.

Sagot

Piliin natin ang state na $|\psi\rangle = \frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle$. Ang kaukulang density matrix na $\rho$ ay

$$\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}$$

Ngayon, ilalapat natin ang dephasing channel sa density matrix na ito gamit ang mga Kraus operator.

$$\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}$$

Una, mapapansin natin na ang kabuuan ng mga diagonal ay talagang katumbas ng isa, gaya ng dapat. Pangalawa, tandaan na ang mga off-diagonal na elemento ay simula pa lang malaki na, na may kabuuang 24/25, na nagpapahiwatig ng matibay na coherence. Tandaan na habang tumataas ang probability ng isang dephasing error na $p$, bumababa ang mga off-diagonal na elementong ito. Tugma rin ito sa ating inaasahan. Isang subtlety: tandaan kung ano ang mangyayari habang $p\rightarrow 1$. Muling nagiging matibay ang coherence! Mukhang kontra-intuwisyon ito sa simula, dahil ang mataas na probability ng isang dephasing error ay dapat gumulo sa ating phase, tama ba? Ang catch dito ay kung 100% tayong sigurado na nangyari ang isang phase error, muli tayong magkakaroon ng matibay na impormasyon tungkol sa phase; nabaligtad lang talaga ang phase. Sa insight na ito, maaari nating asahan na ang pinakamasamang impormasyon ng phase ay tumutugma sa 50-50 na tsansang mangyari ang isang phase error, at iyon nga mismo ang ating nakikita.

Ang huli nating halimbawa ng isang noise channel na naglalarawan ng mga incoherent error ay ang Pauli noise channel. Inilalarawan ng channel na ito ang paglitaw ng tatlong uri ng error na may independiyenteng mga probability:

• Bit-flip error (X error) na may probability na $p_x$
• Phase-flip error (Z error) na may probability na $p_z$
• Pinagsamang X at Z (Y error) na may probability na $p_y$ Dito, $0\leq p_j \leq 1$ para sa lahat ng $j$. Isang corollary nito ay ang probability na walang mangyayaring error ay $p_I = 1-p_x-p_y-p_z$.

Ang mga Kraus operator para sa channel na ito ay:

$$\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}$$

Sa kaso ng Pauli noise channel, kapaki-pakinabang na isulat ang channel mismo:

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

Makikita natin mula sa anyong ito na ipinapatupad ng Pauli noise channel ang isa o higit pang mga error na katumbas ng aksyon ng mga Pauli matrix na $P_j$, bawat isa ay may probability na $p_j$.

Ang iba't ibang kombinasyon ng mga probability ng flip ay magbubunga ng iba't ibang biswal na representasyon. Dito, biswal nating ipinapakita ang espesyal na kaso kung saan $p_X = p_Y = p_Z$, na tinatawag ding depolarizing channel.

Pagmomodelo ng mga coherent error

Ang mga quantum channel ay maaaring maglarawan ng kapwa coherent at incoherent na error, pero sa praktika, ginagamit ang mga ito higit sa lahat para sa mga incoherent error dahil mas mahusay na inimomodelo ang mga coherent error bilang unitary miscalibration o kina-convert sa mga stochastic channel para sa mas madaling pagsusuri. Sa seksyong ito, ipakikilala natin ang mga approach na mas naaangkop sa mga coherent error.

Ang mga coherent error ay maaaring imodelo gamit ang mga hindi ninanais na unitary gate. Ang ilang simpleng halimbawa ay may kasamang mga misaligned na rotation o under-/over-rotation. Sa larawan sa ibaba, ipinapakita natin ang isang misaligned na rotation bilang karagdagang $Y$ rotation na may maliit na halagang $\epsilon$ bukod pa sa nais na rotation tungkol sa $X$ axis. Ang isang over-rotation ay inilalarawan ng nais na $X$ rotation at karagdagang rotation din sa paligid ng parehong axis na $X_\epsilon$.

Mga two-qubit error at shaded light cones

Ang isang single‑qubit gate ay umiikot sa isang nakahiwalay na qubit. Ang isang two‑qubit gate ay nagpapatupad ng lohika na umaasa sa dalawang qubit, pero hindi ito maaaring gumawa ng direktang pagsukat sa alinman sa dalawang qubit; kailangan nito, samakatuwid, na buksan ang isang interaksyon sa pagitan ng mga qubit. Ang interaksyong ito ang dahilan kung bakit tayo makagagawa ng entanglement, at dito rin nanggagaling ang karamihan sa noise, crosstalk, at hirap sa calibration. Ang interaksyong ito sa pagitan ng mga qubit ay nagbibigay-daan din sa pagkalat ng mga error. Kung ang isang qubit ay may ilang error, at ito ay nagsisilbing control qubit para sa isa pang target qubit, maaaring maipasa ang error sa target. Sa araling ito, susuriin natin kung ano ang ibig sabihin ng mga two-qubit gate para sa mga error rate at ang pagkalat ng mga ito sa loob ng isang circuit.

Mga echoed cross-resonance gate

Ang iba't ibang hardware architecture at gate family ay nag-e-engineer ng interaksyong iyon sa iba't ibang paraan. Ipinapatupad ng mga IBM quantum computer ang mga abstract na two-qubit gate gaya ng CZ o CX gate gamit ang hardware-native na echoed cross-resonance (ECR) gate. Ang mga ECR gate ay bumubuo ng epektibong interaksyong $ZX$ gamit ang isang microwave drive. Ang mga kaugnay na gate gaya ng CNOT ay binubuo mula sa $ZX$ sa pamamagitan ng pagdaragdag ng mga single‑qubit rotation.

Ang iba't ibang qubit ay may iba't ibang resonant frequency (mga frequency na kung saan malakas silang tumutugon). Ang isang karaniwang operasyon ay maaaring gumamit ng resonant frequency na iyon upang mag-udyok ng isang transition sa isang qubit. Pero ano ang mangyayari kung i-drive mo ang qubit C sa resonant frequency ng isang katabing qubit T? Ang mga katabing qubit ay naka-link sa pamamagitan ng isang fixed na capacitive o resonator‑mediated na interaksyon. Dahil sa coupling na ito, ang isang drive sa qubit C ay "tumatagos" (leaks through) papunta sa Hamiltonian ng qubit T. Ang lakas at direksyon ng epektibong drive na ito ay depende sa estado ng qubit C ($|0\rangle$ o $|1\rangle$). Dito, ang qubit C ay ang control at ang qubit T ay ang target.

Ang resulta ay isang epektibong target‑qubit rotation na nakabatay sa estado ng control qubit. Sa matematika:

$$H_{eff} \approx \Omega Z_C X_T +\text{iba pang termino}$$

Itong ZX interaction ang eksaktong kailangan mo upang bumuo ng isang CNOT. Pero ang iba pang termino ay maaaring may kasamang ilang error, at halos tiyak na may kasamang capacitive coupling sa pagitan ng mga qubit C at T, na katumbas ng isang ZZ term.

$$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}}.$$

Maaari nating isipin ang mga karagdagang terminong ito sa sumusunod na paraan:

• IX = hindi sinasadyang na-drive ang target

• ZI = nakakakuha ang control qubit ng hindi ninanais na Z rotation

• IZ = nakakakuha ang target qubit ng hindi ninanais na Z rotation

• ZZ = static na phase shift na nakadepende sa estado

• iba pa = maliliit na XY, XX, at mas mataas na antas na interaksyon

Ang isang ECR gate ay simpleng isang controlled rotation kasama ang isang maingat na piniling echo pulse sa control qubit. Binabaligtad ng echo ang sign ng maraming hindi ninanais na termino habang pinapanatili ang ZX interaction. Kanselado nang mabuti ng prosesong ito ang mga error na IX at ZI, at kung minsan ay ilang mas mataas na antas na termino. Pero hindi makakansela ng echoing ang static na ZZ coupling dahil nagko-commute ito sa echo pulse. Mayroong ibang interaksyon na hindi makakansela sa prosesong ito: ilang residual na nonlinearity at spectator‑qubit effect, leakage at long‑range na drive contamination, kasama ang iba pa — pero lalong mahalaga ang ZZ term.

Ang prosesong ito ay kadalasang nangangailangan ng drive time na isang order of magnitude na mas mahaba kumpara sa single-qubit gate. Ang kombinasyon ng mas mahabang drive time, patuloy na ZZ term sa Hamiltonian, at mga imperpeksyon sa coupling ang naggagawa sa mga two-qubit gate bilang pangunahing pinagmumulan ng mga error sa gate. Tandaan din na kung kailangan ng interaksyon sa isang circuit sa pagitan ng mga qubit na hindi magkatabi, ang kinakailangang mga SWAP gate ay malinaw ding mga two-qubit gate. Ito ang dahilan kung bakit ang standard na sukatan na may kaugnayan sa depth ay: two-qubit, transpiled depth. Higit nating binibigyang-pansin ang mga two-qubit gate dahil dominante ang mga ito sa error ng gate, at kailangan nating tingnan ang mga transpiled circuit dahil ang transpilation ay kadalasang nagpapakilala ng maraming karagdagang two-qubit gate sa anyo ng mga SWAP gate.

Suriin ang iyong pag-unawa

Ipaliwanag kung bakit higit nating binibigyang-pansin ang two-qubit transpiled depth. Siguraduhing isaalang-alang ang mga hadlang ng hardware, at ang katotohanang maaaring mas malaki nang malaki ang single-qubit gate depth.

Sagot

Ang mga two-qubit gate ay may mas mataas na error rate kumpara sa mga single-qubit gate. Hindi perpekto ang mga single-qubit gate, kaya may mga kaso kung saan kapaki-pakinabang ding isaalang-alang ang single-qubit depth. Pero ang two-qubit gate depth ang kadalasang dominante sa pag-uugali ng error ng isang circuit. Kailangan nating isaalang-alang ang transpiled circuit. Ang mga modernong quantum computer ay walang all-to-all na koneksyon ng qubit. Ang mga IBM quantum computer ay gumagamit ng alinman sa isang square lattice o isang "heavy hex" lattice, ibig sabihin, may 2, 3, o 4 na pinakamalapit na kapitbahay ang mga qubit na maaaring direktang ikonekta gamit ang isang solong two-qubit gate. Ang anumang entanglement sa ibang, hindi magkatabing qubit ay nangangailangan ng paglipat ng impormasyon sa quantum computer gamit ang mga two-qubit SWAP gate. Kaya naman, ang transpilation ay kadalasang nagpapataas ng two-qubit gate depth. Para sa mga highly-entangling na circuit, ang pagtaas na ito ay maaaring napakalaki.

Mga shaded light cone

Ipagpalagay na ang isang solong qubit ay lubos na nakahiwalay mula sa lahat ng iba pa. Ang isang error sa qubit na iyon ay hindi magdudulot ng anumang error sa ibang mga qubit. Pero kapag nakikipag-ugnayan ang isang qubit sa iba, maaaring kumalat ang mga error. Ang paraan ng pagkalat ng mga error ay depende sa paraan ng pakikipag-ugnayan ng mga qubit. Isaalang-alang ang circuit sa ibaba. Ipagpalagay na ang anumang mga qubit na magkatabi sa circuit diagram ay magkatabi rin sa quantum chip (ibig sabihin, hindi na kakailanganing i-swap ang impormasyon papunta sa ibang mga qubit upang mapadali ang mga interaksyong inilarawan).

Bagama't maaaring hindi mo ito naisip sa ganitong paraan, ito ay isang uri ng spacetime diagram. Ang vertical axis sa isang quantum circuit ay kumakatawan sa iba't ibang qubit na nakaayos sa espasyo. Ang horizontal axis ay kumakatawan sa oras kung saan inilalapat ang isang sunod-sunod na gate. Sa paghiram ng wika mula sa relativity, ang isang light cone ay kumakatawan sa rehiyon ng spacetime na maaabot mula sa isang punto sa pamamagitan ng mga causal na interaksyon.

Sa larawan sa itaas, hindi pa tinukoy ang uri ng error. Lumalabas na ang uri ng error ay nakaka-apekto sa light cone dahil may mga error na nakaka-apekto sa lohika ng isang two-qubit gate, at may mga hindi naman. Babalikan natin ito sa madaling panahon. Sa ngayon, isaalang-alang ang mga dilaw na linya bilang mga landas ng posibleng pagkalat ng isang uri ng error. Obserbahan, halimbawa sa bahagi (a) ng larawan, na ang isang single-qubit error sa RZ gate sa qubit 4 ay makakalat lang pasulong sa oras sa iisang qubit na iyon. Hindi ito maaaring kumalat sa ibang mga qubit dahil hindi entangled ang qubit 4 sa anumang ibang qubit. Ito ay isang magandang pagkakataon para tandaan na medyo walang silbi ang qubit 4 sa circuit na ito, at sa katunayan, ang buong circuit ay binuo para sa layuning pedagogical lamang.

Ang isang error sa Z gate ng qubit 0 (hindi kinakailangang isang Z-error, basta't may error sa lokasyong iyon), gayunpaman, ay maaaring kumalat sa isa pang qubit: qubit 1, sa pamamagitan ng huling CNOT na gumagamit ng qubit 0 bilang control at qubit 1 bilang target. Ipinapakita ito sa bahagi (b). Gaya ng maaari mong asahan, ang isang error na mas maaga sa circuit ay kadalasang may pagkakataong kumalat sa mas maraming qubit. Ipinapakita sa bahagi (c) na ang isang error sa paunang paghahanda ng estado ng qubit 0 ay maaaring kumalat sa lahat ng qubit maliban sa qubit 4, na nakahiwalay.

Ipinapakita ng setup na ito kung paano makakalat ang isang error pasulong sa oras upang makaapekto sa mga pagsukat. Pero maaari mo ring suriin ang kabaligtarang tanong: para sa isang partikular na single-qubit measurement, aling mga bahagi ng aking circuit ang maaaring nagbigay ng ilang error dito? Sa kasong iyon, magsisimula ka lamang sa pagsukat o iba pang punto ng interes at gagalaw paatras (sa oras) sa buong circuit, sinusundan ang anumang entangling na circuit gaya ng ipinapakita sa bahagi (d). Ipinapakita rin ang ilang random na napiling mga punto para maganap ang mga error.

Sa larawan sa itaas, kumakalat ang mga error sa pagitan ng mga qubit sa pamamagitan ng mga ECR gate, pero maaaring ilapat ang katulad na talakayan sa ibang mga two-qubit gate. Ang mga gate na ito ay may control at target. Malinaw na ang isang error sa control ay maaaring makaapekto sa lohika ng gate at sa gayon ay magresulta sa isang error sa target. Pero paano naman sa kabaligtarang direksyon? Maaari bang kumalat ang isang error sa target patungo sa control qubit? Alalahanin na ang coupling sa pagitan ng control at target para sa mga ECR gate ay hindi purong uring ideal na ZX; mayroon din itong hindi ninanais na ZZ coupling.

Kung ang isang error sa target ay nagko-commute sa ZZ coupling, hindi ito makakalat patungo sa control qubit. Makikita natin ito sa pamamagitan ng mga pisikal na mekanismong nagaganap. Isang mabilis na paraan para makita ito ay kung ang isang error na $E$ ay nagko-commute sa $ZZ$, maaaring baliktarin ang kanilang pagkakasunod-sunod nang hindi naaapektuhan ang kinalabasan. Gayunpaman, kung ang $E$ na nangyayari bago ang $ZZ$ coupling ay katulad ng kumikilos ito pagkatapos ng $ZZ$ coupling, hindi ito maaaring makaapekto sa control, dahil sa huling kaso, kailangang gumalaw pabalik sa oras ang error. Kung hindi nagko-commute ang isang error sa ZZ coupling, maaari nga itong kumalat mula sa target pabalik sa control. Kaya naman, sa kaso ng isang ECR gate, hindi makakalat ang mga Z error mula sa target patungo sa control, pero maaari ito sa mga X o Y error.

Suriin ang iyong pag-unawa

Sa bahagi (d) ng larawan sa itaas, tingnan ang mga vertical na linya sa pagitan ng qubit 0 at 1. Tama bang maaaring kumalat ang ilang error sa mga linyang iyon? Muli, maaaring depende ito sa uri ng error, at hindi pa natin ito natatalakay. Ang tanong ay kung mayroong anumang error na maaaring kumalat gaya ng ipinapakita ng mga vertical na linyang iyon. Ipaliwanag.

Sagot

Oo, tama sila. Sa pagguhit ng light cone paatras mula sa pagsukat, maaaring parang sinasabi mo na may kumikilos mula sa target patungo sa control. Gayunpaman, ang kahulugan ng diagram ay talagang ang isang error ay maaaring gumalaw mula sa control (qubit 0) patungo sa target (qubit 1) upang magdulot ng error sa punto ng interes. Kung ang iyong intuwisyon ay depende ito sa uri ng error, ganap kang tama. Bahagyang tinatalakay ito sa susunod na seksyon.

Magsimula sa isang bersyong walang error ng mga circuit sa diagram sa itaas, subaybayan ang posibleng pagkalat ng isang error sa unang Hadamard gate na kumikilos sa qubit 2. Ilista ang lahat ng mga qubit na maaaring maapektuhan sa katapusan ng circuit kung ang error ay (a) isang phase flip, at (b) isang bit flip. Hint: isipin kung paano ginagamit ang impormasyon sa bawat qubit.

Sagot

(a) Maaaring maapektuhan ang qubit 3, gayundin siyempre ang qubit 2 mismo. Wala nang iba! Kung inilista mo ang mga qubit 0 at 1, tandaan na ang qubit 2 ay ang target ng ECR na nag-e-entangle dito kasama ang qubit 1. Walang pagbabagong ginawa sa qubit 1 sa gate na iyon. (b) Maaaring maapektuhan ang mga qubit 0-3. Ang bit flip o X-type na error ay hindi nagko-commute sa ZZ coupling sa ECR gate at sa gayon ay maaaring kumalat mula sa target patungo sa control.

Pagkalat ng error

Sa naunang seksyon, tinalakay natin ang pagkalat ng error nang hindi ito binibigyan ng pormal na kahulugan. Simula ngayon:

Para sa isang error na $E$ na nangyayari bago ang ilang bahagi ng lohikal na payload ng isang circuit na $U$, ang pagkalat ng error ay nangangahulugan ng paghahanap ng katumbas na operator na $E'$ na muling gumagawa ng parehong maling kinalabasan kapag inilapat pagkatapos ng $U$ sa halip na bago ito.

$$\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 }$$

Ipinahiwatig ng larawan ng pagkalat ng error sa naunang seksyon na maaaring kumalat ang mga error mula sa control qubit patungo sa target qubit sa kabuuan ng isang CNOT gate. Isang paraan upang tingnan kung kailan ito totoo ay ang isaalang-alang ang isang error sa control o sa target bago ang entanglement, at tingnan kung ang operator na iyon ay nagko-commute sa CNOT gate. Kung nagko-commute ang dalawang operator, walang pagkakaiba kung ilalapat mo ang mga ito sa kabaligtarang pagkakasunod-sunod, ibig sabihin, ang error ay maaari lamang na "ilipat lampas" (moved past) sa CNOT nang walang anumang epekto sa ibang mga qubit. Ito ang pinakakaraniwang paraan ng paglapit ng mga tao sa pagkalat ng error, at nagbubunga ito ng mga sumusunod na patakaran:

Ipagpalagay na ang control ay qubit 0 at ang target ay qubit 1. Isaalang-alang ang mga X at Z error sa control at target qubit ($X_c$, $Z_c$, $X_t$, at $Z_t$, ayon sa pagkakasunod). Ang paglipat ng mga error na ito lampas sa isang $\text{CNOT}_{0\to1}$ ay nagiging dahilan upang maging:

$$\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}$$

Sinasabi natin ang nasa itaas nang walang patunay. Pero kung katulad ka ng may-akda ng araling ito, at mas gusto ang Schr"odinger picture, maaari mo ring isulat ang arbitrary na control at target state, ilapat ang error, pagkatapos ang CNOT, at suriin ang huling state. Kung ihahambing mo ang huling state na iyon sa isang walang-error na kaso, makikita mo kung anong kombinasyon ng error na inilapat pagkatapos ng CNOT ang magbubunga ng state na may error, at partikular na, makikita mo kung kumalat ang operasyon ng error mula sa isang qubit patungo sa isa pa.

Paunang control	Paunang target	Error	Huli	Katumbas na error pagkatapos ng CNOT
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Wala	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle +\beta\delta \vert 01\rangle$	Hindi naaangkop
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X sa control	$\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 sa control	$\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 sa 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 sa 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$

Marahil nakakagulat, ang isang Z error sa target ay talagang nagdudulot ng isang error na kumakalat pabalik sa control!

Gaya ng maiisip mo, ang pagsubaybay sa ganitong pagkalat ng mga error operator pasulong sa mga circuit (o katumbas nito, ang pagpapakalat paatras ng mga operator na susukatin) ay komplikado. May mga tool ang Qiskit para mapadali ito, na ating aaralin sa lesson 6 tungkol sa mga modernong workflow.

Mayroong Qiskit addon na tinatawag na Shaded Lightcones. Sinusuri ng shaded lightcones (SLC) addon ang pagkalat ng error sa mga quantum circuit sa pamamagitan ng paggamit ng Pauli propagation upang tukuyin kung aling mga bahagi ng isang circuit ang talagang nakaka-impluwensya sa isang target observable. Ito ay idinisenyo pangunahin upang gawing mas mahusay ang error mitigation, lalo na para sa mga workflow ng probabilistic error cancellation (PEC). Maiksi lamang nating tuklasin ang tool na ito dito, at mas malawak itong gagamitin sa konteksto ng mga teknik ng error mitigation sa mga susunod na aralin. Gumagamit ito ng Pauli operator propagation upang i-map ang pagkalat ng mga error ng iba't ibang uri, na gumagawa ng isang light cone para sa mga X, Y, at Z type na error.

Ang Shaded lightcones (SLC) ay mas malayo pa ang inaabot, gamit ang classical simulations para mas mahigpit na i-bound ang sensitivity sa mga error sa buong circuit. Ito ay nagpapalit ng ilang QPU time para sa CPU time at binabawasan ang sampling overhead na kailangan para i-renormalize ang bias. Sa halip na hard cutoff, ang bawat potensyal na error sa circuit ay binibigyan ng graded na “shade” na nagbibigay ng upper bound sa susceptibility ng observable sa error na iyon. Ang refined characterization na ito ay nagbibigay-daan para sa mas efficient at targeted na aplikasyon ng PEC na may mas mababang variance, habang binibigyan ang user ng kakayahang i-control ang pag-tune ng bias sa observable estimation. Tingnan ang Lightcone shading for classically accelerated quantum error mitigation para sa karagdagang detalye.

Hindi namin ipapakita ang buong workflow dito. Ipapakita lang namin nang diagrammatically kung paano tinatanggap ng workflow na ito ang isang circuit:

Hinihiwalay ng workflow ang circuit sa "mga kahon" na kapaki-pakinabang para sa pag-aaral ng noise behavior:

Sa huli, ginagamit nito ang operator propagation at noise learning para makabuo ng shaded map ng error susceptibility sa buong circuit:

Ang bawat kulay na box sa output ay tumutugma sa isang partikular na qubit sa isang partikular na oras. Ang pinakamadilim (purple) na mga box ay nagpapahiwatig ng qubit at layer kung saan hindi maaaring kumalat ang error patungo sa measurement(s) na pinag-uusapan. Ang pinakamaliwanag (yellow) na mga box ay tumutugma sa isang qubit at layer kung saan malaki ang maaaring maging impluwensya ng error sa measurement(s) na pinag-uusapan.

Pansinin ang purple na mga rehiyon sa kanan ng bawat map. Ang isang error sa parehong layer kung saan may measurement, pero sa ibang qubit, ay hindi makakaapekto sa measurement dahil sa circuit connectivity na ipinapakita. Katulad nito, ang isang error na isang layer pabalik sa oras (isang layer sa kaliwa) ay maaari lang kumalat sa katabing qubit sa susunod na hakbang, dahil sa structure ng entangling layer, at iba pa. Kaya karaniwan ang cone shape sa kanan kapag medyo kaunti lang na qubit ang kasangkot sa measurement na pinag-uusapan.

Suriin ang iyong pagkaunawa

Sa tingin mo, mas mabuti bang gumawa ng shaded lightcone map bago o pagkatapos ng transpilation? Bakit?

Sagot

Kailangan itong gawin pagkatapos ng transpilation. Para maging kapaki-pakinabang ang iba't ibang maps na ito, kailangan nating siguraduhin na ang katabing qubit sa ating circuit ay tumutugma sa katabing qubit sa ating quantum chip. Kung hindi, ang mga entangling gate na ipinapakita na kumikilos sa katabing qubit sa circuit diagram ay mangangailangan ng SWAP gates at mas komplikadong circuit structure.