Hata düzeltme protokolleri neden yalnızca hata oranları başlangıçta önemli ölçüde düşük olduğunda çalışır?

Kuantum hata düzeltmesi , büyük ölçekli kuantum hesaplamaların pratikte mümkün olmadığı kuantum hesaplamanın temel bir yönüdür.

Hataya dayanıklı kuantum hesaplamanın sıklıkla bahsedilen bir yönü, her hata düzeltme protokolünün bir hata oranı eşiğine sahip olmasıdır . Temel olarak, belirli bir hesaplamanın belirli bir protokol aracılığıyla hatalara karşı korunabilmesi için, kapıların hata oranı belirli bir eşiğin altında olmalıdır.

Başka bir deyişle, tek kapıların hata oranları yeterince düşük değilse, hesaplamayı daha güvenilir hale getirmek için hata düzeltme protokolleri uygulamak mümkün değildir.

Bu neden? Başlangıçta çok düşük olmayan hata oranlarını azaltmak neden mümkün değildir?

Biz, bu yüzden normalde, bazı İdeal devlet ile sadakat bir çıkış durumunu karşılaştırmak istediğiniz, bu olarak kullanılan olası ölçüm sonuçları ne kadar iyi anlatmak için iyi bir yoldur p'ye olası ölçüm sonuçları ile karşılaştırmak | ψ ⟩ , nerede | ψ ⟩ doğru çıkış durumu ve ρ noise işleminden sonra elde edilen (potansiyel olarak karışık) durumudur. Biz durumlarını karşılaştırarak konum itibariyle, bu 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>}.$$

Kraus operatörleri kullanarak gürültü ve hata düzeltme işlemleri ile iki tanımlama Kraus operatörleri ile gürültü kanalıdır , N ı ve e Kraus operatörleri ile hata düzeltme kanalı e j , gürültü sonra durumudur ρ ' = N ( | ψ ⟩ ⟨ ψ | ) = ∑ i N i | ψ ⟩ ⟨ ψ | N † i ve hem gürültü hem de hata düzeltmesinden sonraki durum ρ = 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.$$

Bunun sadakat tarafından verilen

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

Hata düzeltme protokolünün herhangi bir kullanımda olması için, hata düzeltmesinden sonra sadakatin gürültüden sonra sadakatten daha büyük olmasını, ancak hata düzeltmesinden önce hata düzeltilmiş durumun düzeltilmemiş durumdan daha az ayırt edilebilir olmasını istiyoruz. İstediğimiz olduğu Bu

$$F\left(\left|\psi\right>, \rho\right) > F\left(\left|\psi\right>, \rho'\right).$$ Sadakat olumlu olduğu için, bu∑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.$$

Yarma düzeltilebilir kısmı içine N c için E ∘ K C ( | ψ ⟩ ⟨ ψ | ) = | ψ ⟩ ⟨ ψ | ve non-düzeltilebilir kısmı, N , N c için E ∘ K , n C ( | ψ ⟩ ⟨ ψ | ) = σ . Hatanın P c olarak düzeltilebilir olma olasılığını belirtmek$\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$ve non-düzeltilebilen olarak (yani çok fazla hata ideal duruma yeniden meydana gelmiş) verir Σ i , j | ⟨ Ψ | E j N i | ψ ⟩ | 2 = p c + P , n C ⟨ ψ | σ | ψ ⟩ ≥ P c , eşitlik varsayarak kabul edilecektir ⟨ ψ | σ | ψ ⟩ = $\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$. Bu yanlış bir 'düzeltme' doğru olana dik bir sonuca yansır.

İçin her QuBit hatanın bir (eşit) olasılıkla qubits, s ( Not : bu olup sahip olan bir olasılık, bir hata olasılığının hesaplanması için kullanılacak gerekir gürültü parametresi ile aynı) düzeltilebilir hata ( n qubit'in k qubit kodlamak için kullanıldığını varsayarsak , Singleton bağlı n - k ≥ 4 t ile belirlenen t qubite kadar hataya izin verir ) 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$

Bu, hata düzeltmesinin ) durumunda gürültüyü azaltmada (en azından bazılarında) başarılı olduğunu verir.

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

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

Yorumlardan düzenleyin:

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

$1$

Bu, kabaca bir yaklaşımla, hata derinliğinin bağlı olduğu ölçüde hatalar çok düşük olmadığı sürece , hata düzeltmenin veya sadece hata oranlarının azaltılmasının hataya dayanıklı hesaplama için yeterli olmadığını gösterir.

Zaten iyi bir matematiksel cevap var, bu yüzden anlaşılması kolay bir cevap vermeye çalışacağım.

Kuantum hata düzeltmesi (QEC), kübitler üzerinde ve arasında çok sayıda eylem (kapı) gerektiren oldukça karmaşık bir algoritmadır. QEC'de, iki kübiti bir üçüncü yardımcı kubite (ancilla) bağlarsınız ve diğer ikisi eşitse (bazı açılardan) bu üçüncü kubite aktarırsınız. Sonra bu bilgiyi ancialla'dan okudunuz. Size eşit olmadığını söylerse, bu bilgilere göre hareket edersiniz (bir düzeltme uygulayın). Eğer kubitlerimiz ve kapılarımız mükemmel değilse bu nasıl yanlış olabilir?

QEC, kubitlerinizde saklanan bilgileri bozabilir. Bu kapılardan her biri, mükemmel bir şekilde yürütülmezlerse, içinde saklanan bilgileri bozabilir. Dolayısıyla, sadece NES'in yürütülmesi ortalama olarak kurtardığından daha fazla bilgiyi yok ederse, işe yaramaz.

Bir hata bulduğunu düşünüyorsun, ama yapmadın. Karşılaştırma (kapıların yürütülmesi) veya bilgilerin okunması (ancilla) kusurluysa, yanlış bilgi alabilir ve bu nedenle "yanlış düzeltmeler" uygulayabilirsiniz (okuma: hataları sun). Ayrıca, yardımcı maddelerdeki bilgiler okumadan önce bozulursa (veya gürültü ile değiştirilirse), yanlış okuma da alırsınız.

Her bir QEC'nin hedefi, düzelttiğinden daha az hata getirmektir, bu nedenle yukarıda belirtilen etkileri en aza indirmeniz gerekir. Tüm matematiği yaparsanız, kubitleriniz, kapılarınız ve okumalarınız için oldukça sıkı gereksinimler görürsünüz (seçtiğiniz QEC algoritmasına bağlı olarak).

Klasik Versiyon

Basit bir klasik hata düzeltme stratejisi düşünün. Kodlamak istediğiniz tek bir bitiniz var,

$$0\mapsto 00000\qquad 1\mapsto 11111$$ Ben 5 bit kodlamak için seçtim, ama herhangi bir tek sayı yapardı (daha iyi daha iyi). Şimdi, bazı bit-flip hatalarının oluştuğunu varsayalım. $$01010.$$ Bu başlangıçta kodlanmış 0 veya 1 miydi? Bit başına hata olasılığının olduğunu varsayarsak,$p$, yarıdan daha azsa, bitlerin yarısından daha azının hatalar olmasını bekliyoruz. Yani, 0'ların sayısına ve 1'lerin sayısına bakıyoruz. Hangisi daha çok olursa olsun, başladığımız olduğunu varsayıyoruz. Buna çoğunluk oyu denir. Yanlış olma ihtimalimiz var, ancak ne kadar çok bit kodlarsak, bu olasılık o kadar küçük olur.

Öte yandan, eğer bunu bilersek $p>\frac12$, yine de düzeltmeyi yapabiliriz. Sadece bir azınlık oyu uyguluyorsunuz! Ancak mesele, tam tersi işlemi yapmanız gerektiğidir. Burada, en azından hangi rejimde çalıştığınızı bilmeniz gerektiğini gösteren keskin bir eşik var.

Hataya dayanıklılık için işler daha da karmaşıklaşır: $01010$sahip olduğunuz dize devletin gerçekte böyle olmayabilir . Yine de düzeltmeniz gereken bazı hatalarla farklı bir şey olabilir, ancak bitleri okurken yaptığınız ölçümler de biraz arızalıdır. Kabaca, bunun keskin geçişi ne yapacağınızı gerçekten bilmediğiniz belirsiz bir bölgeye dönüştürdüğünü hayal edebilirsiniz. Yine de, hata olasılıkları yeterince düşük veya yeterince yüksekse, düzeltebilirsiniz, sadece durumun ne olduğunu bilmeniz gerekir.

Kuantum Sürümü

Genel olarak, kuantum rejiminde işler daha da kötüleşir çünkü iki tür hata ile uğraşmanız gerekir: bit çevirme hataları ($X$) ve faz çevirme hataları ($Z$) ve bu, belirsiz bölgeyi büyütme eğilimindedir. Burada ayrıntılara girmeyeceğim. Ancak, kuantum rejiminde aydınlatıcı olabilecek sevimli bir argüman var.

Bir kuantum hatası düzeltme kodunda depolanmış tek bir mantıksal kubit durumunuz olduğunu düşünün $|\psi\rangle$ karşısında $N$fiziksel kübitler. Bu kodun ne olduğu önemli değil, bu tamamen genel bir argüman. Şimdi o kadar çok gürültü olduğunu hayal edin ki kuantum durumunu yok eder$\lceil N/2\rceil$qubits ("çok fazla gürültü" aslında hataların 50:50 olasılıkla meydana geldiği anlamına gelir, daha önce söylediğimiz gibi düzeltilebilecek% 100'e yakın değil). Bu hatayı düzeltmek imkansızdır. Bunu nasıl bilebilirim? Tamamen gürültüsüz bir versiyonum olduğunu ve$\lfloor N/2\rfloor$qubits ve kalan qubits size vermek. Her birimiz yeterince boş kübit sunuyoruz, böylece$N$toplam qubits ve biz hata düzeltmesi çalıştırın. Bu hata düzeltmesini yapmak mümkün olsaydı, sonuç her ikimizin de orijinal durumuna sahip olacağı olurdu.$|\psi\rangle$. Biz mantıklı kübit klon olurdu! Ancak klonlama imkansızdır, bu nedenle hata düzeltmesi imkansız olmalıdır.

Bana göre bu sorunun iki kısmı var (biri başlıkla, diğeri sorunun kendisiyle ilişkili):

1) Hata düzeltme kodları hangi miktarda parazit etkindir?
2) Kapılardaki hangi kusurlarla hataya dayanıklı kuantum hesaplamaları uygulayabiliriz?

Firs farkı fark edeyim: kuantum hata düzeltme kodları, örneğin iletimdeki kayıpları düzeltmek için birçok farklı senaryoda kullanılabilir. Burada gürültü miktarı, kapıların kusuruna değil, çoğunlukla optik fiberin uzunluğuna bağlıdır. Ancak hataya dayanıklı kuantum hesaplaması yapmak istiyorsak, kapılar ana gürültü kaynağıdır.

1'de)

Hata düzeltme, büyük hata oranlarında (daha küçük $1/2$). Örneğin, basit 3 qubit tekrarlama kodunu ele alalım. Mantıksal hata oranı sadece çoğunluk oyunun yanlış olma olasılığıdır (turuncu çizgi$f(p)=p$ Karşılaştırma için):

Yani ne zaman fiziksel hata oranı $p$ altında $1/2$, mantıksal hata oranı $p$. Bununla birlikte, bu özellikle küçük$p$, çünkü kod oranı $\mathcal{O}(p)$ bir $\mathcal{O}(p^2)$ davranışı.

Açık 2)

Biz keyfi olarak uzun kuantum hesaplamaları bir kuantum bilgisayar ile perfrom etmek istiyoruz. Ancak, kuantum kapıları mükemmel değildir. Kapıların getirdiği hatalarla başa çıkmak için kuantum hata düzeltme kodlarını kullanıyoruz. Bu, bir mantıksal kübitin birçok fiziksel kubite kodlandığı anlamına gelir. Bu fazlalık, fiziksel kubitlerde belirli bir miktar hatayı düzeltmeye izin verir, böylece mantıksal kubitte saklanan bilgiler bozulmadan kalır. Daha büyük kodlar, daha uzun hesaplamaların hala doğru olmasını sağlar . Bununla birlikte, daha büyük kodlar daha fazla kapı içerir (örneğin daha fazla sendrom ölçümü) ve bu kapılar gürültü oluşturur. Burada bir değiş tokuş olduğunu görüyorsunuz ve hangi kodun optimum olduğu açık değil.
Her kapıdan gelen gürültü bir eşiğin altındaysa (hataya dayanıklılık veya doğruluk eşiği), keyfi olarak uzun hesaplamalara izin vermek için kod boyutunu arttırmak mümkündür. Bu eşik, başladığımız koda bağlıdır (genellikle kendisiyle yinelenen şekilde birleştirilir). Bu değeri tahmin etmenin birkaç yolu vardır. Genellikle sayısal simülasyon ile yapılır: Rasgele hatalar ekleyin ve hesaplamanın hala işe yarayıp yaramadığını kontrol edin. Bu yöntem tipik olarak çok yüksek eşik değerleri verir. Literatürde bazı analitik kanıtlar da vardır, örneğin bu Aliferis ve Cross tarafından .

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!