Sample-based Krylov Quantum Diagonalization (SKQD)

Pelajaran ini tentang Sample-based Krylov quantum diagonalization (SKQD) menggabungkan metode-metode yang dijelaskan di pelajaran sebelumnya. Pelajaran ini terdiri dari satu contoh yang memanfaatkan framework pola Qiskit:

• Langkah 1: Petakan masalah ke rangkaian kuantum dan operator
• Langkah 2: Optimalkan untuk hardware target
• Langkah 3: Eksekusi menggunakan Qiskit Primitives
• Langkah 4: Post-process

Salah satu langkah penting dalam metode sample-based quantum diagonalization adalah menghasilkan vektor berkualitas untuk subruang. Di pelajaran sebelumnya, kita menggunakan ansatz LUCJ untuk menghasilkan vektor subruang untuk Hamiltonian kimia. Di pelajaran ini, kita akan menggunakan state Krylov kuantum[1] seperti yang dibahas di pelajaran 2. Pertama, kita akan mengulas cara membuat ruang Krylov di komputer kuantum menggunakan operasi evolusi waktu. Lalu kita akan mengambil sampel darinya. Kita akan memproyeksikan Hamiltonian sistem ke subruang yang diambil sampelnya dan mendiagonalisasinya untuk memperkirakan energi ground state. Algoritma ini terbukti dan secara efisien konvergen ke ground state, di bawah asumsi yang dijelaskan di pelajaran 2.

0. Ruang Krylov

Ingat bahwa ruang Krylov $\mathcal{K}^r$ orde $r$ adalah ruang yang dibentangkan oleh vektor-vektor yang diperoleh dari perkalian pangkat-pangkat lebih tinggi dari matriks $A$, hingga $r-1$, dengan vektor referensi $\vert v \rangle$.

$$\mathcal{K}^r = \left\{ \vert v \rangle, A \vert v \rangle, A^2 \vert v \rangle, ..., A^{r-1} \vert v \rangle \right\}$$

Jika matriks $A$ adalah Hamiltonian $H$, ruang yang sesuai disebut power Krylov space $\mathcal{K}_P$. Dalam kasus di mana $A$ adalah operator evolusi waktu yang dihasilkan oleh Hamiltonian $U=e^{-iH(dt)}$, ruang tersebut disebut unitary Krylov space $\mathcal{K}_U$. Power Krylov subspace tidak bisa dibuat langsung di komputer kuantum karena $H$ bukan operator uniter. Sebaliknya, kita bisa menggunakan operator evolusi waktu $U = e^{-iH(dt)}$ yang terbukti memberikan jaminan konvergensi serupa dengan power Krylov space. Pangkat-pangkat $U$ kemudian menjadi langkah waktu yang berbeda $U^k = e^{-iH(k dt)}$ di mana $k = 0, 1, 2, ..., (r-1)$.

$$\mathcal{K}_U^r = \left\{ \vert \psi \rangle, U \vert \psi \rangle, U^2 \vert \psi \rangle, ..., U^{r-1} \vert \psi \rangle \right\}$$

1. Petakan masalah ke rangkaian kuantum dan operator

Dalam pelajaran ini, kita mempertimbangkan Hamiltonian untuk rantai spin-1/2 XX-Z antiferromagnetik dengan $L = 22$ situs dengan kondisi batas periodik:

$$H = \sum_{i, j}^{N} J_{xy} (X_{i} X_{j} + Y_{i} Y_{j}) + Z_{i} Z_{j}$$

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit qiskit-addon-sqd qiskit-addon-utils qiskit-ibm-runtime

from qiskit.transpiler import CouplingMap
from qiskit_addon_utils.problem_generators import generate_xyz_hamiltonian

num_spins = 22
coupling_map = CouplingMap.from_ring(num_spins)
H_op = generate_xyz_hamiltonian(coupling_map, coupling_constants=(0.3, 0.3, 1.0))

Untuk membangun ruang Krylov, kita membutuhkan tiga bahan utama:

1. Pilihan dimensi Krylov ($r$) dan langkah waktu ($dt$).
2. State awal (referensi) (vektor $\vert v \rangle$ di atas) dengan overlap polinomial dengan state target (ground), di mana state target bersifat sparse. Persyaratan overlap polinomial ini sama seperti dalam algoritma quantum phase estimation.
3. Operator evolusi waktu $U^{k}=e^{-iH(k * dt)}$ ($k = 0, 1, 2, ..., r-1$).

Untuk nilai $r$ yang dipilih (dan $dt$), kita akan membuat $r$ rangkaian kuantum terpisah dan mengambil sampel darinya. Setiap rangkaian kuantum dibuat dengan menggabungkan representasi rangkaian kuantum dari state referensi dan operator evolusi waktu untuk nilai $k$ tertentu.

Dimensi Krylov yang lebih besar meningkatkan konvergensi energi yang diperkirakan. Kita menetapkan dimensi ke $5$ dalam pelajaran ini untuk mengilustrasikan tren konvergensi.

Ref [2] menunjukkan bahwa langkah waktu yang cukup kecil untuk KQD adalah $\pi / \vert \vert H \vert \vert$, dan lebih baik meremehkan nilai ini daripada melebih-lebihkannya. Di sisi lain, memilih $dt$ yang terlalu kecil mengakibatkan pengkondisian subruang Krylov yang lebih buruk, karena vektor basis Krylov berbeda lebih sedikit dari satu langkah waktu ke langkah berikutnya. Selain itu, meski pilihan $dt$ ini terbukti cukup untuk konvergensi SKQD, dalam konteks berbasis sampling ini pilihan optimal $dt$ dalam praktiknya masih menjadi topik studi yang sedang berjalan. Dalam pelajaran ini, kita menetapkan $dt = 0.15$.

Selain dimensi Krylov dan langkah waktu, kita perlu menetapkan jumlah langkah Trotter untuk evolusi waktu. Menggunakan terlalu sedikit langkah menghasilkan kesalahan Trotterisasi yang lebih besar, sementara terlalu banyak langkah menghasilkan rangkaian yang lebih dalam. Dalam pelajaran ini, kita menetapkan jumlah langkah Trotter ke $6$.

# Set parameters for quantum Krylov algorithm
krylov_dim = 5  # size of krylov subspace
dt = 0.15
num_trotter_steps = 6

Selanjutnya, kita perlu memilih state referensi $\vert \psi \rangle$ yang memiliki beberapa overlap dengan ground state. Untuk Hamiltonian ini, kita menggunakan state Neel dengan 1 dan 0 yang bergantian $\vert ...101...010...101 \rangle$ sebagai state referensi kita.

# Prep `Neel` state as the reference state for evolution
from qiskit import QuantumCircuit

qc_state_prep = QuantumCircuit(num_spins)
for i in range(num_spins):
    if i % 2 == 0:
        qc_state_prep.x(i)

Akhirnya, kita perlu memetakan operator evolusi waktu ke rangkaian kuantum. Ini dilakukan di pelajaran 2, tetapi di sini kita akan memanfaatkan metode-metode di Qiskit, khususnya metode bernama synthesis. Ada berbagai metode untuk menyintesis operator matematika ke rangkaian kuantum dengan gate kuantum. Banyak teknik seperti itu tersedia di modul sintesis Qiskit. Kita akan menggunakan pendekatan LieTrotter untuk sintesis [3] [4].

from qiskit.circuit import QuantumRegister
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.synthesis import LieTrotter

evol_gate = PauliEvolutionGate(
    H_op, time=(dt / num_trotter_steps), synthesis=LieTrotter(reps=num_trotter_steps)
)  # `U` operator

qr = QuantumRegister(num_spins)
qc_evol = QuantumCircuit(qr)
qc_evol.append(evol_gate, qargs=qr)

circuits = []
for rep in range(krylov_dim):
    circ = qc_state_prep.copy()

    # Repeating the `U` operator to implement U^0, U^1, U^2, and so on, for power Krylov space
    for _ in range(rep):
        circ.compose(other=qc_evol, inplace=True)

    circ.measure_all()
    circuits.append(circ)

circuits[1].decompose().draw("mpl", fold=-1)

circuits[2].decompose().draw("mpl", fold=-1)

2. Optimalkan untuk hardware target

Setelah membuat rangkaian-rangkaian, kita bisa mengoptimalkannya untuk hardware target. Kita memilih QPU skala utilitas.

import warnings

from qiskit import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

warnings.filterwarnings("ignore")

service = QiskitRuntimeService()
# Use the least-busy backend or specify a quantum computer using the syntax commented out below.
backend = service.least_busy(operational=True, simulator=False)
# backend = service.backend("ibm_brisbane")

Sekarang, kita melakukan transpilasi rangkaian ke Backend target menggunakan preset pass manager.

pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
isa_circuits = pm.run(circuits=circuits)

3. Eksekusi di hardware target

Setelah mengoptimalkan rangkaian untuk eksekusi hardware, kita siap menjalankannya di hardware target dan mengumpulkan sampel untuk estimasi energi ground state.

from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)
job = sampler.run(isa_circuits, shots=100_000)  # Takes approximately 2m 58s of QPU time

counts_all = [job.result()[k].data.meas.get_counts() for k in range(krylov_dim)]

4. Post-process hasil

Selanjutnya, kita mengagregasi hitungan untuk dimensi Krylov yang meningkat secara kumulatif. Menggunakan hitungan kumulatif, kita akan membentangkan subruang untuk dimensi Krylov yang meningkat dan menganalisis perilaku konvergensi.

from collections import Counter

counts_cumulative = []
for i in range(krylov_dim):
    counter = Counter()
    for d in counts_all[: i + 1]:
        counter.update(d)

    counts = dict(counter)
    counts_cumulative.append(counts)

Untuk memproyeksikan dan mendiagonalisasi Hamiltonian, kita menggunakan kemampuan dari qiskit-addon-sqd. Addon ini menawarkan fungsionalitas untuk memproyeksikan Hamiltonian berbasis string Pauli ke subruang dan menyelesaikan eigenvalue menggunakan SciPy.

from qiskit_addon_sqd.counts import counts_to_arrays
from qiskit_addon_sqd.qubit import solve_qubit

Pada prinsipnya, kita bisa menyaring bitstring dengan pola yang salah sebelum membentangkan subruang. Misalnya, ground state untuk Hamiltonian antiferromagnetik dalam pelajaran ini biasanya memiliki jumlah spin "atas" dan "bawah" yang sama, yaitu jumlah "1" dalam bitstring harus tepat setengah dari total jumlah bit (spin) dalam sistem. Fungsi berikut menyaring bitstring dengan jumlah "1" yang salah dari hitungan.

# Filters out bitstrings that do not have specified number (`num_ones`) of `1` bits.
def postselect_counts(counts, num_ones):
    filtered_counts = {}
    for bitstring, freq in counts.items():
        if bitstring.count("1") == num_ones:
            filtered_counts[bitstring] = freq

    return filtered_counts

Menggunakan bitstring dengan jumlah elektron naik/turun yang benar, kita membentangkan subruang dan menghitung eigenvalue untuk dimensi Krylov yang meningkat. Tergantung pada ukuran masalah dan sumber daya klasikal yang tersedia, kita mungkin perlu mengadopsi subsampling (serupa dengan pelajaran tentang SQD) untuk menjaga dimensi subruang tetap terkendali. Selain itu, kita bisa menerapkan gagasan pemulihan konfigurasi serupa dengan Pelajaran 4. Kita bisa menghitung tingkat hunian elektron per situs dari eigenstate yang direkonstruksi dan menggunakan informasi tersebut untuk mengoreksi bitstring dengan jumlah elektron naik/turun yang salah. Kita tinggalkan ini sebagai latihan untuk pembaca yang tertarik.

import numpy as np

num_batches = 10
rand_seed = 0
scipy_kwargs = {"k": 2, "which": "SA"}

ground_state_energies = []
for idx, counts in enumerate(counts_cumulative):
    counts = postselect_counts(counts, num_ones=num_spins // 2)
    bitstring_matrix, probs = counts_to_arrays(counts=counts)

    eigenvals, eigenstates = solve_qubit(
        bitstring_matrix, H_op, verbose=False, **scipy_kwargs
    )
    gs_en = np.min(eigenvals)
    ground_state_energies.append(gs_en)

Selanjutnya, kita memplot energi yang dihitung sebagai fungsi dari dimensi Krylov dan membandingkannya dengan energi eksak. Energi eksak dihitung secara terpisah menggunakan metode brute force klasikal. Kita bisa melihat bahwa energi ground state yang diperkirakan konvergen dengan meningkatnya dimensi ruang Krylov. Meskipun dimensi Krylov sebesar $5$ membatasi, hasilnya masih menunjukkan konvergensi yang mengesankan, yang diharapkan akan meningkat dengan dimensi Krylov yang lebih besar [1].

import matplotlib.pyplot as plt

exact_gs_en = -23.934184
plt.plot(
    range(1, krylov_dim + 1),
    ground_state_energies,
    color="blue",
    linestyle="-.",
    label="estimate",
)
plt.plot(
    range(1, krylov_dim + 1),
    [exact_gs_en] * krylov_dim,
    color="red",
    linestyle="-",
    label="exact",
)
plt.xticks(range(1, krylov_dim + 1), range(1, krylov_dim + 1))
plt.legend()
plt.xlabel("Krylov space dimension")
plt.ylabel("Energy")
plt.ylim([-24, -22.50])
plt.title(
    "Estimating Ground state energy with Sample-based Krylov Quantum Diagonalization"
)
plt.show()

Uji pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk melihat solusinya.

Apa yang bisa dilakukan untuk meningkatkan konvergensi dalam plot di atas?

Jawaban:

Tingkatkan dimensi Krylov. Secara umum, seseorang juga bisa menambah jumlah shot, tetapi ini sudah cukup tinggi dalam perhitungan di atas.

Apa keunggulan utama SKQD dibandingkan (a) SQD, dan (b) KQD?

Jawaban:

Mungkin ada jawaban valid lainnya, tetapi jawaban lengkap harus mencakup yang berikut:

(a) SKQD hadir dengan jaminan konvergensi yang tidak dimiliki SQD. Dalam SQD kamu perlu membuat tebakan yang sangat bagus untuk ansatz-mu yang memiliki overlap luar biasa dengan dukungan ground state dalam basis komputasi, atau kamu perlu memasukkan komponen variasional ke dalam perhitungan untuk mengambil sampel dari keluarga ansaetze.

(b) SKQD memerlukan waktu QPU yang jauh lebih sedikit, karena menghindari perhitungan elemen matriks yang mahal melalui tes Hadamard.

5. Ringkasan

• Estimasi energi ground state melalui sampling state basis Krylov sangat cocok untuk model latis termasuk sistem spin, masalah materi terkondensasi, dan teori gauge latis. Pendekatan ini jauh lebih baik skalanya daripada VQE, karena tidak memerlukan optimasi atas banyak parameter dalam ansatz variasional seperti dalam VQE, atau SQD berbasis ansatz heuristik (misalnya, masalah kimia di pelajaran sebelumnya).
  • Untuk menjaga kedalaman rangkaian tetap rendah, bijaksana untuk menangani masalah latis yang cocok untuk hardware pre-fault tolerant.
• SKQD tidak mengalami masalah pengukuran kuantum seperti dalam VQE. Tidak ada kelompok operator Pauli yang berkomutasi yang perlu diperkirakan.
• SKQD bersifat robust terhadap sampel yang berisik karena seseorang bisa menggunakan rutinitas post-selection yang spesifik terhadap masalah (misalnya, menyaring bitstring yang tidak mematuhi pola spesifik masalah) atau menimbulkan overhead diagonalisasi klasikal (yaitu, mendiagonalisasi dalam subruang yang lebih besar) untuk secara efektif menghilangkan efek noise.

Referensi

[1] Jeffery Yu et al., "Quantum-Centric Algorithm for Sample-Based Krylov Diagonalization" (2025). arxiv:quant-ph/2501.09702.

[2] Ethan N. Epperly, Lin Lin, and Yuji Nakatsukasa. "A theory of quantum subspace diagonalization". SIAM Journal on Matrix Analysis and Applications 43, 1263–1290 (2022).

[2] N. Hatano and M. Suzuki, "Finding Exponential Product Formulas of Higher Orders" (2005). arXiv:math-ph/0506007.

[4] D. Berry, G. Ahokas, R. Cleve and B. Sanders, "Efficient quantum algorithms for simulating sparse Hamiltonians" (2006). arXiv:quant-ph/0508139.