Il codice Shor a 9 qubit

Passiamo ora al codice Shor a 9 qubit, che è un codice di correzione degli errori quantistici ottenuto combinando i due codici considerati nella sezione precedente: il codice a ripetizione a 3 bit per i qubit, che consente di correggere un singolo errore di bit-flip, e la versione modificata di quel codice, che consente di correggere un singolo errore di phase-flip.

Descrizione del codice

Il codice Shor a 9 qubit è il codice che si ottiene concatenando i due codici della sezione precedente. Ciò significa che applichiamo prima una codifica, che codifica un qubit in tre, e poi applichiamo l'altra codifica a ciascuno dei tre qubit usati per la prima codifica, per un totale di nove qubit.

Per essere più precisi, pur potendo applicare i due codici in qualsiasi ordine in questo caso particolare, sceglieremo di applicare prima la versione modificata del codice a ripetizione a 3 bit (che rileva gli errori di phase-flip), e poi codificheremo ciascuno dei tre qubit risultanti in modo indipendente usando il codice a ripetizione a 3 bit originale (che rileva gli errori di bit-flip). Ecco una rappresentazione tramite diagramma circuitale di questa codifica.

Come suggerisce la figura, penseremo ai nove qubit del codice Shor come raggruppati in tre blocchi di tre qubit ciascuno, dove ogni blocco è ottenuto dal secondo passo di codifica (che è il codice a ripetizione a 3 bit ordinario). Il codice a ripetizione a 3 bit ordinario, qui applicato tre volte in modo indipendente, è chiamato codice interno in questo contesto, mentre il codice esterno è il codice usato per il primo passo di codifica, ovvero la versione modificata del codice a ripetizione a 3 bit che rileva gli errori di phase-flip.

Possiamo specificare il codice in modo alternativo descrivendo come i due stati della base standard per il nostro qubit originale vengono codificati.

$$\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) \\[4mm] \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}$$

Una volta noto questo, possiamo determinare per linearità come viene codificato un vettore di stato arbitrario per un qubit.

Correzione degli errori di bit-flip e phase-flip

Errori e gate CNOT

Per analizzare come gli errori $X$ e $Z$ influenzano le codifiche dei qubit, sia per il codice Shor a 9 qubit sia per altri codici, sarà utile osservare alcune semplici relazioni tra questi errori e i gate CNOT. Mentre iniziamo ad analizzare il codice Shor a 9 qubit, questo è un buon momento per fermarci a fare questa osservazione.

I seguenti diagrammi circuitali illustrano tre relazioni di base tra i gate $X$ e i gate CNOT. In particolare, applicare un gate $X$ al qubit target prima di un CNOT equivale a scambiare l'ordine ed eseguire prima il CNOT, ma applicare un gate $X$ al qubit di controllo prima di un CNOT equivale ad applicare gate $X$ a entrambi i qubit dopo il CNOT. Infine, applicare gate $X$ a entrambi i qubit prima di un CNOT equivale ad eseguire prima il CNOT e poi applicare un gate $X$ al qubit di controllo. Queste relazioni possono essere verificate eseguendo le moltiplicazioni di matrici richieste o calcolando l'effetto dei circuiti sugli stati della base standard.

La situazione è analoga per i gate $Z$, con la differenza che i ruoli del qubit di controllo e del qubit target si scambiano. In particolare, valgono le tre relazioni illustrate dai seguenti circuiti quantistici.

Correzione degli errori di bit-flip

Consideriamo ora come gli errori possono essere rilevati e corretti usando il codice Shor a 9 qubit, iniziando con gli errori di bit-flip — che d'ora in poi chiameremo generalmente errori $X$ per brevità.

Per rilevare e correggere gli errori $X$, possiamo semplicemente trattare ciascuno dei tre blocchi della codifica in modo separato. Ogni blocco è una codifica di un qubit tramite il codice a ripetizione a 3 bit, che protegge dagli errori $X$ — quindi, eseguendo le misurazioni della sindrome e le correzioni degli errori $X$ descritte in precedenza su ciascun blocco, possiamo rilevare e correggere fino a un errore $X$ per blocco. In particolare, se c'è al massimo un errore $X$ sui nove qubit della codifica, questo errore verrà rilevato e corretto da questa procedura.

In breve, correggere gli errori di bit-flip è semplice per questo codice, grazie al fatto che il codice interno corregge gli errori di bit-flip.

Correzione degli errori di phase-flip

Consideriamo ora gli errori di phase-flip, o errori $Z$ per brevità. In questo caso non è del tutto chiaro cosa fare, perché è il codice esterno quello che rileva gli errori $Z$, ma il codice interno sembra essere in qualche modo "di intralcio", rendendo il rilevamento e la correzione di questi errori leggermente più difficile.

Supponiamo che un errore $Z$ si verifichi su uno dei 9 qubit del codice Shor, come quello indicato in questo diagramma.

Abbiamo già osservato cosa succede quando si verifica un errore $Z$ usando il codice a ripetizione a 3 bit — è equivalente a un errore $Z$ che si verifica prima della codifica. Nel contesto del codice Shor a 9 qubit, ciò significa che un errore $Z$ su uno qualsiasi dei tre qubit all'interno di un blocco ha sempre lo stesso effetto, equivalente a un errore $Z$ che si verifica sul qubit corrispondente prima che venga applicato il codice interno.

Ad esempio, il diagramma circuitale sopra è equivalente al seguente diagramma. Questo si può dedurre usando le relazioni tra i gate $Z$ e CNOT descritte in precedenza, oppure calcolando semplicemente l'effetto dei circuiti su uno stato arbitrario del qubit $\vert\psi\rangle.$

Questo suggerisce un'opzione per rilevare e correggere gli errori $Z$, ovvero decodificare il codice interno, lasciandoci con i tre qubit usati per la codifica esterna insieme a sei qubit di lavoro inizializzati. Possiamo quindi controllare questi tre qubit del codice esterno per gli errori $Z$, e infine ricodificare usando il codice interno, per tornare alla codifica a 9 qubit che otteniamo dal codice Shor. Se rileviamo un errore $Z$, possiamo correggerlo prima della ricodifica con il codice interno, oppure dopo la ricodifica, applicando un gate $Z$ a uno qualsiasi dei qubit di quel blocco.

Ecco un diagramma circuitale che include il circuito di codifica e l'errore suggerito sopra insieme ai passaggi appena descritti (ma non il passo di correzione effettivo).

In questo particolare esempio, la misurazione della sindrome è $11,$ che localizza l'errore $Z$ come avvenuto su uno dei qubit nel blocco centrale.

Un vantaggio di correggere gli errori $Z$ dopo il passo di ricodifica piuttosto che prima è che possiamo semplificare il circuito sopra. Il seguente circuito è equivalente, ma richiede quattro gate CNOT in meno.

Ancora una volta, la sindrome non indica quale qubit sia stato colpito da un errore $Z$, ma piuttosto quale blocco ha subito un errore $Z$, con l'effetto che è lo stesso indipendentemente da quale qubit all'interno del blocco sia stato colpito. Possiamo quindi correggere l'errore applicando un gate $Z$ a uno qualsiasi dei tre qubit del blocco colpito.

Come nota a margine, qui vediamo un esempio di degenerazione in un codice di correzione degli errori quantistici, dove siamo in grado di correggere certi errori (gli errori $Z$ in questo caso) senza essere in grado di identificarli in modo univoco.

Errori simultanei di bit-flip e phase-flip

Abbiamo ora visto come sia gli errori $X$ che gli errori $Z$ possano essere rilevati e corretti usando il codice Shor a 9 qubit, e in particolare come al massimo un errore $X$ o al massimo un errore $Z$ possano essere rilevati e corretti. Supponiamo ora che si verifichino sia un errore di bit-flip sia un errore di phase-flip, eventualmente sullo stesso qubit. Come si scopre, in questa situazione non occorre fare nulla di diverso rispetto a quanto già discusso — il codice è in grado di rilevare e correggere fino a un errore $X$ e un errore $Z$ simultaneamente, senza ulteriori modifiche.

Per essere più precisi, gli errori $X$ vengono rilevati applicando la misurazione della sindrome del codice a ripetizione a 3 bit ordinario, che viene eseguita separatamente su ciascuno dei tre blocchi di tre qubit; e gli errori $Z$ vengono rilevati attraverso la procedura descritta poco sopra, equivalente alla decodifica del codice interno, all'esecuzione della misurazione della sindrome per il codice a ripetizione a 3 bit modificato per i phase-flip, e poi alla ricodifica. Questi due passi di rilevamento degli errori — così come le correzioni corrispondenti — possono essere eseguiti in modo completamente indipendente l'uno dall'altro, e in effetti non importa in quale ordine vengano eseguiti.

Per capire perché, considera l'esempio rappresentato nel seguente diagramma circuitale, dove sia un errore $X$ sia un errore $Z$ hanno colpito il qubit in basso del blocco centrale.

Osserviamo innanzitutto che l'ordine degli errori non importa, nel senso che invertire la posizione degli errori $X$ e $Z$ produce un circuito equivalente. Per essere chiari, $X$ e $Z$ non commutano, bensì anti-commutano:

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

Questo implica che il seguente circuito è equivalente a quello appena mostrato, a meno di un fattore di fase globale pari a $-1.$

Ora possiamo spostare l'errore $Z$ esattamente come prima per ottenere un altro circuito equivalente.

A questo punto è evidente che se viene eseguita prima la procedura per rilevare e correggere gli errori $X$, l'errore $X$ verrà corretto, dopodiché la procedura per rilevare e correggere gli errori $Z$ potrà essere eseguita per eliminare l'errore $Z$ come prima.

In alternativa, la procedura per rilevare e correggere gli errori $Z$ può essere eseguita per prima. Il fatto che questa procedura funzioni come previsto, anche in presenza di uno o più errori $X$, deriva dal fatto che i gate $X$ su qualsiasi dei nove qubit usati per la codifica commutano con tutti i gate nel nostro circuito semplificato per misurare la sindrome degli errori $Z$. Pertanto, questa misurazione della sindrome identificherà comunque correttamente quale blocco è stato colpito da un errore $Z$. Il fatto che un errore $Z$ su qualsiasi blocco venga corretto applicando un gate $Z$ a qualsiasi qubit di quel blocco, anche se si è verificato anche un errore $X$, deriva dallo stesso argomento precedente sull'ordinamento dei gate $X$ e $Z$ che ci dà circuiti equivalenti a meno di una fase globale.

Ne consegue che il codice Shor a 9 qubit può correggere un errore $X$, un errore $Z$, o entrambi, su uno qualsiasi dei nove qubit usati per questo codice. In effetti, possiamo correggere più errori di così, inclusi più errori $X$ (purché ricadano in blocchi diversi) o più errori $Z$ (purché al massimo un blocco subisca un numero dispari di essi) — ma andando avanti, ciò che sarà più rilevante ai fini di questa lezione è che possiamo correggere un errore $X$, un errore $Z$, o entrambi su qualsiasi singolo qubit.

Riduzione degli errori per errori casuali

Prima di passare all'ultima sezione della lezione, che riguarda gli errori quantistici arbitrari, consideriamo brevemente le prestazioni del codice Shor a 9 qubit quando gli errori rappresentati da matrici di Pauli si verificano casualmente sui qubit.

Per essere più concreti, consideriamo un semplice modello di rumore in cui gli errori si verificano indipendentemente sui qubit, con ogni qubit che subisce un errore con probabilità $p$, e senza correlazione tra gli errori su qubit diversi — in modo analogo a un canale simmetrico binario per i bit classici. Potremmo assegnare probabilità diverse per gli errori $X,$ $Y,$ e $Z$, ma per mantenere le cose il più semplici possibile, considereremo il caso peggiore per il codice Shor a 9 qubit, ovvero che su ciascuno dei qubit colpiti si verifichi un errore $Y$. Un errore $Y$, tra l'altro, è equivalente (a meno di un irrilevante fattore di fase globale) a un errore $X$ e un errore $Z$ che si verificano sullo stesso qubit, dato che $Y = iXZ.$ Questo spiega il nostro apparente disinteresse per gli errori $Y$ fino a questo punto.

Supponiamo ora che $\mathsf{Q}$ sia un qubit in un certo stato che vogliamo proteggere dagli errori, e consideriamo la possibilità di usare il codice Shor a 9 qubit. Una domanda naturale da porsi è: "Dovremmo usarlo?"

La risposta non è necessariamente "sì." Se c'è troppo rumore, il che significa in questo contesto che $p$ è troppo grande, usare il codice Shor potrebbe in realtà peggiorare le cose — proprio come il codice a ripetizione a 3 bit è peggio di nessun codice quando $p$ è maggiore di un mezzo. Ma, se $p$ è sufficientemente piccolo, la risposta è "sì", dovremmo usare il codice, perché diminuirà la probabilità che lo stato codificato venga corrotto. Vediamo perché, e cosa significa che $p$ sia troppo grande o sufficientemente piccolo per questo codice.

Il codice Shor corregge qualsiasi errore di Pauli su un singolo qubit, incluso ovviamente un errore $Y$, ma non corregge correttamente due o più errori $Y$. Per chiarezza, stiamo assumendo di usare le correzioni degli errori $X$ e $Z$ descritte in precedenza nella sezione. (Naturalmente, se sapessimo in anticipo di dover preoccuparci solo degli errori $Y$, sceglieremmo naturalmente le correzioni in modo diverso — ma questo sarebbe barare con il modello di rumore, e potremmo sempre cambiare il modello selezionando diversi errori di Pauli per far fallire questa nuova scelta di correzioni ogni volta che due o più qubit sono colpiti da errori.)

Quindi, il codice protegge $\mathsf{Q}$ finché al massimo uno dei nove qubit è colpito da un errore, il che accade con probabilità

$$(1-p)^9 + 9 p (1-p)^8.$$

Altrimenti, con probabilità

$$1 - (1-p)^9 - 9 p (1-p)^8,$$

il codice non riesce a proteggere $\mathsf{Q}.$

In particolare, ciò significa che, a meno di una fase globale, un'operazione di Pauli non identità verrà applicata al nostro qubit $\mathsf{Q}$ (come qubit logico). Ovvero, se gli errori $X$ e $Z$ vengono rilevati e corretti per il codice Shor come descritto in precedenza nella lezione, ci ritroveremo con la codifica di uno stato equivalente, a meno di una fase globale, alla codifica di un'operazione di Pauli non identità applicata allo stato originale di $\mathsf{Q}.$ Un modo più sintetico per dirlo è che si sarà verificato un errore logico. Questo potrebbe avere o meno un effetto sullo stato originale di $\mathsf{Q}$ — o in altre parole sul qubit logico che abbiamo codificato con nove qubit fisici — ma, ai fini di questa analisi, consideriamo questo evento come un fallimento.

D'altra parte, se non avessimo utilizzato il codice, il nostro unico qubit subirebbe un destino simile (di essere soggetto a un'operazione di Pauli non identità) con probabilità $p.$ Il codice è utile quando la prima probabilità è minore della seconda:

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

Ecco un grafico che illustra, per valori molto piccoli di $p,$ che il codice fornisce un vantaggio, con il punto di pareggio che si verifica intorno a $0.0323.$

Se $p$ è minore di questo punto di pareggio, allora il codice è vantaggioso; al punto di pareggio le probabilità sono uguali, quindi stiamo solo sprecando il nostro tempo insieme a 8 qubit se usiamo il codice; e oltre il punto di pareggio non dovremmo assolutamente usare questo codice perché sta aumentando la probabilità di un errore logico su $\mathsf{Q}.$

Un tre e un quarto percento circa potrebbe non sembrare un punto di pareggio molto buono, soprattutto se confrontato con il $50\%,$ che è il punto di pareggio analogo per il codice a ripetizione a 3 bit per l'informazione classica. Questa differenza è dovuta in larga parte al fatto che l'informazione quantistica è più delicata e più difficile da proteggere rispetto all'informazione classica. Ma anche — pur riconoscendo che il codice Shor a 9 qubit rappresenta una scoperta brillante, essendo il primo codice di correzione degli errori quantistici al mondo — va riconosciuto che in termini pratici non è effettivamente un codice molto efficiente.