Da ich den klassischen linearen Code in vorheriger Artikel verstanden habe, handelt es sich diesmal um eine darauf basierende Klasse der Quantenfehlerkorrektur, "CSS-Code (Calderbank-). Wir werden "Shor-Steane-Code)" studieren. Wir werden auch den "Steane-Code" als eine spezifische Codemethode betrachten. Nachdem Sie ein allgemeines Verständnis haben, überprüfen wir die Funktionsweise des "Steane-Codes" mit dem Quantenberechnungssimulator qlazy.
"CSS-Code" entspricht übrigens einer Unterklasse von "Stabilisator-Code", einer allgemeineren Klasse der Quantenfehlerkorrektur. Dieser Artikel ist auch ein Sprungbrett dafür.
Die folgenden Dokumente wurden als Referenz verwendet.
$ C_1 $ und $ C_2 $ sind die klassischen linearen Codes $ [n, k_1] $ und $ [n, k_2] $ und sind $ C_2 \ Teilmenge C_1 $. Nehmen Sie außerdem an, dass $ C_1 $ und $ C_ {2} ^ {\ perp} $ beide $ t $ -Fehler behandeln können. Zu diesem Zeitpunkt kann der CSS-Code $ CSS (C_1, C_2) $ als der Quantencode von $ [n, k_1 - k_2] $ konstruiert werden, der $ t $ -Fehler behandeln kann. Angenommen, $ x \ in C_1 $ ist ein beliebiges Vorzeichenwort im Vorzeichen $ C_1 $. Zu diesem Zeitpunkt ist der Quantenzustand $ \ ket {x + C_2} $,
\ket{x+C_2} \equiv \frac{1}{\sqrt{|C_{2}|}} \sum_{y \in C_2} \ket{x+y} \tag{1}
Es ist definiert als. Hier repräsentiert $ + $ auf der rechten Seite die Summe jedes Bits Modulo 2 (und so weiter). Der Code, der durch die Überlagerung dieser $ \ ket {x + C_2} $ dargestellt wird, ist der CSS-Code.
Ich weiß nicht was es ist. Kauen.
Auf der rechten Seite von Gleichung (1) wird nun der Zustandsvektor $ \ ket {x + y} $, der die Summe des Elements $ x $ von $ C_1 $ und des Elements $ y $ von $ C_2 $ ist, als Index für alle $ verwendet. Es sieht so aus, als würde man in C_2 $ ungefähr y \ hinzufügen. Es wird durch das Symbol $ \ ket {x + C_2} $ definiert. Mit anderen Worten, $ \ ket {x + C_2} $ setzt einen $ \ ket {x} \ Raum (x \ in C_1) $, während alle $ y \ in C_2 $ Es ist ein überlagerter Zustand, in dem alle Konvertierungen (Hinzufügen von $ y $ zum Inhalt des Kets), die durch Mobilisieren aller oben genannten Elemente durchgeführt werden, kombiniert werden.
Beachten Sie, dass selbst wenn Sie die Elemente des linearen Codes addieren, diese Elemente desselben linearen Codes sind [^ 1], sodass der Inhalt aller Kets auf der rechten Seite die Elemente von $ C_1 $ sind. Machen wir das. Das heißt, jeder der Samen $ x \ in C_1 $ plus alle $ y \ in C_2 \ Teilmenge C_1 $ ist ein Zeichen, das zu $ C_1 $ gehört. Jedes der Ergebnisse des Hinzufügens aller $ y \ in C_2 $ zu einem anderen $ x ^ {\ prime} \ in C_1 $ ist ebenfalls ein Code, der zu $ C_1 $ gehört. Hier ist eine Frage. Hat etwas mit den beiden Codesätzen (jeweils $ 2 ^ {k_2} $) zu tun, die aus $ x $ und $ x ^ {\ prime} $ generiert wurden? Tatsächlich sind sie entweder "alle gleich" oder "alle verschieden" und überlappen sich nicht teilweise.
[^ 1]: Betrachten Sie das $ [n, k] $ -Zeichen $ C $ und lassen Sie seine Generierungsmatrix $ G $ sein. Für jedes $ x_1, x_2 \ in \ {0,1 \} ^ {k} $, wenn $ y_1 = Gx_1, y_2 = Gx_2 $, dann $ y_1, y_2 \ in C $. Das Addieren der beiden Gleichungen ergibt $ y_1 + y_2 = G (x_1 + x_2) $, was $ x_1 + x_2 \ in \ {0,1 \} ^ {k} $ ist, also $ y_1 + y_2 \ in C. $ Ist eingerichtet.
Was meinst du?
Es ist nicht genau das Set, über das wir nachdenken, aber um ein Gefühl dafür zu bekommen, hier ein ähnliches Beispiel. Stellen Sie sich eine Reihe von ganzen Zahlen von $ 0 $ bis $ 99 $ vor. Sei dies die Menge $ C_1 $. Als nächstes extrahieren Sie ein Vielfaches von $ 3 $ aus $ C_1 $. Nennen wir es $ C_2 $. Nehmen Sie nun eine bestimmte Ganzzahl aus $ C_1 $ und verwenden Sie sie als $ x $. Verwenden Sie dies als Startwert, mobilisieren Sie alle $ y \ in C_2 $ und addieren Sie sie zu $ x $ (jedoch mit $ 100 $ als modaler Addition). Alle erhaltenen Ergebnisse sind ganze Zahlen von $ 0 $ bis $ 99 $, also sind sie Elemente von $ C_1 $. Nehmen wir zum Beispiel $ x = 6 $ an. Zu diesem Zeitpunkt sind alle durch Hinzufügen von $ y $ erstellten Ganzzahlen Vielfache von $ 3 $. Betrachten Sie $ x ^ {\ prime} = 15 $ und verwenden Sie $ y \ in C_2 $ auf die gleiche Weise, um eine Menge von ganzen Zahlen zu generieren. Wie Sie sehen können, ist dies auch ein Vielfaches von $ 3 $. Mit anderen Worten, die Menge von Ganzzahlen, die durch das Setzen von $ x = 6, x ^ {\ prime} = 15 $ erzeugt werden, ist eine exakte Übereinstimmung. Was ist als weiteres Beispiel, wenn $ x = 7, x ^ {\ prime} = 31 $? Die generierten Ganzzahlen sind eine Menge, bei der der Rest $ 1 $ beträgt, wenn beide durch $ 3 $ geteilt werden. Auch in diesem Fall sind die beiden genau gleich. Was ist als weiteres Beispiel, wenn $ x = 11, x ^ {\ prime} = 52 $? In diesem Fall wird aus $ x = 11 $ eine ganzzahlige Menge von $ 2 $ generiert, wobei der Rest durch $ 3 $ geteilt wird, und was aus $ x ^ {\ prime} = 52 $ generiert wird, wird durch $ 3 $ geteilt. Eine Reihe von ganzen Zahlen mit einem Rest von $ 1 $. Die beiden sind also völlig inkonsistent. Mit anderen Worten, es ist möglich, die Menge zu klassifizieren, die unter Verwendung der Menge $ C_2 $ mit $ x \ in C_1 $ als Startwert erzeugt wird, gemäß dem Rest, der durch Teilen durch $ 3 $ erhalten wird. Mit $ C_2 $ können Sie $ x \ in C_1 $ in drei Gruppen einteilen. Diese Klassifizierung wird als "Rest" bezeichnet (z. B. "$ 7 $ und $ 31 $ gehören zum selben Überschuss"). Sie können feststellen, ob sie zum selben Überschuss gehören, indem Sie sie subtrahieren, ohne sie alle einzeln generieren zu müssen. Versuchen wir es mit diesem Beispiel. $ 15-6 $ ist $ 9 $ und $ 31-7 $ ist $ 24 $, beide sind Vielfache von $ 3 $. Auf der anderen Seite wird aus $ 52-11 $ $ 41 $, was kein Vielfaches von $ 3 $ ist. Sie können feststellen, ob es zum selben Rest gehört, indem Sie eine Subtraktion durchführen und prüfen, ob es zu $ C_2 $ gehört.
Nun, ich werde die Analogie bis zu diesem Punkt belassen. Vergessen Sie die Definitionen von $ C_1 und C_2 $ im vorherigen Abschnitt. Wenn ich also noch einmal die Definition von Gleichung (1) betrachte, habe ich das Gefühl, dass etwas Ähnliches wahrscheinlich zutrifft. Lassen Sie mich unten zeigen, dass es sich nicht nur so anfühlt, sondern auch so.
Erstens, wenn sie zum selben Rest gehören, dh $ x, x ^ {\ prime} \ in C_1 $ und $ x-x ^ {\ prime} \ in C_2 $
\ket{x + C_2} = \ket{x^{\prime} + C_2} \tag{2}
Ist festgelegt. Lass es uns beweisen.
[Beweis]
Beweisen Sie, dass $ \ ket {x + C_2} - \ ket {x ^ {\ prime} + C_2} $ zu $ 0 $ wird.
\ket{x+C_2} - \ket{x^{\prime}+C_2} = \frac{1}{|C_2|} (\sum_{y \in C_2} \ket{x+y} - \sum_{y \in C_2} \ket{x^{\prime}+y}) \tag{3}
Setze $ x-x ^ {\ prime} = y ^ {\ prime} \ in C_2 $.
\ket{x+C_2} - \ket{x^{\prime}+C_2} = \frac{1}{|C_2|} (\sum_{y \in C_2} \ket{x^{\prime}+y^{\prime}+y} - \sum_{y \in C_2} \ket{x^{\prime}+y}) \tag{4}
Setze $ y ^ {\ prime \ prime} = y ^ {\ prime} + y $. Beachten Sie, dass $ y ^ {\ prime} $ und $ y $ Elemente desselben Vorzeichens $ C_2 $ sind, also $ y ^ {\ prime \ prime} \ in C_2 $.
\ket{x+C_2} - \ket{x^{\prime}+C_2} = \frac{1}{|C_2|} (\sum_{y^{\prime\prime} \in C_2} \ket{x^{\prime}+y^{\prime\prime}} - \sum_{y \in C_2} \ket{x^{\prime}+y}) = 0 \tag{5}
Es wird sein. (Ende der Zertifizierung)
Wenn sie zu verschiedenen Resten gehören, dh $ x, x ^ {\ prime} \ in C_1 $ und $ x-x ^ {\ prime} \ notin C_2 $
\braket{x + C_2}{x^{\prime} + C_2} = 0 \tag{6}
Ist festgelegt. Lass es uns beweisen.
[Beweis]
Erstens können Sie in C_2 $ keine zwei $ y, y ^ {\ prime} \ zu $ x + y = x ^ {\ prime} + y ^ {\ prime} $ bringen. Mit anderen Worten
x+y \neq x^{\prime} + y^{\prime} \tag{7}
ist. Denn wenn die Gleichheit gilt, dann ist $ x-x ^ {\ prime} = y ^ {\ prime} -y \ in C_2 $ [^ 2], was die Annahme leugnet. Daher gilt Gleichung (7). Dann
[^ 2]: Beachten Sie, dass das bitweise Additionsmodulo 2 gleich der Subtraktion ist. $ y ^ {\ prime} -y = y {\ prime} + y $ und $ y ^ {\ prime} -y \ in aufgrund der Natur des linearen Codes, dass selbst wenn Sie Dinge hinzufügen, die zum selben Code gehören, sie zum selben Code gehören. Ich kann C_2 $ sagen.
\begin{align}
\ket{x+C_2} &= \frac{1}{|C_2|} \sum_{y \in C_2} \ket{x+y} \\
\ket{x^{\prime}+C_2} &= \frac{1}{|C_2|} \sum_{y^{\prime} \in C_2} \ket{x^{\prime}+y^{\prime}} \tag{8}
\end{align}
Diese beiden Zustände sind Überlagerungen von Zuständen, die sich überhaupt nicht überlappen.
\braket{x+C_2}{x^{\prime}+C_2} = 0 \tag{9}
Ist festgelegt. (Ende der Zertifizierung)
Nun wollen wir sehen, warum und wie eine Fehlerkorrektur mit dem auf diese Weise definierten Quantencode durchgeführt werden kann. Aber zuerst überprüfen wir, was passiert, wenn Bitinversion und Phaseninversion hinzugefügt werden.
Stellen wir nun den Vektor dar, der den Bitinversionsfehler darstellt, mit dem folgenden Vektor, der einen Binärwert als Element hat.
e_1 = (0, \cdots , 0,1,0, \cdots, 0,1,0, \cdots, 0)^T \tag{10}
Stellen Sie sich vor, die Dimension des Vektors ist $ n $, nur das Element, das der fehlerhaften Quantenbitnummer entspricht, ist $ 1 $, und die anderen sind $ 0 $. In ähnlicher Weise ist auch der Vektor, der den Fehler der Phaseninversion darstellt, der gleiche.
e_2 = (0, \cdots , 0,1,0, \cdots, 0,1,0, \cdots, 0)^T \tag{11}
Ich werde es ausdrücken als. Wie ändert sich der CSS-Code aufgrund eines solchen Fehlers?
\ket{x+C_2} = \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \tag{12}
Es wird sein. Es ist gut, dass der Effekt der Bitinversion durch Hinzufügen von $ e_1 $ zum Inhalt des Kets auf der rechten Seite ausgedrückt wird. Ich denke, dass der Effekt der Phaseninversion $ (-1) ^ {(x + y) e_2} $ ist, was ein wenig schwer zu verstehen ist, daher werde ich eine kleine Erklärung hinzufügen.
$ x + y $ war ein binärer Vektor der Dimension $ n $. Weil es im Ket ist
x+y = (q_1, q_2, \cdots , q_n)^{T} \tag{13}
$ \ Ket {x + y} $ ist übrigens
\ket{x+y} = \ket{q_1}\ket{q_2} \cdots \ket{q_n} \tag{14}
Kann geschrieben werden. Wobei $ \ ket {q_i} $ entweder $ \ ket {0} $ oder $ \ ket {1} $ ist. Da die Phaseninversion eine Umwandlung war, bei der $ \ ket {0} $ unverändert bleibt und $ \ ket {1} $ in $ - \ ket {1} $ geändert wird, werden die $ n $ -Komponenten von Gleichung (11) Wenn $ q_i $ an der Stelle, an der es $ 1 $ ist, $ 1 $ ist, wird das Vorzeichen von Gleichung (14) invertiert. Mit anderen Worten, nur die interne Integration von $ x + y $ und $ e_2 $ kostet $ -1 $, so dass, wie in Gleichung (12) gezeigt, der Koeffizient $ (-1) ^ {(x + y) e_2} $ wird vor dem Status platziert.
Ich werde erklären, wie ein solcher Fehler behoben werden kann. Erstens die Korrektur des Bitinversionsfehlers. Beachten Sie das $ \ ket {x + y + e_1} $ auf der rechten Seite von Gleichung (12). Da es in C_1 $ $ x + y \ war, kann, wenn die Paritätsprüfungsmatrix von $ C_1 $ auf $ H_1 $ gesetzt ist und auf den Inhalt des Kets angewendet werden kann, um das Fehlersyndrom zu berechnen, das Quantenbit mit Bitinversion dort. Es sollte Informationen über die Nummer enthalten. Dazu benötigen wir eine Ansila, um die Ergebnisse des Quantenfehlersyndroms zu speichern. Das ist,
\ket{x+y+e_1}\ket{0} \rightarrow \ket{x+y+e_1}\ket{H_1(x+y+e_1)} = \ket{x+y+e_1}\ket{H_1 e_1} \tag{15}
Wenn die Konvertierung realisiert werden kann, werden die Informationen über die Fehlerbitnummer in das Ansila $ \ ket {H_1 e_1} $ auf der rechten Seite eingegeben.
Welche Art von Quantenschaltung kann dann die Umwandlung von Gleichung (15) realisieren?
Es ist im Allgemeinen plötzlich schwer zu erklären, also betrachten wir ein einfaches Beispiel. Angenommen, Sie möchten die Konvertierung $ \ ket {x} \ ket {0} \ rightarrow \ ket {x} \ ket {Hx} $ erreichen. Insbesondere ist $ \ ket {x} $ ein 3-Quantenbitcode, $ H $ ist eine Paritätsprüfmatrix,
H =
\begin{pmatrix}
1 & 1 & 0 \\
0 & 1 & 1
\end{pmatrix} \tag{16}
Wird besorgt. Zu diesem Zeitpunkt ist die Generierungsmatrix $ G $
G =
\begin{pmatrix}
1\\
1\\
1
\end{pmatrix} \tag{17}
ist. Dies ist also nichts weiter als ein sich wiederholender Code, der ein Quantenbit für drei Quantenbits redundant macht. Mit anderen Worten, es werden Codierungen wie $ \ ket {0} \ rightarrow \ ket {000}, \ ket {1} \ rightarrow \ ket {111} $ realisiert. Das Ergebnis der Berechnung von $ H $ auf dem Eingangsvektor $ x = (x_1, x_2, x_3) ^ {T} $ sollte an Ansila übertragen werden, daher ist die Quantenschaltung wie folgt.
[Die erste Zeile] [2. Zeile]
|x1> --*-------------
|x2> --|--*----*-----
|x3> --|--|----|--*--
| | | |
|0> --X--X----|--|--
|0> ----------X--X--
Der mit [1. Zeile] gekennzeichnete Teil ist die Berechnung, die der 1. Zeile von $ H $ entspricht. Da die Matrixelemente in der ersten und zweiten Spalte 1 sind, ist die erste Ansila $ \ ket {x_1 + x_2} $. Der Teil, in dem [2. Zeile] geschrieben ist, entspricht der 2. Zeile von $ H $. Da die Matrixelemente der 2. und 3. Spalte 1 sind, ist der 2. Ansila diesmal $ \ ket {x_2 + x_3} $.
Diese Idee kann auch verallgemeinert werden, wenn für $ \ ket {x} $ ein beliebiges $ H $ definiert ist. Wenn die $ j $ -Spalte der $ i $ -Zeile von $ H $ $ 1 $ ist, wird das CNOT-Gatter mit dem $ j $ -ten Vorzeichenquantenbit als Steuerbit und dem $ i $ -ten Ansila-Quantenbit als Zielbit verwendet Bereitstellen. Wiederholen Sie dies einige Minuten lang, wenn das Matrixelement $ 1 $ ist. Ich denke, Sie wissen, wie man eine Quantenschaltung erstellt, die die Umwandlung von Gleichung (15) [^ 3] realisiert.
[^ 3]: Dies ist "Übungsübung 10.26" von Neilsen, Chan.
Da der ursprüngliche fehlertragende Zustand Gleichung (12) war, ist das Ergebnis durch das Quantenfehlersyndrom
\begin{align}
\ket{x+C_2} &= \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \ket{0} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \ket{H_1(x+y+e_1)} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \ket{H_1 e_1} \tag{18}
\end{align}
Es wird sein. Wenn der Fehler auf ein Quantenbit beschränkt ist, gibt es nur ein letztes $ \ ket {H_1 e_1} $, das nicht $ \ ket {0} $ ist. Nennen wir es $ \ ket {z_1} $. Invertieren Sie die Quantenbitnummer, die $ z_1 $ entspricht (dh die Spaltennummer, bei der der Spaltenvektor der Paritätsprüfungsmatrix $ z_1 $ ist), nur für den Term auf der rechten Seite, bei dem Ansila $ \ ket {z_1} $ ist. Wenn Sie dies tun, können Sie den Fehler beheben. Wenn in 2 Quantenbits ein Fehler vorliegt, bedeutet dies, dass es zwei andere Arten von Ansila-Zuständen als $ \ ket {0} $ gibt. Sei es $ \ ket {z_1}, \ ket {z_2} $, dann $ z_1 $ und $ nur für den rechten Term, wobei Ansila $ \ ket {z_1} $ oder $ \ ket {z_2} $ ist Die Fehlerkorrektur kann durch Invertieren der Quantenbitnummer durchgeführt werden, die z_2 $ entspricht. Wenn ein Fehler von 3 Quantenbits oder mehr vorliegt, kann der Fehler auf die gleiche Weise korrigiert werden. Damit ist die Korrektur des Bitinversionsfehlers abgeschlossen [^ 4]. Da $ C_1 $ ein Code war, der bis zu $ t $ Fehler korrigieren kann, beträgt die Anzahl der unterstützten Quantenbits bis zu $ t $.
[^ 4]: Es ist möglich, eine Schaltung aufzubauen, die misst, um den Wert von $ z_1, z_2, \ cdots $ zu erhalten, und das Codequantenbit entsprechend invertiert. In diesem Fall möchten Sie ein bedingtes X-Gatter verwenden (ein X-Gatter, das das Messergebnis in einem klassischen Register speichert und es ein- und ausschaltet, je nachdem, ob der Wert 0 oder 1 ist). Wenn es jedoch mehr als ein fehlerhaftes Quantenbit gibt, müssen Sie wahrscheinlich mehrere Messungen durchführen, um mehrere $ z_1, z_2, \ cdots $ zu erhalten. Ich bin also nicht so glücklich. Es ist auch möglich, ein X-Gatter und ein CNOT-Gatter so zu kombinieren, dass sie nur auf $ \ ket {z_i} $ reagieren, anstatt Messungen durchzuführen, und eine Schaltung, die dasselbe erreicht, ist möglich. In diesem Fall ist es nur erforderlich, die Quantenschaltung einmal zu passieren. Ich denke, es ist möglich, Fehler in mehreren Quantenbits zu korrigieren. Die später in diesem Artikel gezeigte Simulation wurde in diese Richtung implementiert.
Infolge der Korrektur des Bitinversionsfehlers ist der Zustand wie folgt.
\frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y} \tag{19}
Betrachten Sie als nächstes die Korrektur von Phaseninversionsfehlern. Der Hinweis ist die Adamar-Transformation.
\begin{align}
\ket{+} \rightarrow \ket{-} \\
\ket{-} \rightarrow \ket{+} \tag{20}
\end{align}
Betrachtet man die Phaseninversion in der Welt der Adamal-Transformation
\begin{align}
\ket{0} \rightarrow \ket{1} \\
\ket{1} \rightarrow \ket{0} \tag{21}
\end{align}
Es wird Bitinversion. Von hier aus habe ich das Gefühl, dass es funktioniert, wenn ich irgendwie eine Adamal-Konvertierung durchführe, den Bitinversionsfehler korrigiere und dann die Adamal-Konvertierung erneut durchführe. In der Tat ist es richtig und kann sauber mathematisch ausgedrückt werden als:
Erstens ist die Adamar-Transformation $ H ^ {\ otimes n} $ für den Quantenbitzustand $ n $
H^{\otimes n} \ket{x} = \frac{1}{\sqrt{2^{n}}} \sum_{z} (-1)^{xz} \ket{z} \tag{22}
Es wird [^ 5]. Damit wird die Adamar-Transformation für Gleichung (19)
[^ 5]: Ich finde es gut, sich offiziell daran zu erinnern.
\begin{align}
& \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} H^{\otimes n} \ket{x+y} \\
&= \frac{1}{\sqrt{|C_2| 2^{n}}} \sum_{z} \sum_{y \in C_2} (-1)^{(x+y)e_2} (-1)^{(x+y)z} \ket{z} \\
&= \frac{1}{\sqrt{|C_2| 2^{n}}} \sum_{z} \sum_{y \in C_2} (-1)^{(x+y)(e_2+z)} \ket{z} \tag{23}
\end{align}
Wenn Sie $ z ^ {\ prime} = z + e_2 $ setzen, lautet die obige Formel
\begin{align}
& \frac{1}{\sqrt{|C2| 2^{n}}} \sum_{z^{\prime}} \sum_{y \in C_2} (-1)^{(x+y)z^{\prime}} \ket{z^{\prime} + e_2} \\
&= \frac{1}{\sqrt{|C2| 2^{n}}} \sum_{z^{\prime}} (-1)^{xz^{\prime}} \sum_{y \in C_2} (-1)^{yz^{\prime}} \ket{z^{\prime} + e_2} \tag{24}
\end{align}
Kann transformiert werden. Achten Sie hier auf $ \ sum_ {y \ in C_2} (-1) ^ {yz ^ {\ prime}} $, vorheriger Artikel Verwendet die Eigenschaften des um Gleichung (46) beschriebenen Doppelzeichens. Wenn in der aktuellen Situation nachgedruckt, ist seine Natur
\begin{align}
& z^{\prime} \in C_{2}^{\perp} \Rightarrow \sum_{y \in C_2} (-1)^{yz^{\prime}} = |C_2| \\
& z^{\prime} \notin C_{2}^{\perp} \Rightarrow \sum_{y \in C_2} (-1)^{yz^{\prime}} = 0 \tag{25}
\end{align}
Wird ausgedrückt als. Wenden Sie dies auf Gleichung (24) an,
\sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime} + e_2} \tag{26}
Es wird sein. Mit anderen Worten, als Ergebnis der Durchführung der Adamal-Transformation erscheint der Effekt der Phaseninversion $ e_2 $ als Addition im Ket. In diesem Fall kann der Effekt von $ e_2 $ durch das Verfahren zur Fehlerkorrektur der Bitinversion wie zuvor beseitigt werden. Ergebnis,
\sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime}} \tag{27}
Es bedeutet das. Wenn Sie die Adamal-Konvertierung erneut ausführen, sollte sie vollständig wiederhergestellt werden. Ich werde es versuchen.
\begin{align}
& \sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime}} \\
& \rightarrow \sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \frac{1}{\sqrt{2^{n}}} \sum_{w} (-1)^{z^{\prime} w} \ket{w} \\
&= \frac{\sqrt{|C_2|}}{2^{n}} \sum_{w} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{(x+w)z^{\prime}} \ket{w} \tag{28}
\end{align}
nochmal,
\frac{\sqrt{|C_2|}}{2^{n}} \sum_{w,x+w \in C_2} |C_{2}^{\perp}| \ket{w} \tag{29}
Hier,
\begin{align}
& |C_2| = 2^{k_2}, |C_{2}^{\perp}| = 2^{n-k_2} \\
& |C_2| |C_{2}^{\perp}| = 2^{n} \tag{30}
\end{align}
Daher ist Gleichung (29)
\frac{1}{\sqrt{|C_2|}} \sum_{w,x+w \in C_2} \ket{w} \tag{31}
Es wird sein. Wenn Sie hier schließlich $ x + w = x-w = y \ in C_2 $ setzen,
\frac{1}{\sqrt{|C_2|}} \sum_{y \in C_2} \ket{x+y} \tag{32}
Dadurch wird der ursprüngliche Zustand vollständig wiederhergestellt.
In Vorletzter Artikel wurde erklärt, dass selbst wenn ein kontinuierlicher Fehler vorliegt, der keine Bitinversion oder Phaseninversion ist, dieser selbst behoben werden kann. Die Erklärung, wie der CSS-Code aufgebaut ist und welche Art von Quantenschaltung zur Korrektur des Fehlers übergeben werden soll, ist vorerst abgeschlossen.
Aber noch ein letztes Wort.
Es gibt Variationen von CSS-Codes mit den Parametern $ u und v $.
\ket{x+C_2} \equiv \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{uy} \ket{x+y+v} \tag{33}
Es ist in definiert und wird als $ CSS_ {u, v} (C_1, C_2) $ -Zeichen bezeichnet. Es gibt zusätzliche Parameter, aber Sie können den Fehler mit derselben Quantenschaltung wie der $ CSS (C_1, C_2) $ -Code korrigieren. Da gesagt wird, dass es bei der Lieferung von Quantenschlüsseln nützlich sein wird, wird hier nur die Definition veröffentlicht und der Beweis weggelassen [^ 6].
[^ 6]: Ich habe einige erstaunliche Beweise dafür gefunden, aber es ist eine Lüge, dass dieser Rand zu eng ist, um ihn zu schreiben (lacht, ich wollte es einmal sagen. Ich kenne die Quelle nicht. Für diejenigen, die [hier] sind (https://ja.m.wikipedia.org/wiki/%E3%83%95%E3%82%A7%E3%83%AB%E3%83%9E%E3%83%BC % E3% 81% AE% E6% 9C% 80% E7% B5% 82% E5% AE% 9A% E7% 90% 86)). Dies ist "Übungsübung 10.27" von Neilsen, Chan. Ich hatte das Gefühl, fast die gleiche Formeltransformation wie oben durchzuführen, also habe ich sie weggelassen.
Nachdem ich die allgemeine Theorie der CSS-Codes verstanden habe, möchte ich ein konkretes Beispiel geben, um das Verständnis weiter zu gewährleisten. Es gibt einen "Steane-Code". Dies ist ein CSS-Code mit $ C_1 = C, C_2 = C ^ {\ perp} $ und $ C $ als Hamming-Code. Die Paritätsprüfmatrix von $ C_1 $ sei $ H_1 $ und die Generierungsmatrix sei $ G_1 $. Wenn Sie der Einfachheit halber den Hamming-Code $ [7,3] $ verwenden, sind $ H_1 und G_1 $
H_1 =
\begin{pmatrix}
0 & 1 & 1 & 1 & 1 & 0 & 0 \\
1 & 0 & 1 & 1 & 0 & 1 & 0 \\
1 & 1 & 0 & 1 & 0 & 0 & 1
\end{pmatrix} \tag{34}
G_1 =
\begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
0 & 0 & 0 & 1 \\
0 & 1 & 1 & 1 \\
1 & 0 & 1 & 1 \\
1 & 1 & 0 & 1
\end{pmatrix} \tag{35}
Kann ausgedrückt werden als (in Standardform geschrieben). Auf der anderen Seite ist $ C_2 $ sein dualer Code, also aus der Definition,
H_2 = G_{1}^{T} =
\begin{pmatrix}
1 & 0 & 0 & 0 & 0 & 1 & 1 \\
0 & 1 & 0 & 0 & 1 & 0 & 1 \\
0 & 0 & 1 & 0 & 1 & 1 & 0 \\
0 & 0 & 0 & 1 & 1 & 1 & 1
\end{pmatrix} \tag{36}
G_2 = H_{1}^{T} =
\begin{pmatrix}
0 & 1 & 1 \\
1 & 0 & 1 \\
1 & 1 & 0 \\
1 & 1 & 1 \\
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{pmatrix} \tag{37}
Kann geschrieben werden als.
Übrigens, um zu sagen, dass der Quantencode, der auf dem auf diese Weise definierten linearen Code basiert, sicherlich ein CSS-Code ist, sind $ C_1 $ und $ C_ {2} ^ {\ perp} $ gleich $ t $. Es ist notwendig, dass die Anzahl der Fehler behandelt werden kann, dh die Codeabstände (Mindestabstände) gleich sind und dass $ C_2 \ Teilmenge C_1 $.
Ersteres ist selbsterklärend, da sowohl $ C_1 $ als auch $ C_ {2} ^ {\ perp} $ per Definition $ C $ sind. Letzteres kann unter Verwendung der Erläuterungen zu Gleichung (45) in Vorheriger Artikel verstanden werden. Ich werde es wieder posten.
G^{T} G = 0 \Leftrightarrow C \subseteq C^{\perp} \tag{38}
Mit anderen Worten, wenn $ G_ {2} ^ {T} G_2 = 0 $ angezeigt werden kann, kann $ C_2 \ subseteq C_ {2} ^ {\ perp} $, dh $ C_2 \ subseteq C_1 $, bewiesen werden. .. Ich werde es versuchen.
G_{2}^{T} G_2 =
\begin{pmatrix}
0 & 1 & 1 & 1 & 1 & 0 & 0 \\
1 & 0 & 1 & 1 & 0 & 1 & 0 \\
1 & 1 & 0 & 1 & 0 & 0 & 1
\end{pmatrix}
\begin{pmatrix}
0 & 1 & 1 \\
1 & 0 & 1 \\
1 & 1 & 0 \\
1 & 1 & 1 \\
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{pmatrix} =
\begin{pmatrix}
0 & 0 & 0 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix} \tag{39}
So konnte ich bestätigen, dass es $ C_2 \ subseteq C_ {2} ^ {\ perp} $ [^ 7] war.
[^ 7]: [7,3] Ich konnte im Fall des Hamming-Codes bestätigen, kann aber noch nicht sagen, ob er für den allgemeinen Hamming-Code gilt (ich denke, er gilt). .. Für einen Moment dachte ich, ich könnte $ HG = 0 $ verwenden, aber ich habe mich geirrt.
Nachdem wir den klassischen linearen Basiscode kennen, erstellen wir einen CSS-Code. Schauen wir uns noch einmal Gleichung (1) an.
\ket{x+C_2} \equiv \frac{1}{\sqrt{|C_{2}|}} \sum_{y \in C_2} \ket{x+y} \tag{1}
Sie können den Code entsprechend erstellen.
Jetzt ist $ C_1 $ der [7,4] Code und $ C_2 $ der [7,3] Code. Daher ist der resultierende CSS-Code ein [7,1] -Code. Da es sich um einen Quantencode handelt, der 1 Quantenbit auf 7 Quantenbits redundant macht, können Sie zwei $ x $ bringen und alle $ y $ wie auf der rechten Seite von Gleichung (1) gezeigt mobilisieren und überlagern. .. Da $ y $ ein [7,3] -Zeichen ist, können Sie alle dreidimensionalen Binärvektoren bringen und die Generierungsmatrix $ G_2 $ in Gleichung (35) berechnen. Nun ist die Frage, was $ x $ zu bringen ist. Wenn Sie zwei $ x $ einbringen, die zum selben Rest gehören, ist dies nicht sinnvoll, da die rechten Seiten genau gleich sind. Sie müssen zwei $ x $ einbringen, die zu verschiedenen Resten gehören. Die Differenz zwischen den beiden $ x $ sollte nicht zu $ C_2 $ gehören, also $ x = (0,0,0,0,0,0,0) ^ {T} $ und $ x Bringen Sie zwei Dinge mit: ^ {\ prime} = (1,1,1,1,1,1,1) ^ {T} $. Auf diese Weise scheint der Unterschied kein Element von $ C_2 $ zu sein. Sei $ \ ket {0_L} $ der von $ x $ erzeugte Startwert und $ \ ket {1_L} $ der von $ x ^ {\ prime} $ erzeugte Zustand.
\begin{align}
\ket{0_L} &= \frac{1}{\sqrt{8}} (\ket{0000000} + \ket{1101001} + \ket{1011010} + \ket{0110011} + \ket{0111100} + \ket{1010101} + \ket{1100110} + \ket{0001111}) \\
\ket{1_L} &= \frac{1}{\sqrt{8}} (\ket{1111111} + \ket{0010110} + \ket{0100101} + \ket{1001100} + \ket{1000011} + \ket{0101010} + \ket{0011001} + \ket{1110000}) \tag{40}
\end{align}
Und jetzt haben wir einen Quantencode. Tatsächlich wird beim Codieren des Ein-Quanten-Bit-Zustands von $ \ ket {\ psi} = \ alpha \ ket {0} + \ beta \ ket {1} $
\ket{\psi} \rightarrow \ket{\psi_{L}} = \alpha \ket{0_L} + \beta \ket{1_L} \tag{41}
Bauen Sie eine geeignete Quantenschaltung auf, um dies zu realisieren.
Unter der Annahme, dass ein Fehler zu diesem Zustand hinzugefügt wird, führen Sie als Nächstes die Schaltung aus, die das Fehlersyndrom berechnet, wie zuvor erläutert. Das heißt, fügen Sie ancilla hinzu und für jeden Zustand,
\ket{x} \ket{0} \rightarrow \ket{x} \ket{H_1 x} \tag{42}
Durch Ausführen der realisierenden Quantenschaltung wird der Effekt des Bitinversionsfehlers von $ H_1 e_1 $ an Ansila übertragen. Bereiten Sie in diesem Fall Ancilla für 3 Quantenbits vor. Wie bereits erwähnt, richten Sie die CNOT-Gatter aus und notieren Sie sich die Position $ 1 $ in jeder Zeile der Paritätsprüfungsmatrix.
|x1> -----------*--------*-------- ...
|x2> --*--------|--------|-*------ ...
|x3> --|-*------|-*------|-|------ ...
|x4> --|-|-*----|-|-*----|-|-*---- ...
|x5> --|-|-|-*--|-|-|----|-|-|---- ...
|x6> --|-|-|-|--|-|-|-*--|-|-|---- ...
|x7> --|-|-|-|--|-|-|-|--|-|-|-*-- ...
| | | | | | | | | | | |
|0> --X-X-X-X--|-|-|-|--|-|-|-|-- ...
|0> -----------X-X-X-X--|-|-|-|-- ...
|0> --------------------X-X-X-X-- ...
Als nächstes wird die Bitinversion gemäß dem Zustand von Ansila durchgeführt. Invertiert das Bit, das dem Wert des Ancilla-Zustands entspricht, der mit dem Wert des Spaltenvektors der Paritätsprüfungsmatrix $ H_1 $ übereinstimmt. Mit anderen Worten, wenn Ansila $ \ ket {011} $ ist, das erste Quantenbit, wenn $ \ ket {101} $, das zweite Quantenbit, wenn $ \ ket {110} $, das dritte Quantenbit und so weiter. , Bitinversionsfehler kann korrigiert werden. Fahren Sie mit der vorherigen Schaltung fort und gehen Sie wie folgt vor.
|x1> ... ----X--------------------------------------------- ...
|x2> ... ----|------X-------------------------------------- ...
|x3> ... ----|------|------X------------------------------- ...
|x4> ... ----|------|------|------X------------------------ ...
|x5> ... ----|------|------|------|------X----------------- ...
|x6> ... ----|------|------|------|------|------X---------- ...
|x7> ... ----|------|------|------|------|------|------X--- ...
| | | | | | |
|0> ... --X-*-X----*------*------*------*----X-*-X--X-*-X-
|0> ... ----*----X-*-X----*------*----X-*-X----*----X-*-X-
|0> ... ----*------*----X-*-X----*----X-*-X--X-*-X----*---
Nachdem der Bitinversionsfehler korrigiert wurde, besteht der nächste Schritt darin, den Phaseninversionsfehler zu behandeln. Verwenden Sie zuerst die Adamar-Transformation. Gleichzeitig hat der Ansila für die Bitinversionsfehlerkorrektur seine Rolle beendet und wird initialisiert. Gehen Sie wie folgt vor:
|x1> ... --H-------------*--------*-------- ...
|x2> ... --H----*--------|--------|-*------ ...
|x3> ... --H----|-*------|-*------|-|------ ...
|x4> ... --H----|-|-*----|-|-*----|-|-*---- ...
|x5> ... --H----|-|-|-*--|-|-|----|-|-|---- ...
|x6> ... --H----|-|-|-|--|-|-|-*--|-|-|---- ...
|x7> ... --H----|-|-|-|--|-|-|-|--|-|-|-*-- ...
| | | | | | | | | | | |
|0> ... -------X-X-X-X--|-|-|-|--|-|-|-|-- ...
|0> ... ----------------X-X-X-X--|-|-|-|-- ...
|0> ... -------------------------X-X-X-X-- ...
Nachdem wir das Fehlersyndrom berechnet haben, können wir den Phaseninversionsfehler korrigieren (tatsächlich den Bitinversionsfehler korrigieren) und schließlich die Adamal-Transformation durchführen, um ihn wiederherzustellen.
|x1> ... ----X---------------------------------------------H--
|x2> ... ----|------X--------------------------------------H--
|x3> ... ----|------|------X-------------------------------H--
|x4> ... ----|------|------|------X------------------------H--
|x5> ... ----|------|------|------|------X-----------------H--
|x6> ... ----|------|------|------|------|------X----------H--
|x7> ... ----|------|------|------|------|------|------X---H--
| | | | | | |
|0> ... --X-*-X----*------*------*------*----X-*-X--X-*-X----
|0> ... ----*----X-*-X----*------*----X-*-X----*----X-*-X----
|0> ... ----*------*----X-*-X----*----X-*-X--X-*-X----*------
Damit ist die Fehlerkorrektur abgeschlossen [^ 8].
[^ 8]: Möglicherweise gibt es eine effizientere Schaltungskonfiguration, aber bitte verzeihen Sie diese, da es sich vorerst um einen Anfängerkurs handelt. Mindestens aufeinanderfolgende X-Gatter können gelöscht werden. Dann wollte ich unbedingt einen 7-Quanten-Steane-Code aus einem 1-Quanten-Bit-Zustand erstellen, aber ich konnte mir keine gute Schaltung vorstellen, deshalb habe ich das auch in diesem Artikel weggelassen. Ich denke, wenn Sie mehr lernen, können Sie eine ordentliche und coole Schaltung schreiben.
Lassen Sie uns nun den oben beschriebenen Steane-Code implementieren. In qlazy wird die Berechnung der Quantenschaltung durchgeführt, indem eine Instanz der Klasse erstellt wird, die dem Quantenzustands- oder Dichteoperator entspricht, und die Gate-Operation ausgeführt wird. Es kann entweder der Quantenzustand oder der Dichteoperator verwendet werden, aber ich werde den Dichteoperator ausprobieren, der Quantenkanäle (Polarisationseliminierung, Amplitudendämpfung usw.) für die Rauschaddition verwenden kann [^ 9].
[^ 9]: 10 Quantum Bit Density Operator Berechnung und Multi-Control NOT (CNOT mit mehreren Control Bits) wird häufig verwendet, so dass die Verarbeitung länger dauert als die Ausführung im Quantenzustand. ..
Der gesamte Code ist unten.
import numpy as np
from qlazypy import QState, DensOp
Hamming = np.array([[0,1,1,1,1,0,0], [1,0,1,1,0,1,0], [1,1,0,1,0,0,1]])
Hamming_T = Hamming.T
Steane_0 = ['0000000', '1101001', '1011010', '0110011',
'0111100', '1010101', '1100110', '0001111']
Steane_1 = ['1111111', '0010110', '0100101', '1001100',
'1000011', '0101010', '0011001', '1110000']
def generate_qstate(qid_C, qid_S):
a = np.random.rand() + np.random.rand() * 1.j
b = np.random.rand() + np.random.rand() * 1.j
print("== quantum state (a |0L> + b |1L>) ==")
print("- a = {:.4f}".format(a))
print("- b = {:.4f}".format(b))
qvec = np.full(2**len(qid_C), 0.+0.j)
for s in Steane_0: qvec[int(s, 2)] = a
for s in Steane_1: qvec[int(s, 2)] = b
norm = np.linalg.norm(qvec)
qvec = qvec / norm
qs_C = QState(vector=qvec)
qs_S = QState(len(qid_S))
qs = qs_C.tenspro(qs_S)
de_ini = DensOp(qstate=[qs])
de_fin = de_ini.clone()
QState.free_all(qs_C, qs_S, qs)
return de_ini, de_fin
def noise(self, kind='', prob=0.0, qid=[]):
print("== noise ({:}) ==".format(kind))
print("- qubit = {:}".format(qid))
print("- prob = {:}".format(prob))
qchannel = {'bit_flip':self.bit_flip, 'phase_flip':self.phase_flip,
'bit_phase_flip':self.bit_phase_flip,
'depolarize':self.depolarize, 'amp_dump':self.amp_dump,
'phase_dump':self.phase_dump}
[qchannel[kind](i,prob=prob) for i in qid]
return self
def correct(self, kind, qid_C, qid_S):
self.reset(qid=qid_S)
if kind == 'phase_flip': [self.h(q) for q in qid_C]
# syndrome
for i, row in enumerate(Hamming):
[self.cx(qid_C[j], qid_S[i]) if row[j] == 1 else False for j in range(len(row))]
# correction
for i, row in enumerate(Hamming_T):
[self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]
self.mcx(qid=qid_S+[qid_C[i]])
[self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]
if kind == 'phase_flip': [self.h(q) for q in qid_C]
return self
if __name__ == '__main__':
# add custom gates
DensOp.add_method(noise)
DensOp.add_method(correct)
# set registers
qid_C = DensOp.create_register(7) # registers for code space
qid_S = DensOp.create_register(3) # registers for error syndrome
DensOp.init_register(qid_C, qid_S)
# generate initial quantum state (density operator)
de_ini, de_fin = generate_qstate(qid_C, qid_S)
# add noise
de_fin.noise(kind='depolarize', qid=[qid_C[3]], prob=1.0)
# error correction
de_fin.correct('bit_flip', qid_C, qid_S)
de_fin.correct('phase_flip', qid_C, qid_S)
# print result
print("== result ==")
print("- fidelity = {:.6f}".format(de_fin.fidelity(de_ini, qid=qid_C)))
DensOp.free_all(de_ini, de_fin)
Ich werde kurz erklären, was Sie tun. Grundsätzlich führen Sie die Fehlerkorrektur nur mit dem oben beschriebenen Steane-Code durch. Schauen Sie sich jetzt den Hauptverarbeitungsabschnitt an.
# add custom gates
DensOp.add_method(noise)
DensOp.add_method(correct)
Daher definieren wir ein benutzerdefiniertes Gate mit Rauschaddition und Fehlerkorrektur als einen Block und legen es als Methode fest. Der Verarbeitungsinhalt wird oben als Funktion definiert.
# set registers
qid_C = DensOp.create_register(7) # registers for code space
qid_S = DensOp.create_register(3) # registers for error syndrome
DensOp.init_register(qid_C, qid_S)
Definiert das zu verwendende Quantenregister. Auf dieser Ebene kann es schneller sein, es von Hand zu schreiben, ohne eine solche Klassenmethode zu verwenden. Jetzt ist qid_C in der Liste [0,1,2,3,4,5,6] und qid_S ist in der Liste [7,8,9].
# generate initial quantum state (density operator)
de_ini, de_fin = generate_qstate(qid_C, qid_S)
Bereiten Sie zufällig einen Quantenzustand (Dichteoperator) mit dem Steane-Code vor. Wie Sie anhand der Funktionsdefinition sehen können, erstellen Sie einen 7-Quantenbit-Quantenzustand $ a \ ket {0_L} + b \ ket {1_L} $, indem Sie die komplexen Zahlen $ a und b $ zufällig festlegen. Erstellen Sie dann einen Zustand von 10 Quantenbits, indem Sie ein Tensorprodukt mit einer Ancilla von 3 Quantenbits ausführen. Basierend darauf wird ein Dichteoperator erstellt und zurückgegeben. Ich habe zwei Duplikate gemacht, die genau gleich sind, aber dies ist am Ende des Programms, um den Anfangszustand und den Zustand des Berechnungsergebnisses zu vergleichen und zu bewerten.
# add noise
de_fin.noise(kind='depolarize', qid=[qid_C[3]], prob=1.0)
Fügen Sie dann Rauschen hinzu. Das Rauschen (Quantenkanal), das standardmäßig mit qlazy geliefert wird, ist "Bitinversion (bit_flip)", "Phaseninversion (phase_flip)" und "Bitphaseninversion (bit_phasee_flip)". Es gibt 6 Typen, "depolarisieren", "Amplituden-Dumping (amp_dump)" und "Phasen-Dumping (phase_dump)", und jeder von ihnen gibt eine Liste der anzuwendenden Quantenbitnummern und eine Wahrscheinlichkeit an, die Rauschintensität als Argumente auszudrücken. Ich bin. Das Funktionsrauschen (benutzerdefiniertes Gate) wird auf den Dichteoperator angewendet, indem die Zeichenfolge angegeben wird, die den Typ des Quantenkanals, die Liste der Quantenbitnummern und die Wahrscheinlichkeit als Argumente angibt. Einzelheiten finden Sie in der Funktionsdefinition.
# error correction
de_fin.correct('bit_flip', qid_C, qid_S)
de_fin.correct('phase_flip', qid_C, qid_S)
Führt eine Bitinversionsfehlerkorrektur und eine Phaseninversionsfehlerkorrektur durch. Die korrekte Funktion (benutzerdefiniertes Gate) gibt eine Zeichenfolge an, die angibt, ob das Argument die Bitinversion oder die Phaseninversion unterstützt, sowie eine Liste von Quantenbitnummern, die dem Codebereich und der Ancilla entsprechen. Werfen wir einen Blick auf den Inhalt der Korrektur.
self.reset(qid=qid_S)
Initialisieren Sie nun Ansila. Für die Berechnung des Fehlersyndroms ist zunächst eine Initialisierung erforderlich.
if kind == 'phase_flip': [self.h(q) for q in qid_C]
Wenn Sie die Phaseninversion unterstützen möchten, müssen Sie zuerst Adamal ausführen, also mache ich das hier.
# syndrome
for i, row in enumerate(Hamming):
[self.cx(qid_C[j], qid_S[i]) if row[j] == 1 else False for j in range(len(row))]
Führen Sie nun die Berechnung des Fehlersyndroms durch. Um die oben beschriebene Schaltung auszuführen, führen wir eine Schleife aus, die CNOT ordnungsgemäß auf jede Zeile der Paritätsprüfungsmatrix des Hamming-Codes anwendet.
# correction
for i, row in enumerate(Hamming_T):
[self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]
self.mcx(qid=qid_S+[qid_C[i]])
[self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]
Dann wird abhängig vom Ergebnis des Fehlersyndroms das Bit invertiert und wiederhergestellt. Abhängig von jeder Spalte der Paritätsprüfungsmatrix des Hamming-Codes wird eine Schleife ausgeführt, die das Multi-Control-NOT (mcx-Methode) entsprechend anwendet.
if kind == 'phase_flip': [self.h(q) for q in qid_C]
Wenn es also die Phaseninversion unterstützt, wenden Sie am Ende Adamal an, um es wiederherzustellen. Damit ist die Fehlerkorrektur abgeschlossen.
Kehren Sie erneut zum Hauptverarbeitungsabschnitt zurück.
# print result
print("== result ==")
print("- fidelity = {:.6f}".format(de_fin.fidelity(de_ini, qid=qid_C)))
Um den ersten Dichteoperator und den Dichteoperator nach Durchführung der Fehlerkorrekturverarbeitung zu vergleichen und zu bewerten, berechnet und zeigt die Wiedergabetreue die Wiedergabetreue von beiden an. Durch Angabe der interessierenden Quantenbitnummernliste im Argument qid kann die Wiedergabetreue nur des relevanten Teils berechnet werden.
DensOp.free_all(de_ini, de_fin)
Geben Sie den verwendeten Speicher frei. Wenn Sie mehrere DensOp-Instanzen als Argumente für die Klassenmethode free_all angeben, können Sie den Speicher mehrerer Instanzen in einer Zeile freigeben (Sie können eine beliebige Anzahl von Instanzen im Argument angeben).
Das Ausführungsergebnis wird angezeigt. Dies ist das Ergebnis der Anwendung des Depolarisationskanals auf das dritte Quantenbit mit einer Wahrscheinlichkeit von 1,0.
== quantum state (a |0L> + b |1L>) ==
- a = 0.4835+0.0654j
- b = 0.2558+0.9664j
== noise (depolarize) ==
- qubit = [3]
- prob = 1.0
== result ==
- fidelity = 1.000000
Da die Wiedergabetreue 1,0 beträgt, war die Fehlerkorrektur erfolgreich. Ich habe versucht, die Quantenbitnummer, den Quantenkanal und die Wahrscheinlichkeit zu ändern, aber auf jeden Fall betrug die Wiedergabetreue 1,0, und ich fand, dass eine Fehlerkorrektur möglich war.
Es war jedoch natürlich nutzlos, wenn die beiden Quantenbits Rauschen aufwiesen. Es ist wie folgt.
== quantum state (a |0L> + b |1L>) ==
- a = 0.4749+0.4393j
- b = 0.5424+0.6672j
== noise (depolarize) ==
- qubit = [3, 4]
- prob = 1.0
== result ==
- fidelity = 0.864784
Und natürlich hat es nicht funktioniert, wenn ich die Fehlerkorrektur für die Phaseninversion weggelassen habe.
# error correction
de_fin.correct('bit_flip', qid_C, qid_S)
# de_fin.correct('phase_flip', qid_C, qid_S)
Wenn Sie den Teil auskommentieren, der der Phaseninversion entspricht,
== quantum state (a |0L> + b |1L>) ==
- a = 0.2903+0.1936j
- b = 0.8322+0.4586j
== noise (depolarize) ==
- qubit = [3]
- prob = 1.0
== result ==
- fidelity = 0.707107
Und dies kann den Fehler auch nicht korrigieren.
So konnte ich den erwarteten Betrieb bestätigen.
Es stellt sich heraus, dass Sie immer einen Quantencode daraus erstellen können, wenn Sie zwei klassische lineare Codes mitbringen, die eine bestimmte Bedingung erfüllen. Mit anderen Worten, wir haben eines der leistungsstarken Werkzeuge, mit denen verschiedene Quantencodes konkret konstruiert werden können. Darüber hinaus kann der "Steane-Code" mit 7 Quantenbits ausgeführt werden. Da der "Shor-Code" 9 Quantenbits benötigte, konnten wir 2 Quantenbits reduzieren (obwohl wir auch eine Ansila von 3 Quantenbits benötigten)!
Wie in der "Einführung" erwähnt, entspricht der "CSS-Code" auch der allgemeineren Unterklasse "Stabilisator-Code". Das nächste Mal möchte ich diesen "Stabilisator-Code" (geplant) studieren.
das ist alles
Recommended Posts