Quasi-Adiabatic Processing of Thermal States

This paper investigates the performance of adiabatic evolution protocols initialized from finite-temperature Gibbs states, demonstrating that key benchmarks such as state diagonality and energy convergence scale polynomially with evolution time and system size, thereby enabling the recovery of thermal expectation values in both integrable and non-integrable systems.

The Gist

Here is an explanation of the paper "Quasi-Adiabatic Processing of Thermal States," translated into everyday language with some creative analogies.

The Big Picture: The "Slow Cook" for Quantum Systems

Imagine you have a pot of soup (a quantum system) that is currently boiling hot and chaotic. You want to slowly turn it down to a gentle simmer so that the flavors settle into a perfect, stable dish. In the quantum world, this "dish" is called a Gibbs state (a thermal state), and the process of turning down the heat is usually done by changing the "recipe" (the Hamiltonian) very, very slowly.

This slow process is called Adiabatic Evolution. The rule of thumb is: If you change the recipe slowly enough, the soup stays perfectly organized.

However, there's a catch. In complex quantum systems (like a pot with thousands of ingredients), the "gaps" between different possible states are so tiny that you would need to cook for forever (exponentially long time) to keep the soup perfectly organized. Since we don't have infinite time, we can't cook it perfectly.

The Question: If we cook it "fast enough" to be practical, but "slow enough" to be decent (a Quasi-Adiabatic process), does the soup still taste right? Can we still get the thermal properties we want, even if the soup isn't perfectly organized?

The Solution: The "Good Enough" Protocol (QATE)

The authors propose a method called Quasi-Adiabatic Thermal Evolution (QATE). Instead of trying to achieve perfection (which is impossible in reasonable time), they ask: How close to perfect do we need to get to make the soup taste good?

They found that for most practical purposes, you don't need the soup to be perfectly organized. You just need two things:

1. The Energy: The total energy of the soup should be close to what it should be.
2. The "Messiness": The soup shouldn't be too chaotic. It needs to be mostly "diagonal" (meaning the ingredients are in their right places, even if a few are slightly mixed up).

The Three "Taste Tests" (Benchmarks)

To see if their "fast cook" method works, the authors invented three ways to taste the soup:

1. The Energy Check ($\Delta E_{QATE}$):

   • Analogy: Imagine you are trying to cool a hot cup of coffee by blowing on it. If you blow for a specific time, the coffee will cool down, but maybe not all the way to the "perfect" temperature. This test measures how much hotter the coffee is than the ideal temperature.
   • Result: They found that as you cook longer, the energy gets closer to the ideal, and the error shrinks predictably.

2. The "Mix-Up" Meter (COD & BOD):

   • Analogy: Imagine a deck of cards. In a perfect adiabatic process, every card stays in its original order. In a "quasi" process, a few cards might get swapped.
   • COD (Commutator Off-Diagonality): This measures how "swapped" the cards are. If the number is low, the deck is mostly in order.
   • BOD (Binned Off-Diagonality): This looks at the swaps between cards that are far apart in value.
   • Result: Even with a "fast" cook, the number of swapped cards stays very low. The soup is still mostly organized.

3. The Variance Check:

   • Analogy: If you take a spoonful of soup, does the temperature vary wildly from spoon to spoon? A good thermal state has a predictable, small variation.
   • Result: The variation scales correctly with the size of the pot, meaning the soup behaves like a real thermal system.

The Surprising Discoveries

The authors tested this on different types of "soups" (quantum models):

• The Simple Soup (Transverse Field Ising Model): This is a mathematically easy model. They proved that the "messiness" and energy errors shrink very quickly as you cook longer. It's like a recipe that is very forgiving; even if you rush a bit, it still tastes great.
• The Chaotic Soup (Non-Integrable Models): These are complex systems where ingredients interact in messy ways. Usually, these are the hardest to control. Surprisingly, the QATE method worked almost as well here as it did for the simple soup! The "messiness" still decreased predictably.
• The "Bad" Starting Point: They found that if you start with a "degenerate" state (a soup that is already perfectly uniform and boring, like plain water), the method fails. You need to start with a state that has some "structure" or "degeneracy" to work with.
• Crossing the "Phase Transition": In cooking, a phase transition is like water turning to ice. Usually, crossing this line is dangerous for adiabatic processes. The authors found that for thermal states, crossing this line isn't as catastrophic as we thought, as long as you don't start with a "boring" (degenerate) state.

Why This Matters

In the real world, quantum computers (like those from Google or IBM) are noisy and can't run for infinite time. We can't wait for the "perfect" adiabatic process.

This paper says: "Don't worry about perfection."
If you use the QATE method, you can prepare thermal states (which are essential for simulating materials, chemistry, and physics) in a reasonable amount of time. Even though the process isn't mathematically perfect, the result is "good enough" to give you the correct physical answers.

The Takeaway Metaphor

Think of the Adiabatic Theorem as trying to walk across a tightrope in a hurricane. To stay perfectly balanced, you must move infinitely slowly. That's impossible.

QATE is like walking across that tightrope in a strong wind, but moving at a brisk, steady pace. You might wobble a little (off-diagonal elements), and you might not end up at the exact coordinate you aimed for (energy difference), but you will still make it across safely, and you'll be close enough to the destination to get the job done.

The paper proves that for quantum systems, this "brisk walk" is actually a very reliable way to get the thermal properties we need, without needing a lifetime to do it.

Technical Summary

Here is a detailed technical summary of the paper "Quasi-Adiabatic Processing of Thermal States" by Irmejs, Bañuls, and Cirac.

1. Problem Statement

The Quantum Adiabatic Algorithm (QAA) is a standard method for preparing ground states of quantum systems by slowly interpolating between a trivial initial Hamiltonian and a complex target Hamiltonian. However, extending this approach to prepare thermal states (Gibbs states) at finite temperatures faces significant challenges:

• Exponential Gaps: In many-body systems, excited states in the bulk of the spectrum are separated by energy gaps that scale exponentially with system size ($N$). Strict adiabaticity would require runtimes ($T$) that scale exponentially with $N$, rendering the approach intractable.
• Spectral Mismatch: Even if adiabaticity is maintained, evolving a Gibbs state from an initial Hamiltonian ($H_{init}$) to a final one ($H_{final}$) does not generally yield the target Gibbs state unless the spectra of $H_{init}$ and $H_{final}$ are exactly proportional.
• Lack of Benchmarks: There is no established framework for quantifying how well a finite-time adiabatic evolution preserves thermal properties when strict adiabaticity is broken.

The authors ask: Can a finite-time unitary evolution (quasi-adiabatic) applied to an initial thermal state recover the thermal expectation values of observables for the final Hamiltonian, even if the final state is not a perfect Gibbs state?

2. Methodology

The authors propose and analyze the Quasi-Adiabatic Thermal Evolution (QATE) protocol.

• Protocol Definition:

  • Start with a Gibbs state $\rho_{init} = e^{-\beta H_{init}} / Z_{init}$ at finite temperature ($\beta > 0$).
  • Evolve the system unitarily via $U = \mathcal{T} e^{-i \int_0^T H(t/T) dt}$, where $H(s)$ interpolates between $H_{init}$ and $H_{final}$.
  • The resulting state is $\rho_{QATE} = U \rho_{init} U^\dagger$.
  • Crucially, the evolution time $T$ scales polynomially with $N$, breaking strict adiabaticity.

• Theoretical Framework (Isentropic Cooling):

  • Since the evolution is unitary, the von Neumann entropy $S[\rho]$ and the eigenvalues of the density matrix are conserved.
  • The process is interpreted as isentropic cooling: the system moves toward lower energy while maintaining constant entropy.
  • The theoretical lower bound for energy at fixed entropy is a state $\rho_{min}$, which is diagonal in the eigenbasis of $H_{final}$ but retains the eigenvalues of $\rho_{init}$.

• Key Benchmarks:
  To assess the success of QATE, the authors introduce three metrics:

  1. Energy Deviation ($\Delta E_{QATE}$): The difference between the energy of $\rho_{QATE}$ and the ideal isentropic limit $\rho_{min}$.
  2. Off-Diagonality Metrics:
     • Commutator Off-Diagonality (COD): $COD = -\frac{\text{Tr}([H_{final}, \rho_{QATE}]^2)}{\text{Tr}(\rho_{QATE}^2)}$. Measures the magnitude of off-diagonal elements in the energy basis.
     • Binned Off-Diagonality (BOD): Measures off-diagonal weights as a function of the energy difference $|E_i - E_j|$ between eigenstates.
  3. Energy Variance: Checks if the variance scales linearly with system size ($O(N)$), a condition required by the Eigenstate Thermalization Hypothesis (ETH) for local observables to be thermal.

3. Key Contributions

• Formalization of QATE: Defined a protocol for processing thermal states without requiring the doubling of the Hilbert space (unlike Thermofield Double approaches).
• Analytical Convergence Proofs: For the Transverse-Field Ising Model (TFIM), the authors analytically proved that the benchmarks (COD, $\Delta E_{QATE}$, Variance) converge to their ideal values with polynomial scaling in both system size ($N$) and evolution time ($T$).
• ETH Validation: Demonstrated that even with broken adiabaticity, if off-diagonal elements are small and energy variance is extensive, local observables recover thermal expectation values.
• Numerical Validation: Verified these findings in non-integrable systems, showing that the $T^{-2}$ scaling of off-diagonality persists even in chaotic regimes.

4. Results

A. Analytical Results (Transverse-Field Ising Model)

• Scaling: For a linear ramp not crossing the critical point, the authors derived that:
  • $COD \sim O(N T^{-2})$
  • $\Delta E_{QATE} \sim O(N T^{-2})$
  • $\Delta Var \sim O(N T^{-2})$
• Critical Point Crossing: When crossing the phase transition ($g=1$), the scaling changes to Kibble-Zurek behavior ($O(N T^{-1/2})$) for short times, reverting to $T^{-2}$ for sufficiently long times ($T \sim O(N^3)$).
• Smooth Ramps: Using a smooth schedule (vanishing derivatives at endpoints) improves the scaling significantly, reaching approximately $O(T^{-8})$.

B. Numerical Results

• Isospectral Models: In models where $H_{init}$ and $H_{final}$ share the same spectrum (ensuring $\Delta E_{min} = 0$), the convergence behavior remains polynomial, though the coefficients vary.
• Non-Integrable Systems: Simulations on mixed-field Ising models (chaotic systems) showed:
  • COD still exhibits $T^{-2}$ scaling, independent of system size $N$ in some regimes.
  • Energy Convergence ($\Delta E_{QATE}$) is slower in non-integrable systems compared to integrable ones but still converges.
  • Local Observables: The 1-norm distance between the reduced density matrix of $\rho_{QATE}$ and the ideal thermal state decays as $T^{-1}$.

C. Temperature and Initial State Dependence

• Temperature: The protocol performs best at very low ($\beta \to \infty$) and very high ($\beta \to 0$) temperatures. The "worst-case" performance occurs at intermediate temperatures ($\beta \approx 1$), where the scaling of energy error changes from $T^{-2}$ (low $T$) to $T^{-0.8}$ (high $T$).
• Initial State Degeneracy: The choice of $H_{init}$ is critical. Degenerate initial states (e.g., commuting terms with flat spectra) lead to significantly worse performance and slower convergence. Non-degenerate initial states are required for success.
• Phase Transitions: Crossing a zero-temperature phase transition does not inherently prevent success, provided the initial state is non-degenerate, as the bulk gaps are already small.

5. Significance and Implications

• Practical Quantum Simulation: QATE offers a viable, near-term strategy for preparing thermal states on quantum devices (e.g., cold atoms, superconducting circuits) without the overhead of Thermofield Double (TFD) methods, which require doubling the system size and engineering non-local Hamiltonians.
• Robustness of ETH: The work reinforces the Eigenstate Thermalization Hypothesis, showing that "almost adiabatic" evolution is sufficient to recover thermal physics, provided the state remains sufficiently diagonal in the energy basis.
• Experimental Relevance: The protocol aligns with current experimental capabilities where finite-entropy states are common, offering a pathway to study thermalization and equilibrium phenomena in quantum simulators.
• Future Directions: The authors suggest extending these analytical guarantees to generic non-integrable systems and optimizing the evolution schedules to further reduce the required runtime.

In summary, the paper establishes that quasi-adiabatic evolution is a robust method for thermal state preparation, provided the evolution time is polynomial in system size and the initial state is non-degenerate. The protocol successfully recovers thermal expectation values by minimizing energy deviation and off-diagonal coherence, validating its utility for future quantum simulations.