Controllare la propagazione degli errori

Il calcolo quantistico tollerante ai guasti è simile a una gara tra errori e correzione degli errori. Se il numero di errori è abbastanza piccolo, la correzione degli errori li correggerà con successo; ma se gli errori sono troppi, la correzione degli errori fallirà.

Per questo motivo, bisogna prestare sufficiente attenzione al modo in cui i calcoli quantistici vengono eseguiti nelle implementazioni tolleranti ai guasti dei circuiti, al fine di controllare la propagazione degli errori. In altre parole, un errore su un qubit può potenzialmente propagarsi a più qubit attraverso l'azione dei gate in un circuito quantistico, il che può causare un aumento drammatico del numero di errori. Questa è una preoccupazione fondamentale: se non riusciamo a controllare la propagazione degli errori, i nostri sforzi di correzione degli errori saranno rapidamente sopraffatti. Se, d'altra parte, siamo in grado di tenere sotto controllo la propagazione degli errori, la correzione degli errori ha una buona possibilità di tenere il passo, consentendo di correggere gli errori a una velocità sufficientemente alta da permettere al calcolo quantistico di funzionare come previsto.

Il punto di partenza per una discussione tecnica di questo problema è il riconoscimento che i gate a due qubit (o gate a più qubit in modo più generale) possono propagare errori, anche quando funzionano perfettamente. Per esempio, considera un gate controlled-NOT e supponi che un errore $X$ si verifichi sul qubit di controllo appena prima che il controlled-NOT venga eseguito. Come già osservato nella lezione "Correggere gli errori quantistici", questo equivale a un errore $X$ che si verifica su entrambi i qubit dopo l'esecuzione del controlled-NOT. La situazione è simile per un errore $Z$ che agisce sul target anziché sul controllo prima dell'esecuzione del gate controlled-NOT.

Questa è una propagazione di errori, perché la posizione sfortunata di un errore $X$ o $Z$ prima del controlled-NOT lo trasforma effettivamente in due errori dopo il controlled-NOT. Ciò accade anche quando il gate controlled-NOT è perfetto, e non dobbiamo dimenticare che un dato gate controlled-NOT potrebbe essere esso stesso rumoroso, il che può creare errori correlati su due qubit.

Ad aggiungere alla nostra preoccupazione c'è il fatto che i successivi gate a due qubit potrebbero propagare ulteriormente questi errori, come suggerisce la figura seguente.

In un certo senso, non possiamo mai aggirare questo problema; finché usiamo gate a più qubit, ci sarà sempre il potenziale per la propagazione degli errori. Tuttavia, come discuteremo nelle sottosezioni che seguono, è possibile adottare misure per limitare i danni causati da questo fenomeno, consentendo di gestire gli errori propagati.

Implementazioni transversali dei gate

Il modo più semplice conosciuto per mitigare la propagazione degli errori nei circuiti quantistici tolleranti ai guasti è implementare i gate transversalmente, il che significa costruire gadget per essi che abbiano una certa forma semplice. In particolare, i gadget devono essere un prodotto tensore di operazioni (o, in altre parole, un circuito quantistico di profondità uno), dove ogni operazione può agire solo su una singola posizione di qubit all'interno di ciascun blocco di codice che tocca. Forse è più facile spiegarlo attraverso alcuni esempi.

Esempi di implementazioni transversali di gate

Considera la figura seguente, che suggerisce un'implementazione transversale di un gate CNOT. (Questa particolare implementazione, in cui i CNOT vengono eseguiti qubit per qubit, funziona solo per i codici CSS — ma funziona, in effetti, per tutti i codici CSS.)

In questa figura ci sono due blocchi di codice, ciascuno raffigurato come composto da cinque qubit (anche se potrebbero essere di più, come già suggerito). Il circuito a destra ha profondità uno, e ciascuno dei gate CNOT agisce su una singola posizione di qubit all'interno di ciascun blocco: sia il controllo che il target del primo CNOT sono il qubit più in alto (ossia il qubit 0 nella convenzione di numerazione di Qiskit), sia il controllo che il target del secondo CNOT sono il secondo qubit dall'alto (ossia il qubit 1), e così via. Quindi, questo è un gadget transversale.

Per un secondo esempio — in realtà una classe di esempi — considera qualsiasi gate di Pauli. I gate di Pauli possono sempre essere implementati transversalmente, per qualsiasi codice stabilizzatore, costruendo gadget composti da operazioni di Pauli. In particolare, ogni operazione di Pauli su un qubit logico codificato da un codice stabilizzatore può essere implementata transversalmente scegliendo un'appropriata operazione di Pauli sui qubit fisici usati per la codifica. Questo è coerente con un fatto menzionato en passant nella lezione "Il formalismo degli stabilizzatori": a meno di una fase globale, le operazioni di Pauli che commutano con ogni generatore di stabilizzatore di un codice stabilizzatore si comportano come operazioni di Pauli sul qubit o qubit codificati da quel codice.

Come esempio specifico, considera il codice di Shor a $9$ qubit, per il quale gli stati della base standard possono essere codificati come segue.

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[3mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

Un gate $X$ sul qubit logico codificato da questo codice può essere implementato transversalmente dall'operazione di Pauli a $9$ qubit

$$Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I}$$

mentre un gate $Z$ sul qubit logico può essere implementato transversalmente dall'operazione di Pauli a $9$ qubit

$$X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}.$$

Entrambe queste operazioni di Pauli hanno peso $3,$ che è il peso minimo richiesto. (Il codice di Shor a $9$ qubit ha distanza $3,$ quindi qualsiasi operazione di Pauli non identità di peso $2$ o inferiore viene rilevata come errore.)

E, per un terzo esempio, il codice di Steane a $7$ qubit (e in effetti ogni codice a colori) consente un'implementazione transversale di tutti i gate di Clifford. Abbiamo già visto come i gate CNOT vengano implementati transversalmente per qualsiasi codice CSS, quindi resta da considerare i gate $H$ e $S$. Un gate di Hadamard applicato a tutti i $7$ qubit del codice di Steane è equivalente all'applicazione di $H$ al qubit logico che codifica, mentre un gate $S^{\dagger}$ (anziché un gate $S$) applicato a tutti i $7$ qubit è equivalente a un gate $S$ logico.

Propagazione degli errori per i gadget transversali

Ora che sappiamo cosa sono le implementazioni transversali dei gate, discutiamo la loro connessione con la propagazione degli errori.

Per un'implementazione transversale di un gate a qubit singolo, abbiamo semplicemente un prodotto tensore di gate a qubit singolo nel nostro gadget, che agisce su un blocco di codice di qubit fisici per il codice correttore di errori quantistici scelto. Anche se uno qualsiasi di questi gate potrebbe fallire e introdurre un errore, non ci sarà nessuna propagazione di errori perché non sono coinvolti gate a qubit multipli. Immediatamente dopo l'applicazione del gadget, viene eseguita la correzione degli errori; e se il numero di errori introdotti dal gadget (o durante l'esecuzione del gadget) è sufficientemente piccolo, gli errori verranno corretti. Quindi, se il tasso di errori introdotti da gate difettosi è sufficientemente piccolo, la correzione degli errori ha buone possibilità di riuscire.

Per un'implementazione transversale di un gate a due qubit, d'altra parte, c'è il potenziale per una propagazione degli errori — semplicemente non c'è modo di evitarlo, come abbiamo già osservato. Il punto essenziale, tuttavia, è che un gadget transversale non può mai causare una propagazione degli errori all'interno di un singolo blocco di codice.

Per esempio, considerando l'implementazione transversale di un gate CNOT per un codice CSS descritta sopra, un errore $X$ potrebbe verificarsi sul qubit superiore del blocco di codice superiore appena prima che il gadget venga eseguito, e il primo CNOT all'interno del gadget propagherà quell'errore al qubit superiore nel blocco inferiore. Tuttavia, i due errori risultanti si trovano ora in blocchi di codice separati. Quindi, assumendo che il nostro codice possa correggere un errore $X$, i passaggi di correzione degli errori che avvengono dopo il gadget correggeranno i due errori $X$ individualmente — perché si verifica solo un singolo errore all'interno di ciascun blocco di codice. Al contrario, se la propagazione degli errori avvenisse all'interno dello stesso blocco di codice, potrebbe trasformare un errore a basso peso in un errore ad alto peso che il codice non riesce a gestire.

Non-universalità dei gate transversali

Per due codici stabilizzatori diversi, può accadere che un particolare gate possa essere implementato transversalmente con un codice ma non con l'altro. Per esempio, mentre non è possibile implementare un gate $T$ transversalmente usando il codice di Steane a $7$ qubit, ci sono altri codici per i quali ciò è possibile.

Sfortunatamente, non è mai possibile, per nessun codice correttore di errori quantistici non banale, implementare un insieme universale di gate transversalmente. Questo fatto è noto come il teorema di Eastin-Knill.

Teorema

Teorema di Eastin-Knill: Per qualsiasi codice correttore di errori quantistici con distanza di almeno 2, l'insieme dei gate logici che possono essere implementati transversalmente genera un insieme di operazioni che (a meno di una fase globale) è discreto, e pertanto non è universale.

La dimostrazione di questo teorema non verrà spiegata qui. (Non è una dimostrazione complicata, ma richiede una conoscenza di base dei gruppi di Lie e delle algebre di Lie, che non fanno parte dei prerequisiti della serie.) L'idea di base, tuttavia, può essere espressa in termini intuitivi: Le famiglie infinite di operazioni transversali non possono rimanere nello spazio del codice di un codice non banale perché differenze infinitesimali nelle operazioni transversali sono ben approssimate da operazioni di Pauli a basso peso, che il codice rileva come errori.

In sintesi, i gadget transversali offrono un'implementazione semplice e intrinsecamente tollerante ai guasti dei gate — ma per qualsiasi scelta ragionevole di un codice correttore di errori quantistici, non esisterà mai un insieme universale di gate che possa essere implementato in questo modo, il che rende necessario l'uso di gadget alternativi.

Magic state

Dato che non è possibile, per nessuna scelta non banale di codice correttore di errori quantistici, implementare un insieme universale di gate quantistici transversalmente, dobbiamo considerare altri metodi per implementare i gate in modo tollerante ai guasti. Un metodo ben noto si basa sulla nozione di magic state, che sono stati quantistici di qubit che consentono implementazioni tolleranti ai guasti di determinati gate.

Implementare gate con i magic state

Cominciamo considerando i gate $S$ e $T$, che hanno le seguenti descrizioni matriciali.

$$S = \begin{pmatrix} 1 & 0\\ 0 & i \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/2} \end{pmatrix} \qquad\text{e}\qquad T = \begin{pmatrix} 1 & 0\\ 0 & \frac{1+i}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/4} \end{pmatrix}$$

Per definizione, $S$ è un'operazione di Clifford, mentre $T$ non lo è; non è possibile implementare un gate $T$ con un circuito composto da gate di Clifford (gate $H$, gate $S$ e gate CNOT).

Tuttavia, è possibile implementare un gate $T$ (a meno di una fase globale) con un circuito composto da gate di Clifford se, in aggiunta, abbiamo una copia dello stato

$$T\vert {+} \rangle = \frac{1}{\sqrt{2}} \vert 0 \rangle + \frac{e^{i\pi/4}}{\sqrt{2}} \vert 1\rangle,$$

e permettiamo misurazioni nella base standard e gate controllati classicamente. In particolare, il circuito seguente mostra un modo per farlo. Il fenomeno mostrato qui è un esempio alquanto semplificato di teletrasporto di gate quantistici.

Per verificare che questo circuito funzioni correttamente, possiamo prima calcolare l'azione del gate CNOT sull'input.

$$T \vert {+} \rangle \otimes \vert\psi\rangle \stackrel{\text{CNOT}}{\longmapsto} \frac{1}{\sqrt{2}} \vert 0\rangle \otimes T \vert \psi\rangle + \frac{1+i}{2} \vert 1\rangle \otimes T^{\dagger} \vert \psi\rangle$$

La misurazione dà quindi gli esiti $0$ e $1$ con probabilità uguale. Se l'esito è $0,$ il gate $S$ non viene eseguito, e lo stato di output è $T\vert\psi\rangle;$ e se l'esito è $1,$ il gate $S$ viene eseguito, e lo stato di output è $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle.$

Lo stato $T\vert {+}\rangle$ è chiamato magic state in questo contesto, sebbene non sia unico in questo senso: anche altri stati sono chiamati magic state quando possono essere usati in modo simile (per gate potenzialmente diversi e usando circuiti diversi). Per esempio, sostituendo lo stato $T\vert{+}\rangle$ con lo stato $S\vert{+}\rangle$ e rimpiazzando il gate $S$ nel circuito sopra con un gate $Z$ si implementa un gate $S$ — il che è potenzialmente utile per il calcolo quantistico tollerante ai guasti usando un codice per il quale i gate $S$ non possono essere implementati transversalmente.

Gadget tolleranti ai guasti dai magic state

Potrebbe non essere chiaro che usare i magic state per implementare gate sia utile per la tolleranza ai guasti. Per l'implementazione del gate $T$ descritta sopra, per esempio, sembra che dobbiamo ancora applicare un gate $T$ a uno stato $\vert{+}\rangle$ per ottenere un magic state, che poi utilizziamo per implementare un gate $T$. Quindi qual è il vantaggio di usare questo approccio per la tolleranza ai guasti?

Ecco tre punti chiave che forniscono una risposta a questa domanda.

1. La creazione di magic state non richiede necessariamente l'applicazione del gate che stiamo cercando di implementare a un particolare stato. Per esempio, applicare un gate $T$ a uno stato $\vert {+} \rangle$ non è l'unico modo per ottenere uno stato $T\vert{+}\rangle$.

2. La creazione di magic state può essere effettuata separatamente dal calcolo in cui vengono utilizzati. Ciò significa che gli errori che sorgono nel processo di creazione dei magic state non si propagheranno al calcolo effettivo che viene eseguito.

3. Se i singoli gate nel circuito che implementa un gate scelto usando un magic state possono essere implementati in modo tollerante ai guasti, e assumiamo la disponibilità di magic state, otteniamo un'implementazione tollerante ai guasti del gate scelto.

Per semplificare la discussione che segue, concentriamoci specificamente sui gate $T$ — tenendo presente che la metodologia può essere estesa ad altri gate. Un'implementazione tollerante ai guasti di un gate $T$ usando magic state ha la forma suggerita dalla figura seguente.

I qubit nel circuito originale del gate $T$ corrispondono a qubit logici in questo diagramma, che sono codificati dal codice che stiamo usando per la tolleranza ai guasti. Gli input e gli output nel diagramma devono quindi essere intesi come codifiche di questi stati. Ciò significa, in particolare, che in realtà non abbiamo bisogno solo dei magic state — abbiamo bisogno di magic state codificati. I gate nel circuito originale del gate $T$ sono qui sostituiti da gadget, che assumiamo siano tolleranti ai guasti.

Questa figura particolare suggerisce quindi che abbiamo già gadget tolleranti ai guasti per i gate CNOT e i gate $S$. Per un codice a colori, questi gadget potrebbero essere transversali; per un codice a superficie (o qualsiasi altro codice CSS), il CNOT può essere eseguito transversalmente, mentre il gadget del gate $S$ potrebbe essere esso stesso implementato usando magic state, come è stato suggerito in precedenza essere possibile. (La figura suggerisce anche che abbiamo un gadget tollerante ai guasti per eseguire una misurazione nella base standard, che abbiamo ignorato finora. Questo potrebbe essere effettivamente difficile per alcuni codici selezionati a tale scopo, ma per un codice CSS è una questione di misurare ogni qubit fisico seguita da post-elaborazione classica.)

L'implementazione è quindi tollerante ai guasti, assumendo di avere una codifica di un magic state $T\vert{+}\rangle.$ Ma non abbiamo ancora affrontato il problema di come ottenere una codifica di questo stato. Un modo per ottenere magic state codificati (o, forse più accuratamente, per migliorarli) è attraverso un processo noto come distillazione di magic state. Il diagramma seguente illustra come appare questo processo al livello più alto.

In parole, una collezione di magic state codificati rumorosi viene alimentata in un tipo speciale di circuito noto come distillatore. Tutti i blocchi di output tranne uno vengono misurati — il che significa che i qubit logici vengono misurati con misurazioni nella base standard. Se uno qualsiasi degli esiti delle misurazioni è $1,$ il processo è fallito e deve essere riavviato. Se, invece, ogni esito della misurazione è $0,$ lo stato risultante del blocco di codice superiore sarà un magic state codificato meno rumoroso. Questo stato potrebbe poi unirsi ad altri quattro come input in un altro distillatore, oppure essere usato per implementare un gate $T$ se è considerato sufficientemente vicino a un vero magic state codificato. Naturalmente, il processo deve iniziare da qualche parte, con una possibilità che è prepararli in modo non tollerante ai guasti.

Ci sono diversi modi noti per costruire il distillatore stesso, ma non verranno spiegati o analizzati qui. A livello logico, l'approccio tipico — in modo notevole e alquanto coincidentale — consiste nell'eseguire un circuito di codifica per un codice stabilizzatore al contrario! Questo potrebbe, in effetti, essere un codice stabilizzatore diverso da quello usato per la correzione degli errori. Per esempio, si potrebbe potenzialmente usare un codice a superficie o a colori per la correzione degli errori, ma eseguire un encoder per il codice a $5$ qubit al contrario ai fini della distillazione dei magic state. I circuiti di codifica per i codici stabilizzatori richiedono solo gate di Clifford, il che semplifica l'implementazione tollerante ai guasti di un distillatore. In realtà, i dettagli dipendono dai codici utilizzati.

In sintesi, questa sezione ha avuto lo scopo di fornire solo una discussione di alto livello sui magic state, con l'intenzione di dare solo un'idea di base di come funzionano. A volte si afferma che il sovraccarico per l'utilizzo dei magic state per implementare gate in modo tollerante ai guasti in questi termini sarebbe estremamente elevato, con la grande maggioranza del lavoro dedicata al processo di distillazione. Tuttavia, questo non è in realtà così chiaro — ci sono molti potenziali modi per ottimizzare questi processi. Esistono, inoltre, approcci alternativi per costruire gadget tolleranti ai guasti per gate che non possono essere implementati transversalmente. Per esempio, deformazione del codice e commutazione del codice sono parole chiave associate ad alcuni di questi schemi — e nuovi modi continuano a essere sviluppati e raffinati.

Correzione degli errori tollerante ai guasti

Oltre all'implementazione dei vari gadget necessari per un'implementazione tollerante ai guasti di un dato circuito quantistico, c'è un'altra questione importante che deve essere riconosciuta: l'implementazione dei passaggi di correzione degli errori stessi. Questo riporta all'idea che qualsiasi cosa che coinvolga informazioni quantistiche è suscettibile agli errori — inclusi i circuiti che sono essi stessi destinati a correggere gli errori.

Considera, per esempio, il tipo di circuito descritto nella lezione "Il formalismo degli stabilizzatori" per misurare i generatori di stabilizzatori in modo non distruttivo usando la stima di fase. Questi circuiti non sono chiaramente tolleranti ai guasti perché possono causare la propagazione degli errori all'interno del blocco di codice su cui operano. Questo potrebbe sembrare piuttosto problematico, ma ci sono diversi modi noti per eseguire la correzione degli errori in modo tollerante ai guasti senza causare la propagazione degli errori all'interno dei blocchi di codice che vengono corretti.

Un metodo è noto come correzione degli errori di Shor, perché fu scoperto per la prima volta da Peter Shor. L'idea è di eseguire le misurazioni della sindrome usando un cosiddetto cat state, che è uno stato a $n$ qubit della forma

$$\frac{1}{\sqrt{2}} \vert 0^n \rangle + \frac{1}{\sqrt{2}} \vert 1^n \rangle,$$

dove $0^n$ e $1^n$ si riferiscono alle stringhe di tutti zeri e tutti uno di lunghezza $n.$ Per esempio, questo è uno stato $\vert\phi^+\rangle$ quando $n=2$ e uno stato GHZ quando $n=3,$ ma in generale, la correzione degli errori di Shor richiede uno stato come questo per $n$ pari al peso del generatore di stabilizzatore che viene misurato.

Come esempio, il circuito mostrato qui misura un generatore di stabilizzatori della forma $P_2\otimes P_1 \otimes P_0.$

Ciò richiede la costruzione del cat state stesso, e per farlo funzionare in modo affidabile in presenza di errori e gate potenzialmente difettosi, il metodo richiede in realtà di eseguire ripetutamente circuiti come questo per fare inferenze su dove potrebbero essere verificati errori diversi durante il processo.

Un metodo alternativo è noto come correzione degli errori di Steane. Questo metodo funziona in modo diverso e funziona solo per i codici CSS. L'idea è che non eseguiamo effettivamente le misurazioni della sindrome sugli stati quantistici codificati nel circuito che stiamo cercando di eseguire, ma invece intenzionalmente propaghiamo gli errori a un sistema di spazio di lavoro, e poi misuriamo quel sistema e classicamente rileviamo gli errori. I seguenti diagrammi circuitali illustrano come questo può essere fatto per rilevare rispettivamente errori $X$ e $Z$.

Un metodo correlato noto come correzione degli errori di Knill estende questo metodo a codici stabilizzatori arbitrari usando il teletrasporto.