Codici stabilizzatori

Adesso definiremo i codici stabilizzatori in generale. Discuteremo anche alcune delle loro proprietà di base e il loro funzionamento, incluso come gli stati possono essere codificati e come gli errori vengono rilevati e corretti mediante questi codici.

Definizione di codici stabilizzatori

Un codice stabilizzatore a $n$ qubit è specificato da una lista di operazioni di Pauli su $n$ qubit, $P_1,\ldots,P_r.$ In questo contesto queste operazioni vengono chiamate generatori dello stabilizzatore, e devono soddisfare le seguenti tre proprietà.

1. I generatori dello stabilizzatore commutano tutti fra loro.

   $$P_j P_k = P_k P_j \qquad \text{(per ogni $j,k\in\{1,\ldots,r\}$)}$$

2. I generatori dello stabilizzatore formano un insieme generatore minimale.

   $$P_k \notin \langle P_1,\ldots,P_{k-1},P_{k+1},\ldots,P_r\rangle \qquad \text{(per ogni $k\in\{1,\ldots,r\}$)}$$

3. Almeno un vettore di stato quantistico è fissato da tutti i generatori dello stabilizzatore.

   $$-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle$$

   (Non è ovvio che l'esistenza di un vettore di stato quantistico $\vert\psi\rangle$ fissato da tutti i generatori dello stabilizzatore, nel senso che $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle,$ sia equivalente a $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle,$ ma è effettivamente così, e vedremo perché più avanti nella lezione.)

Supponendo di avere una tale lista $P_1,\ldots,P_r,$ lo spazio codice definito da questi generatori dello stabilizzatore è il sottospazio $\mathcal{C}$ che contiene tutti i vettori di stato quantistico a $n$ qubit fissati da tutti gli $r$ generatori dello stabilizzatore.

$$\mathcal{C} = \bigl\{ \vert\psi\rangle \,:\, P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle \bigr\}$$

I vettori di stato quantistico in questo sottospazio sono esattamente quelli che possono essere considerati come codifiche valide di stati quantistici. Discuteremo il processo effettivo di codifica più avanti.

Infine, lo stabilizzatore del codice definito dai generatori $P_1, \ldots, P_r$ è l'insieme generato da queste operazioni:

$$\langle P_1,\ldots,P_r\rangle.$$

Un modo naturale di pensare a un codice stabilizzatore è quello di considerare i generatori dello stabilizzatore come osservabili, e di interpretare collettivamente gli esiti delle misurazioni associate a questi osservabili come una sindrome di errore. Le codifiche valide sono vettori di stato quantistico a $n$ qubit per cui gli esiti delle misurazioni, come autovalori, sono garantiti essere tutti $+1.$ Qualsiasi altra sindrome, in cui si verifica almeno un esito di misurazione $-1$, segnala che è stato rilevato un errore.

Tra poco esamineremo diversi esempi, ma prima è opportuno fare alcune osservazioni sulle tre condizioni sui generatori dello stabilizzatore.

La prima condizione è naturale, alla luce dell'interpretazione dei generatori dello stabilizzatore come osservabili, poiché implica che l'ordine in cui vengono eseguite le misurazioni non ha importanza: gli osservabili commutano, quindi anche le misurazioni commutano. Questo impone naturalmente certi vincoli algebrici sui codici stabilizzatori, importanti per il loro funzionamento.

La seconda condizione richiede che i generatori dello stabilizzatore formino un insieme generatore minimale, nel senso che rimuovere uno qualsiasi di essi produrrebbe uno stabilizzatore più piccolo. In senso stretto, questa condizione non è davvero essenziale al funzionamento dei codici stabilizzatori in senso operativo — e, come vedremo nella prossima lezione, a volte ha senso considerare insiemi di generatori dello stabilizzatore per codici che in realtà non soddisfano questa condizione. Tuttavia, ai fini dell'analisi dei codici stabilizzatori e della spiegazione delle loro proprietà, assumeremo che questa condizione sia valida. In breve, questa condizione garantisce che ogni osservabile misurato per ottenere la sindrome di errore aggiunga informazioni sugli errori possibili, piuttosto che essere ridondante e produrre risultati inferibili dalle altre misurazioni dei generatori dello stabilizzatore.

La terza condizione richiede che almeno un vettore non nullo sia fissato da tutti i generatori dello stabilizzatore, il che è equivalente al fatto che $-\mathbb{I}^{\otimes n}$ non sia contenuto nello stabilizzatore. La necessità di questa condizione deriva dal fatto che è effettivamente possibile scegliere un insieme generatore minimale di operazioni di Pauli su $n$ qubit che commutano tutte fra loro, eppure nessun vettore non nullo è fissato da tutte le operazioni. Non siamo interessati a "codici" per cui non esistono codifiche valide, quindi escludiamo questa possibilità richiedendo questa condizione come parte della definizione.

Esempi

Ecco alcuni esempi di codici stabilizzatori per valori piccoli di $n.$ Vedremo altri esempi, inclusi alcuni per cui $n$ può essere molto più grande, nella prossima lezione.

Codice a ripetizione a 3 bit

Il codice a ripetizione a 3 bit è un esempio di codice stabilizzatore, in cui i generatori dello stabilizzatore sono $Z \otimes Z \otimes \mathbb{I}$ e $\mathbb{I} \otimes Z \otimes Z.$

Possiamo verificare facilmente che questi due generatori soddisfano le condizioni richieste. Prima di tutto, i due generatori dello stabilizzatore $Z \otimes Z \otimes \mathbb{I}$ e $\mathbb{I} \otimes Z \otimes Z$ commutano fra loro.

$$(Z \otimes Z \otimes \mathbb{I})(\mathbb{I} \otimes Z \otimes Z) = Z \otimes \mathbb{I} \otimes Z = (\mathbb{I} \otimes Z \otimes Z)(Z \otimes Z \otimes \mathbb{I})$$

In secondo luogo, abbiamo un insieme generatore minimale (abbastanza banalmente in questo caso).

$$\begin{aligned} Z \otimes Z \otimes \mathbb{I} \notin \langle\mathbb{I} \otimes Z \otimes Z\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, \mathbb{I} \otimes Z \otimes Z\}\\[1mm] \mathbb{I} \otimes Z \otimes Z \notin \langle Z \otimes Z \otimes \mathbb{I}\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z \otimes Z \otimes \mathbb{I}\} \end{aligned}$$

E in terzo luogo, sappiamo già che $\vert 000\rangle$ e $\vert 111\rangle,$ così come qualsiasi combinazione lineare di questi vettori, sono fissati sia da $Z \otimes Z \otimes \mathbb{I}$ che da $\mathbb{I} \otimes Z \otimes Z.$ In alternativa, possiamo concluderlo usando la condizione equivalente dalla definizione.

$$-\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\notin \langle Z \otimes Z \otimes \mathbb{I}, \mathbb{I} \otimes Z \otimes Z\rangle = \{ \mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z\otimes Z\otimes\mathbb{I}, Z\otimes\mathbb{I}\otimes Z, \mathbb{I}\otimes Z\otimes Z \}$$

Queste condizioni possono essere molto più difficili da verificare per codici stabilizzatori più complicati.

Codice a ripetizione a 3 bit modificato

Nella lezione precedente abbiamo visto che è possibile modificare il codice a ripetizione a 3 bit in modo che protegga dagli errori di phase-flip invece che dagli errori di bit-flip. Come codice stabilizzatore, questo nuovo codice è facile da descrivere: i suoi generatori dello stabilizzatore sono $X \otimes X \otimes \mathbb{I}$ e $\mathbb{I} \otimes X \otimes X.$

Questa volta i generatori dello stabilizzatore rappresentano osservabili $X\otimes X$ invece di $Z\otimes Z$, quindi sono essenzialmente controlli di parità nella base più/meno piuttosto che nella base standard. Le tre condizioni richieste sui generatori dello stabilizzatore sono facilmente verificabili, in modo analogo al codice a ripetizione a 3 bit ordinario.

Codice di Shor a 9 qubit

Ecco il codice di Shor a 9 qubit, anch'esso un codice stabilizzatore, espresso tramite i generatori dello stabilizzatore.

$$\begin{gathered} Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z\\[1mm] X \otimes X \otimes X \otimes X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\otimes X \otimes X \otimes X \otimes X \otimes X \otimes X \end{gathered}$$

In questo caso, abbiamo essenzialmente tre copie del codice a ripetizione a 3 bit, una per ciascuno dei tre blocchi di tre qubit, insieme agli ultimi due generatori dello stabilizzatore, che assumono una forma che ricorda il circuito per il rilevamento dei phase-flip in questo codice.

Un modo alternativo di pensare agli ultimi due generatori dello stabilizzatore è che assumono la stessa forma del codice a ripetizione a 3 bit per i phase-flip, eccetto che $X\otimes X\otimes X$ è sostituito a $X$, il che è coerente con il fatto che $X\otimes X\otimes X$ corrisponde a un'operazione $X$ sui qubit logici codificati con il codice a ripetizione a 3 bit.

Prima di passare ad altri esempi, va notato che i simboli del prodotto tensoriale vengono spesso omessi quando si descrivono i codici stabilizzatori mediante liste di generatori, perché tende a renderli più facili da leggere e a coglierne gli schemi. Ad esempio, gli stessi generatori dello stabilizzatore del codice di Shor a 9 qubit si presentano così senza i simboli del prodotto tensoriale scritti esplicitamente.

$$\begin{array}{ccccccccc} Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z\\[1mm] X & X & X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I}& X & X & X & X & X & X \end{array}$$

Codice di Steane a 7 qubit

Ecco un altro esempio di codice stabilizzatore, noto come codice di Steane a 7 qubit. Ha alcune caratteristiche notevoli, e torneremo su questo codice di tanto in tanto nelle restanti lezioni del corso.

$$\begin{array}{ccccccc} Z & Z & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] Z & Z & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} \\[1mm] Z & \mathbb{I} & Z & \mathbb{I} & Z & \mathbb{I} & Z \\[1mm] X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] X & X & \mathbb{I} & \mathbb{I} & X & X & \mathbb{I} \\[1mm] X & \mathbb{I} & X & \mathbb{I} & X & \mathbb{I} & X \end{array}$$

Per ora, osserviamo semplicemente che si tratta di un codice stabilizzatore valido. I primi tre generatori dello stabilizzatore commutano chiaramente fra loro, perché $Z$ commuta con se stesso e l'identità commuta con tutto, e la situazione è analoga per gli ultimi tre generatori. Resta da verificare che se prendiamo uno dei generatori $Z$ (cioè uno dei primi tre) e uno dei generatori $X$ (cioè uno degli ultimi tre), questi due generatori commutino, e si possono esaminare le 9 possibili coppie per verificarlo. In tutti questi casi, una matrice $X$ e una $Z$ di Pauli si trovano nella stessa posizione un numero pari di volte, quindi i due generatori commutano, proprio come $X\otimes X$ e $Z\otimes Z$ commutano. Questo è anche un insieme generatore minimale, e definisce uno spazio codice non banale, fatti che sono lasciati alla tua riflessione.

Il codice di Steane a 7 qubit è simile al codice di Shor a 9 qubit nel senso che codifica un singolo qubit e consente la correzione di un errore arbitrario su un qubit, ma richiede solo 7 qubit invece di 9.

Codice a 5 qubit

Sette non è il numero minimo di qubit necessari per codificare un qubit e proteggerlo da un errore arbitrario su un qubit — ecco un codice stabilizzatore che riesce a farlo usando solo 5 qubit.

$$\begin{array}{ccccc} X & Z & Z & X & \mathbb{I} \\[1mm] \mathbb{I} & X & Z & Z & X \\[1mm] X & \mathbb{I} & X & Z & Z \\[1mm] Z & X & \mathbb{I} & X & Z \\[1mm] \end{array}$$

Questo codice è tipicamente chiamato il codice a 5 qubit. È il numero minimo di qubit in un codice di correzione degli errori quantistici che può consentire la correzione di un errore arbitrario su un singolo qubit.

Codici stabilizzatori unidimensionali

Ecco un altro esempio di codice stabilizzatore, anche se in realtà non codifica alcun qubit: lo spazio codice è unidimensionale. È tuttavia ancora un codice stabilizzatore valido per la definizione.

$$\begin{array}{cc} Z & Z \\[1mm] X & X \end{array}$$

Nello specifico, lo spazio codice è lo spazio unidimensionale generato da un e-bit $\vert\phi^+\rangle.$

Ecco un esempio correlato di codice stabilizzatore il cui spazio codice è lo spazio unidimensionale generato da uno stato GHZ $(\vert 000\rangle + \vert 111\rangle)/\sqrt{2}.$

$$\begin{array}{cc} Z & Z & \mathbb{I} \\[1mm] \mathbb{I} & Z & Z \\[1mm] X & X & X \end{array}$$

Dimensione dello spazio codice

Supponiamo di avere un codice stabilizzatore, descritto da generatori dello stabilizzatore $P_1,\ldots,P_r$ su $n$ qubit. Forse la primissima domanda che viene in mente su questo codice è: "Quanti qubit codifica?"

Questa domanda ha una risposta semplice. Supposto che i generatori dello stabilizzatore $P_1, \ldots, P_r$ su $n$ qubit soddisfino i tre requisiti della definizione (ovvero che i generatori commutino tutti fra loro, che questo sia un insieme generatore minimale, e che lo spazio codice non sia vuoto), ne consegue che lo spazio codice per questo codice stabilizzatore ha dimensione $2^{n-r}$, quindi $n-r$ qubit possono essere codificati con questo codice.

In modo intuitivo, abbiamo $n$ qubit da utilizzare per questa codifica, e ogni generatore dello stabilizzatore "sottrae un qubit" in termini di quanti qubit possiamo codificare. Nota che questo non riguarda quali o quanti errori possono essere rilevati o corretti, ma è solo un'affermazione sulla dimensione dello spazio codice.

Ad esempio, sia per il codice a ripetizione a 3 bit che per la versione modificata per gli errori di phase-flip, abbiamo $n=3$ qubit e $r=2$ generatori dello stabilizzatore, e quindi questi codici possono ciascuno codificare 1 qubit. Per un altro esempio, considera il codice a 5 qubit: abbiamo 5 qubit e 4 generatori dello stabilizzatore, quindi ancora una volta lo spazio codice ha dimensione 2, il che significa che un qubit può essere codificato con questo codice. Per un ultimo esempio, il codice i cui generatori dello stabilizzatore sono $X\otimes X$ e $Z\otimes Z$ ha uno spazio codice unidimensionale, generato dallo stato $\vert\phi^+\rangle$, il che è coerente con $n=2$ qubit e $r=2$ generatori dello stabilizzatore.

Vediamo ora come si può dimostrare questo fatto. Il primo passo consiste nell'osservare che, poiché i generatori dello stabilizzatore commutano, e poiché ogni operazione di Pauli è il proprio inverso, ogni elemento dello stabilizzatore può essere espresso come un prodotto

$$P_1^{a_1} \cdots P_r^{a_r},$$

dove $a_1,\ldots,a_r\in\{0,1\}.$ In altre parole, ogni elemento dello stabilizzatore si ottiene moltiplicando insieme un sottoinsieme dei generatori dello stabilizzatore. Ogni elemento dello stabilizzatore può essere espresso in modo unico in questo modo, grazie alla condizione che $\{P_1,\ldots,P_r\}$ sia un insieme generatore minimale.

Successivamente, definiamo $\Pi_k$ come la proiezione sul sottospazio degli autovettori con autovalore $+1$ di $P_k$, per ogni $k\in\{1,\ldots,r\}.$ Queste proiezioni possono essere ottenute mediando le corrispondenti operazioni di Pauli con l'operazione identità come segue.

$$\Pi_k = \frac{\mathbb{I}^{\otimes n} + P_k}{2}$$

Lo spazio codice $\mathcal{C}$ è il sottospazio di tutti i vettori che sono fissati da tutti gli $r$ generatori dello stabilizzatore $P_1,\ldots,P_r$, o equivalentemente, da tutte le $r$ proiezioni $\Pi_1,\ldots,\Pi_r.$

Dato che i generatori dello stabilizzatore commutano tutti fra loro, le proiezioni $\Pi_1,\ldots,\Pi_r$ devono anch'esse commutare. Questo ci consente di usare un fatto dell'algebra lineare, ovvero che il prodotto di queste proiezioni è la proiezione sull'intersezione dei sottospazi corrispondenti alle singole proiezioni. In altre parole, il prodotto $\Pi_1\cdots\Pi_r$ è la proiezione sullo spazio codice $\mathcal{C}.$

Possiamo ora espandere il prodotto $\Pi_1\cdots\Pi_r$ usando le formule per queste proiezioni per ottenere la seguente espressione.

$$\Pi_1\cdots\Pi_r = \biggl(\frac{\mathbb{I}^{\otimes n} + P_1}{2}\biggr)\cdots\biggl(\frac{\mathbb{I}^{\otimes n} + P_r}{2}\biggr) = \frac{1}{2^r}\sum_{a_1,\ldots,a_r \in \{0,1\}} P_1^{a_1}\cdots P_r^{a_r}$$

In parole, la proiezione sullo spazio codice di un codice stabilizzatore è uguale, come matrice, alla media su tutti gli elementi dello stabilizzatore di quel codice.

Infine, possiamo calcolare la dimensione dello spazio codice usando il fatto che la dimensione di qualsiasi sottospazio è uguale alla traccia della proiezione su quel sottospazio. Quindi, la dimensione dello spazio codice $\mathcal{C}$ è data dalla seguente formula.

$$\operatorname{dim}(\mathcal{C}) = \operatorname{Tr}(\Pi_1\cdots\Pi_r) = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r})$$

Possiamo valutare questa espressione facendo uso di un paio di fatti di base.

• Abbiamo $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ e quindi

  $$\operatorname{Tr}(P_1^{0}\cdots P_r^{0}) = 2^n.$$

• Per $(a_1,\ldots,a_r) \neq (0,\ldots,0),$ il prodotto $P_1^{a_1}\cdots P_r^{a_r}$ deve essere $\pm 1$ moltiplicato per un'operazione di Pauli — ma non possiamo ottenere $\mathbb{I}^{\otimes n}$ perché ciò contraddirebbe la minimalità dell'insieme $\{P_1,\ldots,P_r\}$, e non possiamo ottenere $-\mathbb{I}^{\otimes n}$ perché la terza condizione sui generatori dello stabilizzatore lo vieta. Pertanto, poiché la traccia di ogni operazione di Pauli non identica è zero, otteniamo

  $$\operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) = 0.$$

La dimensione dello spazio codice è quindi $2^{n-r}$ come affermato:

$$\begin{aligned} \operatorname{dim}(\mathcal{C}) & = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) \\ & = \frac{1}{2^r} \operatorname{Tr}(P_1^{0}\cdots P_r^{0}) \\ & = 2^{n-r}. \end{aligned}$$

Come osservazione a margine, possiamo ora vedere che l'ipotesi che $-\mathbb{I}^{\otimes n}$ non sia contenuto nello stabilizzatore implica che lo spazio codice deve contenere almeno un vettore di stato quantistico. Questo perché, come abbiamo appena verificato, questa ipotesi implica che lo spazio codice ha dimensione $2^{n-r}$, che non può essere zero. L'implicazione inversa è banale: se $-\mathbb{I}^{\otimes n}$ è contenuto nello stabilizzatore, lo spazio codice non può contenere alcun vettore di stato quantistico, perché nessun vettore non nullo è fissato da questa operazione.

Operazioni di Clifford e codifiche

Successivamente, discuteremo brevemente come i qubit possono essere codificati usando i codici stabilizzatori, ma per farlo dobbiamo prima introdurre le operazioni di Clifford.

Operazioni di Clifford

Le operazioni di Clifford sono operazioni unitarie, su qualsiasi numero di qubit, che possono essere implementate da circuiti quantistici con un insieme ristretto di gate:

• gate di Hadamard
• gate $S$
• gate CNOT

Nota che i gate $T$ non sono inclusi, né i gate di Toffoli e i gate di Fredkin. Non solo questi gate non sono inclusi nell'elenco, ma in realtà non è possibile implementarli usando quelli elencati; non sono operazioni di Clifford. Le operazioni di Pauli, d'altra parte, sono operazioni di Clifford perché possono essere implementate con sequenze di gate di Hadamard e $S$.

Questo è un modo semplice per definire le operazioni di Clifford, ma non spiega perché siano definite così o cosa rende speciale questo particolare insieme di gate. Il vero motivo per cui le operazioni di Clifford sono definite in questo modo è che, a meno di fattori di fase globale, le operazioni di Clifford sono precisamente le operazioni unitarie che trasformano sempre le operazioni di Pauli in operazioni di Pauli per coniugazione. Per essere più precisi, un'operazione unitaria su $n$ qubit $U$ è equivalente a un'operazione di Clifford a meno di un fattore di fase se, e solo se, per ogni operazione di Pauli su $n$ qubit $P$, abbiamo

$$U P U^{\dagger} = \pm Q$$

per qualche operazione di Pauli su $n$ qubit $Q.$

(Nota che non è possibile avere $U P U^{\dagger} = \alpha Q$ per $\alpha\notin\{+1,-1\}$ quando $U$ è unitaria e $P$ e $Q$ sono operazioni di Pauli. Questo segue dal fatto che la matrice sul lato sinistro dell'equazione in questione è sia unitaria che hermitiana, e $+1$ e $-1$ sono le uniche scelte per $\alpha$ che consentono al lato destro di essere unitario e hermitiano.)

È semplice verificare la proprietà di coniugazione appena descritta quando $U$ è un gate di Hadamard, $S$ o CNOT. In particolare, questo è facile per i gate di Hadamard,

$$H X H^{\dagger} = Z, \qquad H Y H^{\dagger} = -Y, \qquad H Z H^{\dagger} = X,$$

e i gate $S$,

$$S X S^{\dagger} = Y, \qquad S Y S^{\dagger} = -X, \qquad S Z S^{\dagger} = Z.$$

Per i gate CNOT, ci sono 15 operazioni di Pauli non identiche su due qubit da verificare. Naturalmente, possono essere verificate individualmente — ma le relazioni tra i gate CNOT e i gate $X$ e $Z$ elencate (in forma di circuito) nella lezione precedente, insieme alle regole di moltiplicazione delle matrici di Pauli, offrono una scorciatoia alla stessa conclusione.

Una volta che sappiamo che questa proprietà di coniugazione vale per i gate di Hadamard, $S$ e CNOT, possiamo immediatamente concludere che vale per i circuiti composti da questi gate — che sono, in altre parole, tutte le operazioni di Clifford.

È più difficile dimostrare che la relazione funziona anche nell'altra direzione, ovvero che se una data operazione unitaria $U$ soddisfa la proprietà di coniugazione per le operazioni di Pauli, allora deve essere possibile implementarla (a meno di una fase globale) usando solo gate di Hadamard, $S$ e CNOT. Questo non sarà spiegato in questa lezione, ma è vero.

Le operazioni di Clifford non sono universali per il calcolo quantistico; a differenza degli insiemi universali di gate quantistici, non è possibile approssimare operazioni unitarie arbitrarie con qualsiasi livello di accuratezza desiderato usando operazioni di Clifford. In effetti, per un dato valore di $n$, esistono solo finitamente molte operazioni di Clifford su $n$ qubit (a meno di fattori di fase). Eseguire operazioni di Clifford su stati della base standard seguiti da misurazioni nella base standard non può nemmeno consentirci di eseguire calcoli al di fuori della portata degli algoritmi classici — perché possiamo simulare efficientemente calcoli di questa forma in modo classico. Questo fatto è noto come teorema di Gottesman-Knill.

Codificatori per codici stabilizzatori

Un codice stabilizzatore definisce uno spazio codice di una certa dimensione, e abbiamo la libertà di usare quello spazio codice come preferiamo — nulla ci obbliga a codificare i qubit in questo spazio codice in un modo specifico. È sempre possibile, tuttavia, usare un'operazione di Clifford come codificatore, se scegliamo di farlo. Per essere più precisi, per qualsiasi codice stabilizzatore che consente di codificare $m$ qubit in $n$ qubit, esiste un'operazione di Clifford su $n$ qubit $U$ tale che, per qualsiasi vettore di stato quantistico $\vert\phi\rangle$ su $m$ qubit, abbiamo che

$$\vert\psi\rangle = U \bigl(\vert 0^{n-m} \rangle \otimes \vert \phi\rangle\bigr)$$

è un vettore di stato quantistico nello spazio codice del nostro codice che possiamo interpretare come una codifica di $\vert\phi\rangle.$

Questo è positivo perché le operazioni di Clifford sono relativamente semplici, rispetto alle operazioni unitarie arbitrarie, e ci sono modi per ottimizzarne l'implementazione usando tecniche simili a quelle trovate nella dimostrazione del teorema di Gottesman-Knill. Di conseguenza, i circuiti per codificare stati con i codici stabilizzatori non devono mai essere troppo grandi. In particolare, è sempre possibile eseguire una codifica per un codice stabilizzatore a $n$ qubit usando un'operazione di Clifford che richiede $O(n^2/\log(n))$ gate. Questo perché ogni operazione di Clifford su $n$ qubit può essere implementata da un circuito di questa dimensione.

Ad esempio, ecco un codificatore per il codice di Steane a 7 qubit. È effettivamente un'operazione di Clifford, e si scopre che questo non richiede nemmeno gate $S$.

Rilevamento degli errori

Per un codice stabilizzatore a $n$ qubit descritto dai generatori del stabilizzatore $P_1,\ldots, P_r,$ il rilevamento degli errori funziona nel modo seguente.

Per rilevare gli errori, tutti i generatori del stabilizzatore vengono misurati come osservabili. Ci sono $r$ generatori del stabilizzatore, e quindi $r$ risultati di misura, ciascuno pari a $+1$ o $-1$ (oppure un valore binario se si sceglie di associare $0$ a $+1$ e $1$ a $-1,$ rispettivamente). I $r$ risultati vengono interpretati collettivamente, come vettore o stringa, come una sindrome. La sindrome $(+1,\ldots,+1)$ indica che nessun errore è stato rilevato, mentre almeno un $-1$ in qualsiasi posizione della sindrome indica che un errore è stato rilevato.

Supponi, in particolare, che $E$ sia un'operazione di Pauli a $n$ qubit, che rappresenta un ipotetico errore. (Consideriamo solo le operazioni di Pauli come errori, tra l'altro, perché la discretizzazione degli errori funziona allo stesso modo per i codici stabilizzatori arbitrari come per il codice di Shor a 9 qubit.) Ci sono tre casi che determinano se $E$ viene rilevato come errore o meno.

Casi di rilevamento degli errori

1. L'operazione $E$ è proporzionale a un elemento del stabilizzatore.

   $$E = \pm Q \; \text{per qualche}\; Q \in \langle P_1,\ldots,P_r\rangle$$

   In questo caso, $E$ deve commutare con ogni generatore del stabilizzatore, quindi si ottiene la sindrome $(+1,\ldots,+1).$ Ciò significa che $E$ non viene rilevato come errore.

2. L'operazione $E$ non è proporzionale a un elemento del stabilizzatore, ma commuta comunque con ogni generatore del stabilizzatore.

   $$E\neq \pm Q\; \text{per} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{ma}\; E P_k = P_k E \;\text{per ogni}\; k\in\{1,\ldots,r\}$$

   Questo è un errore che modifica i vettori nello spazio codice in modo non banale. Tuttavia, poiché $E$ commuta con ogni generatore del stabilizzatore, la sindrome è $(+1,\ldots,+1),$ quindi $E$ non viene rilevato dal codice.

3. L'operazione $E$ anti-commuta con almeno uno dei generatori del stabilizzatore.

   $$P_k E = -E P_k \; \text{per almeno un} \; k\in\{1,\ldots,r\}$$

   La sindrome è diversa da $(+1,\ldots,+1),$ quindi l'errore $E$ viene rilevato dal codice.

Nel primo caso, l'errore $E$ non è un problema perché questa operazione non fa nulla ai vettori nello spazio codice, se non iniettare eventualmente una fase globale irrilevante: $E \ket{\psi} = \pm\ket{\psi}$ per ogni stato codificato $\ket{\psi}.$ In sostanza, questo non è un vero errore — qualunque azione non banale $E$ possa avere si manifesta al di fuori dello spazio codice — quindi è corretto che $E$ non venga rilevato come errore, perché non c'è nulla da fare al riguardo.

Il secondo caso, intuitivamente parlando, è il caso problematico. È l'anti-commutazione di un errore con un generatore del stabilizzatore che causa la comparsa di un $-1$ in qualche punto della sindrome, segnalando un errore, ma ciò non accade in questo caso. Abbiamo quindi un errore $E$ che modifica i vettori nello spazio codice in modo non banale, ma non viene rilevato dal codice. Ad esempio, per il codice a ripetizione a 3 bit, l'operazione $E = X\otimes X\otimes X$ rientra in questa categoria.

Il fatto che un tale errore $E$ debba necessariamente modificare alcuni vettori nello spazio codice in modo non banale può essere argomentato come segue. Dall'ipotesi che $E$ commuti con $P_1,\ldots,P_r$ ma non sia proporzionale a un elemento del stabilizzatore, si può concludere che si otterrebbe un nuovo codice stabilizzatore valido includendo $E$ come generatore del stabilizzatore insieme a $P_1,\ldots,P_r.$ Lo spazio codice di questo nuovo codice, tuttavia, ha solo metà della dimensione dello spazio codice originale, il che permette di concludere che l'azione di $E$ sullo spazio codice originale non può essere proporzionale all'operazione identità.

Per l'ultimo dei tre casi, ovvero quando l'errore $E$ anti-commuta con almeno un generatore del stabilizzatore, la sindrome ha almeno un $-1$ in qualche posizione, il che indica che qualcosa non va. Come già discusso, la sindrome non identificherà univocamente $E$ in generale, quindi è ancora necessario scegliere un'operazione di correzione per ciascuna sindrome, che potrebbe o meno correggere l'errore $E.$ Discuteremo questo passaggio a breve, nell'ultima parte della lezione.

Distanza di un codice stabilizzatore

Come punto terminologico, quando ci riferiamo alla distanza di un codice stabilizzatore, intendiamo il peso minimo di un'operazione di Pauli $E$ che rientra nella seconda categoria sopra — ovvero che modifica lo spazio codice in modo non banale, ma il codice non lo rileva. Quando si dice che un codice stabilizzatore è un codice stabilizzatore $[[n,m,d]],$ usando doppie parentesi quadre, ciò significa quanto segue:

1. Le codifiche hanno lunghezza $n$ qubit,
2. il codice permette di codificare $m$ qubit, e
3. la distanza del codice è $d.$

Come esempio, consideriamo il codice di Steane a 7 qubit. Ecco i generatori del stabilizzatore per questo codice:

$$\begin{array}{ccccccc} Z & Z & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] Z & Z & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} \\[1mm] Z & \mathbb{I} & Z & \mathbb{I} & Z & \mathbb{I} & Z \\[1mm] X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] X & X & \mathbb{I} & \mathbb{I} & X & X & \mathbb{I} \\[1mm] X & \mathbb{I} & X & \mathbb{I} & X & \mathbb{I} & X \end{array}$$

Questo codice ha distanza 3, e possiamo argomentarlo come segue.

Considera prima qualsiasi operazione di Pauli $E$ di peso al massimo 2, e supponi che questa operazione commuti con tutti e sei i generatori del stabilizzatore. Concluderemo che $E$ deve essere l'operazione identità, che (come sempre) è un elemento del stabilizzatore. Questo mostrerà che la distanza del codice è strettamente maggiore di 2. Supponi, in particolare, che $E$ abbia la forma

$$E = P \otimes Q \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}$$

dove $P$ e $Q$ sono possibilmente matrici di Pauli non identità. Questo è solo un caso, ed è necessario ripetere l'argomento che segue per tutte le altre possibili posizioni delle matrici di Pauli non identità tra i fattori tensoriali di $E,$ ma l'argomento è essenzialmente lo stesso per tutte le posizioni possibili.

L'operazione $E$ commuta con tutti e sei i generatori del stabilizzatore, quindi commuta anche con questi due in particolare:

$$\begin{gathered} Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z\\[1mm] X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \end{gathered}$$

Il fattore tensoriale $Q$ nel nostro errore $E$ si allinea con la matrice identità in entrambi questi generatori del stabilizzatore (ecco perché sono stati selezionati). Dato che abbiamo matrici identità nelle 5 posizioni più a destra di $E,$ concludiamo che $P$ deve commutare con $X$ e $Z,$ altrimenti $E$ anti-commuterebbe con uno dei due generatori. Tuttavia, l'unica matrice di Pauli che commuta sia con $X$ che con $Z$ è la matrice identità, quindi $P = \mathbb{I}.$

Ora che sappiamo questo, possiamo scegliere altri due generatori del stabilizzatore che hanno un $X$ e uno $Z$ nella seconda posizione da sinistra, e traiamo una conclusione simile: $Q = \mathbb{I}.$ È quindi il caso che $E$ sia l'operazione identità.

Quindi, non esiste alcun modo in cui un errore di peso al massimo 2 possa sfuggire al rilevamento di questo codice, a meno che l'errore non sia l'operazione identità (che è nel stabilizzatore e quindi non è un vero errore). D'altra parte, esistono operazioni di Pauli di peso 3 che commutano con tutti e sei questi generatori del stabilizzatore, ma non sono proporzionali a elementi del stabilizzatore, come $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ e $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z.$ Ciò stabilisce che questo codice ha distanza 3, come affermato.

Correzione degli errori

L'ultimo argomento di questa lezione è la correzione degli errori per i codici stabilizzatori. Come di consueto, supponiamo di avere un codice stabilizzatore specificato da generatori del stabilizzatore a $n$ qubit $P_1, \ldots, P_r.$

Le operazioni di Pauli a $n$ qubit, come errori che potrebbero influenzare gli stati codificati con questo codice, sono suddivise in collezioni di uguale dimensione in base alla sindrome che producono. Ci sono $2^r$ sindromi distinte e $4^n$ operazioni di Pauli, il che significa che ci sono $4^n/2^r$ operazioni di Pauli che causano ciascuna sindrome. Uno qualsiasi di questi errori potrebbe essere responsabile della sindrome corrispondente.

Tuttavia, tra le $4^n/2^r$ operazioni di Pauli che causano ciascuna sindrome, alcune devono essere considerate equivalenti. In particolare, se il prodotto di due operazioni di Pauli è proporzionale a un elemento del stabilizzatore, allora le due operazioni sono di fatto equivalenti come errori.

Un altro modo di dirlo è che se applichiamo un'operazione di correzione $C$ per tentare di correggere un errore $E,$ allora la correzione ha successo fintanto che la composizione $CE$ è proporzionale a un elemento del stabilizzatore. Dato che ci sono $2^r$ elementi nel stabilizzatore, ne consegue che ogni operazione di correzione $C$ corregge $2^r$ diversi errori di Pauli. Ciò lascia $4^{n-r}$ classi inequivalenti di operazioni di Pauli, considerate come errori, che sono compatibili con ciascuna possibile sindrome.

Ciò significa che, a meno che $n=r$ (nel qual caso abbiamo uno spazio codice banale e unidimensionale), non è possibile correggere ogni errore rilevato da un codice stabilizzatore. Quello che dobbiamo fare invece è scegliere una sola operazione di correzione per ogni sindrome, nella speranza di correggere solo una classe di errori equivalenti che causano quella sindrome.

Una strategia naturale per scegliere quale operazione di correzione eseguire per ciascuna sindrome è scegliere l'operazione di Pauli di peso minimo che, come errore, causa quella sindrome. In effetti potrebbero esserci più operazioni a pari merito come errore di peso minimo compatibile con una data sindrome, nel qual caso se ne può selezionare una qualsiasi. L'idea è che le operazioni di Pauli di peso inferiore rappresentano spiegazioni più probabili per qualunque sindrome sia stata misurata. Questo potrebbe non essere vero per alcuni modelli di rumore, e una strategia alternativa consiste nel calcolare l'errore più probabile che causa la sindrome data, basandosi sul modello di rumore scelto. Per questa lezione, tuttavia, manteniamo le cose semplici e consideriamo solo le correzioni di peso minimo.

Per un codice stabilizzatore di distanza $d,$ questa strategia di scegliere l'operazione di correzione come un'operazione di Pauli di peso minimo compatibile con la sindrome misurata consente sempre di correggere errori di peso strettamente inferiore alla metà di $d,$ ovvero di peso al massimo $(d-1)/2.$ Ciò mostra, ad esempio, che il codice di Steane a 7 qubit può correggere qualsiasi errore di Pauli di peso uno, e per la discretizzazione degli errori, ciò significa che il codice di Steane può correggere un errore arbitrario su un qubit.

Per capire come funziona, considera il diagramma sottostante. Il cerchio a sinistra rappresenta tutte le operazioni di Pauli che producono la sindrome $(+1,\ldots,+1),$ che è la sindrome che suggerisce che non si sono verificati errori e non c'è nulla che non va. Tra queste operazioni troviamo elementi del stabilizzatore (o operazioni proporzionali a elementi del stabilizzatore, per essere più precisi) e anche errori non banali che modificano lo spazio codice in qualche modo ma non vengono rilevati dal codice. Per definizione di distanza, ogni operazione di Pauli in questa categoria deve avere peso almeno $d,$ perché $d$ è definita come il peso minimo di queste operazioni.

Il cerchio a destra rappresenta le operazioni di Pauli che producono una sindrome diversa $s\neq(+1,\ldots,+1),$ incluso un errore $E$ di peso strettamente inferiore a $d/2$ che considereremo.

L'operazione di correzione $C$ scelta per la sindrome $s$ è l'operazione di Pauli di peso minimo nella collezione rappresentata dal cerchio a destra nel diagramma (o una qualsiasi di esse in caso di parità). Quindi, potrebbe essere che $C = E,$ ma non necessariamente. Quello che possiamo affermare con certezza, tuttavia, è che $C$ non può avere peso maggiore del peso di $E,$ perché $C$ ha peso minimo tra le operazioni di questa collezione — e quindi $C$ ha peso strettamente inferiore a $d/2.$

Ora considera cosa accade quando l'operazione di correzione $C$ viene applicata allo stato ottenuto dopo che si è verificato l'errore $E.$ Supponendo che la codifica originale fosse $\vert\psi\rangle,$ ci ritroviamo con $CE\vert\psi\rangle.$ Il nostro obiettivo sarà mostrare che $CE$ è proporzionale a un elemento del stabilizzatore, il che implica che la correzione ha avuto successo e (a meno di una fase globale) ci ritroviamo con lo stato codificato originale $\vert\psi\rangle.$

Innanzitutto, poiché $E$ e $C$ causano la stessa sindrome, la composizione $CE$ deve commutare con ogni generatore del stabilizzatore. In particolare, se $P_k$ è uno qualsiasi dei generatori del stabilizzatore, allora deve valere

$$P_k E = \alpha E P_k \quad\text{e}\quad P_k C = \alpha C P_k$$

per lo stesso valore di $\alpha\in\{+1,-1\},$ poiché questo è il $k$-esimo valore nella sindrome $s$ che sia $C$ che $E$ generano. Quindi si ha

$$P_k (CE) = \alpha C P_k E = \alpha^2 (CE) P_k = (CE) P_k,$$

quindi $P_k$ commuta con $CE.$ Abbiamo quindi dimostrato che $CE$ appartiene al cerchio a sinistra nel diagramma, perché genera la sindrome $(+1,\ldots,+1).$

In secondo luogo, la composizione $CE$ deve avere peso al massimo pari alla somma dei pesi di $C$ e di $E$ — il che segue da una breve riflessione sui prodotti di operazioni di Pauli — e quindi il peso di $CE$ è strettamente inferiore a $d.$ Ciò implica che $CE$ è proporzionale a un elemento del stabilizzatore del nostro codice, che è quello che volevamo dimostrare. Scegliendo le operazioni di correzione come rappresentanti di peso minimo dell'insieme di errori che generano ciascuna sindrome, è quindi garantito che vengano corretti tutti gli errori di Pauli di peso inferiore alla metà della distanza del codice.

Esiste però un problema. Per i codici stabilizzatori in generale, calcolare l'operazione di Pauli di peso minimo che causa una data sindrome è un problema computazionalmente difficile. (Questo vale anche per i codici classici, che in questo contesto possiamo pensare come codici stabilizzatori in cui appaiono solo matrici $\mathbb{I}$ e $Z$ come fattori tensoriali all'interno dei generatori del stabilizzatore.) Quindi, a differenza del passaggio di codifica, le operazioni di Clifford non ci verranno in soccorso questa volta.

La soluzione è scegliere codici specifici per i quali le buone correzioni possono essere calcolate in modo efficiente, e per questo non esiste una ricetta semplice. In parole povere, progettare codici stabilizzatori per i quali le operazioni di correzione efficaci possano essere calcolate in modo efficiente è parte dell'arte del design dei codici quantistici.