CSS Codes

Classical linear codes

โค้ดแก้ไขข้อผิดพลาดแบบคลาสสิกได้รับการศึกษาครั้งแรกในทศวรรษ 1940 และปัจจุบันรู้จักโค้ดจำนวนมาก โดยโค้ดที่ศึกษาและใช้กันมากที่สุดอยู่ในหมวดหมู่ที่เรียกว่า linear codes เราจะเห็นในอีกสักครู่ว่าคำว่า "linear" หมายถึงอะไรในบริบทนี้ แต่วิธีง่าย ๆ ในการอธิบาย linear codes ณ จุดนี้คือ พวกมันคือ stabilizer codes ที่บังเอิญเป็นแบบคลาสสิก CSS codes โดยพื้นฐานแล้วคือ คู่ ของ classical linear codes ที่รวมเข้าด้วยกันเพื่อสร้างโค้ดแก้ไขข้อผิดพลาดเชิงควอนตัม ดังนั้นเพื่อการอภิปรายต่อไปนี้ เราต้องเข้าใจพื้นฐานบางอย่างเกี่ยวกับ classical linear codes

ให้ $\Sigma$ เป็น binary alphabet สำหรับการอภิปรายทั้งหมดนี้ เมื่อเราอ้างถึง classical linear code เราหมายถึงชุดที่ไม่ว่าง $\mathcal{C}\subseteq\Sigma^n$ ของ binary strings ที่มีความยาว $n$ สำหรับจำนวนเต็มบวกบางตัว $n$ ซึ่งต้องตอบสนองคุณสมบัติพื้นฐานเพียงหนึ่งอย่าง: ถ้า $u$ และ $v$ เป็น binary strings ใน $\mathcal{C}$ แล้ว string $u\oplus v$ ก็อยู่ใน $\mathcal{C}$ ด้วย ที่นี่ $u\oplus v$ หมายถึง bitwise exclusive-OR ของ $u$ และ $v$ ดังที่เราพบหลายครั้งใน คอร์ส "Fundamentals of quantum algorithms"

โดยพื้นฐาน เมื่อเราอ้างถึง classical error correcting code ว่าเป็น linear เราคิดถึง binary strings ที่มีความยาว $n$ ในฐานะ vectors $n$ มิติ โดยที่ entries เป็น $0$ หรือ $1$ และต้องการให้โค้ดเองเป็น linear subspace แทนที่จะเป็น vector addition ธรรมดาบนจำนวนจริงหรือจำนวนเชิงซ้อน เราใช้การบวก modulo $2$ ซึ่งก็คือ exclusive-OR กล่าวคือ ถ้ามี codewords สองตัว $u$ และ $v$ หมายความว่า $u$ และ $v$ เป็น binary strings ใน $\mathcal{C}$ แล้ว $u + v$ modulo 2 ซึ่งก็คือ $u\oplus v$ ต้องเป็น codeword ใน $\mathcal{C}$ ด้วย สังเกตโดยเฉพาะว่า implication นี้ต้องเป็นจริงแม้ $u = v$ สิ่งนี้หมายความว่า $\mathcal{C}$ ต้องรวม all-zero string $0^n$ เพราะ bitwise exclusive-OR ของ string ใด ๆ กับตัวมันเองคือ all-zero string

ตัวอย่าง: 3-bit repetition code

3-bit repetition code เป็นตัวอย่างของ classical linear code โดยเฉพาะ เรามี $\mathcal{C} = \{000,111\}$ ดังนั้นเทียบกับเงื่อนไข linearity มีเพียงสองทางเลือกสำหรับ $u$ และสองทางเลือกสำหรับ $v$ เป็นเรื่องง่ายที่จะตรวจสอบสี่คู่ที่เป็นไปได้เพื่อดูว่าเราได้ codeword เสมอเมื่อนำ bitwise exclusive-OR:

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

ตัวอย่าง: $[7,4,3]$-Hamming code

นี่คืออีกตัวอย่างของ classical linear code ที่เรียกว่า $[7,4,3]$-Hamming code มันเป็นหนึ่งใน classical error correcting codes แรก ๆ ที่เคยค้นพบ และประกอบด้วย binary strings ความยาว 7 จำนวน 16 strings เหล่านี้ (บางครั้ง $[7,4,3]$-Hamming code เข้าใจว่าหมายถึงโค้ดที่มี strings เหล่านี้กลับทิศ แต่เราจะถือว่ามันเป็นโค้ดที่มี strings ที่แสดงที่นี่)

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

มีตรรกะง่าย ๆ เบื้องหลังการเลือก strings เหล่านี้ แต่เป็นเรื่องรองจากบท และจะไม่อธิบายที่นี่ สำหรับตอนนี้ เพียงแค่สังเกตว่านี่คือ classical linear code: การ XOR strings สองตัวใด ๆ เข้าด้วยกันจะให้ string อื่นในโค้ดเสมอ

สัญกรณ์ $[7,4,3]$ (ในวงเล็บเหลี่ยมเดี่ยว) หมายความคล้ายกับสัญกรณ์วงเล็บเหลี่ยมคู่สำหรับ stabilizer codes ที่กล่าวถึงในบทก่อนหน้า แต่ที่นี่สำหรับ classical linear codes โดยเฉพาะ codewords มี $7$ bits เราสามารถ encode $4$ bits โดยใช้โค้ด (เพราะมี $16 = 2^4$ codewords) และบังเอิญเป็น distance $3$ code หมายความว่า codewords ที่ต่างกันสองอันต้องต่างกันในอย่างน้อย $3$ ตำแหน่ง ดังนั้นต้อง flip อย่างน้อย $3$ bits เพื่อเปลี่ยน codeword หนึ่งเป็นอีกอัน ข้อเท็จจริงที่ว่านี่คือ distance $3$ code หมายความว่าสามารถแก้ไข bit-flip error ได้สูงสุดหนึ่งอย่าง

การอธิบาย classical linear codes

ตัวอย่างที่กล่าวถึงเพิ่งเป็นตัวอย่างง่าย ๆ ของ classical linear codes แต่แม้แต่ $[7,4,3]$-Hamming code ก็ดูลึกลับบ้างเมื่อ codewords ถูกระบุไว้ง่าย ๆ มีวิธีที่ดีกว่าและมีประสิทธิภาพมากกว่าในการอธิบาย classical linear codes รวมถึงสองวิธีต่อไปนี้

1. Generators วิธีหนึ่งในการอธิบาย classical linear code คือด้วยรายการ codewords ขั้นต่ำที่ generates โค้ด หมายความว่าโดยการนำ subsets ทั้งหมดที่เป็นไปได้ของ codewords เหล่านี้และ XOR เข้าด้วยกัน เราได้โค้ดทั้งหมด

   โดยละเอียดยิ่งขึ้น strings $u_1,\ldots,u_m\in\Sigma^n$ generates classical linear code $\mathcal{C}$ ถ้า

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

   โดยเข้าใจว่า $\alpha u = u$ เมื่อ $\alpha = 1$ และ $\alpha u = 0^n$ เมื่อ $\alpha = 0$ และเราบอกว่ารายการนี้ minimal ถ้าการลบ string หนึ่งออกสร้างโค้ดที่เล็กลง วิธีธรรมชาติในการคิดถึงคำอธิบายดังกล่าวคือ ชุด $\{u_1,\ldots,u_m\}$ เป็น basis ของ $\mathcal{C}$ ในฐานะ subspace โดยที่เราคิดถึง strings ในฐานะ vectors ที่มี entries เป็น binary โดยจำไว้ว่าเราทำงานใน vector space ที่คณิตศาสตร์ทำ modulo $2$

2. Parity checks อีกวิธีธรรมชาติในการอธิบาย classical linear code คือด้วย parity checks — หมายความว่ารายการ binary strings ขั้นต่ำที่ strings ในโค้ดคือตัวที่ binary dot product กับทุก parity check string เป็นศูนย์ (คล้ายกับ bitwise exclusive-OR binary dot product ปรากฏหลายครั้งใน "Fundamentals of quantum algorithms")

   กล่าวคือ strings $v_1,\ldots,v_r\in\Sigma^n$ เป็น parity check strings สำหรับ classical linear code $\mathcal{C}$ ถ้า

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

   และชุดของ strings นี้ minimal ถ้าการลบหนึ่งออกให้โค้ดที่ใหญ่ขึ้น เรียกว่า parity check strings เพราะ $u$ มี binary dot product เท่ากับศูนย์กับ $v$ ถ้าและเฉพาะถ้า bits ของ $u$ ในตำแหน่งที่ $v$ มี 1 มี parity คู่ ดังนั้น เพื่อดูว่า string $u$ อยู่ใน code $\mathcal{C}$ หรือไม่ ก็เพียงพอที่จะตรวจสอบ parity ของ subsets บางอย่างของ bits ของ $u$

   สิ่งสำคัญที่ต้องสังเกตที่นี่คือ binary dot product ไม่ใช่ inner product ในความหมายเป็นทางการ โดยเฉพาะ เมื่อ strings สองตัวมี binary dot product เท่ากับศูนย์ ไม่ได้หมายความว่าพวกมัน orthogonal ในทิศทางที่เรามักคิดถึง orthogonality ตัวอย่างเช่น binary dot product ของ string $11$ กับตัวมันเองเป็นศูนย์ ดังนั้นเป็นไปได้ที่ parity check string สำหรับ classical linear code อยู่ในโค้ดเอง

Classical linear codes บน binary alphabet มักรวม strings จำนวนหนึ่งที่เป็น power ของ $2$ — และสำหรับ classical linear code เดี่ยวที่อธิบายด้วยสองวิธีที่เพิ่งอธิบาย มักเป็นจริงว่า $n = m + r$ โดยเฉพาะ ถ้ามี generators ขั้นต่ำ $m$ ตัว โค้ดจะ encode $m$ bits และจะมี $2^m$ codewords และถ้ามี parity check strings ขั้นต่ำ $r$ ตัว จะมี $2^{n-r}$ codewords ดังนั้น generator แต่ละตัวทำให้ code space เป็นสองเท่า ขณะที่ parity check string แต่ละตัวทำให้ครึ่งหนึ่ง

ตัวอย่างเช่น 3-bit repetition code เป็น linear code ดังนั้นสามารถอธิบายได้ทั้งสองวิธีนี้ โดยเฉพาะ มีเพียงหนึ่งทางเลือกสำหรับ generator ที่ใช้ได้: $111$ เราสามารถอธิบายโค้ดด้วย parity check strings สองตัวแทน เช่น $110$ และ $011$ — ซึ่งน่าจะดูคุ้นเคยจากการอภิปรายก่อนหน้าของโค้ดนี้ — หรือเราอาจนำ parity check strings เป็น $110$ และ $101$ หรือ $101$ และ $011$ แทนก็ได้ (Generators และ parity check strings โดยทั่วไปไม่ unique สำหรับ classical linear code ที่กำหนด)

สำหรับตัวอย่างที่สอง พิจารณา $[7,4,3]$-Hamming code นี่คือทางเลือกหนึ่งสำหรับรายการ generators ที่ใช้ได้

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

และนี่คือทางเลือกสำหรับรายการ parity checks สำหรับโค้ดนี้

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

ที่นี่ นอกจากนี้ เราเห็นว่า ทั้งหมด ของ parity check strings ของเรานั้นอยู่ในโค้ดเอง

ข้อสังเกตสุดท้ายเกี่ยวกับ classical linear codes ซึ่งเชื่อมโยงพวกมันกับ stabilizer formalism คือ parity check strings เทียบเท่ากับ stabilizer generators ที่ประกอบด้วยเฉพาะ $Z$ และ identity Pauli matrices ตัวอย่างเช่น parity check strings $110$ และ $011$ สำหรับ 3-bit repetition code สอดคล้องกับ stabilizer generators $Z\otimes Z\otimes \mathbb{I}$ และ $\mathbb{I}\otimes Z\otimes Z$ พอดี ซึ่งสอดคล้องกับการอภิปรายของ Pauli observables จากบทก่อนหน้า

นิยามของ CSS codes

CSS codes คือ stabilizer codes ที่ได้จากการรวม คู่ ของ classical linear codes บางอย่างเข้าด้วยกัน สิ่งนี้ใช้ไม่ได้กับ classical linear codes สองตัวใด ๆ — โค้ดสองตัวต้องมีความสัมพันธ์บางอย่าง อย่างไรก็ตาม construction นี้เปิดความเป็นไปได้มากมายสำหรับโค้ดแก้ไขข้อผิดพลาดเชิงควอนตัม อาศัยส่วนหนึ่งจาก classical coding theory กว่า 75 ปี

ใน stabilizer formalism stabilizer generators ที่มีเฉพาะ $Z$ และ identity Pauli matrices เทียบเท่ากับ parity checks ดังที่เราเพิ่งสังเกตสำหรับ 3-bit repetition code สำหรับตัวอย่างอื่น พิจารณา parity check strings ต่อไปนี้สำหรับ $[7,4,3]$-Hamming code

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

parity check strings เหล่านี้สอดคล้องกับ stabilizer generators ต่อไปนี้ (เขียนโดยไม่มีสัญลักษณ์ tensor product) ซึ่งเราได้โดยแทน $1$ ด้วย $Z$ และ $0$ ด้วย $\mathbb{I}$ นี่คือสามในหก stabilizer generators สำหรับ 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}$$

เราให้ชื่อ $Z$ stabilizer generators กับ stabilizer generators แบบนี้ หมายความว่ามีเฉพาะ Pauli $Z$ และ identity tensor factors — ดังนั้น $X$ และ $Y$ Pauli matrices ไม่เกิดขึ้นใน $Z$ stabilizer generators

เราสามารถพิจารณา stabilizer generators ที่มีเฉพาะ $X$ และ identity Pauli matrices เป็น tensor factors ด้วย Stabilizer generators แบบนี้มองได้ว่าคล้ายกับ $Z$-stabilizer generators ยกเว้นว่าอธิบาย parity checks ใน $\{\vert+\rangle,\vert-\rangle\}$ basis แทน standard basis Stabilizer generators ของรูปแบบนี้เรียกว่า $X$ stabilizer generators — ดังนั้นไม่อนุญาตให้มี $Y$ หรือ $Z$ Pauli matrices

ตัวอย่างเช่น พิจารณา stabilizer generators สามตัวที่เหลือจาก 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}$$

พวกมันทำตามรูปแบบเดียวกันจาก $[7,4,3]$-Hamming code กับ $Z$-stabilizer generators ยกเว้นคราวนี้แทน $X$ สำหรับ $1$ แทนที่จะเป็น $Z$ สิ่งที่เราได้จาก stabilizer generators สามตัวนี้เท่านั้นคือโค้ดที่รวม 16 states ที่แสดงที่นี่ ซึ่งเราได้โดยนำ Hadamard operations ไปใช้กับ standard basis states ที่สอดคล้องกับ strings ใน $[7,4,3]$-Hamming code (แน่นอน code space สำหรับโค้ดนี้ยังรวม linear combinations ของ states เหล่านี้)

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

ตอนนี้เราสามารถนิยาม CSS codes ด้วยคำพูดง่าย ๆ

นิยาม

CSS code คือ stabilizer code ที่สามารถแสดงได้โดยใช้เฉพาะ $X$ และ $Z$ stabilizer generators

กล่าวคือ CSS codes คือ stabilizer codes ที่เรามี stabilizer generators ที่ไม่มี Pauli $Y$ matrices และ $X$ และ $Z$ ไม่ปรากฏใน stabilizer generator เดียวกัน

เพื่อให้ชัดเจน ตามนิยามนี้ CSS code คือโค้ดที่ เป็นไปได้ ที่จะเลือกแค่ $X$ และ $Z$ stabilizer generators — แต่เราต้องจำไว้ว่ามีอิสระในการเลือก stabilizer generators สำหรับ stabilizer codes ดังนั้น โดยทั่วไปจะมีทางเลือกต่าง ๆ สำหรับ stabilizer generators ของ CSS code ที่บังเอิญไม่เป็น $X$ หรือ $Z$ stabilizer generators (นอกเหนือจากอย่างน้อยหนึ่งทางเลือกที่เป็น)

นี่คือตัวอย่างง่าย ๆ มากของ CSS code ที่รวมทั้ง $Z$ stabilizer generator และ $X$ stabilizer generator:

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

ชัดเจนว่านี่คือ CSS code เพราะ stabilizer generator แรกเป็น $Z$ stabilizer generator และตัวที่สองเป็น $X$ stabilizer generator แน่นอน CSS code ต้องเป็น valid stabilizer code ด้วย — หมายความว่า stabilizer generators ต้อง commute กัน เป็น minimal generating set และ fix quantum state vector อย่างน้อยหนึ่งตัว ข้อกำหนดเหล่านี้ง่ายต่อการสังเกตสำหรับโค้ดนี้ ดังที่เราสังเกตในบทก่อนหน้า code space สำหรับโค้ดนี้คือ one-dimensional space ที่ span ด้วย $\vert\phi^+\rangle$ Bell state ข้อเท็จจริงที่ทั้งสอง stabilizer generators fix state นี้เห็นได้ชัดจากการพิจารณาสอง expressions ต่อไปนี้ของ e-bit พร้อมกับการตีความ stabilizer generators เหล่านี้เป็น parity checks ใน $\{\vert 0\rangle, \vert 1\rangle\}$ และ $\{\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}}$$

7-qubit Steane code เป็นอีกตัวอย่างของ 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}$$

ที่นี่เรามี $Z$ stabilizer generators สามตัวและ $X$ stabilizer generators สามตัว และเราได้ตรวจสอบแล้วว่านี่คือ valid stabilizer code

และ 9-qubit Shor code เป็นอีกตัวอย่าง

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

คราวนี้เรามี $Z$ stabilizer generators หกตัวและ $X$ stabilizer generators เพียงสองตัว ไม่เป็นไร ไม่จำเป็นต้องมีความสมดุลหรือสมมาตรระหว่างสองประเภทของ generators (แม้ว่าบ่อยครั้งจะมี)

อีกครั้ง สิ่งสำคัญคือ CSS codes ต้องเป็น valid stabilizer codes และโดยเฉพาะ $Z$ stabilizer generator แต่ละตัวต้อง commute กับ $X$ stabilizer generator แต่ละตัว ดังนั้น ไม่ใช่ทุกชุดของ $X$ และ $Z$ stabilizer generators ที่กำหนด valid CSS code

การตรวจจับและแก้ไขข้อผิดพลาด

เกี่ยวกับการตรวจจับและแก้ไขข้อผิดพลาด CSS codes โดยทั่วไปมีลักษณะคล้ายกับ 9-qubit Shor code กล่าวคือ $X$ และ $Z$ errors สามารถตรวจจับและแก้ไขได้อย่างอิสระโดยสมบูรณ์ โดยที่ $Z$ stabilizer generators อธิบายโค้ดที่ป้องกัน bit flips และ $X$ stabilizer generators อธิบายโค้ดที่ป้องกัน phase flips อย่างอิสระ สิ่งนี้ทำงานได้เพราะ $Z$ stabilizer generators commute กับ $Z$ errors อย่างจำเป็น รวมถึง $Z$ operations ที่นำไปใช้เป็น corrections ดังนั้นพวกมันมองไม่เห็นทั้งสองอย่างโดยสมบูรณ์ และเช่นเดียวกันสำหรับ $X$ stabilizer generators, errors และ corrections

เป็นตัวอย่าง มาพิจารณา 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}$$

แนวคิดพื้นฐานสำหรับโค้ดนี้ชัดเจนแล้วในตอนนี้: มันเป็น $[7,4,3]$-Hamming code สำหรับ bit-flip errors และ $[7,4,3]$-Hamming code สำหรับ phase-flip errors ข้อเท็จจริงที่ $X$ และ $Z$ stabilizer generators commute กันอาจเป็นความโชคดี เพราะนี่จะไม่เป็น valid stabilizer code หากไม่ได้เป็นเช่นนั้น แต่อันที่จริง มีตัวอย่างที่รู้จักมากมายของ classical linear codes ที่ให้ valid stabilizer code เมื่อใช้ในลักษณะที่คล้ายกัน

โดยทั่วไป สมมติว่ามี CSS code ที่ $Z$ stabilizer generators อนุญาตให้แก้ไข bit-flip errors สูงสุด $j$ อย่าง และ $X$ stabilizer generators อนุญาตให้แก้ไข phase-flip errors สูงสุด $k$ อย่าง ตัวอย่างเช่น $j = 1$ และ $k = 1$ สำหรับ Steane code เนื่องจาก $[7,4,3]$-Hamming code สามารถแก้ไข bit flip หนึ่งอย่างได้ จากนั้นตามมาว่า จาก discretization of errors CSS code นี้สามารถแก้ไข ข้อผิดพลาดใด ๆ บน qubits จำนวนหนึ่งสูงสุดถึง minimum ของ $j$ และ $k$ เพราะเมื่อวัด syndrome ข้อผิดพลาดใด ๆ บน qubit จำนวนนั้นจะ collapse อย่าง probabilistic เป็น combination บางอย่างของ $X$ errors, $Z$ errors หรือทั้งสอง — แล้ว $X$ errors และ $Z$ errors จะถูกตรวจจับและแก้ไขอย่างอิสระ

สรุปได้ว่า ถ้ามี classical linear codes สองตัว (หรือสำเนาสองตัวของ classical linear code เดียวกัน) ที่เข้ากันได้ ในแง่ที่กำหนด $X$ และ $Z$ stabilizer generators ที่ commute กัน CSS code ที่ได้จากการรวมพวกมันจะรับทอดคุณสมบัติการแก้ไขข้อผิดพลาดของโค้ดทั้งสองนั้น ในแง่ที่เพิ่งอธิบาย

สังเกตว่ามีราคาที่ต้องจ่ายด้วย กล่าวคือเราไม่สามารถ encode qubits ได้มากเท่ากับที่เราสามารถ encode bits ด้วย classical codes สองตัว เพราะจำนวนรวมของ stabilizer generators สำหรับ CSS code คือ ผลรวม ของจำนวน parity checks สำหรับ classical linear codes สองตัว และ stabilizer generator แต่ละตัวลด dimension ของ code space ลงครึ่งหนึ่ง ตัวอย่างเช่น $[7,4,3]$-Hamming code อนุญาตให้ encode classical bits สี่อย่าง เพราะมีเพียง parity check strings สามตัวสำหรับโค้ดนี้ ในขณะที่ 7-qubit Steane code encode เพียงหนึ่ง qubit เพราะมี stabilizer generators หกตัว

Code spaces ของ CSS codes

สิ่งสุดท้ายที่เราจะทำในการอภิปราย CSS codes นี้คือพิจารณา code spaces ของโค้ดเหล่านี้ สิ่งนี้จะให้โอกาสตรวจสอบความสัมพันธ์ที่ต้องมีระหว่าง classical linear codes สองตัวเพื่อให้เข้ากันได้ ในแง่ที่สามารถรวมเข้าด้วยกันเพื่อเป็น CSS code

พิจารณา CSS code ใด ๆ บน $n$ qubits และให้ $z_1, \ldots, z_s \in \Sigma^n$ เป็น $n$-bit parity check strings ที่สอดคล้องกับ $Z$ stabilizer generators ของโค้ดนี้ หมายความว่า classical linear code ที่อธิบายด้วยเฉพาะ $Z$ stabilizer generators ซึ่งเราจะตั้งชื่อว่า $\mathcal{C}_Z$ มีรูปแบบต่อไปนี้

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

พูดเป็นคำพูด classical linear code $\mathcal{C}_Z$ มีทุก string ที่ binary dot product กับทุก parity check strings $z_1, \ldots, z_s$ เป็นศูนย์

ในทิศทางเดียวกัน ให้นำ $x_1,\ldots,x_t\in\Sigma^n$ เป็น $n$-bit parity check strings ที่สอดคล้องกับ $X$ stabilizer generators ของโค้ดของเรา ดังนั้น classical linear code ที่สอดคล้องกับ $X$ stabilizer generators มีรูปแบบนี้

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

$X$ stabilizer generators เพียงอย่างเดียวจึงอธิบายโค้ดที่คล้ายกับโค้ดนี้ แต่ใน $\{\vert {+}\rangle,\vert {-}\rangle\}$ basis แทน standard basis

ตอนนี้เราจะแนะนำ classical linear codes ใหม่สองตัวที่ได้มาจากทางเลือกเดียวกันของ strings $z_1,\ldots,z_s$ และ $x_1,\ldots,x_t$ แต่เราถือว่า strings เหล่านี้เป็น generators แทนที่จะเป็น parity check strings โดยเฉพาะ เราได้โค้ดสองตัวนี้

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

สิ่งเหล่านี้เรียกว่า dual codes ของโค้ดที่นิยามก่อนหน้า: $\mathcal{D}_Z$ คือ dual code ของ $\mathcal{C}_Z$ และ $\mathcal{D}_X$ คือ dual code ของ $\mathcal{C}_X$ อาจไม่ชัดเจนในจุดนี้ว่า dual codes เหล่านี้เกี่ยวข้องอย่างไร แต่มันเกี่ยวข้องอย่างมากด้วยหลายเหตุผล รวมถึงสองเหตุผลที่อธิบายในย่อหน้าต่อไปนี้

ประการแรก เงื่อนไขที่ต้องมีสำหรับ classical linear codes $\mathcal{C}_Z$ และ $\mathcal{C}_X$ สองตัวเพื่อให้เข้ากันได้ ในแง่ที่สามารถจับคู่กันเพื่อเป็น CSS code สามารถอธิบายได้ในคำพูดง่าย ๆ โดยอ้างถึง dual codes โดยเฉพาะ ต้องเป็นว่า $\mathcal{D}_Z\subseteq\mathcal{C}_X$ หรือเทียบเท่าคือ $\mathcal{D}_X\subseteq\mathcal{C}_Z$ พูดเป็นคำพูด dual code $\mathcal{D}_Z$ รวม strings ที่สอดคล้องกับ $Z$ stabilizer generators และการที่พวกมันอยู่ใน $\mathcal{C}_X$ เทียบเท่ากับ binary dot product ของแต่ละ string เหล่านี้กับตัวที่สอดคล้องกับ $X$ stabilizer generators เป็นศูนย์ สิ่งนั้น ในทางกลับกัน เทียบเท่ากับ $Z$ stabilizer generator แต่ละตัว commute กับ $X$ stabilizer generator แต่ละตัว หรือโดยสลับบทบาทของ $X$ และ $Z$ stabilizer generators และเริ่มจากการบรรจุ $\mathcal{D}_X\subseteq\mathcal{C}_Z$ เราสามารถสรุปผลเดียวกันได้

ประการที่สอง โดยอ้างถึง dual codes เราสามารถอธิบาย code spaces ของ CSS code ที่กำหนดได้ง่าย โดยเฉพาะ code space ถูก span ด้วย vectors ของรูปแบบต่อไปนี้

$$\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{(for all $u\in\mathcal{C}_Z$)}$$

พูดเป็นคำพูด vectors เหล่านี้คือ uniform superpositions บน strings ใน dual code $\mathcal{D}_X$ ของโค้ดที่สอดคล้องกับ $X$ stabilizer generators ที่ถูก shift ด้วย (กล่าวคือ bitwise XORed กับ) strings ใน code $\mathcal{C}_Z$ ที่สอดคล้องกับ $Z$ stabilizer generators เพื่อให้ชัดเจน ทางเลือกต่าง ๆ สำหรับ shift — แทนด้วย string $u$ ใน expression นี้ — อาจให้ vector เดียวกัน ดังนั้น states เหล่านี้ไม่ได้แตกต่างกันทั้งหมด แต่รวมกันแล้ว span code space ทั้งหมด

นี่คือคำอธิบายเชิงสัญชาตญาณว่าทำไม vectors ดังกล่าวถึงทั้งอยู่ใน code space และ span มัน พิจารณา $n$-qubit standard basis state $\vert u\rangle$ สำหรับ $n$-bit string $u$ ใด ๆ และสมมติว่าเรา project state นี้ลงบน code space กล่าวคือ ให้ $\Pi$ แทน projection ลงบน code space ของ CSS code ของเรา พิจารณา vector $\Pi\vert u\rangle$ มีสองกรณี:

• กรณีที่ 1: $u\in\mathcal{C}_Z$ สิ่งนี้หมายความว่า $Z$ stabilizer generator แต่ละตัวของ CSS code ของเราทำงาน trivially บน $\vert u\rangle$ ในทางกลับกัน $X$ stabilizer generators แต่ละตัว flip bits บางส่วนของ $\vert u\rangle$ โดยเฉพาะ สำหรับ generator $v$ ของ $\mathcal{D}_X$ แต่ละตัว $X$ stabilizer generator ที่สอดคล้องกับ $v$ แปลง $\vert u\rangle$ เป็น $\vert u\oplus v\rangle$ โดยระบุ projection $\Pi$ เป็น ค่าเฉลี่ย บน elements ของ stabilizer (ดังที่เราเห็นในบทก่อนหน้า) เราได้สูตรนี้:

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

• กรณีที่ 2: $u\notin\mathcal{C}_Z$ สิ่งนี้หมายความว่า parity checks อย่างน้อยหนึ่งอันที่สอดคล้องกับ $Z$ stabilizer generators ล้มเหลว ซึ่งก็คือ $\vert u\rangle$ ต้องเป็น $-1$ eigenvector ของ $Z$ stabilizer generators อย่างน้อยหนึ่งตัว code space ของ CSS code คือ intersection ของ $+1$ eigenspaces ของ stabilizer generators ดังนั้น ในฐานะ $-1$ eigenvector ของ $Z$ stabilizer generators อย่างน้อยหนึ่งตัว $\vert u\rangle$ จึง orthogonal กับ code space:

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

และตอนนี้ เมื่อเราวนซ้ำบน $n$-bit strings $u$ ทั้งหมด ทิ้งตัวที่ $\Pi\vert u\rangle = 0$ และ normalize ตัวที่เหลือ เราได้ vectors ที่อธิบายก่อนหน้า ซึ่งแสดงว่าพวกมัน span code space

เรายังสามารถใช้ความสมมาตรระหว่าง $X$ และ $Z$ stabilizer generators เพื่ออธิบาย code space ในทิศทางที่คล้ายกันแต่แตกต่าง โดยเฉพาะ มันคือ space ที่ span ด้วย vectors ที่มีรูปแบบต่อไปนี้

$$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{(for $u\in\mathcal{C}_X$)}$$

โดยพื้นฐาน $X$ และ $Z$ ถูกสลับในทุก instance ที่ปรากฏ — แต่เราต้องสลับ standard basis สำหรับ $\{\vert+\rangle,\vert-\rangle\}$ basis ด้วย ซึ่งเป็นเหตุผลที่ Hadamard operations รวมอยู่

เป็นตัวอย่าง มาพิจารณา 7-qubit Steane code parity check strings สำหรับทั้ง $X$ และ $Z$ stabilizer generators เหมือนกัน: $1111000,$ $1100110,$ และ $1010101$ ดังนั้น codes $\mathcal{C}_X$ และ $\mathcal{C}_Z$ เหมือนกัน ทั้งสองเท่ากับ $[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\}$$

ดังนั้น dual codes $\mathcal{D}_X$ และ $\mathcal{D}_Z$ ก็เหมือนกันด้วย เรามี generators สามตัว ดังนั้นเราได้ strings แปดตัว

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

strings เหล่านี้อยู่ใน $[7,4,3]$-Hamming code ทั้งหมด ดังนั้นเงื่อนไข CSS จึงตอบสนอง: $\mathcal{D}_Z \subseteq \mathcal{C}_X$ หรือเทียบเท่าคือ $\mathcal{D}_X \subseteq \mathcal{C}_Z$

เนื่องจาก $\mathcal{D}_X$ มีครึ่งหนึ่งของ strings ทั้งหมดใน $\mathcal{C}_Z$ จึงมีเพียง vectors $\vert u\oplus \mathcal{D}_X\rangle$ สองตัวที่แตกต่างที่ได้จากการเลือก $u\in\mathcal{C}_Z$ สิ่งนี้คาดหวังได้ เพราะ 7-qubit Steane code มี code space สองมิติ เราสามารถใช้สอง states ที่เราได้ในลักษณะนี้เพื่อ encode logical state $\vert 0\rangle$ และ $\vert 1\rangle$ ดังนี้

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

ตามปกติ ทางเลือกนี้ไม่ได้บังคับ เราเป็นอิสระในการใช้ code space เพื่อ encode qubits อย่างไรก็ได้ตามที่เลือก อย่างไรก็ตาม encoding นี้สอดคล้องกับตัวอย่างของ encoding circuit สำหรับ 7-qubit Steane code ในบทก่อนหน้า