Einführung in die Quantenfehlerkorrektur

In diesem Artikel werden die Grundlagen der Quantenfehlerkorrektur, die Arten von Quantenfehlern und einige gängige Quantenfehlerkorrekturcodes erläutert. Außerdem finden Sie ein Beispiel zum Beheben von Fehlern mithilfe des Drei-Qubit-Codes.

Was ist quantenfehlerkorrektur?

Quantum Error Correction (QEC) ist eine Technik, die es uns ermöglicht, Quanteninformationen vor Fehlern zu schützen. Die Fehlerkorrektur ist besonders wichtig bei Quantencomputern, da effiziente Quantenalgorithmen große Quantencomputer nutzen, die empfindlich auf Rauschen reagieren.

Das Grundprinzip hinter der Quantenfehlerkorrektur besteht darin, dass die Anzahl der Bits, die zum Codieren einer bestimmten Menge von Informationen verwendet werden, erhöht wird. Diese Redundanz ermöglicht es dem Code, Fehler zu erkennen und zu korrigieren.

Die Fehlerraten für Quantencomputer sind in der Regel höher als klassische Computerfehler aufgrund der Herausforderungen, die mit der Erstellung und dem Betriebssystem Quantensysteme verbunden sind. Rauschen, Decoherenz und Unvollkommenheiten in Quantentoren können Fehler in Quantenberechnungen verursachen. Aktuelle Quantencomputer haben Fehlerraten im Bereich von 1 % bis 0,1 %. Das bedeutet also, dass im Durchschnitt eine von 100 bis 1000 Quantentoroperationen zu einem Fehler führt.

Arten von Quantenfehlern

Es gibt zwei grundlegende Arten von Quantenfehlern: Bit-Flips und Phasen-Flips.

Bit-Flip-Fehler treten auf, wenn sich ein Qubit von $\ket{0}$ zu $\ket{1}$ oder umgekehrt ändert. Bit flip errors are also known as \sigma_x-errors, because they map the qubit states $\sigma_x={1}$\ket{\ket{0} and $\sigma_x .\ket{0}$\ket{={1}$$ Dieser Fehler entspricht einem klassischen Bit-Flip-Fehler.

Phasen-Flip-Fehler treten auf, wenn ein Qubit seine Phase ändert. Sie werden auch als \sigma_z fehler bezeichnet, da sie die Qubitzustände $\sigma_z\ket{\ket{0}{0}$= und $\sigma_z \ket{={1}-\ket{1}$zuordnen.$$ Diese Art von Fehler hat keine klassische Analogie.

Bei der Quantenberechnung können Quantenfehler als Bit-Flips, Phasendrehungen oder eine Kombination aus beiden manifestieren.

Wie funktioniert die Quantenfehlerkorrektur?

Quantenfehlerkorrekturcodes funktionieren durch Codieren der Quanteninformationen in eine größere Menge von Qubits, die als physische Qubits bezeichnet werden. Der Gemeinsame Zustand der physischen Qubits stellt einen logischen Qubit dar.

Die physischen Qubits unterliegen Fehlern aufgrund von Decoherenz und Unvollkommenheiten in Quantentoren. Der Code ist so konzipiert, dass Fehler erkannt und korrigiert werden können, indem einige der Qubits im Code gemessen werden.

Stellen Sie sich beispielsweise vor, Sie möchten die Single-Qubit-Nachricht $\ket{0}$senden. Sie können drei physische Qubits verwenden, um die Nachricht zu codieren, senden $\ket{000}$, die als Codewort bezeichnet wird. Dieser Fehlerkorrekturcode ist ein Wiederholungscode, da die Nachricht dreimal wiederholt wird.

Stellen Sie sich nun vor, dass während der Übertragung ein einzelner Bit-Flip-Fehler auftritt, sodass der Empfänger den Status $\ket{010}$erhält. In diesem Szenario kann der Empfänger möglicherweise ableiten, dass die beabsichtigte Nachricht ist $\ket{000}$. Wenn die Nachricht jedoch zwei Bit-Flip-Fehler aufweist, kann der Empfänger eine falsche Nachricht ableiten. Wenn schließlich alle drei Bits gekippt werden, damit die ursprüngliche Nachricht $\ket{000}$ wird $\ket{111}$, hat der Empfänger keine Möglichkeit zu wissen, dass ein Fehler aufgetreten ist.

Der Codeabstand eines QEC-Codes ist die minimale Anzahl von Fehlern, die ein Codewort in ein anderes ändern, d. h. die Anzahl der Fehler, die nicht erkannt werden können. Der Codeabstand $d$ kann wie folgt definiert werden:

$$d = 2t + 1$$

dabei $ist die$ Anzahl der Fehler, die der Code korrigieren kann. Beispielsweise kann der Drei-Bit-Code einen Bit-Flip-Fehler erkennen und korrigieren, also $t = 1$, und damit der Codeabstand ist $d = 3$.

Beachten Sie, dass Wiederholungscodes, z. B. der in diesem Beispiel verwendete Drei-Bit-Code, nur Bit-Flip-Fehler und nicht Phasen-Flip-Fehler korrigieren können. Um beide Arten von Fehlern zu korrigieren, sind komplexere Quantenfehlerkorrekturcodes erforderlich.

Typen von QEC-Codes

Es gibt viele verschiedene Arten von QEC-Codes mit jeweils eigenen Eigenschaften und Vorteilen. Einige gängige QEC-Codes sind:

• Wiederholungscode: Der einfachste Quantenfehlerkorrekturcode, bei dem ein einzelner Qubit in mehrere Qubits codiert wird, indem er mehrmals wiederholt wird. Der Wiederholungscode kann Bit-Flip-Fehler korrigieren, aber keine Phasen-Flip-Fehler.

• Shor-Code: Der erste von Peter Shor entwickelte Quantenfehlerkorrekturcode. Es codiert einen logischen Qubit in neun physische Qubits. Shor-Code kann einen Ein-Bit-Flip-Fehler oder einen Phasen-Flip-Fehler korrigieren, aber beide Fehlertypen können nicht gleichzeitig korrigiert werden.

• Steane-Code: Dies ist ein Sieben-Qubit-Code, der Sowohl Bit-Flip- als auch Phasen-Flip-Fehler korrigieren kann. Es hat den Vorteil, fehlertolerant zu sein, was bedeutet, dass der Fehlerkorrekturprozess selbst keine zusätzlichen Fehler verursacht.

• Surface-Code: Dies ist ein topologischer Fehlerkorrekturcode, der ein zweidimensionales Gitter von Qubits verwendet, um logische Qubits zu codieren. Es hat einen hohen Fehlerkorrekturschwellenwert und gilt als eine der vielversprechendsten Techniken für großflächige, fehlertolerante Quantencomputing. Der Oberflächencode wird vom Azure Quantum Resource Estimator verwendet.

• Hastings-Haah-Code: Dieser Quantenfehlerkorrekturcode bietet in vielen Regimen bessere Raumzeitkosten als Oberflächencodes auf Majorana-Qubits. Bei Gate-basierten Anweisungssätzen ist der Aufwand größer, wodurch dieser Ansatz weniger effizient ist als der Oberflächencode.

Beispiel: Der Drei-Qubit-Code

Der Drei-Qubit-Fehlerkorrekturcode ist ein einfacher Wiederholungscode, der einen Bit-Flip-Fehler erkennen und korrigieren kann. Es codiert ein einzelnes logisches Qubit in drei physische Qubits, indem er das Qubit dreimal wiederholt.

Tipp

Sehen Sie sich das Q# Codebeispiel für den Drei-Qubit-Code an.

Stellen Sie sich vor, Sie möchten ein beliebiges einzelnes Qubit $\ket{\phi}=\alpha\ket{{0} + \beta\ket{1}$senden. Um Fehler zu vermeiden, codieren Sie die Basiszustände $\ket{0}$ und $\ket{1}$ in einen gemeinsamen Zustand von drei Qubits. Die beiden logischen Basiszustände sind $\ket{0_L}=\ket{000}$ und $\ket{1_L.}=\ket{111}$

Daher wird das einzelne Qubit $\ket{\phi}={0}\alpha\ket{+ \beta\ket{1}$ wie folgt codiert:

$$\ket{\phi}{000}\ket{\alpha=_L + \beta\ket{\ket{\alpha{111}=0_L} + 1_L \beta\ket{}$$

Lassen Sie uns die Schritte des Drei-Qubit-Codes aufschlüsseln.

Vorbereiten der Qubits

Zuerst codieren Sie Ihr einzelnes Qubit $\ket{\phi}=\alpha\ket{{0} +\beta\ket{1}$ in einen gemeinsamen Zustand von drei Qubits.

Als Nächstes bereiten Sie zwei weitere Qubits im Zustand $\ket{0}$vor. Der globale Zustand aller drei Qubits lautet $also (\alpha\ket{0} +\beta\ket{1}){000}\alpha\ket{\ket{0}\ket{0}= + . \beta\ket{{100}$

Schließlich codieren Sie den einzelnen Qubit in einen gemeinsamen Zustand von drei Qubits, indem Sie zwei CNOT-Vorgänge anwenden. Der erste CNOT verwendet den ersten Qubit als Kontrolle und fungiert auf dem zweiten Qubit, wodurch + \beta\ket{110}$erzeugt $\alpha\ket{000} wird. Der zweite CNOT verwendet den ersten Qubit als Kontrolle und fungiert auf dem dritten Qubit. Der Zustand der drei Qubits ist jetzt $\alpha\ket{000} + \beta\ket{111}$.

Senden der Qubits

Sie senden alle drei Qubits. Wenn nur Ein-Bit-Flip-Fehler auftreten können, befinden sich die empfangenen Qubits in einem der folgenden Zustände:

Staat	Fehler
$\alpha\ket{000} + \beta\ket{111}$	Kein Fehler
$\alpha\ket{100} + \beta\ket{011}$	Qubit 1
$\alpha\ket{010} + \beta\ket{101}$	Qubit 2
$\alpha\ket{001} + \beta\ket{110}$	Qubit 3

Hinzufügen von Hilfs-Qubits

Zuerst stellen Sie zwei weitere Qubits vor, die im Zustand $\ket{00}$vorbereitet sind. Diese Hilfspaare von Qubits werden verwendet, um Informationen des Fehlers zu extrahieren, ohne direkt zu messen oder Informationen über den logischen Zustand zu erhalten.

Als Nächstes führen Sie vier CNOT-Vorgänge aus: Die ersten beiden Vorgänge verwenden die ersten und zweiten empfangenen Qubits als Kontrolle und reagieren auf den ersten Hilfs-Qubit, und die letzten beiden Vorgänge verwenden die ersten und dritten empfangenen Qubits als Kontrolle und wirken auf das zweite Hilfsbit. Der Gesamtzustand aller fünf Qubits ist jetzt:

Staat	Fehler
$(\alpha\ket{000} + \beta\ket{111})\ket{00}$	Kein Fehler
$(\alpha\ket{100} + \beta\ket{011})\ket{11}$	Qubit 1
$(\alpha\ket{010} + \beta\ket{101})\ket{10}$	Qubit 2
$(\alpha\ket{001} + \beta\ket{110})\ket{01}$	Qubit 3

Abrufen des Fehlersyndroms

Um die Fehlerinformationen abzurufen, messen Sie die beiden Hilfs-Qubits in den Berechnungsbasiszuständen $\ket{0}$ und $\ket{1}$. Dadurch wiederherstellen Sie den Gelenkzustand, der als Fehlersyndrom bezeichnet wird, da es hilft, die Fehler in den empfangenen Qubits zu diagnostizieren.

Nun wissen Sie, in welchen der vier möglichen Zustände sich die drei empfangenen Qubits befinden. Sie können den Fehler korrigieren, indem Sie den Korrekturvorgang anwenden. In diesem Fall behandeln Sie Bit-Flip-Fehler, sodass die Korrektur ein $\sigma_x$ Vorgang ist, der auf einen (oder keine) der Qubits angewendet wird.

Wenn z. B. das Fehlersyndrom lautet $\ket{00}$, befinden sich die empfangenen Qubits im Zustand $\alpha\ket{{000} + \beta\ket{{111}$, was der Zustand ist, den Sie ursprünglich gesendet haben. Wenn das Fehlersyndrom ist $\ket{11}$, dann befinden sich die empfangenen Qubits im Zustand $\alpha\ket{{100} + b\ket{{011}$. Es gibt einen Bit-Flip-Fehler auf dem ersten Qubit, den Sie korrigieren können, indem Sie einen $\sigma_x$ Vorgang auf den ersten Qubit anwenden.

Fehlersyndrom	Reduzieren des Zustands	Berichtigung
$\ket{00}$	$\alpha\ket{000} + \beta\ket{111}$	Keine Maßnahmen
$\ket{01}$	$\alpha\ket{100} + \beta\ket{011}$	Anwenden von $\sigma_x$ auf Qubit 3
$\ket{10}$	$\alpha\ket{010} + \beta\ket{101}$	Anwenden von $\sigma_x$ auf Qubit 2
$\ket{11}$	$\alpha\ket{001} + \beta\ket{110}$	Anwenden von $\sigma_x$ auf Qubit 1

Extrahieren des ursprünglichen Qubits

Zum Extrahieren des ursprünglich übertragenen einzelnen Qubits wenden Sie zwei CNOT-Vorgänge an: eine verwendet den ersten Qubit als Kontrolle und fungiert auf dem zweiten Qubit, und andere verwendet den ersten Qubit als Steuerelement und fungiert auf dem dritten.

Der Zustand des ersten Qubits ist jetzt $\alpha\ket{0} + \beta\ket{1}$, die ursprüngliche Qubit, die Sie übertragen möchten.

Wichtig

Der QEC-Code erhält keine Informationen zu den Koeffizienten $\alpha$ und $\beta$somit Überlagerungen des Berechnungszustands bleiben während der Korrektur intakt.