Dlaczego protokoły korekcji błędów działają tylko wtedy, gdy na początku poziomy błędów są już znacząco niskie?

Kwantowa korekcja błędów jest fundamentalnym aspektem obliczeń kwantowych, bez których obliczenia kwantowe na dużą skalę są praktycznie niewykonalne.

Jednym aspektem tolerancyjnego na błędy obliczenia kwantowego, o którym często się wspomina, jest to, że do każdego protokołu korekcji błędów przypisano próg częstości błędów . Zasadniczo, aby dane obliczenia były chronione przed błędami za pośrednictwem danego protokołu, poziom błędu bramek musi być poniżej pewnego progu.

Innymi słowy, jeśli poziomy błędów pojedynczych bramek nie są wystarczająco niskie, wówczas nie można zastosować protokołów korekcji błędów, aby uczynić obliczenia bardziej wiarygodnymi.

Dlaczego to? Dlaczego na początku nie można zmniejszyć poziomów błędów, które nie są jeszcze bardzo niskie?

Chcemy porównać to stan wyjścia z pewnego stanu idealnego, tak normalnie, wierność, jest stosowany, ponieważ jest to dobry sposób, aby powiedzieć, jak również możliwe wyniki pomiarów p porównać z możliwych wyników pomiarowych | * F ⟩ , gdzie | * F ⟩ jest stan wyjściowy idealny i ρ jest osiągnięty (potencjalnie po zmieszaniu) stan po jakimś procesie hałasu. Ponieważ jesteśmy porównując stany, to F ( | * 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>}.$$

Opisując zarówno procesów korekcyjnych hałasu i błąd za pomocą operatorów Kraus, gdzie jest kanał hałas z operatorami Kraus N I i E jest kanałem korekcji błędów z Kraus operatorzy E j , stan po hałasu jest ρ ' = N ( | * F ⟩ ⟨ ψ | ) = ∑ i N i | * F ⟩ ⟨ * F | N † i, a stan po korekcji szumu i błędu wynosi ρ = 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.$$

Wierność ta jest podana przez

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

Aby protokół korekcji błędów miał jakiekolwiek zastosowanie, chcemy, aby wierność po korekcji błędów była większa niż wierność po szumie, ale przed korektą błędu, tak aby stan z korekcją błędów był mniej odróżnialny od stanu nieskorygowanego. Oznacza to, że chcemy To daje

$$F\left(\left|\psi\right>, \rho\right) > F\left(\left|\psi\right>, \rho'\right).$$ Ponieważ wierność jest dodatnia, można to przepisać jako∑i,j| ⟨* F| EjNi| * F⟩| 2>∑i| ⟨* F| Ni| * F⟩| 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.$$

Dzielenie do skorygowania części N c , dla których E ∘ N c ( | * F ⟩ ⟨ * F | ) = | * F ⟩ ⟨ * F | a nie do naprawienia część, N N c , dla których E ∘ N N C ( | * F ⟩ ⟨ * F | ) = σ . Oznaczające prawdopodobieństwo poprawienia błędu jako 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$i nie można go skorygować (tj. wystąpiło zbyt wiele błędów, aby zrekonstruować stan idealny), ponieważ daje ∑ i , j | ⟨ * F | E j N i | * F ⟩ | 2 = p c + P n c ⟨ * F | σ | * F ⟩ ≥ P c , gdzie równość zostaną przejęte przez zakładając ⟨ * F | σ | * F ⟩ = $\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$. To fałszywa „korekta” rzutuje na wynik ortogonalny do poprawnego.

Dla kubitów, z (równym) prawdopodobieństwem błędu na każdym kubicie jako p ( uwaga : nie jest to to samo, co parametr szumu, który musiałby zostać użyty do obliczenia prawdopodobieństwa błędu), prawdopodobieństwo posiadania błąd korygujący (przy założeniu, że n kubitów zostało użytych do zakodowania k kubitów, co pozwala na błędy do t kubitów, określone przez n - k ≥ 4 t singletona ) wynosi 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$

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

Edytuj z komentarzy:

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

Pokazuje to z grubsza przybliżenie, że korekcja błędów lub jedynie zmniejszenie wskaźników błędów nie wystarcza do obliczeń odpornych na uszkodzenia , chyba że błędy są bardzo niskie, w zależności od głębokości obwodu.

Jest już dobra odpowiedź matematyczna, więc postaram się podać odpowiedź łatwą do zrozumienia.

Kwantowa korekcja błędów (QEC) jest (grupą) raczej złożonym algorytmem (algorytmami), który wymaga wielu działań (bramek) na i między kubitami. W QEC w zasadzie łączysz dwa kubity z trzecim kubitem pomocniczym (ancilla) i przenosisz informacje, jeśli pozostałe dwa są równe (pod pewnymi względami) do tego trzeciego kubita. Następnie czytasz te informacje z ancialla. Jeśli mówi ci, że nie są one równe, działasz na podstawie tych informacji (zastosuj korektę). Jak to może pójść nie tak, jeśli nasze kubity i bramy nie są idealne?

QEC może spowodować zanik informacji przechowywanych w kubitach. Każda z tych bram może zniszczyć przechowywane w nich informacje, jeśli nie zostaną wykonane perfekcyjnie. Więc jeśli samo wykonanie QEC niszczy więcej informacji, niż odzyskuje średnio, jest to bezużyteczne.

Myślisz, że znalazłeś błąd, ale go nie znalazłeś. Jeśli porównanie (wykonanie bramek) lub odczyt informacji (ancilla) jest niedoskonały, możesz uzyskać błędne informacje, a tym samym zastosować „złe poprawki” (czytaj: wprowadzaj błędy). Również, jeśli informacje w ancillas zanikną (lub zostaną zmienione przez hałas), zanim będzie można je odczytać, również błędny odczyt.

Celem każdego QEC jest oczywiście wprowadzenie mniej błędów, niż poprawia, więc musisz zminimalizować wyżej wymienione efekty. Jeśli wykonasz całą matematykę, znajdziesz dość surowe wymagania dotyczące kubitów, bramek i odczytów (w zależności od wybranego algorytmu QEC).

Wersja klasyczna

Pomyśl o prostej strategii klasycznej korekcji błędów. Masz jeden bit, który chcesz zakodować,

$$0\mapsto 00000\qquad 1\mapsto 11111$$ Zdecydowałem się zakodować go na 5 bitów, ale każda nieparzysta liczba byłaby wystarczająca (im więcej, tym lepiej). Załóżmy teraz, że wystąpiły pewne błędy odwracania bitów, więc mamy to $$01010.$$ Czy pierwotnie było to zakodowane 0 czy 1? Jeśli założymy, że prawdopodobieństwo błędu na bit,$p$, jest mniej niż połowa, wtedy spodziewamy się, że mniej niż połowa bitów zawiera błędy. Więc patrzymy na liczbę zer i liczbę jedynek. Cokolwiek jest więcej, zakładamy, że zaczęliśmy. Nazywa się to głosowaniem większościowym. Istnieje pewne prawdopodobieństwo, że się mylimy, ale im więcej bitów zakodowaliśmy, tym mniejsze prawdopodobieństwo.

Z drugiej strony, jeśli to wiemy $p>\frac12$, nadal możemy dokonać korekty. Po prostu wdrożysz głos mniejszości! Chodzi jednak o to, że musisz wykonać całkowicie odwrotną operację. Jest tutaj ostry próg, który pokazuje przynajmniej, że musisz wiedzieć, w jakim systemie pracujesz.

W przypadku odporności na awarie rzeczy stają się bardziej chaotyczne: $01010$Ciąg że masz może nie być tym, co państwo rzeczywiście jest. Może to być coś innego, nadal z pewnymi błędami, które musisz poprawić, ale pomiary wykonane podczas odczytu bitów są również nieco błędne. Z grubsza można sobie wyobrazić, że zmienia to gwałtowne przejście w dwuznaczny region, w którym tak naprawdę nie wiesz, co robić. Jeśli jednak prawdopodobieństwo błędu jest wystarczająco niskie lub wystarczająco wysokie, możesz je poprawić, wystarczy wiedzieć, co się dzieje.

Wersja kwantowa

Ogólnie rzecz biorąc, w reżimie kwantowym sytuacja pogarsza się, ponieważ trzeba radzić sobie z dwoma rodzajami błędów: błędami odwracania bitów ($X$) i błędy odwracania faz ($Z$), co powoduje, że region niejednoznaczny staje się większy. Nie będę się tutaj zagłębiał w szczegóły. Istnieje jednak uroczy argument w reżimie kwantowym, który może być pouczający.

Wyobraź sobie, że masz stan pojedynczego logicznego kubita przechowywanego w kodzie korekcji błędów kwantowych $|\psi\rangle$ przez $N$kubity fizyczne. Nie ma znaczenia, co to za kod, jest to całkowicie ogólny argument. Wyobraź sobie teraz tyle hałasu, że niszczy on stan kwantowy$\lceil N/2\rceil$kubity („tyle hałasu” w rzeczywistości oznacza, że ​​błędy występują z prawdopodobieństwem 50:50, nie zbliżonym do 100%, co, jak już powiedzieliśmy, można poprawić). Nie można poprawić tego błędu. Skąd to wiem? Wyobraź sobie, że mam całkowicie bezszelestną wersję i tak jest$\lfloor N/2\rfloor$kubity i daj pozostałe kubity. Każdy z nas wprowadza wystarczającą liczbę pustych kubitów, abyśmy mieli$N$kubitów ogółem i uruchamiamy na nich korekcję błędów. Gdyby można było wykonać tę korekcję błędów, wynik byłby taki, że oboje mielibyśmy stan pierwotny$|\psi\rangle$. Sklonowalibyśmy logiczny kubit! Ale klonowanie jest niemożliwe, więc korekcja błędów musiała być niemożliwa.

Wydaje mi się, że są dwie części tego pytania (jedna związana z tytułem, druga związana z samym pytaniem):

1) Do jakiego poziomu szumów działają kody korekcji błędów?
2) Z jaką ilością niedoskonałości w bramach możemy zastosować odporne na błędy obliczenia kwantowe?

Pozwólcie, że podkreślę różnicę: kody korekcji błędów kwantowych mogą być stosowane w wielu różnych scenariuszach, na przykład do korygowania strat w transmisjach. Tutaj ilość hałasu zależy głównie od długości światłowodu, a nie od niedoskonałości bram. Jeśli jednak chcemy zastosować obliczenia kwantowe odporne na uszkodzenia, bramki są głównym źródłem hałasu.

Na 1)

Korekcja błędów działa w przypadku dużych poziomów błędów (mniejszych niż $1/2$). Weźmy na przykład prosty 3-qubitowy kod powtórzenia. Logiczny poziom błędu to po prostu prawdopodobieństwo, że większość głosów się pomyli (pomarańczowa linia to$f(p)=p$ dla porownania):

Więc ilekroć fizyczny poziom błędu $p$ jest poniżej $1/2$, logiczny poziom błędu jest mniejszy niż $p$. Należy jednak pamiętać, że jest to szczególnie skuteczne w przypadku małych$p$, ponieważ kod zmienia szybkość z $\mathcal{O}(p)$ do $\mathcal{O}(p^2)$ zachowanie.

2)

Chcemy opierać się na dowolnie długich obliczeniach kwantowych za pomocą komputera kwantowego. Jednak bramy kwantowe nie są idealne. Aby poradzić sobie z błędami wprowadzonymi przez bramki, stosujemy kwantowe kody korekcji błędów. Oznacza to, że jeden logiczny kubit jest zakodowany w wielu fizycznych kubitach. Ta nadmiarowość pozwala skorygować pewną liczbę błędów w kubitach fizycznych, tak że informacje przechowywane w logicznym kubicie pozostają nienaruszone. Większe kody pozwalają, aby dłuższe obliczenia były nadal dokładne . Jednak większe kody obejmują więcej bramek (na przykład więcej pomiarów syndromu) i bramki te wprowadzają hałas. Widzisz, że jest tu pewien kompromis, a który kod jest optymalny, nie jest oczywiste.
Jeśli szum wprowadzany przez każdą bramkę jest poniżej pewnego progu (tolerancja błędu lub próg dokładności), wówczas można zwiększyć rozmiar kodu, aby umożliwić dowolnie długie obliczenia. Ten próg zależy od kodu, od którego zaczęliśmy (zwykle jest iteracyjnie łączony z samym sobą). Istnieje kilka sposobów oszacowania tej wartości. Często odbywa się to za pomocą symulacji numerycznej: Wprowadź losowe błędy i sprawdź, czy obliczenia nadal działają. Ta metoda zazwyczaj podaje zbyt wysokie wartości progowe. W literaturze jest także kilka dowodów analitycznych, na przykład ten autorstwa Aliferis i 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!