Dynamics Simulator - sebuah Qiskit Function oleh Q-CTRL Fire Opal

Lihat referensi API.

catatan

Qiskit Functions adalah fitur eksperimental yang hanya tersedia untuk pengguna IBM Quantum® Premium Plan, Flex Plan, dan On-Prem (melalui API IBM Quantum Platform) Plan. Fitur ini berstatus rilis preview dan dapat berubah.

Gambaran umum

Dynamics Simulator dari Q-CTRL adalah Qiskit Function aplikasi untuk mensimulasikan evolusi waktu model quantum many-body yang didukung di hardware IBM Quantum. Alih-alih menyusun circuit kuantum sendiri, kamu menentukan model fisika, keadaan awal, parameter evolusi waktu, dan observable yang akan diukur.

Fungsi ini membangun dan mengeksekusi dynamic circuit yang diperlukan serta menerapkan workflow optimasi sadar-hardware dan error suppression dari Fire Opal. Hasilnya adalah jejak waktu nilai ekspektasi untuk observable yang kamu minta. Karena fungsi ini menerapkan error suppression secara otomatis, kamu bisa menjalankan circuit pada kedalaman rekor dan tetap melihat sinyal yang bermakna. Dynamics Simulator menghasilkan akurasi solusi yang sepadan dengan tool klasik state-of-the-art yang ada dan memberikan keunggulan kecepatan yang bisa didemonstrasikan.

Pengujian dunia nyata mencapai kesesuaian dalam 1% root mean square error (RMSE) dibandingkan dengan simulasi tensor-network klasik beresolusi tertinggi. Pengujian independen dari komunitas riset telah memvalidasi bahwa komputer kuantum tetap akurat bahkan melampaui demonstrasi awal Q-CTRL.

Benchmark

Jumlah site menentukan berapa banyak qubit yang dibutuhkan, sedangkan jumlah langkah Trotter mengatur kedalaman circuit evolusi waktu. Setiap site lattice memakai dua qubit untuk merepresentasikan okupansi spin-up dan spin-down.

Workflow ini telah didemonstrasikan untuk rantai 60 site (120 qubit) dengan 30 langkah Trotter, dan untuk rantai 31 site (62 qubit) dengan 90 langkah Trotter. Tabel di bawah menunjukkan sumber daya circuit dan waktu eksekusi QPU dari eksperimen yang dilaporkan, yang dilakukan pada perangkat IBM® Heron r3 (ibm_boston) dengan 20.000 shot per circuit.

Ukuran sistem	Langkah Trotter	Kedalaman dua-qubit	Jumlah gate dua-qubit	Waktu QPU	Waktu QPU dengan REM + DR
10 site (20 qubit)	30	152	1.457	2m 46s	4m 25s
10 site (20 qubit)	60	302	2.897	5m 36s	8m 42s
10 site (20 qubit)	90	452	4.337	8m 46s	13m 26s
31 site (62 qubit)	30	152	4.649	2m 46s	4m 25s
31 site (62 qubit)	60	302	9.239	5m 36s	8m 42s
31 site (62 qubit)	90	452	13.829	8m 46s	13m 26s
60 site (120 qubit)	30	152	9.057	2m 46s	4m 25s

Untuk jumlah langkah Trotter yang tetap, kedalaman circuit dan waktu QPU yang dilaporkan tetap sama di semua ukuran sistem yang diuji, sementara jumlah gate dua-qubit bertambah. Menambah jumlah langkah menghasilkan circuit yang lebih dalam dan membutuhkan lebih banyak waktu QPU.

Di sini, waktu QPU adalah total waktu eksekusi hardware kumulatif untuk circuit simulasi utama. Kolom terakhir juga mencakup waktu QPU untuk karakterisasi noise yang dipakai dalam readout error mitigation (REM) dan decay recovery (DR). Panduan ini memakai contoh kecil Fermi-Hubbard satu dimensi untuk menunjukkan workflow lengkap, dari mendefinisikan model hingga memplot dinamika yang terukur.

Deskripsi fungsi

Dinamika kuantum menjelaskan bagaimana sistem kuantum berubah seiring waktu. Mempelajari evolusi ini membantumu memahami bagaimana partikel bergerak, bagaimana korelasi berkembang, dan bagaimana sistem merespons perubahan keadaan atau Hamiltonian-nya.

Model Fermi-Hubbard menjelaskan fermion yang berpindah antar site lattice dan berinteraksi ketika menempati site yang sama. Persaingan antara hopping dan interaksi menjadikannya model yang berguna untuk mempelajari elektron berkorelasi kuat. Evolusi waktunya dapat memperlihatkan bagaimana spin dan muatan merambat, dan bagaimana sistem yang awalnya teratur berelaksasi.

Model

Dynamics Simulator mendukung rantai Fermi-Hubbard satu dimensi dengan batas terbuka. Untuk rantai dengan $L$ site, Hamiltonian didefinisikan sebagai berikut:

$$H = -\sum_{i=0}^{L-2}\sum_{\sigma\in\{\uparrow,\downarrow\}} t_{h,i} \left( c^\dagger_{i\sigma}c_{i+1,\sigma} + c^\dagger_{i+1,\sigma}c_{i\sigma} \right) +\sum_{i=0}^{L-1}U_i n_{i\uparrow}n_{i\downarrow} -\sum_{i=0}^{L-1}\sum_{\sigma\in\{\uparrow,\downarrow\}} \mu_i n_{i\sigma}.$$

Di sini, $c^\dagger_{i\sigma}$ dan $c_{i\sigma}$ menciptakan dan memusnahkan fermion dengan spin $\sigma$ pada site $i$. Operator jumlah $n_{i\sigma}=c^\dagger_{i\sigma}c_{i\sigma}$ mengukur okupansi orbital spin tersebut.

Input model menentukan koefisien berikut:

• hopping_amplitude: $t_{h,i}$, yang mengatur hopping antara site bertetangga $i$ dan $i+1$.

• on_site_interaction: $U_i$, interaksi antara fermion spin-up dan spin-down yang menempati site yang sama.

• chemical_potential: $\mu_i$, potensial kimia lokal, yang masuk ke Hamiltonian dengan tanda minus.

Berikan skalar untuk memakai koefisien yang sama di seluruh rantai, atau list untuk menentukan koefisien bagi bond atau site tertentu.

Dalam satuan di mana $\hbar=1$, keadaan awal berevolusi sebagai berikut:

$$|\psi(t)\rangle=e^{-iHt}|\psi(0)\rangle.$$

Fungsi ini mengestimasi nilai ekspektasi dari observable yang kamu tentukan pada waktu-waktu simulasi yang berurutan.

Workflow

Workflow fungsi ini terdiri dari langkah-langkah berikut:

1. Sintesis algoritmik: Fungsi ini memakai Hamiltonian dan pengaturan waktu simulasi untuk menyusun urutan Trotter-Suzuki yang dioptimalkan, yang mengurangi kedalaman circuit sambil memperhitungkan akurasi simulasi.

2. Pemetaan sadar-hardware: Fungsi ini memetakan dan merutekan circuit dengan memakai konektivitas qubit dan karakteristik error dari backend IBM Quantum yang dipilih.

3. Error suppression lapisan fisik: Fire Opal menggabungkan dynamical decoupling dan koreksi tingkat pulse untuk menekan noise dari lingkungan dan crosstalk selama eksekusi di hardware.

Fungsi ini mengelola tahap-tahap ini secara otomatis dan mengembalikan nilai ekspektasi dari observable yang diminta sepanjang waktu.

Kamu mendefinisikan masalah fisika dan pengaturan simulasi lewat input fungsi. Antarmuka saat ini mendukung evolusi waktu Trotter, di mana time_step mengatur durasi setiap langkah dan step_count mengatur jumlah langkah.

Untuk detail tambahan, lihat gambaran umum Fire Opal dynamics simulator dan referensi API simulate_dynamics.

Mulai

Temukan informasi akses untuk Qiskit Function ini di Qiskit Functions Catalog.

Panduan ini menunjukkan cara memuat Dynamics Simulator dan mensimulasikan rantai Fermi-Hubbard empat site. Kode berikut mengasumsikan kamu sudah menyimpan API key IBM Quantum Platform dan CRN instance ke lingkungan lokalmu.

Untuk instruksi penyiapan akun dan instalasi klien, lihat Mulai menggunakan Qiskit Functions.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "qctrlvisualizer": "qctrlvisualizer", "qiskit_ibm_catalog": "qiskit-ibm-catalog"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# Access the Q-CTRL Dynamics Simulator Qiskit Function.
sim_qf = catalog.load("q-ctrl/dynamics-simulator")

# Check the list of backends you have access to
catalog.backends()

[<IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_phoenix')>,
 <IBMBackend('ibm_pittsburgh')>]

# Select the backend you want to use
backend = catalog.backend("ibm_phoenix")

Contoh: Simulasikan rantai Fermi-Hubbard empat site

Pertimbangkan rantai Fermi-Hubbard satu dimensi empat site dengan amplitudo hopping $t_h=1$, tanpa interaksi on-site, dan potensial kimia nol. Satu fermion spin-up dimulai di site 0 dan berevolusi sepanjang rantai.

Masalah kecil ini menjaga fokus pada workflow Dynamics Simulator:

1. Definisikan model dan simulasi.

2. Definisikan keadaan awal dan observable.

3. Kirim job Qiskit Function.

4. Ambil nilai ekspektasi.

5. Plot dinamikanya.

1. Definisikan masalahnya

site_count = 4

model = {
    "hopping_amplitude": 1.0,
    "on_site_interaction": 0.0,
    "chemical_potential": 0.0,
}

simulation = {
    "time_step": 0.2,
    "step_count": 8,
}

initial_state = "eeeu"

observables = [
    {
        "operators": [[["Nup", site]]],
        "coefficients": [1.0],
    }
    for site in range(site_count)
]

shot_count = 2048

List observable mengukur okupansi spin-up

$$\langle n_{i\uparrow} \rangle$$

di setiap site. Observable dikembalikan dalam urutan yang sama dengan saat diberikan.

2. Jalankan simulasi dinamika

Kirim masalahnya lewat Qiskit Function. Qiskit Functions Catalog menangani autentikasi IBM Quantum, jadi kamu tidak perlu memberikan kredensial Fire Opal atau penyedia hardware terpisah ke sim_qf.run().

job = sim_qf.run(
    model=model,
    simulation=simulation,
    observables=observables,
    initial_state=initial_state,
    shots=shot_count,
    backend_name=backend.name,
)

print(job.job_id, job.status())

68202fad-6919-425d-8fd2-c1c649cd15b1 DONE

Objek yang dikembalikan adalah job Qiskit Function. Kamu bisa menyimpan ID job untuk mengambil atau memeriksa beban kerja tersebut nanti.

3. Ambil hasilnya

result = job.result()

print("Result keys:", sorted(result.keys()))
print("Warnings:", result.get("warnings", []))

Result keys: ['metadata', 'observable_expectation_values', 'observables', 'warnings']
Warnings: []

Ubah nilai ekspektasi observable menjadi array NumPy. Setiap baris sesuai dengan satu observable, dan setiap kolom sesuai dengan waktu simulasi yang tercatat, dimulai dari $t=0$. Untuk contoh ini, keempat baris berisi okupansi spin-up dari site 0 sampai 3.

import numpy as np

expectation_values = np.asarray(
    result["observable_expectation_values"],
    dtype=float,
)

print("Expectation-value array shape:", expectation_values.shape)

Expectation-value array shape: (4, 9)

4. Visualisasikan dinamikanya

Keadaan awal berisi satu fermion spin-up dan tidak ada fermion spin-down. Karena itu evolusinya tetap berada di subruang satu-partikel, yang keempat keadaan basis-nya sesuai dengan fermion yang menempati site 0, 1, 2, dan 3.

Dalam subruang ini, Hamiltonian menghubungkan site-site bertetangga dengan amplitudo hopping $-t_h$. Untuk parameter yang dipakai di sini,

$$H_{\mathrm{1p}} = -t_h \begin{pmatrix} 0 & 1 & 0 & 0 \\ 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}.$$

Diagonalkan matriks ini dengan NumPy lalu evolusikan state awal pada waktu-waktu yang sama dengan yang dikembalikan oleh Dynamics Simulator. Kuadrat magnitudo setiap amplitudo state memberikan okupansi spin-up dari site yang bersangkutan.

Perhitungan ini memberikan evolusi Hamiltonian yang eksak. Perbedaan antara estimasi hardware dan acuan ini bisa berasal dari Trotter step yang terbatas, statistik pengukuran, dan error hardware yang tersisa.

times = np.arange(expectation_values.shape[1]) * simulation["time_step"]

# This reference is specific to a single spin-up fermion.
if (
    len(initial_state) != site_count
    or initial_state.count("u") != 1
    or initial_state.count("e") != site_count - 1
):
    raise ValueError(
        "This reference requires one spin-up fermion and otherwise empty sites."
    )

# Build the Hamiltonian in the single-particle subspace.
hamiltonian = -model["hopping_amplitude"] * (
    np.eye(site_count, k=1) + np.eye(site_count, k=-1)
)
hamiltonian -= model["chemical_potential"] * np.eye(site_count)

# The rightmost character of initial_state corresponds to site 0.
initial_amplitudes = np.zeros(site_count, dtype=complex)
initial_site = initial_state[::-1].index("u")
initial_amplitudes[initial_site] = 1.0

# Evolve the initial state in the Hamiltonian eigenbasis.
energies, eigenvectors = np.linalg.eigh(hamiltonian)
initial_coefficients = eigenvectors.conj().T @ initial_amplitudes

phases = np.exp(-1j * np.outer(energies, times))
states = eigenvectors @ (initial_coefficients[:, None] * phases)

ideal_expectation_values = np.abs(states) ** 2

Buat satu panel untuk setiap site. Kurva solid menunjukkan acuan eksak pada waktu-waktu yang tercatat, dan marker menunjukkan estimasi hardware yang dikembalikan oleh Dynamics Simulator.

import matplotlib.pyplot as plt
import qctrlvisualizer as qv
from qctrlvisualizer import QCTRL_STYLE_COLORS as colors

plt.style.use(qv.get_qctrl_style())

fig, ax = plt.subplots(figsize=(10, 6))

for site in range(len(expectation_values)):
    site_color = colors[site % len(colors)]

    ax.plot(
        times,
        ideal_expectation_values[site],
        color=site_color,
        linewidth=2,
        label=f"Site {site}: exact reference",
    )

    ax.plot(
        times,
        expectation_values[site],
        color=site_color,
        linestyle="--",
        linewidth=1.5,
        marker="o",
        markersize=5,
        label=f"Site {site}: hardware estimate",
    )

ax.set_xlim(times[0], times[-1])
ax.set_ylim(-0.05, 1.05)

ax.set_xlabel(r"Time (units of $\hbar/t_h$)")
ax.set_ylabel(r"$\langle n_{i\uparrow} \rangle$")
ax.set_title("Spin-up occupation dynamics")

ax.legend(
    ncol=2,
    fontsize=10,
    loc="best",
)

fig.tight_layout()
plt.show()

Pada $t=0$, okupansi spin-up yang eksak adalah 1 di site 0 dan 0 di site lainnya. Seiring sistem berevolusi, hopping menyebarkan probabilitas partikel ke seluruh rantai. Okupansi site 1 naik lebih dulu, disusul okupansi site 2 dan 3 yang ikut naik. Untuk parameter dalam contoh ini, waktu terakhir yang tercatat adalah $t=1.6$. Okupansi eksak site 0 sampai 3 masing-masing kira-kira 0.026, 0.370, 0.392, dan 0.211.

Okupansi eksak memenuhi persamaan berikut pada setiap waktu, yang mencerminkan kekekalan jumlah partikel:

$$\sum_{i=0}^{3}\langle n_{i\uparrow}(t)\rangle=1$$

Okupansi tiap site bisa naik dan turun saat partikel berevolusi di sepanjang rantai yang terbatas.

Ambil pesan error

Kalau workload masuk ke state ERROR, panggil job.result() untuk mengambil pesan error-nya. Kamu juga bisa memeriksa log fungsi, kalau tersedia.

print(job.status())

if job.status() == "ERROR":
    print(job.result())
    print(job.logs())

DONE

Masalah validasi input yang umum antara lain model atau metode simulasi yang tidak didukung, string initial state yang terlalu panjang, suku observable dan koefisien yang tidak cocok, atau observable yang merujuk ke site di luar string initial state.

Dapatkan bantuan

Untuk pertanyaan soal perilaku Dynamics Simulator atau Fire Opal, lihat dokumentasi Q-CTRL atau hubungi Q-CTRL.

Untuk autentikasi Qiskit Functions, manajemen job, atau akses IBM Quantum Platform, lihat dokumentasi Qiskit Functions.

Langkah berikutnya

Rekomendasi

• Tinjau referensi API simulate_dynamics untuk definisi model, simulasi, observable, output, dan validasi yang mendasarinya.
• Coba tutorial Dinamika spin dan muatan dalam model Fermi-Hubbard.
• Baca ikhtisar Fire Opal dynamics simulator untuk detail lebih lanjut tentang Trotterization, pemetaan yang sadar hardware, dan penekanan error Fire Opal.
• Ubah parameter model, initial state, time step, jumlah step, dan observable untuk mempelajari masalah dinamika Fermi-Hubbard satu dimensi yang berbeda.