Compiling Catalyst Reaction Energies, Not Molecules: Correlated Trotter Error for Earth-Abundant Metal Centers

Platinum, iridium and rhodium dominate the catalysts that make hydrogen and fuel cells work. Replacing them with cheap metals such as molybdenum, nickel or cobalt is difficult partly because the active sites of those metals are "strongly correlated": several electrons interact in ways that standard simulation methods describe badly. Quantum computers are a candidate tool for these sites, but the chemistry question is never "what is the energy of this molecule." It is "how much energy does the reaction step cost," which is a difference between two closely related intermediates. Today's quantum compilers optimize each molecule's circuit separately. They choose how to group and order Hamiltonian terms so that each circuit is as short as possible. Nobody checks whether those choices make the errors of the two intermediates cancel or add up.

This note proposes difference-aware compilation. The two intermediates of a catalytic step are compiled jointly, using one shared grouping and ordering of terms over a shared orbital basis. The aim is that the discretization error of each simulation (Trotter error) becomes strongly correlated between them and largely cancels in the reaction energy. The central prediction is a specific tension with current practice. Kernpiler-style randomization of term order turns systematic error into noise, which helps a single simulation. In this setting it should hurt, because it destroys the correlation that makes cancellation possible. If the prediction holds, an energy difference at fixed accuracy should need shallower circuits than compiling each intermediate as well as possible on its own.

Core Claim

A Trotterized simulation does not run the true Hamiltonian $H$. It runs a slightly different effective Hamiltonian, $H_{\mathrm{eff}} = H + \delta t^{k} E_P + \dots$. Here $\delta t$ is the time step, $k$ is the order of the product formula, and $E_P$ is an error operator. $E_P$ depends on the compiler's choices $P$: which terms are grouped and exponentiated together, and in what order. To leading order, the energy error for a state $\psi$ is $\delta t^{k}\langle\psi|E_P|\psi\rangle$. For a reaction step from intermediate $A$ to intermediate $B$, the quantity that matters is

$$ \Delta\varepsilon(P_A,P_B) = \delta t^{k}\left(\langle\psi_B|E^{(B)}_{P_B}|\psi_B\rangle - \langle\psi_A|E^{(A)}_{P_A}|\psi_A\rangle\right), $$

where $E^{(A)}$ and $E^{(B)}$ are the error operators built from each intermediate's own Hamiltonian coefficients.

Current compilers choose $P_A$ and $P_B$ independently to minimize circuit cost at a per-state accuracy target. We claim three things. First, when the two intermediates share an aligned active-orbital basis, they share the same Pauli strings and differ only in coefficients. Second, a shared choice $P_A = P_B$, selected to minimize $|\Delta\varepsilon|$ under a gate budget, gives errors in the reaction energy far smaller than independent compilation at equal CNOT count. Third, randomizing the term order within a step works against this cancellation.

This framing comes from the compiler-sensitivity literature. That work established, for classical binaries, that semantically equivalent compiler outputs can differ sharply in downstream behavior. For example, Can Large Language Models Understand Intermediate Representations in Compilers? shows that instruction reordering alone degrades models' reasoning about program state. SK2Decompile shows that arithmetic substitution hides mathematical intent from neural decompilers. Here the "equivalent programs" are different groupings that implement the same ideal evolution $e^{-iHt}$. We ask how sensitive the downstream quantity, a reaction energy, is to that choice. We also ask whether the choice can be steered.

Relation to Prior Work

The method builds directly on Kernpiler. Kernpiler greedily partitions Hamiltonian terms into blocks of at most three qubits, so that commutator error inside a block vanishes. It also reorders and randomizes steps and synthesizes gates with tree search. It reports up to 10x depth reduction and roughly 3x fewer CNOTs than Qiskit's Rustiq. Kernpiler was evaluated on spin models, LiH, HF and protein fragments, and it compiles each Hamiltonian in isolation. We reuse its partitioning and synthesis machinery and change the objective: we compile a pair of Hamiltonians against the error in their difference.

The application comes from Feasibility of accelerating homogeneous catalyst discovery with fault-tolerant quantum computers. That paper estimates costs for molybdenum nitrogen-fixation catalysts. It reports 400,000 CPU-hours for a classical method called density matrix renormalization group (DMRG) and 139,000 QPU-hours for qubitized phase estimation on one pincer-complex step. Its LPBLISS symmetry shift halves Toffoli gate counts. That paper also motivates our focus: the economic value it identifies attaches to a reaction step, yet its resource estimates treat each state's energy separately.

The experimental catalyst papers set which chemistry matters. These include lanthanide-doped MoP, Ni-B and asymmetric Co-N-C. In each, activity hinges on a small shift in how strongly an intermediate such as adsorbed hydrogen binds. That shift is a difference quantity.

Classical surrogates constrain the case for this work rather than undercut it. On OC20 the best graph-network energy error is about 0.4 eV. On OC22 oxide errors are 0.374 eV in-domain and 0.829 eV out-of-domain. Catalyst GFlowNet shows the downstream symptom: a search for non-noble hydrogen catalysts returned Pt and Rh in over 77% of samples.

Coherent feedback control plays a narrow, methodological role, and we say so plainly. Coherent feedback means stabilizing a quantum system with another quantum system rather than by measuring it. Choosing a shared partition under a gate budget is a combinatorial, non-convex problem whose feasible region may be disconnected. Learning-Based Design of LQG Controllers in Quantum Coherent Feedback faced the same structure when designing coherent controllers under physical-realizability equalities. It solved it with differential evolution using four devices: bet-and-run initialization, constraints relaxed during early generations, a penalty that tightens on a schedule, and adaptive search ranges. With these it reached $J_\infty = 2.0064$ against a prior 4.0000 on a cavity benchmark. We borrow that search recipe, relaxing the gate budget early and tightening it on schedule. We do not claim coherent feedback stabilizes the simulator. Nothing in the file supports that for chemical Hamiltonians.

Research Program

The first step is to build matched Hamiltonian pairs. For each catalytic step, we compute both intermediates' electronic Hamiltonians in a single active space. Orbitals are aligned between geometries by maximum overlap, so that the Pauli-string sets coincide and only coefficients differ. Systems include reduced active spaces of the Mo pincer and Schrock nitrogen-fixation steps from the feasibility study, small Co-N-C cluster models for oxygen reduction, and Ni-H and Mo-H cluster models for hydrogen adsorption. All are kept small enough, up to roughly 24–28 qubits, that the exact Trotter unitary and its eigenphases can be computed classically. This lets us measure $\Delta\varepsilon$ exactly rather than estimate it.

The second step is the joint compiler. It searches over shared partitions and orderings. The objective is $|\Delta\varepsilon|$, estimated from the leading-order commutator expression with approximate states from a cheap correlated method, at a CNOT budget fixed by Kernpiler-style synthesis. The search uses the scheduled-penalty differential evolution described above, with Kernpiler's greedy partition as a seed.

The third step is to explain the cancellation, not just measure it. We will separate how much of the gain comes from shared Pauli structure, how much from the two states having similar wavefunctions, and how much is lost to randomization. We will also check whether the gain survives when the intermediates differ in spin state. Spin changes are common in Mo and Co chemistry, and there we expect cancellation to weaken.

Baselines

The naive reference uses standard Qiskit product-formula compilation (PauliEvolutionGate or Rustiq) applied separately to each intermediate. The step size is chosen so that each energy meets the accuracy target alone. This is the default a practitioner would run. Kernpiler reports it to be about 3x worse in CNOTs and up to 10x worse in depth than Kernpiler.

The strongest competitor is Kernpiler applied independently to each intermediate, with its reordering and randomization enabled. This is the best published per-Hamiltonian compiler for this kind of simulation, with average reductions of 34% in CNOTs and 32% in depth over BQSkit synthesis. It receives the same Hamiltonians, the same synthesis backend and the same number of search evaluations as our method. We also apply LPBLISS-style 1-norm shifting to both methods' inputs, so that neither method benefits from it alone.

No reported result was found on Lacuna for Trotter error in reaction-energy differences for any compiler. The comparison point is therefore our own rerun. Our method beats this baseline if it reaches the same $|\Delta\varepsilon|$ with at least about 2x fewer CNOTs, or a lower $|\Delta\varepsilon|$ at equal CNOTs, consistently across most catalytic steps.

Three ablations isolate the key ingredient. The first uses a shared partition chosen by Kernpiler's greedy rule rather than by the difference objective. It tests whether sharing alone is enough. The second uses our shared partition with term-order randomization switched back on. It tests the predicted randomization penalty. The third uses unaligned orbitals between intermediates. It tests whether shared Pauli structure is the mechanism.

For the resource-level comparison, we take the double-factorized qubitized phase-estimation estimates from the feasibility study at its reported 139,000 QPU-hours as the incumbent.

Why not just…?

Why not just shrink the time step until each energy is accurate enough? This always works, but cost grows as the step shrinks. The question is whether cancellation buys the same reaction-energy accuracy more cheaply. The naive and Kernpiler baselines are exactly this alternative at their best. Beating them at equal CNOTs is the test.

Why not just use qubitized phase estimation, which has no Trotter error at all? This is a real threat. The method cost in the feasibility study scales with the Hamiltonian 1-norm and does not depend on term ordering, so our technique gives it nothing. Our contribution matters only if product formulas with correlated error are cheaper than qubitization for a target accuracy on the reaction energy. We will report gate counts for both at matched accuracy on the small active spaces. If qubitization wins everywhere, the honest conclusion is that difference-aware compilation is relevant only to early, non-fault-tolerant devices.

Why not just run DMRG or a better classical surrogate? For small active spaces DMRG is the right tool, and we use it to produce reference energies. The feasibility study's 400,000 CPU-hours per pincer step shows why it does not scale to screening. The OC20 and OC22 errors of 0.4–0.83 eV show that cheap surrogates cannot resolve the binding shifts that the experimental papers rely on. Neither point proves the quantum route wins. This proposal only claims to lower its cost.

Why not just reuse correlated sampling or reference-state subtraction after the fact? Subtracting a cheap reference energy computed with the same circuit could remove part of the shared error. We will include this subtraction applied to independently compiled circuits as an extra comparison. If it matches joint compilation, the compiler change is unnecessary.

Proposed Experiments

The decisive experiment is a curve of reaction-energy error against CNOT count for each matched pair. We use exact Trotter eigenphases and compare against exact diagonalization or converged DMRG. We plot the naive baseline, independent Kernpiler, the three ablations and the joint compiler, and judge each against the conventional chemical-accuracy threshold of about 1 kcal/mol.

The core claim is falsified under three conditions:

  • Shared, difference-optimized partitions do not beat independent Kernpiler on most steps.
  • Switching randomization back on does not measurably reduce cancellation.
  • The gains vanish once orbitals are aligned trivially.

A second experiment extends the leading-order estimator to larger, still classically checkable active spaces. There we test whether the estimator's predicted $\Delta\varepsilon$ ranks partitions correctly, so the method can be trusted where exact checks are impossible. Finally, we run gate-count extrapolations for the Mo pincer step alongside the qubitization estimate to settle the regime question honestly.