Microsoft does multi-qubit operations and error correction
Microsoft improves error correction on Quantinuum machine by partnering with Atom Computing
In September, Microsoft made a series of announcements related to its Azure Quantum Cloud service. Among them was a demonstration of logic operations using the largest number of qubits with error correction.
“Since April, we have tripled the number of logic qubits,” said Microsoft technical scientist Krista Svore. “So we're accelerating toward a hundred logical qubits.” The company has also found a new partner in Atom Computing, which uses neutral atoms to store qubits and has already demonstrated hardware with more than 1,000 hardware qubits.
Taken together, these announcements are the latest sign that quantum computing has emerged from its infancy and is rapidly moving toward systems capable of reliably performing calculations that would be impractical or impossible to perform on classical hardware. We spoke with Microsoft employees and some of its hardware partners to understand what's next to bring us closer to useful quantum computing.
How does this work?
IN draft documentdescribing a new phase of bug fixing, Microsoft and Quantinuum researchers describe the bug fixing framework needed to reach the new milestone. In a simplified form, the qubits on which data is stored can be represented as a grid. Measuring one set of auxiliary qubits should yield four values that are always the same: either all zeros or all ones. Finding an unexpected value—say 0 0 1 0—will tell you where the problem is on the x-axis. After taking a second set of measurements, you can determine the column in the same way.
Note that this system still allows for fatal errors, since it is possible to produce a result with an equal number of zeros and ones. However, it will at least allow you to determine if there is a problem, allowing you to stop and restart the calculation.
Logic qubits offer a way out of the desperate situation caused by the realization that we will never be able to keep hardware qubits from making too many errors to perform reliable calculations. Error correction in classical computers involves measuring the state of bits and comparing their values with the total value. Unfortunately, you can't similarly measure the state of a qubit to determine if an error has occurred, since measuring it forces it to take on a specific value, destroying any superposition of values that makes quantum computing useful.
Logic qubits get around this problem by spreading a single bit of quantum information across many bits, making any error less catastrophic. To detect an error, a few extra bits must be added to the logical qubit so that their value depends on the bits containing the data. You can measure these auxiliary qubits to determine if there is a problem and possibly gain information on how to fix it.
There are many potential error correction schemes, some of which may require allocating around a thousand qubits for each logical qubit. You can get by with fewer – there are circuits with less than 10 qubits. But in general, the fewer hardware qubits you use, the higher the likelihood of errors from which you cannot recover. This trend can be partially offset by hardware qubits, which are less error-prone.
The problem is that this only works if the error rate is low enough that you don't encounter errors during the correction process. In other words, hardware qubits must be so good that they don't throw so many errors that it's impossible to know when an error occurred or how to fix it. This threshold was crossed relatively recently.
In a previous demonstration, Microsoft used hardware from the company Quantinuum, which uses qubits based on ions trapped in electric fields. They have some of the best bug rates reported so far, and Microsoft has shown that this allows bugs to be caught and fixed within multiple rounds of bug fixes. In the new work, the collaboration goes further, performing a variety of error-correcting logic operations on a collection of logic qubits.
Choose your code
As mentioned above, there are many potential bug-fixing schemes, and new ones are being developed regularly. The team behind the new work calls this circuit tesseract code, after the four-dimensional cube, because the connections between the qubits in it have a similar arrangement to the corners of the tesseract. It's worth noting that this design is possible on Quantinuum hardware because the ionic qubits can be moved around, allowing any one of them to connect to any other. This approach may not be possible with hardware qubits, whose connections are determined by the wiring of the hardware.
The result is a logic qubit that uses 16 hardware qubits to store four logic qubits and can protect them from three simultaneous errors. Given the size of Quantinuum's existing hardware, this allowed the researchers to squeeze a dozen logic qubits into the 56 hardware qubits that the Quantinuum H2 machine had.
And it worked. If you were to perform one of the tested operations using only the hardware qubits of the H2 machine, the error rate would be 2.4 percent. Using tesseract code and logic qubits, the error rate dropped to 0.11 percent, a 22-fold improvement. This metric was based on both errors corrected during operations and calculations discarded due to errors that could not be corrected. This is still not low enough to perform the large number of operations required by useful algorithms, but it clearly demonstrates that error correction works as expected.
Success lay in the use of a large number of measurements and operations to correct errors in addition to those required to perform operations that could be used for calculations. So while the circuit was extremely efficient, it significantly increased the amount of feedback between the hardware qubits and the classical computers that control them. Part of Microsoft's announcement on Tuesday was that the company is committed to making sure users never have to deal with such difficulties.
Microsoft spokesperson Swor told Ars that if you use the Azure Q# control language to develop code for any of the supported systems, it will contain all the instructions you need to fix errors, without user interaction. “We're expanding Azure Quantum from what was originally built as a method-as-a-service to access [подверженным ошибкам] quantum computers,” Svor said in interview Ars. Now its capabilities will be expanded to include error correction.”
“We don't write assembly code on a daily basis,” Swore said. “So the analogy is the same, right? You want to write your application in a high-level language. To do this, we introduced Q#, a high-level language for writing quantum algorithms, and then it drops down to the hardware and compiles to the hardware plane for you.” This way, you as a user don’t need to know the details of quantum error correction or how that correction occurs for a given logic operation—it’s all done for you.”
It is worth recognizing that almost all companies in this area have already realized that this will be necessary to remain competitive. And as a supplier of interfaces to the hardware of several quantum computing companies, Microsoft faces a much greater challenge than any of those companies individually.
Balancing needs
As we said, there are many potential error correction codes that could be used, and they involve a trade-off between the degree of error protection and the number of qubits used. Currently, when the number of qubits is small, most work is focused on very compact circuits, but the number of qubits is expected to grow rapidly in the next few years. This will ultimately pose the question of what level of error a given algorithm can tolerate. “I think there may be different ‘ideal options’ for different equipment vendors,” Swor says. “Similarly, there may be different ‘ideal options’ in the application space.”
But this is only part of the problem. Quantinuum's everything-to-everything hardware can be used in virtually any configuration. But other hardware supported by Azure Quantum has a relatively limited number of hard connections between its qubits. At the same time, the connections between the qubits stored in the Quantinuum chips must be organized through the physical movement of ions towards each other, a relatively slow process that must be kept to a minimum.
And, as Svor noted, application features play an important role. Some error correction codes are not very compatible with certain logic operations (technically called non-Clifford gates). Therefore, the specific operations required for the algorithm to operate may determine which error correction codes make sense. (It is also possible, although at greater computational cost, to change the error correction codes in the middle of the algorithm).
There are many potential optimizations that will need to be balanced, and these will vary depending on the algorithm and the hardware it will run on. All of this would have to be done by Microsoft's compiler, which would translate the Q# code into hardware-specific instructions that perform operations on the qubits, be it moving ions or exposing the qubits to microwaves.
Atom Computing founder Ben Bloom said Microsoft's work in this area made the companies' partnership valuable to Atom's hardware development plans. According to Bloom, his company did much of what one would expect from developing neutral atom quantum computing: It showed that it could generate and trap many individual atoms, demonstrated that it could address each of them individually, and worked with equipment suppliers to obtain lasers with lower noise levels to reduce the error rate during operations.
But Atom has discovered that while many of these things are necessary for effective error correction, they aren't the whole story. “They [Microsoft] came to us and they had very specific ideas about what they wanted to do, and we had our own equipment that was built to different specifications,” Bloom says. Now we communicate regularly, and the companies “are really co-designing the system so that it has error correction and hardware and they adapt to each other very, very effectively.” This includes figuring out how to design circuits that minimize the slowest aspect of operations—the movement of atoms.
Bloom is generally optimistic about the progress being made in fixing bugs. “I think that there are new achievements not only at Microsoft, but throughout the world. I would say that in the field of quantum error correction, I think even in the last year or two there has been a huge shift in what is possible.” Over the past five years or so, he says, the number of qubits people estimate is needed to make a reliable logic qubit has decreased by at least an order of magnitude as people have developed more efficient coding schemes.
His optimism was echoed by Quantinuum CEO Raj Khadra: “We can confidently say that what the industry thought would only be achievable in ten to fifteen years, we will make possible by the end of this decade.”
