Note

Cette page a été générée à partir de tutorials/chemistry/1_programmatic_approach.ipynb.

Exécuter en mode interactif dans le IBM Quantum lab.

Structure électronique¶

Introduction¶

Le Hamiltonien moléculaire est

\[\mathcal{H} = - \sum_I \frac{\nabla_{R_I}^2}{M_I} - \sum_i \frac{\nabla_{r_i}^2}{m_e} - \sum_I\sum_i \frac{Z_I e^2}{|R_I-r_i|} + \sum_i \sum_i \sum_{j>i}{|r_i-r_j|} + \frac{e^2} + \sum_I\sum_{J>I} \frac{Z_J e^2}{|R_I-R_J|}\]

Comme les noyaux d’atomes sont beaucoup plus lourds que les électrons ils ne bougent pas sur la même échelle de temps et, par conséquent, le comportement des noyaux et du nuage d’électrons peuvent être découplés. C’est l’approximation de Born-Oppenheimer.

Therefore, one can first tackle the electronic problem with nuclear coordinate entering only as parameters. The energy levels of the electrons in the molecule can be found by solving the non-relativistic time independent Schroedinger equation,

\[\mathcal{H}_{\text{el}} |\Psi_{n}\rangle = E_{n} |\Psi_{n}\rangle\]

où

\[\mathcal{H}_{\text{el}} = - \sum_i \frac{\nabla_{r_i}^2}{m_e} - \sum_I\sum_i \frac{Z_I e^2}{|R_I-r_i|} + \sum_i \sum_{j>i} \frac{e^2}{|r_i-r_j|}.\]

En particulier, l’énergie de l’état fondamental est donnée par:

\[E_0 = \frac{\langle \Psi_0 | H_{\text{el}} | \Psi_0 \rangle}{\langle \Psi_0 | \Psi_0 \rangle}\]

où \(\Psi_0\) est l’état fondamental du système.

Cependant, la dimension de ce problème croît de manière exponentielle avec le nombre de degrés de liberté. Pour résoudre ce problème, nous aimerions préparer \(\Psi_0\) sur un ordinateur quantique et mesurer la valeur d’espérance Hamiltonienne (ou \(E_0\)) directement.

Alors, comment le faire concrètement?

L’état initial de Hartree-Fock¶

Un bon point de départ pour résoudre ce problème est la méthode Hartree-Fock (HF). Cette méthode transforme un problème à N-corps par approximation en N problèmes à un corps où chaque électron évolue dans le champ moyen des autres. La résolution classique des équations HF est efficace et conduit à l’énergie d’échange exacte, mais n’inclut pas de corrélation électronique. Par conséquent, il s’agit généralement d’un bon point de départ pour commencer à ajouter une corrélation.

The Hamiltonian can then be re-expressed in the basis of the solutions of the HF method, also called Molecular Orbitals (MOs):

\[\hat{H}_{elec}=\sum_{pq} h_{pq} \hat{a}^{\dagger}_p \hat{a}_q + \frac{1}{2} \sum_{pqrs} h_{pqrs} \hat{a}^{\dagger}_p \hat{a}^{\dagger}_q \hat{a}_r \hat{a}_s\]

avec les intégrales sur 1 corps

\[h_{pq} = \int \phi^*_p(r) \left( -\frac{1}{2} \nabla^2 - \sum_{I} \frac{Z_I}{R_I- r} \right) \phi_q(r)\]

et les intégrales à 2 corps

\[h_{pqrs} = \int \frac{\phi^*_p(r_1) \phi^*_q(r_2) \phi_r(r_2) \phi_s(r_1)}{|r_1-r_2|}.\]

Les Orbitales Moléculaires (´´Molecular Orbitals´´ ou ´´MOs´´ (\(\phi_u\)) peuvent être occupés ou virtuels (non occupés). Un MO peut contenir 2 électrons. Cependant, dans ce qui suit nous travaillons avec Spin Orbitals qui sont associés à un spin up (\(\alpha\)) d’un spin down (\(\beta\)) electron. Ainsi, Spin Orbitals peuvent contenir un électron ou être inoccupé.

We now show how to concretely realise these steps with Qiskit.

Qiskit est interfacé avec différents codes classiques qui sont en mesure de trouver les solutions HF. Une interface entre Qiskit et les codes suivants est déjà disponible : * Gaussien * Psi4 * PyQuante * PySCF

Dans ce qui suit, nous avons mis en place un moteur PySCF pour la molécule d’hydrogène à la longueur de la liaison d’équilibre (0.735 angstrom) dans l’état singulet et sans charge.

[4]:

from qiskit.chemistry.drivers import PySCFDriver, UnitsType, Molecule
molecule = Molecule(geometry=[['H', [0., 0., 0.]],
                              ['H', [0., 0., 0.735]]],
                     charge=0, multiplicity=1)
driver = PySCFDriver(molecule = molecule, unit=UnitsType.ANGSTROM, basis='sto3g')

Pour plus d’informations sur les conducteurs (´´drivers´´), voir https://qiskit.org/documentation/apidoc/qiskit.chemistry.drivers.html

Le mappage entre les fermions et les qubits¶

ae3dfec201f840fbbeaeaa0eafa4e414

L” Hamiltonien donné dans la section précédente est exprimé en termes d’opérateurs fermioniques. Pour encoder le problème dans l’état d’un ordinateur quantique, ces opérateurs doivent être mappés aux opérateurs de spin (en effet les qubits suivent des statistiques de spin).

Il existe différents types de correspondances avec des propriétés différentes. Qiskit supporte déjà les correspondances suivants: * The Jordan-Wigner’jordan_wigner’mapping (über das paulische äquivalenzverbot. Dans The Collected Works of Eugene Paul Wigner (pp. 109-129). Springer, Berlin, Heidelberg (1993)). * The Parity’parité”(The Journal of chemical physiques, 137 (22), 224109 (2012)) * The Bravyi-Kitaev’bravyi_kitaev”(Annals of Physics, 298 (1), 210-226 (2002)) * The Bravyi-Kitaev Super Fast’bksf”(Annals of Physics, 298 (1), 210-226 (2002))

Le mapping Jordan-Wigner est particulièrement intéressant car il fait correspondre chaque Spin Orbital à un qubit (comme indiqué sur la figure ci-dessus).

Ici nous avons mis en place un objet qui contient toutes les informations sur toute transformation du Hamiltonien fermionique en Hamiltonien de qubits. Dans cet exemple, nous demandons simplement le mappage Jordan-Wigner.

[3]:

from qiskit.chemistry.transformations import (FermionicTransformation,
                                              FermionicTransformationType,
                                              FermionicQubitMappingType)

fermionic_transformation = FermionicTransformation(
            transformation=FermionicTransformationType.FULL,
            qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
            two_qubit_reduction=False,
            freeze_core=False)

Si nous transformons maintenant cet Hamiltonien pour le conducteur (driver) donné et défini ci-dessus, nous obtenons notre opérateur de qubit:

[4]:

qubit_op, _ = fermionic_transformation.transform(driver)
print(qubit_op)
print(fermionic_transformation.molecule_info)

SummedOp([
  -0.8105479805373266 * IIII,
  0.17218393261915552 * IIIZ,
  -0.22575349222402472 * IIZI,
  0.1721839326191556 * IZII,
  -0.22575349222402466 * ZIII,
  0.1209126326177663 * IIZZ,
  0.16892753870087912 * IZIZ,
  0.045232799946057854 * XXYY,
  0.045232799946057854 * YYYY,
  0.045232799946057854 * XXXX,
  0.045232799946057854 * YYXX,
  0.16614543256382414 * ZIIZ,
  0.16614543256382414 * IZZI,
  0.17464343068300453 * ZIZI,
  0.1209126326177663 * ZZII
])
{'num_particles': [1, 1], 'num_orbitals': 4, 'two_qubit_reduction': False, 'z2_symmetries': <qiskit.aqua.operators.legacy.weighted_pauli_operator.Z2Symmetries object at 0x123f6d940>}

Dans la base minimale (STO-3G), il faut 4 qubits. Nous pourrions même abaisser le nombre de qubits en utilisant le mappage Parity qui permet de se débarrasser des qubits par des considérations de symétrie.

[5]:

fermionic_transformation_2 = FermionicTransformation(
            transformation=FermionicTransformationType.FULL,
            qubit_mapping=FermionicQubitMappingType.PARITY,
            two_qubit_reduction=True,
            freeze_core=False)
qubit_op_2, _ = fermionic_transformation_2.transform(driver)
print(qubit_op_2)

SummedOp([
  -1.052373245772859 * II,
  0.39793742484318007 * IZ,
  -0.39793742484318007 * ZI,
  -0.01128010425623538 * ZZ,
  0.18093119978423136 * XX
])

Cette fois-ci, seulement 2 qubits sont nécessaires.

Another possibility is to use the Particle-Hole transformation (Physical Review A, 98(2), 022322 (2018)). This shifts the vacuum state to a state lying in the N-particle Fock space. In this representation the HF (reference) state has a null energy and the optimization procedure is more faster.

[6]:

fermionic_transformation_3 = FermionicTransformation(
            transformation=FermionicTransformationType.PARTICLE_HOLE,
            qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
            two_qubit_reduction=False,
            freeze_core=False)
qubit_op_3, _ = fermionic_transformation_3.transform(driver)
print(qubit_op_3)

SummedOp([
  1.0264200106656571 * IIII,
  0.17218393261915554 * IIIZ,
  -0.22575349222402463 * IIZI,
  0.17218393261915554 * IZII,
  -0.22575349222402458 * ZIII,
  0.16892753870087912 * IZIZ,
  0.045232799946057854 * YYYY,
  0.045232799946057854 * XXYY,
  0.045232799946057854 * YYXX,
  0.045232799946057854 * XXXX,
  0.1209126326177663 * IIZZ,
  0.16614543256382414 * IZZI,
  0.16614543256382414 * ZIIZ,
  0.17464343068300453 * ZIZI,
  0.1209126326177663 * ZZII
])

La liste des mappages et des transformations disponibles est

[7]:

print('*Transformations')
for fer_transform in FermionicTransformationType:
    print(fer_transform)

print('\n*Mappings')
for fer_mapping in FermionicQubitMappingType:
    print(fer_mapping)

*Transformations
FermionicTransformationType.FULL
FermionicTransformationType.PARTICLE_HOLE

*Mappings
FermionicQubitMappingType.JORDAN_WIGNER
FermionicQubitMappingType.PARITY
FermionicQubitMappingType.BRAVYI_KITAEV

Maintenant que l’Hamiltonien est prêt, il peut être utilisé dans un algorithme quantique pour trouver des informations sur la structure électronique de la molécule correspondante. Consultez nos tutoriels sur Calcul de l’état du sol (Ground State Calculation) et Calcul des états excités (Excited State Calculation) pour en savoir plus sur la façon de le faire dans Qiskit !

[1]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.23.0
Terra	0.16.0
Aer	0.7.0
Ignis	0.5.0
Aqua	0.8.0
IBM Q Provider	0.11.0
System information
Python	3.6.9 \|Anaconda, Inc.\| (default, Jul 30 2019, 13:42:17) [GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)]
OS	Darwin
CPUs	2
Memory (Gb)	16.0
Tue Oct 20 18:02:17 2020 CEST

This code is a part of Qiskit

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

[ ]: