Mengendalikan propagasi kesalahan

Komputasi kuantum toleran kesalahan ibarat perlombaan antara kesalahan dan koreksi kesalahan. Jika jumlah kesalahan cukup kecil, koreksi kesalahan akan berhasil mengoreksinya; tetapi jika terlalu banyak kesalahan, koreksi kesalahan akan gagal.

Karena alasan ini, perhatian yang cukup harus diberikan pada cara komputasi kuantum dilakukan dalam implementasi toleran kesalahan, untuk mengendalikan propagasi kesalahan. Artinya, kesalahan pada satu qubit berpotensi menyebar ke beberapa qubit melalui aksi gate dalam sirkuit kuantum, yang dapat menyebabkan jumlah kesalahan meningkat secara dramatis. Ini adalah kekhawatiran utama, karena jika kita tidak berhasil mengendalikan propagasi kesalahan, upaya koreksi kesalahan kita akan segera kewalahan oleh kesalahan. Jika, di sisi lain, kita mampu menjaga propagasi kesalahan tetap terkendali, maka koreksi kesalahan punya kesempatan untuk terus bekerja, memungkinkan kesalahan dikoreksi dengan cukup cepat sehingga komputasi kuantum dapat berfungsi sesuai yang dimaksudkan.

Titik awal untuk diskusi teknis masalah ini adalah pengakuan bahwa gate dua-qubit (atau gate multi-qubit lebih umumnya) dapat menyebarkan kesalahan, bahkan saat mereka berfungsi dengan sempurna. Misalnya, pertimbangkan gate controlled-NOT, dan anggap bahwa kesalahan $X$ terjadi pada qubit kontrol tepat sebelum gate controlled-NOT dilakukan. Seperti yang sudah kita amati dalam pelajaran "Mengoreksi kesalahan kuantum", ini setara dengan kesalahan $X$ yang terjadi pada kedua qubit setelah controlled-NOT dilakukan. Dan situasinya serupa untuk kesalahan $Z$ yang bertindak pada target daripada kontrol sebelum gate controlled-NOT dilakukan.

Ini adalah propagasi kesalahan, karena lokasi kesalahan $X$ atau $Z$ yang tidak menguntungkan sebelum gate controlled-NOT secara efektif mengubahnya menjadi dua kesalahan setelah gate controlled-NOT. Ini terjadi bahkan ketika gate controlled-NOT sempurna, dan kita tidak boleh lupa bahwa gate controlled-NOT tertentu mungkin sendiri berisik, yang dapat menciptakan kesalahan yang berkorelasi pada dua qubit.

Menambah kekhawatiran kita adalah kenyataan bahwa gate dua-qubit berikutnya mungkin menyebarkan kesalahan ini lebih jauh, seperti yang disarankan gambar berikut.

Dalam arti tertentu, kita tidak pernah bisa menghindari ini; selama kita menggunakan gate multi-qubit, akan selalu ada potensi propagasi kesalahan. Namun, seperti yang akan kita bahas di subbagian berikut, langkah-langkah dapat diambil untuk membatasi kerusakan yang ditimbulkannya, memungkinkan kesalahan yang menyebar untuk dikelola.

Implementasi gate transversal

Cara paling sederhana yang diketahui untuk mengurangi propagasi kesalahan dalam sirkuit kuantum toleran kesalahan adalah mengimplementasikan gate secara transversal, yang berarti membangun gadget untuk mereka yang memiliki bentuk sederhana tertentu. Secara khusus, gadget harus berupa produk tensor dari operasi (atau dengan kata lain, sirkuit kuantum kedalaman satu), di mana setiap operasi hanya dapat bertindak pada satu posisi qubit dalam setiap blok kode yang disentuhnya. Ini mungkin paling mudah dijelaskan melalui beberapa contoh.

Contoh implementasi gate transversal

Pertimbangkan gambar berikut, yang menyarankan implementasi transversal dari gate CNOT. (Implementasi khusus ini, di mana CNOT dilakukan qubit demi qubit, hanya berfungsi untuk kode CSS — tetapi memang berfungsi untuk semua kode CSS.)

Ada dua blok kode dalam gambar ini, masing-masing digambarkan terdiri dari lima qubit (meskipun bisa lebih, seperti yang telah disarankan). Sirkuit di sebelah kanan memiliki kedalaman satu, dan masing-masing gate CNOT bertindak pada satu posisi qubit dalam setiap blok: baik kontrol maupun target untuk CNOT pertama adalah qubit paling atas (yaitu, qubit 0 menggunakan konvensi penomoran Qiskit), baik kontrol maupun target untuk CNOT kedua adalah qubit kedua dari atas (yaitu, qubit 1), dan seterusnya. Oleh karena itu, ini adalah gadget transversal.

Untuk contoh kedua — sebenarnya sebuah kelas contoh — pertimbangkan gate Pauli manapun. Gate Pauli selalu dapat diimplementasikan secara transversal, untuk kode stabilizer manapun, dengan membangun gadget yang terdiri dari operasi Pauli. Khususnya, setiap operasi Pauli pada qubit logis yang dikodekan oleh kode stabilizer dapat diimplementasikan secara transversal dengan memilih operasi Pauli yang sesuai pada qubit fisik yang digunakan untuk pengkodean. Ini konsisten dengan fakta yang disebutkan sambil lalu dalam pelajaran "Formalisme stabilizer": sampai fase global, operasi Pauli yang komut dengan setiap generator stabilizer dari kode stabilizer bertindak seperti operasi Pauli pada qubit atau qubit-qubit yang dikodekan oleh kode tersebut.

Sebagai contoh spesifik, pertimbangkan kode Shor $9$-qubit, di mana keadaan basis standar dapat dikodekan sebagai berikut.

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[3mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

Gate $X$ pada qubit logis yang dikodekan oleh kode ini dapat diimplementasikan secara transversal oleh operasi Pauli $9$-qubit

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

sementara gate $Z$ pada qubit logis dapat diimplementasikan secara transversal oleh operasi Pauli $9$-qubit

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

Kedua operasi Pauli ini memiliki bobot $3,$ yang merupakan bobot minimum yang diperlukan. (Kode Shor $9$-qubit memiliki jarak $3,$ sehingga setiap operasi Pauli non-identitas berbobot $2$ atau kurang terdeteksi sebagai kesalahan.)

Dan, untuk contoh ketiga, kode Steane $7$-qubit (dan memang setiap kode warna) memungkinkan implementasi transversal dari semua gate Clifford. Kita sudah melihat bagaimana gate CNOT diimplementasikan secara transversal untuk kode CSS apapun, jadi yang tersisa adalah mempertimbangkan gate $H$ dan $S$. Gate Hadamard yang diterapkan pada semua $7$ qubit kode Steane setara dengan $H$ yang diterapkan pada qubit logis yang dikodekannya, sementara gate $S^{\dagger}$ (bukan gate $S$) yang diterapkan pada semua $7$ qubit setara dengan gate logis $S$.

Propagasi kesalahan untuk gadget transversal

Sekarang setelah kita tahu apa itu implementasi transversal dari gate, mari kita bahas hubungannya dengan propagasi kesalahan.

Untuk implementasi transversal gate satu-qubit, kita cukup memiliki produk tensor dari gate satu-qubit dalam gadget kita, yang bertindak pada blok kode qubit fisik untuk kode koreksi kesalahan kuantum yang dipilih. Meskipun salah satu dari gate ini bisa gagal dan memperkenalkan kesalahan, tidak akan ada propagasi kesalahan karena tidak ada gate multi-qubit yang terlibat. Segera setelah gadget diterapkan, koreksi kesalahan dilakukan; dan jika jumlah kesalahan yang diperkenalkan oleh gadget (atau saat gadget sedang dilakukan) cukup kecil, kesalahan akan dikoreksi. Jadi, jika tingkat kesalahan yang diperkenalkan oleh gate yang salah cukup kecil, koreksi kesalahan punya kesempatan besar untuk berhasil.

Untuk implementasi transversal gate dua-qubit, di sisi lain, ada potensi untuk propagasi kesalahan — tidak ada cara untuk menghindari ini, seperti yang sudah kita amati. Poin penting, bagaimanapun, adalah bahwa gadget transversal tidak pernah dapat menyebabkan propagasi kesalahan dalam satu blok kode.

Misalnya, mempertimbangkan implementasi transversal gate CNOT untuk kode CSS yang dijelaskan di atas, kesalahan $X$ bisa terjadi pada qubit atas dari blok kode atas tepat sebelum gadget dilakukan, dan CNOT pertama dalam gadget akan menyebarkan kesalahan tersebut ke qubit atas di blok bawah. Namun, dua kesalahan yang dihasilkan sekarang berada di blok kode yang terpisah. Jadi, dengan asumsi kode kita dapat mengoreksi kesalahan $X$, langkah koreksi kesalahan yang terjadi setelah gadget akan mengoreksi dua kesalahan $X$ secara individual — karena hanya satu kesalahan yang terjadi dalam setiap blok kode. Sebaliknya, jika propagasi kesalahan terjadi di dalam blok kode yang sama, itu bisa mengubah kesalahan berbobot rendah menjadi kesalahan berbobot tinggi yang tidak dapat ditangani oleh kode.

Non-universalitas gate transversal

Untuk dua kode stabilizer yang berbeda, mungkin saja gate tertentu dapat diimplementasikan secara transversal dengan satu kode tetapi tidak dengan yang lain. Misalnya, meskipun tidak mungkin mengimplementasikan gate $T$ secara transversal menggunakan kode Steane $7$-qubit, ada kode lain yang memungkinkan ini.

Sayangnya, tidak pernah mungkin, untuk kode koreksi kesalahan kuantum non-trivial manapun, mengimplementasikan himpunan gate universal secara transversal. Fakta ini dikenal sebagai teorema Eastin-Knill.

Teorema

Teorema Eastin-Knill: Untuk kode koreksi kesalahan kuantum manapun dengan jarak setidaknya 2, himpunan gate logis yang dapat diimplementasikan secara transversal menghasilkan himpunan operasi yang (sampai fase global) bersifat diskret, dan oleh karena itu tidak universal.

Bukti teorema ini tidak akan dijelaskan di sini. (Ini bukan bukti yang rumit, tetapi memerlukan pengetahuan dasar tentang grup Lie dan aljabar Lie, yang bukan termasuk prasyarat seri ini.) Namun, ide dasarnya dapat disampaikan dalam istilah intuitif: Keluarga tak terbatas operasi transversal tidak mungkin tetap berada dalam ruang kode kode non-trivial karena perbedaan kecil dalam operasi transversal dapat didekati dengan baik oleh operasi Pauli berbobot rendah, yang dideteksi oleh kode sebagai kesalahan.

Singkatnya, gadget transversal menawarkan implementasi gate yang sederhana dan secara inheren toleran kesalahan — tetapi untuk pilihan kode koreksi kesalahan kuantum yang wajar manapun, tidak akan pernah ada himpunan gate universal yang dapat diimplementasikan dengan cara ini, yang mengharuskan penggunaan gadget alternatif.

Magic state

Mengingat tidak mungkin, untuk pilihan non-trivial manapun untuk kode koreksi kesalahan kuantum, mengimplementasikan himpunan gate kuantum universal secara transversal, kita harus mempertimbangkan metode lain untuk mengimplementasikan gate secara toleran kesalahan. Satu metode yang terkenal didasarkan pada gagasan magic state, yang merupakan keadaan kuantum qubit yang memungkinkan implementasi toleran kesalahan dari gate tertentu.

Mengimplementasikan gate dengan magic state

Mari kita mulai dengan mempertimbangkan gate $S$ dan $T$, yang memiliki deskripsi matriks sebagai berikut.

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

Menurut definisi, $S$ adalah operasi Clifford, sementara $T$ bukan; tidak mungkin mengimplementasikan gate $T$ dengan sirkuit yang terdiri dari gate Clifford (gate $H$, gate $S$, dan gate CNOT).

Namun, memungkinkan untuk mengimplementasikan gate $T$ (sampai fase global) dengan sirkuit yang terdiri dari gate Clifford jika, sebagai tambahan, kita memiliki salinan keadaan

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

dan kita mengizinkan pengukuran basis standar dan gate yang dikendalikan secara klasik. Khususnya, sirkuit berikut menunjukkan satu cara untuk melakukannya. Fenomena yang ditampilkan di sini adalah contoh yang agak disederhanakan dari teleportasi gate kuantum.

Untuk memeriksa bahwa sirkuit ini bekerja dengan benar, kita pertama-tama dapat menghitung aksi gate CNOT pada input.

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

Pengukuran oleh karena itu memberikan hasil $0$ dan $1$ dengan probabilitas yang sama. Jika hasilnya adalah $0,$ gate $S$ tidak dilakukan, dan keadaan keluaran adalah $T\vert\psi\rangle;$ dan jika hasilnya adalah $1,$ gate $S$ dilakukan, dan keadaan keluaran adalah $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle.$

Keadaan $T\vert {+}\rangle$ disebut magic state dalam konteks ini, meskipun ini bukan satu-satunya: keadaan lain juga disebut magic state ketika dapat digunakan dengan cara serupa (untuk gate yang mungkin berbeda dan menggunakan sirkuit yang berbeda). Misalnya, menukar keadaan $T\vert{+}\rangle$ dengan keadaan $S\vert{+}\rangle$ dan menggantikan gate $S$ dalam sirkuit di atas dengan gate $Z$ mengimplementasikan gate $S$ — yang berpotensi berguna untuk komputasi kuantum toleran kesalahan menggunakan kode di mana gate $S$ tidak dapat diimplementasikan secara transversal.

Gadget toleran kesalahan dari magic state

Mungkin tidak jelas bahwa menggunakan magic state untuk mengimplementasikan gate berguna untuk toleransi kesalahan. Untuk implementasi gate $T$ yang dijelaskan di atas, misalnya, tampaknya kita masih perlu menerapkan gate $T$ ke keadaan $\vert{+}\rangle$ untuk mendapatkan magic state, yang kemudian kita gunakan untuk mengimplementasikan gate $T$. Jadi apa keuntungan menggunakan pendekatan ini untuk toleransi kesalahan?

Berikut adalah tiga poin kunci yang memberikan jawaban atas pertanyaan ini.

1. Pembuatan magic state tidak mengharuskan penerapan gate yang kita coba implementasikan ke keadaan tertentu. Misalnya, menerapkan gate $T$ ke keadaan $\vert {+} \rangle$ bukan satu-satunya cara untuk mendapatkan keadaan $T\vert{+}\rangle$.

2. Pembuatan magic state dapat dilakukan secara terpisah dari komputasi tempat mereka digunakan. Ini berarti kesalahan yang muncul dalam proses pembuatan magic state tidak akan menyebar ke komputasi aktual yang sedang dilakukan.

3. Jika gate individual dalam sirkuit yang mengimplementasikan gate yang dipilih menggunakan magic state dapat diimplementasikan secara toleran kesalahan, dan kita mengasumsikan ketersediaan magic state, kita mendapatkan implementasi toleran kesalahan dari gate yang dipilih.

Untuk menyederhanakan diskusi berikut, mari kita fokus pada gate $T$ secara spesifik — dengan mengingat bahwa metodologi dapat diperluas ke gate lain. Implementasi toleran kesalahan dari gate $T$ menggunakan magic state mengambil bentuk yang disarankan oleh gambar berikut.

Qubit dalam sirkuit gate $T$ asli sesuai dengan qubit logis dalam diagram ini, yang dikodekan oleh kode apapun yang kita gunakan untuk toleransi kesalahan. Input dan output dalam diagram oleh karena itu harus dipahami sebagai pengkodean dari keadaan-keadaan ini. Ini berarti, khususnya, bahwa kita sebenarnya tidak hanya membutuhkan magic state — kita membutuhkan magic state yang dikodekan. Gate dalam sirkuit gate $T$ asli di sini digantikan oleh gadget, yang kita asumsikan toleran kesalahan.

Gambar khusus ini oleh karena itu menyarankan bahwa kita sudah memiliki gadget toleran kesalahan untuk gate CNOT dan gate $S$. Untuk kode warna, gadget ini bisa bersifat transversal; untuk kode permukaan (atau kode CSS lainnya), CNOT dapat dilakukan secara transversal, sementara gadget gate $S$ mungkin sendiri diimplementasikan menggunakan magic state, seperti yang sebelumnya disarankan memungkinkan. (Gambar juga menyarankan bahwa kita memiliki gadget toleran kesalahan untuk melakukan pengukuran basis standar, yang telah kita abaikan sejauh ini. Ini sebenarnya bisa menantang untuk beberapa kode yang dipilih untuk membuatnya demikian, tetapi untuk kode CSS itu adalah masalah mengukur setiap qubit fisik diikuti oleh pemrosesan pasca-klasik.)

Implementasi oleh karena itu toleran kesalahan, dengan asumsi kita memiliki pengkodean dari magic state $T\vert{+}\rangle$. Tapi, kita masih belum mengatasi masalah bagaimana kita mendapatkan pengkodean dari keadaan ini. Satu cara untuk mendapatkan magic state yang dikodekan (atau, mungkin lebih tepatnya, membuatnya lebih baik) adalah melalui proses yang dikenal sebagai distilasi magic state. Diagram berikut menggambarkan seperti apa proses ini pada tingkat tertinggi.

Singkatnya, koleksi magic state yang dikodekan dengan noise dimasukkan ke dalam jenis sirkuit khusus yang dikenal sebagai distiller. Semua kecuali satu blok keluaran diukur — artinya qubit logis diukur dengan pengukuran basis standar. Jika salah satu hasil pengukuran adalah $1,$ proses telah gagal dan harus dimulai kembali. Namun jika setiap hasil pengukuran adalah $0,$ keadaan yang dihasilkan dari blok kode teratas akan menjadi magic state yang dikodekan dengan noise lebih sedikit. Keadaan ini kemudian bisa bergabung dengan empat lagi sebagai input ke distiller lain, atau digunakan untuk mengimplementasikan gate $T$ jika dianggap cukup dekat dengan magic state yang dikodekan dengan benar. Tentu saja, prosesnya harus dimulai dari suatu tempat, dengan satu kemungkinan adalah mempersiapkannya secara non-toleran kesalahan.

Ada berbagai cara yang diketahui untuk membangun distiller itu sendiri, tetapi tidak akan dijelaskan atau dianalisis di sini. Pada tingkat logis, pendekatan yang umum — secara luar biasa dan agak kebetulan — adalah menjalankan sirkuit pengkodean untuk kode stabilizer secara terbalik! Ini sebenarnya bisa berupa kode stabilizer yang berbeda dari yang digunakan untuk koreksi kesalahan. Misalnya, seseorang berpotensi menggunakan kode permukaan atau kode warna untuk koreksi kesalahan, tetapi menjalankan encoder untuk kode $5$-qubit secara terbalik demi distilasi magic state. Sirkuit pengkodean untuk kode stabilizer hanya memerlukan gate Clifford, yang menyederhanakan implementasi toleran kesalahan dari distiller. Pada kenyataannya, spesifikasinya bergantung pada kode yang digunakan.

Singkatnya, bagian ini bertujuan hanya memberikan diskusi sangat tingkat tinggi tentang magic state, dengan maksud hanya memberikan ide dasar tentang cara kerjanya. Kadang-kadang diklaim bahwa overhead untuk menggunakan magic state guna mengimplementasikan gate secara toleran kesalahan seperti ini akan sangat tinggi, dengan sebagian besar pekerjaan masuk ke proses distilasi. Namun, ini sebenarnya tidak begitu jelas — ada banyak cara potensial untuk mengoptimalkan proses ini. Ada juga, pendekatan alternatif untuk membangun gadget toleran kesalahan untuk gate yang tidak dapat diimplementasikan secara transversal. Misalnya, deformasi kode dan pergantian kode adalah kata kunci yang terkait dengan beberapa skema ini — dan cara-cara baru terus dikembangkan dan disempurnakan.

Koreksi kesalahan toleran kesalahan

Selain implementasi berbagai gadget yang diperlukan untuk implementasi toleran kesalahan dari sirkuit kuantum tertentu, ada masalah penting lain yang harus diakui: implementasi langkah koreksi kesalahan itu sendiri. Ini kembali pada gagasan bahwa segala sesuatu yang melibatkan informasi kuantum rentan terhadap kesalahan — termasuk sirkuit yang sendirinya dimaksudkan untuk mengoreksi kesalahan.

Pertimbangkan, misalnya, jenis sirkuit yang dijelaskan dalam pelajaran "Formalisme stabilizer" untuk mengukur generator stabilizer secara non-destruktif menggunakan estimasi fase. Sirkuit-sirkuit ini jelas tidak toleran kesalahan karena dapat menyebabkan kesalahan menyebar di dalam blok kode yang beroperasi di atasnya. Ini mungkin tampak cukup bermasalah, tetapi ada beberapa cara yang diketahui untuk melakukan koreksi kesalahan secara toleran kesalahan dengan cara yang tidak menyebabkan kesalahan menyebar di dalam blok kode yang dikoreksi.

Satu metode dikenal sebagai koreksi kesalahan Shor, karena pertama kali ditemukan oleh Peter Shor. Idenya adalah melakukan pengukuran sindrom menggunakan apa yang disebut cat state, yang merupakan keadaan $n$-qubit berbentuk

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

di mana $0^n$ dan $1^n$ mengacu pada string semua-nol dan semua-satu dengan panjang $n.$ Misalnya, ini adalah keadaan $\vert\phi^+\rangle$ ketika $n=2$ dan keadaan GHZ ketika $n=3,$ tetapi pada umumnya, koreksi kesalahan Shor memerlukan keadaan seperti ini untuk $n$ yang merupakan bobot dari generator stabilizer yang diukur.

Sebagai contoh, sirkuit yang ditunjukkan di sini mengukur generator stabilizer berbentuk $P_2\otimes P_1 \otimes P_0.$

Ini memerlukan konstruksi cat state itu sendiri, dan untuk membuatnya bekerja dengan andal dalam kehadiran kesalahan dan gate yang berpotensi salah, metode ini sebenarnya memerlukan pengulangan sirkuit seperti ini berkali-kali untuk membuat inferensi tentang di mana berbagai kesalahan mungkin terjadi selama proses.

Metode alternatif dikenal sebagai koreksi kesalahan Steane. Metode ini bekerja berbeda, dan hanya berfungsi untuk kode CSS. Idenya adalah bahwa kita sebenarnya tidak melakukan pengukuran sindrom pada keadaan kuantum yang dikodekan dalam sirkuit yang kita coba jalankan, tetapi sebaliknya kita dengan sengaja menyebarkan kesalahan ke sistem workspace, dan kemudian mengukur sistem tersebut dan secara klasik mendeteksi kesalahan. Diagram sirkuit berikut menggambarkan bagaimana ini dapat dilakukan untuk mendeteksi kesalahan $X$ dan $Z$, masing-masing.

Metode terkait yang dikenal sebagai koreksi kesalahan Knill memperluas metode ini ke kode stabilizer arbitrer menggunakan teleportasi.