November 3, 2020

Jelmer Renema

Qumodes vs. Qubits explained, part I

One of the things I get asked about the most is how the photonic systems that QuiX is working on compare to qubit systems. The short answer is that the QuiX photonic processor uses *qumodes, *which are a different way of carrying and manipulating quantum information than qubits.* *In this post, I’ll explore what the differences and similarities are between qumodes and qubits.

To make the difference clear, I need to introduce the notion of an *encoding*. An encoding is some way of taking information from the outside world and representing it in the hardware of your computer.

How this works is most straightforward to show with an example of a regular (classical) computer: if you have a classical memory consisting of *n* bits (which can be either zero or one), then it is possible to store numbers between 0 and 2*ⁿ *-1 . You can do this by first writing the number in base-2 (i.e. binary). This will give you a set of digits, which will all be zero or one. You can then store the number in memory by assigning to each bit in your memory the value of one of the digits of the number that you are trying to store (represented in the image by plusses and minusses). By going through this process, you have found a way to represent something from the outside world (namely the number you’re trying to store) inside your computer, i.e. you have encoded that number in your computer.

It is important to note that such an encoding is not unique. While it is natural to set the rule that the *n*-th bit in your memory corresponds to the *n*-th bit in your number, there is no law of nature that says that you have to do it that way. If you wanted to, you could make any assignment between digits and bits that you wanted to, for example to have the last bit correspond to the first digit of the number, to have the second to last correspond to the second digit, and so on. If you really wanted to, you could even decide on a lookup table where every number corresponds to some arbitrarily chosen setting of the bits. This would make arithmetic a complete pain, but if you insisted on it, it could be done. This shows that there is some freedom in how you choose your encoding.

However, you are not completely free, because the limitations of your computer system limit what you can encode. As we saw above, you can store 2*ⁿ* numbers (i.e. the numbers from 0 to 2*ⁿ* -1) in a classical memory of *n *bits. If you tried to store more numbers, the procedure would fail. *How could you have guessed that you can store this amount of numbers and no more?*

You could have found this number by counting how many unique ways there are to choose the settings of your memory. Each possible way of choosing the settings is called a *state.* In this case, there are 2*ⁿ* states in the memory, since each bit has two options (zero or one) and there are *n* of them. If we assign a meaning to each state (for example a number, as in the example above), then we run out states when we’ve made 2*ⁿ* of such assignments. So the state space of our system is of size 2*ⁿ*.

So in summary, what we’ve learned from considering this simple classical case is that you can encode things into a computer in different ways, but that the number of things you can encode is limited by the state space of the computer. Next, we’ll consider what happens when you add quantum to the story.

If we go to qubits, not much in this picture changes. While a qubit has infinitely many possible states, it turns out that you should look at what is called the *basis* of the state space, which loosely said means that you should find the minimal number of states in which you can express every other state. For a qubit, this turns out to be two, for example the up state and the down state. To use the language from above, each qubit therefore has 2 ‘possible assignments’, and you have n of them, so by the arguments presented above, there are 2*ⁿ* unique states. Because we are doing quantum mechanics, superpositions of these states are also allowed, but that doesn’t change the picture: the dimensionality of the system is still 2*ⁿ*.

For qumodes, the picture is a bit more complicated. Let’s start by explaining what a qumode actually is. A qumode is a *quantum-mechanical harmonic oscillator*. That is, if you take a harmonic oscillator (for example, a pendulum, or a block of metal on a spring) and you make the system small enough such that quantum mechanics begins to play a role, then you will eventually notice that such a system has discrete quantum states. It is these quantum states which we will use to encode our information.

In our case, the qumode which we’ll use is *light.* Yes, it turns out that a single beam of light is a harmonic oscillator! For the case of light, the states of the harmonic oscillator can also be thought of as corresponding to a given number of *photons*, which are (loosely said) particles of light. Each light beam (or more properly, a *mode*) has full quantum-mechanical dynamics in the distribution of photon numbers, i.e. there is the possibility of superposition, and if you think about more than one optical mode, there is also the possibility of entanglement. The way to think about qumodes is that they are the world in which the photons live.

Things get really interesting if you start considering systems of more than one qumode. Why and how you want to do this is a subject for a whole blog post in itself, but let’s assume for the moment that this is possible. If you bring two qumodes in contact with each other, then photons can jump from one qumode to the other. If the engineering has been done properly, then this can happen without any photons getting lost, i.e. being absorbed or flying out of the system. If there are photons in both qumodes, then generally such an interaction results in entanglement, i.e. in a joint state between the two qumodes.

Now, we can look at the state space of qumodes. Let’s begin with a single qumode. Unlike qubits, the basis of a single qumode contains infinitely many states, since the qumode can contain an arbitrary number of photons. However in practice, a photonic processor will always be run with some states with afinite energy, meaning that there is a limit on the number photons that can be present (because making a photon costs energy).

Let’s assume for the sake of definiteness that we’ve set things up such that there is a fixed and finite number of photons in our qumodes. In that case, the only choice we have to make is how to out these photons among the qumodes. It turns out that if there are N qumodes and n photons, there are

number of ways in which we can do this. This is a very different answer than the one we got in the qubit case. This highlights and important difference between qumodes and qubits: the way their state spaces are structured is completely different. A simple counting argument shows that there isn’t a one-to-one equivalence between qumodes and qubits.

**So there you have it: one of the essential ways in which qumodes and qubits are different is in the structure of their state spaces. In the next installment,we’ll continue this discussion.**

Stay up to date

Oops! Something went wrong while submitting the form.