[PYTHON] Bases de la théorie de l'information quantique: opération logique par code de surface (Brading)
introduction
Article précédent construit un code de correction d'erreur haute performance (code de surface) à l'aide de bits quantiques placés sur une grille mappée sur un tore. J'ai vu que cela pouvait être fait. Cependant, il est très difficile de créer physiquement un tel tore, et le nombre de bits quantiques logiques pouvant être exprimés est proportionnel au nombre de trous dans le tore, donc un ordinateur quantique avec un grand nombre de bits logiques dans cette direction. Semble être presque impossible à créer. Par conséquent, un procédé de codage de surface a été proposé qui peut exécuter des opérations logiques en créant plusieurs défauts d'un certain type sur un simple plan qui n'est pas un tore, en les déplaçant et en les enroulant autour (tressant) comme une tresse. Cette fois, je vais reprendre cela.
Permettez-moi d'abord de dire ce que j'essaie d'expliquer dans les sections qui suivent. Premièrement, dans «l'explication théorique», quel type de défaut peut être créé pour exprimer le bit logique, comment l'opérateur logique $ X $ et l'opérateur logique $ Z $ peuvent être définis, et plus loin en déplaçant le défaut (Braid). Indique qu'une opération logique à 2 bits quantiques (opération CNOT logique) peut être réalisée. Dans "Contrôle d'opération", utilisez le simulateur de calcul quantique qlazy pour confirmer que l'opération CNOT peut effectivement être exécutée en tressant le défaut créé sur le plan. ..
Les documents suivants ont été utilisés comme références.
- Koshiba, Morimae, Fujii "Calcul quantique basé sur l'observation" Corona (2017)
- K.Fujii,"Quantum Computation with Topological Codes - from qubit to topological fault-tolerance",arXiv:1504.01444v1 [quant-ph] 7 Apr 2015
Explication de la théorie
Opérateur de face et opérateur de sommet
Considérez une grille comme indiqué dans la figure ci-dessous. Cette fois, nous ne supposons pas une condition aux limites périodique comme précédente, alors pensez-y comme une grille définie sur un simple plan.
En plus de cela, définissez l'opérateur face et l'opérateur sommet. Les opérateurs de visage sont le produit tenseur des opérateurs $ Z $ sur les quatre côtés qui entourent chaque face et sont soigneusement disposés dans la même forme. Cependant, l'opérateur de sommet est un peu différent. Le nombre d'opérateurs $ X $ pour les opérateurs de vertex aux bords du plan n'est pas de quatre, car chaque sommet au bord du plan se connecte uniquement à trois ou deux côtés. Considérons un groupe de stabilisateurs dont la source est l'opérateur de surface et l'opérateur de sommet définis de cette manière. Si le nombre de grilles est $ M \ fois N $, le nombre d'opérateurs de face est $ MN $, et le nombre d'opérateurs de sommet est $ (M + 1) (N + 1) = MN + M + N + 1 $. , Le nombre total de générateurs est de 2MN + M + N + 1 $. Cependant, tous ne sont pas indépendants. Comme vous pouvez le voir sur la figure ci-dessus, le produit de tous les opérateurs de sommet est $ I $ (opérateur égal) [^ 1]. En d'autres termes, si vous choisissez arbitrairement un opérateur de sommet, il peut être exprimé par le produit de tous les autres opérateurs de sommet, de sorte que le nombre de générateurs indépendants est réduit de 1 à partir de $ MN + M + N + 1 $. Il devient $ MN + M + N $. En revanche, le nombre de bits quantiques est $ (M + 1) N + M (N + 1) = 2MN + M + N $, ce qui équivaut au nombre de générateurs indépendants. Par conséquent, ce groupe de stabilisateurs détermine de manière unique l'état quantique. Cet état est appelé ici «vide». Dans les sections suivantes, nous expliquerons afin que les opérations quantiques puissent être effectuées en créant et en déplaçant des défauts en utilisant ce vide comme point de départ.
[^ 1]: Si vous mettez tous les opérateurs de vertex côte à côte, vous pouvez voir que tous les produits sont des opérateurs d'égalité car l'opérateur $ X $ correspondant au même bit quantique apparaît toujours deux fois. À propos, le produit de tous les opérateurs de face est le produit tensoriel des opérateurs $ Z $ disposés en boucle entourant le plan.
Créer un état de vide
Tout d'abord, comment créer un état de vide. Réfléchissons au type d'opération quantique à effectuer sur un groupe de bits quantiques disposés dans une grille pour créer un tel état de stabilisation (état de vide). Généralement groupe stabilisant
S = <g_1, g_2, g_3, \cdots , g_n> \tag{1}
L'état du stabilisateur spécifié dans est obtenu en mesurant $ g_1, g_2, \ cdots, g_n $ dans l'ordre sous l'état initial $ \ ket {00 \ cdots 0} $. Comme je l'ai expliqué dans Article précédent, passons en revue brièvement. Mesurer $ g_1 $ sous l'état $ \ ket {00 \ cdots 0} $ revient à laisser l'opérateur de projection $ (I \ pm g_1) / 2 $ agir sur l'état. Ici, le signe $ \ pm $ correspond à savoir si la valeur mesurée était $ + 1 $ ou $ -1 $. L'état après la mesure est
g_1 \frac{I \pm g_1}{2} \ket{00 \cdots 0} = \pm \frac{I \pm g_1}{2} \ket{00 \cdots 0} \tag{2}
Par conséquent, il devient l'état sur l'espace propre correspondant à la valeur propre $ + 1 $ ou $ -1 $ de $ g_1 $ (projetée). Ensuite, lorsque $ g_2 $ est mesuré pour cet état mesuré, il est projeté sur l'espace propre correspondant à la valeur propre de $ g_2 $ $ + 1 $ ou $ -1 $ selon la valeur mesurée. De plus, si vous mesurez $ g_3, g_4, \ cdots, g_n $, etc., il sera finalement projeté à l'état (état propre simultané) sur l'espace produit de l'espace propre de $ g_1, g_2, \ cdots, g_n $. Sera fait. Cependant, il est complètement probabiliste quelle valeur propre correspond à chaque $ g_i $. Dans Article précédent, nous avons ajouté une opération pour inverser la valeur propre si elle est projetée sur l'espace propre de $ -1 $. .. Ensuite, l'état stabilisant correspondant au groupe stabilisant de formule (1) peut être obtenu proprement. Cependant, si la procédure est interrompue, par exemple,
S = <-g_1, g_2, -g_3, \cdots , -g_n> \tag{3}
Vous pouvez obtenir l'état du stabilisateur correspondant au groupe de stabilisateurs comme (Cela se produit lorsque la valeur mesurée des 1er, 3e et nième générateurs est -1). En général
S = <\pm g_1, \pm g_2, \pm g_3, \cdots , \pm g_n> \tag{4}
Dans, vous pouvez obtenir l'état du stabilisateur correspondant au groupe de stabilisateurs dans lequel le signe de $ g_i $ est $ + $ ou $ - $ selon la valeur mesurée de chaque générateur. Ce n'est pas du tout un problème, car il suffit de conserver à l'avance les critères de mesure du syndrome pour chaque générateur lors des corrections d'erreurs. En d'autres termes, en supposant que le groupe de stabilisateurs du résultat de la mesure est obtenu comme indiqué dans l'équation (3), si le résultat de la mesure du premier générateur $ g_1 $ est de -1 $, il s'agit d'une valeur normale et il n'y a pas d'erreur. Vous pouvez juger, et inversement, si c'est $ + 1 $, vous pouvez juger qu'il y a eu une erreur, et ainsi de suite.
Lorsque vous effectuez réellement une telle mesure pour créer un état de vide, en plus des bits quantiques (bits quantiques de données) déployés sur les côtés du réseau, des bits quantiques auxiliaires pour la mesure indirecte (mesure symdrome) sont également déployés. C'est bon à faire. La méthode spécifique consiste à ajouter des bits quantiques auxiliaires au centre et à chaque sommet de chaque surface de la grille comme indiqué dans la figure ci-dessous. Le bit quantique auxiliaire déployé au centre de chaque surface sert à la mesure indirecte (mesure du symdrome) de l'opérateur de surface, et le bit quantique auxiliaire déployé à chaque sommet est destiné à la mesure indirecte (mesure du symdrome) de l'opérateur du sommet. Il est.
Avant de mesurer les opérateurs de face et de sommet, initialisez d'abord toutes les données et tous les bits quantiques auxiliaires à $ \ ket {0} $. Ensuite, mesurez indirectement l'opérateur de surface correspondant à chaque surface. Le nombre de bits quantiques auxiliaires correspondant à la surface à mesurer est $ f_0 $, et le nombre de bits quantiques de données sur le côté entourant la surface est $ f_1, f_2, f_3, f_4 $.
f0 --H--*--*--*--*--H-- M
| | | |
f1 -----Z--|--|--|-----
f2 --------Z--|--|-----
f3 -----------Z--|-----
f4 --------------Z-----
Mesurez l'opérateur de surface avec un circuit quantique tel que. Faites cela sur tous les fronts. Mesurez ensuite l'opérateur de sommet pour chaque sommet. Le numéro de bit quantique auxiliaire correspondant au sommet à mesurer est $ v_0 $, et le numéro de bit quantique de données du côté connecté au sommet est $ v_1, v_2, v_3, v_4 $.
v0 --H--*--*--*--*--H-- M
| | | |
v1 -----X--|--|--|-----
v2 --------X--|--|-----
v3 -----------X--|-----
v4 --------------X-----
Mesurez l'opérateur de sommet avec un circuit quantique comme. Faites ceci pour tous les sommets. L'état de vide est maintenant créé.
L'état de vide est un état. Ce n'est pas un espace de code. Pour en faire un espace de code, il faut supprimer au moins une source et considérer un ensemble de stabilisateurs avec des sources indépendantes $ n-1 $. Dernière fois logique les opérateurs $ X $ ou $ Z $ alignés sur la boucle qui entoure le trou en considérant la condition aux limites périodique = torus. J'ai pu être opérateur. Cette fois, nous définirons l'opérateur logique en créant artificiellement un défaut (trou) sur le plan.
Génération de bits défectueux ou quantique
Tout d'abord, définissez un «défaut». Les défauts sont des zones dans lesquelles aucun opérateur de face ou de sommet n'est défini. L'état de vide expliqué plus haut était un état de stabilisation dans lequel les opérateurs de surface et les opérateurs de sommet étaient densément répartis sur tout le réseau. Si vous pouviez créer une région sur ce plan sans opérateur de face (ou opérateur de sommet), ce serait un défaut. Alors, comment faites-vous cette faille? En fait, il peut être facilement créé en mesurant n'importe lequel des bits quantiques sur le plan qui constitue l'état de vide.
Remarquez les deux faces adjacentes qui composent la grille, comme illustré dans la figure ci-dessous. Envisagez de mesurer l'opérateur $ X $ correspondant aux bits quantiques au-dessus desquels les deux faces ont un côté partagé. En d'autres termes, mesurez le 4ème bit quantique de la figure sur la base $ X $ (ou vous pouvez penser au 4ème bit quantique comme étant Adamal gated et mesurant ensuite sur la base $ Z $).
Décrivons cette mesure en termes de style stabilisateur [^ 2]. Il n'y a que deux sources contre-convertibles en opérateur $ X_4 $ que vous voulez mesurer: l'opérateur de surface $ Z_1 Z_3 Z_4 Z_6 \ equiv A_1 $ et l'opérateur de surface $ Z_2 Z_4 Z_5 Z_7 \ equiv A_2 $. Tous les autres opérateurs de face et opérateurs de sommet sont interchangeables. Dans ce cas, un opérateur anti-commutable peut être appliqué aux autres opérateurs anti-commutables pour créer un opérateur anti-commutable tout en gardant les stabilisateurs invariants. Autrement dit, le groupe stabilisateur
[^ 2]: Les mesures de type stabilisateur seront mentionnées plusieurs fois dans les discussions qui suivent. Reportez-vous à l'article précédent "Bases de la théorie de l'information quantique: correction d'erreur quantique (code du stabilisateur: 2)" pour des explications détaillées.
S = <A_1, A_2, \cdots> \tag{5}
À
S = <A_1 A_2, A_2, \cdots> \tag{6}
La seule source anti-commutable peut être $ A_2 $, comme dans. Après cela, je mesure $ X_4 $, qui est la cible de la mesure. Si la valeur mesurée est $ + 1 $, remplacez $ A_2 $ par $ X_4 $, et si c'est $ -1 $, remplacez $ A_2 $ par $ -. Groupe de stabilisateurs remplacé par X_4 $
S = <A_1 A_2, \pm X_4, \cdots> \tag{7}
L'état du stabilisateur correspondant à est l'état après la mesure. Vous pouvez voir que les opérateurs de surface $ A_1 $ et $ A_2 $ qui étaient dans l'état vide d'origine ont disparu et sont remplacés par $ A_1 A_2 $ et $ \ pm X_4 $. En d'autres termes, on peut dire que la mesure de $ X_4 $ a généré deux paires de défauts dans les parties correspondant à $ A_1 $ et $ A_2 $. De plus, cet état est unique à $ X_4 $ car la source contient $ \ pm X_4 $.
Les défauts ont été appariés par mesure, mais l'équation (7) représente un état unique et n'est pas dans l'espace de code. Par exemple, les stabilisateurs excluant $ \ pm X_4 $,
S^{\prime} = <A_1 A_2, \cdots> \tag{8}
Est l'espace de code pour décrire un bit quantique logique.
Alors, comment définir l'opérateur logique $ X $ sur cet espace de code? Apportez à nouveau $ X_4 $. Ce $ X_4 $ agit comme un opérateur logique car il est interchangeable avec toutes les sources de $ S ^ {\ prime} $ et n'est pas un élément de $ S ^ {\ prime} $. Et
<A_1 A_2, X_4, \cdots> \tag{9}
Correspond à la valeur unique $ + 1 $ de $ X_4 $
<A_1 A_2, -X_4, \cdots> \tag{10}
Est dans un état correspondant à la valeur unique $ -1 $ de $ X_4 $, donc si $ X_4 $ est défini comme un opérateur logique $ X $, l'équation (9) est $ \ ket {+ ^ {L}} $, l'équation (10). ) Représentera $ \ ket {- ^ {L}} $ ($ L $ avec une supervision représentera un bit quantique logique; il en sera de même ci-après).
D'autre part, l'opérateur logique $ Z $ peut être sélectionné à partir de l'opérateur logique $ X $ $ X_4 $, qui est anti-convertible à toutes les sources de $ S ^ {\ prime} $. Par exemple, $ A_1 $ répond à cette exigence et peut être défini comme l'opérateur logique $ Z $ [^ 3]. Alternativement, $ A_2 $ peut être un opérateur logique $ Z $.
[^ 3]: Veuillez noter que $ A_1 $ ou $ A_2 $ n'est plus l'origine de ce groupe de stabilisateurs.
Ce qui précède est la méthode la plus simple pour créer une paire de défauts (= comment créer un espace de code). Ce type de défaut est appelé un défaut de type p car le défaut est un manque d'opérateurs de surface sur le réseau régulier. Il existe également un autre type de défaut. C'est le manque d'opérateurs de surface sur les grilles doubles (c'est-à-dire les opérateurs de sommet dans les grilles régulières). La méthode de création est expliquée ci-dessous.
Faites attention aux deux faces adjacentes qui composent le double réseau comme indiqué sur la figure ci-dessous (oubliez le numéro de bit quantique ci-dessus et réaffectez le numéro de bit quantique). Dans la grille normale d'origine, il s'agit d'un caractère croisé adjacent. Envisagez de mesurer l'opérateur $ Z $ correspondant au bit quantique au-dessus des deux caractères croisés, qui ont un côté partagé. Autrement dit, mesurez le 4e bit quantique de la figure sur la base $ Z $.
Décrivons cette mesure en termes de style stabilisateur. Il n'y a que deux sources anti-convertibles à l'opérateur $ Z_4 $ que vous voulez mesurer: l'opérateur de sommet $ X_1 X_3 X_4 X_6 \ equiv B_1 $ et l'opérateur de sommet $ X_2 X_4 X_5 X_7 \ equiv B_2 $. Tous les autres opérateurs de visage et opérateurs de visage sont interchangeables. Comme dans la discussion précédente, l'état après la mesure est
S = <B_1 B_2, \pm Z_4, \cdots> \tag{11}
Et c'est l'état unique de $ \ pm Z_4 $. Exclure $ \ pm Z_4 $ ici
S^{\prime} = <B_1 B_2, \cdots> \tag{12}
Considérant qu'il s'agit d'un groupe de stabilisateurs qui définissent l'espace de code. Donc si vous ramenez $ Z_4 $, il est interchangeable avec toutes les sources de $ S ^ {\ prime} $ et n'est pas un élément de $ S ^ {\ prime} $, donc le rôle de l'opérateur logique Jouera. Et
<B_1 B_2, Z_4, \cdots> \tag{13}
Correspond à la valeur unique $ + 1 $ de $ Z_4 $
<B_1 B_2, -Z_4, \cdots> \tag{14}
L'état correspondant à la valeur unique $ -1 $ de $ Z_4 $, donc si $ Z_4 $ est défini comme l'opérateur logique $ Z $, l'équation (13) est $ \ ket {0 ^ {L}} $, l'équation (14 ) Représentera $ \ ket {1 ^ {L}} $.
D'un autre côté, pour l'opérateur logique $ X $, vous pouvez choisir un opérateur qui est anti-commutable avec $ Z_4 $ et qui est commutable avec toutes les sources de $ S $. Par exemple, $ B_1 $ répond à cette exigence, vous pouvez donc le définir comme un opérateur logique $ X $. Alternativement, $ B_2 $ peut être un opérateur logique $ X $.
Ce qui précède est la méthode la plus simple pour créer des paires de défauts sur une double grille. Ce type de défaut est appelé défaut de type d car le défaut est un manque d'opérateurs de surface sur le double réseau.
Mouvement de bits défectueux ou quantique
Vous pouvez également étendre la zone du défaut en répétant la mesure. En mesurant les bits quantiques autour du défaut de type p à la base $ X $ comme indiqué dans la figure ci-dessous, la zone de défaut se développe (zone bleu clair). Les bits quantiques indiqués par des cercles noirs sont les bits quantiques mesurés.
Vous pouvez également éliminer les défauts. Commencez par agrandir le défaut de type p dans le sens horizontal, comme indiqué à gauche dans la figure ci-dessous. En plus de cela, éliminons le milieu des trois défauts alignés. Comme cela équivaut à restaurer l'opérateur de surface correspondant à cette surface, il suffit de mesurer l'opérateur de surface. En fait, la mesure indirecte est effectuée à l'aide du bit quantique auxiliaire correspondant à la surface (non représenté sur la figure ci-dessous). Ensuite, ce sera comme indiqué sur la droite dans la figure ci-dessous.
Est-ce vrai même si on dit que ce sera le cas? Je vais l'entendre, alors vérifions ce processus au format stabilisateur comme avant. L'état de gauche sur la figure ci-dessus peut être obtenu en prolongeant la discussion lorsque l'équation (7) a été obtenue.
S = <A_1 A_2 A_3, \pm X_5, \pm X_6, \cdots> \tag{15}
Tu peux voir ça Ici, le signe de $ \ pm $ est déterminé en fonction du résultat de la mesure de $ X_5 $ et du résultat de la mesure de $ X_6 $. Sous cette condition, mesurez $ A_2 $. $ A_2 $ est anti-commutable avec $ X_5 $ et $ X_6 $, donc multipliez d'abord l'un ou l'autre pour en faire un anti-commutable. Par exemple
S = <A_1 A_2 A_3, \pm X_5 X_6, \pm X_6, \cdots> \tag{16}
Faire. Ensuite, la seule source anti-convertible en $ A_2 $ est $ \ pm X_6 $. En plus de cela, mesurez $ A_2 $. En fonction du résultat de la mesure
S = <A_1 A_2 A_3, \pm X_5 X_6, \pm A_2, \cdots> \tag{17}
L'état change comme ça. L'état du stabilisateur ne change pas même si une source est transférée vers une autre source. Par exemple, essayez de multiplier la troisième source par la première source. Puis
S = <\pm A_1 A_3, \pm X_5 X_6, \pm A_2, \cdots> \tag{18}
Ce sera. Ceci complète l'état sur la droite dans la figure ci-dessus. En d'autres termes, vous pouvez déplacer les défauts en combinant expansion et disparition.
Ici, en considérant l'espace de code défini par le groupe de stabilisateurs à l'exclusion de $ \ pm X_5 X_6 $, la chaîne de $ X_5 X_6 $ est utilisée comme opérateur logique $ X $ comme dans la discussion précédente, et le défaut est $ A_1 $. Nous pouvons voir que nous pouvons définir la boucle autour de comme un opérateur logique $ Z $.
Au fait, que se passe-t-il si vous vous sentez mal à l'aise avec le signe $ + $ ou $ - $ selon la valeur mesurée? J'ajouterai un peu. Supposons que $ X_6 $ soit mesuré et que le signe de $ X_6 $ dans l'équation (15) devienne $ - $. Dans ce cas, introduisez l'opérateur logique $ Z $ $ A_3 $ (ou $ A_1 A_2 $), qui est un opérateur contre-commutable avec $ X_6 $ et commutable avec tous les autres générateurs, et effectuez l'opération entière. C'est bon. D'un autre côté, si le signe de $ A_2 $ dans l'équation (17) devient $ - $ suite à la mesure de $ A_2 $, l'opérateur logique $ X $ avant de déplacer $ X_5 $ doit être calculé comme un tout. C'est bon [^ 4]. résultat,
[^ 4]: Lors de la vérification ultérieure de l'opération, effectuez la simulation de mouvement des paires de défauts de cette manière.
S = <A_1 A_3, X_5 X_6, A_2, \cdots> \tag{19}
Vous pouvez obtenir une condition propre comme celle-ci. C'est l'état unique correspondant à la valeur unique $ + 1 $ de $ X_5 X_6 $. Ce processus peut être exécuté en continu autant de fois que vous le souhaitez et vous pouvez déplacer la paire défectueuse n'importe où. Cependant, quel que soit le placement, l'état déterminé par celui-ci est l'état unique du produit tensoriel de l'opérateur $ X $ sur la chaîne reliant les deux défauts [^ 5]. Et le produit tensoriel de l'opérateur $ X $ sur cette chaîne agit comme l'opérateur logique $ X $, et l'opérateur $ Z $ sur la boucle entourant l'un des deux défauts est l'opérateur logique $ Z $. Il joue un rôle [^ 6].
[^ 5]: La même chose est vraie pour toute chaîne qui relie des défauts. Article précédent est une histoire similaire à dire que le produit des opérateurs sur une boucle qui peut être continuellement transformée représente le même effet.
[^ 6]: Compte tenu de l'espace de code déterminé par le groupe de stabilisateurs excluant $ X_5 X_6 $ de l'équation (19), les opérateurs logiques $ X $ et logiques $ Z $ sont tels que décrits dans le texte. L'équation (19) représente l'état $ \ ket {+ ^ {L}} $ car il est unique à la valeur propre $ + 1 $ du $ X $ logique. Si vous calculez le $ Z $ logique dans cet état, la phase logique sera inversée et remplacée par l'état $ \ ket {- ^ {L}} $.
Ce qui précède est le même pour les défauts de type d, et les défauts peuvent être déplacés en répétant l'expansion et la disparition, et le produit tenseur de l'opérateur $ Z $ sur la chaîne reliant les défauts devient l'état propre. Et le produit tensoriel de l'opérateur $ Z $ sur cette chaîne agit comme l'opérateur logique $ Z $, et l'opérateur $ X $ sur la boucle (dans la grille double) qui entoure l'un des deux défauts est le $ X logique. Agit comme un opérateur $.
Par souci de simplicité, nous avons principalement considéré les défauts dus à l'absence d'un opérateur de face (ou opérateur de sommet), mais comme expliqué précédemment, il peut être développé de manière arbitraire. Par exemple, une grande paire de défauts comme le montre la figure ci-dessous peut être facilement créée en répétant la mesure.
Si vous faites un si gros défaut, le nombre d'opérateurs Pauli qui composent l'opérateur logique augmentera en conséquence. En d'autres termes, la distance de code augmente [^ 7]. Plus la distance de code est grande, plus les bits quantiques peuvent être corrigés. Concrètement, un code avec une distance de $ 2t + 1 $ permet de corriger des erreurs dans le bit quantique $ t $. À propos, dans le cas de la figure ci-dessus, la distance de code est de 16 (comme vous pouvez le voir en comptant), donc le nombre de bits quantiques qui peuvent être corrigés est de 7.
[^ 7]: La distance de code dans le code de correction d'erreur quantique est définie comme le nombre minimum d'opérateurs Pauli qui composent un opérateur logique. L'implication est le nombre minimum de bits quantiques qui ont changé lors de l'exécution d'une opération logique à partir de n'importe quel code et de son déplacement vers un autre code. La distance de code est définie de cette manière car le nombre de bits quantiques changeants est égal au nombre d'opérateurs Pauli inclus dans l'opérateur logique. À propos, la distance de code dans le code linéaire classique est la valeur minimale de la distance de bourdonnement entre des codes logiquement différents. En d'autres termes, à la fois dans les cas quantique et classique, la distance de code peut être considérée comme un indice qui indique combien de bits doivent être modifiés pour passer d'un code à un autre.
Arithmétique à 2 bits quantiques par tressage
Je vais résumer le contenu jusqu'à la section précédente. Si vous créez une paire de défauts de type p par mesure à partir d'un état de vide, cet état est l'état propre du produit tensoriel de l'opérateur Pauli $ X $ sur la chaîne reliant ces défauts. Considérant l'origine excluant la chaîne, c'est-à-dire l'espace de code défini par les deux défauts (de type p) créés dans le vide, le produit tenseur de l'opérateur Pauli $ X $ sur la chaîne reliant les défauts est ce code. Vous pouvez le considérer comme un opérateur logique $ X $ dans l'espace. De plus, si tel est le cas, le produit tensoriel de l'opérateur Pauli $ Z $ sur la boucle entourant l'un ou l'autre des défauts devient l'opérateur logique $ Z $ dans cet espace de code. Par contre, si vous créez une paire de défauts de type d, son état est l'état propre du produit tensoriel de l'opérateur Pauli $ Z $ sur la chaîne reliant les défauts. Considérant l'origine excluant la chaîne, c'est-à-dire l'espace de code défini par les deux défauts (de type d) créés dans le vide, le produit tensoriel de l'opérateur Pauli $ Z $ sur la chaîne reliant les défauts est ce code. Vous pouvez le considérer comme un opérateur logique $ Z $ dans l'espace. De plus, si tel est le cas, le produit tensoriel de l'opérateur Pauli $ X $ sur la boucle entourant l'un ou l'autre des défauts devient l'opérateur logique $ X $ dans cet espace de code. C'était ça.
Maintenant, supposons qu'une paire de défauts de type p et une paire de défauts de type d existent séparément sur un plan, comme illustré dans la figure ci-dessous. Dans le cas de la paire de défauts de type p, au lieu de la disparition des deux opérateurs de face, le produit des deux opérateurs de face manquante est nouvellement ajouté au générateur, de sorte qu'un bit quantique logique est maintenant disponible. Vous pouvez l'exprimer. De plus, dans le cas de la paire de défauts de type d, au lieu de la disparition des deux opérateurs de sommet, le produit des deux opérateurs de sommet manquants est nouvellement ajouté au générateur, il s'agit donc d'un quantum logique. Cela signifie que le bit peut être exprimé. Par conséquent, deux bits quantiques logiques peuvent être exprimés par le défaut représenté sur la figure ci-dessous.
Ici, laissez la paire de défauts de type p être le 0ème bit quantique logique et la paire de défauts de type d le 1er bit quantique logique. Supposons que vous souhaitiez que le 0ème bit quantique logique soit l'état propre de l'opérateur logique $ X $. Autrement dit, supposons que vous vouliez initialiser le 0ème bit quantique à $ \ ket {+ ^ {L}} $ ou $ \ ket {- ^ {L}} $. Que devrais-je faire? Si vous vous souvenez des bases du format du stabilisateur, vous le comprendrez immédiatement. Tout ce que vous avez à faire est d'ajouter l'opérateur logique $ X $, c'est-à-dire le produit tenseur de l'opérateur $ X $ placé sur la chaîne reliant les défauts, au générateur (voir la figure ci-dessous). Cela créera l'état $ \ ket {+ ^ L} $. Comme expliqué dans la section précédente, si vous générez une paire de défauts de type p et déplacez l'un des défauts, soit l'état $ \ ket {+ ^ L} $ soit $ \ ket {- ^ L} $ sera naturel. Tu peux l'avoir. Si vous obtenez $ \ ket {- ^ L} $ (ou $ \ ket {+ ^ L} $), alors l'opérateur logique $ Z $, c'est-à-dire Pauli $ Z $ sur la boucle qui entoure l'un ou l'autre défaut. Il peut être changé en $ \ ket {+ ^ L} $ (ou $ \ ket {- ^ L} $) en appliquant le produit tensoriel de l'opérateur à cet état.
Si vous voulez initialiser le premier bit quantique à $ \ ket {0 ^ L} $ ou $ \ ket {1 ^ L} $, vous voulez utiliser l'opérateur logique $ Z $, c'est-à-dire $ placé sur la chaîne de défauts. Tout ce que vous avez à faire est d'ajouter le produit tensoriel de l'opérateur Z $ à la source (voir ci-dessous). Cela créera l'état $ \ ket {0 ^ L} $. Comme expliqué dans la section précédente, si vous générez une paire de défauts de type d et déplacez l'un des défauts, cet état sera naturellement $ \ ket {0 ^ L} $ ou $ \ ket {1 ^ L} $. Il peut être obtenu. Si vous obtenez $ \ ket {1 ^ L} $ (ou $ \ ket {0 ^ L} $), alors l'opérateur logique $ X $, c'est-à-dire le Pauli $ X $ sur la boucle qui entoure l'un ou l'autre défaut. Il peut être changé en $ \ ket {0 ^ L} $ (ou $ \ ket {1 ^ L} $) en agissant sur le produit tensoriel de l'opérateur sur cet état.
Montrons qu'une opération CNOT logique peut être effectuée en utilisant ces deux bits quantiques logiques. En termes de style stabilisateur, ce qui devrait être réalisé est
CNOT: <XI,IZ> \rightarrow <XX,ZZ> \tag{20}
C'est une conversion. Exprimé sous forme de circuit quantique pour deux bits quantiques logiques
X --*-- X I --*-- Z
| |
I --X-- X Z --X-- Z
Ce serait bien si cela pouvait être réalisé.
Permettez-moi de conclure d'abord [^ 8]. Déplacez l'une des paires de défauts de type p afin qu'elle s'enroule autour de l'un des défauts de type D. Par exemple, comme le montre la figure (1) ci-dessous, le 0ème bit quantique logique est défini sur l'état propre (la valeur propre est 1) de l'opérateur logique $ X $, et l'un des défauts de type p (le côté droit) comme indiqué dans la figure (2) ci-dessous. ) Est déplacé autour de l'un des défauts de type d (à droite). Ensuite, la chaîne d'opérateurs $ X $ s'enroule autour du défaut de type D. Puisque l'état entier ne change pas même si l'opérateur $ X $ sur la boucle évidente est appliqué, la boucle de l'opérateur $ X $ (indiquée par la ligne orange) comme indiqué dans (3) ci-dessous est appliquée. Après tout, comme le montre (4) ci-dessous, la chaîne d'opérateurs $ X $ est divisée en deux parties. L'un est une chaîne qui relie la paire de défauts de type p d'origine, et l'autre est une boucle qui s'enroule autour du défaut de type D. Puisque cette boucle ne change pas d'état même si elle se contracte continuellement, elle se contracte jusqu'à la limite entourant le défaut de type d dans (4) ci-dessous. L'opérateur $ X $ de cette boucle étant l'opérateur logique $ X $ du premier bit quantique logique, le premier bit quantique logique se trouve dans l'état propre (la valeur unique est 1) de l'opérateur logique $ X $. Je suis. Cela signifie que l'état initial logique $ XI $ est passé à l'état final logique $ XX $.
[^ 8]: Je ne comprends pas vraiment l'origine de l'idée pourquoi on pensait que CNOT pouvait être réalisé avec ça, alors je transpire.
Ce qui suit montre qu'un mouvement similaire change l'état initial logique $ IZ $ en l'état final logique $ ZZ $. Comme le montre la figure (1) ci-dessous, définissez le premier bit quantique logique sur l'état propre de l'opérateur logique $ Z $ (la valeur propre est 1), et faites en sorte que le défaut de type p contourne le défaut de type d comme précédemment. Déménager à. Lorsque le défaut de type p atteint la chaîne de l'opérateur $ Z $ qui relie les défauts de type d et se déplace plus loin, il se déplace tout en poussant et en transformant la chaîne de l'opérateur $ Z $ comme indiqué dans (2) ci-dessous. Il sera en forme [^ 9]. L'état ne change pas même si l'opérateur $ Z $ sur la boucle auto-explicative est appliqué, donc si vous appliquez la boucle de l'opérateur $ Z $ (indiqué par la ligne orange) comme indiqué dans (3) ci-dessous, Après tout, la chaîne d'opérateurs $ Z $ est divisée en deux parties, comme le montre (4) ci-dessous. L'un est une chaîne qui relie la paire de défauts de type d d'origine, et l'autre est une boucle qui s'enroule autour du défaut de type p. Puisque l'opérateur $ Z $ de cette boucle était l'opérateur logique $ Z $ du 0ème bit quantique logique, le 0ème bit quantique logique est dans l'état propre (la valeur unique est 1) de l'opérateur logique $ Z $. Je suis. Nous savons maintenant que l'état initial logique $ IZ $ est passé à l'état final logique $ ZZ $.
[^ 9]: Je n'expliquerai pas en détail pourquoi cela se produit. Vous pouvez le voir en vérifiant les mesures au format stabilisateur tout en calculant manuellement chacune d'elles.
De cette manière, Braiding a pu effectuer une opération CNOT sur un bit quantique logique 2. L'état initial est $ \ ket {+ ^ {L} 0 ^ {L}} $ et l'opération CNOT est effectuée dessus, donc l'état final est l'état logique de Bell $ (\ ket {0 ^ {L} 0 ^ {L }} + \ ket {1 ^ {L} 1 ^ {L}}) / \ sqrt {2} $. C'est ça.
Contrôle de fonctionnement
Ensuite, en utilisant le simulateur de calcul quantique qlazy, le code de surface est construit en générant des défauts dans un plan de réseau, et l'opération CNOT par tressage est exécutée correctement. Voyons ce que nous pouvons faire. Je voudrais exécuter l'exemple ci-dessus tel quel. L'état initial est $ \ ket {+ ^ {L} 0 ^ {L}} $ et l'opération CNOT est effectuée dessus, donc l'état final est l'état logique de Bell $ (\ ket {0 ^ {L} 0 ^ {L }} + \ ket {1 ^ {L} 1 ^ {L}}) / \ sqrt {2} $ devrait être. Lorsqu'il est mesuré sur une base logique $ Z $, l'état $ \ ket {0 ^ {L} 0 ^ {L}} $ ou l'état $ \ ket {1 ^ {L} 1 ^ {L}} $ a 50-50 chances. Il doit être observé, alors vérifiez-le.
la mise en oeuvre
Voici l'intégralité du code Python.
from collections import Counter
from qlazypy import Stabilizer
def get_common_qid(obj_A, obj_B):
return list(set(obj_A['dat']) & set(obj_B['dat']))
def create_lattice(row, col):
face = [[None]*col for _ in range(row)]
vertex = [[None]*(col+1) for _ in range(row+1)]
q_row = 2 * row + 1
q_col = 2 * col + 1
q_id = 0
for i in range(q_row):
for j in range(q_col):
if i%2 == 1 and j%2 == 1: # face
dat = []
dat.append((i - 1) * q_col + j) # up
dat.append((i + 1) * q_col + j) # down
dat.append(i * q_col + (j - 1)) # left
dat.append(i * q_col + (j + 1)) # right
face[i//2][j//2] = {'anc': q_id, 'dat': dat}
elif i%2 == 0 and j%2 == 0: # vertex
dat = []
if i > 0: dat.append((i - 1) * q_col + j) # up
if i < q_row - 1: dat.append((i + 1) * q_col + j) # down
if j > 0: dat.append(i * q_col + (j - 1)) # left
if j < q_col - 1: dat.append(i * q_col + (j + 1)) # right
vertex[i//2][j//2] = {'anc': q_id, 'dat': dat}
q_id += 1
return {'face': face, 'vertex': vertex}
def initialize(sb, lattice):
sb.set_all('Z')
for face_list in lattice['face']:
for face in face_list:
sb.h(face['anc'])
[sb.cz(face['anc'], target) for target in face['dat']]
sb.h(face['anc'])
sb.m(qid=[face['anc']])
for vertex_list in lattice['vertex']:
for vertex in vertex_list:
sb.h(vertex['anc'])
[sb.cx(vertex['anc'], target) for target in vertex['dat']]
sb.h(vertex['anc'])
sb.m(qid=[vertex['anc']])
def create_move_defect_p(sb, pos_A, pos_B, path, lattice):
# create defect pair
face_A = lattice['face'][pos_A[0]][pos_A[1]]
face_B = lattice['face'][pos_B[0]][pos_B[1]]
q = get_common_qid(face_A, face_B)[0]
md = sb.h(q).m(qid=[q])
sb.h(q)
if md.last == '1': [sb.z(i) for i in face_B['dat']]
# move defect
chain = [q]
for i in range(1,len(path)):
# extend defect
face_A = lattice['face'][path[i-1][0]][path[i-1][1]]
face_B = lattice['face'][path[i][0]][path[i][1]]
q = get_common_qid(face_A, face_B)[0]
md = sb.h(q).m(qid=[q])
sb.h(q)
if md.last == '1': [sb.z(i) for i in face_B['dat']]
# remove defect
sb.h(face_A['anc'])
[sb.cz(face_A['anc'], target) for target in face_A['dat']]
sb.h(face_A['anc'])
md = sb.m(qid=[face_A['anc']])
if md.last == '1': [sb.x(i) for i in chain]
chain.append(q)
def create_move_defect_d(sb, pos_A, pos_B, path, lattice):
# create defect pair
vertex_A = lattice['vertex'][pos_A[0]][pos_A[1]]
vertex_B = lattice['vertex'][pos_B[0]][pos_B[1]]
q = get_common_qid(vertex_A, vertex_B)[0]
md = sb.m(qid=[q])
if md.last == '1': [sb.x(i) for i in vertex_B['dat']]
# move defect
chain = [q]
for i in range(1,len(path)):
# extend defect
vertex_A = lattice['vertex'][path[i-1][0]][path[i-1][1]]
vertex_B = lattice['vertex'][path[i][0]][path[i][1]]
q = get_common_qid(vertex_A, vertex_B)[0]
md = sb.m(qid=[q])
if md.last == '1': [sb.x(i) for i in vertex_B['dat']]
# remove defect
sb.h(vertex_A['anc'])
[sb.cx(vertex_A['anc'], target) for target in vertex_A['dat']]
sb.h(vertex_A['anc'])
md = sb.m(qid=[vertex_A['anc']])
if md.last == '1': [sb.z(i) for i in chain]
chain.append(q)
def get_chain(pos_list, lattice):
chain = []
for i in range(1,len(pos_list)):
pos_A = pos_list[i-1]
pos_B = pos_list[i]
chain.append(get_common_qid(lattice['vertex'][pos_A[0]][pos_A[1]],
lattice['vertex'][pos_B[0]][pos_B[1]])[0])
return chain
def measure_logical_Z(sb, face, chain, shots=10):
mval_list = []
for _ in range(shots):
sb_tmp = sb.clone()
mval_0 = sb_tmp.m(qid=face['dat']).last
mval_1 = sb_tmp.m(qid=chain).last
mval = (str(sum([int(s) for s in list(mval_0)])%2)
+ str(sum([int(s) for s in list(mval_1)])%2))
mval_list.append(mval)
sb_tmp.free()
return Counter(mval_list)
if __name__ == '__main__':
lattice_row = 4
lattice_col = 6
lattice = create_lattice(lattice_row, lattice_col)
# make vacuum state
qubit_num = (2*lattice_row + 1) * (2*lattice_col + 1)
sb = Stabilizer(qubit_num=qubit_num)
initialize(sb, lattice)
# logical qubit #1
d_pos_A = [2,1]
d_pos_B = [2,2]
d_path = [[2,2],[2,3],[2,4]]
create_move_defect_d(sb, d_pos_A, d_pos_B, d_path, lattice)
# logical qubit #0
p_pos_A = [0,0]
p_pos_B = [0,1]
# p_path = [[0,1],[0,2]]
p_path = [[0,1],[0,2],[1,2],[2,2],[3,2],[3,3],[3,4],[3,5],
[2,5],[1,5],[0,5],[0,4],[0,3],[0,2]]
create_move_defect_p(sb, p_pos_A, p_pos_B, p_path, lattice)
# measure logical qubits: #0 and #1
face = lattice['face'][p_pos_A[0]][p_pos_A[1]]
chain = get_chain([[2,1],[2,2],[2,3],[2,4]], lattice)
freq = measure_logical_Z(sb, face, chain, shots=100)
print(freq)
sb.free()
Je vais vous expliquer ce que vous faites. Regardez la section de traitement principale.
lattice_row = 4
lattice_col = 6
lattice = create_lattice(lattice_row, lattice_col)
Crée des informations de grille pour organiser les bits quantiques. Lattice_row et lattice_col donnés comme arguments sont respectivement le nombre de grilles verticales (faces) et le nombre de grilles horizontales (faces). Comme vous pouvez le voir en regardant le contenu de la fonction, les données de sortie sont des données de dictionnaire {'face': face, 'vertex': vertex}. Ici, face est un tableau bidimensionnel (liste de listes) agencé selon la position de la face, et ses éléments sont {'anc': q0, 'dat': [q1, q2, q3, q4]} Ce sont les données du dictionnaire. anc est le numéro du bit quantique auxiliaire pour la surface correspondante et dat est le numéro du bit quantique de données situé à la limite de cette surface. De plus, vertex est un tableau bidimensionnel (liste de listes) agencé selon la position des sommets, et ses éléments sont les mêmes que face {'anc': q0, 'dat': [q1, q2, q3, q4 ]} Ce sont les données du dictionnaire. anc est le numéro du bit quantique auxiliaire pour le sommet correspondant et dat est le numéro du bit quantique de données situé du côté se connectant à ce sommet. Avec cela, nous avons défini les informations de grille auxquelles nous pensons sans omission [^ 10]. Voir la définition de la fonction pour plus de détails.
[^ 10]: Je pense qu'il existe plusieurs façons de définir les informations de la grille en tant que données, mais après avoir inventé ma propre méthode compte tenu de la facilité de traitement ultérieur, c'est comme ça C'est devenu un peu compliqué dans le vent.
prochain,
# make vacuum state
qubit_num = (2*lattice_row + 1) * (2*lattice_col + 1)
sb = Stabilizer(qubit_num=qubit_num)
initialize(sb, lattice)
Ensuite, créez un état de vide. Tout d'abord, calculez le nombre de bits quantiques et stockez-le dans qubit_num. L'hypothèse actuelle est de 117 bits quantiques. Il est impossible de calculer un état quantique de cette échelle avec un simulateur. Mais ne t'inquiète pas. Parce que je veux faire cette rotation Braidinng, j'ai ajouté une classe Stabilizer à qlazy pour effectuer des calculs de stabilisation (v.0.1.1). Fondamentalement, seule l'opération Clifford peut être effectuée, mais le calcul peut être effectué sans limitation du nombre de bits quantiques (tant que la mémoire le permet). Je vais l'utiliser cette fois. Donnez le nombre de bits quantiques à l'argument du constructeur Stabilizer pour créer une instance et l'utiliser comme variable sb. Dans l'état initial, toutes les sources sont des opérateurs d'égalité, donc initialisez-les de manière appropriée pour créer un état de vide. Je fais cela avec la fonction initialize. Dans la première ligne de la fonction initialize
sb.set_all('Z')
Cependant, cela signifie que tous les bits quantiques sont définis sur l'opérateur $ Z $. Autrement dit, cela signifie que tous les bits quantiques sont initialisés à $ \ ket {0} $. Un état de vide est créé en mesurant indirectement les générateurs dans l'ordre avec ceci comme point de départ. Plus précisément, procédez comme suit:
for face_list in lattice['face']:
for face in face_list:
sb.h(face['anc'])
[sb.cz(face['anc'], target) for target in face['dat']]
sb.h(face['anc'])
sb.m(qid=[face['anc']])
Seule la partie qui mesure l'opérateur de surface est extraite, mais la partie qui mesure l'opérateur de sommet est également la même [^ 11].
[^ 11]: Le périphérique des données de treillis défini précédemment est vivant ici. La structure des données de la grille peut avoir été un peu déroutante, mais je pense que la mise en œuvre qui l'utilise est relativement facile à comprendre et simple, mais qu'en est-il?
Une fois le vide en place, l'étape suivante consiste à créer un bit quantique logique en appariant et en déplaçant les défauts. Pour faciliter la mise en œuvre, commencez par le premier bit quantique logique au lieu du 0e.
# logical qubit #1
d_pos_A = [2,1]
d_pos_B = [2,2]
d_path = [[2,2],[2,3],[2,4]]
create_move_defect_d(sb, d_pos_A, d_pos_B, d_path, lattice)
Ici, d_pos_A et d_pos_B représentent chacun les coordonnées de sommet du défaut de type d à appairer en premier. Je pense que ce sera plus facile à comprendre si vous regardez également le chiffre utilisé dans l'explication précédente. Les informations d'itinéraire de déplacement pour déplacer le défaut droit apparié sont d_path. Indique que le défaut se déplace dans l'ordre des coordonnées des sommets [2,2] -> [2,3] -> [2,4]. Create_move_defect_d est une fonction qui modifie réellement l'état en prenant sb, d_pos_A, d_pos_B et d_path comme arguments. Jetons un coup d'œil au contenu de la fonction.
# create defect pair
vertex_A = lattice['vertex'][pos_A[0]][pos_A[1]]
vertex_B = lattice['vertex'][pos_B[0]][pos_B[1]]
q = get_common_qid(vertex_A, vertex_B)[0]
md = sb.m(qid=[q])
if md.last == '1': [sb.x(i) for i in vertex_B['dat']]
Générera une paire de défauts de type D. Pour identifier les bits quantiques à mesurer à la base $ Z $, obtenez les informations de sommets appariés à partir de lattice et stockez-les dans vertex_A et vertex_B. Appelez la fonction get_common_qid pour obtenir les nombres de bits quantiques généralement contenus dans vertex_A et vertex_B (voir la définition de la fonction pour plus de détails). La variable q est ce nombre, donc mesurez-le sur une base $ Z $. Le résultat de la mesure est stocké dans la variable md et la dernière propriété devient la valeur mesurée. Si le résultat de la mesure est $ \ ket {0} $, rien n'est fait, et s'il s'agit de $ \ ket {1} $, l'opérateur logique $ X $ est utilisé pour inverser la valeur propre. Cela signifie que les défauts ont été appariés, mais comme ils sont adjacents, déplacez-en un (vers la droite).
# move defect
chain = [q]
for i in range(1,len(path)):
# extend defect
vertex_A = lattice['vertex'][path[i-1][0]][path[i-1][1]]
vertex_B = lattice['vertex'][path[i][0]][path[i][1]]
q = get_common_qid(vertex_A, vertex_B)[0]
md = sb.m(qid=[q])
if md.last == '1': [sb.x(i) for i in vertex_B['dat']]
# remove defect
sb.h(vertex_A['anc'])
[sb.cx(vertex_A['anc'], target) for target in vertex_A['dat']]
sb.h(vertex_A['anc'])
md = sb.m(qid=[vertex_A['anc']])
if md.last == '1': [sb.z(i) for i in chain]
chain.append(q)
Le contenu de la boucle for ci-dessus est divisé en deux parties. La première moitié est la partie qui agrandit le défaut d'un carré en fonction des informations d'itinéraire de mouvement, et la seconde moitié est la partie qui élimine le défaut d'origine. Dans la première moitié de la partie en expansion, le sommet correspondant au défaut d'origine est vertex_A, le sommet correspondant au défaut en expansion est vertex_B et le bit quantique commun aux deux est mesuré par $ Z $. Comme précédemment, si le résultat de la mesure est $ \ ket {0} $, rien n'est fait, et s'il s'agit de $ \ ket {1} $, l'opérateur logique $ X $ est appliqué pour inverser la valeur propre. Dans la dernière partie à éteindre, l'opérateur de sommet à la position de défaut d'origine est restauré, de sorte que l'opérateur de sommet est mesuré. Dans ce cas, une mesure indirecte utilisant le bit quantique auxiliaire doit être effectuée, de sorte que l'opération CNOT ciblant les quatre bits quantiques de données qui composent l'opérateur de sommet est prise en sandwich par Adamar pour le bit quantique auxiliaire. Ensuite, le bit quantique auxiliaire est mesuré sur la base de $ Z $, mais si le résultat de la mesure est $ \ ket {0} $, rien n'est fait, et s'il s'agit de $ \ ket {1} $, la valeur propre est inversée. Activez l'opérateur logique $ Z $. Ici, chain est une liste de nombres de bits quantiques contenus dans la chaîne que porte le défaut en mouvement. Puisque le produit tensoriel de l'opérateur $ Z $ déployé sur ce bit quantique devient l'opérateur logique $ Z $, le numéro de bit quantique est ajouté à chaque fois qu'il est déplacé, et l'opération logique $ Z $ à ce point est exécutée correctement. Je pourrai le faire. Si vous devez inverser les valeurs propres, utilisez l'opérateur logique $ Z $ basé sur cette chaîne. Le premier bit quantique logique est maintenant dans l'état $ \ ket {0 ^ {L}} $.
Revenez à la section de traitement principale, puis créez le 0ème bit quantique logique. En d'autres termes, les défauts de type p sont appariés et déplacés.
# logical qubit #0
p_pos_A = [0,0]
p_pos_B = [0,1]
# p_path = [[0,1],[0,2]]
p_path = [[0,1],[0,2],[1,2],[2,2],[3,2],[3,3],[3,4],[3,5],
[2,5],[1,5],[0,5],[0,4],[0,3],[0,2]]
create_move_defect_p(sb, p_pos_A, p_pos_B, p_path, lattice)
Ici, p_pos_A et p_pos_B représentent les coordonnées de la face qui apparie en premier les défauts de type p. p_path représente les informations de route de mouvement lors du déplacement de l'un des défauts appariés (vers la droite). Le p_path commenté est un mouvement court, donc l'état logique résultant est l'état unique $ \ ket {+ ^ {L}} $ de l'opérateur logique $ X $. D'autre part, le p_path non commenté est un mouvement court, et (comme vous pouvez le voir en le comparant avec la figure précédente) c'est un mouvement qui contourne le défaut de type D. Donc, si vous le déplacez pendant une longue période, vous devriez être en mesure de réaliser l'opération CNOT pour l'état logique. Avec ceux-ci comme arguments, exécutez la fonction create_move_defect_p pour changer l'état. Le contenu de la fonction se comportera de la même manière que le type d, donc l'explication est omise.
Enfin, mesurez les deux bits quantiques logiques sur la base logique $ Z $ et affichez le résultat.
# measure logical qubits: #0 and #1
face = lattice['face'][p_pos_A[0]][p_pos_A[1]]
chain = get_chain([[2,1],[2,2],[2,3],[2,4]], lattice)
freq = measure_logical_Z(sb, face, chain, shots=100)
print(freq)
Puisque le 0ème bit quantique logique est un défaut de type p, l'opérateur logique $ Z $ est l'opérateur $ Z $ qui englobe l'un des défauts. La face variable sert à localiser l'opérateur $ Z $. De plus, comme le premier bit quantique logique est un défaut de type d, l'opérateur logique $ Z $ est un opérateur $ Z $ sur la chaîne reliant les deux défauts. La chaîne de variables sert à stocker l'emplacement de l'opérateur $ Z $. Obtenez-le avec la fonction get_chain. Les données de fréquence sont acquises en donnant au stabilisateur sb, face, chain et shots = 100 représentant le nombre de mesures comme arguments de la fonction measure_logical_Z. Dans la fonction, la mesure est répétée honnêtement en fonction du visage et de la chaîne, le résultat est compté, les données de fréquence (instance de la classe Counter standard Python) sont créées et renvoyées. c'est tout.
résultat
Maintenant, montrons le résultat de l'exécution. Examinons d'abord le cas où le 0ème bit quantique logique n'est pas encapsulé. Décommentez les données d'itinéraire qui parcourent une courte distance, qui ont été commentées dans le code ci-dessus, et commentez les données d'itinéraire qui parcourent une longue distance. En d'autres termes
p_path = [[0,1],[0,2]]
# p_path = [[0,1],[0,2],[1,2],[2,2],[3,2],[3,3],[3,4],[3,5],
# [2,5],[1,5],[0,5],[0,4],[0,3],[0,2]]
Je vais essayer de l'exécuter comme. Puis
Counter({'00': 53, '10': 47})
est devenu. Le 0ème bit quantique logique est $ \ ket {+ ^ {L}} $ et le 1er bit quantique logique est $ \ ket {0 ^ {L}} $. En d'autres termes
\ket{+^{L} 0^{L}} = \frac{1}{\sqrt{2}} (\ket{0^{L} 0^{L}} + \ket{1^{L} 0^{L}}) \tag{21}
Donc, il est correct que $ \ ket {0 ^ {L} 0 ^ {L}} $ et $ \ ket {1 ^ {L} 0 ^ {L}} $ sont observés avec une probabilité de 50%. est.
Considérons cela comme l'état initial, puis examinons le cas où le défaut de type p contourne le défaut de type d et retourne à l'emplacement de l'état initial. Inversons le commentaire précédent et exécutons-le. En d'autres termes
# p_path = [[0,1],[0,2]]
p_path = [[0,1],[0,2],[1,2],[2,2],[3,2],[3,3],[3,4],[3,5],
[2,5],[1,5],[0,5],[0,4],[0,3],[0,2]]
Lorsqu'il est exécuté comme
Counter({'11': 53, '00': 47})
Le résultat est. C'est juste
\frac{1}{\sqrt{2}} (\ket{0^{L} 0^{L}} + \ket{1^{L} 1^{L}}) \tag{22}
Il est égal au résultat de la mesure de l'état de Bell. J'ai donc pu confirmer que l'opération CNOT était bien réalisée. Félicitations, félicitations.
en conclusion
Je voulais en quelque sorte reproduire de mes propres mains le phénomène intéressant selon lequel si vous créez un défaut sur un avion et que vous l'enroulez autour d'un autre défaut, cela devient une opération CNOT, alors cette fois j'ai commencé par implémenter un calcul de format de stabilisateur. Quand je l'ai essayé, ce n'était pas aussi facile que prévu (juste à cause de mon manque de connaissances), par exemple, comment calculer le nombre de générateurs indépendants du groupe de stabilisateurs et un opérateur du groupe de stabilisateurs. J'étais un peu inquiet de savoir comment déterminer s'il s'agissait d'un élément (même si j'ai fini par utiliser la "méthode de balayage" pour calculer le rang de la matrice d'inspection). En outre, en ce qui concerne le mouvement des défauts dans le code de surface, le manuel dit «Mesurer», mais il ne dit même pas quoi faire lorsque la valeur propre devient -1 (c'est-à-dire «interligne». "Lisez-le"), mais j'ai fait un essai et une erreur en écrivant le programme (j'ai découvert que je devais le faire comme décrit dans le texte). Il m'a donc fallu un temps inattendu pour terminer cet article. Cependant, je suis heureux d'avoir beaucoup appris.
Eh bien, la prochaine fois. Je n'ai pas encore décidé, mais maintenant que j'ai réalisé l'opération de Clifford liée au code de surface, je réfléchis à la façon de réaliser l'opération logique non-Clifford ensuite.
c'est tout
Recommended Posts