Formula multi-produk untuk mengurangi kesalahan Trotter

Perkiraan penggunaan: Empat menit pada prosesor Heron r2 (CATATAN: Ini hanya perkiraan. Waktu aktual kamu bisa berbeda.)

Hasil pembelajaran

Bagaimana multi-product formulas (MPF) mengurangi error Trotter dalam simulasi Hamiltonian dengan menggabungkan nilai ekspektasi dari beberapa sirkuit dangkal
Kapan MPF menguntungkan dibanding product formula standar dan kapan bukan alat yang tepat
Cara menghitung koefisien MPF statis dan dinamis menggunakan paket qiskit_addon_mpf
Cara mengeksekusi alur kerja MPF end-to-end pada hardware IBM Quantum®, termasuk transpilasi, mitigasi error, dan post-processing

Prasyarat

Metode kompilasi untuk sirkuit simulasi Hamiltonian — memperkenalkan sirkuit Trotter (product formula) dalam Qiskit.
Product formula dalam Qiskit, khususnya kelas sintesis SuzukiTrotter dan LieTrotter.
Primitif Qiskit dan antarmuka Estimator.

Latar Belakang

Apa itu multi-product formulas?

Saat mensimulasikan sistem kuantum pada komputer kuantum, tugas utamanya adalah mengaproksimasi operator evolusi-waktu $e^{-iHt}$ untuk Hamiltonian $H$ . Pendekatan standar menggunakan product formulas (PF), juga dikenal sebagai dekomposisi Trotter-Suzuki. Ini menguraikan $H = \sum_{a=1}^d F_a$ menjadi suku-suku yang unitary individualnya $e^{-iF_a t}$ efisien untuk diimplementasikan, lalu mengaproksimasi evolusi penuh sebagai produk terurut dari unitary-unitary yang lebih sederhana ini.

Product formula orde-pertama (Lie-Trotter) adalah:

S_1(t) := \prod_{a=1}^d e^{-i F_a t},

yang menimbulkan error kuadratik: $S_1(t) = e^{-iHt} + \mathcal{O}(t^2)$ . Formula simetrik orde-lebih-tinggi $S_{2\chi}(t)$ , di mana $\chi$ melabeli orde dari product formula simetrik (lihat Ref. [1]), konvergen lebih cepat sebagai $e^{-iHt} + \mathcal{O}(t^{2\chi+1})$ , tapi dengan biaya sirkuit yang lebih dalam per langkah.

Untuk mengurangi error pada orde $\chi$ yang tetap, biasanya seseorang membagi total waktu evolusi $t$ menjadi $k$ langkah Trotter yang lebih kecil. Setiap langkah mengaproksimasi $e^{-iHt/k}$ dengan product formula dan langkah-langkahnya digabungkan berurutan:

e^{-iHt} \approx \left[S_{2\chi}(t/k)\right]^k.

Untuk formula simetrik orde- $2\chi$ , error Trotter residual kemudian berskala sebagai $\mathcal{O}\!\left(t^{2\chi+1} / k^{2\chi}\right)$ . Jadi meningkatkan $k$ dengan cepat menekan error Trotter — tapi juga secara linear memperdalam sirkuit, dan pada hardware ber-noise itu berarti lebih banyak akumulasi noise gate. Ketegangan antara error Trotter (menguntungkan $k$ lebih besar) dan noise hardware (menguntungkan $k$ lebih kecil) inilah yang persis dirancang untuk diselesaikan oleh multi-product formula. Perhatikan bahwa MPF adalah tentang menggabungkan hasil dari pilihan $k$ yang berbeda-beda pada orde $\chi$ yang tetap — mereka tidak mengubah orde dari product formula yang mendasarinya.

Multi-product formulas (MPF) [1] membangun kombinasi linear berbobot dari nilai ekspektasi yang diperoleh dari beberapa sirkuit Trotter yang lebih dangkal, masing-masing menggunakan jumlah langkah Trotter yang berbeda $k_1, k_2, \ldots, k_r$ (sekumpulan $r$ jumlah langkah):

\langle A \rangle_{\text{MPF}}(t) = \sum_{j=1}^r x_j \, \langle A \rangle_{k_j}(t),

di mana $\langle A \rangle_{k_j}(t)$ adalah nilai ekspektasi dari observabel $A$ pada waktu $t$ yang diestimasi dari sirkuit Trotter dengan $k_j$ langkah, dan koefisien $\{x_j\}_{j=1}^r$ dipilih sehingga suku-suku error Trotter yang dominan dalam kombinasi tersebut saling meniadakan. Kita akan meninjau kembali ekspresi ini di Langkah 4, di mana kita mengevaluasinya secara eksplisit untuk menggabungkan hasil-hasil Trotter kita. Poin praktis utamanya adalah sirkuit terdalam dalam MPF hanya membutuhkan $k_{\max}$ langkah, yang jauh lebih kecil daripada $k$ tunggal yang dibutuhkan untuk mencapai error Trotter efektif yang sama secara langsung. Sirkuit yang lebih dangkal membuat pendekatan MPF lebih cocok untuk hardware ber-noise.

Bagaimana koefisien-koefisien ditentukan?

Ada dua keluarga koefisien MPF:

Koefisien statis tidak bergantung pada Hamiltonian, state awal, dan waktu evolusi. Koefisien ini ditemukan dengan menyelesaikan sistem linear $Ax = b$ yang memaksakan peniadaan suku-suku error Trotter yang dominan. Untuk sekumpulan langkah Trotter $\{k_j\}_{j=1}^r$ yang digunakan dengan product formula simetrik orde- $2\chi$ , mengekspansi error Trotter dalam pangkat invers $k_j$ menghasilkan persamaan kendala berbentuk:

\sum_{j=1}^r x_j = 1, \quad \sum_{j=1}^r \frac{x_j}{k_j^{\eta_n}} = 0 \quad (n = 0, \ldots, r-2),

di mana eksponen bilangan bulat $\{\eta_n\}$ adalah orde dari suku-suku error Trotter yang berurutan untuk product formula yang dipilih. Untuk PF simetrik orde- $2\chi$ , error dominan dalam $\left[S_{2\chi}(t/k)\right]^k$ berskala sebagai $1/k^{2\chi}$ , dengan koreksi selanjutnya pada $1/k^{2\chi+2}, 1/k^{2\chi+4}, \ldots$ — sehingga eksponennya adalah $\eta_n = 2\chi + 2n$ . Untuk PF non-simetrik, baik pangkat ganjil maupun genap berkontribusi dan $\eta_n = 2\chi + n$ . Lihat Ref. [1] untuk derivasi lengkapnya. Persamaan pertama dalam sistem di atas memastikan ketidak-biasan (MPF mereproduksi nilai ekspektasi eksak pada limit $k_j \to \infty$ ), dan $r-1$ persamaan yang tersisa secara berurutan meniadakan $r-1$ suku error Trotter pertama. Ketika norma- $L_1$ $\|x\|_1$ yang dihasilkan terlalu besar (yang memperkuat noise sampling), kamu bisa sebagai gantinya menyelesaikan optimisasi aproksimasi yang membatasi $\|x\|_1$ sambil meminimalkan $\|Ax - b\|$ .

Koefisien dinamis [2], [3] tambahannya bergantung pada Hamiltonian, state awal, dan waktu evolusi $t$ . Koefisien ini meminimalkan jarak norma-Frobenius antara state yang terevolusi-waktu sebenarnya dan aproksimasi MPF:

\|\rho(t) - \mu^D(t)\|_F^2 = 1 + \sum_{i,j} M_{ij}(t)\, x_i(t)\, x_j(t) - 2\sum_i L_i(t)\, x_i(t),

di mana $M_{ij}(t) = \mathrm{Tr}[\rho_{k_i}(t)\,\rho_{k_j}(t)]$ adalah matriks Gram dari overlap antara state-state yang terevolusi-Trotter untuk jumlah langkah $k_i, k_j$ yang berbeda, dan $L_i(t) = \mathrm{Tr}[\rho(t)\,\rho_{k_i}(t)]$ mengukur overlap dengan state eksak (aproksimasi). Dalam tutorial ini, besaran-besaran tersebut dihitung secara efisien menggunakan metode tensor-network, khususnya backend berbasis TeNPy dalam qiskit_addon_mpf.

Kapan menggunakan MPF

MPF paling menguntungkan ketika:

Kedalaman sirkuit menjadi hambatan. Jika noise hardware membatasi kedalaman yang bisa kamu jalankan, gunakan MPF untuk mencapai akurasi Trotter efektif yang lebih tinggi dari sirkuit yang lebih dangkal.
Kamu membutuhkan nilai ekspektasi yang akurat, bukan persiapan state penuh. MPF beroperasi pada level nilai ekspektasi — mereka menggabungkan angka klasik, bukan state kuantum. Karena itu MPF ideal untuk estimasi observabel saat menggunakan primitif Estimator.
Kamu menggabungkan jumlah langkah Trotter yang sedang. Biasanya menggabungkan $r = 3$ – $5$ jumlah langkah $k_j$ yang berbeda sudah cukup untuk meniadakan beberapa suku error Trotter yang dominan sambil menjaga $\|x\|_1$ tetap terkendali.

Kapan MPF mungkin tidak membantu

Waktu evolusi yang sangat singkat. Ketika $t$ cukup kecil sehingga satu formula Trotter orde-rendah saja sudah akurat, overhead menjalankan beberapa sirkuit tidak diperlukan.
Tugas persiapan-state. MPF menghasilkan nilai ekspektasi yang terkoreksi, bukan state kuantum yang terkoreksi. Jika kamu membutuhkan state yang benar-benar terevolusi-waktu (misalnya, sebagai input untuk subrutin kuantum lain), MPF tidak berlaku.
Jumlah langkah Trotter yang melanggar rezim konvergensi. Derivasi koefisien statis mengekspansi setiap $\left[S_{2\chi}(t/k_j)\right]^{k_j}$ individual sebagai deret dalam $t/k_j$ ; ekspansi ini hanya konvergen dengan baik ketika $t/k_{\min} \lesssim 1$ . Jika $k_{\min}$ dipilih terlalu kecil untuk $t$ yang diberikan, sirkuit paling dangkal berada jauh di luar rezim perturbatif, suku-suku error orde-lebih-tinggi yang dibiarkan MPF tidak teniadakan menjadi besar, dan peniadaannya bisa membutuhkan koefisien yang besar. Norma- $L_1$ $\|x\|_1$ adalah diagnostik praktisnya: ketika $\|x\|_1 \gg 1$ , overhead sampling $\propto \|x\|_1^2$ mungkin melebihi pengurangan error Trotter. Lihat panduan tentang memilih langkah Trotter untuk detailnya.

Apa yang dibahas tutorial ini

Tutorial ini memandu melalui alur kerja MPF end-to-end dalam dua tahap. Pertama, sebuah contoh simulator skala-kecil (rantai Heisenberg 10-qubit) mendemonstrasikan cara menyiapkan masalah, menghitung koefisien MPF statis dan dinamis, dan membandingkan nilai ekspektasi yang dihasilkan terhadap diagonalisasi eksak. Kemudian, sebuah contoh hardware skala-besar (rantai XXZ 50-qubit) menunjukkan cara transpilasi, eksekusi pada hardware IBM Quantum dengan mitigasi error, dan post-process hasil menggunakan koefisien MPF. Sepanjang tutorial, kita menggunakan paket qiskit_addon_mpf bersama alat-alat Qiskit standar.

Persyaratan

Sebelum memulai tutorial ini, pastikan kamu sudah menginstal hal-hal berikut:

Qiskit SDK v2.0 atau lebih baru, dengan dukungan visualisasi
Qiskit Runtime v0.22 atau lebih baru (pip install qiskit-ibm-runtime)
Simulator Qiskit Aer (pip install qiskit-aer)
MPF Qiskit addon dengan backend TeNPy (pip install "qiskit-addon-mpf[tenpy]")
Utilitas addon Qiskit (pip install qiskit-addon-utils)
SciPy (pip install scipy)

Persiapan

Di bawah ini kami mengumpulkan semua impor paket yang digunakan sepanjang tutorial ini dalam satu sel. Kami juga mendefinisikan pass transpiler CollectAndCollapse yang menggabungkan rotasi rxx dan ryy yang berdekatan menjadi satu XXPlusYYGate. Pass ini diterapkan baik selama konstruksi sirkuit di Langkah 1 (untuk menjaga jumlah gate tetap rendah) maupun secara tidak langsung saat kita mengekstrak struktur berlapis untuk MPF dinamis di Langkah 4 (TeNPy mengharapkan gate dua-qubit, bukan pasangan rotasi yang belum digabungkan).

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit qiskit-addon-mpf qiskit-addon-utils qiskit-aer qiskit-ibm-runtime scipy

import warnings

import numpy as np
import matplotlib.pyplot as plt
from functools import partial
from copy import deepcopy

from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli, SparsePauliOp, Statevector
from qiskit.synthesis import SuzukiTrotter
from qiskit.transpiler import CouplingMap, PassManager
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.circuit.library import XXPlusYYGate
from qiskit.transpiler.passes.optimization.collect_and_collapse import (
    CollectAndCollapse,
    collect_using_filter_function,
    collapse_to_operation,
)

from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import EstimatorV2 as Estimator, QiskitRuntimeService

from qiskit_addon_utils.problem_generators import (
    generate_xyz_hamiltonian,
    generate_time_evolution_circuit,
)
from qiskit_addon_utils.slicing import slice_by_depth
from qiskit_addon_mpf.static import setup_static_lse
from qiskit_addon_mpf.dynamic import setup_dynamic_lse
from qiskit_addon_mpf.costs import (
    setup_exact_problem,
    setup_sum_of_squares_problem,
    setup_frobenius_problem,
)
from qiskit_addon_mpf.backends.tenpy_layers import (
    LayerModel,
    LayerwiseEvolver,
)
from qiskit_addon_mpf.backends.tenpy_tebd import MPOState, MPS_neel_state

from scipy.linalg import expm

# Suppress TeNPy's `unit_cell_width` future-API warning. The default
# (`unit_cell_width=len(sites)`) is correct for Chain lattices, which is what
# `CouplingMap.from_line(...)` produces here, so the warning is informational.
warnings.filterwarnings(
    "ignore",
    message=r".*unit_cell_width.*",
    category=UserWarning,
)

# --- Helper: collect XX + YY rotations into a single gate ---
def filter_function(node):
    return node.op.name in {"rxx", "ryy"}

collect_function = partial(
    collect_using_filter_function,
    filter_function=filter_function,
    split_blocks=True,
    min_block_size=1,
)

def collapse_to_xx_plus_yy(block):
    param = 0.0
    for node in block.data:
        param += node.operation.params[0]
    return XXPlusYYGate(param)

collapse_function = partial(
    collapse_to_operation,
    collapse_function=collapse_to_xx_plus_yy,
)

pm = PassManager()
pm.append(CollectAndCollapse(collect_function, collapse_function))

Contoh simulator skala-kecil

Langkah 1: Petakan input klasik ke masalah kuantum

Kita mulai dengan model Heisenberg 10-qubit pada sebuah garis, menggunakan state Néel $\vert 0101\ldots01 \rangle$ sebagai state awal. Hamiltonian-nya adalah:

\hat{\mathcal{H}}_{\text{Heis}} = J \sum_{i=1}^{L-1} \left(X_i X_{i+1} + Y_i Y_{i+1} + Z_i Z_{i+1}\right),

di mana $J$ adalah kekuatan kopling tetangga-terdekat. Kita mengukur korelator ZZ $Z_{L/2-1} Z_{L/2}$ pada sepasang qubit di tengah rantai, dan menggunakan langkah Trotter $k_j = [1, 2, 4]$ dengan product formula orde-kedua.

L = 10

# Generate coupling map and Hamiltonian
coupling_map = CouplingMap.from_line(L, bidirectional=False)

hamiltonian = generate_xyz_hamiltonian(
    coupling_map,
    coupling_constants=(1.0, 1.0, 1.0),
    ext_magnetic_field=(0.0, 0.0, 0.0),
)
print(hamiltonian)

SparsePauliOp(['IIIIIIIXXI', 'IIIIIIIYYI', 'IIIIIIIZZI', 'IIIIIXXIII', 'IIIIIYYIII', 'IIIIIZZIII', 'IIIXXIIIII', 'IIIYYIIIII', 'IIIZZIIIII', 'IXXIIIIIII', 'IYYIIIIIII', 'IZZIIIIIII', 'IIIIIIIIXX', 'IIIIIIIIYY', 'IIIIIIIIZZ', 'IIIIIIXXII', 'IIIIIIYYII', 'IIIIIIZZII', 'IIIIXXIIII', 'IIIIYYIIII', 'IIIIZZIIII', 'IIXXIIIIII', 'IIYYIIIIII', 'IIZZIIIIII', 'XXIIIIIIII', 'YYIIIIIIII', 'ZZIIIIIIII'],
              coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,
 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j,
 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])

# Observable: ZZ on the middle pair of qubits
observable = SparsePauliOp.from_sparse_list(
    [("ZZ", (L // 2 - 1, L // 2), 1.0)], num_qubits=L
)
print(observable)

SparsePauliOp(['IIIIZZIIII'],
              coeffs=[1.+0.j])

# MPF parameters
mpf_trotter_steps = [1, 2, 4]
order = 2
symmetric = False

trotter_times = np.arange(0.5, 1.55, 0.1)
exact_evolution_times = np.arange(trotter_times[0], 1.55, 0.05)

Bangun sirkuit Trotter

Kita membuat sirkuit-sirkuit yang mengimplementasikan evolusi-waktu Trotter aproksimasi untuk setiap titik waktu dan setiap jumlah langkah Trotter. Pass CollectAndCollapse yang didefinisikan di bagian Persiapan mengumpulkan rotasi XX dan YY menjadi gate XX+YY tunggal, untuk mempersiapkan simulasi tensor-network yang lebih efisien nanti.

# Initial Neel state preparation
initial_state_circ = QuantumCircuit(L)
initial_state_circ.x([i for i in range(L) if i % 2 != 0])

all_circs = []
for total_time in trotter_times:
    mpf_trotter_circs = [
        generate_time_evolution_circuit(
            hamiltonian,
            time=total_time,
            synthesis=SuzukiTrotter(reps=num_steps, order=order),
        )
        for num_steps in mpf_trotter_steps
    ]

    mpf_trotter_circs = pm.run(
        mpf_trotter_circs
    )  # Collect XX and YY into XX + YY

    mpf_circuits = [
        initial_state_circ.compose(circuit) for circuit in mpf_trotter_circs
    ]
    all_circs.append(mpf_circuits)

mpf_circuits[-1].draw("mpl", fold=-1)

Output of the previous code cell

Langkah 2: Optimalkan masalah untuk eksekusi hardware kuantum

Untuk contoh skala-kecil kita menargetkan simulator Aer. Dua transformasi terjadi sebelum sirkuit siap dieksekusi:

Pengumpulan gate pada level simulasi-Hamiltonian. Di sel Persiapan kita membangun pass CollectAndCollapse yang menggabungkan rotasi rxx dan ryy yang berdekatan menjadi satu XXPlusYYGate. Kita sudah menerapkan pass ini saat kita membangun sirkuit-sirkuit Trotter di Langkah 1 (panggilan pm.run(...)). Ini sekaligus mengurangi jumlah gate dua-qubit dan menghasilkan struktur yang lebih cocok untuk simulasi tensor-network untuk komputasi koefisien dinamis nanti.
Menurunkan ke ISA simulator. Di bawah ini kita menjalankan pass manager preset Qiskit pada optimization_level=3 untuk menurunkan setiap sirkuit Trotter ke arsitektur instruction-set (ISA) simulator.

aer_sim = AerSimulator()
pm_sim = generate_preset_pass_manager(backend=aer_sim, optimization_level=3)

isa_circs_all_times = [
    pm_sim.run([deepcopy(c) for c in mpf_circuits])
    for mpf_circuits in all_circs
]

Langkah 3: Eksekusi menggunakan primitif Qiskit

Untuk contoh skala-kecil kita menjalankan sirkuit-sirkuit Trotter yang telah diturunkan-ISA melalui primitif EstimatorV2 yang didukung oleh Aer. Melakukan hal ini memberi kita nilai referensi tanpa noise untuk setiap pasangan $(k_j, t)$ — ini adalah nilai-nilai $\langle A \rangle_{k_j}(t)$ yang akan digabungkan oleh MPF di Langkah 4. Kita menyapu berbagai waktu evolusi sehingga kita nantinya bisa memplot kurva deret-waktu penuh dari setiap product formula individual dan dari MPF.

estimator = Estimator(mode=aer_sim)

mpf_expvals_all_times, mpf_stds_all_times = [], []
for isa_circuits in isa_circs_all_times:
    result = estimator.run(
        [(circuit, observable) for circuit in isa_circuits], precision=0.005
    ).result()
    mpf_expvals_all_times.append([res.data.evs for res in result])
    mpf_stds_all_times.append([res.data.stds for res in result])

Langkah 4: Pasca-proses dan kembalikan hasil dalam format klasik yang diinginkan

Langkah 4 adalah tempat MPF sebenarnya dibangun. Meskipun koefisien $x_j$ dihitung di sini (dan, untuk varian dinamis, komputasi ini bisa intensif), secara konseptual koefisien-koefisien tersebut adalah resep klasik untuk menggabungkan pengukuran kuantum dari Langkah 3 menjadi satu nilai ekspektasi terkoreksi — jadi kita memperlakukan seluruh alur kerja koefisien dan kombinasi sebagai post-processing.

Untuk menilai seberapa baik MPF mengikuti dinamika sebenarnya, pertama kita menghitung nilai ekspektasi yang terevolusi-waktu secara eksak dengan langsung mengeksponensiasi Hamiltonian. Ini hanya dapat dilakukan karena $L = 10$ ; dalam contoh hardware skala-besar di bawah kita harus mengandalkan estimasi tensor-network sebagai gantinya.

exact_expvals = []
for t in exact_evolution_times:
    exp_H = expm(-1j * t * hamiltonian.to_matrix())
    initial_state = Statevector(initial_state_circ).data
    time_evolved_state = exp_H @ initial_state

    exact_obs = (
        time_evolved_state.conj()
        @ observable.to_matrix()
        @ time_evolved_state
    ).real
    exact_expvals.append(exact_obs)

Koefisien MPF statis

MPF statis menggunakan koefisien $x_j$ yang tidak bergantung pada waktu evolusi, Hamiltonian, dan state awal. Kita menyiapkan sistem linear $Ax = b$ yang dijelaskan dalam Latar Belakang dan menyelesaikan untuk koefisien-koefisiennya. Matriks $A$ ditentukan oleh jumlah langkah Trotter $k_j$ , orde $\chi$ dari product formula, dan apakah formula tersebut simetrik (yang mengontrol eksponen $\eta_n$ ).

Untuk contoh skala-kecil kita, kita menggunakan $k_j = [1, 2, 4]$ dengan formula Suzuki-Trotter orde- $2\chi=2$ non-simetrik (jadi $\chi=1$ dan $\eta_n = 2 + n$ , memberikan $\eta_0 = 2,\, \eta_1 = 3$ ). Sistemnya menjadi:

A = \begin{bmatrix} 1 & 1 & 1\\ 1 & \frac{1}{2^2} & \frac{1}{4^2} \\ 1 & \frac{1}{2^3} & \frac{1}{4^3} \\ \end{bmatrix}, \quad b = \begin{bmatrix} 1 \\ 0 \\ 0 \end{bmatrix}.

Baris pertama menegakkan sifat unbiased ( $\sum_j x_j = 1$ ); baris kedua dan ketiga membatalkan suku error Trotter $1/k^2$ terdepan dan $1/k^3$ orde berikutnya secara berturut-turut.

Menyiapkan LSE

Kita menggunakan setup_static_lse dari qiskit_addon_mpf.static untuk menyusun matriks $A$ dan vektor ruas kanan $b$ yang dijelaskan di atas. Matriks $A$ tidak hanya bergantung pada $k_j$ tetapi juga pada pilihan kita atas formula produk — khususnya orde-nya $\chi$ dan apakah formula tersebut simetris. Flag symmetric mengontrol pola eksponen $\eta_n$ (formula simetris hanya menghasilkan suku error Trotter berpangkat genap; lihat Ref. [1]). Perlu dicatat bahwa, sebagaimana ditunjukkan pada Ref. [2], mengatur symmetric=True tidak benar-benar diperlukan bahkan ketika PF yang mendasarinya simetris — LSE non-simetris tetap valid (ia menegakkan batasan tambahan yang sebenarnya tidak diperlukan).

Untuk contoh kita, kita sudah mengatur order = 2 dan symmetric = False pada Langkah 1.

lse = setup_static_lse(mpf_trotter_steps, order=order, symmetric=symmetric)

Periksa matriks $A$ dan vektor $b$ yang telah dibangun untuk memastikan keduanya sesuai dengan sistem yang dituliskan di atas.

lse.A

array([[1.      , 1.      , 1.      ],
       [1.      , 0.25    , 0.0625  ],
       [1.      , 0.125   , 0.015625]])

lse.b

array([1., 0., 0.])

Dengan LSE di tangan, kita menyelesaikan koefisien statis $x_j$ melalui lse.solve() (ini adalah solusi langsung $x = A^{-1}b$ ).

mpf_coeffs = lse.solve()
print(
    f"The static coefficients associated with the ansatze are: {mpf_coeffs}"
)

The static coefficients associated with the ansatze are: [ 0.04761905 -0.57142857  1.52380952]

Optimalkan $x$ menggunakan model eksak

Sebagai alternatif dari komputasi $x = A^{-1}b$ , kamu bisa menggunakan setup_exact_model untuk mengonstruksi instance cvxpy.Problem yang menggunakan LSE sebagai kendala dan solusi optimalnya akan menghasilkan $x$ .

model_exact, coeffs_exact = setup_exact_problem(lse)
model_exact.solve()
print(coeffs_exact.value)

[ 0.04761905 -0.57142857  1.52380952]

print(
    "L1 norm of the exact coefficients:",
    np.linalg.norm(coeffs_exact.value, ord=1),
)

L1 norm of the exact coefficients: 2.1428571428556378

Optimalkan $x$ menggunakan model aproksimasi

Bisa saja terjadi bahwa norma $L_1$ untuk sekumpulan nilai $k_j$ yang dipilih dianggap terlalu tinggi. Jika itu terjadi dan kamu tidak bisa memilih sekumpulan nilai $k_j$ yang berbeda, kamu bisa menggunakan solusi aproksimasi yang membatasi norma- $L_1$ ke ambang batas tertentu sambil meminimalkan $\|Ax - b\|$ . Lihat panduan How to use the approximate model.

model_approx, coeffs_approx = setup_sum_of_squares_problem(
    lse, max_l1_norm=1.5
)
model_approx.solve()
print(coeffs_approx.value)
print(
    "L1 norm of the approximate coefficients:",
    np.linalg.norm(coeffs_approx.value, ord=1),
)

[-1.10294118e-03 -2.48897059e-01  1.25000000e+00]
L1 norm of the approximate coefficients: 1.5

Koefisien MPF dinamis

MPF statis membatalkan suku error Trotter dengan cara yang agnostik terhadap Hamiltonian dan keadaan, sehingga tidak selalu menghasilkan error aproksimasi sekecil mungkin untuk Hamiltonian dan keadaan awal tertentu. MPF dinamis (Ref. [2], [3]) justru mencari koefisien yang bergantung pada waktu $x_i(t)$ yang meminimalkan jarak norma-Frobenius $\|\rho(t) - \mu^D(t)\|_F^2$ pada setiap waktu $t$ . Seperti ditunjukkan pada bagian Background, ini memerlukan matriks overlap $M_{ij}(t)$ antara keadaan-keadaan yang dievolusikan Trotter dan overlap $L_i(t)$ dengan keadaan eksak — keduanya kita estimasi menggunakan backend tensor-network (TeNPy) pada qiskit_addon_mpf.

Untuk menyiapkan LSE dinamis kita memerlukan tiga bahan:

Sebuah factory evolver aproksimasi yang akan dijalankan addon untuk setiap $k_j$ guna menghasilkan $\rho_{k_j}(t)$ sebagai MPS/MPO. Kita membangunnya dari struktur berlapis sirkuit Trotter orde- $2$ (satu lapisan per slice_by_depth), dibungkus sebagai LayerwiseEvolver dengan parameter pemotongan (truncation) TeNPy.
Sebuah factory evolver eksak yang menghasilkan referensi akurasi tinggi $\rho(t)$ . Kita menggunakan sirkuit Suzuki-Trotter orde empat dengan langkah waktu kecil (dt=0.1, order=4) sebagai proksi evolusi eksak.
Sebuah factory identitas dan sebuah MPS keadaan awal yang menjadi benih simulasi TeNPy.

Sel di bawah ini membangun factory evolver aproksimasi.

# Create approximate time-evolution circuits
single_2nd_order_circ = generate_time_evolution_circuit(
    hamiltonian, time=1.0, synthesis=SuzukiTrotter(reps=1, order=order)
)
single_2nd_order_circ = pm.run(single_2nd_order_circ)  # collect XX and YY

# Find layers in the circuit
layers = slice_by_depth(single_2nd_order_circ, max_slice_depth=1)

# Create tensor network models
models = [
    LayerModel.from_quantum_circuit(layer, conserve="Sz") for layer in layers
]

# Create the time-evolution object
approx_factory = partial(
    LayerwiseEvolver,
    layers=models,
    options={
        "preserve_norm": False,
        "trunc_params": {
            "chi_max": 64,
            "svd_min": 1e-8,
            "trunc_cut": None,
        },
        "max_delta_t": 2,
    },
)

peringatan

Opsi LayerwiseEvolver yang menentukan detail simulasi tensor network harus dipilih dengan hati-hati untuk menghindari terbentuknya masalah optimisasi yang tidak terdefinisi dengan baik.

Kita mengaproksimasi keadaan yang berevolusi seiring waktu secara eksak dengan formula Suzuki-Trotter orde empat menggunakan langkah waktu kecil dt=0.1. Parameter truncation TeNPy dapat memengaruhi akurasi, jadi penting untuk mengeksplorasi berbagai rentang nilai.

single_4th_order_circ = generate_time_evolution_circuit(
    hamiltonian, time=1.0, synthesis=SuzukiTrotter(reps=1, order=4)
)
single_4th_order_circ = pm.run(single_4th_order_circ)
exact_model_layers = [
    LayerModel.from_quantum_circuit(layer, conserve="Sz")
    for layer in slice_by_depth(single_4th_order_circ, max_slice_depth=1)
]

exact_factory = partial(
    LayerwiseEvolver,
    layers=exact_model_layers,
    dt=0.1,
    options={
        "preserve_norm": False,
        "trunc_params": {
            "chi_max": 64,
            "svd_min": 1e-8,
            "trunc_cut": None,
        },
        "max_delta_t": 2,
    },
)

Terakhir, kita mendefinisikan identity_factory yang menghasilkan keadaan MPO awal dan menyiapkan keadaan awal Néel sebagai MPS yang sesuai dengan lattice yang digunakan model Trotter berlapis.

def identity_factory():
    return MPOState.initialize_from_lattice(models[0].lat, conserve=True)

mps_initial_state = MPS_neel_state(models[0].lat)

Dengan factory-factory sudah siap, kita sekarang menghitung koefisien dinamis pada setiap waktu evolusi. Untuk setiap $t$ , setup_dynamic_lse membangun matriks overlap yang relevan melalui TeNPy, dan setup_frobenius_problem mengembalikan cvxpy.Problem yang meminimalkan biaya norma-Frobenius. Solver mengembalikan koefisien $x_j(t)$ yang disesuaikan untuk waktu tersebut; kita mengumpulkannya di mpf_dynamic_coeffs_list. Jika solver gagal untuk suatu $t$ , kita jatuh kembali ke koefisien nol agar loop tetap berlanjut.

mpf_dynamic_coeffs_list = []
for t in trotter_times:
    print(f"Computing dynamic coefficients for time={t}")
    lse = setup_dynamic_lse(
        mpf_trotter_steps,
        t,
        identity_factory,
        exact_factory,
        approx_factory,
        mps_initial_state,
    )
    problem, coeffs = setup_frobenius_problem(lse)
    try:
        problem.solve()
        mpf_dynamic_coeffs_list.append(coeffs.value)
    except Exception as error:
        mpf_dynamic_coeffs_list.append(np.zeros(len(mpf_trotter_steps)))
        print(error, "Calculation Failed for time", t)
    print("")

Computing dynamic coefficients for time=0.5

Computing dynamic coefficients for time=0.6

Computing dynamic coefficients for time=0.7

Computing dynamic coefficients for time=0.7999999999999999

Computing dynamic coefficients for time=0.8999999999999999

Computing dynamic coefficients for time=0.9999999999999999

Computing dynamic coefficients for time=1.0999999999999999

Computing dynamic coefficients for time=1.1999999999999997

Computing dynamic coefficients for time=1.2999999999999998

Computing dynamic coefficients for time=1.4

Computing dynamic coefficients for time=1.4999999999999998

Menggabungkan nilai ekspektasi Trotter dengan koefisien MPF

Sekarang kita mengevaluasi $\langle A \rangle_{\text{MPF}}(t) = \sum_j x_j \, \langle A \rangle_{k_j}(t)$ untuk setiap set koefisien (statis-eksak, statis-aproksimasi, dan dinamis), merambatkan standard error per-sirkuit, dan memplot deret waktu yang dihasilkan terhadap kurva diagonalisasi eksak.

sym = {1: "^", 2: "s", 4: "p"}
# Get expectation values at all times for each Trotter step
for k, step in enumerate(mpf_trotter_steps):
    trotter_curve, trotter_curve_error = [], []
    for trotter_expvals, trotter_stds in zip(
        mpf_expvals_all_times, mpf_stds_all_times
    ):
        trotter_curve.append(trotter_expvals[k])
        trotter_curve_error.append(trotter_stds[k])

    plt.errorbar(
        trotter_times,
        trotter_curve,
        yerr=trotter_curve_error,
        alpha=0.5,
        markersize=4,
        marker=sym[step],
        color="grey",
        label=f"{mpf_trotter_steps[k]} Trotter steps",
    )

# Get expectation values at all times for the static MPF with exact coeffs
exact_mpf_curve, exact_mpf_curve_error = [], []
for trotter_expvals, trotter_stds in zip(
    mpf_expvals_all_times, mpf_stds_all_times
):
    mpf_std = np.sqrt(
        sum(
            [
                (coeff**2) * (std**2)
                for coeff, std in zip(coeffs_exact.value, trotter_stds)
            ]
        )
    )
    exact_mpf_curve_error.append(mpf_std)
    exact_mpf_curve.append(trotter_expvals @ coeffs_exact.value)

plt.errorbar(
    trotter_times,
    exact_mpf_curve,
    yerr=exact_mpf_curve_error,
    markersize=4,
    marker="o",
    label="Static MPF - Exact",
    color="purple",
)

# Get expectation values at all times for the static MPF with approximate coeffs
approx_mpf_curve, approx_mpf_curve_error = [], []
for trotter_expvals, trotter_stds in zip(
    mpf_expvals_all_times, mpf_stds_all_times
):
    mpf_std = np.sqrt(
        sum(
            [
                (coeff**2) * (std**2)
                for coeff, std in zip(coeffs_approx.value, trotter_stds)
            ]
        )
    )
    approx_mpf_curve_error.append(mpf_std)
    approx_mpf_curve.append(trotter_expvals @ coeffs_approx.value)

plt.errorbar(
    trotter_times,
    approx_mpf_curve,
    yerr=approx_mpf_curve_error,
    markersize=4,
    marker="o",
    label="Static MPF - Approx",
    color="orange",
)

# Get expectation values at all times for the dynamic MPF
dynamic_mpf_curve, dynamic_mpf_curve_error = [], []
for trotter_expvals, trotter_stds, dynamic_coeffs in zip(
    mpf_expvals_all_times, mpf_stds_all_times, mpf_dynamic_coeffs_list
):
    mpf_std = np.sqrt(
        sum(
            [
                (coeff**2) * (std**2)
                for coeff, std in zip(dynamic_coeffs, trotter_stds)
            ]
        )
    )
    dynamic_mpf_curve_error.append(mpf_std)
    dynamic_mpf_curve.append(trotter_expvals @ dynamic_coeffs)

plt.errorbar(
    trotter_times,
    dynamic_mpf_curve,
    yerr=dynamic_mpf_curve_error,
    markersize=4,
    marker="o",
    label="Dynamic MPF",
    color="pink",
)

# Exact expectation values
plt.plot(
    exact_evolution_times,
    exact_expvals,
    color="red",
    linestyle="--",
    label="Exact time-evolution",
)

plt.title(f"$\\langle Z_{{{L//2-1}}} Z_{{{L//2}}} \\rangle$ vs time")
plt.xlabel("Time")
plt.ylabel("Expectation Value")
plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.2), ncol=2)
plt.grid(alpha=0.1)
plt.tight_layout()
plt.show()

Output of the previous code cell

Plot di atas mengilustrasikan interaksi antara error Trotter dan error sampling.

Error Trotter. Formula produk individual (marker abu-abu) semakin menyimpang dari kurva eksak seiring bertambahnya waktu. Sirkuit $k=1$ memiliki penyimpangan terbesar dan paling dangkal, tetapi sirkuit ini juga sudah berada di rezim di mana $t/k \gtrsim 1$ , sehingga suku error terdepan $1/k^{2}$ menjadi besar. Kombinasi MPF (marker berwarna) membatalkan beberapa suku error Trotter terdepan ini, sehingga mereka mengikuti kurva eksak jauh lebih dekat dibandingkan sirkuit $k_j$ tunggal manapun. Celah yang tersisa mencerminkan suku Trotter orde lebih tinggi yang tidak dibatalkan oleh MPF: MPF statis orde- $2$ , $r=3$ hanya menghilangkan dua orde error pertama, dan pada $t/k_{\min}$ besar, ekor yang tidak dibatalkan akhirnya mendominasi — jadi MPF tidak menjamin bahwa sirkuit yang sangat dangkal tetap akurat pada waktu sembarang.
Error sampling. Bar error yang lebih lebar pada kurva MPF merupakan konsekuensi langsung dari kombinasi linear: merambatkan standard error per-sirkuit $\sigma_{k_j}$ yang independen menghasilkan varian total $\sigma_{\text{MPF}}^2 = \sum_j x_j^2 \, \sigma_{k_j}^2$ . Oleh karena itu, semakin besar $\|x\|_2$ (dan dalam praktiknya $\|x\|_1$ , yang merupakan hal yang kita kontrol), semakin banyak shot yang diperlukan untuk mencapai target ketidakpastian tertentu. Ini adalah trade-off di balik opsi solver aproksimasi pada bagian Background: kita membatasi $\|x\|_1$ agar overhead ini tetap terkendali. Yang terpenting, tidak seperti error Trotter, error sampling menyusut dengan $1/\sqrt{N_{\text{shots}}}$ , sehingga selalu bisa dikurangi dengan menggunakan lebih banyak shot.

Pada contoh hardware skala besar di bawah ini, noise hardware masuk sebagai sumber error tambahan pada setiap $\langle A \rangle_{k_j}$ , yang serupa akan diperkuat oleh koefisien MPF. Kita akan melihat bagaimana mitigasi error berinteraksi dengan MPF pada bagian tersebut.

Contoh hardware skala besar

Pada bagian ini kita meningkatkan skala masalah melebihi apa yang bisa disimulasikan secara eksak. Kita mereproduksi beberapa hasil yang ditunjukkan pada Ref. [3], menggunakan rantai XXZ 50-qubit pada waktu $t = 3$ . Kita mengikuti alur kerja empat langkah yang sama seperti contoh skala kecil, kini menargetkan hardware kuantum nyata dengan mitigasi error. Seperti pada template, setiap langkah ditandai inline di dalam kode, dan satu langkah bisa mencakup beberapa sel ketika output antaranya layak untuk diperiksa. Pemetaannya mencerminkan contoh skala kecil: mendefinisikan Hamiltonian, memilih parameter Trotter, menghitung koefisien MPF (statis dan dinamis), dan membangun sirkuit. Perbedaan utamanya adalah:

Sebuah Hamiltonian XXZ pada 50 situs dengan coupling acak yang diambil dari $\mathcal{U}(0.5, 1.5)$ (Ref. [3]).
Sebuah formula Trotter orde dua simetris dengan $k_j = [3, 4, 6]$ (sehingga $\chi=1$ , symmetric=True).
Satu waktu evolusi tetap $t = 3$ . Dengan $k_{\min}=3$ ini memberikan $t/k_{\min}=1$ , menjaga konstituen dangkal tetap berada dalam rezim konvergensi Trotter di mana model error terdepan yang diandalkan MPF berlaku.
Sebuah run perbandingan sirkuit tunggal tambahan dengan $k = 10$ langkah Trotter, digunakan sebagai baseline. Kita memilih $k = 10$ karena depth dua-qubitnya pada hardware lebih dalam daripada konstituen MPF terdalam ( $k_{\max}=6$ ) ditambah overhead menjalankan beberapa sirkuit MPF — cukup dalam untuk dibatasi noise, yaitu rezim di mana kombinasi MPF diharapkan mengungguli baseline sirkuit tunggal. Ini adalah perbandingan "sirkuit dalam tunggal" terhadap kombinasi MPF, bukan sirkuit yang menargetkan error Trotter efektif MPF (yang akan memerlukan jauh lebih banyak langkah).

Perlu dicatat bahwa meskipun kita masih di Langkah 1 di sini (pemetaan dan pembangunan sirkuit), kita juga menghitung terlebih dahulu koefisien dinamis bersama dengan koefisien statis pada sel ini. Koefisien dinamis bergantung pada $H$ dan $t$ tetapi tidak pada pengukuran kuantum, sehingga dapat dihitung kapan saja sebelum Langkah 4. Kita melakukannya sekarang agar semua pengaturan khusus MPF berada di satu tempat.

# -------------------------Step 1-------------------------
L = 50
coupling_map = CouplingMap.from_line(L, bidirectional=False)

# XXZ Hamiltonian with random couplings (Ref. [3])
np.random.seed(0)
even_edges = list(coupling_map.get_edges())[::2]
odd_edges = list(coupling_map.get_edges())[1::2]

Js = np.random.uniform(0.5, 1.5, size=L)
hamiltonian = SparsePauliOp(Pauli("I" * L))
for i, edge in enumerate(even_edges + odd_edges):
    hamiltonian += SparsePauliOp.from_sparse_list(
        [
            ("XX", (edge), 2 * Js[i]),
            ("YY", (edge), 2 * Js[i]),
            ("ZZ", (edge), 4 * Js[i]),
        ],
        num_qubits=L,
    )

observable = SparsePauliOp.from_sparse_list(
    [("ZZ", (L // 2 - 1, L // 2), 1.0)], num_qubits=L
)

total_time = 3
mpf_trotter_steps = [3, 4, 6]
order = 2
symmetric = True

# Static coefficients
lse = setup_static_lse(mpf_trotter_steps, order=order, symmetric=symmetric)
mpf_coeffs = lse.solve()
print(f"Static coefficients: {mpf_coeffs}")
print(f"L1 norm: {np.linalg.norm(mpf_coeffs, ord=1)}")

model_approx, coeffs_approx = setup_sum_of_squares_problem(
    lse, max_l1_norm=2.0
)
model_approx.solve()
print(f"Approximate coefficients: {coeffs_approx.value}")
print(f"L1 norm (approx): {np.linalg.norm(coeffs_approx.value, ord=1)}")

# -------------------------Dynamic coefficients-------------------------
single_2nd_order_circ = generate_time_evolution_circuit(
    hamiltonian, time=1.0, synthesis=SuzukiTrotter(reps=1, order=order)
)
single_2nd_order_circ = pm.run(single_2nd_order_circ)

layers = slice_by_depth(single_2nd_order_circ, max_slice_depth=1)
models = [
    LayerModel.from_quantum_circuit(layer, conserve="Sz") for layer in layers
]

approx_factory = partial(
    LayerwiseEvolver,
    layers=models,
    options={
        "preserve_norm": False,
        "trunc_params": {"chi_max": 64, "svd_min": 1e-8, "trunc_cut": None},
        "max_delta_t": 4,
    },
)

single_4th_order_circ = generate_time_evolution_circuit(
    hamiltonian, time=1.0, synthesis=SuzukiTrotter(reps=1, order=4)
)
single_4th_order_circ = pm.run(single_4th_order_circ)
exact_model_layers = [
    LayerModel.from_quantum_circuit(layer, conserve="Sz")
    for layer in slice_by_depth(single_4th_order_circ, max_slice_depth=1)
]

exact_factory = partial(
    LayerwiseEvolver,
    layers=exact_model_layers,
    dt=0.1,
    options={
        "preserve_norm": False,
        "trunc_params": {"chi_max": 64, "svd_min": 1e-8, "trunc_cut": None},
        "max_delta_t": 3,
    },
)

def identity_factory():
    return MPOState.initialize_from_lattice(models[0].lat, conserve=True)

mps_initial_state = MPS_neel_state(models[0].lat)

print(f"Computing dynamic coefficients for time={total_time}")
lse_dyn = setup_dynamic_lse(
    mpf_trotter_steps,
    total_time,
    identity_factory,
    exact_factory,
    approx_factory,
    mps_initial_state,
)
problem, coeffs_dyn = setup_frobenius_problem(lse_dyn)
try:
    problem.solve()
    mpf_dynamic_coeffs = coeffs_dyn.value
except Exception as error:
    mpf_dynamic_coeffs = np.zeros(len(mpf_trotter_steps))
    print(error, "Calculation Failed")

# -------------------------Step 1 (cont): Build circuits-------------------------
mpf_circuits = []
for k in mpf_trotter_steps:
    circuit = QuantumCircuit(L)
    circuit.x([i for i in range(L) if i % 2])
    trotter_circ = generate_time_evolution_circuit(
        hamiltonian,
        synthesis=SuzukiTrotter(reps=k, order=order),
        time=total_time,
    )
    circuit.compose(trotter_circ, qubits=range(L), inplace=True)
    mpf_circuits.append(circuit)

# Baseline "single deep circuit" comparison run with k=10 Trotter steps.
# Its two-qubit depth is deeper than the deepest MPF constituent (k_max=6) plus
# the overhead of running multiple circuits, pushing it into the noise-limited
# regime where MPF is expected to outperform. It does NOT target the MPF's effective
# Trotter error (which would require many more steps).
comp_circuit = QuantumCircuit(L)
comp_circuit.x([i for i in range(L) if i % 2])
trotter_circ = generate_time_evolution_circuit(
    hamiltonian,
    synthesis=SuzukiTrotter(reps=10, order=order),
    time=total_time,
)
comp_circuit.compose(trotter_circ, qubits=range(L), inplace=True)
mpf_circuits.append(comp_circuit)

Static coefficients: [ 0.42857143 -1.82857143  2.4       ]
L1 norm: 4.65714285714286
Approximate coefficients: [-0.4942491   0.40206845  1.09218065]
L1 norm (approx): 1.9884981979026675
Computing dynamic coefficients for time=3

Sekarang kita mengoptimalkan sirkuit untuk backend yang dipilih. Kita menggunakan Qiskit preset pass manager pada optimization_level=3, yang secara otomatis memilih sekumpulan qubit fisik yang baik dan merutekan setiap sirkuit ke topologi perangkat.

# -------------------------Step 2-------------------------
service = QiskitRuntimeService()
# backend = service.least_busy(operational=True, simulator=False, min_num_qubits=L)
backend = service.backend("ibm_fez")
print(backend)

transpiler = generate_preset_pass_manager(
    optimization_level=3, backend=backend
)
transpiled_circuits = [transpiler.run(circ) for circ in mpf_circuits]

isa_observables = [
    observable.apply_layout(circ.layout) for circ in transpiled_circuits
]

<IBMBackend('ibm_fez')>

Menjalankan sirkuit yang lebih dalam pada hardware nyata memerlukan mitigasi error yang agresif. Kita mengaktifkan dynamical decoupling, gate dan measurement twirling, mitigasi error pengukuran, dan zero-noise extrapolation (ZNE). Perlu dicatat bahwa faktor noise ZNE yang kita gunakan di sini (1, 1.2, 1.4) lebih kecil dibandingkan pada skenario sirkuit dangkal, karena konstituen MPF yang lebih dalam sudah mendekati ambang noise dan amplifikasi noise yang besar akan mendorongnya melewati titik di mana ekstrapolasi ZNE masih andal.

Kita mengirimkan keempat sirkuit (tiga konstituen MPF pada $k_j = [3, 4, 6]$ ditambah baseline $k = 10$ ) dalam satu job Estimator.

# -------------------------Step 3-------------------------
estimator = Estimator(mode=backend)
estimator.options.default_shots = 30000

# Error suppression/mitigation
estimator.options.dynamical_decoupling.enable = True
estimator.options.twirling.enable_gates = True
estimator.options.twirling.enable_measure = True
estimator.options.twirling.num_randomizations = "auto"
estimator.options.twirling.strategy = "active-accum"
estimator.options.resilience.measure_mitigation = True
estimator.options.experimental.execution_path = "gen3-turbo"

estimator.options.resilience.zne_mitigation = True
estimator.options.resilience.zne.noise_factors = (1, 1.2, 1.4)
estimator.options.resilience.zne.extrapolator = "linear"

estimator.options.environment.job_tags = ["TUT_MPF"]

job_50 = estimator.run(
    [
        (circ, observable)
        for circ, observable in zip(transpiled_circuits, isa_observables)
    ]
)

Kita mengambil nilai ekspektasi dan standar deviasi per-sirkuit dari hasil job, lalu menggabungkannya dengan setiap set koefisien MPF persis seperti pada contoh skala kecil: $\langle A \rangle_{\text{MPF}} = \sum_j x_j \, \langle A \rangle_{k_j}$ , dengan varian yang dirambatkan $\sigma^2 = \sum_j x_j^2 \sigma_{k_j}^2$ .

# -------------------------Step 4-------------------------
result = job_50.result()
evs = [res.data.evs for res in result]
std = [res.data.stds for res in result]

print(evs)
print(std)

[array(-0.07916195), array(-0.04479681), array(-0.2560756), array(-0.06045848)]
[array(0.04605538), array(0.10056336), array(0.14426151), array(0.04059092)]

exact_mpf_std = np.sqrt(
    sum([(coeff**2) * (std**2) for coeff, std in zip(mpf_coeffs, std[:3])])
)
print(
    "Exact static MPF expectation value: ",
    evs[:3] @ mpf_coeffs,
    "+-",
    exact_mpf_std,
)
approx_mpf_std = np.sqrt(
    sum(
        [
            (coeff**2) * (std**2)
            for coeff, std in zip(coeffs_approx.value, std[:3])
        ]
    )
)
print(
    "Approximate static MPF expectation value: ",
    evs[:3] @ coeffs_approx.value,
    "+-",
    approx_mpf_std,
)
dynamic_mpf_std = np.sqrt(
    sum(
        [
            (coeff**2) * (std**2)
            for coeff, std in zip(mpf_dynamic_coeffs, std[:3])
        ]
    )
)
print(
    "Dynamic MPF expectation value: ",
    evs[:3] @ mpf_dynamic_coeffs,
    "+-",
    dynamic_mpf_std,
)

Exact static MPF expectation value:  -0.5665938395816946 +- 0.3925273058119915
Approximate static MPF expectation value:  -0.25856647611537903 +- 0.164249927266166
Dynamic MPF expectation value:  -0.12667812062949296 +- 0.06059471006973169

sym = {3: "^", 4: "s", 6: "p"}
for k, step in enumerate(mpf_trotter_steps):
    plt.errorbar(
        k,
        evs[k],
        yerr=std[k],
        alpha=0.5,
        markersize=4,
        marker=sym[step],
        color="grey",
        label=f"{mpf_trotter_steps[k]} Trotter steps",
    )

plt.errorbar(
    3,
    evs[-1],
    yerr=std[-1],
    alpha=0.5,
    markersize=8,
    marker="x",
    color="blue",
    label="10 Trotter steps",
)

plt.errorbar(
    4,
    evs[:3] @ mpf_coeffs,
    yerr=exact_mpf_std,
    markersize=4,
    marker="o",
    color="purple",
    label="Static MPF",
)

plt.errorbar(
    5,
    evs[:3] @ coeffs_approx.value,
    yerr=approx_mpf_std,
    markersize=4,
    marker="o",
    color="orange",
    label="Approximate static MPF",
)

plt.errorbar(
    6,
    evs[:3] @ mpf_dynamic_coeffs,
    yerr=dynamic_mpf_std,
    markersize=4,
    marker="o",
    color="pink",
    label="Dynamic MPF",
)

exact_obs = -0.24384471447172074  # Calculated via Tensor Network calculation
plt.axhline(
    y=exact_obs, linestyle="--", color="red", label="Exact time-evolution"
)

plt.title(
    f"$\\langle Z_{{{L//2-1}}} Z_{{{L//2}}} \\rangle$ at time {total_time} for the different methods"
)
plt.xlabel("Method")
plt.ylabel("Expectation Value")
plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.2), ncol=2)
plt.grid(alpha=0.1)
plt.tight_layout()
plt.show()

Output of the previous code cell

Beberapa pengamatan tentang hasil hardware di atas:

Semakin dalam tidak gratis pada hardware. Baseline sirkuit tunggal langsung menceritakan hal ini: sirkuit $k = 6$ hampir eksak ( $-0.256$ dibanding referensi $-0.244$ ), namun baseline $k = 10$ yang lebih dalam justru lebih buruk ( $-0.061$ , meleset $\sim 0.18$ ), bukan lebih baik. Setelah error Trotter sudah kecil, menambah langkah kebanyakan hanya memperdalam sirkuit dan mengakumulasi lebih banyak noise gate dan dekoherensi. Inilah tepatnya rezim tempat MPF dibangun: mencapai akurasi sirkuit dalam hanya dengan menggunakan konstituen dangkal.
MPF dengan norma kecil mengalahkan sirkuit tunggal yang dalam. MPF statis-aproksimasi (dibatasi pada $\|x\|_1 \approx 2$ ) mendarat di $-0.259$ , dalam jarak $\sim 0.015$ dari referensi dan jauh lebih dekat daripada baseline $k = 10$ . MPF dinamis ( $-0.127$ ) juga dengan nyaman mengalahkan baseline tersebut. Keduanya hanya menggabungkan sirkuit dangkal $k_j = [3, 4, 6]$ , namun berhasil memperoleh jawaban yang tidak bisa dicapai oleh sirkuit tunggal yang dalam.
Norma koefisien lebih penting daripada optimalitas matematis. MPF statis-eksak memiliki $\|x\|_1 = 4.66$ dan merupakan estimator terburuk dari semuanya ( $-0.567$ , meleset lebih dari $0.3$ ): norma koefisien yang besar memperkuat sisa noise gate, dekoherensi, dan error ZNE pada setiap $\langle A \rangle_{k_j}$ dengan faktor yang kurang lebih sama, mengalahkan pembatalan error Trotter yang diperolehnya. Membatasi norma (solver statis-aproksimasi, $\|x\|_1 \approx 2$ ) menghilangkan dominasi ini dan memberikan estimasi terbaik — meskipun koefisiennya tidak lagi membatalkan error Trotter terdepan secara eksak.
Sirkuit dangkal individual masih bisa kompetitif. Konstituen tunggal $k = 6$ ( $-0.256$ ) sendiri sudah hampir eksak di sini — pada run ini bahkan sedikit lebih dekat daripada MPF statis-aproksimasi. Masalahnya adalah kamu tidak tahu sebelumnya $k$ mana yang berada di titik ideal "konvergen tetapi belum dibatasi noise", dan pilihan yang terlihat aman yaitu sekadar memperdalam sirkuit ( $k = 10$ ) untuk menjamin konvergensi Trotter justru merupakan pilihan yang gagal. MPF memberikan kombinasi sirkuit dangkal yang berprinsip tanpa perlu menebak depth yang tepat.

Kesimpulan praktisnya adalah bahwa pada hardware, MPF sebaiknya dipasangkan dengan mitigasi error yang kuat pada setiap $\langle A \rangle_{k_j}$ individual, norma- $L_1$ koefisien harus dijaga tetap sedang (gunakan solver aproksimasi, atau MPF dinamis), dan langkah Trotter $k_j$ harus dipilih sehingga $t/k_{\min} \lesssim 1$ — di sini $k_{\min} = 3$ pada $t = 3$ memberikan $t/k_{\min} = 1$ , menjaga konstituen tetap berada dalam rezim konvergen di mana model error terdepan yang diandalkan MPF statis berlaku. Dengan pilihan-pilihan tersebut, MPF dengan norma kecil di sini menyamai sirkuit tunggal yang konvergen sementara baseline naif "tinggal perdalam saja" tidak, memulihkan keunggulan depth-versus-akurasi yang ditunjukkan pada Ref. [3]. Perlu dicatat juga bahwa run individual bersifat noisy — pada pengiriman lain dari job yang sama (atau backend yang berbeda), urutan pastinya bisa berubah; tren yang robust adalah bahwa MPF dengan $\|x\|_1$ kecil berkinerja baik, MPF statis-eksak dengan $\|x\|_1$ besar diperkuat oleh noise hardware, dan sirkuit tunggal yang terlalu dalam dibatasi noise.

Langkah selanjutnya

Rekomendasi

Jika kamu merasa karya ini menarik, kamu mungkin tertarik dengan materi berikut:

How to choose the Trotter steps for an MPF — panduan praktis memilih nilai $k_j$ untuk menghindari ketidakstabilan
How to use the approximate model — menyesuaikan batasan norma- $L_1$ dan opsi solver untuk MPF statis-aproksimasi
qiskit-addon-mpf API reference — dokumentasi lengkap untuk modul statis, dinamis, dan backend

Referensi

[1] Vazquez, A. C., Egger, D. J., Ochsner, D., & Woerner, S. Well-conditioned multi-product formulas for hardware-friendly Hamiltonian simulation. Quantum, 7, 1067 (2023)

[2] Zhuk, S., Robertson, N. F., & Bravyi, S. Trotter error bounds and dynamic multi-product formulas for Hamiltonian simulation. Physical Review Research, 6(3), 033309 (2024)

[3] Robertson, N. F., et al. Tensor network enhanced dynamic multiproduct formulas. arXiv:2407.17405 (2024)

Hasil pembelajaran​

Prasyarat​

Latar Belakang​

Apa itu multi-product formulas?​

Bagaimana koefisien-koefisien ditentukan?​

Kapan menggunakan MPF​

Kapan MPF mungkin tidak membantu​

Apa yang dibahas tutorial ini​

Persyaratan​

Persiapan​

Contoh simulator skala-kecil​

Langkah 1: Petakan input klasik ke masalah kuantum​

Bangun sirkuit Trotter​

Langkah 2: Optimalkan masalah untuk eksekusi hardware kuantum​

Langkah 3: Eksekusi menggunakan primitif Qiskit​

Langkah 4: Pasca-proses dan kembalikan hasil dalam format klasik yang diinginkan​

Koefisien MPF statis​

Menyiapkan LSE​

Optimalkan xxx menggunakan model eksak​

Optimalkan xxx menggunakan model aproksimasi​

Koefisien MPF dinamis​

Menggabungkan nilai ekspektasi Trotter dengan koefisien MPF​

Contoh hardware skala besar​

Langkah selanjutnya​

Referensi​

Hasil pembelajaran

Prasyarat

Latar Belakang

Apa itu multi-product formulas?

Bagaimana koefisien-koefisien ditentukan?

Kapan menggunakan MPF

Kapan MPF mungkin tidak membantu

Apa yang dibahas tutorial ini

Persyaratan

Persiapan

Contoh simulator skala-kecil

Langkah 1: Petakan input klasik ke masalah kuantum

Bangun sirkuit Trotter

Langkah 2: Optimalkan masalah untuk eksekusi hardware kuantum

Langkah 3: Eksekusi menggunakan primitif Qiskit

Langkah 4: Pasca-proses dan kembalikan hasil dalam format klasik yang diinginkan

Koefisien MPF statis

Menyiapkan LSE

Optimalkan $x$ menggunakan model eksak

Optimalkan $x$ menggunakan model aproksimasi

Koefisien MPF dinamis

Menggabungkan nilai ekspektasi Trotter dengan koefisien MPF

Contoh hardware skala besar

Langkah selanjutnya

Referensi