Strong empiricalAlgorithmsProduct-formula Hamiltonian simulation2026-07-16

Trotter–Suzuki Hamiltonian simulation

Approximates the time evolution of a Hamiltonian with non-commuting terms by alternating their individual exponentials.

hamiltonian simulationtrotterproduct formulatime evolution

Atlas stars stay in the public catalog. Saving this entry to your workspace starts an unstarred private copy.

Most Hamiltonians of interest have non-commuting terms, so e^{-iHt} cannot be split exactly into a product of per-term exponentials. Trotter–Suzuki formulas approximate it by alternating the terms in short steps.

Circuit & simulation

q[0]

RX (X term)RZ (Z term)Repeat r steps

|0⟩ at t=π/(2√2) (exact target)50%

|1⟩ at t=π/(2√2) (exact target)50%

What this takes and returns

TakesNothingWhat joins here

No input port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.

Nothing in the Atlas meets this end.

ReturnsNothingWhat joins here

No output port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.

Nothing in the Atlas meets this end.

This record publishes no gate sequence and no register, so there is nothing here to read an interface off. Absent rather than empty. See all 152 →

Where this sits

This record is named by the layer graph at:

Simulate Hamiltonian evolution Slot
Takes An access model for $H$ — a sum of efficiently exponentiable terms, sparse-access oracles, or a block-encoding — plus an evolution time $t$ and a target error $\varepsilon$ . Returns A circuit approximating $e^{-iHt}$ to within $\varepsilon$ , with a stated query or gate count, an ancilla count, and the norm parameter — sparsity times $\lVert H\rVert_{\max}$ , or the LCU 1-norm — that the cost is measured against.
Product-formula (Trotter-Suzuki) simulation Method
Takes An access model for $H$ — a sum of efficiently exponentiable terms, sparse-access oracles, or a block-encoding — plus an evolution time $t$ and a target error $\varepsilon$ . Returns A circuit approximating $e^{-iHt}$ to within $\varepsilon$ , with a stated query or gate count, an ancilla count, and the norm parameter — sparsity times $\lVert H\rVert_{\max}$ , or the LCU 1-norm — that the cost is measured against.

How it works

Simulating $e^{-iHt}$ for a Hamiltonian $H=\sum_j A_j$ with non-commuting terms $A_j$ cannot generally be done by exponentiating each term separately, since $e^{-i(A+B)t}\neq e^{-iAt}e^{-iBt}$ unless $[A,B]=0$ . The first-order Trotter formula approximates it anyway by splitting the evolution into $r$ short steps:

e^{-iHt} \approx \left(\prod_j e^{-iA_j t/r}\right)^{r},

with error $O(t^2/r)$ per Lloyd's original analysis (1996); tighter, commutator-dependent bounds (Childs, Su, Tran, Wiebe, Zhu, 2019) show the error scales with $\sum_{i<j}\|[A_i,A_j]\|$ , vanishing exactly when the terms commute. Suzuki's symmetric (even-order) product formulas reduce the error to $O(t^{p+1}/r^p)$ for order $p$ , at the cost of more exponentials evaluated per step.

Exactly solvable small instance. Take the single-qubit Hamiltonian $H=X+Z=\sqrt2\,\hat n\cdot\vec\sigma$ with $\hat n=(1,0,1)/\sqrt2$ , and note $[X,Z]=-2iY\neq0$ , so a Trotter error genuinely exists here. Exact evolution from $|0\rangle$ gives

e^{-iHt}|0\rangle = \left[\cos(\sqrt2 t) - i\frac{\sin(\sqrt2 t)}{\sqrt2}\right]|0\rangle - i\frac{\sin(\sqrt2 t)}{\sqrt2}|1\rangle,

so $P(|0\rangle) = 1-\tfrac12\sin^2(\sqrt2 t)$ and $P(|1\rangle)=\tfrac12\sin^2(\sqrt2 t)$ . Choosing $t=\pi/(2\sqrt2)$ makes $\sqrt2 t=\pi/2$ , giving $P(|0\rangle)=P(|1\rangle)=0.5$ exactly — a concrete analytic target that the first-order Trotter circuit (alternating $R_X$ and $R_Z$ layers) converges to as the number of steps $r$ grows, with discrepancy shrinking as $O(t^2/r)$ .

Where it is used. Trotterization is the default way to run digital Hamiltonian simulation on gate-based hardware, and underlies quantum chemistry, condensed-matter, and QITE/VarQITE pipelines that need $e^{-iHt}$ or $e^{-H\tau}$ as a subroutine.

Implementation

FrameworkNative

trotter_suzuki_simulation.py

from qiskit import QuantumCircuit

def trotter_step(t, r):
    """First-order Trotter step for H = X + Z on one qubit."""
    qc = QuantumCircuit(1, name=f"Trotter step (t={t:.3f}, r={r})")
    dt = t / r
    for _ in range(r):
        qc.rx(2 * dt, 0)   # e^{-i X dt}
        qc.rz(2 * dt, 0)   # e^{-i Z dt}
    return qc

t, r = 1.1107, 4  # t = pi / (2*sqrt(2)) approximately
qc = QuantumCircuit(1, 1)
qc.append(trotter_step(t, r), [0])
qc.measure(0, 0)

FINAL_CIRCUIT = qc

Quantum vs classical

Classical baseline

Classical simulation of Hamiltonian dynamics on n qubits requires exponentiating or repeatedly applying a 2^n × 2^n matrix, exponential cost in n for generic H.

Quantum claim

The Trotter circuit's depth per step scales polynomially in n and the number of Hamiltonian terms, with total error O(t²/r) controllable by increasing r.

How to compare

Compare total gate count (∝ r × number of terms) and achieved state fidelity/observable error against classical exact or tensor-network simulation for the same Hamiltonian size and evolution time.

Declared gaps

Nobody has reviewed this record for gaps yet.

Literature & references

Universal Quantum Simulators1996 · Seth Lloyd

Original proof that a quantum computer can efficiently simulate local Hamiltonians via Trotterization, with the O(t²/r) error bound.

doi.org/10.1126/science.273.5278.1073 ↗

A Theory of Trotter Error2019 · Andrew M. Childs, Yuan Su, Minh C. Tran, Nathan Wiebe, Shuchen Zhu

Tighter Trotter error bounds in terms of nested commutators, sharpening the resource estimates used in practice.

arxiv.org/abs/1912.08854 ↗

Verification

Strong empirical

Verified by construction
Small-instance agreement
Peer-reviewed paper

Method: The circuit alternates RX/RZ layers implementing a first-order Trotter step for H=X+Z. The exact (non-Trotterized) evolution e^{-iHt}|0> is derived analytically at a specific t and compared against the target the Trotter circuit approximates.
Result: Pass · at t=π/(2√2), exact evolution under H=X+Z gives P(|0>)=P(|1>)=0.5 exactly, the target the Trotter circuit converges to as the step count r grows.
Caveat: This record verifies the product-formula construction and an exact target state at one qubit; it does not measure the actual Trotter error at finite r on hardware.

Facts

Qubits: 1 (toy instance)
Trotter steps: r = 4 (shown)
Error scaling: O(t²/r) first order
Formula: e^{-iHt} ≈ (Π_j e^{-iA_j t/r})^r
Exact target (t=π/(2√2)): P(0)=P(1)=0.5
Higher order: Suzuki: O(t^{p+1}/r^p)

Source

Universal Quantum Simulators ↗

Kind: curated reference
Reviewed by: Leona Quantum curation pass
License: CC BY 4.0-compatible reference metadata

Industry use cases

Simulating molecular and materials Hamiltonians for chemistry
Quantum dynamics of spin chains and lattice models
Subroutine inside QITE and other time-dependent simulation methods