Toric code

Susunod, tatalakayin natin ang isang partikular na CSS code na kilala bilang ang toric code, na natuklasan ni Alexei Kitaev noong 1997. Sa katunayan, ang toric code ay hindi isang solong code kundi isang pamilya ng mga code — isa para sa bawat positibong integer simula sa 2. Mayroon itong ilang mahahalagang katangian:

• Ang mga stabilizer generator ay may mababang timbang, at partikular na lahat sila ay may timbang na 4. Sa wika ng coding theory, ang toric code ay halimbawa ng quantum low-density parity check code, o quantum LDPC code (kung saan ang mababa ay nangangahulugang 4 sa kasong ito). Maganda ito dahil ang bawat sukat ng stabilizer generator ay hindi kailangang isangkot ang napakaraming qubit.

• Ang toric code ay may geometric locality. Ibig sabihin, hindi lamang mababa ang timbang ng mga stabilizer generator, kundi posible rin na isaayos ang mga qubit sa espasyo upang bawat sukat ng stabilizer generator ay kinukuha lamang ang mga qubit na magkakatabi. Sa prinsipyo, mas madaling ipatupad ang mga sukat na ito kaysa sa mga kinukuhang mga qubit na malayo sa isa't isa sa espasyo.

• Ang mga miyembro ng pamilya ng toric code ay may lalong malaking distansya at kayang tiisin ang medyo mataas na rate ng error.

Paglalarawan ng toric code

Hayaan ang $L\geq 2$ na maging isang positibong integer, at isaalang-alang ang isang $L\times L$ lattice na may tinatawag na periodic na mga hangganan. Halimbawa, ilarawan ng figure na ito ang isang $L\times L$ lattice para sa $L=9.$

Mapapansin na ang mga linya sa kanan at sa ibaba ay mga may-putol na linya. Ito ay upang ipahiwatig na ang may-putol na linya sa kanan ay parehong linya ng linya sa pinakakaliwang bahagi, at gayundin, ang may-putol na linya sa ibaba ay parehong linya ng nasa pinakataas.

Upang matupad ang ganitong uri ng pagsasaayos nang pisikal ay nangangailangan ng tatlong dimensyon. Sa partikular, maaari nating gawin ang lattice sa anyo ng silindro sa pamamagitan ng pagtatambal ng kaliwa at kanang panig, pagkatapos ay baguhin ang silindro upang ang mga bilog sa mga dulo, na noon ay ang tuktok at ilalim na gilid ng lattice, ay magkita. O maaari nating itambal muna ang taas at ibaba bago ang mga gilid; gumagana sa dalawang paraan at walang pagkakaiba kung alin ang pinili natin para sa layunin ng talakayan na ito.

Ang makukuha natin ay isang torus — o sa madaling salita, isang donut (bagaman ang pag-iisip nito bilang panloob na tubo ng gulong ay marahil mas maayos na imahe dahil hindi ito solidong bagay: naging ibabaw lamang ng torus ang lattice). Dito nagmula ang pangalang "toric code."

Ang paraan ng "paglalakad" sa isang torus na tulad nito, sa pagitan ng mga katabing punto sa lattice, ay malamang na pamilyar sa mga naglaro ng mga lumang video game, kung saan ang paglabas sa itaas ng screen ay nagdudulot sa iyo ng paglabas sa ibaba, at gayundin para sa kaliwa at kanang gilid ng screen. Ganito ang ating pagtingin sa lattice na may periodic na mga hangganan, imbes na talakayin nang tiyak ang isang torus sa 3-dimensional na espasyo.

Susunod, ang mga qubit ay inilalagay sa mga gilid ng lattice na ito, tulad ng ilustrasyon sa sumusunod na figure, kung saan ang mga qubit ay ipinahihiwatig ng mga solid na asul na bilog.

Tandaan na ang mga qubit na nakalagay sa mga may-putol na linya ay hindi solid dahil kinakatawan na sila sa mga pinakamataas at pinakakaliwang linya ng lattice. Sa kabuuan, mayroon $2L^2$ na qubit: $L^2$ na qubit sa mga pahalang na linya at $L^2$ na qubit sa mga patayong linya.

Para mailarawan ang toric code mismo, kailangan pa nating ilarawan ang mga stabilizer generator:

• Para sa bawat tile na nabuo ng mga linya sa lattice, mayroong isang $Z$ stabilizer generator, na nakuha sa pamamagitan ng pag-tensor ng mga $Z$ matrix sa apat na qubit na dumadampi sa tile na iyon kasama ang mga identity matrix sa lahat ng iba pang qubit.

• Para sa bawat vertex na nabuo ng mga linya sa lattice, mayroong isang $X$ stabilizer generator, na nakuha sa pamamagitan ng pag-tensor ng mga $X$ matrix sa apat na qubit na katabi ng vertex na iyon kasama ang mga identity matrix sa lahat ng iba pang qubit.

Sa dalawang kaso, nakakakuha tayo ng weight-4 na Pauli operation. Indibidwal na, ang mga stabilizer generator na ito ay maaaring mailarawan tulad ng sumusunod.

Narito ang isang ilustrasyon na nagpapakita ng ilang halimbawa ng mga stabilizer generator sa konteksto ng lattice mismo. Mapapansin na kasama ang mga stabilizer generator na nakabalot sa paligid ng mga periodic na hangganan. Ang mga generator na nakabalot sa paligid ng mga periodic na hangganan ay hindi espesyal o sa anumang paraan ay natatangi mula sa mga hindi nakabalot.

Ang mga stabilizer generator ay kailangang mag-commute para maging isang wastong stabilizer code ito. Tulad ng dati, ang lahat ng $Z$ stabilizer generator ay nagko-commute sa isa't isa, dahil nagko-commute ang $Z$ sa sarili nito at nagko-commute ang identity sa lahat ng bagay, at gayundin para sa mga $X$ stabilizer generator. Ang mga $Z$ at $X$ stabilizer generator ay malinaw na nagko-commute kapag kumikilos sila nang nontrivially sa magkaparehong mga qubit, tulad ng sa mga halimbawa sa nakaraang figure. Ang natitirang posibilidad ay ang isang $Z$ stabilizer generator at isang $X$ stabilizer generator ay magkapatong sa mga qubit na pinagkilosan nila nang nontrivially, at sa tuwing nangyayari ito ang mga generator ay laging nagkakapatong sa dalawang qubit, tulad sa susunod na figure.

Dahil dito, dalawang stabilizer generator na tulad nito ay nagko-commute, tulad ng nagko-commute ang $Z\otimes Z$ at $X\otimes X$. Kaya nagko-commute ang lahat ng stabilizer generator sa isa't isa.

Ang pangalawang kinakailangang kondisyon sa mga stabilizer generator para sa isang stabilizer code ay ang mga ito ay bumubuo ng isang minimal generating set. Ang kondisyong ito ay hindi natutupad ng koleksyong ito: kapag pinarami natin ang lahat ng $Z$ stabilizer generator, makukuha natin ang identity operation, at gayundin para sa mga $X$ stabilizer generator. Kaya, maaaring ipahayag ang anumang isa sa mga $Z$ stabilizer generator bilang produkto ng lahat ng natitirang isa, at gayundin, maaaring ipahayag ang anumang isa sa mga $X$ stabilizer generator bilang produkto ng natitirang mga $X$ stabilizer generator. Kung aalisin natin ang anumang isa sa mga $Z$ stabilizer generator at anumang isa sa mga $X$ stabilizer generator, makakakuha tayo ng isang minimal generating set.

Para maging malinaw tungkol dito, pantay-pantay ang ating pagpapahalaga sa lahat ng mga stabilizer generator, at sa mahigpit na operational na paraan walang pangangailangan na pumili ng isang stabilizer generator ng bawat uri upang alisin. Ngunit, para sa layunin ng pag-aanalisa ng code — at pagbibilang ng mga generator lalo na — maaari nating isipin na isang stabilizer generator ng bawat uri ang naalis, upang makakuha tayo ng minimal generating set, habang isinaalang-alang na lagi nating maipapaliwanag ang mga resulta ng mga naalis na generator na ito (iniisip ang mga ito bilang mga observable) mula sa mga resulta ng lahat ng iba pang stabilizer generator observable ng parehong uri.

Nag-iiwan ito ng $L^2 - 1$ na stabilizer generator ng bawat uri, o $2L^2 - 2$ sa kabuuan, sa isang (hypothetical) minimal generating set. Dahil mayroon $2L^2$ na qubit sa kabuuan, nangangahulugan ito na ang toric code ay nag-e-encode ng $2L^2 - 2 (L^2 - 1) = 2$ na qubit.

Ang huling kinakailangang kondisyon ng mga stabilizer generator ay ang kahit isang quantum state vector ay naayos ng lahat ng stabilizer generator. Makikita natin na ito ay ang kaso habang nagpapatuloy tayo sa pagsusuri ng code, ngunit posible rin na mag-isip na walang paraan upang makabuo ng $-1$ beses ng identity sa lahat ng $2L^2$ na qubit mula sa mga stabilizer generator.

Pag-detect ng mga error

Ang toric code ay may simpleng at eleganteng paglalarawan, ngunit ang mga katangian nito sa quantum error correction ay maaaring hindi malinaw sa unang tingin. Lumalabas na ito ay isang kamangha-manghang code! Para maunawaan kung bakit at paano ito gumagana, simulan natin sa pag-isip ng iba't ibang error at ang mga syndrome na nabubuo nila.

Ang toric code ay isang CSS code, dahil lahat ng ating stabilizer generator ay alinman sa $Z$ o $X$ stabilizer generator. Nangangahulugan ito na ang mga $X$ error at $Z$ error ay maaaring ma-detect (at posibleng maayos) nang hiwalay. Sa katunayan, mayroong simpleng symmetry sa pagitan ng mga $Z$ at $X$ stabilizer generator na nagbibigay-daan sa atin na suriin ang mga $X$ error at $Z$ error sa halos parehong paraan. Kaya, magtutuon tayo sa mga $X$ error, na posibleng nade-detect ng mga $Z$ stabilizer generator — ngunit ang buong talakayan na sumusunod ay maaaring isalin mula sa mga $X$ error patungo sa mga $Z$ error, na katulad na nade-detect ng mga $X$ stabilizer generator.

Ang sumusunod na diagram ay nagpapakita ng epekto ng isang $X$ error sa isang qubit. Dito, ang pagpapalagay ay ang ating $2L^2$ na qubit ay dati ay nasa isang estado na nasa loob ng code space ng toric code, na nagdudulot sa lahat ng sukat ng stabilizer generator na maglabas ng $+1.$ Ang mga $Z$ stabilizer generator ay nagde-detect ng mga $X$ error, at mayroon isang naturang stabilizer generator para sa bawat tile sa figure, kaya maaari nating ipahiwatig ang resulta ng sukat ng kaukulang stabilizer generator sa pamamagitan ng kulay ng tile na iyon: ang mga $+1$ na resulta ay ipinahihiwatig ng mga puting tile at ang mga $-1$ na resulta ay ipinahihiwatig ng mga kulay-abong tile. Kapag nangyari ang isang bit-flip error sa isa sa mga qubit, ang epekto ay ang mga sukat ng stabilizer generator na kaukulang sa dalawang tile na dumadampi sa apektadong qubit ay naglalabas na ngayon ng $-1.$

Ito ay malintuindihan kapag isinaalang-alang natin ang mga $Z$ stabilizer generator at kung paano sila kumikilos. Sa esensya, ang bawat $Z$ stabilizer generator ay sumusukat ng parity ng apat na qubit na dumadampi sa kaukulang tile (kaugnay sa standard na batayan). Kaya, ang isang $+1$ na resulta ay hindi nagpapahiwatig na walang $X$ error na nangyari sa apat na qubit na ito, kundi nagpapahiwatig ito na ang pantay na bilang ng mga $X$ error ay nangyari sa mga qubit na ito, habang ang isang $-1$ na resulta ay nagpapahiwatig na ang gansal na bilang ng mga $X$ error ay nangyari. Ang isang $X$ error ay nagbabago ng parity ng apat na bit sa parehong tile na dinadampi nito, na nagdudulot sa mga sukat ng stabilizer generator na maglabas ng $-1.$

Susunod, dalhin natin ang maraming $X$ error upang makita kung ano ang mangyayari. Sa partikular, isasaalang-alang natin ang isang chain ng magkakatabi na $X$ error, kung saan ang dalawang $X$ error ay magkatabi kapag nakaapekto sila sa mga qubit na dumadampi sa parehong tile.

Ang dalawang $Z$ stabilizer generator sa mga dulo ng chain ay parehong nagbibigay ng $-1$ na resulta sa kasong ito, dahil ang gansal na bilang ng mga $X$ error ay nangyari sa dalawang kaukulang tile. Lahat ng iba pang $Z$ stabilizer generator, sa kabilang banda, ay nagbibigay ng $+1$ na resulta, kasama na ang mga dumadampi sa chain ngunit hindi sa mga dulo, dahil ang pantay na bilang ng mga $X$ error ay nangyari sa mga qubit na dumadampi sa kaukulang tile.

Kaya, hangga't mayroon tayong isang chain ng mga $X$ error na may mga dulo, madi-detect ng toric code na nangyari ang mga error, na nagresulta sa mga $-1$ na resulta ng sukat para sa mga $Z$ stabilizer generator na kaukulang sa mga dulo ng chain. Tandaan na ang aktwal na chain ng mga error ay hindi nahayag, ang mga dulo lamang! Okey lang ito — sa susunod na subseksyon makikita natin na hindi natin kailangang malaman nang eksakto kung aling mga qubit ang naapektuhan ng mga $X$ error para maayos ang mga ito. (Ang toric code ay halimbawa ng isang lubhang degenerate na code, sa kahulugang hindi nito karaniwang natutukoy nang natatangi ang mga error na inaayos nito.)

Gayunpaman, posible para sa isang chain ng magkakatabi na $X$ error na walang mga dulo, ibig sabihin ang isang chain ng mga error ay maaaring bumuo ng isang closed loop, tulad sa sumusunod na figure.

Sa ganitong kaso, ang pantay na bilang ng mga $X$ error ay nangyari sa bawat tile, kaya ang bawat sukat ng stabilizer generator ay nagresulta sa isang $+1$ na resulta. Ang mga closed loop ng magkakatabi na $X$ error ay hindi kaya nde-detect ng code.

Maaaring mapabigo ito, dahil kailangan lamang natin ng apat na $X$ error upang bumuo ng closed loop (at umaasa tayo sa isang bagay na mas mabuti kaysa sa isang distance 4 code). Gayunpaman, ang isang closed loop ng mga $X$ error ng anyo na inilarawan sa nakaraang figure ay hindi talaga isang error — dahil nasa stabilizer ito! Tandaan na, bukod sa mga $Z$ stabilizer generator, mayroon din tayong isang $X$ stabilizer generator para sa bawat vertex sa lattice. At kapag pinarami natin ang magkakatabi na $X$ stabilizer generator, ang resulta ay makakakuha tayo ng mga closed loop ng mga $X$ operation. Halimbawa, ang closed loop sa nakaraang figure ay maaaring makuha sa pamamagitan ng pagpaparami ng mga $X$ stabilizer generator na ipinahihiwatig sa sumusunod na figure.

Ngunit, hindi ito ang tanging uri ng closed loop ng mga $X$ error na maaari nating magkaroon — at hindi totoong ang bawat closed loop ng mga $X$ error ay kasama sa stabilizer. Sa partikular, maaaring ilarawan ang iba't ibang uri ng loop tulad ng sumusunod.

1. Mga closed loop ng mga $X$ error na may pantay na bilang ng mga $X$ error sa bawat pahalang na linya at bawat patayong linya ng mga qubit. (Ang halimbawa na ipinakita sa itaas ay nahuhulog sa kategoryang ito.) Ang mga loop ng ganitong anyo ay laging nasa stabilizer, dahil epektibo silang maaaring bawasan sa wala sa pamamagitan ng pagpaparami nila ng mga $X$ stabilizer generator.

2. Mga closed loop ng mga $X$ error na may gansal na bilang ng mga $X$ error sa kahit isang pahalang na linya o kahit isang patayong linya ng mga qubit. Ang mga loop ng ganitong anyo ay hindi kailanman nasa stabilizer at kaya kumakatawan sa mga nontrivial na error na hindi nade-detect ng code.

Isang halimbawa ng isang closed loop ng mga $X$ error sa ikalawang kategorya ay ipinapakita sa sumusunod na diagram.

Ang ganitong chain ng mga error ay hindi nasa stabilizer dahil ang bawat $X$ stabilizer generator ay naglalagay ng pantay na bilang ng mga $X$ operation sa bawat pahalang na linya at bawat patayong linya ng mga qubit. Ito ay kaya isang aktwal na halimbawa ng nontrivial na error na nabigo ang code na ma-detect.

Ang susi ay ang tanging paraan upang bumuo ng loop ng pangalawang uri ay ang pag-ikot sa paligid ng torus, ibig sabihin alinman sa paligid ng butas sa gitna ng torus, sa loob nito, o pareho. Intuitibong nagsasalita, ang isang chain ng mga $X$ error na tulad nito ay hindi maaaring bawasan sa wala sa pamamagitan ng pagpaparami nito ng mga $X$ stabilizer generator dahil pinipigilan ito ng topology ng isang torus. Ang toric code ay minsan naka-kategorya bilang isang topological na quantum error correcting code para sa kadahilanang ito. Ang pinakamaikling naturang loop ay $L,$ at kaya ito ang distansya ng toric code: ang anumang closed loop ng mga $X$ error na may haba na mas maikli sa $L$ ay kailangang nahuhulog sa unang kategorya, at kaya nasa stabilizer; at ang anumang chain ng mga $X$ error na may mga dulo ay nade-detect ng code.

Dahil ang toric code ay gumagamit ng $2L^2$ na qubit upang i-encode ang $2$ qubit at may distansyang $L,$ sumusunod na ito ay isang $[[2L^2,2,L]]$ stabilizer code.

Pag-ayos ng mga error

Tinalakay na natin ang pag-detect ng error para sa toric code, at ngayon ay maikling tatalakayin natin kung paano ayusin ang mga error. Ang toric code ay isang CSS code, kaya ang mga $X$ error at $Z$ error ay maaaring ma-detect at maayos nang hiwalay. Pinanatili ang ating pokus sa mga $Z$ stabilizer generator, na nagde-detect ng mga $X$ error, isaalang-alang natin kung paano maayos ang isang chain ng mga $X$ error. (Ang mga $Z$ error ay naayos sa isang simetrikal na paraan.)

Kung lumitaw ang isang syndrome na naiiba sa $(+1,\ldots,+1)$ syndrome kapag sinusukat ang mga $Z$ stabilizer generator, ang mga $-1$ na resulta ay nagpapakita ng mga dulo ng isa o higit pang chain ng mga $X$ error. Maaari nating subukang ayusin ang mga error na ito sa pamamagitan ng pagtatambal ng mga $-1$ na resulta at pagbuo ng isang chain ng mga $X$ correction sa pagitan nila. Kapag ginagawa ito, makatuwirang pumili ng pinakamaikling landas kung saan nagaganap ang mga correction.

Halimbawa, isaalang-alang ang sumusunod na diagram, na nagpapakita ng isang syndrome na may dalawang $-1$ na resulta, ipinahihiwatig ng mga kulay-abong tile, na dulot ng isang chain ng mga $X$ error na ilustrado ng magentang linya at mga bilog. Tulad ng nabanggit na natin, ang chain mismo ay hindi nahayag ng syndrome; ang mga dulo lamang ang nakikita.

Upang subukang ayusin ang chain ng mga error na ito, isang pinakamaikling landas sa pagitan ng mga $-1$ na resulta ng sukat ay pinipili at ang mga $X$ gate ay inilalapat bilang mga correction sa mga qubit kasama ang landas na ito (ipinahihiwatig sa dilaw sa figure). Bagaman ang mga correction ay maaaring hindi tumugma sa aktwal na chain ng mga error, ang mga error at correction na magkasama ay bumubuo ng isang closed loop ng mga $X$ operation na nasa stabilizer ng code. Ang correction ay samakatuwid ay matagumpay sa sitwasyong ito, dahil ang pinagsama-samang epekto ng mga error at correction ay walang ginagawa sa isang encoded state.

Ang estratehiyang ito ay hindi laging magiging matagumpay. Halimbawa, isang iba pang paliwanag para sa parehong syndrome gaya ng sa nakaraang figure ay ipinapakita sa sumusunod na figure.

Sa pagkakataong ito, ang parehong chain ng mga correction gaya ng dati ay nabigo na ayusin ang chain ng mga error na ito, dahil ang pinagsama-samang epekto ng mga error at correction ay ang makakuha tayo ng isang closed loop ng mga $X$ operation na nakabalot sa paligid ng torus, at kaya may nontrivial na epekto sa code space. Kaya, walang garantiya na ang estratehiya na kakabanggit, ng pagpili ng pinakamaikling landas ng mga $X$ correction sa pagitan ng dalawang $-1$ na resulta ng syndrome, ay maayos na maaayos ang error na nagdulot ng syndrome na ito.

Marahil mas malamang, depende sa noise model, ang isang syndrome na may higit sa dalawang $-1$ na entry ay sinusukat, tulad ng mungkahi ng sumusunod na figure.

Sa ganitong kaso, may iba't ibang kilalang estratehiya sa correction. Ang isang natural na estratehiya ay ang pagtatangkang ipares ang mga $-1$ na resulta ng sukat at magsagawa ng mga correction kasama ang mga pinakamaikling landas na nagkokonekta sa mga pares, tulad ng ipinahihiwatig sa figure sa dilaw. Sa partikular, maaaring kalkulahin ang isang minimum-weight perfect matching sa pagitan ng mga $-1$ na resulta ng sukat, at pagkatapos ay ang mga pares ay kinokonekta ng mga pinakamaikling landas ng mga $X$ correction. Ang pagkalkula ng isang minimum-weight perfect matching ay maaaring gawin nang mahusay sa isang klasikal na algorithm na kilala bilang ang blossom algorithm, na natuklasan ni Edmonds noong dekada 1960.

Ang diskarteng ito ay karaniwang hindi optimal para sa mga pinakakaraniwan na pinag-aaralang noise model, ngunit batay sa mga numerical simulation ito ay napakabisa sa pagsasagawa sa ibaba ng noise rate na humigit-kumulang 10%, kung ang mga independent na Pauli error ay ipinapalagay kung saan ang $X,$ $Y,$ at $Z,$ ay pantay na malamang. Ang pagpapalaki ng $L$ ay walang malaking epekto sa break-even point kung saan nagsisimula ang code na makatulong, ngunit nagdudulot ng mas mabilis na pagbaba sa probabilidad ng isang logical error habang bumababa ang error rate nang lampas sa break-even point.