[lkdvos]

Description

Restructures MPSKit's sweep-based solvers and time integrators as iterators with a common shape, adds an in-place timestep! for infinite TDVP, and fixes three time-evolution bugs found along the way. Apart from the behaviour changes listed below, results, logging and returned values are unchanged.

Sweep solvers

Every converted solver has a state struct, and Base.iterate runs sweep!(it, state, Val(:right), iter) followed by sweep!(it, state, Val(:left), iter), then any finalize or error step. Finite sweeps take their sites from _sweep_ranges. Converted:

• finite find_groundstate with DMRG/DMRG2 (DMRGState, sweep_converged)
• finite approximate! with DMRG/DMRG2
• propagator with DynamicalDMRG (NaiveInvert, Jeckelmann)
• multiline approximate! and leading_boundary with IDMRG/IDMRG2, sharing one IDMRGState and one bond-change measure (bondresidual)

Time evolution

• A single TimeStepState carries one time step t → t + dt (state, operator, environments, time, scheduler, allocator and truncation errors).
• Finite TDVP, TDVP2 and BUG are each just a per-site local_update!. A step is a forward and a backward sweep!, and each half-sweep advances state.t by dt / 2.
• An infinite TDVP step is split into localupdate_step! (concurrent AC/C integration), gauge_step! (regauge and in-place gaugefix!) and recalculate! of the environments.
• _timestep!(alg, state) is the single entry point. One generic finite timestep!, one copying timestep and the shared _timestep_copy live in time_evolve.jl, with alg left abstract. Each algorithm only provides _timestep! and _promotes_to_complex.
• time_evolve/time_evolve!: one iteration is one time step plus finalize. Only the first step copies (or promotes) the state. After that, every step runs in place and reuses the step state's scheduler and allocator.
• New: in-place timestep!(::InfiniteMPS, H, t, dt, ::TDVP), which also makes time_evolve! work for infinite TDVP.

Bug fixes

• InfiniteMPS(C, AR) threw a MethodError (eltype instead of scalartype), which broke infinite TDVP with leftorthflag = false.
• Real-time infinite TDVP from a real InfiniteMPS with a real Hamiltonian failed with an InexactError. The environments are now rebuilt for the promoted complex state, as for finite MPS.
• TDVP, TDVP2 and BUG now promote a real state to complex for imaginary-time evolution with a complex dt, rather than failing.

Behaviour changes

• A finalize callback in time_evolve that keeps the state of an earlier step now sees it updated by later steps, as with time_evolve!, because steps run in place.
• For multiline IDMRG with several rows, the changes of the rows are now summed, as IDMRG2 already did, instead of combined in a 2-norm. This makes the stopping criterion marginally stricter.
• Accumulating state.t per half-sweep can change the time passed to a time-dependent Hamiltonian in the last bit ((t + dt/2) + dt/2 vs t + dt).

Smaller cleanups

• IterLog(::Algorithm) names logs after the algorithm type.
• The redundant = it.state defaults on Base.iterate are removed, since iterativesolvers.jl already provides the one-argument method.
• state arguments are now typed, which avoids method ambiguities with the generic time_evolve iterator.

This gives the finite environment cache from ld-envs per-site hook points in DMRG, TDVP/TDVP2, BUG and dynamical DMRG. ld-envs will be rebased onto this branch. It is also a step towards migrating these solvers to AlgorithmsInterface.jl, which will be a separate PR.

Verification

• Equivalence against main (sweep-solver refactor): scripts ran the same cases on main and on this branch with fixed seeds, comparing with isequal.
  • Compared: raw MPS tensors, AlgorithmInfo fields, energies and returned values, every iteration log record and warning, and the arguments of finalize calls.
  • All 168 cases were identical: 28 DMRG/approximate, 8 dynamical DMRG, 18 IDMRG and 114 TDVP/BUG/time_evolve.
  • Coverage includes converging and maxiter-limited runs, maxiter = 0, CBE and DMRG3S, nearest-neighbour and long-range models, real-valued initial states, time-dependent operators, and empty or single-point t_span.
• Shared finite step state: the 114 finite TDVP/TDVP2/BUG cases are bit-identical before and after reusing the step state across time_evolve steps.
• Infinite TDVP: 222 cases (serial and dynamic schedulers, both gauges, real and complex states and steps, time-dependent operators, time_evolve), compared before and after the infinite rewrite.
  • Every final state where the old code worked is identical.
  • All 59 cases that previously errored (the two bugs above) now run.
  • The remaining differences are expected:
    • finalize snapshots, because steps are in place;
    • one complex-dt case that previously used incorrect real environments;
    • a warning, consistent with finite MPS, when real environments are rebuilt for a promoted state.
• Tests: all timeevolution/* and states/* tests pass, including new tests for in-place infinite timestep!/time_evolve!, leftorthflag = false, real infinite TDVP and the InfiniteMPS(C, AR) constructor. The groundstate, approximate, dynamical DMRG, statmech, fidelity susceptibility and anyonic braiding tests passed on the solver refactor.
• Ambiguities: Test.detect_ambiguities(MPSKit) is unchanged from main (135).

Checklist

• Tests pass locally (relevant subset, see above)
• Documentation updated, if this PR changes public API: adds timestep!(::InfiniteMPS, …, ::TDVP); no other public API change
• Runic formatter is run
• Changelog entry added under [Unreleased] in docs/src/changelog.md

🤖 Generated with Claude Code

[lkdvos]

For context, this is the first part of some other changes where I want to uniformize the approach of the algorithms, because I actually need to rework the way the environments work. I figured out we are doing some of the expensive work in the AC_hamiltonian construction twice, and want to cache that which, depending on the model, leads to quite substantial speedups. However, it basically means that I want some way of tracking internal state per algorithm, therefore leading me to push for uniformizing this solver pattern, which we already had for VUMPS and some of the other algorithms for example.

I'm still trying to do some work on AlgorithmsInterface to actually commit switching to that, which I still think will make some of the boilerplate here less annoying, as well as getting a better way of controlling the logging and stopping criteria without requiring changes in the library itself.

[borisdevos]

Minor comments on my part, but it's all refactoring and I don't think many things are lost. Homogenising things like this will make maintenance easier in the long run, so I'm in favor (even though it's yet another iteration of this code, every time I look at it it's different 😆 )

[lkdvos]

documentation failure is unrelated, will merge once tests pass