การควบคุมการแพร่กระจายของข้อผิดพลาด

Fault-tolerant quantum computation คล้ายกับการแข่งขันระหว่างข้อผิดพลาดและ error correction ถ้าจำนวนข้อผิดพลาดน้อยพอ error correction จะแก้ไขได้สำเร็จ; แต่ถ้ามีข้อผิดพลาดมากเกินไป error correction จะล้มเหลว

ด้วยเหตุนี้ ต้องระมัดระวังอย่างเพียงพอในวิธีที่การคำนวณเชิงควอนตัมดำเนินการในการ implement แบบ fault-tolerant ของ circuits เพื่อควบคุม การแพร่กระจายของข้อผิดพลาด กล่าวคือ ข้อผิดพลาดบน Qubit หนึ่งอาจแพร่กระจายไปยัง Qubit หลายตัวผ่านการกระทำของ gates ใน quantum circuit ซึ่งอาจทำให้จำนวนข้อผิดพลาดเพิ่มขึ้นอย่างมาก นี่เป็นข้อกังวลสูงสุด เพราะถ้าเราไม่สามารถควบคุมการแพร่กระจายของข้อผิดพลาดได้ ความพยายามในการแก้ไขข้อผิดพลาดของเราจะถูกท่วมท้นด้วยข้อผิดพลาดอย่างรวดเร็ว ในทางกลับกัน ถ้าเราสามารถควบคุมการแพร่กระจายของข้อผิดพลาดได้ error correction ก็มีโอกาสสู้กลับ ช่วยให้แก้ข้อผิดพลาดได้ในอัตราสูงพอที่จะให้การคำนวณเชิงควอนตัมทำงานตามที่ตั้งใจ

จุดเริ่มต้นสำหรับการพูดถึงทางเทคนิคของประเด็นนี้คือการตระหนักว่า two-qubit gates (หรือ multiple-qubit gates โดยทั่วไปกว่า) สามารถแพร่กระจายข้อผิดพลาดได้ แม้จะทำงานได้สมบูรณ์แบบ ตัวอย่างเช่น พิจารณา controlled-NOT gate และสมมติว่า $X$ error เกิดขึ้นบน control qubit ก่อนที่ controlled-NOT gate จะดำเนินการ ดังที่เราสังเกตไปแล้วในบทเรียน "Correcting quantum errors" สิ่งนี้เทียบเท่ากับ $X$ error ที่เกิดขึ้นบน ทั้งสอง Qubit หลัง controlled-NOT ดำเนินการ และสถานการณ์คล้ายกันสำหรับ $Z$ error ที่กระทำบน target แทน control ก่อน controlled-NOT gate ดำเนินการ

นี่คือ การแพร่กระจายของข้อผิดพลาด เพราะตำแหน่งที่โชคร้ายของ $X$ หรือ $Z$ error ก่อน controlled-NOT gate ทำให้กลายเป็นสองข้อผิดพลาดหลัง controlled-NOT gate สิ่งนี้เกิดขึ้นแม้ว่า controlled-NOT gate จะสมบูรณ์แบบ และเราต้องไม่ลืมว่า controlled-NOT gate ที่กำหนดอาจมีสัญญาณรบกวนเอง ซึ่งอาจ สร้าง ข้อผิดพลาดที่สัมพันธ์กันบนสอง Qubit

เพิ่มความกังวลของเราคือข้อเท็จจริงที่ว่า two-qubit gates ถัดไปอาจแพร่กระจายข้อผิดพลาดเหล่านี้ต่อไป ดังที่รูปต่อไปนี้แนะนำ

ในบางแง่ เราไม่สามารถหลีกเลี่ยงสิ่งนี้ได้; ตราบใดที่เราใช้ multiple-qubit gates ก็จะมีโอกาสเกิดการแพร่กระจายข้อผิดพลาดเสมอ อย่างไรก็ตาม ดังที่เราจะพูดถึงใน subsections ต่อไป สามารถดำเนินการขั้นตอนต่าง ๆ เพื่อจำกัดความเสียหายที่เกิดขึ้น ทำให้ข้อผิดพลาดที่แพร่กระจายสามารถจัดการได้

การ implement gate แบบ transversal

วิธีที่รู้จักง่ายที่สุดในการลดการแพร่กระจายข้อผิดพลาดใน fault-tolerant quantum circuits คือการ implement gates แบบ transversal ซึ่งหมายถึงการสร้าง gadgets สำหรับพวกมันที่มีรูปแบบเรียบง่ายหนึ่ง โดยเฉพาะอย่างยิ่ง gadgets ต้องเป็น tensor product ของการดำเนินการ (หรือกล่าวอีกนัยหนึ่ง quantum circuit แบบ depth-one) โดยแต่ละการดำเนินการสามารถกระทำได้บน ตำแหน่ง Qubit เดียวภายในแต่ละ code block ที่สัมผัส บางทีสิ่งนี้อธิบายได้ง่ายที่สุดผ่านตัวอย่าง

ตัวอย่างของการ implement gate แบบ transversal

พิจารณารูปต่อไปนี้ ซึ่งแนะนำการ implement แบบ transversal ของ CNOT gate (การ implement เฉพาะนี้ ที่ทำ CNOTs ทีละ Qubit ใช้ได้เฉพาะกับ CSS codes — แต่ในความเป็นจริงใช้ได้กับ CSS codes ทุกอัน)

มีสอง code blocks ในรูปนี้ แต่ละอันแสดงว่าประกอบด้วยห้า Qubit (แม้ว่าอาจมากกว่าได้ดังที่แนะนำแล้ว) Circuit ทางขวามี depth หนึ่ง และแต่ละ CNOT gate กระทำบนตำแหน่ง Qubit เดียวในแต่ละบล็อก: ทั้ง control และ target สำหรับ CNOT แรกคือ Qubit บนสุด (กล่าวคือ qubit 0 โดยใช้ขนบการนับ Qiskit), ทั้ง control และ target สำหรับ CNOT ที่สองคือ Qubit อันดับสองจากบน (กล่าวคือ qubit 1) และอื่น ๆ ดังนั้น นี่คือ transversal gadget

สำหรับตัวอย่างที่สอง — จริง ๆ แล้วเป็นคลาสของตัวอย่าง — พิจารณา Pauli gate ใด ๆ Pauli gates สามารถ implement แบบ transversal ได้เสมอ สำหรับ stabilizer code ใด ๆ โดยสร้าง gadgets ที่ประกอบด้วยการดำเนินการ Pauli โดยเฉพาะอย่างยิ่ง การดำเนินการ Pauli ทุกอันบน logical qubit ที่เข้ารหัสโดย stabilizer code สามารถ implement แบบ transversal ได้โดยเลือกการดำเนินการ Pauli ที่เหมาะสมบน physical qubits ที่ใช้สำหรับการเข้ารหัส สิ่งนี้สอดคล้องกับข้อเท็จจริงที่กล่าวถึงผ่าน ๆ ในบทเรียน "Stabilizer formalism": ยกเว้น global phase การดำเนินการ Pauli ที่ commute กับ stabilizer generator ทุกตัวของ stabilizer code ทำงานเหมือนการดำเนินการ Pauli บน Qubit หรือ Qubit ที่เข้ารหัสโดย code นั้น

เป็นตัวอย่างเฉพาะ พิจารณา $9$-qubit Shor code ซึ่งสถานะฐานมาตรฐานสามารถเข้ารหัสได้ดังนี้

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

$X$ gate บน logical qubit ที่เข้ารหัสโดย code นี้สามารถ implement แบบ transversal ได้ด้วย $9$-qubit Pauli operation

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

ในขณะที่ $Z$ gate บน logical qubit สามารถ implement แบบ transversal ได้ด้วย $9$-qubit Pauli operation

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

Pauli operations ทั้งสองมี weight $3$ ซึ่งเป็น weight ขั้นต่ำที่จำเป็น ($9$-qubit Shor code มี distance $3$ ดังนั้น Pauli operation ที่ไม่ใช่ identity ใด ๆ ที่มี weight $2$ หรือน้อยกว่าจะถูกตรวจจับว่าเป็นข้อผิดพลาด)

และสำหรับตัวอย่างที่สาม $7$-qubit Steane code (และจริง ๆ แล้ว color code ทุกอัน) ช่วยให้ implement Clifford gates ทั้งหมด แบบ transversal ได้ เราได้เห็นแล้วว่า CNOT gates implement แบบ transversal สำหรับ CSS code ใด ๆ ดังนั้นยังต้องพิจารณา $H$ และ $S$ gates Hadamard gate ที่ใช้กับทั้ง $7$ Qubit ของ Steane code เทียบเท่ากับ $H$ ที่ใช้กับ logical qubit ที่มันเข้ารหัส ในขณะที่ $S^{\dagger}$ gate (แทนที่จะเป็น $S$ gate) ที่ใช้กับทั้ง $7$ Qubit เทียบเท่ากับ logical $S$ gate

การแพร่กระจายข้อผิดพลาดสำหรับ transversal gadgets

ตอนนี้ที่เราทราบว่า transversal implementations ของ gates คืออะไร มาพูดถึงความเชื่อมโยงกับการแพร่กระจายข้อผิดพลาด

สำหรับ transversal implementation ของ single-qubit gate เราเพียงแต่มี tensor product ของ single-qubit gates ใน gadget ของเรา ซึ่งกระทำบน code block ของ physical qubits สำหรับ quantum error correcting code ที่เลือก แม้ว่า gate เหล่านี้อาจล้มเหลวและก่อให้เกิดข้อผิดพลาด แต่จะไม่มี การแพร่กระจาย ของข้อผิดพลาดเพราะไม่มี multiple-qubit gates เกี่ยวข้อง ทันทีหลังจาก gadget ดำเนินการ error correction จะดำเนินการ; และถ้าจำนวนข้อผิดพลาดที่เกิดขึ้นโดย gadget (หรือขณะที่ gadget กำลังดำเนินการ) น้อยพอ ข้อผิดพลาดจะถูกแก้ไข ดังนั้น ถ้าอัตราข้อผิดพลาดที่เกิดขึ้นโดย faulty gates น้อยพอ error correction มีโอกาสสูงที่จะสำเร็จ

สำหรับ transversal implementation ของ two-qubit gate ในทางกลับกัน มีโอกาสเกิดการแพร่กระจายข้อผิดพลาด — ไม่มีทางหลีกเลี่ยงสิ่งนี้ได้ ดังที่เราสังเกตไปแล้ว ประเด็นสำคัญอย่างไรก็ตามคือ transversal gadget ไม่สามารถทำให้เกิดการแพร่กระจายข้อผิดพลาด ภายใน code block เดียว ได้

ตัวอย่างเช่น พิจารณา transversal implementation ของ CNOT gate สำหรับ CSS code ที่อธิบายข้างต้น $X$ error อาจเกิดขึ้นบน Qubit บนสุดของ code block บนก่อน gadget ดำเนินการ และ CNOT แรกภายใน gadget จะแพร่กระจายข้อผิดพลาดนั้นไปยัง Qubit บนสุดใน block ล่าง อย่างไรก็ตาม ข้อผิดพลาดสองอันที่ได้ตอนนี้อยู่ใน code blocks แยกกัน ดังนั้น สมมติว่า code ของเราสามารถแก้ $X$ error ได้ ขั้นตอน error correction ที่เกิดขึ้นหลัง gadget จะแก้ $X$ errors สองอันอย่างอิสระ — เพราะมีข้อผิดพลาดเพียงอันเดียวในแต่ละ code block ในทางกลับกัน ถ้าการแพร่กระจายข้อผิดพลาดเกิดขึ้นภายใน code block เดียวกัน อาจทำให้ข้อผิดพลาด weight ต่ำกลายเป็นข้อผิดพลาด weight สูงที่ code ไม่สามารถจัดการได้

ความไม่เป็นสากลของ transversal gates

สำหรับ stabilizer codes สองอัน อาจเป็นไปได้ที่ gate หนึ่งสามารถ implement แบบ transversal ได้ด้วย code หนึ่งแต่ไม่ใช่อีก code ตัวอย่างเช่น แม้ว่าจะไม่สามารถ implement $T$ gate แบบ transversal โดยใช้ $7$-qubit Steane code แต่มี code อื่นที่สามารถทำได้

น่าเสียดายที่เป็นไปไม่ได้เลย สำหรับ quantum error correcting code ที่ไม่ใช่ trivial ใด ๆ ที่จะ implement ชุด gates สากล แบบ transversal ข้อเท็จจริงนี้รู้จักกันในชื่อ Eastin-Knill theorem

ทฤษฎีบท

Eastin-Knill theorem: สำหรับ quantum error correcting code ใด ๆ ที่มี distance อย่างน้อย 2 ชุดของ logical gates ที่สามารถ implement แบบ transversal ได้จะสร้างชุดการดำเนินการ (ยกเว้น global phase) ที่เป็น discrete และดังนั้นจึงไม่เป็นสากล

การพิสูจน์ทฤษฎีบทนี้จะไม่อธิบายที่นี่ (ไม่ใช่การพิสูจน์ที่ซับซ้อน แต่ต้องการความรู้พื้นฐานของ Lie groups และ Lie algebras ซึ่งไม่ได้อยู่ในข้อกำหนดเบื้องต้นของ series นี้) อย่างไรก็ตาม แนวคิดพื้นฐานสามารถถ่ายทอดในรูปแบบ intuitive ได้: ครอบครัวอนันต์ของ transversal operations ไม่สามารถอยู่ภายใน code space ของ code ที่ไม่ใช่ trivial ได้ เพราะความแตกต่างเล็กน้อยใน transversal operations สามารถประมาณได้ดีด้วย Pauli operations ที่มี weight ต่ำ ซึ่ง code ตรวจจับว่าเป็นข้อผิดพลาด

โดยสรุป transversal gadgets ให้การ implement gates ที่เรียบง่ายและมี fault tolerance โดยธรรมชาติ — แต่สำหรับทางเลือกที่สมเหตุสมผลของ quantum error correcting code ใด ๆ ก็ตาม ไม่มี universal gate set ที่สามารถ implement ในลักษณะนี้ได้ ซึ่งจำเป็นต้องใช้ gadgets ทางเลือก

Magic states

เนื่องจากเป็นไปไม่ได้ สำหรับทางเลือก quantum error correcting code ที่ไม่ใช่ trivial ใด ๆ ที่จะ implement universal set ของ quantum gates แบบ transversal เราจึงต้องพิจารณาวิธีอื่นในการ implement gates แบบ fault-tolerant วิธีที่รู้จักกันดีวิธีหนึ่งอิงบนแนวคิดของ magic states ซึ่งเป็นสถานะควอนตัมของ Qubit ที่ช่วยให้ implement บาง gates แบบ fault-tolerant ได้

การ implement gates ด้วย magic states

เริ่มต้นด้วยการพิจารณา $S$ และ $T$ gates ซึ่งมีคำอธิบายเมทริกซ์ดังนี้

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

ตามนิยาม $S$ เป็น Clifford operation ในขณะที่ $T$ ไม่ใช่; ไม่สามารถ implement $T$ gate ด้วย circuit ที่ประกอบด้วย Clifford gates ($H$ gates, $S$ gates, และ CNOT gates) ได้

อย่างไรก็ตาม สามารถ implement $T$ gate (ยกเว้น global phase) ด้วย circuit ที่ประกอบด้วย Clifford gates ได้ ถ้าเรามีสำเนาของสถานะ

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

และเราอนุญาตให้มีการวัดในฐานมาตรฐานและให้ gates ถูกควบคุมแบบ classical โดยเฉพาะอย่างยิ่ง circuit ต่อไปนี้แสดงหนึ่งวิธีในการทำสิ่งนี้ ปรากฏการณ์ที่แสดงที่นี่เป็นตัวอย่างที่ค่อนข้างง่ายของ quantum gate teleportation

เพื่อตรวจสอบว่า circuit นี้ทำงานถูกต้อง เราสามารถคำนวณการกระทำของ CNOT gate บน 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$$

ดังนั้นการวัดจะให้ผลลัพธ์ $0$ และ $1$ ด้วยความน่าจะเป็นเท่ากัน ถ้าผลลัพธ์คือ $0$ $S$ gate จะไม่ดำเนินการ และสถานะ output คือ $T\vert\psi\rangle$; และ ถ้าผลลัพธ์คือ $1$ $S$ gate จะดำเนินการ และสถานะ output คือ $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle$

สถานะ $T\vert {+}\rangle$ เรียกว่า magic state ในบริบทนี้ แม้ว่าจะไม่ได้เป็นเฉพาะตัวในแง่นี้: สถานะอื่น ๆ ก็เรียกว่า magic states เมื่อสามารถใช้ในลักษณะที่คล้ายกัน (สำหรับ gates ที่อาจต่างกันและใช้ circuits ต่างกัน) ตัวอย่างเช่น การแลกสถานะ $T\vert{+}\rangle$ เป็นสถานะ $S\vert{+}\rangle$ และแทนที่ $S$ gate ใน circuit ข้างต้นด้วย $Z$ gate จะ implement $S$ gate — ซึ่งอาจเป็นประโยชน์สำหรับ fault-tolerant quantum computation โดยใช้ code ที่ไม่สามารถ implement $S$ gates แบบ transversal ได้

Fault-tolerant gadgets จาก magic states

อาจยังไม่ชัดเจนว่าการใช้ magic states เพื่อ implement gates มีประโยชน์สำหรับ fault-tolerance สำหรับการ implement $T$ gate ที่อธิบายข้างต้น เป็นต้น ดูเหมือนว่าเรายังต้องใช้ $T$ gate กับสถานะ $\vert{+}\rangle$ เพื่อให้ได้ magic state ซึ่งเราใช้เพื่อ implement $T$ gate แล้วอะไรคือข้อได้เปรียบของการใช้แนวทางนี้สำหรับ fault-tolerance?

นี่คือสามประเด็นสำคัญที่ให้คำตอบสำหรับคำถามนี้

1. การสร้าง magic states ไม่จำเป็นต้องใช้ gate ที่เราพยายาม implement กับสถานะเฉพาะ ตัวอย่างเช่น การใช้ $T$ gate กับสถานะ $\vert {+} \rangle$ ไม่ใช่วิธีเดียวในการได้สถานะ $T\vert{+}\rangle$

2. การสร้าง magic states สามารถทำแยกจาก computation ที่ใช้พวกมัน ซึ่งหมายความว่าข้อผิดพลาดที่เกิดขึ้นในกระบวนการสร้าง magic state จะไม่แพร่กระจายไปยัง computation จริงที่กำลังดำเนินการ

3. ถ้า gates แต่ละตัวใน circuit ที่ implement gate ที่เลือกโดยใช้ magic state สามารถ implement แบบ fault-tolerant และสมมติว่ามี magic states พร้อมใช้ เราจะได้การ implement แบบ fault-tolerant ของ gate ที่เลือก

เพื่อทำให้การพูดถึงต่อไปนี้ง่ายขึ้น มุ่งเน้นที่ $T$ gates โดยเฉพาะ — โดยคำนึงว่าวิธีการสามารถขยายไปยัง gates อื่น ๆ ได้ การ implement แบบ fault-tolerant ของ $T$ gate โดยใช้ magic states อยู่ในรูปแบบที่แนะนำโดยรูปต่อไปนี้

Qubits ใน original $T$-gate circuit สอดคล้องกับ logical qubits ในแผนภาพนี้ ซึ่งเข้ารหัสโดย code ใด ๆ ที่เราใช้สำหรับ fault-tolerance Input และ output ในแผนภาพจึงควรเข้าใจว่าเป็น encodings ของสถานะเหล่านี้ ซึ่งหมายความว่าโดยเฉพาะอย่างยิ่ง เราไม่ต้องการแค่ magic states — เราต้องการ encoded magic states Gates ใน original $T$-gate circuit ถูกแทนที่ที่นี่ด้วย gadgets ซึ่งเราสมมติว่าเป็น fault-tolerant

รูปเฉพาะนี้จึงแนะนำว่าเรามี fault-tolerant gadgets สำหรับ CNOT gates และ $S$ gates แล้ว สำหรับ color code gadgets เหล่านี้อาจเป็น transversal; สำหรับ surface code (หรือ CSS code อื่น ๆ) CNOT สามารถดำเนินการแบบ transversal ได้ ในขณะที่ $S$ gate gadget อาจ implement เองโดยใช้ magic states ดังที่แนะนำว่าเป็นไปได้ก่อนหน้า (รูปยังแนะนำว่าเรามี fault-tolerant gadget สำหรับดำเนินการวัดในฐานมาตรฐาน ซึ่งเราละเลยมาจนถึงตอนนี้ สิ่งนี้อาจท้าทายสำหรับ codes บางอันที่เลือกเพื่อทำให้เป็นเช่นนั้น แต่สำหรับ CSS code มันเป็นเรื่องของการวัดแต่ละ physical qubit ตามด้วย classical post-processing)

การ implement จึงเป็น fault-tolerant สมมติว่าเรามี encoding ของ magic state $T\vert{+}\rangle$ แต่เรายังไม่ได้แก้ปัญหาว่าเราจะได้ encoding ของสถานะนี้อย่างไร วิธีหนึ่งในการได้ encoded magic states (หรือบางทีแม่นยำกว่าเพื่อทำให้ดีขึ้น) คือผ่านกระบวนการที่รู้จักกันในชื่อ magic state distillation แผนภาพต่อไปนี้แสดงสิ่งที่กระบวนการนี้ดูเหมือนในระดับสูงสุด

กล่าวเป็นคำพูด คอลเลคชันของ noisy encoded magic states ถูกป้อนเข้า circuit พิเศษที่รู้จักกันในชื่อ distiller ทุก output block ยกเว้นหนึ่งอันจะถูกวัด — หมายความว่า logical qubits ถูกวัดด้วยการวัดในฐานมาตรฐาน ถ้าผลการวัดใด ๆ คือ $1$ กระบวนการล้มเหลวและต้องเริ่มใหม่ อย่างไรก็ตาม ถ้าผลการวัดทุกอันคือ $0$ สถานะที่ได้ของ top code block จะเป็น encoded magic state ที่มีสัญญาณรบกวนน้อยลง จากนั้นสถานะนี้อาจเข้าร่วมอีกสี่อันเป็น input เข้า distiller อีกอัน หรือใช้ implement $T$ gate ถ้าถือว่าใกล้เคียงกับ encoded magic state จริงเพียงพอ แน่นอน กระบวนการต้องเริ่มต้นที่ไหนสักแห่ง โดยหนึ่งความเป็นไปได้คือการเตรียมพวกมันแบบ non-fault-tolerant

มีวิธีที่รู้จักกันหลายวิธีในการสร้าง distiller เอง แต่จะไม่อธิบายหรือวิเคราะห์ที่นี่ ในระดับ logical วิธีทั่วไป — อย่างน่าทึ่งและบังเอิญ — คือการรัน encoding circuit สำหรับ stabilizer code แบบย้อนกลับ! นี่อาจเป็น stabilizer code ที่แตกต่างจาก code ที่ใช้สำหรับ error correction ตัวอย่างเช่น อาจใช้ surface หรือ color code สำหรับ error correction แต่รัน encoder สำหรับ $5$-qubit code แบบย้อนกลับสำหรับ magic state distillation Encoding circuits สำหรับ stabilizer codes ต้องการ Clifford gates เท่านั้น ซึ่งทำให้ fault-tolerant implementation ของ distiller ง่ายขึ้น ในความเป็นจริง ความเฉพาะเจาะจงขึ้นอยู่กับ codes ที่ใช้

โดยสรุป ส่วนนี้มีจุดประสงค์เพื่อให้การพูดถึง magic states ในระดับสูงมากเท่านั้น โดยมีเจตนาเพียงเพื่อให้แนวคิดพื้นฐานว่ามันทำงานอย่างไร บางครั้งมีการอ้างว่า overhead สำหรับการใช้ magic states เพื่อ implement gates แบบ fault-tolerant ตามแนวทางเหล่านี้จะสูงมาก โดยงานส่วนใหญ่จะเข้าไปในกระบวนการ distillation อย่างไรก็ตาม สิ่งนี้จริง ๆ แล้วไม่ชัดเจน — มีวิธีที่เป็นไปได้หลายวิธีในการ optimize กระบวนการเหล่านี้ นอกจากนี้ยังมีแนวทางทางเลือกในการสร้าง fault-tolerant gadgets สำหรับ gates ที่ไม่สามารถ implement แบบ transversal ได้ ตัวอย่างเช่น code deformation และ code switching เป็น keywords ที่เกี่ยวข้องกับ schemes บางอย่างเหล่านี้ — และวิธีใหม่ ๆ ยังคงถูกพัฒนาและปรับปรุงอยู่

Fault-tolerant error correction

นอกจากการ implement ของ gadgets ต่าง ๆ ที่จำเป็นสำหรับการ implement แบบ fault-tolerant ของ quantum circuit ที่กำหนด ยังมีประเด็นสำคัญอีกอย่างหนึ่งที่ต้องตระหนัก: การ implement ของขั้นตอน error correction เอง นี่กลับไปสู่แนวคิดที่ว่าทุกสิ่งที่เกี่ยวข้องกับสารสนเทศควอนตัมอ่อนไหวต่อข้อผิดพลาด — รวมถึง circuits ที่มีจุดประสงค์เพื่อแก้ข้อผิดพลาดเอง

พิจารณาตัวอย่างเช่น ประเภทของ circuit ที่อธิบายในบทเรียน "The stabilizer formalism" สำหรับการวัด stabilizer generators แบบ non-destructive โดยใช้ phase estimation Circuits เหล่านี้ชัดเจนว่าไม่ใช่ fault-tolerant เพราะอาจทำให้ข้อผิดพลาดแพร่กระจายภายใน code block ที่ดำเนินการ สิ่งนี้อาจดูค่อนข้างมีปัญหา แต่มีวิธีที่รู้จักกันหลายวิธีในการดำเนินการ error correction แบบ fault-tolerant ที่ไม่ทำให้ข้อผิดพลาดแพร่กระจายภายใน code blocks ที่กำลังแก้ไข

วิธีหนึ่งรู้จักกันในชื่อ Shor error correction เพราะค้นพบโดย Peter Shor ก่อน แนวคิดคือการดำเนินการ syndrome measurements โดยใช้ cat state ซึ่งเป็นสถานะ $n$-qubit ของรูปแบบ

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

โดยที่ $0^n$ และ $1^n$ อ้างถึงสตริงที่มีแต่ศูนย์และแต่หนึ่งที่มีความยาว $n$ ตัวอย่างเช่น นี่คือสถานะ $\vert\phi^+\rangle$ เมื่อ $n=2$ และ GHZ state เมื่อ $n=3$ แต่โดยทั่วไป Shor error correction ต้องการสถานะแบบนี้สำหรับ $n$ เป็น weight ของ stabilizer generator ที่กำลังวัด

เป็นตัวอย่าง circuit ที่แสดงที่นี่วัด stabilizer generator ของรูปแบบ $P_2\otimes P_1 \otimes P_0$

สิ่งนี้จำเป็นต้องมีการสร้าง cat state เอง และเพื่อให้ทำงานได้อย่างน่าเชื่อถือในกรณีที่มีข้อผิดพลาดและ gates ที่อาจบกพร่อง วิธีนี้จริง ๆ แล้วต้องรัน circuits แบบนี้ซ้ำ ๆ เพื่อสรุปเกี่ยวกับข้อผิดพลาดต่าง ๆ ที่อาจเกิดขึ้นระหว่างกระบวนการ

วิธีทางเลือกรู้จักกันในชื่อ Steane error correction วิธีนี้ทำงานแตกต่างกัน และใช้ได้เฉพาะกับ CSS codes แนวคิดคือเราไม่ได้ดำเนินการ syndrome measurements บน encoded quantum states ใน circuit ที่เราพยายามรัน แต่แทนที่จะ ตั้งใจ แพร่กระจายข้อผิดพลาดไปยัง workspace system แล้ววัด system นั้นและ ตรวจจับข้อผิดพลาดแบบ classical แผนภาพ circuit ต่อไปนี้แสดงวิธีที่สามารถทำสิ่งนี้เพื่อตรวจจับ $X$ และ $Z$ errors ตามลำดับ

วิธีที่เกี่ยวข้องที่รู้จักกันในชื่อ Knill error correction ขยายวิธีนี้ไปยัง stabilizer codes แบบสุ่มโดยใช้ teleportation