Breakeven Is Where the Race Starts

This article asks what IonQ’s quantum low-density parity-check (qLDPC) breakeven result actually demonstrates, and what still has to improve. Nine codes from three families ran on one forty-ion processor with all-to-all connectivity and mid-circuit measurement without ion transport. Several logical lifetimes reached the physical-qubit range, but increasing code distance did not clearly lower logical error, the most demanding runs suffered heavy leakage-driven post-selection, and simultaneous two-qubit operation remains harder to characterize than isolated pair benchmarks. The result is therefore better read as a hardware and control milestone than as a scaling demonstration. The investor question is whether stronger codes begin to lower logical error while leakage, correction-cycle time, and workload-level gate error fall with them.

Breakeven sounds like a finish line. It is the point where an error-corrected qubit lasts at least as long as the raw physical qubits it is built from, and for years it was one of the milestones the field was chasing. This IonQ paper reports reaching it on some of its codes.¹ Read closely, it is better understood as the point where error correction stops losing the trade, and the paper is most useful for showing everything that still has to go right after that.

The trade error correction makes

A single physical qubit is too fragile to trust with a long calculation. Error correction spreads one unit of quantum information, a logical qubit, across many physical ones, then repeatedly checks those physical qubits for signs of damage without looking at the information itself. Codes are written $[[n,k,d]]$: $n$ physical qubits protecting $k$ logical qubits, with a distance $d$ that measures how many errors the code can absorb before the information is lost. A larger distance should mean stronger protection.

The trade is overhead. The surface code, the field’s workhorse, is easy to wire up because each qubit only talks to its neighbors, but it is expected to need hundreds of physical qubits for every logical qubit once you want error rates low enough to be useful. Google has already shown the surface code passing breakeven, with a logical memory that outlived its best physical qubit by a factor of 2.4.²

What is new here is the price. IonQ runs a different family, called quantum low-density parity-check codes, which pack more logical qubits into each block. One of them stores 4 logical qubits in 18 physical ones. The catch is that these codes need qubits far apart in the block to interact, and on most hardware that means a connection that does not exist.

Forty ions, any pair

A trapped-ion chain does not have that problem. IonQ holds forty barium ions in a single stationary line and drives its gates with steerable laser beams that can address any ion, or any pair. Nine different codes, from three families, ran on the same device with no hardware changes between them. Each code shares the forty ions with the ancillas that check it: the 18-qubit code, for instance, uses 14 more ions to carry out its checks, 32 in all.

Any pair is a lot of pairs. Forty ions make

$$\binom{40}{2} = \frac{40 \times 39}{2} = 780$$

possible two-qubit gates, and they are not equally good. IonQ benchmarked every one. In the paper’s own noise model, every error source gets a number except the two-qubit gate, which is marked “variable” and points instead to the whole measured distribution. That is not a gap. It is the honest object: a single figure would be an average over 780 things that differ.

A single figure would be an average over 780 things that differ.

They then used the spread. For each code they chose which physical ions play which role, steering the circuit’s gates toward the better pairs. For most circuits that cut the average two-qubit infidelity by a third to a half, without touching the hardware or the calibrations. The exception confirms the mechanism. One code reads the same check through different ancillas in different rounds, and so ends up using every possible ion pair at some point. It can use the weaker pairs less often, but it cannot avoid them, and it gained only 12 percent.

The shelf

Error correction has an awkward requirement. You must keep measuring some qubits, called ancillas, without disturbing the ones carrying the information. In a trapped-ion computer, measuring an ion means shining light on it and watching for fluorescence, and every other ion shares the same trap.

IonQ’s answer uses an architecture built around long-lived metastable states.³ Before measuring, they move the whole chain into a different set of internal atomic states, a shelf where the readout light no longer acts on them. The light still reaches every ion; the shelved ones are simply no longer tuned to it. Then they bring only the ancillas back, measure them, use those same ancillas to cool the chain’s motion and reset them, and finally return everyone to work.

Figure 1: Same ions, different jobs at different moments. Shelving lets a stationary chain measure itself mid-computation without moving ions or keeping ions just for cooling. Drawn as a schematic ten-ion subset of the forty-ion chain, seven data ions and three ancillas, with the ancillas cooling the chain at the reset stage.

The payoff is what it avoids. In trapped-ion machines that move ions around, the paper notes, transport and cooling consume most of the execution time, and up to half the ions can be dedicated purely to cooling. Among its references for that is Quantinuum’s Helios.⁴ Here there is no ion transport and there are no coolant ions.

What the checking costs

But measuring is not free. Each round is an operation in its own right, with its own errors. Measurement error sits at $9 \times 10^{-3}$, the largest single figure in the paper’s noise table and roughly thirty times the single-qubit gate error of $3.2 \times 10^{-4}$.

Leakage is the other cost, and the paper puts a number on one of the hardest errors to catch: an ion slipping out of the two states that stand for 0 and 1. IonQ catches it during the measurement itself: an ancilla that stays dark when it should glow, or a shelved data ion that glows when it should stay dark, flags an ion that has left its states. The paper’s noise model puts the rate at about $1.7 \times 10^{-3}$ per round, a figure first estimated from characterization and then tuned, and names the measurement machinery itself as the dominant source. More correction cycles mean more measurement rounds, and more leaks.

More correction cycles mean more measurement rounds, and more leaks.

In this experiment a detected leak costs the whole run. For the most demanding code, after six rounds of correction, 74.8 percent of the runs were thrown away. The paper also simulates the alternative, resetting the leaked ion and treating its position as a known error. Its main text summarizes the penalty as about 10 to 17 percent. Appendix E is more specific: at worst an 11 percent increase in logical error for this family of codes and 20 percent for another, which correspond to logical lifetimes 10 percent and 17 percent shorter. The main text’s range is the lifetime cost, quoted as though it were the error-rate cost. They did not build the recovery here, but it shows that a leak need not cost the whole run.

Two further caveats sit in the fine print. The per-pair gate errors were measured one pair at a time. A test that placed several pairs in the same circuit showed higher error rates, which the authors attribute to effects like crosstalk, but testing every combination would have been prohibitively slow, so the isolated numbers were scaled up uniformly to match. A single scale factor preserves the ranking of good and bad pairs by construction. They checked representative pairs under simultaneous operation, but not enough combinations to establish that the ranking holds across the whole machine under real circuit load. And the noise model’s parameters were fine-tuned by minimizing the very logical error rates it is used to interpret.

The result that matters most

The paper ran three versions of one code family, each larger and with a higher distance, in principle harder for errors to defeat. It reports the logical error rate per cycle, $p_L$, derived from a fitted decay constant $\tau$, roughly the number of correction cycles over which the encoded information decays:

$$p_L = \tfrac{1}{2}\left(1 - e^{-1/\tau}\right).$$

Code	Distance	$p_L$, $X$ basis	$p_L$, $Z$ basis	Cycle time
$[[18,4,3]]$	3	$(2.01 \pm 0.6) \times 10^{-2}$	$(1.08 \pm 0.8) \times 10^{-2}$	42 ms
$[[24,4,4]]$	4	$(2.18 \pm 0.4) \times 10^{-2}$	$(1.34 \pm 0.4) \times 10^{-2}$	65 ms
$[[30,4,5]]$	5	$(3.37 \pm 2.4) \times 10^{-2}$	$(1.82 \pm 0.3) \times 10^{-2}$	86 ms

The larger codes did not get better. The trend runs the wrong way in both bases. The paper’s other two families are less clean comparisons, but they mostly point the same way, and since the individual error bars overlap, this is a trend rather than a proof. A larger code means more checks, more gates, more measurement rounds, more idle time and more chances to leak. The data are consistent with that extra machinery eating the protection the larger code is supposed to buy. Each cycle also takes longer.

That is the opposite of Google’s surface-code result, where the logical error rate fell by a factor of 2.14 each time the distance grew by two. A falling line is what error correction is supposed to look like.

Figure 2: The scoreboard for error correction. Bigger codes should push the logical error down. On this hardware the central values rise instead, although the error bars overlap. The inset is illustrative, not IonQ’s data.

Breakeven, in proportion

Even the breakeven claim is modest on inspection. The strongest case is a logical lifetime of $3.95 \pm 0.68$ seconds against $3.3 \pm 0.9$ for the physical qubits, and the two intervals overlap for most of their width, so the experiment does not resolve a real advantage either way. The paper’s own results section describes the logical lifetimes as comparable to the physical ones within error bars. One code, the concatenated one, did not reach even that.

The comparison that does stand out is against the one earlier demonstration of a code like this, on a superconducting chip fitted with long-range couplers built for that single code, which lost about 9 percent per logical qubit per cycle. On a code of the same size, 4 logical qubits in 18 physical ones, IonQ’s rate is about 4 times lower for one type of error and about 9 times lower for the other.

The paper is less careful about its breakeven wording. Its introduction says the logical lifetime marginally exceeds the physical one in one case; its results section says it does in several. It does not change the conclusion, but it is the kind of thing a careful reader should notice.

My takeaway. IonQ reached the breakeven regime with a high-rate code, four logical qubits in an 18-qubit block, on a machine that measures itself without moving a single ion. What it has not shown is that the saving survives once you demand a genuinely low logical error rate: the larger codes did not help, most of the demanding runs were discarded, and the machinery of correction has become a major error source in its own right.

Where I land

As a physicist, the shelving trick is the part I will remember: one chain of identical ions, each taking different jobs at different moments, measuring itself without moving. It is genuinely clever engineering.

As an investor, I read the paper as a clear map of the next hurdle rather than a win. Breakeven with a high-rate code is an encouraging step toward lower overhead. But the error correction does not yet get better as it gets bigger, and until it does, the logical qubit is a proof of concept rather than a building block. Breakeven is where that race starts.

The investor view: what to watch next

Three papers on hardware errors have left me convinced that no single number tells you whether a machine is getting better. What I would follow instead is two habits for reading any result, and four measurements to read with them.

A prediction made before the run is evidence. A number inferred afterward is a hypothesis until someone changes the machine and checks.

Two habits.

Ask whether the model predicted or was fitted. IonQ’s noise model was tuned against the same logical error rates it is used to interpret. Quantinuum’s thermal-state model made a firm prediction and missed it by more than six standard deviations, and the miss is what pointed to leakage.⁵ Pasqal inferred a calibration offset from its data after the fact, then tested it by mistuning its machine on purpose, and the model followed.⁶ A prediction made before the run is evidence. A number inferred afterward is a hypothesis until someone changes the machine and checks.

Ask which machine, and when. Quantinuum’s thermal-state data came from H1-1 in August 2025, a generation before Helios. IonQ’s came from one forty-ion chain. Pasqal checked one model against three machines of the same generation. A result on one device is a data point. The same model holding across devices is closer to a property of the product.

Four measurements. Only the first is the score.

1. Logical error as the code gets stronger. This is the scoreboard. Error correction works only if bigger codes produce lower logical error, and Google has shown that on the surface code. The result to wait for from trapped-ion, high-rate codes is the first time the larger code wins, in both bases, by more than its error bars.

2. Leakage per correction round, and what happens to it. IonQ’s noise model puts leakage at about $1.7 \times 10^{-3}$ per round, and the experiment discarded every run in which it was detected. Discarding most of the data does not scale. Resetting the leaked ion and correcting for it does, and IonQ’s own simulation puts the cost at an 11 to 20 percent rise in logical error, depending on the code family. Watch for that done on hardware, and for the rate itself to fall. Leakage is also the error that left Quantinuum’s thermal-state result unconfirmed, on a machine that needed spare qubits to detect it.

3. Two-qubit error under real workload. A benchmark of one pair at a time is the flattering number. The useful one is the error when many pairs work in the same circuit, and whether the good pairs stay good.

4. Time per correction cycle. Here it ran from about 35 to 86 milliseconds, depending on the code. Google’s was 1.1 microseconds. A computation needing a million correction cycles would take about twelve hours at 42 milliseconds per cycle, and about a second at 1.1 microseconds. Trapped ions trade speed for connectivity and long-lived qubits, and the question is whether the cycle gets shorter as the codes grow. Read the two numbers as physical context rather than a race result: one IonQ cycle protects four logical qubits and Google’s protects one, so a cycle is not the same unit of work on the two machines. The number I actually want, once anyone can report it, is the time to reach a target logical error rate, and then how many logical operations per second the machine sustains there.

The last three tell you why the score moved. Only the first tells you whether it did.

Sources & notes

E. Tham, M. L. Goldman, S. Debnath et al. (IonQ), “Breakeven demonstration of quantum low-density parity-check codes,” arXiv:2606.06455 (2026).
Google Quantum AI, “Quantum error correction below the surface code threshold,” Nature 638, 920-926 (2025). doi:10.1038/s41586-024-08449-y.
D. T. C. Allcock, W. C. Campbell, J. Chiaverini et al., “omg blueprint for trapped ion quantum computing with metastable states,” Applied Physics Letters 119, 214002 (2021). doi:10.1063/5.0069544.
A. Ransford et al., “A 98-qubit trapped-ion quantum computer with all-to-all connectivity,” Nature 655, 81-86 (2026). doi:10.1038/s41586-026-10676-4. Cited by the IonQ paper, in its preprint form, among its examples of transport and cooling costs.
E. Granet and H. Dreyer, “Adiabatic preparation of thermal states and entropy-noise relation on noisy quantum computers,” npj Quantum Information 12, 105 (2026). doi:10.1038/s41534-026-01320-0. Hardware data from Quantinuum’s H1-1 system, taken in August 2025.
C. Dalyac, S. Julià-Farré, L. Leclerc, V. Vitale et al. (Pasqal), “Noise-aware emulation and cross-device validation of neutral atom analog quantum processing units,” arXiv:2607.28364 (2026).