Der 9-Qubit-Shor-Code

Nun wenden wir uns dem 9-Qubit-Shor-Code zu, einem quantenfehlerkorrigierenden Code, der durch die Kombination der beiden im vorherigen Abschnitt betrachteten Codes entsteht: dem 3-Bit-Wiederholungscode für Qubits, der die Korrektur eines einzelnen Bit-Flip-Fehlers ermöglicht, und der modifizierten Version dieses Codes, die die Korrektur eines einzelnen Phasen-Flip-Fehlers ermöglicht.

Codebeschreibung

Der 9-Qubit-Shor-Code ergibt sich durch Verkettung der beiden Codes aus dem vorherigen Abschnitt. Das bedeutet, dass wir zunächst eine Kodierung anwenden, die ein Qubit in drei kodiert, und dann die andere Kodierung auf jedes der drei Qubits aus der ersten Kodierung anwenden, was insgesamt neun Qubits ergibt.

Genauer gesagt, obwohl wir die beiden Codes in diesem speziellen Fall in beliebiger Reihenfolge anwenden könnten, wählen wir, zuerst die modifizierte Version des 3-Bit-Wiederholungscodes anzuwenden (der Phasen-Flip-Fehler erkennt), und dann jedes der drei resultierenden Qubits unabhängig mit dem ursprünglichen 3-Bit-Wiederholungscode (der Bit-Flip-Fehler erkennt) zu kodieren. Hier ist eine Schaltkreisdiagramm-Darstellung dieser Kodierung.

Wie die Abbildung andeutet, werden wir die neun Qubits des Shor-Codes als in drei Blöcke zu je drei Qubits gruppiert betrachten, wobei jeder Block aus dem zweiten Kodierungsschritt (dem gewöhnlichen 3-Bit-Wiederholungscode) erhalten wird. Der gewöhnliche 3-Bit-Wiederholungscode, der hier dreimal unabhängig angewendet wird, wird in diesem Kontext als innerer Code bezeichnet, während der äußere Code der Code ist, der für den ersten Kodierungsschritt verwendet wird: die modifizierte Version des 3-Bit-Wiederholungscodes, der Phasen-Flip-Fehler erkennt.

Alternativ können wir den Code spezifizieren, indem wir beschreiben, wie die beiden Standardbasiszustände unseres ursprünglichen Qubits kodiert werden.

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[4mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

Sobald wir das wissen, können wir durch Linearität bestimmen, wie ein beliebiger Qubit-Zustandsvektor kodiert wird.

Korrektur von Bit-Flip- und Phasen-Flip-Fehlern

Fehler und CNOT-Gates

Um zu analysieren, wie $X$- und $Z$-Fehler Kodierungen von Qubits beeinflussen – sowohl für den 9-Qubit-Shor-Code als auch für andere Codes –, ist es hilfreich, einige einfache Beziehungen zwischen diesen Fehlern und CNOT-Gates zu beachten. Zu Beginn der Analyse des 9-Qubit-Shor-Codes ist es ein guter Moment, dies zu tun.

Die folgenden Schaltkreisdiagramme veranschaulichen drei grundlegende Beziehungen zwischen $X$-Gates und CNOT-Gates. Konkret: Das Anwenden eines $X$-Gates auf das Ziel-Qubit vor einem CNOT entspricht dem Vertauschen der Reihenfolge und dem Durchführen des CNOT zuerst, aber das Anwenden eines $X$-Gates auf das Kontroll-Qubit vor einem CNOT entspricht dem Anwenden von $X$-Gates auf beide Qubits nach dem CNOT. Schließlich entspricht das Anwenden von $X$-Gates auf beide Qubits vor einem CNOT dem Durchführen des CNOT zuerst und dann dem Anwenden eines $X$-Gates auf das Kontroll-Qubit. Diese Beziehungen können durch die erforderlichen Matrixmultiplikationen oder durch die Berechnung der Wirkung der Schaltkreise auf Standardbasiszustände verifiziert werden.

Die Situation ist für $Z$-Gates ähnlich, außer dass die Rollen des Kontroll- und Ziel-Qubits wechseln. Insbesondere haben wir die drei Beziehungen, die durch die folgenden Quantenschaltkreise dargestellt werden.

Korrektur von Bit-Flip-Fehlern

Nun betrachten wir, wie Fehler mithilfe des 9-Qubit-Shor-Codes erkannt und korrigiert werden können, beginnend mit Bit-Flip-Fehlern – die wir der Kürze halber fortan als $X$-Fehler bezeichnen.

Um $X$-Fehler zu erkennen und zu korrigieren, können wir jeden der drei Blöcke in der Kodierung separat behandeln. Jeder Block ist eine Kodierung eines Qubits mit dem 3-Bit-Wiederholungscode, der gegen $X$-Fehler schützt – indem wir also die zuvor beschriebenen Syndrom-Messungen und $X$-Fehlerkorrekturen auf jeden Block anwenden, können wir bis zu einem $X$-Fehler pro Block erkennen und korrigieren. Wenn also höchstens ein $X$-Fehler auf den neun Qubits der Kodierung vorliegt, wird dieser Fehler durch dieses Verfahren erkannt und korrigiert.

Kurz gesagt: Die Korrektur von Bit-Flip-Fehlern ist für diesen Code einfach, da der innere Code Bit-Flip-Fehler korrigiert.

Korrektur von Phasen-Flip-Fehlern

Als nächstes betrachten wir Phasen-Flip-Fehler, oder kurz $Z$-Fehler. Diesmal ist nicht ganz so klar, was zu tun ist, da der äußere Code derjenige ist, der $Z$-Fehler erkennt, aber der innere Code scheint irgendwie „im Weg" zu sein, wodurch die Erkennung und Korrektur dieser Fehler etwas schwieriger wird.

Angenommen, ein $Z$-Fehler tritt auf einem der 9 Qubits des Shor-Codes auf, wie es in diesem Diagramm dargestellt ist.

Wir haben bereits beobachtet, was passiert, wenn ein $Z$-Fehler auftritt, während wir den 3-Bit-Wiederholungscode verwenden – er entspricht einem $Z$-Fehler, der vor der Kodierung auftritt. Im Kontext des 9-Qubit-Shor-Codes bedeutet das, dass ein $Z$-Fehler auf jedem der drei Qubits innerhalb eines Blocks immer denselben Effekt hat, der einem $Z$-Fehler auf dem entsprechenden Qubit vor der Anwendung des inneren Codes entspricht.

Das obige Schaltkreisdiagramm ist beispielsweise äquivalent zum folgenden Diagramm. Dies kann mithilfe der oben beschriebenen Beziehungen zwischen $Z$ und CNOT-Gates begründet werden, oder einfach indem man die Schaltkreise auf einem beliebigen Qubit-Zustand $\vert\psi\rangle$ auswertet.

Das deutet auf eine Möglichkeit zur Erkennung und Korrektur von $Z$-Fehlern hin: den inneren Code zu dekodieren, sodass wir die drei Qubits der äußeren Kodierung zusammen mit sechs initialisierten Workspace-Qubits erhalten. Wir können dann diese drei Qubits des äußeren Codes auf $Z$-Fehler prüfen und schließlich mit dem inneren Code wieder kodieren, um zur 9-Qubit-Kodierung zurückzukehren, die wir vom Shor-Code erhalten. Wenn wir einen $Z$-Fehler erkennen, können wir ihn entweder vor dem erneuten Kodieren mit dem inneren Code korrigieren oder danach, indem wir ein $Z$-Gate auf eines der Qubits in diesem Block anwenden.

Hier ist ein Schaltkreisdiagramm, das den Kodierschaltkreis und den oben angedeuteten Fehler zusammen mit den gerade beschriebenen Schritten enthält (aber nicht den eigentlichen Korrekturschritt).

In diesem konkreten Beispiel ist das Syndrom-Messergebnis $11$, was den $Z$-Fehler als in einem der Qubits im mittleren Block aufgetreten identifiziert.

Ein Vorteil der Korrektur von $Z$-Fehlern nach dem erneuten Kodierungsschritt statt davor ist, dass der obige Schaltkreis vereinfacht werden kann. Der folgende Schaltkreis ist äquivalent, benötigt aber vier CNOT-Gates weniger.

Auch hier gibt das Syndrom nicht an, welches Qubit von einem $Z$-Fehler betroffen ist, sondern welcher Block einen $Z$-Fehler erfahren hat, wobei der Effekt unabhängig davon derselbe ist, welches Qubit innerhalb des Blocks betroffen war. Wir können den Fehler dann korrigieren, indem wir ein $Z$-Gate auf eines der drei Qubits des betroffenen Blocks anwenden.

Übrigens sehen wir hier ein Beispiel für Degeneriertheit in einem quantenfehlerkorrigierenden Code: Wir können bestimmte Fehler (in diesem Fall $Z$-Fehler) korrigieren, ohne sie eindeutig identifizieren zu können.

Gleichzeitige Bit- und Phasen-Flip-Fehler

Wir haben nun gesehen, wie sowohl $X$- als auch $Z$-Fehler mithilfe des 9-Qubit-Shor-Codes erkannt und korrigiert werden können – insbesondere wie höchstens ein $X$-Fehler oder höchstens ein $Z$-Fehler erkannt und korrigiert werden kann. Nehmen wir nun an, dass sowohl ein Bit-Flip- als auch ein Phasen-Flip-Fehler auftreten, möglicherweise auf demselben Qubit. Es stellt sich heraus, dass in dieser Situation nichts anderes getan werden muss als das, was bereits besprochen wurde – der Code kann bis zu einen $X$-Fehler und einen $Z$-Fehler gleichzeitig erkennen und korrigieren, ohne weitere Modifikation.

Genauer gesagt werden $X$-Fehler durch die Anwendung der gewöhnlichen 3-Bit-Wiederholungscode-Syndrom-Messung erkannt, die separat auf jeden der drei Blöcke aus je drei Qubits angewendet wird; und $Z$-Fehler werden durch das gerade oben beschriebene Verfahren erkannt, was dem Dekodieren des inneren Codes, der Durchführung der Syndrom-Messung für den modifizierten 3-Bit-Wiederholungscode für Phasen-Flips und dann dem erneuten Kodieren entspricht. Diese beiden Fehlererkennungsschritte – sowie die entsprechenden Korrekturen – können völlig unabhängig voneinander durchgeführt werden, und es spielt tatsächlich keine Rolle, in welcher Reihenfolge sie durchgeführt werden.

Um zu verstehen, warum das so ist, betrachte das folgende Schaltkreisdiagramm, in dem sowohl ein $X$- als auch ein $Z$-Fehler das unterste Qubit des mittleren Blocks beeinflusst haben.

Zuerst stellen wir fest, dass die Reihenfolge der Fehler keine Rolle spielt, in dem Sinne, dass das Vertauschen der Position der $X$- und $Z$-Fehler einen äquivalenten Schaltkreis ergibt. Dabei ist klar: $X$ und $Z$ kommutieren nicht, sie antikommutieren:

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

Das impliziert, dass der folgende Schaltkreis äquivalent zu dem eben gezeigten ist, bis auf einen globalen Phasenfaktor von $-1$.

Wir können den $Z$-Fehler jetzt wie zuvor verschieben, um einen weiteren äquivalenten Schaltkreis zu erhalten.

Zu diesem Zeitpunkt ist es offensichtlich: Wenn das Verfahren zur Erkennung und Korrektur von $X$-Fehlern zuerst durchgeführt wird, wird der $X$-Fehler korrigiert, wonach das Verfahren zur Erkennung und Korrektur von $Z$-Fehlern wie zuvor durchgeführt werden kann, um den $Z$-Fehler zu beseitigen.

Alternativ kann das Verfahren zur Erkennung und Korrektur von $Z$-Fehlern zuerst durchgeführt werden. Die Tatsache, dass dieses Verfahren wie erwartet funktioniert, auch in Gegenwart eines oder mehrerer $X$-Fehler, folgt daraus, dass $X$-Gates auf jedem der neun Qubits der Kodierung mit allen Gates in unserem vereinfachten Schaltkreis zur Messung des Syndroms für $Z$-Fehler kommutieren. Daher wird diese Syndrom-Messung den Block, der von einem $Z$-Fehler betroffen ist, immer noch korrekt identifizieren. Die Tatsache, dass ein $Z$-Fehler auf jedem Block durch Anwenden eines $Z$-Gates auf jedes Qubit dieses Blocks korrigiert wird, selbst wenn auch ein $X$-Fehler aufgetreten ist, folgt aus demselben Argument wie oben bezüglich der Reihenfolge von $X$- und $Z$-Gates, das uns äquivalente Schaltkreise bis auf einen globalen Phasenfaktor liefert.

Es folgt, dass der 9-Qubit-Shor-Code einen $X$-Fehler, einen $Z$-Fehler oder beides auf jedem der neun Qubits dieses Codes korrigieren kann. Tatsächlich können wir mehr Fehler als das korrigieren, einschließlich mehrerer $X$-Fehler (solange sie auf verschiedene Blöcke fallen) oder mehrerer $Z$-Fehler (solange höchstens ein Block eine ungerade Anzahl davon erfährt) – aber für die Zwecke dieser Lektion ist am relevantesten, dass wir einen $X$-Fehler, einen $Z$-Fehler oder beides auf jedem Qubit korrigieren können.

Fehlerreduktion bei zufälligen Fehlern

Bevor wir zum letzten Abschnitt der Lektion übergehen, der sich mit beliebigen Quantenfehlern befasst, betrachten wir kurz die Leistung des 9-Qubit-Shor-Codes, wenn durch Pauli-Matrizen dargestellte Fehler zufällig auf den Qubits auftreten.

Konkreter betrachten wir ein einfaches Rauschmodell, bei dem Fehler unabhängig auf den Qubits auftreten, wobei jedes Qubit mit Wahrscheinlichkeit $p$ einen Fehler erfährt und keine Korrelation zwischen Fehlern auf verschiedenen Qubits besteht – ähnlich wie bei einem binären symmetrischen Kanal für klassische Bits. Wir könnten unterschiedliche Wahrscheinlichkeiten für das Auftreten von $X$-, $Y$- und $Z$-Fehlern zuweisen, aber um die Dinge so einfach wie möglich zu halten, betrachten wir den schlimmsten Fall für den 9-Qubit-Shor-Code, nämlich dass ein $Y$-Fehler auf jedem der betroffenen Qubits auftritt. Ein $Y$-Fehler ist übrigens äquivalent (bis auf einen irrelevanten globalen Phasenfaktor) dazu, dass sowohl ein $X$- als auch ein $Z$-Fehler auf demselben Qubit auftreten, da $Y = iXZ.$ Das erklärt unsere scheinbare Vernachlässigung von $Y$-Fehlern bis zu diesem Punkt.

Nehmen wir nun an, dass $\mathsf{Q}$ ein Qubit in einem bestimmten Zustand ist, den wir gegen Fehler schützen möchten, und betrachten wir die Option, den 9-Qubit-Shor-Code zu verwenden. Eine natürliche Frage lautet: „Sollten wir ihn verwenden?"

Die Antwort ist nicht unbedingt „ja". Wenn es zu viel Rauschen gibt – in diesem Kontext bedeutet das, dass $p$ zu groß ist –, könnte die Verwendung des Shor-Codes die Dinge sogar verschlechtern – genau wie der 3-Bit-Wiederholungscode schlechter als kein Code ist, wenn $p$ größer als ein Halb ist. Aber wenn $p$ klein genug ist, lautet die Antwort „ja", wir sollten den Code verwenden, weil er die Wahrscheinlichkeit verringert, dass der kodierte Zustand verfälscht wird. Schauen wir uns an, warum das so ist und was es bedeutet, dass $p$ für diesen Code zu groß oder klein genug ist.

Der Shor-Code korrigiert jeden Pauli-Fehler auf einem einzelnen Qubit, einschließlich eines $Y$-Fehlers natürlich, aber er korrigiert zwei oder mehr $Y$-Fehler nicht ordnungsgemäß. Um das klarzustellen: Wir gehen davon aus, dass wir die $X$- und $Z$-Fehlerkorrekturen verwenden, die früher im Abschnitt beschrieben wurden. (Natürlich würden wir, wenn wir im Voraus wüssten, dass wir uns nur um $Y$-Fehler sorgen müssen, unsere Korrekturen entsprechend anders wählen – aber das würde das Rauschmodell austricksen, und wir könnten das Modell immer durch die Auswahl anderer Pauli-Fehler ändern, um diese neue Wahl von Korrekturen zu Fall zu bringen, wenn zwei oder mehr Qubits von Fehlern betroffen sind.)

Der Code schützt $\mathsf{Q}$ also solange, wie höchstens eines der neun Qubits von einem Fehler betroffen ist, was mit Wahrscheinlichkeit

$$(1-p)^9 + 9 p (1-p)^8$$

eintritt.

Andernfalls versagt der Code mit Wahrscheinlichkeit

$$1 - (1-p)^9 - 9 p (1-p)^8$$

beim Schutz von $\mathsf{Q}.$

Konkret bedeutet das in diesem Kontext, dass – bis auf einen globalen Phasenfaktor – eine nicht-identische Pauli-Operation auf unser Qubit $\mathsf{Q}$ (als logisches Qubit) angewendet wird. Das heißt: Wenn $X$- und $Z$-Fehler für den Shor-Code wie früher in der Lektion beschrieben erkannt und korrigiert werden, bleiben wir mit der Kodierung eines Zustands zurück, der – bis auf einen globalen Phasenfaktor – äquivalent zur Kodierung einer nicht-identischen Pauli-Operation auf den ursprünglichen Zustand von $\mathsf{Q}$ ist. Kürzer ausgedrückt: Es ist ein logischer Fehler aufgetreten. Das mag sich auf den ursprünglichen Zustand von $\mathsf{Q}$ auswirken oder auch nicht – oder mit anderen Worten, auf das logische Qubit, das wir mit neun physischen Qubits kodiert haben –, aber für diese Analyse betrachten wir dieses Ereignis als Versagen.

Wenn wir den Code andererseits gar nicht verwenden, würde unser einziges Qubit ein ähnliches Schicksal (dem Unterliegen einer nicht-identischen Pauli-Operation) mit Wahrscheinlichkeit $p$ erleiden. Der Code hilft, wenn die erste Wahrscheinlichkeit kleiner als die zweite ist:

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

Hier ist ein Diagramm, das für sehr kleine Werte von $p$ zeigt, dass der Code einen Vorteil bietet, wobei der Break-Even-Punkt bei etwa $0{,}0323$ liegt.

Wenn $p$ kleiner als dieser Break-Even-Punkt ist, hilft der Code; am Break-Even-Punkt sind die Wahrscheinlichkeiten gleich, sodass wir bei Verwendung des Codes nur Zeit und 8 Qubits verschwenden; und jenseits des Break-Even-Punkts sollten wir diesen Code absolut nicht verwenden, weil er die Wahrscheinlichkeit eines logischen Fehlers auf $\mathsf{Q}$ erhöht.

Etwas über drei Prozent mag kein besonders guter Break-Even-Punkt erscheinen, besonders im Vergleich zu $50\%$, was der analoge Break-Even-Punkt für den 3-Bit-Wiederholungscode für klassische Information ist. Dieser Unterschied liegt zu einem großen Teil daran, dass Quanteninformation empfindlicher und schwerer zu schützen ist als klassische Information. Aber auch – obwohl man anerkennt, dass der 9-Qubit-Shor-Code eine brillante Entdeckung darstellt, als der erste quantenfehlerkorrigierende Code der Welt – muss anerkannt werden, dass er praktisch betrachtet kein besonders guter Code ist.