Contrôle de la propagation des erreurs

Le calcul quantique tolérant aux fautes ressemble à une course entre les erreurs et la correction d'erreurs. Si le nombre d'erreurs est suffisamment faible, la correction d'erreurs réussira à les corriger ; mais s'il y a trop d'erreurs, la correction d'erreurs échouera.

Pour cette raison, une attention suffisante doit être accordée à la façon dont les calculs quantiques sont effectués dans les implémentations tolérantes aux fautes de circuits, pour contrôler la propagation des erreurs. En effet, une erreur sur un qubit peut potentiellement se propager à plusieurs qubits par l'action des portes dans un circuit quantique, ce qui peut entraîner une augmentation dramatique du nombre d'erreurs. C'est une préoccupation primordiale, car si nous ne parvenons pas à contrôler la propagation des erreurs, nos efforts de correction d'erreurs seront rapidement submergés par les erreurs. Si, en revanche, nous sommes capables de maintenir la propagation des erreurs sous contrôle, la correction d'erreurs a une chance de suivre, permettant aux erreurs d'être corrigées à un rythme suffisamment élevé pour que le calcul quantique fonctionne comme prévu.

Le point de départ d'une discussion technique de cette question est la reconnaissance que les portes à deux qubits (ou les portes à plusieurs qubits plus généralement) peuvent propager des erreurs, même lorsqu'elles fonctionnent parfaitement. Par exemple, considère une porte NOT contrôlé, et suppose qu'une erreur $X$ se produit sur le qubit de contrôle juste avant que la porte NOT contrôlé soit effectuée. Comme nous l'avons déjà observé dans la leçon « Correction des erreurs quantiques », cela est équivalent à une erreur $X$ se produisant sur les deux qubits après que la porte NOT contrôlé est effectuée. La situation est similaire pour une erreur $Z$ agissant sur la cible plutôt que sur le contrôle avant que la porte NOT contrôlé soit effectuée.

Il s'agit d'une propagation d'erreurs, car l'emplacement malheureux d'une erreur $X$ ou $Z$ avant la porte NOT contrôlé la transforme effectivement en deux erreurs après la porte NOT contrôlé. Cela se produit même lorsque la porte NOT contrôlé est parfaite, et nous ne devons pas oublier qu'une porte NOT contrôlé donnée peut elle-même être bruyante, ce qui peut créer des erreurs corrélées sur deux qubits.

Ce qui s'ajoute à nos préoccupations est le fait que des portes à deux qubits ultérieures pourraient propager ces erreurs encore plus loin, comme le suggère la figure suivante.

Dans un sens, nous ne pouvons jamais contourner cela ; tant que nous utilisons des portes à plusieurs qubits, il y aura un potentiel de propagation d'erreurs. Cependant, comme nous le verrons dans les sous-sections suivantes, des mesures peuvent être prises pour limiter les dégâts causés, permettant de gérer les erreurs propagées.

Implémentations de portes transversales

La façon la plus simple connue pour atténuer la propagation d'erreurs dans les circuits quantiques tolérants aux fautes est d'implémenter les portes transversalement, ce qui signifie construire des gadgets pour eux qui ont une certaine forme simple. Plus précisément, les gadgets doivent être un produit tensoriel d'opérations (ou, en d'autres termes, un circuit quantique de profondeur un), où chaque opération ne peut agir que sur une seule position de qubit dans chaque bloc de code qu'elle touche. Cela est peut-être plus facile à expliquer à travers quelques exemples.

Exemples d'implémentations de portes transversales

Considère la figure suivante, qui suggère une implémentation transversale d'une porte CNOT. (Cette implémentation particulière, où les CNOT sont effectués qubit par qubit, ne fonctionne que pour les codes CSS — mais elle fonctionne effectivement pour tous les codes CSS.)

Il y a deux blocs de code dans cette figure, chacun représenté comme composé de cinq qubits (bien que ce puisse être davantage, comme cela a déjà été suggéré). Le circuit à droite a une profondeur de un, et chacune des portes CNOT agit sur une seule position de qubit dans chaque bloc : le contrôle et la cible pour le premier CNOT sont tous deux le qubit le plus en haut (c'est-à-dire le qubit 0 selon la convention de numérotation de Qiskit), le contrôle et la cible pour le deuxième CNOT sont tous deux le qubit deuxième en partant du haut (c'est-à-dire le qubit 1), et ainsi de suite. Il s'agit donc d'un gadget transversal.

Pour un deuxième exemple — réellement une classe d'exemples — considère toute porte de Pauli. Les portes de Pauli peuvent toujours être implémentées transversalement, pour tout code stabilisateur, en construisant des gadgets composés d'opérations de Pauli. En particulier, toute opération de Pauli sur un qubit logique encodé par un code stabilisateur peut être implémentée transversalement en choisissant une opération de Pauli appropriée sur les qubits physiques utilisés pour l'encodage. Cela est cohérent avec un fait mentionné en passant dans la leçon « Formalisme des stabilisateurs » : à une phase globale près, les opérations de Pauli qui commutent avec chaque générateur de stabilisateur d'un code stabilisateur agissent comme des opérations de Pauli sur le qubit ou les qubits encodés par ce code.

Comme exemple spécifique, considère le code de Shor à $9$ qubits, pour lequel les états de la base standard pourraient être encodés comme suit.

$$\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) \\[3mm] \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 porte $X$ sur le qubit logique encodé par ce code peut être implémentée transversalement par l'opération de Pauli à $9$ qubits

$$Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I}$$

tandis qu'une porte $Z$ sur le qubit logique peut être implémentée transversalement par l'opération de Pauli à $9$ qubits

$$X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}.$$

Ces deux opérations de Pauli ont un poids $3,$ qui est le poids minimum requis. (Le code de Shor à $9$ qubits a une distance $3,$ donc toute opération de Pauli non identitaire de poids $2$ ou moins est détectée comme une erreur.)

Et, pour un troisième exemple, le code de Steane à $7$ qubits (et en fait tout code couleur) permet une implémentation transversale de toutes les portes de Clifford. Nous avons déjà vu comment les portes CNOT sont implémentées transversalement pour tout code CSS, il reste donc à considérer les portes $H$ et $S$. Une porte de Hadamard appliquée à tous les $7$ qubits du code de Steane est équivalente à $H$ appliqué au qubit logique qu'il encode, tandis qu'une porte $S^{\dagger}$ (par opposition à une porte $S$) appliquée à tous les $7$ qubits est équivalente à une porte $S$ logique.

Propagation d'erreurs pour les gadgets transversaux

Maintenant que nous savons ce que sont les implémentations transversales de portes, discutons de leur lien avec la propagation des erreurs.

Pour une implémentation transversale d'une porte à un qubit, nous avons simplement un produit tensoriel de portes à un qubit dans notre gadget, qui agit sur un bloc de code de qubits physiques pour le code correcteur d'erreurs quantiques choisi. Bien que l'une quelconque de ces portes pourrait défaillir et introduire une erreur, il n'y aura pas de propagation d'erreurs car aucune porte à plusieurs qubits n'est impliquée. Immédiatement après l'application du gadget, la correction d'erreurs est effectuée ; et si le nombre d'erreurs introduites par le gadget (ou pendant l'exécution du gadget) est suffisamment faible, les erreurs seront corrigées. Donc, si le taux d'erreurs introduites par des portes défectueuses est suffisamment faible, la correction d'erreurs a de bonnes chances de réussir.

Pour une implémentation transversale d'une porte à deux qubits, en revanche, il y a un potentiel de propagation des erreurs — il n'y a simplement aucun moyen de l'éviter, comme nous l'avons déjà observé. Le point essentiel, cependant, est qu'un gadget transversal ne peut jamais provoquer de propagation d'erreurs à l'intérieur d'un seul bloc de code.

Par exemple, en considérant l'implémentation transversale d'une porte CNOT pour un code CSS décrite ci-dessus, une erreur $X$ pourrait se produire sur le qubit supérieur du bloc de code supérieur juste avant l'exécution du gadget, et le premier CNOT dans le gadget propagera cette erreur au qubit supérieur dans le bloc inférieur. Cependant, les deux erreurs résultantes se trouvent maintenant dans des blocs de code séparés. Donc, en supposant que notre code peut corriger une erreur $X$, les étapes de correction d'erreurs qui ont lieu après le gadget corrigeront individuellement les deux erreurs $X$ — parce qu'une seule erreur se produit dans chaque bloc de code. En revanche, si la propagation des erreurs se produisait à l'intérieur du même bloc de code, elle pourrait transformer une erreur de faible poids en une erreur de poids élevé que le code ne peut pas gérer.

Non-universalité des portes transversales

Pour deux codes stabilisateurs différents, il peut être qu'une porte particulière peut être implémentée transversalement avec un code mais pas avec l'autre. Par exemple, bien qu'il ne soit pas possible d'implémenter une porte $T$ transversalement avec le code de Steane à $7$ qubits, il existe d'autres codes pour lesquels c'est possible.

Malheureusement, il n'est jamais possible, pour aucun code correcteur d'erreurs quantiques non trivial, d'implémenter un ensemble universel de portes transversalement. Ce fait est connu sous le nom de théorème d'Eastin-Knill.

Théorème

Théorème d'Eastin-Knill : Pour tout code correcteur d'erreurs quantiques de distance au moins 2, l'ensemble des portes logiques pouvant être implémentées transversalement engendre un ensemble d'opérations qui (à une phase globale près) est discret, et n'est donc pas universel.

La preuve de ce théorème ne sera pas expliquée ici. (Ce n'est pas une preuve compliquée, mais elle nécessite une connaissance de base des groupes de Lie et des algèbres de Lie, qui ne font pas partie des prérequis de la série.) L'idée de base, cependant, peut être exprimée en termes intuitifs : Des familles infinies d'opérations transversales ne peuvent pas rester dans l'espace de code d'un code non trivial car les différences infimes entre les opérations transversales sont bien approximées par des opérations de Pauli de faible poids, que le code détecte comme des erreurs.

En résumé, les gadgets transversaux offrent une implémentation simple et intrinsèquement tolérante aux fautes des portes — mais pour tout choix raisonnable d'un code correcteur d'erreurs quantiques, il n'y aura jamais un ensemble universel de portes pouvant être implémentées de cette façon, ce qui nécessite l'utilisation de gadgets alternatifs.

États magiques

Étant donné qu'il n'est pas possible, pour aucun choix non trivial de code correcteur d'erreurs quantiques, d'implémenter un ensemble universel de portes quantiques transversalement, nous devons considérer d'autres méthodes pour implémenter les portes de façon tolérante aux fautes. Une méthode bien connue est basée sur la notion d'états magiques, qui sont des états quantiques de qubits permettant des implémentations tolérantes aux fautes de certaines portes.

Implémentation de portes avec des états magiques

Commençons par considérer les portes $S$ et $T$, dont les descriptions matricielles sont les suivantes.

$$S = \begin{pmatrix} 1 & 0\\ 0 & i \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/2} \end{pmatrix} \qquad\text{et}\qquad T = \begin{pmatrix} 1 & 0\\ 0 & \frac{1+i}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/4} \end{pmatrix}$$

Par définition, $S$ est une opération de Clifford, tandis que $T$ ne l'est pas ; il n'est pas possible d'implémenter une porte $T$ avec un circuit composé de portes de Clifford (portes $H$, portes $S$ et portes CNOT).

Cependant, il est possible d'implémenter une porte $T$ (à une phase globale près) avec un circuit composé de portes de Clifford si, en plus, nous avons une copie de l'état

$$T\vert {+} \rangle = \frac{1}{\sqrt{2}} \vert 0 \rangle + \frac{e^{i\pi/4}}{\sqrt{2}} \vert 1\rangle,$$

et que nous autorisons des mesures dans la base standard et des portes classiquement contrôlées. En particulier, le circuit suivant montre une façon de le faire. Le phénomène illustré ici est un exemple quelque peu simplifié de téléportation de porte quantique.

Pour vérifier que ce circuit fonctionne correctement, nous pouvons d'abord calculer l'action de la porte CNOT sur l'entrée.

$$T \vert {+} \rangle \otimes \vert\psi\rangle \stackrel{\text{CNOT}}{\longmapsto} \frac{1}{\sqrt{2}} \vert 0\rangle \otimes T \vert \psi\rangle + \frac{1+i}{2} \vert 1\rangle \otimes T^{\dagger} \vert \psi\rangle$$

La mesure donne donc les résultats $0$ et $1$ avec une probabilité égale. Si le résultat est $0,$ la porte $S$ n'est pas effectuée, et l'état de sortie est $T\vert\psi\rangle$ ; et si le résultat est $1,$ la porte $S$ est effectuée, et l'état de sortie est $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle.$

L'état $T\vert {+}\rangle$ est appelé un état magique dans ce contexte, bien qu'il ne soit pas unique à cet égard : d'autres états sont également appelés états magiques lorsqu'ils peuvent être utilisés de manière similaire (pour des portes possiblement différentes et en utilisant des circuits différents). Par exemple, remplacer l'état $T\vert{+}\rangle$ par l'état $S\vert{+}\rangle$ et remplacer la porte $S$ dans le circuit ci-dessus par une porte $Z$ implémente une porte $S$ — ce qui est potentiellement utile pour le calcul quantique tolérant aux fautes utilisant un code pour lequel les portes $S$ ne peuvent pas être implémentées transversalement.

Gadgets tolérants aux fautes à partir d'états magiques

Il peut ne pas être clair que l'utilisation d'états magiques pour implémenter des portes est utile pour la tolérance aux fautes. Pour l'implémentation de la porte $T$ décrite ci-dessus, par exemple, il semble que nous devons encore appliquer une porte $T$ à un état $\vert{+}\rangle$ pour obtenir un état magique, que nous utilisons ensuite pour implémenter une porte $T$. Alors quel est l'avantage d'utiliser cette approche pour la tolérance aux fautes ?

Voici trois points clés qui fournissent une réponse à cette question.

1. La création d'états magiques ne nécessite pas l'application de la porte que nous essayons d'implémenter à un état particulier. Par exemple, appliquer une porte $T$ à un état $\vert {+} \rangle$ n'est pas la seule façon d'obtenir un état $T\vert{+}\rangle$.

2. La création d'états magiques peut être faite séparément du calcul dans lequel ils sont utilisés. Cela signifie que les erreurs qui surviennent dans le processus de création d'état magique ne se propageront pas au calcul réel effectué.

3. Si les portes individuelles dans le circuit implémentant une porte choisie à l'aide d'un état magique peuvent être implémentées de façon tolérante aux fautes, et que nous supposons la disponibilité d'états magiques, nous obtenons une implémentation tolérante aux fautes de la porte choisie.

Pour simplifier la discussion qui suit, concentrons-nous sur les portes $T$ spécifiquement — en gardant à l'esprit que la méthodologie peut être étendue à d'autres portes. Une implémentation tolérante aux fautes d'une porte $T$ utilisant des états magiques prend la forme suggérée par la figure suivante.

Les qubits dans le circuit $T$ original correspondent à des qubits logiques dans ce diagramme, encodés par le code que nous utilisons pour la tolérance aux fautes. Les entrées et sorties dans le diagramme doivent donc être comprises comme des encodages de ces états. Cela signifie, en particulier, que nous n'avons pas seulement besoin d'états magiques — nous avons besoin d'états magiques encodés. Les portes dans le circuit $T$ original sont ici remplacées par des gadgets, que nous supposons être tolérants aux fautes.

Cette figure particulière suggère donc que nous avons déjà des gadgets tolérants aux fautes pour les portes CNOT et $S$. Pour un code couleur, ces gadgets pourraient être transversaux ; pour un code de surface (ou tout autre code CSS), le CNOT peut être effectué transversalement, tandis que le gadget de porte $S$ pourrait lui-même être implémenté à l'aide d'états magiques, comme il a été suggéré précédemment. (La figure suggère également que nous avons un gadget tolérant aux fautes pour effectuer une mesure dans la base standard, ce que nous avons ignoré jusqu'à présent. Cela pourrait en fait être difficile pour certains codes sélectionnés à cet effet, mais pour un code CSS c'est une question de mesurer chaque qubit physique suivie d'un post-traitement classique.)

L'implémentation est donc tolérante aux fautes, en supposant que nous disposions d'un encodage d'un état magique $T\vert{+}\rangle.$ Mais nous n'avons pas encore abordé la question de comment nous obtenons un encodage de cet état. Un moyen d'obtenir des états magiques encodés (ou, peut-être plus précisément, de les améliorer) est via un processus connu sous le nom de distillation d'états magiques. Le diagramme suivant illustre à quoi ressemble ce processus au plus haut niveau.

En d'autres termes, une collection d'états magiques encodés bruités est transmise à un type spécial de circuit connu sous le nom de distillateur. Tous les blocs de sortie sauf un sont mesurés — ce qui signifie que les qubits logiques sont mesurés avec des mesures dans la base standard. Si l'un des résultats de mesure est $1,$ le processus a échoué et doit être redémarré. Si, cependant, chaque résultat de mesure est $0,$ l'état résultant du bloc de code supérieur sera un état magique encodé moins bruité. Cet état pourrait ensuite rejoindre quatre autres comme entrées dans un autre distillateur, ou être utilisé pour implémenter une porte $T$ s'il est jugé suffisamment proche d'un véritable état magique encodé. Bien sûr, le processus doit commencer quelque part, une possibilité étant de les préparer de façon non tolérante aux fautes.

Il existe différentes façons connues de construire le distillateur lui-même, mais elles ne seront pas expliquées ni analysées ici. Au niveau logique, l'approche typique — de façon remarquable et quelque peu fortuite — est d'exécuter un circuit d'encodage pour un code stabilisateur à rebours ! Il pourrait s'agir d'un code stabilisateur différent de celui utilisé pour la correction d'erreurs. Par exemple, on pourrait potentiellement utiliser un code de surface ou couleur pour la correction d'erreurs, mais exécuter un encodeur pour le code à $5$ qubits à rebours pour la distillation d'états magiques. Les circuits d'encodage pour les codes stabilisateurs ne nécessitent que des portes de Clifford, ce qui simplifie l'implémentation tolérante aux fautes d'un distillateur. En réalité, les spécificités dépendent des codes utilisés.

En résumé, cette section a visé à fournir seulement une discussion à très haut niveau des états magiques, avec l'intention de donner juste une idée de base de leur fonctionnement. On affirme parfois que les frais généraux liés à l'utilisation d'états magiques pour implémenter des portes de façon tolérante aux fautes selon ces lignes seraient extrêmement élevés, la grande majorité du travail allant dans le processus de distillation. Cependant, ce n'est en fait pas si clair — il existe de nombreuses façons potentielles d'optimiser ces processus. Il existe, en outre, des approches alternatives pour construire des gadgets tolérants aux fautes pour des portes qui ne peuvent pas être implémentées transversalement. Par exemple, la déformation de code et le changement de code sont des mots-clés associés à certains de ces schémas — et de nouvelles façons continuent d'être développées et raffinées.

Correction d'erreurs tolérante aux fautes

En plus de l'implémentation des divers gadgets requis pour une implémentation tolérante aux fautes d'un circuit quantique donné, il existe un autre problème important qui doit être reconnu : l'implémentation des étapes de correction d'erreurs elles-mêmes. Cela renvoie à l'idée que tout ce qui implique de l'information quantique est susceptible aux erreurs — y compris les circuits qui sont eux-mêmes destinés à corriger les erreurs.

Considère, par exemple, le type de circuit décrit dans la leçon « Le formalisme des stabilisateurs » pour mesurer les générateurs de stabilisateurs de façon non destructive en utilisant l'estimation de phase. Ces circuits ne sont clairement pas tolérants aux fautes car ils peuvent provoquer la propagation d'erreurs à l'intérieur du bloc de code sur lequel ils opèrent. Cela peut sembler assez problématique, mais il existe plusieurs façons connues d'effectuer la correction d'erreurs de façon tolérante aux fautes sans provoquer la propagation des erreurs dans les blocs de code corrigés.

Une méthode est connue sous le nom de correction d'erreurs de Shor, car elle a été découverte pour la première fois par Peter Shor. L'idée est d'effectuer des mesures de syndrome à l'aide d'un soi-disant état chat, qui est un état à $n$ qubits de la forme

$$\frac{1}{\sqrt{2}} \vert 0^n \rangle + \frac{1}{\sqrt{2}} \vert 1^n \rangle,$$

où $0^n$ et $1^n$ désignent les chaînes de zéros et d'uns de longueur $n.$ Par exemple, c'est un état $\vert\phi^+\rangle$ quand $n=2$ et un état GHZ quand $n=3,$ mais en général, la correction d'erreurs de Shor nécessite un état comme celui-ci pour $n$ égal au poids du générateur de stabilisateur mesuré.

Comme exemple, le circuit montré ici mesure un générateur de stabilisateur de la forme $P_2\otimes P_1 \otimes P_0.$

Cela nécessite la construction de l'état chat lui-même, et pour le faire fonctionner de façon fiable en présence d'erreurs et de portes potentiellement défectueuses, la méthode nécessite en fait d'exécuter des circuits comme celui-ci de façon répétée pour faire des inférences sur l'endroit où différentes erreurs peuvent s'être produites pendant le processus.

Une méthode alternative est connue sous le nom de correction d'erreurs de Steane. Cette méthode fonctionne différemment, et elle ne fonctionne que pour les codes CSS. L'idée est que nous n'effectuons pas réellement les mesures de syndrome sur les états quantiques encodés dans le circuit que nous essayons d'exécuter, mais que nous propageons intentionnellement les erreurs à un système d'espace de travail, puis mesurons ce système et détectons les erreurs de façon classique. Les diagrammes de circuits suivants illustrent comment cela peut être fait pour détecter les erreurs $X$ et $Z$, respectivement.

Une méthode connexe connue sous le nom de correction d'erreurs de Knill étend cette méthode aux codes stabilisateurs arbitraires en utilisant la téléportation.