The Memory Has to Survive the Protection: A Hydrogen Molecule, Error-Corrected

I picked this week's paper for a personal reason. When I first wrote about Quantinuum, I came away impressed: a beautiful machine, error correction further along than almost anyone's. So when the same team published a paper that ran real error correction through a real chemistry calculation, I wanted to see the moat up close. What I found instead was a bottleneck, and it was not where I expected. Not the gates. The memory. The paper is a Quantinuum result in PRX Quantum: the first demonstration of an end-to-end pipeline with quantum error correction for computing molecular electronic structure.¹ The molecule is molecular hydrogen, H₂, the simplest molecule there is; the machine is Quantinuum's trapped-ion computer, H2-2.² The headline number is genuinely good, the ground-state energy landing within statistical distance of the exact answer, but the central value is close while the uncertainty is still far too large for chemical precision. It is my own opinion, written to learn in public, and it is not a valuation and not financial advice. Do your own research.

Why point a quantum computer at a molecule at all

Start with the problem, because it is the reason quantum computers are interesting for chemistry at all. The ground-state energy of a molecule is the lowest energy its electrons can settle into, and it is one of the quantities a chemist most wants to know: differences in ground-state energy between configurations tell you which structures are stable and how much energy a reaction takes in or gives out. Computing it accurately, for molecules whose electrons are strongly correlated, is exactly the kind of task classical methods struggle with as the system grows.

The trouble is correlation. Each electron's behavior depends on where all the others are, so you cannot treat them one at a time. The number of distinct configurations the electrons can occupy grows exponentially with the size of the molecule, and solving the electronic problem exactly across the full space of configurations available in the chosen basis, what chemists call full configuration interaction (FCI), becomes impossibly expensive very fast. That is why the exact reference energy $E_{\mathrm{FCI}}$ carries that label, and why energies here are quoted in hartree, the atomic unit of energy this field works in. A quantum computer does not sidestep this by magically holding every configuration at once. What it can do is let a quantum state evolve naturally inside that huge space, following the same physics the molecule itself would, and then extract a single number, an energy, from that evolution without listing every amplitude by hand. The tool that pulls the number out is quantum phase estimation.³

To make the problem fit today's hardware, the authors shrink it hard. They reduce hydrogen to a single-qubit problem, a Hamiltonian (the mathematical object that encodes a system's energy) of the form

$$H = h_1 Z + h_2 X + h_3 I,$$

where $Z$, $X$ and $I$ are standard single-qubit operators and the coefficients $h_i$ are numbers fixed in advance by ordinary classical chemistry software. This is a toy, and the authors say so plainly. The point is not the molecule. The point is to run the whole machine, end to end, on a problem whose exact answer we already know.

Energy hidden in a phase

So how does a quantum computer turn an evolving quantum state into an energy? Through a phase. If you take an energy eigenstate $\lvert E \rangle$, a state of a single definite energy $E$, and let it evolve for a time $t$ under $U = e^{-iHt}$, nothing about it changes except that it picks up a phase,

$$U\,\lvert E \rangle = e^{i\varphi}\,\lvert E \rangle , \qquad E = -\varphi/t .$$

The phase $\varphi$ is fixed by the energy and the elapsed time (here in the paper's sign convention, so that $E = -\varphi/t$), so reading the phase and dividing by the time would give the energy. The catch is that a phase is invisible on its own. Quantum phase estimation (QPE) is the trick that makes it measurable, by interfering the state's phase against a separate probe qubit so that it shows up in the odds of how the probe reads out.

Hand-drawn blue-pen flow, left to right: an H2 molecule; an evolution box reading apply U to the k with U equals e to the minus i H t; a single probe qubit spilling a row of one-bit outcomes, one bit per run; and a classical computer producing a bell curve whose single red peak is the inferred phase, leading to the energy. — Figure 1: How a quantum computer reads an energy. A molecule's energy is hidden in the phase its state accumulates as it evolves; QPE reads that phase out through a probe qubit, one bit per run, and a classical computer combines many such bits into the inferred phase (red), and from it the energy.

The lighter algorithm, and what it reveals

This paper uses the lighter, single-probe version of QPE⁴ rather than the textbook version, which spreads the phase across a whole register of readout qubits and decodes it with an inverse quantum Fourier transform.⁵ In the lighter route, each run gives just one phase-dependent bit at chosen settings, and a classical computer afterward combines thousands of such bits to infer the most likely phase. I walk through that mechanism, and its subtleties such as how a trial state can produce several peaks, more fully in my note on quantum phase estimation. The important point here is the trade: the authors shrink the coherent quantum circuit, the part that must survive as one unbroken computation, and pay for it with many repetitions and classical post-processing. And even shrunk, that circuit is still long enough for another problem to appear.

When protection costs more than it saves

To run a circuit that long, you need error correction. The authors encode each logical qubit, the protected unit of information, in a $[[7,1,3]]$ color code: seven physical qubits sharing one logical qubit, at a code distance of 3, which corrects any single physical-qubit error. Errors are caught by measuring the code's stabilizers, without reading out and destroying the stored information itself.⁶

But there is a gap between "corrects one qubit error" and "safe," and that gap is why fault tolerance is a separate idea from error correction. Fixing a single error on a logical qubit that is just sitting in memory is one thing. The danger is what happens during the operations themselves. A single fault in the middle of a gate can spread: pass one error through a two-qubit gate and it can become two, and two errors can form a weight-2 pattern the code is not guaranteed to correct. So the two ideas do different jobs: quantum error correction detects and corrects errors in the encoded information, while fault tolerance controls how faults spread while operations are being performed, keeping one fault from becoming an uncorrectable mess before the next round of correction. The paper needs both, and the tension between them runs through the whole design.

The natural instinct is to make every operation fault-tolerant. A fault-tolerant (FT) component is built so that no single physical fault can produce a logical error; you need at least two faults to slip through. If $p$ is the physical error rate, a strictly FT component fails at a rate that scales as $A p^2$, while a lighter, non-FT component can fail from a single fault and so scales as $B p$. As $p$ shrinks, $p^2$ should win handily.

Except it does not always. Fault tolerance is bought with extra gates, measurements, and helper qubits, and all of that overhead inflates the prefactor $A$. When $p$ is not small enough and the FT machinery is heavy enough, you land in the regime where $A p^2 > B p$: the protection costs more than the error it prevents. It is insurance whose premium exceeds the loss.

Hand-drawn blue-pen graph of logical error rate against physical error rate p. A straight line labeled B p and an upward parabola labeled A p squared rise from the origin and cross at a single red dot. Left of the crossing, at small p, is labeled FT wins; the region right of the crossing is labeled overhead can dominate. — Figure 2: When protection costs more than it saves. A fault-tolerant component fails at a rate growing as *A p²*, a lighter one as *B p*. For very small physical error the fault-tolerant curve wins, but its heavy overhead inflates A, so when that overhead is heavy enough (red region) the less heavily protected component can actually be safer. The plot illustrates the argument rather than locating any specific machine on it.

It is insurance whose premium exceeds the loss.

So the authors settle for partial fault tolerance: relax strict fault tolerance exactly where it is most expensive, and add lighter checks in its place.⁷ One particularly expensive ingredient is the arbitrary-angle rotation, because its fully fault-tolerant form requires magic state distillation, an elaborate process for refining the special resource states that such rotations consume, together with the gate synthesis needed to build an arbitrary angle out of a fixed set of protected gates. Rather than pay that, the authors implement the rotation a lighter way and lean on a technique called recursive gate teleportation (RGT).⁸

RGT is worth slowing down on, because it involves two different kinds of retry that are easy to run together in one's head. A helper qubit is prepared carrying the desired rotation, and then that rotation is teleported onto the working qubit. The teleportation has two possible branches: sometimes it applies the intended angle, and sometimes, as an ordinary consequence of the measurement it uses, it applies the opposite angle. The second branch is not an error; it is an expected outcome, and it is corrected by conditionally following with another teleportation at a doubled angle, a finite recursion rather than an unbounded loop. That is the first kind of retry. The second is different: the helper state itself has to be prepared, and its preparation is watched by a quantum error detection (QED) round. If that check trips, only the helper preparation is repeated, locally, without discarding the computation. It is only when those local retries are exhausted, or a QED check rejects a run outright, that a full shot is thrown away; in this experiment about 4.7% of shots were discarded that way. The design is less heavily protected than a strictly fault-tolerant one, and that is the point: detect, retry locally where you can, and accept a small rate of lost runs, in exchange for far less overhead.

Did the correction help? Yes. Then the diagnosis.

That leaves the question the whole exercise is meant to answer: did the error correction actually help? It did. In the deeper circuits, adding real-time Steane QEC gadgets, error-correction routines run in the middle of the computation rather than only at the end, reduced the loss of coherence compared with running the same encoded circuit without them.¹ That is not trivial. The gadgets add circuitry, and it would have been easy for the extra machinery to inject more error than it removed. It did the opposite: intermediate error correction suppressed noise rather than proliferating it, even after paying for its own overhead.

The machine did not fail. It handed the next problem to the memory.

Then came the diagnosis. To find what limited the result, the authors ran an emulator of their own machine with the noise sources switched on one at a time, and asked which one hurt the encoded QPE circuit most. The answer was not the two-qubit gates that usually take the blame. In this circuit, and at the noise levels of this device, the dominant modeled source of error was memory noise: the slow loss of coherence while qubits sit idle or are physically shuttled around the trap. More precisely it was the incoherent part of that memory noise, which in their simulation was much larger than the gate-and-readout contribution.¹ This is a statement about this encoded circuit on this setup, not a universal verdict on Quantinuum or on trapped ions; a different algorithm, code, or device would rebalance the ledger.

Why does idling dominate? Look at where the time goes inside a single controlled evolution. Of the total, the transversal two-qubit (CX) gates take about 2%, the recursive-gate-teleportation rotations about 76%, and the QEC gadgets about 22%.¹ The rotations are genuine computation, not waste, so this is not a story of 2% real work and 98% overhead. The problem is structural. The RGT rotations and the QEC gadgets are built from intricately nested, conditional operations: prepare a helper, check it, branch on the result, teleport, perhaps retry with a doubled angle, measure a syndrome, branch again. While that long conditional sequence plays out on some qubits, the others, including the ones holding the logical state, have nothing to do but wait and stay coherent. The idle time is not a side effect bolted on; it is manufactured by the very machinery that protects and drives the computation. And a qubit that waits accumulates memory noise. The team suppresses the orderly, coherent part of that drift with dynamical decoupling, a sequence of flips that reverses a slowly building phase error before it can pile up, but the random, incoherent part slips through.¹

Hand-drawn blue-pen schematic. A time bar for one controlled-evolution step is split into a thin two-qubit CX segment about 2 percent, a wide rotation-gadgets RGT segment about 76 percent, and an error-correction QEC segment about 22 percent. Below, a busy qubit timeline is dense with operation ticks, while a data qubit timeline has short bursts separated by long idle gaps, with a red arrow marking where memory noise creeps in. — Figure 3: Where the time goes, and who has to wait. Inside one controlled-evolution step, the two-qubit gates take about 2% of the time, the arbitrary-angle rotation gadgets about 76%, and the error-correction gadgets about 22%; the rotations are real computation, not overhead. The catch is structural: those rotation and correction gadgets are long, nested, conditional sequences, so a data qubit carrying the computation sits through several long idle gaps between its own operations, and it must stay coherent across every one of them. That idling was the dominant modeled source of error in this circuit.

The investor's read

The error correction worked, and that is the real news. But it also relocated the problem.

Then I put the investor's hat back on, and this is where the paper touched my earlier view. When I wrote Quantinuum's story, I described a board assembled to manufacture and sell rather than to invent, and I wrote a line I now want to qualify: "The invention, management is telling you, is largely done."

After this week, I think that was too simple. I already saw Quantinuum's full stack, its control of the algorithm, the compiler, the error correction and the classical processing, as a business moat. What I under-weighted is that the same full stack is also the engineering that makes the machine useful at all. This result did not come from better qubits alone. It came from co-designing the algorithm, the code, the compiler and the postprocessing around what the hardware can actually survive. The invention is not finished; some of it clearly lives higher up the stack too, in the architecture of the whole application and not only in the physics of the qubit. The qubits are no longer the whole story. They are just the part everyone photographs.

There is an investor thought hiding in that. If a useful quantum computer needs this much classical scaffolding around it, control, decoding, compilation, postprocessing, then a quantum boom may also be a classical-compute boom, growing right alongside the qubits. The quantum machine does the one part classical computers cannot; the classical machine keeps showing up everywhere else. And the specific wall this paper hit, memory noise, belongs to this circuit on this device, not to Quantinuum or trapped ions as a whole; another algorithm or machine would surface a different limiting error. But the broader lesson looks like it generalizes: quantum computing is a co-design problem, hardware and algorithm and compiler tuned to one another.

I want to keep the result in proportion. This is still hydrogen, in a minimal basis, a benchmark whose answer we already knew, and the estimate does not yet reach chemical precision (about 0.0016 hartree), a common accuracy benchmark in quantum chemistry. What I like is the direction. It is less "look at our qubits" and more "how do we make the application run, end to end." That shift, from showcasing hardware to optimizing a whole workflow around it, is what a business eventually has to do.

Where I land

I will end the week wearing both hats, which is the point of this notebook. As a physicist, I find the honesty of the paper bracing: it builds a genuine error-corrected chemistry calculation, and then it turns around and tells you exactly which wall it hit next, and why. As an investor, I come away with my Quantinuum picture slightly redrawn. The invention I once filed under "largely done" is still very much underway. Much of it clearly lives higher up the stack too, in the system wrapped around the qubit. That is not a bearish read or a bullish one. It is a more accurate one. The hard part of quantum computing is no longer only building the machine. It is making the whole application survive itself.

That gives me a simple watchlist for future Quantinuum papers. A logical qubit is not useful because it exists; it is useful if the application can keep it alive long enough to ask the question. So I will not be watching only for bigger qubit counts or cleaner gate fidelities. I will look for evidence that memory noise is coming down, that protected circuits spend less time waiting, and that fewer shots are lost to the retry-and-discard machinery. Or, on the other side of the ledger, that the classical stack, compilation, decoding, control, and post-processing, is growing strong enough to carry real applications rather than one-off demonstrations. Either path counts: better hardware that needs fewer compensating steps, or a stronger classical layer that makes those steps scalable. Somewhere in that balance is the bridge from a beautiful demonstration to future revenue.

Sources & notes

K. Yamamoto, Y. Kikuchi, D. Amaro, B. Criger, S. Dilkes, C. Ryan-Anderson, A. Tranter, J. M. Dreiling, D. Gresh, C. Foltz, M. Mills, S. A. Moses, P. E. Siegfried, M. D. Urmey, J. J. Burau, A. Hankin, D. Lucchetti, J. P. Gaebler, N. C. Brown, B. Neyenhuis, and D. Muñoz Ramo, "Quantum Error-Corrected Computation of Molecular Energies," PRX Quantum 7, 020319 (2026). DOI: 10.1103/m7j3-5sk6. Quantinuum. Source for all quantitative claims here: the end-to-end QEC pipeline and the $[[7,1,3]]$ color-code encoding; the estimated energy $E - E_{\mathrm{FCI}} = 0.001(13)$ hartree and the chemical-precision figure of about 0.0016 hartree; the single-ancilla information-theory QPE with classical post-processing; the partial fault-tolerance design, recursive gate teleportation, and the 4.7% of shots discarded by the error-detection gadgets; the demonstration that Steane QEC gadgets reduced decoherence; the emulator study finding incoherent memory noise the dominant modeled error source for this encoded circuit; the breakdown of operation time within a controlled evolution (about 2% two-qubit gates, 76% rotation gadgets, 22% QEC gadgets) and the attribution of long idle times to nested conditional operations; and the use of dynamical decoupling against coherent memory noise.
S. A. Moses, C. H. Baldwin, M. S. Allman, R. Ancona, L. Ascarrunz, C. Barnes, J. Bartolotta, B. Bjork, P. Blanchard, M. Bohn, et al., "A Race-Track Trapped-Ion Quantum Processor," Phys. Rev. X 13, 041052 (2023). DOI: 10.1103/PhysRevX.13.041052. The System Model H2 trapped-ion architecture on which this work was run.
A. Aspuru-Guzik, A. D. Dutoi, P. J. Love, and M. Head-Gordon, "Simulated Quantum Computation of Molecular Energies," Science 309, 1704 (2005). DOI: 10.1126/science.1113479. An origin point for using quantum phase estimation to compute molecular ground-state energies, and for the exponential-scaling argument that motivates it.
K. M. Svore, M. B. Hastings, and M. Freedman, "Faster Phase Estimation," Quantum Inf. Comput. 14, 306 (2014). DOI: 10.26421/QIC14.3-4-7. The single-ancilla, sample-heavy style of phase estimation, decoded classically, that the paper adopts in place of the textbook register-and-inverse-QFT version.
M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information (Cambridge University Press, 2010). The standard reference for textbook quantum phase estimation and the inverse quantum Fourier transform.
A. M. Steane, "Multiple-Particle Interference and Quantum Error Correction," Proc. R. Soc. Lond. A 452, 2551 (1996). DOI: 10.1098/rspa.1996.0136. The seven-qubit code family, of which the $[[7,1,3]]$ color code used here is a member, and the source of the transversal Clifford gates the authors rely on.
Y. Akahoshi, K. Maruyama, H. Oshima, S. Sato, and K. Fujii, "Partially Fault-Tolerant Quantum Computing Architecture with Error-Corrected Clifford Gates and Space-Time Efficient Analog Rotations," PRX Quantum 5, 010337 (2024). DOI: 10.1103/PRXQuantum.5.010337. The partial-fault-tolerance design principle: relax strict fault tolerance for the expensive arbitrary-angle rotations to cut overhead.
C. J. Trout and K. R. Brown, "Magic State Distillation and Gate Compilation in Quantum Algorithms for Quantum Chemistry," Int. J. Quantum Chem. 115, 1296 (2015). DOI: 10.1002/qua.24856. Background for the recursive gate teleportation used to apply arbitrary-angle rotations in a repeat-until-success fashion.