[PYTHON] Bases de la théorie de l'information quantique: correction d'erreur quantique (code du stabilisateur: 4)

\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

Dans l'article Dernière fois, j'ai compris la théorie du code du stabilisateur, donc cette fois je prendrai un exemple concret de code de stabilisateur et utiliserai le simulateur de calcul quantique qlazy pour vérifier son fonctionnement. À la fin de Dernière fois, j'ai présenté les générateurs de "Shor code", "Steane code" et "5 quantum bit code". Parmi ceux-ci, le «code Shor» et le «code Steane» ont déjà été vérifiés pour leur fonctionnement dans un autre article [^ 1], nous allons donc implémenter ici le «code à 5 bits quantiques» et vérifier le fonctionnement.

[^ 1]: This et This.

Préparation

Tout d'abord, je vais lister à nouveau les quatre origines et l'opérateur logique Z.

La source	opérateur
g_{1}	X \otimes Z \otimes Z \otimes X \otimes I
g_{2}	I \otimes X \otimes Z \otimes Z \otimes X
g_{3}	X \otimes I \otimes X \otimes Z \otimes Z
g_{4}	Z \otimes X \otimes I \otimes X \otimes Z
\bar{Z} \equiv g_{5}	Z \otimes Z \otimes Z \otimes Z \otimes Z

Bien que non indiqué dans le tableau, l'opérateur logique X est $ X \ otimes X \ otimes X \ otimes X \ otimes X $.

Je voudrais concevoir un circuit quantique basé sur cela, mais cela nécessite une certaine préparation.

Pour créer un état de base logique $ \ ket {0_L} $ à partir de $ \ ket {00000} $, changez l'opérateur $ g_ {i} ^ {\ prime} $ correspondant à la source $ g_i $ en $ g_ {i J'ai dû choisir d'être anti-commutable avec $ et tous les autres $ g_j (j \ ne i) $. J'ai pensé que je devrais créer une matrice de contrôle [^ 2] pour le générateur ci-dessus et créer une matrice de contrôle pour $ g_ {i} ^ {\ prime} $, et à la suite d'essais et d'erreurs, j'ai trouvé ce qui suit. C'est fait [^ 3].

[^ 2]: Voir Article précédent. [^ 3]: Il existe peut-être une procédure polyvalente et intelligente, mais j'en suis satisfait.

	opérateur
g_{1}^{\prime}	Z \otimes I \otimes Z \otimes I \otimes I
g_{2}^{\prime}	Z \otimes Z \otimes Z \otimes Z \otimes I
g_{3}^{\prime}	Z \otimes Z \otimes I \otimes Z \otimes Z
g_{4}^{\prime}	Z \otimes I \otimes Z \otimes Z \otimes I
\bar{Z}^{\prime} \equiv g_{5}^{\prime}	X \otimes X \otimes X \otimes X \otimes X

En tant qu'ensemble de bruit, préparez tout ce qui opère les opérateurs du groupe Pauli $ X, Z, XZ $ pour chaque bit quantique comme indiqué ci-dessous.

bruit	opérateur
E_{0}	I \otimes I \otimes I \otimes I \otimes I
E_{1}	X \otimes I \otimes I \otimes I \otimes I
E_{2}	Z \otimes I \otimes I \otimes I \otimes I
E_{3}	XZ \otimes I \otimes I \otimes I \otimes I
E_{4}	I \otimes X \otimes I \otimes I \otimes I
E_{5}	I \otimes Z \otimes I \otimes I \otimes I
E_{6}	I \otimes XZ \otimes I \otimes I \otimes I
E_{7}	I \otimes I \otimes X \otimes I \otimes I
E_{8}	I \otimes I \otimes Z \otimes I \otimes I
E_{9}	I \otimes I \otimes XZ \otimes I \otimes I
E_{10}	I \otimes I \otimes I \otimes X \otimes I
E_{11}	I \otimes I \otimes I \otimes Z \otimes I
E_{12}	I \otimes I \otimes I \otimes XZ \otimes I
E_{13}	I \otimes I \otimes I \otimes I \otimes X
E_{14}	I \otimes I \otimes I \otimes I \otimes Z
E_{15}	I \otimes I \otimes I \otimes I \otimes XZ

Nous avons également besoin d'une liste de mesures $ \ {\ beta_ {l} ^ {(i)} \} $ lorsque la source est mesurée avec le bruit $ E_i $ ajouté.

g_l E_i = \beta_{l}^{(i)} E_i g_l \tag{1}

Il peut être calculé avec. Autrement dit, si $ g_l $ et $ E_i $ sont convertibles, alors $ \ beta_ {l} ^ {(i)} = + 1 $ et s'ils sont anti-convertibles, alors $ \ beta_ {l} ^ {(i)} = - C'est 1 $. Vous trouverez ci-dessous une liste de mesures pour chaque bruit. Dans la deuxième colonne, la valeur mesurée $ + 1 $ est répertoriée comme $ + $, et la valeur mesurée $ -1 $ est répertoriée comme $ - $. De plus, la valeur mesurée de $ + 1 $ signifie $ \ ket {0} $, et la valeur mesurée de $ -1 $ signifie $ \ ket {1} , donc dans la troisième colonne, cet index ( 0 $) Ou 1 $). Lors de l'implémentation en tant que circuit quantique, il est préférable de se référer à la série $ (0,1) $ dans la troisième colonne car la valeur mesurée est obtenue sous forme d'indice.

bruit	(g_1, g_2, g_3, g_4)Valeur mesurée de	Indicateur de valeur mesurée
E_{0}	(+,+,+,+)	(0,0,0,0)
E_{1}	(+,+,+,-)	(0,0,0,1)
E_{2}	(-,+,-,+)	(1,0,1,0)
E_{3}	(-,+,-,-)	(1,0,1,1)
E_{4}	(-,+,+,+)	(1,0,0,0)
E_{5}	(+,-,+,-)	(0,1,0,1)
E_{6}	(-,-,+,-)	(1,1,0,1)
E_{7}	(-,-,+,+)	(1,1,0,0)
E_{8}	(+,+,-,+)	(0,0,1,0)
E_{9}	(-,-,-,+)	(1,1,1,0)
E_{10}	(+,-,-,+)	(0,1,1,0)
E_{11}	(-,+,+,-)	(1,0,0,1)
E_{12}	(-,-,-,-)	(1,1,1,1)
E_{13}	(+,+,-,-)	(0,0,1,1)
E_{14}	(+,-,+,+)	(0,1,0,0)
E_{15}	(+,-,-,-)	(0,1,1,1)

Les préparatifs sont maintenant terminés. Maintenant, le circuit quantique est illustré ci-dessous.

Circuit quantique

Tout d'abord, nous montrons un circuit qui obtient l'état de base logique $ \ ket {0_L} $ à partir de l'état de base physique $ \ ket {00000} $.

|0> --H---*---H---M
|0> --H---|-------|-------*---H---M
|0> --H---|-------|-------|-------|-------*---H---M
|0> --H---|-------|-------|-------|-------|-------|-------*---H---M
|0> --H---|-------|-------|-------|-------|-------|-------|-------|-------*---H---M
          |       |       |       |       |       |       |       |       |       |
|0> ----|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---
|0> ----|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---
|0> ----|g1 |---|g1'|---|g2 |---|g2'|---|g3 |---|g3'|---|g4 |---|g4'|---|g5 |---|g5'|---  |0L>
|0> ----|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---
|0> ----|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---|   |---

Ensuite, l'état quantique inconnu 1 $ \ ket {\ psi} $ est encodé en utilisant la technique de téléportation quantique.

|psi> ----------*---H-----------M
                |               |
|0>   --H---*---X---------M     |
            |             |     |
      ------X-------------X-----Z---
      ------X-------------X-----Z---
|0L>  ------X-------------X-----Z--- |psi_L>
      ------X-------------X-----Z---
      ------X-------------X-----Z---

Maintenant que nous avons l'état encodé $ \ ket {\ psi_L} $, nous allons ajouter du bruit. Ici, Ei représente une sorte de bruit.

        ---|  |---
        ---|  |---
|psi_L> ---|Ei|--- |psi_L'>
        ---|  |---
        ---|  |---

Enfin, si vous mesurez le syndrome de détection d'erreur et effectuez le calcul inverse du bruit pour la récupération, l'état sera rétabli.

     |0> --H---*--------------------------H-----M
     |0> --H---|-------*------------------H-----M
     |0> --H---|-------|-------*----------H-----M
     |0> --H---|-------|-------|------*---H-----M
               |       |       |      |         |
         ----|   |---|   |---|   |--|   |-----|   |----
         ----|   |---|   |---|   |--|   |-----|   |----
|psi_L'> ----|g1 |---|g2 |---|g3 |--|g4 |-----|E+ |---- |psi>
         ----|   |---|   |---|   |--|   |-----|   |----
         ----|   |---|   |---|   |--|   |-----|   |----

C'est tout pour le circuit quantique.

la mise en oeuvre

Montrons un exemple d'implémentation par qlazy.

import numpy as np
from qlazypy import QState

def logic_x(self, qid):

    [self.x(q) for q in qid]
    return self
    
def logic_z(self, qid):

    [self.z(q) for q in qid]
    return self
    
def ctr_logic_x(self, q, qid):

    [self.cx(q, qtar) for qtar in qid]
    return self

def ctr_logic_z(self, q, qid):

    [self.cz(q, qtar) for qtar in qid]
    return self

def ctr_g1(self, q, qid):

    self.cx(q, qid[0]).cz(q, qid[1]).cz(q, qid[2]).cx(q, qid[3])
    return self

def ctr_g2(self, q, qid):

    self.cx(q, qid[1]).cz(q, qid[2]).cz(q, qid[3]).cx(q, qid[4])
    return self

def ctr_g3(self, q, qid):

    self.cx(q, qid[0]).cx(q, qid[2]).cz(q, qid[3]).cz(q, qid[4])
    return self
    
def ctr_g4(self, q, qid):

    self.cz(q, qid[0]).cx(q, qid[1]).cx(q, qid[3]).cz(q, qid[4])
    return self

def encode(self, phase, qid_anc, qid_cod):

    # make logical zero state: |0>_L

    # g1
    self.h(qid_anc[0]).ctr_g1(qid_anc[0], qid_cod).h(qid_anc[0])
    self.m(qid=[qid_anc[0]])
    mval = self.m_value(binary=True)
    if mval == '1': self.z(qid_cod[0]).z(qid_cod[2])
    self.reset(qid=[qid_anc[0]])

    # g2
    self.h(qid_anc[1]).ctr_g2(qid_anc[1], qid_cod).h(qid_anc[1])
    self.m(qid=[qid_anc[1]])
    mval = self.m_value(binary=True)
    if mval == '1': self.z(qid_cod[0]).z(qid_cod[1]).z(qid_cod[2]).z(qid_cod[3])
    self.reset(qid=[qid_anc[1]])
    
    # g3
    self.h(qid_anc[2]).ctr_g3(qid_anc[2], qid_cod).h(qid_anc[2])
    self.m(qid=[qid_anc[2]])
    mval = self.m_value(binary=True)
    if mval == '1': self.z(qid_cod[0]).z(qid_cod[1]).z(qid_cod[3]).z(qid_cod[4])
    self.reset(qid=[qid_anc[2]])
    
    # g4
    self.h(qid_anc[3]).ctr_g4(qid_anc[3], qid_cod).h(qid_anc[3])
    self.m(qid=[qid_anc[3]])
    mval = self.m_value(binary=True)
    if mval == '1': self.z(qid_cod[0]).z(qid_cod[2]).z(qid_cod[3])
    self.reset(qid=[qid_anc[3]])

    # logical z
    self.h(qid_anc[4]).ctr_logic_z(qid_anc[4], qid_cod).h(qid_anc[4])
    self.m(qid=[qid_anc[4]])
    mval = self.m_value(binary=True)
    if mval == '1':
        self.x(qid_cod[0]).x(qid_cod[1]).x(qid_cod[2]).x(qid_cod[3]).x(qid_cod[4])
    self.reset(qid=[qid_anc[4]])

    # make random quantum state and encode (with quantum teleportation)

    self.reset(qid=qid_anc)
    self.u3(qid_anc[0], alpha=phase[0], beta=phase[1], gamma=phase[2]) # input quantum state
    print("* input quantum state")
    self.show(qid=[qid_anc[0]])
    
    self.h(qid_anc[1])
    self.ctr_logic_x(qid_anc[1], qid_cod).cx(qid_anc[0], qid_anc[1])
    self.h(qid_anc[0])
    self.m(qid=qid_anc[0:2])
    mval = self.m_value(binary=True)
    if mval == '00': pass
    elif mval == '01': self.logic_x(qid_cod)
    elif mval == '10': self.logic_z(qid_cod)
    elif mval == '11': self.logic_x(qid_cod).logic_z(qid_cod)
    self.reset(qid=qid_anc)
    
    return self

def add_noise(self, q, qid, kind):

    if kind == 'X': self.x(qid[q])
    elif kind == 'Z': self.z(qid[q])
    elif kind == 'XZ': self.z(qid[q]).x(qid[q])
    return self

def correct_err(self, qid_anc, qid_cod):

    self.reset(qid=qid_anc)

    # syndrome
    self.h(qid_anc[0]).ctr_g1(qid_anc[0], qid_cod).h(qid_anc[0])
    self.h(qid_anc[1]).ctr_g2(qid_anc[1], qid_cod).h(qid_anc[1])
    self.h(qid_anc[2]).ctr_g3(qid_anc[2], qid_cod).h(qid_anc[2])
    self.h(qid_anc[3]).ctr_g4(qid_anc[3], qid_cod).h(qid_anc[3])
    self.m(qid=qid_anc[0:4])
    mval = self.m_value(binary=True)
    print("* syndrome =", mval)

    # recovery
    if mval == '0000': pass
    elif mval == '0001': self.x(qid_cod[0])
    elif mval == '1010': self.z(qid_cod[0])
    elif mval == '1011': self.z(qid_cod[0]).x(qid_cod[0])
    elif mval == '1000': self.x(qid_cod[1])
    elif mval == '0101': self.z(qid_cod[1])
    elif mval == '1101': self.z(qid_cod[1]).x(qid_cod[1])
    elif mval == '1100': self.x(qid_cod[2])
    elif mval == '0010': self.z(qid_cod[2])
    elif mval == '1110': self.z(qid_cod[2]).x(qid_cod[2])
    elif mval == '0110': self.x(qid_cod[3])
    elif mval == '1001': self.z(qid_cod[3])
    elif mval == '1111': self.z(qid_cod[3]).x(qid_cod[3])
    elif mval == '0011': self.x(qid_cod[4])
    elif mval == '0100': self.z(qid_cod[4])
    elif mval == '0111': self.z(qid_cod[4]).x(qid_cod[4])

    return self

if __name__ == '__main__':

    QState.add_methods(logic_x, logic_z, ctr_logic_x, ctr_logic_z,
                       ctr_g1, ctr_g2, ctr_g3, ctr_g4,
                       encode, add_noise, correct_err)

    # create registers
    qid_anc = QState.create_register(5)
    qid_cod = QState.create_register(5)
    qnum = QState.init_register(qid_anc, qid_cod)

    # parameters for input quantum state (U3 gate params)
    phase = [np.random.rand(), np.random.rand(), np.random.rand()]

    # encode quantum state
    qs_ini = QState(qnum)
    qs_ini.encode(phase, qid_anc, qid_cod)
    qs_fin = qs_ini.clone()

    # noise
    q = np.random.randint(0, len(qid_cod))
    kind = np.random.choice(['X','Z','XZ'])
    print("* noise '{:}' to #{:} qubit".format(kind, q))
    qs_fin.add_noise(q, qid_cod, kind)

    # error correction
    qs_fin.correct_err(qid_anc, qid_cod)

    # result
    fid = qs_ini.fidelity(qs_fin, qid=qid_cod)
    print("* fidelity = {:.6f}".format(fid))
    
    QState.free_all(qs_ini, qs_fin)

Je vais vous expliquer ce que vous faites dans l'ordre. Regardez la section de traitement principale.

QState.add_methods(logic_x, logic_z, ctr_logic_x, ctr_logic_z,
                   ctr_g1, ctr_g2, ctr_g3, ctr_g4,
                   encode, add_noise, correct_err)

Maintenant, enregistrez la méthode personnalisée indiquée ci-dessus en tant que méthode de la classe QState qui représente l'état quantique.

# create registers
qid_anc = QState.create_register(5)
qid_cod = QState.create_register(5)
qnum = QState.init_register(qid_anc, qid_cod)

Ensuite, générez le registre à utiliser à partir de maintenant. Cela définit des valeurs de variable telles que qid_anc = [0,1,2,3,4], qid_cod = [5,6,7,8,9], qnum = 10 [^ 4]. qid_anc correspond à 5 bits quantiques auxiliaires. Dans le circuit quantique illustré ci-dessus, 5 bits quantiques auxiliaires sont nécessaires pour créer l'état de base logique, 2 pour créer l'état de code dans la téléportation quantique et 4 pour corriger l'erreur. Cinq bits quantiques auxiliaires suffisent car l'état peut être réinitialisé juste avant chaque étape. qid_cod est un bit quantique pour décrire l'état du signe. Puisqu'il s'agit d'un code à 5 bits quantiques, il suffit de préparer 5 bits quantiques.

[^ 4]: Bien sûr, vous pouvez définir la valeur de la variable directement sans utiliser une telle méthode de classe. Lorsqu'il s'agit de circuits quantiques compliqués, je pense que c'est plus facile à mettre en œuvre. L'exemple actuel n'est pas si compliqué, donc peu importe lequel.

# parameters for input quantum state (U3 gate params)
phase = [np.random.rand(), np.random.rand(), np.random.rand()]

Ainsi, 3 phases de paramètres aléatoires sont générées pour créer l'état de code de manière appropriée (3 paramètres pour le fonctionnement de la porte U3).

# encode quantum state
qs_ini = QState(qnum)
qs_ini.encode(phase, qid_anc, qid_cod)
qs_fin = qs_ini.clone()

Alors, créez d'abord l'état initial comprenant le bit quantique auxiliaire, puis convertissez-le en état codé avec la méthode d'encodage. Je copie qs_ini dans qs_fin, qui consiste finalement à évaluer si l'état d'origine et l'état corrigé des erreurs correspondent.

Jetons maintenant un œil au contenu de la méthode d'encode.

# g1
self.h(qid_anc[0]).ctr_g1(qid_anc[0], qid_cod).h(qid_anc[0])
self.m(qid=[qid_anc[0]])
mval = self.m_value(binary=True)
if mval == '1': self.z(qid_cod[0]).z(qid_cod[2])
self.reset(qid=[qid_anc[0]])

 ...

Crée l'état de base logique $ \ ket {0_L} $. Effectuez les opérations indiquées dans le circuit quantique ci-dessus dans l'ordre. La valeur mesurée (indice) de la mesure indirecte est dans la variable mval. Si c'est "0", ne faites rien, si c'est "1", calculez $ g_ {1} ^ {\ prime} = ZIZII $. Une fois terminé, réinitialisez le 0ème bit quantique auxiliaire utilisé. Par la suite, la même chose est faite pour tous les autres générateurs et l'opérateur logique Z.

self.u3(qid_anc[0], alpha=phase[0], beta=phase[1], gamma=phase[2]) # input quantum state
print("* input quantum state")
self.show(qid=[qid_anc[0]])

Ensuite, un état aléatoire à 1 bit quantique est créé en calculant la porte U3 avec phase comme argument pour le 0ème bit quantique auxiliaire. Ensuite, l'état est affiché.

self.h(qid_anc[1])
self.ctr_logic_x(qid_anc[1], qid_cod).cx(qid_anc[0], qid_anc[1])
self.h(qid_anc[0])
self.m(qid=qid_anc[0:2])
mval = self.m_value(binary=True)
if mval == '00': pass
elif mval == '01': self.logic_x(qid_cod)
elif mval == '10': self.logic_z(qid_cod)
elif mval == '11': self.logic_x(qid_cod).logic_z(qid_cod)
self.reset(qid=qid_anc)

Exécutez maintenant le circuit de téléportation quantique. Le résultat de l'exécution de deux mesures est entré en mval, et si vous exécutez l'opérateur ne rien faire / X logique / Z logique / XZ logique selon les quatre modèles, 5 à partir de l'état de 1 bit quantique créé précédemment au hasard Vous pouvez obtenir l'état codé du bit quantique.

Revenez à la section de traitement principale.

# noise
q = np.random.randint(0, len(qid_cod))
kind = np.random.choice(['X','Z','XZ'])
print("* noise '{:}' to #{:} qubit".format(kind, q))
qs_fin.add_noise(q, qid_cod, kind)

Ensuite, le bruit est ajouté de manière aléatoire à l'état codé de 5 bits quantiques. Sélectionnez aléatoirement le bit quantique et sélectionnez aléatoirement le type de bruit parmi X / Z / XZ. Le traitement proprement dit est effectué par la méthode add_noise. Voir la définition de la fonction pour plus de détails.

# error correction
qs_fin.correct_err(qid_anc, qid_cod)

Ensuite, effectuez une correction d'erreur.

Jetons un coup d'œil au contenu de la méthode correct_err.

self.reset(qid=qid_anc)

Donc, réinitialisez d'abord tous les bits quantiques auxiliaires.

# syndrome
self.h(qid_anc[0]).ctr_g1(qid_anc[0], qid_cod).h(qid_anc[0])
self.h(qid_anc[1]).ctr_g2(qid_anc[1], qid_cod).h(qid_anc[1])
self.h(qid_anc[2]).ctr_g3(qid_anc[2], qid_cod).h(qid_anc[2])
self.h(qid_anc[3]).ctr_g4(qid_anc[3], qid_cod).h(qid_anc[3])
self.m(qid=qid_anc[0:4])
mval = self.m_value(binary=True)
print("* syndrome =", mval)

Ensuite, une mesure de détection d'erreur (mesure de symdrome) est effectuée. La valeur mesurée (chaîne de caractères binaires à 4 chiffres) entre dans la variable mval. En fonction de cette chaîne binaire,

# recovery
if mval == '0000': pass
elif mval == '0001': self.x(qid_cod[0])
elif mval == '1010': self.z(qid_cod[0])
elif mval == '1011': self.z(qid_cod[0]).x(qid_cod[0])
elif mval == '1000': self.x(qid_cod[1])
elif mval == '0101': self.z(qid_cod[1])
elif mval == '1101': self.z(qid_cod[1]).x(qid_cod[1])
elif mval == '1100': self.x(qid_cod[2])
elif mval == '0010': self.z(qid_cod[2])
elif mval == '1110': self.z(qid_cod[2]).x(qid_cod[2])
elif mval == '0110': self.x(qid_cod[3])
elif mval == '1001': self.z(qid_cod[3])
elif mval == '1111': self.z(qid_cod[3]).x(qid_cod[3])
elif mval == '0011': self.x(qid_cod[4])
elif mval == '0100': self.z(qid_cod[4])
elif mval == '0111': self.z(qid_cod[4]).x(qid_cod[4])

Pour effectuer le calcul inverse du bruit. Cela devrait restaurer l'état du signe.

Revenez à la section de traitement principale.

# result
fid = qs_ini.fidelity(qs_fin, qid=qid_cod)
print("* fidelity = {:.6f}".format(fid))

Ensuite, calculez et affichez la fidélité pour voir la différence entre l'état quantique d'origine et l'état quantique après correction d'erreur [^ 5]. Si la correction d'erreur réussit, la fidélité doit être de 1,0.

[^ 5]: L'argument de méthode de fidélité qid calcule la fidélité pour le sous-système représenté par une liste de nombres de bits quantiques particulière.

Contrôle de fonctionnement

Maintenant, exécutons le programme ci-dessus.

* input quantum state
c[0] = +0.3382-0.0000*i : 0.1143 |++
c[1] = -0.6657+0.6652*i : 0.8857 |++++++++++
* noise 'Z' to #4 qubit
* syndrome = 0100
* fidelity = 1.000000

Un état quantique correctement réglé 1 a été codé, et le bruit «Z» a été ajouté au 4ème bit quantique, mais le modèle d'erreur était «0100» ($ E_ {14} = IIIIZ $) par mesure du syndrome. À la suite de l'exécution du calcul inverse, la fidélité est devenue 1,000000. La correction d'erreur a donc réussi.

Si vous l'exécutez à nouveau,

* input quantum state
c[0] = +0.7701-0.0000*i : 0.5931 |+++++++
c[1] = -0.1945+0.6075*i : 0.4069 |+++++
* noise 'X' to #1 qubit
* syndrome = 1000
* fidelity = 1.000000

Ensuite, un modèle de bruit différent a été ajouté à l'état différent du précédent, mais la correction d'erreur a également réussi dans ce cas. Je l'ai essayé plusieurs fois et cela n'a pas échoué. Alors, félicitations, félicitations.

en conclusion

Ceci complète la série "Stabilizer Code" qui a été poursuivie quatre fois. Il y a quelques problèmes non résolus intéressants, tels que la forme standard des codes de stabilisateur et comment créer un état de base logique en utilisant uniquement des opérations unitaires, mais je voudrais passer à autre chose. La prochaine fois, nous prévoyons un «calcul quantique tolérant aux pannes».

c'est tout