The time_evolve interface

time_evolve is the single entry point for every algorithm in this package. The Hamiltonian is always given as driving channels; only alg changes which integrator runs.

ψ = time_evolve(channels, ψ0, 0.0, 10.0; nsteps = 100)                        # cfet (default)
ψ = time_evolve(channels, ψ0, 0.0, 10.0; alg = "magnus", nsteps = 100)
ψ = time_evolve(channels, ψ0, 0.0, 10.0; alg = "dyson", order = 3, nsteps = 100)

Each algorithm also has a direct driver — piecewise_constant_tdvp, dyson_evolve, magnus_evolve, cfet_evolve — which time_evolve forwards to; use those when you want a method-specific option without going through alg_kwargs.

Keywords

Unknown algorithm names raise an ArgumentError listing the valid ones (EVOLUTION_ALGORITHMS).

Which algorithm to use

Use alg = "cfet" (the default) — see Commutator-free propagator (CFET), measured faster and more accurate than alg = "magnus" at equal step count, and uniformly good across the whole accuracy range with no cliff at either end. alg = "dyson" is size-extensive — its accuracy does not degrade with chain length, see Scope and limitations — but CFET/Magnus's exponentiation resums disjoint higher-order terms for free, which the plain truncated Dyson series does not, so CFET/Magnus are markedly more accurate at the same order. That said, if your accuracy target is moderate (roughly 1e-6–1e-8), alg = "dyson" at order 2–3 measured 3–6× cheaper than cfet/magnus for comparable accuracy, because it applies a single MPO per step rather than running an internal TDVP sweep — see When Dyson wins on cost for the full comparison and where that advantage reverses.

Measured infidelity against a dense RK4 reference for a driven TFIM chain (Sz·Sz + an oscillating transverse field) at fixed dt = 0.05, order 2, versus chain length:

dyson_evolve's error grows only mildly over this range (roughly linearly in N) and it beats piecewise_constant_tdvp at every size — a direct consequence of the size-extensive construction it is built on (see Dyson series). Magnus remains the most accurate of the three by several orders of magnitude, for the reason above.

The direct construction dyson_mpo/dyson_terms does not share this scaling: its error grows by a factor of ~1600 over the same range (≈ N^4.7 for this model), worse than simply freezing the Hamiltonian by N ≈ 4 — see Scope and limitations for the mechanism and Dyson series for when to reach for it directly regardless.

Equal-error runtime: Magnus vs. piecewise-constant TDVP

Measured on the paper's modulated TFIM over one period at N = 8 with exact bond dimension (so truncation contributes nothing), against an exact dense RK4 reference:

To be precise about where these orders come from: TDVP is not the limiting factor in either. Two-site TDVP applied to a time-independent generator at exact bond dimension is accurate to ~1e-7 within a few sweeps — it acts as an essentially exact exponentiator. The second order of piecewise_constant_tdvp is entirely the Hamiltonian-freezing error: switching eval_at from :midpoint to :start drops the method to first order (measured ratios 1.99 vs 4.00), with everything else unchanged. So the comparison above is really midpoint freezing (2nd order) versus Ω₁ + Ω₂ with exact time-ordered integrals (4th order), both exponentiated by the same near-exact TDVP.

With truncation, TDVP additionally contributes a projection error, but that is controlled by bond dimension rather than by dt and so does not change these orders.

Magnus costs about twice as much per step but converges at roughly fourth order rather than second, so the equal-accuracy speedup grows as the tolerance tightens:

Asymptotically the ratio scales as ε^(-1/4): reaching error ε needs ns ∝ ε^(-1/2) segmented steps but only ns ∝ ε^(-1/4) Magnus steps. Below about 1e-6 the order-2 Magnus error flattens against the internal TDVP exponentiation error — raise tdvp_kwargs.nsteps there.

CFET (see its own page) beats Magnus on both axes simultaneously and is the better default in practice.

Imaginary time

Pass generator_prefactor = -1 (with normalize = true, since the evolution is no longer unitary) to project toward the ground state:

ψ = time_evolve(channels, ψ0, 0.0, 6.0;
                alg = "cfet", nsteps = 60,
                generator_prefactor = -1, normalize = true)

This works for every algorithm: the factor is carried by the time-ordered integrals for Magnus and Dyson, and applied directly to each exponent for CFET and the piecewise-constant driver.

Reference

time_evolve(channels::DrivingChannels, ψ0::MPS, times; alg = "cfet", kwargs...)
time_evolve(channels, ψ0, t_start, t_stop; dt = nothing, nsteps = nothing, alg = "cfet", kwargs...)

sites = siteinds("S=1/2", 20)
ramp = Ramp(SmoothstepRamp(), 0.0, 10.0, 0.0, 2.0)

# Channels can be given inline as (driving function, MPO) tuples.
ψ = time_evolve([(one, Hzz), (ramp, Hx)], ψ0, 0.0, 10.0;
                nsteps = 100, cutoff = 1e-10, maxdim = 128)

# Same Hamiltonian, different integrator — nothing else changes.
ψ_pc = time_evolve([(one, Hzz), (ramp, Hx)], ψ0, 0.0, 10.0;
                   alg = "piecewise_constant", nsteps = 100)

time_evolve([(f1, H1), (f2, H2), ...], ψ0, t_start, t_stop; kwargs...)

EVOLUTION_ALGORITHMS