Depuis que j'ai compris le code linéaire classique dans Article précédent, cette fois c'est une classe de correction d'erreur quantique basée sur elle, "code CSS (Calderbank-). Nous étudierons le "code Shor-Steane)". Nous examinerons également le "code Steane" comme méthode de code spécifique. Maintenant que vous avez une compréhension générale, vérifions le fonctionnement du "code Steane" à l'aide du simulateur de calcul quantique qlazy.
A propos, "CSS code" correspond à une sous-classe de "Stabilizer code" qui est une classe plus générale de correction d'erreur quantique. Cet article se positionne également comme un tremplin vers cela.
Les documents suivants ont été utilisés comme références.
$ C_1 $ et $ C_2 $ sont les codes linéaires classiques $ [n, k_1] $ et $ [n, k_2] $, et sont $ C_2 \ sous-ensemble C_1 $. Supposons également que $ C_1 $ et $ C_ {2} ^ {\ perp} $ peuvent tous deux gérer les erreurs $ t $. À ce stade, le code CSS $ CSS (C_1, C_2) $ peut être construit comme le code quantique de $ [n, k_1 --k_2] $ qui peut gérer les erreurs $ t $. Supposons que $ x \ in C_1 $ soit un mot de signe arbitraire dans le signe $ C_1 $. A ce moment, l'état quantique $ \ ket {x + C_2} $,
\ket{x+C_2} \equiv \frac{1}{\sqrt{|C_{2}|}} \sum_{y \in C_2} \ket{x+y} \tag{1}
Il est défini comme. Ici, $ + $ sur le côté droit représente la somme de chaque bit modulo 2 (idem ci-dessous). Le code représenté par la superposition de ces $ \ ket {x + C_2} $ est le code CSS.
Je ne sais pas ce que c'est. Mâcher.
Maintenant, sur le côté droit de l'équation (1), le vecteur d'état $ \ ket {x + y} $, qui est la somme de l'élément $ x $ de $ C_1 $ et de l'élément $ y $ de $ C_2 $, est utilisé comme index. Cela ressemble à ajouter environ y \ dans C_2 $. Il est défini par le symbole $ \ ket {x + C_2} $. En d'autres termes, $ \ ket {x + C_2} $ amorce un $ \ ket {x} \ space (x \ in C_1) $, alors que tout $ y \ dans C_2 $ C'est un état superposé dans lequel toutes les conversions (ajoutant $ y $ au contenu du ket) effectuées en mobilisant tout ce qui précède sont combinées.
Notez que même si vous ajoutez les éléments du code linéaire ensemble, ils seront les éléments du même code linéaire [^ 1], donc le contenu de tous les kets sur le côté droit sont les éléments de $ C_1 $. Faisons le. Autrement dit, chacune des valeurs de départ $ x \ dans C_1 $ plus toutes les $ y \ dans C_2 \ sous-ensemble C_1 $ est un signe qui appartient à $ C_1 $. Chacun des résultats de l'ajout de tout $ y \ dans C_2 $ à un autre $ x ^ {\ prime} \ dans C_1 $ est également un code qui appartient à $ C_1 $. Voici une question. Y a-t-il quelque chose à voir avec les deux jeux de codes (chacun $ 2 ^ {k_2} $ set) générés à partir de $ x $ et $ x ^ {\ prime} $ en tant que graines? En fait, ils sont «tous identiques» ou «tous différents» et ne se chevauchent pas partiellement.
[^ 1]: Considérons $ [n, k] $ signe $ C $ et laissez sa matrice de génération être $ G $. Pour tout $ x_1, x_2 \ in \ {0,1 \} ^ {k} $, si $ y_1 = Gx_1, y_2 = Gx_2 $, alors $ y_1, y_2 \ en C $. L'ajout des deux équations donne $ y_1 + y_2 = G (x_1 + x_2) $, soit $ x_1 + x_2 \ in \ {0,1 \} ^ {k} $, donc $ y_1 + y_2 \ en C $ Est établi.
Que voulez-vous dire?
Ce n'est pas exactement le décor auquel nous pensons, mais pour en avoir une idée, voici un exemple similaire. Imaginez un ensemble d'entiers de 0 $ à 99 $. Soit cela l'ensemble $ C_1 $. Ensuite, extrayez un multiple de 3 $ $ de $ C_1 $. Appelons cela $ C_2 $. Maintenant, prenez un entier spécifique de $ C_1 $ et utilisez-le comme $ x $. En utilisant cela comme une graine, mobilisez tous les $ y \ dans C_2 $ et ajoutez chacun à $ x $ (mais avec $ 100 $ comme addition modale). Tous les résultats obtenus sont des entiers de 0 $ à 99 $, donc ce sont des éléments de $ C_1 $. Par exemple, disons $ x = 6 $. A ce moment, tous les entiers créés en ajoutant $ y $ seront des multiples de $ 3 $. Considérons $ x ^ {\ prime} = 15 $ et utilisez $ y \ dans C_2 $ de la même manière pour générer un ensemble d'entiers. Comme vous pouvez le voir, il s'agit également d'un multiple de 3 $. En d'autres termes, l'ensemble des nombres entiers générés par l'amorçage $ x = 6, x ^ {\ prime} = 15 $ est une correspondance exacte. Comme autre exemple, que se passe-t-il si $ x = 7, x ^ {\ prime} = 31 $? Les entiers générés sont un ensemble où le reste est de 1 $ lorsque les deux sont divisés par 3 $. Donc, dans ce cas également, les deux sont exactement les mêmes. Encore un autre exemple, et si $ x = 11, x ^ {\ prime} = 52 $? Dans ce cas, $ x = 11 $ est généré à partir d'un ensemble d'entiers de $ 2 $ avec le reste divisé par $ 3 $, et $ x ^ {\ prime} = 52 $ est généré à partir de divisé par $ 3 $. Un ensemble d'entiers avec un reste de $ 1 $. Donc, les deux sont complètement incompatibles. En d'autres termes, il est possible de classer l'ensemble généré en utilisant l'ensemble $ C_2 $ avec $ x \ in C_1 $ comme germe, selon le reste obtenu en divisant par $ 3 $. D'ailleurs, $ C_2 $ vous permet de classer $ x \ dans C_1 $ en trois groupes. Cette classification est appelée «reste» (par exemple, «7 $ et 31 $ appartiennent au même surplus»). Vous pouvez dire s'ils appartiennent au même surplus en les soustrayant, sans avoir à les générer tous un par un. Essayons avec cet exemple. 15-6 $ correspondent à 9 $ et 31-7 $ à 24 $, les deux étant des multiples de 3 $. Par contre, 52-11 $ devient 41 $, ce qui n'est pas un multiple de 3 $. Vous pouvez dire s'il appartient au même reste en faisant une soustraction et en voyant s'il appartient à $ C_2 $.
Eh bien, je vais laisser l'analogie jusqu'à ce point. Oubliez les définitions de $ C_1 et C_2 $ dans la section précédente. Donc, en examinant à nouveau la définition de l'équation (1), je pense que quelque chose de similaire est susceptible de se vérifier. Permettez-moi de montrer ci-dessous que non seulement cela en a envie, mais c'est le cas.
Premièrement, s'ils appartiennent au même reste, c'est-à-dire $ x, x ^ {\ prime} \ en C_1 $ et $ x-x ^ {\ prime} \ en C_2 $
\ket{x + C_2} = \ket{x^{\prime} + C_2} \tag{2}
Est établi. Prouvons-le.
[Preuve]
Prouvez que $ \ ket {x + C_2} - \ ket {x ^ {\ prime} + C_2} $ devient $ 0 $.
\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}
Définissez $ x-x ^ {\ prime} = y ^ {\ prime} \ dans 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}
Définissez $ y ^ {\ prime \ prime} = y ^ {\ prime} + y $. Notez que $ y ^ {\ prime} $ et $ y $ sont des éléments du même signe $ C_2 $, donc ils sont $ y ^ {\ prime \ prime} \ dans 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}
Ce sera. (Fin de la certification)
Ensuite, s'ils appartiennent à des restes différents, c'est-à-dire $ x, x ^ {\ prime} \ in C_1 $ et $ x-x ^ {\ prime} \ notin C_2 $
\braket{x + C_2}{x^{\prime} + C_2} = 0 \tag{6}
Est établi. Prouvons-le.
[Preuve]
Premièrement, vous ne pouvez pas amener deux $ y, y ^ {\ prime} \ dans C_2 $ à $ x + y = x ^ {\ prime} + y ^ {\ prime} $. En d'autres termes
x+y \neq x^{\prime} + y^{\prime} \tag{7}
est. Parce que, si l'égalité est vraie, alors $ x-x ^ {\ prime} = y ^ {\ prime} -y \ in C_2 $ [^ 2], niant l'hypothèse. Par conséquent, l'équation (7) est vraie. Puis
[^ 2]: Notez que l'addition bit par bit modulo 2 est égale à la soustraction. $ y ^ {\ prime} -y = y {\ prime} + y $ et $ y ^ {\ prime} -y \ in en raison de la nature du code linéaire que même si vous ajoutez des éléments qui appartiennent au même code, ils appartiennent au même code Je peux dire C_2 $.
\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}
Ces deux états sont des superpositions d'états qui ne se chevauchent pas du tout.
\braket{x+C_2}{x^{\prime}+C_2} = 0 \tag{9}
Est établi. (Fin de la certification)
Voyons maintenant pourquoi et comment la correction d'erreur peut être effectuée avec le code quantique défini de cette manière. Mais d'abord, vérifions ce qui se passe lorsque l'inversion de bits et l'inversion de phase sont ajoutées.
Maintenant, représentons le vecteur qui représente l'erreur d'inversion de bit avec le vecteur suivant qui a une valeur binaire comme élément.
e_1 = (0, \cdots , 0,1,0, \cdots, 0,1,0, \cdots, 0)^T \tag{10}
Imaginons que la dimension du vecteur soit $ n $, seul l'élément correspondant au nombre de bits quantique erroné est $ 1 $ et les autres sont $ 0 $. De même, le vecteur représentant l'erreur d'inversion de phase est également le même.
e_2 = (0, \cdots , 0,1,0, \cdots, 0,1,0, \cdots, 0)^T \tag{11}
Je vais l'exprimer comme. Comment le code CSS change-t-il en raison d'une telle erreur?
\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}
Ce sera. Il est bon que l'effet de l'inversion des bits soit exprimé en ajoutant $ e_1 $ au contenu du ket sur le côté droit. Je pense que l'effet de l'inversion de phase est $ (-1) ^ {(x + y) e_2} $, ce qui est un peu difficile à comprendre, donc j'ajouterai une petite explication.
$ x + y $ était un vecteur binaire de dimension $ n $. Parce que c'est dans le ket
x+y = (q_1, q_2, \cdots , q_n)^{T} \tag{13}
Au fait, $ \ ket {x + y} $ est
\ket{x+y} = \ket{q_1}\ket{q_2} \cdots \ket{q_n} \tag{14}
Peut être écrit. Où $ \ ket {q_i} $ est soit $ \ ket {0} $, soit $ \ ket {1} $. Puisque l'inversion de phase était une conversion qui laisse $ \ ket {0} $ tel quel et change $ \ ket {1} $ en $ - \ ket {1} $, les composants $ n $ de l'équation (11) Lorsque $ q_i $ à l'endroit où il est $ 1 $ est $ 1 $, le signe de l'équation (14) est inversé. En d'autres termes, seule l'intégration interne de $ x + y $ et $ e_2 $ coûte $ -1 $, donc comme indiqué dans l'équation (12), le coefficient $ (-1) ^ {(x + y) e_2} $ sera placé avant l'état.
Je vais vous expliquer comment corriger une telle erreur. Tout d'abord, la correction de l'erreur d'inversion de bit. Remarquez le $ \ ket {x + y + e_1} $ sur le côté droit de l'équation (12). Puisqu'il était $ x + y \ dans C_1 $, si la matrice de contrôle de parité de $ C_1 $ est définie comme $ H_1 $ et qu'elle peut être appliquée au contenu du ket pour calculer le syndrome d'erreur, le bit quantique avec l'inversion de bits. Il doit contenir des informations sur le numéro. Pour ce faire, nous avons besoin d'un ansila pour stocker les résultats du syndrome d'erreur quantique. C'est,
\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}
Si la conversion peut être réalisée, les informations sur le numéro de bit d'erreur seront saisies dans l'ansila $ \ ket {H_1 e_1} $ sur le côté droit.
Alors, quel type de circuit quantique peut réaliser la conversion de l'équation (15)?
C'est difficile à expliquer en général tout à coup, alors considérons un exemple simple. Supposons que vous souhaitiez obtenir la conversion $ \ ket {x} \ ket {0} \ rightarrow \ ket {x} \ ket {Hx} $. Plus précisément, $ \ ket {x} $ est un code à 3 bits quantiques, $ H $ est une matrice de contrôle de parité,
H =
\begin{pmatrix}
1 & 1 & 0 \\
0 & 1 & 1
\end{pmatrix} \tag{16}
ça ira. A ce moment, la matrice de génération $ G $ est
G =
\begin{pmatrix}
1\\
1\\
1
\end{pmatrix} \tag{17}
est. Ce n'est donc rien de plus qu'un code répétitif qui rend un bit quantique redondant en trois bits quantiques. En d'autres termes, il réalise un encodage tel que $ \ ket {0} \ rightarrow \ ket {000}, \ ket {1} \ rightarrow \ ket {111} $. Le résultat du calcul de $ H $ sur le vecteur d'entrée $ x = (x_1, x_2, x_3) ^ {T} $ doit être transféré à Ansila, donc le circuit quantique est le suivant.
[La première ligne] [2e ligne]
|x1> --*-------------
|x2> --|--*----*-----
|x3> --|--|----|--*--
| | | |
|0> --X--X----|--|--
|0> ----------X--X--
La partie marquée [1ère ligne] est le calcul correspondant à la 1ère ligne de $ H $. Puisque les éléments de la matrice dans les première et deuxième colonnes sont 1, le premier ansila est $ \ ket {x_1 + x_2} $. La partie marquée [2ème ligne] est le calcul correspondant à la 2ème ligne de $ H $. Puisque les éléments de la matrice des 2e et 3e colonnes sont 1, cette fois, le 2e Ansila est $ \ ket {x_2 + x_3} $.
Cette idée peut également être généralisée lorsque tout $ H $ est défini pour tout $ \ ket {x} $. Lorsque la colonne $ j $ de la ligne $ i $ de $ H $ est $ 1 $, la porte CNOT avec le bit quantique de signe $ j $ th comme bit de contrôle et le bit quantique $ i $ th ansila comme bit cible Déployer. Répétez cette opération pendant quelques minutes lorsque l'élément de la matrice est de 1 $. Donc, je pense que vous savez comment faire un circuit quantique qui réalise la conversion de l'équation (15) [^ 3].
[^ 3]: Ceci est "Exercice pratique 10.26" de Neilsen, Chan.
Puisque l'état d'origine porteur d'erreur était l'équation (12), le résultat à travers le syndrome d'erreur quantique est
\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}
Ce sera. Si l'erreur est limitée à un bit quantique, il n'y a qu'un seul dernier $ \ ket {H_1 e_1} $ qui n'est pas $ \ ket {0} $. Appelons cela $ \ ket {z_1} $. Seulement pour le terme de droite où Ansila est $ \ ket {z_1} $, le nombre de bits quantiques correspondant à $ z_1 $ (c'est-à-dire le numéro de colonne où le vecteur de colonne de la matrice de contrôle de parité est $ z_1 $) est inversé. Si vous le faites, vous pouvez corriger l'erreur. S'il y a une erreur dans 2 bits quantiques, cela signifie qu'il existe deux types d'états ansila autres que $ \ ket {0} $. Soit $ \ ket {z_1}, \ ket {z_2} $, puis $ z_1 $ et $ uniquement pour le terme de droite où Ansila est $ \ ket {z_1} $ ou $ \ ket {z_2} $ La correction d'erreur peut être effectuée en inversant le nombre de bits quantiques correspondant à z_2 $. S'il y a une erreur de 3 bits quantiques ou plus, l'erreur peut être corrigée de la même manière. Ainsi, la correction de l'erreur d'inversion de bit est terminée [^ 4]. Cependant, puisque $ C_1 $ était un code qui peut corriger jusqu'à $ t $ d'erreurs, le nombre de bits quantiques pouvant être pris en charge est jusqu'à $ t $.
[^ 4]: Il est possible de construire un circuit qui mesure pour obtenir la valeur de $ z_1, z_2, \ cdots $ et inverse le bit quantique de code en conséquence. Dans ce cas, vous aurez envie d'utiliser une porte X conditionnelle (une porte X qui stocke le résultat de la mesure dans un registre classique et l'allume et la désactive selon que la valeur est 0 ou 1). Cependant, s'il y a plus d'un bit quantique erroné, je pense que vous devez effectuer plusieurs mesures pour obtenir plusieurs $ z_1, z_2, \ cdots $. Donc je ne suis pas si content. Un circuit qui réalise la même chose en combinant une porte X et une porte CNOT pour qu'il ne réagisse qu'à $ \ ket {z_i} $ au lieu de faire une mesure est également possible, auquel cas il n'est nécessaire de passer qu'une seule fois le circuit quantique. , Je pense qu'il est possible de corriger les erreurs dans plusieurs bits quantiques. La simulation présentée plus loin dans l'article a été mise en œuvre dans ce sens.
Suite à la correction de l'erreur d'inversion de bit, l'état est le suivant.
\frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y} \tag{19}
Ensuite, considérons la correction des erreurs d'inversion de phase. L'indice est la transformation Adamar.
\begin{align}
\ket{+} \rightarrow \ket{-} \\
\ket{-} \rightarrow \ket{+} \tag{20}
\end{align}
Considérer l'inversion de phase dans le monde de la transformation Adamar
\begin{align}
\ket{0} \rightarrow \ket{1} \\
\ket{1} \rightarrow \ket{0} \tag{21}
\end{align}
Cela devient une inversion de bits. À partir de là, je pense que si j'effectue d'une manière ou d'une autre la conversion Adamal, corrige l'erreur d'inversion de bits, puis effectue à nouveau la conversion Adamal, cela fonctionnera. En fait, il est correct et peut être clairement exprimé mathématiquement comme suit:
Tout d'abord, la transformation Adamar $ H ^ {\ otimes n} $ pour l'état de bit quantique $ n $ est
H^{\otimes n} \ket{x} = \frac{1}{\sqrt{2^{n}}} \sum_{z} (-1)^{xz} \ket{z} \tag{22}
Cela devient [^ 5]. En utilisant cela, la transformation Adamar pour l'équation (19)
[^ 5]: Je pense qu'il est bon de s'en souvenir officiellement.
\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}
Si vous définissez $ z ^ {\ prime} = z + e_2 $, la formule ci-dessus sera
\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}
Peut être transformé. Ici, en faisant attention à $ \ sum_ {y \ in C_2} (-1) ^ {yz ^ {\ prime}} $, article précédent Utilise les propriétés du signe double décrit autour de l'équation (46). Réimprimé dans la situation actuelle, sa nature est
\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}
Est exprimé comme. En appliquant cela à l'équation (24),
\sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime} + e_2} \tag{26}
Ce sera. En d'autres termes, suite à l'exécution de la transformation Adamal, l'effet de l'inversion de phase $ e_2 $ apparaîtra comme une addition dans le ket. Si cela se produit, l'effet de $ e_2 $ peut être éliminé par la procédure de correction d'erreur de l'inversion de bit comme précédemment. résultat,
\sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime}} \tag{27}
Cela signifie que. Si vous exécutez à nouveau la conversion Adamal, elle doit être complètement restaurée. J'essaierai.
\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}
encore,
\frac{\sqrt{|C_2|}}{2^{n}} \sum_{w,x+w \in C_2} |C_{2}^{\perp}| \ket{w} \tag{29}
ici,
\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}
Par conséquent, l'équation (29)
\frac{1}{\sqrt{|C_2|}} \sum_{w,x+w \in C_2} \ket{w} \tag{31}
Ce sera. Ici, si vous définissez $ x + w = x-w = y \ dans C_2 $, après tout,
\frac{1}{\sqrt{|C_2|}} \sum_{y \in C_2} \ket{x+y} \tag{32}
Cela restaurera complètement l'état d'origine.
Il a été expliqué dans Article avant-dernier que même s'il y a une erreur continue autre que l'inversion de bit ou l'inversion de phase, elle peut être traitée par elle-même. Ainsi, l'explication de la façon dont le code CSS est construit et du type de circuit quantique à passer pour corriger l'erreur est terminée pour le moment.
Mais un dernier mot.
Il existe des variantes de codes CSS avec les paramètres $ u et v $.
\ket{x+C_2} \equiv \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{uy} \ket{x+y+v} \tag{33}
Il est défini dans et s'appelle le signe $ CSS_ {u, v} (C_1, C_2) $. Il existe des paramètres supplémentaires, mais vous pouvez corriger l'erreur avec le même circuit quantique que le code $ CSS (C_1, C_2) $. Puisqu'il est dit qu'il sera utile dans la livraison de clés quantiques, seule la définition est affichée ici et la preuve est omise [^ 6].
[^ 6]: J'en ai trouvé une preuve étonnante, mais c'est un mensonge que cette marge est trop étroite pour être écrite (rires, je voulais le dire une fois. Je ne connais pas la source. Pour ceux qui sont [ici](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)). Il s'agit de "Exercice pratique 10.27" de Neilsen, Chan. J'avais l'impression de faire presque la même transformation de formule que ci-dessus, alors je l'ai omise.
Maintenant que je comprends la théorie générale des codes CSS, je voudrais donner un exemple concret pour assurer une meilleure compréhension. Il existe un "code Steane". Ceci est un code CSS avec $ C_1 = C, C_2 = C ^ {\ perp} $ et $ C $ comme code de Hamming. Soit la matrice de contrôle de parité de $ C_1 $ $ H_1 $ et la matrice de génération $ G_1 $. Par souci de simplicité, si vous utilisez le code $ [7,3] $ Hamming, $ H_1 et G_1 $ seront
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}
Peut être exprimé comme (écrit sous forme standard). D'un autre côté, $ C_2 $ est son code dual, donc d'après la définition,
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}
Peut être écrit comme.
D'ailleurs, pour dire que le code quantique basé sur le code linéaire ainsi défini est certainement un code CSS, $ C_1 $ et $ C_ {2} ^ {\ perp} $ sont les mêmes $ t $. Il faut que le nombre d'erreurs puisse être traité, c'est-à-dire que les distances de code (distances minimales) soient égales, et que $ C_2 \ sous-ensemble C_1 $.
La première est explicite car $ C_1 $ et $ C_ {2} ^ {\ perp} $ sont $ C $ par définition. Ce dernier peut être compris en utilisant ce qui a été expliqué autour de l'équation (45) dans Article précédent. Je le posterai à nouveau.
G^{T} G = 0 \Leftrightarrow C \subseteq C^{\perp} \tag{38}
En d'autres termes, si vous pouvez afficher $ G_ {2} ^ {T} G_2 = 0 $, vous pouvez prouver $ C_2 \ subseteq C_ {2} ^ {\ perp} $, c'est-à-dire $ C_2 \ subseteq C_1 $. .. J'essaierai.
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}
Donc, j'ai pu confirmer que c'était $ C_2 \ subseteq C_ {2} ^ {\ perp} $ [^ 7].
[^ 7]: [7,3] J'ai pu confirmer dans le cas du code de Hamming, mais je ne peux pas encore dire s'il est vrai pour le code de Hamming général (je pense que c'est vrai). .. Pendant un moment, j'ai pensé que je pourrais utiliser $ HG = 0 $, mais je me suis trompé.
Maintenant que nous connaissons le code linéaire classique de base, construisons un code CSS. Regardons à nouveau l'équation (1).
\ket{x+C_2} \equiv \frac{1}{\sqrt{|C_{2}|}} \sum_{y \in C_2} \ket{x+y} \tag{1}
Vous pouvez créer le code en fonction de cela.
Maintenant $ C_1 $ est le code [7,4] et $ C_2 $ est le code [7,3]. Par conséquent, le code CSS résultant est un code [7,1]. Puisqu'il s'agit d'un code quantique qui rend 1 bit quantique redondant en 7 bits quantiques, vous pouvez apporter deux $ x $ et mobiliser tous les $ y $ comme indiqué sur le côté droit de l'équation (1) et les superposer. .. Puisque $ y $ est un signe [7,3], vous pouvez ramener tous les vecteurs binaires tridimensionnels et calculer la matrice de génération $ G_2 $ dans l'équation (35). Maintenant, la question est de savoir ce que $ x $ apporter. Si vous apportez deux $ x $ appartenant au même reste, cela n'a pas de sens car les côtés droits sont exactement les mêmes. Vous devez apporter deux $ x $ appartenant à des restes différents. La différence entre les deux $ x $ ne doit pas appartenir à $ C_2 $, donc $ x = (0,0,0,0,0,0,0) ^ {T} $ et $ x Apportez deux choses: ^ {\ prime} = (1,1,1,1,1,1,1) ^ {T} $. De cette façon, la différence ne semble pas être un élément de $ C_2 $. Soit $ \ ket {0_L} $ la graine générée par $ x $ et $ \ ket {1_L} $ l'état généré par $ x ^ {\ prime} $.
\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}
Et maintenant, nous avons un code quantique. En fait, lors de l'encodage de l'état à un bit quantique de $ \ ket {\ psi} = \ alpha \ ket {0} + \ beta \ ket {1} $
\ket{\psi} \rightarrow \ket{\psi_{L}} = \alpha \ket{0_L} + \beta \ket{1_L} \tag{41}
Construisez un circuit quantique adapté à réaliser.
Ensuite, en supposant qu'une erreur sera ajoutée à cet état, exécutez le circuit qui calcule le syndrome d'erreur comme expliqué précédemment. Autrement dit, ajoutez ancilla et pour chaque état,
\ket{x} \ket{0} \rightarrow \ket{x} \ket{H_1 x} \tag{42}
En exécutant le circuit quantique qui réalise, l'effet de l'erreur d'inversion de bits de $ H_1 e_1 $ est transféré à Ansila. Dans ce cas, préparez ancilla pour 3 bits quantiques. Comme mentionné précédemment, alignez les portes CNOT, en notant l'emplacement $ 1 $ dans chaque ligne de la matrice de contrôle de parité.
|x1> -----------*--------*-------- ...
|x2> --*--------|--------|-*------ ...
|x3> --|-*------|-*------|-|------ ...
|x4> --|-|-*----|-|-*----|-|-*---- ...
|x5> --|-|-|-*--|-|-|----|-|-|---- ...
|x6> --|-|-|-|--|-|-|-*--|-|-|---- ...
|x7> --|-|-|-|--|-|-|-|--|-|-|-*-- ...
| | | | | | | | | | | |
|0> --X-X-X-X--|-|-|-|--|-|-|-|-- ...
|0> -----------X-X-X-X--|-|-|-|-- ...
|0> --------------------X-X-X-X-- ...
Ensuite, l'inversion de bits est effectuée en fonction de l'état d'Ansila. Inverse le bit correspondant à l'endroit où l'état de l'ancilla correspond à la valeur du vecteur colonne de la matrice de contrôle de parité $ H_1 $. En d'autres termes, si Ansila est $ \ ket {011} $, le premier bit quantique, si $ \ ket {101} $, le deuxième bit quantique, si $ \ ket {110} $, le troisième bit quantique, et ainsi de suite. , L'erreur d'inversion de bit peut être corrigée. En continuant à partir du circuit précédent, procédez comme suit.
|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----*---
Maintenant que l'erreur d'inversion de bit a été corrigée, l'étape suivante consiste à traiter l'erreur d'inversion de phase. Tout d'abord, utilisez la transformation Adamar. Dans le même temps, l'Ansila pour la correction d'erreur d'inversion de bit a terminé son rôle et est initialisé. En suivant le circuit ci-dessus, procédez comme suit:
|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-- ...
Maintenant que nous avons calculé le syndrome d'erreur, nous pouvons corriger l'erreur d'inversion de phase (en fait, corriger l'erreur d'inversion de bit), et enfin effectuer la transformation Adamal pour la restaurer.
|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----*------
Ceci termine la correction d'erreur [^ 8].
[^ 8]: Il y a peut-être une configuration de circuit plus efficace, mais pardonnez-la car c'est un cours pour débutant pour le moment. Au moins X portes consécutives peuvent être effacées. Ensuite, je voulais vraiment créer un code Steane à 7 quantiques à partir d'un état à 1 bit quantique, mais je ne pouvais pas penser à un bon circuit, alors j'ai également omis cela dans cet article. Je pense que si vous étudiez plus, vous pouvez écrire un circuit soigné et cool.
Maintenant, implémentons le code Steane décrit ci-dessus. Dans qlazy, le calcul du circuit quantique est effectué en créant une instance de la classe correspondant à l'état quantique ou à l'opérateur de densité et en effectuant l'opération de porte. Soit l'état quantique, soit l'opérateur de densité peut être utilisé, mais je vais essayer l'opérateur de densité qui peut utiliser des canaux quantiques (élimination de polarisation, amortissement d'amplitude, etc.) pour l'ajout de bruit [^ 9].
[^ 9]: 10 Le calcul d'opérateur de densité de bits quantiques et le NOT multi-contrôle (CNOT avec plusieurs bits de contrôle) sont utilisés abondamment, donc le traitement prend plus de temps que l'exécution dans l'état quantique. ..
Le code entier est ci-dessous.
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)
Je vais expliquer brièvement ce que vous faites. Fondamentalement, vous effectuez simplement la correction d'erreur avec le code Steane décrit ci-dessus. Maintenant, jetez un œil à la section de traitement principale.
# add custom gates
DensOp.add_method(noise)
DensOp.add_method(correct)
Nous définissons donc une porte personnalisée avec addition de bruit et correction d'erreur comme un seul bloc, et la définissons comme méthode. Le contenu du traitement est défini comme une fonction en haut.
# 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)
Définit le registre quantique à utiliser. À ce niveau, il peut être plus rapide de l'écrire à la main sans utiliser une telle méthode de classe. Maintenant qid_C est dans la liste [0,1,2,3,4,5,6] et qid_S est dans la liste [7,8,9].
# generate initial quantum state (density operator)
de_ini, de_fin = generate_qstate(qid_C, qid_S)
Préparez au hasard un état quantique (opérateur de densité) à l'aide du code Steane. Comme vous pouvez le voir en regardant la définition de la fonction, créez un état quantique à 7 quantités $ a \ ket {0_L} + b \ ket {1_L} $ en définissant aléatoirement les nombres complexes $ a et b $. Créez ensuite un état de 10 bits quantiques en effectuant un produit tensoriel avec ancilla de 3 bits quantiques. Sur cette base, un opérateur de densité est créé et renvoyé. J'ai fait deux doublons qui sont exactement les mêmes, mais c'est à la fin du programme pour comparer et évaluer l'état initial et l'état du résultat du calcul.
# add noise
de_fin.noise(kind='depolarize', qid=[qid_C[3]], prob=1.0)
Puis ajoutez du bruit. Le bruit (canal quantique) fourni en standard avec qlazy est "l'inversion de bit (bit_flip)", "l'inversion de phase (phase_flip)" et "l'inversion de phase de bit (bit_phasee_flip)". Il existe 6 types, "dépolariser", "dumping d'amplitude (amp_dump)" et "déphasage (phase_dump)", et chacun d'eux donne une liste de nombres de bits quantiques à appliquer et une probabilité d'exprimer l'intensité du bruit comme arguments. Je suis. Le bruit de la fonction (porte personnalisée) est appliqué à l'opérateur de densité en spécifiant la chaîne de caractères indiquant le type de canal quantique, la liste de nombres de bits quantiques et la probabilité comme arguments. Voir la définition de la fonction pour plus de détails.
# error correction
de_fin.correct('bit_flip', qid_C, qid_S)
de_fin.correct('phase_flip', qid_C, qid_S)
Exécute une correction d'erreur d'inversion de bit et une correction d'erreur d'inversion de phase. La fonction (porte personnalisée) correct spécifie une chaîne de caractères indiquant si l'argument prend en charge l'inversion de bits ou l'inversion de phase, et une liste de nombres de bits quantiques correspondant à l'espace de code et ancilla. Jetons un œil au contenu de correect.
self.reset(qid=qid_S)
Maintenant initialisez Ansila. L'initialisation est requise en premier pour le calcul du syndrome d'erreur.
if kind == 'phase_flip': [self.h(q) for q in qid_C]
Si vous voulez prendre en charge l'inversion de phase, vous devez d'abord exécuter Adamal, donc je le fais ici.
# 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))]
Maintenant, effectuez le calcul du syndrome d'erreur. Afin d'exécuter le circuit décrit ci-dessus, nous exécutons une boucle qui applique correctement CNOT à chaque ligne de la matrice de contrôle de parité du code de Hamming.
# 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))]
Ensuite, en fonction du résultat du syndrome d'erreur, le bit est inversé et restauré. En fonction de chaque colonne de la matrice de contrôle de parité du code de Hamming, nous exécutons une boucle qui applique de manière appropriée le multi-contrôle NOT (méthode mcx).
if kind == 'phase_flip': [self.h(q) for q in qid_C]
Donc, s'il prend en charge l'inversion de phase, appliquez Adamal à la fin pour le restaurer. Ceci termine la correction d'erreur.
Revenez à nouveau à la section de traitement principale.
# print result
print("== result ==")
print("- fidelity = {:.6f}".format(de_fin.fidelity(de_ini, qid=qid_C)))
Afin de comparer et d'évaluer le premier opérateur de densité et l'opérateur de densité après avoir effectué un traitement de correction d'erreur, le procédé de fidélité calcule et affiche la fidélité des deux. En spécifiant la liste de nombres de bits quantiques d'intérêt dans l'argument qid, la fidélité de seulement la partie pertinente peut être calculée.
DensOp.free_all(de_ini, de_fin)
Libérez la mémoire utilisée. Si vous spécifiez plusieurs instances DensOp en tant qu'arguments de la méthode de classe free_all, vous pouvez libérer la mémoire de plusieurs instances sur une seule ligne (vous pouvez spécifier un nombre quelconque d'instances dans l'argument).
Le résultat de l'exécution est affiché. Ceci est le résultat de l'application du canal de dépolarisation au troisième bit quantique avec une probabilité de 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
Puisque la fidélité est de 1.0, la correction d'erreur a réussi. J'ai essayé de changer le nombre de bits quantiques, le canal quantique et la probabilité, mais dans tous les cas, la fidélité était de 1,0, et j'ai trouvé que la correction d'erreur était possible.
Cependant, bien sûr, il était inutile s'il y avait du bruit dans les deux bits quantiques. C'est comme suit.
== 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
Et, bien sûr, cela ne fonctionnait pas si j'omettais la correction d'erreur pour l'inversion de phase.
# error correction
de_fin.correct('bit_flip', qid_C, qid_S)
# de_fin.correct('phase_flip', qid_C, qid_S)
Si vous commentez la partie correspondant à l'inversion de phase,
== 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
Et cela ne corrige pas non plus l'erreur.
J'ai donc pu confirmer l'opération attendue.
Il s'avère que si vous apportez deux codes linéaires classiques qui satisfont à une certaine condition, vous pouvez toujours construire un code quantique à partir d'eux. En d'autres termes, nous avons l'un des outils puissants qui permettent de construire concrètement divers codes quantiques. De plus, le "code Steane" peut être exécuté avec 7 bits quantiques. Puisque le "code Shor" nécessitait 9 bits quantiques, nous avons pu réduire 2 bits quantiques (bien que nous ayons également eu besoin d'un ansila de 3 bits quantiques)!
Comme mentionné dans l '"Introduction", le "code CSS" est également équivalent à la sous-classe plus générale "code stabilisateur". La prochaine fois, j'aimerais étudier ce "code stabilisateur" (prévu).
c'est tout
Recommended Posts