Diskretisierung von Fehlern

Bisher haben wir $X$-Fehler und $Z$-Fehler im Kontext des 9-Qubit-Shor-Codes betrachtet. In diesem Abschnitt befassen wir uns mit beliebigen Fehlern. Wir werden feststellen, dass wir zur Behandlung solcher Fehler nichts anderes tun müssen als das, was wir bereits besprochen haben; die Fähigkeit, $X$-Fehler, $Z$-Fehler oder beides zu korrigieren, impliziert die Fähigkeit, beliebige Fehler zu korrigieren. Dieses Phänomen wird manchmal als Diskretisierung von Fehlern bezeichnet.

Unitäre Qubit-Fehler

Beginnen wir mit einzelnen unitären Qubit-Fehlern. Solch ein Fehler könnte beispielsweise einer sehr kleinen Rotation der Bloch-Kugel entsprechen, die zum Beispiel einen Fehler durch ein nicht perfektes Gate darstellt. Oder es könnte irgendeine andere unitäre Operation auf einem Qubit sein, die nicht unbedingt nahe bei der Identität liegt.

Es mag so wirken, als wäre die Korrektur solcher Fehler schwierig. Schließlich gibt es unendlich viele solcher möglichen Fehler, und es ist undenkbar, jeden Fehler genau zu identifizieren und dann rückgängig zu machen. Solange wir jedoch einen Bit-Flip, einen Phasen-Flip oder beides korrigieren können, werden wir mit den zuvor in der Lektion beschriebenen Verfahren erfolgreich einen beliebigen einzelnen unitären Qubit-Fehler korrigieren.

Um zu verstehen, warum das so ist, erkennen wir zunächst, dass wir jede beliebige $2 \times 2$ unitäre Matrix $U$, die einen Fehler auf einem einzelnen Qubit darstellt, als Linearkombination der vier Pauli-Matrizen (einschließlich der Identitätsmatrix) ausdrücken können.

$$U = \alpha \mathbb{I} + \beta X + \gamma Y + \delta Z$$

Wie wir sehen werden, kollabieren beim Ausführen der Fehlererkennungsschaltkreise die Messungen, die uns die Syndrom-Bits liefern, den Zustand der Kodierung probabilistisch auf einen Zustand, in dem ein Fehler (oder kein Fehler), der durch eine der vier Pauli-Matrizen dargestellt wird, eingetreten ist. (Aus der Tatsache, dass $U$ unitär ist, folgt, dass die Zahlen $\alpha,$ $\beta,$ $\gamma,$ und $\delta$ die Bedingung $\vert\alpha\vert^2 + \vert\beta\vert^2 + \vert\gamma\vert^2 + \vert\delta\vert^2 = 1$ erfüllen müssen, und tatsächlich sind $\vert\alpha\vert^2,$ $\vert\beta\vert^2,$ $\vert\gamma\vert^2,$ und $\vert\delta\vert^2$ die Wahrscheinlichkeiten, mit denen der kodierte Zustand auf einen Zustand kollabiert, bei dem der entsprechende Pauli-Fehler aufgetreten ist.)

Um zu erläutern, wie das genauer funktioniert, ist es praktisch, Indizes zu verwenden, um anzugeben, auf welches Qubit eine bestimmte unitäre Qubit-Operation wirkt. Wenn wir beispielsweise Qiskits Qubit-Nummerierungskonvention $(\mathsf{Q}_8,\mathsf{Q}_7,\ldots,\mathsf{Q}_0)$ zur Nummerierung der 9 Qubits des Shor-Codes verwenden, erhalten wir diese Ausdrücke für verschiedene unitäre Operationen auf einzelnen Qubits, wobei wir in jedem Fall die unitäre Matrix mit der Identitätsmatrix auf jedem anderen Qubit tensorieren.

$$\begin{aligned} X_0 & = \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes X \\[1.5mm] Z_4 & = \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \\[1.5mm] U_7 & = \mathbb{I} \otimes U \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \end{aligned}$$

Für eine gegebene unitäre Qubit-Operation $U$ können wir die Wirkung von $U$ auf Qubit $k$ mit folgender Formel angeben, die der vorherigen ähnelt, wobei jede Matrix eine auf Qubit $k$ angewendete Operation darstellt.

$$U_k = \alpha \mathbb{I}_k + \beta X_k + \gamma Y_k + \delta Z_k$$

Sei nun $\vert\psi\rangle$ die 9-Qubit-Kodierung eines Qubit-Zustands. Wenn der Fehler $U$ auf Qubit $k$ auftritt, erhalten wir den Zustand $U_k \vert\psi\rangle$, der als Linearkombination von Pauli-Operationen, die auf $\vert\psi\rangle$ wirken, wie folgt ausgedrückt werden kann.

$$U_k \vert\psi\rangle = \alpha \vert\psi\rangle + \beta X_k\vert\psi\rangle + \gamma Y_k\vert\psi\rangle + \delta Z_k\vert\psi\rangle$$

An diesem Punkt nehmen wir die Substitution $Y = iXZ$ vor.

$$U_k \vert\psi\rangle = \alpha \vert\psi\rangle + \beta X_k\vert\psi\rangle + i \gamma X_kZ_k\vert\psi\rangle + \delta Z_k\vert\psi\rangle$$

Betrachten wir nun die zuvor beschriebenen Fehlererkennungs- und Korrekturschritte. Wir können die Messergebnisse der drei inneren Code-Paritätsprüfungen zusammen mit denen des äußeren Codes als ein einziges Syndrom aus 8 Bits betrachten. Unmittelbar vor den eigentlichen Standardbasismessungen, die diese Syndrom-Bits erzeugen, hat der Zustand die folgende Form.

$$\begin{gathered} \alpha\,\vert \mathbb{I} \text{ Syndrom}\rangle \otimes \vert\psi\rangle \\ + \beta\,\vert X_k \text{ Syndrom}\rangle \otimes X_k\vert\psi\rangle \\ + i \gamma\,\vert X_k Z_k \text{ Syndrom}\rangle \otimes X_k Z_k\vert\psi\rangle \\ + \delta\,\vert Z_k \text{ Syndrom}\rangle \otimes Z_k\vert\psi\rangle \end{gathered}$$

Um das klarzustellen: Wir haben an diesem Punkt zwei Systeme. Das System auf der linken Seite sind die 8 Qubits, die wir messen, um das Syndrom zu erhalten, wobei $\vert \mathbb{I} \text{ Syndrom}\rangle,$ $\vert X_k \text{ Syndrom}\rangle$ usw. für den jeweiligen 8-Qubit-Standardbasiszustand stehen, der mit dem entsprechenden Fehler (oder Nicht-Fehler) konsistent ist. Das System auf der rechten Seite sind die 9 Qubits, die wir für die Kodierung verwenden.

Beachte, dass diese beiden Systeme nun (im Allgemeinen) korreliert sind – und das ist der Schlüssel dazu, warum dies funktioniert. Durch Messen des Syndroms kollabiert der Zustand der 9 Qubits auf der rechten Seite effektiv auf einen, bei dem ein Pauli-Fehler, der mit dem gemessenen Syndrom übereinstimmt, auf eines der Qubits angewendet wurde. Außerdem liefert das Syndrom selbst genug Information, um den Fehler rückgängig zu machen und die ursprüngliche Kodierung $\vert\psi\rangle$ wiederherzustellen.

Wenn die Syndrom-Qubits gemessen und die entsprechenden Korrekturen vorgenommen werden, erhalten wir einen Zustand, der als Dichtematrix ausgedrückt werden kann:

$$\xi \otimes \vert\psi\rangle\langle\psi\vert,$$

wobei

$$\begin{aligned} \xi = & \vert\alpha\vert^2 \vert \mathbb{I} \text{ Syndrom}\rangle\langle \mathbb{I} \text{ Syndrom}\vert \\[1mm] & + \vert\beta\vert^2 \vert X_k \text{ Syndrom}\rangle\langle X_k \text{ Syndrom}\vert\\[1mm] & + \vert\gamma\vert^2 \vert X_k Z_k \text{ Syndrom}\rangle\langle X_k Z_k \text{ Syndrom}\vert\\[1mm] & + \vert\delta\vert^2 \vert Z_k \text{ Syndrom}\rangle\langle Z_k \text{ Syndrom}\vert. \end{aligned}$$

Entscheidend ist, dass dies ein Produktzustand ist: Wir haben unsere ursprüngliche, unverfälschte Kodierung als rechten Tensorfaktor, und auf der linken Seite haben wir eine Dichtematrix $\xi$, die ein zufälliges Fehlersyndrom beschreibt. Es gibt keine Korrelation mehr mit dem System auf der rechten Seite, das das einzige ist, das uns interessiert, weil die Fehler korrigiert wurden. An diesem Punkt können wir die Syndrom-Qubits verwerfen oder zurücksetzen, sodass wir sie erneut verwenden können. So wird die durch Fehler erzeugte Zufälligkeit – oder Entropie – aus dem System entfernt.

Das ist die Diskretisierung von Fehlern für den Spezialfall unitärer Fehler. Im Wesentlichen projizieren wir durch das Messen des Syndroms den Fehler effektiv auf einen Fehler, der durch eine Pauli-Matrix beschrieben wird.

Auf den ersten Blick mag es zu schön klingen, um wahr zu sein, dass wir beliebige unitäre Fehler auf diese Weise korrigieren können, sogar Fehler, die winzig und für sich genommen kaum wahrnehmbar sind. Was man hier jedoch verstehen muss: Es handelt sich um einen unitären Fehler auf einem einzelnen Qubit, und durch das Design des Codes kann eine Einzel-Qubit-Operation den Zustand des kodierten logischen Qubits nicht verändern. Alles, was sie bewirken kann, ist, den Zustand aus dem Unterraum gültiger Kodierungen herauszubewegen – doch dann kollabieren die Fehlererkennungen den Zustand, und die Korrekturen bringen ihn zurück an seinen Ausgangspunkt.

Beliebige Qubit-Fehler

Abschließend betrachten wir beliebige Fehler, die nicht unbedingt unitär sind. Genauer gesagt betrachten wir einen Fehler, der durch einen beliebigen Qubit-Kanal $\Phi$ beschrieben wird. Das könnte zum Beispiel ein Dephasierungs- oder Depolarisierungskanal sein, ein Reset-Kanal oder ein ungewöhnlicher Kanal, über den wir noch nie nachgedacht haben.

Der erste Schritt besteht darin, eine beliebige Kraus-Darstellung von $\Phi$ zu betrachten.

$$\Phi(\sigma) = \sum_j A_j \sigma A_j^{\dagger}$$

Dies ist ein Qubit-Kanal, also ist jedes $A_j$ eine $2\times 2$-Matrix, die wir als Linearkombination von Pauli-Matrizen ausdrücken können.

$$A_j = \alpha_j \mathbb{I} + \beta_j X + \gamma_j Y + \delta_j Z$$

Damit können wir die Wirkung des Fehlers $\Phi$ auf ein gewähltes Qubit $k$ in Termen von Pauli-Matrizen wie folgt ausdrücken.

$$\Phi_k \bigl( \vert\psi\rangle\langle\psi\vert\bigr) = \sum_j (\alpha_j \mathbb{I}_k + \beta_j X_k + \gamma_j Y_k + \delta_j Z_k) \vert\psi\rangle\langle\psi\vert (\alpha_j \mathbb{I}_k + \beta_j X_k + \gamma_j Y_k + \delta_j Z_k)^{\dagger}$$

Kurz gesagt: Wir haben alle unsere Kraus-Matrizen als Linearkombinationen von Pauli-Matrizen entwickelt.

Wenn wir nun das Fehlersyndrom berechnen und messen und alle aufgedeckten Fehler korrigieren, erhalten wir einen ähnlichen Zustand wie im Fall eines unitären Fehlers:

$$\xi \otimes \vert\psi\rangle\langle\psi\vert,$$

wobei diesmal gilt:

$$\begin{aligned} \xi = & \sum_j \Bigl(\vert\alpha_j\vert^2 \vert \mathbb{I} \text{ Syndrom}\rangle\langle \mathbb{I} \text{ Syndrom}\vert \\[-3mm] & \qquad + \vert\beta_j\vert^2 \vert X_k \text{ Syndrom}\rangle\langle X_k \text{ Syndrom}\vert\\[2mm] & \qquad + \vert\gamma_j\vert^2 \vert X_k Z_k \text{ Syndrom}\rangle\langle X_k Z_k \text{ Syndrom}\vert\\[2mm] & \qquad + \vert\delta_j\vert^2 \vert Z_k \text{ Syndrom}\rangle\langle Z_k \text{ Syndrom}\vert \Bigr). \end{aligned}$$

Die Details sind etwas unübersichtlicher und werden hier nicht gezeigt. Konzeptuell ist die Idee identisch mit dem unitären Fall.

Verallgemeinerung

Die Diskretisierung von Fehlern verallgemeinert sich auf andere quantenfehlerkorrigierende Codes, einschließlich solcher, die Fehler auf mehreren Qubits erkennen und korrigieren können. In solchen Fällen können Fehler auf mehreren Qubits als Tensorprodukte von Pauli-Matrizen ausgedrückt werden, und entsprechend verschiedene Syndrome geben Pauli-Operationskorrekturen vor, die möglicherweise auf mehreren Qubits statt nur einem durchgeführt werden.

Durch das Messen des Syndroms werden Fehler effektiv auf eine diskrete Menge von Möglichkeiten projiziert oder kollabiert, die durch Tensorprodukte von Pauli-Matrizen repräsentiert werden; durch die Korrektur dieser Pauli-Fehler können wir den ursprünglich kodierten Zustand wiederherstellen. Die dabei erzeugte Zufälligkeit wird derweil in die Syndrom-Qubits übertragen, die verworfen oder zurückgesetzt werden – und so wird die in diesem Prozess erzeugte Zufälligkeit aus dem System entfernt, das die Kodierung speichert.