SQD dan SKQD

Dalam bab ini, kita akan meneroka bagaimana komputer kuantum dan klasik bekerjasama untuk menyelesaikan salah satu cabaran terpenting dalam sains: menganggarkan tenaga molekul dan bahan dengan tepat.

Iskandar Sitdikov menerangkan pendekatan algoritma dalam video berikut.

Hamiltonian

Kunci kepada masalah ini ialah pengendali matematik — Hamiltonian, yang mewakili jumlah tenaga sistem. Untuk tujuan pengiraan, kita boleh menganggap Hamiltonian ini sebagai matriks besar. Penyelesaian yang kita cari — khususnya keadaan asas sistem — ialah nilai eigen terendah bagi matriks ini. Cabaran, walau bagaimanapun, ialah untuk masalah praktikal, matriks Hamiltonian ini sangat besar. Ia berkembang secara eksponen dengan saiz sistem, dengan cepat menjadi terlalu besar ($2^n$ di mana $n$ ialah bilangan Qubit) untuk disimpan atau diselesaikan secara langsung walaupun oleh superkomputer yang paling berkuasa.

$$H = \begin{pmatrix} H_{0,0} & H_{0,1} & \cdots & H_{0,N-1} \\ H_{1,0} & H_{1,1} & \cdots & H_{1,N-1} \\ \vdots & \vdots & \ddots & \vdots \\ H_{N-1,0} & H_{N-1,1} & \cdots & H_{N-1,N-1} \end{pmatrix} \quad (N=2^n)$$

Untuk mengatasi ini, kita menggunakan strategi yang berkuasa yang dikenali sebagai kaedah subruang. Daripada menangani keseluruhan matriks, kita memilih dengan bijak hirisan kecil yang relevan — "subruang" — yang kita percaya mengandungi maklumat terpenting tentang penyelesaian tenaga rendah yang kita cari.

$$\underset{\text{Full Hamiltonian}}{\begin{pmatrix} \ddots & \vdots \\ \cdots & H_{i,j} & \cdots \\ & \vdots & \ddots \end{pmatrix}} \quad \xrightarrow{\text{Project}} \quad \underset{\text{Projected Hamiltonian}}{\tilde{H}} = \begin{pmatrix} \langle b_1 | H | b_1 \rangle & \cdots & \langle b_1 | H | b_L \rangle \\ \vdots & \ddots & \vdots \\ \langle b_L | H | b_1 \rangle & \cdots & \langle b_L | H | b_L \rangle \end{pmatrix} \quad \xrightarrow{\text{Diagonalize}} \quad \underset{\text{Eigenvalues}}{\begin{pmatrix} E_0 & & 0 \\ & \ddots & \\ 0 & & E_{L-1} \end{pmatrix}}$$

Setelah subruang kecil ini ditakrifkan oleh set keadaan asas $\{|b_i\rangle\}$, Hamiltonian penuh diunjurkan ke atasnya untuk mencipta matriks yang lebih kecil, $\tilde{H}$. Setiap elemen matriks ini dikira daripada keadaan asas subruang dan Hamiltonian asal seperti dalam $\langle b_i | H | b_j \rangle$. Matriks kecil ini kemudian boleh dipeserakan dengan mudah pada komputer klasik, dan nilai eigen yang terhasil ialah anggaran tenaga kita.

Seperti yang mungkin anda jangkakan, kejayaan keseluruhan pendekatan ini sangat bergantung pada pemilihan subruang yang "baik". Jika subruang kita tidak mewakili dengan tepat keadaan asas sebenar, jawapan akhir kita akan salah. Di sinilah komputer kuantum berperanan: ia membolehkan kita menyediakan dan mengambil sampel daripada keadaan kuantum kompleks yang direka untuk mengenal pasti subruang penting ini. Untuk masalah yang benar-benar besar, seperti struktur kimia kompleks atau tapak pengikatan, walaupun matriks yang diunjurkan mungkin masih mencabar untuk dipeserakan. Oleh itu, masalah sedemikian sangat sesuai untuk memanfaatkan kekuatan kedua-dua sumber pengiraan kuantum dan klasik.

Dalam bahagian berikutnya, kita akan meneroka dua algoritma lanjutan, SQD dan SKQD, yang memanfaatkan mekanik kuantum untuk mencari dan membina subruang ini. Untuk penerokaan yang lebih mendalam, terdapat kursus penuh di IBM Quantum learning yang didedikasikan kepada topik-topik ini secara terperinci. Untuk tujuan kita dalam kursus ini, kita akan memastikan penjelasan pada peringkat tinggi.

Pepenjurusan Kuantum Berasaskan Sampel

Pepenjurusan Kuantum Berasaskan Sampel (SQD) ialah algoritma variasi yang berkuasa yang melaksanakan kaedah subruang dengan cara kuantum. Ia mengelakkan prosedur yang mahal dan kompleks seperti ujian Hadamard dengan menggunakan komputer kuantum untuk menyediakan keadaan percubaan dan mengambil sampel rentetan bit, yang menentukan subruang untuk pepenjurusan klasik.

Algoritma SQD boleh dipecahkan kepada langkah-langkah berikut:

Langkah 1: Sediakan keadaan Ansatz

Biarkan $H = \sum_{j=1}^Q \alpha_j P_j$ ialah Hamiltonian pada $n$ Qubit. Walaupun keadaan asas sebenar mungkin disokong pada semua $2^n$ keadaan asas, SQD paling berkesan dalam kes di mana keadaan asas boleh dihampirkan dengan baik oleh subruang yang jarang (set rentetan bit bersaiz polinomial).

Untuk membina subruang ini, kita bermula dengan keadaan input $|\phi_0\rangle$, seperti keadaan Hartree-Fock (HF) dalam kimia. Kita kemudian menggunakan Circuit kuantum berparameter, $U(\theta)$, yang dikenali sebagai ansatz.

Rajah ini menggambarkan matlamat ansatz yang baik. Ansatz menyediakan keadaan kuantum yang sokongannya (set keadaan asas yang terdiri daripadanya) seharusnya mempunyai pertindanan besar dengan sokongan keadaan asas sebenar. Circuit ini membolehkan kita mengunjurkan ansatz dengan cepat kepada keadaan asas pengiraan, yang akan digunakan lebih lanjut dalam pepenjurusan klasik. Dalam erti kata lain: kita tidak perlu meneka ansatz yang merupakan keadaan asas; kita hanya perlu ia mengandungi keadaan asas yang sama. Kemudian pepenjurusan klasik Hamiltonian yang diunjurkan akan memberikan kita superposisi keadaan asas yang paling menghampiri keadaan asas.

Langkah 2: Ambil sampel subruang

Dengan mengambil sampel daripada Circuit yang disediakan oleh ansatz, kita mendapat koleksi rentetan bit, $\{b_j\}_{j=1}^L$. Rentetan bit ini menentukan asas subruang yang kita pilih. Masa jalan kuantum untuk langkah ini ditentukan oleh kedalaman Circuit dan bilangan sampel yang diambil.

Langkah 3: Unjur dan peserakan secara klasik

Menggunakan rentetan bit yang diambil sampel, kita mengunjurkan Hamiltonian ke dalam subruang yang dicakupinya. Untuk setiap pasangan rentetan bit $(j, k)$, kita mengira secara klasik elemen matriks $\tilde{H}_{jk} = \langle b_j | H | b_k \rangle$. Kerana pengendali Pauli adalah jarang, langkah ini cekap secara klasik untuk Hamiltonian fizikal. Matriks kecil yang terhasil $\tilde{H}$ kemudian dipeserakan pada pemproses klasik untuk menganggarkan keadaan asas dan tenaganya.

Langkah 4: Optimumkan ansatz (pilihan)

Proses ini boleh dijadikan berulang. Dengan memperlakukan anggaran tenaga keadaan asas sebagai fungsi kos, kita boleh mengoptimumkan parameter Circuit ($\theta$) dengan menggunakan kaedah seperti kecerunan menurun untuk menambah baik ansatz, dan seterusnya, anggaran tenaga dalam lelaran seterusnya.

Kelebihan utama SQD

SQD menawarkan beberapa ciri yang berkuasa yang menjadikannya calon utama untuk menunjukkan kelebihan kuantum:

• Ketahanan yang kuat terhadap hingar: Andaikan keadaan asas sebenar disokong hanya pada dua rentetan bit. Jika ini diambil sampel sama sekali, walaupun pertindanan mereka dengan ansatz kita kecil, pepenjurusan akan memberikan mereka pemberat yang sesuai dan secara berkesan mengabaikan semua rentetan bit asing dan bergelut lain yang mungkin juga telah diambil sampel. Penapisan semula jadi ini menjadikan SQD sangat tahan terhadap hingar.
• Boleh disahkan secara klasik: Berbeza dengan QPE atau VQA, SQD menghasilkan anggaran klasik kepada keadaan asas. Ini bermakna sesiapa yang mempunyai akses kepada senarai rentetan bit dan pemberat mereka boleh mengira semula dan mengesahkan anggaran tenaga secara langsung pada komputer klasik.

SQD telah digunakan untuk menganggarkan tenaga pecahan keadaan asas N$_2$ dan sifat elektronik kluster [2Fe-2S] dan [4Fe-4S] [2], dengan Circuit sebesar 77 Qubit dan 10,570 Gate.

Uji kefahaman anda

Benar atau Salah: SQD boleh digunakan pada sistem kimia.

Jawapan:

Benar

Uji kefahaman anda

Panggil set semua keadaan asas pengiraan yang membentuk ansatz anda $A$. Panggil set semua keadaan asas pengiraan yang membentuk keadaan asas sebenar sistem anda $G$. Yang manakah antara berikut sepadan dengan ansatz yang "baik"? Pilih semua yang berkenaan.

(a) $A \subset G \\$ (b) $A \subseteq G\\$ (c) $G \subset A\\$ (d) $G \subseteq A\\$

Jawapan:

(c) dan (d)

SKQD (Pepenjurusan Kuantum Krylov Berasaskan Sampel)

Pepenjurusan Kuantum Krylov Berasaskan Sampel (SKQD) ialah algoritma berasaskan sampel kuantum yang berkuasa lagi yang dibina atas prinsip SQD. Walaupun matlamatnya sama — untuk mencari subruang yang baik untuk pepenjurusan — SKQD menggunakan kaedah yang lebih berstruktur untuk menjana rentetan bit, terutamanya untuk masalah seperti Hamiltonian kekisi.

Idea teras SKQD ialah daripada mengoptimumkan Circuit berparameter untuk mencari ansatz yang baik, seseorang boleh konvergen secara terbukti ke keadaan asas dengan mengambil sampel daripada set keadaan yang dijana oleh evolusi masa semula jadi sistem — subruang Krylov. Algoritma SKQD boleh dipecahkan kepada langkah-langkah berikut:

Langkah 1: Bina subruang Krylov dengan evolusi masa

Proses bermula dengan keadaan awal $|\phi_0\rangle.$ Yang penting, kita tidak memerlukan keadaan awal ini mempunyai pertindanan yang "baik" dengan keadaan asas. Ia hanya perlu "bersaiz polinomial secara besar", atau diterangkan oleh polinomial dalam saiz sistem. Algoritma itu sendiri kemudian akan mendorong keadaan semakin hampir ke keadaan asas sistem. SKQD menggunakan pengendali evolusi masa, $e^{-iHt}$, untuk panjang masa yang berbeza. Ini mencipta set $d$ keadaan kuantum yang berbeza, ditakrifkan sebagai:

$$|\phi_j\rangle = e^{-i \,\delta t j H}|\phi_0\rangle, \quad \text{for } j = 0, 1, \dots, d-1 \quad \text{}$$

Koleksi keadaan yang berevolusi masa ini membentuk asas Krylov. Langkah ini amat berkesan untuk Hamiltonian kekisi di mana bilangan sebutan dalam Hamiltonian tidak besar. Untuk masalah kimia, evolusi masa ini boleh menghasilkan Circuit yang sangat dalam, itulah sebabnya SQD sering disyorkan untuk kes-kes tersebut.

Langkah 2: Ambil sampel daripada keadaan asas Krylov

Seterusnya, sampel rentetan bit dikumpulkan daripada setiap $d$ keadaan berbeza ($|\phi_0\rangle, |\phi_1\rangle, \dots, |\phi_{d-1}\rangle$) yang disediakan dalam langkah sebelumnya. Semua rentetan bit ini kemudian digabungkan bersama untuk membentuk asas bagi subruang.

Langkah 3: Unjur dan peserakan secara klasik

Langkah ini adalah sama dengan yang ada dalam SQD. Rentetan bit yang dikumpulkan digunakan untuk mengunjurkan Hamiltonian penuh ke dalam subruang yang dicakupinya. Matriks kecil yang terhasil, $\tilde{H}$, kemudian dipeserakan pada komputer klasik untuk mencari tenaga keadaan asas.

Kelebihan utama dan jaminan SKQD

Pendekatan berstruktur SKQD menyediakan faedah yang unik:

• Konvergen yang terbukti: Kelebihan utama SKQD ialah jaminan teoritikalnya mengenai konvergen di bawah syarat tertentu yang jelas. Jika keadaan asas sebenar adalah jarang (boleh dihampirkan dengan baik oleh bilangan polinomial rentetan bit) dan jurang tenaga ke keadaan teruja pertama tidak terlalu kecil, kaedah ini terbukti berkesan dengan cekap. Di bawah syarat ini, SKQD menjamin bahawa ia akan mencari rentetan bit penting yang membentuk keadaan asas dan boleh menganggarkan tenaga keadaan asas dengan ketepatan yang tinggi. Ini hanya memerlukan bilangan polinomial eksperimen kuantum dan tembakan. Jaminan ini meletakkan pendekatan berasaskan sampel atas asas teoritikal yang kukuh, serupa dengan kaedah yang telah ditetapkan seperti anggaran fasa kuantum.

• Faedah dikongsi dengan SQD: Sama seperti SQD, SKQD juga mempunyai sifat ketahanan terhadap hingar. Dalam erti kata lain, selagi seseorang mempunyai semua rentetan bit yang baik dalam set rentetan bit yang diambil sampel, pepenjurusan memberikan hampir sifar pemberat kepada rentetan bit yang salah, menjadikan prosedur tahan terhadap hingar. Lebih lanjut, kerana penyelesaian dihasilkan daripada HPC klasik, tenaga penyelesaian boleh disahkan secara klasik.

Dalam eksperimen, SKQD telah digunakan dengan sehingga 70 Qubit dan beribu-ribu Gate untuk mengkaji keadaan asas model Anderson 4-kekotoran yang kompleks, mencapai persetujuan yang sangat baik dengan kaedah klasik terkini seperti DMRG.[1]

Uji kefahaman anda

Bahagian manakah dalam algoritma SKQD yang menjadikannya lebih sesuai untuk masalah fizikal seperti kekisi spin berbanding dengan masalah kimia? Mengapa?

Jawapan:

Evolusi masa memerlukan Circuit Trotter, yang sangat dalam untuk Hamiltonian yang rumit dan tidak jarang. Interaksi kekisi spin dikawal oleh matriks spin, yang bersamaan dengan matriks Pauli. Oleh itu, Hamiltonian untuk kekisi spin cenderung lebih padat dinyatakan dalam matriks Pauli, terutamanya yang mempunyai interaksi jiran terdekat.

SQD dan SKQD sebagai pengiraan heterogen

Untuk menyatukan semuanya, kita boleh mewakili algoritma berasaskan sampel sebagai kombinasi model pengaturcaraan yang berbeza pada set sumber heterogen. Sebagai contoh, kita boleh mewakili algoritma kita sebagai aliran kerja tugas.

Rajah ini menggambarkan aliran kerja empat peringkat yang asas. Pertama, kita akan mempunyai tugas untuk penyediaan Circuit kuantum yang bertindih dengan keadaan sasaran kita, diikuti oleh tugas untuk transpilasi, yang hanya memerlukan sumber klasik untuk dilaksanakan. Seterusnya akan ada tugas yang menggunakan primitif untuk melaksanakan Circuit kuantum kita, yang memerlukan sumber kuantum. Akhir sekali, kita mempunyai tugas pasca-pemprosesan, yang sendirinya mungkin merupakan algoritma pepenjurusan selari yang berjalan pada berbilang nod.

Selain itu, kita mungkin mahu menjalankan salah satu algoritma ini berkali-kali semasa kita memvariasikan ansatz kita, atau kita mungkin mahu menjalankannya sepenuhnya secara selari dengan populasi yang berbeza.

Seperti yang digambarkan di atas, anda mungkin menjalankan berbilang aliran kerja secara serentak sambil melakukan perkara berikut:

• Memvariasikan parameter atau struktur ansatz untuk mencari yang paling berkesan.
• Bermula dengan keadaan atau konfigurasi awal yang berbeza ("populasi") untuk mengelakkan minimum tempatan dan memastikan keputusan yang lebih kukuh.

Pendekatan berbilang lapisan ini, menggabungkan keheterogenan berasaskan tugas dengan keselarian peringkat aliran kerja, adalah kunci untuk membuka potensi penuh algoritma ini.

Amalan pengaturcaraan

Mari kita praktikkan algoritma SKQD, menunjukkan aliran kerja heterogen yang diterangkan sebelum ini. Prosesnya dipecahkan kepada empat peringkat berbeza, masing-masing dengan skrip Python sendiri dan skrip shell yang sepadan untuk penghantaran kerja.

Pemetaan (mapping.py dan mapping.sh)

Langkah pertama dalam aliran kerja kita ialah menentukan masalah fizikal dan memetakannya kepada set Circuit kuantum.

mapping.py menentukan parameter untuk masalah fizik tertentu — dalam kes ini, model kekotoran Anderson dengan tujuh tapak mandi (n_bath = 7). Ia membina kamiran satu-badan (h1e) dan dua-badan (h2e) yang mewakili Hamiltonian sistem.

...

n_bath = 7  # number of bath sites

...

# One body matrix elements in the "position" basis
h1e = -t * np.diag(np.ones(n_bath), k=1) - t * np.diag(np.ones(n_bath), k=-1)
h1e[impurity_index, impurity_index + 1] = -V
h1e[impurity_index + 1, impurity_index] = -V
h1e[impurity_index, impurity_index] = eps

# Two body matrix elements in the "position" basis
h2e = np.zeros((n_bath + 1, n_bath + 1, n_bath + 1, n_bath + 1))
h2e[impurity_index, impurity_index, impurity_index, impurity_index] = U

...

# The one-body time evolution
free_fermion_evolution = ffsim.qiskit.OrbitalRotationJW(n_modes, Utar)

# The two-body time evolution
def append_diagonal_evolution(dt, U, impurity_qubit, num_orb, q_circuit):
    """Append two-body time evolution to a quantum circuit."""
    if U != 0:
        q_circuit.append(
            CPhaseGate(-dt / 2 * U),
            [impurity_qubit, impurity_qubit + num_orb],
        )

Ia kemudian menjana Circuit kuantum yang diperlukan untuk algoritma SKQD. Ia bermula dengan mencipta keadaan awal (initial_state) dan kemudian menggunakan pengendali evolusi masa untuk bilangan langkah yang berbeza (d = 8) untuk menjana keadaan asas Krylov yang berbeza, $|\phi_j\rangle = (e^{-iHt})^j |\phi_0\rangle$.

# The reference state
def initial_state(q_circuit, norb, nocc):
    """Prepare an initial state."""
    for i in range(nocc):
        q_circuit.append(XGate(), [i])
        q_circuit.append(XGate(), [norb + i])
    rot = XXPlusYYGate(np.pi / 2, -np.pi / 2)

    for i in range(3):
        for j in range(nocc - i - 1, nocc + i, 2):
            q_circuit.append(rot, [j, j + 1])
            q_circuit.append(rot, [norb + j, norb + j + 1])
    q_circuit.append(rot, [j + 1, j + 2])
    q_circuit.append(rot, [norb + j + 1, norb + j + 2])

...

# Generate the initial state
qubits = QuantumRegister(2 * n_modes, name="q")
init_state = QuantumCircuit(qubits)
initial_state(init_state, n_modes, n_modes // 2)

...

d = 8  # Number of Krylov basis states
circuits = []
for i in range(d):
    circ = init_state.copy()
    circuits.append(circ)
    for _ in range(i):
        append_diagonal_evolution(dt, U, impurity_index, n_modes, circ)
        circ.append(free_fermion_evolution, qubits)
        append_diagonal_evolution(dt, U, impurity_index, n_modes, circ)
    circ.measure_all()

print(circuits[0].draw(scale=0.4, fold=-1))

Skrip menyimpan senarai 8 Circuit yang dijana (masing-masing dengan pengukuran ditambahkan) ke fail bernama circuits.qpy.

mapping.sh ialah skrip kumpulan Slurm yang digunakan untuk menghantar kerja mapping.py. Memandangkan ini adalah pengiraan klasik, ia meminta sumber daripada partition CPU standard (--partition=normal).

#!/bin/bash
#
#SBATCH --job-name=sqd-mapping
#SBATCH --output=sqd-mapping.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=normal

srun python /data/ch4/sqd/mapping.py

Pengoptimuman (optimization.py dan optimization.sh)

Setelah kita mempunyai Circuit, Circuit tersebut mesti dioptimumkan dan disusun untuk dijalankan dengan cekap pada perkakasan kuantum sasaran.

Dalam optimization.py, skrip ini mula-mula memuatkan fail circuits.qpy yang dicipta dalam peringkat pemetaan dan membawa maklumat sumber kuantum oleh QRMI(), pengurus sumber kuantum. Kemudian ia menggunakan generate_preset_pass_manager Qiskit dengan peringkat pengoptimuman yang tinggi (optimization_level=3) untuk menukar Circuit logik abstrak menjadi Circuit Seni Bina Set Arahan (ISA). Proses ini menulis semula Circuit menggunakan Gate asli perkakasan dan mengoptimumkannya untuk mengurangkan kedalaman dan meminimumkan ralat.

...
qrmi = QRMI()
resources = qrmi.resources()
quantum_resource = resources[0]
target = quantum_resource.target

pass_manager = generate_preset_pass_manager(
    optimization_level=3,
    target=target
)
isa_circuits = pass_manager.run(circuits)

Circuit yang telah ditranspilasi dan sedia untuk perkakasan disimpan ke fail baharu, isa_circuits.qpy.

Sama seperti skrip pemetaan, kerja Slurm ini juga berjalan pada partition CPU klasik (--partition=normal), kerana transpilasi adalah tugas klasik.

#!/bin/bash
#
#SBATCH --job-name=sqd-mapping
#SBATCH --output=sqd-mapping.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=normal

srun python /data/ch4/sqd/mapping.py

Pelaksanaan (execution.py dan execution.sh)

Ini adalah satu-satunya peringkat di mana komputer kuantum digunakan. Di sini, kita melaksanakan Circuit yang dioptimumkan dan mengumpulkan sampel pengukuran.

execution.py memuatkan fail isa_circuits.qpy yang dioptimumkan, kemudian memulakan primitif SamplerV2 yang disambungkan ke sumber kuantum. Ia kemudian memanggil sampler.run() untuk melaksanakan Circuit pada QPU untuk bilangan tembakan yang ditentukan (shots=500).

...

qrmi = QRMI()
resources = qrmi.resources()
quantum_resource = resources[0]

# Sample from the circuits
noisy_sampler = Sampler(quantum_resource)
job = noisy_sampler.run(isa_circuits, shots=500)

Pada akhir pelaksanaan, keputusan yang diukur (rentetan bit) daripada semua Circuit dikumpulkan dan digabungkan, dan bilangannya disimpan ke fail counts.json.

Skrip Slurm execution.sh berbeza daripada yang lain pada peringkat ini. Ia meminta untuk dijalankan pada partition kuantum (--partition=quantum) dan secara khusus meminta satu QPU (--gres=qpu:1).

#!/bin/bash
#
#SBATCH --job-name=sqd-execution
#SBATCH --output=sqd-execution.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=quantum
#SBATCH --gres=qpu:1

srun python /data/ch4/sqd/execution.py

Pasca-pemprosesan (postprocessing.py dan postprocessing.sh)

Dalam langkah terakhir, kita kembali ke komputer klasik untuk menganalisis data daripada eksperimen kuantum dan mengira keputusan akhir: tenaga keadaan asas sistem sasaran kita.

Program postprocessing.py mula-mula membaca fail counts.json yang mengandungi keputusan pengukuran. Kemudian ia membina semula Hamiltonian model Anderson (menggunakan parameter yang sama seperti dalam mapping.py). Ia kemudian menghantar rentetan bit yang diukur dan definisi Hamiltonian kepada fungsi diagonalize_fermionic_hamiltonian. Fungsi ini menjalankan logik teras SKQD: ia menggunakan rentetan bit untuk membina Hamiltonian $\tilde{H}$ yang diunjurkan dan memeserakannya untuk mencari tenaga keadaan asas.

...

def callback(results: list[SCIResult]):
    result_history.append(results)
    iteration = len(result_history)
    print(f"Iteration {iteration}")
    for i, result in enumerate(results):
        print(f"\tSubsample {i}")
        print(f"\t\tEnergy: {result.energy}")
        print(f"\t\tSubspace dimension: {np.prod(result.sci_state.amplitudes.shape)}")

rng = np.random.default_rng(24)
result = diagonalize_fermionic_hamiltonian(
    h1e,
    h2e,
    bit_array,
    samples_per_batch=300,
    norb=n_modes,
    nelec=nelec,
    num_batches=3,
    max_iterations=10,
    symmetrize_spin=True,
    callback=callback,
    seed=rng,
)

Akhir sekali, ini mencetak tenaga SKQD yang dikira dan membandingkannya dengan tenaga tepat yang diketahui untuk masalah ini, menunjukkan ralat mutlak akhir pengiraan.

Skrip kerja terakhir berjalan pada partition klasik (--partition=normal), kerana semua analisis adalah klasik. Untuk subruang yang besar, langkah ini mungkin memerlukan lebih banyak sumber HPC klasik.

#!/bin/bash
#
#SBATCH --job-name=sqd-postprocessing
#SBATCH --output=sqd-postprocessing.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=normal

srun python /data/ch4/sqd/postprocessing.py

Ringkasan

Dan itulah sahaja! Kita kini telah melalui beberapa konsep dan contoh yang boleh membantu anda bermula dengan pengurusan program hibrid yang kompleks. Sudah tentu, ini hanya permulaan daripada semua yang boleh anda lakukan dengan gabungan sumber HPC kuantum dan klasik.

Untuk meneroka lebih banyak kes penggunaan dan algoritma, layari dokumentasi dan tutorial kita di IBM Quantum Platform, dan pastikan anda melawati sumber yang dikongsi dalam pelajaran seterusnya untuk maklumat lanjut tentang algoritma dan perisian untuk saintis pengiraan dan pentadbir pusat data.

Rujukan

[1] Quantum-Centric Algorithm for Sample-Based Krylov Diagonalization. https://arxiv.org/abs/2501.09702

[2] Chemistry beyond the scale of exact diagonalization on a quantum-centric supercomputer. https://www.science.org/doi/10.1126/sciadv.adu9991