QUICK-PDE: Isang Qiskit Function ng ColibriTD

Tingnan ang API reference

tala

Ang Qiskit Functions ay isang experimental na feature na available para sa mga gumagamit 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 Partial Differential Equation (PDE) solver na ipinapakita dito ay bahagi ng aming Quantum Innovative Computing Kit (QUICK) platform (QUICK-PDE), at nakabalot bilang isang Qiskit Function. Sa pamamagitan ng QUICK-PDE function, maaari kang maglutas ng domain-specific partial differential equations sa IBM Quantum QPUs. Ang function na ito ay nakabatay sa algorithm na inilalarawan sa papel ng ColibriTD na naglalarawan sa H-DES. Kaya ng algorithm na ito na harapin ang mga kumplikadong multi-physics na problema, simula sa Computational Fluid Dynamics (CFD) at Materials Deformation (MD), at may mga karagdagang use case na paparating pa.

Para harapin ang mga differential equations, ang mga trial solution ay naka-encode bilang linear combinations ng mga orthogonal function (karaniwang Chebyshev polynomials, at mas partikular na $2^n$ sa kanila kung saan ang $n$ ay ang bilang ng mga qubit na nag-e-encode ng iyong function), na naka-parametrize sa pamamagitan ng mga anggulo ng isang Variable Quantum Circuit (VQC). Ang ansatz ay bumubuo ng isang estado na nag-e-encode ng function, na sinusuri ng mga observable na ang kombinasyon nito ay nagbibigay-daan sa pag-evaluate ng function sa lahat ng punto. Maaari kang mag-evaluate ng loss function kung saan naka-encode ang mga differential equations, at i-fine-tune ang mga anggulo sa isang hybrid loop, tulad ng ipinapakita sa sumusunod. Ang mga trial solution ay unti-unting lumalapit sa mga aktwal na solusyon hanggang sa makamit mo ang kasiya-siyang resulta.

Bukod sa hybrid loop na ito, maaari ka ring mag-chain ng iba't ibang optimizer. Ito ay kapaki-pakinabang kapag gusto mong gamitin ang isang global optimizer para mahanap ang magandang set ng mga anggulo, at pagkatapos ay isang mas pinong optimizer para sundan ang gradient patungo sa pinakamahusay na set ng kalapit na mga anggulo. Sa kaso ng computational fluid dynamics (CFD), ang default na optimization sequence ay nagbibigay ng pinakamahusay na resulta — ngunit sa kaso ng material deformation (MD), habang nagbibigay ng magandang resulta ang default, maaari mo itong i-configure pa para sa mga benepisyong partikular sa problema.

Tandaan na para sa bawat variable ng function, tinutukoy natin ang bilang ng mga qubit (na maaari mong baguhin). Sa pag-stack ng 10 magkaparehong circuit at pag-evaluate ng 10 magkaparehong observable sa iba't ibang qubit sa buong isang malaking circuit, maaari kang mag-noise-mitigate sa loob ng proseso ng CMA optimization, umaasa sa noise learner method, at makabuluhang mabawasan ang bilang ng mga shot na kailangan.

Computational fluid dynamics

Ang inviscid Burgers' equation ay nagmo-modelo ng daloy ng mga di-malapot na likido tulad ng sumusunod:

$\frac{\partial u}{\partial t} + u\frac{\partial u}{\partial x} = 0,$

Ang $u$ ay kumakatawan sa field ng bilis ng likido. Ang use case na ito ay may temporal na boundary condition: maaari kang pumili ng initial condition at hayaan ang sistema na mag-relax. Sa kasalukuyan, ang mga tanging tinatanggap na initial condition ay mga linear function: $ax + b$. Ang analytical solution ay:

$u(t, x) = \frac{ax + b}{at + 1}.$

Ang pressureless Euler equations ay nagmo-modelo ng compressible inviscid fluid flow na may damping tulad ng sumusunod:

$\frac{\partial g}{\partial t} + u\frac{\partial g}{\partial x} + g\frac{\partial u}{\partial x} = 0,$

$u\frac{\partial g}{\partial t} + g\frac{\partial u}{\partial t} + u^2\frac{\partial g}{\partial x} + 2gu\frac{\partial u}{\partial x} + \frac{\mu}{(1+t)^{\lambda}} g u = 0,$

Ang $g$ ay kumakatawan sa density field, ang $u$ sa velocity field at ang $\mu$ sa isang damping coefficient. Sa ating formulation, itinakda natin na $\lambda = 1$, kaya hindi ito gagamitin bilang parameter sa sumusunod. Ang use-case na ito ay may temporal boundary conditions: $g(0, x) = e^{-x}$ at $u(0, x) = x$. Ang analytical solution ay:

$g(t, x) = \frac{1-\mu}{(1+t)^{1-\mu} - \mu} \exp\!\left(\frac{(\mu-1)\, x}{(1+t)^{1-\mu} - \mu}\right),$

$u(t, x) = \frac{(1-\mu)\, x}{\left((1+t)^{1-\mu} - \mu\right)(1+t)^{\mu}}.$

Ang mga argumento para sa mga differential equation ng CFD ay nasa isang fixed grid, tulad ng sumusunod:

• Ang $t$ ay nasa pagitan ng 0 at 0.95 na may 41 sample points. Ang $x$ ay nasa pagitan ng 0 at 0.95 na may 41 sample points.

Material Deformation

Ang use case na ito ay nakatuon sa hypoelastic deformation na may one-dimensional tensile test, kung saan ang isang bar na nakapirmi sa espasyo ay hinihila sa kabilang dulo nito. Inilalarawan namin ang problema tulad ng sumusunod:

$u' - \frac{\sigma}{3K} - \frac{2}{\sqrt{3}}\epsilon_0\left(\frac{\sigma'}{\sigma_0\sqrt{3}}\right)^n = 0,$

$\sigma' - b = 0,$

Ang $K$ ay kumakatawan sa bulk modulus ng materyal na iniuunat, ang $n$ ang exponent ng isang power law, ang $b$ ang puwersa bawat unit mass, ang $\epsilon_0$ ang proportional stress limit, ang $\sigma_0$ ang proportional strain limit, ang $u$ ang stress function, at ang $\sigma$ ang strain function. Ang analytical solution ay:

$\sigma(x) = \sigma_0 - bx,$

$u(x) = -\frac{3^{-(3+n)/2}}{2bK(1+n)\,\sigma_0^{n}}\Biggl[3^{(1+n)/2}b^2\sigma_0^n(1+n)x^2 - 2\cdot 3^{(1+n)/2}b\sigma_0^n(1+n)\sigma_0 x - 12\epsilon_0 K\sigma_0^{1+n}$ $- 12b\epsilon_0 K\sigma_0^n x\left(\frac{-bx+\sigma_0}{\sigma_0}\right)^n + 12\epsilon_0 K\sigma_0^{n+1}\left(\frac{-bx+\sigma_0}{\sigma_0}\right)^n - 12\epsilon_0 K \sigma_0^{1+n}\Biggr],$

kung saan ang $\sigma_0 = g(0)$ ay ang boundary condition sa strain sa $x=0$.

Ang isinasaalang-alang na bar ay may unitary na haba. Ang use case na ito ay may boundary condition para sa surface stress $t$, o ang dami ng trabahong kailangan para maunat ang bar.

Ang mga argumento para sa mga differential equation ng MD ay nasa isang fixed grid, tulad ng sumusunod:

• Ang $x$ ay nasa pagitan ng 0 at 1 na may 30 sample points.

Mga Benchmark

Ang sumusunod na talahanayan ay nagpapakita ng mga istatistika sa iba't ibang run ng aming function.

Halimbawa	Bilang ng qubit	Inisyalisasyon	Error	Kabuuang oras (min)	Paggamit ng runtime (min)
Inviscid Burgers' equation	50	PHYSICALLY_INFORMED	$10^{-2}$	66	25
Pressureless Euler's equations	70	PHYSICALLY_INFORMED	$10^{-2}$	48	34
Hypoelastic 1D tensile test	18	RANDOM	$10^{-2}$	123	100

Magsimula

Punan ang form para humiling ng access sa QUICK-PDE function. Pagkatapos, kung nai-save mo na ang iyong account sa iyong lokal na environment, piliin ang function tulad ng sumusunod:

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

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "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_cloud / ibm_quantum_platform",
    instance="USER_CRN / HGP",
    token="USER_API_KEY / IQP_API_TOKEN",
)

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# Verify that you have access to the function
catalog.list()

quick = catalog.load("colibritd/quick-pde")

Mga Halimbawa

Para makapagsimula, subukan ang isa sa mga sumusunod na halimbawa:

Inviscid Burgers' equation (CFD)

Para sa Burgers' equation, kapag ang mga initial condition ay nakatakda sa $u(0,x) = x$, ang mga resulta ay tulad ng sumusunod:

# launch the simulation with initial conditions u(0,x) = a*x + b
job = quick.run(
    use_case="CFD_BURGER", physical_parameters={"a": 1.0, "b": 0.0}
)

Suriin ang status ng iyong Qiskit Function workload o kunin ang mga resulta tulad ng sumusunod:

# Print the ID so you can use it later, if necessary
print(job.job_id)
print(job.status())
solution = job.result()

import numpy as np
import matplotlib.pyplot as plt

def plot_result_3d(result):
    fig = plt.figure()
    ax = fig.add_subplot(projection="3d")

    t, x = np.meshgrid(result["samples"]["t"], result["samples"]["x"])

    ax.plot_surface(
        t,
        x,
        result["functions"]["u"],
        edgecolor="royalblue",
        lw=0.25,
        rstride=26,
        cstride=26,
        alpha=0.3,
    )
    ax.scatter(t, x, result["functions"]["u"], marker=".")
    ax.set(xlabel="t", ylabel="x", zlabel="u(t,x)")

    plt.show()

# Call
plot_result_3d(solution)

Pressureless Euler's equation (CFD)

Para sa Euler's equation, kapag ang mga initial condition ay nakatakda sa $g(0, x) = e^{-x}$ at $u(0, x) = x$, para sa isang ibinigay na $\mu$ (dito, $\mu = 0.1$) at $\lambda = 1$, ang mga resulta ay tulad ng sumusunod:

# Launches the solving for an arbitrary mu
job = quick.run(use_case="CFD_EULER", physical_parameters={"mu": 0.1})

solution = job.result()

# Colorplot function
def plot_result_2d(result):
    fig, axes = plt.subplots(1, 2, figsize=(14, 5))

    configs = {
        "g": {"cmap": "viridis", "title": "g(t, x)"},
        "u": {"cmap": "plasma", "title": "u(t, x)"},
    }

    t = result["samples"]["t"]
    x = result["samples"]["x"]

    for ax, (field, cfg) in zip(axes, configs.items()):
        v = result["functions"][field]

        im = ax.contourf(t, x, v, levels=50, cmap=cfg["cmap"])
        fig.colorbar(im, ax=ax, label=cfg["title"])

        ax.set_xlabel("t")
        ax.set_ylabel("x")
        ax.set_title(cfg["title"], fontsize=13, fontweight="bold")

    plt.tight_layout()
    plt.show()

plot_result_2d(solution)

Material Deformation

Ang use case ng material deformation ay nangangailangan ng mga pisikal na parameter ng iyong materyal at ng inilapat na puwersa, tulad ng sumusunod:

# Select the properties of your material
job = quick.run(
    use_case="MD",
    physical_parameters={
        "t": 12.0,
        "K": 100.0,
        "n": 4.0,
        "b": 10.0,
        "epsilon_0": 0.1,
        "sigma_0": 5.0,
    },
)

# Plot the result
solution = job.result()

_ = plt.figure()
stress_plot = plt.subplot(211)
plt.plot(solution["samples"]["x"], solution["functions"]["u"])
strain_plot = plt.subplot(212)
plt.plot(solution["samples"]["x"], solution["functions"]["sigma"])

plt.show()

Ang sumusunod ay isang halimbawa kung paano makuha ang halaga ng function para sa isang partikular na set ng mga coordinate:

# u(t=0.2, x=0.7) == 2
assert solution["samples"]["t"][1] == 0.2
assert solution["samples"]["x"][2] == 0.7
assert solution["functions"]["u"][1, 2] == 2

Kunin ang mga mensahe ng error

Kung ang status ng iyong workload ay ERROR, gamitin ang job.error_message() para makuha ang mensahe ng error na makakatulong sa pag-debug, tulad ng sumusunod:

job = quick.run(use_case="MD", physical_params={})

print(job.error_message())

# A wrapper can also be used for a more human readable version
def pprint_error(job):
    print("".join(eval(job.error_message())["error"]))

print("___")
pprint_error(job)

Humingi ng tulong

Para sa suporta, makipag-ugnayan sa qiskit-function-support@colibritd.com.

Susunod na hakbang

Mga Rekomendasyon

• Punan ang form para humiling ng access sa QUICK-PDE function.
• Bisitahin ang API reference para sa Qiskit Function na ito.
• Subukan ang pag-modelo ng isang daloy ng di-malapot na likido gamit ang QUICK-PDE sa tutorial.
• Suriin ang Jaffali, H., et al. (2025). H-DES: a Quantum-Classical Hybrid Differential Equation Solver. arXiv preprint arXiv:2410.01130.