Simuler la nature

Regarde cette vidéo d'Olivia Lanes sur la simulation de la nature avec des ordinateurs quantiques, ou ouvre la vidéo dans une fenêtre séparée sur YouTube.

Cette leçon s'appuie sur le contenu de ce tutoriel :

Tutoriel sur l'atténuation d'erreurs à l'échelle utilitaire avec l'amplification probabiliste des erreurs

Introduction

L'une des applications les plus convaincantes des ordinateurs quantiques est leur capacité à simuler des phénomènes naturels. Dans cette leçon, nous allons explorer comment les ordinateurs quantiques sont utilisés pour résoudre des problèmes de dynamique quantique — en particulier, comment ils nous aident à comprendre l'évolution temporelle d'un système quantique.

Nous commencerons par un tour d'horizon des étapes générales d'une simulation de ce type. Ensuite, nous examinerons un exemple concret : l'expérience présentée par IBM en 2023, qui a illustré le concept d'utilité quantique. Cette expérience constitue une excellente étude de cas pour comprendre les étapes pratiques et les implications de la simulation de la dynamique quantique sur du matériel quantique réel. À la fin, tu auras une image plus claire de la manière dont les chercheurs abordent ces défis et des raisons pour lesquelles la simulation quantique est si prometteuse pour faire avancer notre compréhension du monde naturel.

Richard Feynman a donné une conférence très influente à Caltech en 1959. Elle s'intitulait fameusement « There's Plenty of Room at the Bottom » (Il y a de la place en bas), en allusion plaisante aux vastes possibilités encore inexplorées à l'échelle microscopique. Feynman soutenait qu'une grande partie de la physique aux niveaux atomique et subatomique restait encore à découvrir.

L'importance de cette conférence s'est accrue dans les années 1980, à mesure que la technologie progressait. À cette période, Feynman a revisité ces idées lors d'une autre conférence importante à Caltech, en présentant un article intitulé « Simulating Physics with Computers » (Simuler la physique avec des ordinateurs). Il y posait une question audacieuse : pourrait-on utiliser des ordinateurs pour effectuer des simulations exactes reproduisant le comportement de la nature au niveau quantique ? Feynman suggérait qu'au lieu de se fier à des approximations grossières pour modéliser les processus atomiques, nous pourrions utiliser des ordinateurs qui exploitent eux-mêmes les lois de la mécanique quantique — non pas simplement pour modéliser la nature, mais pour l'émuler.

C'est ce type de simulation physique que nous allons examiner au fil de cette leçon.

Rappelle-toi ce graphique de chronologie introduit dans un épisode précédent. À un bout du spectre, on trouve des problèmes faciles à résoudre qui ne nécessitent pas la vitesse accrue qu'apporterait l'informatique quantique.

À l'autre extrémité se trouvent des problèmes extrêmement difficiles qui exigent des machines quantiques entièrement tolérantes aux pannes — une technologie qui n'est pas encore disponible. Heureusement, on pense que de nombreux problèmes de simulation se situent quelque part au milieu de cette ligne temporelle, dans la plage où les ordinateurs quantiques actuels peuvent déjà être efficacement appliqués. Il y a de nombreuses raisons d'être enthousiasmé et intrigué par cette perspective, car simuler la nature constitue le fondement d'un large éventail d'applications prometteuses.

Les informations suivantes couvrent le flux de travail général dans les simulations de la nature, puis un exemple spécifique de ce flux de travail pour reproduire les résultats d'une étude bien connue.

Flux de travail général

Avant de pouvoir appliquer l'informatique quantique à ces domaines passionnants, il est important de comprendre d'abord les étapes de base d'un flux de travail de simulation typique :

1. Identifier le Hamiltonien du système
2. Encodage du Hamiltonien
3. Préparation de l'état
4. Évolution temporelle de l'état
5. Optimisation du circuit
6. Exécution du circuit
7. Post-traitement

Le processus commence par l'identification d'un système quantique d'intérêt. Cela permet de déterminer le Hamiltonien qui régit son évolution temporelle, ainsi qu'une description pertinente de ses propriétés initiales, ou son état. Ensuite, tu dois choisir une méthode appropriée pour implémenter l'évolution temporelle de cet état. Note que les quatre premières étapes de ce flux de travail font toutes partie de l'étape de Mapping (mise en correspondance) du cadre Qiskit patterns.

Après avoir configuré le circuit d'évolution temporelle, les étapes suivantes consistent à réaliser l'expérience proprement dite. Cela comprend généralement l'optimisation du circuit quantique qui implémente l'algorithme d'évolution temporelle, l'exécution du circuit sur du matériel quantique, et le post-traitement des résultats. Ces étapes correspondent aux trois dernières étapes du cadre Qiskit patterns.

Ensuite, nous allons expliquer ce que signifient ces étapes avant de passer au code.

1. Identifier le Hamiltonien du système

La première étape essentielle pour réaliser une expérience de simulation est d'identifier le Hamiltonien qui décrit le système. Dans de nombreux cas, le Hamiltonien est bien établi. Cependant, on le construit souvent en additionnant les contributions énergétiques des sous-parties du système. Cela s'exprime généralement comme une somme de termes :

$$H=\sum_i^N {H_i}$$

où chaque terme $H_i$ agit sur l'un des $N$ sous-systèmes locaux (comme une seule particule ou un petit groupe de particules) du Hamiltonien total $H$. Dans le cas de particules élémentaires indiscernables, il est important de déterminer si le système implique des fermions ou des bosons, où les fermions obéissent au principe d'exclusion de Pauli, ce qui signifie que deux fermions identiques ne peuvent pas occuper les mêmes états quantiques, comme les électrons. Contrairement aux fermions, plusieurs bosons peuvent exister dans le même état quantique, et cette différence affecte les statistiques du système et la manière dont il doit être modélisé.

En pratique, on s'intéresse souvent à des systèmes physiques dont les éléments sont supposés bien séparés ou étiquetés, et donc discernables, comme des spins sur un réseau cristallin.

Ce système est composé de spins dipolaires magnétiques disposés sur un réseau cristallin, traités comme des particules discernables en identifiant leur adresse. Ce système est décrit par le modèle d'Ising à champ transverse, et son Hamiltonien est construit à partir de la somme de deux parties :

$$H = \sum_i^N {H_i} = J \sum_{<i,j>}Z_iZ_j + h\sum_{i=0}^N X_i$$

Où le premier terme représente l'énergie d'interaction entre les spins voisins. Ici, $<i,j>$ indique que l'on somme sur toutes les paires de spins directement connectées sur le réseau, $Z_i$ et $Z_j$ sont les matrices de Pauli-Z, qui représentent l'état des spins aux sites $i$ et $j$, et $J$ est la constante de couplage, qui définit la force de cette interaction. Le second terme représente l'influence d'un champ magnétique externe appliqué à l'ensemble du système. Ici, $X_i$ est la matrice de Pauli-X agissant sur le spin individuel au site $i$, et $h$ indique la force de ce champ externe.

2. Encodage du Hamiltonien

L'étape suivante consiste à traduire le Hamiltonien dans une forme que l'ordinateur quantique peut traiter, ce que l'on appelle l'encodage. Ce processus d'encodage dépend essentiellement du type de particules dans les systèmes : discernables ou indiscernables, et fermion ou boson si les particules sont indiscernables.

Si tu as un système avec des particules discernables, comme des spins $1/2$ fixés sur un réseau cristallin (que nous avons examiné brièvement ci-dessus), le Hamiltonien est souvent déjà écrit dans un langage compatible avec les qubits. L'opérateur de Pauli-Z, par exemple, décrit naturellement l'état haut ou bas d'un spin, et aucun encodage spécial n'est nécessaire.

Lors de la simulation de particules indiscernables de fermions ou de bosons, il est nécessaire d'appliquer une transformation d'encodage. Ces particules sont décrites dans un cadre mathématique spécial appelé seconde quantification, qui suit le nombre d'occupation de chaque état quantique en introduisant des opérateurs de création et d'annihilation, où l'opérateur de création $\hat{a}_i^\dagger$ ajoute une particule à l'état $i$ tandis que l'opérateur d'annihilation $\hat{a}_i$ retire une particule de l'état $i$. En s'appuyant sur ce cadre de seconde quantification, le fermion peut être transformé par les transformations de Bravyi-Kitaev et de Jordan-Wigner. La transformation de Jordan-Wigner définit l'opérateur de création fermionique $\hat{f}_j^\dagger = \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j + i Y_j}{2} \Bigr)$ qui remplit le $j$-ième état quantique avec un fermion, et l'opérateur d'annihilation fermionique $\hat{f}_j= \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j - i Y_j}{2} \Bigr)$ qui vide un fermion du $j$-ième état. Tu peux trouver plus de détails sur cette transformation de Jordan-Wigner dans notre Quantum Computing in Practice, épisode 5 - Mapping. De même, les bosons nécessitent également leurs propres méthodes d'encodage, comme la transformation de Holstein-Primakoff, pour être représentés par des qubits.

En définitive, que le chemin soit direct ou nécessite une traduction, l'objectif est le même : exprimer le Hamiltonien du système sous forme d'opérateurs de spin de Pauli qu'un ordinateur quantique peut comprendre et exécuter.

3. Préparation de l'état

Après avoir encodé le Hamiltonien souhaité dans l'ensemble de portes de l'ordinateur quantique, l'étape importante suivante est de choisir un état quantique initial approprié pour commencer la simulation. Le choix de l'état initial influence non seulement la convergence des algorithmes variationnels comme le Variational Quantum Eigensolver (VQE), mais affecte aussi la précision et l'efficacité de l'évolution temporelle et de l'échantillonnage. En essence, l'état initial sert de point de départ pour le calcul, posant les bases pour extraire des observables utiles du système quantique modélisé. Idéalement, cet état devrait représenter une configuration physiquement significative du système étudié.

Pour de nombreuses simulations de chimie quantique, l'état de Hartree-Fock peut être un bon point de départ. Dans le langage de la seconde quantification, l'état de Hartree-Fock ($|\phi\rangle_{HF}$) est créé en appliquant des opérateurs de création ($\hat{a}_i^\dagger$) pour chacune des orbitales de plus basse énergie à l'état du vide ($|vac\rangle = |0_1 ... 0_k ... 0_N\rangle = |0\rangle ^{\otimes N}$), un état sans électrons.

$$|\phi\rangle_{HF} = \prod\limits_{i=1}^k \hat{a}_i^\dagger |0\rangle ^{\otimes N} = \hat{a}_1^\dagger ... \hat{a}_k^\dagger |0_1 ... 0_k ... 0_N\rangle$$

De plus, un ansatz facilement préparable ayant un fort recouvrement avec le véritable état fondamental peut servir de bon état initial pour les problèmes de chimie, comme trouver l'énergie de l'état fondamental.

Plus généralement, on peut écrire un état arbitraire à $n$ qubits comme une superposition d'états de base computationnels $∣c_i\rangle$ avec des coefficients $a_i$, satisfaisant les conditions de normalisation. La préparation d'un tel état peut généralement être abordée en appliquant un opérateur spécifique $\hat{O}$ à l'état initial, qui est par convention l'état de base standard tout-zéro.

$$|\psi\rangle = \sum_{i=0}^{2^n-1}{a_i |c_i\rangle}=\hat{O}|0\rangle^{\otimes n}\\ \text{with} \qquad \sum_{i=0}^{2^n-1}{|a_i^2|}=1$$

Cependant, ce processus nécessite souvent un nombre exponentiel de portes CNOT, ce qui le rend généralement très gourmand en ressources. On se concentre souvent sur la préparation d'états initiaux dont les besoins en ressources d'implémentation sont plus modestes. Pour cette raison, on se concentre souvent sur la préparation d'états initiaux moins complexes. Un choix courant et pratique est un état produit, où les qubits ne sont pas intriqués et peut être préparé en utilisant uniquement des opérations sur un seul qubit, réduisant considérablement les besoins en ressources de la préparation d'état et la complexité. 4. Évolution temporelle de l'état

Maintenant que l'état initial est défini, on peut enfin commencer la simulation elle-même — examiner comment l'état du système $|\phi(t=0)\rangle$ évolue vers $|\phi(t)\rangle$ après un certain temps $t$. En mécanique quantique, cette évolution est décrite par une seule opération mathématique appelée l'opérateur d'évolution temporelle :

$$U(t) = e^{-iHt}$$

où nous avons posé $\hbar=1$ par convention. Appliquer cet opérateur à notre état initial nous donne l'état final : $|\phi(t)\rangle = e^{-iHt}|\phi(t=0)\rangle$

Cependant, construire un circuit quantique qui implémente directement l'opérateur complet $e^{-iHt}$ est généralement impossible lorsque notre Hamiltonien est une somme de différentes parties. Nous avons donc besoin de la Trotterisation.

En termes simples, la Trotterisation est une technique pour approximer l'exponentiation d'une matrice (ici le Hamiltonien, $H$), notamment lorsque l'exposant contient des opérateurs qui ne commutent pas ($[H_A, H_B] \neq 0$). Souvent, le Hamiltonien $H$ est composé de plusieurs opérateurs qui ne commutent pas. Dans ce cas, on ne peut pas séparer leurs exponentielles :

$$e^{-i(H_A + H_B)t} \neq e^{-iH_A t}e^{-iH_B t}$$

Une approche utile consiste à appliquer alternativement leurs exponentielles d'évolution temporelle sur de petites durées $t/n$, un total de $n$ fois. Dans le cas de ces deux contributions qui ne commutent pas, on écrirait

$$e^{−i H t}\approx \left(e^{−i H_A t/n}e^{−i H_B t/n}\right)^n$$

L'erreur introduite par cette approximation est appelée l'erreur de Trotter. On peut réduire cette erreur en augmentant $n$, mais cela a un coût. Des formules plus avancées d'ordre supérieur (le second ordre et d'autres variantes) existent également. Par exemple, la formule du second ordre offre une meilleure précision en appliquant les étapes selon un schéma symétrique.

$$\begin{aligned} \text{Premier ordre :} & \qquad e^{-iHt}\approx \left(\prod_j{e^{-iH_i t/n}}\right)^n\\ \text{Second ordre :} & \qquad e^{-iHt}\approx \left(\prod_{j=1}^N{e^{-iH_j t/2n}}\right)^n\left(\prod_{k=N}^1{e^{-iH_k t/2n}}\right)^n \end{aligned}$$

Ici, $N$ est le nombre de termes qui ne commutent pas, $H_j$, dans le Hamiltonien à décomposer de cette façon, et $n$ est le nombre de petits pas de temps en lesquels cette évolution est divisée. Remarque l'ordre inverse des opérateurs dans le second produit du traitement au second ordre.

Consulte la section sur la Trotterisation dans le cours Quantum Diagonalization Algorithms pour plus de détails. 5. Optimisation du circuit

Après avoir généré le circuit trotterisé, l'étape de mise en correspondance est terminée, et on peut passer à l'optimisation du circuit. Ce processus comprend plusieurs tâches clés :

• Établir une disposition de qubits qui met en correspondance les qubits abstraits du circuit avec les qubits physiques du matériel. Cette étape est nécessaire car l'architecture du matériel impose souvent des contraintes de connectivité spécifiques, tandis que les conceptions de circuits quantiques supposent généralement que n'importe quel qubit peut interagir avec n'importe quel autre.
• Insérer des portes SWAP selon les besoins pour permettre les interactions entre des qubits qui ne sont pas directement connectés sur l'appareil.
• Traduire les portes du circuit en instructions ISA (Instruction Set Architecture) que le matériel peut exécuter directement.
• Effectuer des optimisations de circuit pour réduire la profondeur du circuit et le nombre de portes. Cette optimisation peut également être appliquée plus tôt, sur le circuit virtuel avant que les qubits soient assignés à des connexions matérielles spécifiques.

Il est important de noter qu'une grande partie de ce processus d'optimisation est géré automatiquement par les outils de Qiskit. Nous verrons exactement comment cela fonctionne plus loin dans cette leçon.

6. Exécution du circuit

Après avoir terminé l'étape d'optimisation, nous sommes prêts à exécuter le circuit en utilisant une primitive. Nous considérons une expérience de simulation dont l'objectif est de comprendre comment certaines propriétés du système évoluent dans le temps. À cette fin, la primitive Estimator est le choix le plus approprié, car elle permet de mesurer les valeurs d'espérance des observables correspondant à ces propriétés.

Ensuite, nous utilisons des options incluant des techniques de suppression et d'atténuation des erreurs, pour améliorer la précision de l'Estimator. Enfin, nous exécutons l'expérience pour collecter les résultats.

7. Post-traitement

La dernière étape est le post-traitement des données collectées. Cela implique d'extraire les valeurs d'espérance mesurées ou, si la primitive Sampler a été utilisée, la distribution de probabilité échantillonnée dans la base computationnelle. Lorsque seules les valeurs d'espérance des observables pertinentes sont nécessaires, celles-ci peuvent être directement obtenues à partir de la primitive Estimator, disponibles à la fois sous forme de résultats bruts et avec atténuation des erreurs appliquée. Souvent, ces valeurs d'espérance mesurées servent de point de départ pour des calculs supplémentaires impliquant d'autres grandeurs d'intérêt. Ces calculs supplémentaires ne nécessitent généralement pas de calcul quantique et peuvent être effectués efficacement sur un ordinateur classique.

Reproduire l'article « Utility »

remarque

Cette partie est une présentation de haut niveau du tutoriel Atténuation d'erreurs à l'échelle utilitaire avec l'amplification probabiliste des erreurs, qui reproduit les résultats de l'article Evidence for the Utility of Quantum Computing Before Fault Tolerance. Nous te suggérons fortement d'ouvrir le tutoriel référencé en parallèle de cette session.

Nous allons maintenant examiner un exemple concret tiré d'un article très influent publié par IBM en 2023, intitulé Evidence for the Utility of Quantum Computing Before Fault Tolerance, souvent appelé l'« article sur l'utilité ».

Lors de sa publication, ce travail est rapidement devenu une étude de référence au sein de la communauté de l'informatique quantique. Sa thèse centrale est qu'un ordinateur quantique bruité, utilisant 127 qubits et 2 880 portes, peut produire des valeurs d'espérance précises pour des circuits quantiques qui dépassent les capacités des méthodes de simulation classique par force brute, lesquelles tentent une simulation exacte des mêmes circuits.

Cette étude a été particulièrement significative car elle a démontré que les ordinateurs quantiques peuvent être utilisés pour vérifier ou comparer des résultats avec des méthodes de simulation classique approximatives, telles que les algorithmes de réseau tensoriel — notamment dans des scénarios où la solution exacte n'est pas connue à l'avance.

Un autre aspect remarquable de ce travail est qu'il a été largement reproduit : les chercheurs et les utilisateurs peuvent maintenant répliquer et vérifier l'expérience en utilisant les systèmes quantiques accessibles via le cloud d'IBM et le cadre logiciel Qiskit. Dans ce qui suit, nous te guiderons à travers les étapes pour effectuer cette réplication toi-même en passant en revue le tutoriel d'IBM étape par étape.

Dans cette leçon, nous discutons des étapes spécifiques nécessaires pour traduire le problème en entrées qu'un appareil quantique peut traiter. Nous nous concentrons sur la simulation de la dynamique de la magnétisation totale dans un système de spins dipolaires magnétiques disposés sur un réseau cristallin, soumis à un champ magnétique externe. Ce système peut être décrit par un modèle d'Ising avec un champ magnétique transverse. Nous le représentons en utilisant un circuit quantique paramétré, où les paramètres correspondent aux valeurs réglables des interactions spin-spin ($ZZ$) et à la force du champ magnétique transverse externe ($B_x$, paramétré en utilisant $X$).

Comme cette série s'intitule Quantum Computing in Practice (l'informatique quantique en pratique), nous couvrirons des détails supplémentaires sur les techniques expérimentales utilisées pour améliorer la qualité des résultats. Une procédure importante consiste à identifier et supprimer les « mauvais » qubits — ceux dont les fidélités de portes sont faibles ou les temps de décohérence courts — qui pourraient avoir un impact significatif sur le résultat de l'expérience. Ces qubits problématiques peuvent résulter d'une mauvaise calibration ou d'interactions avec des systèmes à deux niveaux (TLS). La suppression de ces qubits modifie la topologie native du matériel, changeant effectivement le réseau cristallin sur lequel le système est simulé.

De plus, nous discuterons de la façon de construire le circuit quantique paramétré qui implémente l'évolution temporelle du système en utilisant la Trotterisation. Une partie clé de ce processus est l'identification des couches d'intrication dans le circuit, qui jouent un rôle crucial dans la principale technique d'atténuation des erreurs.

Étape 1 de Qiskit patterns : Mettre en correspondance

Le tutoriel accomplit l'étape de mise en correspondance de manière similaire à l'approche générale décrite ci-dessus. Spécifiquement pour ce problème, le tutoriel effectue les opérations suivantes :

• Crée un circuit du modèle d'Ising paramétré
• Crée des couches d'intrication et supprime les mauvais qubits
• Génère une version trotterisée du circuit

Dans le tutoriel, nous commençons par créer une série de fonctions auxiliaires en début de notebook. Ces fonctions sont conçues pour simplifier le processus au fur et à mesure. Elles ne font pas partie obligatoire de la procédure, mais c'est une bonne pratique courante lorsqu'on travaille sur des expériences similaires : décomposer le problème en composants gérables. Les fonctions comprennent

• Supprimer les couplages de qubits
• Définir les couplages de qubits
• Construire les couplages de couches
• Construire la couche d'intrication
• Définir le circuit trotterisé

Ici, explorons un peu plus les sujets liés à ces fonctions. Couplages de couches

Les couplages de couches définissent comment les qubits interagissent avec leurs voisins pendant la simulation. Nos appareils quantiques utilisent une disposition hexagonale lourde (heavy-hexagonal), un schéma distinctif pour connecter les qubits. Dans cette disposition, les connexions entre les qubits — connues sous le nom d'« arêtes » — peuvent être divisées en trois ensembles distincts. Il est important de noter qu'aucune connexion du même ensemble ne partage un qubit. Cette organisation répond à une contrainte matérielle clé : sur un vrai ordinateur quantique, un qubit ne peut participer qu'à une seule porte à deux qubits à un moment donné.

En structurant toutes les connexions en trois couches séparées, les portes à deux qubits peuvent être appliquées sur tout l'appareil en trois cycles successifs. Cela garantit qu'aucun qubit n'est impliqué dans plus d'une porte par couche. Ces portes implémentent l'interaction ZZ dans le modèle d'Ising, et elles sont répétées à chaque pas de temps de la simulation (chaque pas de Trotter).

De plus, une technique appelée twirling est employée pour modifier les caractéristiques du bruit dans l'appareil. Le twirling transforme le bruit de telle sorte que même des modèles de bruit simples deviennent des représentations plus précises des erreurs physiques. Ce raffinement permet une caractérisation plus précise du bruit, qui peut ensuite être exploitée pour améliorer les stratégies d'atténuation des erreurs. Supprimer les « mauvais » qubits

L'étape suivante consiste à supprimer les « mauvais » qubits de la liste des qubits physiques disponibles pour l'expérience. Un qubit peut devenir « mauvais » pour diverses raisons. Parfois, c'est simplement une question de mauvaise calibration, qui peut être corrigée par recalibration. Dans d'autres cas, le problème est plus complexe et lié à ce que l'on appelle un défaut de système à deux niveaux (TLS). Ces défauts TLS provoquent des fluctuations dans les paramètres des qubits et leur relaxation. Résoudre ce problème nécessite souvent de réchauffer l'ensemble du système, puis de le refroidir à nouveau — un processus qui peut prendre du temps et qui n'est pas réalisable lors d'un accès distant au matériel quantique via le cloud.

Pour l'instant, l'approche la plus simple est d'exclure ces qubits problématiques du pool de qubits physiques qui seront utilisés dans l'expérience. IBM Quantum Platform® facilite l'identification des qubits sous-performants sur un QPU. Tu peux soit ouvrir le QPU et visualiser leurs caractéristiques directement sur la plateforme, soit télécharger les données depuis la plateforme sous forme de fichier CSV. Ensuite, crée une liste de qubits à exclure et supprime-les de l'ensemble total de qubits physiques sur l'appareil.

La suppression des qubits peu fiables garantit que le comportement du système est plus prévisible, ce qui améliore la précision de l'expérience. Cela permet également une meilleure modélisation du bruit, qui est essentielle pour mettre en œuvre des stratégies efficaces d'atténuation des erreurs. Circuit trotterisé

Il est maintenant temps de construire notre circuit trotterisé. Comme discuté précédemment, la Trotterisation décompose l'évolution temporelle en étapes discrètes, nous devons donc choisir combien d'étapes utiliser. Pour cet exemple, nous sélectionnerons six étapes. En général, l'approche consiste à équilibrer l'erreur de Trotter — une erreur d'approximation introduite par l'algorithme — avec les erreurs causées par la décohérence. Augmenter le nombre de pas de Trotter réduit l'erreur d'approximation mais nécessite des circuits quantiques plus profonds, qui sont plus sensibles au bruit de décohérence.

Le circuit sera défini en utilisant plusieurs paramètres : le paramètre theta représentant la force du champ magnétique externe, les couplages entre les couches, le nombre d'étapes, le nombre de qubits et, bien sûr, le choix du backend de l'appareil. Étant donné que la magnétisation du système dépend de la force du champ magnétique externe, il est intéressant d'exécuter la simulation à différentes valeurs de champ magnétique. Cette variation correspond à différents angles de rotation pour la porte RX dans le circuit.

from qiskit.circuit import Parameter

num_steps = 6           #Trotter steps
theta = Parameter("theta")
circuit = trotter_circuit(
        theta, layer_couplings, num_steps, qubits = good_qubits, backend = backend
)
num_params = 12

# 12 parameter values for Rx between [0,p/2].
#Reshape to outer product broadcast with observables

parameter_values = np.linespace(0,np.pi/2,num_params).reshape((num_params,1))
num_params = parameter_values.size

Étape 2 de Qiskit patterns : Optimiser

Maintenant que nous avons généré notre circuit, l'étape suivante est de l'optimiser. La première partie de ce processus consiste à définir un gestionnaire de passes (pass manager). Dans le contexte du SDK Qiskit, la transpilation est le processus de transformation d'un circuit d'entrée en une forme adaptée à l'exécution sur un appareil quantique. Cette transformation se produit à travers une séquence d'étapes appelées passes de transpilation. Un gestionnaire de passes est un objet qui contient une liste de ces passes de transpilation et peut les appliquer à un circuit. Pour en créer un, tu initialises un PassManager avec la liste souhaitée de passes de transpilation. En définitive, le gestionnaire de passes produit un circuit ISA — un circuit exprimé en termes de l'Architecture d'Ensemble d'Instructions (ISA) du backend. Cela signifie que le circuit est représenté en utilisant des portes natives du matériel backend, bien qu'il n'inclue pas encore les informations de timing nécessaires pour exécuter le circuit sur l'appareil.

Étape 3 de Qiskit patterns : Exécuter en utilisant des primitives

Il est maintenant temps d'exécuter notre circuit. Nous utiliserons l'Estimator comme outil principal pour cette expérience car notre objectif est de mesurer la magnétisation totale du système. L'Estimator est spécifiquement conçu pour estimer les valeurs d'espérance des observables, ce qui en fait le choix idéal ici. À ce stade, il est également essentiel de configurer nos paramètres d'atténuation des erreurs. Nous appliquerons l'Extrapolation au Zéro Bruit (ZNE) pour améliorer la précision de nos résultats. Dans le tutoriel, tu verras que nous spécifions deux ou plusieurs valeurs de facteur de bruit auxquelles évaluer les modèles extrapolés, et nous sélectionnons l'« Amplification Probabiliste des Erreurs » (PEA) comme méthode d'amplification. PEA est préféré pour cette expérience car il évolue nettement mieux que les autres options, ce qui est crucial lorsqu'on travaille avec des systèmes de 100 qubits ou plus.

C'est tout ce qui est nécessaire pour exécuter l'expérience.

Interlude sur l'atténuation des erreurs

Avant de passer au post-traitement, prenons un bref moment pour clarifier ce qu'on entend par Extrapolation au Zéro Bruit (ZNE). Nous avons abordé ce concept dans des épisodes précédents, mais cela vaut la peine de le revoir brièvement. ZNE est une technique d'atténuation des erreurs conçue pour réduire l'impact d'un bruit inconnu qui se produit pendant l'exécution de circuits quantiques, à condition que ce bruit puisse être mis à l'échelle de manière contrôlée. La méthode repose sur l'hypothèse que les valeurs d'espérance évoluent avec le bruit selon une fonction connue :

$$\langle A(\lambda)\rangle = \langle A(0)\rangle + \sum_{k=0}^m {a_k \lambda^k}+R,$$

où $λ$ représente la force du bruit, qui peut être intentionnellement amplifiée.

Le processus d'implémentation de ZNE comprend les étapes suivantes :

1. Amplifier le bruit du circuit pour différents facteurs de bruit $λ_1$, $λ_2$, … .
2. Exécuter chaque circuit avec bruit amplifiés pour mesurer les valeurs d'espérance correspondantes $\langle A(\lambda_1)\rangle$, $\langle A(\lambda_2)\rangle$, ….
3. Extrapoler ces résultats vers la limite sans bruit \langle $A(\lambda_0)\rangle$.

Cette technique nous permet d'estimer ce que serait le résultat en l'absence de bruit, améliorant ainsi la précision des calculs quantiques.

Le principal défi pour implémenter ZNE efficacement est de développer un modèle de bruit précis pour la valeur d'espérance et d'amplifier le bruit de manière contrôlée et bien comprise. Les techniques courantes pour l'amplification des erreurs dans ZNE comprennent la mise à l'échelle de la durée des impulsions par calibration, la répétition de portes en utilisant des cycles d'identité, et l'ajout de bruit via l'échantillonnage de canaux de Pauli — une méthode connue sous le nom d'Amplification Probabiliste des Erreurs (PEA).

Parmi celles-ci, PEA est souvent le choix préféré pour plusieurs raisons :

• L'étirement des impulsions entraîne un coût de calcul élevé.
• Le repliement de portes (gate folding), qui utilise des insertions d'identités, manque de garanties théoriques solides pour préserver le biais du bruit.
• PEA est applicable à n'importe quel circuit exécuté avec un facteur de bruit natif, bien qu'il nécessite d'apprendre le modèle de bruit à l'avance.

PEA fonctionne sous l'hypothèse d'un modèle de bruit basé sur des couches similaire à celui utilisé dans l'annulation probabiliste des erreurs (PEC). Cependant, contrairement à PEC, il évite la surcharge exponentielle d'échantillonnage qui croît généralement avec le bruit du circuit. Cette efficacité fait de PEA une approche pratique et robuste pour l'amplification du bruit dans ZNE, facilitant une atténuation des erreurs quantiques plus fiable. Pour caractériser le modèle de bruit, nous devons d'abord identifier les couches distinctes d'opérations à deux qubits dans le circuit. Pour chacune de ces couches, nous appliquons une procédure de twirling de Pauli aux portes à deux qubits, ce qui contribue à garantir que le bruit peut être décrit précisément par un modèle de bruit d'amortissement. Ensuite, nous répétons des paires de couches d'identité à différentes profondeurs, et enfin, nous ajustons les valeurs de fidélité pour déterminer les taux d'erreur de chaque canal de bruit.

Bien qu'il soit utile de comprendre cette méthode de manière conceptuelle, son implémentation manuelle dans Qiskit est beaucoup plus simple, comme le montre le tutoriel d'accompagnement.

Étape 4 de Qiskit patterns : Post-traiter

Après la fin de l'expérience, tu peux visualiser le résultat en le post-traitant. La ligne grise en pointillés dans les données tracées représente les résultats obtenus en utilisant des méthodes classiques approximatives, avec l'erreur d'approximation réduite à un faible seuil. Les points de données bruts pour les différents facteurs de bruit, sélectionnés au départ, sont clairement décalés par rapport à cette ligne en pointillés. En revanche, la ligne bleue continue affiche les données après application de notre traitement ZNE, qui rapproche notablement les résultats des valeurs exactes. En résumé, les valeurs obtenues dans des conditions de bruit normales (facteur de bruit nf=1.0) montrent un écart significatif par rapport aux résultats exacts. Pendant ce temps, les valeurs atténuées s'alignent étroitement avec les valeurs exactes, démontrant l'efficacité de la technique d'atténuation du bruit basée sur PEA.

Résumé

Pour résumer rapidement ce que nous avons appris :

• La simulation quantique est l'un des domaines d'application les plus prometteurs à court et moyen terme.
• Elle a des applications très variées, des produits pharmaceutiques à la physique des hautes énergies, la science des matériaux, et bien plus encore.
• L'article sur l'utilité d'IBM, publié en 2023, a montré la voie vers la possibilité d'utiliser des ordinateurs quantiques pour la découverte scientifique, et nous avons travaillé à travers le tutoriel associé à cet article.
• Les étapes pour aborder un problème de simulation de bout en bout sont relativement simples, et nous espérons que tu pourras maintenant utiliser cette vidéo et ce tutoriel comme guide pour encore plus de problèmes de simulation.

Sondage de fin de cours

Félicitations pour avoir terminé ce cours ! Prends un moment pour nous aider à améliorer notre cours en remplissant le court sondage suivant. Tes retours seront utilisés pour améliorer notre offre de contenu et l'expérience utilisateur. Merci !