From Qubits to Computation: How a Quantum Program Runs

Article 2 of 9 — Foundations of Quantum Computing

Article 1 introduced the strange raw materials — qubits, superposition, entanglement, interference. But raw weirdness isn't a computer. To actually compute, you need a way to manipulate those qubits deliberately, in sequence, to transform a question into an answer. That's what this article is about: how quantum gates and circuits turn quantum physics into something that runs a program — and why a quantum computer's output is a roll of loaded dice rather than a single certain result.

The basics explain gates, circuits, and measurement in plain terms. Going Deeper covers reversibility, why you run a quantum program many times, and the rule that you can't copy a qubit.

The basics: quantum gates

A classical computer processes bits using logic gates — tiny operations like AND, OR, and NOT that take bits in and put bits out. A quantum computer has its own version: quantum gates, which manipulate qubits.

But quantum gates work on the full quantum state, not just plain 0s and 1s. A single-qubit gate might flip a qubit, or — more usefully — rotate it into a superposition, or nudge the balance of its 0-and-1 blend. A two-qubit gate can entangle two qubits, linking them so the state of one depends on the other. A famous example is the "controlled-NOT" (CNOT), which flips one qubit only if another is in the 1 state — a basic building block for creating entanglement.

The key idea: gates don't just shuffle 0s and 1s, they reshape the underlying amplitudes — steering the interference that, as Article 1 explained, is where the real power lives.

The basics: quantum circuits

String gates together in a deliberate sequence and you have a quantum circuit — the quantum equivalent of a program. You start the qubits in a known state (usually all 0s), apply a carefully chosen series of gates that puts them into superposition, entangles them, and choreographs the interference, and then you measure at the end to read out a result.

That measurement, recall, collapses the rich quantum state down to ordinary bits — a string of 0s and 1s. So a quantum circuit's job is to arrange everything before measurement so that the bits you read out are very likely to be the answer you want.

The basics: why you run it many times

Here's a feature with no classical equivalent: a single run of a quantum program usually doesn't give you the answer outright. Because measurement is probabilistic, one run gives you one sample from a probability distribution. To find the answer, you typically run the same circuit many times — often called taking many "shots" — and look at the statistics of the outcomes. A well-designed algorithm makes the right answer come up far more often than the wrong ones, so the pattern across many runs reveals it.

This is profoundly different from classical computing, where you run a program once and trust the output. A quantum result is something you build up from repetition, like figuring out a loaded die's bias by rolling it many times.

Going deeper: reversibility, no-cloning, and the hybrid loop

For readers who want more, a few deeper rules shape how quantum programs are built.

Quantum gates are reversible. Unlike many classical gates (an AND gate throws away information — you can't reconstruct the inputs from the output), every quantum gate is reversible: you could in principle run it backwards. This isn't a quirk; it's required by the underlying physics, which is described by mathematical operations called unitary transformations. It constrains how quantum algorithms can be designed — you can't simply "erase" information mid-computation the way classical code does.

You cannot copy a qubit. A cornerstone result called the no-cloning theorem says it's impossible to make an identical copy of an unknown quantum state. This sounds like a footnote but has huge consequences: you can't just back up a qubit the way you copy a file, which is exactly why quantum error correction (Article 4) is so hard, and also why certain quantum cryptography schemes are secure. Much of what makes quantum computing difficult traces back to this one rule.

Computation is a hybrid loop. In practice, quantum processors don't run alone. A classical computer prepares the circuit, sends it to the quantum hardware, collects the measured results across many shots, and processes the statistics — often adjusting and re-running. Today's quantum machines are best understood as specialized accelerators called by classical computers, not standalone replacements. This hybrid pattern is how nearly all real quantum computation happens now.

Why fidelity matters. Every gate is slightly imperfect, and every imperfect gate nudges the computation off course. The more gates a circuit has, the more these small errors pile up — which is the central obstacle the whole field is wrestling with, and the subject of Article 4. The "depth" of circuit you can run before errors swamp the result is one of the truest measures of a quantum computer's real power.

The takeaway

You compute on a quantum machine by applying a sequence of quantum gates — a circuit — that puts qubits into superposition, entangles them, and shapes interference, before measuring to read out ordinary bits. Because measurement is probabilistic, you run the circuit many times and read the answer from the statistics. Quantum gates are reversible, qubits can't be copied, and in practice a classical computer drives the whole loop. And every imperfect gate adds error — which is why how many gates you can run reliably matters as much as how many qubits you have.

What people commonly get wrong

• "One run gives the answer." A single run yields one probabilistic sample; you repeat and read the answer from the statistics.
• "Quantum gates are like AND and OR." They're reversible and act on amplitudes, not just on 0s and 1s.
• "You can copy a qubit to back it up." The no-cloning theorem forbids it — a fact with deep consequences for error correction and cryptography.
• "The quantum computer runs the whole program alone." A classical computer drives the loop; quantum hardware is a specialized accelerator.
• "More qubits is all that matters." Gate quality and circuit depth matter just as much — errors accumulate with every operation.

This article is educational and deliberately simplified; the analogies are first steps, not literal physics, and a full treatment requires the underlying mathematics. It is not technical or professional advice.

Sources for further reading: standard introductions to quantum circuits and gates, including Nielsen & Chuang, Quantum Computation and Quantum Information, and educational materials from established quantum-computing research groups.

Next in the series: Article 3 — The Hardware Race: the wildly different physical ways people are trying to build a qubit, and the trade-offs between them.