Quantum error correction goes well beyond breakeven

Running complicated algorithms on quantum computing hardware is going to require the use of logical qubits, where collections of hardware qubits are linked together in ways that allow errors to be detected and corrected. In general, the more hardware qubits you dedicate to each logical qubit, the better the chances are of identifying errors. But, given that the hardware qubits are prone to errors, adding more of them also increases the probability that errors will occur. If the hardware error rate is too high, then growing the logical qubit will only make matters worse.

Fortunately, several companies have demonstrated hardware where the error rate is not too high. Several demonstrations show logical qubits are beyond the breakeven point, where adding more qubits improves performance. The problem is that the improvement isn’t very dramatic. To lower error rates to levels we’ll need to run complex algorithms, we’d have to add a completely impractical number of qubits to each logical qubit.

On Monday, Quantinuum announced that its current generation of hardware is capable of scaling well beyond the breakeven point. Each step up in the size of logical qubits improved some measures of their performance by a factor of over 10.

Error correction codes and scaling

To understand the results, we must take a little detour through the ideas behind error correction. A logical qubit consists of a set of qubits that hold data, and another set that is used for measurements, all of them entangled to others. There are various error correction “codes,” each of which has a different geometry of entangled connections among its constituent qubits. During operations, measurements of the appropriate qubits produce what’s called “syndrome data,” which can be interpreted to provide an indication of whether an error has occurred within the logical qubit, as well as where and its nature.

Depending on their geometry, error codes have a number of key properties: how many hardware qubits are needed for it to work, how many individual logical qubits it hosts, and something called the distance, which is a rough measure of how many errors can occur simultaneously before the logical qubit fails.

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.

Meet Helios

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.

Color coding

For one of the two experiments the company is announcing today, the company was able to use 13 hardware qubits to build a distance three color code, 37 for distance five, and 73 hardware qubits to get a distance seven logical qubit. These were then used to estimate the error rate that occurs when the logical qubits are simply used to hold onto the same state, essentially acting as a form of quantum memory. The performance of the hardware is good enough now, however, that just doing one round of error correction and measuring can’t provide an accurate measure of how often problems occur—errors are too rare. So instead, the team did 20 rounds of error correction before measuring to determine whether the memory had been maintained.

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.

That other scaling

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.

John is Ars Technica's science editor. He has a Bachelor of Arts in Biochemistry from Columbia University, and a Ph.D. in Molecular and Cell Biology from the University of California, Berkeley. When physically separated from his keyboard, he tends to seek out a bicycle, or a scenic location for communing with his hiking boots.