Repousser les limites de l’informatique quantique appliquée à la chimie

Cet article s’adresse aux lecteurs techniques qui explorent l’intersection entre l’informatique quantique et la chimie computationnelle. Si vous êtes familier avec les circuits quantiques, la modélisation moléculaire ou les frameworks de machine learning comme PennyLane, cette exploration en profondeur est faite pour vous. Et si vous étudiez ces concepts dans votre propre organisation, nous serions ravis de vous aider à démarrer.

Ce que nous allons aborder

La chimie quantique a le potentiel de transformer la façon dont nous concevons de nouveaux matériaux, développons des médicaments plus efficaces et relevons des défis industriels complexes, de l’énergie propre à la fabrication avancée.En termes simples, la chimie quantique applique les principes de la mécanique quantique pour calculer comment les molécules se forment, se lient et interagissent — une tâche notoirement difficile à grande échelle pour les ordinateurs classiques.

Appliquer l’informatique quantique à la chimie ouvre de nouvelles manières d’estimer les énergies de liaison et les distances interatomiques (et c’est justement ce que nous explorons dans cet article).Nous commencerons par un rappel des concepts clés en informatique quantique : comment les qubits (l’équivalent quantique des bits classiques) sont représentés sur la sphère de Bloch et comment les portes quantiques modifient leur état. Ensuite, nous passerons à la pratique : coder un problème de chimie quantique avec PennyLane, une bibliothèque dédiée à l’apprentissage automatique quantique hybride.

Notre exploration commence avec la molécule complexe Cyanex272, mettant en lumière les défis liés à la gestion de ses 54 atomes et 162 électrons dans les limites actuelles des simulations quantiques. L’approche consiste à importer les géométries moléculaires dans PennyLane, à construire des états Hartree-Fock pour représenter les configurations électroniques dans les orbitales atomiques, puis à appliquer des excitations électroniques simples et doubles afin de simuler des superpositions quantiques. L’Hamiltonien moléculaire est ensuite calculé et utilisé pour estimer l’énergie totale du système, l’optimisation par descente de gradient aidant à trouver l’état d’énergie le plus bas, correspondant à la configuration moléculaire la plus probable.

Notre étude examine également comment la réduction de l’espace actif, le choix des bases (basis sets) et les excitations électroniques influencent la complexité computationnelle et la précision des résultats, en utilisant des molécules plus simples comme CH₄ et CH₃ comme modèles. Au fil du processus, divers défis se sont présentés, allant des limites en ressources informatiques aux divergences dans les coordonnées moléculaires selon les sources de données.

Enfin, nous réfléchissons au potentiel futur de l’informatique quantique face aux grappes de GPU pour traiter les calculs complexes de chimie quantique, et spéculons même sur les implications métaphysiques de la manipulation de systèmes quantiques. Bien que la montée en échelle des simulations pour de grandes molécules reste un défi majeur, un socle méthodologique commence à émerger pour l’application de l’informatique quantique aux problèmes chimiques — ouvrant la voie à de futures recherches en expansion de sous-espace quantique, calcul de propriétés moléculaires et estimation de phase quantique.

Informatique quantique : les bases

L’informatique quantique peut être décrite de nombreuses façons, mais au fond, il s’agit d’un mode de calcul qui mobilise l’ensemble des outils mathématiques connus, tout en reposant sur du matériel extrêmement sophistiqué pour effectuer les calculs nécessaires.

Un ordinateur quantique y parvient en exploitant les propriétés de particules étudiées en physique : photons, électrons, atomes, voire des structures moléculaires plus grandes (comme la particule de Majorana développée par Microsoft). Les particules dont on manipule les propriétés en informatique quantique sont souvent regroupées en unités appelées « qubits logiques ».

Lorsque plusieurs particules sont combinées pour former un qubit logique, les calculs deviennent plus robustes face aux erreurs. Un système de grande taille peut également former ce qu’on appelle un qubit topologique. Mais au final, ce que nous avons, c’est un qubit — l’équivalent quantique bien connu du « bit » classique.

Ce qui rend un qubit remarquable, c’est sa capacité à représenter une infinité d’états à l’aide de seulement deux nombres. L’état d’un qubit peut être illustré par ce qu’on appelle une sphère de Bloch — un modèle en 3D qui représente tous les états possibles d’un qubit, répartis sur la surface d’une sphère (voir image ci-dessous).

‍

La sphère de Bloch, comme vous pouvez le voir, possède trois axes : X, Y et Z. Elle est donc définie par trois coordonnées, ainsi que par les angles {θ, ϕ}. Le point situé à la surface de la sphère représente la valeur du qubit. Chaque point sur cette surface a des coordonnées uniques. En langage mathématique, l’état ou la position d’un qubit peut être représenté par un nombre complexe (une seule valeur composée de deux nombres — un pour chaque angle de sa position). Ce qu’il faut retenir, c’est que l’état d’un qubit est représenté par un seul point sur la surface d’une sphère.

On peut effectuer des opérations sur les qubits à l’aide de « portes logiques », telles que des rotations selon un axe, des inversions de bit (bit-flip), ou encore des portes conditionnelles (du type « si ceci, alors cela »). Si vous imaginez un point sur la surface d’une sphère, vous pouvez visualiser le fait de faire tourner cette sphère dans n’importe quelle direction : le point tournera avec elle. Une inversion de bit correspond à une rotation du qubit autour d’un de ses axes.

Je ne vais pas entrer dans les détails des portes logiques de bas niveau, mais il en existe beaucoup. Chaque porte agit sur un ou plusieurs qubits. Comme avec les ordinateurs classiques, il existe un ensemble d’opérations de base que l’on peut appliquer à un qubit. Il suffit ensuite de combiner ces portes pour créer des opérations plus complexes. Mais pour résoudre des problèmes complexes, il faut appliquer ces opérations simples à un très grand nombre de qubits.

Prenons une image, un graphique ou tout autre fichier visuel stocké sur un ordinateur : une taille typique de fichier serait d’environ 4 mégaoctets, soit environ 32 millions de bits. Une seule image nécessite des millions de 0 et de 1 pour être représentée. Nous encodons cet ensemble de bits à l’aide de divers formats de fichiers.

Mais voilà ce qui est fascinant : contrairement à un bit classique, un seul qubit peut représenter une infinité de valeurs. Il n’aura qu’un seul état à un moment donné, mais il peut en coder une infinité. Cela s’explique par le fait qu’il y a une infinité de points à la surface d’une sphère. La seule chose dont nous avons besoin, ce sont des coordonnées plus précises (les angles {θ, ϕ}). Une faible précision donne peu de points sur la sphère, tandis qu’une haute précision permet d’en obtenir beaucoup plus.

Si vous avez déjà fait du rendu 3D, cela correspond au niveau de subdivision, au niveau de détail, à la tessellation ou à la résolution. En pratique cependant, un qubit ne peut pas avoir une infinité d’états. Nous ne disposons tout simplement pas de cette précision, en raison des limites imposées par la physique. Mais je m’égare…

Pour résumer :

• Un qubit est un objet mathématique construit à partir de particules physiques telles que des photons, électrons, protons, molécules, etc.
• Son état est représenté comme un point à la surface de la sphère de Bloch.
• Un qubit existe en superposition, ce qui signifie qu'il peut représenter plusieurs états simultanément.
• Lors de la mesure d'un qubit, nous obtenons une probabilité de le trouver dans un état spécifique (|0> ou |1>).
• Étant donné que les mesures quantiques sont probabilistiques, il est nécessaire de réaliser plusieurs mesures pour obtenir des résultats fiables.

C’est une question profondément philosophique de réfléchir à l’imprévisibilité réelle de notre univers. Après tout, lorsque vous générez des nombres aléatoires sur un ordinateur classique, vous avez toujours besoin d’une valeur “graine” initiale pour commencer.

Une des questions auxquelles je réfléchis depuis plusieurs années, et à laquelle vous vous êtes peut-être aussi posé cette question, est : quels types de problèmes pouvons-nous réellement résoudre avec l’informatique quantique ? Au-delà de la protection de nos nombres aléatoires contre la décryption, bien sûr.

Pour moi, l’un des problèmes les plus fascinants est de comprendre pourquoi il est plus favorable pour les molécules de se former que pour les atomes de rester isolés.

Pour explorer cette question, nous devons déplacer notre focus des qubits vers la chimie.

Transformer la théorie quantique en compréhension chimique

Pour mettre l'informatique quantique à l'épreuve, j'ai cherché à répondre à une grande question : comment les molécules se maintiennent-elles ensemble, et comment pouvons-nous calculer cela en utilisant des qubits ?

La molécule sur laquelle je me suis concentré s'appelle Cyanex272. C'est une molécule organique complexe avec laquelle j'ai travaillé indirectement dans un autre projet d'informatique quantique.

Cyanex272 présente les propriétés suivantes :

• Formule : C16H35O2P
• ‍Atomes : 54
• ‍Protons : 162
• ‍Électrons : 162
• ‍Orbitales atomiques : 134
• ‍Hydrophobe en raison de ses longs groupes Carbone-Hydrogène (CH)
• Possède un seul site actif au niveau du groupe Oxygène-Hydrogène (OH)
  
  • Le site actif se lie généralement à des ions métalliques tels que le Cobalt et le Nickel
  • Dans un environnement à faible pH, l'Oxygène se lie à un hydrogène ionisé (proton) pour former un groupe OH
  • Dans un environnement à pH élevé, l'Hydrogène est généralement libéré, et l'Oxygène préfère se lier aux ions métalliques
• Deux molécules de Cyanex272 se coordonnent avec un ion métallique via le site actif
  
  • Haute sélectivité pour le Cobalt et le Nickel

Mise en place de l'environnement - Dépendances Python

Pour réaliser ces expériences en chimie quantique, j'ai utilisé Python, le langage de programmation incontournable pour le calcul scientifique, accompagné de PennyLane, une bibliothèque spécialement conçue pour l'apprentissage machine hybride quantique et classique. PennyLane offre des outils pour construire des circuits quantiques, simuler des molécules et calculer des énergies à l'aide d'algorithmes quantiques. C'est le pont entre la théorie et le code dans ce projet.

Je vais éviter de détailler l'installation d'un environnement virtuel Python, car le véritable défi ne résidait pas dans la création de l'environnement, mais dans le fait de faire fonctionner les dépendances ensemble.

Comme beaucoup d'autres aspects de l'informatique quantique, cette partie du processus ressemble encore un peu à un Far West. Tous les articles que j'ai lus pour mes recherches étaient basés sur la documentation de PennyLane, mais quand j'ai commencé, je pensais que je pouvais simplement installer les dernières versions de tous les packages dont j'avais besoin avec pip. Ah, quelle erreur !

Il m'a fallu presque une journée (et beaucoup d'essais et erreurs) pour réaliser que chaque dépendance était une version v0—ce qui signifie qu'à chaque changement majeur de version, il y a des changements incompatibles. Certaines versions ne fonctionnent que sur des distributions Linux spécifiques. D'autres ne sont pas du tout compatibles entre elles.

La seule solution fiable que j'ai trouvée a été d'utiliser un conteneur Docker avec un ancien jeu de dépendances qui correspondait au code source du dépôt PennyLane sur lequel je travaillais.C'est la réalité d'un domaine de pointe. Les choses avancent vite, et la stabilité n'est pas garantie.

Je ne vais pas lister toutes les dépendances ici (elles seront probablement obsolètes au moment où vous lirez cela), mais voici la sortie exacte de pip freeze.

Préparation pour la première exécution de chimie quantique

Après avoir parcouru quelques démonstrations et articles de PennyLane, j'avais un plan initial solide en tête. Voici le processus que j'ai suivi et les étapes clés pour réaliser une simulation de chimie quantique avec PennyLane :

1. Importer la géométrie de la molécule dans PennyLane
2. Construire l'état Hartree-Fock (HF) pour représenter les électrons dans les orbitales atomiques
3. Appliquer des excitations simples et doubles pour simuler le mouvement des électrons et la superposition
4. Calculer le Hamiltonien moléculaire pour estimer l'énergie totale du système
5. Utiliser la descente de gradient pour optimiser le système vers son état d'énergie minimale

Étape 1 : Importer la géométrie moléculaire dans PennyLane

La première étape consiste généralement à décrire la molécule avec laquelle vous travaillez, ses symboles atomiques (H, Co, O, C, etc.), ainsi que les coordonnées de ces atomes dans l'espace cartésien 3D. Dans cette configuration, les indices de liste représentent les mêmes noyaux atomiques.

# As an example, here are the coordinates for H2’s optimized geometry:
symbols = ["H", "H"]
geometry = jnp.array([
[-0.672943567415407, 0.0, 0.0],             
[ 0.672943567415407, 0.0, 0.0]
])
mol = qml.qchem.Molecule(symbols, geometry)

La classe Molecule de qchem nécessite que les coordonnées soient données en unités atomiques. Les coordonnées peuvent être n'importe quelle valeur, même des valeurs trop éloignées, ou qui placent les noyaux atomiques au même point dans l'espace. Si la géométrie moléculaire n'est pas dans la configuration optimale, l'Hamiltonien de la molécule ne sera tout simplement pas à son minimum. Nous reviendrons sur l'Hamiltonien, mais en résumé, c’est une fonction qui calcule l’énergie du système.

La géométrie moléculaire est un facteur clé qui détermine l’énergie du système. Les systèmes naturels évolueront naturellement vers leur niveau d’énergie le plus bas (par exemple, via la désintégration alpha, la désintégration bêta ou d'autres phénomènes). Les atomes très proches les uns des autres, en fonction des diamètres nucléaires, se repousseront, et nous verrons une valeur très élevée pour l'Hamiltonien

Lorsque l'Hamiltonien atteint sa valeur d'énergie la plus basse, nous verrons que les atomes sont à leur distance de liaison d’équilibre. Les atomes éloignés se comportent de manière indépendante et ont généralement une énergie (potentielle) plus élevée que lorsqu'ils sont combinés.

Cette image aidera à refléter la relation entre les distances de liaison de H3, une molécule simple.

Lorsque les atomes sont très proches, l'énergie totale est très élevée.À mesure que la longueur de la liaison augmente, l'énergie du système diminue de manière exponentielle jusqu'à ce qu'elle atteigne l'état d'énergie minimale de la molécule. Ensuite, lorsque la longueur de la liaison continue d'augmenter, l'énergie du système augmente à nouveau.

Voici toutes les questions que je me posais à ce moment du processus :

• L'énergie d'un seul atome d'Hydrogène est-elle équivalente à environ trois fois l'énergie d'une molécule H3 très séparée ?
  • -1.27 Hartree pour le H3 optimal contre -0.5 Hartree pour un Hydrogène isolé
  Comment importer la molécule Cyanex-272 dans PennyLane ?Après l'importation de Cyanex272, ses coordonnées sont-elles déjà optimisées ? Autrement dit, est-ce l'état d'énergie le plus bas de son Hamiltonien ?Les coordonnées concernent-elles la forme protonée de la molécule ou la forme déprotonée ?
  • Protonée signifie que l'atome d'Oxygène dans le site actif contient un atome d'Hydrogène (neutralisant essentiellement l'atome)
  • Déprotonée signifie que l'atome d'Oxygène dans le site actif NE contient PAS un atome d'Hydrogène, mais n'a pas nécessairement un ion métallique lié
  • Complexe Métal-Organophosphore signifie que la molécule a une liaison avec un ion métallique dans le site actif
  D'après mes recherches dans la base de données PubChem, je pense que la molécule est sous sa forme protonée, puisque l'Oxygène porte un Hydrogène.

Après une recherche rapide, j'ai trouvé les coordonnées de la molécule Cyanex272 dans la base de données PubChem, la plus grande collection d'informations sur les composés chimiques au monde.

J'ai trouvé que je pouvais télécharger les coordonnées dans différents formats, ou utiliser directement PennyLane :

# Using the xyz file format, a semi-standard for Chemicals
symbols, coordinates = qchem.read_structure("cyanex272.xyz")

# Using the PubChem API and the molecule's PubChem CID
cyanex_272_cid = 157898
symbols, coordinates = qchem.mol_data(cyanex_272_cid, 'CID')

# We could also build it manually, as we saw above.

Avertissement : les coordonnées fournies par PubChem ne sont probablement pas dans les unités atomiques attendues.

Une fois la molécule chargée, nous avons accès à une multitude d'informations, et nous pouvons poursuivre avec notre algorithme quantique.
<Molecule = C16H35O2P, Charge : 0, Base : STO-3G, Orbitals : 134, Electrons : 162, Mult : 1, Coordonnées : [...]>

Étape 2 : Construire l'état Hartree-Fock pour représenter les électrons

Pour notre molécule, il y a 162 électrons, qui sont répartis dans 134 orbitales atomiques. En raison de la nature fermionique des électrons, le principe d'exclusion de Pauli s'applique. Par conséquent, un maximum de deux électrons peut occuper une seule orbitale, et les électrons doivent avoir des spins opposés. 81 orbitales sont complètement occupées (par 2 électrons) et 53 sont inoccupées. Les électrons sont attirés par le noyau atomique chargé positivement, et ils vont naturellement s'organiser en occupant d'abord les orbitales à énergie la plus basse.

Dans toutes les démonstrations de PennyLane, et en effet dans la plupart des problèmes de chimie quantique, vous rencontrerez très probablement l'état Hartree-Fock, couramment abrégé en hf_state.

"La méthode Hartree-Fock (HF) est une méthode d'approximation pour la détermination de la fonction d'onde et de l'énergie d'un système quantique à corps multiples dans un état stationnaire."

La valeur initiale de l'état HF est analogue à la nature fermionique des électrons. Dans un atome, les orbitales à énergie la plus basse sont occupées en premier, et les orbitales à énergie plus élevée sont inoccupées. Ici, un |1> indique qu'il y a un électron dans l'orbitale. Un |0> indique qu'il n'y a pas d'électron dans cette orbitale. Chaque indice dans le tableau représente une orbitale de spin.

• Remarque : L'orbitale dans un état HF est une orbitale de spin, pas une orbitale atomique. Une seule orbitale atomique est décrite par 2 orbitales de spin, car il peut y avoir un maximum de 2 électrons par orbitale atomique.
• Comment l'algorithme du Quantum Variational Eigensolver (QVE) sait-il quelles orbitales et électrons sont "actifs" ?
• Pourquoi y a-t-il 53 orbitales inoccupées lorsqu'on utilise l'ensemble de bases ?
• Que sont les fonctions de base et l'ensemble de bases, et comment s'intègrent-elles dans la méthode HF ? Je crains que cela ne soit trop avancé pour cet article.

Passons donc à la construction de notre état HF pour la molécule Cyanex272.

hf_state = qchem.hf_state(molecule.n_electrons, molecule.n_orbitals * 2)

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0]

qubits = len(hf_state) # 268 qubits

‍
C'est beaucoup de qubits pour une seule molécule ! Et cela ne prend même pas en compte l'ion métallique ni les deuxième et troisième molécules de Cyanex272 nécessaires pour former un complexe chélaté complet. Nous ignorons également la nécessité de la correction des erreurs de qubits. Dans le meilleur des cas, nous avons toujours besoin de centaines de qubits pour modéliser ce système.

À ce stade, j'ai commencé à me demander : comment pouvons-nous calculer directement l'énergie de Hartree-Fock (HF) d'une molécule ? Il semble que nous devons connaître les coefficients alpha pour les fonctions de l'ensemble de bases. Quelque chose comme ceci :

‍qchem.hf_energy(molecule)(*alpha)

La beauté de la chimie est que nous savons que la molécule de Cyanex272 n'a pas 162 électrons "actifs". La plupart de la molécule est stable (en d'autres termes, tous les groupes CH sont stables, et le groupe phosphate est également stable). La seule section instable est le site OH. L'oxygène a 6 électrons de valence, 1 électron est fourni par l'atome d'hydrogène attaché, et l'autre électron est fourni par l'atome de phosphate. Cela complète la couche orbitale de 8 électrons.

Nous pouvons réduire l'espace de problème en spécifiant l'espace actif du système :

hf = qml.qchem.hf_state(electrons=8, orbitals=16)

Dans cette image, les orbitales de cœur sont toutes occupées et ne participeront donc pas aux réactions chimiques. Pour cette raison, nous pouvons les éliminer de l'état de Hartree-Fock et réduire l'expansion combinatoire. Dans cette image, 6 électrons se trouvent dans les orbitales de cœur, et 4 dans les orbitales actives, avec 4 orbitales atomiques, et donc 8 spin-orbitales.

‍
D'accord... parlons maintenant de l'informatique quantique.

‍
Un seul qubit représentera une seule spin-orbital. Lorsque le qubit est dans l'état |0>, cela indique qu'aucun électron n'est présent dans l'orbitale. Dans l'image ci-dessus, il y a 2 orbitales atomiques actives à haute énergie non occupées (les 2 premières lignes rouges). Dans ce cas, l'état HF se terminera par |0000>. Cela signifie qu'il n'y a pas d'électrons dans les 4 dernières spin-orbitales, et les qubits ont une valeur de zéro. De manière similaire, les 2 orbitales atomiques actives inférieures contiennent chacune 2 électrons et 4 spin-orbitales, toutes occupées par un électron. L'état HF commencera donc par |1111>, l'état des 4 premiers qubits. Si nous nous souvenons de la sphère de Bloch de l'introduction, les 4 premiers qubits pointent directement vers le haut, et les 4 derniers qubits pointent directement vers le bas. Les spin-orbitales ne sont pas encore en superposition. Elles ont simplement une valeur classique de 0 ou 1 : non occupée ou occupée.

Étape trois : Simuler le mouvement des électrons avec des excitations simples et doubles.

Lorsque j'ai d'abord lu les démonstrations de PennyLane, j'étais vraiment confus par le circuit quantique. Je me suis retrouvé à me demander : "qu'est-ce que ces excitations simples et doubles ?" Après avoir exploré davantage les démonstrations et lu plus de documentation, cela est devenu plus clair. Nous parlons des excitations des électrons – des électrons qui passent d'une orbitale inférieure à une orbitale supérieure.

Une excitation simple signifie qu'un seul électron passe d'une spin-orbitale à une autre spin-orbitale. À mesure que les électrons se déplacent dans la molécule, ils évitent de se rencontrer, et parfois ils passent d'une orbitale à une autre orbitale non occupée. Cela est connu sous le nom de réarrangement électronique, et son objectif est de tenter de diminuer l'énergie totale du système.

D'un point de vue mécanique quantique, mon hypothèse ici est que pour chaque qubit, nous créons une superposition de configurations électroniques possibles, où la probabilité de trouver un électron dans cette orbitale est proportionnelle à la somme de toutes les excitations possibles d'un électron dans cette orbitale. En prenant le carré de la magnitude du qubit, nous obtenons la probabilité qu'un électron soit trouvé dans l'orbitale que ce qubit représente. Je me rends compte que cela peut paraître un peu compliqué. Décomposons cela davantage.

Un qubit représente une spin-orbitale. Une excitation simple peut être appliquée sur 2 spin-orbitales via la ligne de code suivante :

qml.SingleExcitation(param, wires=[0, 1]) # wires = qubit index

‍
Cela signifie que le qubit 0 (orbitale 0) et le qubit 1 (orbitale 1) ont subi une série de portes quantiques. Cela va placer les 2 qubits (spin-orbitales) en superposition l'un avec l'autre. Les 2 qubits seront corrélés entre eux. Cela échange essentiellement les états des 2 qubits.

Lors de la mesure des qubits, nous verrons si un qubit est dans l'état |1> (occupé) ou |0> (non occupé). Cependant, comme tous les qubits sont corrélés, si un qubit est mesuré comme étant occupé, nous saurons automatiquement que l'autre qubit est dans l'état opposé. Les résultats peuvent être aléatoires à travers différentes simulations, mais dans une simulation donnée, les résultats seront corrélés. Lorsque ces systèmes mécaniques quantiques sont correctement créés, ils conservent le nombre d'électrons. Il n'y a pas d'électrons "perdus". Si un électron "n'est pas dans le premier qubit", il sera dans le "deuxième qubit".

Nous discuterons plus tard du paramètre impliqué.

Une opération SingleExcitation est composée de 6 portes quantiques successives (4 CNOT et 2 rotations PauliY) :

Comptage des permutations d'excitations

Vous pouvez imaginer toutes les permutations possibles de 8 électrons dans 16 orbitaux de spin. Il y en a beaucoup ! Il existe 32 façons dont 8 électrons peuvent être excités vers une coquille électronique supérieure. Il y a 328 façons dont 8 électrons peuvent être excités vers la première ou la deuxième coquille électronique supérieure. Il est également possible de définir la troisième coquille électronique supérieure, mais cela semble être peu courant – du moins aux échelles actuelles des démonstrations de PennyLane. Mon hypothèse est que des atomes plus grands avec plus d’électrons pourraient effectivement bénéficier des TripleExcitations (par exemple : le Cobalt ?!).

Pour pousser cette idée encore plus loin, avec la molécule Cyanex272, si nous voulons calculer toutes les façons dont les électrons peuvent être excités à partir des premiers ou deuxièmes orbitaux, nous pouvons calculer la liste de toutes les permutations possibles d’excitations en utilisant ce qui suit :

singles, doubles = qchem.excitations(
molecule.n_electrons, 
molecule.n_orbitals*2
)
len(singles) # 8586
len(doubles) # 27359289

Cela donne lieu à un circuit quantique véritablement gigantesque, avec des millions d’opérations quantiques effectuées sur des portes. Je commence à me demander si nous essayons de résoudre ces problèmes en utilisant une théorie mathématique qui pourrait être tout simplement trop… expansive ? On dirait que nous essayons de répondre à une question simple comme "2+2" en utilisant la théorie des ensembles ou la théorie des types de l’homotopie.
Pour résumer, nous créons un circuit quantique et appliquons toutes les excitations simples et doubles sur celui-ci. Ces excitations représentent toutes les façons dont les électrons peuvent se déplacer à l’intérieur des orbitaux de spin. Chaque qubit se retrouve en superposition, indiquant si un électron occupe l’orbitale de spin qu’il représente. La mesure simultanée de tous les qubits finit par nous indiquer la distribution électronique dans le système. Mesurer plusieurs fois le système nous donnera la distribution de probabilité de l’endroit où l’électron a le plus de chances d’être trouvé.

Du moins, je pense que c’est ce qui se passe…

Étape quatre : Calcul du hamiltonien moléculaire pour estimer l’énergie du système

En changeant de sujet, passons des qubits simples au système global. Une façon de procéder en chimie quantique est d’utiliser l’hamiltonien moléculaire. Il s’agit d’une fonction qui représente l’énergie totale d’un système. C’est la somme des énergies potentielles et cinétiques de toutes les parties constituantes du système. Pour simplifier les équations, je crois que PennyLane utilise l’hamiltonien moléculaire électronique, c'est-à-dire qu’il ne somme que les énergies électroniques (par exemple, la répulsion électron-électron, l’attraction électron-proton), mais néglige les forces nucléaires. À la fin de la journée, cependant, ce que nous devons comprendre, c’est que l’hamiltonien moléculaire peut être évalué et qu’il nous donne l’énergie du système en unités de Hartree. La valeur d’attente de l’hamiltonien est estimée comme une moyenne sur de nombreuses mesures.

‍
Le calcul de l’hamiltonien à partir de la molécule prend un peu de temps et évolue avec la complexité de la molécule. La réduction de l’espace actif peut aider à réduire le temps de calcul.

• Question : Comment l’hamiltonien change-t-il avec la réduction de l’espace actif ?
• ‍Question : Quelle est l’imprécision des résultats si nous les supprimons ?
• ‍Question : Est-ce que qchem sait automatiquement quels électrons et quels orbitaux peuvent être retirés de la fonction d’onde ? Comment sait-il quels électrons et quels orbitaux peuvent être omis ?

H, qubits = qchem.molecular_hamiltonian(molecule, active_electrons=8, active_orbitals=16)

Lors de l'inspection de l'hamiltonien pour la molécule CH4, nous remarquons que la taille (len(H)) :

• Avec la configuration complète (10 électrons, 9 orbitaux)
  • ~640k caractères
• Lorsque les électrons actifs = 4 électrons (pour la couche externe du carbone)
  • ~120k caractères
• Lorsque les électrons actifs = 4, les orbitaux de spin actifs = 4
  • ~22k caractères
• Lorsque les électrons actifs = 2, les orbitaux de spin actifs = 2
  • ~1,2k caractères

En traçant cela, nous voyons que la taille de l'hamiltonien croît de manière exponentielle avec le nombre d'électrons et d'orbitales actifs. La croissance est approximativement O(M^4), où M est le nombre d'orbitales actifs.

Décomposition de l'hamiltonien quantique

Comme nous l'avons vu, ajouter plus d'électrons et d'orbitales actifs à l'hamiltonien entraîne une addition exponentielle de termes.

print(hamiltonian)
(
    -1067.7631137006906 * I(0)
  + 0.01927739402119371 * Z(0)
  + 0.02010772625946518 * (Y(0) @ Z(1) @ Y(2))
  + 0.02010772625946518 * (X(0) @ Z(1) @ X(2))
  + 0.019277394021193696 * Z(1)
  + 0.02010772625946518 * (Y(1) @ Z(2) @ Y(3))
  + 0.02010772625946518 * (X(1) @ Z(2) @ X(3))
  + 0.007935531547228328 * Z(2)
  + 0.00793553154722832 * Z(3)
  + 0.05099433718166383 * (Z(0) @ Z(1))
  + 0.009079418131571197 * (Y(0) @ Y(2))
  + 0.009079418131571197 * (X(0) @ X(2))
  + 0.009079418131571197 * (Z(0) @ Y(1) @ Z(2) @ Y(3))
  + 0.009079418131571197 * (Z(0) @ X(1) @ Z(2) @ X(3))
  + 0.03578033933168374 * (Y(0) @ X(1) @ X(2) @ Y(3))
  + -0.03578033933168374 * (Y(0) @ Y(1) @ X(2) @ X(3))
  + -0.03578033933168374 * (X(0) @ X(1) @ Y(2) @ Y(3))
  + 0.03578033933168374 * (X(0) @ Y(1) @ Y(2) @ X(3))
  + 0.010160160050190024 * (Z(0) @ Z(2))
  + 0.045940499381873764 * (Z(0) @ Z(3))
  + -0.011035252567698314 * (Y(0) @ Z(1) @ Y(2) @ Z(3))
  + -0.011035252567698314 * (X(0) @ Z(1) @ X(2) @ Z(3))
  + 0.045940499381873764 * (Z(1) @ Z(2))
  + -0.011035252567698314 * (Y(1) @ Y(3))
  + -0.011035252567698314 * (X(1) @ X(3))
  + 0.010160160050190024 * (Z(1) @ Z(3))
  + 0.0522055923559441 * (Z(2) @ Z(3))
)

En examinant cet hamiltonien, nous pouvons remarquer une liste de termes. Chaque terme de l'hamiltonien est composé d'un coefficient et d'une opération quantique. Chaque coefficient multiplie chaque opération. Une opération est définie comme un ensemble d'une ou plusieurs portes de Pauli (Z, X, Y, I) opérant sur des qubits individuels. Les coefficients sont des nombres réels. Lorsqu'un opérateur contient un symbole @, cela indique qu'il s'agit du produit tensoriel des deux portes quantiques.

Nous pouvons voir que -1067 * Matrice identité du qubit 0. Dans cet exemple spécifique, nous avons défini l'espace actif de l'hamiltonien comme étant relativement petit, de sorte que toutes les parties non actives de la molécule Cyanex272 s'additionnent à -1067. Cela était basé sur l'utilisation de deux électrons actifs et des orbitales atomiques. Le terme constant -1067 a été pré-calculé. Dans les problèmes de chimie quantique, nous fixons généralement la position des noyaux, de sorte qu'ils peuvent être considérés comme constants. Les forces nucléaires sont incluses dans ce terme. Le reste des termes de l'hamiltonien compensera ce constant en se concentrant sur les fluctuations.

Étape cinq : Optimisation pour l'état de plus basse énergie avec la descente de gradient‍

La ligne magique de code qui fait tout le travail lourd :

return qml.expval(obs)

Ici, l'expval (valeur d'attente de l'hamiltonien) exécutera le circuit quantique et mesurera l'état final des qubits. Chaque qubit est ensuite combiné dans l'hamiltonien de la fonction d'onde, et la sortie est l'énergie totale de la fonction d'onde (en unités de Hartree). Des recherches supplémentaires permettraient de déterminer comment les états des qubits influencent l'hamiltonien, mais je suppose que l'ensemble de bases joue un rôle énorme.

Maintenant, définissons le circuit quantique :

@qml.qnode(qml.device("default.qubit", wires=number_qubits)
def circuit(params, hamiltonian):
qml.AllSinglesDoubles(
params, number_qubits, 
hf_initial_state, singles, doubles
)
return qml.expval(hamiltonian)

Au lieu de définir manuellement le circuit quantique, l'une de mes méthodes préférées pour le définir est d'utiliser la fonction AllSinglesDoubles. Elle définit la valeur initiale de tous les qubits à l'état HF initial défini ci-dessus. Ainsi, nous avons notre molécule avec tous les électrons dans les orbitales de plus basse énergie. Ensuite, elle applique chaque excitation simple et double que tous les électrons pourraient exprimer. Cela crée une superposition pour chaque qubit qui définit si l’électron se trouve dans ces orbitales, dans cette configuration électronique spécifique. Après avoir exécuté ce circuit quantique plusieurs fois et moyenné les résultats, nous obtenons la valeur d'attente de l'hamiltonien moléculaire, c'est-à-dire l'énergie du système.

Pour calculer le circuit, il suffit de l'exécuter. Voici comment :

theta = np.zeros(len(singles) + len(doubles))
energy = circuit(theta)

Qu'est-ce que les paramètres d'excitation ?

Mais attends une seconde, qu'est-ce que ce theta, un tableau rempli de zéros, avec cette longueur ? Eh bien, ce sont les paramètres des portes quantiques. Ce sont un ensemble de valeurs fournies à chaque excitation, utilisées pour indiquer l'impact de cette excitation sur la fonction d'onde de l'hamiltonien, une déviation de l'état de base Hartree-Fock. Si les paramètres sont tous à zéro, cela équivaut à l'état hf_initial_state, où toutes les orbitales de spin de plus basse énergie sont occupées, et toutes les orbitales de spin actives sont inoccupées. La valeur d'attente de l'hamiltonien nous donne une énergie pour le système, et chaque paramètre ajuste l'impact de chaque excitation sur l'hamiltonien.

Je me demande ce qui se passe lorsque nous prenons l'état initial HF et que nous ajustons simplement un paramètre. Qu'est-ce que cela signifie ? Vérifions cela :

# Starting with the optimized geometry for H3
# With an initial HF state of |110000>

def circuit(params):
    qml.BasisState(hf, wires=qubits)
    qml.DoubleExcitation(params[0], wires=[0, 1, 2, 3])
    qml.DoubleExcitation(params[1], wires=[0, 1, 4, 5])
    return qml.expval(H)

energies = [
    circuit(jnp.array([0.0, 0.0]),
    circuit(jnp.array([0.5, 0.0]),
    circuit(jnp.array([1.0, 0.0])),
    circuit(jnp.array([1.5, 0.0])),
    circuit(jnp.array([500.0, 0.0])),
]

# Energies:
-1.24685995
-1.22922027
-1.04262691
-0.73276445
0.15368139

À mesure que nous augmentons la contribution de la première excitation double, l'énergie totale du système augmente. Je ne suis pas sûr de l'ampleur de la contribution qu'une excitation simple devrait avoir sur l'hamiltonien. Quelles sont les limites ? C'est pourquoi nous devons effectuer une descente de gradient.

Avec ma compréhension limitée de la façon dont chaque excitation contribue à l'hamiltonien, il n'y a qu'une seule manière de résoudre ce problème : effectuer une descente de gradient sur l'hamiltonien. La descente de gradient nous donne une direction claire ; une indication précise des valeurs que nos paramètres doivent avoir. Étant donné qu'il y a potentiellement des milliers de paramètres, nous avons besoin d'algorithmes avancés de descente de gradient. JAX (une bibliothèque Python pour le calcul numérique rapide) et Optax (un kit d'optimisation construit sur JAX) fournissent ces algorithmes :

opt_state = opt.init(theta)

for n in range(max_iterations):
gradient = jax.grad(cost_fn)(theta)
updates, opt_state = opt.update(gradient, opt_state)
theta = optax.apply_updates(theta, updates)

energy = cost_fn(theta)

Letting this run for a while, we can then see the energy level for each gradient descent step:

Step = 0,  E = -1.26999182 Ha,  bond length = 0.96963 A
Step = 4,  E = -1.27440927 Ha,  bond length = 0.98192 A
Step = 8,  E = -1.27443682 Ha,  bond length = 0.98496 A

Alors, qu'est-ce que cela signifie ? L'état de plus basse énergie du système pour les coordonnées fournies (et autres configurations) est la configuration la plus probable. Cela est dû au fait que les systèmes physiques tendent naturellement vers la plus basse énergie. Les désintégrations alpha et bêta, ainsi que d'autres phénomènes physiques, se produisent naturellement pour réduire l'énergie totale. Une fois que nous avons trouvé l'énergie de base de la molécule, nous connaissons la configuration électronique la plus probable.

Qu'est-ce qu'un ensemble de bases ?

Les chimistes computationnels travaillent depuis des décennies pour calculer les coefficients des fonctions gaussiennes qui approximativent la structure orbitale de tous les atomes. Chaque ensemble de bases est une liste de coefficients à appliquer sur des fonctions de type gaussiennes. Où la combinaison linéaire de chaque fonction gaussienne rapproche l'approximation de l'équation de Schrödinger pour cet atome. Le compromis réside dans l'utilisation de la mémoire et des opérations CPU. Par exemple, cet article a été calculé avec l'ensemble de bases STO-3G. C'est un ensemble de bases extrêmement petit avec un nombre minimal de fonctions. Au prix de la précision des résultats, STO-3G calcule l'atome H à -0.49491 Ha, alors qu'en réalité, l'atome H est à -0.5 Ha.

Maintenant que nous avons couvert les étapes clés d'une simulation typique de chimie quantique, examinons comment nous les mettons en pratique sur de vraies molécules — en commençant par Cyanex272.

Mettre Cyanex272 sous le microscope quantique

Comme pour tous les problèmes complexes, commencer par un problème plus simple peut être une bonne idée. PubChem contient les coordonnées de la molécule, fournies dans différents formats, et celles-ci ont été traduites en fichier xyz à l'aide d'un outil en ligne. Cependant, après avoir inspecté les coordonnées et les distances de liaison, il était clair qu'elles n'étaient pas fournies de manière précise.

# Via xyz file
coords = qchem.read_structure('file.xyz')
qchem.Molecule(symbols, coords)
P: 1.75344333, -0.11831944, -0.05601928
O: 1.75323071, -2.63980842, 1.78200772
O: 1.6546751 ,  2.18403242,  1.67107732
distance(P, O[0]) = 3.12 Bohr
distance(P, O[1]) = 2.8798 Bohr

# XYZ file coordinates:
P        0.9278822532     -0.0626119514     -0.0296441248                 
O        0.9277697375     -1.3969264546      0.9429978749                 
O        0.8756163555      1.1557401848      0.8842960358
distance(P, O[0]) = 1.651 Å
distance(P, O[1]) = 1.524 Å

# Via built-in PennyLane qchem.mol_data
qchem.mol_data(cyanex_272_cid, 'CID') # Returns Bohrs
P: 0.06916398, -2.14087073, -1.0053343
O: 2.07227367, -4.37622776, -1.50535583
O: -0.24585337, -0.32824543, -3.132599
distance(P, O[0]) = 3.0429 Bohr ~1.61 Å
distance(P, O[1]) = 2.8124 Bohr ~1.488Å

Il semble que les distances de liaison téléchargées depuis PubChem en tant que coordonnées ne correspondent pas aux distances de liaison de la molécule chargée via l'API (l'appel mol_data()). Une recherche rapide en ligne révèle qu'une distance moyenne de 1,48 Å est courante pour les liaisons P=O, certains affirmant que la distance est de 1,52 Å pour des molécules spécifiques (HO-PO, PO). À l'avenir, les coordonnées mol_data seront utilisées.

Une raison possible pour cela est la confusion des unités dans les fonctions de PennyLane. Certaines fonctions nécessitent que les unités soient en Bohrs, tandis que d'autres attendent des unités en Angströms. Il est donc crucial de prêter attention aux unités avant chaque appel de fonction. Une autre raison possible de la confusion des valeurs est causée par les multiples géométries estimées pour les molécules fournies automatiquement par les outils d'estimation internes de PubChem (Cyanex272 a plusieurs confirmations/formes).

cyanex_272_cid = 157898
symbols, coords = qchem.mol_data(cyanex_272_cid, 'CID')
molecule = qchem.Molecule(
symbols, 
jnp.array(coords), unit="bohr"
# Must load data because Phosphorus > base atomic set in PennyLane
load_data=True,
)
molecule.name = "Cyanex272"

Comme dans la section précédente de cet article, la configuration du Hamiltonien moléculaire est relativement simple. La réduction de l'espace actif est essentielle en raison de l'échelle O(n^4) des termes. Une tentative d'utilisation de 8 électrons dans 8 orbitales actives entraîne toujours un Hamiltonien non calculable. Le conteneur Docker plante avec des exceptions de mémoire insuffisante.

H, qubits = qchem.molecular_hamiltonian(
molecule, 
active_electrons=8,
active_orbitals=8
)
# Number of terms in H: 16^4 = 65,000 terms
# qubits = 16

Cette molécule est tout simplement trop grande, et nos algorithmes/ordinateurs trop inefficaces. Diviser la molécule en morceaux plus petits est actuellement la seule manière réalisable que nous avons pour aller plus loin.

Décomposer les chaînes CH

En inspectant la molécule, nous pouvons observer deux longues chaînes d'hydrocarbures de chaque côté de l'atome de Phosphore central. Chaque chaîne de Carbone est attachée à plusieurs atomes d'Hydrogène, formant plusieurs groupes CH3. Il y a un total de 16 atomes de Carbone, avec 8 de chaque côté de l'atome de Phosphore. Ces chaînes de Carbone rendent la molécule hydrophobe, ce qui la rend facilement séparable des solutions aqueuses.

Dans cette sous-expérience, nous analyserons l'énergie à différentes configurations électroniques actives de la molécule de CH4. Cela ne nous donne pas nécessairement d'informations utiles concernant la molécule de Cyanex272, mais c'est un point de départ intéressant pour comprendre le concept d'espace actif.

Nous pouvons configurer l'expérience de la même manière qu'auparavant, à l'exception de la modification des électrons et orbitales actifs pour divers cas de test. Ce faisant, et sans optimiser les excitations électroniques (en utilisant l'état de Hartree-Fock moyen), nous obtenons une valeur d'espérance du Hamiltonien de -37,72 Ha. Une recherche rapide en ligne nous indique que l'énergie moléculaire totale pour le CH4 est de -39,86 Ha. Nous sommes loin de l'énergie vérifiée expérimentalement pour le Méthane. Que se passe-t-il ?

ch4_hf = qchem.hf_state(
electrons=active_electrons, 
orbitals=active_spin_orbitals
)
singles, doubles = qchem.excitations(
active_electrons, 
active_spin_orbitals
)
energy = run_circuit(jnp.zeros(len(excitations)))

Ici, nous avons utilisé un theta égal à zéro, ce qui indique qu'aucune des excitations n'est appliquée. Cela exécute simplement l'Hamiltonien dans le cadre de Hartree-Fock moyen. Modifier le nombre d'électrons et d'orbitales actifs entraîne une diminution de l'énergie. À mesure que les électrons "se déplacent vers une autre orbitale" pour éviter de se repousser, l'énergie totale diminue.

Comme nous pouvons le voir, le temps par itération augmente de 1 seconde à 96 secondes. Cela exclut la descente de gradient des paramètres. Lorsque l'on inclut la descente de gradient, le temps par itération pour la configuration active complète tend vers "l'infini" (le conteneur Docker plante systématiquement). Peut-être qu'en louant un ordinateur quantique cela pourrait aider. Sinon, sélectionner max_diff=1 dans le qnode de Qml résout le problème, mais il diverge à la septième itération.

Ces résultats indiquent bien que nous nous rapprochons de plus en plus de l'énergie vérifiée expérimentalement (-39,86 Ha). Cette valeur est également fournie par le jeu de données CH4 disponible publiquement de PennyLane. Pour se rapprocher encore davantage, nous devrions éliminer la limite de différenciation des intégrales imposée par le drapeau max_diff, et nous devrions aussi changer le jeu de bases pour un jeu de bases plus complet (actuellement, nous utilisons STO-3G, qui est un jeu de bases très simple. aug-cc-pVQZ ?).

Le plus grand problème pour aller plus loin : comment savons-nous si les valeurs que nous obtenons ont réellement du sens ? Dans le cas de molécules simples, comme le Méthane, nous avons des ensembles de données disponibles qui indiquent le résultat final. Nous pouvons comparer la tendance de la convergence avec les valeurs vérifiées. Dans le cas de molécules complexes, comme la molécule entière de Cyanex 272, comment savons-nous que l'énergie de -1400 Ha est une approximation valide ?

Zoom sur les groupes CH3

Après avoir étudié les chaînes de Carbone, nous pouvons voir que certains des groupes sont des groupes CH3. Pourrions-nous calculer la différence d'énergie en Hartree entre la molécule de CH4 et une molécule de CH3 ? Une chose à noter dans cette expérience est qu'il manque un Hydrogène, ce qui entraîne une charge moléculaire nette de -1. Gardez à l'esprit que ces groupes CH3 sont liés à d'autres groupes CH2/CH3.

En raison de l'Hydrogène manquant, la géométrie de la molécule de CH3 change pour adopter une géométrie plane trigonal. Cela résulte de la répulsion électrostatique équidistante. Dans cet exemple, nous ne procéderons pas à des techniques d'optimisation géométrique. Au lieu de cela, nous utiliserons un peu de trigonométrie pour définir l'angle de 120 degrés des atomes d'Hydrogène.

# Coordinates:
r = 1.09 # angstroms
r = 2.0541323 # bohr / au
ch3_coords = jnp.array([
    0., 0., 0., # Central Carbon
    0., 0., r, 
    -r/2, 0., jnp.sqrt(3)/2*r,
    -r/2, 0., -jnp.sqrt(3)/2*r
])

Si nous essayons d'exécuter la fonction molecular_hamiltonian, nous obtiendrons une erreur. Il y a plusieurs problèmes avec la configuration actuelle. Premièrement, en raison de l'Hydrogène manquant, il manque un électron. Avec un électron manquant, la molécule a une charge nette de 1, nous devons donc modifier la multiplicité de spin à 2. Deuxièmement, étant donné que les systèmes à coque ouverte ne sont pas supportés par la méthode intégrée de PennyLane, nous devons utiliser une autre méthode, comme openfermion.

ch3_molecule = qchem.Molecule(ch3_symbols, ch3_coords, load_data = True, unit="bohr")
ch3_molecule.mult = 2 # one unpaired electron
ch3_H, qubits = qchem.molecular_hamiltonian(
    ch3_molecule, 
    method = 'openfermion' # open-shell systems forces a new method
)

L'exécution du circuit avec le champ moyen HF, excluant les excitations électroniques, donne une énergie de -38,65 Ha. Si nous incluons la descente de gradient pour trouver l'énergie en Ha avec les excitations, nous obtenons des énergies plus proches de -38,704 Ha. Une configuration électronique complète est utilisée ici. Cela nécessite encore un temps d'exécution significatif sur un Macbook moderne, via un conteneur Docker.

Nous pouvons comparer les énergies des molécules CH3 et CH4 et remarquer que l'énergie de CH3 est légèrement plus élevée que celle de CH4. Cela signifie que CH3 réagira plus facilement avec d'autres molécules – et en effet, cette molécule a un Hydrogène manquant. C'est également un système à coque ouverte, ce qui signifie qu'il se liera facilement avec un autre électron libre.

Explorons le site actif de la molécule Cyanex 272.

Examinons le site actif de la molécule Cyanex 272.

Dans le premier segment, nous avons remarqué que la molécule possédait deux longues chaînes d'hydrocarbures. Dans l'image ci-dessous, elles ont été remplacées par deux atomes d'hydrogène, afin de maintenir un système à coque fermée. Cela entraînera une approximation, car les atomes d'hydrogène sont beaucoup plus petits, et donc les forces qui les repoussent l'un de l'autre ne sont pas du tout de la même intensité que celles qui agissent entre les atomes de carbone, qui sont comparativement six fois plus gros.

Lorsque la molécule Cyanex272 se trouve dans une solution fortement acide (avec un pH bas), la molécule HO est liée à l'atome central de phosphore. Dans une solution de faible acidité, où moins d'atomes d'hydrogène sont disponibles, la liaison HO est plus facile à perturber, et un ion métallique pourrait se former à la place. En se souvenant que deux molécules de Cyanex272 sont nécessaires pour chélater le cobalt, cela résulte en deux protons libres.

Co²⁺ + 2(HR) = CoR₂ ​+ 2H⁺

Pouvons-nous observer cela dans cet exemple de chimie quantique ?

Tentons de construire ce système. Si même les plus petits systèmes, comme CH3, prennent des heures à calculer, nous devons réduire le problème à la configuration la plus simple possible. Au lieu d'utiliser Cyanex272 comme réactif, nous utiliserons HOH. Bien que cela ne soit pas nécessairement la meilleure approximation pour ce problème, car H2O est beaucoup plus stable que la molécule HO-P.

Peut-être qu'en louant un ordinateur quantique pour exécuter cette expérience, cela pourrait aider.

symbols_CoO = [
    'Co',
    'O',
    'H'
]
coords_CoO = jnp.array([
    [0., 0., 0.],
    [3.59048, 0., 0.], # 1.9 Angstrom is typical Co-O bond length
    [3.59048 + 1.814, 0, 0.] # 1.81 bohrs typical O-H bond length
])

CoO_molecule = qchem.Molecule(symbols_CoO, coords_CoO, load_data=True)

CoO_molecule.n_electrons # 36 electrons
CoO_molecule.n_orbitals  # 25 orbitals

En calculant l'Hamiltonien en utilisant le backend openfermion, nous découvrons qu'il faut 48 qubits pour le calculer, c'est-à-dire sans réduction de l'espace actif.

Le conteneur Docker a eu des difficultés à exécuter un système de 9 électrons. On peut seulement imaginer les besoins en ressources pour 36 électrons. Cela sans inclure les 50 orbitales de spin nécessaires, ce qui augmente exponentiellement la fonction Hamiltonienne. Nous pourrions réduire l'espace actif pour n'inclure que les électrons de valence. Le cobalt a 9 électrons de valence, l'oxygène en a 6, ce qui donne un total de 15. Cela reste encore extrêmement élevé.

En poussant les limites de ce que les ressources de l'expérience actuellement configurée permettent, nous pouvons définir le nombre d'électrons et d'orbitales actives à 8. Un espace actif de (10, 10) a entraîné un plantage systématique du conteneur Docker.

Voici les résultats des six expériences. L'énergie pourrait être légèrement mieux optimisée si nous envisagions de mettre en œuvre un algorithme optimisé de différenciation géométrique, d'augmenter l'espace actif et/ou de changer l'ensemble de bases utilisé.

Ce que les résultats de la chimie quantique révèlent

En comparant la différence d'énergie en Ha entre Co+2 et Co+3, nous remarquons que Co+2 est moins énergétique. Il est donc plus favorable d’être dans cette configuration, par rapport à Co+3. En effet, c’est ce qui est observé dans la nature : Co+3 est moins stable dans les solutions aqueuses et a tendance à former des complexes avec d’autres atomes en raison de sa densité de charge électronique.

Les résultats indiquent qu’il n’est pas nécessairement favorable d’un point de vue énergétique de former une liaison CoOH par rapport à H2O + Co. Cela est probablement dû au fait que le système a été trop simplifié pour s’adapter aux ressources informatiques. La liaison OH devrait en réalité être une liaison OP. Mon hypothèse est que les 15 électrons du Phosphore permettent une meilleure corrélation électronique entre la liaison CoO. Les électrons partagés entre les atomes résultent probablement en plus de stabilité que lorsque qu'un seul électron est partagé (comme dans le cas de l’OH). Alternativement, le choix de l’ensemble de bases pourrait avoir eu un impact sur les approximations orbitales, avec des résultats moins bons dans les orbitales de plus haut ordre (orbitales p/d).

Comparer l'informatique quantique à la puissance des GPU

Pour obtenir une plus grande précision en chimie computationnelle, des ensembles de bases plus grands sont nécessaires. Un ensemble de bases est composé de fonctions gaussiennes prédéfinies, où chaque fonction supplémentaire dans la combinaison linéaire aide à approximer l'équation de Schrödinger plus précisément. Actuellement, les superordinateurs classiques peuvent gérer des estimations pour des systèmes avec quelques milliers d’atomes. Cependant, comme la chimie computationnelle évolue de manière exponentielle, les superordinateurs classiques finiront par atteindre une limite. Peut-être sommes-nous déjà en train d'approcher cette limite. C'est là que la chimie quantique offre une solution potentielle, car son évolution pourrait être moins restrictive que les approches classiques grâce à la croissance exponentielle de la disponibilité des qubits. D'un autre côté, le parallélisme massif des clusters GPU modernes émerge comme un concurrent fort, remettant en question la nécessité d’utiliser des qubits physiques.

Contrôler le tissu quantique de la réalité

L’idée peut sembler farfelue, mais ce qui semble se produire, c’est que notre connaissance croissante des manipulations quantiques nous permet d’utiliser des machines telles que les ordinateurs quantiques pour contrôler le niveau fondamental de notre Univers. L’informatique quantique pourrait bien être une approche moderne du vieux rêve de l’alchimie. La capacité de confiner les systèmes quantiques et de les protéger de l’entrelacement avec des systèmes externes pourrait être le niveau de contrôle nécessaire pour commencer à construire des structures à l’échelle de Planck.

Lorsque l’on considère comment le tissu fondamental de la réalité est interconnecté avec son espace-temps environnant — régi par la relativité — il devient évident que l’entrelacement joue un rôle crucial. Tout se déplace par rapport à tout le reste. L’ordinateur quantique se déplace avec la Terre, qui se déplace par rapport au Soleil, qui lui-même se déplace par rapport à la Galaxie, jusqu’à des échelles cosmiques. Un ordinateur quantique est un système qui permet à ses qubits de suivre la géométrie de Minkowski de l’espace-temps sans interférence de systèmes externes. Pourrait-on être en train de créer ce que l’on appelle (ou ce qui est en fait inconnu) la matière noire ou l’énergie noire — des particules non entrelacées ? La courbure de l’espace-temps serait donc la seule influence sur les particules non entrelacées.

Quelle direction prendra la chimie quantique désormais ?

Cet essai n'était que le début. Avec la configuration de base en place, il existe tout un monde de techniques de chimie quantique à explorer.

Voici où nous pourrions aller ensuite :

• Calculer l’état énergétique suivant en utilisant l’expansion de sous-espaces quantiques (QSE). Cela peut être utilisé pour comprendre comment les photons sont émis par une molécule : couleurs, fluorescence et réactions photochimiques.
• Calculer les propriétés moléculaires, y compris le moment dipolaire et la distribution de charge.
• Calculer l’estimation de phase quantique (QPE).
• Étudier les changements moléculaires qui se produisent lors des réactions chimiques.
• Utiliser un autre ensemble de bases, en utilisant plus de fonctions gaussiennes au lieu de STO-3G.
• Appliquer la théorie des perturbations sur l’estimation HF : MP2 ?
• Exécuter le modèle en utilisant un ordinateur quantique loué, comme ceux fournis par AWS Braket.

Explorer ce que l’informatique quantique peut faire pour votre entreprise

L’informatique quantique ouvre déjà de nouvelles voies pour relever des défis complexes dans la recherche, la simulation et la résolution de problèmes. Chez Osedea, nous allions curiosité, créativité et expertise technique pour aider les organisations à explorer cette technologie émergente avec confiance.

Nous avons travaillé concrètement avec des algorithmes quantiques, la modélisation moléculaire et des techniques de simulation de nouvelle génération. De la configuration d'environnements quantiques avec PennyLane à l’ajustement des Hamiltoniens moléculaires et l’application du gradient descent, nous savons ce qu’il faut pour transformer la théorie quantique en solutions concrètes.

Si vous êtes prêt à explorer comment l’informatique quantique pourrait débloquer de nouvelles possibilités pour votre organisation, nous serions ravis de vous aider à tracer cette voie.

Contactez-nous – nous sommes toujours partants pour un bon défi !

Lecture complémentaire

Vous voulez approfondir vos connaissances en chimie quantique ?

Consultez cette ressource de l’Université d’État du Montana avec des données sur la géométrie des molécules d'eau et l'énergie des liaisons : A Hartree-Fock Calculation of the Water Molecule.