Dynamics Simulator - פונקציית Qiskit של Q-CTRL Fire Opal

ראה את מקור ה-API.

הערה

Qiskit Functions הן תכונה ניסיונית הזמינה רק למשתמשים בתוכניות IBM Quantum® Premium Plan, Flex Plan ו-On-Prem (דרך IBM Quantum Platform API). הן בסטטוס גרסת תצוגה מקדימה ועשויות להשתנות.

סקירה

ה-Dynamics Simulator של Q-CTRL היא Qiskit Function מסוג application לסימולציה של התפתחות בזמן של מודלי רב-גופים קוונטיים נתמכים על חומרת IBM Quantum. במקום לבנות מעגלים קוונטיים בעצמך, אתה מציין את המודל הפיזיקלי, את המצב ההתחלתי, את פרמטרי ההתפתחות בזמן ואת ה-observables למדידה.

הפונקציה בונה ומריצה את המעגלים הדינמיים הנדרשים ומחילה את תהליך האופטימיזציה ודיכוי השגיאות המודע לחומרה של Fire Opal. התוצאה היא עקבת זמן של ערכי תוחלת עבור ה-observables שביקשת. מכיוון שהפונקציה מחילה דיכוי שגיאות אוטומטית, אפשר להריץ מעגלים בעומקי שיא ועדיין לראות אותות משמעותיים. ה-Dynamics Simulator מספק דיוק פתרון שתואם את הכלים הקלאסיים המתקדמים הקיימים ונותן יתרון מוכח במהירות.

בבדיקות בעולם האמיתי הושגה התאמה בתוך שגיאת שורש ממוצע הריבועים (RMSE) של 1% בהשוואה לסימולציות tensor-network קלאסיות ברזולוציה הגבוהה ביותר. בדיקות עצמאיות מקהילת המחקר אימתו שהמחשב הקוונטי נשאר מדויק גם מעבר להדגמות הראשונות של Q-CTRL.

מבחני ביצועים

מספר האתרים קובע כמה Qubits נדרשים, ואילו מספר צעדי Trotter קובע את עומק מעגלי ההתפתחות בזמן. כל אתר סריג משתמש בשני Qubits כדי לייצג את האכלוסיות של ספין מעלה וספין מטה.

תהליך העבודה הזה הודגם עבור שרשראות של 60 אתרים (120 Qubits) עם 30 צעדי Trotter, ועבור שרשראות של 31 אתרים (62 Qubits) עם 90 צעדי Trotter. הטבלה שלהלן מציגה את משאבי המעגל וזמני הביצוע על QPU מתוך הניסויים שדווחו, שבוצעו על התקן IBM® Heron r3 (ibm_boston) עם 20,000 shots לכל מעגל.

גודל המערכת	צעדי Trotter	עומק דו-Qubit	מספר שערים דו-Qubit	זמן QPU	זמן QPU עם REM + DR
10 אתרים (20 Qubits)	30	152	1,457	2m 46s	4m 25s
10 אתרים (20 Qubits)	60	302	2,897	5m 36s	8m 42s
10 אתרים (20 Qubits)	90	452	4,337	8m 46s	13m 26s
31 אתרים (62 Qubits)	30	152	4,649	2m 46s	4m 25s
31 אתרים (62 Qubits)	60	302	9,239	5m 36s	8m 42s
31 אתרים (62 Qubits)	90	452	13,829	8m 46s	13m 26s
60 אתרים (120 Qubits)	30	152	9,057	2m 46s	4m 25s

עבור מספר קבוע של צעדי Trotter, עומק המעגל וזמן ה-QPU שדווחו נשארים זהים בגדלי המערכת שנבדקו, בעוד שמספר השערים הדו-Qubit גדל. הגדלת מספר הצעדים מייצרת מעגלים עמוקים יותר ודורשת יותר זמן QPU.

כאן, זמן QPU הוא זמן הביצוע המצטבר על החומרה עבור מעגלי הסימולציה הראשיים. העמודה האחרונה כוללת גם את זמן ה-QPU של אפיון הרעש שמשמש להפחתת שגיאות קריאה (REM) ולהתאוששות מדעיכה (DR). המדריך הזה משתמש בדוגמה קטנה של Fermi-Hubbard חד-ממדי כדי להראות את תהליך העבודה המלא, מהגדרת המודל ועד שרטוט הדינמיקה שנמדדה.

תיאור הפונקציה

דינמיקה קוונטית מתארת איך מערכת קוונטית משתנה עם הזמן. חקר ההתפתחות הזו עוזר להבין איך חלקיקים נעים, איך מתפתחים מתאמים, ואיך מערכת מגיבה לשינוי במצב שלה או ב-Hamiltonian שלה.

מודל Fermi-Hubbard מתאר פרמיונים שנעים בין אתרי סריג ומקיימים אינטראקציה כשהם תופסים את אותו אתר. התחרות בין דילוג לאינטראקציות הופכת אותו למודל שימושי לחקר אלקטרונים בעלי מתאמים חזקים. ההתפתחות בזמן שלו יכולה לחשוף איך ספין ומטען מתפשטים, ואיך מערכת מסודרת בתחילה מתרפה.

מודל

ה-Dynamics Simulator תומך בשרשרת Fermi-Hubbard חד-ממדית עם גבולות פתוחים. עבור שרשרת של $L$ אתרים, ה-Hamiltonian מוגדר כך:

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

כאן, $c^\dagger_{i\sigma}$ ו-$c_{i\sigma}$ יוצרים ומשמידים פרמיון עם ספין $\sigma$ באתר $i$. אופרטור המספר $n_{i\sigma}=c^\dagger_{i\sigma}c_{i\sigma}$ מודד את האכלוס של אורביטל הספין הזה.

קלטי המודל מציינים את המקדמים הבאים:

• hopping_amplitude: $t_{h,i}$, ששולט בדילוג בין אתרים שכנים $i$ ו-$i+1$.

• on_site_interaction: $U_i$, האינטראקציה בין פרמיונים עם ספין מעלה לספין מטה שתופסים את אותו אתר.

• chemical_potential: $\mu_i$, הפוטנציאל הכימי המקומי, שנכנס ל-Hamiltonian עם סימן מינוס.

ספק סקלר כדי להשתמש באותו מקדם לאורך כל השרשרת, או רשימה כדי לציין מקדמים לקשרים או לאתרים בודדים.

ביחידות שבהן $\hbar=1$, המצב ההתחלתי מתפתח כך:

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

הפונקציה מעריכה את ערכי התוחלת של ה-observables שציינת בזמני סימולציה עוקבים.

תהליך העבודה

תהליך העבודה של הפונקציה כולל את השלבים הבאים:

1. סינתזה אלגוריתמית: הפונקציה משתמשת בהגדרות ה-Hamiltonian וזמן הסימולציה כדי לבנות רצף Trotter-Suzuki מותאם, שמקטין את עומק המעגל תוך התחשבות בדיוק הסימולציה.

2. מיפוי מודע לחומרה: הפונקציה ממפה ומנתבת את המעגלים באמצעות הקישוריות ומאפייני השגיאה של ה-Backend של IBM Quantum שנבחר.

3. דיכוי שגיאות בשכבה הפיזית: Fire Opal משלבת dynamical decoupling ותיקונים ברמת הפולסים כדי לדכא רעש מהסביבה ו-crosstalk במהלך הביצוע על החומרה.

הפונקציה מנהלת את השלבים האלה אוטומטית ומחזירה את ערכי התוחלת של ה-observables המבוקשים לאורך הזמן.

אתה מגדיר את הבעיה הפיזיקלית ואת הגדרות הסימולציה דרך קלטי הפונקציה. הממשק הנוכחי תומך בהתפתחות בזמן של Trotter, כאשר time_step קובע את משך כל צעד ו-step_count קובע את מספר הצעדים.

לפרטים נוספים, ראה את סקירת ה-dynamics simulator של Fire Opal ואת מקור ה-API של simulate_dynamics.

תחילת העבודה

מידע על גישה ל-Qiskit Function הזו נמצא ב-Qiskit Functions Catalog.

המדריך הזה מראה איך לטעון את ה-Dynamics Simulator ולהריץ סימולציה של שרשרת Fermi-Hubbard בת ארבעה אתרים. הקוד הבא מניח ששמרת כבר את מפתח ה-API של IBM Quantum Platform ואת ה-CRN של ה-instance בסביבה המקומית שלך.

להוראות הגדרת חשבון והתקנת הלקוח, ראה תחילת העבודה עם 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")

דוגמה: סימולציה של שרשרת Fermi-Hubbard בת ארבעה אתרים

נתבונן בשרשרת Fermi-Hubbard חד-ממדית בת ארבעה אתרים עם משרעת דילוג $t_h=1$, בלי אינטראקציה באתר ובפוטנציאל כימי אפס. פרמיון יחיד עם ספין מעלה מתחיל באתר 0 ומתפתח לאורך השרשרת.

הבעיה הקטנה הזו שומרת על המיקוד בתהליך העבודה של ה-Dynamics Simulator:

1. הגדר את המודל והסימולציה.

2. הגדר את המצב ההתחלתי ואת ה-observables.

3. שלח את ה-job של Qiskit Function.

4. אחזר את ערכי התוחלת.

5. שרטטו את הדינמיקה.

1. הגדרת הבעיה

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

רשימת ה-observables מודדת את התפוסה של spin-up

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

בכל אתר. ה-observables מוחזרים באותו סדר שבו סיפקתם אותם.

2. הרצת סימולציית הדינמיקה

שלחו את הבעיה דרך ה-Qiskit Function. ה-Qiskit Functions Catalog מטפל באימות של IBM Quantum, ולכן אין צורך להעביר ל-sim_qf.run() פרטי גישה נפרדים של Fire Opal או של ספק חומרה.

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

האובייקט שמוחזר הוא job של Qiskit Function. אפשר לשמור את מזהה ה-job כדי לאחזר או לבדוק את עומס העבודה מאוחר יותר.

3. אחזור התוצאה

result = job.result()

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

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

המירו את ערכי התצפית של ה-observables למערך NumPy. כל שורה מתאימה ל-observable אחד, וכל עמודה מתאימה לזמן סימולציה שנרשם, החל מ-$t=0$. בדוגמה הזו, ארבע השורות מכילות את תפוסות ה-spin-up של אתרים 0 עד 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. הצגה חזותית של הדינמיקה

המצבההתחלתי מכיל פרמיון אחד עם spin-up ואף פרמיון עם spin-down. לכן ההתפתחות שלו נשארת בתת-המרחב של חלקיק יחיד, שארבעת מצבי הבסיס שלו מתאימים לכך שהפרמיון נמצא באתר 0, 1, 2 או 3.

בתת-המרחב הזה ההמילטוניאן מחבר אתרים שכנים באמפליטודת קפיצה $-t_h$. עבור הפרמטרים שבהם משתמשים כאן,

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

בצעו לכסון של המטריצה הזו עם NumPy והתפתחו את המצב ההתחלתי באותם זמנים שהוחזרו מ-Dynamics Simulator. הגודל בריבוע של כל אמפליטודה של מצב נותן את תפוסת ה-spin-up של האתר המתאים.

החישוב הזה נותן התפתחות המילטוניאנית מדויקת. ההבדלים בין האומדנים מהחומרה לבין ייחוס זה יכולים לנבוע מצעד Trotter סופי, מסטטיסטיקת המדידה ומשגיאות חומרה שנותרו.

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

שרטטו פאנל אחד לכל אתר. העקומות המלאות מראות את הייחוס המדויק בזמנים שנרשמו, והסמנים מראים את האומדנים מהחומרה שהוחזרו מ-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()

ב-$t=0$, תפוסת ה-spin-up המדויקת היא 1 באתר 0 ו-0 בשאר האתרים. ככל שהמערכת מתפתחת, הקפיצות מפזרות את ההסתברות של החלקיק לאורך השרשרת. התפוסה של אתר 1 עולה ראשונה, ואחריה עולה התפוסה באתרים 2 ו-3. עבור הפרמטרים בדוגמה הזו, הזמן האחרון שנרשם הוא $t=1.6$. התפוסות המדויקות של אתרים 0 עד 3 הן בקירוב 0.026, 0.370, 0.392 ו-0.211, בהתאמה.

התפוסות המדויקות מקיימות את המשוואה הבאה בכל זמן, כביטוי לשימור מספר החלקיקים:

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

תפוסות של אתרים בודדים יכולות לעלות ולרדת בזמן שהחלקיק מתפתח לאורך השרשרת הסופית.

אחזור הודעות שגיאה

אם עומס העבודה נכנס למצב ERROR, קראו ל-job.result() כדי לאחזר את הודעת השגיאה. אפשר גם לבדוק את הלוגים של הפונקציה, אם הם זמינים.

print(job.status())

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

DONE

בעיות נפוצות באימות קלט כוללות מודל או שיטת סימולציה שאינם נתמכים, מחרוזת מצב התחלתי ארוכה מדי, אי-התאמה בין איברי ה-observable למקדמים שלהם, או observable שמפנה לאתר שנמצא מחוץ למחרוזת המצב ההתחלתי.

קבלת תמיכה

לשאלות על Dynamics Simulator או על ההתנהגות של Fire Opal, עיינו בתיעוד של Q-CTRL או צרו קשר עם Q-CTRL.

לנושאי אימות ב-Qiskit Functions, ניהול jobs או גישה ל-IBM Quantum Platform, עיינו בתיעוד של Qiskit Functions.

השלבים הבאים

המלצות

• עיינו במדריך ה-API של simulate_dynamics להגדרות של המודל, הסימולציה, ה-observables, הפלט והאימות.
• נסו את המדריך דינמיקה של spin ומטען במודל Fermi-Hubbard.
• קראו את סקירת הסימולטור הדינמי של Fire Opal לפרטים נוספים על Trotterization, מיפוי מודע-חומרה והדחקת שגיאות של Fire Opal.
• שנו את פרמטרי המודל, המצב ההתחלתי, צעד הזמן, מספר הצעדים וה-observables כדי לחקור בעיית דינמיקה חד-ממדית אחרת של Fermi-Hubbard.