Pour la première fois, des Chercheurs ont démontré que l’ajout de plus de « Qubits » à un Ordinateur Quantique, peut le rendre plus résilient (Résilient : Il peut conserver les « Qubits » dans l’état de superposition pendant une longue période). C’est une étape essentielle sur le long chemin vers des Applications pratiques.
Comment construire une Machine « Parfaite » à partir de pièces imparfaites ?
C’est le Principal défi auquel sont confrontés les Chercheurs qui construisent des Ordinateurs Quantiques. Le problème est que leurs éléments constitutifs élémentaires, appelés « Qubits », sont extrêmement sensibles aux perturbations du monde extérieur. Les Prototypes d’Ordinateurs Quantiques d’aujourd’hui, sont trop sujets aux erreurs pour faire quoi que ce soit d’utile.
Dans les années 90, les Chercheurs ont élaboré sur les bases théoriques d’un moyen de surmonter ces erreurs, appelé Correction d’erreur Quantique. L’idée clé était d’amener un groupe de « Qubits Physiques » à fonctionner ensemble comme un seul « Qubit Logique » de haute qualité. L’Ordinateur utiliserait alors plusieurs de ces « Qubits Logiques » pour effectuer des calculs.
Cette Alchimie informatique a ses limites. Si les « Qubits Physiques » sont trop sujets aux pannes, la correction des erreurs et contreproductive : l’ajout de « Qubits Physiques » supplémentaires aggravera les « Qubits Logiques », au lieu de les améliorer. Mais si le taux d’erreur descend en dessous du seuil spécifique, la balance penche (plus vous allez ajouter des « Qubits Physiques », plus chaque « Qubit Logique » devient résilient).
Aujourd’hui, ils ont transformé un groupe de « Qubits Physiques » en un seul « Qubit Logique », puis ont montré qu’à mesure qu’ils ajoutaient davantage de « Qubits Physiques » au groupe, le taux d’erreur du « Qubit Logique » diminuait fortement.
Règles de la Majorité :
La version la plus simple de la Correction d’erreurs fonctionne sur des « Ordinateurs classiques » ordinaires, qui représentent les informations sous forme de Chaine de bits, ou de 0 et 1. Tout problème aléatoire qui inverse la valeur d’un bit, provoquera une erreur.
Vous pouvez vous prémunir contre les erreurs en répartissant les informations sur plusieurs bits. L’approche la plus basique consiste à réécrire chaque 0 en 000 et chaque 1 en 111.
Chaque fois que les trois bits d’un groupe n’ont pas tous la même valeur, vous saurez qu’une erreur s’est produite en un vote majoritaire corrigera le problème.
Seulement la Procédure ne fonctionne pas toujours. Si deux bits d’un triplet souffrent simultanément d’erreurs, le vote majoritaire renverra la mauvaise réponse.
Pour éviter cela, vous pouvez augmenter le nombre de bits dans chaque groupe. Une version de cinq bits de ce « Code de Répétition » par exemple, peut tolérer deux erreurs par groupe. Mais même si ce code plus volumineux peut gérer davantage d’erreurs, vous avez également introduit davantage de risques de problèmes. L’effet net n’est bénéfique que si le taux d’erreur de chaque bit individuel est inférieur à un seuil spécifique. Si ce n’est pas le cas, l’ajout de bits supplémentaires ne fait qu’aggraver votre problème d’erreur.
Comme toujours, dans le monde Quantique, la situation est plus délicate. Les « Qubits » sont sujets à plus de types d’erreurs que leurs cousins classiques. Il est également beaucoup plus difficile de les manipuler. Chaque étape d’un calcul Quantique est une autre source d’erreur, comme la Procédure de Correction d’erreur elle-même. De plus, il n’existe aucun moyen de mesurer l’état d’un « Qubit » sans le perturber de manière irréversible : vous devez, d’une manière ou d’une autre diagnostiquer les erreurs sans jamais les observer directement. Tout cela signifie que les informations Quantiques doivent être traitées avec extrême prudence.
Au début, de nombreux Chercheurs pensaient que la Correction des erreurs Quantiques serait possible. Ils se sont révélés faux au milieu des années 90, lorsque des Chercheurs ont mis au point des exemples simples de code de Correction d’erreurs Quantiques. Mais cela n’a fait que changer le pronostic de désespéré à intimidant.
Lorsque les Chercheurs ont peaufiné les détails, ils ont réalisés qu’ils devraient obtenir un taux d’erreur pour chaque opération sur des « Qubits Physiques » inférieur à 0,01%. Seulement une sur 10 000 pourrait se tromper. Et cela les amènerait simplement au seuil. Il faudrait en fait aller bien au-delà de cela. Autrement, les taux d’erreurs des « Qubits Logiques » diminueraient extrêmement lentement à mesure que davantage de « Qubits Physiques » seraient ajoutés, et la Correction des erreur ne fonctionnerait jamais dans la pratique.
Personne ne savait comment créer un « Qubit » assez bon. Mais il s’est avéré que ces premiers codes n’ont fait qu’effleurer la surface de ce qui est possible.
Le Code des Surfaces :
En 1995, le Physicien Russe, Alexei Kitaev a entendu parler d’une avancée théorique majeur dans le domaine de l’informatique Quantique. l’année précédente, le Mathématicien appliqué Américain, Peter Shor, avait conçu un Algorithme Quantique permettant de décomposer de grands nombres en facteurs premiers.
Kitaev, n’a pas pu mettre la main sur une copie de l’article de Shor, alors il a élaboré sa propre version de l’Algorithme à partir de zéro. Une version qui s’est avérée plus polyvalente que celle de Shor. John Preskill, était enthousiasmé par le résultat et a invité Kitaev à rendre visite à son groupe à Caltech.
Cette brève visite, au Printemps 1997, a été extraordinairement productive. Kitaev a parlé à Preskill de deux nouvelles idées qu’il poursuivait : une approche « Topologique » de l’Informatique Quantique qui ne nécessiterait pas du tout de Correction d’erreur Quantique basé sur des mathématiques similaires. Au début, il ne pensait pas que le code serait utile pour les calculs Quantiques. Preskill, était optimiste et a convaincu Kitaev qu’une légère variation de son idée originale méritait d’être poursuivie.
Cette variation, appelée « Code de Surface », est basée sur deux Grilles de « Qubits Physiques » qui se chevauchent. Ceux de la première Grille sont des « Qubits de Données ». Ceux-ci codent collectivement pour un seul « Qubit Logique ». Ceux du second, sont des « Qubits de Mesure ». Ceux-ci permettent aux Chercheurs de détecter les erreurs indirectement, sans perturber le calcul.
Cela fait beaucoup de « Qubits ». Mais le « Code de Surface » présente d’autres avantages. Son système de Vérification des erreurs est beaucoup plus simple que celui des « Codes Quantiques » concurrents. Cela implique également uniquement des interactions entre « Qubits » voisins (une fonctionnalités que Preskill a trouvée si attrayante).
Dans les années qui ont suivi, Kitaev, Preskill et une poignée de collègues ont peaufinés les détails du « Code de Surface ». En 2006, deux Chercheurs ont montré qu’une version optimisée du code présentait un seuil d’environ 1% soit 100 fois supérieur aux seuils des « Codes Quantiques » antérieurs. Ces taux d’erreur étaient encore hors de portée pour les « Qubits » rudimentaires du milieu des années 2000, mais ils ne semblaient plus si inaccessibles.
Malgré ces progrès, l’intérêt pour le « Code de Surface » est resté confiné à une petite communauté de Théoriciens (des personnes qui ne travaillent par avec les « Qubits » en laboratoire). Leurs articles utilisaient un cadre mathématique abstrait étranger aux expérimentateurs actuels.
En 2008, un Théoricien nommé Austin Fowler a décidé de changer cela en faisant la promotion des avantages du « Code de Surface » auprès des expérimentateurs à travers les États-unis. Après quatre ans, il trouve un public réceptif dans le groupe de Santa Barbara dirigé par John Martinis. Fowler, Martinis et deux autres Chercheurs ont rédigé un article de 50 pages décrivant une implémentation pratique du « Code de Surface ». Ils ont estimé, qu’avec une ingénierie suffisamment intelligente, ils pourraient réduire les taux d’erreur de leurs « Qubits Physiques » de 0,1%, bien de dessous du seuil du « Code de Surface ». Ensuite, en principe, ils pourraient augmenter la taille de la Grille pour réduire le taux d’erreur des « Qubits Logiques » à un niveau arbitrairement bas. Il s’agissait d’un modèle pour un Ordinateur Quantique à grande échelle.
Bien sûr, en construire un, ne serait pas facile. Des estimations superficielles suggèrent qu’une application pratique de l’Algorithme de factorisation de Shor, nécessiterait des milliards d’opérations. Une erreur non corrigée gâcherait le tout. En raison de cette contrainte, ils devaient réduire le taux d’erreur de chaque « Qubit Logique » bien de dessous de, un sur mille milliards. Pour cela, ils auraient besoin d’une immense Grille de « Qubits Physiques ». Les premières estimations du groupe de Santa Barbara suggéraient que chaque « Qubit Logique » pourrait nécessiter des milliers de « Qubits Physiques ».
Mais Martinis, et ses collègues ont continué malgré tout, en publiant une expérience de démonstration de principe, utilisant cinq « Qubits » en 2014. Le résultat a attiré l’attention d’un cadre de Google, qui a rapidement recruté martinis pour diriger une étude interne. Avant d’essayer de gérer des milliers de « Qubits » à la fois, ils devraient faire fonctionne le « Code de Surface » à plus petite échelle. Il faudrait une décennie de travail expérimental minutieux pour y parvenir.
Franchir le Seuil :
Lorsque vous mettez en pratique la Théorie de l’Informatique Quantique, la première étape est peut-être la plus importante : Quel va être le matériel que vous allez utiliser ?
De nombreux systèmes physiques différents peuvent servir de « Qubits », et chacun présente des forces et des faiblesses différentes. Martinis et se collègues se sont spécialisées dans les « Qubits » dits « Supraconducteurs », qui sont de minuscules circuits électriques constitués de métal Supraconducteur sur des Puces de Silicium. Une seule Puce peut héberger de nombreux « Qubits » disposés dans une Grille (c’est la disposition qu’exige le « Code de Surface »).
L’équipe Google Quantum AI, a passé des années a améliorer ses Procédures de Conception et de Fabrication de « Qubits », en passant d’une poignée de « Qubits » à des dizaines et en perfectionnant sa capacité à manipuler plusieurs « Qubits » à la fois. En 2001, ils étaient enfin prêts à essayer pour la première fois la Correction d’erreurs avec le « Code de Surface ». Ils savaient qu’ils pouvaient créer des « Qubits Physiques » individuels avec des taux d’erreur inférieurs au Seuil du « Code de Surface ». Mais il devait voir si ces « Qubits » pouvaient fonctionner ensemble pour créer un « Qubit Logique » meilleur que la somme de ses parties. Plus précisément, ils devaient montrer qu’à mesure qu’ils agrandissaient le code (en utilisant une plus grande partie de la Grille de « Qubits Physiques » pour code le « Qubit Logique »), le taux d’erreur diminuerait.
Ils ont commencé avec le « Code de Surface » le plus petit possible « Distance 3 » qui utilise une Grille de « 3×3 » de « Qubits Physiques » pour coder un « Qubit Logique » (plus huit autres « Qubits » pour la mesure, pour un total de 17). Ensuite, ils ont franchi une étape supplémentaire, jusqu’à un « Code de Surface » de « Distance 5 », qui compte 49 « Qubits » au total (seules les « Distances » de Code Impaires sont utiles).
Dans un article de 2023, l’équipe a signalé que le taux d’erreur du code de « Distance 5 » était légèrement inférieur à celui du code de « Distance 3 ». C’était un résultat encourageant, mais peu concluant : Ils ne pouvaient pas encore crier victoire. Et d’un point de vue pratique, si chaque augmentation ne réduit que légèrement le taux d’erreur, la mise à l’échelle ne sera pas réalisable. pour progresser, ils auraient besoin de meilleurs « Qubits ».
L’équipe a consacré le reste de l’année 2023 à une autre série d’améliorations matérielles. Début 2024, ils devaient tester une toute nouvelle Puce de 72 « Qubits », nommée Willow. Ils ont passé quelques semaines à mettre en place tout l’équipement nécessaire pour mesurer et manipuler les « Subits ». Puis en février, ils ont commencé à collecter des données. Une douzaine de Chercheurs se sont rassemblés dans une salle de conférence pour assister aux premiers résultats.
Puis un graphique est apparu à l’écran. Le taux d’erreur à « Distance 5 » n’était pas légèrement inférieur à celui du code à « Distance 3 ». C’était en baisse de 40%. Au cours des mois suivants, l’équipe a amélioré le chiffre à 50% : une augmentation de la « Distance » de code a réduit de moitié le taux d’erreur du « Qubit Logique ».
L’équipe voulait également voir ce qui se passerait lorsqu’elle continuerait à se développer. Mais un code de « Distance 7 » aurait besoin de 87 « Qubits » au total, soit plus que le nombre total sur leur Puce. En août, un nouveau lot de Puces « Willow » de 105 « Qubits » est sorti, mais à ce moment-là, l’équipe approchait d’une date limite stricte : le cycle de test pour la prochaine série d’Amélioration de Conception était sur le point de commencer. Kevin Satzinger a commencé à accepter l’idée, qu’ils n’auraient pas le temps de mener ces dernières expériences.
La veille de la date limite, deux nouveaux membres de l’équipe, Gabrielle Roberts et Alec Eickbusch, sont resté éveillés jusqu’à 3 heures du matin pour que tout puisse fonctionner suffisamment bien et pouvoir collecter des données. Lorsque le groupe est revenu le lendemain matin, ils ont constaté que le passage d’une « Distance 5 » à une « Distance 7 » avait encore une fois réduit de moitié le taux d’erreur du « Qubit Logique ». Ce type de mise à l’échelle exponentielle, où le taux d’erreur diminue du même facteur à chaque augmentation de la « Distance » du code, est précisément ce que prédit la théorie. C’était un signe sans ambiguïté qu’ils avaient réduit les taux d’erreur des « Qubits Physiques » bien en dessous du Seuil du « Code de Surface ».
Le long chemin à parcourir :
Le résultat a également enthousiasmé d’autres Chercheurs en Informatique Quantique.
Dans le même temps, les Chercheurs reconnaissent qu’ils leur restent encore un long chemin à parcourir. L’équipe de Google Quantum AI n’a démontré la « Correction d’Erreurs » qu’à l’aide d’un seul « Qubit Logique ». l’ajout d’interactions entre plusieurs « Qubits Logique » introduira de nouveaux défis expérimentaux.
Ensuite, il y a la question de la mise à l’échelle. pour que les taux d’erreur soient suffisamment bas pour permettre des calculs Quantiques utiles, les Chercheurs devront encore améliorer leurs « Qubits Physiques » ils devront également créer des « Qubits Logiques » à partir de quelque chose de beaucoup moins grand qu’un code de « Distance 7 ». Enfin, ils devront combiner des milliers de ces « Qubits Logiques », soit plus d’un million de « Qubits Physiques ».
Pendant ce temps, d’autres Chercheurs ont réalisé des progrès impressionnants en utilisant différentes technologies de « Qubits », même s’ils n’ont pas encore montré qu’ils pouvaient réduire les taux d’erreurs en les augmentant. Ces technologies alternatives, pourraient avoir plus de facilité à mettre en oeuvre de nouveaux codes de Correction d’Erreur qui nécessitent moins de « Qubits Physiques ». l’Informatique Quantique en est encore à ses balbutiements. il est trop tôt pour dire quelle approche l’emportera.
John Martinis, qui a quitté Google Quantum AI en 2020, reste optimiste malgré les nombreux défis.
« J’ai vécu le passage d’une poignée de Transistors à des milliards » a-t-il déclaré. « avec suffisamment de temps, si nous sommes assez intelligents, nous pourrions le faire ».