참고

이 페이지는 tutorials/chemistry/1_programmatic_approach.ipynb 에서 생성되었다.

IBM 퀀텀 랩 에서 대화식으로 실행하시오.

전자 회로¶

소개¶

분자 해밀톤은

\[{\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}{|R_I-r_i|} +\sum_i \sum_ {j> i} \frac {e ^ 2}{|r_i-r_j|} +\sum_I \sum_ {J> I} \frac {Z_I Z_J e ^ 2}{|R_I-R_J|}\]

핵들은 동일한 시간 축척으로 이동하지 않는 전자들보다 훨씬 더 무거운 것이기 때문에, 핵들 및 전자들의 거동은 분리될 수 있다. 이것은 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\]

어디

\[\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|}.\]

특히, 접지 상태 에너지는 다음과 같이 주어진다:

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

여기서 \(\Psi_0\) 는 시스템의 접지 상태이다.

However, the dimensionality of this problem grows exponentially with the number of degrees of freedom. To tackle this issue we would like to prepare \(\Psi_0\) on a quantum computer and measure the Hamiltonian expectation value (or \(E_0\)) directly.

So how do we do that concretely?

Hartree-Fock 초기 상태¶

A good starting point for solving this problem is the Hartree-Fock (HF) method. This method approximates a N-body problem into N one-body problems where each electron evolves in the mean-field of the others. Classically solving the HF equations is efficient and leads to the exact exchange energy but does not include any electron correlation. Therefore, it is usually a good starting point to start adding correlation.

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\]

1-체 통합물을 사용하는 경우

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

and 2-body integrals

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

The MOs (\(\phi_u\)) can be occupied or virtual (unoccupied). One MO can contain 2 electrons. However, in what follows we actually work with Spin Orbitals which are associated with a spin up (\(\alpha\)) of spin down (\(\beta\)) electron. Thus Spin Orbitals can contain one electron or be unoccupied.

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

Qiskit is interfaced with different classical codes which are able to find the HF solutions. Interfacing between Qiskit and the following codes is already available: * Gaussian * Psi4 * PyQuante * PySCF

In the following we set up a PySCF driver, for the hydrogen molecule at equilibrium bond length (0.735 angstrom) in the singlet state and with no 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')

드라이버에 대한 자세한 정보는 https://qiskit.org/documentation/apidoc/qiskit.chemistry.drivers.html를 참조하시오.

Fermions 에서 큐비트로의 매핑¶

c715da916a6545f0bc871dc907db14f0

The Hamiltonian given in the previous section is expressed in terms of fermionic operators. To encode the problem into the state of a quantum computer, these operators must be mapped to spin operators (indeed the qubits follow spin statistics).

There exist different mapping types with different properties. Qiskit already supports the following mappings: * The Jordan-Wigner ‘jordan_wigner’ mapping (über das paulische äquivalenzverbot. In The Collected Works of Eugene Paul Wigner (pp. 109-129). Springer, Berlin, Heidelberg (1993)). * The Parity ‘parity’ (The Journal of chemical physics, 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))

The Jordan-Wigner mapping is particularly interesting as it maps each Spin Orbital to a qubit (as shown on the Figure above).

Here we set up an object which contains all the information about any transformation of the fermionic Hamiltonian to the qubits Hamiltonian. In this example we simply ask for the Jordan-Wigner mapping.

[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)

If we now transform this Hamiltonian for the given driver defined above we get our qubit operator:

[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>}

In the minimal (STO-3G) basis set 4 qubits are required. We could even lower the qubit count by using the Parity mapping which allows to get rid of to qubits by symmetry considerations.

[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
])

이번에는 2 개의 큐비트가 필요하다.

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
])

사용 가능한 맵핑 및 변환 목록은 다음과 같다.

[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

Now that the Hamiltonian is ready, it can be used in a quantum algorithm to find information about the electronic structure of the corresponding molecule. Check out our tutorials on Ground State Calculation and Excited States Calculation to learn more about how to do that in 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.

[ ]: