Kontrolle der Fehlerausbreitung

Fehlertolerante Quantenberechnung gleicht einem Wettlauf zwischen Fehlern und Fehlerkorrektur. Wenn die Anzahl der Fehler klein genug ist, wird die Fehlerkorrektur sie erfolgreich korrigieren; wenn es zu viele Fehler gibt, schlägt die Fehlerkorrektur fehl.

Aus diesem Grund muss der Art und Weise, wie Quantenberechnungen in fehlertoleranten Schaltkreisimplementierungen durchgeführt werden, besondere Sorgfalt gewidmet werden, um die Fehlerausbreitung zu kontrollieren. Das heißt: Ein Fehler auf einem Qubit kann sich durch die Wirkung von Gates in einem Quantenschaltkreis potenziell auf mehrere Qubits ausbreiten, was dazu führen kann, dass die Anzahl der Fehler dramatisch zunimmt. Das ist ein zentrales Anliegen, denn wenn wir die Fehlerausbreitung nicht kontrollieren, werden unsere Fehlerkorrekturmaßnahmen schnell von Fehlern überwältigt. Wenn wir dagegen die Ausbreitung von Fehlern unter Kontrolle halten können, hat die Fehlerkorrektur eine echte Chance, mit den Fehlern Schritt zu halten, sodass sie schnell genug korrigiert werden können, um die Quantenberechnung wie beabsichtigt funktionieren zu lassen.

Der Ausgangspunkt für eine technische Diskussion dieses Problems ist die Erkenntnis, dass Zwei-Qubit-Gates (oder allgemeiner Mehr-Qubit-Gates) Fehler ausbreiten können, selbst wenn sie perfekt funktionieren. Betrachte beispielsweise ein kontrolliertes-NOT-Gate und nehme an, dass ein $X$-Fehler kurz vor dem CNOT-Gate auf dem Kontroll-Qubit auftritt. Wie wir bereits in der Lektion „Quantenfehler korrigieren" beobachtet haben, entspricht dies einem $X$-Fehler, der auf beiden Qubits nach dem CNOT auftritt. Ähnlich verhält es sich mit einem $Z$-Fehler auf dem Ziel- statt dem Kontroll-Qubit vor dem CNOT-Gate.

Dies ist eine Fehlerausbreitung, weil der ungünstige Ort eines $X$- oder $Z$-Fehlers vor dem CNOT-Gate diesen nach dem CNOT-Gate effektiv in zwei Fehler verwandelt. Das passiert sogar dann, wenn das CNOT-Gate perfekt ist, und wir dürfen nicht vergessen, dass ein gegebenes CNOT-Gate selbst verrauscht sein kann, was korrelierte Fehler auf zwei Qubits erzeugen kann.

Hinzu kommt, dass nachfolgende Zwei-Qubit-Gates diese Fehler noch weiter ausbreiten könnten, wie die folgende Abbildung andeutet.

In gewissem Sinne können wir dem nie ganz entgehen; solange wir Mehr-Qubit-Gates verwenden, gibt es immer ein Potenzial für Fehlerausbreitung. Aber wie wir in den folgenden Unterabschnitten besprechen werden, können Maßnahmen ergriffen werden, um den dadurch verursachten Schaden zu begrenzen und propagierte Fehler handhabbar zu machen.

Transversale Gate-Implementierungen

Der einfachste bekannte Weg, die Fehlerausbreitung in fehlertoleranten Quantenschaltkreisen zu mildern, ist die transversale Implementierung von Gates, was bedeutet, dass Gadgets mit einer bestimmten einfachen Form für sie gebaut werden. Konkret müssen die Gadgets ein Tensorprodukt von Operationen sein (oder, mit anderen Worten, ein Tiefe-Eins-Quantenschaltkreis), wobei jede Operation nur auf einer einzigen Qubit-Position innerhalb jedes Codeblocks wirken darf, den sie berührt. Dies lässt sich am besten durch einige Beispiele erklären.

Beispiele für transversale Gate-Implementierungen

Betrachte die folgende Abbildung, die eine transversale Implementierung eines CNOT-Gates andeutet. (Diese spezielle Implementierung, bei der CNOTs qubitweise durchgeführt werden, funktioniert nur für CSS-Codes – aber sie funktioniert tatsächlich für alle CSS-Codes.)

In dieser Abbildung gibt es zwei Codeblöcke, die jeweils als aus fünf Qubits bestehend dargestellt sind (obwohl es auch mehr sein könnten, wie bereits angedeutet). Der Schaltkreis auf der rechten Seite hat Tiefe eins, und jedes der CNOT-Gates wirkt auf eine einzige Qubit-Position innerhalb jedes Blocks: Sowohl die Kontrolle als auch das Ziel des ersten CNOTs ist das oberste Qubit (also Qubit 0 in Qiskits Nummerierungskonvention), Sowohl Kontrolle als auch Ziel des zweiten CNOTs ist das zweitoberste Qubit (also Qubit 1), und so weiter. Daher ist dies ein transversales Gadget.

Als zweites Beispiel – eigentlich eine Klasse von Beispielen – betrachten wir ein beliebiges Pauli-Gate. Pauli-Gates können immer transversal implementiert werden, für jeden Stabilisator-Code, indem Gadgets aus Pauli-Operationen aufgebaut werden. Insbesondere kann jede Pauli-Operation auf einem logischen Qubit, das durch einen Stabilisator-Code kodiert ist, transversal implementiert werden, indem eine geeignete Pauli-Operation auf den physischen Qubits der Kodierung gewählt wird. Das stimmt mit einer Tatsache überein, die in der Lektion „Stabilisatorformalismus" beiläufig erwähnt wurde: Bis auf einen globalen Phasenfaktor wirken Pauli-Operationen, die mit jedem Stabilisatorgenerator eines Stabilisator-Codes kommutieren, wie Pauli-Operationen auf dem durch diesen Code kodierten Qubit oder den Qubits.

Als konkretes Beispiel betrachten wir den $9$-Qubit-Shor-Code, für den Standardbasiszustände wie folgt 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) \\[3mm] \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}$$

Ein $X$-Gate auf dem durch diesen Code kodierten logischen Qubit kann transversal durch die $9$-Qubit-Pauli-Operation

$$Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I}$$

implementiert werden, während ein $Z$-Gate auf dem logischen Qubit transversal durch die $9$-Qubit-Pauli-Operation

$$X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}$$

implementiert werden kann.

Beide Pauli-Operationen haben Gewicht $3$, was das minimal erforderliche Gewicht ist. (Der $9$-Qubit-Shor-Code hat Distanz $3$, daher wird jede nicht-identische Pauli-Operation mit Gewicht $2$ oder weniger als Fehler erkannt.)

Als drittes Beispiel erlaubt der $7$-Qubit-Steane-Code (und tatsächlich jeder Farb-Code) eine transversale Implementierung aller Clifford-Gates. Wir haben bereits gesehen, wie CNOT-Gates für jeden CSS-Code transversal implementiert werden, es verbleiben also nur $H$- und $S$-Gates zu betrachten. Ein Hadamard-Gate auf alle $7$ Qubits des Steane-Codes angewendet entspricht $H$ auf dem logischen Qubit, das er kodiert, während ein $S^{\dagger}$-Gate (statt eines $S$-Gates) auf alle $7$ Qubits einem logischen $S$-Gate entspricht.

Fehlerausbreitung für transversale Gadgets

Nachdem wir nun wissen, was transversale Implementierungen von Gates sind, besprechen wir ihren Zusammenhang mit der Fehlerausbreitung.

Bei einer transversalen Implementierung eines Einzel-Qubit-Gates haben wir einfach ein Tensorprodukt von Einzel-Qubit-Gates in unserem Gadget, das auf einen Codeblock physischer Qubits für den gewählten quantenfehlerkorrigierenden Code wirkt. Obwohl jedes dieser Gates fehlschlagen und einen Fehler einführen könnte, wird es keine Ausbreitung von Fehlern geben, da keine Mehr-Qubit-Gates beteiligt sind. Unmittelbar nach der Anwendung des Gadgets wird Fehlerkorrektur durchgeführt; und wenn die Anzahl der durch das Gadget eingeführten Fehler (oder während der Ausführung des Gadgets) ausreichend klein ist, werden die Fehler korrigiert. Wenn also die Rate der durch fehlerhafte Gates eingeführten Fehler ausreichend klein ist, hat die Fehlerkorrektur gute Chancen, erfolgreich zu sein.

Bei einer transversalen Implementierung eines Zwei-Qubit-Gates besteht hingegen das Potenzial für eine Fehlerausbreitung – es gibt einfach keine Möglichkeit, das zu vermeiden, wie wir bereits beobachtet haben. Der wesentliche Punkt ist jedoch, dass ein transversales Gadget niemals eine Fehlerausbreitung innerhalb eines einzelnen Codeblocks verursachen kann.

Betrachte beispielsweise die transversale Implementierung eines CNOT-Gates für einen CSS-Code, wie oben beschrieben: Ein $X$-Fehler könnte auf dem obersten Qubit des oberen Codeblocks kurz vor der Ausführung des Gadgets auftreten, und das erste CNOT innerhalb des Gadgets wird diesen Fehler auf das oberste Qubit im unteren Block ausbreiten. Die zwei resultierenden Fehler befinden sich jedoch nun in getrennten Codeblöcken. Unter der Annahme, dass unser Code einen $X$-Fehler korrigieren kann, werden die Fehlerkorrekturschritte nach dem Gadget die beiden $X$-Fehler einzeln korrigieren – da in jedem Codeblock nur ein einzelner Fehler auftritt. Im Gegensatz dazu könnte, wenn Fehlerausbreitung innerhalb desselben Codeblocks stattfinden würde, ein Fehler mit niedrigem Gewicht in einen Fehler mit hohem Gewicht verwandelt werden, den der Code nicht handhaben kann.

Nicht-Universalität transversaler Gates

Bei zwei verschiedenen Stabilisator-Codes kann es vorkommen, dass ein bestimmtes Gate transversal mit einem Code, aber nicht mit dem anderen implementiert werden kann. Obwohl es zum Beispiel nicht möglich ist, ein $T$-Gate transversal mit dem $7$-Qubit-Steane-Code zu implementieren, gibt es andere Codes, für die das möglich ist.

Leider ist es für keinen nicht-trivialen quantenfehlerkorrigierenden Code möglich, eine universelle Menge von Gates transversal zu implementieren. Diese Tatsache ist als das Eastin-Knill-Theorem bekannt.

Theorem

Eastin-Knill-Theorem: Für jeden quantenfehlerkorrigierenden Code mit Distanz mindestens 2 ist die Menge der logischen Gates, die transversal implementiert werden können, diskret (bis auf einen globalen Phasenfaktor) und daher nicht universell.

Der Beweis dieses Theorems wird hier nicht erläutert. (Es ist kein komplizierter Beweis, erfordert aber Grundkenntnisse über Lie-Gruppen und Lie-Algebren, die nicht zu den Voraussetzungen der Reihe gehören.) Die grundlegende Idee kann jedoch intuitiv vermittelt werden: Unendliche Familien transversaler Operationen können nicht im Koderaum eines nicht-trivialen Codes bleiben, weil winzige Unterschiede in transversalen Operationen gut durch Pauli-Operationen mit niedrigem Gewicht approximiert werden, die der Code als Fehler erkennt.

Zusammenfassend bieten transversale Gadgets eine einfache und inhärent fehlertolerante Implementierung von Gates – aber für jede vernünftige Wahl eines quantenfehlerkorrigierenden Codes wird es niemals ein universelles Gate-Set geben, das auf diese Weise implementiert werden kann, was die Verwendung alternativer Gadgets erfordert.

Magische Zustände

Da es für keinen nicht-trivialen Quantenfehlerkorrekturcode möglich ist, eine universelle Menge von Quanten-Gates transversal zu implementieren, müssen wir andere Methoden in Betracht ziehen, um Gates fehlertolerant zu implementieren. Eine bekannte Methode basiert auf dem Konzept der magischen Zustände, das sind Qubit-Zustände, die fehlertolerante Implementierungen bestimmter Gates ermöglichen.

Gates mit magischen Zuständen implementieren

Beginnen wir mit $S$- und $T$-Gates, die folgende Matrixdarstellungen haben.

$$S = \begin{pmatrix} 1 & 0\\ 0 & i \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/2} \end{pmatrix} \qquad\text{und}\qquad T = \begin{pmatrix} 1 & 0\\ 0 & \frac{1+i}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/4} \end{pmatrix}$$

Per Definition ist $S$ eine Clifford-Operation, während $T$ es nicht ist; es ist nicht möglich, ein $T$-Gate mit einem Schaltkreis aus Clifford-Gates ($H$-Gates, $S$-Gates und CNOT-Gates) zu implementieren.

Es ist jedoch möglich, ein $T$-Gate (bis auf einen globalen Phasenfaktor) mit einem Schaltkreis aus Clifford-Gates zu implementieren, wenn wir zusätzlich eine Kopie des Zustands

$$T\vert {+} \rangle = \frac{1}{\sqrt{2}} \vert 0 \rangle + \frac{e^{i\pi/4}}{\sqrt{2}} \vert 1\rangle$$

haben und Standardbasismessungen sowie klassisch gesteuerte Gates erlaubt sind. Insbesondere zeigt der folgende Schaltkreis eine Möglichkeit, das zu tun. Das hier gezeigte Phänomen ist ein etwas vereinfachtes Beispiel für Quanten-Gate-Teleportation.

Um zu überprüfen, dass dieser Schaltkreis korrekt funktioniert, berechnen wir zunächst die Wirkung des CNOT-Gates auf die Eingabe.

$$T \vert {+} \rangle \otimes \vert\psi\rangle \stackrel{\text{CNOT}}{\longmapsto} \frac{1}{\sqrt{2}} \vert 0\rangle \otimes T \vert \psi\rangle + \frac{1+i}{2} \vert 1\rangle \otimes T^{\dagger} \vert \psi\rangle$$

Die Messung ergibt die Ergebnisse $0$ und $1$ mit gleicher Wahrscheinlichkeit. Wenn das Ergebnis $0$ ist, wird das $S$-Gate nicht durchgeführt, und der Ausgabezustand ist $T\vert\psi\rangle$; und wenn das Ergebnis $1$ ist, wird das $S$-Gate durchgeführt, und der Ausgabezustand ist $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle.$

Der Zustand $T\vert {+}\rangle$ wird in diesem Kontext als magischer Zustand bezeichnet, obwohl er nicht der einzige ist: Andere Zustände werden ebenfalls als magische Zustände bezeichnet, wenn sie auf ähnliche Weise (für möglicherweise andere Gates und mit anderen Schaltkreisen) verwendet werden können. Wenn man zum Beispiel den Zustand $T\vert{+}\rangle$ durch den Zustand $S\vert{+}\rangle$ austauscht und das $S$-Gate im obigen Schaltkreis durch ein $Z$-Gate ersetzt, wird ein $S$-Gate implementiert – was für fehlertolerante Quantenberechnungen nützlich sein könnte, die einen Code verwenden, für den $S$-Gates nicht transversal implementiert werden können.

Fehlertolerante Gadgets aus magischen Zuständen

Es ist möglicherweise nicht offensichtlich, dass die Verwendung von magischen Zuständen zur Implementierung von Gates für die Fehlertoleranz hilfreich ist. Bei der oben beschriebenen $T$-Gate-Implementierung scheint es zum Beispiel so, als müssten wir immer noch ein $T$-Gate auf einen $\vert{+}\rangle$-Zustand anwenden, um einen magischen Zustand zu erhalten, den wir dann verwenden, um ein $T$-Gate zu implementieren. Was ist also der Vorteil dieses Ansatzes für die Fehlertoleranz?

Hier sind drei wichtige Punkte, die eine Antwort auf diese Frage geben.

1. Die Erstellung magischer Zustände erfordert nicht die Anwendung des Gates, das wir zu implementieren versuchen, auf einen bestimmten Zustand. Beispielsweise ist das Anwenden eines $T$-Gates auf einen $\vert {+} \rangle$-Zustand nicht die einzige Möglichkeit, einen $T\vert{+}\rangle$-Zustand zu erhalten.

2. Die Erstellung magischer Zustände kann getrennt von der Berechnung erfolgen, in der sie verwendet werden. Das bedeutet, dass Fehler, die im Prozess der Erstellung magischer Zustände entstehen, sich nicht auf die eigentlich durchgeführte Berechnung ausbreiten.

3. Wenn die einzelnen Gates im Schaltkreis, der ein gewähltes Gate unter Verwendung eines magischen Zustands implementiert, fehlertolerant implementiert werden können, und wir die Verfügbarkeit magischer Zustände voraussetzen, erhalten wir eine fehlertolerante Implementierung des gewählten Gates.

Um die folgende Diskussion zu vereinfachen, konzentrieren wir uns auf $T$-Gates – dabei ist zu beachten, dass die Methodik auf andere Gates ausgeweitet werden kann. Eine fehlertolerante Implementierung eines $T$-Gates mithilfe magischer Zustände hat die Form, die durch die folgende Abbildung angedeutet wird.

Qubits im ursprünglichen $T$-Gate-Schaltkreis entsprechen in diesem Diagramm logischen Qubits, die durch den Code kodiert sind, den wir für die Fehlertoleranz verwenden. Die Ein- und Ausgaben im Diagramm sollten daher als Kodierungen dieser Zustände verstanden werden. Das bedeutet insbesondere, dass wir tatsächlich keine magischen Zustände benötigen – wir benötigen kodierte magische Zustände. Die Gates im ursprünglichen $T$-Gate-Schaltkreis werden hier durch Gadgets ersetzt, die wir als fehlertolerant annehmen.

Diese Abbildung legt daher nahe, dass wir bereits fehlertolerante Gadgets für CNOT-Gates und $S$-Gates haben. Für einen Farb-Code könnten diese Gadgets transversal sein; für einen Oberflächencode (oder jeden anderen CSS-Code) kann das CNOT transversal durchgeführt werden, während das $S$-Gate-Gadget selbst mithilfe von magischen Zuständen implementiert werden könnte, wie es zuvor als möglich angedeutet wurde. (Die Abbildung deutet auch an, dass wir ein fehlertolerantes Gadget zur Durchführung einer Standardbasismessung haben, was wir bisher ignoriert haben. Das könnte für einige Codes tatsächlich eine Herausforderung sein, aber für einen CSS-Code ist es eine Sache, jedes physische Qubit zu messen und dann klassisch nachzuverarbeiten.)

Die Implementierung ist daher fehlertolerant, vorausgesetzt wir haben eine Kodierung eines magischen Zustands $T\vert{+}\rangle$. Aber wir haben noch nicht das Problem behandelt, wie wir eine Kodierung dieses Zustands erhalten. Eine Möglichkeit, kodierte magische Zustände zu erhalten (oder genauer gesagt, sie besser zu machen), ist ein Prozess, der als Magic-State-Destillation bekannt ist. Das folgende Diagramm veranschaulicht, wie dieser Prozess auf höchster Ebene aussieht.

In Worten: Eine Sammlung verrauschter kodierter magischer Zustände wird in einen speziellen Schaltkreis, einen sogenannten Destillator, eingespeist. Alle bis auf einen der Ausgabeblöcke werden gemessen – das bedeutet, dass logische Qubits mit Standardbasismessungen gemessen werden. Wenn eines der Messergebnisse $1$ ist, hat der Prozess versagt und muss neu gestartet werden. Wenn jedoch jedes Messergebnis $0$ ist, wird der resultierende Zustand des obersten Codeblocks ein weniger verrauschter kodierter magischer Zustand sein. Dieser Zustand könnte dann zusammen mit vier weiteren als Eingabe in einen anderen Destillator eingehen oder verwendet werden, um ein $T$-Gate zu implementieren, wenn er als ausreichend nah an einem wahren kodierten magischen Zustand angesehen wird. Natürlich muss der Prozess irgendwo beginnen – eine Möglichkeit ist, die magischen Zustände nicht-fehlertolerant vorzubereiten.

Es gibt verschiedene bekannte Möglichkeiten, den Destillator selbst zu bauen, die hier nicht erklärt oder analysiert werden. Auf logischer Ebene ist der typische Ansatz – bemerkenswert und etwas zufällig – einen Kodierschaltkreis für einen Stabilisator-Code rückwärts auszuführen! Das könnte tatsächlich ein anderer Stabilisator-Code sein als der, der für die Fehlerkorrektur verwendet wird. Man könnte beispielsweise einen Oberflächen- oder Farb-Code für die Fehlerkorrektur verwenden, aber einen Kodierer für den $5$-Qubit-Code rückwärts für die Magic-State-Destillation ausführen. Kodierschaltkreise für Stabilisator-Codes erfordern nur Clifford-Gates, was die fehlertolerante Implementierung eines Destillators vereinfacht. In der Praxis hängen die Einzelheiten von den verwendeten Codes ab.

Zusammenfassend hat dieser Abschnitt nur eine sehr allgemeine Diskussion magischer Zustände angeboten, mit der Absicht, lediglich eine grundlegende Vorstellung davon zu vermitteln, wie das funktioniert. Manchmal wird behauptet, dass der Overhead für die fehlertolerante Implementierung von Gates mithilfe magischer Zustände auf diese Weise extrem hoch wäre, wobei der überwiegende Teil der Arbeit in den Destillationsprozess fließt. Das ist jedoch tatsächlich nicht so klar – es gibt viele potenzielle Optimierungsmöglichkeiten für diese Prozesse. Darüber hinaus gibt es alternative Ansätze zum Aufbau fehlertoleranter Gadgets für Gates, die nicht transversal implementiert werden können. Zum Beispiel sind Code-Deformation und Code-Switching Schlagwörter, die mit einigen dieser Schemata verbunden sind – und neue Methoden werden weiterhin entwickelt und verfeinert.

Fehlertolerante Fehlerkorrektur

Neben der Implementierung der verschiedenen Gadgets, die für eine fehlertolerante Implementierung eines gegebenen Quantenschaltkreises erforderlich sind, gibt es ein weiteres wichtiges Problem, das anerkannt werden muss: die Implementierung der Fehlerkorrekturschritte selbst. Das geht auf die Idee zurück, dass alles, was Quanteninformation betrifft, für Fehler anfällig ist – einschließlich der Schaltkreise, die selbst dazu gedacht sind, Fehler zu korrigieren.

Betrachte beispielsweise den Typ von Schaltkreis, der in der Lektion „Der Stabilisatorformalismus" zur nicht-destruktiven Messung von Stabilisatorgeneratoren mithilfe von Phasenschätzung beschrieben wurde. Diese Schaltkreise sind eindeutig nicht fehlertolerant, da sie dazu führen können, dass sich Fehler innerhalb des Codeblocks ausbreiten, auf dem sie operieren. Das mag ziemlich problematisch erscheinen, aber es gibt mehrere bekannte Wege, Fehlerkorrektur fehlertolerant durchzuführen, ohne Fehler innerhalb der zu korrigierenden Codeblöcke auszubreiten.

Eine Methode ist als Shor-Fehlerkorrektur bekannt, weil sie von Peter Shor erstmals entdeckt wurde. Die Idee ist, Syndrom-Messungen mithilfe eines sogenannten cat state durchzuführen, einem $n$-Qubit-Zustand der Form

$$\frac{1}{\sqrt{2}} \vert 0^n \rangle + \frac{1}{\sqrt{2}} \vert 1^n \rangle,$$

wobei $0^n$ und $1^n$ die aus lauter Nullen bzw. lauter Einsen bestehenden Strings der Länge $n$ bezeichnen. Das ist beispielsweise ein $\vert\phi^+\rangle$-Bell-Zustand für $n=2$ und ein GHZ-Zustand für $n=3$, aber im Allgemeinen erfordert die Shor-Fehlerkorrektur einen solchen Zustand für $n$ als das Gewicht des zu messenden Stabilisatorgenerators.

Als Beispiel misst der hier gezeigte Schaltkreis einen Stabilisatorgenerator der Form $P_2\otimes P_1 \otimes P_0.$

Das erfordert auch den Aufbau des cat state selbst, und damit es in Gegenwart von Fehlern und möglicherweise fehlerhaften Gates zuverlässig funktioniert, erfordert die Methode tatsächlich die wiederholte Ausführung solcher Schaltkreise, um Rückschlüsse darauf zu ziehen, wo im Prozess verschiedene Fehler aufgetreten sein könnten.

Eine alternative Methode ist als Steane-Fehlerkorrektur bekannt. Diese Methode funktioniert anders und funktioniert nur für CSS-Codes. Die Idee ist, dass wir die Syndrom-Messungen auf den kodierten Quantenzuständen des Schaltkreises, den wir ausführen wollen, nicht tatsächlich durchführen, sondern stattdessen Fehler absichtlich auf ein Workspace-System ausbreiten und dann dieses System messen und Fehler klassisch erkennen. Die folgenden Schaltkreisdiagramme veranschaulichen, wie dies für die Erkennung von $X$- bzw. $Z$-Fehlern erfolgen kann.

Eine verwandte Methode, die als Knill-Fehlerkorrektur bekannt ist, erweitert diese Methode auf beliebige Stabilisator-Codes mithilfe von Teleportation.