Mga stabilizer code

Ngayon ay tukuyin natin ang mga stabilizer code sa pangkalahatan. Tatalakayin din natin ang ilan sa kanilang mga pangunahing katangian at kung paano sila gumagana, kasama na kung paano ma-encode ang mga estado at kung paano natutuklas at naitatama ang mga error gamit ang mga code na ito.

Kahulugan ng mga stabilizer code

Ang isang $n$-qubit stabilizer code ay tinutukoy ng isang listahan ng $n$-qubit na mga Pauli operation, $P_1,\ldots,P_r.$ Ang mga operation na ito ay tinatawag na mga stabilizer generator sa kontekstong ito, at dapat nilang matugunan ang sumusunod na tatlong katangian.

1. Ang lahat ng stabilizer generator ay commute sa isa't isa.

   $$P_j P_k = P_k P_j \qquad \text{(para sa lahat ng $j,k\in\{1,\ldots,r\}$)}$$

2. Ang mga stabilizer generator ay bumubuo ng isang minimal generating set.

   $$P_k \notin \langle P_1,\ldots,P_{k-1},P_{k+1},\ldots,P_r\rangle \qquad \text{(para sa lahat ng $k\in\{1,\ldots,r\}$)}$$

3. May hindi bababa sa isang quantum state vector na naayos ng lahat ng stabilizer generator.

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

   (Hindi agad malinaw na ang pag-iral ng isang quantum state vector na $\vert\psi\rangle$ na naayos ng lahat ng stabilizer generator, ibig sabihin $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle,$ ay katumbas ng $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle,$ ngunit totoong ganito ang kaso, at makikita natin kung bakit sa bandang huli ng aralin.)

Kung mayroon tayong ganoong listahan na $P_1,\ldots,P_r,$ ang code space na tinukoy ng mga stabilizer generator na ito ay ang subspace na $\mathcal{C}$ na naglalaman ng bawat $n$-qubit quantum state vector na naayos ng lahat ng $r$ na stabilizer generator na ito.

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

Ang mga quantum state vector sa subspace na ito ay eksakto ang mga maaaring ituring bilang mga wastong encoding ng mga quantum estado. Tatalakayin natin ang aktwal na proseso ng pag-encode sa bandang huli.

Sa wakas, ang stabilizer ng code na tinukoy ng mga stabilizer generator na $P_1, \ldots, P_r$ ay ang set na binuo ng mga operation na ito:

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

Ang natural na paraan upang isipin ang isang stabilizer code ay ang tingnan ang mga stabilizer generator bilang mga observable, at kolektibong bigyang-kahulugan ang mga resulta ng mga sukat na nauugnay sa mga observable na ito bilang isang error syndrome. Ang mga wastong encoding ay $n$-qubit quantum state vector kung saan ang mga resulta ng sukat, bilang mga eigenvalue, ay garantisadong $+1$ lahat. Ang anumang iba pang syndrome, kung saan may kahit isang $-1$ na resulta ng sukat, ay nagpapahiwatig na natuklas ang isang error.

Titingnan natin ang ilang halimbawa sa lalong madaling panahon, ngunit una ay ilang komento tungkol sa tatlong kondisyon sa mga stabilizer generator ang nararapat.

Ang unang kondisyon ay natural, sa liwanag ng interpretasyon ng mga stabilizer generator bilang mga observable, dahil ipinahihiwatig nito na hindi mahalaga kung sa anong pagkakasunod-sunod ginaganap ang mga sukat: ang mga observable ay commute, kaya ang mga sukat ay commute rin. Ang ito ay natural na nagpapataw ng ilang algebraic na hadlang sa mga stabilizer code na mahalaga sa kung paano sila gumagana.

Ang pangalawang kondisyon ay nangangailangan na ang mga stabilizer generator ay bumubuo ng isang minimal generating set, ibig sabihin, ang pag-aalis ng kahit isa sa kanila ay magreresulta sa isang mas maliit na stabilizer. Sa mahigpit na pagsasalita, ang kondisyong ito ay hindi talagang mahalaga sa paraan ng paggana ng mga stabilizer code sa isang operasyonal na kahulugan — at, tulad ng makikita natin sa susunod na aralin, minsan ay may saysay na pag-isipan ang mga set ng stabilizer generator para sa mga code na hindi aktwal na natutugunan ang kondisyong ito. Para sa kapakanan ng pagsusuri ng mga stabilizer code at pagpapaliwanag ng kanilang mga katangian, gayunpaman, ipagpapalagay natin na ang kondisyong ito ay nasa lugar. Sa madaling salita, tinitiyak ng kondisyong ito na ang bawat observable na sinusukat natin upang makuha ang error syndrome ay nagdadagdag ng impormasyon tungkol sa mga posibleng error, sa halip na maging redundante at gumagawa ng mga resulta na maaaring mahiwatig mula sa iba pang mga sukat ng stabilizer generator.

Ang ikatlong kondisyon ay nangangailangan na hindi bababa sa isang nonzero na vector ay naayos ng lahat ng stabilizer generator, na katumbas ng $-\mathbb{I}^{\otimes n}$ na hindi nakapaloob sa stabilizer. Ang pangangailangan para sa kondisyong ito ay nagmumula sa katotohanang posible talaga ang pumili ng isang minimal generating set ng $n$-qubit na mga Pauli operation na lahat ay commute sa isa't isa, gayunpaman walang nonzero na vector ang naayos ng bawat isa sa mga operation. Hindi tayo interesado sa mga "code" na walang wastong encoding, kaya itinatanggal natin ang posibilidad na ito sa pamamagitan ng pag-aatas ng kondisyong ito bilang bahagi ng kahulugan.

Mga halimbawa

Narito ang ilang halimbawa ng mga stabilizer code para sa maliliit na halaga ng $n.$ Makikita natin ang higit pang mga halimbawa, kasama na ang mga kung saan ang $n$ ay maaaring mas malaki, sa susunod na aralin.

3-bit repetition code

Ang 3-bit repetition code ay isang halimbawa ng isang stabilizer code, kung saan ang ating mga stabilizer generator ay $Z \otimes Z \otimes \mathbb{I}$ at $\mathbb{I} \otimes Z \otimes Z.$

Madali nating masusuri na ang dalawang stabilizer generator na ito ay natutugunan ang mga kinakailangang kondisyon. Una, ang dalawang stabilizer generator na $Z \otimes Z \otimes \mathbb{I}$ at $\mathbb{I} \otimes Z \otimes Z$ ay commute sa isa't isa.

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

Pangalawa, mayroon tayong minimal generating set (medyo maliwanag sa kasong ito).

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

At pangatlo, alam na natin na ang $\vert 000\rangle$ at $\vert 111\rangle,$ pati na rin ang anumang linear na kombinasyon ng mga vector na ito, ay naayos ng parehong $Z \otimes Z \otimes \mathbb{I}$ at $\mathbb{I} \otimes Z \otimes Z.$ Bilang alternatibo, maaari nating tapusin ito gamit ang katumbas na kondisyon mula sa kahulugan.

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

Ang mga kondisyong ito ay maaaring maging mas mahirap suriin para sa mas kumplikadong mga stabilizer code.

Binagong 3-bit repetition code

Sa nakaraang aralin, nakita natin na posible ang baguhin ang 3-bit repetition code upang maprotektahan laban sa mga phase-flip error sa halip na mga bit-flip error. Bilang isang stabilizer code, ang bagong code na ito ay madaling ilarawan: ang mga stabilizer generator nito ay $X \otimes X \otimes \mathbb{I}$ at $\mathbb{I} \otimes X \otimes X.$

Sa pagkakataong ito ang mga stabilizer generator ay kumakatawan sa mga $X\otimes X$ observable sa halip na mga $Z\otimes Z$ observable, kaya sila ay mahalagang mga parity check sa plus/minus basis sa halip na sa standard basis. Ang tatlong kinakailangang kondisyon sa mga stabilizer generator ay madaling mapatunayan, sa katulad na paraan tulad ng sa ordinaryong 3-bit repetition code.

9-qubit Shor code

Narito ang 9-qubit Shor code, na isa ring stabilizer code, na ipinahahayag ng mga stabilizer generator.

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

Sa kasong ito, mayroon tayong tatlong kopya ng 3-bit repetition code, isa para sa bawat isa sa tatlong bloke ng tatlong qubit, pati na rin ang huling dalawang stabilizer generator, na may hugis na kapareho ng Circuit para sa pag-detect ng mga phase flip para sa code na ito.

Ang alternatibong paraan upang pag-isipan ang huling dalawang stabilizer generator ay na sila ay may parehong hugis tulad ng para sa 3-bit repetition code para sa mga phase flip, maliban na ang $X\otimes X\otimes X$ ay kapalit ng $X,$ na naaayon sa katotohanang ang $X\otimes X\otimes X$ ay tumutugma sa isang $X$ na operation sa mga logical qubit na na-encode gamit ang 3-bit repetition code.

Bago tayo lumipat sa iba pang mga halimbawa, dapat tandaan na ang mga tensor product symbol ay madalas na inalis kapag inilalarawan ang mga stabilizer code sa pamamagitan ng mga listahan ng stabilizer generator, dahil ito ay karaniwang nagpapagaan ng pagbabasa at pagkita ng kanilang mga pattern. Halimbawa, ang mga parehong stabilizer generator tulad ng nasa itaas para sa 9-qubit Shor code ay ganito ang hitsura nang hindi isinusulat nang malinaw ang mga tensor product symbol.

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

7-qubit Steane code

Narito ang isa pang halimbawa ng isang stabilizer code, na kilala bilang 7-qubit Steane code. Mayroon itong ilang kapansin-pansing katangian, at babalik tayo sa code na ito paminsan-minsan sa natitirang mga aralin ng kurso.

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

Sa ngayon, obserbahan lamang natin na ito ay isang wastong stabilizer code. Malinaw na nag-commute ang unang tatlong stabilizer generator sa isa't isa, dahil ang $Z$ ay nag-commute sa sarili nito at ang identity ay nag-commute sa lahat, at katulad ang sitwasyon para sa huling tatlong stabilizer generator. Nananatili pang suriin na kung kukuha tayo ng isa sa mga $Z$-stabilizer generator (ibig sabihin, isa sa mga unang tatlo) at isa sa mga $X$-stabilizer generator (ibig sabihin, isa sa mga huling tatlo), ang dalawang generator na ito ay nag-commute, at maaaring suriin ang 9 na posibleng pares upang patunayan iyon. Sa lahat ng kasong ito, ang isang $X$ at isang $Z$ na Pauli matrix ay palaging nakahanay sa parehong posisyon nang pantay na bilang ng beses, kaya ang dalawang generator ay mag-co-commute, tulad ng $X\otimes X$ at $Z\otimes Z$ na nag-commute. Ito rin ay isang minimal generating set, at nagtatakda ito ng isang nontrivial na code space, na mga katotohanang iniiwan sa inyo upang pag-isipan.

Ang 7-qubit Steane code ay katulad ng 9-qubit Shor code sa na ini-encode nito ang isang solong qubit at nagpapahintulot ng pagwawasto ng isang arbitrary na error sa isang qubit, ngunit nangangailangan lamang ito ng 7 qubit sa halip na 9.

5-qubit code

Pitong ay hindi ang pinakamaliit na bilang ng mga qubit na kinakailangan upang mag-encode ng isang qubit at maprotektahan ito laban sa isang arbitrary na error sa isang qubit — narito ang isang stabilizer code na ginagawa ito gamit lamang ang 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}$$

Ang code na ito ay karaniwang tinatawag na ang 5-qubit code. Ito ang pinakamaliit na bilang ng mga qubit sa isang quantum error correcting code na maaaring magpahintulot ng pagwawasto ng isang arbitrary na single-qubit error.

Mga one-dimensional na stabilizer code

Narito ang isa pang halimbawa ng isang stabilizer code, kahit na hindi ito aktwal na nag-e-encode ng anumang qubit: ang code space ay one-dimensional. Gayunpaman, ito ay isang wastong stabilizer code pa rin ayon sa kahulugan.

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

Sa partikular, ang code space ay ang one-dimensional na espasyo na isinasaklaw ng isang e-bit na $\vert\phi^+\rangle.$

Narito ang isang kaugnay na halimbawa ng isang stabilizer code na ang code space ay ang one-dimensional na espasyo na isinasaklaw ng isang GHZ state na $(\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}$$

Dimensyon ng code space

Ipagpalagay na mayroon tayong isang stabilizer code, na inilalarawan ng $n$-qubit na mga stabilizer generator na $P_1,\ldots,P_r.$ Marahil ang pinaka-unang tanong na pumapasok sa isip tungkol sa code na ito ay, "Ilang qubit ang ini-encode nito?"

Ang tanong na ito ay may simpleng sagot. Kung ipinapalagay na ang $n$-qubit na mga stabilizer generator na $P_1, \ldots, P_r$ ay natutugunan ang tatlong kinakailangan ng kahulugan (ibig sabihin, ang lahat ng stabilizer generator ay nag-commute sa isa't isa, ito ay isang minimal generating set, at ang code space ay hindi walang laman), dapat na ang code space para sa stabilizer code na ito ay may dimensyong $2^{n-r},$ kaya ang $n-r$ na mga qubit ay maaaring ma-encode gamit ang code na ito.

Sa intuitive na pagsasalita, mayroon tayong $n$ na qubit upang gamitin para sa encoding na ito, at ang bawat stabilizer generator ay epektibong "nag-aalis ng isang qubit" sa mga tuntunin ng kung ilang qubit ang maaari nating i-encode. Tandaan na hindi ito tungkol sa kung aling o gaano karaming mga error ang maaaring matuklas o maiwasto, ito ay isang pahayag lamang tungkol sa dimensyon ng code space.

Halimbawa, para sa parehong 3-bit repetition code at ang binagong bersyon ng code na iyon para sa mga phase-flip error, mayroon tayong $n=3$ na qubit at $r=2$ na stabilizer generator, at samakatuwid ang mga code na ito ay bawat isa ay maaaring mag-encode ng 1 qubit. Para sa isa pang halimbawa, isaalang-alang ang 5-qubit code: mayroon tayong 5 qubit at 4 na stabilizer generator, kaya muli ang code space ay may dimensyon 2, ibig sabihin, ang isang qubit ay maaaring ma-encode gamit ang code na ito. Para sa isang huling halimbawa, ang code na ang mga stabilizer generator ay $X\otimes X$ at $Z\otimes Z$ ay may one-dimensional na code space, na isinasaklaw ng estado na $\vert\phi^+\rangle,$ na naaayon sa pagkakaroon ng $n=2$ na qubit at $r=2$ na stabilizer generator.

Ngayon tingnan natin kung paano mapapatunayan ang katotohanang ito. Ang unang hakbang ay obserbahan na, dahil nag-commute ang mga stabilizer generator, at dahil ang bawat Pauli operation ay ang sariling inverse nito, ang bawat elemento sa stabilizer ay maaaring ipahayag bilang isang produkto

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

kung saan ang $a_1,\ldots,a_r\in\{0,1\}.$ Katumbas nito, ang bawat elemento ng stabilizer ay nakuha sa pamamagitan ng pagpaparami ng ilang subset ng mga stabilizer generator. Sa katunayan, ang bawat elemento ng stabilizer ay maaaring ipahayag nang natatangi sa ganitong paraan, dahil sa kondisyon na ang $\{P_1,\ldots,P_r\}$ ay isang minimal generating set.

Susunod, tukuyin ang $\Pi_k$ bilang ang projection patungo sa espasyo ng mga $+1$-eigenvector ng $P_k,$ para sa bawat $k\in\{1,\ldots,r\}.$ Ang mga projection na ito ay maaaring makuha sa pamamagitan ng pag-average ng mga kaukulang Pauli operation kasama ang identity operation tulad ng sumusunod.

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

Ang code space na $\mathcal{C}$ ay ang subspace ng lahat ng vector na naayos ng lahat ng $r$ na stabilizer generator na $P_1,\ldots,P_r,$ o katumbas nito, lahat ng $r$ na projection na $\Pi_1,\ldots,\Pi_r.$

Dahil ang lahat ng stabilizer generator ay nag-commute sa isa't isa, ang mga projection na $\Pi_1,\ldots,\Pi_r$ ay dapat ding nag-commute. Nagbibigay-daan ito sa atin na gumamit ng isang katotohanan mula sa linear algebra, na ang produkto ng mga projection na ito ay ang projection patungo sa interseksyon ng mga subspace na tumutugma sa mga indibidwal na projection. Ibig sabihin, ang produkto na $\Pi_1\cdots\Pi_r$ ay ang projection patungo sa code space na $\mathcal{C}.$

Maaari na nating palawakin ang produkto na $\Pi_1\cdots\Pi_r$ gamit ang mga formula para sa mga projection na ito upang makuha ang sumusunod na ekspresyon.

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

Sa madaling salita, ang projection patungo sa code space ng isang stabilizer code ay katumbas, bilang isang matrix, sa average sa lahat ng mga elemento sa stabilizer ng code na iyon.

Sa wakas, maaari nating kalkulahin ang dimensyon ng code space sa pamamagitan ng paggamit ng katotohanang ang dimensyon ng anumang subspace ay katumbas ng trace ng projection patungo sa subspace na iyon. Kaya, ang dimensyon ng code space na $\mathcal{C}$ ay ibinibigay ng sumusunod na 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})$$

Maaari nating suriin ang ekspresyong ito sa pamamagitan ng paggamit ng ilang pangunahing katotohanan.

• Mayroon tayong $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ at samakatuwid

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

• Para sa $(a_1,\ldots,a_r) \neq (0,\ldots,0),$ ang produkto na $P_1^{a_1}\cdots P_r^{a_r}$ ay dapat na $\pm 1$ beses ng isang Pauli operation — ngunit hindi tayo makakakuha ng $\mathbb{I}^{\otimes n}$ dahil ito ay magsasalungat sa minimalidad ng set na $\{P_1,\ldots,P_r\},$ at hindi tayo makakakuha ng $-\mathbb{I}^{\otimes n}$ dahil ipinagbabawal ito ng ikatlong kondisyon sa mga stabilizer generator. Samakatuwid, dahil ang trace ng bawat non-identity na Pauli operation ay zero, nakukuha natin

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

Ang dimensyon ng code space ay samakatuwid ay $2^{n-r}$ tulad ng sinabi:

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

Bilang karagdagan, makikita natin ngayon na ang pagpapalagay na ang $-\mathbb{I}^{\otimes n}$ ay hindi nakapaloob sa stabilizer ay nagpapahiwatig na ang code space ay dapat maglaman ng hindi bababa sa isang quantum state vector. Ito ay dahil, tulad ng napatunayan natin, ang pagpapalagay na ito ay nagpapahiwatig na ang code space ay may dimensyong $2^{n-r},$ na hindi maaaring maging zero. Ang kabaligtaran na implikasyon ay nangyayaring magiging trivial: kung ang $-\mathbb{I}^{\otimes n}$ ay nakapaloob sa stabilizer, ang code space ay hindi maaaring maglaman ng anumang quantum state vector, dahil walang nonzero na vector ang naayos ng operation na ito.

Mga Clifford na Operasyon at Encoding

Susunod, tatalakayin natin nang maikli kung paano naka-encode ang mga qubit gamit ang mga stabilizer code, pero para magawa iyon, kailangan muna nating ipakilala ang mga Clifford na operasyon.

Mga Clifford na Operasyon

Ang mga Clifford na operasyon ay mga unitary na operasyon, sa anumang bilang ng mga qubit, na maaaring ipatupad sa pamamagitan ng mga quantum circuit na gumagamit ng limitadong hanay ng mga Gate:

• Mga Hadamard gate
• Mga $S$ gate
• Mga CNOT gate

Pansinin na hindi kasama ang mga $T$ gate, ni ang mga Toffoli gate at Fredkin gate. Hindi lamang hindi sila kasama sa listahan — sa katunayan, hindi posibleng ipatupad ang mga gate na iyon gamit ang mga nakalistang dito; hindi sila mga Clifford na operasyon. Ang mga Pauli na operasyon naman ay mga Clifford na operasyon dahil maaari itong ipatupad gamit ang mga pagkakasunud-sunod ng Hadamard at $S$ gate.

Iyon ay isang simpleng paraan para tukuyin ang mga Clifford na operasyon, ngunit hindi nito ipinapaliwanag kung bakit ganito ang kanilang kahulugan o ano ang espesyal sa partikular na koleksyong ito ng mga gate. Ang tunay na dahilan kung bakit ganito ang kahulugan ng mga Clifford na operasyon ay ang mga ito, hanggang sa mga pandaigdigang phase factor, ay tiyak na ang mga unitary na operasyon na palaging nagko-conjugate ng mga Pauli na operasyon at nagreresulta sa mga Pauli na operasyon. Para maging mas tiyak, ang isang $n$-qubit na unitary na operasyon $U$ ay katumbas ng isang Clifford na operasyon hanggang sa isang phase factor kung, at kung lamang, para sa bawat $n$-qubit na Pauli na operasyon $P,$ mayroon tayong

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

para sa ilang $n$-qubit na Pauli na operasyon $Q.$

(Pansinin na hindi posible na magkaroon ng $U P U^{\dagger} = \alpha Q$ para sa $\alpha\notin\{+1,-1\}$ kapag ang $U$ ay unitary at ang $P$ at $Q$ ay mga Pauli na operasyon. Sumusunod ito mula sa katotohanang ang matrix sa kaliwang bahagi ng equation ay parehong unitary at Hermitian, at ang $+1$ at $-1$ ang tanging mga pagpipilian para sa $\alpha$ na nagpapahintulot sa kanang bahagi na maging unitary at Hermitian din.)

Madaling i-verify ang conjugation property na ito kapag ang $U$ ay isang Hadamard, $S,$ o CNOT gate. Sa partikular, madali ito para sa mga Hadamard gate,

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

at mga $S$ gate,

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

Para sa mga CNOT gate, may 15 na di-pagkakakilanlan na Pauli na operasyon sa dalawang qubit na kailangang suriin. Natural, maaari silang suriin nang isa-isa — ngunit ang mga relasyon sa pagitan ng mga CNOT gate at mga $X$ at $Z$ gate na nakalista (sa anyo ng circuit) sa nakaraang aralin, kasama ang mga patakaran sa pagpaparami ng mga Pauli matrix, ay nag-aalok ng shortcut patungo sa parehong konklusyon.

Kapag nalaman na natin na ang conjugation property na ito ay totoo para sa mga Hadamard, $S,$ at CNOT gate, maaari tayong agad na magsimulang tapusin na ito ay totoo para sa mga circuit na binubuo ng mga gate na ito — ibig sabihin, lahat ng Clifford na operasyon.

Mas mahirap patunayan na ang relasyon ay gumagana sa kabilang direksyon, na kung ang isang ibinigay na unitary na operasyon $U$ ay nakakatugon sa conjugation property para sa mga Pauli na operasyon, kailangang posibleng ipatupad ito (hanggang sa isang global phase) gamit lamang ang Hadamard, $S,$ at CNOT gate. Hindi ito ipapaliwanag sa araling ito, ngunit totoo ito.

Ang mga Clifford na operasyon ay hindi universal para sa quantum computation; hindi tulad ng mga universal na hanay ng quantum gate, hindi posible ang pag-aapproximate ng mga arbitrary na unitary na operasyon sa anumang nais na antas ng katumpakan gamit ang mga Clifford na operasyon. Sa katunayan, para sa isang ibinigay na halaga ng $n,$ may limitadong bilang lamang ng mga $n$-qubit na Clifford na operasyon (hanggang sa mga phase factor). Ang pagsasagawa ng mga Clifford na operasyon sa mga standard basis state na sinusundan ng mga standard basis measurement ay hindi rin nagbibigay-daan sa atin na magsagawa ng mga computation na wala sa abot ng mga klasikal na algorithm — dahil maaari tayong mahusay na mag-simulate ng mga computation na ganito nang klasikal. Ang katotohanang ito ay kilala bilang Gottesman-Knill theorem.

Mga Encoder para sa mga Stabilizer Code

Ang isang stabilizer code ay nagtatakda ng code space na may tiyak na dimensyon, at mayroon tayong kalayaang gamitin ang code space na iyon ayon sa ating kagustuhan — walang pumipigil sa atin na i-encode ang mga qubit sa code space na ito sa isang tiyak na paraan. Palagi itong posible, gayunpaman, na gumamit ng Clifford na operasyon bilang encoder, kung pipiliin nating gawin iyon. Para maging mas tiyak, para sa anumang stabilizer code na nagbibigay-daan sa pag-encode ng $m$ na qubit sa $n$ na qubit, may isang $n$-qubit na Clifford na operasyon $U$ na, para sa anumang $m$-qubit na quantum state vector $\vert\phi\rangle,$ mayroon tayong

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

na isang quantum state vector sa code space ng ating code na maaari nating interpretahin bilang encoding ng $\vert\phi\rangle.$

Ito ay maganda dahil ang mga Clifford na operasyon ay medyo simple, kumpara sa mga arbitrary na unitary na operasyon, at may mga paraan para i-optimize ang kanilang implementasyon gamit ang mga teknik na katulad ng mga makikita sa patunay ng Gottesman-Knill theorem. Bilang resulta, ang mga circuit para sa pag-encode ng mga state gamit ang mga stabilizer code ay hindi kailangang maging masyadong malaki. Sa partikular, palaging posible na magsagawa ng encoding para sa isang $n$-qubit na stabilizer code gamit ang isang Clifford na operasyon na nangangailangan ng $O(n^2/\log(n))$ gate. Ito ay dahil ang bawat Clifford na operasyon sa $n$ na qubit ay maaaring ipatupad ng isang circuit na may sukat na ito.

Halimbawa, narito ang isang encoder para sa 7-qubit Steane code. Ito ay talagang isang Clifford na operasyon, at gaya ng lumalabas, ang isa na ito ay hindi na kailangan pang ng mga $S$ gate.

Pagde-detect ng mga Error

Para sa isang $n$-qubit na stabilizer code na inilalarawan ng mga stabilizer generator na $P_1,\ldots, P_r,$ ang pag-detect ng error ay gumagana sa sumusunod na paraan.

Para ma-detect ang mga error, lahat ng stabilizer generator ay sinusukat bilang mga observable. Mayroon $r$ na stabilizer generator, at samakatuwid $r$ na kinalabasan ng pagsukat, bawat isa ay $+1$ o $-1$ (o isang binary na halaga kung pipiliin nating iugnay ang $0$ sa $+1$ at $1$ sa $-1,$ ayon sa pagkakasunud-sunod). Itinuturing natin ang $r$ na kinalabasan nang magkasama, bilang isang vector o string, bilang isang syndrome. Ang syndrome na $(+1,\ldots,+1)$ ay nagpapahiwatig na walang nadetektang error, habang ang kahit isang $-1$ sa loob ng syndrome ay nagpapahiwatig na may nadetektang error.

Ipagpalagay, sa partikular, na ang $E$ ay isang $n$-qubit na Pauli na operasyon, na kumakatawan sa isang hypothetical na error. (Isinasaalang-alang lamang natin ang mga Pauli na operasyon bilang mga error, sa pamamagitan ng paraan, dahil ang discretization ng mga error ay gumagana sa parehong paraan para sa mga arbitrary na stabilizer code tulad ng para sa 9-qubit Shor code.) May tatlong kaso na nagtatakda kung nadetektahan ang $E$ bilang isang error o hindi.

Mga Kaso sa Pag-detect ng Error

1. Ang operasyon $E$ ay proporsyonal sa isang elemento sa stabilizer.

   $$E = \pm Q \; \text{para sa ilang}\; Q \in \langle P_1,\ldots,P_r\rangle$$

   Sa kasong ito, ang $E$ ay kailangang mag-commute sa bawat stabilizer generator, kaya makukuha natin ang syndrome na $(+1,\ldots,+1).$ Nangangahulugan ito na ang $E$ ay hindi nadetektahan bilang isang error.

2. Ang operasyon $E$ ay hindi proporsyonal sa isang elemento sa stabilizer, ngunit nagko-commute pa rin ito sa bawat stabilizer generator.

   $$E\neq \pm Q\; \text{para sa} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{ngunit}\; E P_k = P_k E \;\text{para sa bawat}\; k\in\{1,\ldots,r\}$$

   Ito ay isang error na nagbabago ng mga vector sa code space sa ilang di-trivial na paraan. Ngunit, dahil ang $E$ ay nagko-commute sa bawat stabilizer generator, ang syndrome ay $(+1,\ldots,+1),$ kaya ang $E$ ay hindi nadetektahan ng code.

3. Ang operasyon $E$ ay nag-anti-commute sa kahit isa sa mga stabilizer generator.

   $$P_k E = -E P_k \; \text{para sa kahit isa} \; k\in\{1,\ldots,r\}$$

   Ang syndrome ay iba sa $(+1,\ldots,+1),$ kaya ang error $E$ ay nadetektahan ng code.

Sa unang kaso, ang error $E$ ay hindi isang alalahanin dahil ang operasyong ito ay walang ginagawa sa mga vector sa code space, maliban sa posibleng mag-inject ng isang hindi-kaugnay na global phase: $E \ket{\psi} = \pm\ket{\psi}$ para sa bawat naka-encode na state na $\ket{\psi}.$ Sa esensya, hindi ito tunay na isang error — anumang di-trivial na aksyon ng $E$ ay nangyayari sa labas ng code space — kaya maganda na ang $E$ ay hindi nadetektahan bilang isang error, dahil wala namang kailangang gawin tungkol dito.

Ang ikalawang kaso, sa intuitive na pagsasalita, ay ang masamang kaso. Ito ay ang anti-commutation ng isang error sa isang stabilizer generator na nagdudulot ng $-1$ na lumabas sa isang lugar sa syndrome, na nagpapahiwatig ng isang error, ngunit hindi iyon nangyayari sa kasong ito. Kaya, mayroon tayong error $E$ na nagbabago ng mga vector sa code space sa ilang di-trivial na paraan, ngunit ito ay hindi nadetektahan ng code. Halimbawa, para sa 3-bit repetition code, ang operasyon $E = X\otimes X\otimes X$ ay napapabilang sa kategoryang ito.

Ang katotohanan na ang ganitong error na $E$ ay kailangang magbago ng ilang vector sa code space sa isang di-trivial na paraan ay maaaring ipangalandakan tulad nito. Sa pamamagitan ng pagpapalagay na ang $E$ ay nagko-commute sa $P_1,\ldots,P_r$ ngunit hindi proporsyonal sa isang stabilizer element, maaari tayong magsimulang tapusin na makakakuha tayo ng isang bago, valid na stabilizer code sa pamamagitan ng pagsasama ng $E$ bilang isang stabilizer generator kasama ang $P_1,\ldots,P_r.$ Ang code space para sa bagong code na ito, gayunpaman, ay may kalahating dimensyon lamang ng orihinal na code space, mula sa kung saan maaari tayong magsimulang tapusin na ang aksyon ng $E$ sa orihinal na code space ay hindi maaaring proporsyonal sa identity na operasyon.

Para sa huli sa tatlong kaso, na ang error $E$ ay nag-anti-commute sa kahit isa sa mga stabilizer generator, ang syndrome ay may kahit isang $-1$ sa isang lugar dito, na nagpapahiwatig na may mali. Tulad ng napag-usapan na natin, ang syndrome ay hindi natatanging nagtatukoy sa $E$ sa pangkalahatan, kaya kinakailangan pa ring pumili ng correction operation para sa bawat syndrome, na maaaring o hindi makakatama sa error $E.$ Tatalakayin natin ang hakbang na ito sa lalong madaling panahon, sa huling bahagi ng aralin.

Distansya ng isang Stabilizer Code

Bilang isang punto ng terminolohiya, kapag tinutukoy natin ang distansya ng isang stabilizer code, ang ibig sabihin natin ay ang pinakamababang weight ng isang Pauli na operasyon $E$ na napapabilang sa ikalawang kategorya sa itaas — ibig sabihin, nagbabago ito ng code space sa ilang di-trivial na paraan, ngunit hindi ito nadetektahan ng code. Kapag sinasabing ang isang stabilizer code ay isang $[[n,m,d]]$ na stabilizer code, gamit ang double square brackets, nangangahulugan ito ng sumusunod:

1. Ang mga encoding ay may haba na $n$ na qubit,
2. pinapahintulutan ng code ang pag-encode ng $m$ na qubit, at
3. ang distansya ng code ay $d.$

Bilang halimbawa, isaalang-alang natin ang 7-qubit Steane code. Narito ang mga stabilizer generator para sa code na ito:

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

Ang code na ito ay may distansyang 3, at maaari nating ipangalandakan ito tulad nito.

Una, isaalang-alang ang anumang Pauli na operasyon $E$ na may weight na hindi hihigit sa 2, at ipagpalagay na nagko-commute ang operasyong ito sa lahat ng anim na stabilizer generator. Magsisimula tayong tapusin na ang $E$ ay kailangang maging identity na operasyon, na (tulad ng palagi) ay isang elemento ng stabilizer. Ipapakita nito na ang distansya ng code ay higit sa 2 nang mahigpit. Ipagpalagay, sa partikular, na ang $E$ ay may anyo

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

para sa $P$ at $Q$ na posibleng di-identity na Pauli matrix. Ito ay isang kaso lamang, at kinakailangang ulitin ang argumento na sumusunod para sa lahat ng iba pang posibleng lokasyon para sa mga di-identity na Pauli matrix sa mga tensor factor ng $E,$ ngunit ang argumento ay halos kapareho para sa lahat ng posibleng lokasyon.

Ang operasyon $E$ ay nagko-commute sa lahat ng anim na stabilizer generator, kaya nagko-commute ito sa dalawang ito sa partikular:

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

Ang tensor factor na $Q$ sa ating error na $E$ ay naka-linya sa identity matrix sa parehong stabilizer generator (kaya naman sila napili). Dahil mayroon tayong mga identity matrix sa pinakakanan na 5 posisyon ng $E,$ magsisimula tayong tapusin na ang $P$ ay kailangang mag-commute sa $X$ at $Z,$ dahil kung hindi, ang $E$ ay mag-anti-commute sa isa sa dalawang generator. Gayunpaman, ang tanging Pauli matrix na nagko-commute sa parehong $X$ at $Z$ ay ang identity matrix, kaya $P = \mathbb{I}.$

Ngayon na alam na natin ito, maaari tayong pumili ng dalawa pang stabilizer generator na may $X$ at $Z$ sa ikalawang posisyon mula sa kaliwa, at makakakuha tayo ng katulad na konklusyon: $Q = \mathbb{I}.$ Samakatuwid, ang $E$ ay ang identity na operasyon.

Kaya, walang paraan para ang isang error na may weight na hindi hihigit sa 2 ay hindi madetektahan ng code na ito, maliban kung ang error ay ang identity na operasyon (na nasa stabilizer at samakatuwid ay hindi tunay na isang error). Sa kabilang banda, mayroon mga weight 3 na Pauli na operasyon na nagko-commute sa lahat ng anim na stabilizer generator na ito, ngunit hindi proporsyonal sa mga stabilizer element, tulad ng $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ at $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z.$ Pinapatunayan nito na ang code na ito ay may distansyang 3, gaya ng sinabi.

Pagwawasto ng mga Error

Ang huling paksa ng talakayan para sa araling ito ay ang pagwawasto ng mga error para sa mga stabilizer code. Tulad ng dati, ipagpalagay na mayroon tayong stabilizer code na tinukoy ng n-qubit na stabilizer generator na $P_1, \ldots, P_r.$

Ang mga $n$-qubit na Pauli na operasyon, bilang mga error na maaaring makaapekto sa mga state na naka-encode gamit ang code na ito, ay nahahati sa mga pantay na laking koleksyon ayon sa kung aling syndrome ang kanilang naisasanhi. Mayroon $2^r$ na natatanging syndrome at $4^n$ na Pauli na operasyon, na nangangahulugang mayroon $4^n/2^r$ na Pauli na operasyon na nagsasanhi ng bawat syndrome. Anuman sa mga error na ito ay maaaring responsable sa kaugnay na syndrome.

Gayunpaman, sa gitna ng $4^n/2^r$ na Pauli na operasyon na nagsasanhi ng bawat syndrome, mayroon ilang dapat ituring na katumbas. Sa partikular, kung ang produkto ng dalawang Pauli na operasyon ay proporsyonal sa isang stabilizer element, ang dalawang operasyong iyon ay epektibong katumbas bilang mga error.

Isa pang paraan para sabihin ito ay kung maglalapat tayo ng correction operation na $C$ para subukang itama ang isang error na $E,$ ang pagwawasto na ito ay matagumpay hangga't ang komposisyon na $CE$ ay proporsyonal sa isang stabilizer element. Dahil mayroon $2^r$ na elemento sa stabilizer, sumusunod na ang bawat correction operation na $C$ ay nagtutuwid ng $2^r$ na iba't ibang Pauli error. Nag-iiwan ito ng $4^{n-r}$ na hindi magkaparehong klase ng Pauli na operasyon, itinuturing bilang mga error, na naaayon sa bawat posibleng syndrome.

Nangangahulugan ito na, maliban kung ang $n=r$ (kung saan mayroon tayong trivial, isang-dimensional na code space), hindi natin maaaring itama ang bawat error na nadetektahan ng isang stabilizer code. Ang dapat nating gawin sa halip ay pumili ng isang correction operation para sa bawat syndrome, sa pag-asa na maitama ang isang klase lamang ng katumbas na mga error na nagsasanhi ng syndrome na ito.

Ang isang natural na estratehiya para pumili ng kung aling correction operation ang isasagawa para sa bawat syndrome ay ang pumili ng pinakamababang weight na Pauli na operasyon na, bilang isang error, ay nagsasanhi ng syndrome na iyon. Maaaring mayroon sa katunayan ng maramihang operasyon na nagtatali para sa pinakamababang weight na error na naaayon sa isang ibinigay na syndrome, kung saan anuman sa mga ito ay maaaring mapili. Ang ideya ay ang mga Pauli na operasyon na may mas mababang weight ay kumakatawan sa mas malamang na mga paliwanag para sa anumang syndrome na nasukat. Maaaring hindi ito ang kaso para sa ilang noise model, at ang isang alternatibong estratehiya ay ang mag-compute ng pinaka-malamang na error na nagsasanhi ng ibinigay na syndrome, batay sa piniling noise model. Para sa araling ito, gayunpaman, pinanatili nating simple ang mga bagay at isinasaalang-alang lamang ang mga pinakamababang weight na pagwawasto.

Para sa isang distansya $d$ na stabilizer code, ang estratehiyang ito ng pagpili ng correction operation na maging isang pinakamababang weight na Pauli na operasyon na naaayon sa nasukat na syndrome ay palaging nagbibigay-daan sa pagwawasto ng mga error na may weight na mahigpit na wala sa kalahati ng $d,$ o sa ibang salita, weight na hindi hihigit sa $(d-1)/2.$ Ipinapakita nito, halimbawa, na ang 7-qubit Steane code ay makakaitama ng anumang weight-one na Pauli error, at sa pamamagitan ng discretization ng mga error, nangangahulugan ito na ang Steane code ay makakaitama ng isang arbitrary na error sa isang qubit.

Para makita kung paano gumagana ito, isaalang-alang ang diagram sa ibaba. Ang bilog sa kaliwa ay kumakatawan sa lahat ng Pauli na operasyon na nagresulta sa syndrome na $(+1,\ldots,+1),$ na ang syndrome na nagmumungkahi na walang naganap na error at walang mali. Sa gitna ng mga operasyong ito mayroon tayo mga elemento ng stabilizer (o mga operasyon na proporsyonal sa mga elemento ng stabilizer, para maging mas tiyak) at mayroon din tayong mga di-trivial na error na nagbabago ng code space sa ilang paraan ngunit hindi nadetektahan ng code. Sa kahulugan ng distansya, ang bawat Pauli na operasyon sa kategoryang ito ay kailangang may weight na hindi bababa sa $d,$ dahil ang $d$ ay tinukoy bilang ang pinakamababang weight ng mga operasyong ito.

Ang bilog sa kanan ay kumakatawan sa mga Pauli na operasyon na nagresulta sa ibang syndrome na $s\neq(+1,\ldots,+1),$ kabilang ang isang error $E$ na may weight na mahigpit na wala sa $d/2$ na ating isasaalang-alang.

Ang correction operation na $C$ na pinili para sa syndrome na $s$ ay ang pinakamababang weight na Pauli na operasyon sa koleksyon na kinakatawan ng bilog sa kanan sa diagram (o anuman sa kanila kung may tali). Kaya, maaaring ang $C = E,$ ngunit hindi kinakailangan. Ang maaari nating sabihin nang may katiyakan, gayunpaman, ay ang $C$ ay hindi maaaring magkaroon ng weight na mas malaki kaysa sa weight ng $E,$ dahil ang $C$ ay may minimal na weight sa gitna ng mga operasyon sa koleksyong ito — at samakatuwid ang $C$ ay may weight na mahigpit na wala sa $d/2.$

Ngayon isaalang-alang kung ano ang mangyayari kapag ang correction operation na $C$ ay inilapat sa anumang state na nakuha natin pagkatapos mangyari ang error na $E.$ Ipagpalagay na ang orihinal na encoding ay $\vert\psi\rangle,$ naiwan tayong may $CE\vert\psi\rangle.$ Ang ating layunin ay ipakita na ang $CE$ ay proporsyonal sa isang elemento sa stabilizer, na nagpapahiwatig na ang pagwawasto ay matagumpay at (hanggang sa isang global phase) naiwan tayo ng orihinal na naka-encode na state na $\vert\psi\rangle.$

Una, dahil ang $E$ at $C$ ay nagsasanhi ng parehong syndrome, ang komposisyon na $CE$ ay kailangang mag-commute sa bawat stabilizer generator. Sa partikular, kung ang $P_k$ ay anuman sa mga stabilizer generator, kailangan nating magkaroon ng

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

para sa parehong halaga ng $\alpha\in\{+1,-1\},$ dahil ito ang $k$-th na entry sa syndrome na $s$ na parehong $C$ at $E$ ang nagge-generate. Samakatuwid, mayroon tayong

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

kaya nagko-commute ang $P_k$ sa $CE.$ Pinatunayan natin samakatuwid na ang $CE$ ay napapabilang sa bilog sa kaliwa sa diagram, dahil nagge-generate ito ng syndrome na $(+1,\ldots,+1).$

Pangalawa, ang komposisyon na $CE$ ay kailangang magkaroon ng weight na hindi hihigit sa kabuuan ng mga weight ng $C$ at $E$ — na sumusunod mula sa sandaling pag-iisip tungkol sa mga produkto ng Pauli na operasyon — at samakatuwid ang weight ng $CE$ ay mahigpit na wala sa $d.$ Nangangahulugan ito na ang $CE$ ay proporsyonal sa isang elemento sa stabilizer ng ating code, na siyang nais nating ipakita. Sa pamamagitan ng pagpili ng ating mga correction operation na maging mga pinakamababang-weight na kinatawan ng hanay ng mga error na nagge-generate ng bawat syndrome, garantisado nating maitatama ang anumang Pauli error na may weight na wala sa kalahati ng distansya ng code.

Mayroon, gayunpaman, isang problema. Para sa mga stabilizer code sa pangkalahatan, ito ay isang computationally mahirap na problema ang mag-compute ng pinakamababang weight na Pauli na operasyon na nagsasanhi ng isang ibinigay na syndrome. (Sa katunayan, totoo ito kahit para sa mga klasikal na code, na sa kontekstong ito ay maaari nating isipin bilang mga stabilizer code kung saan may $\mathbb{I}$ at $Z$ lamang na matrix na lumalabas bilang mga tensor factor sa loob ng mga stabilizer generator.) Kaya, hindi tulad ng encoding step, ang mga Clifford na operasyon ay hindi darating para iligtas tayo sa pagkakataong ito.

Ang solusyon ay pumili ng mga tiyak na code kung saan ang mga magagandang pagwawasto ay maaaring ma-compute nang mahusay, na walang simpleng recipe para dito. Sa madaling salita, ang pagbuo ng mga stabilizer code kung saan ang mga magagandang correction operation ay maaaring ma-compute nang mahusay ay bahagi ng sining ng quantum code design.