Hardware-Aware Orbital Choice for Molecular Simulation on Sparse Quantum Chips

To simulate a molecule on a quantum computer, you first pick a set of electron orbitals and assign each one to a qubit. That choice fixes which pairs of qubits must interact. On real chips, qubits can only talk to their physical neighbors, so a separate program called a compiler then inserts extra "SWAP" operations to shuttle quantum states around. These operations are slow and error-prone. Today the two steps are done by different communities that never look at each other. Chemists choose orbitals to get accurate energies with few qubits. Compilers receive the finished circuit as an anonymous list of gates and route it as well as they can.

This note proposes moving part of the routing problem upstream, into the orbital choice itself. When orbitals are localized on chemical bonds, the pattern of strong interactions between them roughly follows the molecule's own graph. In particular, it follows the "bond-angle" or line graph, in which bonds are nodes and bonds that share an atom are connected. We would embed that graph into the chip's coupling graph. We would then add a penalty to the orbital optimization that pushes interaction strength away from orbital pairs sitting far apart on the hardware. This trades a small, controlled loss in energy accuracy for a large cut in SWAP overhead. A compiler cannot make that trade, because the circuit it receives is already fixed.

Core Claim

The claim has two parts. First, for bond-localized orbitals, a molecule's qubit interaction graph is well approximated by its bond-angle graph plus weaker interactions that decay with distance. This is the dual graph that Geometry-enhanced molecular representation learning for property prediction introduced for property prediction (GEM couples an atom-bond graph with a bond-angle graph during message passing). Here we reuse it as a structural map of where a quantum circuit's gates will fall. Second, a topology-penalized version of the orbital rotation in Qubit Count Reduction by Orthogonally-Constrained Orbital Optimization for Variational Quantum Excited States Solvers produces circuits that need substantially fewer post-routing two-qubit gates at the same energy error than any pipeline that fixes the orbitals first and compiles afterwards.

That paper compresses large basis sets into few qubits, for example reaching cc-pVTZ-level accuracy for H₂ with 14 qubits instead of 56. However, its optimization works purely in the abstract space of quantum states and ignores the chip. The new element is to put the chip into that optimization, with the molecular graph supplying both the initial orbital-to-qubit placement and the target structure.

Written out, we jointly choose an orbital rotation $U$ (a partial unitary from $M$ basis functions to $N$ active orbitals) and a placement $\pi$ of orbitals onto physical qubits by minimizing

$$ \mathcal{L}(U,\pi) = E(U) + \lambda \sum_{p<q} w_{pq}(U)\, c_\pi(p,q). $$

Here $E(U)$ is the active-space energy, computed classically by exact diagonalization at the sizes we study. The weight $w_{pq}(U)$ is the summed magnitude of the one- and two-electron Hamiltonian coefficients coupling orbitals $p$ and $q$ in the rotated basis. The term $c_\pi(p,q)$ is a routing cost model: the extra two-qubit gates a term between $p$ and $q$ incurs under placement $\pi$. This combines the hardware distance and the length of the qubit string that the standard Jordan–Wigner encoding (the usual rule for turning electron operators into qubit operators) attaches to the term. We calibrate $c_\pi$ against actual compiler output. Finally, $\lambda$ sets the accuracy–routing trade-off, and sweeping it traces a Pareto curve.

Research Program

The work has three pieces. The first is an empirical test of the structural claim. For molecules from H₂, LiH and BeH₂ up through hydrogen chains and small hydrocarbons, we localize orbitals and measure what fraction of Hamiltonian weight lies on edges of the bond-angle graph versus off it. If that fraction is low, the molecular graph is a poor prior and the placement component should be dropped. The penalty would then stand alone.

The second piece is the placement. We embed the bond-angle graph into the target coupling graph: heavy-hex for IBM Eagle and Rochester, 2D grids for Sycamore and Willow. Low-dilation embeddings are found by search over subgraphs of the hardware. The Jordan–Wigner ordering is chosen as a path through the embedded region, so that both coupling distance and string length are kept short. This step plays the role that topology-aware initial embedding plays in A High-Performance Multilevel Framework for Quantum Layout Synthesis. That method detects line and star subgraphs in the circuit's interaction graph. Our placement instead reads the expected structure off the molecule before any circuit exists.

The third piece is the penalized orbital optimization. It extends the gradient-projection scheme of the orbital-compression paper by adding the penalty term, and it alternates gradient steps on $U$ with local swaps on $\pi$. The output circuits are handed unmodified to the strongest available compilers. Any gain we report is therefore gain those compilers could not reach on their own.

The prior work plays three distinct roles here. The QUBIKOS study, Assessing Quantum Layout Synthesis Tools via Known Optimal-SWAP Cost Benchmarks, motivates the work. It shows that compilers leave very large optimality gaps on sparse chips: LightSABRE inserts 233.97x the optimal SWAP count on the 127-qubit Eagle, against 1.95x on Sycamore. Reshaping the input is therefore a plausible lever exactly where compilers fail. The exact solvers, Qubit Mapping and Routing via MaxSAT and Optimal Qubit Assignment and Routing via Integer Programming, constrain the work: they do not scale past a few dozen qubits, so we use them only to check small instances. Optimized Qubit Routing for Commuting Gates via Integer Programming supplies an optional downstream method. It reports up to 10x fewer SWAPs on commuting layers, and could route the diagonal density-density part of our Hamiltonians once they are local. Finally, Qubit Routing Using Graph Neural Network Aided Monte Carlo Tree Search learns only on the hardware graph and needed nearly four hours for a 5,960-gate circuit. We deliberately avoid a learned router, because the claim concerns what the input circuit looks like, not how it is searched.

Baselines

The naive reference point is the standard chemistry pipeline. Canonical (delocalized) orbitals are taken in a fixed basis, encoded in Jordan–Wigner order, and compiled with SABRE at default settings. Every method is reported relative to it.

The strongest compiler baseline is ML-SABRE from A High-Performance Multilevel Framework for Quantum Layout Synthesis. It is the strongest because it already discovers interaction-graph clusters and topology motifs automatically, which is exactly the structure our molecular prior claims to provide. Its paper reports, on IBM Eagle relative to SABRE, a 65% reduction in SWAP count and a 17% reduction in depth on QASMBench circuits. We also run LightSABRE and ML-QLS from ML-QLS: Multilevel Quantum Layout Synthesis, which reports 39% fewer SWAPs than QMAP on Eagle.

There is no reported result on Lacuna for any of these compilers on molecular-Hamiltonian circuits. We will therefore establish those numbers ourselves, on the same circuits. Each compiler receives the same random-restart budget and wall-clock limit as our pipeline's combined orbital optimization plus compilation time. The strongest chemistry-side baseline is the unpenalized orbital optimization of Qubit Count Reduction by Orthogonally-Constrained Orbital Optimization for Variational Quantum Excited States Solvers, with its reported energy results on H₂ and square H₄ used as accuracy anchors.

Two ablations isolate the key ingredients. The first keeps the bond-angle-graph placement but sets $\lambda=0$, which tests whether the molecular prior alone helps. The second keeps the penalty but uses the compiler's own initial placement, which tests whether the molecular graph adds anything beyond the penalty. Beating the baselines means one specific thing. At matched energy error versus exact diagonalization in the same active space, our pipeline must produce at least 30% fewer post-routing two-qubit gates on heavy-hex chips than the best combination of localized orbitals, magnitude truncation and ML-SABRE, consistently across molecules.

Why not just…?

Why not just localize the orbitals and let ML-SABRE do the rest? This is the real threat. Localized orbitals already make the interaction graph mirror the molecule, and multilevel clustering is designed to find exactly such structure. We expect this baseline to capture most of the benefit of our placement step. That is why the placement-only ablation exists. If placement alone matches it, we will report that the molecular graph is redundant as a placement prior. The proposal's claim would then rest on the penalty, which changes the circuit and is therefore outside any compiler's reach.

Why not just drop small Hamiltonian terms before compiling? Magnitude truncation also removes long-range gates at some cost in accuracy. If our penalty merely rediscovered truncation, it would be pointless. The difference is that the penalty rotates the orbitals so that weight moves onto hardware-adjacent pairs, rather than simply discarding it. The decisive comparison is the two Pareto curves of energy error against two-qubit gate count. If the curves coincide, the idea fails.

Why not just shrink the qubit count, as orbital compression already does? Fewer qubits do not imply local interactions. The compressed H₂ and H₄ circuits in the orbital-compression paper are still dense in the rotated basis. Our unpenalized-optimization baseline measures how much routing overhead remains after compression alone.

Why not just use a fixed qubit-shuffling schedule for electron operators, designed for linear or grid connectivity? Schedules of this kind give predictable costs on regular grids. They may well be competitive on Sycamore and Willow, where ML-SABRE's own paper finds little room for improvement over SABRE. We expect our gains to concentrate on sparse heavy-hex chips, and we will report grid results separately so that a null result there is visible.

Proposed Experiments

The molecules are H₂, H₄, LiH and BeH₂ in the settings used by the orbital-compression paper, extended to linear hydrogen chains and small hydrocarbons. Energies are computed exactly up to about 20 active orbitals; compilation is run for larger active spaces. Targets are IBM Eagle, IBM Rochester, Google Sycamore and Google Willow. For one ansatz family (we use a fixed number of Trotter-style layers of the Hamiltonian), we report three quantities: post-routing two-qubit gate count, depth, and a fidelity estimate under a per-gate error model.

To check that our cost model $c_\pi$ is not fooling us, we validate it against actual compiler output on QUBIKOS-style instances with known optimal SWAP counts. On instances under 16 qubits, we also compare against an exact solver to see how much of the remaining overhead is compiler suboptimality versus genuine non-locality.

The decisive check is the Pareto comparison on Eagle. Our pipeline wins if, at chemical accuracy relative to the same-active-space exact energy, its two-qubit gate count lies clearly below that of every alternative pipeline. Those alternatives are localized orbitals with ML-SABRE, truncation with ML-SABRE, and unpenalized orbital compression with ML-SABRE. The gap must hold across at least three molecules. A secondary check uses the bond-angle-graph weight fraction. If gains track that fraction across molecules, the molecular graph is doing real work. If gains are flat, the benefit comes from the penalty alone, and the note's first claim is wrong.