Codice torico

Adesso parleremo di un codice CSS specifico noto come codice torico, scoperto da Alexei Kitaev nel 1997. In realtà il codice torico non è un singolo codice, ma una famiglia di codici, uno per ogni intero positivo a partire da 2. Questi codici possiedono alcune proprietà fondamentali:

• I generatori del stabilizzatore hanno peso basso, e in particolare hanno tutti peso 4. Nel gergo della teoria della codifica, il codice torico è un esempio di codice quantistico a controllo di parità a bassa densità, o codice quantistico LDPC (dove bassa in questo caso significa 4). Questa è una proprietà utile perché la misurazione di ciascun generatore del stabilizzatore non richiede il coinvolgimento di troppi qubit.

• Il codice torico ha località geometrica. Ciò significa che non solo i generatori del stabilizzatore hanno peso basso, ma è anche possibile disporre i qubit nello spazio in modo tale che ogni misurazione del generatore del stabilizzatore coinvolga solo qubit vicini tra loro. In linea di principio, questo rende tali misurazioni più facili da implementare rispetto al caso in cui coinvolgessero qubit spazialmente distanti.

• I membri della famiglia del codice torico hanno distanza sempre maggiore e possono tollerare un tasso di errore relativamente alto.

Descrizione del codice torico

Sia $L\geq 2$ un intero positivo e considera un reticolo $L\times L$ con cosiddetti confini periodici. Ad esempio, questa figura mostra un reticolo $L\times L$ per $L=9.$

Nota che le linee a destra e in basso sono tratteggiate. Questo indica che la linea tratteggiata a destra è la stessa linea di quella all'estrema sinistra, e analogamente, la linea tratteggiata in basso è la stessa di quella in cima.

Realizzare fisicamente questo tipo di configurazione richiede tre dimensioni. In particolare, potremmo formare il reticolo come un cilindro abbinando prima i lati sinistro e destro, poi piegare il cilindro in modo che i cerchi alle estremità — che in precedenza erano i bordi superiore e inferiore del reticolo — si incontrino. Oppure potremmo abbinare prima il bordo superiore e inferiore e poi i lati laterali; funziona in entrambi i modi e non fa differenza quale scegliamo ai fini di questa discussione.

Quello che si ottiene è un toro — in altre parole, una ciambella (anche se pensarlo come la camera d'aria di un pneumatico è forse un'immagine più appropriata, perché non si tratta di un solido: il reticolo è diventato solo la superficie di un toro). Da qui il nome "codice torico".

Il modo in cui ci si può "muovere" su un toro come questo, tra punti adiacenti del reticolo, sarà probabilmente familiare a chi ha giocato ai vecchi videogiochi, in cui uscire dal bordo superiore dello schermo fa riapparire dal basso, e lo stesso vale per i bordi sinistro e destro dello schermo. Così è come vedremo questo reticolo con confini periodici, invece di parlare specificamente di un toro nello spazio tridimensionale.

Successivamente, i qubit vengono disposti sui bordi di questo reticolo, come illustrato nella figura seguente, dove i qubit sono indicati da cerchi blu pieni.

I qubit posizionati sulle linee tratteggiate non sono pieni perché sono già rappresentati sulle linee più in alto e più a sinistra del reticolo. In totale ci sono $2L^2$ qubit: $L^2$ qubit sulle linee orizzontali e $L^2$ qubit sulle linee verticali.

Per descrivere il codice torico stesso, resta da descrivere i generatori del stabilizzatore:

• Per ogni riquadro formato dalle linee del reticolo esiste un generatore del stabilizzatore $Z$, ottenuto applicando il tensore di matrici $Z$ ai quattro qubit che toccano quel riquadro, insieme a matrici identità su tutti gli altri qubit.

• Per ogni vertice formato dalle linee del reticolo esiste un generatore del stabilizzatore $X$, ottenuto applicando il tensore di matrici $X$ ai quattro qubit adiacenti a quel vertice, insieme a matrici identità su tutti gli altri qubit.

In entrambi i casi si ottiene un'operazione di Pauli di peso 4. Individualmente, questi generatori del stabilizzatore possono essere illustrati come segue.

Ecco un'illustrazione che mostra alcuni esempi di generatori del stabilizzatore nel contesto del reticolo stesso. Nota che sono inclusi i generatori del stabilizzatore che si avvolgono attorno ai confini periodici. Questi generatori che si avvolgono attorno ai confini periodici non sono speciali né in alcun modo distinti da quelli che non lo fanno.

I generatori del stabilizzatore devono commutare affinché questo sia un codice stabilizzatore valido. Come di consueto, i generatori del stabilizzatore $Z$ commutano tutti tra loro, poiché $Z$ commuta con se stesso e l'identità commuta con tutto, e lo stesso vale per i generatori del stabilizzatore $X$. I generatori del stabilizzatore $Z$ e $X$ commutano chiaramente quando agiscono in modo non banale su insiemi disgiunti di qubit, come negli esempi mostrati nella figura precedente. La possibilità rimanente è che un generatore del stabilizzatore $Z$ e uno $X$ si sovrappongano sui qubit su cui agiscono in modo non banale, e ogni volta che ciò accade i generatori si sovrappongono sempre su due qubit, come nella figura successiva.

Di conseguenza, due generatori del stabilizzatore come questi commutano, proprio come $Z\otimes Z$ e $X\otimes X$ commutano. I generatori del stabilizzatore commutano quindi tutti tra loro.

La seconda condizione richiesta ai generatori del stabilizzatore per un codice stabilizzatore è che formino un insieme generatore minimale. Questa condizione non è in realtà soddisfatta da questa collezione: se moltiplichiamo tutti i generatori del stabilizzatore $Z$ insieme, otteniamo l'operazione identità, e lo stesso vale per i generatori del stabilizzatore $X$. Quindi, qualsiasi generatore del stabilizzatore $Z$ può essere espresso come prodotto di tutti gli altri, e analogamente qualsiasi generatore del stabilizzatore $X$ può essere espresso come prodotto degli altri generatori $X$. Se però rimuoviamo uno qualsiasi dei generatori del stabilizzatore $Z$ e uno dei generatori del stabilizzatore $X$, otteniamo un insieme generatore minimale.

Per chiarire, in realtà ci interessano ugualmente tutti i generatori del stabilizzatore, e in senso strettamente operativo non c'è alcuna necessità di selezionare un generatore del stabilizzatore di ciascun tipo da rimuovere. Ma ai fini dell'analisi del codice — e in particolare del conteggio dei generatori — possiamo immaginare che un generatore del stabilizzatore di ciascun tipo sia stato rimosso, in modo da ottenere un insieme generatore minimale, tenendo presente che potremmo sempre dedurre i risultati di questi generatori rimossi (intesi come osservabili) dai risultati di tutti gli altri osservabili del generatore del stabilizzatore dello stesso tipo.

Questo lascia $L^2 - 1$ generatori del stabilizzatore di ciascun tipo, ovvero $2L^2 - 2$ in totale, in un insieme generatore minimale (ipotetico). Dato che ci sono in totale $2L^2$ qubit, questo significa che il codice torico codifica $2L^2 - 2(L^2 - 1) = 2$ qubit.

L'ultima condizione richiesta ai generatori del stabilizzatore è che almeno un vettore di stato quantistico sia fissato da tutti i generatori del stabilizzatore. Vedremo che questo è il caso man mano che procediamo con l'analisi del codice, ma è anche possibile ragionare sul fatto che non c'è modo di generare $-1$ volte l'identità su tutti i $2L^2$ qubit a partire dai generatori del stabilizzatore.

Rilevamento degli errori

Il codice torico ha una descrizione semplice ed elegante, ma le sue proprietà di correzione degli errori quantistici potrebbero non essere affatto chiare a prima vista. Si scopre che è un codice straordinario! Per capire perché e come funziona, iniziamo considerando i diversi errori e le sindromi che generano.

Il codice torico è un codice CSS, poiché tutti i nostri generatori del stabilizzatore sono o generatori del stabilizzatore $Z$ o $X$. Ciò significa che gli errori $X$ e gli errori $Z$ possono essere rilevati (e possibilmente corretti) separatamente. In realtà, esiste una semplice simmetria tra i generatori del stabilizzatore $Z$ e $X$ che ci consente di analizzare gli errori $X$ e $Z$ in modo essenzialmente identico. Ci concentreremo quindi sugli errori $X$, che vengono potenzialmente rilevati dai generatori del stabilizzatore $Z$ — ma l'intera discussione che segue può essere tradotta dagli errori $X$ agli errori $Z$, che vengono analogamente rilevati dai generatori del stabilizzatore $X$.

Il seguente diagramma mostra l'effetto di un errore $X$ su un singolo qubit. Si assume qui che i nostri $2L^2$ qubit si trovassero precedentemente in uno stato contenuto nello spazio codice del codice torico, facendo sì che tutte le misurazioni dei generatori del stabilizzatore restituissero $+1.$ I generatori del stabilizzatore $Z$ rilevano gli errori $X$, e ce n'è uno per ogni riquadro della figura, quindi possiamo indicare il risultato della misurazione del corrispondente generatore del stabilizzatore con il colore di quel riquadro: i risultati $+1$ sono indicati da riquadri bianchi e i risultati $-1$ da riquadri grigi. Se si verifica un errore di bit-flip su uno dei qubit, l'effetto è che le misurazioni dei generatori del stabilizzatore corrispondenti ai due riquadri che toccano il qubit interessato ora restituiscono $-1.$

Questo è intuitivo quando consideriamo i generatori del stabilizzatore $Z$ e il loro comportamento. In sostanza, ogni generatore del stabilizzatore $Z$ misura la parità dei quattro qubit che toccano il riquadro corrispondente (rispetto alla base standard). Quindi, un risultato $+1$ non indica che non si sono verificati errori $X$ su questi quattro qubit, ma piuttosto che si è verificato un numero pari di errori $X$ su questi qubit, mentre un risultato $-1$ indica che si è verificato un numero dispari di errori $X$. Un singolo errore $X$ inverte quindi la parità dei quattro bit su entrambi i riquadri che tocca, causando che le misurazioni dei generatori del stabilizzatore restituiscano $-1.$

Ora introduciamo più errori $X$ per vedere cosa succede. In particolare, considereremo una catena di errori $X$ adiacenti, dove due errori $X$ sono adiacenti se interessano qubit che toccano lo stesso riquadro.

I due generatori del stabilizzatore $Z$ alle estremità della catena restituiscono entrambi il risultato $-1$ in questo caso, perché su quei due riquadri corrispondenti si è verificato un numero dispari di errori $X$. Tutti gli altri generatori del stabilizzatore $Z$, invece, restituiscono il risultato $+1,$ inclusi quelli che toccano la catena ma non alle estremità, perché sui qubit che toccano i riquadri corrispondenti si è verificato un numero pari di errori $X$.

Quindi, fintanto che abbiamo una catena di errori $X$ con estremità, il codice torico rileverà che si sono verificati degli errori, producendo risultati di misurazione $-1$ per i generatori del stabilizzatore $Z$ corrispondenti alle estremità della catena. Nota che la catena effettiva di errori non viene rivelata, solo le estremità! Va bene — nella prossima sottosezione vedremo che non è necessario sapere esattamente quali qubit sono stati interessati dagli errori $X$ per correggerli. (Il codice torico è un esempio di codice altamente degenere, nel senso che in genere non identifica in modo univoco gli errori che corregge.)

È però possibile che una catena di errori $X$ adiacenti non abbia estremità, il che significa che una catena di errori potrebbe formare un anello chiuso, come nella figura seguente.

In tal caso, su ogni riquadro si è verificato un numero pari di errori $X$, quindi ogni misurazione del generatore del stabilizzatore restituisce un risultato $+1$. Gli anelli chiusi di errori $X$ adiacenti non vengono quindi rilevati dal codice.

Questo potrebbe sembrare deludente, perché bastano solo quattro errori $X$ per formare un anello chiuso (e speriamo in qualcosa di molto migliore di un codice a distanza 4). Tuttavia, un anello chiuso di errori $X$ nella forma mostrata nella figura precedente non è in realtà un errore — perché è nel stabilizzatore! Ricorda che, oltre ai generatori del stabilizzatore $Z$, abbiamo anche un generatore del stabilizzatore $X$ per ogni vertice nel reticolo. E se moltiplichiamo insieme generatori del stabilizzatore $X$ adiacenti, il risultato è che otteniamo anelli chiusi di operazioni $X$. Ad esempio, l'anello chiuso nella figura precedente si può ottenere moltiplicando insieme i generatori del stabilizzatore $X$ indicati nella figura seguente.

Questo, tuttavia, non è l'unico tipo di anello chiuso di errori $X$ che possiamo avere — e non è vero che ogni anello chiuso di errori $X$ sia incluso nel stabilizzatore. In particolare, i diversi tipi di anelli possono essere caratterizzati come segue.

1. Anelli chiusi di errori $X$ con un numero pari di errori $X$ su ogni linea orizzontale e ogni linea verticale di qubit. (L'esempio mostrato sopra rientra in questa categoria.) Gli anelli di questa forma sono sempre contenuti nel stabilizzatore, poiché possono essere efficacemente ridotti a nulla moltiplicandoli per i generatori del stabilizzatore $X$.

2. Anelli chiusi di errori $X$ con un numero dispari di errori $X$ su almeno una linea orizzontale o almeno una linea verticale di qubit. Gli anelli di questa forma non sono mai contenuti nel stabilizzatore e rappresentano quindi errori non banali che passano inosservati dal codice.

Un esempio di anello chiuso di errori $X$ nella seconda categoria è mostrato nel diagramma seguente.

Una tale catena di errori non è contenuta nel stabilizzatore perché ogni generatore del stabilizzatore $X$ pone un numero pari di operazioni $X$ su ogni linea orizzontale e ogni linea verticale di qubit. Questo è quindi un esempio concreto di errore non banale che il codice non riesce a rilevare.

Il punto chiave è che l'unico modo per formare un anello del secondo tipo è girare attorno al toro, ovvero o attorno al buco al centro del toro, attraverso di esso, o in entrambi i modi. Intuitivamente, una catena di errori $X$ di questo tipo non può essere ridotta a nulla moltiplicandola per i generatori del stabilizzatore $X$ perché la topologia di un toro lo impedisce. Per questo motivo il codice torico viene talvolta classificato come codice di correzione degli errori quantistici topologico. La lunghezza minima di tale anello è $L$, e quindi questa è la distanza del codice torico: ogni anello chiuso di errori $X$ con lunghezza inferiore a $L$ deve rientrare nella prima categoria, ed è quindi contenuto nel stabilizzatore; e qualsiasi catena di errori $X$ con estremità viene rilevata dal codice.

Dato che il codice torico utilizza $2L^2$ qubit per codificare $2$ qubit e ha distanza $L$, ne consegue che è un codice stabilizzatore $[[2L^2,2,L]]$.

Correzione degli errori

Abbiamo discusso il rilevamento degli errori per il codice torico, e ora discuteremo brevemente come correggere gli errori. Il codice torico è un codice CSS, quindi gli errori $X$ e $Z$ possono essere rilevati e corretti indipendentemente. Mantenendo la nostra attenzione sui generatori del stabilizzatore $Z$, che rilevano gli errori $X$, consideriamo come una catena di errori $X$ possa essere corretta. (Gli errori $Z$ vengono corretti in modo simmetrico.)

Se quando si misurano i generatori del stabilizzatore $Z$ compare una sindrome diversa dalla sindrome $(+1,\ldots,+1)$, i risultati $-1$ rivelano le estremità di una o più catene di errori $X$. Possiamo tentare di correggere questi errori abbinando i risultati $-1$ e formando una catena di correzioni $X$ tra di essi. In questo contesto, ha senso scegliere i percorsi più brevi lungo i quali avvengono le correzioni.

Considera ad esempio il diagramma seguente, che mostra una sindrome con due risultati $-1$, indicati dai riquadri grigi, causati da una catena di errori $X$ illustrata dalla linea e dai cerchi magenta. Come abbiamo già osservato, la catena stessa non viene rivelata dalla sindrome; solo le estremità sono visibili.

Per tentare di correggere questa catena di errori, si seleziona il percorso più breve tra i risultati di misurazione $-1$ e si applicano gate $X$ come correzioni ai qubit lungo questo percorso (indicati in giallo nella figura). Sebbene le correzioni possano non corrispondere esattamente alla catena effettiva di errori, gli errori e le correzioni insieme formano un anello chiuso di operazioni $X$ che è contenuto nel stabilizzatore del codice. La correzione ha quindi successo in questa situazione, poiché l'effetto combinato degli errori e delle correzioni è di non fare nulla a uno stato codificato.

Questa strategia non avrà sempre successo. Ad esempio, nella figura seguente viene mostrata un'altra spiegazione per la stessa sindrome della figura precedente.

Questa volta, la stessa catena di correzioni di prima non riesce a correggere questa catena di errori, perché l'effetto combinato degli errori e delle correzioni è che si ottiene un anello chiuso di operazioni $X$ che si avvolge attorno al toro, avendo quindi un effetto non banale sullo spazio codice. Quindi, non c'è garanzia che la strategia appena descritta, di scegliere il percorso più breve di correzioni $X$ tra due risultati di sindrome $-1$, corregga correttamente l'errore che ha causato quella sindrome.

Forse più probabile, a seconda del modello di rumore, è che venga misurata una sindrome con più di due voci $-1$, come suggerisce la figura seguente.

In tal caso esistono diverse strategie di correzione note. Una strategia naturale consiste nel tentare di abbinare i risultati di misurazione $-1$ ed eseguire correzioni lungo i percorsi più brevi che collegano le coppie, come indicato in giallo nella figura. In particolare, si può calcolare un matching perfetto di peso minimo tra i risultati di misurazione $-1$, e poi le coppie vengono collegate da percorsi più brevi di correzioni $X$. Il calcolo di un matching perfetto di peso minimo può essere eseguito in modo efficiente con un algoritmo classico noto come algoritmo blossom, scoperto da Edmonds negli anni '60.

Questo approccio in genere non è ottimale per i modelli di rumore più comunemente studiati, ma in base a simulazioni numeriche funziona molto bene in pratica al di sotto di un tasso di rumore di circa il 10%, assumendo errori di Pauli indipendenti in cui $X,$ $Y$ e $Z$ sono ugualmente probabili. Aumentare $L$ non ha un effetto significativo sul punto di pareggio al quale il codice inizia a essere utile, ma porta a una diminuzione più rapida della probabilità di un errore logico man mano che il tasso di errore scende al di sotto di quel punto di pareggio.