Trotter-Suzuki Decomposition

Splitting the evolution of a sum of non-commuting terms into a product of short, individually easy exponentials.

The core identity

Suppose H = A + B where e^(-iAt) and e^(-iBt) are each easy to implement but A and B do not commute. The Lie-Trotter formula states that e^(-i(A+B)t) = lim over r going to infinity of ( e^(-iA t/r) e^(-iB t/r) )^r. For finite r the product is only approximate, but the error shrinks as r grows.

First-order product formula

The single-step first-order approximation is S1(t) = e^(-iAt) e^(-iBt). Its error is set by the commutator: e^(-i(A+B)t) - S1(t) = O(t^2 [A,B]). If A and B commuted, the formula would be exact; the whole cost of simulation comes from non-commutativity.

Trotterization in practice

Divide the total time t into r steps of size t/r. Apply S1(t/r) repeatedly r times. The accumulated error scales as O(t^2/r) per the sum of step errors, so choosing r proportional to t^2/epsilon achieves total error epsilon.

import numpy as np
from scipy.linalg import expm

def trotter_first_order(A, B, t, r):
    step = expm(-1j * A * t / r) @ expm(-1j * B * t / r)
    U = np.linalg.matrix_power(step, r)
    return U

# error vs exact
def trotter_error(A, B, t, r):
    exact = expm(-1j * (A + B) * t)
    approx = trotter_first_order(A, B, t, r)
    return np.linalg.norm(exact - approx, 2)

Many terms

For H = sum over j of H_j, the first-order formula generalizes to the ordered product over j of e^(-i H_j t/r), repeated r times. For local Hamiltonians each H_j acts on a few qubits, so each exponential is a small, hardware-native gate. The total gate count scales with the number of terms times r.

Strengths and limits

• No ancilla qubits are required, unlike LCU or qubitization.
• Circuit structure is simple and regular, easing compilation.
• Error scaling in epsilon is polynomial, worse than the logarithmic scaling of post-Trotter methods.
• Commutator structure can make real error far smaller than worst-case bounds suggest.

Trotterization remains the most widely used method on near-term hardware precisely because it needs no extra qubits and maps cleanly onto physical interactions.