Quanten-Fehlerkorrektur

Inhalt

1 Wozu braucht man eine Quanten-Fehlerkorrektur?

2 Klassische Fehler vs. Quanten-Fehler

3 Fehlerkorrektur zur Behebung von Bitflip-Fehlern

4 Shor’s quantum error-correcting code

5 „Kleine Fehler“

6 Ein Code zur Behebung von Phasen-Fehlern

7 Einige Eigenschaften von fehlerkorrigierenden Codes

8 Die Quantum Hamming Bound

9 Zusammenfassung und Ausblick

10 Literatur- und Quellenverzeichnis

1 Wozu braucht man eine Quanten-Fehlerkorrektur?

Es hat sich in den letzten Jahren gezeigt, dass man unter Ausnutzung quantenmechanischer Eigenschaften bestimmte Rechnungen auf Quanten-Computern im Vergleich zu klassischen Systemen deutlich beschleunigen kann. Obwohl die These, dass Quanten-Computer von klassischen Computern nicht in Polynomialzeit simuliert werden können, bisher unbewiesen ist, so deuten doch viele Erkenntnisse hierauf hin.

Was aber bei den bisher vorgestellten Quanten-Algorithmen immer stillschweigend vorausgesetzt wurde ist, dass in der Rechnung alle Operationen fehlerfrei ausgeführt werden bzw. die Fehlerwahrscheinlichkeit so gering ist, dass man sie vernachlässigen kann. Dies trifft vielleicht bei klassischen Systemen zu, die durch Verstärkung und Dissipation eine bemerkenswert hohe Stabilität erreichen, bei quantenmechanischen Systemen hingegen verhält es sich aber komplett anders.

Quanten-Rechner sind extrem anfällig gegen Rauschen und unpräzise Operationen. Zudem sind klassische Methoden zur Stabilisierung wie Dissipation und Verstärkung auf Quantenebene nicht anwendbar. Zusammengefasst heißt das, Fehler sind unvermeidbar und treten schon nach relativ kurzer Rechenzeit auf.Die Hauptursache für Quantenfehler sind Wechselwirkungen mit der Umgebung. Da Quanten-Computer nicht vollständig von der Umgebung isoliert werden können, ist das sogenannte Phänomen der Dekohärenz unvermeidbar. Lange Rechnungen sind also ohne weiteres nicht durchführbar auf Quanten-Computern, da früher oder später die Dekohärenz die im Quantenspeicher codierte Information zerstört. Der Ausweg heißt hier Quanten-Fehlerkorrektur. Fehlerkorrekturalgorithmen sind bereits bekannt aus klassischen Computersystemen und werden hier zum Beispiel benutzt um Informationen sicher über einen stark rauschbehafteten Kanal (noisy channel) zu transportieren. Solche Algorithmen können angepasst werden an die speziellen Eigenschaften quantenmechanischer Systeme und so die Fehlerwahrscheinlichkeit für Quantenspeicher senken.

Zusammenfassend lässt sich vor diesem Hintergrund also festhalten, dass Quanten-Fehlerkorrektur-Algorithmen praktisch unerlässlich sind, um irgendwelche längeren Berechungen auf Quanten-Computern sicher durchführen zu können.

2 Klassische Fehler vs. Quanten-Fehler

Um Fehler korrigieren zu können, sollte man zunächst mal wissen, welche Fehler überhaupt auftreten können. Bei einem klassischen Computer ist diese Frage einfach zu beantworten. Da alle Informationen in Ketten von Bits codiert sind brauchen wir nur ein einziges Bit exemplarisch zu betrachten: Ein Bit kann den Zustand 0 oder 1 haben. Insofern gibt es auch nur 2 mögliche Fehler bzw. lediglich eine Fehlerart. Eine 1 kann fälschlicherweise durch nicht näher bestimmte Umstände in den Zustand 0 kippen und umgekehrt kann ebenso eine 0 auf 1 kippen. Diese Art von Fehlern bezeichnet man als Bitflip-Fehler.

Bei Quanten-Computern hingegen stellt sich dieser Sachverhalt nicht so einfach dar. Zwar werden Informationen ähnlich wie im klassischen Fall als Ketten von QuBits dargestellt, die das Analogon zum klassischen Bit bilden, jedoch nehmen diese kleinsten Informationseinheiten nicht nur den Zustand 0 oder 1 an, sondern sind mathematisch gesehen nichts anderes als 2-dimensionale komplexe Vektoren bezüglich einer Orthonormal-Basis {|0>, |1>}. Ein QuBit |Y> lässt sich also zum Beispiel folgendermaßen darstellen: |Y>=a|0>+b|1>, wobei a, b Î C. Unsere klassischen BitFlip-Fehler findet man hier auch wieder: Aus dem QuBit |0> kann fälschlicherweise das QuBit |1> werden und ebenso kann die |1> auf |0> flippen. Darüber hinaus können sogenannte Phasen-Fehler auftreten, für die es im klassischen Fall kein Analogon gibt. Hierbei wird aus |0> |0> und aus |1> -|1> oder genauer: Die Superposition a|0>+b|1> wird transformiert in einen orthogonalen Zustand a|0>-b|1>. Ein weiteres Problem sind „kleine Fehler“: Da die Quanten-Information kontinuierlich ist, ist es möglich, dass ein QuBit, das im Zustand |000> sein sollte, durch nicht näher bestimmte Einflüsse zum Beispiel in einen Zustand |000>+e|010> (bzw. |111> Þ |111>-e|101>) wechselt, wobei e eine betragsmäßig „kleine“ Zahl ist. Bei ungünstigen Entwicklungen im Verlauf einer Rechung können sich diese kleinen Fehler akkumulieren und die stetig steigende Wahrscheinlichkeit eines „großen“ Bitflip-Fehlers wird zu einem Problem werden.

3 Fehlerkorrektur zur Behebung von Bitflip-Fehlern

Jetzt, wo wir wissen mit welchen Fehlern wir es zu tun haben, können wir uns darüber Gedanken machen, wie wir diese vermeiden oder zumindest korrigieren können. Da wir nicht in der Lage sind, Fehler mit 100% Sicherheit zu vermeiden und dies auch zu weit in die hardwaretechnische Umsetzung geht, beschränken wir uns auf die Korrektur von bereits entstandenen Fehlern. Schauen wir uns zunächst die Art von Fehlern an, die wir auch schon vom klassischen Fall her kennen: Bitflip-Fehler. Das Korrigieren eines derartigen Fehlers im klassischen Fall stellt sich höchst einfach dar: Man flippt einfach das fehlerhafte Bit und hat damit den Fehler korrigiert. Dies ist deshalb so einfach weil es nur 2 Zustände gibt: Eine 1 die eigentlich eine 0 sein sollte können wir also reparieren durch Flippen der 1 auf 0. Umgekehrt geht es natürlich genauso. Die Frage, die sich aber in diesem Zusammenhang stellt, ist folgende: Woher wissen wir überhaupt, ob ein spezielles Bit fehlerhaft ist oder nicht? Die Antwort: Ohne zusätzliche Informationen über die zu schützenden Informationen hinaus zu speichern, können wir Fehler nicht erkennen. Wir müssen also zusätzliche Informationen speichern (in denen selbstverständlich weitere Fehler auftreten können), mit Hilfe derer wir erkennen können, ob sich ein Fehler eingeschlichen hat und, wenn dem so ist, auch wo.

Ein einfacher Fehlerkorrektur-Code für klassische Computer sieht folgendermaßen aus:

Die zu schützende Information bestehe aus lediglich einem Bit. Dies kann 0 oder 1 sein. Als zusätzliche Information die wir später zur Korrektur eines möglichen Fehler benutzen wollen, fügen wir zu diesem Bit noch 2 weitere hinzu, die den gleichen Zustand haben:

Abbildung in dieser Leseprobe nicht enthalten

Kippt nun das Bit (z.B. die 0 im ersten Fall auf 1), so haben wir im ungeschützten Fall die Information verloren, weil wir ja nicht wissen ob ein Fehler aufgetreten ist. Kippt eines der 3 Bits im geschützen Fall, z.B. das zweite, so ergibt sich folgende Situation:

Abbildung in dieser Leseprobe nicht enthalten

Unter der Annahme, dass wirklich nur ein Bit gekippt ist können wir die Information wiederherstellen, indem wir die 3 Bits 010 betrachten, darauf die Majoritätsfunktion anwenden, die als Ergebnis 0 liefert, und konsequenterweise die 1 in eine 0 flippen:

Abbildung in dieser Leseprobe nicht enthalten

Probleme treten auf, wenn in den 3 Bits 2 oder gleich alle 3 Bits aufgrund eines Fehlers flippen. Durch die Fehlerkorrektur würden wir dann also praktisch die Fehler begünstigen und das einzige richtige Bit (im Falle von 2 gekippten Bits) auch noch auf den falschen Wert flippen und vermeintlicherweise das Bit korrigiert haben.

[...]