CSS Codes

Mga klasikal na linear na code

Unang pinag-aralan ang mga klasikal na error correcting code noong 1940s, at marami na ngayon ang kilala, kung saan ang pinaka-karaniwan at ginagamit na mga code ay nasa kategoryang tinatawag na linear codes. Makikita natin kung ano ang ibig sabihin ng salitang "linear" sa kontekstong ito sa ilang sandali, ngunit isang napaka-simpleng paraan para mailarawan ang mga linear code sa ngayon ay na sila ay mga stabilizer code na klasikal ang katangian. Ang mga CSS code ay mahahalagang pares ng mga klasikal na linear na code na pinagsama upang lumikha ng isang quantum error correcting code. Kaya, para sa talakayan na susunod, kailangan nating maunawaan ang ilang pangunahing bagay tungkol sa mga klasikal na linear na code.

Hayaan ang $\Sigma$ na maging binary alphabet para sa buong talakayan na ito. Kapag sinasabi natin ang klasikal na linear na code, tinutukoy natin ang isang hindi-walang-laman na set $\mathcal{C}\subseteq\Sigma^n$ ng mga binary string na may haba $n,$ para sa ilang positibong integer $n,$ na dapat matupad ang isang pangunahing katangian: kung ang $u$ at $v$ ay mga binary string sa $\mathcal{C},$ ang string na $u\oplus v$ ay nasa $\mathcal{C}$ rin. Dito, ang $u\oplus v$ ay tumutukoy sa bitwise exclusive-OR ng $u$ at $v,$ na natagpuan natin nang maraming beses sa kursong "Fundamentals of quantum algorithms".

Sa esensya, kapag tinutukoy natin ang isang klasikal na error correcting code bilang linear, iniisip natin ang mga binary string na may haba $n$ bilang mga $n$-dimensional na vector, kung saan ang mga entry ay $0$ o $1$ lamang, at hinihiling na ang code mismo ay bumubuo ng isang linear subspace. Sa halip na ordinaryong vector addition sa mga tunay o kumplikadong numero, gayunpaman, gumagamit tayo ng addition modulo $2,$ na simpleng exclusive-OR. Ibig sabihin, kung mayroon tayong dalawang codeword $u$ at $v,$ na ibig sabihin ang $u$ at $v$ ay mga binary string sa $\mathcal{C},$ ang $u + v$ modulo 2, na ibig sabihin ay $u\oplus v,$ ay dapat ding maging codeword sa $\mathcal{C}.$ Pansinin, lalo na, na ang implikasyong ito ay dapat totoo kahit na $u = v.$ Ipinahihiwatig nito na ang $\mathcal{C}$ ay dapat maglaman ng all-zero string na $0^n,$ dahil ang bitwise exclusive-OR ng anumang string sa sarili nito ay ang all-zero string.

Halimbawa: ang 3-bit repetition code

Ang 3-bit repetition code ay isang halimbawa ng klasikal na linear na code. Sa partikular, mayroon tayong $\mathcal{C} = \{000,111\},$ kaya, kaugnay ng kondisyon ng linearidad, may dalawang posibleng pagpipilian para sa $u$ at dalawang posibleng pagpipilian para sa $v.$ Madaling suriin ang apat na posibleng pares upang makita na palagi tayong nakakakuha ng codeword kapag kinuha natin ang bitwise exclusive-OR:

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

Halimbawa: ang $[7,4,3]$-Hamming code

Narito ang isa pang halimbawa ng klasikal na linear na code na tinatawag na $[7,4,3]$-Hamming code. Ito ay isa sa mga pinakaunang klasikal na error correcting code na natuklasan, at binubuo ito ng 16 na binary string na may haba 7. (Minsan ang $[7,4,3]$-Hamming code ay nauunawaan bilang ang code na may mga string na binaliktad, ngunit isasaalang-alang natin ito bilang ang code na naglalaman ng mga string na ipinapakita dito.)

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

Mayroong napaka-simpleng lohika sa likod ng pagpili ng mga string na ito, ngunit ito ay pangalawa sa aralin at hindi ipapaliwanag dito. Sa ngayon, sapat na na obserbahan na ito ay isang klasikal na linear na code: ang pag-XOR ng anumang dalawang string dito ay palaging magreresulta sa isa pang string sa code.

Ang notasyon na $[7,4,3]$ (sa iisang square bracket) ay nangangahulugang katulad sa double square bracket notation para sa mga stabilizer code na binanggit sa nakaraang aralin, ngunit dito ito ay para sa mga klasikal na linear na code. Sa partikular, ang mga codeword ay may $7$ bits, maaari tayong mag-encode ng $4$ bits gamit ang code (dahil mayroong $16 = 2^4$ na codeword), at nagkataon itong maging distance $3$ code, na nangangahulugang ang anumang dalawang natatanging codeword ay dapat mag-iba sa hindi bababa sa $3$ posisyon — kaya hindi bababa sa $3$ bits ang dapat i-flip upang mabago ang isang codeword sa isa pa. Ang katotohanan na ito ay distance $3$ code na nagpapahiwatig na maaari itong mag-correct ng hanggang isang bit-flip error.

Paglalarawan ng mga klasikal na linear na code

Ang mga halimbawa na binanggit ay napaka-simpleng halimbawa ng mga klasikal na linear na code, ngunit kahit ang $[7,4,3]$-Hamming code ay mukhang medyo misteryoso kapag simpleng inilista ang mga codeword. Mayroong mas mahusay, mas episyenteng mga paraan upang ilarawan ang mga klasikal na linear na code, kabilang ang sumusunod na dalawang paraan.

1. Mga generator. Isang paraan upang ilarawan ang isang klasikal na linear na code ay sa pamamagitan ng isang minimal na listahan ng mga codeword na nagge-generate ng code, ibig sabihin sa pamamagitan ng pagkuha ng lahat ng posibleng subset ng mga codeword na ito at pag-XOR sa kanila, makukuha natin ang buong code.

   Sa mas detalyadong pagpapaliwanag, ang mga string na $u_1,\ldots,u_m\in\Sigma^n$ ay nagge-generate ng klasikal na linear na code $\mathcal{C}$ kung

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

   sa pag-unawa na ang $\alpha u = u$ kapag $\alpha = 1$ at $\alpha u = 0^n$ kapag $\alpha = 0,$ at sinasabi natin na ang listahang ito ay minimal kung ang pag-aalis ng isa sa mga string ay nagge-generate ng mas maliit na code. Isang natural na paraan upang isipin ang ganitong paglalarawan ay na ang koleksyon $\{u_1,\ldots,u_m\}$ ay bumubuo ng isang basis para sa $\mathcal{C}$ bilang isang subspace, kung saan iniisip natin ang mga string bilang mga vector na may binary-valued entries, isinasaalang-alang na nagtatrabaho tayo sa isang vector space kung saan ang aritmetika ay ginagawa modulo $2.$

2. Mga parity check. Isa pang natural na paraan upang ilarawan ang isang klasikal na linear na code ay sa pamamagitan ng mga parity check — ibig sabihin ang isang minimal na listahan ng mga binary string kung saan ang mga string sa code ay tiyak na ang mga may binary dot product na zero sa bawat isa sa mga parity check string na ito. (Katulad ng bitwise exclusive-OR, ang binary dot product ay lumabas nang maraming beses sa "Fundamentals of quantum algorithms".)

   Ibig sabihin, ang mga string na $v_1,\ldots,v_r\in\Sigma^n$ ay mga parity check string para sa klasikal na linear na code $\mathcal{C}$ kung

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

   at ang set ng mga string na ito ay minimal kung ang pag-aalis ng isa ay nagresulta sa mas malaking code. Tinatawag itong mga parity check string dahil ang $u$ ay may binary dot product na katumbas ng zero sa $v$ kung at kung ang mga bit ng $u$ sa mga posisyon kung saan ang $v$ ay may 1s ay may pantay na parity. Kaya, upang matukoy kung ang isang string $u$ ay nasa code $\mathcal{C},$ sapat na suriin ang parity ng ilang subset ng mga bit ng $u.$

   Isang mahalagang bagay na dapat pansinin dito ay na ang binary dot product ay hindi isang inner product sa pormal na kahulugan. Sa partikular, kapag ang dalawang string ay may binary dot product na katumbas ng zero, hindi ito nangangahulugang sila ay orthogonal sa karaniwang paraan na iniisip natin ang orthogonality. Halimbawa, ang binary dot product ng string na $11$ sa sarili nito ay zero — kaya posible na ang isang parity check string para sa isang klasikal na linear na code ay nasa code mismo.

Ang mga klasikal na linear na code sa binary alphabet ay palaging naglalaman ng bilang ng mga string na kapangyarihan ng $2$ — at para sa isang solong klasikal na linear na code na inilarawan sa dalawang magkaibang paraan na binanggit, palaging totoo na ang $n = m + r.$ Sa partikular, kung mayroon tayong minimal na set ng $m$ na generator, ang code ay nag-e-encode ng $m$ bits at mayroon tayong $2^m$ na codeword; at kung mayroon tayong minimal na set ng $r$ na parity check string, mayroon tayong $2^{n-r}$ na codeword. Kaya, bawat generator ay nagdodoble ng laki ng code space habang ang bawat parity check string ay naghahatid ng kalahati ng laki ng code space.

Halimbawa, ang 3-bit repetition code ay isang linear na code, kaya maaari itong ilarawan sa parehong paraan na ito. Sa partikular, isang pagpipilian lamang para sa isang generator ang gumagana: $111.$ Maaari rin nating ilarawan ang code sa dalawang parity check string, tulad ng $110$ at $011$ — na dapat ay pamilyar mula sa aming mga nakaraang talakayan tungkol sa code na ito — o maaari rin nating gamitin ang mga parity check string na $110$ at $101,$ o $101$ at $011.$ (Ang mga generator at parity check string ay sa pangkalahatan ay hindi natatangi para sa isang naibigay na klasikal na linear na code.)

Para sa ikalawang halimbawa, isaalang-alang ang $[7,4,3]$-Hamming code. Narito ang isang pagpipilian para sa listahan ng mga generator na gumagana.

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

At narito ang isang pagpipilian para sa listahan ng mga parity check para sa code na ito.

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

Dito, sa pamamagitan ng paraan, makikita natin na ang lahat ng ating mga parity check string ay nasa code mismo.

Isang panghuling puna tungkol sa mga klasikal na linear na code, na nagkokonekta sa kanila sa stabilizer formalism, ay na ang mga parity check string ay katumbas ng mga stabilizer generator na binubuo lamang ng $Z$ at identity Pauli matrices. Halimbawa, ang mga parity check string na $110$ at $011$ para sa 3-bit repetition code ay tiyak na katumbas ng mga stabilizer generator na $Z\otimes Z\otimes \mathbb{I}$ at $\mathbb{I}\otimes Z\otimes Z,$ na naaayon sa mga talakayan ng Pauli observables mula sa nakaraang aralin.

Kahulugan ng mga CSS code

Ang mga CSS code ay mga stabilizer code na nakuha sa pamamagitan ng pagsasama ng ilang pares ng mga klasikal na linear na code. Hindi ito gumagana para sa dalawang arbitrary na klasikal na linear na code — ang dalawang code ay dapat magkaroon ng isang tiyak na relasyon. Gayunpaman, ang konstruksyon na ito ay nagbubukas ng maraming posibilidad para sa mga quantum error correcting code, batay sa mahigit 75 taon ng klasikal na coding theory.

Sa stabilizer formalism, ang mga stabilizer generator na naglalaman lamang ng $Z$ at identity Pauli matrices ay katumbas ng mga parity check, tulad ng aming naobserbahan para sa 3-bit repetition code. Para sa isa pang halimbawa, isaalang-alang ang sumusunod na mga parity check string para sa $[7,4,3]$-Hamming code.

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

Ang mga parity check string na ito ay katumbas ng sumusunod na mga stabilizer generator (isinulat nang walang mga simbolo ng tensor product), na nakuha natin sa pamamagitan ng pagpapalit ng bawat $1$ ng $Z$ at bawat $0$ ng $\mathbb{I}.$ Ito ay tatlo sa anim na stabilizer generator para sa 7-qubit Steane code.

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

Bigyan natin ng pangalang $Z$ stabilizer generator ang mga stabilizer generator na ganito, ibig sabihin mayroon lamang silang Pauli $Z$ at identity tensor factor — kaya ang $X$ at $Y$ Pauli matrices ay hindi kailanman lumalabas sa $Z$ stabilizer generators.

Maaari rin nating isaalang-alang ang mga stabilizer generator kung saan ang $X$ at identity Pauli matrices lamang ang lumalabas bilang mga tensor factor. Ang mga stabilizer generator na ganito ay maaaring ituring bilang katulad ng $Z$-stabilizer generator, maliban na inilarawan nila ang mga parity check sa $\{\vert+\rangle,\vert-\rangle\}$ basis sa halip na sa standard basis. Ang mga stabilizer generator ng ganitong anyo ay tinatawag na $X$ stabilizer generator — kaya walang pinapayagang $Y$ o $Z$ Pauli matrices sa pagkakataong ito.

Halimbawa, isaalang-alang ang natitirang tatlong stabilizer generator mula sa 7-qubit Steane code.

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

Sumusunod sila sa eksaktong parehong pattern mula sa $[7,4,3]$-Hamming code tulad ng $Z$-stabilizer generator, maliban sa pagkakataong ito ay pinapalitan natin ang $X$ para sa $1$ sa halip na $Z.$ Ang makukuha natin mula sa tatlong stabilizer generator na ito lamang ay isang code na naglalaman ng 16 na estado na ipinapakita dito, na nakuha natin sa pamamagitan ng pag-apply ng mga operasyon ng Hadamard sa mga standard basis state na katumbas ng mga string sa $[7,4,3]$-Hamming code. (Syempre, ang code space para sa code na ito ay naglalaman din ng mga linear combination ng mga estado na ito.)

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

Maaari na nating tukuyin ang mga CSS code sa napaka-simpleng mga tuntunin.

Kahulugan

Ang CSS code ay isang stabilizer code na maaaring ipahayag gamit lamang ang $X$ at $Z$ stabilizer generator.

Ibig sabihin, ang mga CSS code ay mga stabilizer code kung saan mayroon tayong mga stabilizer generator na walang lumalabas na Pauli $Y$ matrices, at kung saan ang $X$ at $Z$ ay hindi kailanman lumalabas sa parehong stabilizer generator.

Upang maging malinaw, sa kahulugang ito, ang isang CSS code ay isa kung saan posible na pumili ng $X$ at $Z$ stabilizer generator lamang — ngunit dapat nating isaalang-alang na may kalayaan sa kung paano natin pinipili ang mga stabilizer generator para sa mga stabilizer code. Kaya, sa pangkalahatan ay magkakaroon ng iba't ibang pagpipilian para sa mga stabilizer generator ng isang CSS code na hindi naman magiging $X$ o $Z$ stabilizer generator (bilang karagdagan sa hindi bababa sa isang pagpipilian kung saan sila ay).

Narito ang isang napaka-simpleng halimbawa ng CSS code na naglalaman ng parehong $Z$ stabilizer generator at isang $X$ stabilizer generator:

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

Malinaw na ito ay isang CSS code, dahil ang unang stabilizer generator ay isang $Z$ stabilizer generator at ang pangalawa ay isang $X$ stabilizer generator. Syempre, ang isang CSS code ay dapat ding maging isang wastong stabilizer code — ibig sabihin ang mga stabilizer generator ay dapat mag-commute, bumuo ng isang minimal generating set, at mag-fix ng hindi bababa sa isang quantum state vector. Ang mga kinakailangang ito ay madaling obserbahan para sa code na ito. Tulad ng aming nabanggit sa nakaraang aralin, ang code space para sa code na ito ay ang isang-dimensional na space na na-span ng $\vert\phi^+\rangle$ Bell state. Ang katotohanan na ang parehong stabilizer generator ay nag-fix ng estado na ito ay maliwanag sa pamamagitan ng pagsasaalang-alang ng sumusunod na dalawang pahayag ng isang e-bit, kasama ang isang interpretasyon ng mga stabilizer generator na ito bilang mga parity check sa $\{\vert 0\rangle, \vert 1\rangle\}$ at $\{\vert +\rangle, \vert -\rangle\}$ bases.

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

Ang 7-qubit Steane code ay isa pang halimbawa ng CSS code.

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

Dito mayroon tayong tatlong $Z$ stabilizer generator at tatlong $X$ stabilizer generator, at napatunayan na natin na ito ay isang wastong stabilizer code.

At ang 9-qubit Shor code ay isa pang halimbawa.

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

Sa pagkakataong ito mayroon tayong anim na $Z$ stabilizer generator at dalawang $X$ stabilizer generator lamang. Ayos lang ito, hindi kailangang magkaroon ng balanse o simmetri sa pagitan ng dalawang uri ng generator (kahit na madalas ay mayroon).

Muli, kritikal na ang mga CSS code ay mga wastong stabilizer code, at sa partikular ang bawat $Z$ stabilizer generator ay dapat mag-commute sa bawat $X$ stabilizer generator. Kaya, hindi bawat koleksyon ng $X$ at $Z$ stabilizer generator ay nagtatakda ng isang wastong CSS code.

Pagtuklas at pagwawasto ng error

Kaugnay ng pagtuklas at pagwawasto ng error, ang mga CSS code sa pangkalahatan ay may katulad na katangian sa 9-qubit Shor code, na ang $X$ at $Z$ na error ay maaaring matukoy at maitama nang ganap na nakapag-iisa; ang $Z$ stabilizer generator ay naglalarawan ng isang code na nagpoprotekta laban sa mga bit flip, at ang $X$ stabilizer generator ay naglalarawan ng isang code na nakapag-iisang nagpoprotekta laban sa mga phase flip. Gumagana ito dahil ang $Z$ stabilizer generator ay kinakailangan mag-commute sa mga $Z$ error, pati na rin ang mga $Z$ operasyon na inilalapat bilang mga pagwawasto, kaya ganap silang bigo sa pareho, at ganoon din para sa $X$ stabilizer generator, mga error, at mga pagwawasto.

Bilang halimbawa, isaalang-alang natin ang 7-qubit Steane code.

$$\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 pangunahing ideya para sa code na ito ay maliwanag na ngayon: ito ay isang $[7,4,3]$-Hamming code para sa mga bit-flip error at isang $[7,4,3]$-Hamming code para sa mga phase-flip error. Ang katotohanan na ang $X$ at $Z$ stabilizer generator ay mag-commute ay maaaring masabing magandang swerte, dahil ito ay hindi magiging isang wastong stabilizer code kung hindi. Ngunit mayroon, sa katunayan, maraming kilalang halimbawa ng mga klasikal na linear na code na nagbubunga ng isang wastong stabilizer code kapag ginamit sa katulad na paraan.

Sa pangkalahatan, ipagpalagay na mayroon tayong isang CSS code kung saan ang $Z$ stabilizer generator ay nagpapahintulot ng pagwawasto ng hanggang $j$ na bit-flip error, at ang $X$ stabilizer generator ay nagpapahintulot ng pagwawasto ng hanggang $k$ na phase-flip error. Halimbawa, $j = 1$ at $k = 1$ para sa Steane code, dahil ang $[7,4,3]$-Hamming code ay maaaring mag-correct ng isang bit flip. Sumusunod dito, sa pamamagitan ng discretization ng mga error, na ang CSS code na ito ay maaaring mag-correct ng anumang error sa isang bilang ng mga qubit hanggang sa minimum ng $j$ at $k.$ Ito ay dahil, kapag sinukat ang syndrome, ang isang arbitrary na error sa bilang na ito ng mga qubit ay epektibong nag-collapse nang probabilistiko sa ilang kombinasyon ng $X$ error, $Z$ error, o pareho — at pagkatapos ang $X$ error at $Z$ error ay natatukoy at naitatama nang nakapag-iisa.

Sa buod, sa kondisyon na mayroon tayong dalawang klasikal na linear na code (o dalawang kopya ng isang solong klasikal na linear na code) na compatible, sa kahulugang nagtatakda sila ng $X$ at $Z$ stabilizer generator na nag-commute, ang CSS code na nakuha natin sa pamamagitan ng pagsasama sa kanila ay nagmamana ng mga katangian ng pagwawasto ng error ng dalawang code na iyon, sa kahulugang binanggit lamang.

Pansinin na may bayad na dapat bayaran, na ang mga qubit na maaari nating i-encode ay mas kakaunti kaysa sa mga bit na maaari nating i-encode gamit ang dalawang klasikal na code. Ito ay dahil ang kabuuang bilang ng mga stabilizer generator para sa CSS code ay ang kabuuan ng bilang ng mga parity check para sa dalawang klasikal na linear na code, at ang bawat stabilizer generator ay naghahatid ng kalahati ng dimensyon ng code space. Halimbawa, ang $[7,4,3]$-Hamming code ay nagpapahintulot ng pag-encode ng apat na klasikal na bit, dahil mayroon lamang tatlong parity check string para sa code na ito, samantalang ang 7-qubit Steane code ay nag-e-encode lamang ng isang qubit, dahil mayroon itong anim na stabilizer generator.

Mga code space ng CSS code

Ang huling bagay na gagawin natin sa talakayan ng mga CSS code ay isaalang-alang ang mga code space ng mga code na ito. Bibigyan tayo nito ng pagkakataon na mas detalyadong suriin ang relasyon na dapat mangyari sa pagitan ng dalawang klasikal na linear na code upang maging compatible, sa kahulugang maaari silang pagsamahin upang bumuo ng isang CSS code.

Isaalang-alang ang anumang CSS code sa $n$ na qubit, at hayaan ang $z_1, \ldots, z_s \in \Sigma^n$ na maging $n$-bit parity check string na katumbas ng $Z$ stabilizer generator ng code na ito. Ibig sabihin nito na ang klasikal na linear na code na inilarawan ng $Z$ stabilizer generator lamang, na pananganlan nating $\mathcal{C}_Z,$ ay may sumusunod na anyo.

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

Sa salita, ang klasikal na linear na code $\mathcal{C}_Z$ ay naglalaman ng bawat string na ang binary dot product sa bawat isa sa mga parity check string na $z_1, \ldots, z_s$ ay zero.

Sa katulad na paraan, hayaan nating kunin ang $x_1,\ldots,x_t\in\Sigma^n$ na maging $n$-bit parity check string na katumbas ng $X$ stabilizer generator ng ating code. Kaya, ang klasikal na linear na code na katumbas ng $X$ stabilizer generator ay may ganitong anyo.

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

Ang $X$ stabilizer generator lamang ay naglalarawan ng isang code na katulad ng code na ito, ngunit sa $\{\vert {+}\rangle,\vert {-}\rangle\}$ basis sa halip na sa standard basis.

Ngayon ay ipapakilala natin ang dalawang bagong klasikal na linear na code na nagmula sa parehong mga pagpipilian ng mga string, $z_1,\ldots,z_s$ at $x_1,\ldots,x_t,$ ngunit kung saan kinukuha natin ang mga string na ito bilang mga generator sa halip na mga parity check string. Sa partikular, nakukuha natin ang dalawang code na ito.

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

Ang mga ito ay kilala bilang mga dual code ng mga code na tinukoy noon: ang $\mathcal{D}_Z$ ay ang dual code ng $\mathcal{C}_Z$ at ang $\mathcal{D}_X$ ay ang dual code ng $\mathcal{C}_X.$ Maaaring hindi malinaw sa puntong ito kung bakit ang mga dual code na ito ay may kaugnayan, ngunit lumabas na sila ay medyo may kaugnayan sa maraming dahilan, kabilang ang dalawang dahilan na ipinaliliwanag sa mga sumusunod na talata.

Una, ang mga kondisyon na dapat mangyari para sa dalawang klasikal na linear na code $\mathcal{C}_Z$ at $\mathcal{C}_X$ na maging compatible, sa kahulugang maaari silang ipares upang bumuo ng isang CSS code, ay maaaring ilarawan sa simpleng paraan sa pamamagitan ng pagtukoy sa mga dual code. Sa partikular, dapat na ang $\mathcal{D}_Z\subseteq\mathcal{C}_X,$ o katumbas nito, na ang $\mathcal{D}_X\subseteq\mathcal{C}_Z.$ Sa salita, ang dual code $\mathcal{D}_Z$ ay naglalaman ng mga string na katumbas ng $Z$ stabilizer generator, at ang kanilang pagkaloob sa $\mathcal{C}_X$ ay katumbas ng binary dot product ng bawat isa sa mga string na ito sa mga katumbas ng $X$ stabilizer generator na zero. Iyon naman ay katumbas ng bawat $Z$ stabilizer generator na nag-commute sa bawat $X$ stabilizer generator. Bilang kahalili, sa pamamagitan ng pagpapalit ng mga papel ng $X$ at $Z$ stabilizer generator at pagsisimula mula sa pagkaloob $\mathcal{D}_X\subseteq\mathcal{C}_Z,$ maaari tayong makarating sa parehong konklusyon.

Ikalawa, sa pamamagitan ng pagtukoy sa mga dual code, madali nating mailalarawan ang mga code space ng isang naibigay na CSS code. Sa partikular, ang code space ay na-span ng mga vector na may sumusunod na anyo.

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

Sa salita, ang mga vector na ito ay mga uniform superposition sa mga string sa dual code $\mathcal{D}_X$ ng code na katumbas ng $X$ stabilizer generator, na inilipat ng (ibig sabihin, bitwise XORed sa) mga string sa code $\mathcal{C}_Z$ na katumbas ng $Z$ stabilizer generator. Upang maging malinaw, ang iba't ibang pagpipilian para sa shift — na kinakatawan ng string na $u$ sa pahayag na ito — ay maaaring magresulta sa parehong vector. Kaya, ang mga estadong ito ay hindi lahat natatangi, ngunit sama-sama nilang nispanspan ang buong code space.

Narito ang isang intuitive na paliwanag kung bakit ang mga ganitong vector ay nasa code space at nispanspan ito. Isaalang-alang ang $n$-qubit standard basis state na $\vert u\rangle,$ para sa ilang arbitrary na $n$-bit string $u,$ at ipagpalagay na i-project natin ang estado na ito sa code space. Ibig sabihin, hayaan ang $\Pi$ na tumukoy sa projection sa code space ng ating CSS code, isaalang-alang ang vector na $\Pi\vert u\rangle.$ Mayroong dalawang kaso:

• Kaso 1: $u\in\mathcal{C}_Z.$ Ipinahihiwatig nito na ang bawat $Z$ stabilizer generator ng ating CSS code ay kumikilos nang walang epekto sa $\vert u\rangle.$ Ang mga $X$ stabilizer generator, sa kabilang banda, bawat isa ay simpleng nagba-flip ng ilang bit ng $\vert u\rangle.$ Sa partikular, para sa bawat generator $v$ ng $\mathcal{D}_X,$ ang $X$ stabilizer generator na katumbas ng $v$ ay nagbabago ng $\vert u\rangle$ sa $\vert u\oplus v\rangle.$ Sa pamamagitan ng pag-characterize ng projection $\Pi$ bilang average sa mga elemento ng stabilizer (tulad ng aming nakita sa nakaraang aralin), nakukuha natin ang formula na ito:

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

• Kaso 2: $u\notin\mathcal{C}_Z.$ Ipinahihiwatig nito na hindi bababa sa isa sa mga parity check na katumbas ng $Z$ stabilizer generator ay hindi pumasa, na ibig sabihin ang $\vert u\rangle$ ay dapat maging $-1$ eigenvector ng hindi bababa sa isa sa $Z$ stabilizer generator. Ang code space ng CSS code ay ang intersection ng $+1$ eigenspace ng mga stabilizer generator. Kaya, bilang $-1$ eigenvector ng hindi bababa sa isa sa $Z$ stabilizer generator, ang $\vert u\rangle$ ay samakatuwid na orthogonal sa code space:

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

At ngayon, habang tayo ay nagpapalawak sa lahat ng $n$-bit string $u,$ itinapon ang mga kung saan $\Pi\vert u\rangle = 0,$ at ni-normalize ang natitirang mga ito, nakukuha natin ang mga vector na inilarawan noon, na nagpapakita na nispanspan nila ang code space.

Maaari rin nating gamitin ang simmetri sa pagitan ng $X$ at $Z$ stabilizer generator upang ilarawan ang code space sa katulad ngunit naiibang paraan. Sa partikular, ito ay ang space na na-span ng mga vector na may sumusunod na anyo.

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

Sa esensya, ang $X$ at $Z$ ay napalitan sa bawat pagkakataon na lumabas sila — ngunit dapat din nating palitan ang standard basis para sa $\{\vert+\rangle,\vert-\rangle\}$ basis, kaya kasama ang mga operasyon ng Hadamard.

Bilang halimbawa, isaalang-alang natin ang 7-qubit Steane code. Ang mga parity check string para sa parehong $X$ at $Z$ stabilizer generator ay pareho: $1111000,$ $1100110,$ at $1010101.$ Ang mga code $\mathcal{C}_X$ at $\mathcal{C}_Z$ ay samakatuwid na pareho; parehong katumbas ng $[7,4,3]$-Hamming code.

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

Ang mga dual code $\mathcal{D}_X$ at $\mathcal{D}_Z$ ay samakatuwid na pareho rin. Mayroon tayong tatlong generator, kaya nakakakuha tayo ng walong string.

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

Ang mga string na ito ay lahat nakapaloob sa $[7,4,3]$-Hamming code, kaya ang CSS kondisyon ay natutupad: $\mathcal{D}_Z \subseteq \mathcal{C}_X,$ o katumbas nito, $\mathcal{D}_X \subseteq \mathcal{C}_Z.$

Dahil ang $\mathcal{D}_X$ ay naglalaman ng kalahati ng lahat ng mga string sa $\mathcal{C}_Z,$ may dalawang natatanging vector lamang na $\vert u\oplus \mathcal{D}_X\rangle$ na maaaring makuha sa pamamagitan ng pagpili ng $u\in\mathcal{C}_Z.$ Ito ay inaasahan, dahil ang 7-qubit Steane code ay may dalawang-dimensional na code space. Maaari nating gamitin ang dalawang estado na nakuha natin sa ganitong paraan upang i-encode ang lohikal na estado $\vert 0\rangle$ at $\vert 1\rangle$ tulad ng sumusunod.

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

Tulad ng dati, hindi ito sapilitan sa atin — malaya tayong gamitin ang code space upang i-encode ang mga qubit kung paano man natin gusto. Ang encoding na ito, gayunpaman, ay naaayon sa halimbawa ng isang encoding circuit para sa 7-qubit Steane code sa nakaraang aralin.