Dynamics Simulator - o Qiskit Function de la Q-CTRL Fire Opal

Vezi referința API.

notă

Qiskit Functions sunt o funcție experimentală disponibilă doar utilizatorilor planurilor IBM Quantum® Premium, Flex și On-Prem (prin API-ul IBM Quantum Platform). Se află în stadiul de versiune preview și pot suferi modificări.

Prezentare generală

Dynamics Simulator de la Q-CTRL este o Qiskit Function de aplicație pentru simularea evoluției în timp a modelelor cuantice cu mai mulți corpi suportate, pe hardware IBM Quantum. În loc să construiești tu circuitele cuantice, specifici modelul fizic, starea inițială, parametrii evoluției în timp și observabilele de măsurat.

Funcția construiește și execută circuitele dinamice necesare și aplică workflow-ul Fire Opal de optimizare conștientă de hardware și de suprimare a erorilor. Rezultatul este o evoluție în timp a valorilor medii ale observabilelor pe care le-ai solicitat. Deoarece funcția aplică automat suprimarea erorilor, poți rula circuite la adâncimi record și poți vedea totuși semnale semnificative. Dynamics Simulator oferă o acuratețe a soluției care se potrivește cu cele mai avansate instrumente clasice existente și oferă un avantaj demonstrabil în viteză.

Testele în llume reală au atins o concordanță în limita a 1% eroare pătratică medie (RMSE) comparativ cu simulările clasice cu rețele de tensori de cea mai înaltă rezoluție. Teste independente din comunitatea de cercetare au validat că/ calculatorul cuantic rămâne precis chiar dincolo de demonstrațiile inițiale ale Q-CTRL.

Benchmark-uri

Numărul de situri determină câți qubiți sunt necesari, în timp ce numărul de pași Trotter controlează adâncimea circuitelor de evoluție în timp. Fiecare sit al rețelei folosește doi qubiți pentru a reprezenta ocupările cu spin sus și spin jos.

Acest workflow a fost demonstrat pentru lanțuri de 60 de situri (120 de qubiți) cu 30 de pași Trotter și pentru lanțuri de 31 de situri (62 de qubiți) cu 90 de pași Trotter. Tabelul de mai jos arată resursele circuitelor și timpii de execuție pe QPU din experimentele raportate, realizate pe un dispozitiv IBM® Heron r3 (ibm_boston) cu 20.000 de shot-uri pe circuit.

Dimensiunea sistemului	Pași Trotter	Adâncime pe doi qubiți	Număr de porți pe doi qubiți	Timp QPU	Timp QPU cu REM + DR
10 situri (20 de qubiți)	30	152	1,457	2m 46s	4m 25s
10 situri (20 de qubiți)	60	302	2,897	5m 36s	8m 42s
10 situri (20 de qubiți)	90	452	4,337	8m 46s	13m 26s
31 de situri (62 de qubiți)	30	152	4,649	2m 46s	4m 25s
31 de situri (62 de qubiți)	60	302	9,239	5m 36s	8m 42s
31 de situri (62 de qubiți)	90	452	13,829	8m 46s	13m 26s
60 de situri (120 de qubiți)	30	152	9,057	2m 46s	4m 25s

Pentru un număr fix de pași Trotter, adâncimea raportată a circuitului și timpul QPU rămân aceleași pentru dimensiunile de sistem testate, în timp ce numărul de porți pe doi qubiți crește. Creșterea numărului de pași produce circuite mai adânci și necesită mai mult timp QPU.

Aici, timpul QPU este timpul cumulat de execuție pe hardware pentru circuitele principale de simulare. Ultima coloană include și timpul QPU pentru caracterizarea zgomotului folosită în atenuarea erorilor de citire (REM) și recuperarea decăderii (DR). Acest ghid folosește un mic exemplu Fermi-Hubbard unidimensional pentru a arăta workflow-ul complet, de la definirea modelului până la reprezentarea grafică a dinamicii măsurate.

Descrierea funcției

Dinamica cuantică descrie cum se schimbă un sistem cuantic în timp. Studierea acestei evoluții te ajută să înțelegi cum se mișcă particulele, cum se dezvoltă corelațiile și cum răspunde un sistem la o schimbare a stării sau a Hamiltonianului său.

Modelul Fermi-Hubbard descrie fermioni care se deplasează între situri ale rețelei și interacționează când ocupă același sit. Competiția dintre salt și interacțiuni îl face un model util pentru studierea electronilor puternic corelați. Evoluția sa în timp poate dezvălui cum se propagă spinul și sarcina și cum se relaxează un sistem inițial ordonat.

Model

Dynamics Simulator suportă un lanț Fermi-Hubbard unidimensional cu capete deschise. Pentru un lanț de $L$ situri, Hamiltonianul este definit astfel:

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

Aici, $c^\dagger_{i\sigma}$ și $c_{i\sigma}$ creează și anihilează un fermion cu spin $\sigma$ la situl $i$. Operatorul număr $n_{i\sigma}=c^\dagger_{i\sigma}c_{i\sigma}$ măsoară ocuparea acelui orbital de spin.

Intrările modelului specifică următorii coeficienți:

• hopping_amplitude: $t_{h,i}$, care controlează saltul între siturile vecine $i$ și $i+1$.

• on_site_interaction: $U_i$, interacțiunea dintre fermionii cu spin sus și spin jos care ocupă același sit.

• chemical_potential: $\mu_i$, potențialul chimic local, care intră în Hamiltonian cu semnul minus.

Furnizează un scalar pentru a folosi același coeficient în tot lanțul sau o listă pentru a specifica coeficienți pentru legături sau situri individuale.

În unități în care $\hbar=1$, starea inițială evoluează astfel:

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

Funcția estimează valorile medii ale observabilelor pe care le specifici la momente succesive de simulare.

Workflow

Workflow-ul funcției constă din următorii pași:

1. Sinteză algoritmică: Funcția folosește Hamiltonianul și setările timpului de simulare pentru a construi o secvență Trotter-Suzuki optimizată, care reduce adâncimea circuitului ținând cont de acuratețea simulării.

2. Mapare conștientă de hardware: Funcția mapează și rutează circuitele folosind conectivitatea qubiților și caracteristicile de eroare ale backend-ului IBM Quantum selectat.

3. Suprimarea erorilor la nivel fizic: Fire Opal încorporează decuplare dinamică și corecții la nivel de puls pentru a suprima zgomotul din mediu și crosstalk-ul în timpul execuției pe hardware.

Funcția gestionează automat aceste etape și returnează în timp valorile medii ale observabilelor solicitate.

Definești problema fizică și setările simulării prin intrările funcției. Interfața actuală suportă evoluția în timp Trotter, în care time_step stabilește durata fiecărui pas, iar step_count stabilește numărul de pași.

Pentru detalii suplimentare, vezi prezentarea generală a Fire Opal dynamics simulator și referința API simulate_dynamics.

Primii pași

Găsește informațiile de acces pentru această Qiskit Function în Qiskit Functions Catalog.

Acest ghid arată cum să încarci Dynamics Simulator și să simulezi un lanț Fermi-Hubbard cu patru situri. Codul următor presupune că ai salvat deja cheia API IBM Quantum Platform și CRN-ul instanței în mediul tău local.

Pentru instrucțiuni de configurare a contului și de instalare a clientului, vezi Primii pași cu 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")

Exemplu: simulează un lanț Fermi-Hubbard cu patru situri

Consideră un lanț Fermi-Hubbard unidimensional cu patru situri, cu amplitudinea de salt $t_h=1$, fără interacțiune pe sit și cu potențial chimic zero. Un singur fermion cu spin sus începe la situl 0 și evoluează de-a lungul lanțului.

Această problemă mică păstrează atenția asupra workflow-ului Dynamics Simulator:

1. Definește modelul și simularea.

2. Definește starea inițială și observabilele.

3. Trimite job-ul Qiskit Function.

4. Preia valorile medii.

5. Reprezintă grafic dinamica.

1. Definește 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

Lista de observabile măsoară ocuparea cu spin în sus

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

la fiecare site. Observabilele sunt returnate în aceeași ordine în care au fost furnizate.

2. Rulează simularea dinamicii

Trimite problema prin Qiskit Function. Qiskit Functions Catalog gestionează autentificarea IBM Quantum, deci nu trebuie să transmiți separat credențiale Fire Opal sau ale unui furnizor de hardware către 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

Obiectul returnat este un job Qiskit Function. Poți păstra ID-ul jobului pentru a recupera sau inspecta mai târziu sarcina de lucru.

3. Obține rezultatul

result = job.result()

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

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

Convertește valorile medii ale observabilelor într-un array NumPy. Fiecare rând corespunde unei observabile, iar fiecare coloană corespunde unui moment de simulare înregistrat, începând de la $t=0$. Pentru acest exemplu, cele patru rânduri conțin ocupările cu spin în sus ale site-urilor 0 până la 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. Vizualizează dinamica

Starea inițială conține un fermion cu spin în sus și niciun fermion cu spin în jos. Evoluția sa rămâne așadar în subspațiul cu o singură particulă, ale cărui patru stări de bază corespund fermionului care ocupă site-urile 0, 1, 2 și 3.

În acest subspațiu, hamiltonianul conectează site-urile vecine cu amplitudinea de salt $-t_h$. Pentru parametrii folosiți aici,

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

Diagonalizează această matrice cu NumPy și evoluează starea inițială la aceleași momente de timp care au fost returnate de Dynamics Simulator. Pătratul modulului fiecărei amplitudini de stare dă ocuparea cu spin în sus a site-ului corespunzător.

Acest calcul dă evoluția hamiltoniană exactă. Diferențele dintre estimările hardware și această referință pot include pasul Trotter finit, statisticile de măsurare și erorile hardware reziduale.

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

Reprezintă grafic câte un panou pentru fiecare site. Curbele continue arată referința exactă la momentele înregistrate, iar markerii arată estimările hardware returnate de 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()

La $t=0$, ocuparea exactă cu spin în sus este 1 la site-ul 0 și 0 la celelalte site-uri. Pe măsură ce sistemul evoluează, saltul răspândește probabilitatea particulei de-a lungul lanțului. Ocuparea site-ului 1 crește prima, urmată de creșterea ocupării la site-urile 2 și 3. Pentru parametrii din acest exemplu, ultimul moment înregistrat este $t=1.6$. Ocupările exacte ale site-urilor 0 până la 3 sunt aproximativ 0.026, 0.370, 0.392 și, respectiv, 0.211.

Ocupările exacte satisfac următoarea ecuație la fiecare moment, reflectând conservarea numărului de particule:

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

Ocupările individuale ale site-urilor pot crește și scădea pe măsură ce particula evoluează prin lanțul finit.

Obține mesajele de eroare

Dacă sarcina de lucru intră în starea ERROR, apelează job.result() pentru a obține mesajul de eroare. Poți inspecta și jurnalele funcției, dacă sunt disponibile.

print(job.status())

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

DONE

Problemele frecvente de validare a intrărilor includ un model sau o metodă de simulare neacceptate, un șir de stare inițială prea lung, termeni și coeficienți de observabile care nu se potrivesc sau o observabilă care face referire la un site din afara șirului stării inițiale.

Obține asistență

Pentru întrebări despre comportamentul Dynamics Simulator sau al Fire Opal, consultă documentația Q-CTRL sau contactează Q-CTRL.

Pentru autentificarea Qiskit Functions, gestionarea joburilor sau accesul la IBM Quantum Platform, consultă documentația Qiskit Functions.

Pașii următori

Recomandări

• Consultă referința API simulate_dynamics pentru definițiile modelului, simulării, observabilelor, ieșirii și validării.
• Încearcă tutorialul Dinamica spinului și a sarcinii în modelul Fermi-Hubbard.
• Citește prezentarea generală a Fire Opal dynamics simulator pentru mai multe detalii despre trotterizare, maparea conștientă de hardware și suprimarea erorilor din Fire Opal.
• Modifică parametrii modelului, starea inițială, pasul de timp, numărul de pași și observabilele pentru a studia o altă problemă de dinamică Fermi-Hubbard unidimensională.