It’s relatively easy to store multiple quantum values in one piece of hardware.
It’s possible to go beyond qubits, and have a single piece of hardware that can be in three or more quantum states. Credit: spawns / Getty Images
The world of computers is dominated by binary. Silicon transistors are either conducting or they’re not, and so we’ve developed a whole world of math and logical operations around those binary capabilities. And, for the most part, quantum computing has been developing along similar lines, using qubits that, when measured, will be found in one of two states.
In some cases, the use of binary values is a feature of the object being used to hold the qubit. For example, a technology called dual-rail qubits takes its value from which of two linked resonators holds a photon. But there are many other quantum objects that have access to far more than two states—think of something like all the possible energy states an electron could occupy when orbiting an atom. We can use things like this as qubits by only relying on the lowest two energy levels. But there’s nothing stopping us from using more than two.
In Wednesday’s issue of Nature, researchers describe creating qudits, the generic term for systems that hold quantum information—it’s short for quantum digits. Using a system that can be in three or four possible states (qutrits and ququarts, respectively), they demonstrate the first error correction of higher-order quantum memory.
Making ququarts
More complex qudits haven’t been as popular with the people who are developing quantum computing hardware for a number of reasons; one of them is simply that some hardware only has access to two possible states. In other cases, the energy differences between additional states become small and difficult to distinguish. Finally, some operations can be challenging to execute when you’re working with qudits that can hold multiple values—a completely different programming model than qubit operations might be required.
Still, there’s a strong case to be made that moving beyond qubits could be valuable: it lets us do a lot more with less hardware. Right now, all the major quantum computing efforts are hardware-constrained—we can’t build enough qubits and link them together for error correction to let us do useful calculations. But if we could fit more information in less hardware, it should, in theory, let us get to useful calculations sooner.
The “in theory” comes from the fact that we’d need the hardware to retain a low error rate even as it stores more information. In the new demonstration, the researchers show that, for at least one type of hardware, that condition doesn’t seem to be valid: the more data we store, the more quickly errors occur. But they manage to claw some of that back by demonstrating the first use of error correction on complex qudits.
The device they use relies on a standard transmon, a qubit that has a superconducting wire linked to a microwave resonator. The transmon itself, however, is linked to an additional microwave cavity. With sufficient photons, the cavity can act as an oscillator, with photons sloshing back and forth and creating interference patterns. And it’s possible for the oscillations to have more than one mode. (A mode can be thought of as a unique set of peaks and valleys in the interference pattern.) Given that interference is a quantum behavior, it’s possible to place the system in a superposition between different modes and so use the different modes to store quantum information.
To add modes to the resonator cavity, you need to put more photons into it. This creates more peaks in the interference pattern and packs them in more tightly. But it also increases the rate of photon loss, and thus the probability that the system will experience an error. For the experiments here, the researchers put the cavity in states where it hosted either qutrits or ququarts and used them to experiment with error correction in an attempt to get that error rate back down.
A qubit, qutrit, and ququart walked into a bar…
The key to this work is the transmon connected to the cavity. Normally, the transmon is used to control the state of the cavity and to read out its value when needed. But it’s also possible to use it to perform weak measurements that don’t destroy the state of the qudit in the cavity. These don’t tell you the exact state of the resonator in the cavity, but they can help you figure out whether that state has changed, which means that an error has occurred. By performing a series of such measurements, it’s possible to determine not only the nature of that error, but also what actions need to be taken in order to correct it.
Rather than trying to figure out how to control the qudit based on theoretical considerations, the researchers broke their control system down into a number of variable properties and then used reinforcement learning to optimize all of these variables. The goal of this optimization was to simply stabilize the state of the qudit, keeping it from being lost. You can think of this as getting it to act like something akin to memory (actual computations will require that it retain its state through complex operations.)
For the experiments, the researchers operated the cavity as a qubit, qutrit, and ququart. They measured its longevity in each of those states, both with and without error correction.
The results were pretty clear. Each step up the information ladder, from two to three to four states, shortened the lifespan of the quantum memory. But turning on error correction restored some of the performance. For example, an error corrected qutrit held its state roughly as long as an uncorrected qubit. An error-corrected ququart actually performed better than an uncorrected qutrit.
For each of the three cases, turning on error correction boosted the lifespan by a factor of roughly 1.8.
It’s important to recognize that this is entirely a proof of principle, taking place in a single piece of hardware that isn’t even being linked to additional qudits or used for calculations. But, given that error correction has already been demonstrated to improve performance on qubits, it’s a rather critical proof. Getting this to work also doesn’t solve the issue of the relative complexity of performing calculations on qudits that can hold multiple values.
Still, given a world where we’re constrained by a combination of qubit counts and error rates, a system that should be able to partly solve one of those two problems is definitely worth exploring.
Nature, 2025. DOI: 10.1038/s41586-025-08899-y (About DOIs).
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.
