A gate machine cannot apply a continuous evolution directly; it applies a sequence of gates. To simulate $e^{-iHt}$ when $H$ is a sum of terms, it alternates short evolutions of each term — the Trotter product formula. Because those terms do not commute, the alternation is only approximate, and the error is the price of a finite number of steps. Add steps and the price falls. Watch it fall.
Write $H = A + B$. If $A$ and $B$ commuted, $e^{-iHt}$ would factor cleanly into $e^{-iAt}e^{-iBt}$. They do not — that is what makes the dynamics interesting — so the first-order product formula chops the time into $n$ slices and alternates, leaving an error controlled by the commutator $[A,B]$ that scales as $1/n$ per step and vanishes as $n\to\infty$.
The panel makes this exact on one qubit, where $e^{-iHt}$ has a closed form. Take $H = a\,\sigma_x + b\,\sigma_z$ — two terms that genuinely do not commute — evolve $\lvert 0\rangle$, and compare the true final state to the Trotterised one as you vary the number of steps.
The left panel is the Bloch $x$–$z$ plane: the green dot is where the true evolution lands $\lvert 0\rangle$; the blue path is the Trotterised evolution, stepping alternately about $\sigma_z$ and $\sigma_x$. With $n=1$ the blue endpoint misses badly; raise $n$ and it closes on the green. The right panel plots the gate infidelity against $n$ on a logarithmic axis — a straight line of slope near $-2$, the first-order product formula's $1/n^2$ convergence in fidelity.
trotter_steps parameter setting $n$. On many qubits the closed form is gone and the error must be bounded rather than computed — but its character is the one shown here: it comes from the non-commuting terms, it falls with more steps, and it trades circuit depth against accuracy. The single qubit is the case where that trade-off can be watched exactly. This panel's infidelity was checked against a NumPy reference across three Hamiltonians and twelve step counts; the largest disagreement was under $10^{-15}$.Trotterisation is one of the routes the platform uses to put oscillator dynamics on a gate-based quantum computer, alongside variational and open-system methods. It is the most direct — a faithful digital clock for the Hamiltonian — and its depth-versus-accuracy trade-off is exactly what the error-mitigation and pulse-shaping work is there to soften.
| Method | Idea | Trades |
|---|---|---|
| Trotter product formula | alternate short evolutions of each term | circuit depth ↔ accuracy |
| Higher-order Suzuki | symmetric compositions cancel low-order error | more gates per step, fewer steps |
| Variational (VQE / VarQITE) | optimise a shallow ansatz instead of stepping | depth ↔ classical optimisation |
| Error mitigation | extrapolate hardware noise away post hoc | shots ↔ bias |
Evidence boundary: an exactly-solvable single-qubit illustration computed live in your browser and checked against a NumPy reference to better than $10^{-15}$. It shows the product-formula error in the clean case; it is not a hardware run and makes no advantage claim. The multi-qubit compiler carries the same error with a bound rather than a closed form.