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


15

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?


Nah, pada titik tertentu hanya ada kebisingan. Apakah aneh bahwa ada titik di mana koreksi kesalahan lebih mungkin untuk memperbaiki bagian yang tepat menjadi noise?
Kadal diskrit

1
@ Discretelizard tidak begitu banyak sehingga mungkin ada satu, tetapi ambang biasanya sangat rendah (atau tinggi dalam hal kesetiaan). Kenapa begitu?
glS

Jawaban:


4

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(|ψ,ρ)ρ|ψ|ψρ

F(|ψ,ρ)=ψ|ρ|ψ.

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 NNNiEEj

ρ=N(|ψψ|)=iNi|ψψ|Ni
ρ=EN(|ψψ|)=i,jEjNi|ψψ|NiEj.

Kesetiaan ini diberikan oleh

F(|ψ,ρ)=ψ|ρ|ψ=i,jψ|EjNi|ψψ|NiEj|ψ=i,jψ|EjNi|ψψ|EjNi|ψ=i,j|ψ|EjNi|ψ|2.

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(|ψ,ρ)>F(|ψ,ρ).
Karena kesetiaan adalah positif, ini dapat ditulis ulang sebagaii,j| Ψ| EjNi| ψ| 2>i| Ψ| Ni| ψ| 2.
i,j|ψ|EjNi|ψ|2>i|ψ|Ni|ψ|2.
i,j|ψ|EjNi|ψ|2>i|ψ|Ni|ψ|2.

Memisahkan ke bagian diperbaiki, N c , yang EN c ( | ψ ψ | ) = | ψ ψ | dan bagian non-diperbaiki, N n c , yang EN n c ( | ψ ψ | ) = σ . Denoting probabilitas kesalahan diperbaiki dengan P cNNcENc(|ψψ|)=|ψψ|NncENnc(|ψψ|)=σPcdan 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 ψ | σ | ψ = 0Pnc

i,j|ψ|EjNi|ψ|2=Pc+Pncψ|σ|ψPc,
ψ|σ|ψ=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 cnpnktnk4t.

Pc=jt(nj)pj(1p)nj=(1p)n+np(1p)n1+12n(n1)p2(1p)n2+O(p3)=1(nt+1)pt+1+O(pt+2)

Ni=jαi,jPjPj χj,k=iαi,jαi,k

i|ψ|Ni|ψ|2=j,kχj,kψ|Pj|ψψ|Pk|ψχ0,,0,
χ0,0=(1p)n kesalahan terjadi.

1(nt+1)pt+1(1p)n.
ρ1ppt+1p kecil.

ppt+1pn=5t=1p0.29

Edit dari komentar:

Pc+Pnc=1

i,j|ψ|EjNi|ψ|2=ψ|σ|ψ+Pc(1ψ|σ|ψ).

1(1ψ|σ|ψ)(nt+1)pt+1(1p)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.


Saya pikir Anda mencoba menjelaskan hingga tingkat kesalahan fisik mana kemungkinan kesalahan yang tidak dapat diperbaiki itu rendah? Perhatikan bahwa ambang toleransi kesalahan lebih kecil (urutan besarnya untuk banyak kode)
M. Stern

@ M.Stern Jadi ini adalah perkiraan (sangat kasar) untuk ketika koreksi kesalahan 'mengurangi kesalahan' (yaitu meningkatkan kesetiaan dengan jumlah setelah kebisingan diterapkan), jadi itu jelas bukan ambang toleransi kesalahan, tidak. Melakukan koreksi kesalahan mungkin telah meningkatkan kesetiaan setelah kebisingan dengan jumlah tertentu, tetapi ia tidak menyetel ulangnya atau apa pun, sehingga kesetiaan hanya akan berkurang (dan kesalahan akan menyebar) bahkan jika koreksi kesalahan terus diterapkan, menunjukkan koreksi kesalahan dengan sendirinya tidak cukup untuk toleransi kesalahan
Mithrandir24601

Hm, glS harus menilai apakah itu menjawab pertanyaan. Bagaimanapun itu menarik dan ditulis dengan baik. Jadi Anda berasumsi bahwa negara adalah orthogonal jika kesalahan tidak dapat diperbaiki, kan? (Itu tentu masuk akal dalam banyak skenario.) Ekstrem lainnya adalah ketika ada kemungkinan 50/50 kesalahan logis jika terjadi kesalahan yang tidak dapat diperbaiki.
M. Stern

@ M.Stern Terima kasih! Ya, negara itu ortogonal, atau mengambil batas bawah. Karena membandingkan satu batas bawah dengan yang lain bukanlah ide yang bagus, saya pergi dengan asumsi bahwa mereka ortogonal. Jika ada pengeditan yang Anda rasa akan berguna untuk ditambahkan di akhir ini, selesaikan! Hmm ... Saya pikir mengambil peluang 50/50 kesalahan logis akan menghasilkan hasil yang sama, hanya dengan prefaktor yang berbeda di akhir
Mithrandir24601

4

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).


4

Versi Klasik

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

000000111111
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,hal, 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 hal>12, 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 01010string 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 |ψ seberang Nqubit fisik. Tidak masalah apa kode itu, ini adalah argumen yang sepenuhnya umum. Sekarang bayangkan ada begitu banyak suara yang menghancurkan keadaan kuantumN/2qubits ("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 menggunakannyaN/2qubit dan berikan sisa qubit kepada Anda. Kami masing-masing memperkenalkan cukup qubit kosong sehingga kami dapatNqubit total, dan kami menjalankan koreksi kesalahan pada mereka. cloning demonstration Jika mungkin untuk melakukan koreksi kesalahan itu, hasilnya adalah kita berdua akan memiliki keadaan semula|ψ. Kami akan mengkloning qubit logis! Tetapi kloning tidak mungkin, jadi koreksi kesalahan pasti tidak mungkin.


2

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 adalahf(hal)=hal untuk perbandingan):

plot physical vs logical error rate

Jadi setiap kali tingkat kesalahan fisik hal di bawah 1/2, tingkat kesalahan logis lebih kecil dari hal. Namun perhatikan, itu sangat efektif untuk kecilhal, karena kode mengubah nilai dari HAI(hal) ke a HAI(hal2) 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 .


Paragraf kedua menyentuh poin yang tepat, tetapi masih sangat kualitatif. Anda mengatakan bahwa Anda memerlukan gerbang yang diperkenalkan oleh protokol koreksi kesalahan untuk mengurangi tingkat kesalahan lebih dari yang mereka tingkatkan. Namun, bagaimana orang beralih dari gagasan intuitif ini ke perkiraan kuantitatif aktual di atas ambang batas? Juga, apakah ini menyiratkan ambang batas bawah universal yang tidak dapat dikalahkan oleh protokol koreksi kesalahan?
glS

@ GLS Saya menduga bahwa ada "ambang universal yang lebih rendah", yaitu nilai kesalahan di atas yang tidak ada protokol koreksi toleransi kesalahan. Namun, nilainya harus tergantung pada set gerbang Anda dan model kesalahan Anda. Orang-orang cenderung lebih tertarik pada hasil positif di sini (menunjukkan adanya protokol toleran kesalahan yang baik). Mungkin menarik untuk menemukan batas atas untuk melihat "seberapa banyak ruang yang tersisa" dalam membuat skema toleransi kesalahan kita lebih baik. Saya kira tidak banyak ruang yang tersisa.
Jalex Stark

@ GLS Anda benar, beberapa perhitungan kuantitatif aktual akan meningkatkan jawaban ini. Saya pikir perhitungan ini biasanya dilakukan secara numerik? Tetapi saya juga ingin tahu tentang ini
M. Stern

@JalexStark Apa yang membuat Anda berpikir tidak ada banyak ruang tersisa? Misalnya kode permukaan tampaknya tidak dioptimalkan menggunakan ambang ini. Ini hanya menggunakan interaksi tetangga terdekat pada kisi dan Anda bisa melakukan lebih banyak hal secara umum.
M. Stern

@M.Stern I don't have any theorem-based evidence, and I'm not an expert in the area. I was just guessing based on the amount of work done and on how large the best thresholds are.
Jalex Stark

2

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 ϵ propagates not as Nϵ after N single qubit gates but as N2ϵ. 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+ϵX which you might call an error of ϵ because that is the probability corresponding to the probability amplitude ϵ 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 GN+NϵGNX (if G and X commute, otherwise a more complicated construct that has N distinct terms proportional to ϵ). Hence you would, if measuring then, find an error probability of N2ϵ.

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!


thanks for the answer, but I would appreciate if you could expand the answer to say more about some of the points here. In particular, 1) what do you mean exactly by saying that you need many gates in the error correcting code because there are "many errors to detect"? 2) What do you mean with "straight-forward logical construct"? 3) Why do "coherent errors" imply an error propagation scaling like N2ϵ instead of Nϵ?
glS

@glS I have substantially expanded the answer to address all your questions. Did I manage to do that?
pyramids
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.