Stabilizer-Codes

Jetzt werden wir Stabilizer-Codes im Allgemeinen definieren. Wir besprechen auch einige ihrer grundlegenden Eigenschaften und wie sie funktionieren – darunter, wie Zustände kodiert werden und wie Fehler mit diesen Codes erkannt und korrigiert werden.

Definition von Stabilizer-Codes

Ein $n$-Qubit-Stabilizer-Code wird durch eine Liste von $n$-Qubit-Pauli-Operationen $P_1,\ldots,P_r$ beschrieben. Diese Operationen werden in diesem Kontext als Stabilizer-Generatoren bezeichnet und müssen die folgenden drei Eigenschaften erfüllen.

1. Die Stabilizer-Generatoren kommutieren paarweise miteinander.

   $$P_j P_k = P_k P_j \qquad \text{(für alle $j,k\in\{1,\ldots,r\}$)}$$

2. Die Stabilizer-Generatoren bilden ein minimales Erzeugendensystem.

   $$P_k \notin \langle P_1,\ldots,P_{k-1},P_{k+1},\ldots,P_r\rangle \qquad \text{(für alle $k\in\{1,\ldots,r\}$)}$$

3. Mindestens ein Quantenzustandsvektor wird von allen Stabilizer-Generatoren fixiert.

   $$-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle$$

   (Es ist nicht offensichtlich, dass die Existenz eines Quantenzustandsvektors $\vert\psi\rangle$, der von allen Stabilizer-Generatoren fixiert wird – also $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle$ –, äquivalent zu $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle$ ist. Tatsächlich ist das aber der Fall, und wir werden später in der Lektion sehen, warum.)

Wenn wir eine solche Liste $P_1,\ldots,P_r$ haben, ist der Code-Raum, der durch diese Stabilizer-Generatoren definiert wird, der Unterraum $\mathcal{C}$, der alle $n$-Qubit-Quantenzustandsvektoren enthält, die von allen $r$ Stabilizer-Generatoren fixiert werden.

$$\mathcal{C} = \bigl\{ \vert\psi\rangle \,:\, P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle \bigr\}$$

Quantenzustandsvektoren in diesem Unterraum sind genau diejenigen, die als gültige Kodierungen von Quantenzuständen betrachtet werden können. Den eigentlichen Kodierungsprozess besprechen wir später.

Der Stabilizer des Codes, der durch die Stabilizer-Generatoren $P_1, \ldots, P_r$ definiert wird, ist die von diesen Operationen erzeugte Menge:

$$\langle P_1,\ldots,P_r\rangle.$$

Eine natürliche Sichtweise auf einen Stabilizer-Code ist es, die Stabilizer-Generatoren als Observablen zu betrachten und die Messergebnisse dieser Observablen gemeinsam als Fehlersyndrom zu interpretieren. Gültige Kodierungen sind $n$-Qubit-Quantenzustandsvektoren, bei denen die Messergebnisse als Eigenwerte garantiert alle $+1$ sind. Jedes andere Syndrom, bei dem mindestens ein $-1$ auftritt, zeigt an, dass ein Fehler erkannt wurde.

Wir schauen uns gleich mehrere Beispiele an, aber zunächst noch einige Anmerkungen zu den drei Bedingungen für Stabilizer-Generatoren.

Die erste Bedingung ist naheliegend, wenn man die Stabilizer-Generatoren als Observablen interpretiert: Sie impliziert, dass die Reihenfolge der Messungen keine Rolle spielt – die Observablen kommutieren, also kommutieren auch die Messungen. Das legt bestimmte algebraische Einschränkungen für Stabilizer-Codes fest, die für ihre Funktionsweise wichtig sind.

Die zweite Bedingung verlangt, dass die Stabilizer-Generatoren ein minimales Erzeugendensystem bilden, d. h. das Entfernen eines beliebigen Generators würde zu einem kleineren Stabilizer führen. Genau genommen ist diese Bedingung für die operative Funktionsweise von Stabilizer-Codes nicht wirklich wesentlich – und wie wir in der nächsten Lektion sehen werden, macht es manchmal Sinn, über Mengen von Stabilizer-Generatoren nachzudenken, die diese Bedingung tatsächlich nicht erfüllen. Für die Analyse von Stabilizer-Codes und die Erklärung ihrer Eigenschaften werden wir diese Bedingung jedoch voraussetzen. Kurz gesagt stellt sie sicher, dass jede Observable, die wir zur Ermittlung des Fehlersyndroms messen, neue Information über mögliche Fehler liefert – und nicht redundant ist und Ergebnisse produziert, die sich aus den anderen Stabilizer-Generator-Messungen ableiten lassen.

Die dritte Bedingung verlangt, dass mindestens ein nichttrivialer Vektor von allen Stabilizer-Generatoren fixiert wird, was äquivalent dazu ist, dass $-\mathbb{I}^{\otimes n}$ nicht im Stabilizer enthalten ist. Die Notwendigkeit dieser Bedingung ergibt sich daraus, dass es tatsächlich möglich ist, ein minimales Erzeugendensystem von $n$-Qubit-Pauli-Operationen zu wählen, die alle miteinander kommutieren, ohne dass irgendeiner von ihnen alle nichttrivialen Vektoren fixiert. Wir sind nicht an „Codes" interessiert, für die es keine gültigen Kodierungen gibt, daher schließen wir diese Möglichkeit durch diese Bedingung aus.

Beispiele

Hier sind einige Beispiele für Stabilizer-Codes mit kleinen Werten von $n.$ In der nächsten Lektion werden wir weitere Beispiele sehen, auch solche, bei denen $n$ viel größer sein kann.

3-Bit-Wiederholungscode

Der 3-Bit-Wiederholungscode ist ein Beispiel für einen Stabilizer-Code, bei dem die Stabilizer-Generatoren $Z \otimes Z \otimes \mathbb{I}$ und $\mathbb{I} \otimes Z \otimes Z$ sind.

Wir können leicht überprüfen, dass diese beiden Stabilizer-Generatoren die erforderlichen Bedingungen erfüllen. Erstens kommutieren die beiden Stabilizer-Generatoren $Z \otimes Z \otimes \mathbb{I}$ und $\mathbb{I} \otimes Z \otimes Z$ miteinander.

$$(Z \otimes Z \otimes \mathbb{I})(\mathbb{I} \otimes Z \otimes Z) = Z \otimes \mathbb{I} \otimes Z = (\mathbb{I} \otimes Z \otimes Z)(Z \otimes Z \otimes \mathbb{I})$$

Zweitens haben wir ein minimales Erzeugendensystem (in diesem Fall recht trivial).

$$\begin{aligned} Z \otimes Z \otimes \mathbb{I} \notin \langle\mathbb{I} \otimes Z \otimes Z\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, \mathbb{I} \otimes Z \otimes Z\}\\[1mm] \mathbb{I} \otimes Z \otimes Z \notin \langle Z \otimes Z \otimes \mathbb{I}\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z \otimes Z \otimes \mathbb{I}\} \end{aligned}$$

Und drittens wissen wir bereits, dass $\vert 000\rangle$ und $\vert 111\rangle$ sowie jede Linearkombination dieser Vektoren von $Z \otimes Z \otimes \mathbb{I}$ und $\mathbb{I} \otimes Z \otimes Z$ fixiert werden. Alternativ können wir dies mit der äquivalenten Bedingung aus der Definition schlussfolgern.

$$-\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\notin \langle Z \otimes Z \otimes \mathbb{I}, \mathbb{I} \otimes Z \otimes Z\rangle = \{ \mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z\otimes Z\otimes\mathbb{I}, Z\otimes\mathbb{I}\otimes Z, \mathbb{I}\otimes Z\otimes Z \}$$

Diese Bedingungen können bei komplizierteren Stabilizer-Codes viel schwieriger zu überprüfen sein.

Modifizierter 3-Bit-Wiederholungscode

In der vorherigen Lektion haben wir gesehen, dass sich der 3-Bit-Wiederholungscode so modifizieren lässt, dass er gegen Phasenfehler statt gegen Bitfehler schützt. Als Stabilizer-Code lässt sich dieser neue Code einfach beschreiben: seine Stabilizer-Generatoren sind $X \otimes X \otimes \mathbb{I}$ und $\mathbb{I} \otimes X \otimes X.$

Diesmal repräsentieren die Stabilizer-Generatoren $X\otimes X$-Observablen statt $Z\otimes Z$-Observablen und sind daher im Wesentlichen Paritätsprüfungen in der Plus-/Minus-Basis statt in der Standardbasis. Die drei erforderlichen Bedingungen für die Stabilizer-Generatoren lassen sich ähnlich wie beim gewöhnlichen 3-Bit-Wiederholungscode leicht überprüfen.

9-Qubit-Shor-Code

Hier ist der 9-Qubit-Shor-Code, der ebenfalls ein Stabilizer-Code ist, ausgedrückt durch Stabilizer-Generatoren.

$$\begin{gathered} Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z\\[1mm] X \otimes X \otimes X \otimes X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\otimes X \otimes X \otimes X \otimes X \otimes X \otimes X \end{gathered}$$

In diesem Fall haben wir im Wesentlichen drei Kopien des 3-Bit-Wiederholungscodes, eine für jeden der drei Dreibit-Blöcke, sowie die letzten beiden Stabilizer-Generatoren, die an den Circuit zur Phasenfehlererkennung dieses Codes erinnern.

Eine alternative Betrachtungsweise der letzten beiden Stabilizer-Generatoren ist, dass sie dieselbe Form wie beim 3-Bit-Wiederholungscode für Phasenfehler haben, mit dem Unterschied, dass $X\otimes X\otimes X$ für $X$ eingesetzt wird. Das entspricht der Tatsache, dass $X\otimes X\otimes X$ einer $X$-Operation auf logischen Qubits entspricht, die mit dem 3-Bit-Wiederholungscode kodiert wurden.

Bevor wir zu anderen Beispielen übergehen, sei darauf hingewiesen, dass Tensorproduktzeichen bei der Beschreibung von Stabilizer-Codes durch Listen von Stabilizer-Generatoren häufig weggelassen werden, da dies das Lesen erleichtert und die Muster besser erkennbar macht. Zum Beispiel sehen die oben genannten Stabilizer-Generatoren für den 9-Qubit-Shor-Code ohne explizit geschriebene Tensorproduktzeichen so aus:

$$\begin{array}{ccccccccc} Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z\\[1mm] X & X & X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I}& X & X & X & X & X & X \end{array}$$

7-Qubit-Steane-Code

Hier ist ein weiteres Beispiel für einen Stabilizer-Code, bekannt als 7-Qubit-Steane-Code. Er hat bemerkenswerte Eigenschaften, und wir werden im Laufe der verbleibenden Lektionen des Kurses immer wieder auf diesen Code zurückkommen.

$$\begin{array}{ccccccc} Z & Z & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] Z & Z & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} \\[1mm] Z & \mathbb{I} & Z & \mathbb{I} & Z & \mathbb{I} & Z \\[1mm] X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] X & X & \mathbb{I} & \mathbb{I} & X & X & \mathbb{I} \\[1mm] X & \mathbb{I} & X & \mathbb{I} & X & \mathbb{I} & X \end{array}$$

Zunächst stellen wir einfach fest, dass dies ein gültiger Stabilizer-Code ist. Die ersten drei Stabilizer-Generatoren kommutieren offensichtlich miteinander, da $Z$ mit sich selbst kommutiert und die Identität mit allem kommutiert; ähnliches gilt für die letzten drei Stabilizer-Generatoren. Es bleibt zu überprüfen, dass je ein $Z$-Stabilizer-Generator (d. h. einer der ersten drei) und ein $X$-Stabilizer-Generator (d. h. einer der letzten drei) miteinander kommutieren. Dazu kann man alle 9 möglichen Paarungen durchgehen. In all diesen Fällen tritt ein $X$- und ein $Z$-Pauli-Matrix-Paar stets an denselben Positionen eine gerade Anzahl von Malen auf, sodass die beiden Generatoren kommutieren – genau wie $X\otimes X$ und $Z\otimes Z$ kommutieren. Dies ist auch ein minimales Erzeugendensystem und definiert einen nichttrivialen Code-Raum; diese Tatsachen können von dir selbst nachvollzogen werden.

Der 7-Qubit-Steane-Code ähnelt dem 9-Qubit-Shor-Code darin, dass er ein einzelnes Qubit kodiert und beliebige Fehler auf einem Qubit korrigieren kann, benötigt dafür aber nur 7 statt 9 Qubits.

5-Qubit-Code

Sieben ist nicht die kleinste Anzahl von Qubits, die nötig ist, um ein Qubit zu kodieren und es gegen einen beliebigen Fehler auf einem Qubit zu schützen – hier ist ein Stabilizer-Code, der das mit nur 5 Qubits erreicht.

$$\begin{array}{ccccc} X & Z & Z & X & \mathbb{I} \\[1mm] \mathbb{I} & X & Z & Z & X \\[1mm] X & \mathbb{I} & X & Z & Z \\[1mm] Z & X & \mathbb{I} & X & Z \\[1mm] \end{array}$$

Dieser Code wird üblicherweise als der 5-Qubit-Code bezeichnet. Er stellt die kleinstmögliche Qubit-Anzahl in einem Quantenfehlerkorrekturcode dar, der die Korrektur eines beliebigen Einzelqubit-Fehlers erlaubt.

Eindimensionale Stabilizer-Codes

Hier ist ein weiteres Beispiel für einen Stabilizer-Code, der allerdings keine Qubits kodiert: der Code-Raum ist eindimensional. Es handelt sich dennoch um einen gültigen Stabilizer-Code gemäß der Definition.

$$\begin{array}{cc} Z & Z \\[1mm] X & X \end{array}$$

Konkret ist der Code-Raum der eindimensionale Raum, der durch ein E-Bit $\vert\phi^+\rangle$ aufgespannt wird.

Hier ist ein verwandtes Beispiel für einen Stabilizer-Code, dessen Code-Raum der eindimensionale Raum ist, der durch einen GHZ-Zustand $(\vert 000\rangle + \vert 111\rangle)/\sqrt{2}$ aufgespannt wird.

$$\begin{array}{cc} Z & Z & \mathbb{I} \\[1mm] \mathbb{I} & Z & Z \\[1mm] X & X & X \end{array}$$

Dimension des Code-Raums

Angenommen, wir haben einen Stabilizer-Code, der durch $n$-Qubit-Stabilizer-Generatoren $P_1,\ldots,P_r$ beschrieben wird. Die wohl naheliegendste Frage zu diesem Code ist: „Wie viele Qubits kodiert er?"

Diese Frage hat eine einfache Antwort. Wenn die $n$-Qubit-Stabilizer-Generatoren $P_1, \ldots, P_r$ die drei Anforderungen der Definition erfüllen (d. h. die Stabilizer-Generatoren kommutieren paarweise, es handelt sich um ein minimales Erzeugendensystem, und der Code-Raum ist nichtleer), dann hat der Code-Raum dieses Stabilizer-Codes die Dimension $2^{n-r}$, sodass $n-r$ Qubits mit diesem Code kodiert werden können.

Intuitiv haben wir $n$ Qubits für die Kodierung zur Verfügung, und jeder Stabilizer-Generator „nimmt gewissermaßen ein Qubit weg" in Bezug auf die Anzahl der kodierbaren Qubits. Hinweis: Dies betrifft nicht, welche oder wie viele Fehler erkannt oder korrigiert werden können – es ist lediglich eine Aussage über die Dimension des Code-Raums.

Für den 3-Bit-Wiederholungscode und die modifizierte Version für Phasenfehler gilt zum Beispiel: $n=3$ Qubits und $r=2$ Stabilizer-Generatoren, also kann jeweils 1 Qubit kodiert werden. Als weiteres Beispiel betrachte den 5-Qubit-Code: 5 Qubits und 4 Stabilizer-Generatoren, also hat der Code-Raum wieder Dimension 2, d. h. ein Qubit kann kodiert werden. Als letztes Beispiel: Der Code, dessen Stabilizer-Generatoren $X\otimes X$ und $Z\otimes Z$ sind, hat einen eindimensionalen Code-Raum, aufgespannt durch den Zustand $\vert\phi^+\rangle$ – was mit $n=2$ Qubits und $r=2$ Stabilizer-Generatoren übereinstimmt.

Schauen wir uns nun an, wie sich diese Tatsache beweisen lässt. Der erste Schritt besteht darin, festzustellen, dass – da die Stabilizer-Generatoren kommutieren und jede Pauli-Operation ihre eigene Inverse ist – jedes Element des Stabilizers als Produkt ausgedrückt werden kann:

$$P_1^{a_1} \cdots P_r^{a_r},$$

wobei $a_1,\ldots,a_r\in\{0,1\}.$ Äquivalent dazu wird jedes Element des Stabilizers durch Multiplikation einer Teilmenge der Stabilizer-Generatoren erhalten. Tatsächlich kann jedes Stabilizer-Element auf genau eine solche Weise ausgedrückt werden, was aus der Bedingung folgt, dass $\{P_1,\ldots,P_r\}$ ein minimales Erzeugendensystem ist.

Als nächstes definieren wir $\Pi_k$ als die Projektion auf den Raum der $+1$-Eigenvektoren von $P_k$ für jedes $k\in\{1,\ldots,r\}.$ Diese Projektionen lassen sich durch Mittelung der entsprechenden Pauli-Operationen mit der Identitätsoperation gewinnen:

$$\Pi_k = \frac{\mathbb{I}^{\otimes n} + P_k}{2}$$

Der Code-Raum $\mathcal{C}$ ist der Unterraum aller Vektoren, die von allen $r$ Stabilizer-Generatoren $P_1,\ldots,P_r$ – bzw. äquivalent von allen $r$ Projektionen $\Pi_1,\ldots,\Pi_r$ – fixiert werden.

Da die Stabilizer-Generatoren alle miteinander kommutieren, müssen auch die Projektionen $\Pi_1,\ldots,\Pi_r$ miteinander kommutieren. Das erlaubt uns, einen Satz aus der linearen Algebra zu nutzen: Das Produkt dieser Projektionen ist die Projektion auf den Schnitt der Unterräume der einzelnen Projektionen. Mit anderen Worten: Das Produkt $\Pi_1\cdots\Pi_r$ ist die Projektion auf den Code-Raum $\mathcal{C}.$

Wir können das Produkt $\Pi_1\cdots\Pi_r$ nun mit den Formeln für diese Projektionen ausschreiben und erhalten folgende Darstellung:

$$\Pi_1\cdots\Pi_r = \biggl(\frac{\mathbb{I}^{\otimes n} + P_1}{2}\biggr)\cdots\biggl(\frac{\mathbb{I}^{\otimes n} + P_r}{2}\biggr) = \frac{1}{2^r}\sum_{a_1,\ldots,a_r \in \{0,1\}} P_1^{a_1}\cdots P_r^{a_r}$$

Die Projektion auf den Code-Raum eines Stabilizer-Codes ist also als Matrix gleich dem Durchschnitt über alle Elemente des Stabilizers dieses Codes.

Abschließend können wir die Dimension des Code-Raums berechnen, indem wir nutzen, dass die Dimension eines Unterraums gleich der Spur der Projektion auf diesen Unterraum ist. Die Dimension des Code-Raums $\mathcal{C}$ ist daher:

$$\operatorname{dim}(\mathcal{C}) = \operatorname{Tr}(\Pi_1\cdots\Pi_r) = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r})$$

Diesen Ausdruck können wir mithilfe einiger grundlegender Fakten auswerten.

• Es gilt $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ und daher

  $$\operatorname{Tr}(P_1^{0}\cdots P_r^{0}) = 2^n.$$

• Für $(a_1,\ldots,a_r) \neq (0,\ldots,0)$ muss das Produkt $P_1^{a_1}\cdots P_r^{a_r}$ gleich $\pm 1$ mal einer Pauli-Operation sein – aber wir können $\mathbb{I}^{\otimes n}$ nicht erhalten, da dies der Minimalität der Menge $\{P_1,\ldots,P_r\}$ widersprechen würde, und $-\mathbb{I}^{\otimes n}$ ist durch die dritte Bedingung ausgeschlossen. Da die Spur jeder Nicht-Identitäts-Pauli-Operation null ist, ergibt sich:

  $$\operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) = 0.$$

Die Dimension des Code-Raums ist daher wie behauptet $2^{n-r}$:

$$\begin{aligned} \operatorname{dim}(\mathcal{C}) & = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) \\ & = \frac{1}{2^r} \operatorname{Tr}(P_1^{0}\cdots P_r^{0}) \\ & = 2^{n-r}. \end{aligned}$$

Nebenbei bemerkt: Wir können nun einsehen, dass die Annahme, dass $-\mathbb{I}^{\otimes n}$ nicht im Stabilizer enthalten ist, impliziert, dass der Code-Raum mindestens einen Quantenzustandsvektor enthalten muss. Wie wir gerade gezeigt haben, impliziert diese Annahme nämlich, dass der Code-Raum die Dimension $2^{n-r}$ hat, die nicht null sein kann. Die Umkehrung ist trivial: Wenn $-\mathbb{I}^{\otimes n}$ im Stabilizer enthalten ist, kann der Code-Raum keine Quantenzustandsvektoren enthalten, da kein nichttrivialer Vektor von dieser Operation fixiert wird.

Clifford-Operationen und Kodierungen

Als nächstes besprechen wir kurz, wie Qubits mit Stabilizer-Codes kodiert werden können. Dazu müssen wir zunächst Clifford-Operationen einführen.

Clifford-Operationen

Clifford-Operationen sind unitäre Operationen auf beliebig vielen Qubits, die durch Quantencircuits mit einem eingeschränkten Gate-Satz implementiert werden können:

• Hadamard-Gates
• $S$-Gates
• CNOT-Gates

Beachte, dass $T$-Gates nicht enthalten sind, ebenso wenig wie Toffoli-Gates und Fredkin-Gates. Diese Gates sind nicht nur nicht in der Liste enthalten – es ist tatsächlich nicht möglich, sie mit den aufgeführten Gates zu implementieren; sie sind keine Clifford-Operationen. Pauli-Operationen hingegen sind Clifford-Operationen, da sie durch Sequenzen von Hadamard- und $S$-Gates implementiert werden können.

Das ist eine einfache Definition von Clifford-Operationen, erklärt aber nicht, warum sie so definiert werden oder was diese spezielle Sammlung von Gates auszeichnet. Der eigentliche Grund für diese Definition ist, dass – bis auf globale Phasenfaktoren – die Clifford-Operationen genau diejenigen unitären Operationen sind, die Pauli-Operationen stets durch Konjugation in Pauli-Operationen überführen. Genauer gesagt: Eine $n$-Qubit-unitäre Operation $U$ ist äquivalent zu einer Clifford-Operation bis auf einen Phasenfaktor genau dann, wenn für jede $n$-Qubit-Pauli-Operation $P$ gilt:

$$U P U^{\dagger} = \pm Q$$

für eine $n$-Qubit-Pauli-Operation $Q.$

(Man beachte, dass $U P U^{\dagger} = \alpha Q$ für $\alpha\notin\{+1,-1\}$ nicht möglich ist, wenn $U$ unitär und $P$ und $Q$ Pauli-Operationen sind. Das folgt daraus, dass die Matrix auf der linken Seite der Gleichung sowohl unitär als auch hermitesch ist, und $+1$ und $-1$ die einzigen Werte für $\alpha$ sind, bei denen die rechte Seite ebenfalls unitär und hermitesch ist.)

Es ist straightforward, die beschriebene Konjugationseigenschaft zu überprüfen, wenn $U$ ein Hadamard-, $S$- oder CNOT-Gate ist. Insbesondere gilt dies einfach für Hadamard-Gates:

$$H X H^{\dagger} = Z, \qquad H Y H^{\dagger} = -Y, \qquad H Z H^{\dagger} = X,$$

und für $S$-Gates:

$$S X S^{\dagger} = Y, \qquad S Y S^{\dagger} = -X, \qquad S Z S^{\dagger} = Z.$$

Für CNOT-Gates gibt es 15 Nicht-Identitäts-Pauli-Operationen auf zwei Qubits zu überprüfen. Natürlich können diese einzeln geprüft werden – die Beziehungen zwischen CNOT-Gates und $X$- und $Z$-Gates (in Circuit-Form) aus der vorherigen Lektion zusammen mit den Multiplikationsregeln für Pauli-Matrizen bieten jedoch eine Abkürzung zur gleichen Schlussfolgerung.

Sobald wir wissen, dass diese Konjugationseigenschaft für Hadamard-, $S$- und CNOT-Gates gilt, können wir sofort schlussfolgern, dass sie auch für Circuits aus diesen Gates gilt – d. h. für alle Clifford-Operationen.

Es ist schwieriger zu beweisen, dass die Beziehung auch in die andere Richtung gilt: dass eine unitäre Operation $U$, die die Konjugationseigenschaft für Pauli-Operationen erfüllt, (bis auf eine globale Phase) nur mit Hadamard-, $S$- und CNOT-Gates implementiert werden kann. Das wird in dieser Lektion nicht erklärt, ist aber wahr.

Clifford-Operationen sind nicht universell für Quantencomputing; im Gegensatz zu universellen Gate-Sätzen ist es mit Clifford-Operationen nicht möglich, beliebige unitäre Operationen mit beliebiger Genauigkeit zu approximieren. Tatsächlich gibt es für einen gegebenen Wert von $n$ nur endlich viele $n$-Qubit-Clifford-Operationen (bis auf Phasenfaktoren). Clifford-Operationen auf Standardbasiszuständen, gefolgt von Standardbasismessungen, erlauben keine Berechnungen, die über klassische Algorithmen hinausgehen – denn wir können Berechnungen dieser Form effizient klassisch simulieren. Diese Tatsache ist als Gottesman-Knill-Theorem bekannt.

Kodierer für Stabilizer-Codes

Ein Stabilizer-Code definiert einen Code-Raum einer bestimmten Dimension, und wir haben die Freiheit, diesen Code-Raum nach Belieben zu nutzen – nichts zwingt uns, Qubits auf eine bestimmte Weise in diesen Code-Raum zu kodieren. Es ist jedoch stets möglich, eine Clifford-Operation als Kodierer zu verwenden, wenn wir das möchten. Genauer gesagt: Für jeden Stabilizer-Code, der die Kodierung von $m$ Qubits in $n$ Qubits erlaubt, gibt es eine $n$-Qubit-Clifford-Operation $U$ derart, dass für jeden $m$-Qubit-Quantenzustandsvektor $\vert\phi\rangle$ gilt:

$$\vert\psi\rangle = U \bigl(\vert 0^{n-m} \rangle \otimes \vert \phi\rangle\bigr)$$

ist ein Quantenzustandsvektor im Code-Raum unseres Codes, den wir als Kodierung von $\vert\phi\rangle$ interpretieren können.

Das ist vorteilhaft, da Clifford-Operationen im Vergleich zu beliebigen unitären Operationen relativ einfach sind, und es gibt Möglichkeiten, ihre Implementierung mit Techniken zu optimieren, die denen aus dem Beweis des Gottesman-Knill-Theorems ähneln. Daher müssen Circuits zur Kodierung von Zuständen mit Stabilizer-Codes nie besonders groß sein. Insbesondere kann eine Kodierung für einen $n$-Qubit-Stabilizer-Code stets mit einer Clifford-Operation durchgeführt werden, die $O(n^2/\log(n))$ Gates benötigt. Das liegt daran, dass jede Clifford-Operation auf $n$ Qubits durch einen Circuit dieser Größe implementiert werden kann.

Hier ist zum Beispiel ein Kodierer für den 7-Qubit-Steane-Code. Es handelt sich tatsächlich um eine Clifford-Operation, und in diesem Fall werden nicht einmal $S$-Gates benötigt.

Fehlererkennung

Für einen $n$-Qubit-Stabilizer-Code, der durch Stabilizer-Generatoren $P_1,\ldots, P_r$ beschrieben wird, funktioniert die Fehlererkennung folgendermaßen.

Zur Fehlererkennung werden alle Stabilizer-Generatoren als Observablen gemessen. Es gibt $r$ Stabilizer-Generatoren und damit $r$ Messergebnisse, jedes entweder $+1$ oder $-1$ (oder ein binärer Wert, wenn wir $0$ mit $+1$ und $1$ mit $-1$ assoziieren). Wir interpretieren die $r$ Ergebnisse gemeinsam als Vektor oder Zeichenkette – als Syndrom. Das Syndrom $(+1,\ldots,+1)$ zeigt an, dass kein Fehler erkannt wurde, während mindestens ein $-1$ im Syndrom einen erkannten Fehler signalisiert.

Angenommen, $E$ ist eine $n$-Qubit-Pauli-Operation, die einen hypothetischen Fehler darstellt. (Wir betrachten hier nur Pauli-Operationen als Fehler, da die Diskretisierung von Fehlern für beliebige Stabilizer-Codes genauso funktioniert wie für den 9-Qubit-Shor-Code.) Es gibt drei Fälle, die bestimmen, ob $E$ als Fehler erkannt wird.

Fälle der Fehlererkennung

1. Die Operation $E$ ist proportional zu einem Element des Stabilizers.

   $$E = \pm Q \; \text{für ein}\; Q \in \langle P_1,\ldots,P_r\rangle$$

   In diesem Fall muss $E$ mit jedem Stabilizer-Generator kommutieren, sodass wir das Syndrom $(+1,\ldots,+1)$ erhalten. Das bedeutet, dass $E$ nicht als Fehler erkannt wird.

2. Die Operation $E$ ist nicht proportional zu einem Element des Stabilizers, kommutiert aber trotzdem mit jedem Stabilizer-Generator.

   $$E\neq \pm Q\; \text{für} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{aber}\; E P_k = P_k E \;\text{für alle}\; k\in\{1,\ldots,r\}$$

   Dies ist ein Fehler, der Vektoren im Code-Raum auf nichttriviale Weise verändert. Da $E$ jedoch mit jedem Stabilizer-Generator kommutiert, ist das Syndrom $(+1,\ldots,+1)$, sodass $E$ vom Code nicht erkannt wird.

3. Die Operation $E$ antikommutiert mit mindestens einem der Stabilizer-Generatoren.

   $$P_k E = -E P_k \; \text{für mindestens ein} \; k\in\{1,\ldots,r\}$$

   Das Syndrom unterscheidet sich von $(+1,\ldots,+1)$, sodass der Fehler $E$ vom Code erkannt wird.

Im ersten Fall ist der Fehler $E$ kein Problem, da diese Operation nichts an den Vektoren im Code-Raum ändert, außer möglicherweise eine irrelevante globale Phase einzufügen: $E \ket{\psi} = \pm\ket{\psi}$ für jeden kodierten Zustand $\ket{\psi}.$ Im Wesentlichen handelt es sich dabei nicht um einen echten Fehler – jede nichttriviale Wirkung von $E$ findet außerhalb des Code-Raums statt – daher ist es gut, dass $E$ nicht als Fehler erkannt wird, denn es muss nichts dagegen unternommen werden.

Der zweite Fall ist intuitiv gesehen der problematische. Die Antikommutation eines Fehlers mit einem Stabilizer-Generator führt dazu, dass ein $-1$ im Syndrom erscheint und einen Fehler signalisiert – aber das passiert in diesem Fall nicht. Wir haben also einen Fehler $E$, der Vektoren im Code-Raum auf nichttriviale Weise verändert, aber vom Code unerkannt bleibt. Beim 3-Bit-Wiederholungscode fällt zum Beispiel die Operation $E = X\otimes X\otimes X$ in diese Kategorie.

Die Tatsache, dass ein solcher Fehler $E$ einige Vektoren im Code-Raum auf nichttriviale Weise ändern muss, lässt sich wie folgt begründen. Aus der Annahme, dass $E$ mit $P_1,\ldots,P_r$ kommutiert, aber nicht proportional zu einem Stabilizer-Element ist, lässt sich schlussfolgern, dass wir einen neuen, gültigen Stabilizer-Code erhalten würden, wenn wir $E$ zusammen mit $P_1,\ldots,P_r$ als Stabilizer-Generator hinzufügen. Der Code-Raum dieses neuen Codes hat jedoch nur die halbe Dimension des ursprünglichen Code-Raums, woraus wir schließen können, dass die Wirkung von $E$ auf den ursprünglichen Code-Raum nicht proportional zur Identitätsoperation sein kann.

Im letzten der drei Fälle – wenn der Fehler $E$ mit mindestens einem Stabilizer-Generator antikommutiert – enthält das Syndrom mindestens ein $-1$, was anzeigt, dass etwas nicht stimmt. Wie bereits besprochen, identifiziert das Syndrom $E$ im Allgemeinen nicht eindeutig, sodass für jedes Syndrom eine Korrekturopertion gewählt werden muss, die den Fehler $E$ möglicherweise korrigiert oder auch nicht. Wir besprechen diesen Schritt gleich im letzten Teil der Lektion.

Distanz eines Stabilizer-Codes

Als terminologische Anmerkung: Wenn wir von der Distanz eines Stabilizer-Codes sprechen, meinen wir das minimale Gewicht einer Pauli-Operation $E$, die in die zweite Kategorie oben fällt – d. h. die den Code-Raum auf nichttriviale Weise verändert, aber vom Code nicht erkannt wird. Wenn gesagt wird, dass ein Stabilizer-Code ein $[[n,m,d]]$-Stabilizer-Code ist (mit doppelten eckigen Klammern), bedeutet das:

1. Kodierungen haben eine Länge von $n$ Qubits,
2. der Code erlaubt die Kodierung von $m$ Qubits, und
3. die Distanz des Codes ist $d.$

Als Beispiel betrachten wir den 7-Qubit-Steane-Code. Hier sind die Stabilizer-Generatoren für diesen Code:

$$\begin{array}{ccccccc} Z & Z & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] Z & Z & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} \\[1mm] Z & \mathbb{I} & Z & \mathbb{I} & Z & \mathbb{I} & Z \\[1mm] X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] X & X & \mathbb{I} & \mathbb{I} & X & X & \mathbb{I} \\[1mm] X & \mathbb{I} & X & \mathbb{I} & X & \mathbb{I} & X \end{array}$$

Dieser Code hat Distanz 3, was sich wie folgt begründen lässt.

Betrachte zunächst eine beliebige Pauli-Operation $E$ mit Gewicht höchstens 2, die mit allen sechs Stabilizer-Generatoren kommutiert. Wir werden zeigen, dass $E$ die Identitätsoperation sein muss – die (wie immer) ein Element des Stabilizers ist. Das beweist, dass die Distanz des Codes strikt größer als 2 ist. Angenommen, $E$ hat die Form

$$E = P \otimes Q \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}$$

wobei $P$ und $Q$ möglicherweise Nicht-Identitäts-Pauli-Matrizen sind. Das ist nur ein Fall, und das folgende Argument muss für alle anderen möglichen Positionen der Nicht-Identitäts-Pauli-Matrizen in den Tensorfaktoren von $E$ wiederholt werden – aber das Argument ist für alle möglichen Positionen im Wesentlichen dasselbe.

Die Operation $E$ kommutiert mit allen sechs Stabilizer-Generatoren, also insbesondere mit diesen beiden:

$$\begin{gathered} Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z\\[1mm] X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \end{gathered}$$

Der Tensorfaktor $Q$ in unserem Fehler $E$ wird dabei durch die Identitätsmatrix in beiden Stabilizer-Generatoren abgedeckt (deshalb wurden sie ausgewählt). Da in den fünf rechtesten Positionen von $E$ Identitätsmatrizen stehen, schlussfolgern wir, dass $P$ mit $X$ und $Z$ kommutieren muss – andernfalls würde $E$ mit einem der beiden Generatoren antikommutieren. Die einzige Pauli-Matrix, die mit $X$ und $Z$ kommutiert, ist jedoch die Identitätsmatrix, also $P = \mathbb{I}.$

Da wir das nun wissen, können wir zwei weitere Stabilizer-Generatoren wählen, die in der zweiten Position von links ein $X$ bzw. ein $Z$ haben, und ziehen einen ähnlichen Schluss: $Q = \mathbb{I}.$ Damit ist $E$ die Identitätsoperation.

Es gibt also keine Möglichkeit, dass ein Fehler mit Gewicht höchstens 2 von diesem Code unerkannt bleibt – es sei denn, der Fehler ist die Identitätsoperation (die im Stabilizer ist und daher kein echter Fehler ist). Andererseits gibt es Gewicht-3-Pauli-Operationen, die mit allen sechs Stabilizer-Generatoren kommutieren, aber nicht proportional zu Stabilizer-Elementen sind, etwa $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ und $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z.$ Damit ist bewiesen, dass dieser Code die Distanz 3 hat.

Fehlerkorrektur

Das letzte Thema dieser Lektion ist die Korrektur von Fehlern bei Stabilizer-Codes. Wir gehen davon aus, dass wir einen Stabilizer-Code haben, der durch $n$-Qubit-Stabilizer-Generatoren $P_1, \ldots, P_r$ beschrieben wird.

Die $n$-Qubit-Pauli-Operationen als Fehler, die kodierte Zustände beeinflussen könnten, werden nach dem von ihnen erzeugten Syndrom in gleich große Gruppen eingeteilt. Es gibt $2^r$ verschiedene Syndrome und $4^n$ Pauli-Operationen, also gibt es $4^n/2^r$ Pauli-Operationen, die jedes Syndrom erzeugen. Jede dieser Operationen könnte für das entsprechende Syndrom verantwortlich sein.

Unter den $4^n/2^r$ Pauli-Operationen, die dasselbe Syndrom erzeugen, gibt es einige, die als äquivalent betrachtet werden sollten. Insbesondere sind zwei Pauli-Operationen, deren Produkt proportional zu einem Stabilizer-Element ist, effektiv äquivalent als Fehler.

Anders ausgedrückt: Wenn wir eine Korrekturopertion $C$ anwenden, um einen Fehler $E$ zu korrigieren, ist die Korrektur erfolgreich, solange die Zusammensetzung $CE$ proportional zu einem Stabilizer-Element ist. Da der Stabilizer $2^r$ Elemente hat, korrigiert jede Korrekturopertion $C$ genau $2^r$ verschiedene Pauli-Fehler. Das lässt $4^{n-r}$ inäquivalente Klassen von Pauli-Operationen, die als Fehler betrachtet werden, die mit jedem möglichen Syndrom konsistent sind.

Das bedeutet, dass wir nicht jeden von einem Stabilizer-Code erkannten Fehler korrigieren können – es sei denn, $n=r$ (in diesem Fall haben wir einen trivialen, eindimensionalen Code-Raum). Stattdessen müssen wir für jedes Syndrom genau eine Korrekturopertion wählen, in der Hoffnung, nur eine Klasse von äquivalenten Fehlern zu korrigieren, die dieses Syndrom erzeugen.

Eine naheliegende Strategie für die Wahl der Korrekturopertion für jedes Syndrom ist, die Pauli-Operation mit dem niedrigsten Gewicht zu wählen, die als Fehler dieses Syndrom erzeugt. Es kann tatsächlich mehrere Operationen geben, die für den niedrigstgewichtigen Fehler zu einem gegebenen Syndrom gleichwertig sind – in diesem Fall kann eine beliebige davon gewählt werden. Die Idee ist, dass Pauli-Operationen mit niedrigerem Gewicht wahrscheinlichere Erklärungen für das gemessene Syndrom darstellen. Bei manchen Rauschmodellen ist das möglicherweise nicht der Fall, und eine alternative Strategie besteht darin, den wahrscheinlichsten Fehler zu berechnen, der das gegebene Syndrom verursacht, basierend auf dem gewählten Rauschmodell. Für diese Lektion halten wir es jedoch einfach und betrachten nur Korrekturen mit niedrigstem Gewicht.

Bei einem Stabilizer-Code mit Distanz $d$ erlaubt diese Strategie stets die Korrektur von Fehlern mit einem Gewicht, das strikt kleiner als die Hälfte von $d$ ist – also höchstens $(d-1)/2.$ Das zeigt beispielsweise, dass der 7-Qubit-Steane-Code jeden Gewicht-1-Pauli-Fehler korrigieren kann, und durch die Diskretisierung von Fehlern bedeutet das, dass der Steane-Code einen beliebigen Fehler auf einem Qubit korrigieren kann.

Um zu verstehen, wie das funktioniert, betrachten wir das Diagramm unten. Der linke Kreis stellt alle Pauli-Operationen dar, die das Syndrom $(+1,\ldots,+1)$ erzeugen – das Syndrom, das anzeigt, dass keine Fehler aufgetreten sind und alles in Ordnung ist. Darunter befinden sich Elemente des Stabilizers (bzw. genauer gesagt Operationen, die proportional zu Stabilizer-Elementen sind) sowie nichttriviale Fehler, die den Code-Raum verändern, aber vom Code nicht erkannt werden. Nach der Definition der Distanz muss jede Pauli-Operation in dieser Kategorie Gewicht mindestens $d$ haben, da $d$ als das minimale Gewicht dieser Operationen definiert ist.

Der rechte Kreis stellt die Pauli-Operationen dar, die ein anderes Syndrom $s\neq(+1,\ldots,+1)$ erzeugen, einschließlich eines Fehlers $E$ mit Gewicht strikt kleiner als $d/2$.

Die für das Syndrom $s$ gewählte Korrekturopertion $C$ ist die Pauli-Operation mit dem niedrigsten Gewicht in der Menge, die durch den rechten Kreis im Diagramm dargestellt wird (oder eine davon im Gleichstandsfall). Es kann also sein, dass $C = E$, aber nicht notwendigerweise. Was wir jedoch mit Sicherheit sagen können: $C$ kann kein größeres Gewicht als $E$ haben, da $C$ unter den Operationen in dieser Menge das minimale Gewicht hat – und daher hat $C$ Gewicht strikt kleiner als $d/2.$

Betrachten wir nun, was passiert, wenn die Korrekturopertion $C$ auf den Zustand angewendet wird, den wir nach dem Auftreten des Fehlers $E$ erhalten. Wenn die ursprüngliche Kodierung $\vert\psi\rangle$ war, erhalten wir $CE\vert\psi\rangle.$ Unser Ziel ist es zu zeigen, dass $CE$ proportional zu einem Element des Stabilizers ist, was bedeutet, dass die Korrektur erfolgreich ist und wir (bis auf eine globale Phase) den ursprünglichen kodierten Zustand $\vert\psi\rangle$ zurückerhältst.

Erstens: Da $E$ und $C$ dasselbe Syndrom erzeugen, muss die Zusammensetzung $CE$ mit jedem Stabilizer-Generator kommutieren. Wenn insbesondere $P_k$ ein beliebiger Stabilizer-Generator ist, dann muss gelten:

$$P_k E = \alpha E P_k \quad\text{und}\quad P_k C = \alpha C P_k$$

für denselben Wert von $\alpha\in\{+1,-1\}$, da dies der $k$-te Eintrag des Syndroms $s$ ist, das sowohl $C$ als auch $E$ erzeugen. Daher gilt:

$$P_k (CE) = \alpha C P_k E = \alpha^2 (CE) P_k = (CE) P_k,$$

also kommutiert $P_k$ mit $CE.$ Wir haben damit gezeigt, dass $CE$ im linken Kreis liegt, da es das Syndrom $(+1,\ldots,+1)$ erzeugt.

Zweitens muss das Gewicht der Zusammensetzung $CE$ höchstens gleich der Summe der Gewichte von $C$ und $E$ sein – was aus einem kurzen Nachdenken über Produkte von Pauli-Operationen folgt – und daher ist das Gewicht von $CE$ strikt kleiner als $d.$ Das impliziert, dass $CE$ proportional zu einem Element des Stabilizers unseres Codes ist, was wir zeigen wollten. Indem wir unsere Korrekturoperationen als Vertreter mit niedrigstem Gewicht der Menge von Fehlern wählen, die jeweils ein Syndrom erzeugen, sind wir daher garantiert, alle Pauli-Fehler mit Gewicht kleiner als die Hälfte der Distanz des Codes zu korrigieren.

Es gibt jedoch ein Problem. Bei Stabilizer-Codes im Allgemeinen ist es ein rechentechnisch schwieriges Problem, die Pauli-Operation mit dem niedrigsten Gewicht zu berechnen, die ein gegebenes Syndrom erzeugt. (Das gilt übrigens auch für klassische Codes, die wir in diesem Kontext als Stabilizer-Codes betrachten können, bei denen in den Stabilizer-Generatoren als Tensorfaktoren nur $\mathbb{I}$- und $Z$-Matrizen vorkommen.) Im Gegensatz zum Kodierungsschritt werden Clifford-Operationen uns dieses Mal also nicht zu Hilfe kommen.

Die Lösung besteht darin, spezifische Codes zu wählen, für die gute Korrekturen effizient berechnet werden können – dafür gibt es kein einfaches Rezept. Kurz gesagt ist die Entwicklung von Stabilizer-Codes, für die gute Korrekturoperationen effizient berechenbar sind, ein Teil der Kunst des Quantencode-Designs. Diese Kunst werden wir in der nächsten Lektion in Aktion sehen.