Ang 9-qubit na Shor code

Ngayon ay lilipat tayo sa 9-qubit na Shor code, na isang quantum error correcting code na nakuha sa pamamagitan ng pagsasama ng dalawang code na tinalakay sa nakaraang seksyon: ang 3-bit repetition code para sa mga qubit, na nagpapahintulot ng pagwawasto ng iisang bit-flip error, at ang binagong bersyon ng code na iyon, na nagpapahintulot ng pagwawasto ng iisang phase-flip error.

Paglalarawan ng code

Ang 9-qubit na Shor code ang makukuha natin sa pamamagitan ng concatenation ng dalawang code mula sa nakaraang seksyon. Ibig sabihin, unang mag-a-apply tayo ng isang encoding, na nag-encode ng isang qubit sa tatlo, at pagkatapos ay ia-apply natin ang isa pang encoding sa bawat isa sa tatlong qubit na ginamit para sa unang encoding, na nagreresulta sa siyam na qubit sa kabuuan.

Para maging mas tumpak, kahit na maaari tayong mag-apply ng dalawang code sa alinmang pagkakasunod-sunod sa partikular na kasong ito, pipiliin nating i-apply muna ang binagong bersyon ng 3-bit repetition code (na nakaka-detect ng mga phase-flip error), at pagkatapos ay ie-encode natin ang bawat isa sa tatlong qubit na resulta nito nang hiwalay gamit ang orihinal na 3-bit repetition code (na nakaka-detect ng mga bit-flip error). Narito ang isang circuit diagram na representasyon ng encoding na ito.

Tulad ng iminumungkahi ng figure, iisipin natin ang siyam na qubit ng Shor code bilang naka-grupo sa tatlong bloke ng tatlong qubit, kung saan ang bawat bloke ay nakuha mula sa pangalawang encoding step (na siyang ordinaryong 3-bit repetition code). Ang ordinaryong 3-bit repetition code, na dito ay ina-apply nang tatlong beses nang hiwalay, ay tinatawag na inner code sa kontekstong ito, samantalang ang outer code naman ang code na ginamit para sa unang encoding step, na siyang binagong bersyon ng 3-bit repetition code na nakaka-detect ng mga phase-flip error.

Maaari rin nating tukuyin ang code sa pamamagitan ng paglalarawan kung paano nako-encode ang dalawang standard basis state ng ating orihinal na qubit.

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[4mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

Kapag nalaman na natin ito, maaari nating matukoy sa pamamagitan ng linearity kung paano nako-encode ang isang arbitrary na qubit state vector.

Pagwawasto ng mga bit-flip at phase-flip error

Mga error at CNOT gates

Para masuri kung paano nakakaapekto ang mga $X$ at $Z$ error sa mga encoding ng mga qubit, kapwa para sa 9-qubit na Shor code at sa ibang mga code, magiging kapaki-pakinabang na obserbahan ang ilang simpleng relasyon sa pagitan ng mga error na ito at mga CNOT gate. Habang sisimulan nating suriin ang 9-qubit na Shor code, ito ay isang magandang pagkakataon na huminto at gawin ito.

Ang mga sumusunod na circuit diagram ay naglalarawan ng tatlong pangunahing relasyon sa pagitan ng mga $X$ gate at mga CNOT gate. Sa partikular, ang pag-apply ng isang $X$ gate sa target qubit bago ang isang CNOT ay katumbas ng pagpapalit ng pagkakasunod at pagsasagawa muna ng CNOT, ngunit ang pag-apply ng isang $X$ gate sa control qubit bago ang isang CNOT ay katumbas ng pag-apply ng mga $X$ gate sa parehong qubit pagkatapos ng CNOT. Sa wakas, ang pag-apply ng mga $X$ gate sa parehong qubit bago ang isang CNOT ay katumbas ng pagsasagawa muna ng CNOT at pagkatapos ay pag-apply ng isang $X$ gate sa control qubit. Mabe-verify ang mga relasyong ito sa pamamagitan ng pagsasagawa ng mga kinakailangang matrix multiplication o sa pag-compute ng epekto ng mga circuit sa mga standard basis state.

Katulad ang sitwasyon para sa mga $Z$ gate, maliban na ang mga papel ng control at target na qubit ay magpapalit. Sa partikular, mayroon tayong tatlong relasyon na inilalarawan ng mga sumusunod na quantum circuit.

Pagwawasto ng mga bit-flip error

Ngayon ay isasaalang-alang natin kung paano maaaring ma-detect at maitama ang mga error gamit ang 9-qubit na Shor code, simula sa mga bit-flip error — na sa ngayon ay tatawaging $X$ error para sa ikli.

Para ma-detect at maitama ang mga $X$ error, maaari tayong tratuhin ang bawat isa sa tatlong bloke sa encoding nang hiwalay. Ang bawat bloke ay isang encoding ng isang qubit gamit ang 3-bit repetition code, na nagpoprotekta laban sa mga $X$ error — kaya sa pamamagitan ng pagsasagawa ng mga syndrome measurement at $X$ error correction na inilarawan dati sa bawat bloke, maaari tayong mag-detect at magtama ng hanggang isang $X$ error bawat bloke. Sa partikular, kung may kahit isang $X$ error lamang sa siyam na qubit ng encoding, ang error na ito ay dide-detect at itatama ng pamamaraang ito.

Sa madaling salita, ang pagwawasto ng mga bit-flip error ay simpleng bagay para sa code na ito, dahil sa katotohanang itinatama ng inner code ang mga bit-flip error.

Pagwawasto ng mga phase-flip error

Susunod ay isasaalang-alang natin ang mga phase-flip error, o $Z$ error para sa ikli. Sa pagkakataong ito ay hindi gaanong malinaw kung ano ang dapat nating gawin dahil ang outer code ang nakaka-detect ng mga $Z$ error, ngunit ang inner code ay tila "nasa daan," na ginagawang bahagyang mas mahirap ang pag-detect at pagwawasto ng mga error na ito.

Ipagpalagay na may $Z$ error na nangyayari sa isa sa 9 na qubit ng Shor code, tulad ng ipinapakita sa diagram na ito.

Naobserbahan na natin ang nangyayari kapag may $Z$ error na nagaganap habang ginagamit ang 3-bit repetition code — katumbas ito ng isang $Z$ error na nagaganap bago ang encoding. Sa konteksto ng 9-qubit na Shor code, ibig sabihin nito ay ang isang $Z$ error sa alinman sa tatlong qubit sa loob ng isang bloke ay palaging may parehong epekto, na katumbas ng isang $Z$ error na nagaganap sa kaukulang qubit bago i-apply ang inner code.

Halimbawa, ang circuit diagram sa itaas ay katumbas ng sumusunod na diagram. Maaari itong mapatunayan gamit ang mga relasyon sa pagitan ng $Z$ at mga CNOT gate na inilarawan sa itaas, o sa simpleng pag-evaluate ng mga circuit sa isang arbitrary na qubit state $\vert\psi\rangle.$

Nagmumungkahi ito ng isang opsyon para sa pag-detect at pagwawasto ng mga $Z$ error, na ang i-decode ang inner code, na nag-iiwan sa atin ng tatlong qubit na ginamit para sa outer encoding kasama ang anim na initialized na workspace qubit. Maaari nating suriin ang tatlong qubit na ito ng outer code para sa mga $Z$ error, at pagkatapos ay maaari tayong muling mag-encode gamit ang inner code, upang makabalik tayo sa 9-qubit encoding na makukuha natin mula sa Shor code. Kung ma-detect natin ang isang $Z$ error, maaari nating itama ito bago muling i-encode gamit ang inner code, o maaari nating itama ito pagkatapos ng muling pag-encode, sa pamamagitan ng pag-apply ng $Z$ gate sa alinman sa mga qubit ng bloke na iyon.

Narito ang isang circuit diagram na may kasamang encoding circuit at ang error na iminumungkahi sa itaas kasama ang mga hakbang na inilarawan lamang (ngunit hindi ang aktwal na correction step).

Sa partikular na halimbawang ito, ang syndrome measurement ay $11,$ na nagpapakita na ang $Z$ error ay nangyari sa isa sa mga qubit ng gitnang bloke.

Ang isang bentahe ng pagwawasto ng mga $Z$ error pagkatapos ng muling pag-encode kaysa bago nito ay maaari nating pasimplehin ang circuit sa itaas. Ang sumusunod na circuit ay katumbas, ngunit nangangailangan ng apat na mas kaunting CNOT gate.

Muli, ang syndrome ay hindi nagpapahiwatig kung aling qubit ang naapektuhan ng $Z$ error, kundi kung aling bloke ang nakaranas ng $Z$ error, na may parehong epekto anuman sa loob ng bloke ang naapektuhan. Maaari nating itama ang error sa pamamagitan ng pag-apply ng $Z$ gate sa alinman sa tatlong qubit ng bloke na naapektuhan.

Bilang isang paalala, dito ay nakikita natin ang isang halimbawa ng degeneracy sa isang quantum error-correcting code, kung saan nagagawa nating iwasto ang ilang partikular na error (mga $Z$ error sa kasong ito) nang hindi natin naitutukoy ang mga ito nang natatangi.

Sabay-sabay na mga bit- at phase-flip error

Nakita na natin ngayon kung paano maaaring ma-detect at maitama ang parehong $X$ at $Z$ error gamit ang 9-qubit na Shor code, at sa partikular kung paano maaaring ma-detect at maitama ang kahit isang $X$ error o kahit isang $Z$ error. Ngayon ay ipagpalagay nating nagaganap ang parehong isang bit-flip at isang phase-flip error, posibleng sa parehong qubit. Gaya ng lumabas, wala nang iba pang kailangang gawin sa sitwasyong ito mula sa mga naipakita na — nagagawa ng code na ma-detect at maitama ang hanggang isang $X$ error at isang $Z$ error nang sabay-sabay, nang walang karagdagang pagbabago.

Para maging mas tumpak, ang mga $X$ error ay dide-detect sa pamamagitan ng pag-apply ng ordinaryong 3-bit repetition code syndrome measurement, na isasagawa nang hiwalay sa bawat isa sa tatlong bloke ng tatlong qubit; at ang mga $Z$ error ay dide-detect sa pamamagitan ng pamamaraang inilarawan lamang sa itaas, na katumbas ng pag-decode ng inner code, pagsasagawa ng syndrome measurement para sa binagong 3-bit repetition code para sa mga phase-flip, at pagkatapos ay muling pag-encode. Ang dalawang hakbang sa pag-detect ng error na ito — pati na rin ang mga kaukulang pagwawasto — ay maaaring isagawa nang ganap na hiwalay sa isa't isa, at sa katunayan ay hindi mahalaga kung saang pagkakasunod-sunod sila isasagawa.

Para makita kung bakit ganito, isaalang-alang ang halimbawang inilalarawan sa sumusunod na circuit diagram, kung saan parehong nakaapekto ang $X$ at $Z$ error sa pinakaibabang qubit ng gitnang bloke.

Unang obserbahan natin na ang pagkakasunod-sunod ng mga error ay hindi mahalaga, sa kahulugang ang pagpapalit ng posisyon ng $X$ at $Z$ error ay nagbibigay ng katumbas na circuit. Para maging malinaw, ang $X$ at $Z$ ay hindi nagko-commute, sila ay nag-a-anti-commute:

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

Ibig sabihin nito ay ang sumusunod na circuit ay katumbas ng nasa itaas hanggang sa global phase factor na $-1.$

Maaari na nating ilipat ang $Z$ error tulad ng dati para makakuha ng isa pang katumbas na circuit.

Sa puntong ito ay malinaw na kung ang pamamaraan para ma-detect at maitama ang mga $X$ error ay isasagawa muna, ang $X$ error ay maitatama, pagkatapos nito ay maaaring isagawa ang pamamaraan para ma-detect at maitama ang mga $Z$ error para alisin ang $Z$ error tulad ng dati.

Bilang kahalili, maaaring isagawa muna ang pamamaraan para ma-detect at maitama ang mga $Z$ error. Ang katotohanang gumagana ang pamamaraang ito ayon sa inaasahan, kahit na may isa o higit pang mga $X$ error, ay sumusunod sa katotohanang ang mga $X$ gate sa alinman sa siyam na qubit na ginamit para sa encoding ay nagko-commute sa lahat ng gate sa ating pinasimpleng circuit para sa pagsukat ng syndrome para sa mga $Z$ error. Kaya, ang syndrome measurement na ito ay tama pa ring makakakilala kung aling bloke ang naapektuhan ng isang $Z$ error. Ang katotohanang ang isang $Z$ error sa anumang bloke ay naitutuwid sa pamamagitan ng pag-apply ng isang $Z$ gate sa anumang qubit ng bloke na iyon, kahit na may $X$ error na nangyari rin, ay sumusunod sa parehong argumento sa itaas tungkol sa pagkakasunod-sunod ng $X$ at $Z$ gate na nagbibigay sa atin ng mga katumbas na circuit hanggang sa global phase.

Sumusunod na ang 9-qubit na Shor code ay maaaring magwasto ng isang $X$ error, isang $Z$ error, o pareho, sa alinman sa siyam na qubit na ginamit para sa code na ito. Sa katunayan, maaari tayong magwasto ng higit pang mga error kaysa rito, kabilang ang maraming $X$ error (basta't nasa iba't ibang bloke ang mga ito) o maraming $Z$ error (basta't kahit isang bloke lamang ang nakakaranas ng kakaibang bilang ng mga ito) — ngunit sa pagsulong, ang pinaka-relevant para sa layunin ng araling ito ay maaari tayong magwasto ng isang $X$ error, isang $Z$ error, o pareho sa alinmang qubit.

Pagbabawas ng error para sa mga random na error

Bago tayo lumipat sa huling seksyon ng aralin, na tumutukoy sa mga arbitrary na quantum error, pag-usapan natin nang maikli ang performance ng 9-qubit na Shor code kapag ang mga error na kinakatawan ng mga Pauli matrix ay nagaganap nang random sa mga qubit.

Para maging mas kongkreto, isaalang-alang natin ang isang simpleng noise model kung saan ang mga error ay nagaganap nang nakapag-iisa sa mga qubit, na ang bawat qubit ay nakakaranas ng error nang may probability na $p$, at walang kaugnayan sa pagitan ng mga error sa iba't ibang qubit — katulad ng binary symmetric channel para sa mga classical bit. Maaari tayong mag-assign ng iba't ibang probability para sa $X,$ $Y,$ at $Z$ error na magaganap, ngunit para panatilihing simple hangga't maaari, isasaalang-alang natin ang pinakamasahol na sitwasyon para sa 9-qubit na Shor code, na ang isang $Y$ error ang nagaganap sa bawat isa sa mga naapektuhang qubit. Ang isang $Y$ error, sa pamamagitan ng paraan, ay katumbas (hanggang sa isang irrelevant na global phase factor) ng parehong $X$ at $Z$ error na nagaganap sa parehong qubit, dahil $Y = iXZ.$ Ipinapaliwanag nito ang ating tila pagwawalang-bahala sa mga $Y$ error hanggang sa puntong ito.

Ngayon, ipagpalagay na ang $\mathsf{Q}$ ay isang qubit sa ilang partikular na estado na nais nating protektahan laban sa mga error, maaari nating isaalang-alang ang opsyon na gamitin ang 9-qubit na Shor code. Isang natural na tanong ang dapat itanong: "Dapat ba nating gamitin ito?"

Ang sagot ay hindi kinakailangang "oo." Kung masyadong maraming ingay, ibig sabihin sa kontekstong ito na masyadong malaki ang $p$, ang paggamit ng Shor code ay maaaring talagang magpalala ng mga bagay — tulad ng 3-bit repetition code na mas masahol kaysa sa walang code kapag ang $p$ ay mas malaki sa isa't kalahati. Ngunit, kung maliit lang ang $p$, ang sagot ay "oo," dapat nating gamitin ang code, dahil babawasan nito ang posibilidad na masira ang naka-encode na estado. Tingnan natin kung bakit ganito, at kung ano ang ibig sabihin para sa $p$ na masyadong malaki o maliit na sapat para sa code na ito.

Iniitiwa ng Shor code ang anumang Pauli error sa iisang qubit, kabilang ang isang $Y$ error siyempre, ngunit hindi nito naitutuwid nang wasto ang dalawa o higit pang mga $Y$ error. Para maging malinaw, inaasahan natin na ginagamit natin ang mga $X$ at $Z$ error correction na inilarawan kanina sa seksyon. (Siyempre, kung alam natin nang maaga na kailangan lamang nating mag-alala tungkol sa mga $Y$ error, natural na pipili tayo ng iba't ibang pagwawasto — ngunit iyan ay pandaraya sa noise model, at palagi tayong makakabago ng modelo sa pamamagitan ng pagpili ng iba't ibang Pauli error para gawing mabigo ang bagong pagpipiliang ito kapag naapektuhan ng mga error ang dalawa o higit pang qubit.)

Kaya, pinoprotektahan ng code ang $\mathsf{Q}$ basta't kahit isang qubit lamang sa siyam ang naapektuhan ng error, na nangyayari nang may probability na

$$(1-p)^9 + 9 p (1-p)^8.$$

Kung hindi, nang may probability na

$$1 - (1-p)^9 - 9 p (1-p)^8,$$

nabibigo ang code na protektahan ang $\mathsf{Q}.$

Sa partikular, ang ibig sabihin nito sa kontekstong ito ay, hanggang sa global phase, ang isang non-identity na Pauli operation ay ia-apply sa ating qubit na $\mathsf{Q}$ (bilang isang logical qubit). Ibig sabihin, kung ang mga $X$ at $Z$ error ay dide-detect at itatama para sa Shor code ayon sa inilarawan kanina sa aralin, matitirang may encoding ng isang estado na katumbas, hanggang sa global phase, ng encoding ng isang non-identity na Pauli operation na in-apply sa orihinal na estado ng $\mathsf{Q}.$ Ang mas maikling paraan para sabihin ito ay ang isang logical error ang nagaganap. Maaaring magkaroon o walang epekto iyon sa orihinal na estado ng $\mathsf{Q}$ — o sa ibang salita ang logical qubit na ating na-encode gamit ang siyam na physical qubit — ngunit, para sa layunin ng pagsusuring ito, itinuturing natin ang pangyayaring ito bilang kabiguan.

Sa kabilang banda, kung hindi tayo nag-abala sa paggamit ng code, ang ating isa at tanging qubit ay maaaring makaranas ng katulad na kapalaran (ng pagiging subject sa isang non-identity na Pauli operation) nang may probability na $p.$ Nakakatulong ang code kapag ang unang probability ay mas maliit kaysa sa pangalawa:

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

Narito ang isang plot na naglalarawan, para sa napakaliit na mga halaga ng $p,$ na nagbibigay ng kalamangan ang code, na ang break-even point ay nangyayari sa humigit-kumulang $0.0323.$

Kung ang $p$ ay mas maliit sa break-even point na ito, nakakatulong ang code; sa break-even point ay pantay ang mga probability, kaya't nasasayang lang ang ating oras kasama ang 8 qubit kung gagamitin natin ang code; at higit pa sa break-even point ay talagang hindi dapat gamitin ang code na ito dahil dinadagdagan nito ang posibilidad ng logical error sa $\mathsf{Q}.$

Ang tatlo at isang-kapat na porsyento o thereabouts ay maaaring hindi mukhang napakagandang break-even point, lalo na kung ikukumpara sa $50\%,$ na siyang katumbas na break-even point para sa 3-bit repetition code para sa classical information. Ang pagkakaibang ito ay, malaking bahagi nito, dahil sa katotohanang ang quantum information ay mas marupok at mas mahirap protektahan kaysa sa classical information. Ngunit pati na rin — habang kinikilala na ang 9-qubit na Shor code ay kumakatawan sa isang magiting na natuklasan, bilang unang quantum error correcting code sa mundo — dapat pati na rin itong kilalanin na hindi ito talaga isang napakagandang code sa mga praktikal na termino.