Hamiltonian Simulation

Hamiltonian simulation is the algorithmic task of implementing or approximating the unitary evolution generated by a specified Hamiltonian. For a finite-dimensional, time-independent Hermitian operator $H$, the target is

$$U_H(t) = e^{-iHt/\hbar}.$$

The input is not merely the matrix $H$. An executable problem must say how $H$ is accessed: as exponentiable local terms, sparse-entry oracles, a linear combination of unitaries, a block encoding, a native physical interaction, or some other structured representation. The access model fixes which algorithms apply and what one query hides.

The output is also not a classical wavefunction. The simulation primitive produces a quantum operation, usually to be composed with state preparation, controlled operations, measurements, phase estimation, correlation-function circuits, or another quantum algorithm. A small error in the primitive does not by itself establish a useful scientific prediction; the relevant output and its total uncertainty must still be specified.

The calculations below connect access to $H$, simulation error, and the final observable. Hamiltonian Simulation Algorithms compares the detailed query theorems and their assumptions.

Required background. Digital Quantum Simulation sets up the encoded model and measurement; Algorithmic Primitives introduces coherent queries and block encodings. The unitary-evolution and matrix-exponential pages supply the spectral calculus used below.

Target evolution and error metrics

Specify the finite Hilbert space, Hamiltonian and energy units, access procedure, signed time, and allowed input states before choosing a tolerance. An algorithm that works only in a low-energy subspace solves a different problem from a uniform approximation on every input. A probabilistic procedure also needs a failure probability, distinct from its error on successful runs.

The simulator returns a circuit or physical protocol for $\widetilde U_H(t)$. A strong, state-independent unitary guarantee is

$$\left\| \widetilde U_H(t)-U_H(t) \right\|_{\mathrm{op}} \le \epsilon_{\mathrm{HS}}.$$

This controls every normalized input vector. It also preserves coherent phase relative to a reference branch, which matters for controlled evolution and phase estimation.

If only the induced quantum channel matters, a global phase is unobservable. A phase-insensitive operator distance can minimize over that phase:

$$\min_{\phi\in\mathbb R} \left\| \widetilde U_H(t) -e^{i\phi}U_H(t) \right\|_{\mathrm{op}} \le \epsilon_{\mathrm{ch}}.$$

This is not the diamond distance itself: the induced unitary channels obey $\lVert\widetilde{\mathcal U}-\mathcal U\rVert_\diamond\le2\epsilon_{\mathrm{ch}}$. Noisy channels and postselected operations require their own channel or success-conditioned error statements.

For a fixed input state $\lvert\psi\rangle$, a weaker state-specific promise may suffice:

$$\left\| \left( \widetilde U_H(t)-U_H(t) \right) \lvert\psi\rangle \right\| \le \epsilon_\psi.$$

A local-observable task may be weaker still. These guarantees should not be interchanged after the resource estimate is computed. A method that accurately tracks one low-energy state need not approximate the unitary on the full Hilbert space.

Simulation is not diagonalization

Implementing $e^{-iHt/\hbar}$ does not automatically provide:

• the eigenvalues or eigenvectors of $H$;
• a ground or thermal state;
• all amplitudes of the evolved state;
• a classical description of $H$ learned from data;
• every observable at time $t$;
• an efficient solution for arbitrarily long time.

These may be separate tasks that use Hamiltonian simulation. For example, Quantum Phase Estimation combines controlled evolution with an input having eigenstate overlap and a measurement decoder. Ground-state preparation remains an additional bottleneck. Hamiltonian learning reverses the direction of inference: it uses experimental data to estimate a generator rather than assuming coherent access to that generator.

Metrics and Observable Guarantees

The norm should match the downstream use. Operator norm is convenient for a coherent unitary primitive because it composes under multiplication. If

$$\left\| \widetilde U-U \right\|_{\mathrm{op}} \le\epsilon,$$

then for any normalized $\lvert\psi\rangle$,

$$\left\| \widetilde U\lvert\psi\rangle -U\lvert\psi\rangle \right\| \le\epsilon.$$

The trace distance between the two output pure states is no larger than this vector distance. By convexity, the same state-distance conclusion extends to mixed inputs under the corresponding unitary channels. Consequently, every bounded observable $O$ satisfies

$$\left| \operatorname{Tr} \left[ O \left( \widetilde U\rho\widetilde U^\dagger -U\rho U^\dagger \right) \right] \right| \le 2\lVert O\rVert_\infty\epsilon.$$

This is a worst-case conversion. It may be far looser than the actual error for a local observable, symmetry sector, or selected state. An observable-specific estimate is valuable when it is proved or validated, not when it is inferred merely because the observable is simple.

Errors compose by telescoping

Suppose an algorithm is a product of ideal unitary blocks $U_m\cdots U_1$, while the implementation uses $\widetilde U_m\cdots\widetilde U_1$. Unitary invariance and a telescoping sum give

$$\left\| \widetilde U_m\cdots\widetilde U_1 -U_m\cdots U_1 \right\|_{\mathrm{op}} \le \sum_{j=1}^{m} \left\| \widetilde U_j-U_j \right\|_{\mathrm{op}}.$$

The bound is conservative: coherent errors may cancel or align, and stochastic errors follow a different channel composition. It nevertheless supports a conservative error allocation. Each oracle, arithmetic routine, synthesized rotation, and logical block needs a tolerance compatible with the final budget.

Representation and Hamiltonian Error

Before choosing an algorithm, distinguish the intended Hamiltonian $H$ from the represented generator $\widetilde H$. Duhamel’s identity gives

$$\begin{aligned} e^{-iHt/\hbar} -e^{-i\widetilde Ht/\hbar} &= -\frac{i}{\hbar} \int_0^t e^{-iH(t-s)/\hbar} (H-\widetilde H) e^{-i\widetilde Hs/\hbar} \,ds. \end{aligned}$$

For bounded Hermitian operators,

$$\left\| e^{-iHt/\hbar} -e^{-i\widetilde Ht/\hbar} \right\|_{\mathrm{op}} \le \frac{|t|}{\hbar} \left\| H-\widetilde H \right\|_{\mathrm{op}}.$$

This simple bound has an important consequence: long-time prediction requires correspondingly tighter knowledge of the generator unless structure supplies a better observable-specific argument. More algorithmic precision cannot repair incorrect coefficients, a wrong encoding sector, or a poor physical model.

Energy offsets

For any real $c$,

$$e^{-i(H-cI)t/\hbar} = e^{ict/\hbar} e^{-iHt/\hbar}.$$

The two operators induce the same standalone quantum channel. Subtracting a known energy reference can therefore reduce an LCU or block-encoding normalization without changing state dynamics. The offset is not disposable when the evolution is controlled: its global phase becomes a relative phase on the control. In phase estimation it shifts every inferred energy by $c$ and must be restored in the classical interpretation.

Continuous variables and infinite Hilbert spaces

Circuit algorithms act on finite registers. Bosonic modes, particles in continuum space, and quantum fields therefore require a discretization or cutoff. A declaration such as

$$H_\Lambda = P_\Lambda H P_\Lambda$$

is not yet an error bound. One must control the initial weight outside $P_\Lambda$, transitions through the cutoff boundary, discretization of derivatives or fields, and the target observable’s sensitivity. For unbounded operators, $\lVert H-H_\Lambda\rVert_{\mathrm{op}}$ may be infinite even when low-energy dynamics converge well. State- or energy-constrained estimates are then the appropriate language.

Cutoff size, lattice spacing, volume, boundary conditions, and continuum extrapolation are scientific resources. They should not be hidden inside the qubit count.

Access Models

An access model is a coherent data structure for $H$. Writing down an $N\times N$ matrix classically does not imply an efficient circuit for it. The same mathematical operator can lead to very different simulation costs under different access assumptions.

Exponentiable local terms

Suppose

$$H = \sum_{\ell=1}^{L}H_\ell$$

and each short evolution $e^{-iH_\ell s/\hbar}$ has an efficient circuit. This is the natural input to product formulas and many randomized methods. Implementation costs depend on:

• the decomposition and term order;
• the gate cost and error for each exponential;
• term supports and commutation relations;
• whether negative and controlled times are available;
• coefficient precision and update cost.

A decomposition with small $L$ can still be poor if individual exponentials are expensive. A decomposition with large $L$ can be excellent when terms commute in groups, have low-weight Pauli implementations, or admit parallel execution.

Pauli sums and linear combinations of unitaries

For a qubit Hamiltonian

$$H = \sum_{\ell=0}^{L-1} h_\ell P_\ell, \qquad h_\ell\in\mathbb R,$$

define

$$\lambda = \sum_{\ell=0}^{L-1}|h_\ell|.$$

If $\lambda=0$, then $H=0$ and evolution is the identity. Otherwise omit zero coefficients from the sum. Two coherent oracles provide a standard linear-combination-of-unitaries (LCU) interface. A preparation oracle creates

$$\operatorname{PREPARE}\lvert0\rangle = \sum_{\ell=0}^{L-1} \sqrt{\frac{|h_\ell|}{\lambda}} \lvert\ell\rangle,$$

while

$$\operatorname{SELECT} = \sum_{\ell=0}^{L-1} \lvert\ell\rangle\langle\ell\rvert \otimes \operatorname{sgn}(h_\ell)P_\ell.$$

Complete SELECT on unused index-register states with any unitary, such as $I$; assigning $\operatorname{sgn}(0)=0$ there would not define a unitary oracle. Their sandwich is

$$\left( \langle0\rvert\operatorname{PREPARE}^\dagger \otimes I \right) \operatorname{SELECT} \left( \operatorname{PREPARE}\lvert0\rangle \otimes I \right) = \frac{H}{\lambda}.$$

Thus the oracle pair block-encodes $H$ with normalization $\lambda$. This identity does not say that PREPARE and SELECT are cheap. Their reversible data lookup, coefficient rotations, Pauli addressing, uncomputation, controls, and fault-tolerant synthesis can dominate the final gate count.

Sparse-matrix oracles

A $d$-sparse Hamiltonian has at most $d$ nonzero entries in each row. A reversible location query can preserve its input while writing the column index:

$$O_F\lvert j,\ell,z\rangle =\lvert j,\ell,z\mathbin{\oplus}f(j,\ell)\rangle.$$

Here $\oplus$ is bitwise XOR on a fixed-width output register. The function $f$ includes a specified padding convention for rows with fewer than $d$ entries. This out-of-place definition is reversible even when padding repeats an index. The value query similarly writes a fixed-precision bit string:

$$O_H\lvert j,k,z\rangle =\lvert j,k,z\mathbin{\oplus}\operatorname{enc}(H_{jk})\rangle.$$

The encoding includes real and imaginary parts and their precision. Some sparse-simulation theorems instead assume an in-place location oracle $\lvert j,\ell\rangle\mapsto\lvert j,f(j,\ell)\rangle$. That notation requires a reversible permutation extension on the full register and the stipulated inverse access. An arbitrary padded location function does not supply it; conversion from an out-of-place query may add cost.

Under the appropriate sparse-access assumptions, a common normalization scale is $d\lVert H\rVert_{\max}$, where $\lVert H\rVert_{\max}=\max_{jk}|H_{jk}|$. A query bound counts calls to the specified oracles. A gate count must implement their lookup or reversible arithmetic, including any conversion between oracle models.

Block encoding

With $a$ ancillas, a unitary $U_H$ is an approximate block encoding when

$$\left\| H -\alpha \left( \langle0^a\rvert\otimes I \right) U_H \left( \lvert0^a\rangle\otimes I \right) \right\|_{\mathrm{op}} \le \delta_{\mathrm{BE}}.$$

$\alpha$ and $\delta_{\mathrm{BE}}$ have units of energy in this convention. The normalization obeys $\alpha\ge\lVert H\rVert_{\mathrm{op}}-\delta_{\mathrm{BE}}$ and often exceeds it substantially. The natural dimensionless action is

$$\tau = \frac{\alpha|t|}{\hbar}.$$

For fixed oracle cost, larger $\alpha$ makes simulation harder. Quoting a query count without $\alpha$ is therefore incomplete. Let $B$ be $\alpha$ times the actual encoded block. If $B$ is Hermitian, Duhamel’s bound compares its unitary evolution to that of $H$ and gives

$$\epsilon_{\mathrm{BE,dyn}} \le \frac{|t|}{\hbar} \delta_{\mathrm{BE}}$$

before any phase-processing error is added. A block of a unitary need not be Hermitian: proximity to $H$ alone does not justify treating $B$ as a Hamiltonian. One can instead construct a block encoding of $(B+B^\dagger)/2$, whose error relative to Hermitian $H$ is at most $\delta_{\mathrm{BE}}$, and include that construction’s cost; alternatively use the applicable robust-transformation theorem. Exercise 8 gives a non-Hermitian counterexample.

An error in the full oracle unitary is a different quantity: an operator error $\eta$ per query gives a coarse $Q\eta$ error after $Q$ calls by telescoping. It is not automatically a persistent Hamiltonian perturbation.

Native physical access

If a device evolves directly under $H_{\mathrm{lab}}$, physical time itself is an access primitive. This can be efficient, but it changes the verification problem. The generator must be calibrated, unwanted terms bounded, controls modeled, and target time rescaled. Analog Quantum Simulation explains this calibration and time mapping. A calibrated native block can also be composed with gates as described on Hybrid Quantum Simulation.

Method Families

No method is best independently of the access model, error target, structure, and hardware cost.

Method	Required access	Governing structure	Principal qualification
deterministic product formulas	exponentials of terms $H_\ell$	nested commutators, locality, ordering, step count	direct and ancilla-light, but precision may require many term exponentials
randomized formulas	sampled term exponentials or Pauli rotations	LCU one-norm and average-channel error	low setup and no coherent index register, but random seeds and channel variance matter
truncated Taylor or LCU	coherent PREPARE and SELECT	coefficient normalization, segment count, series order	strong precision scaling with ancillas, arithmetic, and amplification overhead
qubitization and QSP	controlled block encoding and inverse	$\alpha\lvert t\rvert/\hbar$, polynomial degree	near-optimal query scaling, but the oracle expansion can be expensive
interaction-picture or Dyson methods	easy evolution under one part plus time-dependent access to another	integrated interaction normalization and time dependence	can remove a large easy term from the main normalization
variational state propagation	parameterized state and measured tangent data	ansatz residual, metric conditioning, shots	state-specific rather than a uniform coherent unitary guarantee
native analog evolution	calibrated physical generator	model mismatch, leakage, physical time	avoids gate decomposition but has no generic symbolic error parameter

Product formulas

For $H=\sum_\ell H_\ell$, product formulas approximate the exponential by a sequence of term evolutions. For bounded Hermitian terms, a finite-step first-order bound is

$$\left\| e^{-iHt/\hbar} -S_1(t/r)^r \right\|_{\mathrm{op}} \le \frac{t^2}{2r\hbar^2} \sum_{j<k} \left\| [H_j,H_k] \right\|,$$

without an omitted higher-order remainder. Modern analyses can exploit nested commutators, geometry, conservation laws, and local-observable light cones, producing far tighter bounds than replacing every term by its norm.

The formal order does not determine practical performance. One must include the number of exponentials per step, cancellation, ordering, synthesis precision, connectivity, and physical errors. The full derivation and higher-order recursion are derived in Trotter Product Formula.

Randomized formulas

For an LCU $H=\sum_\ell h_\ell P_\ell$, qDRIFT samples term $\ell$ with

$$p_\ell = \frac{|h_\ell|}{\lambda}$$

and applies, for each of $N$ samples,

$$V_\ell = \exp\!\left[ -i\,\operatorname{sgn}(h_\ell) \frac{\lambda t}{N\hbar} P_\ell \right].$$

In the basic analysis, the average-channel error scales as

$$\epsilon_{\mathrm{qD}} = O\!\left( \frac{1}{N} \left( \frac{\lambda t}{\hbar} \right)^2 \right).$$

This dependence is independent of the explicit number of terms $L$, which can be attractive when $L$ is large and $\lambda$ remains manageable. The output of one sampled circuit is not the average channel. A reproducible estimate records random seeds, the number of independently sampled sequences, and the variance across them. Hardware noise can interact with sequence randomness rather than merely add to it.

Truncated Taylor and LCU methods

On a short segment $\Delta t$, the Taylor approximation is

$$e^{-iH\Delta t/\hbar} \approx \sum_{k=0}^{K} \frac{1}{k!} \left( -\frac{iH\Delta t}{\hbar} \right)^k.$$

If $x=\lVert H\rVert\,|\Delta t|/\hbar$, the operator-norm tail is bounded by

$$\left\| e^{-iH\Delta t/\hbar} - \sum_{k=0}^{K} \frac{(-iH\Delta t/\hbar)^k}{k!} \right\| \le e^x \frac{x^{K+1}}{(K+1)!}.$$

When $H$ is an LCU, powers $H^k$ become coherent sums of products of the underlying unitaries. Segmenting time keeps coefficient normalization under control; oblivious amplitude amplification converts the desired encoded block into a near-deterministic unitary. The favorable precision dependence is paid for with coefficient-state preparation, SELECT calls, ancillas, reversible arithmetic, and amplification.

Qubitization and quantum signal processing

For an exact Hermitian block encoding, qubitization constructs invariant signal subspaces of dimension at most two, labeled by eigenvalues $x_j=E_j/\alpha$. Quantum signal processing (QSP) approximates the desired eigenvalue phase

$$f(x)=e^{-i\vartheta x},\qquad \vartheta=\frac{\alpha t}{\hbar},\qquad x\in[-1,1].$$

The polynomial must obey boundedness and parity constraints appropriate to the chosen signal convention. Hamiltonian simulation combines suitable even and odd approximations to the cosine and sine, or uses an equivalent signal construction; an arbitrary complex polynomial is not automatically implementable by one bare QSP sequence. Ancilla success and amplification errors must also be included when converting the encoded result into the desired operation.

With $\tau=|\vartheta|$ and $0<\epsilon<1/2$, a safe joint query upper bound is

$$Q=O\!\left(\tau+\log\frac1\epsilon\right),$$

assuming the specified controlled oracles and inverses. The sharper precision dependence is $O(\log(1/\epsilon)/\log\log(1/\epsilon))$ at fixed nonzero $\tau$, while the time dependence is $O(\tau)$ at fixed error and large $\tau$. These two limits do not imply their naive sum as a uniform joint bound. Low and Chuang explicitly clarify this distinction in footnote 3 of their qubitization analysis.

These are oracle calls. Their gate cost includes phase synthesis, controls, PREPARE, SELECT, arithmetic, and routing. Qubitization and Quantum Signal Processing develops the signal construction and polynomial constraints.

Interaction-picture simulation

Suppose

$$H=A+B,$$

where evolution under $A$ is easy although $\lVert A\rVert$ is large. Write

$$U_H(t) = e^{-iAt/\hbar}U_I(t),$$

where

$$U_I(t) = \mathcal T \exp\!\left[ -\frac{i}{\hbar} \int_0^t B_I(s)\,ds \right]$$

and

$$B_I(s) = e^{iAs/\hbar} B e^{-iAs/\hbar}.$$

Unitary conjugation preserves $\lVert B_I(s)\rVert$, so a method whose main action depends on $B$ rather than $A+B$ can gain substantially. The gain is conditional: implementing coherent, time-dependent access to $B_I(s)$ may require calls to $e^{\pm iAs/\hbar}$, additional clocks, and more arithmetic. The interaction picture moves complexity; it does not erase it.

Variational and learned surrogates

A parameterized circuit can approximate the action of $U_H(t)$ on a selected state family, or compress a trajectory into a low-dimensional manifold. Such methods can reduce coherent depth but generally do not provide a uniform operator-norm approximation on all inputs. Training data, generalization in time or state, optimization cost, and held-out validation become part of the error analysis. Hybrid Quantum Simulation derives variational tangent projection and feedback-error propagation.

Generic Limits and Special Structure

Hamiltonian simulation is efficient for broad structured input models, but the evolution time cannot generally be removed from the complexity. There are sparse black-box Hamiltonian families for which simulating time $t$ requires

$$\Omega\!\left( \frac{\alpha|t|}{\hbar} \right)$$

queries in the relevant natural normalization. Artificially enlarging a loose block-encoding scale $\alpha$ cannot strengthen this physical lower bound. This no-fast-forwarding statement is a worst-case oracle lower bound. It does not say that every physical Hamiltonian is hard or that every circuit must literally have depth proportional to $t$ under every parallel architecture.

Special Hamiltonians may be fast-forwarded or otherwise simplified because they are diagonal in an efficiently accessible basis, commuting, free, integrable, stabilizer-like, low rank, or restricted to a promised subspace. A classical diagonalization that is exponential in system size is not an efficient fast-forwarding construction. The basis transform, eigenvalue arithmetic, controls, and input promise must all be efficient.

Low-energy and local-observable promises

Worst-case operator-norm simulation treats every input state and every part of the spectrum as relevant. Scientific tasks often impose more structure. An initial state may lie in a low-energy subspace, or the output may be a local observable after finite time. Gap amplification, frustration-free structure, and energy-constrained access can improve some low-energy costs. Lieb–Robinson bounds can restrict the region influencing a local observable and make its cost depend on a spacetime light cone rather than the entire lattice.

These gains require explicit promises. A low expectation value does not imply zero high-energy tail, and power-law interactions can broaden light cones. State leakage, boundary truncation, and the actual observable support must be included in the error statement.

Time-Dependent Hamiltonians

For $H(s)$, the target propagator is

$$U(T,0) = \mathcal T \exp\!\left[ -\frac{i}{\hbar} \int_0^T H(s)\,ds \right].$$

Replacing this expression by $e^{-iT H(T/2)/\hbar}$ is an approximation whose validity depends on time variation and commutators at different times. A time-dependent algorithm must specify:

• how $H(s)$ is selected, including a coherent time register when the algorithm requires one;
• time and coefficient precision;
• continuity, differentiability, or bounded-variation assumptions;
• the cost of querying at one time;
• whether the normalization $\alpha(s)$ is known or sampled;
• how endpoint discontinuities and pulse changes are represented.

Adiabatic Quantum Computation treats a specified gapped Hamiltonian path and schedule as the logical computation model, including endpoint decoding and its own resource normalization. Approximating that path’s time-ordered propagator is a separate numerical task: native availability of the path does not automatically provide coherent or controlled oracle access.

Under suitable oracle assumptions, time-dependent algorithms can scale with the integrated action

$$\tau_1 = \frac{1}{\hbar} \int_0^T \alpha(s)\,ds$$

rather than the coarser quantity $T\max_s\alpha(s)/\hbar$. This can be a substantial gain for sharply varying or intermittent generators. Dyson-series, time-dependent product-formula, Magnus, rescaling, and interaction-picture methods impose different smoothness and oracle requirements.

If the supplied generator has a time-dependent error $\Delta H(s)$, Duhamel’s argument generalizes to

$$\left\| U_H(T,0) -U_{H+\Delta H}(T,0) \right\| \le \frac{1}{\hbar} \int_0^T \lVert\Delta H(s)\rVert \,ds.$$

This model error is separate from the algorithm’s approximation to the time-ordered exponential.

Worked Example: One Qubit, Three Views

Consider

$$H = aX+bZ, \qquad a,b\in\mathbb R.$$

Let

$$E = \sqrt{a^2+b^2}.$$

Because $(aX+bZ)^2=E^2I$, the exact evolution is

$$U_H(t) = \cos\!\left( \frac{Et}{\hbar} \right)I -i\sin\!\left( \frac{Et}{\hbar} \right) \frac{aX+bZ}{E}.$$

For $E=0$, interpret the limit as $U_H(t)=I$; no LCU preparation is needed. For $E>0$, this example separates representation, product-formula error, and LCU normalization.

Product-formula view

A first-order $r$-step circuit is

$$S_r(t) = \left[ e^{-iaXt/(r\hbar)} e^{-ibZt/(r\hbar)} \right]^r.$$

Since

$$[aX,bZ] = -2iabY,$$

the finite-step commutator bound gives

$$\left\| U_H(t)-S_r(t) \right\| \le \frac{|ab|t^2}{r\hbar^2}.$$

The formula is exact when $a=0$ or $b=0$, as the commutator diagnosis predicts. The bound can overestimate the actual periodic error and should not be used as an equality.

LCU and block-encoding view

The Pauli decomposition has

$$\lambda = |a|+|b|.$$

PREPARE uses amplitudes $\sqrt{|a|/\lambda}$ and $\sqrt{|b|/\lambda}$, while SELECT applies the signed $X$ or $Z$. The resulting block encoding has action

$$\tau_{\mathrm{LCU}} = \frac{(|a|+|b|)|t|}{\hbar}.$$

The physical spectral action is $E|t|/\hbar$. Their ratio obeys

$$1 \le \frac{|a|+|b|}{\sqrt{a^2+b^2}} \le \sqrt2.$$

Even here, normalization exceeds the operator norm unless one coefficient vanishes. In large Pauli expansions the gap between an LCU one-norm and the spectral norm can be much larger.

Energy-reference view

If the Hamiltonian were

$$H_c = cI+aX+bZ,$$

including $cI$ in the LCU would raise the naive normalization to $|c|+|a|+|b|$. For state dynamics, simulate $H_c-cI$ and ignore the known global phase. For controlled evolution or energy estimation, apply or account for the phase $e^{-ict/\hbar}$ explicitly. A physically irrelevant offset can be algorithmically expensive if the access model is not centered.

From Evolution to an Observable

The useful output determines which controls, powers, and repetitions are needed.

Schrödinger-picture expectation values

For input $\rho_0$ and observable $O$,

$$\mu_O(t) = \operatorname{Tr} \left[ O U_H(t) \rho_0 U_H^\dagger(t) \right].$$

Estimating $\mu_O$ requires repeated state preparation and measurement. If $O=\sum_j o_jP_j$, shot allocation, grouping, readout calibration, and covariance can dominate the evolution circuit. Hamiltonian simulation does not remove the standard error of sampling.

Correlation functions

A dynamical correlator may be

$$C_{AB}(t) = \langle\psi\rvert U_H^\dagger(t) A U_H(t) B \lvert\psi\rangle.$$

Depending on $A$ and $B$, extracting its real and imaginary parts may require an ancilla interferometer, controlled insertions, backward evolution, or special basis measurements. A circuit that implements only uncontrolled $U_H(t)$ may not provide these additional operations.

Spectral estimation

If

$$H\lvert E_j\rangle = E_j\lvert E_j\rangle,$$

then

$$U_H(t_0)\lvert E_j\rangle = e^{-iE_jt_0/\hbar} \lvert E_j\rangle.$$

With the convention $U\lvert E_j\rangle=e^{i\phi_j}\lvert E_j\rangle$, phase estimation reads $\phi_j=-E_jt_0/\hbar$ modulo $2\pi$. Recovering the signed energy therefore requires the corresponding minus sign and a known energy interval or a multiple-time unwrapping strategy. Standard coherent phase estimation resolves a scale $\Delta E$ using evolution times of order $\hbar/\Delta E$, with adequate eigenstate overlap and controlled simulation. This statement concerns that spectral-estimation protocol; extra parametric prior information can define a different estimation problem.

Prepared quantum states

Sometimes the output is the evolved state itself for use by another quantum routine. No immediate tomography is required, but validation still needs operational tests such as symmetries, conserved quantities, Loschmidt echoes, cross-method checks, or selected observables. Saying that a state “is available” should include its preparation success probability and whether the consumer needs a coherent inverse or controlled version.

Propagating errors to the measured output

Model error, a finite cutoff, imperfect access, algorithmic approximation, and hardware noise describe different comparisons. Convert them to a common observable or state/channel metric before adding bounds. For example, Duhamel converts a bounded Hermitian generator error to a dimensionless unitary error; the observable inequality then converts that to the units of $O$. A postselection failure probability cannot simply be added to an energy error.

If $D_{\mathrm{dyn}}$ bounds the trace distance due to preparation and dynamics, and measurement contributes error at most $\epsilon_{\mathrm{meas}}$ on a stated confidence event, a sufficient allocation for tolerance $\epsilon_O$ is

$$2\lVert O\rVert_\infty D_{\mathrm{dyn}} +\epsilon_{\mathrm{meas}}\le\epsilon_O.$$

Systematic biases may align. Statistical uncertainties instead require their covariance and confidence interpretation. There is little benefit in driving algorithmic error far below the model or measurement uncertainty, but a small signal obtained by subtracting large terms can demand tight absolute accuracy.

Resource Accounting

Query complexity is only part of the cost. For a block-encoding method, include:

1. number of calls to $U_H$, $U_H^\dagger$, and controlled variants;
2. gate and depth cost of PREPARE, SELECT, sparse lookup, or arithmetic;
3. block-encoding normalization $\alpha$ and approximation $\delta_{\mathrm{BE}}$;
4. QSP or LCU ancillas, phase precision, and amplification;
5. logical one- and two-qubit gates, non-Clifford gates, and routing;
6. code cycles, logical failure budget, and physical qubits if fault tolerant;
7. state preparations, accepted postselections, measurements, and retries;
8. classical preprocessing, coefficient generation, compilation, and phase synthesis;
9. maximum coherent depth, total interrogation time, and wall-clock latency;
10. output-estimation cost at the requested confidence.

If one block-encoding query costs $G_{\mathrm{BE}}$ logical gates and the phase-processing sequence makes $Q$ queries, a first expansion is

$$G_{\mathrm{signal}} \approx QG_{\mathrm{BE}} +G_{\mathrm{phases}} +G_{\mathrm{control}}.$$

This is still not a hardware estimate. Routing, error correction, measurement, and repetition remain. Resource Estimation Tools explains the conversion from logical circuits to architecture-dependent costs.

Compare equivalent access

A quantum sparse-oracle algorithm should be compared with a classical method given equivalent sparse access, not with a classical program forced to scan a dense matrix. An LCU query should not be priced as one gate if PREPARE performs a large data lookup. Likewise, a classical tensor-network or Monte Carlo method may exploit locality, low entanglement, a favorable sign structure, or a restricted observable that a worst-case Hilbert-space argument ignores.

An end-to-end advantage claim specifies the same model, state family, observable, time, error, confidence, and input-access assumptions on both sides.

Choosing and checking a method

Start with the output and input domain, then compute the relevant commutators, normalization, time, and representation error. Product formulas can be effective when term evolutions are native and ancillas scarce. Qubitization is attractive when a low-normalization block encoding is efficient and high precision is needed. Randomization helps some large Pauli sums; an interaction picture helps when a large term is easy to evolve. Compare complete circuits at matched accuracy, rather than ranking method names alone.

On small instances, independently reconstruct the access oracle and compare the resulting evolution against exact diagonalization. Vary step count, series order, polynomial degree, or random-sequence count. Check coefficient signs, basis order, controls, zero-coupling limits, and the intended global phase. Then test the measured output, including preparation and readout, in a regime where a separate classical or experimental prediction is available.

Conserved quantities and reversal echoes are useful diagnostics, but do not identify the target Hamiltonian by themselves: a perfectly reversible evolution under the wrong generator can pass an echo. Agreement on one small instance likewise does not establish large-instance accuracy or a computational advantage.

Exercises

1. Convert unitary error to observable error

Let $\lVert\widetilde U-U\rVert_{\mathrm{op}}\le\epsilon$. Show that for every normalized pure input and bounded observable $O$, the expectation values after the two evolutions differ by at most $2\lVert O\rVert_\infty\epsilon$.

Solution

Define

$$\lvert\phi\rangle =U\lvert\psi\rangle, \qquad \lvert\widetilde\phi\rangle =\widetilde U\lvert\psi\rangle.$$

Then

$$\lVert\widetilde\phi-\phi\rVert \le \lVert\widetilde U-U\rVert_{\mathrm{op}} \le\epsilon.$$

Add and subtract $\langle\widetilde\phi\rvert O\lvert\phi\rangle$:

$$\begin{aligned} \left| \langle\widetilde\phi\rvert O\lvert\widetilde\phi\rangle -\langle\phi\rvert O\lvert\phi\rangle \right| &\le \left| \langle\widetilde\phi\rvert O (\lvert\widetilde\phi\rangle-\lvert\phi\rangle) \right| + \left| (\langle\widetilde\phi\rvert-\langle\phi\rvert) O \lvert\phi\rangle \right|\\ &\le 2\lVert O\rVert_\infty\epsilon. \end{aligned}$$

The result is worst-case and may be loose for a particular state and observable.

2. Center an energy interval

Suppose $E_{\min}$ and $E_{\max}$ are the actual extreme eigenvalues of $H$. Choose a scalar $c$ that minimizes $\lVert H-cI\rVert_{\mathrm{op}}$ and give the minimum. Why must $c$ still be recorded for phase estimation? What changes if the interval is only a loose enclosure?

Solution

For Hermitian $H$,

$$\lVert H-cI\rVert_{\mathrm{op}} = \max \left( |E_{\min}-c|, |E_{\max}-c| \right).$$

The minimax choice is the interval midpoint,

$$c = \frac{E_{\min}+E_{\max}}{2},$$

giving

$$\min_c \lVert H-cI\rVert_{\mathrm{op}} = \frac{E_{\max}-E_{\min}}{2}.$$

The centered Hamiltonian produces the same standalone state dynamics up to a global phase. Phase estimation measures phases relative to the control, so its energies are shifted by $-c$; adding $c$ back is necessary to report the original spectrum.

For a loose enclosure the midpoint minimizes the guaranteed upper bound, not necessarily the actual norm. For $H=\operatorname{diag}(0,1)$ inside $[-2,4]$, the enclosure midpoint is $1$ and the guaranteed radius is $3$; the true optimal center is $1/2$, with norm $1/2$.

3. Verify the LCU block encoding

Using the PREPARE and SELECT definitions in the text, prove that their all-zero ancilla block equals $H/\lambda$. What fails if the coefficient signs are omitted from SELECT?

Solution

Let

$$\lvert G\rangle = \sum_\ell \sqrt{\frac{|h_\ell|}{\lambda}} \lvert\ell\rangle.$$

Then

$$\begin{aligned} (\langle G\rvert\otimes I) \operatorname{SELECT} (\lvert G\rangle\otimes I) &= \sum_\ell \frac{|h_\ell|}{\lambda} \operatorname{sgn}(h_\ell)P_\ell \\ &= \frac{1}{\lambda} \sum_\ell h_\ell P_\ell = \frac{H}{\lambda}. \end{aligned}$$

Without the signs, the encoded operator would be $\sum_\ell|h_\ell|P_\ell/\lambda$, generally a different Hamiltonian.

4. Compare the one-qubit actions

For $H=aX+bZ$, evaluate the ratio

$$R = \frac{|a|+|b|}{\sqrt{a^2+b^2}}$$

when $|a|=|b|$ and when $b=0$. Interpret the result.

Solution

If $|a|=|b|\ne0$, then

$$R = \frac{2|a|}{\sqrt2|a|} = \sqrt2.$$

If $b=0$ and $a\ne0$, then $R=1$. The LCU normalization equals the spectral norm for a single Pauli term but exceeds it when noncommuting components are encoded separately. Query complexity responds to the access normalization, not only to the physical spectral scale.

5. Distinguish a random circuit from its average

Set $\hbar=1$, $H=(X+Z)/2$, and start in $\lvert0\rangle$. A single qDRIFT step chooses $e^{-itX}$ or $e^{-itZ}$ with equal probability. Find the average $Z$ expectation, compare it with exact evolution, and find the residual variance if one circuit is chosen once and reused for arbitrarily many measurement shots.

Solution

The conditional means are $m_X=\cos(2t)$ and $m_Z=1$, so

$$\overline m=\cos^2t,\qquad \operatorname{Var}_{\mathrm{seed}}(m) =\frac{[1-\cos(2t)]^2}{4}.$$

Exact evolution rotates the initial Bloch vector around $(1,0,1)/\sqrt2$, giving $m_{\mathrm{exact}}=[1+\cos(\sqrt2t)]/2$. Both means start as $1-t^2$, but disagree at order $t^4$. Reusing a single sampled circuit leaves the seed variance even when shot noise vanishes. Resampling independently on every shot instead gives a $\pm1$ random variable with mean $\overline m$ and variance $1-\overline m^2$, so the mean of $M$ shots has variance $(1-\overline m^2)/M$. Neither protocol removes the bias $\overline m-m_{\mathrm{exact}}$ at this fixed one-step approximation.

6. Prove the Hamiltonian perturbation bound

Use Duhamel’s identity to prove

$$\left\| e^{-iHt/\hbar} -e^{-i\widetilde Ht/\hbar} \right\| \le \frac{|t|}{\hbar} \lVert H-\widetilde H\rVert$$

for bounded Hermitian $H$ and $\widetilde H$.

Solution

For $t\ge0$, define

$$F(s) = e^{-iH(t-s)/\hbar} e^{-i\widetilde Hs/\hbar}.$$

Differentiation and integration from $0$ to $t$ give

$$e^{-i\widetilde Ht/\hbar} -e^{-iHt/\hbar} = \frac{i}{\hbar} \int_0^t e^{-iH(t-s)/\hbar} (H-\widetilde H) e^{-i\widetilde Hs/\hbar} \,ds.$$

Both exponentials are unitary, so submultiplicativity gives

$$\left\| e^{-i\widetilde Ht/\hbar} -e^{-iHt/\hbar} \right\| \le \frac{1}{\hbar} \int_0^t \lVert H-\widetilde H\rVert\,ds.$$

This equals $t\lVert H-\widetilde H\rVert/\hbar$. Reversing time gives the absolute-value form.

7. Compare maximum and integrated normalization

A time-dependent oracle has normalization $\alpha(s)=\alpha_0$ for a fraction $q$ of the interval $[0,T]$, with $0<q\le1$, and zero otherwise. Compare $T\max_s\alpha(s)/\hbar$ with the integrated action $\tau_1$.

Solution

The maximum-based quantity is

$$\frac{\alpha_0T}{\hbar}.$$

The integrated action is

$$\tau_1 = \frac{1}{\hbar} \int_0^T\alpha(s)\,ds = \frac{q\alpha_0T}{\hbar}.$$

An algorithm with valid $L^1$-norm scaling can improve the normalization dependence by a factor $1/q$ in this idealized intermittent example. The gain assumes that coherent time access and sampling do not introduce a compensating cost.

8. A unitary with a non-Hermitian signal block

In units with $\hbar=\alpha=1$, let $0<\delta<1$ and define the ancilla unitary

$$U=\begin{pmatrix} i\delta&\sqrt{1-\delta^2}\\ \sqrt{1-\delta^2}&i\delta \end{pmatrix}\otimes I.$$

Verify unitarity. Its top block $B=i\delta I$ approximates the target $H=0$ with operator error $\delta$. Why can one not infer a unitary-evolution error $t\delta$ by treating $B$ as the implemented Hamiltonian?

Solution

The diagonal entries of $U^\dagger U$ are $\delta^2+(1-\delta^2)=1$; the off-diagonal cross terms cancel. Nevertheless $B^\dagger=-B$, so it is not Hermitian. Its formal exponential is $e^{-iBt}=e^{\delta t}I$, which is not unitary, and $\lVert e^{-iBt}-I\rVert=e^{\delta t}-1>\delta t$ for $t>0$.

The block-encoding definition bounds matrix error, not Hermiticity. The Hermitian part $(B+B^\dagger)/2=0$ is the target here, illustrating why a Hermitian construction or a suitable robust-transformation bound is needed.

References

• Y. Atia and D. Aharonov, “Fast-forwarding of Hamiltonians and exponentially precise measurements,” Nature Communications 8, 1572 (2017), doi:10.1038/s41467-017-01637-7.
• D. W. Berry, G. Ahokas, R. Cleve, and B. C. Sanders, “Efficient quantum algorithms for simulating sparse Hamiltonians,” Communications in Mathematical Physics 270, 359–371 (2007), doi:10.1007/s00220-006-0150-x.
• D. W. Berry, A. M. Childs, R. Cleve, R. Kothari, and R. D. Somma, “Simulating Hamiltonian dynamics with a truncated Taylor series,” Physical Review Letters 114, 090502 (2015), doi:10.1103/PhysRevLett.114.090502.
• D. W. Berry, A. M. Childs, and R. Kothari, “Hamiltonian simulation with nearly optimal dependence on all parameters,” in 2015 IEEE 56th Annual Symposium on Foundations of Computer Science, 792–809 (2015), doi:10.1109/FOCS.2015.54.
• D. W. Berry, A. M. Childs, Y. Su, X. Wang, and N. Wiebe, “Time-dependent Hamiltonian simulation with $L^1$-norm scaling,” Quantum 4, 254 (2020), doi:10.22331/q-2020-04-20-254.
• E. Campbell, “Random compiler for fast Hamiltonian simulation,” Physical Review Letters 123, 070503 (2019), doi:10.1103/PhysRevLett.123.070503.
• A. M. Childs, Y. Su, M. C. Tran, N. Wiebe, and S. Zhu, “Theory of Trotter error with commutator scaling,” Physical Review X 11, 011020 (2021), doi:10.1103/PhysRevX.11.011020.
• A. Gilyén, Y. Su, G. H. Low, and N. Wiebe, “Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics,” in Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing, 193–204 (2019), doi:10.1145/3313276.3316366.
• G. H. Low and I. L. Chuang, “Optimal Hamiltonian simulation by quantum signal processing,” Physical Review Letters 118, 010501 (2017), doi:10.1103/PhysRevLett.118.010501.
• G. H. Low and I. L. Chuang, “Hamiltonian simulation by qubitization,” Quantum 3, 163 (2019), doi:10.22331/q-2019-07-12-163.
• G. H. Low and N. Wiebe, “Hamiltonian simulation in the interaction picture,” arXiv:1805.00675 (2018), doi:10.48550/arXiv.1805.00675.
• A. Zlokapa and R. D. Somma, “Hamiltonian simulation for low-energy states with optimal time dependence,” Quantum 8, 1449 (2024), doi:10.22331/q-2024-08-27-1449.