// ARS TECHNICA — CRONACA
Quantum error correction goes well beyond breakeven
A demo of error-corrected qubits shows big reductions in errors as they grow.
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.
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.