Sunday, November 22, 2026
English edition

Development

Quantum error correction goes well beyond breakeven

October 20, 2026 Development Source: Ars Technica

Quantum error correction goes well beyond breakeven

Share this article

Members of some families of error correction codes differ in a fairly simple way: Each step up in size (which may require multiple hardware qubits) means a greater distance. So by adding more hardware qubits, you can create a similar geometry while providing a greater distance. These sorts of codes can be used to measure how well a given quantum processor’s error correction scales. You start by measuring the error rate of the logical qubit with a small distance, say three. Then you can devote more hardware qubits to the text and measure it at a distance of five, repeat the process for a distance of seven, and so on until you run out of hardware qubits to add. If the hardware is past the breakeven point, then the error rate will be lower with each step up in distance. And the scaling factor—how much better the error rate gets at each step—gives you a sense of how far beyond breakeven it is. This matters a great deal for practical reasons. If each step up in size cuts the error rate by a factor of 10, then you only have to step up in distance a few times to get the error rate down by a considerable amount. If, by contrast, the scaling factor is closer to two, then you have to go up in distance many, many times to get the same effect. So far, most demonstrations of scaling beyond the breakeven point have seen the error rate drop by something much closer to two than 10. Which may mean that we’d need to add many thousands of hardware qubits to the logical qubit just to get the error rate down to what we’d need to run a complex algorithm. Quantinuum builds what are called trapped ion quantum computers. As their name implies, each qubit is stored in an ion, an atom that has lost one or more of its electrons. Because they are charged, it’s possible to manipulate these using electrical fields generated by electronics, moving them around and rearranging them. The company’s latest hardware, called Helios, rotates the ions around a ring, selectively shifting the appropriate ones into one of two arms where measurements and operations of the ions’ quantum states can be performed using lasers. Because any two ions can be brought into these arms at the same time, it’s possible to entangle any ion with any other, providing Helios the ability to host essentially any error code. In general, the company’s hardware has relatively low error rates. But previous iterations didn’t have enough qubits to increase the distance of logical qubits very much. But with Helios, the company finally had the ability to use versions of an error correction code (called a color code) with distances of three, five, and seven (though it only has enough hardware qubits to host a single distance of seven logical qubits at a time). In addition, Quantinuum has made a key change in how its processor operates. A significant number of errors in earlier Quantinuum processors occurred through what’s called “leakage.” This occurs when a qubit, instead of occupying one of the two energy states used for calculations, ends up in a nearby energy state that’s not normally used. Now, the company is using a scheme that uses laser light to selectively manipulate those qubits that have leaked into other energy states and bring them back to one of the two used for computation. This suppresses leakage errors by a factor of 6.5 and can be done at the same time the system is using lasers to cool the ions. It has also developed a software-based system that can take any leaked data-holding qubits and swap them out for measurement qubits, which can then be reset and reused. To get this to work, the system had to take the syndrome data obtained from querying the measurement qubits and figure out the nature of any errors that were detected. As the distance of the error correction code goes up, it gets increasingly challenging to perform this analysis rapidly enough to keep it from becoming a bottleneck. The Quantinuum team showed that they had three different pieces of software, each able to operate in real time: a standard algorithm, a convolutional neural network, and a transformer-based neural network. For the distance three color code, the logical error rate was about 5 x 10-4. Stepping up to the distance five code brought that down to about 4 x 10-5, and the distance seven code saw another order-of-magnitude drop, down to 5 x 10-6. Overall, each step up in distance reduced the logical error rate by roughly a factor of 12. That is, to my knowledge, the best scaling seen yet. Another important step that was done here is showing that the syndrome data from one round only correlates with the data from the one immediately before and immediately after. This indicates that there are no systemic sources of error that are biasing the error-detection process. Of course, performing actual operations involves doing considerably more to the logical qubits than allowing them to just sit still and hold their state. So, the researchers also looked at the logical error rate associated with performing a relatively simple two-qubit gate operation. Unfortunately, this requires using two logical qubits, and the Helios processor isn’t able to hold more than one distance seven error code at a time. So instead, the researchers compared using hardware qubits directly and using distance three and five color codes. Running these two-qubit gates directly on the hardware produced an error rate of about 10-3, and the distance three code didn’t improve things dramatically. But the distance five code dropped the logical error rate to about 7 x 10-5. So, the hardware seems to be well beyond breakeven, even when it’s being asked to perform relatively complicated tasks. These results can be viewed a couple of different ways. From the “no big deal” perspective, even the best logical error rate is still too high to perform complicated algorithms, and getting there had some major drawbacks: it was only seen when operations weren’t being performed on the qubit, and the system is only big enough to host one of these. We still have a long way to go before we’re ready to perform lots of error-corrected operations at a potentially useful error rate. From a more optimistic perspective, this is the best scaling I’m aware of, and the performance suggests that getting the hardware error rate down a bit further could have significant payoffs. The logical error rate depends on the hardware error rate in a way that means that, once things get good enough, then small improvements can have very large impacts on the logical error rate. The scaling seen here doesn’t tell us that we’re at that point, but it is suggestive that we’re getting close. The main question for Quantinuum is whether it can scale its qubit counts as effectively as its roadmap suggests it will. If so, it may not need to drop its hardware error rate much to start being able to generate useful logical qubits. That may mean solving somewhat different problems than some of its competitors, who will need to do different combinations of dropping the hardware error rate, boosting qubit counts, or figuring out how to integrate multiple functional units into a single computer.