In the last episodes (check here), we explored different models of quantum computation. We saw that there is not just one way to build a quantum computer. There are circuit based models, measurement based models, and adiabatic or annealing based approaches. Remarkably, all of these are equivalent in what they can compute, at least in principle.

This naturally leads to a question that almost everyone asks at some point.

If we know how to build quantum computers, why do we not already have them?

There are many reasons, far too many to list in a single article. But there is one major roadblock that dominates almost every discussion in quantum computing today. Before we get to it, we need to understand a few essential ingredients.

As we discussed in episodes #2 and #3, classical computers (the computers we use today, such as smartphones and laptops, are called classical computers) work by encoding information as binary numbers, zeros and ones. Any complicated task you perform on your laptop, whether it is watching a video or running a simulation, is ultimately broken down into simple logical operations such as AND, OR, and NOT.

Quantum computers follow the same philosophy. Instead of classical bits, we use qubits. Instead of classical logic gates, we use quantum gates (learn about quantum gates here). And just like in classical computing, any complicated computation can be decomposed into a long sequence of simple, universal building blocks.

This idea is extremely powerful. It means that we do not need a special machine for every problem. We just need a small set of basic gates.

But there is a catch.

The smaller and simpler the building blocks are, the more of them we need.

A skyscraper is made of sand, steel, and concrete. Each piece is simple, but you need an enormous number of them to build something useful. Computation works the same way. To run a useful algorithm, whether classical or quantum, you typically need millions or even billions of gate operations.

Now imagine that every one of these gates is slightly noisy.

A noisy gate does not do exactly what we ask. It does something very close, but not perfect. This is best understood through a game many of us played as children, the telephone game. One person whispers a word to the next, who whispers it to the next, and so on. By the time the message reaches the last person, it often sounds nothing like the original.

This is exactly what happens when errors accumulate in a long computation. A small mistake early on can propagate and amplify as more gates are applied.

You can also imagine it like a painting that gradually changes color from left to right. Each step is only slightly different from the previous one, but after many steps, the final result looks completely different from where you started.

At this point, you might wonder why this is even a problem. When you use a classical computer, you get the same answer every time. Why should quantum computers be any different?

The reason is that quantum hardware is fundamentally fragile.

Most quantum computers today are built from objects at the atomic or sub atomic scale. These systems are extremely sensitive. When we apply a quantum gate, we are trying to control a single particle or a small quantum system with incredible precision.

Unfortunately, the world around us does not stay quiet. Tiny fluctuations in temperature, stray electric or magnetic fields, imperfect control pulses, or interactions with the environment can all disturb the quantum state. Even the act of isolating a quantum system perfectly is already a major engineering challenge.

To understand how serious this challenge is, we need numbers.

Modern classical computers are astonishingly reliable. Their effective error rates are so low, that you can have tens or hundreds of billions of operations without any errors.

Quantum computers today live in a very specific regime, often referred to as the NISQ era, short for Noisy Intermediate Scale Quantum. This term was introduced by John Preskill to emphasize that present day quantum devices sit in an uncomfortable middle ground.

All quantum computers available today, including those developed by companies such as IBM, Google, and Quantinuum, fall within this NISQ category. This means that if you apply about a thousand quantum gates, you should already expect something to go wrong (track these numbers as well, not just the number of qubits, to understand how good their computers are).

With a thousand gates, you can do very little. Most interesting quantum algorithms require circuits that are far deeper, often involving millions or billions of logical gate operations.

This is the central obstacle.

Errors accumulate, and without some way to control them, long quantum computations become impossible.

So the real question is not whether quantum computers make errors. We already know they do.

The answer, at least in theory, is yes. This is the subject of a subfield known as Quantum Error Correction (QEC).

This is a deep and fascinating topic, and it comes with its own challenges and overheads.

In the next episode, we will explore how error correction work, and why they are the bridge between today’s NISQ devices and truly scalable quantum computers.