Unitary imaginary time evolution and ground state preparation using multi-copy protocols

This paper introduces deterministic unitary protocols that approximate imaginary-time evolution for ground-state preparation using multi-copy registers and controlled-SWAP operations, analyzing trade-offs between circuit depth and width in tree versus "hedge" architectures while demonstrating the potential of mid-circuit post-selection and platform-specific implementations.

The Gist

Imagine you are trying to find the absolute lowest point in a vast, foggy mountain range. In the world of quantum physics, this "lowest point" is called the ground state. It's the most stable, calm energy level of a system. Finding it is crucial for designing new materials, drugs, and understanding the universe, but it's incredibly hard because the landscape is full of confusing valleys and hills that trap you.

This paper introduces a clever new way to find that lowest point using a quantum computer. Instead of hiking down the mountain step-by-step (which takes a long time), they propose a method that acts like a quantum gravity slide, letting the system slide down exponentially fast.

Here is the breakdown of their idea using simple analogies:

1. The Problem: The Foggy Mountain

Usually, to find the lowest energy state, you have to simulate time passing. But in the real world, time moves forward, and you just wander around.
Imaginary Time is a mathematical trick. Imagine if time didn't move forward, but instead acted like a "cooling agent." If you run a simulation in "imaginary time," high-energy states (the hot, excited peaks) evaporate quickly, and the system naturally settles into the cold, low-energy valley (the ground state).

The problem? Quantum computers are built to simulate real time, not imaginary time. You can't just tell a quantum computer to "cool down" directly.

2. The Solution: The "Heating and Cooling" Dance

The authors propose a protocol that mimics this cooling effect using multiple copies of the same system.

Think of it like this:

• Imagine you have two identical twins (two copies of your quantum system).
• You want one twin to get "hotter" (higher energy) and the other to get "cooler" (lower energy).
• You use a special quantum move called a SWAP (which is like a magic handshake where they exchange parts of their identity).
• By doing this handshake in a very specific rhythm, you trick the system: one twin effectively moves forward in imaginary time (cooling down), and the other moves backward (heating up).
• The "cool" twin gets closer to the ground state, while the "hot" twin gets pushed away.

3. The Two Architectures: The Tree vs. The Hedge

To cool the system down enough to reach the bottom, you need to repeat this dance many times. The paper proposes two ways to organize the dancers (the copies):

• The Tree Circuit (The "Expensive" Method):
  Imagine a family tree. To cool one person down, you need a huge number of relatives. In this setup, every time you take a step down the mountain, you double the number of copies you need.

  • Pros: It is mathematically guaranteed to work perfectly.
  • Cons: It gets expensive very fast. If you want to go deep, you need an exponential number of copies (like needing 1,000,000 people to take 20 steps).

• The Hedge Circuit (The "Smart" Method):
  Imagine a hedge maze. This is a more compact, efficient arrangement. Instead of doubling the crowd every time, you reuse the existing copies in a clever, repeating pattern.

  • Pros: It uses far fewer copies (only a polynomial number), making it much more feasible for current technology.
  • Cons: It's a "heuristic" approach, meaning it works based on smart guesses and numerical evidence rather than a strict mathematical proof, but the results look very promising.

4. The "Post-Selection" Boost

Sometimes, during the dance, a copy might get "distracted" and wander off course. The authors suggest a trick called post-selection.

• Imagine a referee watching the dance. If a copy wanders too far from the starting line, the referee says, "Reset! Try again!"
• This speeds up the process significantly because you only keep the "good" dancers. It makes the protocol probabilistic (it might take a few tries to get a good result), but it converges to the answer much faster.

5. Trading "Volume" for "Measurements"

The paper also suggests a trade-off. If you don't have enough quantum computers (copies) to build a big circuit, you can build a smaller, simpler circuit and run it many, many times.

• Think of it like taking a photo. You can either use a massive, expensive camera with a huge sensor (many copies) to get a perfect picture in one shot.
• Or, you can use a small, cheap camera (fewer copies) and take thousands of photos, then use a computer to stitch them together to get the same high-quality result.
• This allows researchers to use the hardware they have right now, even if it's not perfect.

Why This Matters

This isn't just theory; it's designed for near-term quantum computers.

• Current quantum devices are noisy and can't hold complex calculations for long.
• This method uses hybrid analog-digital circuits. It uses the natural physics of the machine (analog) to do the heavy lifting and only uses digital "SWAP" gates to manage the copies.
• It fits perfectly into existing experimental setups like optical lattices (atoms trapped in light grids) and Rydberg atom arrays (atoms manipulated by lasers), which are already capable of holding multiple copies of a system.

In summary: The paper provides a practical "recipe" for using multiple copies of a quantum system to simulate a "cooling" process. This allows us to slide quantum systems down to their most stable state much faster than before, using hardware that actually exists today. It's a bridge between the theoretical dream of quantum simulation and the messy reality of building quantum computers.

Technical Summary

Here is a detailed technical summary of the paper "Unitary imaginary time evolution and ground state preparation using multi-copy protocols."

1. Problem Statement

Preparing the ground state of a local Hamiltonian is a central challenge in quantum computation and simulation, essential for understanding quantum matter phases, chemical structures, and solving optimization problems. However, this task is generally QMA-complete (intractable) in the worst case.

Existing approaches face significant trade-offs:

• Variational methods (VQE): Suffer from trainability issues and ansatz dependency.
• Phase Estimation: Requires deep circuits and high coherence, often exceeding near-term hardware capabilities.
• Adiabatic/Dissipative methods: Constrained by relaxation times or mixing rates.
• Imaginary Time Evolution (ITE): While theoretically powerful for exponentially suppressing excited states, standard ITE is non-unitary and non-linear, making it difficult to implement directly on quantum hardware without measurement overhead or complex variational approximations.

The paper addresses the need for a deterministic, unitary protocol that approximates imaginary time evolution using near-term hardware capabilities, specifically leveraging multi-copy registers.

2. Methodology

The authors propose a deterministic approach based on multi-copy protocols that utilize real-time evolution and controlled-SWAP operations to simulate imaginary time dynamics.

Core Mechanism: Double-Bracket Flow

The protocol approximates the imaginary time evolution equation:
$$\frac{d\phi_\beta}{d\beta} = -[[\phi_\beta, H], \phi_\beta]$$
This is achieved by acting on two copies of a quantum state, $\rho_1$ and $\rho_2$.

1. Real-Time Evolution: One copy evolves forward in real time ($e^{-i\sqrt{\epsilon}H}$), while the other remains static or evolves differently.
2. SWAP Interaction: A controlled-SWAP (or a specific unitary generated by the SWAP operator $S$) is applied between the copies.
3. Effective Dynamics: By tracing out one copy, the remaining copy undergoes an effective evolution that approximates a step in imaginary time. Specifically, the gate $W$ (or $U, V$) acts on two identical states $|\psi\rangle \otimes |\psi\rangle$ to produce:
   $$W |\psi\rangle \otimes |\psi\rangle \approx |\psi_{+\epsilon}\rangle \otimes |\psi_{-\epsilon}\rangle$$
   where one copy is "heated" (backward imaginary time) and the other is "cooled" (forward imaginary time).

Circuit Architectures

The paper analyzes two specific circuit families to accumulate these small steps ($\epsilon$) into a large total imaginary time $\beta$:

• Tree Architecture:

  • Structure: A hierarchical tree where gates act on pairs of copies that are in identical states.
  • Resource Scaling: Requires $2^n$copies to achieve$n$ steps of evolution.
  • Convergence: Provable polynomial convergence in depth ($O(1/n)$ error scaling), but with an exponential width (number of copies).
  • Theoretical Bound: The authors derive an upper bound on the trace distance error (Eq. 20), showing it scales with $\beta \|H\|$.

• Hedge Architecture:

  • Structure: A heuristic, compact circuit using a "diamond" block structure. It reuses copies more efficiently by acting on the target copy $n$ times while managing a bookkeeping vector of state evolutions.
  • Resource Scaling: Requires only a polynomial number of copies ($O(n)$) and gates ($O(n^3)$) to achieve $n$ steps.
  • Convergence: Numerical evidence suggests comparable accuracy to the tree circuit with significantly reduced width.

Enhancements

• Mid-Circuit Post-Selection: The authors demonstrate that measuring and post-selecting copies that return to their initial state (or specific states) during the circuit execution can significantly accelerate convergence, albeit introducing a probabilistic element.
• Circuit Volume vs. Shot Complexity Trade-off: A third protocol is introduced where circuit volume (gates/copies) is traded for measurement shots. By preparing multiple copies in an approximate thermal state and using a Swap Trick (measuring $\text{Tr}(\rho^n)$), one can estimate ground state observables. This shifts the cost from quantum resources to classical sampling (shots).

3. Key Contributions

1. Deterministic Unitary ITE: The paper constructs explicit, deterministic quantum circuits that approximate normalized imaginary time evolution without requiring non-unitary operations or variational optimization loops.
2. Multi-Copy Primitives: It establishes that the combination of real-time evolution and SWAP operations generates the necessary algebraic structure (double-bracket flow) to simulate cooling.
3. Two Circuit Families:
   • A Tree circuit with rigorous error bounds but exponential resource requirements.
   • A Hedge circuit that achieves polynomial width, making it more feasible for near-term devices, supported by numerical simulations.
4. Resource Trade-offs: The work elucidates a trade-off between quantum circuit depth/width and classical measurement shots, offering a flexible strategy for ground state preparation.
5. Experimental Roadmap: The paper outlines concrete implementation paths for specific near-term platforms, including neutral atoms in optical lattices and Rydberg atom arrays, where multi-copy registers and SWAP operations are native or easily implementable.

4. Results

• Numerical Validation (Ising Model): Simulations on the mixed-field Ising model ($N$ spins) show that the Tree circuit converges to the ground state. The convergence rate depends primarily on the energy gap and the initial state's overlap with the ground state, rather than just system size (for fixed overlap).
• Hedge Circuit Performance: Numerical results for a single-qubit Hamiltonian ($H=\sigma_z$) and MPS simulations for larger systems show that the infidelity scales as $1/n$(or$1/n^2$for specific parameters) with the number of steps$n$.
• Post-Selection Speedup: Simulations indicate that post-selection can drastically reduce the number of steps required to reach a target fidelity, making the protocol viable even with limited copy numbers.
• Swap Trick Efficacy: The "single-layer" protocol using the swap trick successfully estimates ground state energy, demonstrating that the error in the thermal state approximation converges exponentially with the number of copies $n$.

5. Significance and Outlook

• Near-Term Applicability: Unlike algorithms requiring deep coherent circuits (like QPE), this protocol is designed for hybrid analog-digital execution. It relies on native Hamiltonian evolution and simple SWAP operations, which are natural in analog quantum simulators (e.g., cold atoms, Rydberg arrays).
• Complementarity: These protocols can serve as a "polishing" step after other state preparation methods (like adiabatic evolution) to increase ground state fidelity.
• Theoretical Insight: The work bridges the gap between Euclidean path integrals (imaginary time) and unitary quantum dynamics, providing a practical method to access finite-temperature physics and ground states on quantum hardware.
• Future Directions: The authors highlight the need to further analyze the convergence of the Hedge circuit analytically, optimize gate parameters ($\epsilon$) dynamically, and study the impact of noise on these multi-copy protocols.

In summary, this paper presents a robust, hardware-efficient framework for ground state preparation by transforming the non-unitary problem of imaginary time evolution into a unitary, multi-copy quantum circuit problem, offering a viable path for near-term quantum advantage in simulation tasks.