Commutator-free propagator (CFET)

The scheme — two exponentials at two-point Gauss–Legendre nodes, weighted (3 ± 2√3)/12 — is the standard fourth-order commutator-free exponential time propagator for driven quantum systems, introduced by Alvermann & Fehske (2011), High-order commutator-free exponential time-propagation of driven quantum systems, J. Comput. Phys. 230, 5930.

alg = "cfet" writes each step as a product of exponentials of plain weighted sums of the channel operators, evaluated at Gauss–Legendre nodes:

U(t+h, t) ≈ exp(-i h W₂) exp(-i h W₁),   Wⱼ = Σₐ wⱼₐ H⁽ᵃ⁾

It reaches fourth order without ever forming a commutator. Since commutators are what inflate MPO bond dimension in the Magnus route, each generator here is no larger than H(t) itself — the cost is two TDVP applications per step instead of one, which turns out to be a bargain:

steps	`"magnus"` order 2	`"cfet"` order 4
8	7.45 s, err 5.6e-4	4.13 s, err 3.8e-4
16	14.95 s, err 3.7e-5	7.16 s, err 2.4e-5
32	29.00 s, err 2.5e-6	12.44 s, err 1.7e-6

Measured convergence order 3.97 / 3.99 / 3.86 against an exact dense reference. order = 2 degenerates to the exponential midpoint rule and reproduces "piecewise_constant" exactly (measured order 2.00), which is a useful cross-check that the two share a limit.

"cfet" measured strictly better than "magnus" — roughly 2× faster and ~1.5× more accurate at equal step count — which is why it is the default algorithm for time_evolve.

ψ = time_evolve(channels, ψ0, 0.0, 10.0; nsteps = 100)   # "cfet" by default

A floor, not unbounded convergence

Refining the step count only helps up to a point. Each step still runs through TDVP, and — as documented on The time_evolve interface page — a fixed generator exponentiated by 2-site TDVP has its own roundoff floor: accuracy improves for the first few sweeps, then degrades as more, smaller sweeps accumulate per-application roundoff. For the benchmark model here that floor sits around nsteps ≈ 16; refining well past it can make CFET (or Magnus) less accurate, not more. Consequently, do not validate a fine-step run against the same method at an even finer step count as "ground truth" — it can itself be sitting on that floor, which silently invalidates the comparison. The test suite checks against an independent dense RK4 reference for exactly this reason.

Reference

ITensorTDMPO.cfet_evolve — Function

cfet_evolve(channels, ψ0, times; order = 4, kwargs...)
cfet_evolve(channels, ψ0, t_start, t_stop; dt = nothing, nsteps = nothing, kwargs...)

Time-evolve ψ0 with a commutator-free exponential time propagator (CFET): the step is written as a product of exponentials of plain weighted sums of the channel operators, evaluated at Gauss–Legendre nodes,

\[U(t+h, t) \approx e^{-i h W_2} \, e^{-i h W_1}, \qquad W_j = \sum_a w_{ja} H^{(a)}\]

with the weights of CF4_WEIGHTS at the nodes of CF4_NODES.

This reaches fourth order — the same as magnus_evolve at order = 2 — without ever forming a commutator. Since commutators are what inflate MPO bond dimension in the Magnus route, each generator here is no larger than H(t) itself, at the cost of two TDVP applications per step instead of one.

That trade turns out to be strongly favourable. Measured on the paper's modulated TFIM at N = 8 with exact bond dimension, against an exact dense reference:

steps	`magnus` order 2	`cfet` order 4
8	7.45 s, err 5.6e-4	4.13 s, err 3.8e-4
16	14.95 s, err 3.7e-5	7.16 s, err 2.4e-5
32	29.00 s, err 2.5e-6	12.44 s, err 1.7e-6

so CFET is roughly 2× faster and ~1.5× more accurate at equal step count — it dominates Magnus outright on this benchmark. Measured convergence order 3.97 / 3.99 / 3.86.

order = 2 degenerates to the exponential midpoint rule, which is what piecewise_constant_tdvp already does; order = 4 is the useful setting.

Keywords

order = 4: 2 or 4.
generator_prefactor = -im: each exponential applies exp(prefactor · h · Wⱼ). Pass -1 for imaginary time.
operator_kwargs = (;): truncation of the weighted sums Wⱼ.
tdvp_kwargs = (; cutoff = 1e-10): forwarded to tdvp.
normalize = false: renormalize after each step; set true for imaginary time.
(step_observer!) = nothing, outputlevel = 0: as for the other drivers.

source

cfet_evolve([(f1, H1), (f2, H2), ...], ψ0, args...; kwargs...)

Convenience form taking the channels as a plain list of (driving, MPO) tuples or pairs (see DrivingChannels), for calling this driver directly without building the DrivingChannels object yourself.

source

ITensorTDMPO.cfet_exponents — Function

cfet_exponents(channels, t0, t; order = 4, cutoff, maxdim)

The generators of the exponentials making up one commutator-free step, innermost (applied first) first. Each is a plain weighted sum of the channel operators — no commutators are formed, which is the whole point of the scheme.

source

ITensorTDMPO.CF4_NODES — Constant

Gauss–Legendre nodes on [0, 1] used by the fourth-order commutator-free scheme of Alvermann & Fehske (2011), High-order commutator-free exponential time-propagation of driven quantum systems, J. Comput. Phys. 230, 5930.

source

ITensorTDMPO.CF4_WEIGHTS — Constant

Weights of the fourth-order commutator-free exponential time propagator. Each exponential uses one ordering of these two weights across the two Gauss nodes; they sum to 1/2 so that the two exponentials together carry the full step.

source