In order to effectively discuss quantum computers, here is a quantum cheat sheet that explains most main concepts.

A quantum system

Imagine we received a package with a quantum system inside. We unpack it. We don’t yet understand what it is, but we got it in our hands. We can study it. What we, curious minds, want to do, is to describe it.

First, we notice that it consists of individual units called qudits (yes, quDits). Qudits have states that we can measure. After playing with a bunch of qudits for some time we infer that:

• a qudit measurement can only give n possible values
• measuring seemingly identical qudits at the same time may give different results:
  • at certain times, we get the same state from many qudits - they all behave the same way
  • at other times, the measurement outcome seems completely random

After measuring qudits many times, we get some data that contains:

• time of the measurement
• qudit id (we enumerated them)
• measurement outcome

For any given moment in time, we can compute the probability of getting a certain measurement outcome.

We keep playing with qudits, keep deriving some rules. Eventually we notice that qudits described like that behave following the rules of vector algebra in an n-dimensional Hilbert space. We are very good with math, apparently.

We also notice that the math itself doesn’t change for different n, only the numbers. If n = 2, we call qudits qubits. That is what we use to build quantum computers.

Qubits

A qubit is a quantum bit. When measured, it can be found in one of two possible states: ground (zero) or excited (one).

When we prepare the system, we put the qubits in the init state. Usually it is the ground state. Then we perform some computations using qubits and then we measure and then determine what it means. Until we measure, we don’t exactly know the qubit’s state, it is like tasting food we are cooking: you never know if it is gonna be too much or too little salt. In classical systems, you can measure anything at all times. The soup stays too salty no matter how many times you try it, damn it. In a quantum system, measuring gives you the value of the measured qubit and also messes everything up. So we got to be careful.

How do measurement outcomes relate to the state before measurement?

The way it works is that at any given time, if we measure a qubit, we will get either ground or excited state. But the act of measurement kinda creates this state. And before we measure, something very non-classical is happening.

Wave function

Imagine that on the shoulders of the qubit, there is an angel and a demon. The angel thinks that the ground, relaxed state is better. The demon thinks that agitated, excited state is better. And they are actually fighting to prove a point. At any moment, one of them is winning. If one of them wins, then all measurements will always give us the state the winner was fighting for. But if we measure before the fight is over, the measurement outcome is unknown, but we know that the closer to winning a fighter is, the more likely we measure their preferred state.

Now, the fight is actually..staged. The angel and demon just move following the script they wrote together. The script is called a wave function.

Decoherence

Anyway, qubits are not actually qubits at all times. When we put a qubit in the init state, it is quantum and everything is good. But from that moment on, a classical timer starts ticking. Interaction with the environment makes qubits slowly turn into a non-quantum pumpkin that has no quantum properties.

After that, we need to make it quantum again until it once again turns into a pumpkin. The amount of time it takes a fresh qubit to turn into a pumpkin is called decoherence time.

We care about decoherence time because it breaks everything. Imagine running some program. You have some internal state, but this state slowly changes into something random?? This is not a way to perform reliable computations. So we need to make sure that whatever operations we perform on qubits, they are much faster than decoherence time. That will allow us to run a chunk of computation and get the results before it is pumpkin time.

Quantum computing

The operations we perform on qubits we do with the help of quantum gates. It is the same idea as in classical computers: we have a fixed set of tiny circuits that we use as building blocks for big diverse circuits.

To summarize, quantum computers allow us performing computations. We represent the desired computations as quantum circuits, which consist of quantum gates. We init the qubits and perform operations on qubits using quantum gates before decoherence causes decay of the state, and measure the state of some qubits at the end to get the result.

What is a bit?

A bit, or a classical bit, is a unit of information. We can think of bits as a yes/no answer to some question. We can combine these simple answers to answer more complex questions or infer answers to simpler questions from the answers to more complex ones. This will be boolean logic, which is a subfield of discrete math.

Boolean gates are little devices that perform boolean operations. Arranging boolean gates together results in all kinds of boolean circuits and enables classical computing.

Let’s get physical

How do we turn this abstraction into something real? What is happening inside computers?Which part of the abstraction do we implement?

We implement boolean gates - they are the building blocks of the circuits.

Boolean gates are made of transistors connected to each other in a specific way. There are multiple kinds of transistors but they all work similarly. A transistor is a piece of silicon that is split into layers. Different layers are infused with different atoms, kinda like vanilla and chocolate ice cream layered next to each other. Layering silicon infused with different kinds of atoms enables the physical functions of a transistor. Here is how it works: it is connected to a power source and also has an input and output, three “legs” in total (think of a three-legged silicon spider). If the signal on the input is high enough, the power is flowing through the output ¹.

Connecting transistors in different ways implements different boolean logics and different gates. Bits themselves here are represented by the signal on the wires, high or low voltage level.

Note that this representation applies to computation. For storage, bits are represented differently.

What is a qubit?

A qubit - a quantum bit - is also a unit of information. Measuring a bit can only give one or zero, measuring a qubit can only result in excited or ground state.

A system of bits is modeled as a boolean space with boolean logic rules. A system of qubits is mathematically modeled as a Hilbert space with linear algebra rules.

Instead of boolean gates we have quantum gates, instead of classical circuits we have quantum circuits, and instead of classical computing we have quantum computing.

Instead of classical physics rules, physical qubits follow the rules of quantum mechanics.

Let’s get physical, but make it quantum

Classical gates are implemented with transistors. For quantum gates, there are multiple options: trapped ions, superconducting circuits, photons, etc. There are so many options for a quantum computer because a proper quantum computer doesn’t really exist yet and there is no clear winner. Before we started using transistors for classical computers, other technologies for implementing classical gates were used too.

The difference

So far, we see a clear analogy, but if it was just that, there would be no need in quantum computers. What is the difference?

Superposition

Let’s look into a quantum system and follow what is happening to a qubit’s state. We can split the state lifecycle into parts each of which has two phases:

1. pre-measurement
2. measurement

Measurement in a quantum system doesn’t just show the existing value we didn’t see before, it creates a value. It has to create a value, because there simply was no value before. The qubit was in a superposition state.

Superposition state is not a classical state. It can never be a measurement outcome, it only exists in pre-measurement world.

People often say that superposition state is when the qubit is in both states at once - superposition. I find this interpretation confusing. I like to think of the superposition state as a space of opportunities for the future measured state outcome.

Mathematically, a measurement outcome is a basis state (eigenvector of the measurement operator) - either ground or excited. The superposition state is described as a sum of the two basis states and coefficients standing before them. The coefficients are also not constant, they form a wave function that has different values at different times (angels and demons fighting, remember?). They also can be used to compute the probabilities of getting basis states if we were to measure the qubit in that moment.

Anyway, this property of a qubit - being in a superposition state - is something that makes quantum computing interesting for us.

Entanglement

Entanglement is another property of a quantum system that we are interested in. It is pretty easy to explain: two qubits are related in a way that when we measure one, we learn the value of the other automatically, no matter how far they are physically.

Mathematically it means that we cannot describe the state of one qubit without involving the state of the other qubit. It is like there is a term of the form xy in the equation (where x is a part of the state of one qubit and y is a part of the state of the other qubit).

Conclusion

Quantum computers are modelled after classical computers. We use binary values as the units of information and gates as building blocks. The differences between classical and quantum phenomenons - superposition and entanglement among them - is what makes quantum computers offer unique properties.

Creating a working scallable architecture for a quantum computer is a work in progress and there are multiple approaches being explored. In this post I try to describe the structure of quantum computers more generally and explore two approaches for building quantum computers.

The structure

I identified three functional components that make a quantum computer:

• quantum core - responsible for the quantum magic
• reinforcement layer - makes the core stable and reliable
• classical cortex - that is how we ask the quantum wizzard to do us a quantum favour - provides input and interprets the output

The boundaries might be a bit fuzzy in practice, but I find this structure helpful for easier understanding of the system.

Quantum core

Quantum core is the defining component of the architecture as it dictates what the reinforcement layer and classical cortex work with and constraints the ways they can work together.

“Figuring out” the quantum core of the quantum computer involves the following aspects:

• phyiscal:
  • qubit implementation - this is the defining aspect of the defining component - quantum core - so it is suuuuper defining. Basically it is about the physical system that will be called a qubit in our computer. Naturally, we are picking from the systems that do have quantum properties, such as trapped ions, superconducting circuits, etc. The choice of the qubit implementation tells us how to perform the measurement, what kind of isolation it requires and what should be optimized for.
  • qubit manipulation - it is about how to poke a qubit when you want it to do something. These “something” can be measurement, putting it in the init state, etc.
  • qubit connection - how we connect the qubits together to enable multi-qubit computations without too much noise ruining everything
• algorithmic:
  • measurement and initialization - are the abstract algorithms that use qubit manipulation to measure the qubit state or to put it in a defined state

A list of criteria that defines what makes a proper quantum core is called DiVincenzo criteria. Here is my free interpretation of the list:

• clear qubit definition
• scalability without a significant loss of quantum properties
• ability to initialize the state
• ability to measure
• long enough coherence times
• a defined set of quantum gates that allows building any circuit

There are also two criteria for quantum communication specifically, but I’ll skip those here.

Reinforcement layer

The reinforcement layer is all about making the system stable:

• physical isolation - how to keep qubits noise free, increase the duration of the coherence period, keep qubits from affecting each other unintentionally, etc
• error correction - given that the quantum system is fragile and expensive, we would like to increase the fidelity of the system

Classical cortex

The classical cortex aspects include:

• control system that we use to direct the computer into doing what we want. It includes the electronic part - how do we literally connect classical and non-classical pieces together
• interpretation software - we need a system that translates our lowly questions into something the quantum sage can understand and then translate the wise quantum words back

Exploring the real architectures

Now let’s take a look at two approaches for building quantum computers. We will consider it from the perspective of the suuuuperdefining component - qubit implementation.

Architecture II: Trapped ions

Ions are atoms that lost some electrons. We know that atoms are neutral: the nucleus is positively charged, and electrons balance it out by their negative charge. Removing some electrons leaves a positively charged ion.

Because ions are charged, we can use electric field to control the position of an ion so that it doesn’t fly away. That is why this approach is called trapped.

Encoding qubits and states

One ion corresponds to one qubit. The excited and ground state of a qubit are encoded by an electron either being on a lower or higher energy level. Think of it as of a set of stairs - the higher up you are, the more energy you have. Electrons prefer to be on a lower step of the stairs.

We can manipulate such qubits by shooting some energy at them (using photons) and push them to a higher energy level. They eventually fall back to the lower level and release the energy back - decoherence.

Measurement

A qubit in any state can absorb or emit energy. When it absorbs energy, its electron jumps up the stairs. When it emits energy, the electron jumps down the stairs. It takes different amount of energy to jump between different steps, and the qubit will only absorb the exact amount of energy that it can use to jump somewhere (no energy leftovers).

This is the phenomenon we are basing the measurement strategy on:

1. shoot the amount of energy it takes to jump from ground to excited state
2. if the energy is absorbed, the qubit was in the ground state
3. if it is sent back, it is in the excited state (assuming the system is coherent)

Reinforcement

Trapped-ion-based qubits are small and the more we have, the bigger the negative effects are. We need to keep them cool to have less noise and make the little devils move slower. The more qubits we have, the more different frequencies we need, and, well, eventually it becomes hard to maintain. Photons we use for qubit manipulation can escape, meaning we might miss the cue and they can disturb the system.

Fun facts

Commonly used ions include barium, calcium, beryllium, strontium, and ytterbium. Ytterbium has higher coherehce times, and barium can be manipulated with photons from the visible spectrum.

Architecture II: Superconducting circuits

First things first: what is a superconductor?

Imagine an atom. It has electrons that are stuck to the atom and tearing them off takes some energy. The less energy it takes to take them off, the more conducting the material is. Naturally, there are isolators (very hard to tear off), semiconductors (somewhat hard to tear off), conductors (quite easy). Unnaturally - in very low temperatures - some materials have infinite conductivity. These are called superconductors.

All kinds of materials (compound and pure) can act as superconductors, but for quantum computers most common choices are metals like aluminum and niobium.

Now, what is a circuit? Just a regular classical circuit like in regular classical computers, but with wires made of superconductors. Well, of course we can’t use just any circuit, but the word circuit here means that.

Superconducting circuits seem like the most unusual qubit implementation to me because compared to other choices (ions, photons, etc) they are GIGANTIC. And because most (all?) other implementations are particles, people look at the superconducting circuits in a similar way - sometimes they are called artificial atoms.

Encoding

The superconducting circuit that corresponds to a single qubit is called a transmon. Such circuits contain capacitors and inductors - elements that don’t produce almost any heat - and an element called Josephson junction that makes the energy levels uneven, so we can define the ground and excited states like in atoms.

Such qubits are manipulated using light as well. Transmons require way lower frequencies compared to ions, so we use microwave generators instead of lasers (that we use for ions) to do that.

Measurement

We use resonators to detect changes in the system. A resonator is a device that responds only to specific frequencies of the light. The resonant frequency - the frequency a resonator responds to - changes slightly depending on what state the qubit is in (the qubit and resonator are physically connected), so we can measure the qubit state by measuring the resonator state.

Reinforcement

First, we need really low temperatures for our system to work, and unlike other systems, it isn’t just to make it more stable and less noisy. Superconductivity only happens at low temperatures, so we need it to have any quantum properties at all.

Similarly to the trapped ion situation, the more qubits we connect, the harder it is to control the system, and after a certain limit everything is fucked up completely. Puffff.

Also, because these qubits are GIGANTIC, the decoherence times are LOW, so..we gotta be fast.

And we also need to protect the system from the noise like always.

“Every human being on this planet is obligated to do their best to leave this planet in better shape than we found it. Everyone on the planet is obligated to respect every other human being on this planet.”

I can’t really agree with this. Why are they obligated?

I think people who make such statements are really trying to say “I’m scared of what happens if the majority acts differently. People will start killing each other, the planet will die soon, and it scares me”.

I can totally relate to the sentiment. It scares me too. I want people to respect each other, I want people to respect me. I want people to do no harm to each other and I want people to do no harm to me.

We’ve collectively encoded some of these values into law: don’t kill, don’t steal, don’t harm. That is good. But the fact that we chose these rules doesn’t make them objectively right, they are just our shared preferences. We could have chosen differently. We don’t always choose well.

So when someone says we’re ‘obligated’ to act a certain way, they’re treating it as self-evident. If your position is better, prove it.

And if you don’t want to prove anything, it is fine. Just acknowledge you’re speaking to people who already share your values. Most people who pick up the book probably already do.