⚛️ quantum physics

HamQASBench: A Hamiltonian-Informed Diagnostic Benchmark for Evaluating Quantum Architecture Search

This paper introduces HamQASBench, a Hamiltonian-informed diagnostic benchmark that evaluates Quantum Architecture Search methods by categorizing molecular instances into structural tiers based on Hamiltonian properties and employing multi-dimensional metrics to reveal failure modes—such as over-parameterization and representation bottlenecks—that are invisible to conventional energy-based assessments.

Original authors: Jiayang Niu, Akib Karim, Yan Wang, Jie Li, Ke Deng, Azadeh Alavi, Muhammad Usman, Yongli Ren

Published 2026-07-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jiayang Niu, Akib Karim, Yan Wang, Jie Li, Ke Deng, Azadeh Alavi, Muhammad Usman, Yongli Ren

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a custom key to open a specific, very complex lock (a molecule). In the world of quantum computing, this "key" is a Quantum Circuit, and the process of designing it automatically is called Quantum Architecture Search (QAS).

For a long time, scientists have been trying to build better "key-making machines" (algorithms) that can design these circuits automatically. However, the way they tested these machines was flawed. They would just ask: "Did your key open the lock?" If the answer was "yes," they assumed the machine was smart.

The Problem: The "Fake Key" Trap
The authors of this paper argue that just because a key opens the lock, it doesn't mean it's the right key.

The Analogy: Imagine a lock that can be opened by a tiny, simple key, but also by a massive, heavy, over-engineered key made of 100 pounds of steel. If your machine builds the 100-pound steel key, it still opens the lock (the energy is correct), but it's a terrible design. It's heavy, inefficient, and might break the lock later.
The Flaw: Existing tests only measured if the lock opened (Energy Accuracy). They didn't check if the key was the right shape or if it was unnecessarily heavy. This meant machines could "cheat" by building bloated, inefficient circuits that happened to work by luck, rather than understanding the lock's true structure.

The Solution: HAMQASBENCH
The authors introduce a new testing ground called HAMQASBENCH. Instead of just checking if the lock opens, this new test looks at the blueprint of the lock itself (the Hamiltonian structure).

Think of it like a mechanic who doesn't just check if the car starts, but also looks at the engine's internal gears to see if the mechanic built the right number of gears for that specific engine.

How the New Test Works (The 5 Levels)
The benchmark organizes 11 different molecules into 5 "difficulty tiers," each testing a different aspect of the lock's blueprint:

The "Simple Lock" Tier (Minimalism): Some locks are so simple they only need a tiny key. The test checks if the machine builds a tiny key or if it wastes time building a giant, unnecessary one.
- Result: Some machines built tiny keys; others built massive, redundant keys that still worked but were inefficient.
The "Double-Identity" Tier (Degeneracy): Some locks have two different keys that fit perfectly. The test checks if the machine picks one key and sticks with it, or if it gets confused and keeps switching between the two.
- Result: Some machines got "stuck" on one version of the key, failing to realize there were other valid options, or they couldn't decide which one to use.
The "Tangled Lock" Tier (Representation): Some locks are incredibly complex, with gears that are all tangled together. The test checks if the machine can build a key complex enough to untangle them.
- Result: Machines could handle small tangles, but when the tangle got big, they failed to build a key that actually represented the complexity, even if the energy numbers looked okay.
The "Blocked Hallway" Tier (Topology): Imagine a lock where the gears are arranged in a straight line, and you can't reach the far end without walking past the middle. The test checks if the machine can route the key's movements through the hallway correctly.
- Result: Machines struggled to move information from one end of the line to the other when the path was restricted.
The "Growing Lock" Tier (Scalability): The authors took the same lock and just made it bigger and bigger (adding more parts). They wanted to see if the machine could handle the size increase.
- Result: The machines worked fine for small sizes, but as the lock grew, the search space became too huge for the machines to find the right key, even though the lock's internal complexity didn't actually change.

The New "X-Ray" Tool
To fix the "Fake Key" problem, the authors created a Post-Hoc Critical-Structure Extraction.

The Analogy: After a machine builds a key, this tool acts like a sculptor. It takes the finished key and starts chipping away pieces that aren't strictly necessary. If the key still opens the lock after you chip away 90% of the metal, it proves the machine built a bloated, inefficient key.
The Insight: This tool revealed that many machines were building keys that were 90% "dead weight" (redundant gates) just to get the job done.

The Big Takeaway
The paper concludes that measuring only the final result (energy) is not enough.

A machine can be "wrong" but still get the right answer by accident (over-parameterization).
A machine can get the right energy but build a key that fails to capture the true "shape" of the problem (entanglement mismatch).
A machine can get stuck on a specific version of a solution when multiple exist (eigenstate commitment).

HAMQASBENCH forces these machines to prove they understand the structure of the problem, not just that they can guess the right number. It's the difference between a student who memorizes the answer key versus a student who actually understands the math.

Technical Summary of HAMQASBench: A Hamiltonian-Informed Diagnostic Benchmark for Evaluating Quantum Architecture Search

Problem Statement
Quantum Architecture Search (QAS) aims to automate the design of parameterized quantum circuits (PQCs) for variational quantum algorithms, particularly the Variational Quantum Eigensolver (VQE) used in quantum chemistry. While existing benchmarks organize molecular instances by identity or qubit count and evaluate methods solely on energy accuracy, these criteria are agnostic to the underlying Hamiltonian structure. Consequently, conventional metrics fail to detect structural failures, such as over-parameterization on near-product ground states, commitment to orthogonal eigenstates in degenerate systems, or the inability to encode correct entanglement structures. This limitation obscures whether a method has learned the appropriate circuit topology or merely found a low-lying excited state with similar energy.

Methodology
The authors introduce HAMQASBENCH, a diagnostic benchmark that organizes evaluation around Hamiltonian structural fingerprints rather than molecular identity. The benchmark comprises 11 molecules categorized into five structural tiers based on three complementary perspectives of the qubit Hamiltonian:

Pauli Operator Basis: Measures proximity to diagonal forms ( $r_Z$ ) and the weight of multi-qubit interactions ( $r_{\ge 2}$ ).
Computational Basis Representation: Quantifies diagonal dominance ( $G_1, G_2$ ) using Gershgorin circle theorem principles.
Ground-State Correlation Structure: Characterizes spectral separation (energy gap), degeneracy levels, and single-qubit von Neumann entropy ( $S(q)$ ) to map entanglement distribution.

The five diagnostic tiers are:

Tier 1 (Minimalism): Strongly diagonal-dominant Hamiltonians with near-zero entanglement (e.g., BeH $_2$ , LiH) to test for unnecessary gate insertion.
Tier 2 (Degeneracy): Molecules with degenerate ground states (e.g., CH $_2$ ) to evaluate convergence to consistent structures versus drift across orthogonal eigenstates.
Tier 3 (Representation): Strongly correlated systems with high entanglement (e.g., H $_2$ stretch, H $_2$ O, H $_4$ chain) to test faithful encoding of complex states.
Tier 4 (Topology): Systems with hardware connectivity constraints (nearest-neighbor only) to assess routing capabilities independent of correlation complexity.
Tier 5 (Scalability): A same-family ladder (BeH $_2$ ) increasing from 8 to 14 qubits with controlled entanglement to isolate search space growth as a bottleneck.

To move beyond energy-only evaluation, the paper proposes a post-hoc critical-structure extraction procedure. This algorithm iteratively prunes redundant gates from low-error training-stage circuits using counterfactual importance scoring and a beam search strategy constrained by energy tolerance. The resulting minimal circuits are analyzed via:

Mean Absolute Entropy Score (MAES): Comparing per-qubit von Neumann entropy of the pruned circuit against the exact ground state for non-degenerate cases.
Pairwise State Fidelity: Clustering circuits by fidelity to identify eigenstate commitment patterns in degenerate cases.

The benchmark evaluates five representative QAS methods across four paradigms: Reinforcement Learning (CRLQAS, HYRLQAS), Differentiable Relaxation (QuantumDARTS), Training-Free Filtering (TFQAS), and Generative Modeling (GQEQAS). All methods are standardized to a unified gate basis $\{RX, RY, RZ, CNOT\}$ .

Key Results
Benchmarking across the five tiers reveals failure modes invisible to conventional energy metrics:

Minimalism (Tier 1): While most methods achieve chemical accuracy, they exhibit significant structural redundancy. For instance, QuantumDARTS circuits showed up to 93.8% redundancy compared to the minimal 2-gate structure, a discrepancy invisible to energy metrics.
Degeneracy (Tier 2): Methods like CRLQAS achieved chemical accuracy but demonstrated "eigenstate commitment," where different random seeds converged to structurally distinct circuits targeting orthogonal eigenstates of the degenerate ground state. Energy metrics alone masked this structural inconsistency.
Representation (Tier 3): In strongly correlated systems, energy convergence did not guarantee correct entanglement structure. For H $_2$ O, pruned circuits captured dominant entanglement but missed weaker correlations, indicating structural failure preceding energy failure.
Topology (Tier 4): Enforcing linear connectivity caused a performance drop of over an order of magnitude. Analysis showed that while circuits could find lower-energy solutions by concentrating gates on interior qubits, they systematically failed to represent boundary correlations required by the Hamiltonian.
Scalability (Tier 5): Performance degraded sharply at 12 and 14 qubits. Crucially, this failure was not due to increasing entanglement complexity (which remained low), but rather to search policy instability and optimizer failure in high-dimensional parameter spaces ( $2^{14}$ dimensions).

Significance and Claims
The authors claim that HAMQASBENCH provides a principled foundation for diagnosing QAS methods by grounding evaluation in Hamiltonian structural properties. The primary contribution is the demonstration that energy accuracy is an unreliable proxy for structural correctness. A method can achieve chemical accuracy via over-parameterized circuits, commit to orthogonal eigenstates, or encode incorrect entanglement structures while minimizing energy. By introducing a structural evaluation layer orthogonal to energy metrics, HAMQASBENCH enables the identification of specific failure modes—such as over-parameterization, eigenstate commitment, and topology-induced routing failures—thereby guiding the development of more robust and structurally aware QAS algorithms. The paper emphasizes that these insights are derived from the diagnostic capabilities of the benchmark itself, rather than proposing new applications or future theoretical implications beyond the scope of the presented evaluation.

Technical Summary of HAMQASBench: A Hamiltonian-Informed Diagnostic Benchmark for Evaluating Quantum Architecture Search

More like this