Accuracy and resource advantages of quantum eigenvalue estimation with non-Hermitian transcorrelated electronic Hamiltonians

This paper demonstrates that applying a quantum eigenvalue estimation algorithm to non-Hermitian transcorrelated Hamiltonians with the xTC approximation can achieve chemical accuracy comparable to standard qubitization on significantly larger basis sets for small atoms, though the method's accuracy degrades for larger second-row elements.

The Gist

The Big Picture: Fixing a "Bumpy" Map

Imagine you are trying to draw a map of a very rugged, mountainous terrain (this represents the behavior of electrons in an atom).

The Problem:
In standard quantum chemistry, the "map" we use is made of smooth, flat tiles (called a basis set). The problem is that the actual terrain has sharp, jagged peaks and sudden drops (called cusps) where electrons crash into each other or into the nucleus. To draw these sharp points accurately using smooth tiles, you need millions of tiny tiles. This makes the calculation incredibly slow and expensive, like trying to build a massive Lego castle just to draw a single mountain peak.

The Old Solution (Transcorrelated Method):
Chemists have long used a trick called the Transcorrelated (TC) method. Instead of trying to draw the jagged terrain with more tiles, they change the rules of the map itself. They apply a mathematical "filter" (the Jastrow factor) that smooths out the jagged peaks. Now, the terrain looks like gentle rolling hills. You can draw this smooth landscape with far fewer tiles (a smaller basis set), saving a lot of time and effort.

The Catch:
There's a problem with this filter. While it makes the map easier to draw, it turns the map into a "non-standard" format. It's like taking a standard road map and turning it into a puzzle where the pieces don't fit together in the usual way (the Hamiltonian becomes non-Hermitian). Most of the standard tools we use to read these maps (quantum algorithms) break when they encounter this puzzle format. They simply can't solve it.

The New Tool: The "Universal Translator" (QEVE)

Recently, scientists developed a new tool called QEVE (Quantum Eigenvalue Estimation). Think of QEVE as a Universal Translator. It can take that weird, non-standard puzzle map and translate it into a language the quantum computer understands, allowing us to find the energy of the system.

However, being a Universal Translator is hard work. It requires more steps and more processing power than just reading a standard map. The big question this paper asks is: "Is the extra effort of using the Universal Translator worth it, given that we can use a much smaller map?"

The Experiment: A Race Between Two Strategies

The authors set up a race between two strategies to find the energy of atoms (like Lithium, Carbon, Oxygen, etc.):

1. Team Standard (Qubitization): They use the old, jagged map but with a huge number of tiles (a large basis set like cc-pVQZ). They use the standard, fast reading tool.

   • Pros: The tool is fast and simple.
   • Cons: The map is huge, requiring a massive amount of memory (qubits) and time.

2. Team Smooth (QEVE + TC): They use the smooth, filtered map with very few tiles (a tiny basis set like STO-6G). They use the new, complex Universal Translator (QEVE).

   • Pros: The map is tiny, saving massive amounts of memory.
   • Cons: The translator is slow and complicated.

The Results: Who Won?

The results were a mix of "Great News" and "It Depends."

1. The Memory Winner (Qubits):
Team Smooth won hands down. Because they used a tiny map, they needed significantly fewer qubits (the quantum equivalent of computer memory). This is crucial because current quantum computers are very limited in how much memory they have.

2. The Speed Winner (Gate Count):
This is where it gets tricky. The "Universal Translator" (QEVE) is so complex that it adds a lot of overhead.

• For small atoms (Lithium, Beryllium): The smooth map was so much better that it outweighed the translator's slowness. Team Smooth was faster overall.
• For larger atoms (Oxygen, Fluorine, Neon): The smooth map wasn't quite perfect enough. The errors in the small map started to add up. To fix this, the translator had to work even harder. In these cases, Team Standard (using the huge map) actually ended up being faster or about the same speed.

3. The "Magic" Shortcut (xTC):
The authors also tested a "lite" version of the smooth map called xTC. This is like taking the smooth map and removing a few unnecessary details.

• Result: This made the translator much faster. With xTC, the cost dropped to a level comparable to using a medium-sized map with the standard tool. It's a sweet spot that saves memory without slowing things down too much.

The Bottom Line

This paper is like a guide for a traveler deciding between two routes:

• Route A: A long, straight highway (Standard Method) that requires a huge truck (lots of memory).
• Route B: A short, winding mountain path (Transcorrelated Method) that requires a specialized off-road vehicle (QEVE).

The Verdict:
If you have a small truck (limited qubits), Route B is your only option, and for small towns (small atoms), it's actually faster. But for big cities (large atoms), the winding path gets too tricky, and you might be better off just taking the long highway with your big truck.

The authors conclude that while the new method (QEVE) is theoretically perfect, the "constant factor" (the extra effort to use the translator) is currently too high to always beat the old method. However, for the future of quantum computing, where memory is the biggest bottleneck, learning to drive on these winding mountain paths is essential.

Technical Summary

1. Problem Statement

The electronic structure problem aims to find the ground state energy of a molecular Hamiltonian. Standard quantum algorithms, such as Quantum Phase Estimation (QPE) based on qubitization, require the Hamiltonian to be Hermitian. However, the Transcorrelated (TC) method offers a way to accelerate basis set convergence by transforming the Hamiltonian to remove the electron-electron Coulomb cusp.

• The Challenge: The TC transformation renders the Hamiltonian non-Hermitian and non-normal. This makes standard qubitization algorithms inapplicable.
• The Trade-off: While TC methods allow for high accuracy with smaller basis sets (reducing the number of qubits and terms), the non-Hermitian nature requires more complex algorithms (like Quantum Eigenvalue Estimation, QEVE) which may introduce significant computational overhead.
• The Gap: While a QEVE algorithm for non-Hermitian operators with real spectra was recently proposed with optimal asymptotic scaling ($O(1/\epsilon)$), its constant factor overhead had not been analyzed. It was unclear if the accuracy gains from TC would outweigh the algorithmic cost compared to standard qubitization on larger basis sets.

2. Methodology

The authors performed a comparative resource analysis between two approaches for estimating ground state energies of second-row atoms (Li through Ne):

A. The Hamiltonian Models

1. Standard Hamiltonian: The electronic Hamiltonian projected onto standard Gaussian basis sets (cc-pVDZ, cc-pVTZ, cc-pVQZ). These are Hermitian.
2. Transcorrelated (TC) Hamiltonian: A similarity-transformed Hamiltonian ($\hat{H} = e^{-\hat{J}}\hat{H}_0 e^{\hat{J}}$) where $\hat{J}$ is a Jastrow factor optimized via Variational Monte Carlo (VMC).
   • This Hamiltonian is non-Hermitian and includes three-body terms.
   • The authors utilized the xTC approximation, which discards three-body terms via generalized normal ordering, significantly reducing the number of terms while maintaining accuracy.
   • Calculations were performed in the minimal STO-6G basis.

B. The Algorithms

1. Standard Qubitization: Applied to Hermitian Hamiltonians. The cost is dominated by the number of T-gates required for the quantum walk operator and the number of calls needed to achieve target accuracy $\epsilon$.
2. Quantum Eigenvalue Estimation (QEVE): Applied to the non-Hermitian TC Hamiltonians.
   • This algorithm encodes the spectrum using Chebyshev polynomials.
   • It requires inverting a denominator matrix $C$ using a Quantum Linear System Solver (QLSS) (specifically an adiabatic solver).
   • The complexity depends heavily on the Jordan condition number ($\kappa_S$) of the Hamiltonian, which measures the non-normality of the operator.

C. Resource Metrics

The authors calculated:

• T-gate counts: The primary metric for fault-tolerant runtime.
• Logical Qubit counts: Including registers for the system, ancilla for phase estimation, and LCU (Linear Combination of Unitaries) implementation.
• Accuracy: Compared against the Complete Basis Set (CBS) limit and standard basis set results.

3. Key Contributions

1. First Constant-Factor Analysis of QEVE: The paper provides the first detailed resource estimation for applying QEVE to transcorrelated electronic Hamiltonians, moving beyond asymptotic scaling analysis.
2. Quantification of the xTC Benefit: The study demonstrates that the xTC approximation drastically reduces the number of Hamiltonian terms ($K$) and the one-norm ($\alpha$), making the TC approach computationally viable.
3. Condition Number Characterization: The authors calculated the Jordan condition number ($\kappa_S$) for TC Hamiltonians, identifying it as a critical factor in the cost of the QLSS step within QEVE.
4. Basis Set Equivalence Mapping: The study maps the accuracy of TC methods in minimal bases to the accuracy of standard methods in larger bases, providing a "conversion rate" for quantum resources.

4. Key Results

A. Accuracy vs. Basis Set Size

• Small Atoms (Li, Be): The TC energy in the minimal STO-6G basis is more accurate than the standard Hermitian calculation in the cc-pVQZ (quadruple-zeta) basis.
• Medium Atoms (B, C, N): The TC accuracy lies between the cc-pVTZ and cc-pVQZ levels.
• Larger Atoms (O, F, Ne): The error increases, exceeding the cc-pVDZ level. This suggests the Jastrow factor optimization becomes more difficult for larger systems.

B. Resource Comparison (Gate Counts)

• TC (STO-6G) vs. Standard (cc-pVQZ):
  • The T-gate count for QEVE applied to the TC Hamiltonian (with xTC) is comparable to standard qubitization applied to the much larger cc-pVQZ basis.
  • Without the xTC approximation, the gate count for TC is significantly higher (closer to cc-pVQZ or worse).
• TC (STO-6G) vs. Standard (cc-pVTZ):
  • With the xTC approximation, the QEVE gate count is higher than standard qubitization in the cc-pVTZ basis but significantly lower than cc-pVQZ.
• Qubit Count:
  • The TC approach consistently requires fewer logical qubits than standard methods because the minimal STO-6G basis has far fewer spin-orbitals ($2M$) than cc-pVQZ.
  • Example: QEVE (TC) requires ~128 qubits, whereas standard qubitization (cc-pVQZ) requires ~318 qubits.

C. The Role of the Condition Number

• The Jordan condition number $\kappa_S$ was found to be relatively small for the systems studied, but it remains a significant source of overhead in the QLSS step.
• The xTC approximation significantly reduced $\kappa_S$ in most instances, further lowering the resource cost.

5. Significance and Conclusion

• Feasibility of Non-Hermitian Quantum Chemistry: The paper proves that despite the theoretical overhead of handling non-Hermitian operators, the TC method combined with QEVE is a competitive strategy for fault-tolerant quantum computing.
• Resource Efficiency: For small to medium systems, the TC workflow offers a "sweet spot": it achieves high accuracy (comparable to cc-pVQZ) while using a minimal basis set (STO-6G), resulting in a reduction in qubit count and a gate count comparable to high-quality standard bases.
• Limitations: The method is currently less advantageous for larger atoms (O, F, Ne) where the Jastrow factor optimization struggles, and the overhead of the QEVE algorithm (specifically the QLSS inversion) prevents it from beating standard qubitization in the cc-pVTZ regime.
• Future Outlook: The work highlights that improving the optimization of Jastrow factors and better understanding the condition number of projected non-Hermitian Hamiltonians are critical for unlocking the full potential of transcorrelated quantum chemistry.

In summary, the authors demonstrate that transcorrelated methods can reduce the qubit requirements for quantum chemistry simulations, and with the xTC approximation, the gate overhead of the necessary non-Hermitian algorithms is manageable, making this a promising path for high-accuracy electronic structure calculations on future fault-tolerant quantum computers.