Mengapa protokol koreksi kesalahan hanya berfungsi ketika tingkat kesalahan sudah sangat rendah untuk memulai?

Koreksi kesalahan kuantum adalah aspek fundamental dari perhitungan kuantum, yang tanpanya komputasi kuantum skala besar praktis tidak mungkin dilakukan.

Salah satu aspek komputasi kuantum toleran-kesalahan yang sering disebutkan adalah bahwa setiap protokol koreksi kesalahan telah mengaitkan ambang batas tingkat kesalahan . Pada dasarnya, untuk perhitungan yang diberikan dapat dilindungi terhadap kesalahan melalui protokol yang diberikan, tingkat kesalahan gerbang harus di bawah ambang batas tertentu.

Dengan kata lain, jika tingkat kesalahan gerbang tunggal tidak cukup rendah, maka tidak mungkin untuk menerapkan protokol koreksi kesalahan untuk membuat perhitungan lebih dapat diandalkan.

Kenapa ini? Mengapa tidak mungkin untuk mengurangi tingkat kesalahan yang belum terlalu rendah untuk memulai?

Kami ingin membandingkan keadaan output dengan beberapa negara ideal, jadi biasanya, kesetiaan, digunakan karena ini adalah cara yang baik untuk memberitahu seberapa baik hasil pengukuran kemungkinan ρ dibandingkan dengan hasil pengukuran yang mungkin dari | ψ ⟩ , di mana | ψ ⟩ adalah kondisi keluaran ideal dan ρ adalah dicapai (berpotensi mixed) negara setelah beberapa proses kebisingan. Seperti kita membandingkan negara, ini adalah F ( | ψ ⟩ , ρ ) = $F\left(\left|\psi\right>, \rho\right)$$\rho$$\left|\psi\right>$$\left|\psi\right>$$\rho$

$$F\left(\left|\psi\right>, \rho\right) = \sqrt{\left<\psi\right|\rho\left|\psi\right>}.$$

Menggambarkan baik kebisingan dan kesalahan proses koreksi menggunakan operator Kraus, di mana adalah saluran kebisingan dengan operator Kraus N i dan E adalah saluran koreksi kesalahan dengan Kraus operator E j , negara setelah kebisingan ρ ' = N ( | ψ ⟩ ⟨ ψ | ) = ∑ i N i | ψ ⟩ ⟨ ψ | N † i dan status setelah koreksi noise dan error adalah ρ = E $\mathcal N$$N_i$$\mathcal E$$E_j$

$$\rho' = \mathcal N\left(\left|\psi\rangle\langle\psi\right|\right) = \sum_iN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger$$ $$\rho = \mathcal E\circ\mathcal N\left(\left|\psi\rangle\langle\psi\right|\right) = \sum_{i, j}E_jN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger E_j^\dagger.$$

Kesetiaan ini diberikan oleh

$$\begin{align}F\left(\left|\psi\right>, \rho\right) &= \sqrt{\left<\psi\right|\rho\left|\psi\right>} \\ &= \sqrt{\sum_{i, j}\left<\psi\right|E_jN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger E_j^\dagger\left|\psi\right>} \\&= \sqrt{\sum_{i, j}\left<\psi\right|E_jN_i\left|\psi\rangle\langle\psi\right|E_jN_i\left|\psi\right>^*} \\ &= \sqrt{\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2}.\end{align}$$

Untuk protokol koreksi kesalahan dapat digunakan, kami ingin kesetiaan setelah koreksi kesalahan lebih besar dari kesetiaan setelah noise, tetapi sebelum koreksi kesalahan, sehingga keadaan koreksi kesalahan kurang dapat dibedakan dari keadaan tidak diperbaiki. Artinya, kita ingin Ini memberi

$$F\left(\left|\psi\right>, \rho\right) > F\left(\left|\psi\right>, \rho'\right).$$ Karena kesetiaan adalah positif, ini dapat ditulis ulang sebagai∑i,j| ⟨Ψ| EjNi| ψ⟩| 2>∑i| ⟨Ψ| Ni| ψ⟩| 2 $$\sqrt{\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2} > \sqrt{\sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2}.$$ $$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 > \sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2.$$

Memisahkan ke bagian diperbaiki, N c , yang E ∘ N c ( | ψ ⟩ ⟨ ψ | ) = | ψ ⟩ ⟨ ψ | dan bagian non-diperbaiki, N n c , yang E ∘ N n c ( | ψ ⟩ ⟨ ψ | ) = σ . Denoting probabilitas kesalahan diperbaiki dengan P$\mathcal N$$\mathcal N_c$$\mathcal E\circ\mathcal N_c\left(\left|\psi\rangle\langle\psi\right|\right) = \left|\psi\rangle\langle\psi\right|$$\mathcal N_{nc}$$\mathcal E\circ\mathcal N_{nc}\left(\left|\psi\rangle\langle\psi\right|\right) = \sigma$$\mathbb P_c$dan non-diperbaiki (yaitu terlalu banyak kesalahan telah terjadi untuk merekonstruksi negara ideal) sebagai memberi Σ i , j | ⟨ Ψ | E j N i | ψ ⟩ | 2 = P c + P n c ⟨ ψ | σ | ψ ⟩ ≥ P c , di mana kesetaraan akan ditanggung oleh asumsi ⟨ ψ | σ | ψ ⟩ = $\mathbb P_{nc}$

$$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 = \mathbb P_c + \mathbb P_{nc}\left<\psi\vert\sigma\vert\psi\right> \geq \mathbb P_c,$$ $\left<\psi\vert\sigma\vert\psi\right> = 0$. Itu adalah 'koreksi' palsu yang akan diproyeksikan ke hasil ortogonal ke hasil yang benar.

Untuk qubit, dengan probabilitas kesalahan (sama) pada setiap qubit sebagai p ( catatan : ini tidak sama dengan parameter noise, yang harus digunakan untuk menghitung probabilitas kesalahan), probabilitas memiliki kesalahan yang dapat diperbaiki (dengan asumsi bahwa n qubit telah digunakan untuk menyandikan k qubit, memungkinkan untuk kesalahan hingga t qubit, ditentukan oleh Singleton terikat n - k ≥ 4 t ) adalah P$n$$p$$n$$k$$t$$n-k\geq 4t$.

$$\begin{align} \mathbb P_c &=\sum_j^t {n\choose j}p^j\left(1-p\right)^{n-j}\\ &= \left(1-p\right)^n + np\left(1-p\right)^{n-1} + \frac 12n\left(n-1\right)p^2\left(1-p\right)^{n-2} + \mathcal O\left(p^3\right) \\ &= 1 - {n\choose{t+1}}p^{t+1} + \mathcal O\left(p^{t + 2}\right)\end{align}$$

$N_i = \sum_j\alpha_{i, j}P_j$$P_j$ $\chi_{j, k} = \sum_i\alpha_{i, j}\alpha^*_{i, k}$

$$\sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2 = \sum_{j, k}\chi_{j, k}\left<\psi\right|P_j\left|\psi\right\rangle\left<\psi\right|P_k\left|\psi\right\rangle\geq\chi_{0, ,0},$$ $\chi_{0, 0} = \left(1-p\right)^n$ kesalahan terjadi.

$$1 - {n\choose{t+1}}p^{t+1} \gtrapprox\left(1-p\right)^n.$$ $\rho \ll 1$$p$$p^{t+1}$$p$ kecil.

$p$$p^{t+1}$$p$$n=5$$t=1$$p\approx 0.29$

Edit dari komentar:

$\mathbb P_c + \mathbb P_{nc} = 1$

$$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 = \left<\psi\vert\sigma\vert\psi\right> + \mathbb P_c\left(1-\left<\psi\vert\sigma\vert\psi\right>\right).$$

$$1-\left(1-\left<\psi\vert\sigma\vert\psi\right>\right){n\choose{t+1}}p^{t+1} \gtrapprox\left(1-p\right)^n,$$ yang merupakan perilaku yang sama seperti sebelumnya, hanya dengan konstanta yang berbeda.

$1$

Ini menunjukkan, untuk perkiraan kasar, bahwa koreksi kesalahan, atau hanya mengurangi tingkat kesalahan, tidak cukup untuk perhitungan toleransi kesalahan , kecuali kesalahan sangat rendah, tergantung pada kedalaman rangkaian.

Sudah ada jawaban matematis yang baik, jadi saya akan mencoba dan memberikan jawaban yang mudah dimengerti.

Koreksi kesalahan kuantum (QEC) adalah (kelompok) algoritma yang agak rumit, yang membutuhkan banyak tindakan (gerbang) di dan di antara qubit. Di QEC, Anda cukup menghubungkan dua qubit ke helper-qubit (ancilla) ketiga dan mentransfer informasi jika dua lainnya sama (dalam beberapa hal tertentu) ke dalam qubit ketiga itu. Kemudian Anda membaca informasi itu dari ancialla. Jika itu memberi tahu Anda, bahwa mereka tidak sama, Anda bertindak berdasarkan informasi itu (menerapkan koreksi). Jadi bagaimana itu bisa salah jika qubit dan gerbang kita tidak sempurna?

QEC dapat membuat informasi yang disimpan dalam peluruhan qubit Anda. Setiap gerbang ini dapat meluruhkan informasi yang tersimpan di dalamnya, jika tidak dieksekusi dengan sempurna. Jadi jika hanya menjalankan QEC menghancurkan informasi lebih banyak daripada yang dipulihkan secara rata-rata, itu tidak berguna.

Anda pikir Anda menemukan kesalahan, tetapi ternyata tidak.Jika perbandingan (eksekusi gerbang) atau pembacaan informasi (ancilla) tidak sempurna, Anda mungkin mendapatkan informasi yang salah dan dengan demikian menerapkan "koreksi yang salah" (baca: memperkenalkan kesalahan). Juga jika informasi dalam ancillas meluruh (atau diubah oleh noise) sebelum Anda bisa membacanya, Anda juga akan mendapatkan pembacaan yang salah.

Tujuan dari setiap QEC jelas untuk memperkenalkan lebih sedikit kesalahan daripada yang dikoreksi, jadi Anda perlu meminimalkan efek yang disebutkan di atas. Jika Anda melakukan semua perhitungan, Anda menemukan persyaratan yang sangat ketat pada qubit, gerbang, dan pembacaan Anda (tergantung pada algoritma QEC yang Anda pilih).

Versi Klasik

Pikirkan tentang strategi sederhana koreksi kesalahan klasik. Anda punya satu bit yang ingin Anda encode,

$$0\mapsto 00000\qquad 1\mapsto 11111$$ Saya telah memilih untuk menyandikannya menjadi 5 bit, tetapi angka ganjil mana pun akan melakukannya (semakin banyak semakin baik). Sekarang, mari kita asumsikan beberapa kesalahan bit-flip telah terjadi, jadi apa yang kita miliki adalah $$01010.$$ Apakah ini awalnya 0 atau 1 yang disandikan? Jika kita mengasumsikan bahwa probabilitas kesalahan per bit,$p$, kurang dari setengah, maka kami berharap bahwa kurang dari setengah bit memiliki kesalahan. Jadi, kita melihat jumlah 0s dan jumlah 1s. Mana pun yang lebih dari yang kita asumsikan adalah yang kita mulai. Ini disebut suara terbanyak. Ada beberapa kemungkinan bahwa kita salah, tetapi semakin banyak bit yang kita kodekan, semakin kecil probabilitas ini.

Di sisi lain, kalau kita tahu itu $p>\frac12$, kita masih bisa melakukan koreksi. Anda baru saja menerapkan suara minoritas! Intinya, Anda harus melakukan operasi yang sepenuhnya berlawanan. Ada batas yang tajam di sini yang menunjukkan, paling tidak, bahwa Anda perlu tahu di mana Anda bekerja.

Untuk toleransi kesalahan, hal-hal menjadi berantakan: the $01010$string yang Anda dapatkan mungkin bukan keadaan sebenarnya . Mungkin ada sesuatu yang berbeda, masih dengan beberapa kesalahan yang harus Anda koreksi, tetapi pengukuran yang Anda lakukan dalam membaca bit juga sedikit salah. Secara kasar, Anda mungkin membayangkan ini mengubah transisi tajam menjadi wilayah ambigu di mana Anda tidak benar-benar tahu harus berbuat apa. Namun, jika probabilitas kesalahan cukup rendah, atau cukup tinggi, Anda dapat memperbaikinya, Anda hanya perlu tahu mana masalahnya.

Versi Kuantum

Secara umum, segalanya menjadi lebih buruk dalam rezim kuantum karena Anda harus berurusan dengan dua jenis kesalahan: kesalahan flip bit ($X$) dan kesalahan flip fase ($Z$), dan itu cenderung membuat wilayah ambigu lebih besar. Saya tidak akan membahas lebih jauh di sini. Namun, ada argumen lucu dalam rezim kuantum yang mungkin mencerahkan.

Bayangkan Anda memiliki status qubit logis tunggal yang disimpan dalam kode koreksi kesalahan kuantum $|\psi\rangle$ seberang $N$qubit fisik. Tidak masalah apa kode itu, ini adalah argumen yang sepenuhnya umum. Sekarang bayangkan ada begitu banyak suara yang menghancurkan keadaan kuantum$\lceil N/2\rceil$qubits ("noise begitu banyak" sebenarnya berarti bahwa kesalahan terjadi dengan probabilitas 50:50, tidak mendekati 100% yang, seperti telah kami katakan, dapat diperbaiki). Tidak mungkin untuk memperbaiki kesalahan itu. Bagaimana saya tahu itu? Bayangkan saya memiliki versi yang benar-benar tanpa suara, dan saya tetap menggunakannya$\lfloor N/2\rfloor$qubit dan berikan sisa qubit kepada Anda. Kami masing-masing memperkenalkan cukup qubit kosong sehingga kami dapat$N$qubit total, dan kami menjalankan koreksi kesalahan pada mereka. Jika mungkin untuk melakukan koreksi kesalahan itu, hasilnya adalah kita berdua akan memiliki keadaan semula$|\psi\rangle$. Kami akan mengkloning qubit logis! Tetapi kloning tidak mungkin, jadi koreksi kesalahan pasti tidak mungkin.

Bagi saya sepertinya ada dua bagian dari pertanyaan ini (satu lagi terkait dengan judul, satu lagi terkait dengan pertanyaan itu sendiri):

1) Ke tingkat kebisingan manakah kode koreksi kesalahan efektif?
2) Dengan jumlah ketidaksempurnaan di gerbang mana kita dapat menerapkan perhitungan kuantum toleran-kesalahan?

Biarkan saya menekankan perbedaan: kode koreksi kesalahan kuantum dapat digunakan dalam banyak skenario yang berbeda, misalnya untuk memperbaiki kehilangan transmisi. Di sini jumlah kebisingan sebagian besar tergantung pada panjang serat optik dan bukan pada ketidaksempurnaan gerbang. Namun jika kita ingin menerapkan perhitungan kuantum toleran-kesalahan, gerbang adalah sumber utama kebisingan.

Pada 1)

Koreksi kesalahan berfungsi untuk tingkat kesalahan besar (lebih kecil dari $1/2$). Ambil contoh kode pengulangan 3 qubit yang sederhana. Tingkat kesalahan logis hanyalah probabilitas untuk suara mayoritas menjadi salah (garis oranye adalah$f(p)=p$ untuk perbandingan):

Jadi setiap kali tingkat kesalahan fisik $p$ di bawah $1/2$, tingkat kesalahan logis lebih kecil dari $p$. Namun perhatikan, itu sangat efektif untuk kecil$p$, karena kode mengubah nilai dari $\mathcal{O}(p)$ ke a $\mathcal{O}(p^2)$ tingkah laku.

Pada 2)

Kami ingin meningkatkan perhitungan kuantum yang sewenang-wenang dengan komputer kuantum. Namun, gerbang kuantum tidak sempurna. Untuk mengatasi kesalahan yang diperkenalkan oleh gerbang, kami menggunakan kode koreksi kesalahan kuantum. Ini berarti bahwa satu qubit logis dikodekan ke dalam banyak qubit fisik. Redundansi ini memungkinkan untuk memperbaiki sejumlah kesalahan pada qubit fisik, sehingga informasi yang disimpan dalam qubit logis tetap utuh. Kode yang lebih besar memungkinkan perhitungan yang lebih lama tetap akurat . Namun, kode yang lebih besar melibatkan lebih banyak gerbang (misalnya pengukuran sindrom lebih banyak) dan gerbang ini menimbulkan kebisingan. Anda lihat ada beberapa pertukaran di sini, dan kode mana yang optimal tidak jelas.
Jika kebisingan yang diperkenalkan oleh masing-masing gerbang berada di bawah ambang tertentu (ambang toleransi kesalahan atau ambang batas akurasi), maka dimungkinkan untuk meningkatkan ukuran kode untuk memungkinkan perhitungan panjang yang sewenang-wenang. Ambang ini tergantung pada kode yang kita mulai (biasanya iteratif digabung dengan dirinya sendiri). Ada beberapa cara untuk memperkirakan nilai ini. Seringkali ini dilakukan dengan simulasi numerik: Memperkenalkan kesalahan acak dan memeriksa apakah perhitungan masih berfungsi. Metode ini biasanya memberikan nilai ambang batas yang terlalu tinggi. Ada juga beberapa bukti analitis dalam literatur, misalnya yang satu ini oleh Aliferis dan Cross .

You need a surprisingly large number of quantum gates to implement a quantum error correcting code in a fault-tolerant manner. One part of the reason is that there are many errors to detect since a code that can correct all single qubit errors already requires 5 qubits and each error can be of three kinds (corresponding to unintentional X, Y, Z gates). Hence to even just correct any single qubit error, you already need logic to distinguish between these 15 errors plus the no-error situation: $XIIII$, $YIIII$, $ZIIII$, $IXIII$, $IYIII$, $IZIII$, $IIXII$, $IIYII$, $IIZII$, $IIIXI$, $IIIYI$, $IIIZI$, $IIIIX$, $IIIIY$, $IIIIZ$, $IIIII$ where $X$, $Y$, $Z$ are the possible single qubit errors and $I$ (identity) denotes the no-error-for-this-qubit situation.

The main part of the reason is, however, that you cannot use straight-forward error detection circuitry: Every CNOT (or every other nontrivial 2 or more qubit gate) forwards errors in one qubit to another qubit which would be disastrous for the most trivial case of a single qubit error correcting code and still very bad for more sophisticated codes. Hence a fault-tolerant (useful) implementation of needs even more effort than one might naively think.

With many gates per error correcting step, you can only permit a very low error rate per step. Here yet another problem arises: Since you may have coherent errors, you must be ready for the worst case that an error $\epsilon$ propagates not as $N \epsilon$ after N single qubit gates but as $N^2 \epsilon$. This value must remain sufficiently low such that you overall gain after correcting some (but not all) errors, for example single qubit errors only.

An example for a coherent error is an implementation of a gate $G$ that does, to first order, not simply $G$ but $G + \sqrt{\epsilon} X$ which you might call an error of $\epsilon$ because that is the probability corresponding to the probability amplitude $\sqrt{\epsilon}$ and hence the probability that a measurement directly after the gate reveals that it acted as the error $X$. After $N$ applications of this gate, again to first order, you have actually applied $G^N + N \sqrt{\epsilon} G^N X$ (if G and X commute, otherwise a more complicated construct that has $N$ distinct terms proportional to $\sqrt{\epsilon}$). Hence you would, if measuring then, find an error probability of $N^2 \epsilon$.

Incoherent errors are more benign. Yet if one must give a single value as an error threshold, then one cannot choose to only assume benign errors!