Microsoft boosts error correction on Quantinuum machine, partners with Atom Computing.
On Tuesday, Microsoft made a series of announcements related to its Azure Quantum Cloud service. Among them was a demonstration of logical operations using the largest number of error-corrected qubits yet.
“Since April, we’ve tripled the number of logical qubits here,” said Microsoft Technical Fellow Krysta Svore. “So we are accelerating toward that hundred-logical-qubit capability.” The company has also lined up a new partner in the form of Atom Computing, which uses neutral atoms to hold qubits and has already demonstrated hardware with over 1,000 hardware qubits.
Collectively, the announcements are the latest sign that quantum computing has emerged from its infancy and is rapidly progressing toward the development of systems that can reliably perform calculations that would be impractical or impossible to run on classical hardware. We talked with people at Microsoft and some of its hardware partners to get a sense of what’s coming next to bring us closer to useful quantum computing.
Ars Video
What Happens to the Developers When AI Can Code? | Ars Frontiers
Making error correction simpler
How does that work?
In a draft paper that describes the new error correction milestone, Microsoft and Quantinuum researchers describe the error-correction scheme needed to reach their new milestone. Simplified down, the qubits holding the data could be viewed as a grid. Measuring one set of ancillary qubits should produce four values that are always the same, either all zeros or all ones. Finding an unexpected value—0 0 1 0, say—tells you where on the x-axis the problem resides. Doing a second set of measurements can identify the column in the same way.
Note that this system still allows unrecoverable errors since it could be possible to get a result with an equal number of zeros and ones. Still, it would at least identify that there’s a problem, allowing the calculation to be stopped and restarted.
Logical qubits are a route out of the general despair of realizing that we’re never going to keep hardware qubits from producing too many errors for reliable calculation. Error correction on classical computers involves measuring the state of bits and comparing their values to an aggregated value. Unfortunately, you can’t analogously measure the state of a qubit to determine if an error has occurred since measurement causes it to adopt a concrete value, destroying any of the superposition of values that make quantum computing useful.
Logical qubits get around this by spreading a single bit of quantum information across a collection of bits, which makes any error less catastrophic. Detecting when one occurs involves adding some additional bits to the logical qubit such that their value is dependent upon the ones holding the data. You can measure these ancillary qubits to identify if any problem has occurred and possibly gain information on how to correct it.
There are many potential error correction schemes, some of which can involve dedicating around a thousand qubits to each logical qubit. It’s possible to get away with far less than that—schemes with fewer than 10 qubits exist. But in general, the fewer hardware qubits you use, the greater your chance of experiencing errors that you can’t recover from. This trend can be offset in part through hardware qubits that are less error-prone.
The challenge is that this only works if error rates are low enough that you don’t run into errors during the correction process. In other words, the hardware qubits have to be good enough that they don’t produce so many errors that it’s impossible to know when an error has occurred and how to correct it. That threshold has been passed only relatively recently.
Microsoft’s earlier demonstration involved the use of hardware from Quantinuum, which uses qubits based on ions trapped in electrical fields. These have some of the best error rates yet reported, and Microsoft had shown that this allowed it to catch and correct errors over several rounds of error correction. In the new work, the collaboration went further, performing multiple logical operations with error correction on a collection of logical qubits.
Choose your code
As mentioned above, there are many potential error-correction schemes, with new ones being developed regularly. The team behind the new work calls the scheme a tesseract code, after the four-dimensional cube, as the connections among its qubits share a similar layout as the corners of a tesseract. It’s worth noting that this scheme is possible on Quantinuum hardware because trapped ion qubits can be moved around, allowing any of them to be connected to any other. That may not be possible to do on hardware-based qubits that have their connections set by the hardware’s wiring.
The net result is a logical qubit that uses 16 hardware qubits to hold four logical qubits and can protect them against as many as three simultaneous errors. Given the size of existing Quantinuum hardware, this allowed the researchers to squeeze a dozen logical qubits into the 56 hardware qubits held by the Quantinuum H2 machine.
And it worked. If you were to perform one of the operations tested using simply the hardware qubits of the H2 machine, you’d expect an error rate of 2.4 percent. Using the tesseract code and logical qubits, the error rate dropped to 0.11 percent, an improvement of 22-fold. This rate was based on both errors corrected during the operations and calculations discarded due to errors that could not be corrected. This is still not low enough to enable the large number of operations needed for useful algorithms, but it clearly demonstrates that error correction works as expected.
The success involved using lots of measurements and operations for error correction in addition to the ones required to perform the operations that could be used for calculations. So while the scheme was extremely efficient, it added significantly to the back-and-forth communications between the hardware qubits and the classical computers that control it. Part of Microsoft’s announcement on Tuesday was that it is committing to making sure that users would never have to deal with that complexity.
Microsoft’s Svore told Ars that if you use Azure’s Q# control language to develop code for any of the systems it supports, it will bundle in all the instructions needed for error correction without any need for user involvement. “We’re expanding Azure Quantum, moving from what was stood up initially as a method as a service for accessing [error prone] quantum computers,” Svore told Ars. Its capabilities will now be expanded to include error correction.
“We aren’t writing assembly code on a daily basis,” Svore said. “So here the analogy is the same, right? You want to write your application in a high-level language. For that, we have introduced Q#, a high level language for writing quantum algorithms, and then that gets lowered to the hardware and compiled for you to the hardware plane. So indeed, as a user, you don’t need to know the details of the quantum error correction or how that error correction happens for a given logical operation—that is all done for you.”
It’s worth acknowledging that pretty much every company in this space has already recognized that this will be essential to remain competitive. And as a provider of interfaces to hardware for several quantum computing companies, Microsoft faces a far larger challenge than any of those companies would have individually.
Balancing needs
As we mentioned earlier, there are many potential error-correction codes that can be used, and they involve a trade-off between the degree of error protection and the number of qubits used. At present, with qubits counts low, most work has focused on very compact schemes, but qubits counts are expected to rise rapidly over the next few years. That will eventually present a choice about what sort of error rate a given algorithm might tolerate. “There can be, I think, different sweet spots for different hardware providers,” Svore said. “Similarly, there can be different sweet spots in terms of the application space.”
But that’s only part of the challenge. The all-to-all connectivity of Quantinuum hardware can be used in just about any configuration. But other hardware supported by Azure Quantum has a relatively limited number of hardwired links among its qubits. At the same time, connections among qubits held by Quantinuum’s chips have to be mediated by physically moving the ions together, a relatively slow process that needs to be minimized.
And as Svore indicated, applications matter. Certain error correction codes aren’t especially compatible with specific logical operations (technically termed non-Clifford gates). So the specific operations needed to get an algorithm to work may determine which error-correction codes make sense. (It is also possible, if computationally expensive, to change error-correction codes mid-algorithm.)
There are many potential optimizations that will need to be balanced, and they will change depending on the algorithm and the hardware the algorithm will run on. All of this will need to be handled by Microsoft’s compiler, which converts Q# code into hardware-specific commands that perform operations with qubits, whether that means moving ions or exposing the qubits to microwaves.
Atom Computing founder Ben Bloom said that Microsoft’s work in the area has made the companies’ partnership valuable for Atom’s hardware development plans. Bloom said his company has done many of the things you’d expect to develop neutral atom quantum computing: It showed that it could generate and trap lots of individual atoms, demonstrated that it could address each of them individually, and worked with hardware providers to get lower-noise lasers to reduce the error rate of operations.
But Atom has been finding that, while many of those things would be needed to enable effective error correction, they’re not the entire story. “They [Microsoft] came to us and they had very specific ideas about the kinds of things they wanted to do, and we had our own hardware that was kind of built according to another set of specs,” Bloom said. Now, there’s regular communication, and the companies are “really co-designing the system such that there’s error correction, and there’s hardware, and they map onto each other really, really efficiently.” These include figuring out how to develop schemes that minimize the slowest aspect of operations, moving atoms around.
Bloom was generally optimistic about the progress being made in error correction. “I think that there’s new advances being made not just in Microsoft but all over the world. I would say with quantum error correction, I think even in the last year or two, there’s just been a huge amount of movement about what’s possible.” He said that, over the last five years or so, the number of qubits people are estimating you’d need to make a robust logical qubit has gone down by at least an order of magnitude as people have developed more efficient encoding schemes.
And his optimism was echoed by the CEO of Quantinuum, Raj Hadra, who said, “We can confidently say that what the industry thought was only possible in 2032, 2035—the first half of the next decade—we are going to make possible by the end of this one.
