--- title: Trotterized time evolution of the 2D tilted-field Ising model with LTM AI-QEM description: Simulate Trotterized 2D tilted-field Ising dynamics with Qiskit and the LTM AI-QEM function for quantum error mitigation. source: https://eu-de.quantum.cloud.ibm.com/docs/en/tutorials/trotterized-time-evolution-ltm --- # Trotterized time evolution of the 2D tilted-field Ising model with LTM AI-QEM *Usage estimate: 75 seconds on a Heron r2 processor (LTM AI-QEM: 23 seconds, ZNE: 52 seconds). (NOTE: This is an estimate only. Your runtime might vary.)* Explore the [API reference](/docs/functions/ltm-ai-qem/api-reference) for detailed function specifications. To start using the function, follow the [LTM AI-QEM guide](/docs/functions/ltm-ai-qem). ## Background This tutorial simulates the Trotterized time evolution of the tilted-field Ising model with the LTM AI-QEM function. Originally conceptualized to understand ferromagnetism and quantum phase transitions in magnetic materials, the Ising model [\[1\]](#references) has become a cornerstone of modern many-body physics. At its fundamental level, the model describes a lattice of interacting spins, where each spin can occupy one of two states and interacts with its nearest neighbors. The real-time dynamics of two-dimensional Ising systems become increasingly difficult to simulate classically as the system size and evolution time increase, which makes them an important testbed for quantum simulation. Moreover, because the Hamiltonian is composed of local single-qubit fields and nearest-neighbor two-qubit interactions, its time evolution can be naturally represented with sequences of single- and two-qubit quantum gates. These properties make the model a useful benchmark for studying quantum dynamics on present-day hardware and for evaluating the effectiveness of quantum error mitigation methods. This tutorial covers the following steps: - Describe the tilted-field Ising model and its Trotterized time evolution mathematically. - Define the backend and the qubits on which to simulate the Hamiltonian, and visualize them. - Define the tilted-field Ising Hamiltonian with the Qiskit `SparsePauliOp` class. - Construct the quantum circuits for the evolution of the Hamiltonian with the Qiskit `evolved_operator_ansatz` function. - Define the observable that corresponds to the average magnetization, again with the `SparsePauliOp` class. - Compute the evolution of the average magnetization for an increasing number of Trotter steps with the LTM AI-QEM function. - Apply the zero-noise extrapolation (ZNE) method to the raw QPU results, to compare against the mitigation performed by the LTM AI-QEM function. - List the values of the average magnetization computed with the sparse Pauli dynamics (SPD) algorithm, which serve as the ideal values. - Visualize all of the results to compare the average magnetization mitigated by LTM AI-QEM with the unmitigated results, the results mitigated by ZNE, and the results from the classical SPD algorithm. ## Requirements Install the following Python packages before running the notebook: - Qiskit SDK v2.6.1 or later (`pip install qiskit[all]`) - `qiskit-ibm-runtime` v0.50.0 or later (`pip install qiskit-ibm-runtime`) - Quantum Functions Catalog v0.21.0 or later (`pip install qiskit-ibm-catalog`) - Matplotlib v3.11.2 or later (`pip install matplotlib`) ## Setup Authenticate using your [IBM Quantum® Platform API key](/), and select the LTM AI-QEM function as follows. (This snippet assumes that you already [saved your account](/docs/ibm-quantum-platform/functions-get-started#install-qiskit-functions-catalog-client) to your local environment.) ```python from qiskit_ibm_catalog import FunctionsCatalog catalog = FunctionsCatalog(channel="ibm_quantum_platform") # Access the LTM AI-QEM function ltm_function = catalog.load("ltm/ai-qem") ``` Later in this tutorial, you use the `ltm_function` object to run the quantum circuits and get both the mitigated and unmitigated results. First, define the problem. ## The tilted-field Ising model and its time evolution The Hamiltonian for the tilted-field Ising model is as follows: $$ H = {g_x}\sum_{k\in{N}}{X_k} + {g_z}\sum_{k\in{N}}{Z_k} + J\sum_{\begin{matrix} {(k,l)}{\in}{E} \\ {k0 is better) - pct_improvement: 100 * (MAE_unmitigated - MAE_method) / MAE_unmitigated - error_reduction_factor: MAE_unmitigated / MAE_method (>1 is better) - frac_steps_improved: fraction of steps where the method beats unmitigated """ spd = np.asarray(spd_results, dtype=float) errs = { "Unmitigated": np.abs(spd - np.asarray(noisy_evs, dtype=float)), "ZNE": np.abs(spd - np.asarray(zne_evs, dtype=float)), "LTM AI-QEM": np.abs(spd - np.asarray(mitigated_evs, dtype=float)), } base = errs["Unmitigated"] base_mae = base.mean() eps = 1e-12 metrics = {} for name, e in errs.items(): mae = e.mean() metrics[name] = { "mae": mae, "rmse": float(np.sqrt(np.mean(e**2))), "mean_improvement": float((base - e).mean()), "pct_improvement": float( 100 * (base_mae - mae) / max(base_mae, eps) ), "error_reduction_factor": float(base_mae / max(mae, eps)), } return metrics def plot_trotter_results( trotter_steps, spd_results, mitigated_evs, mitigated_errs, zne_evs, zne_errs, noisy_evs, noisy_errs, title="", print_summary=True, ): """Plot magnetization versus Trotter steps, and the absolute difference from SPD for each method. Top: average magnetization for each method. Bottom: grouped bars of |SPD - method|, with mean improvement annotated. Returns a dict of improvement metrics (see compute_improvement_metrics). """ spd = np.asarray(spd_results) steps = np.asarray(trotter_steps) metrics = compute_improvement_metrics( spd_results, mitigated_evs, zne_evs, noisy_evs ) series = [ (spd_results, None, "Sparse Pauli Dynamics", "*", "green"), ( mitigated_evs, mitigated_errs, "Mitigation by LTM AI-QEM", "P", "royalblue", ), (zne_evs, zne_errs, "Mitigation by ZNE", "^", "darkorange"), (noisy_evs, noisy_errs, "Unmitigated", "X", "red"), ] fig, (ax1, ax2) = plt.subplots( nrows=2, ncols=1, figsize=(12, 10), sharex=True, height_ratios=[2, 1] ) for values, errs, label, marker, color in series: ax1.errorbar( steps, values, yerr=errs, label=label, marker=marker, color=color, markeredgecolor="black", markeredgewidth=0.5, ecolor="black", capsize=5, ) ax1.set_ylabel("Average Magnetization") ax1.set_title(title) ax1.grid(alpha=0.3) ax1.legend() # Bottom: grouped bars with MAE and % improvement in the legend labels bars = [ (mitigated_evs, "LTM AI-QEM", "royalblue"), (zne_evs, "ZNE", "darkorange"), (noisy_evs, "Unmitigated", "red"), ] n = len(bars) width = 0.8 / n for i, (values, key, color) in enumerate(bars): offset = (i - (n - 1) / 2) * width m = metrics[key] if key == "Unmitigated": label = f"|SPD - {key}| (MAE={m['mae']:.3f})" else: label = ( f"|SPD - {key}| (MAE={m['mae']:.3f}, " f"{m['pct_improvement']:+.1f}% vs unmitigated)" ) ax2.bar( steps + offset, np.abs(spd - np.asarray(values)), width=width, label=label, color=color, edgecolor="black", linewidth=0.5, ) if key != "Unmitigated": pass ax2.axhline( m["mae"], color=color, linestyle="--", linewidth=1, alpha=0.8 ) ax2.set_xticks(steps) ax2.set_xlabel("Trotter Steps") ax2.set_ylabel("|SPD - method|") ax2.set_title( "Difference from SPD (closer to 0 is better; dashed = mean error)" ) ax2.grid(alpha=0.3, axis="y") ax2.legend() fig.tight_layout() plt.show() if print_summary: print( f"{'Method':<12}{'MAE':>10}{'RMSE':>10}{'Mean impr.':>12}" f"{'% impr.':>10}{'Factor':>9}" ) for name, m in metrics.items(): print( f"{name:<12}{m['mae']:>10.4f}{m['rmse']:>10.4f}" f"{m['mean_improvement']:>12.4f}{m['pct_improvement']:>9.1f}%" f"{m['error_reduction_factor']:>9.2f}" ) return None ``` ```python plot_trotter_results( trotter_steps, spd_results, mitigated_evs, mitigated_stds, zne_evs, zne_stds, noisy_evs, noisy_stds, ) ``` Output: ![Output of the previous code cell](https://eu-de.quantum.cloud.ibm.com/docs/images/tutorials/trotterized-time-evolution-ltm/extracted-outputs/84a5d8f2-0.avif) ``` Method MAE RMSE Mean impr. % impr. Factor Unmitigated 0.2660 0.2852 0.0000 0.0% 1.00 ZNE 0.2491 0.2704 0.0169 6.4% 1.07 LTM AI-QEM 0.0554 0.0617 0.2106 79.2% 4.80 ``` The LTM AI-QEM results closely follow the SPD results for all Trotter steps. LTM AI-QEM reduces the mean absolute error (MAE) to 0.055, compared with 0.249 for ZNE and 0.266 for the unmitigated results. This is a 79.2% improvement over the unmitigated results, whereas ZNE provides a 6.4% improvement. The corresponding root mean squared error (RMSE) values are 0.062 for LTM AI-QEM, 0.270 for ZNE, and 0.285 for the unmitigated results. LTM AI-QEM achieves this improvement without additional QPU time, because the correction is applied during post-processing. ## References \[1] [J. Vovrosh et al., “Simulating dynamics of the two-dimensional transverse-field Ising model: A comparative study of large-scale classical numerics,” Physical Review Research 8, 023311 (2026).](https://journals.aps.org/prresearch/abstract/10.1103/x4gs-g63p) \[2] [T. Begusic, J. Gray, G. K. Chan, Sci. Adv. 10, eadk4321 (2024). arXiv:2308.05077 (2023).](https://arxiv.org/abs/2308.05077) \[3] [T. Begusic, G. K. Chan, PRX Quantum 6, 020302 (2025).](https://link.aps.org/doi/10.1103/PRXQuantum.6.020302) \[4] [Y. Kim, A. Eddins, S. Anand, K. X. Wei, E. Van Den Berg, S. Rosenblatt, H. Nayfeh, Y. Wu, M. Zaletel, K. Temme, and A. Kandala, “Evidence for the utility of quantum computing before fault tolerance,” Nature 618, 500 (2023).](https://doi.org/10.1038/s41586-023-06096-3) \[5] [GitHub tbegusic/spd](https://github.com/tbegusic/spd)