Rumore ed errori

Questa lezione introdurrà il rumore e gli errori quantistici, incluse molte delle loro fonti, tracciando analogie con gli errori classici. Comprendere i tipi di errori che possono verificarsi, e la capacità di modellare il rumore utilizzando i canali quantistici, sarà fondamentale per comprendere le lezioni future. Infatti, la maggior parte dei metodi di gestione degli errori richiede che sappiamo qualcosa sul tipo di rumore o errori che cerchiamo di ridurre o correggere.

Questo video fornisce una panoramica del rumore e degli errori ed evidenzia alcuni risultati computazionali. Il testo seguente aggiunge maggiori dettagli ed esplora alcuni tipi di errori utilizzando Qiskit.

Cause

Rumore ed errori classici

Per comprendere gli errori e il rumore quantistici, iniziamo dall'analogo classico. Gli errori nei computer classici si verificano per svariati motivi, tra cui molteplici meccanismi di accumulo spurio di carica, eventi singoli (single-event upsets) e lenta degradazione dei materiali. Alcuni di questi meccanismi (non tutti) hanno analoghi nel calcolo quantistico e saranno fondamentali per comprendere gli errori e il rumore quantistici. Ne esaminiamo brevemente alcuni prima di passare agli analoghi quantistici.

Rumore termico:

Quando i componenti di un computer si riscaldano, il moto termico degli atomi e dei portatori di carica modifica la resistività del materiale (di solito aumentandola). Ciò significa che la resistenza nel circuito può variare. Sebbene raro, questo può portare a una transizione logica spuria in un transistor. Sebbene piccole variazioni siano inevitabili, un adeguato raffreddamento dei componenti è fondamentale per evitare questi effetti.

Danno termico e degradazione:

Il ripetuto riscaldamento e raffreddamento dei materiali può causare una migrazione molto lenta degli elementi conduttivi (metalli). Nel migliore dei casi, questo modifica la resistenza o la capacità (o entrambe) degli elementi del circuito e porta a un'imprecisione nella tempistica del funzionamento del circuito. Nel peggiore dei casi, provoca un cortocircuito o un guasto grave. Anche in questo caso, un adeguato controllo della temperatura è fondamentale per prevenire questo tipo di degradazione.

Effetti indotti da radiazioni (single-event upsets, SEU):

A volte, particelle ad alta energia possono ionizzare gli atomi all'interno di un processore e provocare una carica spuria. Se ciò accade nel posto e nel momento sbagliati, può portare a errori logici. La fonte di queste particelle ad alta energia (comprese le radiazioni elettromagnetiche e i neutroni) è tipicamente costituita da interazioni ad alta energia nell'alta atmosfera. Questi eventi sono quindi più comuni in ambienti ad alta quota, incluso lo spazio. Vengono affrontati utilizzando codici di correzione degli errori e progettazioni resistenti alle radiazioni.

Interferenza elettromagnetica:

Gli errori possono anche essere causati da campi elettromagnetici (EM) esterni provenienti da linee elettriche di commutazione, trasmettitori radio o altri componenti del sistema. Questo è diverso dalla radiazione ad alta energia del fenomeno precedente. In questo caso, campi EM vaganti e dipendenti dal tempo inducono corrente e tensione nei componenti di calcolo (anziché ionizzare un particolare atomo in un singolo evento). Poiché la dipendenza temporale dei campi è un fattore determinante per le tensioni indotte, questo tipo di interferenza è particolarmente importante nei sistemi ad alta frequenza. Questi errori possono essere contrastati tramite schermatura e messa a terra, tra le altre cose.

Crosstalk tra interconnessioni:

L'accoppiamento capacitivo o induttivo tra conduttori adiacenti, specialmente nei circuiti integrati su scala nanometrica, può portare a segnali spuri. Questo è legato all'interferenza elettromagnetica, ma è diverso perché la fonte del campo problematico è un altro componente all'interno del circuito del computer. Pensa a due fili molto vicini tra loro. Se il filo A subisce una transizione improvvisa (variazione di tensione), può indurre correnti nel filo adiacente B. La direzione e l'entità esatte dipendono dal layout del circuito; potrebbe trattarsi di un flusso netto e coerente di carica o di qualcosa di più simile a correnti parassite di carica. Ma in alcuni casi ciò può portare a transizioni logiche indesiderate. Questi effetti di crosstalk possono essere mitigati tramite una spaziatura ottimale del layout, la schermatura e tempi di salita del segnale controllati.

Questo non è un elenco completo, ma è sufficiente per iniziare a vedere i paralleli con il calcolo quantistico. Nota che in tutti i tipi di interazioni indesiderate sopra descritte, la manifestazione del rumore come errore logico può assumere solo la forma di uno 0 che diventa 1, o di un 1 che diventa 0. Questo è tutto ciò che è consentito nello spazio degli stati dei bit classici.

Rumore ed errori quantistici

Nel calcolo quantistico, il rumore e gli errori vengono spesso discussi insieme, ma è importante riconoscere la differenza. Il rumore quantistico si riferisce al disturbo fisico sottostante che colpisce i qubit e i sistemi quantistici. Include tutte le forme di interazioni o fluttuazioni indesiderate provenienti dall'ambiente, controlli imperfetti o difetti hardware che fanno allontanare lo stato quantistico da quello ideale. Gli errori quantistici sono le deviazioni o i difetti specifici nell'informazione quantistica che derivano dal rumore quantistico. Gli errori quantistici sono le manifestazioni misurabili o operative del rumore, e gli errori includono bit-flip, phase-flip, smorzamento dell'ampiezza (amplitude damping) e altro ancora. Sia il rumore che gli errori possono verificarsi in modo continuo. Ad esempio, il campo utilizzato in un gate quantistico potrebbe essere errato dello 0,1%, dello 0,15% o di qualsiasi altra frazione. Questo potrebbe portare a una fase su un qubit che è errata, anch'essa di qualsiasi entità continua. Ma vedrai che, in pratica e specialmente nella correzione degli errori, è comune vedere gli errori trattati come se fossero discreti: raggruppando gli effetti accumulati in un bit-flip discreto o in un'unica rotazione di fase. Questo è utile per correggere gli errori e caratterizzarli, ma non significa che l'effetto del rumore su un qubit sia esclusivamente un insieme discreto di errori.

Esistono molti tipi di rumore che influenzano i computer quantistici. Alcuni possono provocare più tipi di errori, mentre altri sono associati a manifestazioni di errore specifiche. Un elenco completo va oltre lo scopo di questa lezione; ecco un elenco parziale rilevante per il resto di questo corso, alcuni con paralleli al rumore del calcolo classico.

Thermal:

I due stati di base computazionali $|0\rangle$ e $|1\rangle$ di un qubit sono separati da una quantità di energia molto piccola. Il valore esatto dipende, ovviamente, dall'hardware quantistico. Per i qubit a stato solido (transmon a frequenza fissa) come quelli utilizzati da IBM Quantum®, il divario energetico tra questi stati è dell'ordine di $10^{-24}$ J, ovvero pochi microelettronvolt. Questa scala di energia può essere collegata alla frequenza tramite $E=hf$ o a una temperatura caratteristica. Poiché la temperatura è legata all'energia cinetica media delle particelle in un campione, possiamo usare la costante di Boltzmann per ottenere una stima della temperatura alla quale le particelle medie avrebbero abbastanza energia da causare una transizione:

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

Per ridurre la probabilità che le interazioni termiche causino transizioni da uno stato di base computazionale del qubit a un altro, la temperatura dei qubit deve essere mantenuta sostanzialmente al di sotto di 100 mK, idealmente più vicina a 15-25 mK. Qualsiasi aumento significativo della temperatura al di sopra di queste soglie provocherebbe un'occupazione totalmente casuale degli stati e una perdita totale dell'informazione quantistica.

Questo è analogo agli errori termici che possono verificarsi nei computer classici, in quanto entrambi hanno origine termica — ma la scala di temperatura è ovviamente diversa, così come il meccanismo di perdita dell'informazione.

Crosstalk e interferenza:

Il crosstalk nel calcolo quantistico si riferisce a qualsiasi accoppiamento o interferenza indesiderati tra qubit o linee di controllo, tale per cui un'operazione o un segnale destinati a un qubit influenzano inavvertitamente altri qubit. Si manifesta come errori o correlazioni tra qubit che idealmente dovrebbero essere indipendenti.

Nelle architetture a qubit superconduttori come quelle utilizzate da IBM®, il crosstalk può derivare da segnali di controllo a microonde che si propagano nei qubit vicini, da un accoppiamento non intenzionale tra i risonatori di lettura, o da crosstalk di flusso tra gli anelli dei qubit.

Molti degli approcci per minimizzare il crosstalk sono incorporati nella progettazione di un computer quantistico, come la spaziatura dei qubit e la garanzia che i qubit adiacenti abbiano frequenze operative diverse. Esistono anche approcci software per mitigare gli errori di crosstalk, che verranno discussi nelle lezioni successive.

Operazioni di gate imperfette:

Le operazioni sui qubit vengono eseguite utilizzando hardware con precisione finita e che può essere soggetto a rumore o ad altre fonti di imprecisione. In particolare, impulsi a microonde di durata e orientamento specifici vengono utilizzati per implementare i gate di rotazione. Supponiamo, ad esempio, che un impulso a microonde debba ruotare di 0,30 radianti attorno all'asse $X$ . C'è una precisione finita nell'orientamento, il che porta a una certa imprecisione nell'asse di rotazione. Inoltre, esiste sempre un compromesso fondamentale tra la frequenza di un impulso e la sua durata. Un impulso molto lungo può avere essenzialmente un comportamento sinusoidale con praticamente un'unica frequenza. Per formare un pacchetto breve, è necessaria una sovrapposizione di molte frequenze. Questo è lo stesso compromesso alla base della relazione di indeterminazione energia-tempo, sebbene la precisione dei gate non stia ancora spingendosi contro questi limiti fondamentali; c'è margine di miglioramento.

Rumore intrinsecamente quantistico:

Quest'ultimo tipo di rumore è piuttosto diverso dagli altri; non è dovuto a errori, ma alla natura della meccanica quantistica. Supponiamo che un qubit nello stato quantistico $|\psi\rangle$ venga misurato e collassi in un autostato ( $|0\rangle$ o $|1\rangle$ ). In un sistema transmon a frequenza fissa, il qubit è accoppiato dispersivamente a un risonatore a microonde la cui frequenza di risonanza dipende leggermente dallo stato del qubit. Un impulso di sonda a microonde viene inviato attraverso il risonatore, e il segnale in uscita acquisisce uno sfasamento e una variazione di ampiezza dipendenti dallo stato. Questo segnale viene quindi amplificato e misurato utilizzando elettronica classica.

A livello quantistico, il segnale di misurazione è portato da un campo a microonde coerente con un numero medio finito di fotoni. A causa della natura quantistica dei campi elettromagnetici, le quadrature del campo mostrano fluttuazioni intrinseche. Queste fluttuazioni sono indipendenti dalle imperfezioni tecniche e si presentano anche per uno stato coerente ideale. Aumentare il numero medio di fotoni $N$ aumenta il segnale di misurazione, ma il livello fondamentale di rumore rimane finito, per cui la distinguibilità tra i risultati migliora solo come $\sqrt{N}$ .

Quindi, anche se il qubit è preparato perfettamente e la catena di misurazione è ideale, il segnale di lettura corrispondente a un dato stato del qubit non è un singolo valore fisso ma una distribuzione che limita quanto bene i risultati possano essere distinti. Questa sovrapposizione rappresenta una fonte fondamentale di incertezza nel processo di misurazione stesso. In pratica, sebbene il rumore tecnico proveniente da amplificatori e altri componenti spesso domini, questo rumore quantistico intrinseco stabilisce un limite inferiore alla fedeltà di lettura.

L'incertezza non è errore:

Queste fonti di rumore sono tutte diverse dall'incertezza fondamentale associata alle misurazioni degli stati quantistici. Per contrasto, supponiamo di avere un qubit in uno stato quantistico:

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

Questo stato ha il 64% di probabilità di essere misurato nello stato $|0\rangle$ e il 36% di probabilità di essere misurato nello stato $|1\rangle$ . Ma una singola misurazione produrrà solo un $|0\rangle$ o un $|1\rangle$ — quindi una singola misurazione raramente ci dirà molto sullo stato prima della misurazione. Sono necessarie molte misurazioni per ottenere informazioni dettagliate sullo stato. Su dieci misurazioni, potremmo aspettarci che sei o sette diano $|0\rangle$ . Ma non sarebbe sconvolgente se le prime dieci misurazioni dessero tutte $|0\rangle$ (come lanciare una moneta equa e ottenere "testa" dieci volte di fila: insolito, ma del tutto plausibile). Se ripetessimo la misurazione 1000 volte e ottenessimo sempre $|0\rangle$ , quello sì che sarebbe sconvolgente.

Esiste quindi un'incertezza nella nostra conoscenza dello stato quantistico basata su qualsiasi numero finito di misurazioni. Man mano che ripetiamo le misurazioni, la nostra conoscenza dello stato quantistico prima della misurazione migliora, ma non è mai perfetta. Si potrebbe dire colloquialmente che c'è sempre un qualche "errore" sottostante in ogni risultato di misurazione quantistica. Ma questo è un uso diverso del termine "errore", ed è meglio descritto come incertezza statistica. Il processo di aumento della conoscenza di uno stato quantistico attraverso molte misurazioni è chiamato tomografia dello stato quantistico. La tomografia dello stato quantistico, tuttavia, non si limita alle misurazioni lungo Z; si riferisce generalmente a misurazioni lungo assi ortogonali (come X, Y e Z) per la determinazione delle ampiezze e della fase relativa. Per saperne di più su questo processo, consulta questa sezione nel corso di John Watrous su General Formulation of Quantum Information, oppure, per un'implementazione pratica, consulta questa lezione sul teletrasporto del corso Utility-Scale Quantum Computing.

Osservare gli errori e il loro accumulo

In questa sezione, utilizzeremo computer quantistici reali per osservare gli errori quantistici e il loro accumulo in condizioni diverse. In pratica, molte fonti di errori quantistici sono tipicamente presenti simultaneamente. Per osservare diversi tipi di errori in modo in qualche modo isolato, dovremo utilizzare circuiti progettati per tale isolamento. I circuiti utilizzati nelle applicazioni del calcolo quantistico avranno un aspetto molto più complicato.

Iniziamo con gli errori di rilassamento energetico.

Errori di rilassamento energetico ( $T_1$ )

Ricorda dalla nostra discussione sul rumore termico che, a qualsiasi temperatura diversa da zero, esiste una certa probabilità che un sistema quantistico subisca una transizione tra autostati energetici. Il rilassamento ( $|1\rangle \rightarrow |0\rangle$ ) domina perché è guidato dall'emissione spontanea (indipendente dalla temperatura), mentre la bassa temperatura sopprime il processo di eccitazione concorrente. Più a lungo un qubit resta inattivo, più tempo ha per subire una tale transizione. La probabilità che un qubit preparato nello stato $|1\rangle$ rimanga in $|1\rangle$ dopo un tempo $t$ è data da

p = e^{-t/T_1}

Qui, il tempo $T_1$ è un tempo caratteristico determinato sperimentalmente che è diverso per ogni qubit, e può anche cambiare leggermente nel tempo. I computer quantistici IBM® vengono sottoposti a benchmark regolarmente, quindi i tempi $T_1$ che trovi elencati per i qubit sui computer quantistici IBM dovrebbero essere accurati e aggiornati. Un valore elevato di $T_1$ significa che il qubit rimane più a lungo (in media) nello stato in cui è stato preparato. I valori tipici di $T_1$ differiscono tra le architetture; i qubit nei computer quantistici IBM hanno spesso tempi $T_1$ dell'ordine di 200-300 $\mu s$ , e puoi verificare i valori più recenti nella pagina Compute resources.

Il tempo caratteristico $T_2$ misura qualcosa di diverso: la perdita di informazione di fase. Torneremo su questo più avanti.

Per osservare gli errori di rilassamento energetico, prepareremo i qubit nello stato $|1\rangle$ e poi li lasceremo intenzionalmente inattivi per lunghi periodi di tempo. Questa è la parte artificiale. Nei flussi di lavoro quantistici reali, potresti avere alcuni qubit che restano inattivi per lunghi periodi mentre i processi vengono eseguiti su altri qubit; pertanto, alcune istanze di tali tempi di inattività non sono artificiali.

Iniziamo importando alcuni pacchetti e selezionando il backend meno occupato.

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

Ora selezioneremo un qubit su cui lavorare, in questo caso il qubit zero. Possiamo importare direttamente le proprietà di questo qubit, inclusi $T_1$ e $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

Conoscere $T_1$ in unità di microsecondi è importante, ma potresti non avere una percezione intuitiva di cosa ciò significhi. Dopotutto, le operazioni di gate sui computer quantistici sono molto veloci. La vera domanda è: quanto possiamo fare su un computer quantistico in quella quantità di tempo. A tal fine, è utile mettere in relazione $T_1$ con altre scale temporali utilizzate nel calcolo quantistico — nello specifico con le seguenti:

tempo di campionamento $dt$ - il più piccolo tick di clock su cui i processi di controllo possono essere implementati sul computer quantistico.
tempi dei gate a singolo qubit - il tempo necessario per implementare un'operazione di gate su un singolo qubit. Non sarà un valore unico, ma un intervallo di valori possibili a seconda del tipo di gate.
tempi dei gate a due qubit - il tempo necessario per implementare un'operazione di gate su due qubit adiacenti. Anche questo può assumere un intervallo di valori, ma è tipicamente circa un ordine di grandezza più lungo rispetto a un gate a singolo qubit.

Verifichiamo $dt$ per il nostro backend e mostriamo alcuni intervalli plausibili per i tempi dei gate.

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

# Access the backend target
target = backend.target

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

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

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

    return results

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

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

Using backend: ibm_boston

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

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

Questi tempi dei gate varieranno da backend a backend. Codificheremo manualmente (hard-code) un tempo di gate a due qubit ricavato da ibm_boston di 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

Tieni presente che qui non sono state prese in considerazione altre fonti di errore né la loro soppressione o mitigazione. Gli errori $T_1$ non sono gli unici errori in gioco in un sistema quantistico, quindi non preoccuparti troppo di questi numeri. Ciò significa semplicemente che, in assenza di qualsiasi soppressione, potremmo plausibilmente implementare dell'ordine di migliaia di gate a due qubit prima che gli errori $T_1$ inizino a dominare. Altri errori tipicamente domineranno a profondità molto più basse, e viceversa gli errori $T_1$ potrebbero comunque valere la pena di essere soppressi a tempi molto più brevi di quelli necessari per annullare completamente il segnale.

Inizieremo utilizzando un simulatore con un modello di rumore, e poi confronteremo i risultati con l'hardware reale.

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)

Definiamo un passo temporale per le nostre misurazioni corrispondente alla stima massima per il tempo di un gate a due qubit. Poi costruiremo 50 circuiti a incrementi di quel passo temporale. In questo modo, vedremo cosa succede su una scala temporale simile all'implementazione di 80 gate a due qubit. La precisione qui non è critica, quindi utilizzeremo solo una manciata di shot.

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

Costruiamo un modello di rumore per il nostro simulatore che include esplicitamente gli errori di rilassamento termico.

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

Ora costruiamo i nostri circuiti e osservabili. Sono eccezionalmente semplici. I circuiti consisteranno semplicemente nel preparare il qubit in $|1\rangle$ e nell'implementare ritardi per periodi di tempo crescenti, utilizzando i tempi caratteristici dei gate e $dt$ definiti sopra. Gli osservabili saranno semplicemente $Z$ , perché ciò che vogliamo sapere è se il qubit è rimasto in $|1\rangle$ o è decaduto a $|0\rangle$ . Sebbene la transpilazione non sia sempre necessaria per i simulatori, procediamo comunque a transpilare i nostri circuiti qui per un uso successivo su un backend reale.

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)

Eseguiamo il nostro job utilizzando un simulatore.

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

Infine, tracciamo i risultati in un grafico.

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

Output of the previous code cell

Il decadimento esponenziale è chiaramente visibile e, in questo lasso di tempo, decade fino a poco meno del 40% di probabilità di trovarsi in $|1\rangle$ . Nota che questo è esattamente coerente con il modello: $p = e^{-t/t_1}$ dove abbiamo scelto che il $t$ massimo sia dello stesso ordine di $t_1$ ; ricorda che avevamo detto che $t_1$ potrebbe corrispondere a 60 gate (o quell'ordine di grandezza), e qui $t$ corrisponde a 60 gate. Quindi

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

Ora eseguiamo gli stessi circuiti su un computer quantistico reale. Per coprire la stessa durata di ritardo con meno job, aumenteremo l'unità di ritardo e diminuiremo il numero di punti.

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

Ora tracciamo i risultati in un grafico.

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

Output of the previous code cell

Come possiamo vedere, il decadimento dello stato $|1\rangle$ nel tempo corrisponde alla teoria (e alla definizione di $T_1$ ). Inoltre, in questo caso il simulatore riproduce abbastanza bene il comportamento del computer quantistico reale. Ecco alcune cose da tenere presente riguardo al decadimento di questo stato:

Abbiamo ritardato artificialmente la misurazione per una quantità di tempo irrealistica. Questi ritardi corrispondono alla scala temporale di circuiti estremamente profondi che potrebbero consistere di migliaia di gate a due qubit. Questo è stato fatto solo per mostrare che gli effetti del rumore termico esistono. Nei circuiti reali applicati a problemi del mondo reale, le operazioni verrebbero eseguite su altri qubit mentre alcuni potrebbero restare inattivi abbastanza a lungo perché gli errori di rilassamento energetico diventino rilevanti — ma altri errori dominerebbero prima di raggiungere un $T_1$ completo.
Non è stata utilizzata alcuna tecnica di mitigazione o soppressione degli errori. Possiamo alterare questa curva di decadimento utilizzando le tecniche che impareremo in questo corso.
Qui abbiamo utilizzato solo 100 shot, un numero insolitamente basso perché volevamo solo dimostrare che l'effetto esiste. Nelle applicazioni probabilmente utilizzerai più di 1.000 shot.

Questa prima visualizzazione dell'errore non ha richiesto quasi nessun gate a parte i ritardi (e il singolo gate X utilizzato per preparare $|1\rangle$ ). Vediamo ora un altro esempio incentrato sull'errore di gate.

Errori di gate e accumulo

Quando applichiamo un gate quantistico, ad esempio un gate $X$ , teoricamente questo gate ruota uno stato quantistico di un angolo $\pi$ radianti attorno all'asse $X$ sulla sfera di Bloch, mappando $\alpha |0\rangle + \beta |1\rangle$ in $\alpha |1\rangle + \beta |0\rangle$ tramite

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

Tuttavia, un gate reale è imperfetto. Potrebbe essere orientato in modo imperfetto (causando rotazioni non perfettamente attorno all'asse X) oppure potrebbe causare una rotazione leggermente maggiore o minore di quella prevista. Modelliamo un errore di gate come una pura sovra/sotto-rotazione di un piccolo angolo $\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}

Se un gate imperfetto viene applicato molte volte, i piccoli errori $\epsilon$ possono accumularsi. A volte questi errori multipli causano addirittura uno spostamento dello stato nella stessa direzione ogni volta (un fenomeno chiamato "accumulo coerente", che rivedremo più avanti). Vediamo cosa succede quando applichiamo un vero gate X a un qubit molte volte.

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

Output of the previous code cell

Il valore di aspettazione parte da circa 1,0 come previsto e decade, ma non decade semplicemente a zero! Diventa negativo. Se si trattasse di rumore termico o di interazioni casuali, non renderebbe $|1\rangle$ più probabile da misurare rispetto a $|0\rangle$ . Questo errore è chiaramente diverso. E ha senso nel contesto della nostra discussione su sovra/sotto-rotazione. Se ogni coppia di rotazioni che dovrebbe annullarsi finisce invece per ruotare di un piccolo angolo, molte ripetizioni di questo tipo permetterebbero allo stato di ruotare lentamente da $|0\rangle$ verso $|1\rangle$ .

È improbabile che l'accumulo di errori mostrato qui proceda in modo così pulito in un flusso di lavoro reale. Prima di tutto, abbiamo disattivato esplicitamente la mitigazione degli errori ed eseguito la stessa sequenza ripetitiva di porte per permettere agli errori di accumularsi in modo coerente. Questo viene fatto unicamente per dimostrare che questi errori esistono. Quando utilizziamo tecniche di gestione del rumore (ad esempio, il Pauli twirling), possiamo influenzare il modo in cui l'errore si accumula, spesso ottenendo un errore complessivo inferiore.

Possiamo verificare esattamente quanto bene il nostro modello di questo errore si adatti ai dati sperimentali costruendo esplicitamente un modello di rumore e utilizzando un simulatore. Nel modello seguente, costruiamo esplicitamente un errore corrispondente a 0,025 radianti. Non è un numero magico; si può semplicemente regolare l'errore finché non descrive ragionevolmente l'esperimento.

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

Ora possiamo tracciare insieme le curve reali e simulate.

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

Output of the previous code cell

L'errore nel circuito reale era descritto abbastanza bene dal modello di errore di sovra/sotto-rotazione. Chiaramente tipi diversi di rumore ed errori si accumuleranno in modo diverso e produrranno effetti drasticamente diversi sulla fedeltà dei nostri circuiti quantistici. Diventa quindi molto importante classificare e caratterizzare gli errori che possono verificarsi in modo più formale di quanto abbiamo fatto finora.

Caratterizzare gli errori quantistici

Abbiamo già descritto alcune delle fonti di rumore quantistico e potremmo classificare gli errori in base alle categorie di rumore che li causano. Ma potrebbero esserci diverse categorie di errori quantistici utili nella correzione e nella mitigazione degli errori. Ad esempio, dobbiamo sapere in quale punto si verificano gli errori e come si accumulano se vogliamo correggerli o mitigarli. Nello specificare dove (in quali processi) si verificano gli errori, una categoria importante e comune è quella degli errori di preparazione dello stato e misurazione (o errori SPAM, in breve). Qui, il termine “preparazione dello stato” non indica tutto ciò che viene fatto su uno stato per prepararlo alla misurazione. Piuttosto, si riferisce all'inizializzazione dei qubit, alla “preparazione” dei qubit per l'esecuzione di un algoritmo, e quindi questa categoria SPAM esclude cose come gli errori di gate durante l'esecuzione dell'algoritmo.

Un'altra distinzione importante è se gli errori sono coerenti o incoerenti. Per riassumere brevemente (li tratteremo più in dettaglio di seguito), gli errori coerenti sono tipicamente modellati da operazioni unitarie e preservano la purezza dello stato. Gli errori incoerenti sono modellati da canali quantistici non unitari e generalmente riducono la purezza dello stato. È facile visualizzare gli errori incoerenti come interazioni termiche che causano perdita di informazione quantistica, ma in realtà potrebbero essere causati da qualsiasi accoppiamento casuale con l'ambiente. Come esempio di errore coerente, supponiamo che vi sia un'imperfezione nell'orientamento dell'impulso nell'implementazione di un gate RY tale che un gate $RY(\theta)$ causi in realtà $RY(\theta) \cdot RX(\epsilon)$ . Un'imperfezione di questo tipo causerebbe sempre una rotazione erronea attorno a X nella stessa direzione. Questo sarebbe un errore coerente.

Nota che gli errori SPAM includono un mix di errori coerenti, come guasti sistematici di controllo, ed errori incoerenti, come la perdita di fotoni e gli effetti termici. Poiché ciò coinvolge più fasi e fonti di errore, gli errori SPAM sono meglio descritti come una combinazione sia di errori coerenti che incoerenti.

Errori SPAM

Come suggerisce il nome, gli errori SPAM si verificano in due fasi distinte di un esperimento quantistico: la preparazione iniziale e la lettura/misurazione. Gli errori di preparazione dello stato si verificano quando l'hardware non riesce a inizializzare in modo affidabile i qubit nello stato di partenza desiderato ( $|0\rangle$ per i computer quantistici IBM). Le cause includono:

eccitazione termica (i qubit reali non sono raffreddati perfettamente e possono occasionalmente iniziare in $|1\rangle$ invece che in $|0\rangle$ )
fotoni residui o rumore nei risonatori nei qubit superconduttori
derive nella calibrazione che influenzano l'accuratezza con cui i qubit vengono reimpostati

Gli errori di misurazione si verificano durante il processo di lettura, quando l'apparato di misurazione identifica in modo errato lo stato del qubit. Le fonti includono:

rumore dell'amplificatore di lettura che causa confusione tra $|0\rangle$ e $|1\rangle$
rilassamento del qubit durante la lettura (per esempio, un qubit in $|1\rangle$ decade a $|0\rangle$ appena prima o durante la misurazione)
crosstalk tra le linee di lettura: la lettura di un qubit influenza leggermente le letture dei qubit vicini
soglie di discriminazione imperfette nei sistemi di misurazione basati su risonatori IBM

Gli errori SPAM sono principalmente incoerenti. Gli errori di preparazione agiscono come miscele casuali di stati eccitati e fondamentali. Gli errori di misurazione si comportano come confusione classica: con probabilità $p$ , $|0\rangle$ viene riportato come $|1\rangle$ o viceversa. Questi sono distinti dagli errori unitari coerenti (come porte mal calibrate che causano sfasamenti sistematici). Gli errori SPAM assomigliano invece a rumore classico casuale, sebbene possano esistere rare distorsioni coerenti nella lettura.

Gli errori SPAM possono essere problematici per il benchmarking randomizzato o per circuiti a bassa profondità in cui la preparazione dello stato e la misurazione rappresentano una grande frazione dell'errore totale. Sono meno un problema per circuiti molto profondi, specialmente quelli con molti gate a due qubit.

Matematicamente, gli errori SPAM possono essere descritti come la produzione di una distribuzione rumorosa $\vec{p}_\text{noisy}$ che è correlata alla distribuzione ideale $\vec{p}_\text{ideal}$ tramite una matrice $A$ :

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

Qui $p_i$ è la probabilità di misurare la stringa di bit $i$ , e $A_{ij}$ è la probabilità di ottenere lo stato $j$ quando lo stato avrebbe dovuto essere preparato nello stato $i$ . Immagina il contesto delle stringhe di bit campionate dal Sampler. La tua distribuzione misurata degli stati sarà composta da molte misurazioni accurate, ma anche da alcune misurazioni in cui le istruzioni per la preparazione dello stato non corrispondono allo stato osservato. Ciò significa che le probabilità saranno leggermente errate.

A two-part figure. On the left is a histogram showing the ideal and noisy measurement results. On the right is a reduced assignment matrix mapping probabilities from the noisy measured results to the ideal case.

Nella figura sopra, la parte (a) mostra la distribuzione ideale di uno stato GHZ in verde acqua, e le misurazioni effettive in viola. Nella parte (b) vediamo un esempio di matrice $A$ . Nota che la matrice non è perfettamente simmetrica rispetto alla diagonale, poiché ogni qubit non deve necessariamente avere la stessa probabilità di restituire erroneamente uno 0 e di restituire erroneamente un 1. In pratica, è spesso difficile separare gli errori di preparazione e di lettura, quindi vengono spesso combinati in un unico trattamento (da cui l'uso comune del termine SPAM).

Un modo per correggere questi errori SPAM è utilizzare circuiti semplici con esiti di misurazione ideali noti e confrontarli con gli esiti misurati in presenza di errori SPAM. Questo può essere usato per ricostruire tramite reverse-engineering gli esiti ideali di circuiti più complessi. Per stati generali ad alta entropia, ciò potrebbe richiedere la costruzione di una matrice con $2^N\times2^N$ probabilità, ma in casi meno estremi questi errori possono essere mitigati.

Errori coerenti contro errori incoerenti

Gli errori coerenti sono mis-rotazioni sistematiche, deterministiche e unitarie dello stato quantistico. Derivano da operazioni quantistiche imperfette che deviano in modo prevedibile. Gli esempi includono piccoli errori nella rotazione applicata dai gate di rotazione a singolo qubit, inclusi quelli causati dalla deriva di calibrazione che porterebbe costantemente a sovra- o sotto-ruotare. Matematicamente, potremmo scrivere che un gate di rotazione reale, ad esempio $\tilde{R_X}(\theta)$ , è dato dal gate di rotazione ideale più un errore aggiuntivo:

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

per una piccola sotto- o sovra-rotazione $\epsilon$ . Altri esempi includono un gate a due qubit che aggiunge un piccolo sfasamento indesiderato e impulsi di controllo che deviano sistematicamente dalla forma ideale.

Una caratteristica chiave degli errori coerenti è che sono deterministici e possono essere modellati essi stessi da gate unitari. Di conseguenza preservano la purezza dello stato quantistico: l'informazione quantistica non viene persa, è stata semplicemente elaborata in modo imperfetto. Un altro punto importante da notare è che gli errori coerenti ripetuti interferiscono costruttivamente e talvolta crescono quadraticamente con il numero di gate.

Questi errori sono a volte prevedibili e possono quindi essere in parte calibrati via. Ma gli errori coerenti che rimangono possono accumularsi rapidamente, causando fastidiose deviazioni dagli stati ideali. Questo significa che a volte è vantaggioso “randomizzare” intenzionalmente gli errori coerenti. Questa procedura e la sua utilità saranno trattate nella lezione sulla mitigazione degli errori.

Perché sono fastidiosi

Gli errori coerenti possono “accumularsi” in modi pericolosi, producendo grandi deviazioni dallo stato corretto se non vengono randomizzati o corretti.

Gli errori incoerenti sono stocastici, casuali e spesso non unitari. Derivano da interazioni con l'ambiente o da fonti di rumore non controllate. Ne abbiamo già visti alcuni esempi: il rilassamento energetico / decadimento $T_1$ è incoerente. Lo sono anche il rumore stocastico delle porte, il rumore termico e l'errore di misurazione.

La caratteristica chiave degli errori incoerenti è che non sono gli stessi ogni volta che viene eseguita un'operazione. Non sono unitari, quindi non possono essere modellati da un semplice gate quantistico unitario come potrebbero esserlo gli errori coerenti. Poiché sono incoerenti, tipicamente si accumulano in modo lineare come il rumore casuale, non come una sovra-rotazione costante.

Gli errori incoerenti fanno sì che i qubit perdano informazione in modo irreversibile (perdita di purezza e di informazione di fase).

Quindi quale dei due è peggiore? Come per la maggior parte delle cose nel calcolo quantistico, dipende. Il punto è che gli errori coerenti si accumulano più velocemente e in modo non lineare (il che è negativo). Ma possono essere in parte calibrati via e l'informazione di fase è ancora presente nel sistema, se si riesce a capire come estrarla correttamente. Gli errori incoerenti si accumulano linearmente, il che è positivo per due motivi: è più lento dell'accumulo coerente ed è abbastanza facile vedere come gli effetti degli errori incoerenti si scalano per processi come l'estrapolazione a rumore zero (ZNE), che sarà trattata nella lezione sulla mitigazione degli errori. Tuttavia, quando si verificano errori incoerenti, l'informazione quantistica va veramente persa, non semplicemente oscurata.

Matrici di densità e canali quantistici

Nelle sezioni seguenti, approfondiremo alcuni tipi di errori coerenti e incoerenti e vedremo come possono essere modellati matematicamente utilizzando i canali quantistici. Prima, è opportuno un breve ripasso delle matrici di densità e dei canali quantistici. Per una trattazione completa e rigorosa di questi argomenti, consulta il corso di John Watrous General formulation of quantum information su IBM Quantum Learning. La trattazione qui sarà guidata da esempi e meno formale.

I canali quantistici sono il modo più generale per descrivere come un sistema quantistico evolve, interagisce e subisce rumore. Se sei abituato agli stati puri e all'evoluzione unitaria, i canali quantistici sono il passo successivo naturale.

Nella meccanica quantistica standard, uno stato "puro" è scritto come $|\psi\rangle$ . Qui "puro" si riferisce alla purezza dell'informazione o della conoscenza della preparazione dello stato; non significa un autostato di qualche sistema. Per un esempio di qubit, $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ è uno stato puro perché abbiamo una conoscenza perfetta delle ampiezze relative e della fase. L'evoluzione temporale di uno stato puro di questo tipo è governata da un operatore unitario $U$ :

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

secondo l'equazione di Schr"odinger, in cui $U = e^{-iHt/\hbar}$ , dove $H$ è l'Hamiltoniana del sistema e $\hbar$ è la costante di Planck ridotta, spesso “posta uguale a uno” o, più rigorosamente, assorbita nell'Hamiltoniana in modo che tutte le energie siano espresse in unità di $\hbar$ .

L'evoluzione unitaria è reversibile, deterministica e isolata. Ma questo non è adeguato per descrivere sistemi quantistici reali. Nei sistemi quantistici reali:

Eseguiamo misurazioni, facendo collassare lo stato quantistico in un autostato del sistema. Questo è esplicitamente non unitario.
Il sistema interagisce con un ambiente. Ciò significa che il sistema non è veramente isolato, e poiché l'ambiente non può essere tracciato all'infinito, ciò corrisponde a una perdita di informazione.
Praticamente parlando: il rumore corrompe lo stato. E altro ancora.

L'evoluzione unitaria da sola non può descrivere questi processi; abbiamo quindi bisogno di una rappresentazione più generale degli stati e dei processi quantistici. Uno stato misto descrive una distribuzione classica di stati quantistici. Cioè, sappiamo già che lo stato quantistico: $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ ha il 50% di probabilità di essere misurato (collassato in informazione classica) nello stato $|0\rangle$ e il 50% di probabilità di essere misurato in $|1\rangle$ . Ma l'affermazione è che lo stato quantistico iniziale è esattamente $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ con probabilità del 100%. Ora vogliamo aggiungere sopra la probabilità quantomeccanica una probabilità classica, per esempio:

Lo stato quantistico iniziale è preparato in $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ con una probabilità classica del 25%, ed è preparato in $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle-i|1\rangle)$ con una probabilità classica del 75% (nota le diverse fasi relative).

A volte ciò può essere dovuto a probabilità classiche esplicite nella preparazione; altre volte può essere dovuto all'entanglement con parti dell'ambiente che ignoriamo. In ogni caso, è chiara la necessità di uno strumento per descrivere questa distribuzione classica di stati quantomeccanici. I soli stati puri non possono rappresentare queste possibilità. Introduciamo quindi la matrice di densità.

Uno stato misto è descritto da un operatore di densità:

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

Qui, $|\psi_i\rangle$ è uno stato quantistico (non necessariamente un autostato di un particolare operatore) e $p_i$ è la probabilità classica che il sistema sia preparato nello stato $|\psi_i\rangle$ . Questa è una buona prescrizione per costruire una matrice di densità a partire da una distribuzione classica nota di stati quantistici. D'altra parte, potremmo voler sapere, data sia una distribuzione classica di stati quantistici sia una probabilità quantomeccanica di diversi esiti di misurazione, qual è la probabilità che una misurazione produca un particolare stato (come $|0\rangle$ , o $|1\rangle$ , o altri stati quando sono coinvolti più qubit). È qui che la matrice di densità è particolarmente utile. Possiamo anche scriverla in una base $\{|i\rangle\}$ come:

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

Qui gli elementi diagonali $\rho_{ii}$ sono probabilità:

$\rho_{00}$ = probabilità che il qubit sia in $|0\rangle$
$\rho_{11}$ = probabilità che il qubit sia in $|1\rangle$

Sono reali, non negativi e sommano a 1.

Gli elementi fuori diagonale $\rho_{ij}, i \neq j$ sono coerenze: relazioni di fase o capacità di interferenza, e corrispondono generalmente a quanta informazione quantomeccanica è contenuta nello stato. Questa è un'affermazione informale, ma vediamo cosa significa in pratica.

Esempio

Considera lo stato puro $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ . (a) Cosa sai delle probabilità di misurazione e dell'informazione di fase senza fare alcun calcolo? (b) Costruisci la matrice di densità e verifica la tua intuizione.

Solution:

(a) Poiché è uno stato puro, esiste una sola fase possibile tra $|0\rangle$ e $|1\rangle$ : +1. Questa è un'informazione di fase perfetta, quindi ci aspettiamo che gli elementi fuori diagonale nella nostra matrice di densità siano grandi. Potresti avere più intuizione di questa sui termini fuori diagonale, ma per ora è sufficiente. Inoltre, le ampiezze dei due stati di base sono uguali, quindi ci aspettiamo una probabilità del 50% di misurare $|0\rangle$ o $|1\rangle$ . Quindi ci aspettiamo che i termini diagonali siano 1/2. (b) Usando la definizione sopra:

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

$p_i \neq 0$ solo per lo stato $|\psi\rangle$ . Possiamo quindi scrivere

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

I termini diagonali sono ciascuno $1/2$ come previsto, e gli elementi fuori diagonale sono grandi (sommano a uno).

Ora vediamo cosa succede quando non abbiamo una buona informazione di fase.

Esempio

Considera un caso simile, ma ora con una probabilità classica del 50% di essere nello stato $|\psi_+\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ e una probabilità classica del 50% di essere nello stato $|\psi_-\rangle = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$ . Stesse due domande: (a) Cosa sai delle probabilità di misurazione e dell'informazione di fase senza fare alcun calcolo? (b) Costruisci la matrice di densità e verifica la tua intuizione.

Solution:

(a) Come prima, le ampiezze dei due stati di base sono uguali, quindi ci aspettiamo una probabilità del 50% di misurare $|0\rangle$ o $|1\rangle$ . Quindi ci aspettiamo che i termini diagonali siano 1/2. Ma questa volta ci sono due possibilità opposte per la fase tra $|0\rangle$ e $|1\rangle$ : +1 e -1, ed entrambe sono ugualmente probabili. Ci si potrebbe aspettare che con due fasi opposte ugualmente probabili, si abbia poca o nessuna informazione di fase. Ci si potrebbe aspettare che i termini fuori diagonale siano piccoli. (b) Usando di nuovo la definizione sopra

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

$p_i \neq 0$ solo per i due stati $|\psi_+\rangle$ e $|\psi_-\rangle$ . Possiamo quindi scrivere

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

I termini fuori diagonale sono piccoli, di fatto zero, come previsto. Gli elementi diagonali sono ancora del 50% ciascuno, il che ha senso perché ciascuno degli stati nella miscela aveva $|0\rangle$ e $|1\rangle$ pesati equamente.

Questa costruzione diventa più interessante all'aumentare del numero di qubit. Esplora questo aspetto nelle domande seguenti.

Verifica la tua comprensione

Scrivi la matrice di densità per lo stato di Bell puro $|\Phi_+\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ .

Risposta

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

$p_i \neq 0$ solo per lo stato $|\Phi_+\rangle$ . Possiamo quindi scrivere

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

Scrivi la matrice di densità per una probabilità classica del 25% di $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ e una probabilità classica del 75% di $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$ .

Risposta

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

$p_i \neq 0$ solo per i due stati $|\Phi_+\rangle$ e $|\Psi_-\rangle$ . Possiamo quindi scrivere

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

Modifica il tuo lavoro dalla domanda precedente per scrivere la matrice di densità per una probabilità classica del 50% di $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ e una probabilità classica del 50% di $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$ . Prevedi quale informazione di fase dovrebbe persistere.

Risposta

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

$p_i \neq 0$ solo per i due stati $|\Phi_+\rangle$ e $|\Psi_-\rangle$ . Possiamo quindi scrivere

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

I termini diagonali sommano a 1, come devono. I termini fuori diagonale non si annullano qui come accadeva in un precedente esempio a un qubit. Puoi vedere perché, nella matematica, ma una spiegazione sintetica è che ora ci sono più stati nel nostro spazio di Hilbert. Sebbene il primo stato di Bell avesse una fase relativa positiva e il secondo una negativa, queste fasi erano tra stati di base diversi. Il primo stato di Bell aveva una fase tra $|00\rangle$ e $|11\rangle$ , mentre il secondo aveva una fase relativa tra $|01\rangle$ e $|10\rangle$ .

Canali quantistici

Un canale quantistico è la trasformazione fisicamente più generale ammessa per uno stato quantistico. Porta una matrice di densità iniziale $\rho$ in un'altra matrice di densità:

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

Qui $\Phi(\rho)$ indica un canale quantistico $\Phi$ che agisce su una matrice di densità $\rho$ , da non confondere con gli stati di Bell $|\Phi_+\rangle$ o $|\Phi_-\rangle$ .

I canali quantistici sono estremamente generali. Possono includere:

Evoluzione unitaria $\Phi(\rho) = U\rho U^\dagger$
Miscele probabilistiche di unitarie
Measurements
Decoherence
Smorzamento di ampiezza (perdita di energia)
Defasamento (perdita di informazione di fase)
Interazione con un ambiente E molte altre cose.

Un modo di pensare ai canali quantistici è che sono per le matrici di densità ciò che le unitarie sono per gli stati puri. Ma la generalità delle matrici di densità permette ai canali quantistici corrispondenti di essere molto più generali e quindi più potenti.

Gli unici vincoli su un canale quantistico sono che deve essere:

Lineare Le miscele di stati dovrebbero evolvere in modo coerente: $\Phi(p\rho_1 + (1-p)\rho_2) = p\Phi(\rho_1) + (1-p)\Phi(\rho_2)$
Completamente positivo Non dovrebbe produrre probabilità negative, anche se il tuo sistema è entangled con qualcos'altro.
Che preserva la traccia Le probabilità devono sommare a 1. Questi requisiti sono a volte raccolti insieme nell'acronimo CPTP: Completely Positive Trace-Preserving maps (mappe completamente positive che preservano la traccia).

Esistono diverse rappresentazioni dei canali quantistici, tra cui le rappresentazioni di Stinespring, Kraus e Choi. Queste sono trattate in dettaglio in questa lezione sui canali quantistici in General formulation of quantum information, dove viene anche mostrato che sono equivalenti. Non entreremo qui in queste diverse rappresentazioni. Basti dire che sono analoghe a descrivere vettori usando tre diversi sistemi di coordinate. Ciascuna potrebbe enfatizzare aspetti diversi e costruire l'intuizione in modo diverso; ma tutte forniscono la risposta corretta. Le rappresentazioni di Kraus sono convenienti per i nostri scopi. Offrono un modo formulaico e conveniente per esprimere l'azione di un canale tramite moltiplicazione e addizione di matrici. In particolare, una rappresentazione di Kraus è una specifica di un canale, $\Phi$ , nella forma seguente.

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

Qui, $A_0,\ldots,A_{N-1}$ sono matrici che hanno tutte le stesse dimensioni: le loro colonne corrispondono agli stati classici del sistema di ingresso, $\mathsf{X}$ , e le loro righe corrispondono agli stati classici del sistema di uscita, che sia $\mathsf{X}$ o un altro sistema $\mathsf{Y}$ . Affinché $\Phi$ sia un canale valido, queste matrici devono soddisfare la seguente condizione.

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

Queste matrici sono chiamate matrici di Kraus. Questa formulazione è applicabile non solo ai canali di rumore, ma a processi e canali quantistici generali, inclusa la misurazione. Vediamo un esempio di come questi possano essere usati per costruire canali nel contesto del rumore e degli errori.

Canale completamente defasante

Considera un canale che distrugge tutta l'informazione di fase e chiamiamolo il canale completamente defasante. Questo significa che il canale dovrebbe prendere qualsiasi matrice di densità della forma

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

e mapparla in

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

Se assumiamo che la matrice di densità sia già stata scritta nella base computazionale, possiamo esprimere $\rho_{ij}$ come $\langle i|\rho|j\rangle$ . Questo suggerisce un insieme di matrici di Kraus che possono realizzare questa azione del canale: $A_k = |k\rangle\langle k|$ . Applichiamo questa strategia a un caso di esempio di un singolo qubit, e vediamo se funziona come richiesto:

Poni $A_0 = \vert 0\rangle\langle 0\vert$ e $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}

Poiché $\langle 0 \vert \rho \vert 0\rangle$ è un numero, possiamo semplicemente spostare il vettore $\vert 0\rangle$ oltre. Questo vale anche per il secondo termine. Abbiamo:

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

Nota che queste matrici soddisfano la condizione richiesta:

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

Vale la pena notare che questa scelta di matrici di Kraus non è unica.

Caratterizzare il rumore come canali

In questa sezione utilizzeremo il modello della sfera di Bloch e la matematica dei canali quantistici per comprendere meglio vari tipi di rumore ed errori.

Errori incoerenti

Torniamo agli errori incoerenti ed esploriamo nello specifico gli errori di rilassamento energetico. Ricorda che lo stato $|0\rangle$ è lo stato fondamentale di un qubit e lo stato $|1\rangle$ ha un'energia leggermente più alta. A volte gli stati quantistici decadono semplicemente e spontaneamente da un livello energetico più alto a uno più basso. Il processo di emissione spontanea è un argomento ricco e non può essere veramente compreso senza un trattamento basato sulla teoria quantistica dei campi. Ma l'intuizione ci è molto familiare: perturbazioni casuali possono far rotolare un sasso giù per una collina; non lo faranno rotolare su per la collina. Per quanto tempo un qubit rimane nello stato a energia più alta è caratterizzato da un tempo $T_1$ . Più precisamente, la probabilità che un qubit preparato nello stato $|1\rangle$ rimanga in quello stato dopo un tempo $t$ è $e^{-t/T_1}$ . Oppure, equivalentemente, la probabilità $p$ di un errore di rilassamento energetico dopo un tempo $t$ è

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

Per descrivere questo con un canale quantistico nella rappresentazione di Kraus, abbiamo bisogno di matrici di Kraus che corrispondano a

lasciare invariati gli stati $|0\rangle$
trasformare gli stati $|1\rangle$ in $|0\rangle$ con una certa probabilità p.

Definiamo

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

Per prima cosa, verifichiamo che questo abbia gli effetti desiderati su una matrice di densità. Consideriamo un sistema che si trova in uno stato puro $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ . Abbiamo visto in un esempio precedente che la matrice di densità per questo caso è

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

Applicando il canale di rilassamento energetico tramite le matrici di Kraus, otteniamo la nuova matrice densità mappata:

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

Esaminiamo questo risultato e confrontiamolo con la nostra intuizione:

Per prima cosa, verifichiamo il limite quando $t$ tende a zero. Recuperiamo la nostra matrice densità iniziale, come dovrebbe essere:

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

Con il passare del tempo, ci aspetteremmo che la probabilità di misurare lo stato $|0\rangle$ aumenti, e che la probabilità di misurare $|1\rangle$ diminuisca. Anche in questo caso, è esattamente ciò che osserviamo, poiché

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

Possiamo anche vedere banalmente che le probabilità di misurare $|0\rangle$ e $|1\rangle$ sommano a 1, come deve essere.

Lo scaling preciso dei termini di coerenza (fuori diagonale) esula dallo scopo di questa trattazione. Ma è chiaro che inizialmente abbiamo un'informazione di fase perfetta, e dopo un tempo molto lungo non può esserci alcuna informazione di fase poiché il sistema è completamente rilassato nello stato $|0\rangle$ . Pertanto, i termini di coerenza devono decadere a zero per tempi molto lunghi. Infatti,

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

Molti dei vincoli sulle nostre matrici di Kraus sono verificati implicitamente attraverso queste considerazioni intuitive. Si dovrebbe verificare rigorosamente che i vincoli sui canali (e sulle matrici di Kraus in particolare) siano soddisfatti, ma lasciamo questo come esercizio al lettore.

Graficamente, questo tipo di canale può essere rappresentato usando una sfera di Bloch. Uno stato puro giace sulla superficie di una sfera di Bloch. Gli stati misti si spostano verso l'interno della sfera e si allargano rispetto a un singolo punto. L'inclusione di probabilità classiche si osserva attraverso la riduzione della distanza assoluta dall'origine a uno qualsiasi degli stati della miscela, e l'allargamento da un singolo punto a una regione indica la mescolanza di più stati possibili. Nel caso speciale di un canale di rilassamento energetico, lo stato misto (matrice di densità) dopo un tempo non trascurabile apparirebbe come nell'immagine sottostante: una regione all'interno della sfera di Bloch, spostata verso l'alto in direzione del polo $|0\rangle$ , e ristretta sia lungo l'asse $Z$ che lungo il piano $XY$ , sebbene in misura minore rispetto a $Z$ .

A Bloch sphere with a shaded region near the zero-state pole. The region is a shrunken oblate spheroid.

Nota che la regione non è un "cappuccio" della sfera di Bloch, come a volte appare in una rappresentazione prospettica. Come si può vedere chiaramente nel video, si tratta di uno sferoide oblato, ristretto e spostato verso lo stato $|0\rangle$ . I canali di rumore (e i canali in generale) sono ovviamente applicabili a sistemi di qualsiasi dimensione. Ma rappresentarli visivamente (come con una sfera di Bloch) diventa difficile man mano che aumenta il numero di stati mutuamente ortogonali nello spazio di Hilbert.

Verifica la tua comprensione

Verifica che le matrici di Kraus usate nel canale di rilassamento energetico sopra soddisfino la condizione di identità:

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

Risposta

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

Presenteremo altri due tipi di canali di rumore incoerenti, ma lasceremo la maggior parte dell'interpretazione e della verifica come esercizi. Il prossimo è il canale di defasamento, che descrive una perdita di informazione di fase, ma con la conservazione delle ampiezze. Sebbene si possano ancora avere sia probabilità classiche che quantomeccaniche coinvolte nella probabilità di misurazione complessiva, la perdita di informazione di fase viene spesso descritta come una perdita di informazione quantistica, o come il sistema che diventa più classico.

Allo stesso modo in cui il rilassamento energetico è stato descritto con un tempo caratteristico $T_1$ , gli errori di defasamento sono descritti da un secondo parametro temporale $T_2$ . La probabilità di un errore di defasamento dopo un tempo $t$ è data da

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

Un insieme di matrici di Kraus per il canale di defasamento su un singolo qubit, in termini di questa probabilità, è il seguente:

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

Il risultato di questo canale di defasamento è visualizzato usando una sfera di Bloch nella figura sottostante.

A Bloch sphere with a shaded region extending to both poles along the vertical z axis, but shrunken in the x-y plane. The region is again a shrunken oblate spheroid, but this time still centered on the origin and shrunken toward the z-axis.

Nota che le ampiezze non vengono modificate, quindi qualsiasi stato che si trova esattamente su un polo ( $|0\rangle$ o $|1\rangle$ ) non è influenzato ed è ancora mappato sulla superficie della sfera nella regione ombreggiata. Ma l'informazione di fase viene persa, il che corrisponde a un restringimento della regione ombreggiata lungo il piano $XY$ . Un modo per dare senso a questo è: qualsiasi stato quantistico possibile può ancora avere una fase ben definita, ma poiché esiste una probabilità classica di trovare diversi stati con fasi ben definite diverse, la probabilità complessiva di una qualsiasi fase ben definita viene ridotta.

Verifica la tua comprensione

Verifica che le matrici di Kraus definite sopra per il canale di defasamento soddisfino la condizione di identità:

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

Risposta

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

Parti da uno stato puro di un singolo qubit a tua scelta, con una fase ben definita tra $|0\rangle$ e $|1\rangle$ . Scrivilo come matrice di densità. Applica il canale di defasamento usando gli operatori di Kraus suggeriti sopra. Interpreta la matrice di densità mappata risultante.

Risposta

Scegliamo lo stato $|\psi\rangle = \frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle$ . La matrice densità corrispondente $\rho$ è

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

Ora applichiamo il canale di defasamento a questa matrice densità usando gli operatori di Kraus.

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

Innanzitutto, notiamo che la somma degli elementi diagonali è effettivamente uguale a uno, come deve essere. In secondo luogo, nota che gli elementi fuori diagonale erano inizialmente grandi, con una somma di 24/25, indicando una forte coerenza. Nota che all'aumentare della probabilità di un errore di defasamento $p$ , questi elementi fuori diagonale diminuiscono. Anche questo corrisponde alla nostra aspettativa. Una sottigliezza: nota cosa succede quando $p\rightarrow 1$ . La coerenza torna a essere forte! Questo sembra controintuitivo a prima vista, perché un'alta probabilità di un errore di defasamento dovrebbe rovinare la nostra fase, giusto? Il trucco è che se siamo sicuri al 100% che si verifichi un errore di fase, allora abbiamo di nuovo una forte informazione sulla fase; la fase si è semplicemente invertita. Con questa intuizione, ci potremmo aspettare che la peggiore informazione di fase corrisponda a una probabilità del 50-50 che si verifichi un errore di fase, ed è esattamente ciò che troviamo.

Il nostro ultimo esempio di canale di rumore che descrive errori incoerenti è il canale di rumore di Pauli. Questo canale descrive il verificarsi di tre tipi di errori con probabilità indipendenti:

Errore di bit-flip (errore X) con probabilità $p_x$
Errore di phase-flip (errore Z) con probabilità $p_z$
Combinazione di X e Z (errore Y) con probabilità $p_y$ Qui, $0\leq p_j \leq 1$ per tutti i $j$ . Un corollario è che la probabilità che non si verifichi alcun errore è $p_I = 1-p_x-p_y-p_z$ .

Gli operatori di Kraus per questo canale sono:

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

Nel caso del canale di rumore di Pauli, è istruttivo scrivere il canale stesso:

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

Da questa forma vediamo che il canale di rumore di Pauli implementa uno o più errori corrispondenti all'azione delle matrici di Pauli $P_j$ , ciascuna con probabilità $p_j$ .

Diverse combinazioni di probabilità di flip produrranno visualizzazioni diverse. Qui visualizziamo il caso speciale in cui $p_X = p_Y = p_Z$ , chiamato anche canale di depolarizzazione.

A Bloch sphere with a shaded region shrunken uniformly toward the center.

Modellare gli errori coerenti

I canali quantistici possono rappresentare sia errori coerenti che incoerenti, ma in pratica vengono usati principalmente per errori incoerenti, perché gli errori coerenti sono meglio modellati come miscalibrazioni unitarie o convertiti in canali stocastici per un'analisi più semplice. In questa sezione introdurremo approcci più applicabili agli errori coerenti.

Gli errori coerenti possono essere modellati tramite gate unitari indesiderati. Alcuni esempi semplici includono rotazioni disallineate o sotto-/sovra-rotazione. Nell'immagine sottostante, mostriamo una rotazione disallineata come una rotazione $Y$ aggiuntiva di una piccola quantità $\epsilon$ oltre alla rotazione desiderata attorno all'asse $X$ . Una sovra-rotazione è descritta dalla rotazione $X$ desiderata più un'ulteriore rotazione attorno allo stesso asse $X_\epsilon$ .

Small circuit diagrams showing that a gate error on a rotation could show up as misalignment (as in a slight erroneous rotation about Y when intending to rotate about X) or as over/under rotation (as in an erroneous extra rotation about X).

Errori a due qubit e coni di luce ombreggiati

Un gate a singolo qubit ruota un qubit isolato. Un gate a due qubit implementa una logica che si basa su due qubit, ma non può effettuare una misurazione diretta di nessuno dei due qubit; deve quindi attivare un'interazione tra i qubit. Questa interazione è il motivo per cui possiamo costruire l'entanglement, ed è anche da dove proviene gran parte del rumore, del crosstalk e delle difficoltà di calibrazione. Questa interazione tra qubit permette anche agli errori di propagarsi. Se un qubit presenta un errore, e funge da qubit di controllo per un altro qubit bersaglio, l'errore può essere trasferito al bersaglio. In questa lezione esamineremo cosa significano i gate a due qubit per i tassi di errore e la loro propagazione all'interno di un circuito.

Gate cross-resonance echoed

Diverse architetture hardware e famiglie di gate progettano questa interazione in modi diversi. I computer quantistici IBM implementano gate astratti a due qubit come i gate CZ o CX usando gate echoed cross-resonance (ECR) nativi dell'hardware. I gate ECR generano un'interazione efficace $ZX$ usando un pilotaggio a microonde. Gate correlati come CNOT sono costruiti a partire da $ZX$ aggiungendo rotazioni a singolo qubit.

Qubit diversi hanno frequenze di risonanza diverse (frequenze a cui reagiscono fortemente). Un'operazione standard potrebbe usare quella frequenza di risonanza per indurre una transizione in un qubit. Ma cosa succede se si pilota il qubit C alla frequenza di risonanza di un qubit adiacente T? I qubit adiacenti sono collegati da un'interazione fissa capacitiva o mediata da risonatore. A causa di questo accoppiamento, un pilotaggio sul qubit C "filtra" nell'Hamiltoniana del qubit T. L'intensità e la direzione di questo pilotaggio efficace dipendono dallo stato del qubit C ( $|0\rangle$ o $|1\rangle$ ). Qui, il qubit C è il controllo e il qubit T è il bersaglio.

Il risultato è una rotazione efficace del qubit bersaglio condizionata dallo stato del qubit di controllo. Matematicamente:

H_{eff} \approx \Omega Z_C X_T +\text{altri termini}

Questa interazione ZX è esattamente ciò di cui hai bisogno per costruire un CNOT. Ma gli altri termini potrebbero includere alcuni errori, e includono quasi certamente un accoppiamento capacitivo tra i qubit C e T, che corrisponde a un termine ZZ.

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

Possiamo pensare a questi termini aggiuntivi nel modo seguente:

IX = il bersaglio viene pilotato involontariamente
ZI = il qubit di controllo acquisisce una rotazione Z indesiderata
IZ = il qubit bersaglio acquisisce una rotazione Z indesiderata
ZZ = spostamento di fase statico dipendente dallo stato
altri = piccole interazioni XY, XX, di ordine superiore

Un gate ECR è semplicemente una rotazione controllata più un impulso di eco accuratamente scelto sul qubit di controllo. L'eco inverte il segno di molti termini indesiderati preservando l'interazione ZX. Questo processo annulla piuttosto bene gli errori IX e ZI, e a volte alcuni termini di ordine superiore. Ma l'eco non può annullare l'accoppiamento ZZ statico perché commuta con l'impulso di eco. Ci sono altre interazioni che non verranno annullate in questo processo: alcune non linearità residue ed effetti da qubit spettatori, leakage e contaminazione da pilotaggio a lungo raggio, oltre ad alcune altre — ma il termine ZZ è particolarmente importante.

Questo processo spesso richiede tempi di pilotaggio di un ordine di grandezza superiori rispetto ai gate a singolo qubit. La combinazione di tempi di pilotaggio più lunghi, termini ZZ persistenti nell'Hamiltoniana e imperfezioni nell'accoppiamento rende i gate a due qubit la fonte dominante di errori di gate. Nota anche che se in un circuito servono interazioni tra qubit non adiacenti, i gate SWAP necessari sono ovviamente anch'essi gate a due qubit. Ecco perché la metrica standard relativa alla profondità è: profondità a due qubit, transpilata. Ci interessano principalmente i gate a due qubit perché dominano l'errore di gate, e dobbiamo guardare ai circuiti transpilati perché la transpilazione spesso introduce molti gate a due qubit aggiuntivi sotto forma di gate SWAP.

Verifica la tua comprensione

Spiega perché ci interessiamo principalmente alla profondità transpilata a due qubit. Assicurati di considerare i vincoli hardware, e il fatto che la profondità dei gate a singolo qubit potrebbe essere molto maggiore.

Risposta

I gate a due qubit hanno tassi di errore molto più alti rispetto ai gate a singolo qubit. I gate a singolo qubit non sono perfetti, quindi ci possono essere casi in cui è utile considerare anche la profondità a singolo qubit. Ma la profondità dei gate a due qubit tende a dominare il comportamento degli errori di un circuito. Dobbiamo considerare il circuito traspilato. I computer quantistici moderni non hanno una connettività qubit-qubit di tipo all-to-all. I computer quantistici IBM usano un reticolo quadrato oppure un reticolo "heavy hex", il che significa che i qubit hanno 2, 3 o 4 vicini più prossimi a cui possono essere accoppiati direttamente tramite un singolo gate a due qubit. Qualsiasi entanglement con altri qubit non adiacenti richiede lo spostamento dell'informazione all'interno del computer quantistico usando gate SWAP a due qubit. Quindi, la traspilazione tende ad aumentare la profondità dei gate a due qubit. Per circuiti fortemente entangled, questo aumento potrebbe essere molto grande.

Coni di luce ombreggiati

Supponiamo che un singolo qubit sia ben isolato da tutti gli altri. Un errore su quel qubit non causerà alcun errore su altri qubit. Ma quando un qubit interagisce con un altro, gli errori possono propagarsi. Il modo in cui gli errori si propagano dipende dal modo in cui i qubit interagiscono. Considera il circuito sottostante. Supponiamo che eventuali qubit adiacenti nel diagramma del circuito siano adiacenti anche sul chip quantistico (cioè, non sarà necessario spostare l'informazione verso altri qubit per facilitare le interazioni descritte).

Four circuit diagrams showing how errors can propagate. If a qubit is not entangled with other qubits, an error is confined. Most qubits will be entangled with some others, and thus errors can propagate from one qubit to another.

Anche se potresti non averlo pensato in questo modo, si tratta di una sorta di diagramma spaziotemporale. L'asse verticale in un circuito quantistico rappresenta diversi qubit disposti nello spazio. L'asse orizzontale rappresenta il tempo durante il quale viene applicata una sequenza di gate. Prendendo in prestito il linguaggio della relatività, un cono di luce rappresenta la regione dello spaziotempo raggiungibile da un punto tramite interazioni causali.

Nella figura sopra, il tipo di errore non è stato specificato. Si scopre che il tipo di errore influisce sul cono di luce poiché alcuni errori influenzano la logica di un gate a due qubit, mentre altri no. Torneremo su questo tra poco. Per ora, considera le linee gialle come percorsi di potenziale propagazione di un certo tipo di errore. Osserva, ad esempio nella parte (a) della figura, che un errore a singolo qubit sul gate RZ nel qubit 4 può propagarsi solo in avanti nel tempo su quel singolo qubit. Non può diffondersi ad altri qubit perché il qubit 4 non è entangled con nessun altro qubit. Questo è un buon momento per notare che il qubit 4 è piuttosto inutile in questo circuito, e in effetti l'intero circuito è costruito solo a scopo didattico.

Un errore sul gate Z del qubit 0 (non necessariamente un errore Z, semplicemente un errore in quella posizione), tuttavia, potrebbe propagarsi a un altro qubit: il qubit 1, tramite il CNOT finale che usa il qubit 0 come controllo e il qubit 1 come bersaglio. Questo è mostrato nella parte (b). Come ci si potrebbe aspettare, un errore più precoce nel circuito avrà spesso la possibilità di propagarsi attraverso più qubit. La parte (c) mostra che un errore nella preparazione dello stato iniziale del qubit 0 può diffondersi a tutti i qubit tranne il qubit 4, che è isolato.

Questa configurazione mostra come un errore possa propagarsi in avanti nel tempo per influenzare le misurazioni. Ma puoi anche esaminare la domanda inversa: per una specifica misurazione a singolo qubit, quali parti del mio circuito potrebbero aver contribuito con un errore ad essa? In quel caso dovresti semplicemente partire dalla misurazione o da un altro punto di interesse e procedere all'indietro (nel tempo) attraverso il circuito, seguendo eventuali circuiti entangling come mostrato nella parte (d). Sono mostrati anche alcuni punti scelti casualmente in cui potrebbero verificarsi errori.

Nella figura sopra, gli errori si propagano tra i qubit tramite gate ECR, ma un discorso simile potrebbe applicarsi ad altri gate a due qubit. Questi gate hanno un controllo e un bersaglio. È chiaro che un errore sul controllo può influenzare la logica del gate e quindi provocare un errore sul bersaglio. Ma che dire della direzione opposta? Un errore sul bersaglio può propagarsi al qubit di controllo? Ricorda che l'accoppiamento tra controllo e bersaglio per i gate ECR non è puramente del tipo ZX ideale; presenta anche un accoppiamento ZZ indesiderato.

Se un errore sul bersaglio commuta con l'accoppiamento ZZ, allora non può propagarsi al qubit di controllo. Possiamo vederlo attraverso i meccanismi fisici in gioco. Un modo rapido per capirlo è che se un errore $E$ commuta con $ZZ$ , allora il loro ordine può essere scambiato senza influire sul risultato. Tuttavia, se $E$ che si verifica appena prima dell'accoppiamento $ZZ$ è equivalente ad agire dopo l'accoppiamento $ZZ$ , allora non può influenzare il controllo, poiché in quest'ultimo caso l'errore dovrebbe muoversi indietro nel tempo. Se un errore non commuta con l'accoppiamento ZZ, allora potrebbe effettivamente propagarsi dal bersaglio al controllo. Quindi, nel caso di un gate ECR, gli errori Z non potrebbero propagarsi dal bersaglio al controllo, ma gli errori X o Y sì.

Verifica la tua comprensione

Nella parte (d) della figura sopra, osserva le linee verticali tra i qubit 0 e 1. È corretto affermare che alcuni errori potrebbero propagarsi lungo quelle linee? Anche in questo caso, può dipendere dal tipo di errore, e non ne abbiamo ancora discusso. La domanda è se esiste un errore che potrebbe propagarsi come mostrato da quelle linee verticali. Spiega.

Risposta

Sì, sono corrette. Nel tracciare il cono di luce all'indietro a partire dalla misurazione, potrebbe sembrare di affermare che qualcosa si muova dal bersaglio al controllo. Tuttavia, il significato del diagramma è in realtà che un errore potrebbe essersi spostato dal controllo (qubit 0) al bersaglio (qubit 1) per causare un errore nel punto di interesse. Se la tua intuizione è che dipenda dal tipo di errore, hai assolutamente ragione. Questo viene affrontato parzialmente nella prossima sezione.

Partendo da una versione priva di errori dei circuiti nel diagramma sopra, traccia la potenziale propagazione di un errore nel primo gate di Hadamard che agisce sul qubit 2. Elenca tutti i qubit che potrebbero essere influenzati entro la fine del circuito se l'errore è (a) un phase flip, e (b) un bit flip. Suggerimento: pensa a come viene usata l'informazione su ciascun qubit.

Risposta

(a) Il qubit 3 potrebbe essere influenzato, oltre ovviamente al qubit 2 stesso. Nessun altro! Se hai elencato i qubit 0 e 1, nota che il qubit 2 è il bersaglio dell'ECR che lo entangla con il qubit 1. In quel gate non viene apportata alcuna modifica al qubit 1. (b) I qubit 0-3 potrebbero essere influenzati. L'errore di bit flip o di tipo X non commuta con l'accoppiamento ZZ nel gate ECR e quindi può propagarsi dal bersaglio al controllo.

Propagazione degli errori

Nella sezione precedente abbiamo discusso la propagazione degli errori senza darne una definizione formale. Andando avanti:

Per un errore $E$ che si verifica prima di una parte del payload logico di un circuito $U$ , la propagazione dell'errore significa trovare l'operatore equivalente $E'$ che riproduce lo stesso risultato errato quando viene applicato dopo $U$ anziché prima.

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

L'immagine della propagazione degli errori nella sezione precedente suggeriva che gli errori potessero propagarsi da un qubit di controllo a un qubit bersaglio attraverso un gate CNOT. Un modo per verificare quando questo è vero è considerare un errore sul controllo o sul bersaglio prima dell'entanglement, e verificare se quell'operatore commuta con il gate CNOT. Se i due operatori commutano, allora non c'è differenza se li si applica in ordine inverso, il che significa che l'errore potrebbe essere semplicemente "spostato oltre" il CNOT senza avere alcun effetto su altri qubit. Questo è il modo più comune in cui le persone affrontano la propagazione degli errori, e produce le seguenti regole:

Sia il controllo il qubit 0 e il bersaglio il qubit 1. Considera gli errori X e Z sui qubit di controllo e bersaglio ( $X_c$ , $Z_c$ , $X_t$ e $Z_t$ , rispettivamente). Spostando questi errori oltre un $\text{CNOT}_{0\to1}$ , gli errori diventano:

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

Affermiamo quanto sopra senza dimostrazione. Ma se sei come l'autore di questa lezione, e preferisci la rappresentazione di Schr"odinger, puoi anche scrivere stati arbitrari di controllo e bersaglio, applicare l'errore, poi il CNOT, ed esaminare lo stato finale. Se confronti quello stato finale con un caso privo di errori, puoi vedere quale combinazione di errori applicata dopo il CNOT produrrebbe lo stato errato, e in particolare, puoi vedere se l'operazione di errore si è propagata da un qubit all'altro.

Stato iniziale del controllo	Stato iniziale del bersaglio	Errore	Finale	Equivalente errore post-CNOT
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Nessuno	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle +\beta\delta \vert 01\rangle$	Non applicabile
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X sul controllo	$\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 sul controllo	$\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 sul bersaglio	$\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 sul bersaglio	$\alpha\gamma \vert 00\rangle-\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c Z_t$

Forse sorprendentemente, un errore Z sul bersaglio causa effettivamente la propagazione di un errore indietro verso il controllo!

Come puoi immaginare, tracciare tale propagazione degli operatori di errore in avanti attraverso i circuiti (o, equivalentemente, propagare all'indietro gli operatori da misurare) è complicato. Qiskit dispone di strumenti per facilitare questo, che impareremo a conoscere nella lezione 6 sui flussi di lavoro moderni.

Esiste un addon di Qiskit chiamato Shaded Lightcones. L'addon shaded lightcones (SLC) analizza la propagazione degli errori nei circuiti quantistici usando la propagazione di Pauli per identificare quali parti di un circuito possono effettivamente influenzare un osservabile bersaglio. È progettato principalmente per rendere più efficiente la mitigazione degli errori, specialmente per i flussi di lavoro di probabilistic error cancellation (PEC). Qui esploreremo questo strumento solo brevemente, e ne faremo un uso più ampio nel contesto delle tecniche di mitigazione degli errori nelle prossime lezioni. Usa la propagazione degli operatori di Pauli per mappare la propagazione di errori di diversi tipi, producendo un cono di luce per gli errori di tipo X, Y e Z.

I coni di luce ombreggiati (SLC) vanno oltre, utilizzando simulazioni classiche per delimitare più strettamente la sensibilità agli errori in tutto il circuito. Questo scambia un po' di tempo QPU per tempo CPU e riduce l'overhead di campionamento necessario per rinormalizzare il bias. Invece di un cutoff netto, a ogni potenziale errore nel circuito viene assegnata una "sfumatura" graduata che delimita superiormente la sensibilità dell'osservabile a quell'errore. Questa caratterizzazione raffinata consente applicazioni più efficienti e mirate della PEC con varianza ridotta, dando all'utente la possibilità di regolare in modo controllabile il bias nella stima dell'osservabile. Consulta Lightcone shading for classically accelerated quantum error mitigation per maggiori dettagli.

Non presenteremo qui un flusso di lavoro completo. Mostriamo semplicemente in modo schematico come questo flusso di lavoro prende un circuito:

A ten-qubit quantum circuit that has been transpiled and has many entangling and rotation layers.

Il flusso di lavoro separa il circuito in "box" utili per apprendere il comportamento del rumore:

The same ten-qubit quantum circuit as in the previous figure, but now similar layers have been "boxed", meaning they have been outlined in a red box.

Infine, utilizza la propagazione degli operatori e l'apprendimento del rumore per produrre una mappa ombreggiata della sensibilità agli errori in tutto il circuito:

An error susceptibility map is shown for errors of various types.

Ogni box colorato nell'output corrisponde a uno specifico qubit in un momento specifico. I box più scuri (viola) indicano un qubit e uno strato in cui un errore non può propagarsi alla misura o alle misure di interesse. I box più chiari (giallo) corrispondono a un qubit e uno strato in cui un errore può avere una forte influenza sulla misura o sulle misure di interesse.

Nota le regioni viola a destra di ogni mappa. Un errore nello stesso strato della misura, ma su un qubit diverso, non può influenzare la misura data la connettività del circuito mostrata. Analogamente, un errore uno strato indietro nel tempo (uno strato a sinistra) può propagarsi solo al qubit adiacente nel passo successivo, a causa della struttura dello strato di entanglement, e così via. Quindi la forma a cono a destra è generale ogniqualvolta relativamente pochi qubit siano coinvolti nella misura di interesse.

Verifica la tua comprensione

Pensi che sia meglio creare una mappa a cono di luce ombreggiato prima o dopo la traspilazione? Perché?

Risposta

Deve essere fatto dopo la traspilazione. Perché queste diverse mappe siano utili dobbiamo assicurarci che i qubit adiacenti nel nostro circuito corrispondano a qubit adiacenti sul nostro chip quantistico. Altrimenti, i gate di entanglement mostrati come agenti sui qubit adiacenti nello schema del circuito finirebbero per richiedere gate SWAP e una struttura del circuito più complicata.

Cause​

Rumore ed errori classici​

Rumore ed errori quantistici​

Osservare gli errori e il loro accumulo​

Errori di rilassamento energetico (T1T_1T1​)​

Errori di gate e accumulo​

Caratterizzare gli errori quantistici​

Errori SPAM​

Errori coerenti contro errori incoerenti​

Perché sono fastidiosi​

Matrici di densità e canali quantistici​

Esempio​

Esempio​

Verifica la tua comprensione​

Canali quantistici​

Canale completamente defasante​

Caratterizzare il rumore come canali​

Errori incoerenti​

Verifica la tua comprensione​

Verifica la tua comprensione​

Modellare gli errori coerenti​

Errori a due qubit e coni di luce ombreggiati​

Gate cross-resonance echoed​

Verifica la tua comprensione​

Coni di luce ombreggiati​

Verifica la tua comprensione​

Propagazione degli errori​

Verifica la tua comprensione​

Cause

Rumore ed errori classici

Rumore ed errori quantistici

Osservare gli errori e il loro accumulo

Errori di rilassamento energetico ( $T_1$ )

Errori di gate e accumulo

Caratterizzare gli errori quantistici

Errori SPAM

Errori coerenti contro errori incoerenti

Perché sono fastidiosi

Matrici di densità e canali quantistici

Esempio

Esempio

Verifica la tua comprensione

Canali quantistici

Canale completamente defasante

Caratterizzare il rumore come canali

Errori incoerenti

Verifica la tua comprensione

Verifica la tua comprensione

Modellare gli errori coerenti

Errori a due qubit e coni di luce ombreggiati

Gate cross-resonance echoed

Verifica la tua comprensione

Coni di luce ombreggiati

Verifica la tua comprensione

Propagazione degli errori

Verifica la tua comprensione