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.

One of the most basic concepts in modern days quantum computing is a quantum circuit. It is essentially the second thing most quantum computing students learn after getting familiar with a qubit is the quantum circuit. Though the initial circuits (resembling “Hello World!” examples from other computer science fields) seem to be fairly simple, the subject is actually quite complex. In this blog post I cover the essentials of circuit notation: what it is, what are the principles and conventions used when plotting them. I also focus on the most popular quantum computing framework by far – Qiskit – for reasons that I will explain later.

In essentials, circuits are models of computation in which information is carried by wires through a network of gates, which represent operations on the information that is being carried. Quantum circuits are a specific model of computation based on this more general concept. If this definition seems to be too abstract for you, you can think of circuits as graphs where nodes are gates and edges are wires. 

The concept itself comes from the field of electric engineering. Basically, classical circuits are no different from electric ones, since they follow exactly the same principals. The only difference is that computing circuits (regardless being classical or quantum) are rarely cyclic, and they usually represent a finite sequence of operations that does not permit a loop. Quantum circuits operate on completely different physical laws, but the concept itself is as described above.

Circuits can be boolean or arithmetic. Boolean circuits are used to compute logical values (true and false) for predicates, whereas arithmetic circuits are used to do maths. Fun fact, it can be also done with the boolean circuits, but is highly inefficient. 

Circuit Diagrams

In the quantum circuit model, wires represent qubits. Wires are plotted as horizontal lines stretching from left to right, usually denoted with some sort of a qubit’s identifier (q for example). 

Gates represent operations on these qubits. They are usually drawn as squares of different colouring with letters distinguishing their type. There are exceptions depending on what gate is used in a given circuit. The operations they represent can be a computation or a measurement. 

Below is a diagram of a sample circuit.

In the diagram, you can see one qubit (q) represented with a wire (the horizontal line), and one gate (the dark blue square with X) representing a computation. In this case it is a boolean negation implemented with a NOT (X) gate. You can read more about this gate here if you are unfamiliar with it.

Quantum computations must be eventually measured in order to make some use of them. After all, if we applied only computation steps, we would never know what we actually computed.

A measurement is represented in a diagram with a gray square with a control on it. It always must be accompanied by a double horizontal line representing a classical register. The classical register in quantum computing is used to store results of the computations in a form that is understandable by classical computers that oversee QPUs (Quantum Processing Units). Let’s take a look at an example.

Here, the measurement operation is represented with the grey square with a control, and the bit is represented with a double horizontal line (annotated c). Transfer of a state between a quantum and a classical register is drawn with a double line arrow.

Circuit Depth and Width

As you may intuitively think, circuits may vary in size. In fact, there are two parameters that describe it: width and depth.

Quantum circuit width refers to the number of qubits actively involved in a quantum circuit. In other words, it determines the size of the quantum state being manipulated. For example, a circuit acting on two qubits has a width of two like in the following diagram.

Here we have two qubits (q₀ and q₁) that are being used simultaneously in a computation (represented with a CNOT gate).

It is important to remember that even if some qubits are idle during certain operations, their presence contributes to the overall circuit width.

The other circuit’s parameter – quantum circuit depth – refers to the number of quantum gates used at a particular step or layer of a quantum circuit. To put it more formally, it relates to the computational parallelism or the number of simultaneous operations being performed in the circuit.

Let’s see it in an example. In the following diagram, there are two gates acting on two different qubits (q₀ and q₁) simultaneously, so the depth of the circuit at that layer is two.

Width and depth are independent values, though depth can never exceed the overall width of the circuit. Moreover, it is important to remember that while depth is measured for a given part of the circuit, the width is a global value of all the qubits constituting the given circuit.

Qubits Ordering

I have already hinted this in the introduction. Every quantum programming framework has its own convention of drawing quantum diagrams and ordering qubits in them. I use almost exclusively Qiskit, since it is by far the most popular programming framework for QPUs, as well as having really great learning resources. Therefore, I will explain in this post its respective convention.

In Qiskit, the topmost qubit in a circuit diagram has index 0, and corresponds to the rightmost position in a tuple of qubits. The second-from-top qubit has index 1, and corresponds to the position second-from-right in a tuple, and so on, down to the bottommost qubit, which has the highest index, and corresponds to the leftmost position in a tuple.

In particular, Qiskit’s default names for the qubits in an n-qubit circuit are represented by the n-tuple (q_n−1, …, q₀), with q₀ being the qubit on the top and q_n−1 on the bottom in quantum circuit diagrams.

This convention leads to confusing situations, since it is also reflected in memory arrays that store results of computations. You can read more about it in my post about endianness in Qiskit.

Plotting a Circuit

There is one final thing that must be covered before concluding. How can you get such nice quantum diagrams? In truth, plotting a circuit is fairly easy with Jupyter notebooks and Qiskit.

First, you have to define a circuit using Qiskit’s circuit API. Then, you can call the draw method to plot the circuit. It accepts an optional argument that defines what library is used to do the plotting. One of the most popular ones is the Matplotlib, which can be chosen by passing the ”mpl” string as an argument.

Here’s an example of a simple circuit and code that plots it with the Matplotlib library.

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

register_qubits = 1
register_bits = 1

quantum_register = QuantumRegister(register_qubits, "q")
classical_register = ClassicalRegister(register_bits, "c")

circuit = QuantumCircuit(quantum_register, classical_register)
circuit.h(quantum_register[0])
circuit.x(quantum_register[0])
circuit.measure(quantum_register, classical_register)

circuit.draw("mpl")

And the resulting diagram. Viola!

Conclusion

Circuits are models of computation in which information is carried by wires through a network of gates, which represent operations on the information carried by the wires. In quantum circuits, qubits are equivalent to wires, and operations on them to quantum gates.

The amount of qubits that are being used in a given circuit is called circuit’s width. The number of gates that are being applied parallel to one or more qubits in a given step is called circuit’s depth. 

Qubit ordering depends on the computational framework you use. In Qiskit, the topmost qubit in a circuit diagram has index 0, and corresponds to the rightmost position in a tuple of qubits. The bottommost qubit, which has the highest index, and corresponds to the leftmost position in a tuple.

A picture is worth a thousand words, and the same holds true with quantum circuits. The easiest way to plot a circuit is to define it programmatically, and then use the Matplotlib library to get the drawing.

I hope that this post puts an understandable picture on the somewhat complicated concept of quantum circuits, and they will become easier to reason with.

Almost everyone starts learning quantum computing using single quantum systems (i.e. with just one qubit). However, soon enough we switch to multiple quantum systems (with two or more qubits) in our pursuit of knowledge about gates and algorithms. One of the first things we learn then are two-qubit gates, like the collection of controlled gates (ex. CNOT) or the SWAP gate.

This is usually the moment when you may get confused with Qiskit’s behaviour. You take a two-qubit gate like the SWAP gate, you apply it to |01⟩ for example, and in the results you see that nothing was swapped. In reality the gate worked as expected, and the confusion is rooted in the way Qiskit stores its state in memory. 

Why is this happening? Let us start with implementing a program that can demonstrate this oddity. 

Swapping Qubits’ States

There are many ways of changing the state of a two-qubit quantum system. I have already mentioned controlled gates which I believe are the most popular gates in quantum circuits nowadays. However, in this post I would like to use a simple example with a SWAP gate. This gate works in a very intuitive way, and is easy to understand even without robust quantum computing or computing in general knowledge. 

The SWAP gate works in a pretty straightforward way: it swaps the values of two qubits. How does it exactly work? Every quantum gate can be represented with a unitary matrix. What a unitary matrix is is beyond the scope of this post. If you are nonetheless interested, I can tell for starters that it is a complex square matrix that, when multiplied by its conjugate transpose, results in the identity matrix. You can read more about unitary matrices here. 

Without going into further details, here’s the matrix for the SWAP gate. 

In order to apply it to a two qubits quantum system we have to multiply it by the matrix representing that system.

In short, two-qubit quantum systems are represented by a single column matrix that corresponds to every possible combination of those systems. You can see them all below.

(If you don’t know what these numbers are, please read my earlier blog post.)

When you apply this matrix to a ket, it simply swaps the second the the third coefficients. So in general:

(If you do not know what kets are, you can read about them here.)

The SWAP Gate in Action 

In order to use the SWAP gate in our example, we must write a circuit that uses it. We start off with importing all necessary dependencies.

from itertools import product
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit_aer import Aer

Then, we define a set of variables that we’ll use later in the program.

register_qubits = 2
register_bits = 2
zero_ket = [1, 0]
one_ket = [0, 1]
# Generate all possible combinations of zero_ket and one_ket
ket_combinations = list(product([zero_ket, one_ket], repeat=2))
first_qubit = 0
second_qubit = 1
shots = 100

Their purpose will come clear when they’re used later in the code.

As I mentioned before, we can have four different combinations of two basic computational states: |0⟩ and |1⟩. Just as a reminder, they’re |00⟩, |01⟩, |10⟩ and |11⟩. In order to fully demonstrate what the SWAP gate does, we have to take a look at all of those combinations. We created them on line 9 of this program:

ket_combinations = list(product([zero_ket, one_ket], repeat=2))

This line essentially combines |0⟩ and |1⟩ into a collection of |00⟩, |01⟩, |10⟩ and |11⟩. We can then iterate over these combinations.

for ket_combination in ket_combinations:

The actual circuit is created and run within the loop. I will not go into details here, but please read what quantum circuits are and quantum simulators are if you would like to know more.

    quantum_register = QuantumRegister(register_qubits, "q")
    classical_register = ClassicalRegister(register_bits, "c")
    circuit = QuantumCircuit(quantum_register, classical_register)
    circuit.initialize(ket_combination[0], first_qubit)
    circuit.initialize(ket_combination[1], second_qubit)
    circuit.swap(quantum_register[first_qubit], quantum_register[second_qubit])
    circuit.measure(quantum_register, classical_register)

    simulator = Aer.get_backend("qasm_simulator")
    transpiled_circuit = transpile(circuit, simulator)
    result = simulator.run(transpiled_circuit, shots=shots).result()
    print(f"For the first qubit {ket_combination[0]} and the second qubit {ket_combination[1]} the SWAP result is: {result.get_counts(circuit)}")

First off, we create a quantum and a classical register on lines 14 and 15. You can think of those registers as processor’s stack memory, the one that’s closest to it. The quantum register is used for storing qubits’ states, whereas the classical register is used for storing the values that are read out during measurement.

Then we implement the actual circuit (lines 16-20).

circuit = QuantumCircuit(quantum_register, classical_register)
circuit.initialize(ket_combination[0], first_qubit)
circuit.initialize(ket_combination[1], second_qubit)
circuit.swap(quantum_register[first_qubit], quantum_register[second_qubit])
circuit.measure(quantum_register, classical_register)

We define the circuit object by calling the QuantumCircuit(quantum_register, classical_register) constructor.

We then initialise our two qubits with whatever kets we have in a given loop iteration.

circuit.initialize(ket_combination[0], first_qubit)
circuit.initialize(ket_combination[1], second_qubit)

Finally, we apply the SWAP gate…

circuit.swap(quantum_register[first_qubit], quantum_register[second_qubit])

…and measure.

circuit.measure(quantum_register, classical_register)

If you plotted this circuit with the following line of code – circuit.draw(output=’mpl’) – you’d get this diagram.

(I’ll cover circuit diagrams in one of the future blog posts.)

It represent the following quantum operation: SWAP|00⟩.

Run the program, and you’ll get the following results.

For the first qubit [1, 0] and the second qubit [1, 0] the SWAP result is: {'00': 100}
For the first qubit [1, 0] and the second qubit [0, 1] the SWAP result is: {'01': 100}
For the first qubit [0, 1] and the second qubit [1, 0] the SWAP result is: {'10': 100}
For the first qubit [0, 1] and the second qubit [0, 1] the SWAP result is: {'11': 100}

The number 100 is the number of times a given circuit was run (it’s important in a non-one probability readout like in this example).

[1, 0] is a row matrix that can be also written as |0⟩, and [0, 1] is a row matrix that can be written as |1⟩. So reading the results as they are yields this:

• |00⟩ → {’00’: 100}
• |01⟩ → {’01’: 100}
• |10⟩ → {’10’: 100}
• |11⟩ → {’11’: 100}

It looks like this program doesn’t work at all! But it does. The confusion lies in the way Qiskit stores values internally. It uses little endian.

Little Endian

What is little endian, or endianness in general? Endianness is the order in which bytes within a word of digital data are transmitted over a data communication medium or addressed (by rising addresses) in computer memory, counting only byte significance compared to earliness. The name is taken from the novel Gulliver’s Travels. You can read more about it here.

It sure sounds complicated, but in simpler words, endianness determines from which end of memory space the bytes are ordered. There are two types of endianness: the big endian and the little endian.

• A big-endian system stores the most significant byte of a word at the smallest memory address and the least significant byte at the largest.
• A little-endian system, in contrast, stores the least-significant byte at the smallest address.

Big endian is thus closer to the way the digits of numbers are written left-to-right in English, comparing digits to bytes. Little endian, on the other hand, reverses the natural ordering of the bits.

Here is a visual representation of these two systems.

Source: https://en.wikipedia.org/wiki/Endianness#/media/File:32bit-Endianess.svg 

In the above example you can clearly see that while the big-endian preserves the natural ordering of a given processor word (or any binary value in general), the little-endian essentially reverses it. And this is the case with Qiskit. It uses internally little-endian to store quantum processing results, and hence prints them accordingly. For two-qubit systems it maps to the following list.

Getting the Big-endian Result

It is possible in Qiskit to change the ordering of the qubits from little-endian to big-endian. However, it is quite limited. For example, it can be easily done for circuit drawings with the reverse_bits() function. Unfortunately, it looks like switching to big-endian for the Result object that we use to query for whatever we computed is not supported.

Conclusion

Interpreting results obtained from quantum circuits in Qiskit can be challenging. This is due to the fact that Qiskit uses little-endian to store computation results. It stores the least significant bit (the right-hand most) in the first memory index, and the rest of the bits follow. The result is hence a reverse of natural ordering that we expect in ket representations of quantum systems and can be confusing for new and experienced users.

In the previous article, I covered the Bloch sphere, one of the most helpful visual tools for understanding qubits. The Bloch sphere allows us to represent a qubit’s state as a point in three-dimensional space. While this point represents the qubit’s state, it’s often even more useful to consider its position in relation to one of the three primary axes on the sphere – x, y, and z. These axes are not arbitrary; each one is linked to a unique set of orthonormal basis vectors, commonly referred to as computational bases.

In quantum computing, a computational basis provides a standardised framework to measure or affect a qubit’s state. If you’re unfamiliar with the term “orthonormal basis vectors,” consider reviewing this helpful Wikipedia page on orthonormality. These bases are “computational” because they lay the groundwork for every computation we perform in quantum computing.

While any set of orthonormal basis vectors could theoretically serve as computational bases in quantum computing, there are three primary ones that are used most frequently: the computational basis, the Hadamard basis, and the circular basis. Each of these serves a distinct purpose in interpreting and manipulating qubit states.

The Computational Basis

The computational basis, aligned with the z-axis of the Bloch sphere, is the foundation of quantum measurement. It’s the most common basis for reading the results of quantum computations because it directly corresponds to binary classical states, making it easier to translate quantum states into familiar classical outputs. The computational basis consists of two column vectors and , often written in Dirac notation as |0⟩ and |1⟩. These two states represent the “north” and “south” poles of the Bloch sphere, and they correspond to the conventional binary states, 0 and 1. When a qubit is measured in this basis, it “collapses” to one of these two poles, giving us a straightforward binary result.

The Hadamard Basis

Next, the Hadamard basis is associated with the x-axis of the Bloch sphere, which represents a state along the sphere’s equator rather than at its poles. This basis is one of the most powerful tools in quantum computing because it allows us to use any real number as a qubit’s state, not just the discrete values of 0 or 1. For a deeper dive into why this is significant, check out my article on quantum vs classical computing. The Hadamard basis enables superdense coding, a technique that leverages quantum superposition to represent classical bits in more complex ways. 

The Hadamard basis consists of two vectors and , denoted in Dirac notation as |+⟩ and |-⟩. These states lie along the equator of the Bloch sphere, representing the ability of qubits to exist in a superposition of 0 and 1 simultaneously. This property underlies many of quantum computing’s most promising applications, such as quantum parallelism, where the system explores multiple possibilities at once, and quantum encryption, where superpositions contribute to secure data encoding.

The Circular Basis

Finally, the circular basis aligns with the y-dimension of the Bloch sphere and introduces an essential concept called phase. In quantum mechanics, a qubit’s phase describes the relative angle or orientation of its wave function in its quantum state. This phase does not impact the probability of measuring the qubit in a particular state; rather, it influences how qubits interact with each other, particularly in superpositions and entangled states. 

This phase-based interference is foundational for many quantum algorithms and gate operations, such as the Hadamard gate and controlled-phase gates, which rely on phase manipulation to perform complex calculations. The circular basis uses two vectors and , usually written as |i⟩ and |-i⟩ in Dirac notation, to describe these states. This notation represents the relative phase of the qubit, allowing for fine-tuned control over quantum states and facilitating advanced computational processes like error correction and phase estimation.

Conclusion

Understanding the computational bases—computational, Hadamard, and circular—is essential for anyone delving into quantum computing. These bases provide different frameworks for interpreting and manipulating qubit states, whether through straightforward binary measurement, superposition, or phase manipulation.

Each basis has a unique role: the computational basis is the go-to for classical readouts, the Hadamard basis introduces superpositions that allow for more complex computations, and the circular basis enables control over phase, crucial for advanced algorithms and gate operations.

By mastering these foundations, we gain a toolkit to understand and perform quantum operations more effectively, unlocking the full potential of qubits for quantum computing tasks. Whether you’re analysing measurement outcomes or engineering interference patterns, these computational bases form the core of your journey through quantum mechanics and computation.

Preface

As a software engineer, I recently embarked on a journey to learn quantum computing. The experience has been both fascinating and frustrating, as I found it incredibly difficult to come across simple explanations for this complex field. In light of this, I decided to start a “Simple Quantum Computing” series. Through this series, I aim to demystify quantum computing for myself and for you, dear reader, as we explore what could very well be the most revolutionary computing technology of the 21st century.

Introduction

Quantum computing represents the bleeding edge of technology. As software engineers, it is one of the most advanced areas we can dive into. Its potential impact on the world is enormous, particularly when it comes to cryptography. Quantum computers have already shown that they can break modern cryptographic algorithms with relative ease.

Despite its prospect, quantum computing has not yet gained widespread popularity. Unlike artificial intelligence, which saw a surge in interest with the advent of models like ChatGPT, quantum computing remains a niche area. This is partly due to the limited job market demanding quantum skills, but it is also due to the steep learning curve associated with the technology.

So, why exactly is quantum computing so hard to understand?

Analog Computational Values

As software engineers, we are used to binary computational values—0s and 1s. These discrete values form the foundation of classical computing, with processor words built from them, and every computation within a CPU is based on these simple, binary states.

Quantum Processing Units (QPUs), however, operate on a completely different principle. They use analog, or continuous, values instead of discrete ones. There is no clear-cut 0 or 1 in quantum computing; instead, everything is represented by complex numbers that can take on any value between the quantum states |0⟩ and |1⟩. These states are known as kets, a concept I will delve into further in a later post.

This shift from binary to analog values presents a significant challenge. As developers, we are not trained to work with these continuous values. For example, there is no straightforward equivalent of a boolean in quantum computing—no simple 0 or 1 to latch onto.

Moreover, modern QPUs must be controlled by classical CPUs. This means that the analog values computed by a QPU have to be translated into discrete values for the CPU to process. This translation introduces a loss of information and a level of unpredictability, as the process is not deterministic. The notion of working with probabilities—something that quantum computing heavily relies on—is foreign to most of us in the field of computer science, where even pseudo-random numbers are not truly random.

Overall, the different computational bases and the need to convert between them add a significant layer of complexity that we are simply not accustomed to dealing with.

Complex Mathematics

Another major hurdle in understanding quantum computing is the complex mathematics involved. To grasp the concepts of quantum computing, one must be comfortable with advanced mathematical theories and methods that go beyond basic arithmetic or algebra.

Some of the key mathematical areas used in quantum computing include:

• Complex Numbers: One of the fundamental concepts is the extension of the real number system to include imaginary numbers. A complex number is expressed as a + bi, where a and b are real numbers, and i is the imaginary unit, satisfying i² = −1.
• Complex Analysis: This is the study of functions that operate on complex numbers. It includes topics such as analytic functions, complex integration, and conformal mappings.
• Abstract Algebra: This area involves the study of algebraic structures like groups, rings, and fields. These structures are used to generalise algebraic concepts and solve equations in more abstract settings.

While it is possible to create simpler mathematical models by abstracting parts of this complex mathematics, understanding the original concepts is still crucial, and may be difficult (definitely for me!).

Programming a Processing Unit

Beyond the challenge of analog values and complex mathematics, there is the task of actually programming quantum processing units. Programming modern QPUs is reminiscent of programming early CPUs in the 1950s. If you compare quantum programming frameworks like Qiskit to early high-level programming languages like Autocode, you will notice striking similarities.

Both require you to think in terms of bits (or qubits), registers, memory, and gates. It is a very low-level form of programming that most modern software engineers are unaccustomed to. We lack the high-level frameworks and abstractions that we are familiar with in classical computing, making it even harder to get started in quantum computing.

Conclusion

Quantum computing represents a paradigm shift in how we approach computation, challenging many of the fundamental principles that have guided software engineering for decades. The complexity of analog computational values, the necessity to grasp advanced mathematics, and the low-level nature of quantum programming make it a field that is difficult to understand and master. 

However, these very challenges are what make quantum computing so promising and exciting. Just as classical computing evolved from low-level machine code to high-level languages and user-friendly frameworks, quantum computing will likely undergo a similar evolution. We are simply not there yet.

In this post series – simple quantum computing – I plan to write about different aspects of quantum computing that I found difficult to learn, and do my best to explain them in much simpler terms. I hope it will help both me and you understand what I believe to be the most promising computational technology of the XXI century.