# Quantenfehlerkorrektur

Quantenfehlerkorrektur wird in der Quanteninformatik benutzt, um Quanteninformation vor Fehlern infolge von Dekohärenz und Quantenrauschen zu schützen. Quantenfehlerkorrekturen sind grundlegend beim Ausführen von fehlertoleranten Quantenberechnungen, welche nicht nur Störungen in gespeicherter Quanteninformation beheben, sondern auch fehlerhafte Quantengatter sowie fehlerhafte Messungen.

## Allgemeines

Quantencomputer sind besonders fehleranfällig aufgrund Dekohärenz und anderer Ursachen. Die DiVincenzo-Kriterien für die Architektur von Quantencomputern betonen die Notwendigkeit einer Quantenfehlerkorrektur, um eine zuverlässige und fehlertorante Berechnung sicherzustellen. Ohne Fehlerkorrektur wären Quantencomputer wiederum auch ohne großen Nutzen, da die Fehleranfälligkeit hoch ist.
Die klassische Fehlerkorrektur verwendet Redundanz. Der einfachste Weg ist, die Information mehrfach zu speichern, und wenn diese Kopien sich später unterscheiden, die Mehrheit auszuwählen. Angenommen, wir kopieren ein Bit dreimal. Wir nehmen weiter an, dass eine Störung den Zustand der drei Bits so verändert, dass ein Bit den Wert Null annimmt, aber die anderen beiden den Wert Eins. Wir setzen auch voraus, dass Störungen unabhängig sind und mit einer gewissen Wahrscheinlichkeit p auftreten. Es ist sehr wahrscheinlich, dass der Fehler bei einem Bit liegt und die gesendete Nachricht drei Einsen enthält. Es besteht auch eine Wahrscheinlichkeit, dass ein Doppelfehler auftritt und die gesendete Nachricht drei Nullen enthält, aber dieses Ergebnis ist weniger wahrscheinlich als das erste.
Quanteninformation zu kopieren, ist laut dem No-Cloning-Theorem nicht möglich und stellt daher eine Einschränkung bei der Formulierung einer Theorie der Quantenfehlerkorrektur dar. Aber es ist möglich, die Information von einem Qubit auf ein verschränktes System von mehreren Qubits zu übertragen. Peter Shor entdeckte 1995 als Erster diese Methode, indem er einen Code zur Quantenfehlerkorrektur entwickelte, der die Information von einem Qubit auf ein verschränktes System von neun Qubits übertrug. Ein Code, basierend auf Quantenfehlerkorrektur, schützt Quanteninformation gegen Fehler von begrenzter Form. Shors Code bedeutete einen signifikanten Durchbruch in der Quanteninformatik, der zeigte, dass Quanteninformationen in einer systematischen Weise gegen Fehler geschützt werden konnten, und legte die Grundlagen für die sich entwickelnde Quantenfehlerkorrektur.
Klassische fehlerkorrigierende Codes verwenden eine Syndrom-Messung um festzustellen, welcher Fehler einen verschlüsselten Zustand zerstört. Der Fehler wird dann rückgängig gemacht, indem eine durch das Syndrom bestimmte, korrigierende Operation angewendet wird. Quantenfehlerkorrektur verwendet auch eine Syndrom-Messung. Allerdings muss nun, anders als im klassischen Fall, sichergestellt werden, dass sich aus der Syndrommessung keine Information über die kodierte Quanteninformation entnehmen lässt, sondern nur über das Vorliegen und die Art eines Fehlers. Eine Syndrom-Messung kann (für eine begrenzte Menge von mit dem verwendeten Code korrigierbaren Fehlern) bestimmen, ob ein Qubit beschädigt wurde, und wenn ja, welches beschädigt wurde. Darüber hinaus sagt uns das Ergebnis der Operation nicht nur, welches physikalische Qubit betroffen war, sondern auch, auf welchem der möglichen Wege es betroffen war. Letzteres ist auf den ersten Blick überraschend, da es nur eine endliche, diskrete Menge von Syndromen gibt, aber ein Kontinuum von unendlich vielen möglichen Fehleroperationen. Ein ähnliches Problem tritt in klassischen Analogrechnern auf, in denen das Auftreten eines Kontinuums an möglichen Fehlern dazu führt, dass alle Vorteile, die ein fehlerfreier Analogrechner gegenüber einem Digitalrechner hätte, verloren gehen. Die Quantenfehlerkorrektur macht sich bei der Messung des Syndroms den projektiven Effekt jeder Quantenmessung zunutze. Die Syndrommessung diskretisiert das Kontinuum an möglichen Fehlern, indem sie den Zustand des kodierten Qubits entweder auf den fehlerfreien Unterraum oder auf den Unterraum projiziert, der zu einem bestimmten der korrigierbaren Fehler (typischerweise eine Kombination von Bitflip- und Phasenflip-Fehlern an bestimmten Qubits, den sogenannten „Pauli-Fehlern“, da sie sich durch Anwendung der Pauli-Matrizen $X,Z,Y$ auf ein oder mehrere Qubits beschreiben lassen) gehört. Die Syndrom-Messung „zwingt“ das Qubit, sich für einen speziellen „Pauli-Fehler“ zu „entscheiden“, und das Messergebnis sagt, für welchen. Da die Pauli-Fehler alle umkehrbar sind (durch die erneute Anwendung derselben Pauli-Matrizen auf dieselben Qubits), erlaubt die Kenntnis des Syndroms nun, den Fehler zu korrigieren.
Die Syndrom-Messung sagt uns so viel wie möglich über den ereigneten Fehler, aber überhaupt nichts über den Wert, der im Qubit gespeichert ist – anders würde die Messung jegliche Superposition des Qubits und anderer Qubits im Quantencomputer zerstören.

## Der Bit-Flip-Code

Für klassische Bits kann ein Wiederholungscode angewandt werden, da Bits leicht zu messen und wiederherzustellen sind. Für Qubits ist dies hingegen, aufgrund des No-Cloning-Theorems, welches die Erzeugung von identischen Kopien eines beliebigen Quantenzustandes verbietet, nicht mehr möglich, denn ein einzelnes Qubit in einem unbekannten Zustand kann nicht dreimal kopiert werden wie im oberen Beispiel verlangt, und jegliche Messung würde Information im Qubit verändern. Dennoch gibt es für Quantencomputer Methoden, ein Qubit gegen Bit-Flip-Fehler zu schützen. Die einfachste ist der 3-Qubit-Bit-Flip-Code, der aber schon die allgemeine Vorgehensweise illustriert: es werden verschränkte Zustände verwendet, um das Qubit zu kodieren und Syndrommessungen, die blind sind für den Zustand des kodierten Qubits, um den Fehler zu entdecken. Damit wird das gleiche Ergebnis erreicht wie mit dem Wiederholungscode klassische Bits: ein Bit-Flip-Fehler pro logischem (Qu)Bit kann korrigiert werden.
Der Coderaum wird aufgespannt durch die zwei 3-Qubit-Zustände $|000\rangle$ und $|111\rangle$. Der Zustand $|\psi \rangle =\alpha _{0}|0\rangle +\alpha _{1}|1\rangle$ eines Qubits kann mittels zweier CNOT-Gatter in den Coderaum geschrieben werden. Dazu verwendet man zwei weitere, im Zustand $|0\rangle$ präparierte Qubits und wendet dann ein CNOT auf Qubit 1 und 2 und dann ein weiteres CNOT auf Qubit 1 und 3 an, wobei jeweils Qubit 1 das Kontroll-Qubit ist.
Das Ergebnis sieht folgendermaßen aus: $|\psi '\rangle =\alpha _{0}|000\rangle +\alpha _{1}|111\rangle .$ Dies ist ein Zustand von drei Qubits, der —für $|\alpha _{0}|\not =0,1$— drei verschränkte Qubits beschreibt und verschieden ist vom dreifachen „Klon“ des Zustands $|\psi \rangle$. Um das Vorgehen zur Fehlerkorrektur zu illustrieren, betrachtet man beispielhaft den Fall, dass das erste Qubit einem Bit-Flip-Fehler unterliegt. Das Ergebnis würde folgendermaßen aussehen: $|\psi '_{r}\rangle =\alpha _{0}|100\rangle +\alpha _{1}|011\rangle$. Um die Umkehrung bei irgendeinem der drei möglichen Qubits festzustellen, benötigt man eine Syndromdiagnose, die einerseits feststellen muss, dass das erste Bit geflippt wurde (beziehungsweise, dass nichts geflippt wurde, wenn das Qubit weiterhin im Zustand $|\psi '\rangle$ ist) und andererseits keine Information über den Zustand selbst liefert (d. h., unabhängig ist von $\alpha _{0},\alpha _{1}$). Dies kann durch eine Messung erreicht werden, welche durch die folgenden vier, paarweise orthogonalen Projektionsoperatoren definiert ist:
    $P_{0}=|000\rangle \langle 000|+|111\rangle \langle 111|$
    $P_{1}=|100\rangle \langle 100|+|011\rangle \langle 011|$
    $P_{2}=|010\rangle \langle 010|+|101\rangle \langle 101|$
    $P_{3}=|001\rangle \langle 001|+|110\rangle \langle 110|$
Hier projiziert $P_{0}$ auf den Coderaum und liefert somit immer das Ergebnis 1 für jeden Zustand der Form $\alpha |000\rangle +\beta |111\rangle$, insbesondere für $|\psi '\rangle$. Dagegen projiziert $P_{1}$ auf den Unterraum, in dem das erste Qubit geflippt wurde und entsprechend $P_{2},P_{3}$ für die anderen beiden Qubits. Für den Zustand $|\psi _{r}'\rangle$ ergeben sich damit die folgenden Resultate:
    $\langle \psi '_{r}|P_{0}|\psi '_{r}\rangle =0,$
    $\langle \psi '_{r}|P_{1}|\psi '_{r}\rangle =1,$
    $\langle \psi '_{r}|P_{2}|\psi '_{r}\rangle =0,$
    $\langle \psi '_{r}|P_{3}|\psi '_{r}\rangle =0.$
Das Messresultat („Syndrom“) $(0100)$ signalisiert, somit, dass das zweite Qubit einem Bit-Flip unterlegen ist. Durch Anwendung eines Nicht-Gatters auf das Qubit 1 kann der Fehler dann korrigiert werden: ${\text{NOT}}_{1}|\psi '_{r}\rangle =|\psi '>$. Wenn allerdings zwei Bit-Flip-Fehler passieren, bevor das Syndrom gemessen wird, dann funktioniert der Code nicht mehr, denn zwei Bit-Flips an verschiedenen Qubits produzieren dasselbe Syndrom wie ein Bitflip am dritten Qubit und die Korrekturoperation führt dann zu einem Bit-Flip-Fehler des logischen Qubits. Für die Korrektur von mehr als einem Fehler ist (wie auch beim klassischen Wiederholungscode) mehr Redundanz nötig.

## Der Sign-Flip-Code

Der Bit Flip ist die einzige Art Fehler in klassischen Computern, in Quantencomputern kann jedoch außerdem noch ein Sign Flip auftreten. Um mit dieser Art Fehler umzugehen, verwendet man den Sign Flip Code. Durch die Übertragung in einem Kanal kann das Vorzeichen zwischen $|0\rangle$ und $|1\rangle$ ebenfalls umgekehrt werden. Zum Beispiel ein Qubit im Zustand $|-\rangle =(|0\rangle -|1\rangle )/{\sqrt {2}}$ möge durch Umkehrung des Vorzeichens in $|+\rangle =(|0\rangle +|1\rangle )/{\sqrt {2}}$ umgewandelt werden.
Der Originalzustand des Qubits
    $|\psi \rangle =\alpha _{0}|+\rangle +\alpha _{1}|-\rangle$
wird in den Zustand
    $|\psi '\rangle =\alpha _{0}|+++\rangle +\alpha _{1}|---\rangle .$
umgewandelt.
Die Verbesserung des Fehlers nach dem Sign Flip Code ist identisch mit dem Bit Flip Code.

## Der Shor-Code

Der nach Peter Shor benannte Code ist ein Quantenfehlercode, der ein logisches Qubit in neun physischen Qubits codiert und die Prinzipien der klassischen Fehlerkorrektur und der Quantenmechanik kombiniert. Er benutzt eine Reihe von kontrollierten Operationen nach einem spezifischen Muster. Das Muster erlaubt den Code, sowohl Bits Flips als auch Sign Flips Fehler zu erkennen, ohne das logische Qubit direkt zu messen, sondern lediglich die zusätzlichen Qubits. Der Code ist eine Kombination des Sign-Flip-Codes und des Bit-Flip-Codes.
Der Fehlerkorrektur-Code auf Kanäle angewandt, möge entweder das Bit umkehren oder das Vorzeichen umkehren. Es ist ebenso möglich, beide Codes in einem Code zu kombinieren. Der Shor Code ist nur eine Methode, welche beliebige Qubit-Fehler korrigieren kann.
Das erste, vierte und siebte Qubit sind für den Sign Flip Code, während die Dreier-Gruppen (1,2,3), (4,5,6), und (7,8,9) für den Bit Flip Code ausgelegt sind. Mit dem Shor Code wird der Zustand eines Qubits $|\psi \rangle =\alpha _{0}|0\rangle +\alpha _{1}|1\rangle$ in ein Produkt von 9 Qubits $|\psi '\rangle =\alpha _{0}|0_{S}\rangle +\alpha _{1}|1_{S}\rangle$ transformiert, wobei
    $|0_{S}\rangle =(|000000000\rangle +|000000111\rangle +|000111000\rangle +|000111111\rangle +|111000000\rangle +|111000111\rangle +|111111000\rangle +|111111111\rangle )/{\sqrt {8}}$
    $|1_{S}\rangle =(|000000000\rangle -|000000111\rangle -|000111000\rangle +|000111111\rangle -|111000000\rangle +|111000111\rangle +|111111000\rangle -|111111111\rangle )/{\sqrt {8}}$
Wenn ein Bit-Flip-Fehler an einem Qubit auftritt, wird eine Syndrom-Analyse an jeder Gruppe von Zuständen (1,2,3), (4,5,6), und (7,8,9), ausgeführt und der Fehler korrigiert.
Wenn die 3-Bit-Flip-Gruppen (1,2,3), (4,5,6), und (7,8,9) als drei Eingänge betrachtet werden, dann kann der Shor-Code-Schaltkreis auf einen Sign Flip Code reduziert werden. Das heißt, der Shor Code kann auch Sign-Flip-Fehler an einem einzelnen Qubit reparieren. Der Shor Code kann auch jeden beliebigen Fehler (Bit Flip und Sign Flip) an einem einzelnen Qubit korrigieren. Wenn ein beliebiger Fehler eine beliebige unitäre Transformation $U$ ist, welche an einem Qubit einwirkt
    $U|\psi \rangle =|\psi _{e}\rangle .$
    $|\psi \rangle$ ist der Originalzustand des einzelnen Qubits, welches betroffen ist. $U$ kann beschrieben werden in der Form
    $U=C_{0}I+C_{1}\sigma _{x}+C_{2}\sigma _{y}+C_{3}\sigma _{z}$
wobei $C_{0}$,$C_{1}$,$C_{2}$, und $C_{3}$ komplexe Koeffizienten sind, $I$ ist die Identität, und die Pauli-Matrizen sind gegeben durch
    $\sigma _{x}={\biggl{\begin{matrix}0&1\\1&0\end{matrix}}{\biggr )};$
    $\sigma _{y}={\biggl{\begin{matrix}0&-i\\i&0\end{matrix}}{\biggr )};$
    $\sigma _{z}={\biggl{\begin{matrix}1&0\\0&-1\end{matrix}}{\biggr )}$
Die Pauli-Matrizen sind eine Gruppe von 2×2 hermiteschen und unitären Matrizen. Ist $U=I$, dann heißt das, der Zustand ist unverändert. Wenn $U=\sigma _{x}$ ist, dann hat sich ein Bit-Flip-Fehler im Kanal ereignet, wenn $U=\sigma _{z}$ ist, dann muss sich das Vorzeichen umgekehrt haben, und laut $U=i\sigma _{y}$ beides, ein Bit Flip und ein Sign Flip. Dann wird die Fehlerkorrektur wie oben den Fehler korrigieren. Aber der Shor Code funktioniert nur im Falle eines 1-Qubit-Fehlers.
Der Shor Code wurde in vielen Quantensystemen implementiert und dient als Komponente für komplexere Fehlerkorrekturcodes und fehlertolerante Architekturen und deren Weiterentwicklung. Die Implementierung erfordert eine präzise Kontrolle von Multiplen Qubits und komplexe Fehlermessungen. Im Gegenzug bietet der Code Robustheit. Der hohe Overhead in der Redundanz von 9 physikalischen Qubits für jedes logische Qubit bedeutet eine Herausforderung für die Skalierbarkeitsbemühungen.

## Modelle

Mit der Zeit sind von Forschern verschiedene Codemodelle entwickelt worden.
* Peter Shors 9-qubit-code, auch bekannt als der Shor-Code, verschlüsselt ein logisches Qubit in neun physikalische Qubits und kann beliebige Fehler an einem einzelnen Qubit korrigieren.
* Andrew Steane fand einen Code, der dasselbe mit 7 anstatt 9 Qubits macht (Steane-Code).
* Raymond Laflamme fand eine Klasse von 5-Qubit Codes, welche dasselbe machen, und welche auch die Eigenschaft besitzen, fehlertolerant zu sein.
* Eine Verallgemeinerung dieses Konzepts sind die CSS-Codes, benannt nach den Erfindern: Robert Calderbank, Peter Shor und Andrew Steane. Laut der Quanten-Hamming-Schranke, benötigt die Kodierung eines einzelnen logischen Qubits mit der Möglichkeit zur Korrektur beliebiger Ein-Qubit-Fehler ein Minimum von fünf physikalischen Qubits.
* Eine allgemeinere Klasse von Codes sind die Stabilizer-Codes, entdeckt von Daniel Gottesman, und von Calderbank und Shor zusammen mit Eric Rains und Neil Sloane; diese werden additive Codes genannt.
* Eine neuere Idee sind Alexei Kitajews Topologische Quantencodes und die allgemeinere Idee von topologischen Quantencomputern.
Diese Codes erlauben allerdings Quantencomputing mit beliebiger Länge und sind Inhalt des Grenzwert-Theorems, begründet von Michael Ben-Or und Dorit Aharonov, welches behauptet, dass man alle Fehler korrigieren kann, wenn man Quanten-Codes verkettet, wie die CSS-Codes, das heißt jedes logische Qubit mit demselben Code wieder verschlüsseln, und so weiter, auf logarithmisch vielen Stufen—„liefert“ die Fehlerrate von individuellen Quantengattern unter einem bestimmten Grenzwert; würde man hingegen für größere Fehlerraten versuchen, die Syndrome zu messen und Fehler zu korrigieren, würden mehr neue Fehler einfließen als korrigiert werden.
2004 wurde von Emanuel Knill für diesen Grenzwert geschätzt, dass er bei 1–3 % liegen könnte, sofern ausreichend viele Qubits vorhanden sind.

## Experimentelle Realisierung

2022 haben Forscher einen fehlertoleranten universellen Satz von Gattern für zwei logische Qubits in einem Quantencomputer mit 16 gefangenen Ionen demonstriert. Die logischen Qubits wurden auf jeweils sieben Atome verteilt. Auf diesen haben die Physiker zwei Rechengatter realisiert, die für einen universellen Gattersatz notwendig sind: ein CNOT-Gatter und ein logisches T-Gatter.