Warum funktionieren Fehlerkorrektur-Protokolle nur, wenn die Fehlerraten zu Beginn bereits signifikant niedrig sind?

Die Quantenfehlerkorrektur ist ein grundlegender Aspekt der Quantenberechnung, ohne den umfangreiche Quantenberechnungen praktisch nicht durchführbar sind.

Ein Aspekt der fehlertoleranten Quantenberechnung, der oft erwähnt wird, besteht darin, dass jedem Fehlerkorrekturprotokoll eine Fehlerratenschwelle zugeordnet ist . Grundsätzlich muss die Fehlerrate der Gatter unter einem bestimmten Schwellenwert liegen, damit eine bestimmte Berechnung über ein bestimmtes Protokoll vor Fehlern geschützt werden kann.

Mit anderen Worten, wenn die Fehlerraten einzelner Gatter nicht niedrig genug sind, ist es nicht möglich, Fehlerkorrekturprotokolle anzuwenden, um die Berechnung zuverlässiger zu machen.

Warum ist das? Warum ist es nicht möglich, Fehlerraten zu reduzieren, die anfangs noch nicht sehr niedrig sind?

Wir wollen einen Ausgangszustand mit einem gewissen idealen Zustand vergleichen, so normal, Treue, , da dies verwendet wird , ist ein guter Weg , zu sagen , wie gut die möglichen Messergebnisse von ρ mit den möglichen Messergebnissen vergleichen von$F\left(\left|\psi\right>, \rho\right)$$\rho$ , wo | & psgr; ⟩ ist der ideale Ausgangszustand und ρ ist die erreichte (potentiell gemischt) Zustand nachgewissen Rauschprozess. Wie wir Staaten sindvergleichen,ist F ( | & psgr; ⟩ , ρ ) = $\left|\psi\right>$$\left|\psi\right>$$\rho$

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

Beschreiben sowohl die Geräusch- und Fehlerkorrekturprozesse Kraus Operatoren, wobei der Rauschkanal mit Kraus Operatoren ist N i und E ist der Fehlerkorrekturkanal mit Kraus Operatoren E j , der Zustand nach Rauschen ρ ' = N ( | & psgr; ⟩ ⟨ ψ | ) = ∑ i N i | & psgr; ⟩ ⟨ & psgr; | N † i und der Zustand nach Rausch- und Fehlerkorrektur ist ρ = 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.$$

Die Treue dieser ist gegeben durch

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

Damit das Fehlerkorrekturprotokoll von Nutzen ist, soll die Wiedergabetreue nach der Fehlerkorrektur größer sein als die Wiedergabetreue nach dem Rauschen, jedoch vor der Fehlerkorrektur, damit der fehlerkorrigierte Zustand weniger vom nicht korrigierten Zustand unterschieden werden kann. Das heißt, wir wollen Dies ergibt

$$F\left(\left|\psi\right>, \rho\right) > F\left(\left|\psi\right>, \rho'\right).$$ Da die Wiedergabetreue positiv ist, kann dies als∑i,j|umgeschrieben werden ⟨& Psgr;| EjNi| & psgr;⟩| 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.$$

Splitting in den korrigierbaren Teil, N c , für die E ∘ N c ( | & psgr; ⟩ ⟨ & psgr; | ) = | & psgr; ⟩ ⟨ & psgr; | und das nicht-korrigierbare Teil, N n c , für die E ∘ N n c ( | & psgr; ⟩ ⟨ & psgr; | ) = σ . Bezeichnet die Wahrscheinlichkeit, dass der Fehler korrigierbar ist, als 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$und nicht korrigierbare (dh zu viele Fehler aufgetreten sind den idealen Zustand zu rekonstruieren) als ergibt Σ i , j | ⟨ & Psgr; | E j N i | & psgr; ⟩ | 2 = P c + P n c ≤ ≤ | σ | & psgr; ⟩ & ge ; P c , wo Gleichheit unter der Annahme ausgegangen wird ⟨ & psgr; | σ | & psgr; ⟩ = $\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$. Das ist eine falsche 'Korrektur', die auf ein orthogonales Ergebnis projiziert, um das richtige zu erhalten.

Für Qubits mit einer (gleichen) Fehlerwahrscheinlichkeit für jedes Qubit als p ( Anmerkung : Dies ist nicht dasselbe wie der Rauschparameter, der zur Berechnung der Fehlerwahrscheinlichkeit verwendet werden müsste), die Wahrscheinlichkeit, a zu haben korrigierbarer Fehler (unter der Annahme, dass die n Qubits zum Codieren von $n$$p$$n$$k$ Qubits , was Fehler auf bis zu Qubits ermöglicht, bestimmt durch die Singleton-Grenze n - k ≥ 4 t ) ist P$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$

Bearbeiten von Kommentaren:

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

Das Einstecken wie oben weiter ergibt

$$1-\left(1-\left<\psi\vert\sigma\vert\psi\right>\right){n\choose{t+1}}p^{t+1} \gtrapprox\left(1-p\right)^n,$$ Das ist das gleiche Verhalten wie zuvor, nur mit einer anderen Konstante.

Dies zeigt auch, dass eine Fehlerkorrektur zwar die Wiedergabetreue erhöhen kann, jedoch nicht die Wiedergabetreue auf $1$, zumal es durch die Implementierung der Fehlerkorrektur zu Fehlern kommt (z. B. Gate-Fehler, weil in der Realität kein Gate perfekt implementiert werden kann). Da jede einigermaßen tiefe Schaltung per Definition eine angemessene Anzahl von Gattern erfordert, wird die Wiedergabetreue nach jedem Gate geringer sein als die Wiedergabetreue des vorherigen Gates (im Durchschnitt) und das Fehlerkorrekturprotokoll wird weniger effektiv sein. Es wird dann eine abgeschnittene Anzahl von Gattern geben, an welchem ​​Punkt das Fehlerkorrekturprotokoll die Wiedergabetreue verringern wird und die Fehler sich fortlaufend verstärken werden.

Dies zeigt in grober Näherung, dass eine Fehlerkorrektur oder lediglich eine Reduzierung der Fehlerraten für eine fehlertolerante Berechnung nicht ausreicht , es sei denn, die Fehler sind abhängig von der Schaltkreistiefe extrem gering.

Da es bereits eine gute mathematische Antwort gibt, werde ich versuchen, eine leicht verständliche zu finden.

Quantum Error Correction (QEC) ist eine (Gruppe von) ziemlich komplexen Algorithmen, die eine Vielzahl von Aktionen (Gates) auf und zwischen Qubits erfordern. In QEC verbinden Sie so ziemlich zwei Qubits mit einem dritten Helfer-Qubit (ancilla) und übertragen die Informationen in dieses dritte Qubit, wenn die anderen beiden (in gewisser Hinsicht) gleich sind. Dann liest du diese Information aus der Ancialla. Wenn es Ihnen sagt, dass sie nicht gleich sind, handeln Sie anhand dieser Informationen (wenden Sie eine Korrektur an). Wie kann das schief gehen, wenn unsere Qubits und Tore nicht perfekt sind?

QEC kann die in Ihren Qubits gespeicherten Informationen zum Verfall bringen. Jedes dieser Gatter kann die in ihnen gespeicherten Informationen abbauen, wenn sie nicht perfekt ausgeführt werden. Wenn nur die QEC ausgeführt wird, werden mehr Informationen zerstört, als im Durchschnitt wiederhergestellt werden, ist dies nutzlos.

Sie glauben, Sie haben einen Fehler gefunden, aber nicht. Wenn der Vergleich (Ausführung von Toren) oder das Auslesen der Informationen (ancilla) unvollständig ist, erhalten Sie möglicherweise falsche Informationen und wenden daher "falsche Korrekturen" an (lesen: Fehler einführen). Auch wenn die Informationen in den Ancillas verfallen (oder sich durch Rauschen ändern), bevor Sie sie auslesen können, werden Sie ebenfalls falsch ausgelesen.

Das Ziel jeder QEC ist es offensichtlich, weniger Fehler einzuführen, als sie korrigieren. Daher müssen Sie die oben genannten Effekte minimieren. Wenn Sie alle Berechnungen durchführen, stellen Sie ziemlich strenge Anforderungen an Ihre Qubits, Gates und Readouts (abhängig von dem von Ihnen gewählten QEC-Algorithmus).

Klassische Version

Denken Sie an eine einfache Strategie der klassischen Fehlerkorrektur. Sie haben ein einzelnes Bit, das Sie codieren möchten,

$$0\mapsto 00000\qquad 1\mapsto 11111$$ Ich habe beschlossen, es in 5 Bits zu kodieren, aber jede ungerade Zahl würde ausreichen (je mehr, desto besser). Nehmen wir nun an, dass einige Bit-Flip-Fehler aufgetreten sind $$01010.$$ War dies ursprünglich die codierte 0 oder 1? Wenn wir davon ausgehen, dass die Wahrscheinlichkeit eines Fehlers pro Bit,$p$Ist, weniger als eine Hälfte, dann erwarten wir, dass weniger als die Hälfte der Bits Fehler aufweist. Wir betrachten also die Anzahl der Nullen und die Anzahl der Einsen. Was immer es mehr gibt, ist das, von dem wir annehmen, dass es das ist, mit dem wir begonnen haben. Dies wird als Mehrheitsabstimmung bezeichnet. Es besteht eine gewisse Wahrscheinlichkeit, dass wir falsch liegen, aber je mehr Bits wir codieren, desto geringer ist diese Wahrscheinlichkeit.

Andererseits, wenn wir das wissen $p>\frac12$können wir noch die korrektur machen. Sie würden nur eine Minderheitsabstimmung durchführen! Der Punkt ist jedoch, dass Sie vollständig das Gegenteil tun müssen. Hier gibt es eine scharfe Schwelle, die zumindest anzeigt, dass Sie wissen müssen, in welchem ​​Regime Sie arbeiten.

Aus Gründen der Fehlertoleranz wird es unordentlicher: das $01010$Die Zeichenfolge, die Sie erhalten haben, entspricht möglicherweise nicht dem tatsächlichen Status . Es mag etwas anderes sein, immer noch mit einigen Fehlern, die Sie korrigieren müssen, aber die Messungen, die Sie beim Lesen der Bits vorgenommen haben, sind ebenfalls leicht fehlerhaft. Sie können sich vorstellen, dass der scharfe Übergang zu einer mehrdeutigen Region wird, in der Sie nicht genau wissen, was Sie tun sollen. Wenn die Fehlerwahrscheinlichkeiten niedrig genug oder hoch genug sind, müssen Sie nur wissen, was der Fall ist.

Quantenversion

Im Allgemeinen verschlechtern sich die Dinge im Quantenregime, weil Sie mit zwei Arten von Fehlern umgehen müssen: Bit-Flip-Fehler ($X$) und Phasenumkehrfehler ($Z$), und das macht die mehrdeutige Region tendenziell größer. Ich werde hier nicht weiter auf Details eingehen. Es gibt jedoch ein nettes Argument im Quantenregime, das aufschlussreich sein könnte.

Stellen Sie sich vor, Sie haben den Zustand eines einzelnen logischen Qubits in einem Quantenfehlerkorrekturcode gespeichert $|\psi\rangle$ über $N$physische Qubits. Es spielt keine Rolle, um welchen Code es sich handelt, dies ist ein ganz allgemeines Argument. Stellen Sie sich nun vor, es gibt so viel Rauschen, dass es den Quantenzustand zerstört$\lceil N/2\rceil$Qubits ("so viel Rauschen" bedeutet eigentlich, dass Fehler mit einer Wahrscheinlichkeit von 50:50 auftreten und nicht nahe an 100% liegen, was, wie wir bereits gesagt haben, korrigiert werden kann). Es ist unmöglich, diesen Fehler zu korrigieren. Woher weiß ich das? Stellen Sie sich vor, ich hätte eine völlig geräuschlose Version und behalte sie bei$\lfloor N/2\rfloor$Qubits und geben Sie die restlichen Qubits an Sie. Wir führen jeweils genügend leere Qubits ein, damit wir haben$N$Qubits insgesamt, und wir führen auf ihnen eine Fehlerkorrektur durch. Wenn es möglich wäre, diese Fehlerkorrektur durchzuführen, würde das Ergebnis sein, dass wir beide den ursprünglichen Zustand haben würden$|\psi\rangle$. Wir hätten das logische Qubit geklont! Da das Klonen jedoch nicht möglich ist, muss die Fehlerkorrektur unmöglich gewesen sein.

Für mich scheint es zwei Teile dieser Frage zu geben (einen mehr im Zusammenhang mit dem Titel, einen mehr im Zusammenhang mit der Frage selbst):

1) Auf welchen Rauschbetrag sind Fehlerkorrekturcodes wirksam?
2) Mit welchem ​​Ausmaß an Unvollkommenheit in Gattern können wir fehlertolerante Quantenberechnungen implementieren?

Lassen Sie mich den Unterschied betonen: Quantenfehlerkorrekturcodes können in vielen verschiedenen Szenarien verwendet werden, um beispielsweise Übertragungsverluste zu korrigieren. Hier hängt die Menge des Rauschens hauptsächlich von der Länge der optischen Faser und nicht von der Unvollkommenheit der Tore ab. Wenn wir jedoch fehlertolerante Quantenberechnungen implementieren möchten, sind die Gatter die Hauptquelle für Rauschen.

Auf 1)

Die Fehlerkorrektur funktioniert bei großen Fehlerraten (kleiner als $1/2$). Nehmen Sie zum Beispiel den einfachen 3-Qubit-Wiederholungscode. Die logische Fehlerrate ist nur die Wahrscheinlichkeit, dass die Mehrheitswahl falsch ist (die orange Linie ist$f(p)=p$ zum Vergleich):

Also wann immer die physikalische Fehlerrate $p$ ist unterhalb $1/2$ist die logische Fehlerrate kleiner als $p$. Beachten Sie jedoch, dass dies besonders effektiv für kleine ist$p$, weil der Code die Rate von ändert $\mathcal{O}(p)$ zu einer $\mathcal{O}(p^2)$ Verhalten.

Auf 2)

Wir wollen mit einem Quantencomputer beliebig lange Quantenberechnungen durchführen. Die Quantentore sind jedoch nicht perfekt. Um mit den durch die Gatter eingebrachten Fehlern fertig zu werden, verwenden wir Quantenfehlerkorrekturcodes. Dies bedeutet, dass ein logisches Qubit in viele physikalische Qubits codiert wird. Diese Redundanz ermöglicht es, eine bestimmte Menge von Fehlern in den physikalischen Qubits zu korrigieren, so dass die in dem logischen Qubit gespeicherten Informationen intakt bleiben. Größere Codes ermöglichen, dass längere Berechnungen immer noch genau sind . Größere Codes beinhalten jedoch mehr Gatter (zum Beispiel mehr Syndrommessungen) und diese Gatter führen Rauschen ein. Sie sehen, dass es hier einen Kompromiss gibt, und welcher Code optimal ist, ist nicht klar.
Wenn das durch jedes Gatter eingeführte Rauschen unter einem Schwellenwert (der Fehlertoleranz- oder Genauigkeitsschwelle) liegt, ist es möglich, die Codegröße zu erhöhen, um beliebig lange Berechnungen zu ermöglichen. Dieser Schwellenwert hängt von dem Code ab, mit dem wir begonnen haben (normalerweise wird er iterativ mit sich selbst verkettet). Es gibt verschiedene Möglichkeiten, diesen Wert zu schätzen. Oft geschieht dies durch numerische Simulation: Führen Sie zufällige Fehler ein und prüfen Sie, ob die Berechnung noch funktioniert. Diese Methode liefert typischerweise zu hohe Schwellenwerte. Es gibt auch einige analytische Beweise in der Literatur, zum Beispiel diesen von Aliferis und Cross .

Sie benötigen eine überraschend große Anzahl von Quantentoren, um einen Quantenfehlerkorrekturcode fehlertolerant zu implementieren. Ein Teil des Grundes ist, dass es viele Fehler zu entdecken gibt, da ein Code, der alle einzelnen Qubit-Fehler korrigieren kann, bereits 5 Qubits erfordert und jeder Fehler von drei Arten sein kann (entsprechend unbeabsichtigten X-, Y-, Z-Gattern). Um also nur einen einzelnen Qubit-Fehler zu korrigieren, benötigen Sie bereits Logik, um zwischen diesen 15 Fehlern und der fehlerfreien Situation zu unterscheiden:$XIIII$, $YIIII$, $ZIIII$, $IXIII$, $IYIII$, $IZIII$, $IIXII$, $IIYII$, $IIZII$, $IIIXI$, $IIIYI$, $IIIZI$, $IIIIX$, $IIIIY$, $IIIIZ$, $IIIII$ wo $X$, $Y$, $Z$ sind die möglichen Single-Qubit-Fehler und $I$ (Identität) bezeichnet die Situation ohne Fehler für dieses Qubit.

Der Hauptgrund ist jedoch, dass Sie keine einfache Fehlererkennungsschaltung verwenden können: Jedes CNOT (oder jedes andere nichttriviale 2-Bit- oder mehr-Bit-Gatter) leitet Fehler in einem Qubit an ein anderes Qubit weiter, was für das Trivialste katastrophal wäre Fall eines einzelnen Qubit-Fehlerkorrekturcodes und immer noch sehr schlecht für anspruchsvollere Codes. Daher ist eine fehlertolerante (nützliche) Umsetzung von Bedürfnissen noch aufwändiger, als man naiv annehmen könnte.

Bei vielen Gattern pro Fehlerkorrekturschritt kann nur eine sehr geringe Fehlerrate pro Schritt zugelassen werden. Hier ergibt sich noch ein weiteres Problem: Da Sie möglicherweise kohärente Fehler haben, müssen Sie für den schlimmsten Fall bereit sein, dass ein Fehler auftritt$\epsilon$ propagiert nicht als $N \epsilon$ nach N einzelnen Qubit-Gattern aber als $N^2 \epsilon$. Dieser Wert muss ausreichend niedrig bleiben, damit Sie nach der Korrektur einiger (aber nicht aller) Fehler, z. B. nur einzelner Qubit-Fehler, einen Gesamtgewinn erzielen.

Ein Beispiel für einen kohärenten Fehler ist die Implementierung eines Gatters $G$ das tut auf erste bestellung nicht einfach $G$ aber $G + \sqrt{\epsilon} X$ von dem du einen Fehler nennen könntest $\epsilon$ denn das ist die Wahrscheinlichkeit, die der Wahrscheinlichkeitsamplitude entspricht $\sqrt{\epsilon}$ und daher die Wahrscheinlichkeit, dass eine Messung direkt nach dem Tor ergibt, dass es sich um den Fehler handelte $X$. Nach$N$ anwendungen dieses tores, wieder auf erste bestellung, hast du tatsächlich beantragt $G^N + N \sqrt{\epsilon} G^N X$ (wenn G und X pendeln, sonst ein komplizierteres Konstrukt, das hat $N$ verschiedene Begriffe proportional zu $\sqrt{\epsilon}$). Wenn Sie also messen, finden Sie eine Fehlerwahrscheinlichkeit von$N^2 \epsilon$.

Inkohärente Fehler sind harmloser. Wenn man jedoch einen einzelnen Wert als Fehlerschwelle angeben muss, kann man nicht nur harmlose Fehler annehmen!