I-deploy at patakbuhin ang isang Qiskit Function template para sa AQC + Trotter Hamiltonian dynamics

Pangkalahatang-ideya

Ito ay isang experiment-agnostic na Qiskit Function template para sa Hamiltonian dynamics. Kapag binigyan ng 1D nearest-neighbor Pauli Hamiltonian, isang inihandang initial state (opsyonal), at isang set ng mga observable, isinasagawa nito ang Trotter time-evolution, approximate quantum compilation (AQC) circuit compression, at mitigated execution, pagkatapos ay ibinabalik ang time series ng bawat observable. Palitan ang setup (PRE) at ang analysis (POST) at ang parehong core ay magpapatakbo ng ibang eksperimento:

PRE (ang iyong setup)	FUNCTION (na-deploy dito)	POST (ang iyong analysis)
Maghanda ng state, bilang circuit o product state, na may opsyonal na local kick	Trotter synthesis → AQC compression → execution sa statevector, fake, o runtime, na nagbabalik ng $\langle O \rangle(t)$	$S(q, \omega)$ para sa neutron scattering, o magnetization, transport, quench dynamics, at iba pa

Ang template ay nai-publish sa Qiskit Function templates repository, kasama ang iba pang application template. Dine-deploy ito ng notebook na ito sa iyong sariling Qiskit Serverless account. Patakbuhin ito nang isang beses, at anumang notebook ay maaari nang tumawag sa function gamit ang serverless.load("aqc-dynamics-function").

Para sa isang naipatupad na siyentipikong halimbawa, tingnan ang Simulate neutron scattering with an AQC + Trotter dynamics Serverless workflow, na tumatawag sa function na ito para kalkulahin ang dynamical structure factor ng KCuF$_3$. Sa halip, sinasaklaw ng notebook na ito ang deployment at ang input contract.

Mga Kinakailangan

Bago magsimula, tiyakin na mayroon ka ng mga sumusunod sa kernel environment ng notebook na ito:

• Qiskit SDK v2.0 o mas bago (pip install qiskit).

• Ang Qiskit IBM Catalog client (pip install qiskit-ibm-catalog), na nagde-deploy at nagpapatakbo ng mga workload sa Qiskit Serverless.

Ang mga sariling siyentipikong dependency ng function (qiskit-addon-aqc-tensor, cotengrust, qiskit-aer) ay hindi kailangang i-install nang lokal.

Kunin ang mga source file ng template

Ang function ay isang maliit na Python package na pinapatakbo ng Qiskit Serverless sa cloud, kaya kailangang umiral ang source nito bilang mga lokal na file na ina-upload sa oras ng deployment. Ang package ay nai-publish sa Qiskit Function templates repository.

I-download ang source_files

Ang download ay isang solong zip, na pinangalanan ayon sa buong path ng directory sa repository:

qiskit-community qiskit-function-templates main physics aqc_trotter source_files.zip

1. I-unzip ito sa directory na naglalaman ng notebook na ito.

2. Palitan ang pangalan ng na-extract na folder mula sa mahabang pangalang iyon patungong source_files.

Magiging ganito ang hitsura ng iyong working directory:

your-working-directory/
├── function-template-aqc-trotter.ipynb    <- this notebook
└── source_files/                         <- the renamed folder
    ├── __init__.py
    ├── program.py
    └── source/
        ├── __init__.py
        ├── _serverless.py
        ├── app_function.py
        ├── aqc.py
        ├── build.py
        ├── execute.py
        └── hamiltonian.py

Kailangang eksaktong source_files ang pangalan, dahil iyon ang working_dir na ina-upload ng Step 3.

Ang program.py ay ang entry point na tinatawag ng gateway. Ang lahat sa ilalim ng source/ ay ang implementation, na hinati ayon sa stage: Hamiltonian at Trotter synthesis, AQC compression, at execution. Wala sa mga ito ang kailangang i-edit para patakbuhin ang mga halimbawang sumusunod. Ina-upload ng Step 3 ang buong directory, kaya ulitin ang hakbang na iyon tuwing magbabago ka ng file.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-catalog

1. Pag-authenticate

Gamitin ang qiskit-ibm-catalog para mag-authenticate sa QiskitServerless gamit ang iyong API key (token) at CRN (instance), na mahahanap mo sa dashboard ng IBM Quantum® Platform. Gamit ang mga kredensyal na ito, maaari mong i-instantiate ang serverless client nang lokal para mag-upload o magpatakbo ng piniling function:

from qiskit_ibm_catalog import QiskitServerless
serverless = QiskitServerless(channel="ibm_quantum_platform", token="MY_TOKEN", instance="MY_CRN")

Opsyonal mong magamit ang save_account() para i-save ang iyong mga kredensyal sa iyong lokal na environment (tingnan ang gabay na Set up your IBM Cloud® account). Tandaan na isinusulat nito ang iyong mga kredensyal sa parehong file gaya ng QiskitRuntimeService.save_account():

QiskitServerless.save_account(channel="ibm_quantum_platform", token="MY_TOKEN", instance="MY_CRN")

Kung na-save na ang account, hindi na kailangang magbigay ng token para mag-authenticate:

from qiskit_ibm_catalog import QiskitServerless

# Authenticate to the remote cluster
# In this case, loading a saved account
serverless = QiskitServerless()

# REPLACE WITH YOUR OWN CREDENTIALS or SAVED ACCOUNT
# serverless = QiskitServerless(channel="ibm_quantum_platform", token="MY_TOKEN", instance="MY_CRN")

2. Ideklara ang mga dependency

Mga package na kailangan ng function bukod pa sa managed base serverless image.

tala

Ini-install lamang ng gateway ang mga pangalan sa allowlist nito (requirements-dynamic-dependencies.txt), na tinutugma ayon sa pangalan ng package at naka-pin sa pinapayagang bersyon gamit ang ==. Ang anumang iba pa ay dapat dumating nang transitively (bilang dependency ng isang allowlisted na package). Ginagalang ang [extras] syntax: ang qiskit-addon-aqc-tensor[quimb-jax] ang nag-i-install ng quimb at jax. Kailangan ang cotengrust para sa memory efficiency habang sumasagawa ng tensor network simulation. Nakalista nang hiwalay ang qiskit-aer para sa fake backend (local noisy simulation).

DEPENDENCIES = [
    "qiskit-addon-aqc-tensor[quimb-jax]==0.3.1",
    "qiskit-aer==0.17.2",
    "cotengrust==0.2.0",
]

3. I-define at i-upload ang function

from qiskit_ibm_catalog import QiskitFunction

fn = QiskitFunction(
    title="aqc-dynamics-function",
    entrypoint="program.py",
    working_dir="source_files/",
    dependencies=DEPENDENCIES,
)
serverless.upload(fn)

QiskitFunction(aqc-dynamics-function)

4. Beripikahin na na-register ito

next(p for p in serverless.list() if p.title == "aqc-dynamics-function")

QiskitFunction(aqc-dynamics-function)

Reference ng Function

Ito ay isang maikling panimula. Ang bawat field ay kumpletong nadodokumento sa AQC Dynamics Template README: ang kumpletong talahanayan ng mga input kasama ang mga panuntunan sa validation nito, ang mga output field, ang mga execution backend, at karagdagang mga naipatupad na halimbawa. Ang sumusunod ay ang maikling bersyon, sapat para maunawaan ang mga halimbawang susunod.

Mga Input

Ang bawat run ay isang solong fn.run(...) na tawag. Tatlo lamang sa mga input sa talahanayan ang kinakailangan: hamiltonian, t_steps, at aqc_segments. Ang lahat pagkatapos ng mga ito ay opsyonal at babalik sa default na ipinapakita, kaya ang minimal na tawag ay tatlong argumento at ang natitira sa talahanayan ay ang functionality na maaari mong piliing gamitin. Ang num_qubits ng Hamiltonian ang nagtatakda ng haba ng chain, kaya walang hiwalay na input para sa laki.

Input	Default	Paglalarawan
hamiltonian	required	1D nearest-neighbor Pauli Hamiltonian bilang SparsePauliOp. Ang mga string ay Pauli operator, kaya walang implicit na factor na one half.
t_steps	required	Kabuuang Trotter steps. Umuunlad hanggang T = t_steps * dt at nag-uulat ng bawat observable sa bawat t_k = k * dt.
aqc_segments	required	Compression plan: isang listahan ng {"n_steps": k, "ansatz_steps": m}. Ang sum(n_steps) na mga step ay kino-compress; ang natitira ay tatakbo bilang plain Trotter.
dt	0.2	Physical time na umuusad sa bawat isang Trotter step.
initial_state	|0...0>	Isang inihandang QuantumCircuit na e-evolve. Isama ang anumang local kick sa circuit na ito.
observables	per-site Z	Anumang tinatanggap ng EstimatorV2 bilang observables argument nito. Isang observable bawat output column.
trotter_options	2nd-order Suzuki	{"method": ..., "synthesis_settings": {...}}. Ang reps at time ay pag-aari ng function.
aqc_options	tingnan ang paglalarawan	max_bond (32), cutoff (1e-8), autodiff_backend ("jax"), fidelity_target (None), optimizer_settings (L-BFGS-B, jac=True, maxiter=300).
estimator_options	DD, twirling, TREX	EstimatorV2.options, ipinapasa nang as-is. Papalitan nang lubusan ng isang ibinigay na dictionary ang mga default sa halip na pagsamahin ang mga ito.
transpiler_options	{"optimization_level": 3}	generate_preset_pass_manager keyword arguments. Tinatanggihan ang backend at target, dahil pag-aari ng execution path ang mga ito.
backend	"runtime"	"statevector", "fake", o "runtime".
backend_name	pinaka-hindi-busy	Pangalan ng IBM® backend para sa runtime, o isang pinangalanang fake backend.
batches	1	Hatiin ang mga circuit sa N na runtime job. Ang isang batch ay nagsu-submit ng isang solong job at hindi gumagawa ng session.
parallel_sim	False	Ikalat ang mga lokal na simulator path sa lahat ng available na core gamit ang Ray. Walang epekto sa runtime.
return_circuits	False	Ibalik ang logical na AQC + Trotter circuit sa resulta kasama ang observable series.

Mga Execution Backend

Ang tatlong path ay gumagamit ng parehong code at parehong mitigation settings. Nagkakaiba lamang sila sa kung saan tumatakbo ang mga circuit.

backend	Ano ito	Mga Kredensyal	Mga Tala
"statevector"	Eksaktong StatevectorEstimator	Serverless account lamang	Ang eksaktong reference path. Walang QPU time.
"fake"	Noisy na lokal na simulation sa isang Qiskit fake backend	Serverless account lamang	Isang tapat na rehearsal ng mitigated na runtime path. Kailangan ang qiskit-aer. Default sa 127-qubit na fake_sherbrooke.
"runtime" (default)	Ang mitigated na EstimatorV2 laban sa isang tunay na QPU	Serverless account at isang instance na may QPU access	Opsyonal ang backend_name; kapag inalis ito, pinipili ang pinaka-hindi-busy na device.

Ang dalawang simulator path ay tumatawag pa rin sa na-deploy na function, kaya kailangan nila ng na-save na Serverless account kahit hindi sila gumagamit ng QPU time. Ang dalawang halimbawang sumusunod ay nagpapatakbo ng parehong workload sa statevector muna, pagkatapos ay sa runtime.

Resulta

Ang job.result() ay nagbabalik ng plain dictionary:

{
    "times": [...],                  # length t_steps + 1, t_k = k * dt (t=0 is the prepared state)
    "expectation_values": [[...]],   # shape (n_times, n_observables)
    "observable_labels": [...],      # for example: ["Z_0", "ZZ_0_1"]
    "metadata": {
        "n", "t_steps", "dt", "tier",
        "aqc_compressed_steps": 5,   # total compressed steps (= sum of segment n_steps)
        "aqc_segments": [            # per segment: the plan plus its own results
            {"n_steps": 3, "ansatz_steps": 1, "steps": [1, 2, 3], "n_params": 133,
             "fidelities": {"1": ..., "2": ..., "3": ...}},
            {"n_steps": 2, "ansatz_steps": 2, "steps": [4, 5], "n_params": 245,
             "fidelities": {"4": ..., "5": ...}},
        ],
        "execution_backend",
        "aqc_fidelities": {"1": ..., "2": ...},  # flat per-step fidelity, all compressed steps
        "circuit_stats": {           # per-step 2q depth and gate count, full Trotter vs AQC
            "1": {"full_trotter": {"depth_2q": ..., "num_2q_gates": ...},
                "aqc_trotter":  {"depth_2q": ..., "num_2q_gates": ...}},
            "2": {...},
        },
        "warnings": [...],           # non-fatal notices; for example, a cotengrust fallback
        "resource_usage": {          # per stage; QPU_TIME is the charged QPU time
            "RUNNING: OPTIMIZING_FOR_HARDWARE": {"CPU_TIME": ...},
            "RUNNING: WAITING_FOR_QPU": {"CPU_TIME": ...},
            "RUNNING: EXECUTING_QPU": {"QPU_TIME": ...},
        },
    },
    # present only when return_circuits=True
    "circuits": [QuantumCircuit, ...],  # one per evolved step; circuits[i] is at times[i + 1]
}

Ang aqc_fidelities at circuit_stats ang dalawang dapat basahin muna: sama-sama nilang sinasabi sa iyo kung nanatiling tapat ang compression at kung talagang nakatipid ito ng depth. Sa runtime, iniuulat ng resource_usage ang queue wait nang hiwalay sa QPU time na sinisingil sa iyo. Ang isang tinanggihang input ay mabilis na mabibigo bilang isang structured na ServerlessError (code 4615).

Halimbawa ng Simulator

Patakbuhin muna ang function sa eksaktong statevector backend. Hindi ito gumagastos ng QPU time at nagpapatunay ng deployment mula simula hanggang katapusan. Ang modelo dito ay isang eight-qubit na transverse-field Ising chain, at inaalis ang observables kaya sinusukat ng function ang default na per-site $Z$.

Ang compression plan ang input na sulit unawain. Ang bawat segment na {"n_steps": k, "ansatz_steps": m} ay nagko-compress ng k na magkakasunod na Trotter step papunta sa isang ansatz na binuo mula sa isang m-step na Trotter target, at anumang mga step lampas sa sum(n_steps) ay tatakbo bilang plain Trotter. Ang maaga, mababang-entanglement na mga step ay maayos na kino-compress papunta sa isang mababaw na single-layer ansatz; ang mas huling, mas mataas ang entanglement na mga step ay nangangailangan ng mas malalim.

from qiskit.quantum_info import SparsePauliOp

fn = serverless.load("aqc-dynamics-function")

n = 8
H = SparsePauliOp.from_sparse_list(
    [("ZZ", [i, i + 1], 1.0) for i in range(n - 1)]
    + [("X", [i], 0.8) for i in range(n)],
    num_qubits=n,
)

job = fn.run(
    t_steps=8,
    aqc_segments=[
        {
            "n_steps": 4,
            "ansatz_steps": 1,
        },  # early steps -> shallow 1-layer ansatz
        {
            "n_steps": 2,
            "ansatz_steps": 2,
        },  # later steps -> deeper 2-layer ansatz
    ],
    hamiltonian=H,
    aqc_options={"max_bond": 32},
    backend="statevector",
)
print("job ID:", job.job_id)

job ID: ee1f3793-e995-427d-81d1-5924549beb38

Sundan ang Run at Basahin ang Resulta

Iniuulat ng status() ang parehong coarse job lifecycle at ang per-stage sub-status na ipina-publish ng function habang tumatakbo ito. Ang parehong mga stage ay nalalapat sa hardware run mamaya sa gabay na ito:

QUEUED -> INITIALIZING -> RUNNING: OPTIMIZING_FOR_HARDWARE -> RUNNING: WAITING_FOR_QPU -> RUNNING: EXECUTING_QPU -> RUNNING: POST_PROCESSING -> DONE

Value ng status()	Stage
RUNNING: OPTIMIZING_FOR_HARDWARE	paghahanda ng state, pagbuo ng Trotter, AQC compression
RUNNING: WAITING_FOR_QPU	naka-queue sa QPU (runtime backend lamang)
RUNNING: EXECUTING_QPU	isinasagawa ang mga circuit (direktang minamarkahan ito ng mga lokal na simulator)
RUNNING: POST_PROCESSING	binubuo ang result dictionary

Ang mga terminal state ay DONE, ERROR, at CANCELED. Ang statevector run na ito ay walang QPU queue, kaya nilalaktawan nito ang RUNNING: WAITING_FOR_QPU. Gamitin ang job.logs() anumang oras para makita ang per-stage logs, kabilang ang AQC fidelity na naabot sa bawat step.

print(job.status())  # re-run until this reports DONE

DONE

import numpy as np

result = job.result()
ev = np.array(result["expectation_values"])

print("observables:", result["observable_labels"])
print("shape:", ev.shape, "-> (n_times, n_observables)")
print("first row (t = 0, the prepared state):", np.round(ev[0], 4))
print("last row (t = t_steps * dt):", np.round(ev[-1], 4))
print(
    "AQC fidelities:",
    {k: round(v, 4) for k, v in result["metadata"]["aqc_fidelities"].items()},
)

# What the compression bought: 2-qubit depth at the final time step.
stats = result["metadata"]["circuit_stats"][
    str(result["metadata"]["t_steps"])
]
print(
    "2q depth at the final step:",
    stats["full_trotter"]["depth_2q"],
    "(full Trotter) ->",
    stats["aqc_trotter"]["depth_2q"],
    "(AQC + Trotter)",
)

observables: ['Z_0', 'Z_1', 'Z_2', 'Z_3', 'Z_4', 'Z_5', 'Z_6', 'Z_7']
shape: (9, 8) -> (n_times, n_observables)
first row (t = 0, the prepared state): [1. 1. 1. 1. 1. 1. 1. 1.]
last row (t = t_steps * dt): [0.1442 0.2956 0.4686 0.4877 0.4869 0.4686 0.2963 0.1441]
AQC fidelities: {'1': 1.0, '2': 1.0, '3': 1.0, '4': 1.0, '5': 1.0, '6': 0.9999}
2q depth at the final step: 210 (full Trotter) -> 79 (AQC + Trotter)

Halimbawa ng Hardware

Ang isang function call na may backend="runtime" ay nagta-transpile at nagsasagawa sa isang tunay na IBM Quantum processor, gamit ang built-in error mitigation ng function: dynamical decoupling (XY4), gate twirling, at twirled readout error extinction (TREX). Pinipili ng backend_name ang device; alisin ito at kukunin ng function ang pinaka-hindi-busy na isa.

Walang nagbabago sa science code. Ang naiiba mula sa simulator example ay ang haba ng chain, ang bilang ng Trotter steps, ang compression plan, ang backend, at ang mga explicit na mitigation setting na sinasaklaw sa sumusunod na seksyon.

Pagsukat sa Laki ng Job para sa Control Hardware

Ang estimator_options ang input na sulit itakda nang sinasadya. Bumubuo ang gate twirling ng num_randomizations na hiwalay na randomized circuit para sa bawat PUB, at ang buong job, bawat PUB kasama ang lahat ng randomizations nito, ay kailangang magkasya sa instruction memory ng classical control system ng QPU. Bilang default, 1000 randomizations ang ginagamit ng function, kaya ang isang 10-step na evolution ay nagsu-submit ng 11 PUB na tig-1000 circuit bawat isa: humigit-kumulang 11,000 circuit instance sa isang solong job.

Kapag lumampas sa hawak ng control system, mabibigo ang job na may error 6073. Ibinibigay ng Job limits ang mga threshold at kung paano bibilangin laban sa mga ito, ang pangunahin ay 26.8 milyong control-system instruction bawat qubit, na inilalapat kada job sa halip na kada PUB. Ang dynamical decoupling ay nagdaragdag ng mga gate na binibilang dito.

Dalawang input ang kumokontrol sa laki:

• Itinatakda ng estimator_options ang shot budget. Ang kabuuang shots ay num_randomizations * shots_per_randomization, kaya maaari mong ipagpalit ang randomizations laban sa shots per randomization, panatilihin ang statistics, at bawasan pa rin ang program. Gumagamit ang sumusunod na cell ng 100 randomizations sa 200 shots bawat isa, na 20,000 shots bawat observable at humigit-kumulang isang ikasampu ng circuit instances na isu-submit ng mga default. Tingnan ang TwirlingOptions at Estimator options para sa kumpletong set ng mga field.

• Hinahati ng batches ang mga PUB sa ganoong dami ng magkakahiwalay na runtime job, na siyang remedyo na iminumungkahi mismo ng error 6073 at kung bakit mahalaga ang per-job na pagbabalangkas. Ang pagtakda ng batches=4 ay nagpapadala ng humigit-kumulang tatlong PUB bawat job sa halip na labing-isa nang sabay-sabay, at lumalabas nang magkasama ang mga job sa isang batch kaya minsan lang naka-queue ang grupo sa halip na hiwalay na naka-queue ang bawat job.

Tandaan na ang isang ibinigay na estimator_options ay lubusang pumapalit sa mga default ng function sa halip na pagsamahin sa mga ito, kaya muling isinaad ang dynamical decoupling at TREX sa sumusunod na cell para mapanatili itong naka-on.

from qiskit.quantum_info import SparsePauliOp

fn = serverless.load("aqc-dynamics-function")

n = 10
H = SparsePauliOp.from_sparse_list(
    [("ZZ", [i, i + 1], 1.0) for i in range(n - 1)]
    + [("X", [i], 0.8) for i in range(n)],
    num_qubits=n,
)

job = fn.run(
    t_steps=10,
    aqc_segments=[
        {
            "n_steps": 3,
            "ansatz_steps": 1,
        },  # early steps -> shallow 1-layer ansatz
        {
            "n_steps": 3,
            "ansatz_steps": 2,
        },  # later steps -> deeper 2-layer ansatz
    ],
    hamiltonian=H,
    aqc_options={"max_bond": 32},
    backend="runtime",
    backend_name="ibm_marrakesh",
    # The function defaults to 1000 twirling randomizations, which was too large
    # for this device. Total shots is num_randomizations *
    # shots_per_randomization, so this is 20,000 shots per observable.
    estimator_options={
        "dynamical_decoupling": {"enable": True, "sequence_type": "XY4"},
        "twirling": {
            "enable_gates": True,
            "num_randomizations": 100,
            "shots_per_randomization": 200,
        },
        "resilience": {"measure_mitigation": True},
    },
)
print("job ID (save this to reconnect later):", job.job_id)

job ID (save this to reconnect later): 7229a8bf-9f83-4785-8dd4-489844abc2d9

Muling pagkonekta sa mahabang tumatakbong job

Ang isang hardware run ay hindi mabilis, at karamihan sa oras ay classical sa halip na nasa QPU. Ang AQC compression ay tumatakbo sa loob ng function bago may maabot sa QPU, at ang QPU queue ay dagdag pa dito. Hindi mo kailangang panatilihing bukas ang notebook o kernel na ito habang tumatakbo ito.

Kopyahin ang job ID na naka-print ng nakaraang cell at i-save ito. Ang susunod na tatlong cell ay nagbibigay-daan sa iyong bumalik sa run mamaya:

1. Muling kumonekta, kailangan lamang sa isang bagong kernel session: patakbuhin muli ang Authentication cell para muling likhain ang serverless, pagkatapos ay muling buuin ang job handle mula sa ID na na-save mo. Laktawan ang cell na ito kung nasa session ka pa rin kung saan ka nag-submit, dahil live na ang handle.

2. Suriin ang status: patakbuhin muli hanggang mag-ulat ito ng DONE.

3. Kunin ang resulta: patakbuhin lamang kapag DONE na ang status.

I-paste ang iyong na-save na ID sa ibabaw ng placeholder sa sumusunod na reconnect cell.

# Reconnect to a previously submitted job by its ID. Only needed in a NEW kernel
# session; if you are still in the session where you submitted, the `job` handle
# from the preceding cell is already live, so skip this cell. Replace the ID that follows with your own.
job = serverless.get_job_by_id("<your job ID>")

# Re-run this until it reports DONE, then fetch the result in the following cell.
print(job.status())

DONE

import numpy as np

# Run this only once the preceding status cell reports DONE. result() blocks until
# the job finishes, so calling it earlier just waits.
result = job.result()
ev = np.array(result["expectation_values"])

print("backend:", result["metadata"]["execution_backend"])
print("shape:", ev.shape, "-> (n_times, n_observables)")
print("last row (t = t_steps * dt):", np.round(ev[-1], 4))
print(
    "AQC fidelities:",
    {k: round(v, 4) for k, v in result["metadata"]["aqc_fidelities"].items()},
)

# What the compression bought: 2-qubit depth at the final time step.
stats = result["metadata"]["circuit_stats"][
    str(result["metadata"]["t_steps"])
]
print(
    "2q depth at the final step:",
    stats["full_trotter"]["depth_2q"],
    "(full Trotter) ->",
    stats["aqc_trotter"]["depth_2q"],
    "(AQC + Trotter)",
)

backend: runtime
shape: (11, 10) -> (n_times, n_observables)
last row (t = t_steps * dt): [0.1504 0.1361 0.218  0.2144 0.2275 0.1783 0.1749 0.1599 0.0915 0.0922]
AQC fidelities: {'1': 1.0, '2': 1.0, '3': 1.0, '4': 1.0, '5': 0.9999, '6': 0.9999}
2q depth at the final step: 342 (full Trotter) -> 171 (AQC + Trotter)

Mga Susunod na Hakbang

Mga rekomendasyon

• Sundan ang Simulate neutron scattering with an AQC + Trotter dynamics Serverless workflow, ang kasamang halimbawa na tumatawag sa na-deploy na function na ito para kalkulahin ang dynamical structure factor ng KCuF$_3$.

• Basahin ang AQC Dynamics Template on GitHub para sa kumpletong input at output contract, karagdagang mga halimbawa, at mga detalye ng citation.

• Mag-browse sa Qiskit Function templates repository para sa iba pang application template na ginawa sa parehong paraan.

• Basahin ang Qiskit Serverless guide para sa pamamahala ng mga na-deploy na function.

• Mas alamin pa nang mas malalim ang AQC compression stage gamit ang dokumentasyon ng Qiskit addon: AQC-Tensor.