Dynamics Simulator - isang Qiskit Function ng Q-CTRL Fire Opal

Tingnan ang API reference.

tala

Ang Qiskit Functions ay isang experimental na feature na available lang sa mga user ng IBM Quantum® Premium Plan, Flex Plan, at On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan. Nasa preview release status ang mga ito at maaaring magbago.

Pangkalahatang-ideya

Ang Q-CTRL Dynamics Simulator ay isang application Qiskit Function para sa pag-simulate ng time evolution ng mga sinusuportahang quantum many-body model sa IBM Quantum hardware. Sa halip na ikaw mismo ang bumuo ng mga quantum circuit, tutukuyin mo ang physical model, ang initial state, ang mga parameter ng time-evolution, at ang mga observable na susukatin.

Binubuo at ine-execute ng function ang mga kinakailangang dynamic circuit at inilalapat ang hardware-aware optimization at error suppression workflow ng Fire Opal. Ang result ay time trace ng mga expectation value ng mga observable na hiniling mo. Dahil awtomatikong naglalapat ang function ng error suppression, makakapagpatakbo ka ng mga circuit sa record na depth at makikita pa rin ang makabuluhang signal. Naghahatid ang Dynamics Simulator ng solution accuracy na tumutugma sa mga kasalukuyang state-of-the-art na classical tool at nagbibigay ng nakikitang bentahe sa bilis.

Sa real-world na pagsubok, naabot ang pagtutugma sa loob ng 1% root mean square error (RMSE) kumpara sa mga classical tensor-network simulation na pinakamataas ang resolution. Pinatunayan ng mga independent na test mula sa research community na nananatiling tumpak ang quantum computer kahit lampas pa sa mga unang demonstrasyon ng Q-CTRL.

Mga benchmark

Ang bilang ng mga site ang tumutukoy kung ilang qubit ang kailangan, habang kinokontrol naman ng bilang ng mga Trotter step ang depth ng mga time-evolution circuit. Gumagamit ang bawat lattice site ng dalawang qubit para katawanin ang spin-up at spin-down na occupation.

Naipakita na ang workflow na ito para sa mga chain na 60 site (120 qubit) na may 30 Trotter step, at para sa mga chain na 31 site (62 qubit) na may 90 Trotter step. Ipinapakita ng table sa ibaba ang mga circuit resource at QPU execution time mula sa mga iniulat na eksperimento, na isinagawa sa IBM® Heron r3 (ibm_boston) na device na may 20,000 shot kada circuit.

Laki ng system	Mga Trotter step	Two-qubit depth	Bilang ng two-qubit gate	QPU time	QPU time na may 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

Para sa nakapirming bilang ng Trotter step, nananatiling pareho ang iniulat na circuit depth at QPU time sa lahat ng nasubukang laki ng system, habang tumataas ang bilang ng two-qubit gate. Ang pagdagdag ng mga step ay nagbubunga ng mas malalalim na circuit at nangangailangan ng mas maraming QPU time.

Dito, ang QPU time ay ang pinagsama-samang hardware execution time para sa mga pangunahing simulation circuit. Kasama rin sa huling column ang QPU time para sa noise characterization na ginagamit sa readout error mitigation (REM) at decay recovery (DR). Gumagamit ang gabay na ito ng maliit na one-dimensional na halimbawa ng Fermi-Hubbard para ipakita ang kumpletong workflow mula sa pagtukoy ng model hanggang sa pag-plot ng nasukat na dynamics.

Paglalarawan ng function

Inilalarawan ng quantum dynamics kung paano nagbabago ang quantum system sa paglipas ng panahon. Ang pag-aaral sa ebolusyong ito ay tumutulong sa iyong maunawaan kung paano gumagalaw ang mga particle, paano nabubuo ang mga correlation, at paano tumutugon ang system sa pagbabago ng state o Hamiltonian nito.

Inilalarawan ng Fermi-Hubbard model ang mga fermion na gumagalaw sa pagitan ng mga lattice site at nag-iinteract kapag nasa iisang site. Dahil sa paligsahan ng hopping at mga interaction, kapaki-pakinabang itong model para pag-aralan ang mga strongly correlated na electron. Maipapakita ng time evolution nito kung paano kumakalat ang spin at charge, at kung paano nagre-relax ang system na dating maayos ang pagkakaayos.

Model

Sinusuportahan ng Dynamics Simulator ang one-dimensional na Fermi-Hubbard chain na may mga open boundary. Para sa chain na may $L$ site, tinutukoy ang Hamiltonian tulad ng sumusunod:

$$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}.$$

Dito, ang $c^\dagger_{i\sigma}$ at $c_{i\sigma}$ ay lumilikha at nag-aannihilate ng fermion na may spin $\sigma$ sa site $i$. Sinusukat ng number operator na $n_{i\sigma}=c^\dagger_{i\sigma}c_{i\sigma}$ ang occupation ng spin orbital na iyon.

Tinutukoy ng mga model input ang mga sumusunod na coefficient:

• hopping_amplitude: $t_{h,i}$, na kumokontrol sa hopping sa pagitan ng magkatabing site na $i$ at $i+1$.

• on_site_interaction: $U_i$, ang interaction sa pagitan ng spin-up at spin-down na mga fermion na nasa iisang site.

• chemical_potential: $\mu_i$, ang local na chemical potential, na pumapasok sa Hamiltonian na may negatibong sign.

Magbigay ng scalar para gamitin ang parehong coefficient sa buong chain, o list para tukuyin ang mga coefficient ng bawat bond o site.

Sa mga unit kung saan $\hbar=1$, ganito nag-e-evolve ang initial state:

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

Tinatantiya ng function ang mga expectation value ng mga observable na tinukoy mo sa magkakasunod na simulation time.

Workflow

Binubuo ang workflow ng function ng mga sumusunod na hakbang:

1. Algorithmic synthesis: Ginagamit ng function ang Hamiltonian at mga setting ng simulation time para bumuo ng optimized na Trotter-Suzuki sequence, na nagbabawas ng circuit depth habang isinasaalang-alang ang simulation accuracy.

2. Hardware-aware mapping: Ma-map at ni-route ng function ang mga circuit gamit ang qubit connectivity at mga error characteristic ng napiling IBM Quantum backend.

3. Physical-layer error suppression: Isinasama ng Fire Opal ang dynamical decoupling at mga pulse-level na correction para pigilan ang noise mula sa environment at crosstalk habang nag-e-execute sa hardware.

Awtomatikong pinamamahalaan ng function ang mga yugtong ito at ibinabalik ang mga expectation value ng hiniling na mga observable sa paglipas ng panahon.

Tinutukoy mo ang physical na problema at mga setting ng simulation sa pamamagitan ng mga input ng function. Sinusuportahan ng kasalukuyang interface ang Trotter time evolution, kung saan itinatakda ng time_step ang tagal ng bawat step at itinatakda ng step_count ang bilang ng mga step.

Para sa karagdagang detalye, tingnan ang Fire Opal dynamics simulator overview at ang simulate_dynamics API reference.

Magsimula

Hanapin ang access information para sa Qiskit Function na ito sa Qiskit Functions Catalog.

Ipinapakita ng gabay na ito kung paano i-load ang Dynamics Simulator at mag-simulate ng apat-na-site na Fermi-Hubbard chain. Ipinapalagay ng sumusunod na code na na-save mo na ang IBM Quantum Platform API key at instance CRN mo sa local environment mo.

Para sa account setup at mga tagubilin sa pag-install ng client, tingnan ang Magsimula sa 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")

Halimbawa: I-simulate ang apat-na-site na Fermi-Hubbard chain

Isaalang-alang ang apat-na-site na one-dimensional na Fermi-Hubbard chain na may hopping amplitude na $t_h=1$, walang on-site interaction, at zero chemical potential. Isang spin-up na fermion ang nagsisimula sa site 0 at nag-e-evolve sa buong chain.

Pinapanatili ng maliit na problemang ito ang focus sa workflow ng Dynamics Simulator:

1. Tukuyin ang model at simulation.

2. Tukuyin ang initial state at mga observable.

3. Isumite ang Qiskit Function job.

4. Kunin ang mga expectation value.

5. I-plot ang dynamics.

1. Tukuyin ang problema

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

Sinusukat ng listahan ng mga observable ang spin-up occupation

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

sa bawat site. Ibinabalik ang mga observable sa parehong pagkakasunod-sunod kung paano ibinigay ang mga ito.

2. Patakbuhin ang dynamics simulation

I-submit ang problema sa pamamagitan ng Qiskit Function. Ang Qiskit Functions Catalog ang humahawak ng IBM Quantum authentication, kaya hindi mo na kailangang magpasa ng hiwalay na Fire Opal o hardware-provider credentials sa 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

Ang ibinalik na object ay isang Qiskit Function job. Puwede mong itago ang job ID para makuha o masilip ang workload mamaya.

3. Kunin ang resulta

result = job.result()

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

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

I-convert ang mga expectation value ng observable sa isang NumPy array. Ang bawat row ay tumutugma sa isang observable, at ang bawat column ay tumutugma sa isang naitalang simulation time, simula sa $t=0$. Sa halimbawang ito, ang apat na row ay naglalaman ng spin-up occupation ng mga site 0 hanggang 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. I-visualize ang dynamics

Ang initial state ay may isang spin-up fermion at walang spin-down fermion. Kaya ang ebolusyon nito ay nananatili sa single-particle subspace, na ang apat na basis state ay tumutugma sa fermion na nasa site 0, 1, 2, at 3.

Sa subspace na ito, ikinokonekta ng Hamiltonian ang magkakatabing site gamit ang hopping amplitude na $-t_h$. Para sa mga parameter na ginamit dito,

$$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}.$$

I-diagonalize ang matrix na ito gamit ang NumPy at i-evolve ang initial state sa parehong mga oras na ibinalik ng Dynamics Simulator. Ang squared magnitude ng bawat state amplitude ang nagbibigay ng spin-up occupation ng katumbas na site.

Nagbibigay ang kalkulasyong ito ng eksaktong Hamiltonian evolution. Ang mga pagkakaiba ng hardware estimate at ng reference na ito ay maaaring manggaling sa finite Trotter step, measurement statistics, at natitirang hardware error.

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

Mag-plot ng isang panel para sa bawat site. Ipinapakita ng mga solid na kurba ang eksaktong reference sa mga naitalang oras, at ipinapakita ng mga marker ang hardware estimate na ibinalik ng 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()

Sa $t=0$, ang eksaktong spin-up occupation ay 1 sa site 0 at 0 sa iba pang site. Habang nag-e-evolve ang sistema, ikinakalat ng hopping ang probability ng particle sa buong chain. Unang tumataas ang occupation ng site 1, sunod ang pagtaas ng occupation sa mga site 2 at 3. Para sa mga parameter sa halimbawang ito, ang huling naitalang oras ay $t=1.6$. Ang eksaktong occupation ng mga site 0 hanggang 3 ay humigit-kumulang 0.026, 0.370, 0.392, at 0.211, ayon sa pagkakasunod.

Natutugunan ng eksaktong occupation ang sumusunod na equation sa bawat oras, na sumasalamin sa conservation ng bilang ng particle:

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

Ang occupation ng bawat site ay puwedeng tumaas at bumaba habang gumagalaw ang particle sa finite chain.

Kunin ang mga error message

Kung pumasok ang workload sa ERROR state, tawagin ang job.result() para makuha ang error message. Puwede mo ring silipin ang function logs, kung available ang mga ito.

print(job.status())

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

DONE

Kabilang sa mga karaniwang isyu sa input validation ang hindi suportadong model o simulation method, initial-state string na masyadong mahaba, hindi magkatugmang observable term at coefficient, o observable na tumutukoy sa site na wala sa initial-state string.

Humingi ng suporta

Para sa mga tanong tungkol sa Dynamics Simulator o sa behavior ng Fire Opal, tingnan ang Q-CTRL documentation o makipag-ugnayan sa Q-CTRL.

Para sa Qiskit Functions authentication, job management, o access sa IBM Quantum Platform, tingnan ang Qiskit Functions documentation.

Mga susunod na hakbang

Mga rekomendasyon

• Tingnan ang simulate_dynamics API reference para sa mga definition ng pinagbabatayang model, simulation, observable, output, at validation.
• Subukan ang tutorial na Spin and charge dynamics in the Fermi-Hubbard model.
• Basahin ang Fire Opal dynamics simulator overview para sa karagdagang detalye tungkol sa Trotterization, hardware-aware mapping, at Fire Opal error suppression.
• Baguhin ang mga model parameter, initial state, time step, bilang ng step, at mga observable para pag-aralan ang ibang one-dimensional na Fermi-Hubbard dynamics problem.