Le code de Shor à 9 qubits

Nous nous intéressons maintenant au code de Shor à 9 qubits, qui est un code correcteur d'erreurs quantiques obtenu en combinant les deux codes étudiés dans la section précédente : le code à répétition 3 bits pour les qubits, qui permet de corriger une seule erreur de retournement de bit, et la version modifiée de ce code, qui permet de corriger une seule erreur de retournement de phase.

Description du code

Le code de Shor à 9 qubits est le code que l'on obtient en concaténant les deux codes de la section précédente. Cela signifie que l'on applique d'abord un encodage qui encode un qubit en trois, puis on applique l'autre encodage à chacun des trois qubits issus du premier encodage, ce qui donne neuf qubits au total.

Pour être plus précis, bien qu'on puisse appliquer les deux codes dans n'importe quel ordre dans ce cas particulier, nous choisissons d'appliquer d'abord la version modifiée du code à répétition 3 bits (qui détecte les erreurs de retournement de phase), puis d'encoder chacun des trois qubits résultants indépendamment en utilisant le code à répétition 3 bits original (qui détecte les erreurs de retournement de bit). Voici une représentation sous forme de diagramme de circuit de cet encodage.

Comme le suggère la figure, nous allons considérer les neuf qubits du code de Shor comme étant regroupés en trois blocs de trois qubits, où chaque bloc est obtenu à partir de la deuxième étape d'encodage (qui est le code à répétition 3 bits ordinaire). Le code à répétition 3 bits ordinaire, appliqué ici trois fois indépendamment, est appelé le code interne dans ce contexte, tandis que le code externe est le code utilisé pour la première étape d'encodage, à savoir la version modifiée du code à répétition 3 bits qui détecte les erreurs de retournement de phase.

On peut également spécifier le code en décrivant comment les deux états de la base standard pour notre qubit original sont encodés.

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[4mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

Une fois cela connu, on peut déterminer par linéarité comment un vecteur d'état de qubit arbitraire est encodé.

Correction des erreurs de retournement de bit et de phase

Erreurs et portes CNOT

Pour analyser comment les erreurs $X$ et $Z$ affectent les encodages de qubits, aussi bien pour le code de Shor à 9 qubits que pour d'autres codes, il est utile d'observer quelques relations simples entre ces erreurs et les portes CNOT. Alors que nous commençons à analyser le code de Shor à 9 qubits, c'est le bon moment pour faire une pause et examiner cela.

Les diagrammes de circuits suivants illustrent trois relations fondamentales entre les portes $X$ et les portes CNOT. Plus précisément, appliquer une porte $X$ au qubit cible avant un CNOT est équivalent à inverser l'ordre et effectuer d'abord le CNOT, mais appliquer une porte $X$ au qubit de contrôle avant un CNOT est équivalent à appliquer des portes $X$ aux deux qubits après le CNOT. Enfin, appliquer des portes $X$ aux deux qubits avant un CNOT est équivalent à effectuer d'abord le CNOT, puis à appliquer une porte $X$ au qubit de contrôle. Ces relations peuvent être vérifiées en effectuant les multiplications matricielles requises ou en calculant l'effet des circuits sur les états de la base standard.

La situation est similaire pour les portes $Z$, sauf que les rôles du qubit de contrôle et du qubit cible sont échangés. En particulier, on a les trois relations représentées par les circuits quantiques suivants.

Correction des erreurs de retournement de bit

Nous allons maintenant examiner comment les erreurs peuvent être détectées et corrigées à l'aide du code de Shor à 9 qubits, en commençant par les erreurs de retournement de bit — que nous désignerons généralement comme des erreurs $X$ dorénavant, par souci de concision.

Pour détecter et corriger les erreurs $X$, on peut simplement traiter chacun des trois blocs de l'encodage séparément. Chaque bloc est un encodage d'un qubit utilisant le code à répétition 3 bits, qui protège contre les erreurs $X$ — ainsi, en effectuant les mesures du syndrome et les corrections d'erreurs $X$ décrites précédemment sur chaque bloc, on peut détecter et corriger jusqu'à une erreur $X$ par bloc. En particulier, s'il y a au plus une erreur $X$ sur les neuf qubits de l'encodage, cette erreur sera détectée et corrigée par cette procédure.

En résumé, la correction des erreurs de retournement de bit est simple pour ce code, grâce au fait que le code interne corrige ces erreurs.

Correction des erreurs de retournement de phase

Examinons maintenant les erreurs de retournement de phase, ou erreurs $Z$ pour faire court. Cette fois, la marche à suivre n'est pas aussi évidente, car c'est le code externe qui détecte les erreurs $Z$, mais le code interne semble en quelque sorte « être dans le chemin », rendant la détection et la correction de ces erreurs légèrement plus difficile.

Supposons qu'une erreur $Z$ survienne sur l'un des 9 qubits du code de Shor, comme celui indiqué dans ce diagramme.

Nous avons déjà observé ce qui se passe lorsqu'une erreur $Z$ survient avec le code à répétition 3 bits — c'est équivalent à une erreur $Z$ survenant avant l'encodage. Dans le contexte du code de Shor à 9 qubits, cela signifie qu'une erreur $Z$ sur n'importe lequel des trois qubits d'un bloc a toujours le même effet, équivalent à une erreur $Z$ survenant sur le qubit correspondant avant que le code interne soit appliqué.

Par exemple, le diagramme de circuit ci-dessus est équivalent au diagramme suivant. Cela peut être raisonné en utilisant les relations entre les portes $Z$ et CNOT décrites ci-dessus, ou simplement en évaluant les circuits sur un état de qubit arbitraire $\vert\psi\rangle.$

Ceci suggère une option pour détecter et corriger les erreurs $Z$, qui consiste à décoder le code interne, nous laissant avec les trois qubits utilisés pour l'encodage externe ainsi que six qubits de travail initialisés. On peut ensuite vérifier ces trois qubits du code externe pour les erreurs $Z$, puis enfin ré-encoder en utilisant le code interne, pour revenir à l'encodage à 9 qubits que nous donne le code de Shor. Si une erreur $Z$ est détectée, on peut la corriger avant le ré-encodage avec le code interne, ou après le ré-encodage, en appliquant une porte $Z$ à n'importe lequel des qubits de ce bloc.

Voici un diagramme de circuit qui inclut le circuit d'encodage et l'erreur suggérée ci-dessus ainsi que les étapes qui viennent d'être décrites (mais pas l'étape de correction proprement dite).

Dans cet exemple particulier, la mesure du syndrome est $11,$ ce qui localise l'erreur $Z$ comme étant survenue sur l'un des qubits du bloc du milieu.

Un avantage de corriger les erreurs $Z$ après l'étape de ré-encodage plutôt qu'avant est que l'on peut simplifier le circuit ci-dessus. Le circuit suivant est équivalent, mais nécessite quatre portes CNOT de moins.

Une fois de plus, le syndrome n'indique pas quel qubit a été affecté par une erreur $Z$, mais plutôt quel bloc a subi une erreur $Z$, avec le même effet quelle que soit la position du qubit affecté dans le bloc. On peut alors corriger l'erreur en appliquant une porte $Z$ à n'importe lequel des trois qubits du bloc affecté.

Notons au passage qu'on voit ici un exemple de dégénérescence dans un code correcteur d'erreurs quantiques, où on est capable de corriger certaines erreurs (les erreurs $Z$ dans ce cas) sans être en mesure de les identifier de manière unique.

Erreurs simultanées de retournement de bit et de phase

Nous avons maintenant vu comment les erreurs $X$ et $Z$ peuvent être détectées et corrigées à l'aide du code de Shor à 9 qubits, et en particulier comment au plus une erreur $X$ ou au plus une erreur $Z$ peuvent être détectées et corrigées. Supposons maintenant qu'une erreur de retournement de bit et une erreur de retournement de phase surviennent toutes les deux, éventuellement sur le même qubit. En réalité, rien de différent ne doit être fait dans cette situation par rapport à ce qui a déjà été discuté — le code est capable de détecter et de corriger jusqu'à une erreur $X$ et une erreur $Z$ simultanément, sans modification supplémentaire.

Pour être plus précis, les erreurs $X$ sont détectées en appliquant la mesure du syndrome du code à répétition 3 bits ordinaire, effectuée séparément sur chacun des trois blocs de trois qubits ; et les erreurs $Z$ sont détectées via la procédure décrite juste au-dessus, qui est équivalente à décoder le code interne, effectuer la mesure du syndrome pour le code à répétition 3 bits modifié pour les retournements de phase, puis ré-encoder. Ces deux étapes de détection d'erreurs — ainsi que les corrections correspondantes — peuvent être effectuées de manière complètement indépendante l'une de l'autre, et en fait l'ordre dans lequel elles sont effectuées n'a pas d'importance.

Pour comprendre pourquoi, considérons l'exemple représenté dans le diagramme de circuit suivant, où une erreur $X$ et une erreur $Z$ ont toutes deux affecté le qubit inférieur du bloc du milieu.

Observons d'abord que l'ordre des erreurs n'a pas d'importance, dans le sens où inverser la position des erreurs $X$ et $Z$ produit un circuit équivalent. Pour être clair, $X$ et $Z$ ne commutent pas, ils anti-commutent :

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

Cela implique que le circuit suivant est équivalent à celui qui précède à un facteur de phase globale $-1$ près.

On peut maintenant déplacer l'erreur $Z$ comme précédemment pour obtenir un autre circuit équivalent.

À ce stade, il est évident que si la procédure de détection et de correction des erreurs $X$ est effectuée en premier, l'erreur $X$ sera corrigée, après quoi la procédure de détection et de correction des erreurs $Z$ peut être effectuée pour éliminer l'erreur $Z$ comme précédemment.

Alternativement, la procédure de détection et de correction des erreurs $Z$ peut être effectuée en premier. Le fait que cette procédure fonctionne comme prévu, même en présence d'une ou plusieurs erreurs $X$, découle du fait que les portes $X$ sur n'importe lequel des neuf qubits utilisés pour l'encodage commutent avec toutes les portes de notre circuit simplifié pour mesurer le syndrome des erreurs $Z$. Ainsi, cette mesure du syndrome identifiera toujours correctement quel bloc a été affecté par une erreur $Z$. Le fait qu'une erreur $Z$ sur n'importe quel bloc soit corrigée en appliquant une porte $Z$ à n'importe quel qubit de ce bloc, même si une erreur $X$ s'est également produite, découle du même argument ci-dessus concernant l'ordre des portes $X$ et $Z$ qui donne des circuits équivalents à une phase globale près.

Il s'ensuit que le code de Shor à 9 qubits peut corriger une erreur $X$, une erreur $Z$, ou les deux, sur n'importe lequel des neuf qubits utilisés pour ce code. En fait, on peut corriger davantage d'erreurs que cela, y compris plusieurs erreurs $X$ (à condition qu'elles se trouvent dans des blocs différents) ou plusieurs erreurs $Z$ (à condition qu'au plus un bloc en subisse un nombre impair) — mais pour la suite, ce qui sera le plus pertinent aux fins de cette leçon est qu'on peut corriger une erreur $X$, une erreur $Z$, ou les deux sur n'importe quel qubit.

Réduction des erreurs pour des erreurs aléatoires

Avant de passer à la dernière section de la leçon, qui concerne les erreurs quantiques arbitraires, considérons brièvement les performances du code de Shor à 9 qubits lorsque des erreurs représentées par des matrices de Pauli surviennent aléatoirement sur les qubits.

Pour être plus concret, considérons un modèle de bruit simple où les erreurs surviennent indépendamment sur les qubits, chaque qubit subissant une erreur avec probabilité $p$, sans corrélation entre les erreurs sur différents qubits — dans un esprit similaire à un canal symétrique binaire pour les bits classiques. On pourrait attribuer des probabilités différentes pour que des erreurs $X,$ $Y,$ et $Z$ surviennent, mais pour garder les choses aussi simples que possible, nous allons considérer le pire cas pour le code de Shor à 9 qubits, c'est-à-dire qu'une erreur $Y$ survient sur chacun des qubits affectés. Une erreur $Y$, soit dit en passant, est équivalente (à un facteur de phase globale non pertinent près) à la fois à une erreur $X$ et à une erreur $Z$ survenant sur le même qubit, étant donné que $Y = iXZ.$ Cela explique notre apparent désintérêt pour les erreurs $Y$ jusqu'à présent.

Maintenant, supposons que $\mathsf{Q}$ soit un qubit dans un état particulier que nous souhaitons protéger contre les erreurs, et envisageons l'option d'utiliser le code de Shor à 9 qubits. Une question naturelle à poser est : « Devrait-on l'utiliser ? »

La réponse n'est pas nécessairement « oui ». S'il y a trop de bruit, ce qui signifie dans ce contexte que $p$ est trop grand, l'utilisation du code de Shor pourrait en fait aggraver les choses — tout comme le code à répétition 3 bits est pire qu'aucun code lorsque $p$ est supérieur à un demi. Mais si $p$ est suffisamment petit, alors la réponse est « oui », on devrait utiliser le code, car il diminuera la probabilité que l'état encodé soit corrompu. Voyons pourquoi c'est le cas, et ce que cela signifie pour $p$ d'être trop grand ou suffisamment petit pour ce code.

Le code de Shor corrige toute erreur de Pauli sur un seul qubit, y compris bien sûr une erreur $Y$, mais il ne corrige pas correctement deux erreurs $Y$ ou plus. Pour être clair, nous supposons que nous utilisons les corrections d'erreurs $X$ et $Z$ décrites plus tôt dans la section. (Bien sûr, si nous savions à l'avance que nous n'avions à nous soucier que des erreurs $Y$, nous choisirions naturellement nos corrections différemment — mais c'est tricher le modèle de bruit, et on pourrait toujours modifier le modèle en sélectionnant différentes erreurs de Pauli pour faire échouer ce nouveau choix de corrections dès que deux qubits ou plus sont affectés par des erreurs.)

Ainsi, le code protège $\mathsf{Q}$ à condition qu'au plus un des neuf qubits soit affecté par une erreur, ce qui se produit avec probabilité

$$(1-p)^9 + 9 p (1-p)^8.$$

Sinon, avec probabilité

$$1 - (1-p)^9 - 9 p (1-p)^8,$$

le code échoue à protéger $\mathsf{Q}.$

Plus précisément, ce que cela signifie dans ce contexte est que, à une phase globale près, une opération de Pauli non identité sera appliquée à notre qubit $\mathsf{Q}$ (en tant que qubit logique). C'est-à-dire que si les erreurs $X$ et $Z$ sont détectées et corrigées pour le code de Shor comme décrit plus tôt dans la leçon, nous nous retrouverons avec l'encodage d'un état équivalent, à une phase globale près, à l'encodage d'une opération de Pauli non identité appliquée à l'état original de $\mathsf{Q}.$ Une façon plus succincte de dire cela est qu'une erreur logique aura eu lieu. Cela peut avoir ou ne pas avoir d'effet sur l'état original de $\mathsf{Q}$ — ou en d'autres termes le qubit logique que nous avons encodé avec neuf qubits physiques — mais, pour les besoins de cette analyse, nous considérons cet événement comme un échec.

En revanche, si nous ne prenions pas la peine d'utiliser le code, notre unique qubit subirait un sort similaire (être soumis à une opération de Pauli non identité) avec probabilité $p.$ Le code est utile lorsque la première probabilité est inférieure à la seconde :

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

Voici un graphique qui illustre, pour de très petites valeurs de $p,$ que le code procure un avantage, le point d'équilibre se situant aux alentours de $0{,}0323.$

Si $p$ est inférieur à ce point d'équilibre, le code est utile ; au point d'équilibre, les probabilités sont égales, donc on gaspille simplement notre temps ainsi que 8 qubits si on utilise le code ; et au-delà du point d'équilibre, on ne devrait absolument pas utiliser ce code car il augmente le risque d'une erreur logique sur $\mathsf{Q}.$

Trois virgule vingt-cinq pour cent environ peut ne pas sembler un très bon point d'équilibre, surtout comparé à $50\%,$ qui est le point d'équilibre analogue pour le code à répétition 3 bits pour l'information classique. Cette différence est, en grande partie, due au fait que l'information quantique est plus délicate et plus difficile à protéger que l'information classique. Mais aussi — tout en reconnaissant que le code de Shor à 9 qubits représente une découverte brillante, en tant que premier code correcteur d'erreurs quantiques au monde — il faut admettre qu'il n'est en réalité pas un très bon code en termes pratiques.