Kode stabilizer

Sekarang kita akan mendefinisikan kode stabilizer secara umum. Kita juga akan membahas beberapa sifat dasarnya dan cara kerjanya, termasuk bagaimana state bisa diencode dan bagaimana error dideteksi serta dikoreksi menggunakan kode-kode ini.

Definisi kode stabilizer

Sebuah kode stabilizer $n$-Qubit ditentukan oleh daftar operasi Pauli $n$-Qubit, $P_1,\ldots,P_r.$ Operasi-operasi ini disebut generator stabilizer dalam konteks ini, dan harus memenuhi tiga sifat berikut.

1. Generator stabilizer semuanya komutatif satu sama lain.

   $$P_j P_k = P_k P_j \qquad \text{(for all $j,k\in\{1,\ldots,r\}$)}$$

2. Generator stabilizer membentuk himpunan penghasil minimal.

   $$P_k \notin \langle P_1,\ldots,P_{k-1},P_{k+1},\ldots,P_r\rangle \qquad \text{(for all $k\in\{1,\ldots,r\}$)}$$

3. Setidaknya ada satu vektor state kuantum yang ditetapkan oleh semua generator stabilizer.

   $$-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle$$

   (Mungkin tidak langsung terlihat bahwa keberadaan vektor state kuantum $\vert\psi\rangle$ yang ditetapkan oleh semua generator stabilizer, yaitu $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle,$ setara dengan $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle,$ namun memang demikian adanya, dan kita akan melihat alasannya sedikit lebih lanjut dalam pelajaran ini.)

Dengan asumsi kita punya daftar $P_1,\ldots,P_r$ seperti itu, ruang kode yang didefinisikan oleh generator stabilizer ini adalah subruang $\mathcal{C}$ yang memuat setiap vektor state kuantum $n$-Qubit yang ditetapkan oleh semua $r$ generator stabilizer ini.

$$\mathcal{C} = \bigl\{ \vert\psi\rangle \,:\, P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle \bigr\}$$

Vektor state kuantum dalam subruang ini adalah tepat vektor yang bisa dipandang sebagai encoding valid dari state kuantum. Kita akan membahas proses encoding yang sebenarnya nanti.

Akhirnya, stabilizer dari kode yang didefinisikan oleh generator stabilizer $P_1, \ldots, P_r$ adalah himpunan yang dihasilkan oleh operasi-operasi ini:

$$\langle P_1,\ldots,P_r\rangle.$$

Cara alami untuk memikirkan kode stabilizer adalah dengan memandang generator stabilizer sebagai observable, dan secara kolektif menginterpretasikan hasil pengukuran yang terkait dengan observable ini sebagai sindrom error. Encoding valid adalah vektor state kuantum $n$-Qubit yang hasil pengukurannya, sebagai nilai eigen, semuanya dijamin $+1.$ Sindrom lainnya, di mana setidaknya ada satu hasil pengukuran $-1,$ menandakan bahwa error telah terdeteksi.

Kita akan melihat beberapa contoh sebentar lagi, tapi pertama-tama ada beberapa catatan tentang tiga kondisi pada generator stabilizer.

Kondisi pertama bersifat alami, mengingat interpretasi generator stabilizer sebagai observable, karena kondisi ini mengimplikasikan bahwa urutan pengukuran tidak berpengaruh: observable-nya komutatif, sehingga pengukurannya juga komutatif. Ini secara alami memaksakan batasan aljabar tertentu pada kode stabilizer yang penting bagi cara kerjanya.

Kondisi kedua mengharuskan generator stabilizer membentuk himpunan penghasil minimal, artinya menghapus salah satunya akan menghasilkan stabilizer yang lebih kecil. Secara ketat, kondisi ini sebenarnya tidak esensial bagi cara kerja kode stabilizer dalam arti operasional — dan, seperti yang akan kita lihat di pelajaran berikutnya, terkadang memang masuk akal untuk memikirkan himpunan generator stabilizer untuk kode yang tidak memenuhi kondisi ini. Demi keperluan analisis kode stabilizer dan menjelaskan sifat-sifatnya, bagaimanapun, kita akan mengasumsikan kondisi ini berlaku. Singkatnya, kondisi ini menjamin bahwa setiap observable yang kita ukur untuk mendapatkan sindrom error menambah informasi tentang kemungkinan error, alih-alih bersifat redundan dan menghasilkan hasil yang bisa disimpulkan dari pengukuran generator stabilizer lainnya.

Kondisi ketiga mengharuskan setidaknya ada satu vektor tak-nol yang ditetapkan oleh semua generator stabilizer, yang setara dengan $-\mathbb{I}^{\otimes n}$ tidak termuat dalam stabilizer. Kebutuhan akan kondisi ini berasal dari fakta bahwa sebenarnya mungkin untuk memilih himpunan penghasil minimal dari operasi Pauli $n$-Qubit yang semuanya komutatif satu sama lain, namun tidak ada vektor tak-nol yang ditetapkan oleh setiap operasi. Kita tidak tertarik pada "kode" yang tidak memiliki encoding valid, sehingga kita menyingkirkan kemungkinan ini dengan menjadikannya bagian dari definisi.

Contoh

Berikut beberapa contoh kode stabilizer untuk nilai $n$ kecil. Kita akan melihat lebih banyak contoh, termasuk yang $n$-nya bisa jauh lebih besar, di pelajaran berikutnya.

Kode repetisi 3-bit

Kode repetisi 3-bit adalah contoh kode stabilizer, di mana generator stabilizer kita adalah $Z \otimes Z \otimes \mathbb{I}$ dan $\mathbb{I} \otimes Z \otimes Z.$

Kita bisa dengan mudah memeriksa bahwa dua generator stabilizer ini memenuhi kondisi yang diperlukan. Pertama, dua generator stabilizer $Z \otimes Z \otimes \mathbb{I}$ dan $\mathbb{I} \otimes Z \otimes Z$ saling komutatif.

$$(Z \otimes Z \otimes \mathbb{I})(\mathbb{I} \otimes Z \otimes Z) = Z \otimes \mathbb{I} \otimes Z = (\mathbb{I} \otimes Z \otimes Z)(Z \otimes Z \otimes \mathbb{I})$$

Kedua, kita memiliki himpunan penghasil minimal (yang dalam kasus ini cukup jelas).

$$\begin{aligned} Z \otimes Z \otimes \mathbb{I} \notin \langle\mathbb{I} \otimes Z \otimes Z\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, \mathbb{I} \otimes Z \otimes Z\}\\[1mm] \mathbb{I} \otimes Z \otimes Z \notin \langle Z \otimes Z \otimes \mathbb{I}\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z \otimes Z \otimes \mathbb{I}\} \end{aligned}$$

Dan ketiga, kita sudah tahu bahwa $\vert 000\rangle$ dan $\vert 111\rangle,$ serta kombinasi linear dari vektor-vektor ini, ditetapkan oleh $Z \otimes Z \otimes \mathbb{I}$ maupun $\mathbb{I} \otimes Z \otimes Z.$ Kita juga bisa menyimpulkan ini menggunakan kondisi ekuivalen dari definisi.

$$-\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\notin \langle Z \otimes Z \otimes \mathbb{I}, \mathbb{I} \otimes Z \otimes Z\rangle = \{ \mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z\otimes Z\otimes\mathbb{I}, Z\otimes\mathbb{I}\otimes Z, \mathbb{I}\otimes Z\otimes Z \}$$

Kondisi-kondisi ini bisa jauh lebih sulit untuk diperiksa pada kode stabilizer yang lebih rumit.

Kode repetisi 3-bit yang dimodifikasi

Pada pelajaran sebelumnya, kita melihat bahwa kode repetisi 3-bit bisa dimodifikasi agar melindungi dari error phase-flip alih-alih bit-flip. Sebagai kode stabilizer, kode baru ini mudah dideskripsikan: generator stabilizernya adalah $X \otimes X \otimes \mathbb{I}$ dan $\mathbb{I} \otimes X \otimes X.$

Kali ini generator stabilizer merepresentasikan observable $X\otimes X$ alih-alih $Z\otimes Z,$ sehingga pada dasarnya ini adalah pemeriksaan paritas dalam basis plus/minus alih-alih basis standar. Tiga kondisi yang diperlukan pada generator stabilizer mudah diverifikasi, dengan cara yang mirip dengan kode repetisi 3-bit biasa.

Kode Shor 9-Qubit

Berikut kode Shor 9-Qubit, yang juga merupakan kode stabilizer, dinyatakan dengan generator stabilizer.

$$\begin{gathered} Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z\\[1mm] X \otimes X \otimes X \otimes X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\otimes X \otimes X \otimes X \otimes X \otimes X \otimes X \end{gathered}$$

Dalam kasus ini, pada dasarnya kita memiliki tiga salinan kode repetisi 3-bit, satu untuk masing-masing dari tiga blok tiga Qubit, serta dua generator stabilizer terakhir, yang mengambil bentuk yang mengingatkan kita pada sirkuit untuk mendeteksi phase flip pada kode ini.

Cara alternatif untuk memikirkan dua generator stabilizer terakhir adalah bahwa mereka mengambil bentuk yang sama seperti pada kode repetisi 3-bit untuk phase flip, kecuali bahwa $X\otimes X\otimes X$ disubstitusikan untuk $X,$ yang konsisten dengan fakta bahwa $X\otimes X\otimes X$ sesuai dengan operasi $X$ pada Qubit logis yang diencode menggunakan kode repetisi 3-bit.

Sebelum melanjutkan ke contoh lain, perlu dicatat bahwa simbol produk tensor sering dihilangkan saat mendeskripsikan kode stabilizer berdasarkan daftar generator stabilizer, karena cenderung membuatnya lebih mudah dibaca dan melihat polanya. Misalnya, generator stabilizer yang sama seperti di atas untuk kode Shor 9-Qubit terlihat seperti ini tanpa simbol produk tensor yang ditulis secara eksplisit.

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

Kode Steane 7-Qubit

Berikut contoh lain dari kode stabilizer, yang dikenal sebagai kode Steane 7-Qubit. Kode ini memiliki beberapa fitur luar biasa, dan kita akan kembali ke kode ini dari waktu ke waktu sepanjang pelajaran-pelajaran berikutnya dalam kursus ini.

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

Untuk sekarang, mari kita cukup amati bahwa ini adalah kode stabilizer yang valid. Tiga generator stabilizer pertama jelas komutatif satu sama lain, karena $Z$ komutatif dengan dirinya sendiri dan identitas komutatif dengan segalanya, dan situasinya serupa untuk tiga generator stabilizer terakhir. Yang tersisa adalah memeriksa bahwa jika kita ambil salah satu generator $Z$-stabilizer (yaitu, salah satu dari tiga yang pertama) dan salah satu generator $X$-stabilizer (yaitu, salah satu dari tiga yang terakhir), maka keduanya komutatif, dan seseorang bisa melalui 9 kemungkinan pasangan untuk memeriksanya. Dalam semua kasus ini, matriks Pauli $X$ dan $Z$ selalu sejajar pada posisi yang sama sejumlah genap, sehingga dua generator akan komutatif, sama seperti $X\otimes X$ dan $Z\otimes Z$ yang komutatif. Ini juga merupakan himpunan penghasil minimal, dan mendefinisikan ruang kode yang tidak trivial, yang merupakan fakta yang diserahkan kepada kamu untuk direnungkan.

Kode Steane 7-Qubit mirip dengan kode Shor 9-Qubit dalam hal bahwa keduanya mengenkode satu Qubit dan memungkinkan koreksi error sembarang pada satu Qubit, tetapi hanya membutuhkan 7 Qubit alih-alih 9.

Kode 5-Qubit

Tujuh bukanlah jumlah Qubit terkecil yang diperlukan untuk mengenkode satu Qubit dan melindunginya dari error sembarang pada satu Qubit — berikut kode stabilizer yang melakukan ini hanya dengan 5 Qubit.

$$\begin{array}{ccccc} X & Z & Z & X & \mathbb{I} \\[1mm] \mathbb{I} & X & Z & Z & X \\[1mm] X & \mathbb{I} & X & Z & Z \\[1mm] Z & X & \mathbb{I} & X & Z \\[1mm] \end{array}$$

Kode ini biasanya disebut kode 5-Qubit. Ini adalah jumlah Qubit terkecil dalam kode koreksi error kuantum yang bisa memungkinkan koreksi error satu Qubit sembarang.

Kode stabilizer satu dimensi

Berikut contoh lain dari kode stabilizer, meski sebenarnya tidak mengenkode Qubit apapun: ruang kodenya berdimensi satu. Namun, ini tetap merupakan kode stabilizer yang valid menurut definisi.

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

Secara spesifik, ruang kode adalah ruang satu dimensi yang direntangkan oleh e-bit $\vert\phi^+\rangle.$

Berikut contoh terkait dari kode stabilizer yang ruang kodenya adalah ruang satu dimensi yang direntangkan oleh state GHZ $(\vert 000\rangle + \vert 111\rangle)/\sqrt{2}.$

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

Dimensi ruang kode

Misalkan kita memiliki kode stabilizer, yang dideskripsikan oleh generator stabilizer $n$-Qubit $P_1,\ldots,P_r.$ Mungkin pertanyaan pertama yang muncul tentang kode ini adalah, "Berapa banyak Qubit yang diencode?"

Pertanyaan ini memiliki jawaban sederhana. Dengan asumsi generator stabilizer $n$-Qubit $P_1, \ldots, P_r$ memenuhi tiga persyaratan definisi (yaitu, generator stabilizer semuanya komutatif satu sama lain, ini adalah himpunan penghasil minimal, dan ruang kode tidak kosong), maka ruang kode untuk kode stabilizer ini memiliki dimensi $2^{n-r},$ sehingga $n-r$ Qubit bisa diencode menggunakan kode ini.

Secara intuitif, kita memiliki $n$ Qubit untuk digunakan dalam encoding ini, dan setiap generator stabilizer secara efektif "mengambil satu Qubit" dalam hal berapa banyak Qubit yang bisa kita enkode. Perlu dicatat bahwa ini bukan tentang error mana atau berapa banyak yang bisa dideteksi atau dikoreksi, ini hanya pernyataan tentang dimensi ruang kode.

Misalnya, untuk kode repetisi 3-bit maupun versi modifikasinya untuk error phase-flip, kita memiliki $n=3$ Qubit dan $r=2$ generator stabilizer, sehingga masing-masing kode ini bisa mengenkode 1 Qubit. Sebagai contoh lain, pertimbangkan kode 5-Qubit: kita memiliki 5 Qubit dan 4 generator stabilizer, sehingga sekali lagi ruang kode berdimensi 2, artinya satu Qubit bisa diencode menggunakan kode ini. Sebagai contoh terakhir, kode yang generator stabilizernya adalah $X\otimes X$ dan $Z\otimes Z$ memiliki ruang kode berdimensi satu, direntangkan oleh state $\vert\phi^+\rangle,$ yang konsisten dengan memiliki $n=2$ Qubit dan $r=2$ generator stabilizer.

Sekarang mari kita lihat bagaimana fakta ini bisa dibuktikan. Langkah pertama adalah mengamati bahwa, karena generator stabilizer komutatif, dan karena setiap operasi Pauli adalah inversnya sendiri, setiap elemen dalam stabilizer bisa dinyatakan sebagai produk

$$P_1^{a_1} \cdots P_r^{a_r},$$

di mana $a_1,\ldots,a_r\in\{0,1\}.$ Ekuivalennya, setiap elemen stabilizer diperoleh dengan mengalikan beberapa subset dari generator stabilizer. Memang, setiap elemen stabilizer bisa dinyatakan secara unik dengan cara ini, karena kondisi bahwa $\{P_1,\ldots,P_r\}$ adalah himpunan penghasil minimal.

Selanjutnya, definisikan $\Pi_k$ sebagai proyeksi ke ruang vektor-eigen $+1$ dari $P_k,$ untuk setiap $k\in\{1,\ldots,r\}.$ Proyeksi-proyeksi ini bisa diperoleh dengan merata-ratakan operasi Pauli yang bersangkutan dengan operasi identitas sebagai berikut.

$$\Pi_k = \frac{\mathbb{I}^{\otimes n} + P_k}{2}$$

Ruang kode $\mathcal{C}$ adalah subruang dari semua vektor yang ditetapkan oleh semua $r$ generator stabilizer $P_1,\ldots,P_r,$ atau ekuivalennya, semua $r$ proyeksi $\Pi_1,\ldots,\Pi_r.$

Mengingat bahwa generator stabilizer semuanya komutatif satu sama lain, proyeksi $\Pi_1,\ldots,\Pi_r$ juga harus komutatif. Ini memungkinkan kita menggunakan fakta dari aljabar linear, yaitu bahwa produk dari proyeksi-proyeksi ini adalah proyeksi ke irisan dari subruang-subruang yang berhubungan dengan proyeksi-proyeksi individual. Artinya, produk $\Pi_1\cdots\Pi_r$ adalah proyeksi ke ruang kode $\mathcal{C}.$

Kita sekarang bisa menguraikan produk $\Pi_1\cdots\Pi_r$ menggunakan formula untuk proyeksi-proyeksi ini untuk mendapatkan ekspresi berikut.

$$\Pi_1\cdots\Pi_r = \biggl(\frac{\mathbb{I}^{\otimes n} + P_1}{2}\biggr)\cdots\biggl(\frac{\mathbb{I}^{\otimes n} + P_r}{2}\biggr) = \frac{1}{2^r}\sum_{a_1,\ldots,a_r \in \{0,1\}} P_1^{a_1}\cdots P_r^{a_r}$$

Dengan kata lain, proyeksi ke ruang kode dari sebuah kode stabilizer sama, sebagai matriks, dengan rata-rata atas semua elemen dalam stabilizer dari kode tersebut.

Akhirnya, kita bisa menghitung dimensi ruang kode dengan menggunakan fakta bahwa dimensi subruang mana pun sama dengan jejak proyeksi ke subruang tersebut. Dengan demikian, dimensi ruang kode $\mathcal{C}$ diberikan oleh formula berikut.

$$\operatorname{dim}(\mathcal{C}) = \operatorname{Tr}(\Pi_1\cdots\Pi_r) = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r})$$

Kita bisa mengevaluasi ekspresi ini dengan menggunakan beberapa fakta dasar.

• Kita memiliki $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ sehingga

  $$\operatorname{Tr}(P_1^{0}\cdots P_r^{0}) = 2^n.$$

• Untuk $(a_1,\ldots,a_r) \neq (0,\ldots,0),$ produk $P_1^{a_1}\cdots P_r^{a_r}$ haruslah $\pm 1$ kali operasi Pauli — tetapi kita tidak bisa mendapatkan $\mathbb{I}^{\otimes n}$ karena ini akan bertentangan dengan minimalitas himpunan $\{P_1,\ldots,P_r\},$ dan kita tidak bisa mendapatkan $-\mathbb{I}^{\otimes n}$ karena kondisi ketiga pada generator stabilizer melarangnya. Oleh karena itu, karena jejak setiap operasi Pauli non-identitas adalah nol, kita mendapatkan

  $$\operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) = 0.$$

Dimensi ruang kode dengan demikian adalah $2^{n-r}$ sebagaimana diklaim:

$$\begin{aligned} \operatorname{dim}(\mathcal{C}) & = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) \\ & = \frac{1}{2^r} \operatorname{Tr}(P_1^{0}\cdots P_r^{0}) \\ & = 2^{n-r}. \end{aligned}$$

Sebagai catatan tambahan, kita sekarang bisa melihat bahwa asumsi bahwa $-\mathbb{I}^{\otimes n}$ tidak termuat dalam stabilizer mengimplikasikan bahwa ruang kode harus memuat setidaknya satu vektor state kuantum. Ini karena, seperti yang baru saja kita verifikasi, asumsi ini mengimplikasikan bahwa ruang kode memiliki dimensi $2^{n-r},$ yang tidak mungkin nol. Implikasi kebalikannya ternyata trivial: jika $-\mathbb{I}^{\otimes n}$ termuat dalam stabilizer, maka ruang kode tidak mungkin memuat vektor state kuantum manapun, karena tidak ada vektor tak-nol yang ditetapkan oleh operasi ini.

Operasi Clifford dan pengkodean

Selanjutnya, kita akan membahas secara singkat bagaimana qubit bisa dikodekan menggunakan stabilizer codes, tapi untuk itu kita perlu mengenalkan dulu operasi Clifford.

Operasi Clifford

Operasi Clifford adalah operasi uniter, pada qubit berapa pun, yang bisa diimplementasikan oleh quantum circuit dengan kumpulan gate yang terbatas:

• Hadamard gates
• Gate $S$
• CNOT gates

Perlu diperhatikan bahwa gate $T$ tidak termasuk, begitu pula Toffoli gates dan Fredkin gates. Bukan hanya gate-gate tersebut tidak ada dalam daftar, bahkan faktanya tidak mungkin mengimplementasikan gate-gate itu menggunakan yang ada di sini; mereka bukan operasi Clifford. Operasi Pauli, di sisi lain, adalah operasi Clifford karena bisa diimplementasikan dengan rangkaian gate Hadamard dan $S$.

Itu cara sederhana untuk mendefinisikan operasi Clifford, tapi tidak menjelaskan kenapa didefinisikan seperti ini atau apa yang istimewa dari kumpulan gate tertentu ini. Alasan sebenarnya operasi Clifford didefinisikan seperti ini adalah bahwa, sampai faktor fase global, operasi Clifford adalah tepat operasi uniter yang selalu mengubah operasi Pauli menjadi operasi Pauli melalui konjugasi. Lebih tepatnya, operasi uniter $n$-qubit $U$ setara dengan operasi Clifford sampai faktor fase jika, dan hanya jika, untuk setiap operasi Pauli $n$-qubit $P,$ kita punya

$$U P U^{\dagger} = \pm Q$$

untuk suatu operasi Pauli $n$-qubit $Q.$

(Perlu dicatat bahwa tidak mungkin ada $U P U^{\dagger} = \alpha Q$ untuk $\alpha\notin\{+1,-1\}$ ketika $U$ adalah uniter dan $P$ dan $Q$ adalah operasi Pauli. Ini mengikuti dari fakta bahwa matriks di sisi kiri persamaan tersebut adalah uniter sekaligus Hermitian, dan $+1$ serta $-1$ adalah satu-satunya pilihan untuk $\alpha$ yang memungkinkan sisi kanan menjadi uniter dan Hermitian juga.)

Cukup mudah untuk memverifikasi sifat konjugasi yang baru saja dijelaskan ketika $U$ adalah Hadamard, gate $S,$ atau CNOT. Khususnya, ini mudah untuk Hadamard gates,

$$H X H^{\dagger} = Z, \qquad H Y H^{\dagger} = -Y, \qquad H Z H^{\dagger} = X,$$

dan gate $S,$

$$S X S^{\dagger} = Y, \qquad S Y S^{\dagger} = -X, \qquad S Z S^{\dagger} = Z.$$

Untuk CNOT gates, ada 15 operasi Pauli non-identitas pada dua qubit yang perlu dicek. Tentu saja, bisa dicek satu per satu — tapi hubungan antara CNOT gates dan gate $X$ dan $Z$ yang terdaftar (dalam bentuk circuit) di pelajaran sebelumnya, bersama dengan aturan perkalian untuk matriks Pauli, menawarkan jalan pintas menuju kesimpulan yang sama.

Begitu kita tahu bahwa sifat konjugasi ini benar untuk Hadamard, gate $S,$ dan CNOT gates, kita bisa langsung menyimpulkan bahwa itu benar untuk circuit yang tersusun dari gate-gate ini — yang artinya, semua operasi Clifford.

Lebih sulit untuk membuktikan bahwa hubungan ini bekerja ke arah sebaliknya, yaitu bahwa jika suatu operasi uniter $U$ memenuhi sifat konjugasi untuk operasi Pauli, maka harus mungkin untuk mengimplementasikannya (sampai fase global) hanya menggunakan Hadamard, $S,$ dan CNOT gates. Ini tidak akan dijelaskan di pelajaran ini, tapi memang benar.

Operasi Clifford bukan universal untuk komputasi kuantum; tidak seperti kumpulan gate kuantum universal, pendekatan operasi uniter sembarang ke tingkat akurasi berapa pun dengan operasi Clifford tidak mungkin dilakukan. Memang, untuk nilai $n$ tertentu, hanya ada finitely many operasi Clifford $n$-qubit (sampai faktor fase). Melakukan operasi Clifford pada standard basis states diikuti dengan standard basis measurements juga tidak bisa memungkinkan kita melakukan komputasi yang di luar jangkauan algoritma klasik — karena kita bisa secara efisien mensimulasikan komputasi bentuk ini secara klasikal. Fakta ini dikenal sebagai teorema Gottesman-Knill.

Encoder untuk stabilizer codes

Stabilizer code mendefinisikan code space dengan dimensi tertentu, dan kita punya kebebasan untuk menggunakan code space itu sesuka kita — tidak ada yang memaksa kita untuk mengkodekan qubit ke dalam code space ini dengan cara tertentu. Namun selalu mungkin menggunakan operasi Clifford sebagai encoder, jika kita memilih itu. Lebih tepatnya, untuk setiap stabilizer code yang memungkinkan $m$ qubit dikodekan ke dalam $n$ qubit, ada operasi Clifford $n$-qubit $U$ sehingga, untuk setiap vektor state kuantum $m$-qubit $\vert\phi\rangle,$ kita punya bahwa

$$\vert\psi\rangle = U \bigl(\vert 0^{n-m} \rangle \otimes \vert \phi\rangle\bigr)$$

adalah vektor state kuantum dalam code space dari kode kita yang bisa kita interpretasikan sebagai pengkodean dari $\vert\phi\rangle.$

Ini bagus karena operasi Clifford relatif sederhana, dibandingkan dengan operasi uniter sembarang, dan ada cara untuk mengoptimalkan implementasinya menggunakan teknik yang mirip dengan yang ditemukan dalam bukti teorema Gottesman-Knill. Hasilnya, circuit untuk mengkodekan state menggunakan stabilizer codes tidak perlu terlalu besar. Khususnya, selalu mungkin melakukan pengkodean untuk stabilizer code $n$-qubit menggunakan operasi Clifford yang membutuhkan gate $O(n^2/\log(n))$. Ini karena setiap operasi Clifford pada $n$ qubit bisa diimplementasikan oleh circuit berukuran ini.

Misalnya, berikut adalah encoder untuk 7-qubit Steane code. Ini memang operasi Clifford, dan ternyata yang ini bahkan tidak perlu gate $S$.

Mendeteksi error

Untuk stabilizer code $n$-qubit yang dijelaskan oleh stabilizer generators $P_1,\ldots, P_r,$ deteksi error bekerja dengan cara berikut.

Untuk mendeteksi error, semua stabilizer generators diukur sebagai observabel. Ada $r$ stabilizer generators, dan karenanya $r$ hasil pengukuran, masing-masing bernilai $+1$ atau $-1$ (atau nilai biner jika kita memilih untuk mengasosiasikan $0$ dengan $+1$ dan $1$ dengan $-1,$ masing-masing). Kita menginterpretasikan $r$ hasil tersebut secara kolektif, sebagai vektor atau string, sebagai syndrome. Syndrome $(+1,\ldots,+1)$ menunjukkan bahwa tidak ada error yang terdeteksi, sementara setidaknya satu $-1$ di dalam syndrome menunjukkan bahwa suatu error telah terdeteksi.

Misalkan, khususnya, bahwa $E$ adalah operasi Pauli $n$-qubit, mewakili error hipotetis. (Kita hanya mempertimbangkan operasi Pauli sebagai error, ngomong-ngomong, karena diskretisasi error bekerja dengan cara yang sama untuk stabilizer codes sembarang seperti yang terjadi untuk 9-qubit Shor code.) Ada tiga kasus yang menentukan apakah $E$ terdeteksi sebagai error atau tidak.

Kasus-kasus deteksi error

1. Operasi $E$ proporsional terhadap suatu elemen dalam stabilizer.

   $$E = \pm Q \; \text{for some}\; Q \in \langle P_1,\ldots,P_r\rangle$$

   Dalam kasus ini, $E$ harus komutatif dengan setiap stabilizer generator, jadi kita memperoleh syndrome $(+1,\ldots,+1).$ Ini berarti $E$ tidak terdeteksi sebagai error.

2. Operasi $E$ tidak proporsional terhadap elemen dalam stabilizer, tapi tetap saja komutatif dengan setiap stabilizer generator.

   $$E\neq \pm Q\; \text{for} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{but}\; E P_k = P_k E \;\text{for every}\; k\in\{1,\ldots,r\}$$

   Ini adalah error yang mengubah vektor dalam code space dengan cara yang tidak trivial. Tapi, karena $E$ komutatif dengan setiap stabilizer generator, syndrome-nya adalah $(+1,\ldots,+1),$ sehingga $E$ tidak terdeteksi oleh kode.

3. Operasi $E$ anti-komutatif dengan setidaknya satu stabilizer generator.

   $$P_k E = -E P_k \; \text{for at least one} \; k\in\{1,\ldots,r\}$$

   Syndrome-nya berbeda dari $(+1,\ldots,+1),$ jadi error $E$ terdeteksi oleh kode.

Dalam kasus pertama, error $E$ bukan masalah karena operasi ini tidak melakukan apa pun pada vektor dalam code space, kecuali mungkin menyuntikkan fase global yang tidak relevan: $E \ket{\psi} = \pm\ket{\psi}$ untuk setiap encoded state $\ket{\psi}.$ Pada dasarnya, ini sebenarnya bukan error — tindakan non-trivial apa pun yang mungkin dilakukan $E$ terjadi di luar code space — jadi bagus bahwa $E$ tidak terdeteksi sebagai error, karena tidak perlu dilakukan apa pun.

Kasus kedua, secara intuitif, adalah kasus yang buruk. Anti-komutasi suatu error dengan stabilizer generator yang menyebabkan $-1$ muncul di suatu tempat dalam syndrome, yang menandakan error, tapi itu tidak terjadi dalam kasus ini. Jadi, kita punya error $E$ yang memang mengubah vektor dalam code space dengan cara yang tidak trivial, tapi tidak terdeteksi oleh kode. Misalnya, untuk 3-bit repetition code, operasi $E = X\otimes X\otimes X$ termasuk dalam kategori ini.

Fakta bahwa error $E$ seperti itu harus mengubah beberapa vektor dalam code space dengan cara yang tidak trivial bisa diargumentasikan sebagai berikut. Dengan asumsi bahwa $E$ komutatif dengan $P_1,\ldots,P_r$ tapi tidak proporsional terhadap elemen stabilizer, kita bisa menyimpulkan bahwa kita akan mendapatkan stabilizer code baru yang valid dengan memasukkan $E$ sebagai stabilizer generator bersama $P_1,\ldots,P_r.$ Namun code space untuk kode baru ini hanya memiliki setengah dimensi dari code space asli, yang dari sana kita bisa menyimpulkan bahwa aksi $E$ pada code space asli tidak bisa proporsional terhadap operasi identitas.

Untuk kasus terakhir dari tiga kasus tersebut, yaitu bahwa error $E$ anti-komutatif dengan setidaknya satu stabilizer generator, syndrome memiliki setidaknya satu $-1$ di suatu tempat, yang menunjukkan ada yang salah. Seperti yang sudah kita bahas, syndrome tidak akan secara unik mengidentifikasi $E$ secara umum, jadi masih perlu memilih operasi koreksi untuk setiap syndrome, yang mungkin atau tidak mungkin mengoreksi error $E.$ Kita akan membahas langkah ini sebentar lagi, di bagian terakhir pelajaran.

Jarak stabilizer code

Sebagai terminologi, ketika kita menyebut jarak dari suatu stabilizer code, yang kita maksud adalah bobot minimum dari operasi Pauli $E$ yang termasuk dalam kategori kedua di atas — artinya operasi yang mengubah code space dengan cara yang tidak trivial, tapi kode tidak mendeteksi ini. Ketika disebutkan bahwa suatu stabilizer code adalah stabilizer code $[[n,m,d]]$, menggunakan tanda kurung siku ganda, ini berarti:

1. Pengkodean panjangnya $n$ qubit,
2. kode memungkinkan pengkodean $m$ qubit, dan
3. jarak kode adalah $d.$

Sebagai contoh, mari kita perhatikan 7-qubit Steane code. Berikut adalah stabilizer generators untuk kode ini:

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

Kode ini memiliki jarak 3, dan kita bisa berargumen seperti ini.

Pertama, perhatikan operasi Pauli $E$ berbobot paling banyak 2, dan anggap operasi ini komutatif dengan semua enam stabilizer generators. Kita akan menyimpulkan bahwa $E$ harus merupakan operasi identitas, yang (seperti biasa) adalah elemen dari stabilizer. Ini akan menunjukkan bahwa jarak kode secara ketat lebih besar dari 2. Anggap, khususnya, bahwa $E$ berbentuk

$$E = P \otimes Q \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}$$

untuk $P$ dan $Q$ yang mungkin merupakan matriks Pauli non-identitas. Ini hanya satu kasus, dan perlu mengulangi argumen yang menyusul untuk semua lokasi lain yang mungkin untuk matriks Pauli non-identitas di antara faktor tensor dari $E,$ tapi argumennya pada dasarnya sama untuk semua lokasi yang mungkin.

Operasi $E$ komutatif dengan semua enam stabilizer generators, jadi komutatif dengan dua ini khususnya:

$$\begin{gathered} Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z\\[1mm] X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \end{gathered}$$

Faktor tensor $Q$ dalam error $E$ kita sejajar dengan matriks identitas dalam kedua stabilizer generators ini (itulah mengapa keduanya dipilih). Mengingat bahwa kita memiliki matriks identitas di 5 posisi paling kanan dari $E,$ kita menyimpulkan bahwa $P$ harus komutatif dengan $X$ dan $Z,$ karena jika tidak $E$ akan anti-komutatif dengan salah satu dari dua generator tersebut. Namun, satu-satunya matriks Pauli yang komutatif dengan $X$ maupun $Z$ adalah matriks identitas, jadi $P = \mathbb{I}.$

Sekarang kita tahu ini, kita bisa memilih dua stabilizer generators lagi yang memiliki $X$ dan $Z$ di posisi kedua dari kiri, dan kita menarik kesimpulan serupa: $Q = \mathbb{I}.$ Oleh karena itu, $E$ adalah operasi identitas.

Jadi, tidak ada cara bagi error berbobot paling banyak 2 untuk tidak terdeteksi oleh kode ini, kecuali error tersebut adalah operasi identitas (yang ada dalam stabilizer dan karenanya bukan error sungguhan). Di sisi lain, ada operasi Pauli berbobot 3 yang komutatif dengan semua enam stabilizer generators ini, tapi tidak proporsional terhadap elemen stabilizer, seperti $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ dan $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z.$ Ini menetapkan bahwa kode ini memiliki jarak 3, seperti yang diklaim.

Mengoreksi error

Topik pembahasan terakhir untuk pelajaran ini adalah koreksi error untuk stabilizer codes. Seperti biasa, anggap kita memiliki stabilizer code yang ditentukan oleh stabilizer generators $n$-qubit $P_1, \ldots, P_r.$

Operasi Pauli $n$-qubit, sebagai error yang bisa mempengaruhi state yang dikodekan menggunakan kode ini, dipartisi ke dalam koleksi berukuran sama sesuai dengan syndrome yang mereka sebabkan. Ada $2^r$ syndrome yang berbeda dan $4^n$ operasi Pauli, yang berarti ada $4^n/2^r$ operasi Pauli yang menyebabkan setiap syndrome. Error mana pun dari operasi-operasi ini bisa bertanggung jawab atas syndrome yang bersangkutan.

Namun, di antara $4^n/2^r$ operasi Pauli yang menyebabkan setiap syndrome, ada beberapa yang harus dianggap setara. Khususnya, jika produk dari dua operasi Pauli proporsional terhadap elemen stabilizer, maka kedua operasi tersebut secara efektif setara sebagai error.

Cara lain untuk mengatakannya adalah bahwa jika kita menerapkan operasi koreksi $C$ untuk mencoba mengoreksi error $E,$ maka koreksi ini berhasil selama komposisi $CE$ proporsional terhadap elemen stabilizer. Mengingat ada $2^r$ elemen dalam stabilizer, berikut bahwa setiap operasi koreksi $C$ mengoreksi $2^r$ error Pauli yang berbeda. Ini meninggalkan $4^{n-r}$ kelas operasi Pauli yang tidak setara, yang dianggap sebagai error, yang konsisten dengan setiap syndrome yang mungkin.

Ini berarti bahwa, kecuali $n=r$ (di mana kita memiliki code space satu dimensi yang trivial), kita tidak mungkin mengoreksi setiap error yang terdeteksi oleh stabilizer code. Yang harus kita lakukan sebagai gantinya adalah memilih hanya satu operasi koreksi untuk setiap syndrome, dengan harapan mengoreksi hanya satu kelas error setara yang menyebabkan syndrome ini.

Satu strategi alami untuk memilih operasi koreksi mana yang dilakukan untuk setiap syndrome adalah memilih operasi Pauli berbobot paling rendah yang, sebagai error, menyebabkan syndrome tersebut. Sebenarnya mungkin ada beberapa operasi yang seri untuk error berbobot terendah yang konsisten dengan syndrome tertentu, di mana kasus mana pun salah satunya bisa dipilih. Idenya adalah bahwa operasi Pauli berbobot lebih rendah mewakili penjelasan yang lebih mungkin untuk syndrome yang telah diukur. Ini mungkin sebenarnya tidak berlaku untuk beberapa noise model, dan satu strategi alternatif adalah menghitung error yang paling mungkin yang menyebabkan syndrome yang diberikan, berdasarkan noise model yang dipilih. Untuk pelajaran ini, namun, kita akan membuat hal sederhana dan hanya mempertimbangkan koreksi berbobot terendah.

Untuk stabilizer code berjarak $d,$ strategi memilih operasi koreksi sebagai operasi Pauli berbobot terendah yang konsisten dengan syndrome yang diukur selalu memungkinkan koreksi error berbobot ketat kurang dari setengah $d,$ atau dengan kata lain, bobot paling banyak $(d-1)/2.$ Ini menunjukkan, misalnya, bahwa 7-qubit Steane code bisa mengoreksi error Pauli berbobot satu apa pun, dan dengan diskretisasi error, ini berarti bahwa Steane code bisa mengoreksi error sembarang pada satu qubit.

Untuk melihat cara kerjanya, perhatikan diagram di bawah. Lingkaran di sebelah kiri mewakili semua operasi Pauli yang menghasilkan syndrome $(+1,\ldots,+1),$ yang merupakan syndrome yang menunjukkan bahwa tidak ada error yang terjadi dan semuanya baik-baik saja. Di antara operasi-operasi ini kita memiliki elemen stabilizer (atau operasi yang proporsional terhadap elemen stabilizer, lebih tepatnya) dan juga error non-trivial yang mengubah code space dengan suatu cara tapi tidak terdeteksi oleh kode. Berdasarkan definisi jarak, setiap operasi Pauli dalam kategori ini harus berbobot setidaknya $d,$ karena $d$ didefinisikan sebagai bobot minimum dari operasi-operasi ini.

Lingkaran di sebelah kanan mewakili operasi Pauli yang menghasilkan syndrome berbeda $s\neq(+1,\ldots,+1),$ termasuk error $E$ berbobot ketat kurang dari $d/2$ yang akan kita pertimbangkan.

Operasi koreksi $C$ yang dipilih untuk syndrome $s$ adalah operasi Pauli berbobot paling rendah dalam koleksi yang diwakili oleh lingkaran di sebelah kanan dalam diagram (atau salah satunya jika ada seri). Jadi, bisa saja $C = E,$ tapi tidak harus. Yang bisa kita katakan dengan pasti, namun, adalah bahwa $C$ tidak bisa berbobot lebih besar dari bobot $E,$ karena $C$ berbobot minimal di antara operasi dalam koleksi ini — dan karenanya $C$ berbobot ketat kurang dari $d/2.$

Sekarang perhatikan apa yang terjadi ketika operasi koreksi $C$ diterapkan pada state apa pun yang kita peroleh setelah error $E$ terjadi. Dengan asumsi bahwa pengkodean asli adalah $\vert\psi\rangle,$ kita tersisa dengan $CE\vert\psi\rangle.$ Tujuan kita adalah menunjukkan bahwa $CE$ proporsional terhadap elemen dalam stabilizer, yang menyiratkan bahwa koreksi berhasil dan (sampai fase global) kita tersisa dengan encoded state asli $\vert\psi\rangle.$

Pertama, karena $E$ dan $C$ menyebabkan syndrome yang sama, komposisi $CE$ harus komutatif dengan setiap stabilizer generator. Khususnya, jika $P_k$ adalah salah satu stabilizer generators, maka kita harus punya

$$P_k E = \alpha E P_k \quad\text{and}\quad P_k C = \alpha C P_k$$

untuk nilai $\alpha\in\{+1,-1\}$ yang sama, karena ini adalah entri ke-$k$ dalam syndrome $s$ yang keduanya $C$ dan $E$ hasilkan. Karenanya, kita punya

$$P_k (CE) = \alpha C P_k E = \alpha^2 (CE) P_k = (CE) P_k,$$

jadi $P_k$ komutatif dengan $CE.$ Kita telah menunjukkan bahwa $CE$ masuk dalam lingkaran di sebelah kiri dalam diagram, karena menghasilkan syndrome $(+1,\ldots,+1).$

Kedua, komposisi $CE$ harus berbobot paling banyak jumlah bobot $C$ dan $E$ — yang mengikuti dari sejenak memikirkan produk operasi Pauli — dan karenanya bobot $CE$ secara ketat kurang dari $d.$ Ini menyiratkan bahwa $CE$ proporsional terhadap elemen dalam stabilizer kode kita, yang itulah yang ingin kita tunjukkan. Dengan memilih operasi koreksi kita sebagai representasi berbobot terendah dari kumpulan error yang menghasilkan setiap syndrome, kita dijamin dapat mengoreksi error Pauli apa pun berbobot kurang dari setengah jarak kode.

Namun ada satu masalah. Untuk stabilizer codes secara umum, menghitung operasi Pauli berbobot terendah yang menyebabkan syndrome tertentu adalah masalah yang sulit secara komputasional. (Memang, ini benar bahkan untuk kode klasik, yang dalam konteks ini bisa kita anggap sebagai stabilizer codes di mana hanya matriks $\mathbb{I}$ dan $Z$ yang muncul sebagai faktor tensor dalam stabilizer generators.) Jadi, tidak seperti langkah pengkodean, operasi Clifford tidak akan datang menyelamatkan kita kali ini.

Solusinya adalah memilih kode-kode tertentu yang koreksinya bisa dihitung secara efisien, yang untuk itu tidak ada resep sederhana. Singkatnya, merancang stabilizer codes yang operasi koreksinya bisa dihitung secara efisien adalah bagian dari seni desain kode kuantum. Kita akan melihat seni ini dalam aksi di pelajaran berikutnya.