Introduction à la correction des erreurs quantiques

Cet article explique les principes de base de la correction des erreurs quantiques, les types d’erreurs quantiques et certains codes courants de correction des erreurs quantiques. Il fournit également un exemple de correction des erreurs à l’aide du code à trois qubits.

Qu’est-ce que la correction des erreurs quantiques ?

La correction des erreurs quantiques (QEC) est une technique qui nous permet de protéger les informations quantiques contre les erreurs. La correction des erreurs est particulièrement importante dans les ordinateurs quantiques, car les algorithmes quantiques efficaces utilisent des ordinateurs quantiques à grande échelle, qui sont sensibles au bruit.

Le principe de base de la correction des erreurs quantiques est que le nombre de bits utilisés pour encoder une quantité donnée d’informations est augmenté. Cette redondance permet au code de détecter et de corriger les erreurs.

Les taux d’erreur des ordinateurs quantiques sont généralement plus élevés que les erreurs de l’ordinateur classique en raison des défis liés à la création et à l’exploitation de systèmes quantiques. Le bruit, la décohence et les imperfections dans les portes quantiques peuvent provoquer des erreurs dans les calculs quantiques. Les ordinateurs quantiques actuels ont des taux d’erreur compris entre 1 % et 0,1 %. En d’autres termes, cela signifie qu’en moyenne, une opération de porte quantique sur 100 à 1 000 entraîne une erreur.

Types d’erreurs quantiques

Il existe deux types fondamentaux d’erreurs quantiques : les retournements de bits et les retournements de phase.

Les erreurs de retournement de bits se produisent lorsqu’un qubit passe ou $\ket{0}$ $\ket{1}$ inversement. Les erreurs de basculement de bits sont également appelées \sigma_x-errors, car elles mappent les états $qubits \sigma_x \ket{0}{1}$\ket{=et $\sigma_x=\ket{0}${1}\ket{.$$ Cette erreur est analogue à une erreur classique de retournement de bits.

Les erreurs de retourne de phase se produisent lorsqu’un qubit change sa phase. Ils sont également appelés \sigma_z-erreurs, car ils mappent les états $qubit \sigma_z\ket{\ket{0}{0}$= et $\sigma_z{1}\ket{= -.\ket{1}$$$ Ce type d’erreur n’a pas d’analogie classique.

Dans l’informatique quantique, les erreurs quantiques peuvent se manifester sous forme de retournements de bits, de retournes de phase ou d’une combinaison des deux.

Comment fonctionne la correction des erreurs quantiques ?

Les codes de correction d’erreur quantique fonctionnent en encodant les informations quantiques dans un plus grand ensemble de qubits, appelés qubits physiques. L’état conjoint des qubits physiques représente un qubit logique.

Les qubits physiques sont soumis à des erreurs en raison de la décohérence et des imperfections dans les portes quantiques. Le code est conçu afin que les erreurs puissent être détectées et corrigées en mesurant certains qubits du code.

Par exemple, imaginez que vous souhaitez envoyer le message $\ket{0}$à qubit unique. Vous pouvez utiliser trois qubits physiques pour encoder le message, en envoyant$\ket{000}$, ce qui est appelé codeword. Ce code de correction d’erreur est un code de répétition, car le message est répété trois fois.

À présent, imaginez qu’une erreur de basculement binaire unique se produit pendant la transmission afin que ce que le destinataire reçoit est l’état $\ket{010}$. Dans ce scénario, le destinataire peut être en mesure de déduire que le message prévu est $\ket{000}$. Toutefois, si le message est soumis à deux erreurs de basculement de bits, le destinataire peut déduire un message incorrect. Enfin, si les trois bits sont retournés afin que le message $\ket{000}$ d’origine devienne $\ket{111}$, le destinataire n’a aucun moyen de connaître une erreur s’est produite.

La distance de code d’un code QEC est le nombre minimal d’erreurs qui modifient un mot de code en un autre, autrement dit le nombre d’erreurs qui ne peuvent pas être détectées. La distance $de code d$ peut être définie en tant que

$$d = 2t + 1$$

où $t’est$ le nombre d’erreurs que le code peut corriger. Par exemple, le code à trois bits peut détecter et corriger une erreur de retournement de bits, donc $t = 1$, et donc la distance de code est $d = 3$.

Notez que les codes de répétition, tels que le code trois bits utilisé dans cet exemple, ne peuvent corriger que les erreurs de retournement de bits, et non les erreurs de retour de phase. Pour corriger les deux types d’erreurs, des codes de correction d’erreurs quantiques plus sophistiqués sont nécessaires.

Types de codes QEC

Il existe de nombreux types de codes QEC différents, chacun avec ses propres propriétés et avantages. Voici quelques codes QEC courants :

• Code de répétition : code de correction d’erreur quantique le plus simple, où un qubit unique est encodé en plusieurs qubits en le répétant plusieurs fois. Le code de répétition peut corriger les erreurs de retournement de bits, mais pas les erreurs de retournement de phase.

• Code Shor : le premier code de correction d’erreur quantique, développé par Peter Shor. Il encode un qubit logique en neuf qubits physiques. Le code Shor peut corriger une erreur de retournement un bit ou une erreur de retournement de phase, mais il ne peut pas corriger les deux types d’erreurs en même temps.

• Code Steane : il s’agit d’un code de sept qubits qui peut corriger les erreurs de retournement de bits et de phase. Il présente l’avantage d’être tolérant aux erreurs, ce qui signifie que le processus de correction des erreurs lui-même n’introduit pas d’erreurs supplémentaires.

• Code surface : il s’agit d’un code de correction d’erreur topologique qui utilise un treillis bidimensionnel de qubits pour encoder des qubits logiques. Il a un seuil de correction d’erreur élevé et est considéré comme l’une des techniques les plus prometteuses pour l’informatique quantique à tolérance de panne à grande échelle. Le code de surface est utilisé par l’estimateur de ressources Azure Quantum.

• Code Hastings-Haah : ce code de correction d’erreur quantique offre de meilleurs coûts d’espace-temps que les codes de surface sur les qubits Majorana dans de nombreux régimes. Pour les jeux d’instructions basés sur la porte, la surcharge est plus grande, ce qui rend cette approche moins efficace que le code surface.

Exemple : code à trois qubits

Le code de correction d’erreur à trois qubits est un code de répétition simple qui peut détecter et corriger une erreur de retournement de bit. Il encode un qubit logique unique en trois qubits physiques en répétant le qubit trois fois.

Imaginez que vous souhaitez envoyer un qubit $\ket{\phi}=\alpha\ket{{0} unique arbitraire + . \beta\ket{1}$ Pour éviter les erreurs, vous encoderez les états $\ket{0}$ de base et $\ket{1}$ dans un état conjoint de trois qubits. Les deux états de base logique sont $\ket{0_L}=\ket{000}$ et $\ket{1_L.}=\ket{111}$

Par conséquent, le qubit $\ket{\phi}={0}\alpha\ket{unique + \beta\ket{1}$ est encodé comme suit :

$$\ket{\phi}{000}\ket{\alpha=_L + \beta\ket{\ket{\alpha{111}=0_L} + 1_L \beta\ket{}$$

Nous allons décomposer les étapes du code à trois qubits.

Préparation des qubits

Tout d’abord, vous encodez votre qubit $\ket{\phi}=\alpha\ket{{0} unique +\beta\ket{1}$ dans un état commun de trois qubits.

Ensuite, vous préparez deux qubits supplémentaires dans l’état $\ket{0}$. Ainsi, l’état global des trois qubits est $(\alpha\ket{0} +\beta\ket{1})\ket{0}\ket{0}=\alpha\ket{{000} + \beta\ket{{100}$.

Enfin, vous encodez le qubit unique dans un état conjoint de trois qubits, en appliquant deux opérations CNOT. Le premier CNOT utilise le premier qubit comme contrôle et agit sur le deuxième qubit, produisant $\alpha\ket{000} + \beta\ket{110}$. Le deuxième CNOT utilise le premier qubit comme contrôle et agit sur le troisième qubit. L’état des trois qubits est maintenant $\alpha\ket{000} + \beta\ket{111}$.

Envoi des qubits

Vous envoyez les trois qubits. En supposant que seules des erreurs de retournement un bit peuvent se produire, les qubits reçus se trouvent dans l’un des états suivants :

Ajout de qubits auxiliaires

Tout d’abord, vous introduisez deux qubits supplémentaires, préparés dans l’état $\ket{00}$. Cette paire auxiliaire de qubits est utilisée pour extraire des informations de l’erreur sans mesurer ou obtenir directement des informations sur l’état logique.

Ensuite, vous effectuez quatre opérations CNOT : les deux premières opérations utilisent les qubits du premier et du deuxième reçu comme contrôle et agissent sur le premier qubit auxiliaire, et les deux dernières opérations utilisent les qubits du premier et du troisième reçu comme contrôle et agissent sur le deuxième bit auxiliaire. L’état total des cinq qubits est maintenant :

Récupération du syndrome d’erreur

Pour récupérer les informations d’erreur, vous mesurez les deux qubits auxiliaires dans les états $\ket{0}$ de base de calcul et $\ket{1}$. En procédant ainsi, vous récupérez l’état de l’articulation, qui est appelé syndrome d’erreur, car il aide à diagnostiquer les erreurs dans les qubits reçus.

Maintenant, vous savez quels états possibles les trois qubits reçus sont en. Vous pouvez corriger l’erreur en appliquant l’opération de correction. Dans ce cas, vous traitez d’erreurs de retournement de bits. Par conséquent, la correction est une $opération \sigma_x$ appliquée à un (ou aucun) des qubits.

Par exemple, si le syndrome d’erreur est $\ket{00}$, alors les qubits reçus sont dans l’état $\alpha{000}\ket{+ \beta\ket{{111}$, qui est l’état que vous avez envoyé à l’origine. Si le syndrome d’erreur est $\ket{11}$, les qubits reçus sont dans l’état $\alpha{100}\ket{+ b.\ket{{011}$ Il existe une erreur de basculement de bit sur le premier qubit, que vous pouvez corriger en appliquant une $opération \sigma_x$ au premier qubit.

Extraction du qubit d’origine

Enfin, pour extraire le qubit unique que vous souhaitez transmettre à l’origine, vous appliquez deux opérations CNOT : l’une utilise le premier qubit comme contrôle et agit sur le deuxième qubit, et d’autres utilisent le premier qubit comme contrôle et agit sur le troisième.

L’état du premier qubit est maintenant $\alpha\ket{0} + \beta\ket{1}$, qui est le qubit d’origine que vous souhaitez transmettre.