Computing Green's functions and improving ground state energy estimation on quantum computers with Liouvillian recursion

This paper presents a noise-robust, quantum-classical hybrid algorithm using Liouvillian recursion to compute many-body Green's functions on near-term quantum hardware, which subsequently enables more accurate ground state energy estimation via the Galitskii-Migdal formula than direct Hamiltonian expectation values.

The Gist

Imagine you are trying to bake the perfect chocolate cake (the ground state of a complex material). You have a recipe, but your oven is a bit old and unreliable (the quantum computer is noisy), and your ingredients aren't 100% pure (your approximate ground state isn't perfect).

Usually, if you taste the cake straight out of the oven, it might be a bit off. But what if there was a way to take that slightly imperfect cake, run it through a special "flavor analyzer," and mathematically reconstruct the true recipe of the perfect cake, even better than if you had just tasted the raw ingredients?

That is essentially what this paper does, but instead of cakes, they are simulating electrons in a material, and instead of a flavor analyzer, they use a mathematical technique called Liouvillian recursion on a quantum computer.

Here is a breakdown of their breakthrough in simple terms:

1. The Problem: The "Noisy" Kitchen

Scientists want to use quantum computers to simulate how electrons behave in complex materials (like superconductors). To do this, they need to calculate something called a Green's function. Think of the Green's function as a "map" that tells you how an electron moves and interacts with others.

However, current quantum computers are "noisy." They make mistakes. If you try to calculate this map directly, the noise ruins the picture. Also, getting the perfect starting point (the ground state) is incredibly hard. Most methods require deep, complex circuits that break down on today's machines.

2. The Solution: The "Recursive Ladder"

The authors used a method called Liouvillian recursion.

• The Analogy: Imagine you are trying to guess the shape of a hidden object in a dark room. You can't see it all at once.
  • Step 1: You touch the object with your hand (measure the first observable).
  • Step 2: You use that touch to guess the next part of the shape, then touch that part (measure the next observable).
  • Step 3: You keep doing this, building a "ladder" of information step-by-step.

In physics, this "ladder" is built by repeatedly asking the quantum computer: "If I push this electron here, what happens next?" The computer answers, and the algorithm uses that answer to ask the next, slightly more complex question.

3. The Magic Trick: Getting Better Than the Starting Point

Here is the most surprising part of the paper.

Usually, if you start with a bad approximation of a cake, your final result is a bad cake. But this algorithm is like a magic filter.

• They started with three different "imperfect" starting points (some were 99% accurate, some only 76% accurate).
• They ran their recursive ladder.
• The Result: Even when they started with a very poor approximation (76% accurate), the final calculated energy of the system was more accurate than the energy you would get just by looking at the imperfect starting point directly.

It's as if you started with a slightly burnt cake, ran it through their machine, and the machine told you, "Actually, the true recipe was perfect, and here is the exact temperature you needed."

4. The "Exponential" Trade-off

There is a catch. As you climb higher up the "ladder" (doing more iterations), the math gets incredibly complicated. The number of calculations needed grows exponentially (it doubles, then quadruples, then explodes).

• The Fear: "This will take forever and use too much power!"
• The Reality: The authors found that the accuracy also improves exponentially. The more steps you take, the closer you get to the truth, and you get there so fast that it cancels out the extra work.

They measured this using something called the Wasserstein distance (a fancy way of measuring how far apart two probability maps are). They found that even though the work grows fast, the error shrinks even faster. The result is that the total effort required is actually quite manageable (polynomial), making this method viable for future quantum computers.

5. Why This Matters

• Noise Resilience: The method works surprisingly well even when the quantum computer is making mistakes. It's like a song that still sounds good even if the singer is slightly off-key.
• Better Energy Estimates: By using this method, they can predict the energy of a material more accurately than standard methods, which is crucial for designing new batteries, superconductors, or drugs.
• Real-World Test: They didn't just simulate this on a supercomputer; they actually ran it on a real IBM quantum processor (the "IBM Quebec" chip) and it worked.

The Bottom Line

This paper introduces a new way to use today's imperfect quantum computers to solve complex physics problems. By using a "recursive ladder" approach, they can turn a rough, noisy guess into a highly accurate prediction of how electrons behave. It's a significant step toward using quantum computers to discover new materials that could change our world.

Technical Summary

Here is a detailed technical summary of the paper "Computing Green's functions and improving ground state energy estimation on quantum computers with Liouvillian recursion."

1. Problem Statement

Simulating strongly correlated electron systems is a primary application for quantum computing, particularly for Dynamical Mean-Field Theory (DMFT) impurity solvers. A critical requirement for these simulations is the calculation of the single-particle Green's function, which provides response functions and physical observables.

Existing quantum algorithms for computing Green's functions face significant hurdles for Near-Term Intermediate-Scale Quantum (NISQ) devices:

• Circuit Depth: Many methods require deep circuits involving multi-qubit control operations or time evolution, which are currently infeasible.
• Ground State Sensitivity: Most algorithms require a perfect ground state preparation. Since preparing high-fidelity ground states is difficult even on quantum computers, errors in the initial state often propagate and degrade the results.
• Complexity: Subspace diagonalization methods can be computationally expensive or lack systematic convergence guarantees.

The authors aim to develop a hybrid quantum-classical algorithm that computes accurate Green's functions and improves ground state energy estimation using only query access to an approximate ground state, while maintaining robustness against noise and ground state imperfections.

2. Methodology

The paper proposes a Liouvillian recursion method adapted for quantum computers. The core idea is to build a continued-fraction representation of the Green's function by recursively measuring observables generated by the Liouvillian superoperator.

A. Theoretical Framework

• Retarded Green's Function: Defined as $G_{rr'}(t) = -i\langle \{c_r(t), c^\dagger_{r'}\} \rangle \theta(t)$.
• Diagonal Elements (Local): The diagonal Green's function $G_{rr}(\omega)$ is expressed as a continued fraction:
  $$G^{(k)}_{rr}(\omega) = \frac{1}{\omega - \alpha_{0,r} - \frac{\beta^2_{1,r}}{\omega - \alpha_{1,r} - \dots}}$$
  The coefficients $\alpha_{k,r}$ and $\beta_{k,r}$ are computed recursively using the Liouvillian action $L(f) = [H, f]$.
  • Recursion: $f_{k+1,r} \propto [H, f_{k,r}] - \alpha_{k,r}f_{k,r} - \beta_{k,r}f_{k-1,r}$.
  • Measurement: The coefficients are derived from expectation values of anticommutators:
    • $\beta^2_{k,r} = \langle \{ \beta_{k,r}f^\dagger_{k,r}, \beta_{k,r}f_{k,r} \} \rangle$
    • $\alpha_{k,r} = \langle \{ f^\dagger_{k,r}, [H, f_{k,r}] \} \rangle$
• Off-Diagonal Elements (Inter-site): Instead of matrix continued fractions, the authors use a polynomial hybrid formulation. Off-diagonal elements $G_{r'r}(\omega)$ are reconstructed using the diagonal Green's function and orthogonal polynomials $Q_{k,r}(\omega)$ and $L_{k,r}(\omega)$, requiring only one additional expectation value per iteration: $m_{k,r'r} = \langle \{f_{k,r}, c^\dagger_{r'}\} \rangle$.

B. Quantum Implementation

• Hybrid Approach: The quantum computer prepares an approximate ground state $|g\rangle = U_g|0\rangle$ and measures the required expectation values (4, 5, and 9 in the paper) via statistical sampling. The classical computer handles the recursion relations, polynomial expansions, and continued fraction assembly.
• Hamiltonian Mapping: The method is benchmarked on the 1D Hubbard model (4 sites, open boundary, half-filling, $U=4t$). The Hamiltonian is mapped to 8 qubits using the Jordan-Wigner transformation, resulting in 17 Pauli terms.
• Error Mitigation: Hardware runs on the IBM Quebec processor utilized Twirled Readout Error eXtinction (TREX), Zero Noise Extrapolation (ZNE), and gate twirling.

3. Key Contributions

1. Full Retarded Green's Function: Unlike previous works that separated hole and electron contributions, this algorithm computes the full retarded Green's function.
2. Polynomial Hybrid Formulation: The authors introduce a method to compute off-diagonal elements using polynomial expansions rather than matrix continued fractions, reducing complexity.
3. Energy Improvement via Galitskii-Migdal: The paper demonstrates that Green's functions computed via this recursion can be fed into the Galitskii-Migdal formula to estimate the ground state energy. Crucially, this estimate is often more accurate than the direct expectation value $\langle H \rangle$ of the approximate ground state circuit, even when the circuit fidelity is low.
4. Complexity Analysis: The authors prove that while the number of Pauli operators grows exponentially with iterations (a typical bottleneck), the exponential convergence of the recursion method compensates for this cost. This results in an effective computational complexity that is polynomial in the inverse of the Green's function accuracy (measured by Wasserstein distance).

4. Results

The algorithm was tested on the IBM Quebec superconducting processor and via classical simulation for three approximate ground states with fidelities of 0.999, 0.963, and 0.768.

• Green's Function Accuracy:
  • Hardware results for both diagonal ($G_{00}$) and off-diagonal ($G_{01}$) elements matched simulation results quantitatively at iteration $k=6$.
  • The results qualitatively approached the exact solution (converged at $k=30$) very quickly, even with low-fidelity ground states.
• Energy Estimation:
  • For all three circuits, the energy estimates derived from the Galitskii-Migdal formula (using even iterations $k=2, 4, 6...$) were closer to the true ground state energy ($E_0 = -9.9531$) than the direct hardware expectation value $\langle H \rangle$.
  • Robustness: Even with a low-fidelity circuit (0.768), where $\langle H \rangle$ was far from the true energy, the Green's function-based estimate remained superior.
  • Noise Resilience: The algorithm showed inherent robustness; results for low-fidelity states tracked high-fidelity states closely in the early iterations, suggesting the method is insensitive to initial ground state imperfections.
• Convergence vs. Cost:
  • Figure 3 in the paper demonstrates that the Wasserstein distance to the exact solution scales as $d \propto p^{-1/4}$, where $p$ is the number of Pauli operators. This confirms a polynomial scaling of computational cost with respect to accuracy, despite the exponential growth of operators.

5. Significance

• NISQ Suitability: The method is uniquely suited for near-term quantum computers because it avoids deep time-evolution circuits and is robust against both hardware noise and imperfect ground state preparation.
• DMFT Applications: By providing a reliable way to compute impurity Green's functions and improve energy estimates, this algorithm offers a viable path for integrating quantum computers into Dynamical Mean-Field Theory workflows for studying correlated materials.
• Theoretical Insight: The work validates the theoretical prediction that Liouvillian recursion converges exponentially, effectively neutralizing the exponential cost of operator expansion. This suggests that quantum advantage for Green's function computation may be achievable with relatively shallow circuits and moderate iteration counts.

In conclusion, this paper presents a robust, hybrid quantum-classical algorithm that leverages Liouvillian recursion to compute Green's functions and refine ground state energies, demonstrating that high-accuracy results are attainable on current noisy hardware even with suboptimal state preparation.