Are there qudit systems, and why are they not as popular as qubit systems?

Question

Qudit is a $d$-level system that generalizes a qubit. From what I understood qudits are more resource efficient when it comes to spanning the state space. If $N$ is a dimension of a state space, then we need $\log_2 N$ qubits. With qudits, we need $\log_d N$ qudits. Taking the ratio of the two yields $\log_2 d$ improvement. I guess, this reduction should also reflect in efficiency of construction of algorithms.

Moreover, it seems, qudits have their own set of universal gates some of which are very similar to qubit gates. Algorithms like QFT, DJ, QPE can be implemented with qudits as well.

Why qudits are not as popular? What is the practical $d>2$ we could hope for in the future?

Answer 1

I would like to give a more practical/experimental point of view. There is at least 3 points that makes calibration of qudit processor harder (but not impossible) and explain why current effort is mostly concentrated on qubit. By experience, my example are mostly coming from Superconducting circuits.

Controlling a single qudit is hard: You need to be able to access $d-1$ transitions, which requires more calibration than for a qubit, and the space you need to take into consideration for your calibration is much larger (hence harder experimentally to calibrate). An example, for qutrit in Superconducting circuits you need, for each transition (01 and 12) to calibrate the following:

• Frequency of the drive
• amplitude of the drive
• An extra parameter (DRAG coefficient) to reduce leakage
• a phase to make sure that X and Y gates a 90degree apart. but you also need an extra phase for the idle state (so +1 calibration per transition gate and per extra level). These extra calibration are actually experimentally expensive as they increase the calibration time by a lot. For 2-qutrit gate, this is even more hard, as now, the space to calibrate over is very large (comparable to a 3-qubit gate). This make qudit harder than qubit to scale.

Another point to consider is device design: when designing a device, you need to do a lot of compromise. For instance, speed of readout vs coherence of your qudit/qubit etc... You also need to filter out some un-wanted frequency etc... This make the design of a qudit chip way more complex than a qubit chip, and also completely change the viability of making such a qudit processor. One example, is that the frequency collision constraints on a qudit chip is much more strict since you can now populate more levels. This is again an extra difficulty in scaling up. Another example is in the mechanism that generate a qudit entanglement gate.

Coherence of qudit devices is usually lower than qubit device. For instance, in the transmon architecture, the |2>--> |1> transition has a T1 of half the one of |1>--> |0> ideally. Experimentally, you get lower than that. This makes accessing these extra state hard on the coherence side: You need to be very good for your qubit to even consider higher existed states.

With all these, there has still been a lot of development recently on qudit, and hopefully, more of this challenges will be tackles. But as of today, it is not clear if the scaling of the Hilbert space for qudit is worth the extra complexity of constructing and calibrating these devices.

Answer 2

Practically, qudrits are much harder to work with.

For a single qubit, you only need two quantum states and the ability to drive the single transition $|0\rangle \leftrightarrow |1\rangle$ effectively. Many systems like NV spins, superconducting qubits, Rydberg atoms, etc. use two states out of three or more inherent to each platform as a computational basis. Only needing to drive one transition is helpful because you can pick states that are the easiest to drive resonantly and are unlikely to be driven to some state outside of your computational basis (e.g. if you're trying to excite $|0\rangle \to |1\rangle$ physically, you wouldn't want to excite your qubit in $|1\rangle$ to some state $|2\rangle$).

For a qutrit, you now need 3 states that are well isolated from the rest of your system, but you also now have to be able to drive the $|0\rangle \leftrightarrow |1\rangle$, $|0\rangle \leftrightarrow |2\rangle$, and $|1\rangle \leftrightarrow |2\rangle$ transitions independently just for control of that single qutrit. This driving complexity of scales quadratically (needing $\frac{d(d-1)}{2}$ different drives) with the dimension $d$ of your qudit, and that's only for single qudit control. Two qubit gates are even harder to implement and usual rely on some sort of coupling that exists between excited states that doesn't for ground states. To implement a two qudit gate, you'd likely need more coupling mechanisms which may or may not be practical to implement on your platform of choice.

TLDR: Building a quantum computer based on qubits with 2 states and a single transition to worry about is hard, and building one with qudits with $d$ states and $O(d^2)$ transitions is much harder.

Answer 3

Often when considering such questions it may be beneficial to ask about the same thing, but from a classical perspective. For example, we can ask why do we privilege bits over, say, trits, and ask "are there any classical, ternary systems, and why would they not be as popular?"

I found out when researching this answer that a ternary computer was built by Thomas Fowler in the 1840's - Fowler was prior to or contemporaneous with Boole, from which we get boolean logic to describe two-bit operators such as AND and NOR. Indeed, the alphabet in Turing's original machines did not have only two symbols; I've read that Shannon (or maybe von Neumann?) was the first to reduce his alphabet to $0$ and $1$.

Although nothing seems to have precluded basing computation on some other arbitrary radix, other than $2$, for convenience and probably for historical reasons, bits won out over trits. There certainly has to be some path-dependence or QWERTY-like hysteresis. It might help that now, classically, bits are cheap (as opposed to quantumly, where qubits are expensive). Bits were expensive in the past, so it might have made more sense to explore ternary or mixed-radix computation, but we are long past that now and we can always pad our problem input to the next-largest power of two. See, e.g., the approach to binary-coded decimals, where we use for bits to store a decimal digit but ignore or don't-care states such as 1110.

Take note that for any radix that is not prime, for example a qudit-based system with $d=4$, we can always factor the radix into its prime decomposition, and make a similar statement. However, controlling such a qudit with $d=4$ is no easier than controlling two qubits, which, as @ChrisE mentioned, is hard enough already.

Interestingly, in certain kinds of FLASH memory, individual cells or transistors are capable of storing more than one bit of memory by discretizing the threshold voltages. Nonetheless in each such example, the number of such voltage levels is a power of two.

Similarly if we had perfect control of artificial atoms with $d=4$ or $d=8$ energy levels I would suspect that we would simply call our atom a "multi-level qubit", and still intuit our system in binary. However, if we had perfect control of an artificial atom with $d=5$ energy levels, at this time I don't think we'd want to easily give up and ignore the extra control we have of the fifth state!

See also, this very nice (although now closed) question on Stack Overflow about the classical case, with considerations similar to those in this thread.