Dynamics Simulator – Qiskit Function od Q-CTRL Fire Opal

Viz referenční dokumentace API.

poznámka

Qiskit Functions jsou experimentální funkce dostupné pouze uživatelům plánů IBM Quantum® Premium Plan, Flex Plan a On-Prem (prostřednictvím IBM Quantum Platform API). Jsou ve stavu náhledového vydání a mohou se změnit.

Přehled

Q-CTRL Dynamics Simulator je aplikační Qiskit Function pro simulaci časového vývoje podporovaných kvantových modelů mnoha těles na hardwaru IBM Quantum. Místo vlastního sestavování kvantových obvodů zadáš fyzikální model, počáteční stav, parametry časového vývoje a observable, které se mají měřit.

Funkce sestaví a provede potřebné dynamické obvody a použije optimalizaci Fire Opal s ohledem na hardware a workflow potlačení chyb. Výsledkem je časový průběh očekávaných hodnot požadovaných observable. Protože funkce potlačuje chyby automaticky, můžeš spouštět obvody s rekordní hloubkou a stále vidět smysluplné signály. Dynamics Simulator poskytuje přesnost řešení odpovídající stávajícím nejmodernějším klasickým nástrojům a prokazatelnou výhodu v rychlosti.

Testování v reálných podmínkách dosáhlo shody v rámci 1% střední kvadratické chyby (RMSE) při porovnání s klasickými simulacemi tenzorových sítí s nejvyšším rozlišením. Nezávislé testy z výzkumné komunity potvrdily, že kvantový počítač zůstává přesný i nad rámec původních demonstrací Q-CTRL.

Benchmarky

Počet míst určuje, kolik qubitů je potřeba, zatímco počet Trotterových kroků řídí hloubku obvodů časového vývoje. Každé místo mřížky používá dva qubity k reprezentaci obsazení se spinem nahoru a spinem dolů.

Tento workflow byl demonstrován pro řetězce o 60 místech (120 qubitů) s 30 Trotterovými kroky a pro řetězce o 31 místech (62 qubitů) s 90 Trotterovými kroky. Následující tabulka ukazuje prostředky obvodů a časy provádění na QPU z publikovaných experimentů, provedených na zařízení IBM® Heron r3 (ibm_boston) s 20 000 shoty na obvod.

Velikost systému	Trotterovy kroky	Hloubka dvouqubitových bran	Počet dvouqubitových bran	Čas na QPU	Čas na QPU s REM + DR
10 míst (20 qubitů)	30	152	1,457	2m 46s	4m 25s
10 míst (20 qubitů)	60	302	2,897	5m 36s	8m 42s
10 míst (20 qubitů)	90	452	4,337	8m 46s	13m 26s
31 míst (62 qubitů)	30	152	4,649	2m 46s	4m 25s
31 míst (62 qubitů)	60	302	9,239	5m 36s	8m 42s
31 míst (62 qubitů)	90	452	13,829	8m 46s	13m 26s
60 míst (120 qubitů)	30	152	9,057	2m 46s	4m 25s

Při pevném počtu Trotterových kroků zůstávají uváděná hloubka obvodu a čas na QPU stejné napříč testovanými velikostmi systému, zatímco počet dvouqubitových bran roste. Zvýšení počtu kroků vede k hlubším obvodům a vyžaduje více času na QPU.

Čas na QPU je zde kumulativní doba provádění hlavních simulačních obvodů na hardwaru. Poslední sloupec zahrnuje také čas na QPU pro charakterizaci šumu použitou při potlačení chyb čtení (REM) a obnově po rozpadu (DR). Tento průvodce používá malý jednorozměrný příklad Fermiho–Hubbardova modelu, aby ukázal kompletní workflow od definice modelu po vykreslení měřené dynamiky.

Popis funkce

Kvantová dynamika popisuje, jak se kvantový systém mění v čase. Studium tohoto vývoje ti pomáhá pochopit, jak se částice pohybují, jak se vyvíjejí korelace a jak systém reaguje na změnu svého stavu nebo Hamiltoniánu.

Fermiho–Hubbardův model popisuje fermiony pohybující se mezi místy mřížky a interagující, když obsadí stejné místo. Soupeření mezi přeskoky a interakcemi z něj činí užitečný model pro studium silně korelovaných elektronů. Jeho časový vývoj může odhalit, jak se šíří spin a náboj a jak relaxuje původně uspořádaný systém.

Model

Dynamics Simulator podporuje jednorozměrný Fermiho–Hubbardův řetězec s otevřenými okraji. Pro řetězec o $L$ místech je Hamiltonián definován takto:

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

Zde $c^\dagger_{i\sigma}$ a $c_{i\sigma}$ vytvářejí a ničí fermion se spinem $\sigma$ na místě $i$. Operátor počtu $n_{i\sigma}=c^\dagger_{i\sigma}c_{i\sigma}$ měří obsazení tohoto spinového orbitalu.

Vstupy modelu určují následující koeficienty:

• hopping_amplitude: $t_{h,i}$, který řídí přeskoky mezi sousedními místy $i$ a $i+1$.

• on_site_interaction: $U_i$, interakce mezi fermiony se spinem nahoru a dolů obsazujícími stejné místo.

• chemical_potential: $\mu_i$, lokální chemický potenciál, který vstupuje do Hamiltoniánu se záporným znaménkem.

Zadej skalár, chceš-li použít stejný koeficient v celém řetězci, nebo seznam, chceš-li určit koeficienty pro jednotlivé vazby či místa.

V jednotkách, kde $\hbar=1$, se počáteční stav vyvíjí takto:

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

Funkce odhaduje očekávané hodnoty zadaných observable v postupných časech simulace.

Workflow

Workflow funkce se skládá z následujících kroků:

1. Algoritmická syntéza: Funkce použije Hamiltonián a nastavení doby simulace k sestavení optimalizované Trotterovy–Suzukiho posloupnosti, která snižuje hloubku obvodu a zároveň zohledňuje přesnost simulace.

2. Mapování s ohledem na hardware: Funkce mapuje a směruje obvody pomocí konektivity qubitů a charakteristik chyb vybraného backendu IBM Quantum.

3. Potlačení chyb na fyzické vrstvě: Fire Opal zahrnuje dynamické oddělení a korekce na úrovni pulzů, které potlačují šum z prostředí a crosstalk během provádění na hardwaru.

Funkce tyto fáze spravuje automaticky a vrací očekávané hodnoty požadovaných observable v čase.

Fyzikální problém a nastavení simulace definuješ prostřednictvím vstupů funkce. Současné rozhraní podporuje Trotterův časový vývoj, kde time_step určuje délku každého kroku a step_count určuje počet kroků.

Další podrobnosti najdeš v přehledu Fire Opal dynamics simulator a v referenční dokumentaci API simulate_dynamics.

Začínáme

Informace o přístupu k této Qiskit Function najdeš v katalogu Qiskit Functions.

Tento průvodce ukazuje, jak načíst Dynamics Simulator a simulovat čtyřmístný Fermiho–Hubbardův řetězec. Následující kód předpokládá, že už máš svůj API klíč IBM Quantum Platform a CRN instance uložené v lokálním prostředí.

Pokyny k nastavení účtu a instalaci klienta najdeš v části Začínáme s 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")

Příklad: Simulace čtyřmístného Fermiho–Hubbardova řetězce

Uvažuj čtyřmístný jednorozměrný Fermi-Hubbardův řetězec s amplitudou přeskoku $t_h=1$, bez interakce na místě a s nulovým chemickým potenciálem. Jediný fermion se spinem nahoru začíná na místě 0 a vyvíjí se podél řetězce.

Tento malý problém udržuje pozornost na pracovním postupu Dynamics Simulator:

1. Definuj model a simulaci.

2. Definuj počáteční stav a pozorovatelné.

3. Odešli úlohu Qiskit Function.

4. Získej očekávané hodnoty.

5. Vykresli dynamiku.

1. Definice problému

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

Seznam pozorovatelných měří obsazení se spinem nahoru

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

na každém místě. Pozorovatelné jsou vráceny ve stejném pořadí, v jakém byly zadány.

2. Spuštění simulace dynamiky

Odešli problém prostřednictvím Qiskit Function. Qiskit Functions Catalog zajišťuje autentizaci IBM Quantum, takže do sim_qf.run() nepředáváš samostatné přihlašovací údaje pro Fire Opal ani pro poskytovatele hardwaru.

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

Vrácený objekt je úloha Qiskit Function. ID úlohy si můžeš ponechat, abys mohl(a) úlohu později načíst nebo zkontrolovat.

3. Získání výsledku

result = job.result()

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

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

Převeď očekávané hodnoty pozorovatelných na pole NumPy. Každý řádek odpovídá jedné pozorovatelné a každý sloupec zaznamenanému času simulace, počínaje $t=0$. V tomto příkladu obsahují čtyři řádky obsazení se spinem nahoru na místech 0 až 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. Vizualizace dynamiky

Počáteční stav obsahuje jeden fermion se spinem nahoru a žádné fermiony se spinem dolů. Jeho vývoj proto zůstává v jednočásticovém podprostoru, jehož čtyři bázové stavy odpovídají fermionu na místech 0, 1, 2 a 3.

V tomto podprostoru hamiltonián propojuje sousední místa s amplitudou přeskoku $-t_h$. Pro zde použité parametry platí

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

Diagonalizuj tuto matici pomocí NumPy a vyvíjej počáteční stav ve stejných časech, které vrátil Dynamics Simulator. Druhá mocnina velikosti každé amplitudy stavu udává obsazení odpovídajícího místa se spinem nahoru.

Tento výpočet dává přesný hamiltoniánovský vývoj. Rozdíly mezi odhady z hardwaru a touto referencí mohou zahrnovat konečný Trotterův krok, statistiku měření a zbytkové chyby hardwaru.

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

Vykresli jeden panel pro každé místo. Plné křivky ukazují přesnou referenci v zaznamenaných časech a značky ukazují odhady z hardwaru vrácené Dynamics Simulatorem.

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()

V čase $t=0$ je přesné obsazení se spinem nahoru rovno 1 na místě 0 a 0 na ostatních místech. Jak se systém vyvíjí, přeskoky rozprostírají pravděpodobnost částice podél řetězce. Nejprve roste obsazení místa 1, poté následuje rostoucí obsazení míst 2 a 3. Pro parametry v tomto příkladu je poslední zaznamenaný čas $t=1.6$. Přesná obsazení míst 0 až 3 jsou přibližně 0.026, 0.370, 0.392 a 0.211.

Přesná obsazení v každém čase splňují následující rovnici, což odráží zachování počtu částic:

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

Obsazení jednotlivých míst mohou růst i klesat, jak se částice vyvíjí v konečném řetězci.

Získání chybových zpráv

Pokud úloha přejde do stavu ERROR, zavolej job.result() a získáš chybovou zprávu. Můžeš také zkontrolovat logy funkce, pokud jsou k dispozici.

print(job.status())

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

DONE

Mezi časté problémy při validaci vstupu patří nepodporovaný model nebo metoda simulace, příliš dlouhý řetězec počátečního stavu, neodpovídající členy a koeficienty pozorovatelné, nebo pozorovatelná odkazující na místo mimo řetězec počátečního stavu.

Získání podpory

S dotazy k chování Dynamics Simulator nebo Fire Opal se obrať na dokumentaci Q-CTRL nebo kontaktuj Q-CTRL.

K autentizaci Qiskit Functions, správě úloh nebo přístupu k IBM Quantum Platform viz dokumentace Qiskit Functions.

Další kroky

Doporučení

• Prostuduj referenci API simulate_dynamics, kde najdeš definice modelu, simulace, pozorovatelných, výstupu a validace.
• Vyzkoušej tutoriál Dynamika spinu a náboje v modelu Fermi-Hubbard.
• Přečti si přehled simulátoru dynamiky Fire Opal, kde najdeš více o Trotterizaci, mapování s ohledem na hardware a potlačení chyb ve Fire Opal.
• Uprav parametry modelu, počáteční stav, časový krok, počet kroků a pozorovatelné a studuj jiný problém dynamiky jednorozměrného Fermi-Hubbardova modelu.