Case Study: Choosing a Trotter Step Size

Executive Summary

Simulating time evolution requires splitting $e^{-iHt}$ into pieces, and the step size controls a direct trade: small steps mean small Trotter error and many gates; large steps mean few gates and large Trotter error. On a noisy device there is a third term, because more gates also means more hardware error — so the total error curve has a minimum, and running with the smallest possible step size is actively wrong.

This case study finds that minimum for a concrete Hamiltonian, on real hardware parameters, and shows that the optimal step size on a NISQ device is far coarser than numerical-analysis intuition suggests.

Skills applied

• Deriving Trotter error scaling for first- and second-order formulas (§17.5).
• Counting gates per Trotter step for a given Hamiltonian (§17.7).
• Combining algorithmic and hardware error into a total error model.
• Optimizing a discretization parameter against a real error budget.

Phase 1: The Hamiltonian

A 6-site transverse-field Ising chain:

$$H = -J\sum_{i=1}^{5} Z_iZ_{i+1} - h\sum_{i=1}^{6} X_i$$

with $J = 1$, $h = 0.8$. The two terms do not commute: $[Z_iZ_{i+1}, X_i] \ne 0$. That non-commutativity is precisely the source of Trotter error — and also of the interesting physics.

Target: evolve to $t = 5$ and measure $\langle Z_1 Z_6\rangle$.

Phase 2: Trotter error

First-order Trotter with $r$ steps of size $\Delta t = t/r$:

$$e^{-iHt} \approx \left(e^{-iH_{ZZ}\Delta t}\,e^{-iH_X\Delta t}\right)^{r}$$

Error per step is $O(\Delta t^2\|[H_{ZZ}, H_X]\|)$, so total error is

$$\varepsilon_{\text{Trotter}} \approx \frac{t^2\|[H_{ZZ},H_X]\|}{2r} = \frac{C}{r}$$

Second-order (symmetric) Trotter — half a step of one term, a full step of the other, half again — improves this to $O(t^3/r^2)$.

For this chain, numerically fitting the constants: $C_1 \approx 24$ for first order, $C_2 \approx 31$ for second order (with the $1/r^2$ scaling).

Second order is dramatically better at essentially the same gate cost per step — roughly 1.5× the gates for a quadratically better error. Never use first-order Trotter on hardware; the second-order formula is almost free.

Phase 3: Gate cost

Per second-order Trotter step on this chain:

So $r$ steps cost $10r$ two-qubit gates.

Phase 4: Total error on hardware

Hardware error at $\epsilon_{2q} = 7\times10^{-3}$ per two-qubit gate. Circuit fidelity after $g$ gates is $(1-\epsilon)^g$, and the induced error on an observable bounded by 1 is roughly $1 - (1-\epsilon)^{10r}$.

Total error model:

$$\varepsilon_{\text{total}}(r) \approx \underbrace{\frac{31}{r^2}}_{\text{Trotter}} + \underbrace{\left(1 - (1-0.007)^{10r}\right)}_{\text{hardware}}$$

The optimum is around $r \approx 13$–15, with total error ~0.79 — and even that is poor. Beyond $r \approx 15$, reducing Trotter error makes the answer worse, because every additional step adds more hardware error than it removes algorithmic error.

The counter-intuitive result. A numerical analyst asked to minimize Trotter error would choose $r = 200$. On this device that produces pure noise. The correct step size is set by the hardware, not by the discretization theory.

Phase 5: What to do when the optimum is still bad

Total error of 0.79 on an observable bounded by 1 is not a usable result. Four responses, in order of practicality:

1. Shorten the evolution. Error grows as $t^3/r^2$ while gate count grows as $r$; halving $t$ improves the trade substantially. Ask whether the physics question really needs $t=5$.
2. Better hardware. At $\epsilon_{2q} = 10^{-3}$, the optimum moves to $r \approx 30$ with total error ~0.25 — usable. This is the single largest lever.
3. Error mitigation. Zero-noise extrapolation (Chapter 18) can recover a factor of a few at the cost of many more shots.
4. Better simulation algorithms. Qubitization and LCU methods achieve better asymptotic scaling than Trotter, though with larger constant factors and ancilla requirements — usually worse on small NISQ problems and much better at fault-tolerant scale.

What not to do: report the $r=100$ result because it has the smallest Trotter error. The Trotter error is not the error.

Phase 6: The general procedure

For any Hamiltonian simulation on real hardware:

1. Use second-order or higher Trotter; the improvement is nearly free.
2. Estimate the Trotter constant empirically by simulating small instances exactly and fitting.
3. Count two-qubit gates per step.
4. Build the total error model and find the minimum numerically.
5. Check whether the minimum is small enough to answer the question. If not, change the question or the hardware — not the step size.

Discussion Questions

1. Trotter error falls as $1/r^2$ while hardware error grows roughly linearly in $r$. Show that a minimum must exist and estimate its location analytically.
2. Second-order Trotter costs ~1.5× the gates for quadratically better error. Under what circumstances would first order still be preferable?
3. At $\epsilon_{2q} = 10^{-3}$ the optimum moved from $r=13$ to $r=30$. Derive the scaling of $r_{\text{opt}}$ with $\epsilon_{2q}$.
4. Qubitization scales better asymptotically but has larger constants. At what problem size would you switch?

Your Turn: Extensions

• Implement first- and second-order Trotter for this chain and verify the error scaling against exact diagonalization.
• Build the total error model for your own backend's error rate and locate the optimum.
• Add zero-noise extrapolation and measure how much of the hardware error it recovers.
• Repeat for a Hamiltonian whose terms commute and confirm the Trotter error vanishes.

Key Takeaways

• Trotter error falls as $1/r$ (first order) or $1/r^2$ (second order); hardware error grows with gate count, so total error has a minimum at finite $r$.
• On NISQ hardware the optimum is far coarser than discretization theory alone would suggest — minimizing Trotter error can make the answer worse.
• Second-order Trotter is nearly free relative to first order and should be the default.
• Gate error rate, not step size, is the dominant lever: 7× better fidelity moved the achievable error from 0.79 to 0.25 here.
• Always model total error, find the optimum numerically, and check it is small enough to answer the question before running.