Suppression des erreurs quantiques en mettant à l’échelle un qubit logique de code de floor – Google AI Weblog

Dans de nombreuses années, les scientifiques pourront utiliser des ordinateurs quantiques tolérants aux pannes pour des calculs à grande échelle avec des purposes scientifiques et industrielles. Ces ordinateurs quantiques seront beaucoup plus gros qu’aujourd’hui, composés de thousands and thousands de bits quantiques cohérents, ou qubits. Mais il y a un hic : ces blocs de development de base doivent être suffisamment bons, sinon les systèmes seront submergés d’erreurs.

Actuellement, les taux d’erreur des qubits sur notre 3ème génération Sycomore processeur se situent généralement entre 1 sur 10 000 et 1 sur 100. notre travail et que d’autres, nous comprenons que le développement d’ordinateurs quantiques à grande échelle nécessitera des taux d’erreur beaucoup plus faibles. Nous aurons besoin de taux de l’ordre de 1 sur 10⁹ à 1 sur 10⁶ pour exécuter des circuits quantiques capables de résoudre des problèmes industriels pertinents.

Alors, remark y arriver, sachant qu’il est peu possible d’obtenir trois à six ordres de grandeur de meilleures performances de nos qubits physiques actuels ? Notre équipe a créé une feuille de route qui a orienté nos recherches au cours des dernières années, améliorant progressivement les performances de nos ordinateurs quantiques vers un ordinateur quantique tolérant aux pannes.

Feuille de route pour la development d’un ordinateur quantique à correction d’erreurs utile avec des étapes clés. Nous construisons actuellement un qubit logique que nous ferons évoluer à l’avenir.

Aujourd’hui dans « Suppression des erreurs quantiques en mettant à l’échelle un qubit logique de code de floor« , Publié dans Nature, nous annonçons que nous avons franchi la deuxième étape de notre feuille de route. Nos résultats expérimentaux démontrent un prototype de l’unité de base d’un ordinateur quantique à correction d’erreur connu sous le nom de qubit logiqueavec des performances proches du régime qui permet l’informatique quantique évolutive et tolérante aux pannes.

Des qubits physiques aux qubits logiques

Correction d’erreur quantique (QEC) représente un changement significatif par rapport à l’informatique quantique d’aujourd’hui, où chaque qubit physique sur le processeur agit comme une unité de calcul. Il fournit la recette pour atteindre de faibles erreurs en échangeant de nombreux bien qubits pour un glorious un : les informations sont encodées sur plusieurs qubits physiques pour construire un seul qubit logique qui est plus résilient et succesful d’exécuter des algorithmes quantiques à grande échelle. Dans les bonnes situations, plus il y a de qubits physiques utilisés pour construire un qubit logique, meilleur est ce qubit logique.

Cependant, cela ne fonctionnera pas si les erreurs supplémentaires de chaque qubit physique supplémentaire l’emportent sur les avantages de QEC. Jusqu’à présent, les taux d’erreurs physiques élevés l’ont toujours emporté.

Pour cela, nous utilisons un code correcteur d’erreurs particulier appelé code floor et montrer pour la première fois que l’augmentation de la taille du code diminue le taux d’erreur du qubit logique. Une première pour une plate-forme d’informatique quantique, cela a été réalisé en atténuant minutieusement de nombreuses sources d’erreur alors que nous sommes passés de 17 à 49 qubits physiques. Ce travail est la preuve qu’avec suffisamment de soin, nous pouvons produire les qubits logiques nécessaires à un ordinateur quantique à grande échelle avec correction d’erreurs.

Correction d’erreur quantique avec codes de floor

Remark un code correcteur d’erreurs protège-t-il les informations ? Prenons un exemple easy de la communication classique : Bob veut envoyer à Alice un seul bit qui lit « 1 » sur un canal de communication bruyant. Reconnaissant que le message est perdu si le bit passe à « 0 », Bob envoie à la place trois bits : « 111 ». Si l’on retourne par erreur, Alice pourrait prendre un vote majoritaire (un easy code de correction d’erreur) de tous les bits reçus et toujours comprendre le message prévu. Répéter l’data plus de trois fois – en augmentant la « taille » du code – permettrait au code de tolérer plus d’erreurs individuelles.

De nombreux qubits physiques sur un processeur quantique agissant comme un qubit logique dans un code de correction d’erreur appelé a code superficiel.

Un code de floor reprend ce principe et think about une implémentation quantique pratique. Il doit satisfaire deux contraintes supplémentaires. Premièrement, le code de floor doit être succesful de corriger non seulement les retournements de bits, en prenant un qubit de |0⟩ pour |1⟩mais aussi part retourne. Cette erreur est propre aux états quantiques et transforme un qubit en un superposition indiquer, par exemple de « |0⟩ + |1⟩ » pour « |0⟩ – |1⟩”. Deuxièmement, vérifier les états des qubits détruirait leurs superpositions, il faut donc un moyen de détecter les erreurs sans mesurer directement les états.

Pour répondre à ces contraintes, nous organisons deux sorts de qubits sur un damier. Les qubits de « données » sur les sommets constituent le qubit logique, tandis que les qubits de « mesure » ​​au centre de chaque carré sont utilisés pour les soi-disant « mesures de stabilisation ». Ces mesures nous indiquent si les qubits sont tous identiques, comme souhaité ou différents, signalant qu’une erreur s’est produite, sans réellement révéler la valeur des qubits de données individuels.

Nous assemblons deux sorts de mesures de stabilisateur dans un motif en damier pour protéger les données logiques des retournements de bit et de part. Si certaines des mesures du stabilisateur enregistrent une erreur, des corrélations dans les mesures du stabilisateur sont utilisées pour identifier quelle(s) erreur(s) s’est produite et où.

Code de floor QEC. Qubits de données (jaune) sont aux sommets d’un damier. Les qubits de mesure au centre de chaque carré sont utilisés pour les mesures de stabilisation (carrés bleus). Les carrés bleu foncé vérifient les erreurs de basculement de bit, tandis que les carrés bleu clair vérifient les erreurs de basculement de part. Gauche: Une erreur d’inversion de part. Les deux mesures de stabilisateur bleu clair les plus proches enregistrent l’erreur (rouge clair). Droite: Une erreur de retournement de bit. Les deux mesures de stabilisateur bleu foncé les plus proches enregistrent l’erreur (rouge foncé).

Tout comme le message de Bob à Alice dans l’exemple ci-dessus est devenu plus robuste contre les erreurs avec l’augmentation de la taille du code, un code de plus grande floor protège mieux les informations logiques qu’il contient. Le code de floor peut supporter un sure nombre d’erreurs de basculement de bit et de part, chacune égale à moins de la moitié du distanceoù la distance est le nombre de qubits de données qui couvrent le code de floor dans l’une ou l’autre dimension.

Mais voici le problème : chaque qubit physique individuel est sujet aux erreurs, donc plus il y a de qubits dans un code, plus il y a de risques d’erreurs. Nous voulons que la safety plus élevée offerte par QEC l’emporte sur les possibilités accrues d’erreurs à mesure que nous augmentons le nombre de qubits. Pour que cela se produise, les qubits physiques doivent avoir des erreurs inférieures au soi-disant «seuil de tolérance aux pannes». Pour le code de floor, ce seuil est assez bas. Si bas qu’il n’a pas été doable expérimentalement jusqu’à récemment. Nous sommes maintenant sur le level d’atteindre ce régime convoité.

Créer et contrôler des qubits physiques de haute qualité

Pour entrer dans le régime où la QEC s’améliore avec l’échelle, il a fallu améliorer chaque facet de nos ordinateurs quantiques, de la nanofabrication des qubits physiques au contrôle optimisé du système quantique complet. Ces expériences se sont déroulées sur un système de pointe de 3e génération Sycomore structure de processeur optimisée pour QEC utilisant le code de floor avec des améliorations à tous les niveaux :

• Augmentation de la rest des qubits et des durées de vie du déphasage grâce à un processus de fabrication amélioré et à une réduction du bruit environnemental à proximité du processeur quantique.
• Réduction de la diaphonie entre tous les qubits physiques pendant le fonctionnement en parallèle en optimisant la conception et la nanofabrication du circuit du processeur quantique.
• Dérive réduite et fidélité de contrôle qubit améliorée grâce à une électronique personnalisée améliorée.
• Mis en œuvre opérations de lecture et de réinitialisation plus rapides et plus fidèles par rapport aux générations précédentes du processeur Sycamore.
• Réduction des erreurs d’étalonnage en modélisant de manière approfondie le système quantique complet et en utilisant de meilleurs algorithmes d’optimisation du système.
• Développement d’étalonnages contextuels et entièrement parallèles pour minimiser la dérive et optimiser les paramètres de contrôle des circuits QEC.
• Protocoles de découplage dynamique améliorés pour protéger les qubits physiques du bruit et de la diaphonie pendant les opérations d’inactivité.

Exécution de circuits de code de floor

Avec ces mises à niveau en place, nous avons mené des expériences pour comparer le ratio (𝚲_3,5) entre le taux d’erreur logique d’un code de floor à distance 3 (ε₃) avec 17 qubits à celui d’un code de floor à distance 5 (ε₅) avec 49 qubits — 𝚲_3,5 = ε₃ / ε₅.

Comparaison de la fidélité logique (définie comme 1-ε) entre les codes de floor à distance-3 (d=3) et à distance-5 (d=5). Le code de distance-5 contient quatre preparations de distance-3 possibles, avec un exemple indiqué dans le contour rouge (gauche). Au fur et à mesure que des améliorations ont été apportées, la fidélité d = 5 a augmenté plus rapidement que celle du d = 3, dépassant finalement le code de distance-3, comme indiqué dans les factors de données en haut à droite (droite), dont la moyenne se situe légèrement à gauche de ε3 = ε5 doubler.

Les résultats de ces expériences sont présentés ci-dessus à droite. Des améliorations continues sur plusieurs mois nous ont permis de réduire les erreurs logiques des deux grilles, conduisant à la grille de distance-5 (ε₅ = 2,914 %) surpassant les grilles de distance-3 (ε₃ = 3,028 %) de 4 % (𝚲_3,5 = 1,04) avec une confiance de 5𝛔. Bien que cela puisse sembler être une petite amélioration, il est necessary de souligner que le résultat représente une première dans le domaine depuis le 1995 de Peter Shor. Proposition de la CEQ. Un code plus grand surpassant un code plus petit est une signature clé de QEC, et toutes les architectures informatiques quantiques devront franchir cet impediment pour réaliser un chemin vers les faibles erreurs nécessaires aux purposes quantiques.

La voie à suivre

Ces résultats indiquent que nous entrons dans une nouvelle ère de QEC pratique. L’équipe Google Quantum AI a passé ces dernières années à réfléchir à la manière dont nous définissons le succès dans cette nouvelle ère et dont nous mesurons les progrès en cours de route.

L’objectif ultime est de démontrer une voie pour atteindre les faibles erreurs nécessaires à l’utilisation des ordinateurs quantiques dans des purposes significatives. À cette fin, notre objectif reste d’atteindre des taux d’erreur logique de 1 sur 10⁶ ou moins par cycle de QEC. Dans la determine ci-dessous à gauche, nous décrivons le chemin que nous prévoyons pour atteindre cet objectif. Alors que nous continuons à améliorer nos qubits physiques (et donc les performances de nos qubits logiques), nous prévoyons d’augmenter progressivement 𝚲 de près de 1 dans ce travail à des nombres plus grands. La determine ci-dessous montre qu’une valeur de 𝚲 = 4 et une distance de code de 17 (577 qubits physiques avec une qualité suffisante) donneront un taux d’erreur logique inférieur à notre objectif de 1 sur 10⁶.

Bien que ce résultat soit encore dans quelques années, nous disposons d’une approach expérimentale pour sonder des taux d’erreur aussi faibles avec le matériel d’aujourd’hui, bien que dans des circonstances limitées. Alors que les codes de floor bidimensionnels nous permettent de corriger à la fois les erreurs de bit et de part, nous pouvons également construire codes de répétition unidimensionnels qui ne sont capables de résoudre qu’un seul sort d’erreur avec des exigences assouplies. Ci-dessous à droite, nous montrons qu’un code de répétition à distance de 25 peut atteindre des taux d’erreur par cycle proches de 1 sur 10⁶. À des erreurs aussi faibles, nous voyons de nouveaux sorts de mécanismes d’erreur qui ne sont pas encore observables avec nos codes de floor. En contrôlant ces mécanismes d’erreur, nous pouvons améliorer les codes de répétition à des taux d’erreur proches de 1 sur 10⁷.

Gauche: Development attendue à mesure que nous améliorons les performances (quantifiées par 𝚲) et l’échelle (quantifiée par la distance de code) pour les codes de floor. Droite: Taux d’erreurs logiques mesurés expérimentalement par cycle en fonction de la distance des codes de répétition unidimensionnels et des codes de floor bidimensionnels.

L’atteinte de cette étape reflète trois années de travail ciblé par toute l’équipe Google Quantum AI suite à notre démonstration d’un ordinateur quantique surpassant un ordinateur classique. Dans notre marche vers la development d’ordinateurs quantiques tolérants aux pannes, nous continuerons à utiliser les taux d’erreur cibles de la determine ci-dessus pour mesurer nos progrès. Avec de nouvelles améliorations vers notre prochaine étape, nous prévoyons d’entrer dans le régime de tolérance aux pannes, où nous pouvons supprimer de manière exponentielle les erreurs logiques et déverrouiller les premières purposes quantiques utiles à correction d’erreurs. En attendant, nous continuons à explorer diverses façons de résoudre des problèmes à l’aide d’ordinateurs quantiques dans des sujets allant de la physique de la matière condensée pour chimie, apprentissage automatiqueet la science des matériaux.