Scalable Quantum Algorithms for Gutzwiller Projection

This paper introduces scalable quantum algorithms that combine arbitrary BCS state preparation with amplitude amplification to achieve a quadratic reduction in projection queries, enabling the efficient preparation of Gutzwiller-projected states for simulating strongly correlated lattice models like the $t$-$J$ model.

The Gist

The Big Picture: Finding the "Perfect" Starting Point

Imagine you are trying to solve a massive, incredibly difficult puzzle (representing a complex material like a high-temperature superconductor). To solve it quickly, you need to start with a puzzle piece that is already very close to the final picture. If you start with a random piece, you might spend forever trying to find the right spot.

In the world of quantum computing, this "perfect starting piece" is called an input state. The paper focuses on a specific type of starting state called a Gutzwiller-projected BCS state (or RVB state). Think of this state as a highly educated guess that physicists know is very good for describing how electrons behave in these tricky materials.

However, there is a problem: Creating this perfect starting piece on a quantum computer is incredibly hard.

The Problem: The "Double Occupancy" Rule

Imagine a crowded dance floor (the quantum computer) where electrons are the dancers. In the specific materials the authors are studying, there is a strict rule: No two dancers of opposite spins can stand on the same spot at the same time. If they do, the energy becomes too high, and the state is "ruined."

1. The Easy Part (BCS State): The authors can easily create a "dance floor" where the dancers are moving in a coordinated, beautiful pattern (the BCS state).
2. The Hard Part (The Projection): The problem is that in this easy pattern, some dancers accidentally end up standing on the same spot (double occupancy). To get the "perfect" RVB state, you have to remove all those pairs.

The Old Way (Measurement-Based Postselection):
Imagine trying to fix the dance floor by having a referee watch every single spot.

• If the referee sees a pair, they yell "Stop!" and everyone has to go back to the dressing room and start the whole dance over from scratch.
• Because the "perfect" dance is so rare compared to the "messy" dance, the referee will yell "Stop!" almost every time.
• You might have to restart the dance trillions of times just to get one successful run. This is too slow and expensive for a quantum computer.

The Solution: The "Amplitude Amplification" Trick

The authors propose a new method called Amplitude Amplification for Gutzwiller Projection (AAGP).

Instead of watching and restarting, imagine you have a magical conductor who can coherently nudge the dancers.

• Every time the dancers accidentally step on each other, the conductor doesn't stop the music. Instead, they subtly change the rhythm to make that "mistake" less likely and the "perfect" pattern more likely.
• They repeat this nudge many times.
• The Magic: While the old method required trillions of tries (linear scaling), this new method only requires the square root of that number (quadratic scaling).

The Analogy:

• Old Way: You are looking for a specific needle in a haystack. You pull out a handful of hay, check it, and if it's not the needle, you throw the whole haystack away and start with a new one.
• New Way (AAGP): You have a magnet that gently pulls the needle closer to the surface every time you check. You don't have to throw the haystack away; you just keep using the magnet until the needle pops out.

The Results: A Massive Leap Forward

The authors ran simulations to see how much better this new method is.

• The Challenge: For a system with 100 sites (a "dance floor" with 100 spots), the probability of the perfect state existing naturally is so tiny that the old method would need to try about 10,000,000,000,000,000 (10 quadrillion) times.
• The Breakthrough: Using their new AAGP method, they only need to try about 10,000,000 (10 million) times.

The Takeaway:
This is a reduction of seven orders of magnitude. To put that in perspective, if the old method would take a human lifetime to finish, the new method could finish it in a few hours.

Why This Matters

The paper doesn't claim this solves the whole problem of simulating materials. It claims to solve the first, most critical step: getting the right starting point.

• Without this new trick, preparing these specific quantum states is effectively impossible for large systems because the computer would run out of time and energy.
• With this new trick, these states become practical and usable. It turns a "theoretical idea" into a "deployable tool" for quantum computers.

In short, the authors built a "turbocharger" for preparing the starting states of quantum simulations, making it possible to study complex materials on quantum computers that was previously out of reach.

Technical Summary

Technical Summary: Scalable Quantum Algorithms for Gutzwiller Projection

Problem Statement
Quantum simulation of strongly correlated lattice models, such as the Hubbard and $t$-$J$ models, offers a pathway to study quantum materials beyond the reach of exact classical diagonalization. However, the efficacy of algorithms like Variational Quantum Eigensolvers (VQE) and Quantum Phase Estimation (QPE) is critically dependent on the quality of the input state. For strongly repulsive systems, the Gutzwiller-projected Bardeen-Cooper-Schrieffer (BCS) state (often called the Resonating Valence Bond or RVB state) is a physically motivated ansatz that captures the no-double-occupancy constraint inherent in these models.

The primary obstacle to utilizing RVB states on quantum hardware is the non-trivial nature of the Gutzwiller projection ($\mathcal{P}_G$). A naive approach involves repeatedly measuring double occupancy at every lattice site and post-selecting outcomes with no double occupancy. This measurement-based method is highly inefficient because the probability weight ($W$) of the RVB state within the unprojected BCS state decreases exponentially with system size. Consequently, the number of required queries scales as $O(1/W)$, rendering the preparation of RVB states for physically relevant system sizes (e.g., $\sim 100$ sites) effectively impossible due to the exponential suppression of success probability.

Methodology
The authors propose a scalable quantum algorithm termed Amplitude Amplification for Gutzwiller Projection (AAGP) to overcome the inefficiency of post-selection. The methodology consists of two main components:

1. Construction of Arbitrary BCS States:
   The authors detail a circuit construction for preparing arbitrary BCS states on finite-size quantum computers, even when translational symmetry is broken (e.g., in disordered systems). This is achieved via the Bloch-Messiah decomposition.

   • The BCS Hamiltonian is expressed in the Bogoliubov-de Gennes (BdG) form.
   • The single-particle Hamiltonian matrix is diagonalized classically to obtain the Bogoliubov transformation.
   • A unitary operator $U_{BCS}$ is constructed using a sequence of Givens rotations (implemented via quantum circuits) to map the vacuum state to the desired BCS state. This process handles the transformation from electronic operators to the diagonalized quasiparticle basis.

2. Amplitude Amplification for Projection:
   Instead of measuring and discarding failed states, the AAGP algorithm coherently amplifies the amplitude of the Gutzwiller-projected component within the BCS state.

   • The algorithm treats the projection as a search problem where the target state is the RVB state ($|\psi_{RVB}\rangle$) and the initial state is the BCS state ($|\psi_{BCS}\rangle$).
   • It employs a series of unitary operations involving $U_{BCS}$, its inverse $U_{BCS}^\dagger$, and conditional phase rotations ($R_{vac}$ and $R_G$) that act on the vacuum and the Gutzwiller-projected subspace, respectively.
   • By optimizing the rotation angles (derived from Chebyshev polynomials), the algorithm amplifies the success probability to near unity.
   • Crucially, the number of queries to the BCS preparation circuit scales as $O(1/\sqrt{W})$, providing a quadratic speedup over the $O(1/W)$ scaling of measurement-based post-selection.

Key Results
The paper provides a rigorous analysis of the resource scaling and numerical benchmarks for the square-lattice $t$-$J$ model:

• Scaling Analysis: The total T-gate count for preparing the RVB state on $N_s$ sites is derived as $O\left(\frac{\ln(2/\delta)}{\sqrt{W}} N_s^2 \log^2(1/\epsilon)\right)$, where $\delta$ is the tolerance and $\epsilon$ is the precision. This represents a significant improvement in fault-tolerant resource scaling compared to post-selection.
• Probability Weight ($W$): Numerical calculations for systems up to $N_s=20$ (the limit of classical exact diagonalization) show that $W$ decays exponentially with system size ($W \approx A e^{-\lambda N_s}$).
• Benchmark Performance: For a 100-site benchmark (a size beyond classical exact diagonalization but relevant for physical many-body behavior), the projected-state weight is estimated to be $W \approx 1.7 \times 10^{-15}$.
  • A measurement-based approach would require $\sim 10^{15}$ queries.
  • The AAGP algorithm reduces this requirement to $\sim 10^7$–$10^8$ queries.
  • This constitutes a reduction of approximately seven orders of magnitude.

Significance and Claims
The authors assert that the significance of AAGP extends beyond asymptotic theory. While the overall resource cost is still governed by the exponentially small weight $W$, the quadratic improvement is sufficient to cross a "practical finite-size threshold."

• Enabling Primitive: The paper claims that AAGP transforms the preparation of projected BCS/RVB states from "effectively unusable" to "plausibly deployable" within a larger fault-tolerant workflow for system sizes of $\sim 100$ sites.
• Versatility: The algorithm is not limited to translationally invariant systems; it supports disordered models, various lattice geometries, and tunable filling factors. It can serve as an input state for studying quantum spin liquids (e.g., Dirac spin liquids on kagome lattices) and high-temperature superconductivity mechanisms.
• Modest Scope: The authors explicitly state that AAGP does not solve the entire resource challenge of simulating strongly correlated models but removes a specific, critical obstruction: the preparation of high-quality input states. They view it as an "enabling input-state preparation primitive."
• Future Extensions: The paper notes that while the current implementation enforces strict no-double-occupancy (the $t$-$J$ limit), the framework could potentially be extended to Hubbard models by perturbatively adding double occupancies via unitary transformations, though this is identified as future work rather than a current result.