Compressed minimum-purity time evolution for late-time quantum dynamics

This paper introduces the Compressed Minimum-Purity Time Evolution (CoMPuTE) method, which maintains accurate long-time quantum dynamics by evolving reduced local density matrices under a minimum-purity principle, thereby achieving computational efficiency and enabling the study of late-time phenomena like energy diffusion in higher-dimensional systems.

The Gist

Imagine you are trying to predict how a complex crowd of people moves through a city square over several hours. At the very beginning, everyone is standing still or moving in simple patterns. But as time goes on, people start bumping into each other, forming groups, creating complex waves of movement, and getting tangled up in a massive, chaotic web of interactions.

If you tried to track every single person's exact position and relationship with every other person, your computer would run out of memory almost instantly. This is the problem physicists face when simulating quantum systems (tiny particles) over long periods: the "entanglement" or connection between particles grows so fast that it becomes impossible to calculate.

However, the authors of this paper noticed something interesting: while the details of the crowd get messy, the overall flow of the crowd often settles into simple, predictable patterns (like traffic flowing smoothly or heat spreading out). They asked: Can we throw away the messy, irrelevant details to keep the simulation running, without losing the important big-picture behavior?

To answer this, they created a new method called CoMPuTE (Compressed Minimum-Purity Time Evolution). Here is how it works, using simple analogies:

The Old Way: The "Perfect Memory" Problem

Previous methods (like the one called LITE) tried to keep a "perfect memory" of the system's state. To do this, they had to perform very heavy mathematical calculations (involving "matrix logarithms") to decide what information was important and what could be forgotten.

• The Analogy: Imagine trying to clean a room by weighing every single item to decide if it's trash. It's accurate, but it takes forever and requires a super-computer.

The New Way: CoMPuTE's "Purity" Trick

The authors realized they could use a simpler, faster way to measure "messiness." Instead of weighing every item, they use a concept they call "Purity."

• The Analogy: Think of "Purity" as a measure of how "mixed up" a group of particles is. A pure group is like a clear glass of water; a mixed group is like muddy water.
• The Strategy: CoMPuTE tracks small groups of particles (reduced density matrices) instead of the whole system. As these groups get bigger and more complex, the method asks: "Is this group getting too muddy?"
  • If it gets too muddy (too much complexity), the method performs a "cleaning step." It throws away the extra "mud" (irrelevant information) but carefully ensures that the "water level" (energy and currents) at the edges of the group stays exactly the same.
  • The Big Win: Because they use this "Purity" measure instead of the heavy "Perfect Memory" math, the calculations become millions of times faster. It's like switching from weighing every item to just looking at the color of the water to decide if it's clean.

What They Tested

The team tested this new "cleaning" method in three different scenarios:

1. The Heat Diffusion Test (The Ising Model):
   They simulated how heat spreads through a chain of magnets.

   • Result: CoMPuTE predicted the speed of heat spreading almost perfectly, matching the old, slower methods. But because it was so much faster, they could simulate larger groups and for longer times, giving a more precise answer.

2. The "Pure" State Test (Floquet Dynamics):
   They tried starting with a system that was perfectly ordered (a "pure" state), which is very hard to simulate because it creates chaos quickly.

   • Result: The old method struggled with these pure states, but CoMPuTE handled them easily. It successfully tracked how the system heated up and relaxed over time, proving it can handle "genuinely out-of-equilibrium" situations.

3. The "Super-Diffusion" Test (The XXZ Chain):
   They simulated a special type of magnetic chain where particles move in a weird, "super-fast" way (superdiffusion).

   • Result: This was the limit test. CoMPuTE worked well for a long time, but eventually, the "cleaning" step had to throw away information that was actually important for this specific type of movement.
   • The Lesson: This didn't mean the method failed; it meant they found the exact point where the "small group" view wasn't enough to see the "big picture" anymore. It showed them exactly where the method's limits are, which is valuable knowledge.

The Bottom Line

The paper claims that CoMPuTE is a faster, more efficient way to simulate how quantum systems behave over long periods.

• It trades a tiny bit of mathematical "perfection" for a massive gain in speed.
• It allows scientists to simulate larger systems and longer times than before.
• It works well for standard heat and energy transport.
• It can even handle systems starting from perfectly ordered states.
• It helps scientists understand when and why a simulation might break down, specifically when the physics requires looking at very large, complex connections between particles.

In short, CoMPuTE is like a smart filter that lets you watch the movie of a quantum system's life without your computer crashing, as long as you don't need to see every single frame of the background noise.

Technical Summary

Technical Summary: Compressed Minimum-Purity Time Evolution (CoMPuTE)

Problem Statement
Numerical simulation of unitary time evolution in quantum many-body systems is severely limited by the rapid generation of entanglement and complex correlations, which causes the computational cost to scale exponentially with system size and time. While late-time dynamics of physical observables often exhibit effective simplicity (e.g., hydrodynamics or kinetic theory), capturing these regimes requires bridging the gap between short-time microscopic complexity and long-time emergent behavior. Existing methods, such as the Local-Information Time Evolution (LITE) algorithm, attempt to address this by evolving a hierarchy of reduced density matrices (RDMs) and closing the hierarchy via information-theoretic principles. However, LITE relies on the von Neumann entropy, requiring matrix logarithms and spectral decompositions. These operations impose a computational cost scaling as $O(d^3_\ell)$ (where $d_\ell$ is the subsystem Hilbert space dimension) and introduce numerical instabilities, particularly for pure states or small eigenvalues, limiting the accessible subsystem sizes and time scales.

Methodology
The authors introduce Compressed Minimum-Purity Time Evolution (CoMPuTE), an algorithmic refinement of LITE that replaces the von Neumann entropy with the Rényi-2 entropy (equivalently, purity) as the measure of information.

• Hierarchy and Closure: CoMPuTE evolves a consistent set of local RDMs organized on a subsystem lattice up to a maximum level $\ell_{max}$. The hierarchy is closed using a "minimum-purity principle" rather than maximum-entropy recovery.
• Purity Gain and Currents: The method introduces purity gain ($\gamma^\ell_n$), a scale-resolved diagnostic defined as the overlap-corrected change in Rényi-2 purity when combining overlapping lower-level marginals into a parent subsystem. Unlike von Neumann irreducible information, purity gain is signed (can be negative) because Rényi-2 entropy lacks a general strong-subadditivity property. The dynamics of purity are governed by local continuity equations involving purity currents at the boundaries of subsystems.
• Recovery and Removal Steps:
  • Recovery: When higher-level RDMs are needed for the equations of motion, they are reconstructed from overlapping lower-level marginals. CoMPuTE formulates this as a constrained optimization problem: minimizing the purity (maximizing Rényi-2 entropy) subject to marginal constraints. This yields a closed-form solution (Eq. 28) that avoids matrix decompositions.
  • Removal: When the accumulated purity gain at the top level exceeds a threshold, a "removal" step resets the working level to a lower truncation scale $\ell_{min}$. This step applies a correction that minimizes purity while preserving boundary marginals and purity currents.
• Computational Complexity: By utilizing Rényi-2 entropy, the evaluation of information content reduces to calculating $\text{Tr}(\rho^2)$, which scales as $O(d^2_\ell)$ via matrix contractions. The recovery and removal steps are reformulated as constrained least-squares problems (projections), eliminating the need for matrix logarithms and spectral decompositions. This reduces the overall computational complexity by a factor of $d_\ell$ compared to LITE.

Key Contributions

1. Algorithmic Efficiency: CoMPuTE replaces the computationally expensive $O(d^3_\ell)$ operations of LITE with $O(d^2_\ell)$ operations, enabling simulations at significantly larger subsystem sizes.
2. Pure-State Propagation: The avoidance of matrix logarithms removes numerical instabilities associated with vanishing eigenvalues, making the propagation of pure initial states practical, a regime where standard LITE is often prohibitive.
3. New Diagnostic Tool: The introduction of purity gain provides a scale-resolved diagnostic for information flow, analogous to the information lattice in LITE but computationally cheaper to evaluate.

Results and Benchmarks
The paper validates CoMPuTE against LITE, Density Matrix Truncation (DMT), and exact diagonalization (ED) across three distinct regimes:

1. Diffusive Transport (Mixed-Field Ising Model):

   • CoMPuTE reproduces the time-dependent energy diffusion coefficient $D_E(t)$ with high accuracy, matching LITE results across various truncation parameters ($\ell_{min}, \ell_{max}$).
   • Due to the reduced computational cost, CoMPuTE accesses larger $\ell_{max}$ values (up to 13 spins). This allows for a converged determination of the late-time diffusion plateau ($\bar{D}_E \approx 1.43$) without the need for the linear extrapolation in $1/\ell_{min}$ required by previous LITE studies, aligning with literature values.
   • Runtime benchmarks show CoMPuTE is approximately six orders of magnitude faster than LITE for the largest simulated subsystems.

2. Driven Floquet Dynamics:

   • The method successfully simulates a driven spin chain starting from a pure product state, a scenario difficult for standard LITE.
   • CoMPuTE captures the relaxation and heating trends toward an infinite-temperature state, matching DMT results.
   • Scale-resolved purity gain diagnostics reveal distinct dynamics for pure versus locally mixed initial states, showing strong transient purity flows that decay during heating.

3. Integrable Transport (XXZ Chain at $\Delta=1$):

   • The method is tested on the superdiffusive spin transport regime, which is governed by quasiparticles with growing spatial support (Bethe ansatz strings).
   • CoMPuTE correctly captures the superdiffusive scaling $D_\sigma(t) \propto (Jt)^{1/3}$ over a time window that extends systematically as $\ell_{min}$ increases.
   • The breakdown of superdiffusion at a crossover time $t_{cross}$ is observed to scale as $J t_{cross} \propto \ell_{min}^3$, consistent with kinetic theory predictions that the truncation limits the maximum effective string length.
   • In contrast, energy transport (which is ballistic and tied to local currents) remains robust over the accessible window, demonstrating that the method's limitations are tied to the non-local structure of the relevant transport modes rather than a generic instability.

Significance and Claims
The paper claims that CoMPuTE enhances the computational efficiency of information-lattice methods by removing the bottleneck of matrix decompositions, thereby opening a route to simulating larger subsystems and longer time scales. It demonstrates that replacing von Neumann entropy with Rényi-2 entropy preserves the accuracy of transport observables in diffusive and driven regimes while enabling the study of pure-state dynamics.

The authors modestly note that while CoMPuTE extends the accessible time window for integrable systems, the method still faces fundamental limits when transport is governed by increasingly non-local operators (as seen in the XXZ chain), where the truncation scale $\ell_{max}$ ultimately bounds the duration of the anomalous regime. However, the method transforms this limitation into a systematic convergence problem in $\ell_{max}$ rather than an immediate numerical failure. The paper concludes that these improvements make CoMPuTE a promising basis for future extensions to higher spatial dimensions, though such extensions would require new geometric and recovery strategies.