Hamiltonian untuk Kimia Kuantum
Mari kita mulakan dengan gambaran ringkas tentang peranan yang dimainkan oleh Hamiltonian dalam VQE.
Gambaran Keseluruhan Hamiltonian dalam VQE​
Dr. Victoria Lipinska membimbing kita melalui Hamiltonian dan cara memetakannya untuk digunakan dalam pengkomputeran kuantum.
Rujukan​
Artikel-artikel berikut dirujuk dalam video di atas.
- 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.
Menyediakan Hamiltonian untuk Kimia Kuantum​
Langkah pertama yang baik dalam mengaplikasikan pengkomputeran kuantum kepada masalah kimia ialah mentakrifkan Hamiltonian untuk sistem yang diminati. Di sini, kita akan mengehadkan perbincangan kepada Hamiltonian kimia kuantum, kerana Hamiltonian tersebut memerlukan beberapa pemetaan khusus untuk sistem fermion yang serupa.
Sebagai seseorang yang bekerja dalam kimia kuantum, anda mungkin sudah mempunyai perisian kegemaran untuk pemodelan molekul, yang boleh menghasilkan Hamiltonian yang menggambarkan sistem yang diminati. Di sini, kita akan menggunakan kod yang dibina hanya pada PySCF, numpy, dan Qiskit. Tetapi proses penyediaan Hamiltonian juga boleh dipindahkan ke penyelesaian prapakej. Satu-satunya perbezaan antara pendekatan ini dengan perisian lain ialah perbezaan sintaks kecil; sebahagiannya ditangani dalam subseksyen "Perisian pihak ketiga" untuk memudahkan integrasi aliran kerja sedia ada.
Menghasilkan Hamiltonian kimia kuantum untuk digunakan pada QPU IBM Quantum® melibatkan langkah-langkah berikut:
- Takrifkan molekul anda (geometri, spin, ruang aktif, dan sebagainya)
- Jana Hamiltonian fermionic (operator penciptaan dan pemusnahan)
- Petakan daripada Hamiltonian fermionic kepada operator bosonik (dalam konteks ini, menggunakan operator Pauli)
- Jika menggunakan perisian pihak ketiga: Tangani sebarang ketidakpadanan sintaks antara perisian penjana dan Qiskit
Hamiltonian fermionic ditulis dalam sebutan operator fermionic, dan khususnya, mengambil kira bahawa elektron adalah fermion yang tidak boleh dibezakan. Ini bermakna ia mematuhi statistik yang sama sekali berbeza daripada yang berlaku untuk Qubit bosonik yang boleh dibezakan. Itulah sebabnya proses pemetaan diperlukan.
Mereka yang sudah biasa dengan proses-proses ini mungkin boleh melangkau bahagian ini. Matlamat:
Matlamat akhir adalah untuk mendapatkan Hamiltonian dalam bentuk:
# 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')]
Atau
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])
Kita akan mulakan dengan mengimport beberapa pakej:
import numpy as np
from pyscf import ao2mo, gto, mcscf, scf
- Takrifkan molekul anda
Di sini kita akan menentukan atribut molekul yang diminati. Dalam contoh ini, kita telah memilih hidrogen dwiatomik (kerana Hamiltonian yang dihasilkan cukup pendek untuk dipaparkan). Rangka Kerja Simulasi Kimia berasaskan Python (PySCF) mempunyai koleksi modul struktur elektronik yang luas yang boleh digunakan untuk, antara lain, menjana Hamiltonian molekul yang sesuai untuk pengkomputeran kuantum. Panduan PySCF Quickstart adalah sumber yang sangat baik untuk penerangan lengkap semua pemboleh ubah dan fungsi. Kita hanya akan memberikan gambaran paling ringkas, kerana ini sudah pun biasa bagi kebanyakan anda. Untuk memahami ini dengan lebih baik, layari PySCF. Secara ringkas:
distance boleh digunakan untuk molekul dwiatomik, atau hanya nyatakan koordinat Cartesian untuk setiap atom. Jarak dalam unit Angstrom.
gto menjana orbital jenis Gaussian.
basis merujuk kepada fungsi yang digunakan untuk memodelkan orbital molekul. Di sini 'sto-6g' adalah asas minimal yang biasa, dinamakan sempena pemasangan Orbital Jenis Slater menggunakan 6 orbital Gaussian primitif.
spin nilai integer yang menunjukkan bilangan elektron tidak berpasangan (bersamaan dengan ). Perhatikan bahawa sesetengah perisian menggunakan multiplisiti ().
charge cas molekul.
symmetry - kumpulan simetri titik molekul, sama ada ditentukan dengan rentetan atau dikesan secara automatik dengan menetapkan "symmetry = True". Di sini "Dooh" adalah kumpulan simetri yang sesuai untuk molekul dwiatomik dengan dua spesies atom yang sama.
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>
Ingat bahawa seseorang boleh menggambarkan tenaga jumlah (yang merangkumi tenaga tolakan nukleus serta tenaga elektronik), tenaga orbital elektronik jumlah, atau tenaga sebahagian subset orbital elektronik (dengan subset komplementari dibekukan). Dalam kes khusus , perhatikan tenaga-tenaga berbeza di bawah, dan perhatikan bahawa jumlah tenaga tolak tenaga tolakan nukleus memang menghasilkan tenaga elektronik:
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)
- Jana Hamiltonian fermionic
scf merujuk kepada pelbagai kaedah medan diri-konsisten.
rhf seperti dalam mf = scf.RHF(mol) dalam mf adalah penyelesai yang menggunakan pengiraan Hartree Fock Terhad. Kernel ini (E, di bawah) adalah tenaga jumlah, termasuk tolakan nukleus dan orbital molekul.
mcscf adalah pakej medan diri-konsisten berbilang konfigurasi.
ao2mo adalah transformasi daripada orbital atom kepada orbital molekul.
Kita juga menggunakan pemboleh ubah berikut:
ncas: bilangan orbital dalam ruang aktif lengkap
nelecas: bilangan elektron dalam ruang aktif lengkap
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]
Kita mahu Hamiltonian, dan ini sering diasingkan kepada tenaga teras elektronik (ecore, tidak terlibat dalam minimisasi), operator elektron tunggal (h1e), dan tenaga dua elektron (h2e). Ini diekstrak secara eksplisit di bawah dalam dua baris terakhir.
h1e, ecore = mx.get_h1eff()
h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)
Hamiltonian ini pada masa ini adalah operator fermionic (penciptaan dan pemusnahan), yang boleh digunakan untuk sistem fermion (yang tidak boleh dibezakan), dan sesuai dengan antisimetri di bawah pertukaran. Ini menghasilkan statistik yang berbeza berbanding yang berlaku untuk sistem yang boleh dibezakan atau bosonik. Untuk menjalankan pengiraan pada QPU IBM Quantum, kita memerlukan operator bosonik yang menggambarkan tenaga. Hasil pemetaan sedemikian secara konvensional ditulis dalam sebutan operator Pauli, kerana ia adalah Hermitian dan unitari. Terdapat beberapa pemetaan yang boleh digunakan. Salah satu yang paling mudah ialah transformasi Jordan Wigner.
- Memetakan Hamiltonian
Perlu diambil perhatian bahawa terdapat banyak alat yang tersedia untuk memetakan Hamiltonian kimia kepada yang sesuai untuk dijalankan pada komputer kuantum. Di sini, kita melaksanakan pemetaan Jordan Wigner secara terus menggunakan hanya PySCF, numpy, dan Qiskit. Kita komen di bawah tentang pertimbangan sintaks untuk penyelesaian lain. Fungsi Cholesky membantu kita mendapatkan penguraian pangkat rendah bagi sebutan dua elektron dalam 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
Fungsi identity dan creators_destructors menggantikan operator penciptaan dan pemusnahan dalam Hamiltonian fermionic dengan operator Pauli; creators_destructors menggunakan pemetaan Jordan-Wigner.
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
Akhirnya, build_hamiltonian menggunakan fungsi cholesky, identity, dan creators_destructors untuk mencipta Hamiltonian akhir yang sesuai untuk dijalankan pada komputer kuantum.
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()
Akhirnya, kita gunakan build_hamiltonian untuk membina Hamiltonian Qubit kita daripada operator Pauli menggunakan transformasi Jordan-Wigner. Ini juga memberikan kita ketepatan penguraian Cholesky yang kita gunakan.
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])
Buku nota molekul contoh ini menunjukkan persediaan dan Hamiltonian untuk beberapa molekul dengan kerumitan yang berbeza-beza; dengan sedikit pengubahsuaian, ini seharusnya membolehkan anda mengkaji kebanyakan molekul kecil.
Mari kita perhatikan secara ringkas dua perkara penting yang perlu dipertimbangkan semasa membina operator fermionic untuk sesebuah molekul. Apabila jenis molekul berubah, simetrinya juga akan berubah. Begitu juga, bilangan orbital dengan simetri pelbagai, seperti "A1" yang simetri silinder, akan berubah. Perubahan ini jelas kelihatan walaupun dengan sambungan mudah kepada LiH, seperti yang dilihat di sini:
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)
Perlu juga diperhatikan bahawa seseorang boleh dengan cepat kehilangan intuisi untuk Hamiltonian akhir yang dihasilkan. Hamiltonian untuk LiH (menggunakan mapper Jordan-Wigner) sudah terdiri daripada 276 sebutan.
len(build_hamiltonian(ecore, h1e, h2e))
accuracy of Cholesky decomposition 1.1102230246251565e-16
276
Apabila ragu-ragu tentang simetri, seseorang juga boleh menjana beberapa maklumat simetri untuk molekul tersebut dengan menetapkan symmetry = True dan 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>
Antara maklumat berguna yang lain, ini mengembalikan point group symmetry = Coov dan juga bilangan orbital dalam setiap representasi tak terturunkan.
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
Ini tidak semestinya memberitahu anda berapa banyak orbital yang anda mahu sertakan dalam ruang aktif anda, tetapi ia membantu anda melihat orbital yang ada dan simetrinya.
Menentukan simetri dan orbital sering berguna, tetapi anda juga boleh menentukan bilangan orbital yang ingin disertakan. Pertimbangkan kes etena, di bawah. Menggunakan verbose = 4, kita boleh cetak simetri pelbagai 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>
Kita peroleh:
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
Tetapi daripada menentukan semua orbital mengikut simetri, kita boleh tulis sahaja:
active_space = range(mol.nelectron // 2 - 2, mol.nelectron // 2 + 2)
Dalam pendekatan ini, kita ambil beberapa orbital berhampiran aras pengisian (valens dan tidak diduduki). Di sini, 5 orbital telah dipilih untuk disertakan dalam ruang aktif (yang ke-6 hingga ke-10).
print(
mol.nelectron // 2 - 2,
mol.nelectron // 2 + 2,
)
6 10
- Perisian Pihak Ketiga
Terdapat beberapa pakej perisian yang dibangunkan untuk kimia kuantum, ada yang menawarkan pelbagai mapper dan alat untuk mengehadkan ruang aktif. Langkah-langkah yang diterangkan di atas adalah umum dan boleh digunakan untuk perisian pihak ketiga juga. Tetapi perisian lain ini mungkin mengembalikan Hamiltonian dalam format yang tidak diterima oleh Qiskit. Sebagai contoh, sesetengah perisian mengembalikan Hamiltonian dalam bentuk:
H = -0.042 [] + -0.045 [X0 X1 Y2 Y3] + ... + 0.178 [Z0] + ... + 0.176 [Z2 Z3] + -0.243 [Z3]
Perhatikan khususnya bahawa Gate dinombori, dan operator identiti tidak ditunjukkan. Ini berbeza dengan Hamiltonian yang digunakan dalam Qiskit, yang akan menulis sebutan [Z2 Z3] sebagai ZZII (Qubit 0 dan 1 dikenakan operator identiti, Qubit 2 dan 3 dikenakan operator Z, disusun dengan Qubit 0 paling jauh ke kanan).
Untuk menampung sebarang aliran kerja sedia ada yang anda miliki, blok kod di bawah menukar dari satu sintaks ke satu lagi. Fungsi convert_openfermion_to_qiskit mengambil sebagai argumennya Hamiltonian yang dijana dalam OpenFermion atau Tangelo (dan sudah dipetakan kepada operator Pauli menggunakan mana-mana mapper yang tersedia), dan bilangan Qubit yang diperlukan untuk molekul.
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)
Selanjutnya, buku nota Python ini mengandungi kod contoh lengkap untuk memindahkan Hamiltonian daripada aliran kerja perisian lain ke dalam Qiskit, termasuk penukaran di atas.
Anda kini sepatutnya mempunyai pelbagai alat untuk mendapatkan Hamiltonian yang diperlukan bagi menjalankan pengiraan kimia kuantum pada komputer kuantum IBM®.