Resource Scaling

A Trotter simulation is built from a simple recipe: chop the total evolution time $t$ into $r$ steps, approximate each step with a product of local exponentials, and repeat. The important question for any practical application is: how do the required resources — circuit depth, gate count, qubit overhead — grow as we demand higher accuracy or longer simulation times?

The first-order error budget

Recall the first-order Lie–Trotter product formula for two non-commuting terms $A$ and $B$ :

e^{-i(A+B)t} = \left(e^{-iAt/r}\,e^{-iBt/r}\right)^r + O\!\left(\frac{t^2 \|[A,B]\|}{r}\right).

The error in a single step of size $\delta = t/r$ is $O(\delta^2 \|[A,B]\|)$ ; after $r$ steps the errors accumulate to $O(r \cdot \delta^2) = O(t^2\|[A,B]\|/r)$ . To keep the total error below a target $\varepsilon$ we need

r \;\geq\; \frac{t^2\,\Lambda}{\varepsilon},

where $\Lambda = \|[A, B]\|$ is a norm capturing the non-commutativity of the Hamiltonian terms. For a $k$ -term Hamiltonian $H = \sum_{j=1}^k H_j$ the analogous bound involves the sum of all pairwise commutator norms.

Second-order (symmetric) Trotterization

The symmetric Suzuki–Trotter formula

e^{-i(A+B)t/r} \approx e^{-iAt/(2r)}\,e^{-iBt/r}\,e^{-iAt/(2r)}

cancels the leading-order error by symmetry. Each step costs roughly twice as many gates, but the accumulated error per step is $O(\delta^3)$ , giving a total error of $O(r \cdot \delta^3) = O(t^3/r^2)$ . To reach accuracy $\varepsilon$ with this formula we need

r \;\geq\; \left(\frac{t^3 \Lambda'}{\varepsilon}\right)^{1/2},

where $\Lambda'$ absorbs higher commutator norms. The step count grows as $t^{3/2}/\varepsilon^{1/2}$ rather than $t^2/\varepsilon$ — a significant improvement when $t$ or $1/\varepsilon$ is large.

More generally, the $2k$ -th order Suzuki formula achieves error $O(t^{2k+1}/r^{2k})$ , giving a step count scaling as $t^{1 + 1/(2k)}/\varepsilon^{1/(2k)}$ , which approaches linear in $t$ (with vanishing $\varepsilon$ -dependence) as the order $k$ grows.

Gate count and circuit depth

For a Hamiltonian with $\Gamma$ Pauli terms, each Trotter step requires $\Gamma$ elementary rotations (one $e^{-i h_j P_j \delta}$ per term). Each such rotation compiles to a constant number of CNOT gates and single-qubit gates. The total gate count is therefore

\text{gates} \;\sim\; r \cdot \Gamma \cdot g,

where $g$ is the per-term gate cost. For a geometrically local Hamiltonian on $n$ qubits (each term acting on at most $\ell$ neighbouring sites), one can often parallelise non-overlapping terms, so the circuit depth is smaller than the gate count by a factor up to $n$ .

Putting it together: a scaling table

The table below summarises how the Trotter step count $r$ (and hence circuit depth) scales with simulation time $t$ and target error $\varepsilon$ for the most common product formulas.

| Formula | Step count $r$ | Error per step | |---|---|---| | First-order | $O(t^2/\varepsilon)$ | $O(\delta^2)$ | | Second-order | $O(t^{3/2}/\sqrt{\varepsilon})$ | $O(\delta^3)$ | | $2k$ -th order | $O\!\left(t^{1+1/(2k)}/\varepsilon^{1/(2k)}\right)$ | $O(\delta^{2k+1})$ |

Practical takeaways

Choosing the step count. Given a simulation time $t$ , an error tolerance $\varepsilon$ , and an estimate of $\Lambda$ from the Hamiltonian structure, the required step count $r$ is set by the appropriate formula above. Increasing $r$ beyond the minimum adds unnecessary circuit depth without improving accuracy.

Error accumulates, not averages. Trotter errors add coherently over steps, not randomly. The $O(t^2/r)$ bound for first order is a worst-case bound; in practice the effective constant can be smaller, but conservative resource estimates should use the analytic bound.

Gate parallelism matters. On hardware with limited qubit connectivity, the mapping from logical to physical qubits can substantially increase the CNOT count. Accurate resource estimates must account for compilation overhead, not just the abstract gate count.

The accuracy–time trade-off. Longer simulation times demand more steps. For $t$ much larger than $1/\Lambda$ , even high-order formulas require deep circuits; this is why fault-tolerant hardware is considered necessary for simulating long-time dynamics of strongly-interacting systems.

Summary

The first-order Trotter formula requires $r = O(t^2/\varepsilon)$ steps; higher-order symmetric formulas reduce this to $r = O((t/\varepsilon)^{1+1/(2k)})$ . Circuit depth is proportional to $r$ times the per-step cost, which grows linearly with the number of Hamiltonian terms. Understanding these scalings is essential for estimating whether a target simulation is within reach of a given quantum device.