Dynamics Simulator - a Qiskit Function by Q-CTRL Fire Opal

Consulta il riferimento API.

nota

Qiskit Functions sono una funzionalità sperimentale disponibile solo per gli utenti dei piani IBM Quantum® Premium Plan, Flex Plan e On-Prem (tramite l'API di IBM Quantum Platform). Sono in stato di rilascio in anteprima e soggette a modifiche.

Panoramica

Il Dynamics Simulator di Q-CTRL è una Qiskit Function applicativa per simulare l'evoluzione temporale di modelli quantistici a molti corpi supportati su hardware IBM Quantum. Invece di costruire tu stesso i circuiti quantistici, specifichi il modello fisico, lo stato iniziale, i parametri di evoluzione temporale e le osservabili da misurare.

La funzione costruisce ed esegue i circuiti dinamici necessari e applica il workflow di ottimizzazione hardware-aware e di soppressione degli errori di Fire Opal. Il risultato è una traccia temporale dei valori di aspettazione per le osservabili richieste. Poiché la funzione applica automaticamente la soppressione degli errori, puoi eseguire circuiti a profondità record e ottenere comunque segnali significativi. Il Dynamics Simulator offre un'accuratezza della soluzione pari a quella degli attuali strumenti classici allo stato dell'arte e dimostra un vantaggio in termini di velocità.

I test nel mondo reale hanno raggiunto un accordo entro l'1% di errore quadratico medio (RMSE) rispetto alle simulazioni classiche con reti di tensori a più alta risoluzione. Test indipendenti della comunità di ricerca hanno validato che il computer quantistico rimane accurato anche oltre le dimostrazioni iniziali di Q-CTRL.

Benchmark

Il numero di siti determina quanti qubit sono necessari, mentre il numero di passi di Trotter controlla la profondità dei circuiti di evoluzione temporale. Ogni sito del reticolo usa due qubit per rappresentare le occupazioni di spin-up e spin-down.

Questo workflow è stato dimostrato per catene di 60 siti (120 qubit) con 30 passi di Trotter e per catene di 31 siti (62 qubit) con 90 passi di Trotter. La tabella seguente mostra le risorse dei circuiti e i tempi di esecuzione su QPU degli esperimenti riportati, eseguiti su un dispositivo IBM® Heron r3 (ibm_boston) con 20.000 shot per circuito.

Dimensione del sistema	Passi di Trotter	Profondità a due qubit	Numero di gate a due qubit	Tempo QPU	Tempo QPU con REM + DR
10 siti (20 qubit)	30	152	1,457	2m 46s	4m 25s
10 siti (20 qubit)	60	302	2,897	5m 36s	8m 42s
10 siti (20 qubit)	90	452	4,337	8m 46s	13m 26s
31 siti (62 qubit)	30	152	4,649	2m 46s	4m 25s
31 siti (62 qubit)	60	302	9,239	5m 36s	8m 42s
31 siti (62 qubit)	90	452	13,829	8m 46s	13m 26s
60 siti (120 qubit)	30	152	9,057	2m 46s	4m 25s

Per un numero fisso di passi di Trotter, la profondità del circuito riportata e il tempo QPU restano gli stessi tra le dimensioni di sistema testate, mentre il numero di gate a due qubit aumenta. Aumentare il numero di passi produce circuiti più profondi e richiede più tempo QPU.

Qui, il tempo QPU è il tempo cumulativo di esecuzione hardware per i circuiti di simulazione principali. L'ultima colonna include anche il tempo QPU per la caratterizzazione del rumore usata nella mitigazione degli errori di lettura (REM) e nel recupero del decadimento (DR). Questa guida usa un piccolo esempio unidimensionale di Fermi-Hubbard per mostrare il workflow completo, dalla definizione del modello al grafico della dinamica misurata.

Descrizione della funzione

La dinamica quantistica descrive come un sistema quantistico cambia nel tempo. Studiare questa evoluzione ti aiuta a capire come si muovono le particelle, come si sviluppano le correlazioni e come un sistema risponde a un cambiamento del suo stato o del suo Hamiltoniano.

Il modello di Fermi-Hubbard descrive fermioni che si muovono tra i siti del reticolo e interagiscono quando occupano lo stesso sito. La competizione tra hopping e interazioni lo rende un modello utile per studiare gli elettroni fortemente correlati. La sua evoluzione temporale può rivelare come si propagano spin e carica e come si rilassa un sistema inizialmente ordinato.

Modello

Il Dynamics Simulator supporta una catena di Fermi-Hubbard unidimensionale con bordi aperti. Per una catena di $L$ siti, l'Hamiltoniano è definito come segue:

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

Qui, $c^\dagger_{i\sigma}$ e $c_{i\sigma}$ creano e annichilano un fermione con spin $\sigma$ al sito $i$. L'operatore numero $n_{i\sigma}=c^\dagger_{i\sigma}c_{i\sigma}$ misura l'occupazione di quell'orbitale di spin.

Gli input del modello specificano i coefficienti seguenti:

• hopping_amplitude: $t_{h,i}$, che controlla l'hopping tra i siti vicini $i$ e $i+1$.

• on_site_interaction: $U_i$, l'interazione tra fermioni di spin-up e spin-down che occupano lo stesso sito.

• chemical_potential: $\mu_i$, il potenziale chimico locale, che entra nell'Hamiltoniano con segno meno.

Fornisci uno scalare per usare lo stesso coefficiente in tutta la catena, oppure una lista per specificare i coefficienti dei singoli legami o siti.

In unità in cui $\hbar=1$, lo stato iniziale evolve come segue:

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

La funzione stima i valori di aspettazione delle osservabili che specifichi a tempi di simulazione successivi.

Workflow

Il workflow della funzione è costituito dai passaggi seguenti:

1. Sintesi algoritmica: la funzione usa l'Hamiltoniano e le impostazioni del tempo di simulazione per costruire una sequenza di Trotter-Suzuki ottimizzata, che riduce la profondità del circuito tenendo conto dell'accuratezza della simulazione.

2. Mappatura hardware-aware: la funzione mappa e instrada i circuiti usando la connettività dei qubit e le caratteristiche di errore del backend IBM Quantum selezionato.

3. Soppressione degli errori a livello fisico: Fire Opal incorpora il disaccoppiamento dinamico e correzioni a livello di impulso per sopprimere il rumore dell'ambiente e il crosstalk durante l'esecuzione sull'hardware.

La funzione gestisce automaticamente queste fasi e restituisce nel tempo i valori di aspettazione delle osservabili richieste.

Definisci il problema fisico e le impostazioni di simulazione tramite gli input della funzione. L'interfaccia attuale supporta l'evoluzione temporale di Trotter, dove time_step imposta la durata di ogni passo e step_count imposta il numero di passi.

Per ulteriori dettagli, consulta la panoramica del dynamics simulator di Fire Opal e il riferimento API di simulate_dynamics.

Inizia

Trova le informazioni di accesso per questa Qiskit Function nel Qiskit Functions Catalog.

Questa guida mostra come caricare il Dynamics Simulator e simulare una catena di Fermi-Hubbard a quattro siti. Il codice seguente presuppone che tu abbia già salvato la tua chiave API di IBM Quantum Platform e il CRN dell'istanza nel tuo ambiente locale.

Per le istruzioni di configurazione dell'account e di installazione del client, consulta Inizia con 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")

Esempio: simulare una catena di Fermi-Hubbard a quattro siti

Considera una catena di Fermi-Hubbard unidimensionale a quattro siti con ampiezza di hopping $t_h=1$, nessuna interazione on-site e potenziale chimico nullo. Un singolo fermione con spin-up parte dal sito 0 ed evolve lungo la catena.

Questo piccolo problema mantiene l'attenzione sul workflow del Dynamics Simulator:

1. Definisci il modello e la simulazione.

2. Definisci lo stato iniziale e le osservabili.

3. Invia il job della Qiskit Function.

4. Recupera i valori di aspettazione.

5. Rappresenta graficamente la dinamica.

1. Definisci il 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

L'elenco delle osservabili misura l'occupazione di spin-up

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

in ciascun sito. Le osservabili vengono restituite nello stesso ordine in cui sono state fornite.

2. Esegui la simulazione della dinamica

Invia il problema tramite la Qiskit Function. Il Qiskit Functions Catalog gestisce l'autenticazione IBM Quantum, quindi non passi credenziali separate di Fire Opal o del provider hardware a 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

L'oggetto restituito è un job di Qiskit Function. Puoi conservare l'ID del job per recuperare o ispezionare il carico di lavoro in un secondo momento.

3. Recupera il risultato

result = job.result()

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

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

Converti i valori di aspettazione delle osservabili in un array NumPy. Ogni riga corrisponde a un'osservabile e ogni colonna corrisponde a un tempo di simulazione registrato, a partire da $t=0$. In questo esempio, le quattro righe contengono le occupazioni di spin-up dei siti da 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. Visualizza la dinamica

Lo stato iniziale contiene un fermione con spin-up e nessun fermione con spin-down. La sua evoluzione rimane quindi nel sottospazio a singola particella, i cui quattro stati di base corrispondono al fermione che occupa i siti 0, 1, 2 e 3.

In questo sottospazio, l'Hamiltoniana collega i siti vicini con ampiezza di hopping $-t_h$. Per i parametri usati qui,

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

Diagonalizza questa matrice con NumPy ed fai evolvere lo stato iniziale agli stessi tempi restituiti dal Dynamics Simulator. Il modulo quadrato di ciascuna ampiezza di stato fornisce l'occupazione di spin-up del sito corrispondente.

Questo calcolo fornisce l'evoluzione hamiltoniana esatta. Le differenze tra le stime dell'hardware e questo riferimento possono includere il passo di Trotter finito, la statistica di misura e gli errori residui dell'hardware.

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

Traccia un pannello per ciascun sito. Le curve continue mostrano il riferimento esatto ai tempi registrati, e i marcatori mostrano le stime dell'hardware restituite dal 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()

A $t=0$, l'occupazione di spin-up esatta è 1 nel sito 0 e 0 negli altri siti. Man mano che il sistema evolve, l'hopping distribuisce la probabilità della particella lungo la catena. L'occupazione del sito 1 aumenta per prima, seguita dall'aumento dell'occupazione nei siti 2 e 3. Per i parametri di questo esempio, l'ultimo tempo registrato è $t=1.6$. Le occupazioni esatte dei siti da 0 a 3 sono rispettivamente circa 0.026, 0.370, 0.392 e 0.211.

Le occupazioni esatte soddisfano la seguente equazione a ogni istante, a riflesso della conservazione del numero di particelle:

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

Le occupazioni dei singoli siti possono aumentare e diminuire man mano che la particella evolve lungo la catena finita.

Recuperare i messaggi di errore

Se il workload entra nello stato ERROR, chiama job.result() per recuperare il messaggio di errore. Puoi anche ispezionare i log della funzione, se disponibili.

print(job.status())

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

DONE

I problemi comuni di validazione dell'input includono un modello o un metodo di simulazione non supportato, una stringa di stato iniziale troppo lunga, termini e coefficienti dell'osservabile non corrispondenti, oppure un'osservabile che fa riferimento a un sito esterno alla stringa dello stato iniziale.

Ottenere supporto

Per domande sul comportamento di Dynamics Simulator o Fire Opal, consulta la documentazione di Q-CTRL oppure contatta Q-CTRL.

Per l'autenticazione di Qiskit Functions, la gestione dei job o l'accesso a IBM Quantum Platform, consulta la documentazione di Qiskit Functions.

Passaggi successivi

Raccomandazioni

• Consulta il riferimento API di simulate_dynamics per le definizioni sottostanti di modello, simulazione, osservabile, output e validazione.
• Prova il tutorial Dinamica di spin e carica nel modello di Fermi-Hubbard.
• Leggi la panoramica del simulatore di dinamica Fire Opal per maggiori dettagli su Trotterizzazione, mappatura consapevole dell'hardware e soppressione degli errori di Fire Opal.
• Modifica i parametri del modello, lo stato iniziale, il passo temporale, il numero di passi e le osservabili per studiare un diverso problema di dinamica di Fermi-Hubbard unidimensionale.