Quelle est la différence entre «espace de code», «mot de code» et «code de stabilisateur»?

Je continue de lire (par exemple Nielsen et Chuang, 2010; p. 456 et 465) les trois phases suivantes; "espace de code", "mot de code" et "code de stabilisateur" - mais j'ai du mal à en trouver les définitions et, surtout, comment elles diffèrent les unes des autres.

Ma question est donc; comment ces trois termes sont-ils définis et comment sont-ils liés?

Espaces de code et mots de code

Un code correcteur d'erreurs quantiques est souvent identifié avec l'espace de code (Nielsen & Chuang semblent certainement le faire). L' espace de code par exemple d'un code de correction d'erreur quantique à bits, est un sous-espace vectoriel .$\mathcal C$$n$$\mathcal C \subseteq \mathcal H_2^{\otimes n}$

Un mot de code (terminologie empruntée à la théorie classique de la correction d'erreur) est un état pour un certain espace de code: c'est-à-dire qu'il s'agit d'un état qui code pour certaines données.$\lvert \psi \rangle \in \mathcal C$

Codes de correction d'erreur quantique

En pratique, nous exigeons que certaines propriétés non triviales contiennent un code de correction d'erreur quantique, telles que:

• C'est , de sorte qu'il y ait une quantité non nulle d'informations en cours de codage;$\mathop{\mathrm{dim}} \mathcal C \geqslant 2$
• Qu'il existe un ensemble d'au moins deux opérateurs, y compris l'opérateur , tels que - si est le projecteur orthogonal sur - nous avons pour certains scalaires (appelées conditions Knill – Laflamme ).$\mathcal E = \{ E_1, E_2, \ldots \}$$E_1 = \mathbb 1$$P$$\mathcal C$ $$P E_j E_k P = \alpha_{j,k} P$$ $\alpha_{j,k}$

Cela détermine un ensemble d'opérateurs d'erreur contre lesquels vous pouvez en principe protéger un état , en ce sens que si les conditions Knill – Laflamme prévalent d'un ensemble d'opérateurs et d'un opérateur agit sur votre état, il est en principe possible de détecter le fait que s'est produit (par opposition à un autre opérateur dans ) et d'annuler l'erreur, sans perturber les données stockées dans l'état d'origine .$\lvert \psi \rangle \in \mathcal C$$\mathcal E$$E \in \mathcal E$$E$$\mathcal E$$\lvert \psi \rangle$

Un code de correction d'erreur quantique est un espace de code , avec un ensemble d'opérateurs d'erreur qui satisfont aux conditions de Knill – Laflamme - c'est-à-dire qu'un code de correction d'erreur quantique doit spécifier contre quelles erreurs il est censé se protéger. .$\mathcal C$$\mathcal E$

Pourquoi il est courant d'identifier les codes de correction d'erreurs quantiques avec leurs espaces de code

Vous ne pouvez pas déterminer un ensemble unique d'opérateurs qui satisfont aux conditions Knill – Laflamme à partir de l'espace-code seul. Cependant, il est plus courant de considérer quels opérateurs de faible poids (ceux qui n'agissent que sur un petit nombre de qubits) peuvent être corrigés simultanément par un code, et dans une certaine mesure cela peut être dérivé du seul espace de code. La distance de code d'un espace de code est le plus petit nombre de qubits sur lequel vous devez agir, pour transformer un "mot-code" en un mot de code distinct . Si nous décrivons alors un espace de code comme étant un$\mathcal E$$\mathcal C$$\mathcal C$$\lvert \psi \rangle \in \mathcal C$$\lvert \psi' \rangle \in \mathcal C$$[\![n,k,d]\!]$ , cela dit alors que a la dimension , et que l'ensemble que nous considérons est l'ensemble de tous les opérateurs Pauli avec un poids au plus .$\mathcal C \subseteq \mathcal H_2^{\otimes n}$$2^k$$\mathcal E$$\lfloor (d{-}1)/2 \rfloor$

Dans certains cas, décrire un code comme un code Suffit. Par exemple, le code à 5 qubits est un code , Et il est possible de montrer que cinq qubits ne peuvent pas coder un seul qubit de telle manière que toute autre erreur puisse être corrigée en plus de toutes les erreurs de qubit unique. Cependant, il n'en va pas de même pour le code Steane , peut protéger contre toute erreur de Pauli à un seul qubit ainsi que certaines (mais pas toutes) les erreurs de Pauli à deux qubits. Quelles erreurs Pauli à deux qubits vous devriez$[\![n,k,d]\!]$$[\![5,1,3]\!]$$[\![7,1,3]\!]$protéger contre dépend de votre modèle d'erreur; et si votre bruit est symétrique et distribué indépendamment, peu importe ce que vous choisissez (de sorte que vous ferez probablement le choix conventionnel de toute erreur unique avec toute erreur unique ). Il s'agit cependant d'un choix , qui vous guidera dans la manière de protéger vos données contre le bruit.$X$$Z$

Codes stabilisateurs

Un code stabilisateur est un code de correction d'erreur quantique déterminé par un ensemble de générateurs de stabilisateurs , qui sont des opérateurs Pauli qui commutent entre eux, et qui définissent un espace-code par l'intersection de leurs espaces +1. (Il est souvent utile de considérer le groupe de stabilisateurs formé par les produits de )$\mathscr S$$\mathcal C$ $\mathcal G$$P \in \mathscr S$

Presque tous les codes de correction d'erreur quantique que les gens considèrent dans la pratique sont des codes stabilisateurs. C'est l'une des raisons pour lesquelles vous pouvez rencontrer des problèmes pour distinguer les deux termes. Cependant, nous n'exigeons pas qu'un code de correction d'erreur quantique soit un code stabilisateur - tout comme en principe nous n'exigeons pas qu'un code de correction d'erreur classique soit un code linéaire. Les codes de stabilisateur se trouvent être un moyen extrêmement efficace de décrire les codes de correction d'erreurs quantiques, tout comme les codes de correction d'erreurs linéaires sont un moyen extrêmement efficace de décrire les codes de correction d'erreurs classiques. Et en effet, les codes stabilisateurs peuvent être considérés comme une généralisation naturelle de la théorie des codes linéaires classiques à la correction d'erreur quantique.

Comme les gens sont souvent intéressés uniquement par les opérateurs de faible poids qui sont inférieurs à la moitié de la distance du code, l'ensemble des stabilisateurs est souvent tout ce que les gens disent d'un code de correction de stabilisateur. Cependant, pour spécifier l'ensemble d'erreurs contre lesquelles le code peut se protéger, il est également nécessaire de spécifier une relation entre les opérateurs de produits Pauli et les sous-ensembles , tels que$\mathcal E$$\sigma$$E$$S \subseteq \mathscr S$

• $E$ anticommute avec si et seulement si pour ;$P \in \mathscr S$$P \in S$$\sigma(E,S)$
• Si satisfont tous deux et , alors .$E, E'$$\sigma(E,S)$$\sigma(E',S)$$E E' \in \mathcal G = \langle \mathscr S \rangle$

Cela définit un ensemble d'erreurs contre lesquelles le code peut protéger. Les sous-ensembles sont appelés syndromes d'erreur , et la relation que j'ai appelée ici (que vous ne voyez généralement pas sous un nom explicite) associe des syndromes à une ou plusieurs erreurs qui causent ce syndrome , et dont les effets sur le code sont équivalents.

Les `` syndromes '' représentent des informations qui peuvent être réellement obtenues sur une erreur par une `` mesure cohérente '', c'est-à-dire en mesurant les opérateurs comme observables (un processus qui est généralement simulé par une estimation de valeur propre). Une erreur «provoque» un syndrome si, pour tout mot de code , l'état est dans l' espace de tous opérateurs , et dans l' -eigenspace de tous les autres opérateurs . (Cette propriété est directement liée à l'anticommutation de avec tous les éléments de$P \in \mathscr S$$E$$S \subseteq \mathscr S$$\lvert \psi \rangle \in \mathcal C$$E \lvert \psi \rangle$$-1$$P \in S$$+1$$\mathscr S$$E$$S \subseteq \mathscr S$ , et uniquement ces éléments.)

Un mot de code (pour un code quantique) est un état quantique qui est généralement associé à un état dans la base logique. Donc, vous aurez un état qui correspond à l'état 0 du qubit à encoder (vous n'avez pas besoin d'utiliser des qubits, mais vous l'êtes probablement), et vous en aurez un autre qui est qui correspond à l'état 1 du qubit à encoder.$|\psi_0\rangle$$|\psi_1\rangle$

L'espace de code est l'espace couvert par les mots de code, c'est-à-dire tout l'espace pour tous les et (normalisés).$\alpha|\psi_0\rangle+\beta|\psi_1\rangle$$\alpha$$\beta$

Un code stabilisateur est un formalisme possible pour vous dire comment travailler les mots de code et donc l'espace de code. Pour un code [[n, k, d]], vous disposez de nk opérateurs de stabilisateur ( ) qui commutent mutuellement et agissent sur n qubits. Tout état dans l'espace de code satisfait . Vous aurez en outre les opérateurs et pour qui commutent tous avec les stabilisateurs mais par paire à , , pour les indices correspondants. Ceux-ci définissent les opérateurs logiques de Pauli pour le code, et les mots de code sont donc les états qui satisfont$S$$S^2=\mathbb{I}$$|\psi\rangle$$S|\psi\rangle=|\psi\rangle$$Z_m$$X_m$$m=1,\ldots k$$S$$\{Z_m,X_m\}=0$$Z_m|\psi\rangle=\pm|\psi\rangle$ .

Dans un code de correction d'erreur quantique, vous stockez un certain nombre de qubits logiques , , dans un état de nombreux qubits physiques, .$k$$n$

Un mot de code est un état des qubits physiques associé à un état logique spécifique. Ainsi, par exemple, cependant, vous stockez l'état pour l'un de vos qubits logiques est un mot de code.$|0\rangle$

L'espace de code est l'espace Hilbert couvert par tous les mots de code possibles. Pour un code stabilisateur, ce terme est synonyme d'espace stabilisateur. Tout état dans cet espace de code est un mot de code

Un code stabilisateur est un code correcteur d'erreur quantique décrit par le formalisme du stabilisateur. L'espace stabilisateur est défini comme l' espace mutuel des produits tensoriels mutuellement commutants et indépendants des opérateurs de Pauli.$+1$$n-k$