Molecular Excited States using Quantum Subspace Methods: Accuracy, Resource Reduction, and Error-Mitigated Hardware Implementation of q-sc-EOM

This study demonstrates that the q-sc-EOM algorithm, enhanced by scaling-reduction techniques and error-mitigation strategies, can accurately compute excited-state potential energy surfaces on near-term quantum hardware, marking a significant step toward practical quantum utility in chemical simulations.

The Gist

Imagine you are trying to predict how a complex machine, like a car engine or a chemical reaction, behaves when you push it to its limits. In the world of chemistry, this is like trying to understand what happens when a molecule is stretched until its bonds break, or when it gets excited by light.

For decades, scientists have used powerful classical computers to simulate these scenarios. But there's a catch: when molecules get really "stressed" (like when bonds are breaking or electrons are highly correlated), classical computers hit a wall. They start making guesses that are too simple, leading to wrong answers. It's like trying to predict the weather during a hurricane using a simple barometer; the tools just aren't sophisticated enough for the chaos.

This paper is about using Quantum Computers to solve these messy, chaotic problems, specifically focusing on excited states (when a molecule has extra energy). Here is a simple breakdown of what the researchers did, using some everyday analogies.

1. The Problem: The "Broken Car" Scenario

Think of a molecule as a car.

• Normal driving (Ground State): The car is running smoothly. Classical computers (like a standard GPS) can predict the route perfectly.
• Breaking down (Excited State/Bond Breaking): The car is in a crash, parts are flying off, and the engine is sputtering. Classical computers get confused and give bad directions.
• The Quantum Solution: Quantum computers are like a super-smart mechanic who can see the chaos from a different dimension. They don't just guess; they simulate the actual physics of the crash to tell you exactly what happens.

2. The Toolkit: Building the Right Map

To get the quantum computer to do this, the researchers combined three specific tools (algorithms):

• ADAPT-VQE (The Adaptive Builder): Imagine you are building a Lego castle. Instead of using a pre-made box of bricks (which might not fit), this tool adds one brick at a time, only choosing the brick that makes the castle most stable. It builds the perfect "ground state" (the starting point) for the molecule.
• LUCJ (The Local Connector): Quantum computers are currently a bit fragile and noisy. This tool is like a "local neighborhood" rule. Instead of asking every Lego brick to talk to every other brick across the whole castle (which takes too long and causes errors), it only lets nearby bricks talk to each other. This makes the process faster and less prone to mistakes.
• q-sc-EOM (The Excited State Detective): Once the ground state is built, this tool acts like a detective. It asks, "If we poke this molecule, what happens?" It calculates the energy of the excited states without having to simulate the whole universe again.

3. The Bottleneck: The "Library" Problem

The researchers found a major problem: To get accurate answers, the quantum computer had to ask too many questions.

• The Analogy: Imagine you are trying to find a specific book in a library. The old method (Brute Force) required you to walk down every single aisle, check every single shelf, and read every single book title. If the library has 1,000 books, that's 1,000 trips. If it has 1,000,000 books, you'd need to walk 1,000,000 times. This is what they call O(N¹²) scaling—it gets impossible very fast.

The Fix: The "Smart Librarian"
The researchers introduced two tricks to speed this up:

1. The Davidson Algorithm: Instead of checking every book, this algorithm is like a smart librarian who knows exactly which section the book is in. It narrows down the search to just the relevant shelves. This cuts the walking time down significantly.
2. Basis Rotation Grouping: Imagine you have to measure the weight of 100 different fruits. Instead of weighing them one by one, you put them in groups based on their type (all apples together, all oranges together) and weigh the groups. This reduces the number of trips to the scale.

The Result: They reduced the "walking time" from 1,000,000 trips down to just 10,000. This makes the method scalable for larger molecules.

4. The Reality Check: Testing on Real Hardware

They didn't just run this on a perfect simulation; they tried it on a real quantum computer (IBM's hardware).

• The Noise Issue: Real quantum computers are like trying to hear a whisper in a rock concert. There is "noise" (static) from the hardware itself.
• The Findings:
  • Sampling Noise (The Static): They thought the main problem would be just not taking enough "samples" (like taking a blurry photo). They found that even with a lot of samples, the results were okay.
  • Gate Noise (The Broken Microphone): The real problem was the hardware itself making mistakes during the calculation (the "gates"). It's like the microphone is distorted.
  • Error Mitigation: They used "noise-canceling headphones" (techniques like symmetry projection) to clean up the signal. It helped, but the hardware is still a bit too "noisy" for perfect results right now.

5. The Big Picture: Why This Matters

The researchers tested this on molecules like Ammonia (NH3) and Water (H2O) when their bonds were breaking.

• Classical computers failed to predict the energy accurately once the bonds started stretching.
• The Quantum method (even with current noisy hardware) got much closer to the truth.

The Conclusion:
This paper is a roadmap. It says: "We have the right map (algorithms), and we know how to make the journey faster (resource reduction). The only thing holding us back is that the vehicle (the quantum computer) is a bit bumpy right now."

As quantum computers get better and less noisy, this method will allow us to design new drugs, better solar cells, and stronger materials by simulating chemical reactions that are currently impossible to predict. We are moving from "theoretical possibility" to "practical utility."

Technical Summary

1. Problem Statement

Accurately simulating molecular excited states, particularly in regimes involving strong electron correlation (e.g., bond breaking, conical intersections, and multi-reference systems), remains a significant challenge for classical computational chemistry.

• Classical Limitations: Standard methods like Coupled Cluster Singles and Doubles with perturbative Triples (CCSD(T)) and Equation of Motion-CCSD (EOM-CCSD) often fail when the ground state exhibits strong multi-reference character. While methods like CASPT2 and DMRG exist, they have limited scalability.
• Quantum Opportunity: Quantum computers offer a pathway to solve the exponentially scaling electronic structure problem. However, near-term quantum hardware is noisy (NISQ era), and existing algorithms for excited states often suffer from prohibitive measurement costs (shot scaling) and sensitivity to hardware noise.
• Specific Challenge: The paper addresses the need for a scalable, accurate, and hardware-feasible quantum algorithm for excited states that can outperform classical methods in difficult chemical scenarios while mitigating the massive resource overhead (specifically the $O(N^{12})$ measurement scaling) associated with current approaches.

2. Methodology

The authors propose a hybrid quantum-classical workflow combining three core components:

A. Ground State Preparation

To generate a high-quality reference state ($|\Psi_{VQE}\rangle$) required for excited state calculations, two variational ansätze were utilized:

1. ADAPT-VQE (Adaptive Derivative Assembled Pseudo Trotter): Dynamically builds the ansatz by iteratively adding operators with the highest energy gradient. This captures strong correlation effectively but traditionally requires high measurement counts.
2. LUCJ (Local Unitary Cluster Jastrow): A hardware-efficient ansatz that constrains entangling operations to local qubit connectivity, reducing circuit depth and SWAP overhead while maintaining chemical motivation.

B. Excited State Calculation: q-sc-EOM

The Quantum Self-Consistent Equation of Motion (q-sc-EOM) method is used to calculate excited states.

• It solves a generalized eigenvalue problem $MC = CE$, where $M$ is a matrix of excitation operators acting on the ground state.
• Unlike standard qEOM, q-sc-EOM ensures size-extensivity and correct orthogonality (satisfying the "killer condition"), making it theoretically rigorous and robust against measurement errors.

C. Resource Reduction Strategies

To overcome the $O(N^{12})$ measurement scaling of the brute-force q-sc-EOM implementation, two key strategies were integrated:

1. Davidson Algorithm: Adapted for quantum computing to iteratively expand a subspace of guess vectors toward the target eigenstates. This avoids calculating all matrix elements, reducing the scaling from $O(N^{12})$ to approximately $O(N^8)$.
2. Basis Rotation Grouping (BRG): Utilizes low-rank factorization of the two-electron tensor ($g_{pqrs}$) to map the Hamiltonian to a diagonal form in rotated orbital bases. This reduces the number of measurement groups significantly, further lowering the scaling to $O(N^5)$.

D. Error Mitigation

On hardware, the study employed a stack of mitigation techniques:

• Pauli Grouping: Compressing measurements by grouping commuting Pauli terms.
• M3 Readout Mitigation: Matrix-free measurement error correction based on local assignment calibrations.
• Symmetry Postselection: Filtering bitstrings to enforce particle number ($N_\alpha, N_\beta$) and spin ($S_z$) conservation.
• Adaptive Shot Allocation: Dynamically distributing shots based on the variance of matrix elements.

3. Key Contributions

1. Algorithmic Integration: Successfully combined ADAPT-VQE/LUCJ with q-sc-EOM to create a robust workflow for excited states in strongly correlated regimes.
2. Scalability Breakthrough: Demonstrated that combining the Davidson algorithm with Basis Rotation Grouping reduces the measurement shot scaling from $O(N^{12})$ to $O(N^5)$, making the method feasible for larger molecular systems.
3. Hardware Benchmarking: Provided one of the first detailed implementations of q-sc-EOM on real quantum hardware (IBM Pittsburgh) and simulators, rigorously analyzing error sources.
4. Error Source Identification: Identified that while readout errors can be mitigated, gate-level noise (coherent errors, crosstalk) is the predominant bottleneck limiting accuracy in current NISQ devices for excited state calculations.

4. Results

A. Accuracy vs. Classical Methods (Simulation)

• Systems Tested: Ammonia ($NH_3$) and Water ($H_2O$) undergoing simultaneous two-bond breaking.
• Performance: The quantum approach (ADAPT-VQE + q-sc-EOM) produced potential energy surfaces that closely matched Full Configuration Interaction (FCI) benchmarks.
• Comparison: In the bond-breaking regime where the ground state becomes multi-reference, classical EOM-CCSD failed to reproduce accurate excited states. The quantum method, by capturing the multi-reference character of the ground state via ADAPT-VQE, maintained high accuracy even in these challenging regimes.
• Noise Resilience: Even with statistical sampling noise (shot noise), the quantum algorithm outperformed EOM-CCSD in describing doubly excited states.

B. Resource Efficiency

• The combination of Davidson and BRG successfully reduced the effective shot count scaling to $O(N^5)$.
• Accuracy tests on linear hydrogen chains ($H_2$ to $H_{10}$) showed that BRG preserves energy accuracy (errors $< 10^{-6}$ Ha) while drastically reducing the number of measurement groups.

C. Hardware Implementation

• Setup: Experiments were run on IBM Pittsburgh hardware (and FakeTorino) using the LUCJ ansatz for the ground state.
• Accuracy: With error mitigation (M3 + Symmetry Postselection), excited state energies for $H_2O$ and $H_2$ reached accuracies within 50 mHa (milli-Hartree) of the exact values.
• Error Analysis:
  • Increasing shot counts did not significantly improve results beyond a certain point, indicating that gate errors, not sampling noise, are the limiting factor.
  • Techniques like Twirling and Zero Noise Extrapolation showed mixed or negligible results, whereas Symmetry Postselection provided the most consistent improvement.
  • The results highlighted that current hardware noise causes systematic biases that are amplified through the subspace diagonalization process.

5. Significance and Conclusion

This work establishes a clear path toward quantum utility in excited-state chemistry.

• Algorithmic Viability: It proves that quantum subspace methods are not just theoretically sound but are becoming algorithmically viable for chemically relevant problems, particularly where classical methods fail (multi-reference systems).
• Resource Optimization: The reduction of measurement scaling to $O(N^5)$ is a critical step toward applying these methods to larger, industrially relevant molecules.
• Hardware Reality Check: The study provides a realistic assessment of current hardware capabilities, identifying gate fidelity as the primary hurdle. It suggests that while current devices can provide qualitative insights and semi-quantitative results (within 50 mHa), achieving "chemical accuracy" (1 kcal/mol $\approx$ 1.6 mHa) for complex excited states will require substantial improvements in gate fidelities and more advanced error mitigation techniques tailored specifically for excited-state subspaces.

In summary, the paper demonstrates that by combining adaptive ground-state preparation, rigorous excited-state formalism (q-sc-EOM), and aggressive resource reduction strategies, quantum computers can begin to solve excited-state problems that are intractable for classical computers, provided hardware noise is sufficiently managed.