Kode Shor 9-Qubit

Sekarang kita beralih ke kode Shor 9-Qubit, yang merupakan kode koreksi kesalahan kuantum yang diperoleh dengan menggabungkan dua kode yang dipertimbangkan di bagian sebelumnya: kode repetisi 3-bit untuk Qubit, yang memungkinkan koreksi satu kesalahan bit-flip, dan versi yang dimodifikasi dari kode tersebut, yang memungkinkan koreksi satu kesalahan phase-flip.

Deskripsi kode

Kode Shor 9-Qubit adalah kode yang kita peroleh dengan menggabungkan dua kode dari bagian sebelumnya. Ini berarti kita pertama menerapkan satu encoding, yang meng-encode satu Qubit menjadi tiga, dan kemudian kita menerapkan encoding lainnya ke masing-masing dari tiga Qubit yang digunakan untuk encoding pertama, menghasilkan sembilan Qubit secara total.

Lebih tepatnya, meskipun kita bisa menerapkan dua kode dalam urutan mana pun dalam kasus khusus ini, kita akan memilih untuk pertama menerapkan versi yang dimodifikasi dari kode repetisi 3-bit (yang mendeteksi kesalahan phase-flip), dan kemudian kita meng-encode masing-masing dari tiga Qubit yang dihasilkan secara independen menggunakan kode repetisi 3-bit asli (yang mendeteksi kesalahan bit-flip). Berikut adalah representasi diagram Circuit dari encoding ini.

Seperti yang disarankan oleh gambar, kita akan memikirkan sembilan Qubit dari kode Shor sebagai dikelompokkan menjadi tiga blok tiga Qubit, di mana setiap blok diperoleh dari langkah encoding kedua (yang merupakan kode repetisi 3-bit biasa). Kode repetisi 3-bit biasa, yang di sini diterapkan tiga kali secara independen, disebut kode dalam dalam konteks ini, sedangkan kode luar adalah kode yang digunakan untuk langkah encoding pertama, yaitu versi yang dimodifikasi dari kode repetisi 3-bit yang mendeteksi kesalahan phase-flip.

Kita bisa secara alternatif menentukan kode dengan mendeskripsikan bagaimana dua keadaan basis standar untuk Qubit asli kita di-encode.

$$\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) \\[4mm] \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}$$

Begitu kita mengetahui ini, kita bisa menentukan dengan linieritas bagaimana vektor keadaan Qubit sembarangan di-encode.

Mengoreksi kesalahan bit-flip dan phase-flip

Kesalahan dan gate CNOT

Untuk menganalisis bagaimana kesalahan $X$ dan $Z$ mempengaruhi encoding Qubit, baik untuk kode Shor 9-Qubit maupun kode lainnya, akan berguna untuk mengamati beberapa hubungan sederhana antara kesalahan-kesalahan ini dan gate CNOT. Saat kita mulai menganalisis kode Shor 9-Qubit, ini adalah momen yang tepat untuk berhenti sejenak dan melakukan ini.

Diagram Circuit berikut mengilustrasikan tiga hubungan dasar antara gate $X$ dan gate CNOT. Khususnya, menerapkan gate $X$ ke Qubit target sebelum CNOT setara dengan menukar urutan dan melakukan CNOT terlebih dahulu, tetapi menerapkan gate $X$ ke Qubit kontrol sebelum CNOT setara dengan menerapkan gate $X$ ke kedua Qubit setelah CNOT. Akhirnya, menerapkan gate $X$ ke kedua Qubit sebelum CNOT setara dengan melakukan CNOT terlebih dahulu dan kemudian menerapkan gate $X$ ke Qubit kontrol. Hubungan-hubungan ini bisa diverifikasi dengan melakukan perkalian matriks yang diperlukan atau menghitung efek Circuit pada keadaan basis standar.

Situasinya serupa untuk gate $Z$, kecuali bahwa peran Qubit kontrol dan target bertukar. Khususnya, kita memiliki tiga hubungan yang digambarkan oleh Circuit kuantum berikut.

Mengoreksi kesalahan bit-flip

Sekarang kita akan mempertimbangkan bagaimana kesalahan bisa dideteksi dan dikoreksi menggunakan kode Shor 9-Qubit, dimulai dengan kesalahan bit-flip — yang umumnya akan kita sebut kesalahan $X$ mulai sekarang demi keringkasan.

Untuk mendeteksi dan mengoreksi kesalahan $X$, kita cukup memperlakukan masing-masing dari tiga blok dalam encoding secara terpisah. Setiap blok adalah encoding Qubit menggunakan kode repetisi 3-bit, yang melindungi terhadap kesalahan $X$ — sehingga dengan melakukan pengukuran sindrom dan koreksi kesalahan $X$ yang sudah dijelaskan sebelumnya ke setiap blok, kita bisa mendeteksi dan mengoreksi hingga satu kesalahan $X$ per blok. Khususnya, jika ada paling banyak satu kesalahan $X$ pada sembilan Qubit encoding, kesalahan ini akan dideteksi dan dikoreksi oleh prosedur ini.

Singkatnya, mengoreksi kesalahan bit-flip adalah hal yang sederhana untuk kode ini, karena kode dalam mengoreksi kesalahan bit-flip.

Mengoreksi kesalahan phase-flip

Selanjutnya kita akan mempertimbangkan kesalahan phase-flip, atau kesalahan $Z$ untuk keringkasan. Kali ini tidak begitu jelas apa yang harus kita lakukan karena kode luar adalah yang mendeteksi kesalahan $Z$, tetapi kode dalam tampaknya entah bagaimana "menghalangi", membuat deteksi dan koreksi kesalahan ini sedikit lebih sulit.

Misalkan kesalahan $Z$ terjadi pada salah satu dari 9 Qubit kode Shor, seperti yang ditunjukkan dalam diagram ini.

Kita sudah mengamati apa yang terjadi ketika kesalahan $Z$ terjadi saat kita menggunakan kode repetisi 3-bit — ini setara dengan kesalahan $Z$ yang terjadi sebelum encoding. Dalam konteks kode Shor 9-Qubit, ini berarti bahwa kesalahan $Z$ pada salah satu dari tiga Qubit dalam satu blok selalu memiliki efek yang sama, yang setara dengan kesalahan $Z$ yang terjadi pada Qubit yang bersesuaian sebelum kode dalam diterapkan.

Misalnya, diagram Circuit di atas setara dengan diagram berikut. Ini bisa dibuktikan menggunakan hubungan antara gate $Z$ dan CNOT yang dijelaskan di atas, atau cukup dengan mengevaluasi Circuit pada keadaan Qubit sembarangan $\vert\psi\rangle.$

Ini menyarankan satu pilihan untuk mendeteksi dan mengoreksi kesalahan $Z$, yaitu men-decode kode dalam, meninggalkan kita dengan tiga Qubit yang digunakan untuk encoding luar beserta enam Qubit workspace yang sudah diinisialisasi. Kita kemudian bisa memeriksa tiga Qubit kode luar ini untuk kesalahan $Z$, dan akhirnya kita bisa meng-encode ulang menggunakan kode dalam, untuk membawa kita kembali ke encoding 9-Qubit yang kita dapatkan dari kode Shor. Jika kita mendeteksi kesalahan $Z$, kita bisa mengoreksinya sebelum re-encoding dengan kode dalam, atau kita bisa mengoreksinya setelah re-encoding, dengan menerapkan gate $Z$ ke salah satu Qubit dalam blok tersebut.

Berikut adalah diagram Circuit yang mencakup Circuit encoding dan kesalahan yang disarankan di atas bersama dengan langkah-langkah yang baru saja dijelaskan (tetapi bukan langkah koreksi yang sebenarnya).

Dalam contoh khusus ini, pengukuran sindrom adalah $11,$ yang menempatkan kesalahan $Z$ sebagai telah terjadi pada salah satu Qubit di blok tengah.

Salah satu keuntungan mengoreksi kesalahan $Z$ setelah langkah re-encoding daripada sebelumnya adalah bahwa kita bisa menyederhanakan Circuit di atas. Circuit berikut setara, tetapi membutuhkan empat gate CNOT lebih sedikit.

Sekali lagi, sindrom tidak menunjukkan Qubit mana yang telah terpengaruh oleh kesalahan $Z$, melainkan blok mana yang mengalami kesalahan $Z$, dengan efek yang sama terlepas dari Qubit mana dalam blok yang terpengaruh. Kita kemudian bisa mengoreksi kesalahan dengan menerapkan gate $Z$ ke salah satu dari tiga Qubit dari blok mana pun yang terpengaruh.

Sebagai catatan sampingan, di sini kita melihat contoh degenerasi dalam kode koreksi kesalahan kuantum, di mana kita bisa mengoreksi kesalahan tertentu (kesalahan $Z$ dalam kasus ini) tanpa bisa mengidentifikasinya secara unik.

Kesalahan bit-flip dan phase-flip secara bersamaan

Kita sekarang telah melihat bagaimana kesalahan $X$ dan $Z$ bisa dideteksi dan dikoreksi menggunakan kode Shor 9-Qubit, dan khususnya bagaimana paling banyak satu kesalahan $X$ atau paling banyak satu kesalahan $Z$ bisa dideteksi dan dikoreksi. Sekarang misalkan kesalahan bit-flip dan phase-flip terjadi, mungkin pada Qubit yang sama. Ternyata, tidak ada yang berbeda yang perlu dilakukan dalam situasi ini dari apa yang sudah dibahas — kode ini mampu mendeteksi dan mengoreksi hingga satu kesalahan $X$ dan satu kesalahan $Z$ secara bersamaan, tanpa modifikasi lebih lanjut.

Lebih tepatnya, kesalahan $X$ dideteksi dengan menerapkan pengukuran sindrom kode repetisi 3-bit biasa, yang dilakukan secara terpisah pada masing-masing dari tiga blok tiga Qubit; dan kesalahan $Z$ dideteksi melalui prosedur yang dijelaskan tepat di atas, yang setara dengan mendekode kode dalam, melakukan pengukuran sindrom untuk kode repetisi 3-bit yang dimodifikasi untuk phase-flip, dan kemudian meng-encode ulang. Dua langkah deteksi kesalahan ini — serta koreksi yang bersesuaian — bisa dilakukan sepenuhnya secara independen satu sama lain, dan bahkan tidak masalah urutan mana yang dilakukan.

Untuk memahami mengapa ini terjadi, perhatikan contoh yang digambarkan dalam diagram Circuit berikut, di mana kesalahan $X$ dan $Z$ telah mempengaruhi Qubit terbawah dari blok tengah.

Mari kita pertama-tama amati bahwa urutan kesalahan tidak masalah, dalam arti bahwa membalik posisi kesalahan $X$ dan $Z$ menghasilkan Circuit yang setara. Untuk lebih jelasnya, $X$ dan $Z$ tidak komut, mereka anti-komut:

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

Ini berarti bahwa Circuit berikut setara dengan yang baru saja di atas hingga faktor fase global $-1.$

Kita sekarang bisa memindahkan kesalahan $Z$ seperti sebelumnya untuk mendapatkan Circuit setara lainnya.

Pada titik ini jelas bahwa jika prosedur untuk mendeteksi dan mengoreksi kesalahan $X$ dilakukan terlebih dahulu, kesalahan $X$ akan dikoreksi, setelah itu prosedur untuk mendeteksi dan mengoreksi kesalahan $Z$ bisa dilakukan untuk menghilangkan kesalahan $Z$ seperti sebelumnya.

Atau, prosedur untuk mendeteksi dan mengoreksi kesalahan $Z$ bisa dilakukan terlebih dahulu. Fakta bahwa prosedur ini berfungsi seperti yang diharapkan, bahkan dengan adanya satu atau lebih kesalahan $X$, mengikuti dari fakta bahwa gate $X$ pada salah satu dari sembilan Qubit yang digunakan untuk encoding komut dengan semua gate dalam Circuit yang disederhanakan kita untuk mengukur sindrom untuk kesalahan $Z$. Dengan demikian, pengukuran sindrom ini akan tetap mengidentifikasi dengan benar blok mana yang telah terpengaruh oleh kesalahan $Z$. Fakta bahwa kesalahan $Z$ pada blok mana pun dikoreksi dengan menerapkan gate $Z$ ke Qubit mana pun dari blok tersebut, bahkan jika kesalahan $X$ juga terjadi, mengikuti dari argumen yang sama di atas mengenai urutan gate $X$ dan $Z$ yang memberikan Circuit setara hingga fase global.

Dengan demikian, kode Shor 9-Qubit bisa mengoreksi kesalahan $X$, kesalahan $Z$, atau keduanya, pada salah satu dari sembilan Qubit yang digunakan untuk kode ini. Bahkan, kita bisa mengoreksi lebih banyak kesalahan dari itu, termasuk beberapa kesalahan $X$ (selama berada di blok yang berbeda) atau beberapa kesalahan $Z$ (selama paling banyak satu blok mengalami jumlah ganjil dari mereka) — tetapi ke depannya, yang paling relevan untuk tujuan pelajaran ini adalah bahwa kita bisa mengoreksi kesalahan $X$, kesalahan $Z$, atau keduanya pada satu Qubit mana pun.

Pengurangan kesalahan untuk kesalahan acak

Sebelum kita beralih ke bagian terakhir pelajaran, yang berkaitan dengan kesalahan kuantum sembarangan, mari kita secara singkat mempertimbangkan kinerja kode Shor 9-Qubit ketika kesalahan yang direpresentasikan oleh matriks Pauli terjadi secara acak pada Qubit.

Lebih konkretnya, mari kita pertimbangkan model noise sederhana di mana kesalahan terjadi secara independen pada Qubit, dengan setiap Qubit mengalami kesalahan dengan probabilitas $p$, dan tanpa korelasi antara kesalahan pada Qubit yang berbeda — sejalan dengan channel simetris biner untuk bit klasik. Kita bisa menetapkan probabilitas yang berbeda untuk kesalahan $X,$ $Y,$ dan $Z$ yang terjadi, tetapi untuk menjaga semuanya sesederhana mungkin, kita akan mempertimbangkan skenario terburuk untuk kode Shor 9-Qubit, yaitu bahwa kesalahan $Y$ terjadi pada setiap Qubit yang terpengaruh. Omong-omong, kesalahan $Y$ setara (hingga faktor fase global yang tidak relevan) dengan kesalahan $X$ dan $Z$ yang terjadi pada Qubit yang sama, mengingat bahwa $Y = iXZ.$ Ini menjelaskan pengabaian kesalahan $Y$ yang tampak hingga titik ini.

Sekarang, misalkan $\mathsf{Q}$ adalah Qubit dalam beberapa keadaan tertentu yang ingin kita lindungi dari kesalahan, kita bisa mempertimbangkan pilihan untuk menggunakan kode Shor 9-Qubit. Pertanyaan yang wajar untuk diajukan adalah, "Haruskah kita menggunakannya?"

Jawabannya tidak selalu "ya." Jika terlalu banyak noise, artinya dalam konteks ini bahwa $p$ terlalu besar, menggunakan kode Shor sebenarnya bisa memperburuk keadaan — sama seperti kode repetisi 3-bit lebih buruk daripada tidak ada kode ketika $p$ lebih besar dari setengah. Tetapi, jika $p$ cukup kecil, maka jawabannya adalah "ya," kita harus menggunakan kode, karena akan mengurangi kemungkinan keadaan yang di-encode menjadi rusak. Mari kita lihat mengapa ini terjadi, dan apa artinya $p$ terlalu besar atau cukup kecil untuk kode ini.

Kode Shor mengoreksi kesalahan Pauli mana pun pada satu Qubit, termasuk kesalahan $Y$ tentu saja, tetapi tidak mengoreksi dengan benar dua atau lebih kesalahan $Y$. Untuk lebih jelasnya, kita mengasumsikan bahwa kita menggunakan koreksi kesalahan $X$ dan $Z$ yang dijelaskan sebelumnya dalam bagian. (Tentu saja, jika kita tahu sebelumnya bahwa kita hanya perlu khawatir tentang kesalahan $Y$, kita akan secara alami memilih koreksi yang berbeda — tetapi itu curang terhadap model noise, dan kita selalu bisa mengubah model dengan memilih kesalahan Pauli yang berbeda untuk membuat pilihan koreksi baru ini gagal setiap kali dua atau lebih Qubit terpengaruh oleh kesalahan.)

Jadi, kode melindungi $\mathsf{Q}$ selama paling banyak satu dari sembilan Qubit yang terpengaruh oleh kesalahan, yang terjadi dengan probabilitas

$$(1-p)^9 + 9 p (1-p)^8.$$

Jika tidak, dengan probabilitas

$$1 - (1-p)^9 - 9 p (1-p)^8,$$

kode gagal melindungi $\mathsf{Q}.$

Khususnya, yang dimaksud dalam konteks ini adalah bahwa, hingga fase global, operasi Pauli non-identitas akan diterapkan ke Qubit kita $\mathsf{Q}$ (sebagai Qubit logis). Artinya, jika kesalahan $X$ dan $Z$ dideteksi dan dikoreksi untuk kode Shor seperti yang dijelaskan sebelumnya dalam pelajaran, kita akan dibiarkan dengan encoding keadaan yang setara, hingga fase global, dengan encoding operasi Pauli non-identitas yang diterapkan ke keadaan asli $\mathsf{Q}.$ Cara yang lebih ringkas untuk mengatakan ini adalah bahwa kesalahan logis telah terjadi. Itu mungkin atau tidak berpengaruh pada keadaan asli $\mathsf{Q}$ — atau dengan kata lain Qubit logis yang telah kita encode dengan sembilan Qubit fisik — tetapi, demi analisis ini, kita menganggap peristiwa ini sebagai kegagalan.

Di sisi lain, jika kita tidak repot menggunakan kode, satu-satunya Qubit kita akan mengalami nasib serupa (berupa operasi Pauli non-identitas yang diterapkan) dengan probabilitas $p.$ Kode membantu ketika probabilitas pertama lebih kecil dari yang kedua:

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

Berikut adalah plot yang mengilustrasikan, untuk nilai $p$ yang sangat kecil, bahwa kode memberikan keuntungan, dengan titik impas terjadi pada sekitar $0.0323.$

Jika $p$ lebih kecil dari titik impas ini, maka kode membantu; pada titik impas probabilitasnya sama, sehingga kita hanya membuang-buang waktu beserta 8 Qubit jika kita menggunakan kode; dan melewati titik impas kita sebaiknya sama sekali tidak menggunakan kode ini karena meningkatkan peluang kesalahan logis pada $\mathsf{Q}.$

Tiga dan seperempat persen atau lebih mungkin tidak terlihat seperti titik impas yang sangat bagus, terutama bila dibandingkan dengan $50\%,$ yang merupakan titik impas analogi untuk kode repetisi 3-bit untuk informasi klasik. Perbedaan ini, sebagian besar, karena informasi kuantum lebih rapuh dan lebih sulit dilindungi daripada informasi klasik. Tetapi juga — sambil mengakui bahwa kode Shor 9-Qubit merupakan penemuan brilian, sebagai kode koreksi kesalahan kuantum pertama di dunia — harus diakui bahwa sebenarnya ini bukan kode yang sangat bagus dari segi praktis.