Kode CSS

Kode linear klasik

Kode koreksi kesalahan klasik pertama kali dipelajari pada tahun 1940-an, dan sekarang sudah banyak kode yang diketahui, di mana kode yang paling umum dipelajari dan digunakan masuk ke dalam kategori yang disebut kode linear. Kita akan melihat arti kata "linear" dalam konteks ini sebentar lagi, tapi cara sederhana untuk menjelaskan kode linear saat ini adalah bahwa mereka adalah kode stabilizer yang kebetulan bersifat klasik. Kode CSS pada dasarnya adalah pasangan kode linear klasik yang digabungkan untuk membentuk kode koreksi kesalahan kuantum. Jadi, demi pembahasan berikut ini, kita perlu memahami beberapa hal dasar tentang kode linear klasik.

Misalkan $\Sigma$ adalah alfabet biner untuk seluruh pembahasan ini. Ketika kita menyebut kode linear klasik, yang kita maksud adalah himpunan non-kosong $\mathcal{C}\subseteq\Sigma^n$ dari string biner dengan panjang $n,$ untuk suatu bilangan bulat positif $n,$ yang harus memenuhi satu sifat dasar: jika $u$ dan $v$ adalah string biner dalam $\mathcal{C},$ maka string $u\oplus v$ juga ada dalam $\mathcal{C}.$ Di sini, $u\oplus v$ mengacu pada exclusive-OR bitwise dari $u$ dan $v,$ seperti yang kita temui berkali-kali dalam kursus "Fundamentals of quantum algorithms".

Pada intinya, ketika kita menyebut kode koreksi kesalahan klasik sebagai linear, kita memikirkan string biner dengan panjang $n$ sebagai vektor berdimensi $n,$ di mana entri-entrinya adalah $0$ atau $1,$ dan mengharuskan kode itu sendiri membentuk subruang linear. Namun, alih-alih penjumlahan vektor biasa atas bilangan real atau kompleks, kita menggunakan penjumlahan modulo $2,$ yang merupakan exclusive-OR. Artinya, jika kita punya dua codeword $u$ dan $v,$ yang berarti $u$ dan $v$ adalah string biner dalam $\mathcal{C},$ maka $u + v$ modulo 2, yaitu $u\oplus v,$ juga harus menjadi codeword dalam $\mathcal{C}.$ Perhatikan, khususnya, bahwa implikasi ini harus benar bahkan jika $u = v.$ Ini berarti $\mathcal{C}$ harus menyertakan string all-zero $0^n,$ karena exclusive-OR bitwise dari string apapun dengan dirinya sendiri adalah string all-zero.

Contoh: kode repetisi 3-bit

Kode repetisi 3-bit adalah contoh kode linear klasik. Secara khusus, kita punya $\mathcal{C} = \{000,111\},$ jadi, berkaitan dengan kondisi linearitas, hanya ada dua pilihan untuk $u$ dan dua pilihan untuk $v.$ Mudah untuk menelusuri keempat pasangan yang mungkin dan melihat bahwa kita selalu mendapatkan codeword ketika mengambil exclusive-OR bitwise:

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

Contoh: kode $[7,4,3]$-Hamming

Ini adalah contoh lain dari kode linear klasik yang disebut kode $[7,4,3]$-Hamming. Ini adalah salah satu kode koreksi kesalahan klasik pertama yang pernah ditemukan, dan terdiri dari 16 string biner dengan panjang 7. (Terkadang kode $[7,4,3]$-Hamming dipahami sebagai kode dengan string-string ini dibalik, tapi kita akan menggunakannya sebagai kode yang memuat string-string yang ditampilkan di sini.)

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

Ada logika yang sangat sederhana di balik pemilihan string-string ini, tapi itu adalah hal sekunder dari pelajaran dan tidak akan dijelaskan di sini. Untuk sekarang, cukup untuk mengamati bahwa ini adalah kode linear klasik: meng-XOR dua string manapun dari string-string ini akan selalu menghasilkan string lain yang ada dalam kode.

Notasi $[7,4,3]$ (dalam tanda kurung siku tunggal) memiliki arti yang analog dengan notasi tanda kurung siku ganda untuk kode stabilizer yang disebutkan dalam pelajaran sebelumnya, tapi di sini untuk kode linear klasik. Secara khusus, codeword memiliki $7$ bit, kita bisa mengenkode $4$ bit menggunakan kode (karena ada $16 = 2^4$ codeword), dan kebetulan ini adalah kode jarak $3,$ yang berarti dua codeword yang berbeda harus berbeda setidaknya di $3$ posisi — jadi setidaknya $3$ bit harus dibalik untuk mengubah satu codeword menjadi codeword lain. Fakta bahwa ini adalah kode jarak $3$ berarti kode ini bisa mengoreksi hingga satu kesalahan bit-flip.

Mendeskripsikan kode linear klasik

Contoh-contoh yang baru saja disebutkan adalah contoh sangat sederhana dari kode linear klasik, tapi bahkan kode $[7,4,3]$-Hamming terlihat agak misterius ketika codeword-nya hanya didaftarkan. Ada cara yang lebih baik dan lebih efisien untuk mendeskripsikan kode linear klasik, termasuk dua cara berikut.

1. Generator. Satu cara untuk mendeskripsikan kode linear klasik adalah dengan daftar minimal codeword yang menghasilkan kode tersebut, artinya dengan mengambil semua subset yang mungkin dari codeword-codeword ini dan meng-XOR mereka bersama, kita mendapatkan seluruh kode.

   Lebih rinci, string $u_1,\ldots,u_m\in\Sigma^n$ menghasilkan kode linear klasik $\mathcal{C}$ jika

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

   dengan pengertian bahwa $\alpha u = u$ ketika $\alpha = 1$ dan $\alpha u = 0^n$ ketika $\alpha = 0,$ dan kita katakan bahwa daftar ini minimal jika menghapus salah satu string menghasilkan kode yang lebih kecil. Cara alami untuk memikirkan deskripsi seperti itu adalah bahwa koleksi $\{u_1,\ldots,u_m\}$ membentuk sebuah basis untuk $\mathcal{C}$ sebagai subruang, di mana kita memikirkan string sebagai vektor dengan entri bernilai biner, mengingat bahwa kita bekerja dalam ruang vektor di mana aritmatika dilakukan modulo $2.$

2. Parity check. Cara alami lainnya untuk mendeskripsikan kode linear klasik adalah dengan parity check — yaitu daftar minimal string biner di mana string-string dalam kode adalah persis yang memiliki dot product biner dengan setiap string parity check ini bernilai nol. (Mirip dengan exclusive-OR bitwise, dot product biner muncul beberapa kali dalam "Fundamentals of quantum algorithms".)

   Artinya, string $v_1,\ldots,v_r\in\Sigma^n$ adalah string parity check untuk kode linear klasik $\mathcal{C}$ jika

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

   dan himpunan string ini minimal jika menghapus satu menghasilkan kode yang lebih besar. Ini disebut string parity check karena $u$ memiliki dot product biner sama dengan nol dengan $v$ jika dan hanya jika bit-bit $u$ di posisi di mana $v$ memiliki angka 1 memiliki paritas genap. Jadi, untuk menentukan apakah string $u$ ada dalam kode $\mathcal{C},$ cukup untuk memeriksa paritas subset tertentu dari bit-bit $u.$

   Hal penting yang perlu diperhatikan di sini adalah bahwa dot product biner bukanlah inner product dalam pengertian formal. Secara khusus, ketika dua string memiliki dot product biner sama dengan nol, itu tidak berarti bahwa mereka ortogonal dengan cara biasa kita memikirkan ortogonalitas. Misalnya, dot product biner dari string $11$ dengan dirinya sendiri adalah nol — jadi mungkin saja string parity check untuk kode linear klasik ada di dalam kode itu sendiri.

Kode linear klasik atas alfabet biner selalu menyertakan sejumlah string yang merupakan pangkat $2$ — dan untuk kode linear klasik tunggal yang dideskripsikan dalam dua cara berbeda yang baru saja dijelaskan, akan selalu berlaku bahwa $n = m + r.$ Secara khusus, jika kita memiliki himpunan minimal $m$ generator, maka kode mengenkode $m$ bit dan kita pasti akan memiliki $2^m$ codeword; dan jika kita memiliki himpunan minimal $r$ string parity check, maka kita akan memiliki $2^{n-r}$ codeword. Jadi, setiap generator menggandakan ukuran ruang kode sementara setiap string parity check mengurangi separuh ukuran ruang kode.

Misalnya, kode repetisi 3-bit adalah kode linear, jadi bisa dideskripsikan dalam kedua cara ini. Secara khusus, hanya ada satu pilihan generator yang berfungsi: $111.$ Kita bisa secara alternatif mendeskripsikan kode dengan dua string parity check, seperti $110$ dan $011$ — yang sudah familiar dari pembahasan kode ini sebelumnya — atau kita bisa menggunakan string parity check $110$ dan $101,$ atau $101$ dan $011.$ (Generator dan string parity check umumnya tidak unik untuk kode linear klasik tertentu.)

Untuk contoh kedua, pertimbangkan kode $[7,4,3]$-Hamming. Berikut adalah satu pilihan untuk daftar generator yang berfungsi.

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

Dan berikut adalah pilihan untuk daftar parity check untuk kode ini.

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

Di sini, omong-omong, kita melihat bahwa semua string parity check kita sendiri ada dalam kode.

Satu catatan terakhir tentang kode linear klasik, yang menghubungkannya dengan formalisme stabilizer, adalah bahwa string parity check setara dengan generator stabilizer yang hanya terdiri dari matriks Pauli $Z$ dan identitas. Misalnya, string parity check $110$ dan $011$ untuk kode repetisi 3-bit secara tepat bersesuaian dengan generator stabilizer $Z\otimes Z\otimes \mathbb{I}$ dan $\mathbb{I}\otimes Z\otimes Z,$ yang konsisten dengan pembahasan Pauli observable dari pelajaran sebelumnya.

Definisi kode CSS

Kode CSS adalah kode stabilizer yang diperoleh dengan menggabungkan pasangan tertentu dari kode linear klasik. Ini tidak bekerja untuk dua kode linear klasik yang sembarang — dua kode tersebut harus memiliki hubungan tertentu. Meski begitu, konstruksi ini membuka banyak kemungkinan untuk kode koreksi kesalahan kuantum, yang sebagian didasarkan pada lebih dari 75 tahun teori kode klasik.

Dalam formalisme stabilizer, generator stabilizer yang hanya mengandung matriks Pauli $Z$ dan identitas setara dengan parity check, seperti yang baru saja kita amati untuk kode repetisi 3-bit. Untuk contoh lain, pertimbangkan string parity check berikut untuk kode $[7,4,3]$-Hamming.

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

String parity check ini bersesuaian dengan generator stabilizer berikut (ditulis tanpa simbol tensor product), yang kita peroleh dengan mengganti setiap $1$ dengan $Z$ dan setiap $0$ dengan $\mathbb{I}.$ Ini adalah tiga dari enam generator stabilizer untuk kode Steane 7-qubit.

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

Mari kita beri nama generator stabilizer $Z$ untuk generator stabilizer seperti ini, artinya generator yang hanya memiliki faktor tensor Pauli $Z$ dan identitas — jadi matriks Pauli $X$ dan $Y$ tidak pernah muncul dalam generator stabilizer $Z$.

Kita juga bisa mempertimbangkan generator stabilizer di mana hanya matriks Pauli $X$ dan identitas yang muncul sebagai faktor tensor. Generator stabilizer seperti ini bisa dilihat sebagai analog dari generator stabilizer $Z,$ kecuali bahwa mereka mendeskripsikan parity check dalam basis $\{\vert+\rangle,\vert-\rangle\}$ daripada basis standar. Generator stabilizer dalam bentuk ini disebut generator stabilizer $X$ — jadi tidak ada matriks Pauli $Y$ atau $Z$ yang diizinkan kali ini.

Misalnya, pertimbangkan tiga generator stabilizer yang tersisa dari kode Steane 7-qubit.

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

Mereka mengikuti pola yang persis sama dari kode $[7,4,3]$-Hamming seperti generator stabilizer $Z,$ kecuali kali ini kita mengganti $X$ untuk $1$ daripada $Z.$ Yang kita peroleh hanya dari tiga generator stabilizer ini adalah kode yang mencakup 16 state yang ditampilkan di sini, yang kita dapatkan dengan menerapkan operasi Hadamard ke state basis standar yang bersesuaian dengan string dalam kode $[7,4,3]$-Hamming. (Tentu saja, ruang kode untuk kode ini juga mencakup kombinasi linear dari state-state ini.)

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

Kita sekarang bisa mendefinisikan kode CSS dalam istilah yang sangat sederhana.

Definisi

Kode CSS adalah kode stabilizer yang bisa diekspresikan hanya menggunakan generator stabilizer $X$ dan $Z$.

Artinya, kode CSS adalah kode stabilizer di mana kita memiliki generator stabilizer yang tidak ada matriks Pauli $Y$ yang muncul, dan di mana $X$ dan $Z$ tidak pernah muncul dalam generator stabilizer yang sama.

Untuk lebih jelasnya, berdasarkan definisi ini, kode CSS adalah kode di mana mungkin untuk memilih hanya generator stabilizer $X$ dan $Z$ — tapi kita harus ingat bahwa ada kebebasan dalam cara kita memilih generator stabilizer untuk kode stabilizer. Jadi, umumnya akan ada pilihan berbeda untuk generator stabilizer kode CSS yang tidak kebetulan merupakan generator stabilizer $X$ atau $Z$ (selain setidaknya satu pilihan yang memang demikian).

Berikut adalah contoh sangat sederhana dari kode CSS yang mencakup generator stabilizer $Z$ dan generator stabilizer $X$:

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

Jelas bahwa ini adalah kode CSS, karena generator stabilizer pertama adalah generator stabilizer $Z$ dan yang kedua adalah generator stabilizer $X$. Tentu saja, kode CSS juga harus merupakan kode stabilizer yang valid — artinya generator stabilizer harus komut, membentuk himpunan pembangkit minimal, dan menetapkan setidaknya satu vektor state kuantum. Persyaratan-persyaratan ini kebetulan mudah untuk diamati untuk kode ini. Seperti yang kita catat dalam pelajaran sebelumnya, ruang kode untuk kode ini adalah ruang satu dimensi yang direntang oleh Bell state $\vert\phi^+\rangle.$ Fakta bahwa kedua generator stabilizer menetapkan state ini terlihat dengan mempertimbangkan dua ekspresi berikut dari sebuah e-bit, bersama dengan interpretasi generator stabilizer ini sebagai parity check dalam basis $\{\vert 0\rangle, \vert 1\rangle\}$ dan $\{\vert +\rangle, \vert -\rangle\}$.

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

Kode Steane 7-qubit adalah contoh lain dari kode CSS.

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

Di sini kita memiliki tiga generator stabilizer $Z$ dan tiga generator stabilizer $X,$ dan kita sudah memverifikasi bahwa ini adalah kode stabilizer yang valid.

Dan kode Shor 9-qubit adalah contoh lainnya.

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

Kali ini kita memiliki enam generator stabilizer $Z$ dan hanya dua generator stabilizer $X.$ Tidak masalah, tidak perlu ada keseimbangan atau simetri antara dua jenis generator (meskipun seringkali ada).

Sekali lagi, sangat penting bahwa kode CSS adalah kode stabilizer yang valid, dan khususnya setiap generator stabilizer $Z$ harus komut dengan setiap generator stabilizer $X.$ Jadi, tidak setiap kumpulan generator stabilizer $X$ dan $Z$ mendefinisikan kode CSS yang valid.

Deteksi dan koreksi kesalahan

Berkaitan dengan deteksi dan koreksi kesalahan, kode CSS secara umum memiliki karakteristik yang mirip dengan kode Shor 9-qubit, yaitu kesalahan $X$ dan $Z$ bisa dideteksi dan dikoreksi secara independen; generator stabilizer $Z$ mendeskripsikan kode yang melindungi terhadap bit flip, dan generator stabilizer $X$ mendeskripsikan kode yang secara independen melindungi terhadap phase flip. Ini berhasil karena generator stabilizer $Z$ harus komut dengan kesalahan $Z,$ serta operasi $Z$ yang diterapkan sebagai koreksi, sehingga mereka sepenuhnya tidak peduli dengan keduanya, dan begitu juga untuk generator stabilizer $X,$ kesalahan, dan koreksi.

Sebagai contoh, mari kita pertimbangkan kode Steane 7-qubit.

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

Ide dasar untuk kode ini sekarang sudah jelas: ini adalah kode $[7,4,3]$-Hamming untuk kesalahan bit-flip dan kode $[7,4,3]$-Hamming untuk kesalahan phase-flip. Fakta bahwa generator stabilizer $X$ dan $Z$ komut mungkin adalah keberuntungan, karena ini tidak akan menjadi kode stabilizer yang valid jika tidak demikian. Tapi ada, sebenarnya, banyak contoh kode linear klasik yang menghasilkan kode stabilizer yang valid ketika digunakan dengan cara yang serupa.

Secara umum, misalkan kita punya kode CSS di mana generator stabilizer $Z$ memungkinkan koreksi hingga $j$ kesalahan bit-flip, dan generator stabilizer $X$ memungkinkan koreksi hingga $k$ kesalahan phase-flip. Misalnya, $j = 1$ dan $k = 1$ untuk kode Steane, mengingat bahwa kode $[7,4,3]$-Hamming bisa mengoreksi satu bit flip. Kemudian, berdasarkan diskritisasi kesalahan, kode CSS ini bisa mengoreksi kesalahan apapun pada sejumlah qubit hingga minimum dari $j$ dan $k.$ Ini karena, ketika syndrome diukur, kesalahan sembarang pada jumlah qubit ini secara efektif kolaps secara probabilistik menjadi beberapa kombinasi kesalahan $X,$ kesalahan $Z,$ atau keduanya — dan kemudian kesalahan $X$ dan kesalahan $Z$ dideteksi dan dikoreksi secara independen.

Singkatnya, asalkan kita punya dua kode linear klasik (atau dua salinan dari satu kode linear klasik) yang kompatibel, dalam artian mereka mendefinisikan generator stabilizer $X$ dan $Z$ yang komut, kode CSS yang kita peroleh dengan menggabungkannya mewarisi sifat koreksi kesalahan dari dua kode tersebut, dalam pengertian yang baru saja dijelaskan.

Perhatikan bahwa ada harga yang harus dibayar, yaitu kita tidak bisa mengenkode sebanyak qubit seperti yang bisa kita lakukan dengan bit menggunakan dua kode klasik. Ini karena jumlah total generator stabilizer untuk kode CSS adalah jumlah dari jumlah parity check untuk dua kode linear klasik, dan setiap generator stabilizer mengurangi separuh dimensi ruang kode. Misalnya, kode $[7,4,3]$-Hamming memungkinkan pengenkodean empat bit klasik, karena kita hanya punya tiga string parity check untuk kode ini, sedangkan kode Steane 7-qubit hanya mengenkode satu qubit, karena memiliki enam generator stabilizer.

Ruang kode dari kode CSS

Hal terakhir yang akan kita lakukan dalam pembahasan kode CSS ini adalah mempertimbangkan ruang kode dari kode-kode ini. Ini akan memberi kita kesempatan untuk memeriksa lebih detail hubungan yang harus ada antara dua kode linear klasik agar kompatibel, dalam artian bisa digabungkan untuk membentuk kode CSS.

Pertimbangkan kode CSS apapun pada $n$ qubit, dan misalkan $z_1, \ldots, z_s \in \Sigma^n$ adalah string parity check $n$-bit yang bersesuaian dengan generator stabilizer $Z$ dari kode ini. Ini berarti kode linear klasik yang dijelaskan hanya oleh generator stabilizer $Z,$ yang akan kita namai $\mathcal{C}_Z,$ mengambil bentuk berikut.

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

Dengan kata lain, kode linear klasik $\mathcal{C}_Z$ memuat setiap string yang dot product binernya dengan setiap string parity check $z_1, \ldots, z_s$ adalah nol.

Dengan cara yang sama, mari kita ambil $x_1,\ldots,x_t\in\Sigma^n$ sebagai string parity check $n$-bit yang bersesuaian dengan generator stabilizer $X$ dari kode kita. Dengan demikian, kode linear klasik yang bersesuaian dengan generator stabilizer $X$ mengambil bentuk ini.

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

Generator stabilizer $X$ sendiri oleh karena itu mendeskripsikan kode yang mirip dengan kode ini, tapi dalam basis $\{\vert {+}\rangle,\vert {-}\rangle\}$ daripada basis standar.

Sekarang kita akan memperkenalkan dua kode linear klasik baru yang diturunkan dari pilihan string yang sama, $z_1,\ldots,z_s$ dan $x_1,\ldots,x_t,$ tapi di mana kita mengambil string-string ini sebagai generator daripada string parity check. Secara khusus, kita mendapatkan dua kode ini.

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

Ini dikenal sebagai kode dual dari kode-kode yang didefinisikan sebelumnya: $\mathcal{D}_Z$ adalah kode dual dari $\mathcal{C}_Z$ dan $\mathcal{D}_X$ adalah kode dual dari $\mathcal{C}_X.$ Mungkin belum jelas pada poin ini mengapa kode dual ini relevan, tapi ternyata sangat relevan karena beberapa alasan, termasuk dua alasan yang dijelaskan dalam paragraf berikut.

Pertama, kondisi yang harus dipenuhi agar dua kode linear klasik $\mathcal{C}_Z$ dan $\mathcal{C}_X$ kompatibel, dalam artian bisa dipasangkan untuk membentuk kode CSS, bisa dideskripsikan dalam istilah sederhana dengan merujuk pada kode dual. Secara khusus, harus berlaku bahwa $\mathcal{D}_Z\subseteq\mathcal{C}_X,$ atau ekuivalennya, bahwa $\mathcal{D}_X\subseteq\mathcal{C}_Z.$ Dengan kata lain, kode dual $\mathcal{D}_Z$ mencakup string yang bersesuaian dengan generator stabilizer $Z,$ dan ketercakupannya dalam $\mathcal{C}_X$ setara dengan dot product biner dari setiap string ini dengan yang bersesuaian dengan generator stabilizer $X$ adalah nol. Itu, pada gilirannya, setara dengan setiap generator stabilizer $Z$ komut dengan setiap generator stabilizer $X.$ Atau, dengan membalikkan peran generator stabilizer $X$ dan $Z$ dan mulai dari ketercakupan $\mathcal{D}_X\subseteq\mathcal{C}_Z,$ kita bisa mencapai kesimpulan yang sama.

Kedua, dengan merujuk pada kode dual, kita bisa dengan mudah mendeskripsikan ruang kode dari kode CSS tertentu. Secara khusus, ruang kode direntang oleh vektor dengan bentuk berikut.

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

Dengan kata lain, vektor-vektor ini adalah superposisi uniform atas string dalam kode dual $\mathcal{D}_X$ dari kode yang bersesuaian dengan generator stabilizer $X,$ yang digeser oleh (dengan kata lain, di-XOR bitwise dengan) string dalam kode $\mathcal{C}_Z$ yang bersesuaian dengan generator stabilizer $Z.$ Untuk lebih jelasnya, pilihan berbeda untuk pergeseran — diwakili oleh string $u$ dalam ekspresi ini — bisa menghasilkan vektor yang sama. Jadi, state-state ini tidak semuanya berbeda, tapi secara kolektif mereka merentang seluruh ruang kode.

Berikut adalah penjelasan intuitif mengapa vektor-vektor tersebut berada di dalam ruang kode dan merentangnya. Pertimbangkan state basis standar $n$-qubit $\vert u\rangle,$ untuk string $n$-bit sembarang $u,$ dan misalkan kita memproyeksikan state ini ke ruang kode. Artinya, dengan membiarkan $\Pi$ menunjukkan proyeksi ke ruang kode CSS kita, pertimbangkan vektor $\Pi\vert u\rangle.$ Ada dua kasus:

• Kasus 1: $u\in\mathcal{C}_Z.$ Ini berarti setiap generator stabilizer $Z$ dari kode CSS kita beraksi secara trivial pada $\vert u\rangle.$ Generator stabilizer $X,$ di sisi lain, masing-masing hanya membalik beberapa bit dari $\vert u\rangle.$ Secara khusus, untuk setiap generator $v$ dari $\mathcal{D}_X,$ generator stabilizer $X$ yang bersesuaian dengan $v$ mengubah $\vert u\rangle$ menjadi $\vert u\oplus v\rangle.$ Dengan mengkarakterisasi proyeksi $\Pi$ sebagai rata-rata atas elemen-elemen stabilizer (seperti yang kita lihat dalam pelajaran sebelumnya), kita memperoleh formula ini:

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

• Kasus 2: $u\notin\mathcal{C}_Z.$ Ini berarti setidaknya satu parity check yang bersesuaian dengan generator stabilizer $Z$ gagal, yang artinya $\vert u\rangle$ harus merupakan eigenvector $-1$ dari setidaknya satu generator stabilizer $Z.$ Ruang kode dari kode CSS adalah irisan dari eigenspace $+1$ dari generator stabilizer. Jadi, sebagai eigenvector $-1$ dari setidaknya satu generator stabilizer $Z,$ $\vert u\rangle$ oleh karena itu ortogonal terhadap ruang kode:

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

Dan sekarang, saat kita merentang semua string $n$-bit $u,$ membuang yang membuat $\Pi\vert u\rangle = 0,$ dan menormalisasi sisanya, kita mendapatkan vektor-vektor yang dijelaskan sebelumnya, yang menunjukkan bahwa mereka merentang ruang kode.

Kita juga bisa menggunakan simetri antara generator stabilizer $X$ dan $Z$ untuk mendeskripsikan ruang kode dengan cara yang serupa tapi berbeda. Secara khusus, ini adalah ruang yang direntang oleh vektor dengan bentuk berikut.

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

Pada intinya, $X$ dan $Z$ telah ditukar di setiap kemunculannya — tapi kita juga harus menukar basis standar dengan basis $\{\vert+\rangle,\vert-\rangle\},$ itulah mengapa operasi Hadamard disertakan.

Sebagai contoh, mari kita pertimbangkan kode Steane 7-qubit. String parity check untuk generator stabilizer $X$ maupun $Z$ adalah sama: $1111000,$ $1100110,$ dan $1010101.$ Kode $\mathcal{C}_X$ dan $\mathcal{C}_Z$ oleh karena itu sama; keduanya sama dengan kode $[7,4,3]$-Hamming.

$$\mathcal{C}_X = \mathcal{C}_Z = \{0000000, 0000111, 0011001, 0011110, 0101010, 0101101, 0110011, 0110100, 1001011, 1001100, 1010010, 1010101, 1100001, 1100110, 1111000, 1111111\}$$

Kode dual $\mathcal{D}_X$ dan $\mathcal{D}_Z$ oleh karena itu juga sama. Kita memiliki tiga generator, jadi kita mendapatkan delapan string.

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

String-string ini semuanya terkandung dalam kode $[7,4,3]$-Hamming, sehingga kondisi CSS terpenuhi: $\mathcal{D}_Z \subseteq \mathcal{C}_X,$ atau ekuivalennya, $\mathcal{D}_X \subseteq \mathcal{C}_Z.$

Mengingat bahwa $\mathcal{D}_X$ memuat setengah dari semua string dalam $\mathcal{C}_Z,$ hanya ada dua vektor berbeda $\vert u\oplus \mathcal{D}_X\rangle$ yang bisa diperoleh dengan memilih $u\in\mathcal{C}_Z.$ Ini diharapkan, karena kode Steane 7-qubit memiliki ruang kode dua dimensi. Kita bisa menggunakan dua state yang kita peroleh dengan cara ini untuk mengenkode state logis $\vert 0\rangle$ dan $\vert 1\rangle$ sebagai berikut.

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

Seperti biasa, pilihan ini tidak diwajibkan — kita bebas menggunakan ruang kode untuk mengenkode qubit dengan cara apapun yang kita pilih. Namun, enkoding ini konsisten dengan contoh Circuit enkoding untuk kode Steane 7-qubit dalam pelajaran sebelumnya.