Solveur d'équations quantiques variationnelles (VQE)

Pour ce module, les étudiants doivent disposer d'un environnement Python fonctionnel et des dernières versions des paquets suivants :

• qiskit
• qiskit_ibm_runtime
• qiskit-aer
• qiskit.visualization
• numpy
• pylatexenc

Pour configurer et installer ces paquets, voir le guide d' installation de Qiskit. Pour exécuter des tâches sur de véritables ordinateurs quantiques, les étudiants devront créer un compte IBM Cloud en suivant les étapes du guide Configurer votre compte IBM Cloud.

Ce module a été testé et a utilisé environ 8 minutes de temps de QPU. Il s'agit d'une estimation et votre utilisation réelle peut varier.

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Présentation

Depuis le développement du modèle de la mécanique quantique au début du 20e siècle, les scientifiques ont compris que les électrons ne suivent pas des trajectoires fixes autour du noyau d'un atome, mais qu'ils existent plutôt dans des régions de probabilité appelées orbitales. Ces orbitales correspondent à des niveaux d'énergie spécifiques et discrets que les électrons peuvent occuper. Les électrons résident naturellement dans les niveaux d'énergie disponibles les plus bas, connus sous le nom d'état fondamental. Toutefois, si un électron absorbe suffisamment d'énergie, il peut passer à un niveau d'énergie supérieur, entrant ainsi dans un état excité. Cet état d'excitation est temporaire, et l'électron finira par revenir à un niveau d'énergie inférieur, libérant l'énergie absorbée, souvent sous forme de lumière. Ce processus fondamental d'absorption et d'émission d'énergie est important pour comprendre comment les atomes interagissent et forment des liaisons.

Lorsque les atomes s'assemblent pour former des molécules, leurs orbitales atomiques se combinent pour former des orbitales moléculaires. La disposition et les niveaux d'énergie des électrons au sein de ces orbitales moléculaires déterminent les propriétés de la molécule résultante et la force des liaisons chimiques. Par exemple, lors de la formation d'une molécule d'hydrogène ( $H_2$ ) à partir de deux atomes d'hydrogène individuels, l'électron de chaque atome occupe des orbitales atomiques. Lorsque les atomes se rapprochent l'un de l'autre, ces orbitales atomiques se chevauchent et se combinent pour former de nouvelles orbitales moléculaires - l'une avec une énergie plus faible (une orbitale de liaison) et l'autre avec une énergie plus élevée (une orbitale d'antiliaison). Les deux électrons, un pour chaque atome d'hydrogène, occuperont de préférence l'orbitale de liaison à plus faible énergie, ce qui entraînera la formation d'une liaison covalente stable qui maintiendra la molécule $H_2$ ensemble. La différence d'énergie entre les atomes séparés et la molécule formée, en particulier l'énergie des électrons dans les orbitales moléculaires, détermine la stabilité et les propriétés de la liaison.

Dans les sections suivantes, nous explorerons ce processus de formation moléculaire, en nous concentrant sur la molécule $H_2$. Nous utiliserons un véritable ordinateur quantique, combiné à des techniques d'optimisation classiques, pour trouver l'énergie de ce processus simple mais fondamental. Cette expérience permettra de démontrer concrètement comment l'informatique quantique peut être appliquée à la résolution de problèmes de chimie computationnelle et de mieux comprendre le rôle de l'énergie des électrons.

VQE - Un algorithme quantique variationnel pour les problèmes d'eigenvaleurs

Techniques d'approximation pour la chimie - principe variationnel et ensemble de base

Les contributions d'Erwin Schrödinger à la mécanique quantique ne se limitent pas à l'introduction d'un nouveau modèle électronique; fondamentalement, il a établi la mécanique ondulatoire en développant la célèbre équation de Schrödinger dépendant du temps :

Ici, $\hat{H}$ est l'opérateur hamiltonien, qui représente l'énergie totale du système, et $|\psi\rangle$ est la fonction d'onde qui contient toutes les informations sur l'état quantique du système. (Note : $\frac{d}{dt}$ est la dérivée temporelle totale, et nous n'incluons pas explicitement la valeur propre de l'énergie $E$ ici)

Cependant, dans de nombreuses applications pratiques, telles que la détermination des niveaux d'énergie autorisés des atomes et des molécules, nous utilisons plutôt l'équation de Schrödinger indépendante du temps (équation des valeurs propres de l'énergie), qui est dérivée de la forme dépendante du temps en supposant un état stationnaire. Un état stationnaire est un état quantique dans lequel la densité de probabilité de trouver une particule en un point donné de l'espace ne change pas avec le temps.

$\hat{H}|\psi\rangle = E|\psi\rangle$

Sous cette forme, $E$ représente la valeur propre de l'énergie correspondant à l'état quantique $|\psi\rangle$. Le hamiltonien comprend diverses contributions énergétiques, telles que l'énergie cinétique des électrons et des noyaux, les forces d'attraction entre les électrons et les noyaux, et les forces de répulsion entre les électrons.

La résolution de l'équation des valeurs propres de l'énergie permet de calculer les niveaux d'énergie quantifiés des systèmes atomiques et moléculaires. Cependant, pour les molécules, il est difficile de la résoudre exactement car la fonction d'onde $\Psi$, qui décrit la distribution spatiale des électrons, est complexe et à haute dimension.

Par conséquent, les scientifiques utilisent des techniques d'approximation pour obtenir des solutions pratiques et précises. Dans ce travail, nous nous concentrerons sur deux méthodes clés :

1. Principe variationnel

   Cette méthode permet d'obtenir une approximation de la fonction d'onde et de l'ajuster pour se rapprocher le plus possible de l'énergie cible, généralement l'énergie de l'état fondamental du système. L'idée clé du principe de variation est simple :

   • Si nous devinons une fonction d'onde $\Psi_\text{trial}$ (une "fonction d'essai"), l'énergie calculée à partir de celle-ci sera toujours égale ou supérieure à l'énergie de l'état fondamental ( $E_0$ ) du système. $E_\text{approx} = \frac{\langle \Psi_\text{trial}|\hat{H}|\Psi_\text{trial}\rangle}{\langle \Psi_\text{trial}|\Psi_\text{trial}\rangle} \geq E_0$
   • En ajustant les paramètres $\theta$ dans la fonction d'essai, $|\Psi_\text{trial}(\theta)\rangle$, nous pouvons obtenir une approximation de plus en plus précise de l'énergie de l'état fondamental.
   • Sa précision dépend fortement du choix de la fonction d'onde d'essai $\Psi_\text{trial}$. Une fonction d'essai mal choisie peut conduire à une estimation de l'énergie qui est loin d'être précise.

2. Approximation de l'ensemble de base

   La deuxième méthode d'approximation intervient au stade de la construction de la fonction d'onde - l'approche des ensembles de base. En chimie quantique, il est presque impossible de résoudre exactement l'équation de Schrödinger pour les molécules. Au lieu de cela, nous approximons la fonction d'onde complexe à plusieurs électrons en la construisant à partir de fonctions mathématiques prédéfinies plus simples. Un ensemble de base est essentiellement une collection de ces fonctions mathématiques connues, généralement centrées sur les atomes de la molécule, qui sont utilisées comme éléments de base pour représenter la forme et le comportement des électrons dans le système. Imaginez que vous essayez de recréer une sculpture détaillée à l'aide d'une collection de briques LEGO standard. Plus vous avez de types et de tailles de briques (plus l'ensemble de base est grand), plus vous pouvez vous approcher de la forme originale avec précision.

   Ces fonctions de base sont souvent inspirées des solutions analytiques pour des systèmes simples comme l'atome d'hydrogène, prenant des formes telles que les fonctions de type gaussien ou de Slater, bien qu'il s'agisse toujours d'approximations. Au lieu de travailler avec les orbitales moléculaires complètes, théoriquement "exactes" mais irréalisables, nous les exprimons sous la forme d'une combinaison linéaire (une somme avec des coefficients) de ces fonctions de base. Cette méthode est connue sous le nom de combinaison linéaire d'orbitales atomiques (LCAO) lorsque les fonctions de base ressemblent à des orbitales atomiques. En optimisant les coefficients de cette combinaison linéaire, nous pouvons trouver la meilleure fonction d'onde approximative possible et l'énergie dans les limites de l'ensemble de base choisi.

   • Plus le nombre de fonctions incluses dans l'ensemble de base est élevé, meilleure est l'approximation, mais cela se fait au prix d'un effort de calcul plus important.
   • Un petit ensemble de base fournit une estimation approximative, tandis qu'un grand ensemble de base donne des résultats plus précis au prix de ressources informatiques plus importantes.

En résumé, pour rendre les calculs réalisables et réduire les coûts de calcul, nous utilisons le principe variationnel en approximant la fonction d'onde, ce qui réduit la complexité de calcul et permet une optimisation itérative pour minimiser l'énergie. Parallèlement, l'approche par ensembles de bases simplifie les calculs en représentant les orbitales atomiques comme une combinaison de fonctions prédéfinies, plutôt que de résoudre directement une fonction d'onde continue.

Vérifiez votre compréhension

Considérons la fonction d'onde d'essai $\Psi_\text{trial}(\alpha,x) = Ae^{- \alpha x^2}$ où $A$ est une constante de normalisation et $\alpha$ un paramètre ajustable.

(a) Normaliser la fonction d'onde d'essai en déterminant l' $A$ e de telle sorte que $\int_{-\infty}^{\infty} |\Psi_\text{trial}|^2 dx = 1$.

• Réponse

  Pour normaliser la fonction d'onde d'essai donnée :

  $\int_{-\infty}^{\infty} |\Psi_\text{trial}|^2 dx = \int_{-\infty}^{\infty} A^2 e^{-2 \alpha x^2} dx = 1$

  Utilisez l'intégrale de Gauss :

  $\int_{-\infty}^{\infty} e^{-a x^2} dx = \sqrt{\frac{\pi}{a}} \text{, for } a>0$

  set $a = 2\alpha$ then get : $A^2\sqrt{\frac{\pi}{a}} = 1$ $\therefore A = (\frac{2\alpha}{\pi})^{1/4}$

(b) Calculez la valeur attendue de l' $\hat{H}$ e hamiltonien donnée par $\hat{H} = -\frac{\hbar^2}{2m} \frac{d^2}{dx^2} + V(x)$ où $V(x) = \frac{1}{2}m\omega^2x^2$, ce qui correspond à un potentiel d'oscillateur harmonique simple.

• Réponse

  L'hamiltonien d'un oscillateur harmonique est :

  $\hat{H} = -\frac{\hbar^2}{2m} \frac{d^2}{dx^2} + \frac{1}{2} m \omega^2 x^2$

  Valeur attendue de l'énergie cinétique

  $\langle T \rangle = -\frac{\hbar^2}{2m} \int_{-\infty}^{\infty} \Psi_\text{trial}^* \frac{d^2}{dx^2} \Psi_\text{trial} dx$

  En prenant la dérivée seconde :

  $\frac{d}{dx} \Psi_\text{trial} = -2\alpha x A e^{-\alpha x^2}$

  $\frac{d^2}{dx^2} \Psi_\text{trial} = A e^{-\alpha x^2} (4\alpha^2 x^2 - 2\alpha)$

  Ainsi :

  $T = -\frac{\hbar^2}{2m} \int_{-\infty}^{\infty} A^2 e^{-2\alpha x^2} (4\alpha^2 x^2 - 2\alpha) dx$

  En utilisant les résultats de l'intégrale gaussienne standard :

  $\langle T \rangle = \frac{\hbar^2 \alpha}{2m}$

  Valeur attendue de l'énergie potentielle

  $\langle V \rangle = \frac{1}{2} m \omega^2 \int_{-\infty}^{\infty} x^2 |\Psi_\text{trial}|^2 dx$

  Utilisation :

  $\int_{-\infty}^{\infty} x^2 e^{-a x^2} dx = \frac{\sqrt{\pi}}{2a^{3/2}}$

  nous obtenons :

  $\langle V \rangle = \frac{m \omega^2}{4\alpha}$

  Valeur attendue totale de l'énergie

  $\therefore E_\text{approx}(\alpha) = \frac{\hbar^2 \alpha}{2m} + \frac{m \omega^2}{4\alpha}$

(c) Utiliser le principe variationnel pour déterminer l' $\alpha$ optimale en minimisant $E_\text{approx}(\alpha)$.

• Réponse

  Optimiser l' $\alpha$ e pour une consommation d'énergie minimale

  Distinguer

  $\frac{d}{d\alpha} \left( \frac{\hbar^2 \alpha}{2m} + \frac{m \omega^2}{4\alpha} \right) = 0$

  Résoudre :

  $\frac{\hbar^2}{2m} - \frac{m \omega^2}{4\alpha^2} = 0$

  $\alpha_\text{opt} = \frac{m\omega}{2\hbar}$

  En substituant $\alpha_\text{opt}$ à $E_\text{approx}$ :

  $\therefore E_\text{approx} = \frac{\hbar \omega}{2}$

  qui correspond à l'énergie exacte de l'état fondamental de l'oscillateur harmonique quantique.

VQE (solveur d'équations quantiques variationnelles)

Le résolveur quantique variationnel (VQE) est la principale méthode que nous utiliserons pour explorer le processus $H+H = H_2$. Nous verrons ici ce qu'est le VQE et comment il fonctionne. Mais faisons d'abord une pause et examinons une chose très importante à travers la question de l'enregistrement.

Vérifiez votre compréhension

Si nous disposons déjà d'autant de stratégies pour résoudre les problèmes de chimie, pourquoi avons-nous besoin d'un ordinateur quantique? Et quel est l'intérêt d'utiliser à la fois des ordinateurs quantiques et des ordinateurs classiques?

• Réponse

  L'informatique quantique a la possibilité de révolutionner la chimie en s'attaquant aux problèmes auxquels les ordinateurs classiques sont confrontés en raison de l'échelle exponentielle des états quantiques. Richard Feynman a fait remarquer que pour simuler la nature, les calculs doivent également être quantiques [réf. 1.]

  Par exemple, la simulation de la caféine avec l'ensemble de base le plus simple ( STO-3G ) nécessiterait $10^{48}$ bits, soit beaucoup plus que le nombre total d'étoiles dans l'univers observable ( $10^{24}$ ) [ref 2.] Un ordinateur quantique peut décrire les orbitales électroniques de la caféine avec 160 qubits.

  Les ordinateurs quantiques traitent naturellement les interactions quantiques en utilisant la superposition et l'enchevêtrement, ce qui constitue un moyen prometteur de permettre des simulations moléculaires précises. En outre, nous pouvons combiner les avantages des ordinateurs quantiques (simulation électronique) et des ordinateurs classiques (pré/post-traitement des données, gestion du processus algorithmique, optimisation, etc.) Ils devraient permettre d'améliorer la découverte de matériaux, la conception de médicaments et les prévisions de réactions, en réduisant le nombre d'expériences d'essai et d'erreur coûteuses. [réf. 3][ref 4]

  Si vous voulez savoir pourquoi les ordinateurs quantiques sont nécessaires pour résoudre des problèmes de chimie et pourquoi utiliser à la fois des ressources informatiques quantiques et classiques, consultez les articles suivants :

  • Algorithmes émergents d'informatique quantique pour la chimie quantique
  • La chimie au-delà des solutions exactes sur un superordinateur centré sur les quanta
  • Supercalculateur centré sur les quanta pour la science des matériaux : Une perspective sur les défis et les orientations futures

Revenons maintenant à VQE.

La VQE combine la puissance des ordinateurs quantiques avec celle des ordinateurs classiques, en utilisant fondamentalement des principes variationnels pour obtenir l'énergie de l'état fondamental du système. Pour comprendre le VQE, il faut d'abord le décomposer en trois parties :

Observable (quantique) : l'hamiltonien moléculaire (énergie d'une molécule)

Dans la VQE, le hamiltonien moléculaire/atomique est une observable, ce qui signifie que nous pouvons mesurer sa valeur par le biais d'une expérience. Notre objectif est de trouver l'énergie la plus basse possible (l'énergie de l'état fondamental) de la molécule. Pour ce faire, nous utilisons un état quantique d'essai, généré par un circuit quantique paramétré (ansatz). Nous mesurons l'observable et optimisons l'état quantique jusqu'à ce que nous atteignions l'énergie la plus basse possible.

L'ensemble de bases utilisé pour l'hamiltonien moléculaire détermine le nombre de qubits requis et affecte directement la précision de l'EQV. Le choix du bon jeu de base est essentiel pour équilibrer l'efficacité et la précision. Pour simplifier les calculs sans modifier l'ensemble des bases, nous pouvons utiliser des stratégies telles que l'imposition de la symétrie et la réduction de l'espace actif. De nombreuses molécules ont des formes symétriques (comme un papillon ou un flocon de neige), ce qui signifie que certaines parties se comportent de la même manière. Au lieu de tout calculer séparément, nous pouvons nous concentrer uniquement sur les parties uniques, ce qui permet d'économiser des ressources quantiques et de tirer parti de la symétrie. Dans la réduction de l'espace actif, nous ne considérons que les orbitales importantes, car tous les électrons n'ont pas un impact significatif sur l'énergie moléculaire. Les électrons proches du noyau restent pour la plupart inchangés, tandis que les autres influencent la liaison. En appliquant ces méthodes, nous pouvons rendre VQE plus efficace tout en maintenant la précision.

Une fois que nous avons obtenu un hamiltonien moléculaire en utilisant l'ensemble de bases approprié et les stratégies ci-dessus, nous devons transformer cet hamiltonien en un hamiltonien adapté aux ordinateurs quantiques. La mise en correspondance des problèmes avec les opérateurs de Pauli peut s'avérer assez compliquée. C'est particulièrement vrai en chimie quantique, qui travaille avec des particules indiscernables (électrons), puisque les qubits sont discernables. Nous n'entrerons pas ici dans les détails des correspondances, mais nous vous renvoyons aux ressources suivantes. Une discussion générale sur la cartographie d'un problème aux opérateurs quantiques peut être trouvée dans L'informatique quantique en pratique. Une discussion plus détaillée sur la conversion des problèmes de chimie en opérateurs quantiques est disponible dans Quantum chemistry with VQE (Chimie quantique avec VQE ).

Pour ce module, nous vous fournirons les hamiltoniens appropriés (un qubit) pour $H$ et $H_2$ afin que nous puissions nous concentrer sur l'utilisation de l'ordinateur quantique. Ces hamiltoniens à un qubit sont préparés en utilisant l'ensemble de base STO-6G et la cartographie de Jordan-Wigner, qui est la cartographie la plus directe avec l'interprétation physique la plus simple, parce qu'elle fait correspondre l'occupation d'une orbitale de spin à l'occupation d'un qubit. Nous avons également utilisé une technique de réduction des qubits en utilisant une symétrie de l'hamiltonien, qui utilise les modèles de comportement des occupations de spin pour réduire le nombre de qubits. Pour la molécule $H_2$, nous supposons que la distance entre les deux atomes d'hydrogène est de 0.735 $\mathring A$.

Approche (quantique) : la fonction d'onde d'essai (comment construire un état quantique trivial avec un circuit quantique)

Pour VQE, l'ansatz (pluriel : ansätze) se compose de deux éléments clés. La première est la préparation de l'état initial, qui établit l'état du qubit en appliquant des portes quantiques sans paramètre de variation. Le deuxième composant est le circuit quantique paramétré, un circuit quantique spécial dont les paramètres sont réglables, comme les cadrans d'une radio. Ces paramètres seront utilisés pour la dernière partie - l'optimiseur classique - pour nous aider à atteindre le meilleur état fondamental possible.

Dans la section sur le principe variationnel, nous avons appris que la qualité de l'état d'essai affecte la qualité des résultats de l'algorithme variationnel. Cela signifie que le choix d'un bon ansatz est important pour la VQE. Une fois de plus, il s'agit d'un sujet riche et complexe. Nous n'aborderons pas ici les différents types d'ansatz ni leurs origines. Si vous souhaitez en savoir plus sur les circuits quantiques paramétrés et les ansatz, vous pouvez consulter la leçon Ansatz et forme variationnelle du cours Conception d'algorithmes variationnels, qui fournit des explications détaillées et des exemples d'ansätze.

Comme nous allons utiliser un hamiltonien à une qubite dans ce module, nous avons besoin d'un circuit quantique paramétré à une qubite en guise d'anatz. Nous verrons trois types de réponses à un qubit dans la section suivante. Nous les comparerons et discuterons des considérations clés dans le choix d'un ansatz.

Optimiseur (classique) : réglage fin du circuit quantique

Une fois que l'ordinateur quantique a mesuré l'énergie de l'observable à partir de l'ansatz, les paramètres de l'ansatz et la valeur de l'énergie sont envoyés à l'optimiseur classique pour être réglés. Ce processus d'optimisation est réalisé sur un ordinateur classique, généralement à l'aide de logiciels scientifiques généraux tels que SciPy.

L'optimiseur classique traite l'énergie mesurée comme une fonction de coût. Dans les problèmes d'optimisation, une fonction de coût (parfois appelée aussi fonction objectif) est une fonction mathématique qui mesure la "qualité" d'une solution donnée. L'objectif de l'optimiseur est de trouver l'ensemble des paramètres qui minimisent cette fonction de coût. Dans le contexte de la recherche de l'énergie de l'état fondamental d'une molécule, l'énergie elle-même sert de fonction de coût - nous voulons trouver les paramètres de notre circuit quantique (notre "solution") qui produisent l'énergie la plus basse possible. L'optimiseur classique utilise cette valeur énergétique mesurée (le coût) et détermine le prochain ensemble de paramètres optimisés pour l'ansatz quantique. Ces paramètres mis à jour sont ensuite renvoyés au circuit quantique, et le processus est répété. À chaque itération, l'optimiseur classique ajuste les paramètres pour tenter de réduire l'énergie (minimiser la fonction de coût) jusqu'à ce qu'un critère de convergence prédéfini soit atteint, garantissant idéalement que l'énergie la plus basse possible (correspondant à l'état fondamental de la molécule pour cette distance de liaison et cet ensemble de base) est trouvée.

De nombreuses stratégies d'optimisation sont proposées par des logiciels scientifiques tels que SciPy. Pour en savoir plus, consultez la leçon Boucles d'optimisation du cours Conception d'algorithmes variationnels. Nous utiliserons ici COBYLA (Constrained Optimization BY Linear Approximations), un algorithme d'optimisation adapté aux paysages énergétiques complexes. En particulier, COBYLA ne tente pas de calculer le gradient de la fonction étudiée; c'est ce qu'on appelle un optimiseur sans gradient. Imaginez que vous essayez de trouver le plus haut sommet d'une chaîne de montagnes les yeux fermés. Comme vous ne pouvez pas voir l'ensemble du paysage, vous faites de petits pas dans différentes directions, tout en vérifiant si vous montez ou descendez. COBYLA fonctionne de la même manière : il se déplace dans l'espace des paramètres, en testant différentes valeurs et en améliorant progressivement le résultat jusqu'à ce qu'il trouve la meilleure.

Vous êtes maintenant prêt à effectuer un calcul VQE. À cette fin, essayez la question de contrôle ci-dessous, qui récapitule l'ensemble du processus.

Vérifiez votre compréhension

Complétez les espaces vides avec les termes appropriés pour terminer le résumé du processus VQE, puis cliquez pour vérifier vos réponses.

VQE est un algorithme quantique variationnel, qui combine la puissance de (1) ______ et de l'informatique classique, utilisé pour trouver (2) _______________ d'une molécule. Le processus commence par la définition de (3) ______________, qui représente l'énergie totale du système et sert d'observable dans les mesures quantiques. Ensuite, nous préparons un (4) ______________, un circuit quantique dont les paramètres sont réglables et qui représente la fonction d'onde d'essai de la molécule. Ces paramètres sont optimisés à l'aide d'un (5) ___________, un algorithme classique qui ajuste les paramètres de manière itérative afin de minimiser l'énergie mesurée. Dans la discussion ci-dessus, nous avons utilisé l'optimiseur (6) ___________ optimizer, qui affine les paramètres de l'ansatz sans nécessiter de calculs de dérivées. Le processus se poursuit jusqu'à ce que nous atteignions (7) _____________, ce qui signifie que nous avons trouvé l'énergie la plus basse possible de la molécule.

Banque de mots :

• optimiseur classique
• énergie de l'état fondamental
• matériel efficace
• ansatz
• hamiltonien moléculaire
• COBYLA
• informatique quantique
• convergence

• Réponse

  1 → informatique quantique

  2 → énergie de l'état fondamental

  3 → Hamiltonien moléculaire

  4 → ansatz

  5 → optimiseur classique

  6 → COBYLA

  7 → convergence

Calculer l'énergie de l'état fondamental d'un atome d'hydrogène avec VQE

Utilisons maintenant ce que nous avons appris pour calculer l'énergie de l'état fondamental d'un atome d'hydrogène. Tout au long du module, nous utiliserons un cadre pour l'informatique quantique connu sous le nom de "modèles Qiskit", qui décompose les flux de travail en plusieurs étapes :

• Etape 1 : Tracer un problème quantique à partir d'entrées classiques
• Étape 2 : Optimisation du problème pour l'exécution quantique
• Étape 3 : Exécution à l'aide des primitives « IBM Quantum »
• Étape 4 : Post-traitement et analyse classique

Nous suivrons généralement les étapes suivantes.

Commençons par installer quelques paquets indispensables, notamment les primitives d' IBM Quantum. Nous choisirons également l'ordinateur quantique le moins sollicité parmi ceux dont nous disposons.

Le code ci-dessous permet de sauvegarder vos données d'identification lors de la première utilisation. Veillez à supprimer ces informations du bloc-notes après l'avoir enregistré dans votre environnement, afin que vos informations d'identification ne soient pas accidentellement partagées lorsque vous partagez le bloc-notes. Voir Configurer votre compte IBM Cloud et Initialiser le service dans un environnement non fiable pour plus d'informations.

# Load IBM Quantum Compute Service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Runtime primitive and session
from qiskit_ibm_runtime import EstimatorV2 as Estimator

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',
# instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

Output:

ibm_brisbane

La cellule ci-dessous vous permettra de basculer entre l'utilisation du simulateur ou du matériel réel tout au long du carnet. Nous vous recommandons de l'exécuter maintenant :

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

# Alternatively, load a fake backend with generic properties and define a simulator.


noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)

Étape 1 : Transposer le problème en circuits quantiques et opérateurs

Nous commençons notre calcul de la VQE en définissant l'hamiltonien de la molécule d'hydrogène ( $H_2$ ) à une distance de liaison spécifique. Cet hamiltonien représente l'énergie totale du système en termes d'opérateurs de qubits; il a été dérivé et transposé à partir du système moléculaire selon une procédure standard : 1) en utilisant le jeu de bases d' STO-6G s (un ensemble spécifique de fonctions mathématiques servant à approximer les orbitales électroniques), 2) en appliquant la transformation de Jordan-Wigner (une technique permettant de traduire les opérateurs fermioniques décrivant les électrons en opérateurs de qubits), et 3) en effectuant une réduction des qubits à l'aide de la parité de l'hamiltonien afin de simplifier le problème.

Comme nous l'avons expliqué précédemment, les énergies de l'état fondamental calculées dépendent fortement de la sélection du jeu de base et de la géométrie moléculaire (comme la distance entre les liaisons). Pour cette configuration spécifique et après ces transformations, l'hamiltonien du qubit résultant est simple :

$\hat{H} = -0.2355 I + 0.2355 Z$

Ici, $I$ représente l'opérateur d'identité et $Z$ représente l'opérateur Pauli-Z, agissant sur un seul qubit. Les coefficients sont dérivés des intégrales calculées à l'aide de l'ensemble de bases STO-6G à cette distance de liaison particulière avec une transformation appropriée.

Cet hamiltonien étant défini, nous pouvons maintenant utiliser VQE pour calculer l'énergie de l'état fondamental. Il est utile de comparer l'énergie de l'état fondamental que nous avons calculée aux valeurs attendues. Pour un atome d'hydrogène (H) isolé, l'énergie de l'état fondamental est exactement -0.5 Hartree (en l'absence d'effets relativistes). Calculons l'énergie exacte de l'état fondamental de l' hamiltonien de notre qubit spécifique tel que défini ci-dessus et comparons-la aux valeurs connues.

from qiskit.quantum_info import SparsePauliOp
import numpy as np

# Qubit Hamiltonian of the hydrogen atom generated by using STO-3G basis set and parity mapping
Hamiltonian = SparsePauliOp.from_list([("I", -0.2355), ("Z", 0.2355)])

# exact ground state energy of Hamiltonian

A = np.array(Hamiltonian)
eigenvalues, eigenvectors = np.linalg.eig(A)
print(
    "The exact ground state energy of the Hamiltonian is ",
    min(eigenvalues).real,
    "hartree",
)
h = min(eigenvalues.real)

Output:

The exact ground state energy of the Hamiltonian is  -0.471 hartree

Ensuite, nous avons besoin d'un circuit quantique paramétré, un ansatz, pour préparer une fonction d'onde d'essai $\Psi_\text{trial}$ pour l'état fondamental. L'objectif est de trouver les paramètres $\theta$ qui minimisent la valeur espérée de l'énergie $\langle\psi(\theta)|\hat{H}|\psi(\theta)\rangle$. Le choix de l'ansatz est crucial car il détermine l'ensemble des états quantiques possibles que notre circuit peut préparer. Un "bon" ansatz est celui qui est suffisamment souple pour représenter un état très proche du véritable état fondamental de l'hamiltonien que nous étudions, mais qui n'est pas si complexe qu'il nécessite trop de paramètres ou un circuit trop profond pour les ordinateurs quantiques actuels.

Ici, nous allons essayer trois réponses différentes pour un qubit afin de voir laquelle fournit une meilleure "couverture" des états quantiques possibles dans lesquels un seul qubit peut se trouver. La "couverture" fait référence à la gamme d'états quantiques que le circuit d'ansatz peut produire en faisant varier ses paramètres.

Nous utiliserons trois réponses basées sur différentes combinaisons de portes de rotation à un qubit :

• Ansatz de porte rotative à un axe : cet ansatz utilise des rotations autour d'un seul axe ( $R_x(\theta)$ ). Sur la sphère de Bloch, cela correspond à se déplacer uniquement le long d'un cercle spécifique. Il s'agit de l'option la moins flexible, qui ne couvre qu'un nombre limité d'États.
• Two 2-axis rotational gate ansätze : Ces ansätze combinent des rotations autour de deux axes différents ( $R_x(\theta_1) R_z(\theta_2)$ et $R_x(\theta_1) R_z(\theta_2) R_x(\theta_3)$ ). Cela nous permet d'atteindre une plus grande partie de la sphère de Bloch qu'avec une rotation autour d'un seul axe.

En comparant les résultats VQE obtenus avec ces trois ansätze, nous pouvons voir comment la flexibilité et la couverture de l'espace d'état de l'ansatz influencent notre capacité à trouver la véritable énergie de l'état fondamental de notre hamiltonien simplifié. Un ansatz plus souple permet de trouver une meilleure approximation, mais il peut aussi être plus difficile pour l'optimiseur classique.

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import Statevector, DensityMatrix, Pauli

theta = Parameter("θ")
phi = Parameter("φ")
lam = Parameter("λ")

ansatz1 = QuantumCircuit(1)
ansatz1.rx(theta, 0)

ansatz2 = QuantumCircuit(1)
ansatz2.rx(theta, 0)
ansatz2.rz(phi, 0)

ansatz3 = QuantumCircuit(1)
ansatz3.rx(theta, 0)
ansatz3.rz(phi, 0)
ansatz3.rx(lam, 0)

Output:

<qiskit.circuit.instructionset.InstructionSet at 0x1059def80>

Maintenant, générons 5000 nombres aléatoires pour chaque paramètre et traçons la distribution des états quantiques aléatoires, générés par les trois réponses avec ces paramètres aléatoires. Vous pouvez considérer ces paramètres comme des rotations autour de différents axes sur une surface sphérique. Pour voir la distribution de l'état quantique, nous utiliserons la sphère de Bloch, une sphère tridimensionnelle qui montre l'état d'un seul qubit. Chaque point de la sphère représente un état possible du qubit, où les pôles nord et sud sont comme les classiques "0" et "1", mais le qubit peut aussi se trouver n'importe où entre les deux, ce qui démontre des propriétés quantiques spéciales telles que la superposition. Tout d'abord, préparez les fonctions nécessaires pour tracer la sphère de Bloch 3D et préparez 5000 paramètres aléatoires.

import matplotlib.pyplot as plt


def plot_bloch(bloch_vectors):
    # Extract X, Y, Z coordinates for 3D projection
    X_coords = bloch_vectors[:, 0]
    Z_coords = bloch_vectors[:, 2]

    # Compute Y coordinates from X and Z to approximate the full Bloch sphere projection
    Y_coords = bloch_vectors[:, 1]

    # Create 3D plot
    fig = plt.figure(figsize=(8, 8))
    ax = fig.add_subplot(111, projection="3d")
    ax.scatter(X_coords, Y_coords, Z_coords, color="blue", alpha=0.6)

    # Labels and title
    ax.set_xlabel("X")
    ax.set_ylabel("Y")
    ax.set_zlabel("Z")
    ax.set_title("Parameterized 1-Qubit Circuit on 3D Bloch Sphere")

    # Set axis limits and make them equal
    ax.set_xlim([-1, 1])
    ax.set_ylim([-1, 1])
    ax.set_zlim([-1, 1])

    # Ensure equal aspect ratio for all axes
    ax.set_box_aspect([1, 1, 1])  # Equal scaling for x, y, z axes

    # Show grid
    ax.grid(True)

    plt.show()


num_samples = 5000  # Number of random states
theta_vals = np.random.uniform(0, 2 * np.pi, num_samples)
phi_vals = np.random.uniform(0, 2 * np.pi, num_samples)
lam_vals = np.random.uniform(0, 2 * np.pi, num_samples)

Voyons comment fonctionne notre premier ansatz.

# List to store Bloch Sphere XZ coordinates
bloch_vectors = []

# Generate quantum states and extract Bloch vectors
for i in range(num_samples):
    # Create a circuit and bind parameters
    qc = ansatz1
    bound_qc = qc.assign_parameters({theta: theta_vals[i]})  # , lam: lam_vals[i]})
    state = Statevector.from_instruction(bound_qc)
    rho = DensityMatrix(state)

    X = rho.expectation_value(Pauli("X")).real
    Y = rho.expectation_value(Pauli("Y")).real
    Z = rho.expectation_value(Pauli("Z")).real
    bloch_vectors.append([X, Y, Z])  # Store X, Z components

# Convert to a numpy array for plotting
bloch_vectors = np.array(bloch_vectors)

plot_bloch(bloch_vectors)

Output:

Nous pouvons voir que notre premier ansatz renvoie un état quantique distribué en forme d'anneau de la sphère de Bloch. Cela est logique, car nous n'avons donné à l'ansatz qu'un seul paramètre de rotation. Il ne peut donc produire que des états tournés autour d'un axe. En partant du point $(0,0,1)$ et en tournant autour d'un axe, on obtient toujours un anneau. Vérifions ensuite notre deuxième ansatz, qui comporte deux portes de rotation orthogonales - Rx et Rz.

bloch_vectors = []

# Generate quantum states and extract Bloch vectors
for i in range(num_samples):
    # Create circuit and bind parameters
    qc = ansatz2
    bound_qc = qc.assign_parameters(
        {theta: theta_vals[i], phi: phi_vals[i]}
    )  # , lam: lam_vals[i]})
    state = Statevector.from_instruction(bound_qc)
    rho = DensityMatrix(state)

    X = rho.expectation_value(Pauli("X")).real
    Y = rho.expectation_value(Pauli("Y")).real
    Z = rho.expectation_value(Pauli("Z")).real
    bloch_vectors.append([X, Y, Z])  # Store X, Z components

# Convert to numpy array for plotting
bloch_vectors = np.array(bloch_vectors)

plot_bloch(bloch_vectors)

Output:

Ici, nous pouvons voir que notre deuxième ansatz couvre une plus grande partie de la sphère de Bloch - mais notez que les points sont plus concentrés autour des pôles et plus étalés autour de l'équateur. Il est maintenant temps de vérifier notre dernier ansatz.

bloch_vectors = []

# Generate quantum states and extract Bloch vectors
for i in range(num_samples):
    # Create circuit and bind parameters
    qc = ansatz3
    bound_qc = qc.assign_parameters(
        {theta: theta_vals[i], phi: phi_vals[i], lam: lam_vals[i]}
    )
    state = Statevector.from_instruction(bound_qc)
    rho = DensityMatrix(state)

    X = rho.expectation_value(Pauli("X")).real
    Y = rho.expectation_value(Pauli("Y")).real
    Z = rho.expectation_value(Pauli("Z")).real
    bloch_vectors.append([X, Y, Z])  # Store X, Z components

# Convert to numpy array for plotting
bloch_vectors = np.array(bloch_vectors)

plot_bloch(bloch_vectors)

Output:

Ici, vous pouvez voir des états quantiques plus uniformément distribués générés par notre dernier ansatz.

Comme indiqué, la meilleure chose à faire est d'acquérir des connaissances sur l'état fondamental que vous recherchez et d'utiliser un ansatz qui est bien adapté pour sonder les états proches de cet état fondamental. Par exemple, si nous savons que notre état fondamental est proche d'un pôle, nous pourrions choisir l'ansatz 2. Par souci de simplicité, nous nous en tiendrons à l'ansatz 3, qui sonde uniformément l'ensemble de la sphère de Bloch.

Maintenant que nous avons choisi notre ansatz, dessinons le circuit.

# Pre-defined ansatz circuit and operator class for Hamiltonian

ansatz = ansatz3

num_params = ansatz.num_parameters
print("This circuit has ", num_params, "parameters")

ansatz.draw("mpl", style="iqp")

Output:

This circuit has  3 parameters

Étape 2 : Optimisation pour le matériel cible

Lorsqu'on effectue un calcul sur un véritable ordinateur quantique, on ne se préoccupe pas seulement de la logique du circuit quantique. Nous nous intéressons également aux opérations qui peuvent être effectuées par cet ordinateur quantique particulier et à l'emplacement des qubits que nous utilisons sur l'ordinateur quantique. Sont-ils situés l'un à côté de l'autre? Sont-ils éloignés les uns des autres? L'étape suivante consiste donc à réécrire notre circuit en utilisant des portes naturelles pour l'ordinateur quantique que nous utiliserons, et en tenant compte de la disposition des qubits. Cela peut être fait par transpilation - après ce processus, vous pouvez voir notre simple ansatz converti en un ensemble différent de portes, et nos qubits abstraits seront mis en correspondance avec des qubits physiques sur un véritable ordinateur quantique.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

config = backend.configuration()

print("Backend: {config.backend_name}")
print("Native gates: ", config.supported_instructions, ",")


target = backend.target

pm = generate_preset_pass_manager(target=target, optimization_level=3)

ansatz_isa = pm.run(ansatz)

ansatz_isa.draw(output="mpl", idle_wires=False, style="iqp")

Output:

Backend: {config.backend_name}
Native gates:  ['ecr', 'id', 'delay', 'measure', 'reset', 'rz', 'sx', 'x'] ,

Vous pouvez voir que les portes rx, rz de notre ansatz ont été converties en une série de portes rz, sx , qui sont les portes natives de notre backend. Vous pouvez également voir que notre site q0 est maintenant mappé dans le cinquième qubit physique. Nous devons également adapter notre hamiltonien en fonction de ces changements, comme dans le code suivant :

Hamiltonian_isa = Hamiltonian.apply_layout(layout=ansatz_isa.layout)

Étape 3 : Exécuter sur le matériel cible

Il est maintenant temps de faire fonctionner notre VQE sur une véritable QPU. Pour cela, nous avons d'abord besoin d'une fonction de coût pour le processus d'optimisation, qui évalue la valeur d'espérance de l'hamiltonien avec un état quantique, généré par l'ansatz. Ne vous inquiétez pas ! Vous n'avez pas besoin de tout coder vous-même. Nous avons préparé une fonction pour cela, et tout ce que vous avez à faire est d'exécuter la cellule ci-dessous.

def cost_func(params, ansatz, hamiltonian, estimator):
    """Return estimate of energy from estimator

    Parameters:
        params (ndarray): Array of ansatz parameters
        ansatz (QuantumCircuit): Parameterized ansatz circuit
        hamiltonian (SparsePauliOp): Operator representation of Hamiltonian
        estimator (EstimatorV2): Estimator primitive instance
        cost_history_dict: Dictionary for storing intermediate results

    Returns:
        float: Energy estimate
    """
    pub = (ansatz, [hamiltonian], [params])
    result = estimator.run(pubs=[pub]).result()
    energy = result[0].data.evs[0]

    cost_history_dict["iters"] += 1
    cost_history_dict["prev_vector"] = params
    cost_history_dict["cost_history"].append(energy)
    print(f"Iters. done: {cost_history_dict['iters']} [Current cost: {energy}]")

    return energy

Enfin, nous préparons les paramètres initiaux pour notre ansatz et son processus d'optimisation. Vous pouvez simplement utiliser des zéros ou des valeurs aléatoires. Nous avons sélectionné les paramètres initiaux ci-dessous, mais n'hésitez pas à commenter ou décommenter les lignes de la cellule pour échantillonner les paramètres de manière aléatoire, uniformément de 0 à $2\pi$.

# x0 = np.random.uniform(0, 2*pi, 3)
x0 = [1, 1, 0]

# QPU Est. 2min for ibm_brisbane

from scipy.optimize import minimize
from qiskit_ibm_runtime import Batch

batch = Batch(backend=backend)

cost_history_dict = {
    "prev_vector": None,
    "iters": 0,
    "cost_history": [],
}
estimator = Estimator(mode=batch)
estimator.options.default_shots = 10000

res = minimize(
    cost_func,
    x0,
    args=(ansatz_isa, Hamiltonian_isa, estimator),
    method="cobyla",
    options={"maxiter": 10, "tol": 0.01},
)

batch.close()

Output:

Iters. done: 1 [Current cost: -0.3361517318448143]
Iters. done: 2 [Current cost: -0.4682546422099432]
Iters. done: 3 [Current cost: -0.38985802144149584]
Iters. done: 4 [Current cost: -0.38319217316749354]
Iters. done: 5 [Current cost: -0.4628720756579032]
Iters. done: 6 [Current cost: -0.4683301936226905]
Iters. done: 7 [Current cost: -0.45480498699294747]
Iters. done: 8 [Current cost: -0.4690533242050814]
Iters. done: 9 [Current cost: -0.465867415110354]
Iters. done: 10 [Current cost: -0.4606882723137227]

h_vqe = res.fun
print("The reference ground state energy is ", min(eigenvalues))
print("The computed ground state energy is ", h_vqe)

Output:

The reference ground state energy is  (-0.471+0j)
The computed ground state energy is  -0.4690533242050814

Félicitations ! Vous venez de terminer avec succès votre première expérience de chimie quantique. Nous pouvons constater une différence entre l'énergie exacte de l'état fondamental de l'hamiltonien et la nôtre, mais comme nous avons utilisé une technique d'atténuation des erreurs par défaut (qui corrige les erreurs de lecture), la différence est mineure. C'est un très bon début!

Remarque : vous pouvez obtenir un meilleur résultat en définissant un niveau d'atténuation des erreurs à l'aide de resilience_level. La valeur par défaut est 1; si vous définissez une valeur supérieure, cela mobilisera davantage de temps de calcul du QPU, mais pourrait donner un meilleur résultat.

Étape 4 : Post-traitement

Il est temps d'examiner le fonctionnement de notre optimiseur classique. Exécutez la cellule ci-dessous et observez le modèle de convergence.

fig, ax = plt.subplots()
x = np.linspace(0, 10, 10)

# Define the constant function
y_constant = np.full_like(x, h)
ax.plot(
    range(cost_history_dict["iters"]), cost_history_dict["cost_history"], label="VQE"
)
ax.set_xlabel("Iterations")
ax.set_ylabel("Cost (Hartree)")
ax.plot(y_constant, label="Target")
plt.legend()
plt.draw()

Output:

Nous sommes partis d'une valeur initiale assez bonne, de sorte que nous avons obtenu une bonne valeur finale en seulement 10 étapes. Vous pouvez voir des pics petits et grands, et c'est la caractéristique typique de l'optimiseur COBYLA - il cherche dans l'espace comme s'il ne voyait pas le paysage et ajuste la taille des pas à chaque mesure.

Vérifiez votre compréhension

Quelle est votre observation? Quelle partie du processus ci-dessus peut être améliorée afin d'obtenir des résultats plus proches des valeurs théoriques, ou plus proches de l'énergie précise de l'état fondamental de l'hamiltonien? Quels sont les éléments à prendre en compte à cet égard?

• Réponse

  La première chose à considérer est le changement de l'ensemble des bases utilisées dans le calcul de l'hamiltonien des molécules. Comme mentionné précédemment, l'énergie de l'état fondamental de l'atome H est -0.5 Hartree, comme on le sait, et la base STO-6G que nous avons choisie n'est pas suffisante pour dériver cette valeur avec précision.

  Le choix d'un type de base plus complexe augmente le nombre de qubits utilisés par l'hamiltonien; nous devons donc choisir un ansatz plus complexe et plus adapté aux problèmes de chimie.

  L'optimisation suivante concerne la gestion du bruit dans la QPU. Des techniques d'atténuation des erreurs plus avancées donnent de meilleurs résultats mais peuvent être plus longues à mettre en œuvre. Il faut également tenir compte de l'influence du site shot_number sur les résultats.

  Enfin, il est également possible d'obtenir une meilleure convergence en essayant différents optimiseurs.

Calculez l'énergie de l'état fondamental de la molécule d'hydrogène avec VQE

Maintenant que nous avons examiné le processus global de l'EQV en utilisant les atomes $H$, nous allons calculer plus rapidement l'énergie de l'état fondamental de la molécule $H_2$.

Étape 1 : Transposer le problème en circuits quantiques et opérateurs

Nous vous proposons également un hamiltonien à un qubit qui utilise la base STO-6G et la transformation de Jordan-Wigner, avec une réduction de qubit en utilisant une symétrie de l'hamiltonien. Notez que nous avons utilisé une distance atomique entre deux atomes d'hydrogène de 0.735 $\mathring A$.

Contrairement au calcul d'un seul atome d'hydrogène ( $H$ ), pour calculer l'état fondamental d'une molécule d'hydrogène ( $H_2$ ), il faut également tenir compte de la force de répulsion agissant entre les noyaux des deux atomes d'hydrogène, en plus de l'énergie associée aux orbitales électroniques. Dans cette étape, nous donnerons cette valeur comme une constante, et nous calculerons effectivement cette valeur dans le problème d'enregistrement. $\hat{H} = -1.04886 I + -0.79674 Z + 0.18122 X$

h2_hamiltonian = SparsePauliOp.from_list(
    [("I", -1.04886087), ("Z", -0.7967368), ("X", 0.18121804)]
)

# exact ground state energy of hamiltonian
nuclear_repulsion = 0.71997
A = np.array(h2_hamiltonian)
eigenvalues, eigenvectors = np.linalg.eig(A)
print("Electronic ground state energy (Hartree): ", min(eigenvalues).real)
print("Nuclear repulsion energy (Hartree): ", nuclear_repulsion)
print(
    "Total ground state energy (Hartree): ", min(eigenvalues).real + nuclear_repulsion
)
h2 = min(eigenvalues).real + nuclear_repulsion

Output:

Electronic ground state energy (Hartree):  -1.8659468547627318
Nuclear repulsion energy (Hartree):  0.71997
Total ground state energy (Hartree):  -1.1459768547627318

Étape 2 : Optimisation pour le matériel cible

Étant donné que le nombre de qubits utilisés par l'EQV et l'hamiltonien précédents est le même que le backend à utiliser pour l'exécution, nous utiliserons l'ansatz existant et sa forme optimisée.

h2_hamiltonian_isa = h2_hamiltonian.apply_layout(layout=ansatz_isa.layout)

Étape 3 : Exécuter sur le matériel cible

Il est maintenant temps d'effectuer les calculs sur la QPU réelle. Presque tout est identique, mais nous utiliserons le point initial approprié pour ajuster l'hamiltonien. De même, lors d'une partie itérative, certains paramètres de Estimator, qui est utilisé pour calculer les espérances de l'hamiltonien pour l'ansatz dans la QPU, seront réglés légèrement différemment des calculs précédents. Nous reviendrons sur ce changement dans une question d'enregistrement.

x0 = [2, 0, 0]

# QPU time 4min for ibm_brisbane
batch = Batch(backend=backend)

cost_history_dict = {
    "prev_vector": None,
    "iters": 0,
    "cost_history": [],
}
estimator = Estimator(mode=batch)
estimator.options.default_shots = 10000

res = minimize(
    cost_func,
    x0,
    args=(ansatz_isa, h2_hamiltonian_isa, estimator),
    method="cobyla",
    options={"maxiter": 15},
)

batch.close()

Output:

Iters. done: 1 [Current cost: -0.710621837568328]
Iters. done: 2 [Current cost: -0.2603208441168329]
Iters. done: 3 [Current cost: -0.25548711201326424]
Iters. done: 4 [Current cost: -0.581129450619904]
Iters. done: 5 [Current cost: -1.722920997605439]
Iters. done: 6 [Current cost: -1.6633324849371915]
Iters. done: 7 [Current cost: -1.8066989598929164]
Iters. done: 8 [Current cost: -1.8051093803839542]
Iters. done: 9 [Current cost: -1.802692217571555]
Iters. done: 10 [Current cost: -1.8233585485263144]
Iters. done: 11 [Current cost: -1.6904116652617205]
Iters. done: 12 [Current cost: -1.8245120321245392]
Iters. done: 13 [Current cost: -1.6837021361383608]
Iters. done: 14 [Current cost: -1.8166632606115467]
Iters. done: 15 [Current cost: -1.863446212658907]

h2_vqe = res.fun + nuclear_repulsion
print(
    "The reference ground state energy is ", min(eigenvalues).real + nuclear_repulsion
)
print("The computed ground state energy is ", h2_vqe)

Output:

The reference ground state energy is  -1.1459768547627318
The computed ground state energy is  -1.143476212658907

Bien que la VQE fournisse théoriquement une limite supérieure à l'énergie réelle de l'état fondamental, les mises en œuvre pratiques sur du matériel quantique réel ou simulé bruyant, ainsi que les approximations faites lors de la préparation de l'hamiltonien (comme les ensembles de bases ou la réduction des qubits), peuvent introduire des erreurs qui se traduisent parfois par une énergie mesurée légèrement inférieure à la valeur théorique exacte ou à une référence numérique spécifique. Bien qu'il y ait quelques erreurs, les résultats semblent satisfaisants, surtout si l'on tient compte du petit nombre d'étapes. Terminons maintenant ce calcul de la VQE en examinant le fonctionnement de l'optimiseur.

Étape 4 : Post-traitement

fig, ax = plt.subplots()
x = np.linspace(0, 5, 15)

# Define the constant function
y_constant = np.full_like(x, min(eigenvalues))
ax.plot(
    range(cost_history_dict["iters"]), cost_history_dict["cost_history"], label="VQE"
)
ax.set_xlabel("Iterations")
ax.set_ylabel("Cost (Hartree)")
ax.plot(y_constant, label="Target")
plt.legend()
plt.draw()

Output:

Vérifiez votre compréhension

Calculons l'énergie de répulsion nucléaire de la molécule $H_2$, que nous avons incluse comme valeur constante ( 0.71997 Hartree).

Veuillez utiliser la loi de Coulomb et les unités atomiques pour vous assurer d'obtenir la valeur en Hartree.

• Réponse

  Les deux noyaux d'hydrogène étant chargés positivement, ils se repoussent l'un l'autre en raison de la force électrostatique. Cette répulsion est décrite par la loi de Coulomb :

  $E_{repulsive} = \frac{e^2}{4\pi\epsilon_0R}$

  où $e$ est la charge du proton, $\epsilon_0$ est la permittivité du vide et $R$ est la distance entre les deux noyaux, mesurée en mètres ou en rayons de Bohr en unité de joules (J).

  Pour calculer cette énergie en Hartrees, nous devons convertir l'équation ci-dessus dans le système des unités atomiques (UA). En UA, $e^2 = 1$, $4\pi\epsilon_0=1$ et le rayon de Bohr ( $a_0$ ) est égal à 1 et devient l'échelle de longueur fondamentale en UA. Avec ces simplifications, la loi de Coulomb se réduit à :

  $E_{repulsion} = \frac{1}{R}$

  où $R$ doit être mesuré en rayons de Bohr ( $a_0$ ).

  Pour convertir la séparation nucléaire donnée dans $\r{A}$ en $a_0$, nous avons besoin de cette relation de conversion :

  $1\r{A} = 1.88973 a_0$

  ainsi, $0.735\r{A}$ devient $0.735 * 1.88973 = 1.38895 a_0$.

  Par conséquent, l'énergie de répulsion nucléaire d'un site $H_2$ donné est la suivante

  $E_{repulsion} = \frac{1}{R} = \frac{1}{1.38895} = 0.71997 Hartree$

Calculer l'énergie de réaction de l' $H + H = H_2$

Utilisons maintenant ce que nous avons obtenu! Vous avez utilisé VQE, un résolveur quantique variationnel, pour calculer l'énergie de l'état fondamental de l'atome $H$ et de la molécule $H_2$. Il reste à utiliser les valeurs calculées pour obtenir l'énergie de réaction du processus $H+H=H_2$.

L'énergie de réaction est le changement d'énergie qui se produit lorsque des substances réagissent pour former de nouvelles substances. Imaginez que vous construisiez quelque chose : parfois vous devez y mettre de l'énergie (comme en empilant des blocs), et parfois l'énergie est libérée (comme une balle qui dévale une pente). En chimie, les réactions absorbent de l'énergie (endothermique) ou en libèrent (exothermique).

L'énergie de réaction du processus $H+H = H_2$ peut être calculée par la formule suivante :

$E_{reaction} = E_{H_2} - (E_H + E_H)$

En exécutant la cellule ci-dessous, nous pouvons le constater visuellement. Nous utiliserons ici la valeur exacte de l'état fondamental de chaque hamiltonien, et nous comparerons l'énergie de réaction de la solution exacte et les résultats de VQE.

# Theoretical values
E_H_theo = h.real
E_H2_theo = h2

# Experimental values
E_H_exp = h_vqe
E_H2_exp = h2_vqe

# Calculate reaction energies
E_reaction_theo = E_H2_theo - (2 * E_H_theo)
E_reaction_exp = E_H2_exp - (2 * E_H_exp)

# Set up the plot
fig, ax = plt.subplots(figsize=(8, 6))
ax.set_xlim(0, 3)
ax.set_ylim(-1.16, -0.93)  # Adjust y-axis range to highlight differences
ax.set_xticks([])
ax.set_ylabel("Energy (Hartree)")
ax.set_title("H + H → H₂ Reaction Energy Diagram")

# Plot theoretical energy levels
ax.hlines(
    y=2 * E_H_theo, xmin=0.5, xmax=1.3, linewidth=2, color="r", label="2H (Exact)"
)
ax.hlines(y=E_H2_theo, xmin=1.3, xmax=2, linewidth=2, color="b", label="H₂ (Exact)")

# Plot experimental energy levels
ax.hlines(
    y=2 * E_H_exp,
    xmin=0.5,
    xmax=1.5,
    linewidth=2,
    color="r",
    linestyle="dashed",
    label="2H (VQE)",
)
ax.hlines(
    y=E_H2_exp,
    xmin=1.5,
    xmax=2.5,
    linewidth=2,
    color="b",
    linestyle="dashed",
    label="H₂ (VQE)",
)

# Add labels
ax.text(
    1,
    2 * E_H_theo,
    f"2H: {2*E_H_theo:.4f}",
    verticalalignment="top",
    horizontalalignment="left",
)
ax.text(
    2,
    E_H2_theo,
    f"H₂: {E_H2_theo:.4f}",
    verticalalignment="top",
    horizontalalignment="left",
)
ax.text(
    1,
    2 * E_H_exp,
    f"2H_VQE: {2*E_H_exp:.4f}",
    verticalalignment="bottom",
    horizontalalignment="right",
)
ax.text(
    2,
    E_H2_exp,
    f"H₂_VQE: {E_H2_exp:.4f}",
    verticalalignment="bottom",
    horizontalalignment="right",
)

# Add arrows for reaction energy with ΔE label in the middle
mid_y_theo = (2 * E_H_theo + E_H2_theo) / 2
mid_y_exp = (2 * E_H_exp + E_H2_exp) / 2
ax.annotate(
    "",
    xy=(1.3, E_H2_theo),
    xytext=(1.3, 2 * E_H_theo),
    arrowprops=dict(arrowstyle="<->", color="g"),
)
ax.text(
    1.35, mid_y_theo, f"ΔE: {E_reaction_theo:.4f}", color="g", verticalalignment="top"
)

ax.annotate(
    "",
    xy=(1.5, E_H2_exp),
    xytext=(1.5, 2 * E_H_exp),
    arrowprops=dict(arrowstyle="<->", color="g", linestyle="dashed"),
)
ax.text(
    1.55,
    mid_y_exp,
    f"ΔE_VQE: {E_reaction_exp:.4f}",
    color="g",
    verticalalignment="center",
)

# Add legend
ax.legend()

plt.show()

Output:

Comme le montre la figure, malgré quelques erreurs, l'énergie exacte de l'état fondamental des hamiltoniens et l'énergie de réaction calculée à l'aide des résultats de la VQE sont similaires, proches de -0.2 Hartree.

Il convient de noter ici que l'énergie de réaction de ce processus a une valeur négative, ce qui signifie que l'énergie est libérée par le processus et que la molécule résultante a une énergie inférieure à celle de deux atomes simples.

6. Conclusion

Résumons ce que nous avons appris jusqu'à présent.

Nous avons d'abord examiné deux techniques d'approximation importantes nécessaires pour résoudre les problèmes de chimie quantique : le principe variationnel et les choix d'ensembles de base, qui sont tous deux fondamentaux pour la VQE. Nous avons exploré le principe variationnel à la main, en calculant l'énergie de l'état fondamental de l'oscillateur harmonique simple.

Ensuite, nous avons exploré VQE, un algorithme largement utilisé pour calculer l'énergie de l'état fondamental d'un système quantique. Nous avons exécuté un code pour calculer les énergies de l'état fondamental de l'hydrogène atomique ( $H$ ) et de la molécule d'hydrogène ( $H_2$ ). Nous avons notamment appris qu'il est nécessaire d'obtenir l'hamiltonien moléculaire approprié pour le système et de le transformer en une forme exécutable sur un ordinateur quantique. Nous avons également vu que l'ansatz, un circuit quantique paramétré, est nécessaire pour préparer les états quantiques d'essai dans le cadre de l'EQV, et nous avons discuté de l'importance de choisir une structure de circuit d'ansatz appropriée. Nous avons également appris que la VQE repose sur un processus d'optimisation itératif utilisant un ordinateur classique, guidant le circuit quantique pour trouver l'état d'énergie le plus bas, et nous avons vu comment le processus converge.

Enfin, nous avons utilisé les énergies calculées de l'état fondamental de $H$ et $H_2$ obtenues par VQE pour calculer l'énergie de réaction pour le processus $H + H \rightarrow H_2$.

VQE est un algorithme quantique puissant à court terme, mais il est important d'être conscient de ses limites. Les performances de la VQE dépendent fortement du choix de l'ansatz - la recherche d'un ansatz pouvant être préparé efficacement et représentant avec précision l'état fondamental réel devient un défi pour les molécules plus grandes et plus complexes. En outre, le matériel quantique actuel est sensible au bruit, ce qui peut avoir un impact sur la précision des résultats de l'EQV, en particulier pour les circuits plus profonds ou pour un plus grand nombre de qubits. Malgré ces difficultés, VQE sert d'algorithme de base et les recherches en cours explorent des méthodes variationnelles plus sophistiquées et des techniques d'atténuation des erreurs afin de repousser les limites de ce qui est possible en chimie quantique sur des ordinateurs quantiques à court terme. Par exemple, des algorithmes tels que la diagonalisation quantique basée sur les échantillons (SQD) sont en cours de développement. Ils exploitent les échantillons obtenus à partir de circuits quantiques combinés à une diagonalisation classique dans un sous-espace afin d'améliorer l'estimation de l'énergie et de remédier à certaines des limitations auxquelles est confrontée la VQE, notamment en ce qui concerne l'efficacité de la mesure et la robustesse au bruit.

Révision et questions

Concepts essentiels :

• L'algorithme quantique variationnel est un paradigme informatique dans lequel un ordinateur classique et un ordinateur quantique travaillent ensemble pour résoudre un problème.
• Dans VQE, nous partons d'un hamiltonien de notre système et nous le transposons sur des qubits pour l'exécuter sur l'ordinateur quantique. Nous sélectionnons un circuit quantique paramétré, un ansatz, et effectuons des mesures répétées, en faisant varier les paramètres de l'ansatz, jusqu'à ce que la valeur d'énergie la plus basse soit atteinte. La recherche dans l'espace des paramètres est effectuée à l'aide d'un optimiseur classique. Pour obtenir de bons résultats, il est nécessaire de sélectionner un bon ansatz et un optimiseur approprié.
• L'énergie de réaction est la variation totale d'énergie dans une réaction chimique, déterminée par la différence entre l'énergie des réactifs et celle des produits.

true/false

1. Le principe variationnel stipule que la valeur espérée de l'énergie pour toute fonction d'onde d'essai est toujours supérieure ou égale à l'énergie réelle de l'état fondamental.
2. Un ensemble de bases est une collection de fonctions utilisées pour approximer les fonctions d'onde quantiques.
3. VQE est un algorithme quantique utilisé pour résoudre exactement l'équation de Schrödinger pour un hamiltonien donné.
4. Dans l'EQV, un circuit quantique paramétré (un ansatz) est utilisé pour préparer les fonctions d'onde d'essai.
5. Le choix de l'optimiseur dans VQE (par exemple, COBYLA, SPSA ou ADAM) n'a pas d'incidence sur la qualité du résultat.
6. Qiskit's Estimator est utilisé pour calculer directement les valeurs d'espérance des hamiltoniens dans VQE.

Questions à choix multiples :

1. À quoi sert l'hamiltonien dans VQE?

• A) Générer des états quantiques aléatoires
• B) Déterminer l'énergie des états quantiques
• C) Optimiser les circuits quantiques
• D) Créer un enchevêtrement

2. Quel est l'objectif principal de l'algorithme VQE?

• A) Trouver l'énergie de l'état fondamental d'un hamiltonien
• B) Créer une intrication entre les qubits
• C) Effectuer la recherche de Grover
• D) Pour casser le cryptage RSA

3. Combien d'états quantiques sont générés dans ce cahier pour comparer l'ansatz?

• A) 100
• B) 1000
• C) 5000
• D) 10,000

4. Pourquoi un optimiseur classique est-il nécessaire dans VQE?

• A) Effectuer des mesures quantiques
• B) Mise à jour des paramètres de l'ansatz pour minimiser l'énergie
• C) Enchevêtrer des qubits
• D) Générer un hasard quantique

5. Pourquoi l'ansatz est-il conçu pour être paramétré?

• A) Permettre la préparation de l'état quantique
• B) Permettre la recherche d'un large espace d'états quantiques
• C) Réduire la complexité des circuits
• D) Mesurer directement les valeurs propres

6. Laquelle des affirmations suivantes est la plus correcte concernant le choix d'un bon ansatz?

• A) Un ansatz doit produire des états uniformément répartis sur la sphère de Bloch, sinon il échoue.
• B) Un ansatz doit être adapté à votre système pour s'assurer qu'il peut générer des états proches de l'état fondamental.
• C) Un ansatz doit produire des états aléatoires en utilisant ses paramètres variationnels.
• D) Un meilleur ansatz a toujours plus de paramètres variationnels.

(Facultatif) Annexe : Surcoût de l'optimiseur en fonction de la complexité de l'approche

La VQE est confrontée à plusieurs défis bien connusref [6], et les suivants sont liés à ce que nous avons appris ci-dessus.

1. Défis liés à la sélection de l'Ansatz

Le choix du bon ansatz variationnel constitue un défi inhérent. Les réponses inspirées de la chimie (comme l'UCCSD) offrent une précision physique mais nécessitent des circuits profonds, tandis que les réponses efficaces sur le plan matériel ont des circuits moins profonds mais peuvent manquer d'interprétabilité physique. En outre, de nombreuses réponses introduisent des paramètres variationnels excessifs qui contribuent peu à l'amélioration de la précision mais augmentent considérablement la difficulté de l'optimisation.

2. Difficultés d'optimisation

Le paysage d'optimisation de la VQE peut comporter des régions où les gradients disparaissent de manière exponentielle (plateaux stériles), ce qui rend difficile la mise à jour efficace des paramètres variationnels par les optimiseurs classiques. Pour ce faire, les chercheurs ont essayé d'utiliser différents types d'optimiseurs - basés sur le gradient et sans gradient, mais tous deux sont confrontés à des difficultés. Les optimiseurs basés sur le gradient souffrent de plateaux stériles, tandis que les méthodes sans gradient nécessitent un grand nombre d'évaluations de fonctions.

3. Frais généraux de l'optimiseur

Un autre défi bien connu est celui de la surcharge de l'optimiseur, qui est liée à l'échelle du problème. Les circuits quantiques requis pour la VQE gagnent en profondeur et en complexité à mesure que la taille du problème augmente, ce qui accroît également le nombre de paramètres à optimiser. Le processus d'optimisation devient difficile lorsque le nombre de paramètres augmente, ce qui entraîne une convergence lente et des difficultés à trouver la solution optimale.

Nous allons examiner ces défis en utilisant VQE pour une molécule $H_2$, avec deux types différents de réponses.

(Remarque : cette opération peut prendre plus de temps à la QPU; n'hésitez donc pas à utiliser un simulateur si vous ne disposez pas de suffisamment de temps)

from qiskit.circuit import ParameterVector

num_iter = 4
alpha = ParameterVector("alpha", 3)
beta = ParameterVector("beta", 3 * num_iter)

# step1: Map problem to quantum circuits and operators
hamiltonian = SparsePauliOp.from_list(
    [("I", -1.04886087), ("Z", -0.7967368), ("X", 0.18121804)]
)

ansatz_1 = ansatz3
ansatz_2 = QuantumCircuit(1)
for i in range(num_iter):
    ansatz_2.rx(beta[i * 3 + 0], 0)
    ansatz_2.rz(beta[i * 3 + 1], 0)
    ansatz_2.rx(beta[i * 3 + 2], 0)

ansatz_1.draw("mpl")

Output:

ansatz_2.draw("mpl")

Output:

# Step 2: Optimize for target hardware

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

ansatz_isa_1 = pm.run(ansatz_1)
ansatz_isa_2 = pm.run(ansatz_2)
hamiltonian_isa_1 = hamiltonian.apply_layout(layout=ansatz_isa_1.layout)
hamiltonian_isa_2 = hamiltonian.apply_layout(layout=ansatz_isa_2.layout)

Exécutons maintenant une EQV avec un point initial composé de tous les 1, avec un maximum de 20 étapes, et comparons la convergence des deux exécutions.

# QPU time 3m 40s for ibm_brisbane
# Step 3: Execute on target hardware

from scipy.optimize import minimize

x0 = np.ones(ansatz_1.num_parameters)

batch = Batch(backend=backend)


cost_history_dict = {
    "prev_vector": None,
    "iters": 0,
    "cost_history": [],
}
estimator = Estimator(mode=batch)
estimator.options.default_shots = 2048

res = minimize(
    cost_func,
    x0,
    args=(ansatz_isa_1, hamiltonian_isa_1, estimator),
    method="cobyla",
    options={"maxiter": 20},
)

batch.close()

Output:

Iters. done: 1 [Current cost: -0.8782202668652658]
Iters. done: 2 [Current cost: -0.43473160695469165]
Iters. done: 3 [Current cost: -0.4076372093159749]
Iters. done: 4 [Current cost: -1.3587839859772106]
Iters. done: 5 [Current cost: -1.774529906754082]
Iters. done: 6 [Current cost: -1.541934983115727]
Iters. done: 7 [Current cost: -1.2732403113465345]
Iters. done: 8 [Current cost: -1.820842221085785]
Iters. done: 9 [Current cost: -1.8065762857059005]
Iters. done: 10 [Current cost: -1.8126394095981146]
Iters. done: 11 [Current cost: -1.8205831886180421]
Iters. done: 12 [Current cost: -1.8086715778994924]
Iters. done: 13 [Current cost: -1.8307676638629322]
Iters. done: 14 [Current cost: -1.8177328827556327]
Iters. done: 15 [Current cost: -1.8179426218088064]
Iters. done: 16 [Current cost: -1.8109239667991088]
Iters. done: 17 [Current cost: -1.824271872489647]
Iters. done: 18 [Current cost: -1.813167587671394]
Iters. done: 19 [Current cost: -1.824647343397313]
Iters. done: 20 [Current cost: -1.8219785311686143]

# Save Cost_history as a new list
ansatz_1_history = cost_history_dict["cost_history"]

# QPU time 3m 40s for ibm_brisbane

x0 = np.ones(ansatz_2.num_parameters)

batch = Batch(backend=backend)


cost_history_dict = {
    "prev_vector": None,
    "iters": 0,
    "cost_history": [],
}
estimator = Estimator(mode=batch)
estimator.options.default_shots = 2048

res = minimize(
    cost_func,
    x0,
    args=(ansatz_isa_2, hamiltonian_isa_2, estimator),
    method="cobyla",
    options={"maxiter": 20},
)

batch.close()

Output:

Iters. done: 1 [Current cost: -0.738191173881188]
Iters. done: 2 [Current cost: -0.42636037194506304]
Iters. done: 3 [Current cost: -1.3503788613797374]
Iters. done: 4 [Current cost: -0.9109204349776897]
Iters. done: 5 [Current cost: -0.9060873157510835]
Iters. done: 6 [Current cost: -0.7735065414083984]
Iters. done: 7 [Current cost: -1.586889197437709]
Iters. done: 8 [Current cost: -1.659215191584943]
Iters. done: 9 [Current cost: -1.245445981794618]
Iters. done: 10 [Current cost: -1.1608385766138023]
Iters. done: 11 [Current cost: -1.1551733876027737]
Iters. done: 12 [Current cost: -1.8143337768286332]
Iters. done: 13 [Current cost: -1.2510951563756598]
Iters. done: 14 [Current cost: -1.6918311531865413]
Iters. done: 15 [Current cost: -1.8163783305531838]
Iters. done: 16 [Current cost: -1.8434877732947152]
Iters. done: 17 [Current cost: -1.8461898233304472]
Iters. done: 18 [Current cost: -1.0346471214915485]
Iters. done: 19 [Current cost: -1.8322518854150687]
Iters. done: 20 [Current cost: -1.717144678705999]

ansatz_2_history = cost_history_dict["cost_history"]

fig, ax = plt.subplots()

# Define the constant function)
ax.plot(
    range(cost_history_dict["iters"]),
    ansatz_1_history,
    label="Ansatz with 3 parameters",
)
ax.plot(
    range(cost_history_dict["iters"]),
    ansatz_2_history,
    label="Ansatz with 12 parameters",
)
ax.set_xlabel("Iterations")
ax.set_ylabel("Cost (Hartree)")
plt.legend()
plt.draw()

Output:

Le graphique ci-dessus montre clairement que le processus d'optimisation de l'ansatz avec plus de variables prend plus de temps pour atteindre une convergence stable.

Plutôt que de s'appuyer sur des circuits simples à un seul qubit et sur un ansatz direct, la complexité de l'optimisation augmente lorsque des circuits quantiques plus importants et des ansätze structurés plus complexes sont nécessaires. Cela met en évidence un problème bien connu dans les VQE : la surcharge de l'optimiseur.

Les chercheurs continuent à développer diverses méthodologies avancées permettant d'utiliser les ordinateurs quantiques pour résoudre des problèmes chimiques. Vous pouvez accéder à divers supports pédagogiques sur IBM Quantum Learning.

Références

• [ref 1 ] Richard P. Feynman, Simulating Physics with Computers, International Journal of Theoretical Physics, 1982.
• [réf. 2] Marov, M.Y. (2015). La structure de l'univers. Dans : Les fondements de l'astrophysique moderne. Springer, New York, NY.
• [ref 3 ] Comment résoudre les problèmes difficiles du génie chimique avec l'informatique quantique, IBM Research Blog, 2023.
• [réf. 4 ] Y. Cao, J. Romero et A. Aspuru-Guzik, "Potential of quantum computing for drug discovery," in IBM Journal of Research and Development, vol. 62, no. 6, pp. 6:1-6:20, 1 Nov.-Dec. 2018
• [réf. 5 ] État actuel du calcul de la structure moléculaire, REv. Mod. Physique. 32, 170, 1960
• [réf. 6 ] Fedorov, D.A.., Peng, B., Govind, N. et al. Méthode VQE : bref aperçu et développements récents. Mater Theory 6, 2 (2022)