Trotter-Suzuki Decomposition

Overview

The Trotter-Suzuki decomposition, also called a product formula, is the simplest and most widely used way to simulate how a quantum system changes with time on a quantum computer. A Hamiltonian is usually a sum of simple pieces, such as interactions between neighboring particles. The evolution under the whole sum is hard to implement directly, but the evolution under each piece is easy. Trotter's idea is to alternate among the easy pieces in many short steps, so that their combined effect approximates the true evolution.

This is the method behind most quantum simulation experiments run to date, including digital simulations of spin models on superconducting chips and trapped ions. It is also the baseline against which newer algorithms, such as those based on linear combination of unitaries and quantum signal processing, are compared.

The problem it solves

Simulating how a quantum system evolves over time, when the full evolution operator is too complex to implement directly as a quantum circuit.

History and background

Hale Trotter proved in 1959 that the exponential of a sum of two operators can be written as the limit of alternating exponentials of each, a result in pure mathematics. Masuo Suzuki developed higher-order versions in 1976 and, in 1990 and 1991, constructed systematic fractal decompositions that achieve arbitrarily high order, which he used for quantum Monte Carlo simulations in statistical physics.

Richard Feynman suggested in 1982 that quantum computers could simulate quantum physics, and Seth Lloyd showed in a 1996 Science paper, Universal Quantum Simulators, that product formulas give an efficient way to do it for local Hamiltonians. The first digital quantum simulation experiment, by Lanyon and colleagues in 2011, used trapped ions and Trotter steps. In 2021 Childs, Su, Tran, Wiebe, and Zhu proved improved error bounds with commutator scaling, and in 2023 IBM's 127-qubit utility experiment used Trotterized dynamics of a kicked Ising model.

How it works

Splits the system's total energy description into simpler pieces, then alternates applying each piece for very short time steps — approximating the full evolution increasingly accurately as the steps get smaller.

If two operators A and B commute, the exponential of their sum is exactly the product of their exponentials. If they do not commute, which is the typical case in quantum mechanics, the product differs from the true evolution by an error that depends on their commutator. For a short time step, that error is small, and it shrinks as the step gets shorter.

Splitting total time t into n steps of size t over n, and applying the pieces in turn within each step, gives the first-order formula. The error for each step is of order the square of the step size, so the total error over n steps scales as t squared over n. Doubling the number of steps halves the error.

Symmetrizing the ordering of the pieces cancels the leading error term, giving the second-order formula, whose error scales as t cubed over n squared. Suzuki's recursive construction builds formulas of order 2k, which have errors that fall even faster with n, at the price of a number of stages per step that grows like 5 to the power k minus 1. In practice, a moderate order such as 2 or 4 is a good compromise.

Step by step

1. Write the Hamiltonian as a sum of terms, H equal to H sub 1 plus H sub 2 plus and so on, each of which can be exponentiated by a simple circuit, such as a product of Pauli rotations.
2. Choose the total evolution time t, the number of Trotter steps n, and the order of the formula, based on the target error.
3. For each Trotter step, apply the exponentials e to the minus i H sub j times t over n in a fixed sequence, in the first-order ordering or the symmetrized second-order ordering.
4. Compile each exponential into native gates, for example a rotation about a Pauli string, which uses a ladder of CNOT gates and a single-qubit rotation.
5. Repeat the step n times, then measure the observables of interest or pass the final state to the rest of the algorithm.
6. Check convergence by running with different values of n and extrapolating to the limit of a small step, if needed.

A worked example

Consider two spins with Hamiltonian H equal to J times the Pauli Z Z interaction plus h times the Pauli X on each spin. The ZZ term and the X terms do not commute. For evolution time t equal to 1 and strengths J and h of order 1, a first-order Trotter formula with n equal to 10 steps applies, in each step, a ZZ rotation by angle 2 J t over n followed by X rotations by angle 2 h t over n.

The error scales as t squared over n, so n equal to 10 gives an error of order a few percent, and n equal to 100 gives an error of order a tenth of a percent. On real hardware, every extra step adds gates and noise, so the best number of steps balances Trotter error against hardware error, and the optimum is often much smaller than the theoretical bound suggests.

Complexity and resources

What hardware it needs

• Native two-qubit gates, ideally with all the interactions in the Hamiltonian matched to the hardware's connectivity.
• Enough coherence for the full sequence of steps, with total depth proportional to the number of steps times the terms per step.
• No fault tolerance is strictly needed for small demonstrations, making it a natural near-term method.

Applications

• Simulating dynamics of spin models, such as Ising and Heisenberg chains, on current quantum hardware.
• Time evolution in quantum chemistry and materials science, often as part of larger algorithms.
• Preparing states by adiabatic evolution with a Trotterized schedule.
• Benchmarking quantum devices with circuits that have known classical solutions in limits.

Limitations and caveats

• The error decreases slowly with the number of steps, so high accuracy needs many gates.
• The dependence on precision is polynomial, worse than the logarithmic dependence achieved by newer methods.
• For molecules with many non-commuting terms, the cost can be large.
• Noise on current devices limits the number of steps that can be run.

Common misconceptions

• Trotterization does not give exact time evolution. It is an approximation whose error you must control.
• Smaller steps are not always better on a noisy device, since each step adds hardware error.
• The worst-case bounds are usually pessimistic. Observed errors can be much smaller.

How it compares

• Linear combination of unitaries and quantum signal processing reach logarithmic scaling in 1 over the error but need more ancilla qubits and deeper circuits per step.
• Randomized product formulas such as qDRIFT sample terms at random, trading some accuracy for independence from the number of terms.
• Variational approaches avoid explicit time stepping but lack accuracy guarantees.

Real-world impact

The foundational method underlying most practical quantum simulation algorithms used in chemistry and materials science applications today, including implementations on real NISQ hardware.

Why it matters

Trotterization is the workhorse of digital quantum simulation, the application that Feynman proposed as the main reason to build quantum computers. Almost every demonstration of quantum dynamics on real hardware uses it, so understanding its error and cost is essential for reading experimental papers.

It is also a good illustration of the trade-off between algorithmic simplicity and asymptotic efficiency. Newer methods win on paper for large systems and high precision, while Trotter remains competitive on today's small, noisy machines.

Frequently asked questions

Keep learning

• Related algorithm: Linear Combination of Unitaries (LCU)
• Related algorithm: Quantum Signal Processing (QSP)
• Related algorithm: Quantum Phase Estimation (QPE)
• Related algorithm: Variational Quantum Eigensolver (VQE)

This page is written for educational purposes. Complexity statements describe the best known results at the time of review (September 30, 2026), and research in this area moves quickly, so check recent papers before relying on a specific bound.

← Back to Algorithms Database