WorksPhysics and Astronomy
Exact environment checkpointing for memory-limited DMRG and TDVP
Abstract
Finite matrix-product-state sweep algorithms, such as the density-matrix renormalization group (DMRG) and the time-dependent variational principle (TDVP), store one environment tensor per site. At the bond dimensions needed for frustrated and two-dimensional systems this stack, rather than the state itself, exhausts the memory of the device. We adapt checkpointing to these sweeps: every -th environment is kept, with for sites, and the blocks in between are rebuilt when the sweep returns to them. The rebuild repeats the original contractions, so energies and states are reproduced bit for bit when the contractions are deterministic. Environment memory falls by 4.6-10x on cylinders of 96-384 sites. Bond-dimension searches with an implementation that rebuilds checkpoints at each half-sweep give gains of 1.77 for one level and 2.07 for two levels with eight contraction chunks on a single 141 GB GPU, using a 144-site triangular - cylinder and stored baselines with matching chunking. Separate timings with checkpoints retained across half-sweeps give a one-level overhead of 6-15%, depending on the local eigensolver. At the two-level schedule with eight chunks takes 1.42 times the sweep time of the equally chunked stored baseline, or 1.79 times that of the unchunked stored baseline. Simple models of the memory and the run time reproduce the measurements to within a few per cent. Unlike offloading, the method needs no host memory or disk, and the two can be combined. Implementations are provided for ITensorMPS.jl, TeNPy, MPSKit.jl and quimb.
Introduction
The density-matrix renormalization group (DMRG) [3, 4] [1, 2] and its time-dependent extensions are central tools for strongly correlated quantum systems. Matrix-product-state (MPS) methods for time evolution include time-evolving block decimation and adaptive time-dependent DMRG [5, 6, 7], as well as the time-dependent variational principle (TDVP) [8, 9, 10]. These methods address one-dimensional systems, two-dimensional cylinders [11] and strongly correlated molecules [12]. They also provide classical benchmarks for quantum algorithms and starting states for quantum state preparation and phase estimation [13, 14].
The bond dimension sets how much entanglement an MPS can carry across a cut: at most Schmidt coefficients are kept, so the entanglement entropy is bounded by . Ground states of gapped local Hamiltonians obey an area law [15, 16], which in one dimension means a bounded entropy and explains the success of DMRG there. On a cylinder the cut runs around the circumference, the entropy grows in proportion to the width, and the bond dimension needed for a given accuracy grows roughly exponentially with it [11]. The open questions of frustrated magnetism, such as whether a candidate spin liquid survives as the cylinder is widened, are therefore decided at bond dimensions in the thousands, and every factor gained in is spent on the next width or on a tighter extrapolation. Out of equilibrium the demand is steeper still, because the entanglement generated by a quench keeps growing with time [10].
At these bond dimensions the dominant memory cost is not the MPS but the environment tensors. A left or right environment is the contraction of the Hamiltonian with the part of the state that lies outside the sites being updated. For a matrix product operator (MPO) of bond dimension , a dense environment holds numbers, against for an MPS tensor with local dimension . A two-dimensional Hamiltonian wrapped onto a chain has of several tens, so the stack of environments outweighs the state by an order of magnitude. For a 144-site triangular - cylinder with at the stack occupies about 158 GB in double precision, more than a single NVIDIA H200 provides. The established remedies move environments to host memory or disk, or distribute the calculation over several devices [17, 18, 19, 20, 21]. Recomputing environments on demand has been noted as a further option when device and host memory are both exhausted [22].
Trading storage for recomputation is standard practice in reverse-mode automatic differentiation. Checkpointing schemes [23, 24] reduce the memory of a backward pass from linear to sublinear in the number of steps; they are used in training large neural networks [25] and in differentiable tensor-network programming [26]. A DMRG or TDVP sweep has the same structure: one half-sweep produces a sequence of environments and the next consumes them in reverse order. Here we carry the idea over to these sweeps. The schedules themselves are standard. What is specific to a sweep is that checkpoints released on one side are replaced by new ones on the other, and that the cost of a rebuild is weighed against a local eigensolver instead of a gradient step.
We show that keeping a sparse set of environments and rebuilding the rest leaves the local update, and hence the result, unchanged. Earlier searches with checkpoints rebuilt at each half-sweep increased the largest bond dimension that fits on one GPU by factors of 1.77 for one level and 2.07 for two levels, relative to stored baselines with matching chunking. We distinguish these limits from the fixed- measurements with retained checkpoints in Sec. IV C. We give models for the memory and the run time of the one-level schedule; they agree with measurements to within 2% near the optimal spacing and to within 1%, respectively. We measure both quantities on GPUs with 24 to 141 GB of usable memory and compare recomputation with offloading to host memory and disk. Implementations in four libraries show how the same schedule behaves with block-sparse tensors and under different memory managers.
Environment checkpointing in MPS sweeps
An environment summarises the rest of the lattice as it appears to the sites being updated; it descends from the environment block of the original formulation of DMRG [1, 2]. It is a function of the MPS and MPO tensors on one side of the active sites and of nothing else. If those tensors have not changed, contracting them again returns the same environment, so nothing about the quantum state is lost by discarding it. A sweep guarantees exactly this condition: the tensors ahead of the active sites are not modified until the sweep reaches them.
Reconstructing environments during a sweep
Consider a finite MPS on sites with local Hilbert-space dimension , and a Hamiltonian MPO of bond dimension . The MPS bond dimension limits the variational state, whereas describes the operator representation [27, 28]. A sweep consists of two half-sweeps, from left to right and back. In a two-site DMRG step at , the effective Hamiltonian is obtained from the left environment , the two local MPO tensors , and the right environment [4, 29] [2]. A dense environment, which we also call a block, has three indices of dimensions . Moving the update one site to the right extends the left environment by one contraction, , at cost . Here contracts the previous environment with the local MPS tensor, its conjugate and the MPO tensor. The next half-sweep consumes these environments in reverse order, which is why codes normally keep the whole stack.
Instead, we keep every -th environment as a checkpoint. During the return half-sweep, a missing block is rebuilt from the nearest checkpoint on the unvisited side, and the segment in between is retained until its blocks have been consumed (Figure 1). The tensors on the unvisited side have not yet been updated in that half-sweep, so the rebuild uses the same inputs as the original contraction. Consumed checkpoints are released, and the checkpoints constructed on the opposite side are retained for the following half-sweep.

Figure 1. Environment storage and reconstruction. (a) A full stack retains a block at every position. (b) Checkpoints are spaced by sites. On a right-to-left half-sweep, the temporary blocks between a retained and the required are rebuilt from left to right and then consumed in the opposite order. Blue boxes denote checkpoints and orange boxes the active rebuilt segment. Used left blocks are released while right checkpoints are produced for the next half-sweep. Boxes represent environment blocks, not physical sites or MPS tensors.
Algorithm 1. Checkpointed right-to-left half-sweep
Input: left checkpoints from the previous half-sweep, the left boundary , and the right boundary .
for :
if is absent:
choose the nearest stored with ;
build and store for ;
solve with and split the updated two-site tensor;
build from and the updated tensor at site ;
release the consumed , except ;
release unless it is a checkpoint or a boundary block.
The checkpoints are a by-product of the ordinary sweep. A left-to-right half-sweep builds the left environments and the return half-sweep builds the right ones, and retaining every -th block adds no contraction to either. The extra work is the rebuild of the dropped environments when they are needed in reverse order. Algorithm 1 gives a right-to-left half-sweep; the left-to-right version is its mirror image.
Because the rebuild repeats the same floating-point contractions, energies and states are reproduced bit for bit whenever the contractions, the local solver and the remaining numerical settings are deterministic. No additional truncation of the MPS is introduced. The same holds for TDVP, including the backward evolution of the bond tensor, which uses the same environments [9, 10]; its time-step and projection errors remain those of the underlying integrator.
Memory and recomputation cost
Let be the number of entries of one dense environment in the bulk. We express environment memory in these units; conversion to bytes multiplies by the storage per number. During a right-to-left half-sweep the left checkpoints ahead of the active sites are consumed one by one, while every -th right environment built behind them is kept for the return. The two sets together number about at every moment. To these is added one active segment of at most rebuilt blocks, so that, apart from boundary blocks and those in current use,
This is minimal at , where it equals instead of . Increasing leaves fewer checkpoints but lengthens the temporary segment, and the optimum balances the two. The minimum is shallow: any between and is within 25% of it, so needs no tuning. Equation (1) treats all blocks as equal, whereas near open ends the bond dimension, and with it the block, is smaller than in the bulk; we return to this point in Sec. IV B.
All but one environment in each segment is rebuilt once per half-sweep, about contractions, so the time for a full sweep is
where is the time with all environments stored. For large this is one extra environment update per site and half-sweep. How much that matters depends on the local eigensolver, which applies the effective Hamiltonian repeatedly, by Davidson [30] or Lanczos iteration. To estimate the additional arithmetic work, we count multiplications in the dense contractions. One application to a two-site tensor requires multiplications and one environment update . Their ratio is , where is about 4% at , and . For a step with applications, let denote the multiplication count of the decomposition and remaining work in units of . The regular environment update contributes one further unit. Within this count, the relative increase in arithmetic work is
For spin- sites and , the right-hand side is about 10% with four applications per solve and 18% with two. With fifty applications it is below 1%. These are operation-count estimates, not rigorous bounds on wall time. The contractions and the decomposition can achieve different throughputs, and data movement and allocation also contribute to the measured time. If the dominant contractions have comparable throughput, the count explains why a more expensive local solve reduces the relative runtime overhead. At fixed , and solver settings, their leading multiplication counts scale as , so the estimate has little dependence on . In a single-site update the two contraction counts are equal and the factor is absent, which increases the estimated relative arithmetic overhead. Runtime comparisons below use measured sweep times.
The reversal problem of automatic differentiation traverses a sequence of steps backwards with a fixed number of snapshots, and binomial schedules, implemented by revolve, minimise the recomputation in that setting [23, 24]. They gain by placing new snapshots in the slots that are freed as the reversal proceeds. In a sweep with retained checkpoints (Algorithm 1) this freedom is absent. The preceding half-sweep supplies the checkpoints at no cost, and every slot freed on one side is taken up at once by a checkpoint laid down on the other, so the number of checkpoints stays at about throughout. Uniform spacing is therefore the natural choice, and it needs only a few dozen lines in each library. Only if the checkpoints are rebuilt at the start of every half-sweep, at the cost of a further environment updates, do the freed slots stay free; gaps that widen as the checkpoints are consumed would then lower the memory from to about .
Two-level schedule
If one level does not save enough memory, a second can be added [24]. Every -th environment is kept globally, as before. When a segment of blocks is rebuilt, only every -th block in it is kept, and each of the remaining blocks is rebuilt from the nearest kept block when the sweep reaches it and released after use. The active segment then holds blocks instead of , so that
plus the block in current use. For fixed this is minimal at , where it equals : the second level acts as a one-level schedule on a chain coarse-grained by . The price is paid in recomputation. A block at distance from the nearest kept block needs updates, so a group of blocks costs updates, or per site, in addition to the one update per site of the first pass through the segment. The sweep time becomes
For the one-level optimum holds about 24 blocks. The choice , used below holds about 10, with 3.3 extra updates per site and half-sweep on an exact count, against 0.9 for one level. Keeping the whole group of blocks instead would reduce this to about two updates per site at the price of further blocks. We use the leaner variant because the second level is needed only when memory is the binding constraint.
Where the saving applies
The peak memory is , where comprises the MPS, the intermediates of the effective Hamiltonian and the basis vectors of the eigensolver. Checkpointing reduces only the second term, so it helps most where that term dominates: long systems, wide MPOs and large bond dimensions. Where working memory dominates, it has to be reduced by other means. A more compact MPO [28, 31] or the use of symmetry sectors [29, 32] acts on other terms of this balance and combines with checkpointing. Since every term scales as in the bulk, the largest bond dimension that fits a given device scales as the inverse square root of the memory needed at fixed . A reduction of the peak by a factor therefore raises the attainable bond dimension by about .
Implementations and correctness checks
The implementations cover two situations: a code with explicit control of device memory, and existing tensor-network libraries with their own allocation behaviour. Our main measurements use a standalone CUDA code for two-site DMRG (double precision, contractions with cuBLAS and cuTENSOR, no quantum-number symmetries). Two changes besides checkpointing were needed before the environment saving became visible in the peak. The Davidson basis is sized to the actual number of matrix-vector products, and the intermediate of the effective Hamiltonian can be split into chunks that are contracted one after another, which we call chunking. Device memory is managed with the stream-ordered allocator (cudaMallocAsync/cudaFreeAsync), so that released environments return to the pool at once. Memory is quoted in decimal gigabytes ( bytes). In these units the NVIDIA H100 and H200 cards used here report 85.0 and 150.1 GB; we refer to them by their nominal sizes of 80 and 141 GB.
We also implemented the scheme as drop-in components for four libraries:
ITensorMPS.jl [33]: CheckpointedProjMPO, an AbstractProjMPO usable with dmrg and tdvp, with an optional two-level schedule and offload of checkpoints to host memory or disk;
TeNPy [34]: a checkpointed MPO environment, now part of the library as the DMRG option
env_checkpoint_everyand available as a plugin for earlier versions;MPSKit.jl [35]: an environment type that uses MPSKit’s own dependency tracking;
quimb [36]: a checkpointed moving environment for open boundary conditions.
None requires changes to user code beyond selecting the environment type. The code is released under the MIT License [37]. The GPU code was built with CUDA 12.1 and cuTENSOR 2; the library benchmarks used ITensorMPS.jl 0.4.2 with Julia 1.10, MPSKit.jl 0.13.13, TeNPy 1.1.1 with NumPy 2.4.6 (OpenBLAS 0.3.31) and quimb 1.15.0.
For the GPU benchmarks we use the spin-1/2 - Heisenberg Hamiltonian,
where is the spin operator at site and the sums run over nearest and next-nearest neighbours; we set . On the square lattice we take , in the non-magnetic window between Néel and stripe order [38], and on the triangular lattice , inside the proposed spin-liquid phase [39]. In both regimes competing states lie close in energy, and the conclusions drawn from cylinders rest on the largest bond dimensions available, which makes these models natural test cases. Cylinders are open along their length and periodic around the circumference. They are labelled by the number of sites around the circumference and by the orientation of the lattice, with a nearest-neighbour bond direction along the circumference (YC) or along the axis (XC). We use square YC6, YC8 and YC10 cylinders (, 26 and 32) and triangular XC6 and XC8 cylinders ( and 50), with up to 384 sites. The spin-1 and quantum-chemistry benchmarks are specified where they appear.
The numerical checks run the same initial state, local solver and truncation settings with the two storage schemes. Checkpointing alters neither the variational optimisation nor the basis enrichment used by a library [40, 41], so agreement between the two runs tests the reconstruction itself, whether or not the chosen bond dimension has converged the physics.
In the GPU code, energies are identical to the last bit between stored and checkpointed runs for every from 4 to 72, for the two-level schedule, for three models and two eigensolvers. Over a 20-sweep run at the maximum difference is exactly zero. Chunking the effective Hamiltonian changes the order of summation and hence the last two to three digits, an agreement to . In eight runs at that varied , the Davidson basis size and the chunking, checkpointing changed no digit of the energy, the truncation error or the residual.
In the libraries, DMRG energies agree exactly (difference 0.0) with those of the native environments in ITensorMPS.jl (dense and U(1)), TeNPy (including mixers and disk caching), MPSKit.jl (dense and U(1)) and quimb, and TDVP states agree to .
In ITensorMPS.jl, one-site TDVP agrees to and the two-level schedule (, ) reproduces the energy exactly. For infinite MPS in TeNPy the option is inactive. In the longer CPU benchmarks of Sec. IV E (real-time TDVP over 13 steps, ab initio DMRG with , MPSKit.jl DMRG up to ) all printed energies agree to 12 digits.
Memory savings and computational performance
We separate three questions: what recomputation costs in time at fixed numerical settings, how much memory it saves, and how much further in bond dimension a given device can then go.
Runtime overhead
Two local solvers are used throughout. Davidson-4 limits the Davidson iteration to four matrix-vector products per local solve and truncates by diagonalising the reduced density matrix of the two-site tensor [1]. Davidson-2 uses two products and a warm-started truncation: the kept basis is not obtained from a diagonalisation but is initialised with the MPS tensor that is being replaced and improved by one step of subspace iteration, . The full diagonalisation is used only where the bond dimension changes. Local solves are thus not converged within a step, as is common in production runs, where the sweeping itself converges the state. Stored and checkpointed runs always share the same setting.
Table I lists the overhead of the one-level schedule with . The cleanest comparison is with a stored run that keeps its environments from one half-sweep to the next, the checkpointed run keeping its checkpoints in the same way. For the triangular XC6 cylinder at the overhead is then 6.0% with Davidson-4 and 13.7% with Davidson-2, with a spread of at most 0.2% over three runs. The larger overhead for the cheaper solver follows the trend of the operation-count estimate in Eq. (3). Energies agree to the last printed digit in all twelve runs, and the peak memory is 19.3 against 52.1 GB. At the Davidson-2 overhead is 15% (Sec. IV C), consistent with an overhead that does not depend on . With local solves converged fully it falls to 0.5% (693 against 690 s per sweep).
An earlier set of runs used a stored baseline that rebuilds all environments at the start of each half-sweep, with the checkpoints rebuilt likewise. Both variants then carry the same additional rebuild, and the extra work of checkpointing is unchanged at environment updates per half-sweep. These runs give median overheads of 6.2% (triangular XC6, ) and 6.4% (square YC8, ) with Davidson-4, and 14.5% with Davidson-2, with a larger scatter between runs (Table I). Equation (2), with and measured once,
| model, | solver | median | IQR (runs) |
| tri. XC6, 1024 | Davidson-4 | 6.0% | 5.98–6.00% (3) |
| tri. XC6, 1024 | Davidson-2 | 13.7% | 13.5–13.7% (3) |
| tri. XC6, 1024 | Davidson-4 | 6.2% | 4.8–8.4% (10) |
| square YC8, 2048 | Davidson-4 | 6.4% | 6.2–6.5% (5) |
| tri. XC6, 1024 | Davidson-2 | 14.5% | 12.1–21.6% (10) |
Table I. Overhead in time of checkpointing () relative to storing all environments, GPU code on one H200; energies are identical in every pair. Davidson-4: at most four matrix-vector products per local solve and truncation through the reduced density matrix. Davidson-2: two products and warm-started truncation. In the first two rows, stored runs keep their environments and checkpointed runs their checkpoints across half-sweeps; in the last three, both are rebuilt at the start of each half-sweep. IQR: interquartile range.
reproduces every measured to within 1%.
The extra work cannot be overlapped with the solver. Profiling shows the GPU 98–99% busy during a sweep, so the rebuild competes for a device that is already saturated.
Memory
Table II shows peak and environment memory for square YC6 cylinders of increasing length at . The spacing that minimises memory in a scan over is 10, 14 and 20 for , 192 and 384, against , 13.9 and 19.6. Environment memory falls by factors of 4.6, 6.7 and 10, close to the of Eq. (1), and the saving in peak memory grows from 1.9 to 3.8. Figure 2 shows the full scans. With and the non-environment memory taken from the stored run, Eq. (1) predicts the peak of all 15 checkpointed runs to within 2% for . For larger it underestimates the peak by up to 7% (, ). The block size inferred from the stored run is an average that includes the small blocks near the open ends, whereas a long active segment in the bulk consists of full-size blocks.
Figure 2. Environment memory against checkpoint spacing for square YC6 cylinders at (points), with Eq. (1) for taken from the run that stores all environments (dashed). Vertical lines mark .
The saving also depends on the model, through the length and the MPO bond dimension , whose product sets the size of the stack. At the peak falls by a factor of 1.5 for square YC10 (, ), 1.8 for square YC8 (, ), 2.7 for triangulalar XC6 (, ) and 3.4 for triangular XC8 (, ; 86.1 GB → 25.1 GB). The ordering follows . The YC10 cylinder has a wider MPO than YC8 but is shorter, and gains less.
Two settings unrelated to checkpointing also change the peak, and we varied them separately (triangular XC6, , Davidson-4). With a Davidson basis of eight vectors and no chunking, checkpointing with lowers the peak from 52.0 to 19.2 GB and raises the sweep time from 32.3 to 34.0 s. A basis of 160 vectors adds 10 GB, and four chunks save 1.9 GB for 14% more time, with or without checkpointing. Chunking becomes cheaper relative to the sweep as grows. At (Davidson-2, ), two, four, eight and sixteen chunks save 5.1, 7.5, 8.9 and 9.4 GB of a 66.0 GB peak for 1%, 3%, 13% and 25% more time, so four chunks capture most of the saving at little cost. Figure 3 shows how the peak divides between MPS, environments and working memory.
Figure 3. Peak GPU memory split into MPS, environments and working memory for the triangular XC6 cylinder, with all environments stored (store) and checkpointed with (ckpt). Storing all environments at does not fit on the device.
Largest attainable bond dimension
The practical question is how far a given device can go. We define the limit as the largest for which two full sweeps complete, located on a grid of 64 or 128. Table III separates two sets of measurements for the triangular XC6 cylinder on one H200. The bond-dimension searches use a build that rebuilds environments or checkpoints at the start of each half-sweep. The fixed- timings and memory measurements use a build with environments or checkpoints retained across half-sweeps.
| configuration | ratio | (s) | (GB) | |
| stored | 1664 | – | 42.6 | 111.9 |
| stored, 8 chunks | 1792 | – | 53.7 | 106.9 |
| one-level, | 2944 | 1.77 | 49.0 | 39.1 |
| two-level, 8 chunks | 3712 | 2.07 | 76.3 | 25.4 |
Table III. Triangular XC6 cylinder () on one H200, Davidson-2. The rebuilding-build columns report earlier searches for the largest completing two full sweeps, on a grid of 128. Their ratios compare runs with the same chunking. The retaining-build columns report time per sweep and peak memory at , averaged over the second and third sweeps with environments or checkpoints kept across half-sweeps.
In the earlier searches, without chunking, the one-level schedule raised the limit from 1664 to 2944, a factor of 1.77. With eight chunks the stored limit was 1792 and the two-level schedule (, ) reached 3712, a factor of 2.07. On a grid of 128 these ratios are defined to about ±0.1. For the retaining build, the measured peaks at give the square-root estimates and from Sec. II D, close to the ratios measured with the rebuilding build.
The fixed- timings distinguish the two runtime baselines. At the retaining build gives times the stored sweep time for one level without chunking. Eight chunks alone raise the stored time by 26%. The two-level schedule with eight chunks takes times the time of the equally chunked stored run, or times that of the unchunked stored run. The 2.07 reach ratio is measured with the rebuilding build and the 1.42 runtime ratio with the retaining build, each relative to an equally chunked stored baseline. The count of Sec. II C accounts for the
additional time at matched chunking. The one-level run gives ms, and the two-level schedule performs about 475 environment updates per half-sweep against 132. This predicts 23 s per sweep on top of the stored run with the same chunking, and the measured difference is 22.6 s. In memory, the two-level run holds 7.2 GB of environments, ten blocks of 0.72 GB as expected from Eq. (4), against 15.8 GB (22 blocks) for one level and 88.8 GB with all environments stored.
At the two-level limit measured with the earlier rebuilding build, the environments are no longer the largest term. Of the 138 GB in use at , the MPS takes 27 GB, the environments 38 GB and the working memory 74 GB. Further gains must come from the working memory of the local update.
Table IV lists the earlier rebuilding-build searches on the other devices and memory budgets. Here the stored runs use no chunking and the checkpointed runs the two-level schedule with eight chunks (triangular; , ) or sixteen (square; , ), so the ratios include the effect of chunking. On the H200 that effect is one grid step in the stored limit: the ratio is 2.23 with the chunking unmatched and 2.07 with it matched. On an 80 GB H100 the triangular limit rises from 1280 to 2816. For the square YC8 cylinder the search was stopped at 3328 on the H100, where the run filled the card, and at 4096 on the H200 with 124.6 GB in use, so those values are lower bounds.
To emulate cards with less memory we reserve a fixed ballast allocation on the H200 before the run and repeat the search for the triangular cylinder. With 24 GB usable the limit rises from 640 to 1408, with 40 GB from 768 to 1920, and with 48 GB from 896 to 2048. These are ratios of 2.2 to 2.5, with an uncertainty of about from the grid of 128. At the 24 GB limit the environments occupy 15.7 GB stored at but 5.4 GB checkpointed at . At a checkpointed sweep takes 14.1 s against 7.6 s stored. The stored runs start from a random state and the checkpointed runs from a converged state; a checkpointed run from a random state completes at 24 GB and with the same 5.4 GB of environments.
In ITensorMPS.jl with U(1) symmetry on an 80 GB H100 (square YC8), the native ProjMPO reaches and CheckpointedProjMPO reaches on a coarse grid, a factor of 1.29, with comparable sweep times. With dense tensors checkpointing does not extend the reach: every variant, including two-level schedules, host offload of checkpoints, and chunked effective Hamiltonians, fails at or 2560. The allocation that fails is a single environment-sized temporary inside the two-site update. The limit is thus set by the working memory of the library and not by the stored environments, the situation described in Sec. II D. DiskProjMPO reaches 2560 but is slower: 614 s per sweep at , against 357 s checkpointed and 376 s for ProjMPO.
Comparison with host-memory and disk offloading
Moving environments off the device exchanges GPU memory for host storage and data transfer, and asynchronous transfer and distributed storage are central to several large-scale implementations [17, 19, 20, 21]. We compared recomputation with asynchronous offload and prefetching in the same code, on the triangular XC6 cylinder.
We first routed the offload through a file system (Table V). At recomputation takes 18.2 s per sweep. Offload to host memory through a RAM disk takes 25 s. A node-local disk matches this only while the page cache of the operating system absorbs the writes (25 s in the first sweep, 208 s afterwards). The parallel file system takes 34–37 s and synchronous offload 75–85 s. At the RAM-disk run exceeded the 200 GB memory limit of its job in the first sweep, while recomputation ran at 128 s per sweep.
A direct implementation does better (Table VI). Environments are copied with cudaMemcpyAsync to and from page-locked (pinned) host buffers on a separate stream, with two blocks fetched ahead of the sweep. After a first sweep of 25 s that allocates the buffers, a sweep at takes 16.3–16.4 s. This equals the time with every environment stored and is 10% less than with recomputation, at a peak GPU memory of 13.6 GB against 19.1 GB checkpointed. At the sweep time varies between 49 and 62 s. At the pinned run was terminated in its second sweep on exceeding the 290 GB memory limit of the job, while the checkpointed run completed at a peak of 66.6 GB and 110–128 s per sweep. Energies are identical in every run.
| (s) | (GB) | (s) | (GB) | |
| stored | 16.2–16.3 | 51.8 | 49.2 | 111.9 |
| checkpointed | 18.1 | 19.1 | 55.4 | 39.0 |
| pinned offload | 16.3–16.4 | 13.6 | 49–62 | 26.4 |
Table VI. Pinned asynchronous offload compared with stored and checkpointed () environments: time per sweep and peak GPU memory for the triangular XC6 cylinder on one H200, Davidson-2, three runs per setting from the same initial state, other settings as in Table V.
| method | ||
| recomputation | 18.2 | 128 |
| host memory (/dev/shm) | 24.6–25.1 | out of memory |
| node-local disk | 24.9, then 208 | 130, then 1291 |
| parallel file system | 34–37 | 188–221 |
| same, synchronous | 75–85 | – |
| all environments stored | 16.2–16.3 | – |
Table V. Time per sweep (s) for the triangular XC6 cylinder: recomputation () against asynchronous offload with prefetching through a file system, GPU code on one H200, Davidson-2, environments rebuilt at the start of each half-sweep.
The host requirement of both offload routes, as implemented here, is twice the stack. Each keeps one host buffer, or one file, for every left and every right block and reuses it in the next sweep without releasing it in between, so the left and the right stack reside on the host together. At one stack is 158 GB and the two amount to about 315 GB. An implementation that released the buffers of consumed blocks would need half of this and would have fitted within the 290 GB limit.
The two methods thus draw on different resources. One block at , is 0.32 GB; moving it over PCIe 5 at about 25 GB/s takes 13 ms, against 8.3 ms to rebuild it. The transfer, however, runs on the copy engines while the solver computes, so a well-overlapped offload costs almost no time, whereas a rebuild competes for the saturated GPU. The scaling favours offload further as grows, since the transfer time grows as and the rebuild as . What offload requires instead is host memory for the whole stack, of order , which becomes the binding limit at large and on shared nodes with per-job memory limits. Recomputation needs no host memory, and its footprint on the device grows only as . Where host memory is plentiful, pinned offload is the faster choice; where it is not, checkpointing remains available. The two combine naturally: if only the checkpoints leave the device, the host requirement falls by a factor of and the device holds a single segment. The ITensorMPS.jl implementation offers this combination.
CPU libraries
CPU implementations test how the schedule interacts with block-sparse tensors and with the memory management of each library.
In TeNPy, on square YC6 cylinders with conservation, the peak resident memory falls by 2.9× (24 × 6, ), 3.3× (24 × 6, ), 4.0× (48 × 6, ) and 4.3× (48 × 6, ; 49.7 GB → 11.6 GB), with identical energies. No run took longer with checkpointing, and in three repeated pairs at the checkpointed runs were 6–15% faster, an effect examined in Sec. IV F.
Time evolution is a natural application. After a quench the entanglement entropy typically grows linearly in time, so the bond dimension needed for a faithful state grows exponentially [5, 6, 10] and a simulation ends when the state no longer fits. A fixed factor gained in then buys a fixed increment in the reachable time. Checkpointing moves this storage limit and leaves the growth of entanglement and the errors of the integrator untouched.
Table VII lists three further comparisons, each with one storage scheme per process. The first is real-time two-site TDVP in ITensorMPS.jl: a quench from a Néel state on a square Heisenberg YC6 cylinder (12 × 6, U(1), , ). Energies agree at every step and the peak memory falls from 6.38 to 4.82 GB. Figure 4 shows two runs of each scheme on a dedicated node (64-core AMD EPYC 7542, one thread per Julia process, eight BLAS threads). Up to the checkpointed steps are slower, by 10% summed over steps 2–11, as expected from the extra environment updates. At the order reverses: the stored step takes 3716 s in one run and did not finish within the remaining 3870 s of the other, while the checkpointed step takes 1581 and 1606 s. In a first run with four threads the corresponding step, at , took 3969 s stored against 1369–1440 s checkpointed, so that within the same 2.5 h the checkpointed run completed 16 steps and the stored run 13.
Figure 4. Real-time two-site TDVP in ITensorMPS.jl (square Heisenberg YC6, 12 × 6, U(1), ): time per step (solid) and garbage-collection time per step (dotted) against the bond dimension reached at that step, two runs each on a dedicated 64-core node. The first step includes compilation. The stored run 2 was stopped by its time limit during the last step; the arrow marks the lower bound. Energies agree to all printed digits at every step.
| run | time (s) | RAM (GB) |
| TDVP step, | 3969 → 1369 | 6.38 → 4.82 |
| TDVP step, † | → 1594 | 5.5 → 4.5 |
| same, no forced GC † | 3414 → 1734 | 5.6 → 4.6 |
| MPSKit, | 3003 → 2455 | 9.35 → 7.63 |
| MPSKit, † | 1753 → 1532 | 6.4 → 6.5 |
| H, | 232 → 253 | 6.70 → 6.23 |
| H, † | 412 → 426 | 6.8 → 6.3 |
Table VII. CPU benchmarks, stored → checkpointed environments (energies identical). TDVP and H: ITensorMPS.jl. Rows marked † are medians over repeated pairs on a dedicated node; the others are single runs. GC: garbage collection. TeNPy: see Table VIII.
The second comparison is DMRG in MPSKit.jl on a spin-1 Heisenberg YC6 cylinder (24 × 6, U(1)). The checkpointed run is 1.22× faster overall and uses 7.63 instead of 9.35 GB at ; two repeated pairs with on the dedicated node give 1.14× at equal peak memory. The third is ab initio DMRG [12, 31] of an H chain (STO-6G) in ITensorMPS.jl. Here the MPO is wide () and the chain short, so the effective Hamiltonian dominates the memory and checkpointing changes little: 6.70 → 6.23 GB, with the checkpointed run 2–9% slower.
Codes that already keep their environments on disk, such as block2 [42], are in a different position: there the same schedule would save disk space and input/output instead of memory. For an H chain (STO-6G, 50 orbitals, , SU(2)) the environment files of block2 occupy about 40 GB, and disk input/output accounts for 16–29% of the run.
Memory management and CPU timing
On the GPU, checkpointing always costs time (Sec. IV A). On CPUs, in libraries written in garbage-collected or allocation-heavy languages, we repeatedly found the checkpointed run as fast as the stored one or faster (TeNPy, MPSKit.jl, and TDVP in ITensorMPS.jl), although it performs strictly more arithmetic. The extra arithmetic is visible where it can be isolated, as the 10% in the early TDVP steps of Figure 4. The gain has a different origin: the cost of managing a large live memory footprint.
Garbage collection in Julia. Julia’s collector periodically marks all reachable objects, so the cost of a full collection grows with the live heap. With every environment stored, the live heap at is dominated by 72 environment blocks; with checkpointing () it holds about 25. In the TDVP runs of Figure 4 the time spent in garbage collection grows smoothly with in both cases and stays below 6% of the step time with checkpointing. At the stored run crosses a threshold: 2079 s of its 3716 s step are spent in the collector, against 62 and 82 s in the two checkpointed runs. The checkpointed projector calls the collector after dropping blocks. With that call removed, so that both runs follow Julia’s default policy, the checkpointed step takes 1724 and 1744 s (54–58 s in the collector) against 3405 and 3423 s stored (1550–1610 s). The forced call thus accounts for about 8% of the step and not for the difference. The peak resident memory of the stored run is only 20% higher (5.5 against 4.5 GB) and far below the 200 GB available, which rules out swapping or memory exhaustion: the work of the collector scales with the number of live blocks. Whether a given run crosses the threshold depends on the collector’s heuristics, which explains why the same stored step took 3716 s in one run and more than 3870 s in the other.
Allocation and page faults in Python. TeNPy allocates every environment as a fresh NumPy array. Table VIII shows three alternated pairs on the dedicated Rome node and three runs on a second, Genoa, node. The user CPU time, which measures the arithmetic, differs little between stored and checkpointed runs. On the Rome node the system time and the number of minor page faults, which measure the kernel’s work in mapping fresh memory, fall several-fold with checkpointing, and the wall time falls by a factor of 1.09 (median of three pairs; range 1.04–1.14). On the Genoa node the page faults fall 3.6-fold and the wall time by a factor of 1.15, while the system time changes by about 12%. The reduction in page faults is thus the common feature of the faster runs. We attribute the gain to memory-mapping
| run | wall (s) | sys. (s) | faults () | GB |
| R1, stored | 12798 | 23383 | 836 | 13.5 |
| R1, ckpt. | 11732 | 4035 | 216 | 3.44 |
| R2, stored | 12983 | 25629 | 890 | 13.3 |
| R2, ckpt. | 11381 | 5999 | 278 | 3.56 |
| R3, stored | 12192 | 19438 | 733 | 13.5 |
| R3, ckpt. | 11684 | 5845 | 275 | 3.56 |
| G, stored | 2111 | 49256 | 580 | 13.3 |
| G, stored | 2123 | 49964 | 578 | 13.3 |
| G, ckpt. | 1831 | 43352 | 162 | 3.19 |
Table VIII. TeNPy two-site DMRG, square - YC6, , , conserved, 64 BLAS threads (OpenBLAS), stored against checkpointed () environments, energies identical: wall time, system CPU time, minor page faults and peak RAM. R: Rome, AMD EPYC 7542, whole node, pairs alternated. G: Genoa, AMD EPYC 9654, 128 of 192 cores allocated, two stored runs and one checkpointed run; the node was not reserved exclusively.
:::
work that grows with the amount of memory a process keeps mapped; its size depends on the machine. These speedups are a side effect of the memory saving and not a property of the algorithm. In a code that preallocates its environment storage, as our GPU code does through a memory pool, they are absent and only the cost of recomputation remains. They are nevertheless what a user of these libraries will observe: in the CPU benchmarks above, the memory saving usually came with no increase in wall time.
Convergence at large bond dimension
Completing sweeps at a larger is a test of memory, not of convergence. Whether the additional Schmidt states improve the answer has to be checked separately, through the local optimisation, the truncation and the finite-size effects [11, 43]. As an illustration of calculations that checkpointing brings within reach of one device, we followed the energies of two cylinders on a single H200 with the Davidson-4 solver up to , beyond the stored limits of Table IV.
| GPU | model | stored | ckpt. | ratio |
| H100 80 GB | tri. XC6 | 1280 | 2816 | 2.2 |
| H100 80 GB | sq. YC8 | 1664 | ||
| H200 141 GB | tri. XC6 | 1664 | 3712 | 2.2 |
| H200 141 GB | sq. YC8 | 2176 | ||
| H200, 24 GB cap | tri. XC6 | 640 | 1408 | 2.2 |
| H200, 40 GB cap | tri. XC6 | 768 | 1920 | 2.5 |
| H200, 48 GB cap | tri. XC6 | 896 | 2048 | 2.3 |
Table IV. Largest bond dimension completing two full sweeps on one GPU, GPU code. Stored runs use no chunking; checkpointed runs use the two-level schedule with chunking (see text). These earlier rebuilding-build limits are located on a grid of 64 or 128. In the last three rows the usable memory of an H200 is capped by a ballast allocation. Table III resolves the H200 triangular case by configuration.
For the square YC8 cylinder (, ) the energy at is , changing by per sweep. Two further sweeps with tighter local solves (up to 24 matrix-vector products per solve; largest residual after the first and after the second) shift the energy by , to . This change is much smaller than the extrapolation uncertainty quoted below. The tighter local solves therefore support truncation-dominated error at this , although they do not certify convergence to the global ground state. A full energy variance was not evaluated at this size. We estimate the remaining finite- bias by extrapolating in the truncation error [44]. A linear fit over the largest bond dimensions gives , where the uncertainty is the spread of fits starting at , and (Figure 5). This fit spread is not a rigorous error bound. Subtracting an cylinder to remove the open ends gives a bulk energy of per site, consistent within about with the DMRG results of Gong et al. [38]. For the triangular XC6 cylinder the energy converges to at , with an extrapolated .
Figure 5. Ground-state energy against summed truncation error at the last sweep of each bond dimension (labels), with a linear fit through the four largest (dashed) and its intercept (diamond). All runs use checkpointed environments on a single H200.
Practical use
Environment checkpointing is a small change with a predictable cost and no effect on results. It is most useful where environments dominate memory: long systems, wide MPOs, large bond dimensions, and a GPU whose memory is the limit. Its overhead, about one environment update per site and half-sweep for one level, cannot be hidden on a device that is already busy and is largest with cheap local solvers.
Estimating the benefit. The gain follows from the composition of the peak. In our GPU code at (triangular XC6, ) the stored environments take 88.8 GB, the working memory 18.4 GB and the MPS 4.7 GB. The working memory is equivalent to about 26 environment blocks, several times the of a single two-site intermediate, and chunking brings it to about 19. Checkpointing pays once is well above this number, and the saving grows with length, from at to at in peak memory (Table II). The same numbers bound what can be gained. With environments and working memory removed altogether, the MPS alone would give an estimated gain in bond dimension of relative to the unchunked stored baseline. For comparison, the earlier two-level search gave relative to that baseline, including the gain from chunking. For short chains with wide MPOs, as in ab initio chemistry with tens of orbitals, the gain is small (Sec. IV E). A single calibration sweep of a stored run suffices for an estimate: with and read from it, Eq. (1) predicts the checkpointed peak to within 2% near the optimal spacing, and Eq. (2) the time to within 1%. Extrapolation to a larger must allow for the growth of the working memory and, in symmetric codes, of the symmetry blocks.
| best () | peak (GB) | env. (GB) | saving | |
| 96 | 10 (9.8) | 21.3 → 11.3 | 12.7 → 2.8 | 1.9× |
| 192 | 14 (13.9) | 38.6 → 14.4 | 28.4 → 4.2 | 2.7× |
| 384 | 20 (19.6) | 73.2 → 19.4 | 59.8 → 6.0 | 3.8× |
Table II. Square YC6 cylinder, , GPU code: memory with all environments stored and with checkpointing at the measured optimal .
Choosing the schedule. The default in all our implementations is . The minimum of Eq. (1) is flat and the measured optimum lies within one site of (Table II); a larger lengthens the rebuilt segment and a smaller one keeps more checkpoints, with no gain in either direction. The two-level schedule should be reserved for cases in which one level does not fit, since its recomputation grows linearly with [Eq. (5)]. Chunking is best limited to about four chunks, which give most of its saving for a few per cent in time at large (Sec. IV B).
Combining memory-saving methods. Checkpointing combines with symmetry-based block sparsity [29, 32], mixed precision and offloading; bitwise comparisons then require the precision and contraction settings to be held fixed. With offload, only the checkpoints need leave the device, which lowers the host-memory requirement that limited offload in Sec. IV D from order to order . Symmetric tensors benefit as well: with U(1) symmetry in ITensorMPS.jl the attainable bond dimension on an H100 rose by a factor of 1.29.
Scope. The reconstruction argument holds whenever an algorithm consumes environments built from a part of the state that has not changed. Beyond the DMRG and TDVP implementations tested here, this includes excited-state optimisation [11], finite-temperature evolution by purification or typical states [45, 46], and variational MPS compression in the simulation of quantum circuits. What matters is the contraction schedule and not the MPS form alone: gate-based evolution and MPO-based propagation update the state differently [5, 10, 47] and need not offer the same saving. In out-of-core codes the schedule would reduce disk use instead of memory.
Limitations. The GPU measurements use one dense code without quantum-number symmetries; block sparsity would shift the balance between environments and working memory. Bond-dimension limits are located on a grid of 64 or 128, and the square-lattice values are lower bounds. The capped runs reproduce the memory of a smaller card but not its bandwidth or speed. The combination of checkpointing with offload was not benchmarked. The CPU speedups depend on the runtime and the machine (Sec. IV F). In quimb the moving environment is built in full before the first block is dropped, so the steady-state memory is reduced but not the peak at start-up. Where the working memory of a library dominates, as in dense ITensorMPS.jl or in quimb’s effective-Hamiltonian contraction at large sizes, that memory has to be reduced first.
Conclusion
The environments of a finite MPS sweep can be treated as a cache and not as part of the state: they are determined by tensors that the sweep has not yet touched, and can be rebuilt exactly when needed. Keeping every -th environment reduces their memory from to blocks at the cost of one environment update per site and half-sweep, which adds 6–15% to the sweep time for short local solves and less than 1% for converged ones. Earlier searches with checkpoints rebuilt at each half-sweep increased the attainable bond dimension by factors of 1.77 for one level and 2.07 for two levels with eight chunks, relative to stored baselines with matching chunking. With retained checkpoints at , the two-level schedule takes 1.42 times the sweep time of the equally chunked stored baseline, or 1.79 times that of the unchunked stored baseline. At the two-level limit measured with rebuilt checkpoints, the working memory of the local update is the largest contribution to the peak. The method needs no host memory, complements offloading, and is available for four widely used libraries. The bond dimension required on a cylinder grows exponentially with its width, and after a quench exponentially with time. A factor of two in therefore translates into a tighter extrapolation on the widest accessible cylinder and a fixed gain in reachable time, on unchanged hardware.
Code and data availability
The implementations, the GPU code, tests, run scripts and raw benchmark outputs are available at https://github.com/NihalShriv/envcheckpoint. The version used for this paper, v0.4.2, is archived at 10.5281/zenodo.24193745 [37]; 10.5281/zenodo.2375022 resolves all versions. The data behind the tables and figures and the figure-generation script are in the repository’s results/ directory. The TeNPy implementation has been merged into the library (https://github.com/tenpy/tenpy/pull/713). The ITensorMPS.jl contribution is under review (https://github.com/ITensor/ITensorMPS.jl/pull/228).
Acknowledgments
The calculations were performed on the Sharanga high-performance computing facility of BITS Pilani, Hyderabad Campus.
RB thanks support from an intramural grant CDRF C2/24/282 from BITS Pilani, and from ANRF India through ANRF/ARG/2025/009241/PS. RB acknowledges stimulating discussions with Indrakshi Raychowdhury on quantum algorithms, which motivated the present work.
ChatGPT Astra (OpenAI) was used to assist in framing the logical flow of the manuscript, and Claude Code was used to develop the analysis code. The authors take responsibility for the final results and conclusions.
References
References
- [3]U. Schollwöck, The density-matrix renormalization group, Rev. Mod. Phys. 77, 259 (2005).DOI
- [4]U. Schollwöck, The density-matrix renormalization group in the age of matrix product states, Ann. Phys. 326, 96 (2011).DOI
- [5]G. Vidal, Efficient Simulation of One-Dimensional Quantum Many-Body Systems, Phys. Rev. Lett. 93, 040502 (2004).pubmed.ncbi.nlm.nih.gov/15323740
- [6]S. R. White and A. E. Feiguin, Real-Time Evolution Using the Density Matrix Renormalization Group, Phys. Rev. Lett. 93, 076401 (2004).pubmed.ncbi.nlm.nih.gov/15324254
- [7]A. J. Daley, C. Kollath, U. Schollwöck, and G. Vidal, Time-dependent density-matrix renormalization-group using adaptive effective Hilbert spaces, J. Stat. Mech. 2004, P04005 (2004).DOI
- [8]J. Haegeman, J. I. Cirac, T. J. Osborne, I. Pizorn, H. Verschelde, and F. Verstraete, Time-Dependent Variational Principle for Quantum Lattices, Phys. Rev. Lett. 107, 070601 (2011).DOI
- [9]J. Haegeman, C. Lubich, I. Oseledets, B. Vandereycken, and F. Verstraete, Unifying time evolution and optimization with matrix product states, Phys. Rev. B 94, 165116 (2016).DOI
- [10]S. Paeckel, T. Köhler, A. Swoboda, S. R. Manmana, U. Schollwöck, and C. Hubig, Time-evolution methods for matrix-product states, Ann. Phys. 411, 167998 (2019).
- [11]E. M. Stoudenmire and S. R. White, Studying Two-Dimensional Systems with the Density Matrix Renormalization Group, Annu. Rev. Condens. Matter Phys. 3, 111 (2012).DOI
- [12]G. K.-L. Chan and S. Sharma, The Density Matrix Renormalization Group in Quantum Chemistry, Annu. Rev. Phys. Chem. 62, 465 (2011).DOI
- [13]S.-J. Ran, Encoding of matrix product states into quantum circuits of one- and two-qubit gates, Phys. Rev. A 101, 032310 (2020).
- [14]S. Lee, J. Lee, H. Zhai, Y. Tong, A. M. Dalzell, A. Kumar, P. Helms, J. Gray, Z.-H. Cui, W. Liu, M. Kastoryano, R. Babbush, J. Preskill, D. R. Reichman, E. T. Campbell, E. F. Valeev, L. Lin, and G. K.-L. Chan, Evaluating the evidence for exponential quantum advantage in ground-state quantum chemistry, Nat. Commun. 14, 1952 (2023).DOI
- [15]F. Verstraete and J. I. Cirac, Matrix product states represent ground states faithfully, Phys. Rev. B 73, 094423 (2006).DOI
- [16]J. Eisert, M. Cramer, and M. B. Plenio, Colloquium: Area laws for the entanglement entropy, Rev. Mod. Phys. 82, 277 (2010).DOI
- [17]C. Xiang, W. Jia, W.-H. Fang, and Z. Li, Distributed Multi-GPU Ab Initio Density Matrix Renormalization Group Algorithm with Applications to the P-Cluster of Nitrogenase, J. Chem. Theory Comput. 20, 775 (2024).
- [18]M. Ganahl, J. Beall, M. Hauru, A. G. Lewis, T. Wojno, J. H. Yoo, Y. Zou, and G. Vidal, Density Matrix Renormalization Group with Tensor Processing Units, PRX Quantum 4, 010317 (2023).DOI
- [19]A. Menczer and Ö. Legeza, Boosting the effective performance of massively parallel tensor network state algorithms on hybrid CPU-GPU based architectures via non-Abelian symmetries (2023), arXiv:2309.16724 [physics.comp-ph].arxiv.org/abs/2309.16724
- [20]A. Menczer and Ö. Legeza, Cost optimized ab initio tensor network state methods: industrial perspectives (2024), arXiv:2412.04676 [physics.comp-ph].arxiv.org/abs/2412.04676
- [21]H. Zhai and G. K.-L. Chan, Low communication high performance ab initio density matrix renormalization group algorithms, J. Chem. Phys. 154, 224116 (2021).DOI
- [22]M. Drescher, L. Vanderstraeten, R. Moessner, and F. Pollmann, Spectral Functions of an Extended Antiferromagnetic S = 1/2 Heisenberg Model on the Triangular Lattice (2025), arXiv:2508.17292 [cond-mat.str-el].arxiv.org/abs/2508.17292
- [23]A. Griewank, Achieving logarithmic growth of temporal and spatial complexity in reverse automatic differentiation, Optim. Methods Softw. 1, 35 (1992).DOI
- [24]A. Griewank and A. Walther, Algorithm 799: revolve: an implementation of checkpointing for the reverse or adjoint mode of computational differentiation, ACM Trans. Math. Softw. 26, 1 (2000).
- [25]T. Chen, B. Xu, C. Zhang, and C. Guestrin, Training Deep Nets with Sublinear Memory Cost (2016), arXiv:1604.06174 [cs.LG].arxiv.org/abs/1604.06174
- [26]H.-J. Liao, J.-G. Liu, L. Wang, and T. Xiang, Differentiable Programming Tensor Networks, Phys. Rev. X 9, 031041 (2019).DOI
- [27]G. M. Crosswhite and D. Bacon, Finite automata for caching in matrix product algorithms, Phys. Rev. A 78, 012356 (2008).DOI
- [28]C. Hubig, I. P. McCulloch, and U. Schollwöck, Generic construction of efficient matrix product operators, Phys. Rev. B 95, 035129 (2017).DOI
- [29]I. P. McCulloch, From density-matrix renormalization group to matrix product states, J. Stat. Mech. 2007, P10014 (2007).DOI
- [30]E. R. Davidson, The iterative calculation of a few of the lowest eigenvalues and corresponding eigenvectors of large real-symmetric matrices, J. Comput. Phys. 17, 87 (1975).DOI
- [31]G. K.-L. Chan, A. Kesselman, N. Nakatani, Z. Li, and S. R. White, Matrix product operators, matrix product states, and ab initio density matrix renormalization group algorithms, J. Chem. Phys. 145, 014102 (2016).arxiv.org/abs/1605.02611
- [32]S. Singh, R. N. C. Pfeifer, and G. Vidal, Tensor network decompositions in the presence of a global symmetry, Phys. Rev. A 82, 050301 (2010).DOI
- [33]M. Fishman, S. R. White, and E. M. Stoudenmire, The Tensor Software Library for Tensor Network Calculations, SciPost Phys. Codebases , 4 (2022).DOI
- [34]J. Hauschild and F. Pollmann, Efficient numerical simulations with Tensor Networks: Tensor Network Python (TeNPy), SciPost Phys. Lect. Notes , 5 (2018).DOI
- [35]L. Devos, M. Van Damme, and J. Haegeman, MPSKit (2026), software, all versions; accessed 11 November 2026.
- [36]J. Gray, quimb: A python package for quantum information and many-body calculations, J. Open Source Softw. 3, 819 (2018).DOI
- [37]N. K. Shrivastava, envcheckpoint: exact low-memory environments for DMRG/TDVP (2026), software and benchmark archive, version v0.4.2.
- [38]S.-S. Gong, W. Zhu, D. N. Sheng, O. I. Motrunich, and M. P. A. Fisher, Plaquette Ordered Phase and Quantum Phase Diagram in the Spin-1/2 J₁-J₂ Square Heisenberg Model, Phys. Rev. Lett. 113, 027201 (2014).DOI
- [39]Z. Zhu and S. R. White, Spin liquid phase of the S = 1/2 J₁-J₂ Heisenberg model on the triangular lattice, Phys. Rev. B 92, 041105 (2015).
- [40]S. R. White, Density matrix renormalization group algorithms with a single center site, Phys. Rev. B 72, 180403 (2005).DOI
- [41]C. Hubig, I. P. McCulloch, U. Schollwöck, and F. A. Wolf, Strictly single-site DMRG algorithm with subspace expansion, Phys. Rev. B 91, 155115 (2015).DOI
- [42]H. Zhai, H. R. Larsson, S. Lee, Z.-H. Cui, T. Zhu, C. Sun, L. Peng, R. Peng, K. Liao, J. Tölle, J. Yang, S. Li, and G. K.-L. Chan, Block2: A comprehensive open source framework to develop and apply state-of-the-art DMRG algorithms in electronic structure and beyond, J. Chem. Phys. 159, 234801 (2023).DOI
- [43]S. R. White and A. L. Chernyshev, Néel Order in Square and Triangular Lattice Heisenberg Models, Phys. Rev. Lett. 99, 127004 (2007).DOI
- [44]C. Hubig, J. Haegeman, and U. Schollwöck, Error estimates for extrapolations with matrix-product states, Phys. Rev. B 97, 045125 (2018).DOI
- [45]F. Verstraete, J. J. García-Ripoll, and J. I. Cirac, Matrix Product Density Operators: Simulation of Finite-Temperature and Dissipative Systems, Phys. Rev. Lett. 93, 207204 (2004).pubmed.ncbi.nlm.nih.gov/15600964
- [46]S. R. White, Minimally Entangled Typical Quantum States at Finite Temperature, Phys. Rev. Lett. 102, 190601 (2009).DOI
- [47]M. P. Zaletel, R. S. K. Mong, C. Karrasch, J. E. Moore, and F. Pollmann, Time-evolving a matrix product state with long-ranged interactions, Phys. Rev. B 91, 165112 (2015).DOI



