Codici CSS

Codici lineari classici

I codici classici di correzione degli errori furono studiati per la prima volta negli anni '40, e oggi ne esistono molti tipi diversi. I codici più comunemente studiati e utilizzati appartengono a una categoria nota come codici lineari. Vedremo tra poco esattamente cosa significa la parola "lineare" in questo contesto, ma un modo molto semplice per descrivere i codici lineari è che si tratta di codici stabilizzatori che sono, per l'appunto, classici. I codici CSS sono essenzialmente coppie di codici lineari classici che vengono combinati insieme per creare un codice quantistico di correzione degli errori. Quindi, ai fini della discussione che segue, è necessario capire alcune nozioni di base sui codici lineari classici.

Sia $\Sigma$ l'alfabeto binario per l'intera discussione. Quando parliamo di codice lineare classico, intendiamo un insieme non vuoto $\mathcal{C}\subseteq\Sigma^n$ di stringhe binarie di lunghezza $n,$ per qualche intero positivo $n,$ che deve soddisfare una sola proprietà fondamentale: se $u$ e $v$ sono stringhe binarie in $\mathcal{C},$ allora la stringa $u\oplus v$ è anch'essa in $\mathcal{C}.$ Qui, $u\oplus v$ indica l'OR esclusivo bit a bit di $u$ e $v,$ come abbiamo incontrato più volte nel corso "Fondamenti degli algoritmi quantistici".

In sostanza, quando definiamo lineare un codice classico di correzione degli errori, stiamo considerando le stringhe binarie di lunghezza $n$ come vettori $n$-dimensionali con componenti in $\{0, 1\},$ e richiediamo che il codice stesso formi un sottospazio lineare. Invece della consueta addizione vettoriale sui numeri reali o complessi, utilizziamo però l'addizione modulo $2,$ che corrisponde semplicemente all'OR esclusivo. Ovvero, se abbiamo due parole di codice $u$ e $v,$ cioè due stringhe binarie in $\mathcal{C},$ allora $u + v$ modulo 2, ossia $u\oplus v,$ deve essere anch'essa una parola di codice in $\mathcal{C}.$ Nota in particolare che questa implicazione deve valere anche nel caso $u = v.$ Questo implica che $\mathcal{C}$ deve contenere la stringa tutta-zero $0^n,$ poiché l'OR esclusivo bit a bit di qualsiasi stringa con se stessa è la stringa tutta-zero.

Esempio: il codice a ripetizione a 3 bit

Il codice a ripetizione a 3 bit è un esempio di codice lineare classico. In particolare, $\mathcal{C} = \{000,111\},$ quindi, rispetto alla condizione di linearità, ci sono solo due possibili scelte per $u$ e due possibili scelte per $v.$ È banale verificare le quattro coppie possibili per constatare che l'OR esclusivo bit a bit produce sempre una parola di codice:

$$000 \oplus 000 = 000, \quad 000 \oplus 111 = 111, \quad 111 \oplus 000 = 111, \quad 111 \oplus 111 = 000.$$

Esempio: il codice di Hamming $[7,4,3]$

Ecco un altro esempio di codice lineare classico, chiamato codice di Hamming $[7,4,3].$ È stato uno dei primissimi codici classici di correzione degli errori mai scoperti, e consiste in queste 16 stringhe binarie di lunghezza 7. (A volte il codice di Hamming $[7,4,3]$ è inteso come il codice con queste stringhe invertite, ma qui lo prenderemo come il codice contenente le stringhe mostrate.)

$$\begin{array}{cccc} 0000000 & 1100001 & 1010010 & 0110011\\[1mm] 0110100 & 1010101 & 1100110 & 0000111\\[1mm] 1111000 & 0011001 & 0101010 & 1001011\\[1mm] 1001100 & 0101101 & 0011110 & 1111111 \end{array}$$

C'è una logica molto semplice dietro la scelta di queste stringhe, ma è secondaria rispetto all'argomento e non verrà spiegata qui. Per ora è sufficiente osservare che si tratta di un codice lineare classico: l'XOR di due qualsiasi di queste stringhe darà sempre un'altra stringa nel codice.

La notazione $[7,4,3]$ (tra parentesi quadre singole) ha un significato analogo alla notazione con doppie parentesi quadre per i codici stabilizzatori menzionata nella lezione precedente, ma qui si applica ai codici lineari classici. In particolare, le parole di codice hanno $7$ bit, possiamo codificare $4$ bit con questo codice (perché ci sono $16 = 2^4$ parole di codice), e si tratta di un codice a distanza $3,$ il che significa che due qualsiasi parole di codice distinte devono differire in almeno $3$ posizioni — quindi occorre invertire almeno $3$ bit per trasformare una parola di codice in un'altra. Il fatto che sia un codice a distanza $3$ implica che può correggere fino a un errore di inversione di bit.

Descrivere i codici lineari classici

Gli esempi appena citati sono esempi molto semplici di codici lineari classici, ma anche il codice di Hamming $[7,4,3]$ appare alquanto misterioso quando le parole di codice vengono semplicemente elencate. Esistono modi migliori ed efficaci per descrivere i codici lineari classici, tra cui i seguenti due.

1. Generatori. Un modo per descrivere un codice lineare classico è fornire un elenco minimale di parole di codice che generano il codice, nel senso che prendendo tutti i possibili sottoinsiemi di queste parole di codice e applicando l'XOR tra di esse si ottiene l'intero codice.

   In modo più dettagliato, le stringhe $u_1,\ldots,u_m\in\Sigma^n$ generano il codice lineare classico $\mathcal{C}$ se

   $$\mathcal{C} = \bigl\{\alpha_1 u_1 \oplus \cdots \oplus \alpha_m u_m\,:\,\alpha_1,\ldots,\alpha_m\in\{0,1\}\bigr\},$$

   con l'intesa che $\alpha u = u$ quando $\alpha = 1$ e $\alpha u = 0^n$ quando $\alpha = 0,$ e diciamo che questo elenco è minimale se rimuovendo una delle stringhe si genera un codice più piccolo. Un modo naturale di interpretare tale descrizione è che la collezione $\{u_1,\ldots,u_m\}$ forma una base per $\mathcal{C}$ come sottospazio, considerando le stringhe come vettori con componenti binarie, tenendo presente che stiamo lavorando in uno spazio vettoriale dove l'aritmetica è fatta modulo $2.$

2. Controlli di parità. Un altro modo naturale per descrivere un codice lineare classico è mediante i controlli di parità — ovvero un elenco minimale di stringhe binarie tali che le stringhe nel codice siano esattamente quelle il cui prodotto scalare binario con ognuna di queste stringhe di controllo di parità è zero. (Come l'OR esclusivo bit a bit, il prodotto scalare binario è apparso più volte in "Fondamenti degli algoritmi quantistici".)

   Cioè, le stringhe $v_1,\ldots,v_r\in\Sigma^n$ sono stringhe di controllo di parità per il codice lineare classico $\mathcal{C}$ se

   $$\mathcal{C} = \bigl\{ u\in \Sigma^n\,:\, u\cdot v_1 = \cdots = u \cdot v_r = 0 \bigr\},$$

   e questo insieme di stringhe è minimale se rimuovendone una si ottiene un codice più grande. Queste vengono chiamate stringhe di controllo di parità perché $u$ ha prodotto scalare binario uguale a zero con $v$ se e solo se i bit di $u$ nelle posizioni in cui $v$ ha un $1$ hanno parità pari. Quindi, per determinare se una stringa $u$ è nel codice $\mathcal{C},$ è sufficiente verificare la parità di certi sottoinsiemi dei bit di $u.$

   Una cosa importante da notare è che il prodotto scalare binario non è un prodotto interno in senso formale. In particolare, quando due stringhe hanno prodotto scalare binario uguale a zero, non significa che siano ortogonali nel senso in cui siamo soliti intendere l'ortogonalità. Per esempio, il prodotto scalare binario della stringa $11$ con se stessa è zero — quindi è possibile che una stringa di controllo di parità per un codice lineare classico sia essa stessa nel codice.

I codici lineari classici sull'alfabeto binario contengono sempre un numero di stringhe che è una potenza di $2$ — e per un singolo codice lineare classico descritto nei due modi appena descritti, varrà sempre che $n = m + r.$ In particolare, se abbiamo un insieme minimale di $m$ generatori, allora il codice codifica $m$ bit e avremo necessariamente $2^m$ parole di codice; e se abbiamo un insieme minimale di $r$ stringhe di controllo di parità, avremo $2^{n-r}$ parole di codice. Quindi, ogni generatore raddoppia la dimensione dello spazio codice mentre ogni stringa di controllo di parità ne dimezza la dimensione.

Per esempio, il codice a ripetizione a 3 bit è un codice lineare, quindi può essere descritto in entrambi questi modi. In particolare, c'è solo una scelta possibile per un generatore che funziona: $111.$ In alternativa possiamo descrivere il codice con due stringhe di controllo di parità, come $110$ e $011$ — che dovrebbero sembrare familiari dalle discussioni precedenti su questo codice — oppure potremmo scegliere le stringhe di controllo di parità $110$ e $101,$ o $101$ e $011.$ (I generatori e le stringhe di controllo di parità non sono in generale unici per un dato codice lineare classico.)

Per un secondo esempio, consideriamo il codice di Hamming $[7,4,3].$ Ecco una scelta di elenco di generatori che funziona.

$$\begin{array}{c} 1111000\\[1mm] 0110100\\[1mm] 1010010\\[1mm] 1100001 \end{array}$$

Ed ecco una scelta di elenco di controlli di parità per questo codice.

$$\begin{array}{c} 1111000\\[1mm] 1100110\\[1mm] 1010101 \end{array}$$

Qui, tra l'altro, notiamo che tutte le nostre stringhe di controllo di parità sono esse stesse nel codice.

Un'ultima osservazione sui codici lineari classici, che li collega al formalismo degli stabilizzatori, è che le stringhe di controllo di parità sono equivalenti ai generatori stabilizzatori composti solo da matrici di Pauli $Z$ e dall'identità. Per esempio, le stringhe di controllo di parità $110$ e $011$ per il codice a ripetizione a 3 bit corrispondono esattamente ai generatori stabilizzatori $Z\otimes Z\otimes \mathbb{I}$ e $\mathbb{I}\otimes Z\otimes Z,$ il che è coerente con le discussioni sulle osservabili di Pauli della lezione precedente.

Definizione dei codici CSS

I codici CSS sono codici stabilizzatori ottenuti combinando insieme certe coppie di codici lineari classici. Questo non funziona per due codici lineari classici arbitrari — i due codici devono avere una certa relazione. Tuttavia, questa costruzione apre molte possibilità per i codici quantistici di correzione degli errori, basandosi in parte su oltre 75 anni di teoria classica dei codici.

Nel formalismo degli stabilizzatori, i generatori stabilizzatori contenenti solo matrici di Pauli $Z$ e l'identità sono equivalenti ai controlli di parità, come abbiamo appena osservato per il codice a ripetizione a 3 bit. Per un altro esempio, considera le seguenti stringhe di controllo di parità per il codice di Hamming $[7,4,3].$

$$\begin{array}{c} 1111000\\[1mm] 1100110\\[1mm] 1010101 \end{array}$$

Queste stringhe di controllo di parità corrispondono ai seguenti generatori stabilizzatori (scritti senza simboli di prodotto tensoriale), che otteniamo sostituendo ogni $1$ con $Z$ e ogni $0$ con $\mathbb{I}.$ Questi sono tre dei sei generatori stabilizzatori per il codice di Steane a 7 qubit.

$$\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 \end{array}$$

Chiamiamo generatori $Z$ stabilizzatori i generatori stabilizzatori di questo tipo, ovvero quelli che contengono solo fattori tensoriali di Pauli $Z$ e identità — quindi le matrici di Pauli $X$ e $Y$ non compaiono mai nei generatori $Z$ stabilizzatori.

Possiamo anche considerare i generatori stabilizzatori in cui compaiono solo matrici di Pauli $X$ e l'identità come fattori tensoriali. Generatori stabilizzatori di questo tipo possono essere visti come analoghi ai generatori $Z$ stabilizzatori, con la differenza che descrivono controlli di parità nella base $\{\vert+\rangle,\vert-\rangle\}$ anziché nella base standard. I generatori stabilizzatori di questa forma sono chiamati generatori $X$ stabilizzatori — stavolta non sono ammesse matrici di Pauli $Y$ o $Z.$

Per esempio, considera i restanti tre generatori stabilizzatori del codice di Steane a 7 qubit.

$$\begin{array}{ccccccc} 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}$$

Seguono esattamente lo stesso schema del codice di Hamming $[7,4,3]$ dei generatori $Z$ stabilizzatori, con la differenza che questa volta sostituiamo $X$ al posto di $1$ anziché $Z.$ Ciò che otteniamo solo da questi tre generatori stabilizzatori è un codice che include i 16 stati mostrati qui, che si ottengono applicando operazioni di Hadamard agli stati della base computazionale corrispondenti alle stringhe nel codice di Hamming $[7,4,3].$ (Naturalmente, lo spazio codice per questo codice include anche le combinazioni lineari di questi stati.)

$$\begin{array}{cccc} \vert {+++++++} \rangle \quad & \vert {--++++-} \rangle \quad & \vert {-+-++-+} \rangle \quad & \vert {+--++--} \rangle \\ \vert {+--+-++} \rangle \quad & \vert {-+-+-+-} \rangle \quad & \vert {--++--+} \rangle \quad & \vert {++++---} \rangle \\ \vert {----+++} \rangle \quad & \vert {++--++-} \rangle \quad & \vert {+-+-+-+} \rangle \quad & \vert {-++-+--} \rangle \\ \vert {-++--++} \rangle \quad & \vert {+-+--+-} \rangle \quad & \vert {++----+} \rangle \quad & \vert {-------} \rangle \end{array}$$

Possiamo ora definire i codici CSS in termini molto semplici.

Definizione

Un codice CSS è un codice stabilizzatore che può essere espresso usando solo generatori $X$ e $Z$ stabilizzatori.

Ovvero, i codici CSS sono codici stabilizzatori per i quali disponiamo di generatori stabilizzatori in cui non compaiono matrici di Pauli $Y,$ e in cui $X$ e $Z$ non compaiono mai nello stesso generatore stabilizzatore.

Per essere precisi, per questa definizione un codice CSS è un codice per cui è possibile scegliere solo generatori $X$ e $Z$ stabilizzatori — ma dobbiamo tenere presente che c'è libertà nella scelta dei generatori stabilizzatori per i codici stabilizzatori. In generale, ci saranno quindi scelte diverse per i generatori stabilizzatori di un codice CSS che non sono generatori $X$ o $Z$ stabilizzatori (oltre ad almeno una scelta per cui lo sono).

Ecco un esempio molto semplice di codice CSS che include sia un generatore $Z$ stabilizzatore sia un generatore $X$ stabilizzatore:

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

È chiaro che questo è un codice CSS, perché il primo generatore stabilizzatore è un generatore $Z$ stabilizzatore e il secondo è un generatore $X$ stabilizzatore. Naturalmente, un codice CSS deve anche essere un codice stabilizzatore valido — il che significa che i generatori stabilizzatori devono commutare, formare un insieme generatore minimale e fissare almeno un vettore di stato quantistico. Questi requisiti risultano facili da verificare per questo codice. Come abbiamo notato nella lezione precedente, lo spazio codice per questo codice è lo spazio unidimensionale generato dallo stato di Bell $\vert\phi^+\rangle.$ Il fatto che entrambi i generatori stabilizzatori fissino questo stato è evidente considerando le seguenti due espressioni di un e-bit, insieme a un'interpretazione di questi generatori stabilizzatori come controlli di parità nelle basi $\{\vert 0\rangle, \vert 1\rangle\}$ e $\{\vert +\rangle, \vert -\rangle\}.$

$$\vert\phi^+\rangle = \frac{\vert 0\rangle\vert 0\rangle + \vert 1\rangle\vert 1\rangle}{\sqrt{2}} = \frac{\vert +\rangle\vert +\rangle + \vert -\rangle\vert -\rangle}{\sqrt{2}}$$

Il codice di Steane a 7 qubit è un altro esempio di codice CSS.

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

Qui abbiamo tre generatori $Z$ stabilizzatori e tre generatori $X$ stabilizzatori, e abbiamo già verificato che si tratta di un codice stabilizzatore valido.

E il codice di Shor a 9 qubit è un altro esempio.

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

Questa volta abbiamo sei generatori $Z$ stabilizzatori e solo due generatori $X$ stabilizzatori. Va bene così: non è necessario che ci sia un equilibrio o una simmetria tra i due tipi di generatori (anche se spesso c'è).

Ancora una volta, è fondamentale che i codici CSS siano codici stabilizzatori validi, e in particolare ogni generatore $Z$ stabilizzatore deve commutare con ogni generatore $X$ stabilizzatore. Quindi, non ogni collezione di generatori $X$ e $Z$ stabilizzatori definisce un codice CSS valido.

Rilevamento e correzione degli errori

Per quanto riguarda il rilevamento e la correzione degli errori, i codici CSS in generale hanno una caratteristica simile a quella del codice di Shor a 9 qubit: gli errori $X$ e $Z$ possono essere rilevati e corretti in modo completamente indipendente; i generatori stabilizzatori $Z$ descrivono un codice che protegge dai bit flip, mentre i generatori stabilizzatori $X$ descrivono un codice che protegge in modo indipendente dai phase flip. Questo funziona perché i generatori stabilizzatori $Z$ commutano necessariamente con gli errori $Z$, nonché con le operazioni $Z$ applicate come correzioni — e sono quindi completamente insensibili a entrambi; lo stesso vale per i generatori stabilizzatori $X$, i loro errori e le relative correzioni.

Come esempio, consideriamo il codice di Steane a 7 qubit.

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

L'idea di base per questo codice è ora evidente: si tratta di un codice $[7,4,3]$-Hamming per gli errori di bit flip e di un codice $[7,4,3]$-Hamming per gli errori di phase flip. Il fatto che i generatori stabilizzatori $X$ e $Z$ commutino è forse una fortunata coincidenza, perché se non lo facessero il codice non sarebbe un codice stabilizzatore valido. Esistono tuttavia molti esempi noti di codici lineari classici che producono un codice stabilizzatore valido se usati in modo analogo.

In generale, supponiamo di avere un codice CSS per cui i generatori stabilizzatori $Z$ consentono la correzione di fino a $j$ errori di bit flip, e i generatori stabilizzatori $X$ consentono la correzione di fino a $k$ errori di phase flip. Ad esempio, $j = 1$ e $k = 1$ per il codice di Steane, dato che il codice $[7,4,3]$-Hamming può correggere un singolo bit flip. Ne consegue, per la discretizzazione degli errori, che questo codice CSS può correggere qualsiasi errore su un numero di qubit pari al minimo tra $j$ e $k$. Questo avviene perché, quando viene misurata la sindrome, un errore arbitrario su tale numero di qubit collassa probabilisticamente in una qualche combinazione di errori $X$, errori $Z$ o entrambi — dopodiché gli errori $X$ e gli errori $Z$ vengono rilevati e corretti in modo indipendente.

In sintesi, a condizione di avere due codici lineari classici (o due copie dello stesso codice lineare classico) compatibili — nel senso che definiscono generatori stabilizzatori $X$ e $Z$ che commutano — il codice CSS ottenuto combinandoli eredita le proprietà di correzione degli errori di quei due codici, nel senso appena descritto.

Occorre però notare che c'è un prezzo da pagare: non è possibile codificare tanti qubit quanti bit si potrebbero codificare con i due codici classici. Questo perché il numero totale di generatori stabilizzatori per il codice CSS è la somma del numero di controlli di parità dei due codici lineari classici, e ogni generatore stabilizzatore dimezza la dimensione dello spazio codice. Ad esempio, il codice $[7,4,3]$-Hamming permette di codificare quattro bit classici, dato che ha solo tre stringhe di controllo di parità, mentre il codice di Steane a 7 qubit codifica un solo qubit, perché ha sei generatori stabilizzatori.

Spazi codice dei codici CSS

L'ultima cosa che faremo in questa trattazione dei codici CSS è considerare gli spazi codice di questi codici. Questo ci darà l'opportunità di esaminare più nel dettaglio la relazione che deve sussistere tra due codici lineari classici affinché siano compatibili, nel senso che possono essere combinati insieme per formare un codice CSS.

Consideriamo un codice CSS qualsiasi su $n$ qubit, e siano $z_1, \ldots, z_s \in \Sigma^n$ le stringhe di controllo di parità a $n$ bit che corrispondono ai generatori stabilizzatori $Z$ di questo codice. Ciò significa che il codice lineare classico descritto dai soli generatori stabilizzatori $Z$, che chiameremo $\mathcal{C}_Z,$ ha la seguente forma.

$$\mathcal{C}_Z = \bigl\{ u \in \Sigma^n \,:\, u \cdot z_1 = \cdots = u \cdot z_s = 0 \bigr\}$$

In altre parole, il codice lineare classico $\mathcal{C}_Z$ contiene tutte le stringhe il cui prodotto scalare binario con ciascuna delle stringhe di controllo di parità $z_1, \ldots, z_s$ è zero.

Analogamente, siano $x_1,\ldots,x_t\in\Sigma^n$ le stringhe di controllo di parità a $n$ bit corrispondenti ai generatori stabilizzatori $X$ del nostro codice. Il codice lineare classico corrispondente ai generatori stabilizzatori $X$ ha quindi questa forma.

$$\mathcal{C}_X = \bigl\{ u \in \Sigma^n \,:\, u \cdot x_1 = \cdots = u \cdot x_t = 0 \bigr\}$$

I soli generatori stabilizzatori $X$ descrivono quindi un codice simile a questo, ma nella base $\{\vert {+}\rangle,\vert {-}\rangle\}$ invece che nella base standard.

Introduciamo ora due nuovi codici lineari classici derivati dagli stessi insiemi di stringhe, $z_1,\ldots,z_s$ e $x_1,\ldots,x_t,$ ma considerando queste stringhe come generatori invece che come stringhe di controllo di parità. In particolare, otteniamo questi due codici.

$$\begin{aligned} \mathcal{D}_Z & = \bigl\{ \alpha_1 z_1 \oplus \cdots \oplus \alpha_s z_s \,:\, \alpha_1,\ldots,\alpha_s \in \{0,1\} \bigr\}\\[1mm] \mathcal{D}_X & = \bigl\{ \alpha_1 x_1 \oplus \cdots \oplus \alpha_t x_t \,:\, \alpha_1,\ldots,\alpha_t \in \{0,1\} \bigr\} \end{aligned}$$

Questi sono noti come i codici duali dei codici definiti in precedenza: $\mathcal{D}_Z$ è il codice duale di $\mathcal{C}_Z$ e $\mathcal{D}_X$ è il codice duale di $\mathcal{C}_X.$ Può non essere chiaro a questo punto perché questi codici duali siano rilevanti, ma risultano esserlo per molteplici ragioni, tra cui le due spiegate nei paragrafi seguenti.

In primo luogo, le condizioni che devono valere affinché due codici lineari classici $\mathcal{C}_Z$ e $\mathcal{C}_X$ siano compatibili — nel senso che possono essere accoppiati per formare un codice CSS — possono essere descritte in termini semplici facendo riferimento ai codici duali. In particolare, deve valere $\mathcal{D}_Z\subseteq\mathcal{C}_X,$ o equivalentemente $\mathcal{D}_X\subseteq\mathcal{C}_Z.$ In altre parole, il codice duale $\mathcal{D}_Z$ include le stringhe corrispondenti ai generatori stabilizzatori $Z$, e il fatto che siano contenute in $\mathcal{C}_X$ equivale a dire che il prodotto scalare binario di ciascuna di queste stringhe con quelle corrispondenti ai generatori stabilizzatori $X$ è zero. Ciò, a sua volta, equivale al fatto che ogni generatore stabilizzatore $Z$ commuta con ogni generatore stabilizzatore $X$. In alternativa, scambiando i ruoli dei generatori stabilizzatori $X$ e $Z$ e partendo dalla contenenza $\mathcal{D}_X\subseteq\mathcal{C}_Z,$ si giunge alla stessa conclusione.

In secondo luogo, facendo riferimento ai codici duali, possiamo descrivere facilmente gli spazi codice di un dato codice CSS. In particolare, lo spazio codice è generato da vettori della forma seguente.

$$\vert u \oplus \mathcal{D}_X\rangle = \frac{1}{\sqrt{2^t}} \sum_{v\in\mathcal{D}_X} \vert u \oplus v\rangle \qquad \text{(per ogni $u\in\mathcal{C}_Z$)}$$

In altre parole, questi vettori sono sovrapposizioni uniformi sulle stringhe del codice duale $\mathcal{D}_X$ del codice corrispondente ai generatori stabilizzatori $X$, traslate (cioè sottoposte a XOR bit a bit) con le stringhe del codice $\mathcal{C}_Z$ corrispondente ai generatori stabilizzatori $Z$. Per essere precisi, scelte diverse per la traslazione — rappresentata dalla stringa $u$ in questa espressione — possono dare luogo allo stesso vettore. Quindi, questi stati non sono tutti distinti, ma nel loro insieme generano l'intero spazio codice.

Ecco una spiegazione intuitiva del perché tali vettori appartengano allo spazio codice e lo generino. Consideriamo lo stato della base standard a $n$ qubit $\vert u\rangle,$ per una qualsiasi stringa a $n$ bit $u,$ e supponiamo di proiettare questo stato sullo spazio codice. Ossia, indicando con $\Pi$ la proiezione sullo spazio codice del nostro codice CSS, consideriamo il vettore $\Pi\vert u\rangle.$ Si presentano due casi:

• Caso 1: $u\in\mathcal{C}_Z.$ Questo implica che ogni generatore stabilizzatore $Z$ del nostro codice CSS agisce in modo banale su $\vert u\rangle.$ I generatori stabilizzatori $X$, invece, si limitano ciascuno a invertire alcuni dei bit di $\vert u\rangle.$ In particolare, per ogni generatore $v$ di $\mathcal{D}_X,$ il generatore stabilizzatore $X$ corrispondente a $v$ trasforma $\vert u\rangle$ in $\vert u\oplus v\rangle.$ Caratterizzando la proiezione $\Pi$ come la media sugli elementi dello stabilizzatore (come abbiamo visto nella lezione precedente), otteniamo la formula seguente:

  $$\Pi \vert u \rangle = \frac{1}{2^t} \sum_{v\in\mathcal{D}_{X}} \vert u \oplus v\rangle = \frac{1}{\sqrt{2^t}} \vert u \oplus \mathcal{D}_X\rangle.$$

• Caso 2: $u\notin\mathcal{C}_Z.$ Questo implica che almeno uno dei controlli di parità corrispondenti ai generatori stabilizzatori $Z$ fallisce, il che significa che $\vert u\rangle$ deve essere un autovettore con autovalore $-1$ di almeno uno dei generatori stabilizzatori $Z$. Lo spazio codice del codice CSS è l'intersezione degli autospazi con autovalore $+1$ dei generatori stabilizzatori. Pertanto, essendo un autovettore con autovalore $-1$ di almeno uno dei generatori stabilizzatori $Z$, $\vert u\rangle$ è ortogonale allo spazio codice:

  $$\Pi\vert u\rangle = 0.$$

Ora, considerando tutte le stringhe a $n$ bit $u$, scartando quelle per cui $\Pi\vert u\rangle = 0$ e normalizzando le rimanenti, otteniamo i vettori descritti in precedenza, il che dimostra che generano lo spazio codice.

Possiamo anche sfruttare la simmetria tra i generatori stabilizzatori $X$ e $Z$ per descrivere lo spazio codice in un modo simile ma diverso. In particolare, è lo spazio generato da vettori della forma seguente.

$$H^{\otimes n} \vert u \oplus \mathcal{D}_Z\rangle = \frac{1}{\sqrt{2^s}} \sum_{v\in\mathcal{D}_Z} H^{\otimes n}\vert u \oplus v\rangle \qquad \text{(per $u\in\mathcal{C}_X$)}$$

In sostanza, $X$ e $Z$ sono stati scambiati in ogni occorrenza — ma dobbiamo anche scambiare la base standard con la base $\{\vert+\rangle,\vert-\rangle\}$, motivo per cui sono incluse le operazioni di Hadamard.

Come esempio, consideriamo il codice di Steane a 7 qubit. Le stringhe di controllo di parità per i generatori stabilizzatori $X$ e $Z$ sono le stesse: $1111000,$ $1100110,$ e $1010101.$ I codici $\mathcal{C}_X$ e $\mathcal{C}_Z$ sono quindi uguali; entrambi coincidono con il codice $[7,4,3]$-Hamming.

$$\mathcal{C}_X = \mathcal{C}_Z = \{0000000, 0000111, 0011001, 0011110, 0101010, 0101101, 0110011, 0110100, 1001011, 1001100, 1010010, 1010101, 1100001, 1100110, 1111000, 1111111\}$$

Anche i codici duali $\mathcal{D}_X$ e $\mathcal{D}_Z$ sono quindi uguali. Abbiamo tre generatori, quindi otteniamo otto stringhe.

$$\mathcal{D}_X = \mathcal{D}_Z = \{0000000, 0011110, 0101101, 0110011, 1001011, 1010101, 1100110, 1111000\}$$

Queste stringhe sono tutte contenute nel codice $[7,4,3]$-Hamming, e quindi la condizione CSS è soddisfatta: $\mathcal{D}_Z \subseteq \mathcal{C}_X,$ o equivalentemente $\mathcal{D}_X \subseteq \mathcal{C}_Z.$

Dato che $\mathcal{D}_X$ contiene metà di tutte le stringhe in $\mathcal{C}_Z,$ i vettori distinti $\vert u\oplus \mathcal{D}_X\rangle$ ottenibili scegliendo $u\in\mathcal{C}_Z$ sono solo due. Questo è atteso, poiché il codice di Steane a 7 qubit ha uno spazio codice bidimensionale. Possiamo usare i due stati ottenuti in questo modo per codificare gli stati logici $\vert 0\rangle$ e $\vert 1\rangle$ nel modo seguente.

$$\begin{aligned} \vert 0\rangle & \mapsto \frac{ \vert 0000000\rangle + \vert 0011110\rangle + \vert 0101101\rangle + \vert 0110011\rangle + \vert 1001011\rangle + \vert 1010101\rangle + \vert 1100110\rangle + \vert 1111000\rangle }{\sqrt{8}}\\[4mm] \vert 1\rangle & \mapsto \frac{ \vert 0000111\rangle + \vert 0011001\rangle + \vert 0101010\rangle + \vert 0110100\rangle + \vert 1001100\rangle + \vert 1010010\rangle + \vert 1100001\rangle + \vert 1111111\rangle }{\sqrt{8}} \end{aligned}$$

Come sempre, questa scelta non è obbligata — siamo liberi di usare lo spazio codice per codificare i qubit nel modo che preferiamo. Questa codifica è tuttavia coerente con l'esempio di circuito di codifica per il codice di Steane a 7 qubit presentato nella lezione precedente.