Pagkontrol sa pagkalat ng error

Ang fault-tolerant quantum computation ay katulad ng isang karera sa pagitan ng mga error at ng error correction. Kung sapat na kaunti ang bilang ng mga error, matagumpay na maitutuwid ng error correction ang mga ito; ngunit kung masyadong marami, mabibigo ang error correction.

Dahil dito, kailangang bigyan ng sapat na pansin ang paraan ng pagsasagawa ng quantum computations sa fault-tolerant na mga implementasyon ng mga circuit, upang makontrol ang pagkalat ng error. Ibig sabihin, ang isang error sa isang qubit ay maaaring kumalat sa maraming qubit sa pamamagitan ng pagkilos ng mga gate sa isang quantum circuit, na maaaring magdulot ng dramatikong pagtaas ng bilang ng mga error. Ito ay isang napakahalgang alalahanin, dahil kung hindi natin makontrol ang pagkalat ng error, ang ating mga pagsisikap sa error correction ay mabilis na malulubos ng mga error. Kung, sa kabilang banda, kaya nating kontrolin ang pagkalat ng mga error, mayroon namang pagkakataon ang error correction na makasabay, na nagbibigay-daan sa mga error na matuwid nang sapat para mapatakbo nang maayos ang quantum computation.

Ang simula ng teknikal na talakayan ng isyung ito ay ang pagkilala na ang two-qubit gates (o multiple-qubit gates sa pangkalahatan) ay maaaring magkalat ng mga error, kahit na perpekto ang kanilang paggana. Halimbawa, isaalang-alang ang isang controlled-NOT gate, at ipagpalagay na may $X$ error na nangyayari sa control qubit bago pa man isagawa ang controlled-NOT gate. Tulad ng napansin na natin sa aralin na "Correcting quantum errors", ito ay katumbas ng isang $X$ error na nangyayari sa parehong qubit pagkatapos isagawa ang controlled-NOT. At katulad ang sitwasyon para sa isang $Z$ error na kumikilos sa target sa halip na ang control bago pa man isagawa ang controlled-NOT gate.

Ito ay isang pagkalat ng mga error, dahil ang masamang posisyon ng isang $X$ o $Z$ error bago ang controlled-NOT gate ay epektibong ginagawang dalawang error pagkatapos ng controlled-NOT gate. Nangyayari ito kahit perpekto ang controlled-NOT gate, at hindi natin dapat kalimutan na ang isang partikular na controlled-NOT gate ay maaaring mismo ay may ingay, na maaaring lumikha ng mga correlated na error sa dalawang qubit.

Dagdag pa sa ating alalahanin ay ang katotohanan na ang mga kasunod na two-qubit gate ay maaaring magpalat pa ng mga error na ito, gaya ng iminumungkahi ng sumusunod na pigura.

Sa ilang paraan, hindi natin ito maiwasan; hangga't gumagamit tayo ng multiple-qubit gates, laging may potensyal na pagkalat ng error. Gayunpaman, tulad ng tatalakayin natin sa mga subseksyon na susunod, may mga hakbang na maaaring gawin upang limitahan ang pinsalang dulot nito, na nagbibigay-daan sa pamamahala ng mga kumakalat na error.

Mga transversal gate implementation

Ang pinakasimpleng kilalang paraan upang mabawasan ang pagkalat ng error sa fault-tolerant quantum circuits ay ang pagpapatupad ng mga gate nang transversally, na nangangahulugang ang pagbuo ng mga gadget para sa mga ito na may isang partikular na simpleng anyo. Partikular, ang mga gadget ay dapat na isang tensor product ng mga operasyon (o, sa madaling salita, isang depth-one quantum circuit), kung saan ang bawat operasyon ay maaari lamang kumilos sa isang qubit posisyon sa loob ng bawat code block na naabot nito. Marahil ito ay pinakamadaling ipaliwanag sa pamamagitan ng mga halimbawa.

Mga halimbawa ng transversal gate implementation

Isaalang-alang ang sumusunod na pigura, na nagmumungkahi ng isang transversal na implementasyon ng isang CNOT gate. (Ang partikular na implementasyong ito, kung saan ang mga CNOT ay isinasagawa qubit sa qubit, ay gumagana lamang para sa mga CSS code — ngunit totoo naman, gumagana ito para sa lahat ng CSS code.)

Mayroong dalawang code block sa pigura na ito, bawisa ay inilalarawan na binubuo ng limang qubit (kahit na maaaring mas marami pa, tulad ng naipahiwatig na). Ang circuit sa kanan ay may depth one, at ang bawat CNOT gate ay kumikilos sa isang qubit posisyon sa loob ng bawat block: ang control at target para sa unang CNOT ay ang pinakamataas na qubit (iyon ay, qubit 0 gamit ang Qiskit numbering convention), ang control at target para sa pangalawang CNOT ay ang qubit pangalawa mula sa itaas (iyon ay, qubit 1), at iba pa. Kaya naman, ito ay isang transversal na gadget.

Para sa pangalawang halimbawa — talagang isang klase ng mga halimbawa — isaalang-alang ang anumang Pauli gate. Ang mga Pauli gate ay palaging maaaring ipatupad nang transversally, para sa anumang stabilizer code, sa pamamagitan ng pagbuo ng mga gadget na binubuo ng mga Pauli operation. Partikular, ang bawat Pauli operation sa isang logical qubit na naka-encode ng isang stabilizer code ay maaaring ipatupad nang transversally sa pamamagitan ng pagpili ng naaangkop na Pauli operation sa mga pisikal na qubit na ginagamit para sa encoding. Ito ay naaayon sa isang katotohanang binanggit nang mabilis sa aralin na "Stabilizer formalism": hanggang sa isang global phase, ang mga Pauli operation na nagko-commute sa bawat stabilizer generator ng isang stabilizer code ay kumikilos tulad ng mga Pauli operation sa qubit o mga qubit na naka-encode ng code na iyon.

Bilang isang tiyak na halimbawa, isaalang-alang ang $9$-qubit Shor code, kung saan ang mga standard basis state ay maaaring i-encode tulad ng sumusunod.

$$\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) \\[3mm] \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}$$

Ang isang $X$ gate sa logical qubit na naka-encode ng code na ito ay maaaring ipatupad nang transversally ng $9$-qubit Pauli operation na

$$Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I}$$

habang ang isang $Z$ gate sa logical qubit ay maaaring ipatupad nang transversally ng $9$-qubit Pauli operation na

$$X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}.$$

Ang parehong mga Pauli operation na ito ay may weight na $3,$ na siyang pinakamababang weight na kinakailangan. (Ang $9$-qubit Shor code ay may distance na $3,$ kaya ang anumang hindi-identity Pauli operation na may weight na $2$ o mas mababa ay natukoy bilang isang error.)

At, para sa ikatlong halimbawa, ang $7$-qubit Steane code (at talagang bawat color code) ay nagbibigay-daan sa transversal na implementasyon ng lahat ng Clifford gate. Nakita na natin kung paano ang mga CNOT gate ay ipinatupad nang transversally para sa anumang CSS code, kaya nananatili pa ring isaalang-alang ang mga $H$ at $S$ gate. Ang isang Hadamard gate na inilapat sa lahat ng $7$ qubit ng Steane code ay katumbas ng $H$ na inilapat sa logical qubit na naka-encode nito, habang ang isang $S^{\dagger}$ gate (kumpara sa isang $S$ gate) na inilapat sa lahat ng $7$ qubit ay katumbas ng isang logical $S$ gate.

Pagkalat ng error para sa mga transversal gadget

Ngayong alam na natin kung ano ang mga transversal na implementasyon ng mga gate, talakayin natin ang kanilang koneksyon sa pagkalat ng error.

Para sa isang transversal na implementasyon ng isang single-qubit gate, mayroon lamang tayong tensor product ng mga single-qubit gate sa ating gadget, na kumikilos sa isang code block ng mga pisikal na qubit para sa napiling quantum error correcting code. Kahit na ang alinman sa mga gate na ito ay maaaring mabigo at magpakilala ng isang error, wala itong pagkalat ng mga error dahil walang multiple-qubit gate na kasangkot. Kaagad pagkatapos mailapat ang gadget, ang error correction ay isasagawa; at kung sapat na maliit ang bilang ng mga error na ipinakilala ng gadget (o habang isinasagawa ang gadget), ang mga error ay maitutuwid. Kaya, kung sapat na maliit ang rate ng mga error na ipinakilala ng mga sira-sirang gate, mayroon namang magandang pagkakataon ang error correction na magtagumpay.

Para sa isang transversal na implementasyon ng isang two-qubit gate, sa kabilang banda, may potensyal para sa pagkalat ng mga error — walang paraan upang maiwasan ito, tulad ng napansin na natin. Ang mahalagang punto, gayunpaman, ay ang isang transversal na gadget ay hindi kailanman maaaring magdulot ng pagkalat ng mga error sa loob ng isang code block.

Halimbawa, isaalang-alang ang transversal na implementasyon ng isang CNOT gate para sa isang CSS code na inilarawan sa itaas, maaaring may $X$ error na mangyari sa pinakamataas na qubit ng nangungunang code block bago isagawa ang gadget, at ang unang CNOT sa loob ng gadget ay magkakalat ng error na iyon sa pinakamataas na qubit sa mas mababang block. Gayunpaman, ang dalawang nagresultang error ay nasa hiwalay na code block na ngayon. Kaya, ipagpalagay na ang ating code ay maaaring itama ang isang $X$ error, ang mga hakbang sa error correction na nangyayari pagkatapos ng gadget ay maitutuwid ang dalawang $X$ error nang isa-isa — dahil isang error lamang ang nangyayari sa loob ng bawat code block. Sa kaibahan, kung ang pagkalat ng error ay mangyayari sa loob ng parehong code block, maaari nitong gawing high-weight error ang isang low-weight error na hindi na kayang harapin ng code.

Hindi-universalidad ng mga transversal gate

Para sa dalawang magkaibang stabilizer code, maaaring posible ang transversal na implementasyon ng isang partikular na gate gamit ang isang code ngunit hindi sa isa pa. Halimbawa, habang hindi posible na ipatupad ang isang $T$ gate nang transversally gamit ang $7$-qubit Steane code, may iba pang mga code para sa kung saan ito ay posible.

Sa kasamaang palad, hindi kailanman posible, para sa anumang hindi-trivial na quantum error correcting code, na ipatupad ang isang universal na hanay ng mga gate nang transversally. Ang katotohanang ito ay kilala bilang Eastin-Knill theorem.

Teorema

Eastin-Knill theorem: Para sa anumang quantum error correcting code na may distance na hindi bababa sa 2, ang hanay ng mga logical gate na maaaring ipatupad nang transversally ay bumubuo ng isang hanay ng mga operasyon na (hanggang sa isang global phase) ay discrete, at samakatuwid ay hindi universal.

Ang patunay ng teoremang ito ay hindi ipapaliwanag dito. (Hindi ito isang kumplikadong patunay, ngunit nangangailangan ng pangunahing kaalaman sa Lie groups at Lie algebras, na hindi kabilang sa mga paunang kinakailangan ng serye.) Ang pangunahing ideya, gayunpaman, ay maaaring ipaliwanag sa intuitive na paraan: Ang mga walang katapusang pamilya ng mga transversal na operasyon ay hindi maaaring manatili sa loob ng code space ng isang hindi-trivial na code dahil ang maliliit na pagkakaiba sa mga transversal na operasyon ay mahusay na napro-approximate ng mga low-weight Pauli operation, na natutukoy ng code bilang mga error.

Sa buod, nag-aalok ang mga transversal gadget ng isang simple at likas na fault-tolerant na implementasyon ng mga gate — ngunit para sa anumang makatuwirang pagpili ng quantum error correcting code, wala kailanman ang isang universal gate set na maaaring ipatupad sa ganitong paraan, na nagpapailalim sa paggamit ng mga alternatibong gadget.

Mga magic state

Dahil hindi posible, para sa anumang hindi-trivial na pagpili ng quantum error correcting code, na ipatupad nang transversally ang isang universal na hanay ng mga quantum gate, kailangan nating isaalang-alang ang iba pang mga paraan upang ipatupad ang mga gate nang fault-tolerantly. Ang isang kilalang pamamaraan ay batay sa konsepto ng mga magic state, na mga quantum state ng mga qubit na nagbibigay-daan sa fault-tolerant na implementasyon ng ilang partikular na gate.

Pagpapatupad ng mga gate gamit ang mga magic state

Magsimula tayo sa pagsasaalang-alang ng mga $S$ at $T$ gate, na may mga matrix description tulad ng sumusunod.

$$S = \begin{pmatrix} 1 & 0\\ 0 & i \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/2} \end{pmatrix} \qquad\text{and}\qquad T = \begin{pmatrix} 1 & 0\\ 0 & \frac{1+i}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/4} \end{pmatrix}$$

Sa kahulugan, ang $S$ ay isang Clifford operation, habang ang $T$ ay hindi; hindi posible na ipatupad ang isang $T$ gate gamit ang isang circuit na binubuo ng mga Clifford gate ($H$ gate, $S$ gate, at CNOT gate).

Gayunpaman, posible na ipatupad ang isang $T$ gate (hanggang sa isang global phase) gamit ang isang circuit na binubuo ng mga Clifford gate kung, bukod pa rito, mayroon tayong kopya ng state na

$$T\vert {+} \rangle = \frac{1}{\sqrt{2}} \vert 0 \rangle + \frac{e^{i\pi/4}}{\sqrt{2}} \vert 1\rangle,$$

at pinapayagan natin ang mga standard basis measurement at ang mga gate na classically controlled. Partikular, ang sumusunod na circuit ay nagpapakita ng isang paraan upang gawin ito. Ang kababalaghang ipinapakita dito ay isang medyo simplipikadong halimbawa ng quantum gate teleportation.

Upang masuri kung gumagana nang tama ang circuit na ito, maaari muna nating kalkulahin ang pagkilos ng CNOT gate sa input.

$$T \vert {+} \rangle \otimes \vert\psi\rangle \stackrel{\text{CNOT}}{\longmapsto} \frac{1}{\sqrt{2}} \vert 0\rangle \otimes T \vert \psi\rangle + \frac{1+i}{2} \vert 1\rangle \otimes T^{\dagger} \vert \psi\rangle$$

Ang measurement ay nagbibigay ng mga resulta na $0$ at $1$ nang may pantay na posibilidad. Kung ang resulta ay $0,$ hindi isasagawa ang $S$ gate, at ang output state ay $T\vert\psi\rangle;$ at kung ang resulta ay $1,$ isasagawa ang $S$ gate, at ang output state ay $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle.$

Ang state na $T\vert {+}\rangle$ ay tinatawag na isang magic state sa kontekstong ito, kahit na hindi ito natatangi sa aspektong ito: ang iba pang mga state ay tinatawag din na magic state kapag maaari silang gamitin sa katulad na paraan (para sa posibleng iba't ibang gate at gamit ang iba't ibang circuit). Halimbawa, ang pagpapalit ng state na $T\vert{+}\rangle$ ng state na $S\vert{+}\rangle$ at ang pagpapalit ng $S$ gate sa circuit sa itaas ng isang $Z$ gate ay nagpapatupad ng isang $S$ gate — na posibleng kapaki-pakinabang para sa fault-tolerant quantum computation gamit ang isang code kung saan ang mga $S$ gate ay hindi maaaring ipatupad nang transversally.

Fault-tolerant na mga gadget mula sa mga magic state

Maaaring hindi malinaw na ang paggamit ng mga magic state upang ipatupad ang mga gate ay kapaki-pakinabang para sa fault-tolerance. Para sa implementasyon ng $T$ gate na inilarawan sa itaas, halimbawa, tila kailangan pa rin nating ilapat ang isang $T$ gate sa isang $\vert{+}\rangle$ state upang makuha ang isang magic state, na pagkatapos ay gagamitin natin upang ipatupad ang isang $T$ gate. Kaya ano ang kalamangan ng paggamit ng pamamaraang ito para sa fault-tolerance?

Narito ang tatlong pangunahing punto na nagbibigay ng sagot sa tanong na ito.

1. Ang paglikha ng mga magic state ay hindi nangangailangan ng pagpapatupad ng gate na sinisikap nating ipatupad sa isang partikular na state. Halimbawa, ang pagpapatupad ng isang $T$ gate sa isang $\vert {+} \rangle$ state ay hindi ang tanging paraan upang makuha ang isang $T\vert{+}\rangle$ state.

2. Ang paglikha ng mga magic state ay maaaring gawin nang hiwalay sa computation kung saan ginagamit ang mga ito. Nangangahulugan ito na ang mga error na nagmumula sa proseso ng paglikha ng magic state ay hindi makakalat sa aktwal na computation na isinasagawa.

3. Kung ang mga indibidwal na gate sa circuit na nagpapatupad ng isang napiling gate gamit ang isang magic state ay maaaring ipatupad nang fault-tolerantly, at ipagpalagay natin ang pagkakaroon ng mga magic state, makakakuha tayo ng fault-tolerant na implementasyon ng napiling gate.

Upang pasimplehin ang talakayan na susunod, mag-focus tayo sa mga $T$ gate nang partikular — tandaan na ang pamamaraan ay maaaring palawakin sa iba pang mga gate. Ang isang fault-tolerant na implementasyon ng isang $T$ gate gamit ang mga magic state ay may anyo na iminumungkahi ng sumusunod na pigura.

Ang mga qubit sa orihinal na $T$-gate circuit ay tumutugma sa mga logical qubit sa diagram na ito, na naka-encode ng anumang code na ginagamit natin para sa fault-tolerance. Ang mga input at output sa diagram ay dapat na maunawaan bilang mga encoding ng mga state na ito. Nangangahulugan ito, partikular, na hindi lamang talaga natin kailangan ng mga magic state — kailangan natin ng mga naka-encode na magic state. Ang mga gate sa orihinal na $T$-gate circuit ay pinalitan dito ng mga gadget, na ipinagpapalagay na fault-tolerant.

Ang partikular na pigura na ito ay nagmumungkahi samakatuwid na mayroon na tayong fault-tolerant na mga gadget para sa mga CNOT gate at $S$ gate. Para sa isang color code, ang mga gadget na ito ay maaaring transversal; para sa isang surface code (o anumang iba pang CSS code), ang CNOT ay maaaring isagawa nang transversally, habang ang $S$ gate gadget ay maaaring mismo ay ipatupad gamit ang mga magic state, tulad ng iminungkahi nang maaga na posible. (Iminumungkahi rin ng pigura na mayroon tayong fault-tolerant na gadget para sa pagsasagawa ng isang standard basis measurement, na hindi pa natin pinag-uusapan. Ito ay maaaring talagang maging mapaghamong para sa ilang mga code na pinili upang maging ganoon, ngunit para sa isang CSS code ito ay isang bagay ng pagsukat sa bawat pisikal na qubit na sinusundan ng classical na post-processing.)

Ang implementasyon ay samakatuwid fault-tolerant, ipagpalagay na mayroon tayong encoding ng isang magic state na $T\vert{+}\rangle.$ Ngunit, hindi pa natin tinugunan ang isyu kung paano natin makukuha ang encoding ng state na ito. Ang isang paraan upang makakuha ng mga naka-encode na magic state (o, marahil mas tumpak, upang mapabuti ang mga ito) ay sa pamamagitan ng isang proseso na kilala bilang magic state distillation. Ang sumusunod na diagram ay naglalarawan kung ano ang hitsura ng prosesong ito sa pinakamataas na antas.

Sa madaling salita, isang koleksyon ng mga maingay na naka-encode na magic state ay ipinasok sa isang espesyal na uri ng circuit na kilala bilang isang distiller. Lahat maliban sa isa sa mga output block ay sinusukat — nangangahulugang ang mga logical qubit ay sinusukat gamit ang mga standard basis measurement. Kung ang alinman sa mga resulta ng measurement ay $1,$ nabigo ang proseso at kailangang i-restart. Gayunpaman, kung ang bawat resulta ng measurement ay $0,$ ang nagresultang state ng nangungunang code block ay magiging isang hindi gaanong maingay na naka-encode na magic state. Ang state na ito ay maaaring sumali sa apat pa bilang mga input sa isa pang distiller, o gamitin upang ipatupad ang isang $T$ gate kung itinuturing na sapat itong malapit sa isang tunay na naka-encode na magic state. Siyempre, ang proseso ay dapat magsimula sa isang lugar, at ang isang posibilidad ay ang paghahanda sa mga ito nang hindi-fault-tolerantly.

Mayroong iba't ibang kilalang paraan upang buuin ang distiller mismo, ngunit hindi sila ipapaliwanag o susuriin dito. Sa isang logical na antas, ang karaniwang pamamaraan — kahanga-hanga at medyo ng aksidente — ay ang patakbuhin ang isang encoding circuit para sa isang stabilizer code nang baligtad! Ito ay maaaring, sa katunayan, ay isang naiibang stabilizer code mula sa ginagamit para sa error correction. Halimbawa, ang isa ay maaaring gumamit ng isang surface o color code para sa error correction, ngunit patakbuhin ang isang encoder para sa $5$-qubit code nang baligtad para sa layunin ng magic state distillation. Ang mga encoding circuit para sa mga stabilizer code ay nangangailangan lamang ng mga Clifford gate, na nagpapasimple sa fault-tolerant na implementasyon ng isang distiller. Sa katunayan, ang mga detalye ay nakasalalay sa mga code na ginagamit.

Sa buod, layunin ng seksyong ito na magbigay lamang ng napakataas na antas na talakayan ng mga magic state, na may intensyon na magbigay lamang ng pangunahing ideya kung paano ito gumagana. Minsan ay sinasabi na ang overhead para sa paggamit ng mga magic state upang ipatupad ang mga gate nang fault-tolerantly sa ganitong paraan ay magiging napakataas, na ang malaking bahagi ng trabaho ay napupunta sa proseso ng distillation. Gayunpaman, hindi ito talagang malinaw — maraming potensyal na paraan upang ma-optimize ang mga prosesong ito. Mayroon din, bukod pa rito, mga alternatibong pamamaraan upang bumuo ng fault-tolerant na mga gadget para sa mga gate na hindi maaaring ipatupad nang transversally. Halimbawa, ang code deformation at code switching ay mga keyword na nauugnay sa ilan sa mga scheme na ito — at ang mga bagong paraan ay patuloy na binubuo at pinipino.

Fault-tolerant na error correction

Bukod sa implementasyon ng iba't ibang gadget na kinakailangan para sa isang fault-tolerant na implementasyon ng isang partikular na quantum circuit, may isa pang mahalagang isyu na kailangang kilalanin: ang implementasyon ng mga hakbang sa error correction mismo. Bumabalik ito sa ideya na ang anumang bagay na kinasasangkutan ng quantum information ay susceptible sa mga error — kabilang ang mga circuit na nilalayong itama ang mga error.

Isaalang-alang, halimbawa, ang uri ng circuit na inilarawan sa aralin na "The stabilizer formalism" para sa pagsukat ng mga stabilizer generator nang hindi mapanganib gamit ang phase estimation. Ang mga circuit na ito ay malinaw na hindi fault-tolerant dahil maaari silang magdulot ng mga error na kumalat sa loob ng code block kung saan sila nag-ooperate. Maaaring mukhang medyo problemado ito, ngunit may maraming kilalang paraan upang isagawa ang error correction nang fault-tolerantly sa paraan na hindi nagdudulot ng mga error na kumalat sa loob ng mga code block na tinatama.

Ang isang pamamaraan ay kilala bilang Shor error correction, dahil ito ay unang natuklasan ni Peter Shor. Ang ideya ay ang pagsasagawa ng syndrome measurement gamit ang tinatawag na cat state, na isang $n$-qubit state ng anyo

$$\frac{1}{\sqrt{2}} \vert 0^n \rangle + \frac{1}{\sqrt{2}} \vert 1^n \rangle,$$

kung saan ang $0^n$ at $1^n$ ay tumutukoy sa lahat-zero at lahat-isa na mga string ng haba $n.$ Halimbawa, ito ay isang $\vert\phi^+\rangle$ state kapag $n=2$ at isang GHZ state kapag $n=3,$ ngunit sa pangkalahatan, ang Shor error correction ay nangangailangan ng isang state tulad nito para sa $n$ na siyang weight ng stabilizer generator na sinusukat.

Bilang halimbawa, ang circuit na ipinakita dito ay sumusukat ng isang stabilizer generator ng anyo $P_2\otimes P_1 \otimes P_0.$

Nangangailangan ito ng konstruksyon ng cat state mismo, at upang gumana nang maaasahan sa presensya ng mga error at mga posibleng may-sira na gate, ang pamamaraan ay talagang nangangailangan ng paulit-ulit na pagpapatakbo ng mga circuit tulad nito upang makapag-gawa ng mga konklusyon tungkol sa kung saan ang iba't ibang error ay maaaring nangyari sa panahon ng proseso.

Ang isang alternatibong pamamaraan ay kilala bilang Steane error correction. Ang pamamaraang ito ay gumagana nang iba, at gumagana lamang ito para sa mga CSS code. Ang ideya ay hindi talaga natin isinasagawa ang mga syndrome measurement sa mga naka-encode na quantum state sa circuit na sinisikap nating patakbuhin, ngunit sa halip ay sadya nating pinalalapag ang mga error sa isang workspace system, at pagkatapos ay sinusukat ang system na iyon at classically itinutukoy ang mga error. Ang mga sumusunod na circuit diagram ay naglalarawan kung paano ito maaaring gawin para sa pag-detect ng mga $X$ at $Z$ error, ayon sa pagkakasunod.

Ang isang kaugnay na pamamaraan na kilala bilang Knill error correction ay nagpapalawak ng pamamaraang ito sa mga arbitrary na stabilizer code gamit ang teleportation.