Over the past 30+ episodes (check here), we have explored quantum computing from many angles; the basics of qubits, different hardware approaches, applications, and the strange physics underneath it all. But underneath all of that complexity lies a surprisingly simple idea:

This is true for both classical and quantum computers.

When you edit a video, play a game, or book a flight online, it feels like your computer is doing something enormously sophisticated. And it is, but at the lowest level, everything reduces to operations on bits: 0s and 1s.

Deep inside the processor, tiny logic gates work together to transform streams of 0s and 1s into everything you see on your screen.

The remarkable part is that modern computing does not require thousands of different kinds of gates. A very small collection is enough to build any computation imaginable. This collection is called a universal gate set.

In classical computing, gates like NOT, AND, OR form a universal gate set. Your entire digital world is constructed from combinations of these simple operations repeated billions of times per second.

It is important to note that in both classical and quantum computing, the universal gate set is not unique. There can be many different combinations of gates that are sufficient to perform any computation.

So naturally, we can ask:

Because in the end, building a quantum computer is really about one thing:

Quantum gates operate on qubits instead of classical bits. Unlike classical bits, qubits are not restricted to just 0 or 1. They can exist in combinations of both, a property known as superposition.

This allows quantum gates to do things that are impossible in classical computing.

Let’s look at a few important ones.

One of the most famous quantum gates is the Hadamard gate, usually written as H.

If you apply a Hadamard gate to a qubit in state 0, it creates an equal superposition of 0 and 1. In a loose intuitive sense, the qubit becomes “50% 0 and 50% 1” until it is measured.

This operation has no true classical equivalent. A classical bit cannot exist in a superposition it must always be either 0 or 1.

The Hadamard gate is one of the key ingredients behind quantum computing.

Another fundamental quantum gate is the CNOT (Controlled-NOT) gate.

This is a two-qubit gate.

Its rule is simple:

On the surface, this may not sound revolutionary. But when combined with superposition, the CNOT gate can create one of the strangest phenomena in physics:

Entanglement

Entangled qubits become correlated in ways that classical systems cannot replicate. In fact, much of quantum computing’s power comes from the interplay between:

Classical logic gates act on bits that are either 0 or 1.

Quantum gates are richer because qubits can be also rotated continuously and not just flipped.

These rotations are performed around different axes — X, Y, and Z — and are related to the Pauli gates (Pauli-X, Pauli-Y, Pauli-Z).

This ability to continuously rotate qubits is a key reason quantum computation is fundamentally different from classical computation.

Now comes one of the most fascinating ideas in quantum computing.

To understand what this means, think about a flight simulator. A flight simulator is not a real airplane, but a computer program that mathematically models how an airplane would behave, how it turns, accelerates, reacts to wind, and so on.

In the same way, a quantum computer simulator is not a real quantum machine. Instead, a classical computer mathematically models what qubits and quantum gates would do.

This is actually how most people first learn quantum computing today (for example, Qiskit by IBM). You can play with the simulator here:

Many quantum algorithms are first tested on simulators running on ordinary laptops or data centers.

So why build quantum computers at all?

Because there’s a catch — and it’s a very big one.

Quantum gates are often divided into two broad categories:

The Clifford family includes gates such as:

In the late 1990s, Daniel Gottesman and Emanuel Knill proved a remarkable result known as the Gottesman–Knill theorem.

It showed that:

This was a huge insight.

Even though Clifford circuits can generate superposition and entanglement, they still do not provide the full power of quantum computation.

To build a truly universal quantum computer, we must add at least one non-Clifford gate.

A famous example is the T gate. The T gate is a single-qubit rotation gate. More specifically, it rotates the qubit around the Z-axis of the Bloch sphere by 45 degrees (or π/4 radians). In the first glance, it seems easy but in practise it will change the coefficients of quantum state in a non-trivial way and therefore it is extremely hard to simulate on a classical computer.

Once non-Clifford gates enter the picture, classical simulation becomes dramatically harder.

The difficulty grows exponentially with the number of qubits.

A quantum state with:

This is the key reason physical quantum computers matter. If classical computers could efficiently simulate universal quantum computers, there would be little point in building quantum hardware in the first place.

But universal quantum systems, especially those with many non-Clifford operations, appear to escape efficient classical simulation.

And that is where the promise of quantum advantage comes from.

At first glance, quantum computing can seem overwhelmingly complicated: exotic physics, strange mathematics, superconducting circuits, trapped ions, error correction, and more.

But underneath all of it lies a beautifully simple foundation:

A small set of quantum gates.

Just like classical computing emerged from combinations of simple logic gates, quantum computing emerges from combinations of quantum gates acting on qubits.

The challenge and the opportunity is that quantum gates unlock behaviors that classical gates never could:

And somewhere inside those operations may lie computational power beyond what classical machines can efficiently achieve.