Trotter-Suzuki Decomposition

You have a Hamiltonian in hand. Last chapter gave you the zoo — Ising, Heisenberg, Hubbard, molecular — and convinced you that every one of them is a sum of k-local terms, H = \sum_j h_j. Your quantum computer wants to run e^{-iHt}, the unitary that evolves a state for time t under H. You know what each e^{-i h_j t} looks like individually — a small bounded-size unitary on the few qubits h_j touches, which you can compile into elementary gates. What you need is a way to glue those pieces into the full e^{-iHt}.

Here is the wrinkle. If A and B were ordinary numbers, you could write e^{A+B} = e^A \cdot e^B without a second thought. But Hamiltonian terms are matrices, and matrices do not commute in general. The Pauli operators X and Z famously satisfy XZ = -ZX — their product depends on the order. For non-commuting operators, e^{A+B} is not the same as e^A e^B. If you just multiplied the exponentials of the individual terms, you would be computing the wrong unitary.

Trotter's insight — the foundation of quantum Hamiltonian simulation — is that if you chop the time into very small slices, the error from pretending the pieces commute shrinks faster than the number of slices grows. In the limit of infinitely many slices, the approximation becomes exact. For any finite number of slices, the error is controllable. That is what you are going to derive and count in this chapter.

The core obstacle — non-commutativity

Start with the sharpest possible picture. Two 2 \times 2 matrices:

Compute both orderings.

Why they are different: X flips the basis then Z adds a sign to |1\rangle; but Z first adds a sign then X flips — the sign ends up on the other basis element. The commutator [X, Z] = XZ - ZX = -2iY is not zero. Two Pauli operators on the same qubit generically do not commute.

Expand e^{X+Z} as a power series to second order:

Now expand e^X e^Z, also to second order:

Compare the second-order pieces. In e^{X+Z} you have \frac{1}{2}(XZ + ZX) — the symmetric combination. In e^X e^Z you have XZ alone. The difference is

Why this matters: whenever [A, B] \neq 0, the product e^A e^B differs from e^{A+B} at second order in the size of A and B. The leading error is proportional to the commutator. If you make A and B smaller — say, replace A by A/n and B by B/n — the commutator gets smaller by 1/n^2. That is the lever Trotter will pull.

So if A and B do not commute, e^{A+B} is not e^A e^B. What is it?

Trotter's formula — the idea

Trotter's 1959 theorem [1] says this. For any bounded operators A and B (bounded means their operator norms \|A\| and \|B\| are finite — always true for k-local terms with bounded coefficients), the limit

holds exactly. The product of exponentials, if you slice each one into n pieces and interleave them, converges to the exponential of the sum.

Heuristic picture. Cut the time interval [0, t] into n small slices, each of length \Delta t = t/n. Over one slice, evolve first by A alone for time \Delta t, then by B alone for time \Delta t. Do this n times in a row. In the limit n \to \infty, \Delta t \to 0, the non-commutativity error in each slice shrinks like (\Delta t)^2 = (t/n)^2, and since there are n slices, the total error shrinks like t^2 / n \to 0. You end up with the correct unitary e^{A+B}.

That is the idea in one breath. Now make it quantitative.

The first-order Trotter formula

Substitute A \to -iAt, B \to -iBt into Trotter's identity (the -i factors and the time t are absorbed into the operators). The formula becomes

For finite n, define the first-order Trotter approximation

The question is: how close is U_1(t, n) to the true unitary e^{-i(A+B)t}?

The error bound, derived

You can read off the leading-order error from the Baker-Campbell-Hausdorff expansion. For small \Delta t = t/n:

Why: the BCH formula says e^X e^Y = e^{X + Y + \tfrac{1}{2}[X, Y] + \ldots}. Plug in X = -iA\Delta t, Y = -iB\Delta t. The commutator [X, Y] = -\Delta t^2 [A, B]. The leading correction to e^{-i(A+B)\Delta t} is -\tfrac{1}{2}\Delta t^2 [A, B].

Step from one slice to n slices. Each slice introduces an error of size \frac{1}{2}\Delta t^2 \|[A, B]\| in the operator norm. The errors accumulate — roughly, the total error after n slices is n times the per-slice error:

This is the first-order Trotter error bound. It scales as O(t^2 / n) — quadratic in the total time t, inverse in the number of slices n.

Generalising to a sum of J terms

For a local Hamiltonian H = \sum_{j=1}^J h_j, apply the same idea piece by piece. One Trotter step through all J terms is

The full simulation is n Trotter steps:

The error per step picks up contributions from every pair of non-commuting terms. A standard bound [2][4]:

If each \|h_j\| \leq \Lambda (a uniform bound on each term's operator norm) and there are J terms, the sum of commutator norms is at most J^2 \Lambda^2, giving

For k-local Hamiltonians with \|h_j\| = O(1) and J polynomial in the number of qubits N, this is the bound. For many physical Hamiltonians the commutator count is much smaller — only pairs of terms that share a qubit can fail to commute, which for nearest-neighbour 2-local Hamiltonians gives O(N) non-zero commutators, not O(N^2).

Reading the bound. Three knobs control the cost:

• Longer evolution (t bigger) costs quadratically more steps for the same precision.
• Tighter precision (\epsilon smaller) costs inverse-linearly more steps.
• More non-commuting term pairs (J bigger, or more commutator weight) cost linearly more per step.

A picture of one Trotter step

Why locality is the load-bearing assumption

Take a moment to see what makes this work. Each factor e^{-i h_j t/n} is the exponential of a k-local operator. An operator that touches k qubits is a 2^k \times 2^k matrix — size 4 for k=2, size 16 for k=4, a fixed number. Its exponential is another 2^k \times 2^k unitary, and by the Solovay-Kitaev theorem any such unitary can be built out of O(4^k) gates from a universal gate set, to error \epsilon, in \text{polylog}(1/\epsilon) steps.

For bounded k, this is O(1) gates per factor. The full Trotter circuit has J \cdot n factors, each O(1) gates, so the total gate count is O(J n). Setting n = O(J^2 t^2 / \epsilon) to hit error \epsilon gives total gates O(J^3 t^2 / \epsilon) — polynomial in every parameter. This is Lloyd's efficient quantum simulation theorem [2].

Contrast with a generic (non-local) Hamiltonian. An arbitrary 2^N \times 2^N Hermitian has 4^N independent real parameters. There is no hope of decomposing e^{-iHt} into anything polynomial in N; the unitary simply has too much information in it. Locality is what makes the problem tractable, and Trotter is the algorithm that exploits it.

Why this is the Feynman-Lloyd theorem: Feynman (chapter 129) argued that nature, being quantum-mechanical, can only be efficiently simulated by another quantum system. Lloyd's 1996 paper gave the first proof — an explicit quantum algorithm (first-order Trotter) that simulates any k-local Hamiltonian in polynomial time, polynomial space, and with bounded error. Before Lloyd, "efficient quantum simulation" was a hope. After Lloyd, it was a theorem.

Examples — work through the counts

Common confusions

• "Trotter is exact." No — Trotter is exact only in the n \to \infty limit. For any finite n, there is a nonzero error proportional to t^2 / n. The statement "Trotter becomes exact for small step sizes" is right as a limit; "Trotter is exact" is wrong.

• "If the Hamiltonian terms commute, there is no Trotter error." Correct. If every [h_j, h_k] = 0, then e^{-iHt} = \prod_j e^{-i h_j t} exactly, and Trotter gives the answer in n = 1 step. This is the reason diagonalisable Hamiltonians (which are sums of commuting projectors) are trivial to simulate.

• "More Trotter steps always beats the noise trade-off on hardware." No, and this is a real engineering dilemma. Each Trotter step costs gates, and each gate has a small error probability p_{\text{gate}}. For G total gates, the circuit error is roughly G \cdot p_{\text{gate}}, which grows with n. So there is an optimal n that balances Trotter error (falling) against gate noise (rising). Past the optimum, more steps make things worse.

• "Trotter and qubitisation are alternative approaches to the same problem." Close, but they solve the problem differently. Trotter uses the Hamiltonian directly through its time-evolution operator e^{-iHt}. Qubitisation (Low-Chuang 2017) uses a block encoding of H as a sub-block of a larger unitary, and achieves better asymptotic scaling — O(t + \log(1/\epsilon)) instead of Trotter's O(t^2/\epsilon). For very long simulations or very tight precision, qubitisation is the winner; for short simulations and reasonable precision, Trotter is simpler and sometimes cheaper.

• "First-order Trotter is good enough for any problem." The asymptotic scaling n \propto t^2 / \epsilon says otherwise. For chemical-accuracy calculations (\epsilon \sim 10^{-3} Hartree) on molecules over tens of atoms, the gate count at first order exceeds 10^{10} — beyond any foreseeable machine. Higher-order Trotter (next chapter) and post-Trotter methods (LCU, qubitisation) were developed precisely because first-order is not good enough for real chemistry.

• "Trotter only works for Pauli-sum Hamiltonians." Not quite. Trotter works for any sum H = \sum_j h_j where each h_j can be efficiently exponentiated. Pauli-sum form is the most common because e^{-i P \theta} for a Pauli string P is standard. But h_j can be any k-local operator — a projector, a hopping term, a four-fermion Coulomb term — as long as you have a gate implementation for e^{-i h_j \Delta t}.

Going deeper

Baker-Campbell-Hausdorff corrections

The formula e^A e^B = e^{A + B + \tfrac{1}{2}[A, B] + \tfrac{1}{12}([A, [A, B]] - [B, [A, B]]) + \ldots} is the Baker-Campbell-Hausdorff expansion. Every term in the BCH series is a nested commutator of A and B. When you Trotterise with small step \Delta t = t/n, each slice introduces a correction

in the exponent. Summing over n slices, the linear part gives the desired t(A + B); the quadratic commutator term gives a total error \propto n \cdot \Delta t^2 = t^2/n, which is the first-order Trotter error. Pushing BCH to third order gives the leading O(t^3/n^2) correction after careful reshuffling — which is the error of second-order (symmetric) Trotter. Higher-order Suzuki formulas kill these corrections systematically.

Commutator-scaling bounds — tighter than worst-case

The bound \|U_1 - e^{-iHt}\| \leq \tfrac{t^2}{2n} \sum_{j < k} \|[h_j, h_k]\| is tighter than the worst-case bound O(J^2 \Lambda^2 t^2 / n) because many commutators vanish. For a nearest-neighbour 2-local Hamiltonian on an N-qubit lattice, only terms sharing a qubit fail to commute — there are O(N) such non-zero commutators, not O(N^2). Childs et al. 2019 [6] proved commutator-based Trotter bounds with explicit constants, showing that physical Hamiltonians often need far fewer steps than worst-case analysis predicts. This "commutator scaling" is why real-world quantum-chemistry simulations use Trotter in practice.

Post-Trotter methods

Three modern algorithms improve over Trotter.

• Linear Combinations of Unitaries (LCU) [5] (Berry, Childs, Kothari 2015). Expand e^{-iHt} = \sum_k c_k U_k as a linear combination of unitaries — for instance, via the Taylor series e^{-iHt} = \sum_k (-iHt)^k / k!. Apply each U_k via a multiplexed quantum oracle and use amplitude amplification to select the weighted sum. Scaling: O(\tau \log(\tau/\epsilon) / \log\log(\tau/\epsilon)) where \tau = t \|H\|_1.

• qDRIFT (Campbell 2019). Randomly sample terms h_j from H with probability proportional to \|h_j\| and apply them. Expected gate count scales as O(t^2 \|H\|_1^2 / \epsilon) — independent of the number of terms J, a huge win for Hamiltonians with many small terms.

• Qubitisation (Low, Chuang 2017). Block-encode H into a larger unitary and implement e^{-iHt} via Quantum Signal Processing. Scaling: O(t \|H\| + \log(1/\epsilon)) — optimal in both t and \epsilon. See chapter 134.

The hierarchy: Trotter is simplest and most versatile; LCU is better scaling but needs more ancilla qubits; qubitisation is optimal but requires the most complex block-encoding machinery.

Application to quantum chemistry

For real molecules, first-order Trotter applied to the molecular Hamiltonian (Part 15 later chapters) gives gate counts of order 10^{10}–10^{14} for chemical accuracy — well out of reach of NISQ. Much of the last decade of quantum-chemistry-on-QC research is about engineering the constant factors. Key tricks:

• Term ordering. Reordering the terms so commuting groups evolve together can shave orders of magnitude off the gate count.
• Fermionic SWAP networks. Exploit the structure of Jordan-Wigner encodings to compile each e^{-i h_j \Delta t} efficiently.
• Trotter error from the actual commutator structure. Rather than worst-case bounds, numerical studies estimate the true Trotter error for specific molecules and show that fewer steps often suffice.
• Adaptive step sizes. Use small Trotter steps where the Hamiltonian changes rapidly and larger steps elsewhere.

A 2020 paper by Campbell and co-authors estimated that simulating FeMoCo — the nitrogen-fixation enzyme active site — needs around 10^{10} gates with heavily optimised Trotter. With qubitisation, that drops to 10^{8}. Both are beyond NISQ; fault tolerance is required. The open question is whether the hardware gets there before the classical competition (tensor networks, DMRG extended to larger systems) solves the same problems.

Indian research connections

TIFR's theoretical condensed-matter group has published on Trotter-based simulation of Hubbard models; IISc Bangalore's quantum chemistry group (Mukhopadhyay, Mandal, and others) has VQE + Trotter hybrid-algorithm papers. India's National Quantum Mission explicitly lists Hamiltonian simulation as a priority use case for the future fault-tolerant quantum computing effort.

Where this leads next

• Higher-Order Trotter — chapter 132, Suzuki's symmetric and fourth-order formulas that dramatically improve the error-vs-gate-count trade-off.
• Linear Combinations of Unitaries — chapter 133, the first major post-Trotter method.
• Qubitisation and Block Encoding — chapter 134, the optimal-scaling modern method.
• Local Hamiltonians — chapter 130, the structural assumption that makes Trotter efficient.
• Feynman Revisited — chapter 129, the original motivation for quantum Hamiltonian simulation.

References

1. Wikipedia, Lie product formula (Trotter product formula) — the original Trotter 1959 identity and its extensions.
2. Seth Lloyd, Universal Quantum Simulators, Science 273, 1073 (1996) — DOI:10.1126/science.273.5278.1073.
3. Nielsen and Chuang, Quantum Computation and Quantum Information, §4.7 — Cambridge University Press.
4. John Preskill, Lecture Notes on Quantum Computation, Chapter 7 — theory.caltech.edu/~preskill/ph229.
5. Berry, Childs, Kothari, Hamiltonian simulation with nearly optimal dependence on all parameters (2015) — arXiv:1501.01715.
6. Childs, Su, Tran, Wiebe, Zhu, A Theory of Trotter Error (2019) — arXiv:1912.08854.