Coduri stabilizatoare

Acum vom defini codurile stabilizatoare în general. Vom discuta, de asemenea, câteva dintre proprietățile lor de bază și modul în care funcționează, inclusiv cum pot fi codificate stările și cum sunt detectate și corectate erorile folosind aceste coduri.

Definiția codurilor stabilizatoare

Un cod stabilizator pe $n$ qubiți este specificat printr-o listă de operații Pauli pe $n$ qubiți, $P_1,\ldots,P_r.$ Aceste operații sunt numite generatori stabilizatori în acest context și trebuie să satisfacă următoarele trei proprietăți.

1. Generatorii stabilizatori comutează toți unul cu celălalt.

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

2. Generatorii stabilizatori formează o mulțime generatoare minimală.

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

3. Cel puțin un vector de stare cuantică este fixat de toți generatorii stabilizatori.

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

   (Nu este evident că existența unui vector de stare cuantică $\vert\psi\rangle$ fixat de toți generatorii stabilizatori, adică $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle,$ este echivalentă cu $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle,$ dar într-adevăr acesta este cazul, și vom vedea de ce puțin mai târziu în lecție.)

Presupunând că avem o astfel de listă $P_1,\ldots,P_r,$ spațiul de cod definit de acești generatori stabilizatori este subspațiul $\mathcal{C}$ care conține fiecare vector de stare cuantică pe $n$ qubiți fixat de toți cei $r$ generatori stabilizatori.

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

Vectorii de stare cuantică din acest subspațiu sunt tocmai cei care pot fi priviți ca codificări valide ale stărilor cuantice. Vom discuta procesul efectiv de codificare mai târziu.

În final, stabilizatorul codului definit de generatorii stabilizatori $P_1, \ldots, P_r$ este mulțimea generată de aceste operații:

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

Un mod natural de a te gândi la un cod stabilizator este să privești generatorii stabilizatori ca observabile și să interpretezi colectiv rezultatele măsurătorilor asociate acestor observabile ca un sindrom de eroare. Codificările valide sunt vectori de stare cuantică pe $n$ qubiți pentru care rezultatele măsurătorilor, ca valori proprii, sunt garantate a fi toate $+1.$ Orice alt sindrom, în care apare cel puțin un rezultat de măsurare $-1,$ semnalează că a fost detectată o eroare.

Vom analiza câteva exemple în scurt timp, dar mai întâi câteva remarci despre cele trei condiții asupra generatorilor stabilizatori sunt necesare.

Prima condiție este naturală, în lumina interpretării generatorilor stabilizatori ca observabile, deoarece implică faptul că ordinea în care sunt efectuate măsurătorile nu contează: observabilele comutează, deci măsurătorile comutează. Aceasta impune în mod natural anumite constrângeri algebrice asupra codurilor stabilizatoare, care sunt importante pentru modul în care funcționează.

A doua condiție impune ca generatorii stabilizatori să formeze o mulțime generatoare minimală, ceea ce înseamnă că eliminarea oricăruia dintre ei ar duce la un stabilizator mai mic. Strict vorbind, această condiție nu este cu adevărat esențială pentru modul în care funcționează codurile stabilizatoare într-un sens operațional — și, după cum vom vedea în lecția următoare, uneori are sens să te gândești la mulțimi de generatori stabilizatori pentru coduri care de fapt nu satisfac această condiție. Totuși, în scopul analizării codurilor stabilizatoare și al explicării proprietăților lor, vom presupune că această condiție este în vigoare. Pe scurt, această condiție garantează că fiecare observabilă pe care o măsurăm pentru a obține sindromul de eroare adaugă informații despre posibilele erori, în loc să fie redundantă și să producă rezultate care ar putea fi deduse din celelalte măsurători ale generatorilor stabilizatori.

A treia condiție impune ca cel puțin un vector nenul să fie fixat de toți generatorii stabilizatori, ceea ce este echivalent cu faptul că $-\mathbb{I}^{\otimes n}$ nu este conținut în stabilizator. Necesitatea acestei condiții provine din faptul că este de fapt posibil să alegi o mulțime generatoare minimală de operații Pauli pe $n$ qubiți care comutează toate unul cu celălalt, și totuși niciun vector nenul să nu fie fixat de fiecare dintre operații. Nu suntem interesați de „coduri" pentru care nu există codificări valide, deci excludem această posibilitate impunând această condiție ca parte a definiției.

Exemple

Iată câteva exemple de coduri stabilizatoare pentru valori mici ale lui $n.$ Vom vedea mai multe exemple, inclusiv unele pentru care $n$ poate fi mult mai mare, în lecția următoare.

Codul de repetiție pe 3 biți

Codul de repetiție pe 3 biți este un exemplu de cod stabilizator, unde generatorii noștri stabilizatori sunt $Z \otimes Z \otimes \mathbb{I}$ și $\mathbb{I} \otimes Z \otimes Z.$

Putem verifica ușor că acești doi generatori stabilizatori îndeplinesc condițiile necesare. În primul rând, cei doi generatori stabilizatori $Z \otimes Z \otimes \mathbb{I}$ și $\mathbb{I} \otimes Z \otimes Z$ comutează unul cu celălalt.

$$(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})$$

În al doilea rând, avem o mulțime generatoare minimală (destul de trivial în acest caz).

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

Și în al treilea rând, știm deja că $\vert 000\rangle$ și $\vert 111\rangle,$ precum și orice combinație liniară a acestor vectori, sunt fixați de atât $Z \otimes Z \otimes \mathbb{I}$ cât și $\mathbb{I} \otimes Z \otimes Z.$ Alternativ, putem concluziona aceasta folosind condiția echivalentă din definiție.

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

Aceste condiții pot fi mult mai dificil de verificat pentru coduri stabilizatoare mai complicate.

Codul de repetiție pe 3 biți modificat

În lecția anterioară, am văzut că este posibil să modifici codul de repetiție pe 3 biți astfel încât să protejeze împotriva erorilor de inversare a fazei, mai degrabă decât a erorilor de inversare a biților. Ca cod stabilizator, acest nou cod este ușor de descris: generatorii săi stabilizatori sunt $X \otimes X \otimes \mathbb{I}$ și $\mathbb{I} \otimes X \otimes X.$

De data aceasta, generatorii stabilizatori reprezintă observabile $X\otimes X$ în loc de observabile $Z\otimes Z$, deci sunt în esență verificări de paritate în baza plus/minus, mai degrabă decât în baza standard. Cele trei condiții necesare asupra generatorilor stabilizatori se verifică ușor, pe linii similare cu codul obișnuit de repetiție pe 3 biți.

Codul Shor pe 9 qubiți

Iată codul Shor pe 9 qubiți, care este de asemenea un cod stabilizator, exprimat prin generatori stabilizatori.

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

În acest caz, avem practic trei copii ale codului de repetiție pe 3 biți, câte una pentru fiecare dintre cele trei blocuri de trei qubiți, precum și ultimii doi generatori Stabilizer, care au o formă ce amintește de circuitul pentru detectarea erorilor de inversare de fază pentru acest cod.

O modalitate alternativă de a privi ultimii doi generatori Stabilizer este că aceștia au aceeași formă ca pentru codul de repetiție pe 3 biți pentru erorile de inversare de fază, cu excepția faptului că $X\otimes X\otimes X$ este substituit cu $X,$ ceea ce este consistent cu faptul că $X\otimes X\otimes X$ corespunde unei operații $X$ pe qubiții logici codificați folosind codul de repetiție pe 3 biți.

Înainte de a trece la alte exemple, trebuie menționat că simbolurile produsului tensorial sunt adesea omise atunci când se descriu codurile Stabilizer prin liste de generatori Stabilizer, deoarece tind să le facă mai ușor de citit și să le evidențieze tiparele. De exemplu, aceiași generatori Stabilizer de mai sus pentru codul Shor pe 9 qubiți arată astfel fără simbolurile produsului tensorial scrise explicit.

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

Codul Steane pe 7 qubiți

Iată un alt exemplu de cod Stabilizer, cunoscut sub numele de codul Steane pe 7 qubiți. Are câteva caracteristici remarcabile și vom reveni la acest cod din când în când pe parcursul lecțiilor rămase ale cursului.

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

Deocamdată, să observăm pur și simplu că acesta este un cod Stabilizer valid. Primii trei generatori Stabilizer comutează în mod evident între ei, deoarece $Z$ comutează cu el însuși, iar identitatea comutează cu orice, iar situația este similară pentru ultimii trei generatori Stabilizer. Rămâne de verificat că, dacă luăm unul dintre generatorii de tip $Z$-Stabilizer (adică unul dintre primii trei) și unul dintre generatorii de tip $X$-Stabilizer (adică unul dintre ultimii trei), atunci acești doi generatori comutează, și se pot parcurge cele 9 perechi posibile pentru a verifica aceasta. În toate aceste cazuri, o matrice Pauli $X$ și una $Z$ se aliniază întotdeauna pe aceeași poziție de un număr par de ori, astfel încât cei doi generatori vor comuta, la fel cum $X\otimes X$ și $Z\otimes Z$ comutează. Acesta este, de asemenea, un set minimal de generatori și definește un spațiu de cod netrivial, fapte pe care le lăsăm ca exercițiu de reflecție.

Codul Steane pe 7 qubiți este similar cu codul Shor pe 9 qubiți în sensul că codifică un singur Qubit și permite corectarea unei erori arbitrare pe un singur Qubit, dar necesită doar 7 qubiți în loc de 9.

Codul pe 5 qubiți

Șapte nu este cel mai mic număr de qubiți necesar pentru a codifica un Qubit și a-l proteja împotriva unei erori arbitrare pe un singur Qubit — iată un cod Stabilizer care realizează acest lucru folosind doar 5 qubiți.

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

Acest cod este denumit în mod obișnuit codul pe 5 qubiți. Acesta este cel mai mic număr de qubiți dintr-un cod de corecție a erorilor cuantice care poate permite corectarea unei erori arbitrare pe un singur Qubit.

Coduri Stabilizer unidimensionale

Iată un alt exemplu de cod Stabilizer, deși acesta nu codifică efectiv niciun Qubit: spațiul de cod este unidimensional. Este totuși un cod Stabilizer valid conform definiției.

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

Mai precis, spațiul de cod este spațiul unidimensional generat de un e-bit $\vert\phi^+\rangle.$

Iată un exemplu înrudit de cod Stabilizer al cărui spațiu de cod este spațiul unidimensional generat de o stare 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}$$

Dimensiunea spațiului de cod

Presupunem că avem un cod Stabilizer, descris de generatorii Stabilizer pe $n$ qubiți $P_1,\ldots,P_r.$ Poate că prima întrebare care ne vine în minte despre acest cod este: „Câți qubiți codifică?"

Această întrebare are un răspuns simplu. Presupunând că generatorii Stabilizer pe $n$ qubiți $P_1, \ldots, P_r$ satisfac cele trei cerințe ale definiției (și anume că generatorii Stabilizer comutează toți între ei, că acesta este un set minimal de generatori și că spațiul de cod este nevid), atunci spațiul de cod al acestui cod Stabilizer trebuie să aibă dimensiunea $2^{n-r},$ deci $n-r$ qubiți pot fi codificați folosind acest cod.

Intuitiv vorbind, avem $n$ qubiți de utilizat pentru această codificare, iar fiecare generator Stabilizer „ia efectiv un Qubit" în ceea ce privește numărul de qubiți pe care îi putem codifica. Reține că aceasta nu se referă la ce sau câte erori pot fi detectate sau corectate, ci este doar o afirmație despre dimensiunea spațiului de cod.

De exemplu, atât pentru codul de repetiție pe 3 biți, cât și pentru versiunea modificată a acelui cod pentru erorile de inversare de fază, avem $n=3$ qubiți și $r=2$ generatori Stabilizer, și deci aceste coduri pot codifica fiecare câte 1 Qubit. Pentru un alt exemplu, consideră codul pe 5 qubiți: avem 5 qubiți și 4 generatori Stabilizer, deci spațiul de cod are din nou dimensiunea 2, ceea ce înseamnă că un Qubit poate fi codificat folosind acest cod. Pentru un ultim exemplu, codul ai cărui generatori Stabilizer sunt $X\otimes X$ și $Z\otimes Z$ are un spațiu de cod unidimensional, generat de starea $\vert\phi^+\rangle,$ ceea ce este consistent cu $n=2$ qubiți și $r=2$ generatori Stabilizer.

Acum să vedem cum se poate demonstra acest fapt. Primul pas este să observăm că, deoarece generatorii Stabilizer comutează, și deoarece orice operație Pauli este propria sa inversă, orice element din Stabilizer poate fi exprimat ca un produs

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

unde $a_1,\ldots,a_r\in\{0,1\}.$ Echivalent, fiecare element al Stabilizer-ului se obține înmulțind un subset oarecare de generatori Stabilizer. Într-adevăr, fiecare element al Stabilizer-ului poate fi exprimat unic în acest mod, datorită condiției că $\{P_1,\ldots,P_r\}$ este un set minimal de generatori.

În continuare, definim $\Pi_k$ ca proiecția pe spațiul vectorilor proprii cu valoarea proprie $+1$ ai lui $P_k,$ pentru fiecare $k\in\{1,\ldots,r\}.$ Aceste proiecții pot fi obținute prin medierea operațiilor Pauli corespunzătoare cu operația identitate, după cum urmează.

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

Spațiul de cod $\mathcal{C}$ este subspațiul tuturor vectorilor care sunt fixați de toți cei $r$ generatori Stabilizer $P_1,\ldots,P_r,$ sau echivalent, de toate cele $r$ proiecții $\Pi_1,\ldots,\Pi_r.$

Dat fiind că generatorii Stabilizer comutează toți între ei, proiecțiile $\Pi_1,\ldots,\Pi_r$ trebuie de asemenea să comute. Aceasta ne permite să folosim un fapt din algebră liniară, și anume că produsul acestor proiecții este proiecția pe intersecția subspațiilor corespunzătoare proiecțiilor individuale. Cu alte cuvinte, produsul $\Pi_1\cdots\Pi_r$ este proiecția pe spațiul de cod $\mathcal{C}.$

Putem acum să extindem produsul $\Pi_1\cdots\Pi_r$ folosind formulele pentru aceste proiecții și să obținem expresia următoare.

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

Cu alte cuvinte, proiecția pe spațiul de cod al unui cod Stabilizer este egală, ca matrice, cu media tuturor elementelor din Stabilizer-ul acelui cod.

În final, putem calcula dimensiunea spațiului de cod folosind faptul că dimensiunea oricărui subspațiu este egală cu urma proiecției pe acel subspațiu. Astfel, dimensiunea spațiului de cod $\mathcal{C}$ este dată de formula următoare.

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

Putem evalua această expresie folosind câteva fapte elementare.

• Avem $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ și, prin urmare,

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

• Pentru $(a_1,\ldots,a_r) \neq (0,\ldots,0),$ produsul $P_1^{a_1}\cdots P_r^{a_r}$ trebuie să fie $\pm 1$ înmulțit cu o operație Pauli — dar nu putem obține $\mathbb{I}^{\otimes n}$ deoarece asta ar contrazice minimalitatea mulțimii $\{P_1,\ldots,P_r\},$ și nu putem obține $-\mathbb{I}^{\otimes n}$ deoarece a treia condiție impusă generatorilor Stabilizer interzice acest lucru. Prin urmare, deoarece urma oricărei operații Pauli non-identitate este zero, obținem

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

Dimensiunea spațiului codului este deci $2^{n-r}$, conform afirmației:

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

Ca o observație suplimentară, putem acum vedea că ipoteza conform căreia $-\mathbb{I}^{\otimes n}$ nu este conținut în Stabilizer implică faptul că spațiul codului trebuie să conțină cel puțin un vector de stare cuantică. Aceasta deoarece, după cum tocmai am verificat, această ipoteză implică faptul că spațiul codului are dimensiunea $2^{n-r},$ care nu poate fi zero. Implicația inversă se dovedește a fi trivială: dacă $-\mathbb{I}^{\otimes n}$ este conținut în Stabilizer, atunci spațiul codului nu poate conține niciun vector de stare cuantică, deoarece niciun vector nenul nu este fixat de această operație.

Operații Clifford și codificări

În continuare, vom discuta pe scurt cum pot fi codificați qubiții folosind coduri Stabilizer, dar pentru aceasta trebuie mai întâi să introducem operațiile Clifford.

Operații Clifford

Operațiile Clifford sunt operații unitare, pe orice număr de qubiți, care pot fi implementate prin circuite cuantice cu un set restricționat de porți:

• porți Hadamard
• porți $S$
• porți CNOT

Observă că porțile $T$ nu sunt incluse, la fel cum nu sunt incluse nici porțile Toffoli și Fredkin. Nu numai că acele porți nu figurează în listă, dar, de fapt, nu este posibil să le implementezi folosind porțile listate aici; ele nu sunt operații Clifford. Operațiile Pauli, pe de altă parte, sunt operații Clifford deoarece pot fi implementate cu secvențe de porți Hadamard și $S$.

Aceasta este o modalitate simplă de a defini operațiile Clifford, dar nu explică de ce sunt definite astfel sau ce este special la această colecție particulară de porți. Motivul real pentru care operațiile Clifford sunt definite în acest mod este că, până la factori de fază globali, operațiile Clifford sunt exact acele operații unitare care transformă întotdeauna operațiile Pauli în operații Pauli prin conjugare. Mai precis, o operație unitară pe $n$ qubiți $U$ este echivalentă cu o operație Clifford până la un factor de fază dacă și numai dacă, pentru orice operație Pauli pe $n$ qubiți $P,$ avem

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

pentru o anumită operație Pauli pe $n$ qubiți $Q.$

(Observă că nu este posibil să avem $U P U^{\dagger} = \alpha Q$ pentru $\alpha\notin\{+1,-1\}$ când $U$ este unitar și $P$ și $Q$ sunt operații Pauli. Aceasta rezultă din faptul că matricea din membrul stâng al ecuației în cauză este atât unitară, cât și hermitiană, iar $+1$ și $-1$ sunt singurele alegeri pentru $\alpha$ care permit ca membrul drept să fie de asemenea unitar și hermitian.)

Este simplu să verifici proprietatea de conjugare descrisă mai sus când $U$ este o poartă Hadamard, $S$ sau CNOT. În particular, aceasta este ușor pentru porțile Hadamard,

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

și porțile $S$,

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

Pentru porțile CNOT, există 15 operații Pauli non-identitate pe doi qubiți de verificat. Desigur, ele pot fi verificate individual — dar relațiile dintre porțile CNOT și porțile $X$ și $Z$ enumerate (în formă de Circuit) în lecția anterioară, împreună cu regulile de înmulțire pentru matricele Pauli, oferă o scurtătură spre aceeași concluzie.

Odată ce știm că această proprietate de conjugare este adevărată pentru porțile Hadamard, $S$ și CNOT, putem concluziona imediat că este adevărată și pentru circuite compuse din aceste porți — adică, pentru toate operațiile Clifford.

Este mai dificil să demonstrezi că relația funcționează și în cealaltă direcție, și anume că dacă o operație unitară dată $U$ satisface proprietatea de conjugare pentru operații Pauli, atunci trebuie să fie posibil să o implementezi (până la o fază globală) folosind doar porți Hadamard, $S$ și CNOT. Aceasta nu va fi explicată în această lecție, dar este adevărat.

Operațiile Clifford nu sunt universale pentru calculul cuantic; spre deosebire de seturile universale de porți cuantice, nu este posibil să aproximezi operații unitare arbitrare la orice nivel de precizie dorit cu operații Clifford. Într-adevăr, pentru o valoare dată a lui $n,$ există doar un număr finit de operații Clifford pe $n$ qubiți (până la factori de fază). Efectuarea operațiilor Clifford pe stări în baza standard, urmată de măsurători în baza standard, nu ne permite nici să efectuăm calcule care să depășească capacitățile algoritmilor clasici — deoarece putem simula eficient clasic calculele de această formă. Acest fapt este cunoscut sub numele de teorema Gottesman-Knill.

Codificatoare pentru coduri Stabilizer

Un cod Stabilizer definește un spațiu al codului cu o anumită dimensiune, iar noi avem libertatea de a folosi acel spațiu al codului cum dorim — nimic nu ne obligă să codificăm qubiții în acest spațiu al codului într-un mod specific. Este întotdeauna posibil, totuși, să folosești o operație Clifford ca și codificator, dacă alegi să faci asta. Mai precis, pentru orice cod Stabilizer care permite codificarea a $m$ qubiți în $n$ qubiți, există o operație Clifford pe $n$ qubiți $U$ astfel încât, pentru orice vector de stare cuantică pe $m$ qubiți $\vert\phi\rangle,$ avem că

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

este un vector de stare cuantică în spațiul codului nostru, pe care îl putem interpreta ca o codificare a lui $\vert\phi\rangle.$

Aceasta este o veste bună, deoarece operațiile Clifford sunt relativ simple, comparativ cu operațiile unitare arbitrare, și există modalități de a optimiza implementarea lor folosind tehnici similare cu cele din demonstrația teoremei Gottesman-Knill. Ca urmare, circuitele pentru codificarea stărilor cu coduri Stabilizer nu trebuie să fie niciodată prea mari. În particular, este întotdeauna posibil să efectuezi o codificare pentru un cod Stabilizer pe $n$ qubiți folosind o operație Clifford care necesită $O(n^2/\log(n))$ porți. Aceasta se datorează faptului că orice operație Clifford pe $n$ qubiți poate fi implementată printr-un Circuit de această dimensiune.

De exemplu, iată un codificator pentru codul Steane cu 7 qubiți. Este într-adevăr o operație Clifford și, după cum se dovedește, acesta nu necesită nici măcar porți $S$.

Detectarea erorilor

Pentru un cod Stabilizer pe $n$ qubiți descris de generatorii Stabilizer $P_1,\ldots, P_r,$ detectarea erorilor funcționează în felul următor.

Pentru a detecta erori, toți generatorii Stabilizer sunt măsurați ca observabile. Există $r$ generatori Stabilizer și, prin urmare, $r$ rezultate ale măsurătorilor, fiecare dintre ele fiind $+1$ sau $-1$ (sau o valoare binară dacă alegem să asociem $0$ cu $+1$ și $1$ cu $-1,$ respectiv). Interpretăm cele $r$ rezultate în mod colectiv, ca un vector sau șir de caractere, ca un sindrom. Sindromul $(+1,\ldots,+1)$ indică faptul că nu a fost detectată nicio eroare, în timp ce cel puțin un $-1$ undeva în cadrul sindromului indică faptul că a fost detectată o eroare.

Să presupunem, în particular, că $E$ este o operație Pauli pe $n$ qubiți, reprezentând o eroare ipotetică. (Avem în vedere doar operațiile Pauli ca erori, de altfel, deoarece discretizarea erorilor funcționează la fel pentru codurile Stabilizer arbitrare ca și pentru codul Shor cu 9 qubiți.) Există trei cazuri care determină dacă $E$ este sau nu detectată ca eroare.

Cazuri de detectare a erorilor

1. Operația $E$ este proporțională cu un element din Stabilizer.

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

   În acest caz, $E$ trebuie să comute cu fiecare generator Stabilizer, deci obținem sindromul $(+1,\ldots,+1).$ Aceasta înseamnă că $E$ nu este detectată ca eroare.

2. Operația $E$ nu este proporțională cu un element din Stabilizer, dar comută totuși cu fiecare generator Stabilizer.

   $$E\neq \pm Q\; \text{pentru} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{dar}\; E P_k = P_k E \;\text{pentru orice}\; k\in\{1,\ldots,r\}$$

   Aceasta este o eroare care modifică vectorii din spațiul codului într-un mod netrivial. Dar, deoarece $E$ comută cu fiecare generator Stabilizer, sindromul este $(+1,\ldots,+1),$ deci $E$ trece nedetectată de cod.

3. Operația $E$ anti-comută cu cel puțin unul dintre generatorii Stabilizer.

   $$P_k E = -E P_k \; \text{for at least one} \; k\in\{1,\ldots,r\}$$

   Sindromul este diferit de $(+1,\ldots,+1),$ deci eroarea $E$ este detectată de cod.

În primul caz, eroarea $E$ nu reprezintă o problemă, deoarece această operație nu face nimic vectorilor din spațiul codului, cu excepția faptului că poate injecta o fază globală irelevantă: $E \ket{\psi} = \pm\ket{\psi}$ pentru orice stare codată $\ket{\psi}.$ În esență, aceasta nu este de fapt o eroare — orice acțiune netrivială ar putea avea $E$ are loc în afara spațiului codului — deci este bine că $E$ nu este detectată ca eroare, deoarece nu trebuie făcut nimic în legătură cu ea.

Al doilea caz, vorbind intuitiv, este cazul rău. Anti-comutarea unei erori cu un generator Stabilizer este cea care face să apară un $-1$ undeva în sindrom, semnalând o eroare, dar asta nu se întâmplă în acest caz. Astfel, avem o eroare $E$ care schimbă vectorii din spațiul codului în mod netrivial, dar care trece nedetectată de cod. De exemplu, pentru codul de repetiție pe 3 biți, operația $E = X\otimes X\otimes X$ se încadrează în această categorie.

Faptul că o astfel de eroare $E$ trebuie să schimbe anumiți vectori din spațiul codului în mod netrivial poate fi argumentat după cum urmează. Pe baza ipotezei că $E$ comută cu $P_1,\ldots,P_r$, dar nu este proporțională cu un element Stabilizer, putem concluziona că am obține un nou cod Stabilizer valid incluzând $E$ ca generator Stabilizer alături de $P_1,\ldots,P_r.$ Spațiul codului pentru acest nou cod are însă doar jumătate din dimensiunea spațiului codului original, din care putem concluziona că acțiunea lui $E$ asupra spațiului codului original nu poate fi proporțională cu operația identitate.

Pentru ultimul dintre cele trei cazuri, și anume că eroarea $E$ anti-comută cu cel puțin un generator Stabilizer, sindromul are cel puțin un $-1$ undeva în el, ceea ce indică faptul că ceva este în neregulă. Cum am discutat deja, sindromul nu va identifica în mod unic $E$ în general, deci este totuși necesar să alegi o operație de corecție pentru fiecare sindrom, care poate corecta sau nu eroarea $E.$ Vom discuta acest pas în scurt timp, în ultima parte a lecției.

Distanța unui cod Stabilizer

Ca terminologie, când ne referim la distanța unui cod Stabilizer, înțelegem greutatea minimă a unei operații Pauli $E$ care se încadrează în a doua categorie de mai sus — adică schimbă spațiul codului în mod netrivial, dar codul nu detectează asta. Când se spune că un cod Stabilizer este un cod Stabilizer $[[n,m,d]]$, folosind paranteze pătrate duble, asta înseamnă următoarele:

1. Codificările au lungimea de $n$ qubiți,
2. codul permite codificarea a $m$ qubiți, și
3. distanța codului este $d.$

Ca exemplu, să considerăm codul Steane pe 7 qubiți. Iată generatorii Stabilizer pentru acest cod:

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

Acest cod are distanța 3, și putem argumenta asta după cum urmează.

Mai întâi, consideră orice operație Pauli $E$ cu greutate cel mult 2 și presupune că această operație comută cu toți cei șase generatori Stabilizer. Vom concluziona că $E$ trebuie să fie operația identitate, care (ca întotdeauna) este un element al Stabilizer-ului. Asta va arăta că distanța codului este strict mai mare decât 2. Presupune, în particular, că $E$ are forma

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

pentru $P$ și $Q$ fiind matrice Pauli posibil non-identitate. Acesta este doar un caz, și este necesar să repeți argumentul care urmează pentru toate celelalte locații posibile ale matricelor Pauli non-identitate printre factorii tensoriali ai lui $E,$ dar argumentul este esențialmente același pentru toate locațiile posibile.

Operația $E$ comută cu toți cei șase generatori Stabilizer, deci comută cu acești doi în particular:

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

Factorul tensorial $Q$ din eroarea noastră $E$ se aliniază cu matricea identitate în ambii acești generatori Stabilizer (de aceea au fost selectați). Dat fiind că avem matrice identitate în cele mai din dreapta 5 poziții ale lui $E,$ concluzionăm că $P$ trebuie să comute cu $X$ și $Z,$ altfel $E$ ar anti-comuta cu unul dintre cei doi generatori. Totuși, singura matrice Pauli care comută atât cu $X$ cât și cu $Z$ este matricea identitate, deci $P = \mathbb{I}.$

Știind acum asta, putem alege încă doi generatori Stabilizer care au un $X$ și un $Z$ în a doua poziție din stânga, și tragem o concluzie similară: $Q = \mathbb{I}.$ Prin urmare, $E$ este operația identitate.

Deci, nu există nicio modalitate ca o eroare cu greutate cel mult 2 să treacă nedetectată de acest cod, cu excepția cazului în care eroarea este operația identitate (care se află în Stabilizer și, prin urmare, nu este de fapt o eroare). Pe de altă parte, există operații Pauli de greutate 3 care comută cu toți cei șase generatori Stabilizer, dar nu sunt proporționale cu elemente Stabilizer, cum ar fi $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ și $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z.$ Asta stabilește că acest cod are distanța 3, așa cum s-a afirmat.

Corectarea erorilor

Ultimul subiect de discuție pentru această lecție este corectarea erorilor pentru codurile Stabilizer. Ca de obicei, presupune că avem un cod Stabilizer specificat de generatori Stabilizer pe $n$ qubiți $P_1, \ldots, P_r.$

Operațiile Pauli pe $n$ qubiți, ca erori care ar putea afecta stările codate cu ajutorul acestui cod, sunt împărțite în colecții de dimensiuni egale în funcție de sindromul pe care îl generează. Există $2^r$ sindroame distincte și $4^n$ operații Pauli, ceea ce înseamnă că există $4^n/2^r$ operații Pauli care generează fiecare sindrom. Oricare dintre aceste erori ar putea fi responsabilă pentru sindromul corespunzător.

Totuși, printre cele $4^n/2^r$ operații Pauli care generează fiecare sindrom, există unele care ar trebui considerate echivalente. În particular, dacă produsul a două operații Pauli este proporțional cu un element Stabilizer, atunci cele două operații sunt efectiv echivalente ca erori.

O altă modalitate de a spune asta este că, dacă aplicăm o operație de corecție $C$ pentru a încerca să corectăm o eroare $E,$ atunci această corecție reușește atâta timp cât compoziția $CE$ este proporțională cu un element Stabilizer. Dat fiind că există $2^r$ elemente în Stabilizer, rezultă că fiecare operație de corecție $C$ corectează $2^r$ erori Pauli diferite. Asta lasă $4^{n-r}$ clase inechivalente de operații Pauli, considerate ca erori, care sunt consistente cu fiecare sindrom posibil.

Asta înseamnă că, dacă $n=r$ (caz în care avem un spațiu de cod trivial, unidimensional), nu putem corecta fiecare eroare detectată de un cod Stabilizer. Ceea ce trebuie să facem în schimb este să alegem o singură operație de corecție pentru fiecare sindrom, în speranța de a corecta o singură clasă de erori echivalente care generează acel sindrom.

O strategie naturală pentru a alege ce operație de corecție să efectuezi pentru fiecare sindrom este să alegi operația Pauli de greutate minimă care, ca eroare, generează acel sindrom. Pot exista de fapt mai multe operații care se egalizează pentru eroarea de cea mai mică greutate consistentă cu un sindrom dat, caz în care oricare dintre ele poate fi selectată. Ideea este că operațiile Pauli de greutate mai mică reprezintă explicații mai probabile pentru orice sindrom a fost măsurat. Asta s-ar putea să nu fie cazul pentru unele modele de zgomot, iar o strategie alternativă este să calculezi eroarea cea mai probabilă care generează sindromul dat, pe baza modelului de zgomot ales. Totuși, pentru această lecție, vom păstra lucrurile simple și vom considera doar corecțiile de greutate minimă.

Pentru un cod Stabilizer cu distanța $d,$ această strategie de a alege operația de corecție ca operație Pauli de greutate minimă consistentă cu sindromul măsurat permite întotdeauna corectarea erorilor cu greutate strict mai mică de jumătate din $d,$ sau, cu alte cuvinte, cu greutate cel mult $(d-1)/2.$ Asta arată, de exemplu, că codul Steane pe 7 qubiți poate corecta orice eroare Pauli de greutate unu, și prin discretizarea erorilor, asta înseamnă că codul Steane poate corecta o eroare arbitrară pe un singur Qubit.

Pentru a vedea cum funcționează asta, consideră diagrama de mai jos. Cercul din stânga reprezintă toate operațiile Pauli care produc sindromul $(+1,\ldots,+1),$ care este sindromul ce sugerează că nu au apărut erori și totul este în regulă. Printre aceste operații avem elemente ale Stabilizer-ului (sau operații proporționale cu elemente ale Stabilizer-ului, pentru a fi mai precis) și avem, de asemenea, erori netriviale care schimbă spațiul codului în vreun fel, dar nu sunt detectate de cod. Prin definiția distanței, fiecare operație Pauli din această categorie trebuie să aibă greutatea cel puțin $d,$ deoarece $d$ este definit ca greutatea minimă a acestor operații.

Cercul din dreapta reprezintă operațiile Pauli care produc un sindrom diferit $s\neq(+1,\ldots,+1),$ inclusiv o eroare $E$ cu greutate strict mai mică decât $d/2$ pe care o vom considera.

Operația de corecție $C$ aleasă pentru sindromul $s$ este operația Pauli de greutate minimă din colecția reprezentată de cercul din dreapta din diagramă (sau oricare dintre ele în caz de egalitate). Deci, s-ar putea ca $C = E,$ dar nu neapărat. Ceea ce putem spune cu certitudine, totuși, este că $C$ nu poate avea greutate mai mare decât greutatea lui $E,$ deoarece $C$ are greutate minimă printre operațiile din această colecție — și, prin urmare, $C$ are greutate strict mai mică decât $d/2.$

Consideră acum ce se întâmplă când operația de corecție $C$ este aplicată oricărei stări obținute după ce eroarea $E$ a avut loc. Presupunând că codificarea originală era $\vert\psi\rangle,$ rămânem cu $CE\vert\psi\rangle.$ Scopul nostru va fi să arătăm că $CE$ este proporțional cu un element din Stabilizer, ceea ce implică faptul că corecția este reușită și (cu excepția unei faze globale) rămânem cu starea codată originală $\vert\psi\rangle.$

Mai întâi, deoarece $E$ și $C$ generează același sindrom, compoziția $CE$ trebuie să comute cu fiecare generator Stabilizer. În particular, dacă $P_k$ este oricare dintre generatorii Stabilizer, atunci trebuie să avem

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

pentru aceeași valoare a lui $\alpha\in\{+1,-1\},$ deoarece acesta este intrarea $k$ în sindromul $s$ pe care atât $C$ cât și $E$ îl generează. Prin urmare, avem

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

deci $P_k$ comută cu $CE.$ Am demonstrat astfel că $CE$ aparține cercului din stânga din diagramă, deoarece generează sindromul $(+1,\ldots,+1).$

În al doilea rând, compoziția $CE$ trebuie să aibă greutate cel mult egală cu suma greutăților lui $C$ și $E$ — ceea ce rezultă dintr-o clipă de gândire despre produse de operații Pauli — și, prin urmare, greutatea lui $CE$ este strict mai mică decât $d.$ Asta implică faptul că $CE$ este proporțional cu un element din Stabilizer-ul codului nostru, ceea ce am vrut să demonstrăm. Alegând operațiile noastre de corecție ca reprezentanți de greutate minimă ai mulțimii de erori care generează fiecare sindrom, suntem astfel garantați să corectăm orice erori Pauli cu greutate mai mică de jumătate din distanța codului.

Există totuși o problemă. Pentru codurile Stabilizer în general, calcularea operației Pauli de greutate minimă care generează un sindrom dat este o problemă dificilă din punct de vedere computațional. (Într-adevăr, asta este valabil chiar și pentru codurile clasice, pe care în acest context le putem gândi ca coduri Stabilizer în care apar doar matrice $\mathbb{I}$ și $Z$ ca factori tensoriali în cadrul generatorilor Stabilizer.) Deci, spre deosebire de etapa de codificare, operațiile Clifford nu ne vor ajuta de data aceasta.

Soluția este să alegi coduri specifice pentru care corecțiile bune pot fi calculate eficient, pentru care nu există o rețetă simplă. Pur și simplu, conceperea codurilor Stabilizer pentru care operațiile de corecție bune pot fi calculate eficient face parte din arta designului codurilor cuantice.