Ang pahinang ito ay hindi pa naisalin. Nakikita mo ang orihinal na bersyon sa Ingles.
Mga Hamiltonian para sa Quantum Chemistry
Magsimula tayo sa isang maikling pangkalahatang-ideya ng papel ng mga Hamiltonian sa VQE.
Pangkalahatang-ideya ng Hamiltonian sa VQE​
Ipinapaliwanag ni Dr. Victoria Lipinska ang mga Hamiltonian at kung paano ito ima-map para magamit sa quantum computing.
Mga Sanggunian​
Ang mga sumusunod na artikulo ay binanggit sa video sa itaas.
- Quantum Algorithms for Fermionic Simulations, Ortiz, et al.
- Simulating Chemistry using Quantum Computers, Kassal et al.
- A Comparison of the Bravyi–Kitaev and Jordan–Wigner Transformations for the Quantum Simulation of Quantum Chemistry, Tranter, et al.
- Quantum Chemistry in the Age of Quantum Computing, Cao, et al.
- Quantum computational chemistry, McArdle, et al.
- The Bravyi-Kitaev transformation for quantum computation of electronic structure, Seeley, et al., McArdle, et al.
Paghahanda ng mga Hamiltonian para sa Quantum Chemistry​
Ang isang magandang unang hakbang sa pag-apply ng quantum computing sa isang problema sa chemistry ay ang pagtukoy ng Hamiltonian para sa sistemang pinag-aaralan. Dito, lilimitahan natin ang talakayan sa mga Hamiltonian ng quantum chemistry, dahil ang mga ito ay nangangailangan ng ilang partikular na pagma-map para sa mga sistema ng magkaparehong fermion.
Bilang isang taong nagtatrabaho sa quantum chemistry, malamang na mayroon ka nang paboritong software para sa pag-modelo ng mga molekula, na kayang gumawa ng Hamiltonian na naglalarawan sa iyong sistema. Dito, gagamit tayo ng code na nakabatay lamang sa PySCF, numpy, at Qiskit. Ngunit ang proseso ng paghahanda ng Hamiltonian ay naaangkop din sa mga pre-packaged na solusyon. Ang pagkakaiba lang ng pamamaraang ito sa ibang software ay mga maliit na pagkakaiba sa syntax; ang ilan sa mga ito ay tinutugunan sa subseksyong "Third-party software" upang mapadali ang pagsasama ng mga kasalukuyang workflow.
Ang pag-generate ng quantum chemistry Hamiltonian para gamitin sa IBM Quantum® QPUs ay kinabibilangan ng mga sumusunod na hakbang:
- Tukuyin ang iyong molekula (geometry, spin, active space, at iba pa)
- I-generate ang fermionic Hamiltonian (mga creation at annihilation operator)
- Mag-map mula sa fermionic Hamiltonian patungo sa bosonic operator (sa kontekstong ito, gamit ang mga Pauli operator)
- Kung gumagamit ng third-party software: Hawakan ang anumang hindi pagkakatugma ng syntax sa pagitan ng generating software at Qiskit
Ang fermionic Hamiltonian ay nakasulat sa mga tuntunin ng fermionic operator, at partikular na isinasaalang-alang na ang mga elektron ay mga hindi makilalang fermion. Ibig sabihin, sumusunod sila sa ganap na magkaibang statistics kaysa sa mga nakikilala at bosonic na qubit. Kaya naman kailangan ang proseso ng pagma-map.
Ang mga pamilyar na sa mga prosesong ito ay maaaring laktawan na ang seksyong ito. Layunin:
Ang panghuling layunin ay makakuha ng Hamiltonian sa sumusunod na anyo:
# Added by doQumentation — required packages for this notebook
!pip install -q numpy openfermion pyscf qiskit
H = [(1, "XX"), (1, "YY"), (1, "ZZ")]
print(H)
[(1, 'XX'), (1, 'YY'), (1, 'ZZ')]
O kaya
from qiskit.quantum_info import SparsePauliOp
H = SparsePauliOp(["XX", "YY", "ZZ"], coeffs=[1.0 + 0.0j, 1.0 + 0.0j, 1.0 + 0.0j])
print(H)
SparsePauliOp(['XX', 'YY', 'ZZ'],
coeffs=[1.+0.j, 1.+0.j, 1.+0.j])
Magsisimula tayo sa pag-import ng ilang package:
import numpy as np
from pyscf import ao2mo, gto, mcscf, scf
- Tukuyin ang iyong molekula
Dito, tutukuyin natin ang mga katangian ng molekulang pinag-aaralan. Sa halimbawang ito, pinili natin ang diatomic hydrogen (dahil ang mga resultang Hamiltonian ay maikling sapat para ipakita). Ang Python-based Simulations of Chemistry Framework (PySCF) ay may malawak na koleksyon ng mga electronic structure module na maaaring gamitin para, sa iba pang mga bagay, gumawa ng mga molecular Hamiltonian na angkop para sa quantum computation. Ang gabay na PySCF Quickstart ay isang mahusay na mapagkukunan para sa kumpletong paglalarawan ng lahat ng variable at functionality. Magbibigay lang tayo ng pinakamaikling pangkalahatang-ideya, dahil pamilyar na ito sa marami sa inyo. Para mas maunawaan ang mga ito, bisitahin ang PySCF. Sa madaling salita:
distance ay maaaring gamitin para sa mga diatomic na molekula, o simpleng tukuyin ang Cartesian coordinates para sa bawat atomo. Ang mga distansya ay nasa yunit ng Angstrom.
gto ay gumagawa ng gaussian-type orbitals.
basis ay tumutukoy sa mga function na ginagamit para mag-modelo ng mga molecular orbital. Dito, ang 'sto-6g' ay isang karaniwang minimal na basis, pinangalan sa pag-fit ng Slater-Type Orbitals gamit ang 6 primitive Gaussian orbital.
spin isang integer na halaga na nagpapahiwatig ng bilang ng mga hindi magkasamang elektron (katumbas ng ). Tandaan na ang ilang software ay gumagamit ng multiplicity sa halip ().
charge ang charge ng molekula.
symmetry - ang point symmetry group ng molekula, alinmang tinukoy gamit ang string o awtomatikong natutukoy sa pamamagitan ng pagtatakda ng "symmetry = True". Dito, ang "Dooh" ay ang naaangkop na symmetry group para sa mga diatomic na molekula na may dalawang parehong uri ng atomo.
distance = 0.735
a = distance / 2
mol = gto.Mole()
mol.build(
verbose=0,
atom=[
["H", (0, 0, -a)],
["H", (0, 0, a)],
],
basis="sto-6g",
spin=0,
charge=0,
symmetry="Dooh",
)
<pyscf.gto.mole.Mole at 0x7fc718f07610>
Tandaan na maaaring ilarawan ang kabuuang enerhiya (na kinabibilangan ng nuclear repulsion energy pati na rin ng electronic), kabuuang electronic orbital energy, o ang enerhiya ng ilang subset ng mga electronic orbital (na may komplementaryong subset na naka-freeze). Sa partikular na kaso ng , pansinin ang iba't ibang enerhiya sa ibaba, at pansinin na ang kabuuang enerhiya na binawasan ng nuclear repulsion energy ay talagang nagbubunga ng electronic energy:
mf = scf.RHF(mol)
mf.scf()
print(
mf.energy_nuc(),
mf.energy_elec()[0],
mf.energy_tot(),
mf.energy_tot() - mol.energy_nuc(),
)
0.7199689944489797 -1.8455976628764188 -1.125628668427439 -1.8455976628764188
active_space = range(mol.nelectron // 2 - 1, mol.nelectron // 2 + 1)
- I-generate ang fermionic Hamiltonian
scf ay tumutukoy sa malawak na hanay ng mga self-consistent field method.
rhf gaya ng mf = scf.RHF(mol) sa mf ay isang solver na gumagamit ng Restricted Hartree Fock calculation. Ang kernel nito (E, sa ibaba) ay ang kabuuang enerhiya, kasama ang nuclear repulsion at molecular orbital.
mcscf ay isang multi-configuration self-consistent fields package.
ao2mo ay isang transformation mula sa atomic orbital patungo sa molecular orbital.
Ginagamit din natin ang mga sumusunod na variable:
ncas: bilang ng mga orbital sa complete active space
nelecas: bilang ng mga elektron sa complete active space
E1 = mf.kernel()
mx = mcscf.CASCI(mf, ncas=2, nelecas=(1, 1))
mo = mx.sort_mo(active_space, base=0)
E2 = mx.kernel(mo)[:2]
Kailangan natin ng isang Hamiltonian, at ito ay madalas na hinihiwalay sa enerhiya ng electronic core (ecore, hindi kasama sa minimization), single-electron operator (h1e), at two-electron energies (h2e). Ang mga ito ay tahasang kinukuha sa ibaba sa huling dalawang linya.
h1e, ecore = mx.get_h1eff()
h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)
Ang mga Hamiltonian na ito ay kasalukuyang fermionic (creation at annihilation) operator, na naaangkop sa mga sistema ng (hindi makilalang) fermion, at alinsunod dito ay napapailalim sa antisymmetry sa ilalim ng palitan. Nagbubunga ito ng iba't ibang statistics kaysa sa maaaring mag-apply sa isang nakikilala o bosonic na sistema. Para makapagpatakbo ng mga kalkulasyon sa IBM Quantum QPU, kailangan natin ng bosonic operator na naglalarawan ng enerhiya. Ang resulta ng ganitong pagma-map ay kaugaliang nakasulat sa mga tuntunin ng Pauli operator, dahil sila ay parehong Hermitian at unitary. May ilang pagma-map na maaaring gamitin. Isa sa pinakasimple ay ang Jordan-Wigner transformation.
- Pag-map ng Hamiltonian
Dapat tandaan na maraming tool ang magagamit para mag-map ng chemical Hamiltonian patungo sa isa na angkop para patakbuhin sa isang quantum computer. Dito, direkta naming isinasagawa ang Jordan-Wigner mapping gamit lamang ang PySCF, numpy, at Qiskit. Nagkokomento tayo sa ibaba tungkol sa mga konsiderasyon sa syntax para sa ibang solusyon. Tinutulungan tayo ng Cholesky function na makakuha ng low-rank decomposition ng mga two-electron term sa Hamiltonian.
def cholesky(V, eps):
# see https://arxiv.org/pdf/1711.02242.pdf section B2
# see https://arxiv.org/abs/1808.02625
# see https://arxiv.org/abs/2104.08957
no = V.shape[0]
chmax, ng = 20 * no, 0
W = V.reshape(no**2, no**2)
L = np.zeros((no**2, chmax))
Dmax = np.diagonal(W).copy()
nu_max = np.argmax(Dmax)
vmax = Dmax[nu_max]
while vmax > eps:
L[:, ng] = W[:, nu_max]
if ng > 0:
L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])
L[:, ng] /= np.sqrt(vmax)
Dmax[: no**2] -= L[: no**2, ng] ** 2
ng += 1
nu_max = np.argmax(Dmax)
vmax = Dmax[nu_max]
L = L[:, :ng].reshape((no, no, ng))
print(
"accuracy of Cholesky decomposition ",
np.abs(np.einsum("prg,qsg->prqs", L, L) - V).max(),
)
return L, ng
Pinapalitan ng mga function na identity at creators_destructors ang mga creation at annihilation operator sa fermionic Hamiltonian ng mga Pauli operator; gumagamit ang creators_destructors ng Jordan-Wigner mapping.
def identity(n):
return SparsePauliOp.from_list([("I" * n, 1)])
def creators_destructors(n, mapping="jordan_wigner"):
c_list = []
if mapping == "jordan_wigner":
for p in range(n):
if p == 0:
ell, r = "I" * (n - 1), ""
elif p == n - 1:
ell, r = "", "Z" * (n - 1)
else:
ell, r = "I" * (n - p - 1), "Z" * p
cp = SparsePauliOp.from_list([(ell + "X" + r, 0.5), (ell + "Y" + r, -0.5j)])
c_list.append(cp)
else:
raise ValueError("Unsupported mapping.")
d_list = [cp.adjoint() for cp in c_list]
return c_list, d_list
Sa wakas, ginagamit ng build_hamiltonian ang mga function na cholesky, identity, at creators_destructors para lumikha ng panghuling Hamiltonian na angkop para patakbuhin sa isang quantum computer.
def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:
ncas, _ = h1e.shape
C, D = creators_destructors(2 * ncas, mapping="jordan_wigner")
Exc = []
for p in range(ncas):
Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]
for r in range(p + 1, ncas):
Excp.append(
C[p] @ D[r]
+ C[ncas + p] @ D[ncas + r]
+ C[r] @ D[p]
+ C[ncas + r] @ D[ncas + p]
)
Exc.append(Excp)
# low-rank decomposition of the Hamiltonian
Lop, ng = cholesky(h2e, 1e-6)
t1e = h1e - 0.5 * np.einsum("pxxr->pr", h2e)
H = ecore * identity(2 * ncas)
# one-body term
for p in range(ncas):
for r in range(p, ncas):
H += t1e[p, r] * Exc[p][r - p]
# two-body term
for g in range(ng):
Lg = 0 * identity(2 * ncas)
for p in range(ncas):
for r in range(p, ncas):
Lg += Lop[p, r, g] * Exc[p][r - p]
H += 0.5 * Lg @ Lg
return H.chop().simplify()
Sa wakas, ginagamit natin ang build_hamiltonian para buuin ang ating qubit Hamiltonian mula sa mga Pauli operator gamit ang Jordan-Wigner transformation. Nagbibigay din ito sa atin ng katumpakan ng Cholesky decomposition na ginamit natin.
H = build_hamiltonian(ecore, h1e, h2e)
print(H)
accuracy of Cholesky decomposition 2.220446049250313e-16
SparsePauliOp(['IIII', 'IIIZ', 'IZII', 'IIZI', 'ZIII', 'IZIZ', 'IIZZ', 'ZIIZ', 'IZZI', 'ZZII', 'ZIZI', 'YYYY', 'XXYY', 'YYXX', 'XXXX'],
coeffs=[-0.09820182+0.j, -0.1740751 +0.j, -0.1740751 +0.j, 0.2242933 +0.j,
0.2242933 +0.j, 0.16891402+0.j, 0.1210099 +0.j, 0.16631441+0.j,
0.16631441+0.j, 0.1210099 +0.j, 0.17504456+0.j, 0.04530451+0.j,
0.04530451+0.j, 0.04530451+0.j, 0.04530451+0.j])
Ipinapakita ng example molecule notebook na ito ang setup at mga Hamiltonian para sa ilang molekula ng iba't ibang kumplikasyon; sa kaunting pagbabago, dapat nitong paganahin kang suriin ang karamihan sa mga maliliit na molekula.
Pansinin natin nang maikli ang dalawang mahalagang puntong dapat isaalang-alang kapag binubuo ang mga fermionic operator para sa isang molekula. Habang nagbabago ang uri ng molekula, magbabago rin ang symmetry. Gayundin, magbabago ang bilang ng mga orbital na may iba't ibang symmetry, tulad ng cylindrically symmetric na "A1". Malinaw ang mga pagbabagong ito kahit sa simpleng extension sa LiH, gaya ng nakikita dito:
distance = 1.56
mol = gto.Mole()
mol.build(
verbose=0,
atom=[["Li", (0, 0, 0)], ["H", (0, 0, distance)]],
basis="sto-6g",
spin=0,
charge=0,
symmetry="Coov",
)
mf = scf.RHF(mol)
E1 = mf.kernel()
# %% ----------------------------------------------------------------------------------------------
mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))
cas_space_symmetry = {"A1": 3, "E1x": 1, "E1y": 1}
mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)
E2 = mx.kernel(mo)[:2]
h1e, ecore = mx.get_h1eff()
h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)
Kapansin-pansin din na mabilis na mawawala ang intuisyon para sa panghuling resultang Hamiltonian. Ang Hamiltonian para sa LiH (gamit ang Jordan-Wigner mapper) ay binubuo na ng 276 term.
len(build_hamiltonian(ecore, h1e, h2e))
accuracy of Cholesky decomposition 1.1102230246251565e-16
276
Kapag may pagdududa tungkol sa mga symmetry, maaari ring mag-generate ng ilang impormasyon tungkol sa symmetry para sa molekula sa pamamagitan ng pagtatakda ng symmetry = True at verbose = 4:
distance = 1.56
mol = gto.Mole()
mol.build(
verbose=4,
atom=[["Li", (0, 0, 0)], ["H", (0, 0, distance)]],
basis="sto-6g",
spin=0,
charge=0,
symmetry=True,
)
System: uname_result(system='Linux', node='IBM-R912JTRT', release='5.10.102.1-microsoft-standard-WSL2', version='#1 SMP Wed Mar 2 00:30:59 UTC 2022', machine='x86_64') Threads 16
Python 3.11.12 (main, May 16 2025, 02:33:32) [GCC 11.4.0]
numpy 2.3.1 scipy 1.16.0 h5py 3.14.0
Date: Mon Jun 30 12:56:55 2025
PySCF version 2.9.0
PySCF path /home/porter284/.pyenv/versions/3.11.12/lib/python3.11/site-packages/pyscf
[CONFIG] conf_file None
[INPUT] verbose = 4
[INPUT] num. atoms = 2
[INPUT] num. electrons = 4
[INPUT] charge = 0
[INPUT] spin (= nelec alpha-beta = 2S) = 0
[INPUT] symmetry True subgroup None
[INPUT] Mole.unit = angstrom
[INPUT] Symbol X Y Z unit X Y Z unit Magmom
[INPUT] 1 Li 0.000000000000 0.000000000000 0.000000000000 AA 0.000000000000 0.000000000000 0.000000000000 Bohr 0.0
[INPUT] 2 H 0.000000000000 0.000000000000 1.560000000000 AA 0.000000000000 0.000000000000 2.947972754321 Bohr 0.0
nuclear repulsion = 1.01764848253846
point group symmetry = Coov
symmetry origin: [0. 0. 0.73699319]
symmetry axis x: [1. 0. 0.]
symmetry axis y: [0. 1. 0.]
symmetry axis z: [0. 0. 1.]
num. orbitals of irrep A1 = 4
num. orbitals of irrep E1x = 1
num. orbitals of irrep E1y = 1
number of shells = 4
number of NR pGTOs = 36
number of NR cGTOs = 6
basis = sto-6g
ecp = {}
CPU time: 9.85
<pyscf.gto.mole.Mole at 0x7fc719f94850>
Bukod sa iba pang kapaki-pakinabang na impormasyon, ibinabalik nito ang parehong point group symmetry = Coov at ang bilang ng mga orbital sa bawat irreducible representation.
point group symmetry = Coov
num. orbitals of irrep A1 = 4
num. orbitals of irrep E1x = 1
num. orbitals of irrep E1y = 1
number of shells = 4
Hindi ito nangangahulugang nagsasabi sa iyo kung gaano karaming orbital ang gusto mong isama sa iyong active space, ngunit tinutulungan ka nitong makita kung anong mga orbital ang naroroon at ang kanilang mga symmetry.
Ang pagtukoy ng symmetry at orbital ay kadalasang kapaki-pakinabang, ngunit maaari ka ring tumukoy ng bilang ng mga orbital na gusto mong isama. Isaalang-alang ang kaso ng ethene sa ibaba. Gamit ang verbose = 4, maaari tayong mag-print ng mga symmetry ng iba't ibang orbital:
# Replace these variables with correct distances:
a = 1
b = 1
c = 1
# Build
mol = gto.Mole()
mol.build(
verbose=4,
atom=[
["C", (0, 0, a)],
["C", (0, 0, -a)],
["H", (0, c, b)],
["H", (0, -c, b)],
["H", (0, c, -b)],
["H", (0, -c, -b)],
],
basis="sto-6g",
spin=0,
charge=0,
symmetry=True,
)
System: uname_result(system='Linux', node='IBM-R912JTRT', release='5.10.102.1-microsoft-standard-WSL2', version='#1 SMP Wed Mar 2 00:30:59 UTC 2022', machine='x86_64') Threads 16
Python 3.11.12 (main, May 16 2025, 02:33:32) [GCC 11.4.0]
numpy 2.3.1 scipy 1.16.0 h5py 3.14.0
Date: Mon Jun 30 12:57:07 2025
PySCF version 2.9.0
PySCF path /home/porter284/.pyenv/versions/3.11.12/lib/python3.11/site-packages/pyscf
[CONFIG] conf_file None
[INPUT] verbose = 4
[INPUT] num. atoms = 6
[INPUT] num. electrons = 16
[INPUT] charge = 0
[INPUT] spin (= nelec alpha-beta = 2S) = 0
[INPUT] symmetry True subgroup None
[INPUT] Mole.unit = angstrom
[INPUT] Symbol X Y Z unit X Y Z unit Magmom
[INPUT] 1 C 0.000000000000 0.000000000000 1.000000000000 AA 0.000000000000 0.000000000000 1.889726124565 Bohr 0.0
[INPUT] 2 C 0.000000000000 0.000000000000 -1.000000000000 AA 0.000000000000 0.000000000000 -1.889726124565 Bohr 0.0
[INPUT] 3 H 0.000000000000 1.000000000000 1.000000000000 AA 0.000000000000 1.889726124565 1.889726124565 Bohr 0.0
[INPUT] 4 H 0.000000000000 -1.000000000000 1.000000000000 AA 0.000000000000 -1.889726124565 1.889726124565 Bohr 0.0
[INPUT] 5 H 0.000000000000 1.000000000000 -1.000000000000 AA 0.000000000000 1.889726124565 -1.889726124565 Bohr 0.0
[INPUT] 6 H 0.000000000000 -1.000000000000 -1.000000000000 AA 0.000000000000 -1.889726124565 -1.889726124565 Bohr 0.0
nuclear repulsion = 29.3377079104231
point group symmetry = D2h
symmetry origin: [0. 0. 0.]
symmetry axis x: [0. 1. 0.]
symmetry axis y: [1. 0. 0.]
symmetry axis z: [-0. -0. -1.]
num. orbitals of irrep Ag = 4
num. orbitals of irrep B2g = 2
num. orbitals of irrep B3g = 1
num. orbitals of irrep B1u = 4
num. orbitals of irrep B2u = 1
num. orbitals of irrep B3u = 2
number of shells = 10
number of NR pGTOs = 84
number of NR cGTOs = 14
basis = sto-6g
ecp = {}
CPU time: 9.92
<pyscf.gto.mole.Mole at 0x7fc719fa9290>
Nakukuha natin:
num. orbitals of irrep Ag = 4
num. orbitals of irrep B2g = 2
num. orbitals of irrep B3g = 1
num. orbitals of irrep B1u = 4
num. orbitals of irrep B2u = 1
num. orbitals of irrep B3u = 2
Ngunit sa halip na tukuyin ang lahat ng orbital ayon sa symmetry, maaari tayong simpleng isulat:
active_space = range(mol.nelectron // 2 - 2, mol.nelectron // 2 + 2)
Sa pamamaraang ito, kumukuha tayo ng ilang orbital malapit sa filling level (valence at unoccupied). Dito, 5 orbital ang napili para isama sa active space (ika-6 hanggang ika-10).
print(
mol.nelectron // 2 - 2,
mol.nelectron // 2 + 2,
)
6 10
- Third-Party Software
May ilang software package na binuo para sa quantum chemistry, ang ilan ay nag-aalok ng maraming mapper at tool para sa paghihigpit ng active space. Ang mga hakbang na inilarawan sa itaas ay pangkalahatan at naaangkop din sa third-party software. Ngunit maaaring magbalik ang ibang software na ito ng mga Hamiltonian sa isang format na hindi tinatanggap ng Qiskit. Halimbawa, ang ilang software ay nagbabalik ng mga Hamiltonian sa sumusunod na anyo:
H = -0.042 [] + -0.045 [X0 X1 Y2 Y3] + ... + 0.178 [Z0] + ... + 0.176 [Z2 Z3] + -0.243 [Z3]
Pansinin lalo na na ang mga gate ay may numero, at hindi ipinapakita ang mga identity operator. Ito ay kaibahan sa mga Hamiltonian na ginagamit sa Qiskit, na isusulat ang term na [Z2 Z3] bilang ZZII (ang qubit 0 at 1 ay kinakatawanan ng identity operator, ang qubit 2 at 3 ay kinakatawanan ng Z operator, inayos nang qubit 0 sa pinakakanan).
Para ma-accommodate ang anumang kasalukuyang workflow na mayroon ka, ang code block sa ibaba ay kino-convert mula sa isang syntax patungo sa isa pa. Ang function na convert_openfermion_to_qiskit ay kumukuha bilang mga argumento nito ng isang Hamiltonian na nalikha sa OpenFermion o Tangelo (at naka-map na sa mga Pauli operator gamit ang anumang available na mapper), at ang bilang ng mga qubit na kailangan para sa molekula.
from openfermion import QubitOperator
from qiskit.quantum_info import SparsePauliOp
def convert_openfermion_to_qiskit(
openfermion_operator: QubitOperator, num_qubits: int
) -> SparsePauliOp:
terms = openfermion_operator.terms
labels = []
coefficients = []
for term, constant in terms.items():
# Default set to identity
operator = list("I" * num_qubits)
# Iterate through PauliSum and replace I with Pauli
for index, pauli in term:
operator[index] = pauli
label = "".join(operator)
labels.append(label)
coefficients.append(constant)
return SparsePauliOp(labels, coefficients)
Bukod pa rito, ang Python notebook na ito ay naglalaman ng kumpletong sample code para sa paglipat ng mga Hamiltonian mula sa ibang software workflow patungo sa Qiskit, kasama ang conversion sa itaas.
Dapat mayroon ka na ngayong isang arsenal ng mga tool para makuha ang Hamiltonian na kailangan mo para magsagawa ng mga kalkulasyon sa quantum chemistry sa IBM® quantum computer.