Convergence Tests

A convergence test checks whether a numerical answer approaches a stable limiting value as the approximation is refined. In quantum mechanics this usually means varying grid spacing, domain size, basis size, time step, quadrature rule, solver tolerance, or sample count and watching the reported physical quantity.

Convergence tests are the working evidence behind numerical trust. They turn “the computation ran” into “the answer is stable under the changes that should matter.”

This page owns the practical workflow. Error Estimates explains how to turn convergence behavior into an uncertainty statement.

Benchmark Problems gives the standard exact and controlled quantum systems used to make those tests concrete.

What Converges?

Always name the quantity being tested. Different quantities can converge at different rates:

• an energy eigenvalue;
• an energy splitting;
• a normalized wavefunction;
• an expectation value;
• a transition probability;
• a scattering phase shift;
• a time-evolved density profile;
• a conserved norm or energy;
• a local observable near a singularity or boundary.

A method can converge for low-energy eigenvalues while failing for high-energy states near the cutoff. A wavefunction can be close in norm while a derivative-sensitive observable is not. A time step can preserve norm while accumulating phase error.

Convergence is therefore a statement about a quantity, a norm or metric, and a refinement path.

Refine One Knob at a Time

A numerical calculation often has several independent approximation parameters:

$$h,\qquad L,\qquad N,\qquad \Delta t,\qquad \tau_{\mathrm{solver}},$$

where $h$ is grid spacing, $L$ is domain size, $N$ is basis size, $\Delta t$ is time step, and $\tau_{\mathrm{solver}}$ is an algebraic solver tolerance.

The basic habit is:

1. hold all but one parameter fixed;
2. refine that parameter over at least three values;
3. record the target quantity;
4. check whether changes shrink in the expected way;
5. repeat for the next parameter.

Changing several parameters at once can hide which error source is limiting the result.

Observed Order

Suppose a quantity has leading error

$$Q(h) = Q + Ch^p + O(h^{p+1}).$$

With results at $h$, $h/2$, and $h/4$, an observed order estimate is

$$p_{\mathrm{obs}} = \frac{ \log \left( \lvert Q(h)-Q(h/2)\rvert / \lvert Q(h/2)-Q(h/4)\rvert \right) }{\log 2}.$$

If the method is in its asymptotic regime and the leading error model holds, $p_{\mathrm{obs}}$ should be close to $p$.

This estimate can fail when the differences are dominated by roundoff, solver tolerance, domain error, cancellation, or a change of eigenstate labeling. Treat unexpected observed order as diagnostic information, not as an annoyance.

Grid-Spacing Refinement

For finite differences, reduce $h$ while holding the physical domain fixed. A second-order stencil should often show $O(h^2)$ behavior for smooth, well-resolved quantities.

For example, if $E_h$ is a low-lying energy,

$$E_h = E + Ch^2 + O(h^4)$$

is common for symmetric second-order discretizations of smooth problems. Halving $h$ should reduce the leading error by about $4$.

Grid refinement must be interpreted with care:

• high-energy states near the grid cutoff converge slowly or not at all;
• nonsmooth potentials can reduce the observed order;
• low-order boundary rows can dominate a high-order interior stencil;
• making $h$ too small can expose roundoff or conditioning issues;
• a fixed finite box may be the dominant error.

For the grid machinery, see Finite Difference Methods.

Domain-Size Refinement

For problems on an infinite domain, first choose a finite computational domain. Then test domain-size error separately from grid-spacing error.

For a localized bound state, increase $L$ and watch whether the target quantity stabilizes:

$$Q(L) \to Q(\infty).$$

For exponentially decaying tails, the error may decrease roughly exponentially with boundary distance once the boundary lies in the forbidden region. For scattering or continuum states, finite-box dependence may remain physically meaningful and should not be dismissed.

A useful two-stage test is:

1. increase $L$ until the answer is insensitive to boundary placement at fixed resolution;
2. refine $h$ inside a sufficiently large domain.

Doing these in the opposite order can waste computation on a finely resolved wrong box.

Basis-Size Refinement

For a basis expansion,

$$\psi_N = \sum_{n=0}^{N-1}c_n\phi_n,$$

increase $N$ and track the target quantity. In a variational Rayleigh-Ritz calculation with a nested trial space and a self-adjoint Hamiltonian bounded below, the ground-state energy often approaches from above:

$$E_0^{(N+1)} \le E_0^{(N)}.$$

This monotonic behavior is powerful, but it depends on the variational setting. It may fail for non-nested bases, non-Hermitian effective Hamiltonians, inconsistent quadrature, or algorithms that do not solve the finite problem accurately.

For spectral methods, coefficient decay is another diagnostic. Rapid decay suggests the basis resolves the function; slow decay indicates limited smoothness, boundary mismatch, or unresolved structure.

Time-Step Refinement

For time-dependent calculations, reduce $\Delta t$ while holding the spatial discretization fixed. If a method is order $q$ in time,

$$Q(\Delta t) = Q + C\Delta t^q + \cdots$$

in the relevant regime. Halving $\Delta t$ should reduce the time-step contribution by about $2^q$.

Time-step convergence should be checked on physical observables, not only on norm. For closed systems, monitor:

• norm preservation;
• energy drift for time-independent Hamiltonians;
• phase-sensitive quantities;
• expectation values;
• probability density shape;
• symmetry quantum numbers.

A norm-preserving method can still have phase error. A stable method can still be inaccurate. The time-integration background is Time-Stepping Methods.

Solver-Tolerance Refinement

Algebraic solver tolerances should be tighter than the discretization error one is trying to observe. Otherwise the convergence test measures the solver stopping rule.

For an eigenvalue calculation, vary the eigensolver tolerance and monitor:

• eigenvalue changes;
• residual norms;
• orthogonality;
• subspace stability near degeneracy;
• symmetry labels.

For implicit time stepping, vary the linear-solve tolerance and check whether norm, energy, and observables change. Solver tolerance is part of the numerical method, not an implementation footnote.

Quadrature Refinement

If matrix elements, normalizations, or expectation values are assembled by quadrature, refine the quadrature rule independently.

Useful checks include:

• increase the number of nodes;
• compare trapezoidal, Simpson, and Gaussian rules when applicable;
• verify exact integrals in a benchmark basis;
• check Hermiticity of assembled matrices;
• monitor cancellation in oscillatory integrals.

Quadrature error can masquerade as basis error. A basis cannot converge if its matrix elements are not computed accurately enough.

Statistical Convergence

For Monte Carlo or measurement-shot estimates, convergence is stochastic. Independent-sample standard errors scale as

$$\operatorname{SE} \propto N^{-1/2}.$$

Convergence tests should include:

• independent random seeds;
• error bars versus sample count;
• autocorrelation or effective sample size for Markov chains;
• bias checks such as burn-in and time-step extrapolation;
• comparison with deterministic benchmarks when available.

More samples reduce variance, not necessarily bias. A tight statistical error bar around a biased estimator is still a precise wrong answer.

Benchmark Comparisons

Benchmarks are problems whose answers are known or independently controllable. Standard quantum benchmarks include:

• infinite square well energies;
• harmonic oscillator spectrum and expectation values;
• free-particle dispersion on a periodic grid;
• two-level-system Rabi oscillations;
• barrier tunneling in limiting regimes;
• hydrogen radial equations;
• exactly diagonalizable small spin systems.

A benchmark should test the same feature used in the real calculation. If the production problem depends on boundary handling, choose a benchmark with nontrivial boundaries. If it depends on long-time phases, use a benchmark with known phase evolution.

Benchmark agreement at one parameter value is not a convergence test. It is a calibration point. The benchmark should also be refined.

Comparing Wavefunctions

Wavefunctions have phase and normalization conventions. Before comparing two numerical wavefunctions, align them.

For normalized states $\psi$ and $\phi$, remove the global phase by maximizing the overlap. A phase-insensitive distance is

$$d(\psi,\phi) = \left( 1-\lvert\langle\psi,\phi\rangle\rvert^2 \right)^{1/2}.$$

Near degeneracy, compare subspaces rather than individual eigenvectors. A tiny perturbation can rotate the basis inside a nearly degenerate eigenspace while leaving physical predictions stable.

For grid wavefunctions, use the discrete inner product with the correct quadrature weights.

Multi-Parameter Convergence

After individual refinements, perform at least one combined refinement check. Some errors interact:

• a smaller grid spacing increases the represented spectral range and can require a smaller time step;
• a larger basis can make an overlap matrix less well conditioned;
• a larger domain can require more grid points to keep the same resolution;
• tighter solver tolerances can reveal previously hidden discretization error.

A practical convergence report often includes a table such as:

run	$L$	$h$	$\Delta t$	tolerance	observable
A	10	0.05	0.002	$10^{-10}$	$Q_A$
B	10	0.025	0.002	$10^{-10}$	$Q_B$
C	12	0.025	0.002	$10^{-10}$	$Q_C$
D	12	0.025	0.001	$10^{-11}$	$Q_D$

The table is not just documentation; it is the argument that the result is stable under meaningful refinement.

When to Stop

Stop refining when the estimated numerical uncertainty is comfortably smaller than the physical question requires.

For example, resolving a $10^{-4}$ energy splitting does not require every individual energy to $10^{-12}$, but it does require the splitting to be stable below $10^{-4}$ under relevant refinements. Conversely, a visually smooth wave packet is not enough if the requested observable is a tiny tail probability.

Computational cost should be spent on the error source that currently dominates.

Common Mistakes

• Refining only the parameter that is easiest to refine.
• Reporting convergence of the norm while the observable of interest is unconverged.
• Using two grid levels and calling the result converged without an observed trend.
• Forgetting to refine the finite domain separately from the grid spacing.
• Comparing wavefunctions without phase alignment or correct inner-product weights.
• Letting solver tolerance dominate a discretization study.
• Trusting variational monotonicity in a setting where its assumptions fail.
• Treating benchmark agreement at one resolution as proof of production accuracy.
• Ignoring high-energy cutoff modes in a time-step convergence test.

Cross-Links

• Error Estimates
• Discretization
• Finite Difference Methods
• Spectral Methods
• Numerical Quadrature
• Matrix Diagonalization
• Sparse Eigensolvers
• Time-Stepping Methods
• PDE Solvers
• Monte Carlo Basics
• Benchmark Problems
• Harmonic Oscillator Spectrum
• Reproducibility Checklist places refinement evidence inside a complete computational release audit.

References

• R. J. LeVeque, Finite Difference Methods for Ordinary and Partial Differential Equations, SIAM, 2007.
• L. N. Trefethen, Spectral Methods in MATLAB, SIAM, 2000.
• J. M. Thijssen, Computational Physics, 2nd ed., Cambridge University Press, 2007.
• T. Pang, An Introduction to Computational Physics, 2nd ed., Cambridge University Press, 2006.
• N. J. Higham, Accuracy and Stability of Numerical Algorithms, 2nd ed., SIAM, 2002.
• D. J. Tannor, Introduction to Quantum Mechanics: A Time-Dependent Perspective, University Science Books, 2007.

Exercises

1. Observed order from three grid spacings.

A calculation gives $Q(h)=1.120$, $Q(h/2)=1.030$, and $Q(h/4)=1.0075$. Estimate the observed order.

Solution

Compute

$$p_{\mathrm{obs}} = \frac{ \log \left( \lvert1.120-1.030\rvert / \lvert1.030-1.0075\rvert \right) }{\log 2}.$$

The ratio is

$$\frac{0.090}{0.0225}=4.$$

Thus

$$p_{\mathrm{obs}} = \frac{\log4}{\log2} = 2.$$

The observed behavior is consistent with second-order convergence.

2. Domain versus grid refinement.

A bound-state energy changes significantly when the box size is increased from $L=8$ to $L=10$, but changes little when $h$ is halved at fixed $L=8$. Which error source is likely dominant?

Solution

The dominant error is likely domain truncation or boundary placement. The grid is already fine enough for the smaller box, but the box itself is still influencing the bound state. Increase the domain until the energy is stable, then repeat grid refinement.

3. Solver tolerance in an eigenvalue calculation.

An eigenvalue changes by $10^{-7}$ when the grid is refined, but by $10^{-4}$ when the eigensolver tolerance is tightened. What should be fixed before interpreting grid convergence?

Solution

The eigensolver tolerance is too loose. The observed changes are dominated by algebraic solver error rather than grid error. Tighten the solver tolerance until eigenvalue changes from further tolerance reduction are comfortably below the grid-refinement changes.

4. Phase-insensitive wavefunction comparison.

Why is $\lVert\psi-\phi\rVert$ not always a good direct comparison between two normalized wavefunctions?

Solution

Quantum states that differ only by a global phase represent the same physical state. If $\phi=e^{i\alpha}\psi$, then $\lVert\psi-\phi\rVert$ can be nonzero even though the states are physically equivalent. A phase-insensitive comparison uses the overlap magnitude, such as

$$d(\psi,\phi) = \left( 1-\lvert\langle\psi,\phi\rangle\rvert^2 \right)^{1/2}.$$

5. Statistical convergence.

If a Monte Carlo estimate has standard error $0.02$ at $N=10{,}000$ independent samples, roughly how many independent samples are needed for standard error $0.005$?

Solution

The desired standard error is smaller by a factor of

$$\frac{0.02}{0.005}=4.$$

Monte Carlo standard error scales as $N^{-1/2}$, so the sample count must increase by $4^2=16$. Thus one needs roughly

$$16\times10{,}000=160{,}000$$

independent samples.