Every computation (regardless of it being quantum or classical) is useless unless we can store and access its results somehow. There are many different ways of storing computational results, but the one closest to the computation itself is a register. A quantum register is a concept in quantum computing that serves a similar purpose to a classical computer’s register, which stores and manipulates binary data (bits). However, instead of storing bits (which can be either 0 or 1), a quantum register holds quantum bits, or qubits. Those (qu)bits are called a register state.

The state is first injected into a register in a process called initialisation. It is nothing else but writing starting values for every qubit (since we are going to talk about quantum registers in this post, I will focus only on qubits from now on) that is present in the register. That is called an initial state. Then every operation on those qubits (implemented with one or more quantum gates) changes the state of the register.

Quantum registers and quantum gates are essentially matrices with complex numbers in them. Many people find them quite difficult to understand and use. The complexity can be somewhat masked by using real numbers instead (it works for a surprising number of cases), but it is still there. However, there is a way to picture the state of a quantum register with something conceptually much simpler. It is the circle notation introduced by Eric Johnston and co-authors in the book titled “Programming Quantum Computers” (O’Reilly, 2019). It is what I will cover in this article. I will accompany it with mathematical and code examples, so you can get a better grasp on the elegantly informative value it provides.

Superposition

Superposition is one of the most famous concepts that went from the quantum computing jargon to the everyday language. You can read more about it in my article about the standard bases if you are interested. In short, it is a quantum state that encodes bits (yes, bits) 0 and 1 with equal probabilistic distribution. We can create it by using a Hadamard gate. In this post I use Qiskit to demonstrate operations on a quantum register. All the code is written using this framework.

from qiskit import QuantumCircuit

circuit = QuantumCircuit(1, 1)
circuit.initialize([1, 0], 0)
circuit.h(0)

In the code above, I created a quantum circuit with one qubit, and one bit (forming respectively a quantum and a classical register). I initialised then the qubit to |0⟩ (zero-ket) which is encoded in Qiskit as [1, 0]. Finally, I applied a Hadamard gate to the first qubit in the register. Qubits are indexed in Qiskit starting from 0 as in most programming frameworks.

Mathematically, this circuit looks like this:

I we expand the Hadamard gate to a matrix, we will get this result

This is the initial state for that particular circuit. If you have never done anything with matrices and linear algebra, then even such a simple example may feel intimidating (it surely was to me in the beginning). However, we can use the circle notation to help us understand what’s happening under the hood.

In the circle notation, every possible quantum register state has a circle assigned to it. Since we are computing with a superposition of one qubit, we can have the register only in two possible states: |0⟩ and |1⟩.

Right now, the circles are empty (and not very helpful). But we will fill them with state soon enough.

The circle notation allows us to work with magnitude (how likely a given result is to be yield) and relative phase (you can think of it as a distance between quantum states – at least for now). We will cover the relative phase soon enough, but Let’s focus on the magnitude first. 

Before we apply the Hadamard gate, the state of our register looks like the following.

We will read |0⟩ with probability equal to 1 and |1⟩ with probability equal to 0. Let’s apply the Hadamard gate, and see how it changes our register.

The 2 is the denominator for both possible ket outcomes, is called the probability amplitude. In order to get the probability, you have to calculate the square root of it. In our case, it’s 1/2 for both values. What does it look like in the circle notation then?

After applying the gate, we have two light purple circles filling out both states. It means that they have equal magnitudes, resulting in equal probability of being read out. And indeed, if we add the following line to our program:

circuit.measure(0, 0)

we will randomly get 0 or 1.

Phase

I have already mentioned that you can utilise a concept called a relative phase in quantum computing. The relative phase refers to the difference in phase between two quantum states. In a superposition of states, these phases can be either identical or different. The relative phase plays a crucial role in quantum interference phenomena and is fundamental for many quantum algorithms. It essentially determines how the combined state evolves over time, affecting the outcome of measurements performed on the system.

In general, it is a fairly complicated concept which I will not cover in full detail in this article. However, I will demonstrate how it is represented in the circle notation.

from qiskit import QuantumCircuit

circuit = QuantumCircuit(1, 1)
circuit.initialize([1, 0], 0)
circuit.p(math.pi/2, 0) # Rotation by 90 degrees.
circuit.measure(0, 0)

This circuit is almost identical to the one where we used a superposition. However, this time we rotate the relative phase by 90°.

Again, we initialise our qubit to |0⟩, and apply the P(𝜃) gate to it, with 𝜃 = 𝝿/2. This is how this operation looks mathematically.

And in the circle notation.

As you can see, we have a new element in the notation – a horizontal line starting from the middle of the circle and pointing at 12 o’clock. It represents the relative phase which the quantum register is in. Let’s see what happens to the register then the gate is applied. First, a bit of linear algebra, if we may.

Now it is time for the circle notation.

The relative phase was rotated by 90° differentiating the two possible states of the register. It is reflected in the circle assigned to |1⟩.

You may wonder what the means. The ei𝜃 is the phase rotated by the angled described with 𝜃. However, this value is not readable. Hence, this matrix is read as |0⟩. There are techniques that allow to change whatever was computed using phase into a readable result (magnitude, in other words), but they are beyond the scope of this post.

Conclusion

In conclusion, quantum registers and their states play a crucial role in quantum computing, serving as the counterpart to classical computer registers. Instead of storing bits, these quantum registers store qubits, which can exist in superposition, encompassing both 0 and 1 with equal probability. The circle notation introduced by Eric Johnston and the colleagues simplified understanding of these states by representing magnitude and relative phase. This notation allows us to visualize the evolution of a register’s state after applying quantum gates like Hadamard or rotation gates. As demonstrated through Qiskit code examples, this circle notation helps in comprehending quantum computing concepts, making it an essential tool for researchers and enthusiasts alike.