Bases de la théorie de l'information quantique: codes de surface topologique

\def\bra#1{\mathinner{\left\langle{#1}\right|}} \def\ket#1{\mathinner{\left|{#1}\right\rangle}} \def\braket#1#2{\mathinner{\left\langle{#1}\middle|#2\right\rangle}}

introduction

Afin de réaliser un calcul quantique tolérant aux pannes, le taux d'erreur de chaque pièce est d'environ 10 $ ^ {-4} = 0,01 % $ ou moins, et la configuration du code concaténé (basé sur le code Steane) est de 7 $. J'ai parlé du besoin de nombreux bits quantiques la dernière fois. Cela rend beaucoup de gens désespérés, mais le "code de surface topologique" décrit ici devrait vous donner la lumière de l'espoir.

Permettez-moi d'abord de dire ce que j'essaie d'expliquer dans les sections qui suivent. Tout d'abord, dans «l'explication théorique», l'état de code du code de surface topologique (ci-après dénommé «code de surface») et comment construire l'opération logique de base sont décrits, puis la correction d'erreur est bien effectuée. Je vais vous expliquer ce que vous pouvez faire. Dans "Operation check", une série de flux de création d'un état de code, d'ajout de bruit et de correction d'erreurs à l'aide du simulateur de calcul quantique qlazy fonctionne correctement. Sois sûr que.

Les documents suivants ont été utilisés comme références.

Koshiba, Morimae, Fujii "Calcul quantique basé sur l'observation" Corona (2017)
Keio University "Quantum Computer Class # 14 Geometric Code"
K.Fujii,"Quantum Computation with Topological Codes - from qubit to topological fault-tolerance",arXiv:1504.01444v1 [quant-ph] 7 Apr 2015
[Technologie de correction des erreurs informatiques Quantum](https://www.google.com/url?sa=t&source=web&rct=j&url=https://ipsj.ixsq.nii.ac.jp/ej/%3Faction% 3Drepository_uri% 26item_id% 3D101754% 26file_id% 3D1% 26file_no% 3D1 & ved = 2ahUKEwist9m8zuPqAhVKfd4KHaXEBg8QFjAAegQIBBAB & usg = AOvVaw0ayU0bWXc63PaMK

Explication de la théorie

Définition du code de surface

Opérateur de face et opérateur de sommet

Un code de surface est un code de correction d'erreur défini par le générateur d'un groupe de stabilisateurs qui sont régulièrement définis sur un plan dans lequel les bits quantiques sont disposés régulièrement. Par exemple, considérons un réseau bidimensionnel de $ n \ fois n $ et placez un bit quantique au milieu de ce côté (à gauche dans la figure ci-dessous). Et on suppose que la condition aux limites périodique est satisfaite. Autrement dit, supposons que les côtés supérieur et inférieur sont identiques et que les côtés gauche et droit sont identiques. Après avoir roulé le côté supérieur et le côté inférieur ensemble pour faire un cylindre, tournez les deux cercles aux deux extrémités du cylindre et collez-les ensemble pour faire une forme de beignet = tore, mais une telle image est. Puisqu'il est difficile d'illustrer un objet en trois dimensions, je vais l'expliquer en utilisant une grille représentée sur un plan en dessous, mais pensez-y comme un développement d'un tore dans votre esprit.

Vous avez besoin d'un générateur pour créer un code de stabilisation. Donc, nous définissons deux sources sur cette grille. L'un est "l'opérateur de plaquette" et l'autre est "l'opérateur étoile" (à droite dans la figure ci-dessus).

L'opérateur de face $ A_m $ est défini comme suit pour chaque face $ f_m $ de la grille.

A_m = \prod_{i \in \partial f_m} Z_i  \tag{1}

Ici, $ \ partial f_m $ représente les quatre côtés correspondant à la frontière de la $ m $ ème face $ f_m $, et $ Z_i $ est le Pauli $ Z $ pour le bit quantique placé du $ i $ ème côté. C'est un opérateur. Comme indiqué sur le côté droit de la figure ci-dessus, vous pouvez l'imaginer comme un carré qui entoure chaque surface. Ceci est réparti sur tout le réseau.

D'autre part, l'opérateur de sommet est défini comme suit pour chaque sommet $ v_k $ de la grille.

B_k = \prod_{j \in \delta v_k} X_j  \tag{2}

Ici, $ \ delta v_k $ représente les quatre côtés connectés au $ k $ e sommet $ v_k $, et $ X_j $ est le Pauli $ X pour les bits quantiques placés du côté $ j $ e. L'opérateur . Comme indiqué sur le côté droit de la figure ci-dessus, vous pouvez l'imaginer comme un caractère croisé centré sur chaque sommet. Ceci est également réparti sur toute la grille comme auparavant. Les opérateurs de face et les opérateurs de sommet sont interchangeables, et lorsqu'un opérateur de sommet et un opérateur de surface se chevauchent, ils partagent toujours deux bits quantiques, ils sont donc interchangeables ( X_ {i} X_ {j). } $ Et $ Z_ {i} Z_ {j} $ sont interchangeables). Par conséquent, nous avons maintenant défini une source réalisable.

Eh bien, voici le problème. Combien de bits quantiques (côtés), d'opérateurs de face et d'opérateurs de sommet y a-t-il dans ce réseau bidimensionnel $ n \ times n $? Compte tenu de la condition aux limites périodique, le nombre de bits quantiques (côtés) est $ 2n ^ 2 $, le nombre d'opérateurs de face (faces) est $ n ^ 2 $ et le nombre d'opérateurs de sommets (sommets) est $. Vous pouvez voir qu'il y a n ^ 2 $ pièces. Il existe des générateurs $ 2n ^ 2 $ qui sont interchangeables, mais tous ne sont pas indépendants. Tous les produits des opérateurs de face sont l'opérateur d'égalité $ I $, et tous les produits des opérateurs de sommet sont également l'opérateur d'égalité $ I $ [^ 1]. Puisqu'il y a deux conditions de contrainte, le nombre de générateurs indépendants est de $ 2n ^ 2-2 $. Puisque le nombre de bits quantiques (côtés) était de $ 2n ^ 2 $, le nombre de bits logiques pouvant être décrits dans cet espace de code est $ 2n ^ {2} - (2n ^ {2} -2) = 2 $ Ce sera un individu.

[^ 1]: Est-ce que ça va? Les opérateurs de surface sont répartis sur le tore sans aucune lacune. Si vous collectez tous les opérateurs de face, l'opérateur $ Z $ correspondant à chaque côté apparaîtra toujours deux fois, donc le produit sera l'opérateur d'égalité $ I $. De même, les opérateurs de sommet sont répartis sur le tore sans aucune interruption. Lorsque tous les opérateurs de sommet sont collectés, l'opérateur $ X $ correspondant à chaque côté apparaît toujours deux fois, donc le produit est l'opérateur d'égalité $ I $.

Double réseau

La grille illustrée dans la figure ci-dessus a des côtés qui relient les sommets, mais vous pouvez penser à une autre grille dont les côtés relient les faces. En d'autres termes, c'est une grille qui les relie à un sommet au centre de la surface (indiqué par une ligne brisée à gauche dans la figure ci-dessous). Un tel réseau est appelé un "double réseau".

Lorsque vous utilisez cette double grille pour représenter les opérateurs de face et de sommet, quelque chose d'étrange se produit (ou, si vous y réfléchissez un instant, vous comprendrez). La forme de l'opérateur de visage devient une croix, la forme de l'opérateur de sommet devient un quadrilatère et l'image de la figure est inversée (à droite sur la figure ci-dessus).

Puisque les faces, les côtés et les sommets du réseau d'origine sont les sommets, les côtés et les faces du double réseau, les générateurs $ A_m et B_k $ peuvent être réécrits dans les mots du double réseau comme suit. Je vais.

A_m = \prod_{i \in \delta \bar{v}_m} Z_i  \tag{3}

B_k = \prod_{j \in \partial \bar{f}_k} X_j  \tag{4}

Ici, $ \ bar {v} _m $ est le sommet lorsque la face $ f_m $ est représentée par la double grille, et $ \ bar {f} _k $ est le plan lorsque le sommet $ v_k $ est représenté par la double grille ( Dorénavant, j'ajouterai une barre au-dessus du symbole pour indiquer clairement qu'il s'agit d'une entité sur un double treillis). Vous verrez pourquoi nous avons introduit ce genre de chose ici dans une explication ultérieure, alors souvenez-vous-en [^ 2].

[^ 2]: À cette époque, dans Référence 3, il est généralement décrit en termes de topologie algébrique utilisant un complexe de chaînes. Je vais. Il est intéressant de noter que les codes de surface peuvent être considérés sur divers types de grilles autres que les grilles carrées, mais ils seront longs, je les omettrai donc dans cet article.

Boucle évidente

Maintenant que la source a été définie, considérons le type de propriété de la boucle définie sur le lattice = torus en termes d'opérateur. Tout d'abord, considérons la frontière $ \ partielle D $ du plan $ D $ sur la grille (voir la figure ci-dessous).

Une telle boucle est appelée "boucle triviale" [^ 3]. Si nous écrivons le produit des opérateurs $ Z $ placés de chaque côté de la boucle comme $ Z (\ partial D) $,

[^ 3]: Une boucle qui peut être contractée à un point par déformation continue est appelée "boucle triviale".

Z(\partial D) = \prod_{m,f_m \in D} A_{m}  \tag{5}

Est établi. Le côté droit est le produit de tous les opérateurs de visage qui composent le visage $ D $. Pouvez-vous voir cela? Deux opérateurs de faces adjacentes partagent un opérateur $ Z $, donc si vous prenez le produit des deux, le côté commun sera $ I $. Lorsque tous les opérateurs de face inclus dans $ D $ sont multipliés, tous les côtés sauf la limite de $ D $ deviennent $ I $, et après tout, seul l'opérateur $ Z $ au-dessus de la limite $ \ partiel D $ reste. Ce sera. Comme il ressort de l'équation (5), cet opérateur $ Z (\ partial D) $ est interchangeable avec toutes les sources et est un élément du groupe de stabilisateurs ($ A_ {m} $). Parce que c'est un produit).

Considérons ensuite la frontière $ \ partial \ bar {D} $ du plan $ \ bar {D} $ défini sur le double réseau (voir la figure ci-dessous).

Si nous écrivons $ X (\ partial \ bar {D}) $ comme le produit des opérateurs $ X $ placés de chaque côté de la boucle sur la grille double,

X(\partial \bar{D}) = \prod_{k,\bar{f}_k \in \bar{D}} B_{k}  \tag{6}

Est établi. Comme précédemment, si vous prenez le produit de tous les opérateurs de surface qui composent la surface (ceux qui étaient des opérateurs de sommet dans la grille d'origine), seul l'opérateur $ X $ sur la frontière reste. Comme il ressort de l'équation (6), cet opérateur $ X (\ partial \ bar {D})) $ est également interchangeable avec toutes les sources et est un élément des stabilisateurs.

Ainsi, le produit des opérateurs $ Z $ placés sur la boucle évidente du treillis d'origine et le produit des opérateurs $ X $ placés sur la boucle évidente du treillis double sont des éléments des stabilisateurs. , Même si cela est appliqué à l'état codé, l'état codé ne change pas.

Boucle non triviale

Ensuite, regardons les propriétés des opérateurs $ Z $ et $ X $ placés au-dessus de la boucle non triviale loop = non trivial.

Dans la figure ci-dessus, il y a une ligne droite étiquetée $ l_1 $, qui est une boucle qui s'enroule autour du tore en fonction des conditions aux limites périodiques. Bien que ce soit une boucle, c'est une boucle non triviale car elle ne peut pas être contractée en un point par déformation continue. L'opérateur $ Z $ est aligné de chaque côté et le produit est pris.

\tilde{Z}_1 = Z(l_1)  \tag{7}

J'écrirai. Alors cet opérateur et les générateurs sont interchangeables. Bien sûr, l'opérateur face ne contient que l'opérateur $ Z $, et l'opérateur sommet a toujours deux côtés qui se chevauchent avec $ l_1 $, il est donc interchangeable [^ 4]. C'est interchangeable, mais ce n'est pas un élément des stabilisateurs. En d'autres termes, il ne peut pas être exprimé sous la forme du produit d'origine. Si vous pensez que c'est un mensonge, faites de votre mieux. Par exemple, disons que vous voulez créer un produit des opérateurs $ Z $ alignés sur $ l_1 $, donc vous alignez les opérateurs de visage à côté de $ l_1 $. Mais le produit de ceux-ci est $ Z (l_1) $ et une autre boucle non triviale d'opérateurs $ Z $.

[^ 4]: Dans la figure, $ l_1 $ est représenté par une ligne droite, mais même s'il s'agit d'une boucle qui n'est pas une ligne droite, il y aura toujours deux côtés qui se chevauchent avec l'opérateur de sommet. Vous pouvez le comprendre en dessinant un diagramme et en y réfléchissant pendant environ une minute.

Qu'est-ce qu'un opérateur interchangeable avec toutes les sources et qui n'est pas un élément des stabilisateurs? La réponse est un opérateur logique. Hmm? C'est peut-être devenu, alors je vais l'expliquer pour le moment. Groupe de stabilisateurs $ S $ utilisant un générateur indépendant,

S = < g_1, g_2, \cdots g_{n-k} >  \tag{8}

Écrivez en tant que et définissez l'état du stabilisateur sur $ \ ket {\ psi} $. En introduisant tous les générateurs $ g_i $ et l'opérateur commutable $ g \ notin S $,

g \ket{\psi} = g g_{i} \ket{\psi} = g_{i} g \ket{\psi}  \tag{9}

Est vrai, donc $ g \ ket {\ psi} $ est l'état sur l'espace produit des espaces propres correspondant à la valeur propre $ + 1 $ de $ g_i $ (état propre simultané). Autrement dit, l'état sur l'espace de code. Cependant, $ g \ ket {\ psi} = \ ket {\ psi} $ ne tient pas (car $ g \ notin S $). Par conséquent, $ g $ est un opérateur qui ne change que l'état logique sans sortir de l'espace de code, c'est-à-dire un opérateur logique.

Supposons maintenant que $ \ tilde {Z} _1 $ défini dans l'équation (7) soit l'opérateur logique $ Z $ pour le premier bit logique [^ 5].

[^ 5]: J'ai utilisé $ l_1 $ pour définir l'opérateur $ Z $ pour le premier bit logique, mais cela peut être une boucle non triviale (pas nécessairement une ligne droite) qui tourne verticalement. Vous pouvez utiliser n'importe quoi.

Alors, comment définissez-vous l'opérateur $ X $ pour le premier bit logique?

\tilde{X}_1 = X(\bar{l}_1)  \tag{10}

Ensuite, il est possible de satisfaire $ \ tilde {X} _1 \ tilde {Z} _1 \ tilde {X} _1 = - \ tilde {Z} _1 $, qui est interchangeable avec tous les générateurs. C'est bon.

De plus, l'opérateur $ Z $ pour le deuxième bit logique

\tilde{Z}_2 = Z(l_2)  \tag{11}

Tu peux le faire. Depuis que j'ai utilisé une boucle non triviale qui tourne verticalement lors de la définition de $ \ tilde {Z} _1 $, j'utilise une boucle non triviale qui tourne horizontalement [^ 6].

[^ 6]: Si vous utilisez une boucle non triviale qui tourne dans le sens vertical, ce sera une opération logique qui a le même effet que $ \ tilde {Z} _1 $, vous devez donc utiliser une boucle topologiquement différente.

L'opérateur $ X $ pour le deuxième bit logique est commutable avec toutes les sources et contre-commutable avec $ \ tilde {Z} _2 $.

\tilde{X}_2 = X(\bar{l}_2)  \tag{12}

Tu peux le faire. Vous avez maintenant tous les opérateurs logiques de base. Encore une fois, les quatre boucles illustrées ci-dessus ne sont qu'un exemple. Si vous fournissez des boucles non triviales topologiquement séparées, une pour la grille d'origine et une pour la grille double, vous pouvez définir les opérateurs $ Z $ et $ X $ pour les deux bits logiques [^ 7].

Correction des erreurs

Maintenant que nous avons défini l'espace de code et les opérateurs logiques de base, voyons comment la correction d'erreur peut être obtenue à l'aide de ce code.

Erreur d'inversion de bit

Tout d'abord, regardons comment le bit d'erreur peut être identifié si une erreur d'inversion de bit se produit dans un bit. Par exemple, supposons qu'une erreur d'inversion de bit se produise dans le bit numéro 4 de la figure ci-dessous.

Dans ce cas, lorsque tous les générateurs sont mesurés, les opérateurs de surface $ Z_ {1} Z_ {2} Z_ {3} Z_ {4} $ et $ Z_ {4} correspondant à $ f_1 $ et $ f_2 $ dans la figure ci-dessus. Seul Z_ {5} Z_ {6} Z_ {7} $ génère la valeur mesurée $ -1 $. Si l'état logique d'origine est $ \ ket {\ psi_ {L}} $

\begin{align}
Z_{1} Z_{2} Z_{3} Z_{4} (X_{4} \ket{\psi_{L}}) &= - X_{4} (Z_{1} Z_{2} Z_{3} Z_{4} \ket{\psi_{L}}) = -X_{4} \ket{\psi_{L}} \\
Z_{4} Z_{5} Z_{6} Z_{7} (X_{4} \ket{\psi_{L}}) &= - X_{4} (Z_{4} Z_{5} Z_{6} Z_{7} \ket{\psi_{L}}) = -X_{4} \ket{\psi_{L}} \tag{13}
\end{align}

À partir de là, nous pouvons voir que la valeur mesurée a une probabilité de 100 $ % $ et sera de -1 $. Par conséquent, si l'opérateur de surface est celui qui mesure le syndrome de chaque générateur et donne $ -1 $, cela signifie qu'il y a eu une erreur d'inversion de bits, et cet emplacement est l'endroit où les opérateurs de surface sont en contact les uns avec les autres. Peut être identifié comme. Vous pouvez revenir à l'état d'origine en exécutant à nouveau l'inversion de bit sur le bit spécifié.

Mais que se passe-t-il si deux bits ou plus ont une erreur d'inversion de bits? Par exemple, considérons le cas où il y a une erreur dans les trois bits indiqués en bleu comme indiqué à gauche dans la figure ci-dessous.

Seuls les opérateurs de surface correspondant à la surface $ f_2 $ et à la surface $ f_7 $ mesurent l'origine et la sortie $ -1 $. Une erreur est également survenue dans les bits qui composent la surface $ f_4 $ et la surface $ f_5 $, mais comme les bits sont inversés en même temps pour chacun des deux bits, la valeur mesurée sera $ + 1 $. S'il y a une erreur dans les bits appartenant aux faces adjacentes comme celle-ci, elle ressemble à une chaîne connectée lorsqu'elle est vue dans une double grille, elle est donc appelée "chaîne d'erreur" (indiquée par la ligne bleue). , Seul l'opérateur de surface correspondant au point final de cette chaîne répond à la mesure du syndrome (la valeur mesurée est $ -1 $, qui est remplie de bleu clair). Nous devons en quelque sorte restaurer toute la chaîne d'erreur à partir de ces informations de point de terminaison et corriger l'erreur. Un soi-disant problème de mauvais réglage? Donc, même si vous faites de votre mieux, c'est une méthode qui ne réussit que de manière probabiliste, non? C'est peut-être devenu une atmosphère. Mais ne t'inquiète pas. Je pense que c'est là que le code de surface est très erratique, mais en fait, ce n'est pas grave si l'estimation de la chaîne d'erreur est dans une certaine mesure désactivée. Je vais vous expliquer pourquoi ça va.

Regardez à droite dans la figure ci-dessus. Supposons que la chaîne d'erreur réelle soit $ \ bar {c} $ (indiquée par la ligne bleue). D'autre part, la chaîne d'erreur estimée est $ \ bar {r} $ (indiquée par la ligne rouge). À ce stade, l'erreur réelle est $ X (\ bar {c}) $, mais l'erreur estimée est $ X (\ bar {r}) $. Comme vous pouvez le voir sur la figure, $ X (\ bar {c}) $ et $ X (\ bar {r}) $ sont les produits des opérateurs de sommet $ B_2, B_4, B_5 $ (la partie remplie en orange clair). Vous pouvez migrer l'un vers l'autre en calculant. En d'autres termes

X(\bar{c}) = B_{2} B_{4} B_{5} X(\bar{r})  \tag{14}

est. Par conséquent, même si vous pensez que l'erreur est $ X (\ bar {r}) $ et effectuez un traitement de récupération,

\begin{align}
X(\bar{r}) X(\bar{c}) \ket{\psi_{L}} &= X(\bar{r}) B_{2} B_{4} B_{5} X(\bar{r}) \ket{\psi_{L}} \\
&= X(\bar{r}) X(\bar{r}) B_{2} B_{4} B_{5} \ket{\psi_{L}} \\
&= B_{2} B_{4} B_{5} \ket{\psi_{L}} = \ket{\psi_{L}} \tag{15}
\end{align}

Après tout, il est revenu à son état d'origine [^ 8]. Par conséquent, si la véritable chaîne d'erreur et la chaîne d'erreur qui peut être transférée par transformation continue peuvent être estimées comme indiqué à droite dans la figure ci-dessus, l'état du code d'origine peut être restauré sans aucun problème.

[^ 8]: $ X (\ bar {r} + \ bar {c}) $ n'a aucun effet sur l'état du signe car $ \ bar {r} + \ bar {c} $ est une boucle explicite Il est également bon de comprendre que cela n'affecte pas.

Cependant, si la chaîne d'erreur est estimée de telle sorte qu'elle ne puisse pas être déformée en permanence de la chaîne d'erreur réelle comme indiqué dans la figure ci-dessous, le processus de récupération échouera.

Erreur d'inversion de phase

Ensuite, considérons le cas où une erreur d'inversion de phase se produit dans n'importe quel bit. Supposons qu'une erreur d'inversion de phase se produise dans le 4ème bit, comme illustré dans la figure ci-dessous.

Dans ce cas, lorsque tous les générateurs sont mesurés, les opérateurs de sommets $ X_ {1} X_ {3} X_ {4} X_ {6} $ et $ X_ {2} correspondant à $ v_1 $ et $ v_2 $ dans la figure ci-dessus. Seul X_ {4} X_ {5} X_ {7} $ génère la valeur mesurée $ -1 $. Si l'état logique d'origine est $ \ ket {\ psi_ {L}} $

\begin{align}
X_{1} X_{3} X_{4} X_{6} (Z_{4} \ket{\psi_{L}}) &= - Z_{4} (X_{1} X_{3} X_{4} X_{6} \ket{\psi_{L}}) = -Z_{4} \ket{\psi_{L}} \\
X_{2} X_{4} X_{5} X_{7} (Z_{4} \ket{\psi_{L}}) &= - Z_{4} (X_{2} X_{4} X_{5} X_{7} \ket{\psi_{L}}) = -Z_{4} \ket{\psi_{L}} \tag{16}
\end{align}

À partir de là, nous pouvons voir que la valeur mesurée a une probabilité de 100 $ % $ et sera de -1 $. Par conséquent, si l'opérateur de sommet est celui qui mesure le syndrome de chaque générateur et donne $ -1 $, cela signifie qu'il y a eu une erreur d'inversion de phase, et cet emplacement est l'endroit où les opérateurs de sommet sont en contact les uns avec les autres. Peut être identifié comme. L'état d'origine peut être restauré en exécutant à nouveau l'inversion de phase sur le bit spécifié.

Mais que se passe-t-il si deux bits ou plus présentent une erreur d'inversion de phase? Par exemple, considérons le cas où il y a une erreur dans les trois bits indiqués en bleu comme indiqué à gauche dans la figure ci-dessous.

Seuls les opérateurs de sommet correspondant au sommet $ v_3 $ et au sommet $ v_4 $ mesurent l'origine et la sortie $ -1 $ (la partie remplie en bleu clair). Une erreur est survenue dans les bits qui composent le sommet $ v_2 $ et le sommet $ v_5 $, mais comme la phase est inversée en même temps pour chacun des deux bits, la valeur mesurée sera $ + 1 $. Dans ce cas, vous devez estimer la chaîne d'erreur qui relie les sommets $ v_3, v_2, v_5, v_4 $. Cependant, comme précédemment, si la chaîne d'erreur estimée $ r $ peut être continuellement transformée à partir de la chaîne d'erreur vraie $ c $, $ Z (r) $ créé en fonction de l'estimation est appliquée. Ce faisant, vous pouvez restaurer l'état logique d'origine. La récupération échoue lorsque la chaîne estimée ne peut pas être continuellement transformée à partir de la chaîne réelle.

Estimation de la chaîne d'erreur

Comme nous venons de le voir, même si l'estimation de la chaîne d'erreur est légèrement décalée, elle peut être récupérée, mais si la chaîne d'erreur estimée ne peut pas être migrée en raison de la chaîne d'erreur réelle et de la déformation continue, la correction d'erreur échouera. .. Je veux éviter autant que possible l'échec, mais réfléchissons à la meilleure façon de l'estimer.

Maintenant, supposons qu'une erreur d'inversion de bit $ X (\ bar {c}) $ se produise sur la chaîne d'erreur $ \ bar {c} $ (le même argument vaut pour l'erreur d'inversion de phase, donc ici l'erreur d'inversion de bit Pensez seulement). Ici, la chaîne d'erreur $ \ bar {c} $ n'est pas nécessairement une chaîne unique. Imaginons que plusieurs chaînes soient regroupées pour représenter $ \ bar {c} $ (ligne bleue dans la figure ci-dessous).

La probabilité d'une telle erreur $ p (\ bar {c}) $ est

p(\bar{c}) = (1-p)^{|E|} \prod_{i \in E} \Bigl(\frac{p}{1-p} \Bigr)^{z_i}  \tag{17}

Peut être exprimé comme. ici,|E|Est le nombre total de côtés,z_iEstiLe deuxième côté est\bar{c}Si inclus dans1, Si non0C'est une valeur binaire qui prend la valeur^[1]。

La chaîne d'erreur la plus plausible est $ \ partial \ bar {c} $ lorsque la mesure du syndrome aboutit au point de terminaison $ \ bar {c} $ boundary $ \ partial \ bar {c} $. Avec $ \ bar {c} ^ {\ prime} $, la probabilité conditionnelle $ p (\ bar {c} ^ {\ prime} | \ partial \ bar {c}) $ est maximisée sous la condition que Il semble bon de penser que oui. En d'autres termes

\bar{r} = \arg \max_{\bar{c}^{\prime}} p(\bar{c}^{\prime}|\partial \bar{c})  \tag{18}

Il semble bon d'estimer la chaîne d'erreur par. Où $ p (\ bar {c} ^ {\ prime} | \ partial \ bar {c}) $ est

p(\bar{c}^{\prime}|\partial \bar{c}) \propto (1-p)^{|E|} \prod_{i \in E} \Bigl( \frac{p}{1-p} \Bigr)^{z_{i}^{\prime}} \Bigr|_{\partial \bar{c}^{\prime} = \partial \bar{c}}  \tag{19}

Peut être exprimé comme. A ce moment, $ z_ {i} ^ {\ prime} $ prend la valeur de $ 1 $ si le $ i $ ème côté est inclus dans $ \ bar {c} ^ {\ prime} $, et $ 0 $ sinon. Puisqu'il est supposé être une valeur binaire, si vous trouvez la série binaire $ \ {z_ {i} ^ {\ prime} \} $ qui maximise l'équation (19), alors $ \ bar {r} dans l'équation (18) Vous savez $. Comme vous pouvez le voir en regardant de près l'équation (19), pour maximiser cela, le nombre de $ 1 $ contenu dans la série binaire $ \ {z_ {i} ^ {\ prime} \} $ doit être minimisé. Ça devrait être. En d'autres termes, tous les points d'extrémité doivent être connectés afin que la distance soit minimisée (ligne rouge dans la figure ci-dessous). Un tel algorithme d'optimisation de graphe est appelé «algorithme de correspondance parfaite de poids minimum», et un algorithme qui peut être résolu en étapes polymorphes est connu (mais il n'est pas bien compris, donc l'explication est omise. Masu, sueur).

Probabilité d'erreur et taux d'échec de correction

En général, si le nombre de bits pour le codage est augmenté pour augmenter la redondance, une correction d'erreur avec de bonnes performances (faible taux d'échec de correction) peut être réalisée, mais en principe, la probabilité d'erreur par bit est inférieure à un certain seuil. Doit être.

Par exemple, en considérant un code d'itération classique qui rend un bit redondant avec $ N $ bits, si une erreur ne dépasse pas la moitié des $ N $ bits, elle peut être complètement restaurée en prenant un vote majoritaire. En gros, si la probabilité d'erreur par bit est inférieure au seuil de 1/2 $, elle peut être restaurée. En disant "grossièrement" ici, cela signifie qu'il est probable qu'une erreur sera mélangée dans plus de la moitié des bits qui composent un signal que vous voulez transmettre, et dans ce cas la restauration échouera. Cependant, si la valeur de $ N $ peut être rendue suffisamment grande, ce taux d'échec peut être réduit à zéro. Bien entendu, à ce stade, la condition préalable que la probabilité d'erreur soit inférieure au seuil ($ 1/2 $) est indispensable. Si la probabilité d'erreur est supérieure au seuil, augmenter la valeur de $ N $ est contre-productif. Plus elle est grande, plus la restauration échouera sûrement [^ 10].

[^ 10]: Les caractéristiques du code de correction d'erreur peuvent être exprimées par une courbe avec la probabilité d'erreur sur l'axe horizontal et le taux d'échec de correction sur l'axe vertical, mais il s'agit d'une courbe en forme de S avec le seuil de probabilité d'erreur comme point de retournement. .. Ainsi, à mesure que la valeur de $ N $ augmente, la courbe en forme de S se resserre et à la limite de $ N $ infini, elle devient une courbe caractéristique échelonnée.

Il en va de même pour le code de correction d'erreur quantique, et le fait que la correction d'erreur soit efficace ou non doit être inférieur à un certain seuil pour la probabilité d'erreur par bit. S'il est inférieur à un certain seuil, si $ N $ est suffisamment grand, le taux d'échec de la correction sera aussi proche de zéro que possible. Cependant, au contraire, si la probabilité d'erreur est supérieure à la valeur seuil, augmenter $ N $ augmentera le taux d'échec de la correction.

Alors, quel est ce seuil pour les codes de surface? Les résultats de la simulation numérique sont publiés dans Référence 3, qui sont cités ci-dessous.

Ici, l'axe horizontal représente la probabilité d'erreur pour chaque bit, l'axe vertical représente le taux d'échec de la correction, la ligne continue est $ n = 10 $, la ligne brisée est $ n = 20 $ et la ligne pointillée est $ n = 30 $. (Je pense maintenant à une grille $ n \ times n $). Il semble que le seuil de probabilité d'erreur soit calculé à environ 10,3 $ % $ à partir du point de retournement de cette courbe en S. D'ailleurs, cette simulation est le cas où la chaîne d'erreur est estimée par «l'algorithme de correspondance parfaite du poids minimum».

Le code de surface est un code de régression qui donne les mêmes résultats de mesure du syndrome pour plusieurs modèles de chaîne d'erreur, de sorte que la distance minimale n'est pas toujours optimale. Le décodage optimal est celui qui maximise la probabilité totale de donner le même résultat de correction, donc dans ce cas ce seuil sera d'environ 10,9 $ % $.

En outre, dans un réseau carré, l'erreur d'inversion de bit et l'erreur d'inversion de phase ont le même seuil de probabilité d'erreur, mais si la forme du réseau est modifiée en forme de nid d'abeille ou en forme de cage, l'erreur d'inversion de bit et les seuils d'erreur d'inversion de phase deviennent asymétriques. .. Dans un système physique réel, l'inversion de phase est souvent plus grande que l'inversion de bits, il semble donc que des simulations basées sur de telles hypothèses soient également effectuées (pour plus de détails, voir [Référence 3](https: // arxiv.). Veuillez vous référer à org / abs / 1504.01444)).

Le seuil d'erreur d'environ 10 $ % $ qui vient d'être expliqué est lié à l'erreur qui se produit lorsque l'état du code est maintenu et transmis par le code de surface. Dans le calcul quantique réel, l'erreur causée par la préparation de l'état initial, le calcul logique et la mesure doit être prise en considération. Il semble que le taux d'erreur par composant soit estimé à environ 1 $ % $ afin de réaliser un calcul quantique tolérant aux pannes en les combinant tous. Comme expliqué dans Article précédent, en supposant un code de concaténation basé sur un code CSS tel que le code Steane, $ 10 ^ {-4} = 0,01 \ C'est un grand pas en avant, car cela signifiait qu'un seuil [^ 11] inférieur ou égal à% $ était nécessaire. C'est ce que j'avais l'habitude de dire dans «l'introduction» comme «la lumière de l'espoir».

[^ 11]: Cela semble être une estimation plutôt douce, et il semble que l'on dit en fait qu'elle est de 10 $ ^ {-5} -10 ^ {-6} $.

Contrôle de fonctionnement

Maintenant, utilisons le simulateur de calcul quantique qlazy pour configurer le code de surface sur la grille $ 3 \ times 3 $ et vérifier que la correction d'erreur peut être effectuée correctement. Je vais.

la mise en oeuvre

Voici l'intégralité du code Python.

from qlazypy import QState

Lattice = [{'edge': 0, 'faces':[0, 6], 'vertices':[0, 1]},
           {'edge': 1, 'faces':[1, 7], 'vertices':[1, 2]},
           {'edge': 2, 'faces':[2, 8], 'vertices':[0, 2]},
           {'edge': 3, 'faces':[0, 2], 'vertices':[0, 3]},
           {'edge': 4, 'faces':[0, 1], 'vertices':[1, 4]},
           {'edge': 5, 'faces':[1, 2], 'vertices':[2, 5]},
           {'edge': 6, 'faces':[0, 3], 'vertices':[3, 4]},
           {'edge': 7, 'faces':[1, 4], 'vertices':[4, 5]},
           {'edge': 8, 'faces':[2, 5], 'vertices':[3, 5]},
           {'edge': 9, 'faces':[3, 5], 'vertices':[3, 6]},
           {'edge':10, 'faces':[3, 4], 'vertices':[4, 7]},
           {'edge':11, 'faces':[4, 5], 'vertices':[5, 8]},
           {'edge':12, 'faces':[3, 6], 'vertices':[6, 7]},
           {'edge':13, 'faces':[4, 7], 'vertices':[7, 8]},
           {'edge':14, 'faces':[5, 8], 'vertices':[6, 8]},
           {'edge':15, 'faces':[6, 8], 'vertices':[0, 6]},
           {'edge':16, 'faces':[6, 7], 'vertices':[1, 7]},
           {'edge':17, 'faces':[7, 8], 'vertices':[2, 8]}]

F_OPERATORS = [{'face':0, 'edges':[ 0,  3,  4,  6]},
               {'face':1, 'edges':[ 1,  4,  5,  7]},
               {'face':2, 'edges':[ 2,  3,  5,  8]},
               {'face':3, 'edges':[ 6,  9, 10, 12]},
               {'face':4, 'edges':[ 7, 10, 11, 13]},
               {'face':5, 'edges':[ 8,  9, 11, 14]},
               {'face':6, 'edges':[ 0, 12, 15, 16]},
               {'face':7, 'edges':[ 1, 13, 16, 17]},
               {'face':8, 'edges':[ 2, 14, 15, 17]}]

V_OPERATORS = [{'vertex':0, 'edges':[ 0,  2,  3, 15]},
               {'vertex':1, 'edges':[ 0,  1,  4, 16]},
               {'vertex':2, 'edges':[ 1,  2,  5, 17]},
               {'vertex':3, 'edges':[ 3,  6,  8,  9]},
               {'vertex':4, 'edges':[ 4,  6,  7, 10]},
               {'vertex':5, 'edges':[ 5,  7,  8, 11]},
               {'vertex':6, 'edges':[ 9, 12, 14, 15]},
               {'vertex':7, 'edges':[10, 12, 13, 16]},
               {'vertex':8, 'edges':[11, 13, 14, 17]}]

LZ_OPERATORS = [{'logical_qid':0, 'edges':[0, 1,  2]},
                {'logical_qid':1, 'edges':[3, 9, 15]}]

LX_OPERATORS = [{'logical_qid':0, 'edges':[0, 6, 12]},
                {'logical_qid':1, 'edges':[3, 4, 5]}]

def make_logical_zero():

    qs = QState(19)  # data:18 + ancilla:1

    mvals = [0, 0, 0, 0, 0, 0, 0, 0, 0] # measured values of 9 plaquette operators
    for vop in V_OPERATORS: # measure and get measured values of 9 star operators
        qid = vop['edges']
        qs.h(18).cx(18,qid[0]).cx(18,qid[1]).cx(18,qid[2]).cx(18,qid[3]).h(18)
        mvals.append(int(qs.m(qid=[18]).last))
        qs.reset(qid=[18])
        
    return qs, mvals

def measure_syndrome(qs, mvals):

    syn = []
    for fop in F_OPERATORS:  # plaquette operators
        qid = fop['edges']
        qs.h(18).cz(18,qid[0]).cz(18,qid[1]).cz(18,qid[2]).cz(18,qid[3]).h(18)
        syn.append(int(qs.m(qid=[18]).last))
        qs.reset(qid=[18])
        
    for vop in V_OPERATORS:  # star operators
        qid = vop['edges']
        qs.h(18).cx(18,qid[0]).cx(18,qid[1]).cx(18,qid[2]).cx(18,qid[3]).h(18)
        syn.append(int(qs.m(qid=[18]).last))
        qs.reset(qid=[18])
        
    for i in range(len(syn)): syn[i] = syn[i]^mvals[i]

    return syn

def get_error_chain(syn):

    face_id = [i for i,v in enumerate(syn) if i < 9 and v == 1]
    vertex_id = [i-9 for i,v in enumerate(syn) if i >= 9 and v == 1]

    e_chn = []
    if face_id != []:  # chain type: X
        for lat in Lattice:
            if lat['faces'][0] == face_id[0] and lat['faces'][1] == face_id[1]:
                e_chn.append({'type':'X', 'qid':[lat['edge']]})
                break

    if vertex_id != []: # chain type: Z
        for lat in Lattice:
            if lat['vertices'][0] == vertex_id[0] and lat['vertices'][1] == vertex_id[1]:
                e_chn.append({'type':'Z', 'qid':[lat['edge']]})
                break

    return e_chn

def error_correction(qs, e_chn):

    for c in e_chn:
        if c['type'] == 'X': [qs.x(i) for i in c['qid']]
        if c['type'] == 'Z': [qs.z(i) for i in c['qid']]

def Lz(self, q):

    [self.z(i) for i in LZ_OPERATORS[q]['edges']]
    return self
        
def Lx(self, q):

    [self.x(i) for i in LX_OPERATORS[q]['edges']]
    return self
    
if __name__ == '__main__':

    QState.add_methods(Lz, Lx)
    
    print("* initial state: logical |11>")
    qs_ini, mval_list = make_logical_zero()  # logical |00>
    qs_ini.Lx(0).Lx(1)  # logical |00> -> |11>
    qs_fin = qs_ini.clone()  # for evaluating later

    print("* add noise")
    qs_fin.x(7)  # bit flip error at #7
    # qs_fin.z(7).x(7)  # bit and phase flip error at #7

    syndrome = measure_syndrome(qs_fin, mval_list)
    err_chain = get_error_chain(syndrome)
    print("* syndrome measurement:", syndrome)
    print("* error chain:", err_chain)

    error_correction(qs_fin, err_chain)
    print("* fidelity after error correction:", qs_fin.fidelity(qs_ini))
    
    QState.free_all(qs_ini, qs_fin)

Tout d'abord, les faces, les côtés et les nombres de sommets sur la grille ont été déterminés comme suit. Ici, $ v_i $ est le visage, $ e_i $ est le côté et $ f_i $ est le haut.

Les variables globales Lattice, F_OPERATORS, V_OPERATORS, LZ_OPERATORS et LX_OPERATORS décrites au début du programme sont des données permettant de définir la structure du graphe, le générateur et l'opérateur logique en supposant ces faces, côtés et sommets. Lattice est une liste de dictionnaires composée de nombres de surfaces et de nombres de sommets connectés de chaque côté. Vous pouvez maintenant décrire la structure graphique de la grille sans omission. F_OPERATORS est une liste de numéros de côté qui composent les limites de chaque face, qui définit les opérateurs de face $ 9 $. V_OPERATORS est une liste de nombres latéraux qui se connectent à chaque sommet, qui définit $ 9 $ d'opérateurs de sommet. LZ_OPERATORS sert à définir deux opérateurs logiques $ Z $, où le $ 0 $ ème logique $ Z $ est $ Z_ {0} Z_ {1} Z_ {2} $, le $ 1 $ ème logique $ Z $ Indique que c'est $ Z_ {3} Z_ {9} Z_ {15} $. LX_OPERATORS sert à définir deux opérateurs logiques $ X $, où la $ 0 $ ème logique $ X $ est $ X_ {0} X_ {6} X_ {12} $, la $ 1 $ ème logique $ X $ Indique que c'est $ X_ {3} X_ {4} X_ {5} $.

Sur la base de cette configuration, examinons chaque partie de la section de traitement principale dans l'ordre.

qs_ini, mval_list = make_logical_zero()  # logical |00>

Crée un état zéro logique. Le contenu de la fonction make_logical_zero est le suivant.

def make_logical_zero():

    qs = QState(19)  # data:18 + ancilla:1

    mvals = [0, 0, 0, 0, 0, 0, 0, 0, 0] # measured values of 9 plaquette operators
    for vop in V_OPERATORS: # measure and get measured values of 9 star operators
        qid = vop['edges']
        qs.h(18).cx(18,qid[0]).cx(18,qid[1]).cx(18,qid[2]).cx(18,qid[3]).h(18)
        mvals.append(int(qs.m(qid=[18]).last))
        qs.reset(qid=[18])
        
    return qs, mvals

Cette fois, les bits de données requis sont de 18 bits (0 à 17), mais 1 bit auxiliaire est ajouté (18) pour la création de l'état initial et la mesure du syndrome, et un total de 19 bits est préparé. Avez-vous besoin de plus de bits auxiliaires? Vous pourriez penser cela, mais ce n'est pas grave car vous pouvez le réutiliser en le réinitialisant plusieurs fois.

Tout d'abord, créez un état physique zéro avec QState (19) et mesurez indirectement la source dans la boucle for. Il semble que vous ne mesuriez que pour l'opérateur de sommet, ce qui est bien. La première chose à préparer est l'état zéro physique, c'est-à-dire l'état propre simultané correspondant à la valeur propre +1 de l'opérateur de surface, de sorte que l'état ne change pas même si l'opérateur de surface est mesuré. En outre, comme l'opérateur de surface et l'opérateur de sommet sont interchangeables, vous pouvez d'abord mesurer l'opérateur de surface. Pour cette raison, il est correct de mesurer simplement l'opérateur de sommet ici.

Donc, je mesure 9 opérateurs de vertex dans l'ordre, mais si le résultat de la mesure est +1 (0 comme indice de la valeur mesurée), je peux passer à la mesure de l'opérateur de sommet suivant tel quel, mais mesure Le problème est lorsque la valeur est -1 (1 comme indice de la valeur mesurée). Il existe également un moyen de préparer un opérateur qui retourne la valeur propre et d'effectuer l'opération, mais ici nous l'omettons. Autrement dit, à travers. Cependant, enregistrez la valeur mesurée (index). Il n'est pas possible d'obtenir des états propres simultanés pour les valeurs propres de toutes les sources +1 mais il est possible de mesurer le syndrome car il est possible de savoir de quelle source la valeur mesurée doit être -1. Si vous voulez mesurer l'origine de la valeur propre de -1, il vous suffit d'inverser l'interprétation de la mesure du syndrome. Dans la fonction ci-dessus, la valeur mesurée (index) est stockée dans une variable de liste appelée mvals. Il y a 18 éléments, mais comme l'opérateur face est absolument 0, je prépare d'abord une liste de 9 0 indépendamment de la présence ou de l'absence, et j'ajoute le résultat à mvals chaque fois que je mesure l'opérateur de sommet. Je vais continuer à le faire. Enfin, il renvoie les états quantiques qs et mvals.

Revenez à la section de traitement principale.

qs_ini.Lx(0).Lx(1)  # logical |00> -> |11>

Ensuite, l'état logique $ \ ket {1_ {L} 1_ {L}} $ est créé en appliquant $ X $ logique aux deux bits logiques ($ \ ket {0_ {L} 0_ {L} C'était correct de commencer à partir de} $, mais je voulais utiliser l'opérateur logique $ X $, donc j'ai défini le point de départ sur $ \ ket {1_ {L} 1_ {L}} $). L'opérateur logique $ X $ est

def Lx(self, q):

    [self.x(i) for i in LX_OPERATORS[q]['edges']]
    return self

Il est défini comme. Comme vous pouvez le voir, je vais omettre l'explication.

qs_fin = qs_ini.clone()  # for evaluating later

Enfin, l'état est dupliqué pour évaluer le résultat de la correction d'erreur. Vous avez maintenant créé l'état initial.

prochain,

qs_fin.x(7)  # bit flip error at #7

Ensuite, ajoutez un peu d'erreur d'inversion au 7ème bit (tout va bien, j'ai donc décidé de manière appropriée).

syndrome = measure_syndrome(qs_fin, mval_list)

Ensuite, mesurez le syndrome pour identifier le bit d'erreur et le type d'erreur. Le contenu de la fonction measure_syndrome est le suivant.

def measure_syndrome(qs, mvals):

    syn = []
    for fop in F_OPERATORS:  # plaquette operators
        qid = fop['edges']
        qs.h(18).cz(18,qid[0]).cz(18,qid[1]).cz(18,qid[2]).cz(18,qid[3]).h(18)
        syn.append(int(qs.m(qid=[18]).last))
        qs.reset(qid=[18])
        
    for vop in V_OPERATORS:  # star operators
        qid = vop['edges']
        qs.h(18).cx(18,qid[0]).cx(18,qid[1]).cx(18,qid[2]).cx(18,qid[3]).h(18)
        syn.append(int(qs.m(qid=[18]).last))
        qs.reset(qid=[18])
        
    for i in range(len(syn)): syn[i] = syn[i]^mvals[i]

    return syn

Les résultats de mesure sont stockés dans la liste tout en mesurant l'opérateur de surface et l'opérateur de sommet dans l'ordre. Il s'agit de la valeur du syndrome, mais comme expliqué précédemment, il existe certains générateurs où la valeur propre -1 (l'indice de mesure est 1) est une valeur normale, donc dans ce cas, l'interprétation doit être inversée. Selon la valeur de la liste de valeurs mesurées mvals enregistrés au moment de la génération de l'état initial

for i in range(len(syn)): syn[i] = syn[i]^mvals[i]

Inverse la valeur du syndrome comme dans. Ce résultat est renvoyé comme la valeur de syndrome correcte.

Revenez à la section de traitement principale.

err_chain = get_error_chain(syndrome)

Estimez la chaîne d'erreur. C'est facile car la grille $ 3 \ times 3 $ ne peut corriger que des erreurs de 1 bit. Le contenu de la fonction get_error_chain est le suivant.

def get_error_chain(syn):

    face_id = [i for i,v in enumerate(syn) if i < 9 and v == 1]
    vertex_id = [i-9 for i,v in enumerate(syn) if i >= 9 and v == 1]

    e_chn = []
    if face_id != []:  # chain type: X
        for lat in Lattice:
            if lat['faces'][0] == face_id[0] and lat['faces'][1] == face_id[1]:
                e_chn.append({'type':'X', 'qid':[lat['edge']]})
                break

    if vertex_id != []: # chain type: Z
        for lat in Lattice:
            if lat['vertices'][0] == vertex_id[0] and lat['vertices'][1] == vertex_id[1]:
                e_chn.append({'type':'Z', 'qid':[lat['edge']]})
                break

    return e_chn

Identifiez le numéro d'opérateur de face face_id et le numéro d'opérateur de sommet vertex_id à partir duquel la valeur du syndrome est 1. Etant donné que le numéro du côté qui constitue la limite de la face correspondante peut être connu à partir de l'opérateur de face spécifié, le numéro du côté commun est le numéro de bit où l'erreur d'inversion de bit s'est produite. De plus, étant donné que le numéro du côté connecté au sommet correspondant peut être connu à partir de l'opérateur de sommet spécifié, le numéro du côté commun sera le numéro de bit où l'erreur d'inversion de phase s'est produite. De cette façon, vous pouvez voir les numéros de bits et les types d'erreur qui composent la chaîne d'erreur. Enregistrez-le dans la liste de dictionnaires e_chn et retournez-le.

Revenez à la section de traitement principale. De la chaîne d'erreurs que l'on vient d'obtenir

error_correction(qs_fin, err_chain)

Pour restaurer l'état d'origine. Le contenu de la fonction error_correction est le suivant.

def error_correction(qs, e_chn):

    for c in e_chn:
        if c['type'] == 'X': [qs.x(i) for i in c['qid']]
        if c['type'] == 'Z': [qs.z(i) for i in c['qid']]

Le processus est tel que vous le voyez (explication omise). Ceci termine la correction d'erreur. À la fin de la section principale de traitement,

print("* fidelity after error correction:", qs_fin.fidelity(qs_ini))

Affiche la fidélité entre l'état initial et l'état final après correction d'erreur. Si la fidélité est de 1,0, la correction d'erreur est réussie.

résultat

Le résultat de l'exécution est indiqué ci-dessous.

* initial state: logical |11>
* add noise
* syndrome measurement: [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
* error chain: [{'type': 'X', 'qid': [7]}]
* fidelity after error correction: 1.0

Les mesures de syndrome ont identifié que les opérateurs de 1er et 4ème visage avaient réagi et que le 7ème bit avait une erreur d'inversion de bit. La fidélité à l'état initial était de 1,0 et il a été constaté qu'il a été restauré correctement.

Ensuite, j'ai essayé d'ajouter l'erreur en tant qu'erreur d'inversion bit / phase comme suit.

# qs_fin.x(7)  # bit flip error at #7
qs_fin.z(7).x(7)  # bit and phase flip error at #7

Le résultat de l'exécution est

* initial state: logical |11>
* add noise (phase and bit flip): X_7 Z_7
* syndrome measurement: [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
* error chain: [{'type': 'X', 'qid': [7]}, {'type': 'Z', 'qid': [7]}]
* fidelity after error correction: 1.0

Il s'est avéré que cela peut également être corrigé correctement.

en conclusion

Vous comprenez maintenant les bases des codes de surface. C'était très frais et intéressant de pouvoir construire un code fort en utilisant pleinement la topologie. J'ai également pu étudier des topologies algébriques, que je ne connaissais pas très bien, à travers les références.

Cette fois, j'ai expliqué le code de surface qui est construit sous la forme d'un tore, mais comment réalisez-vous physiquement le tore? Ou, même si cela peut être réalisé, il existe un problème en ce que seuls deux bits logiques peuvent être exprimés (même s'il y a un trou). Afin de surmonter cela, il semble qu'un code de surface utilisant un plan simple (mais avec des défauts) qui n'est pas un tore soit également proposé, je voudrais donc l'étudier la prochaine fois.

Remerciements: Lors de la compilation de cet article, une session d'étude organisée par Nextremer Co., Ltd. [«4th Topological Quantum Calculation and Surroundings»](https: / /nextremer.connpass.com/event/176939/) et étudié. Les conférences sur les points clés étaient faciles à comprendre et la compréhension a progressé. Merci d'avoir saisi cette opportunité.

c'est tout

formule(17)À première vue, cela peut sembler difficile,\bar{c}Le nombre de faces contenues dansMSi tu essayesp(\bar{c})=(1-p)^{|E|-M} p^{M}=(1-p)^{|E|}(\frac{p}{1-p})^{M}Vous pouvez voir ce que vous pouvez faire. ↩︎