What Is Quantum Computing?
Quantum Computing Fundamentals · Frontiers track
6 min read
In this module
Beyond Classical Bits
We've spent this course climbing up from the simplest possible idea — a bit, a single 0 or 1 — into processors, memory hierarchies, operating systems, and whole ISA families. Everything we've covered so far falls under classical computing: information held as definite binary values, shoved through deterministic logic gates.
Quantum computing pulls the rug out from under that. Instead of bits that sit firmly at 0 or 1, quantum computers run on qubits that can exist in a blend of both at once. This isn't science fiction. Quantum computers are real, built today by IBM, Google, and a clutch of others, and they exploit the laws of quantum mechanics to process information in ways no classical machine ever can.
What Is a Qubit?
A classical bit is a coin lying flat on the table — heads, or tails, no debate. A qubit (quantum bit) is a coin spinning in mid-air. While it spins, it's in some combination of heads and tails at once. Only when it lands (when you measure it) does it commit to a single outcome.
More precisely, a qubit exists in a state described by:
|ψ⟩ = α|0⟩ + β|1⟩Here, α and β are complex numbers called amplitudes. The probability of measuring 0 is |α|², and the probability of measuring 1 is |β|². These probabilities must sum to 1: |α|² + |β|² = 1.
Superposition is the ability of a qubit to exist in a combination of |0⟩ and |1⟩ states simultaneously. This is not the same as the qubit being "partly 0 and partly 1" or "we don't know which it is." The qubit genuinely occupies both states at once in a mathematically precise way. Measurement forces it to collapse to a definite value.
Superposition: The First Key Concept
Picture 3 classical bits. They hold one of 8 values (000 through 111) at any given moment. Three qubits in superposition hold all 8 values at the same time. With N qubits, that scales to 2^N states held in parallel.
Tempting as it sounds, this doesn't mean a quantum computer just "tries every answer at once." That's the most common misconception in the whole field. The real magic is in how you sculpt the amplitudes so that the correct answers grow louder and the wrong answers interfere themselves into silence. Pulling that off is the entire art of quantum algorithm design.
Entanglement: Correlated Qubits
The second piece of the quantum puzzle is entanglement. Once two qubits become entangled, their states are linked in a way nothing in classical physics can quite reproduce. Measure one qubit, and you instantly fix the state of the other, however far apart they happen to be.
A classic example is the Bell state:
|Φ+⟩ = (|00⟩ + |11⟩) / √2Measure the first qubit and read 0, and the second qubit is guaranteed to be 0. If the first comes up 1, so does the second. The outcomes are perfectly correlated, even though each individual qubit, looked at on its own, is a 50/50 coin toss.
Einstein famously sneered at entanglement as "spooky action at a distance," but it doesn't actually allow faster-than-light communication. You can't pick which outcome you get, so you can't send a message through entanglement on its own. What entanglement does provide is the raw resource that quantum algorithms, quantum teleportation, and quantum error correction all draw from.
How Qubits Are Built
Classical bits are cheap to engineer — a transistor, a capacitor, a voltage level. Qubits are a different beast entirely, brutal to build and even harder to keep alive. Several physical implementations are in the running:
- Superconducting qubits — tiny circuits chilled to near absolute zero (around 15 millikelvins), where electrical current flows without resistance. IBM and Google's choice. The most mature technology in play.
- Trapped ions — individual atoms suspended in electromagnetic fields and poked with lasers. IonQ and Quantinuum's territory. Coherence times are excellent, gate speeds less so.
- Photonic qubits — single photons whose polarisation or path carries the quantum information. Xanadu and PsiQuantum are betting here. Lovely for networking, painful for gate operations.
- Topological qubits — Microsoft's long-running bet on encoding quantum information in exotic quasiparticles that resist noise by their very structure. Still squarely experimental.
Qubits are incredibly fragile. Any interaction with the environment - stray electromagnetic fields, thermal vibrations, even a single stray photon - can destroy the delicate quantum state in a process called decoherence. This is why quantum computers are kept in extreme isolation: near absolute zero temperatures, electromagnetic shielding, and vibration dampening. Maintaining quantum states long enough to complete a computation is one of the greatest engineering challenges in the field.
Classical vs. Quantum: What Changes
Quantum doesn't beat classical at everything. For the bulk of everyday tasks — browsing the web, editing documents, compiling code — a classical machine is faster, cheaper, and far more practical. Quantum computers shine on a narrow set of problems:
| Problem Domain | Classical | Quantum |
|---|---|---|
| Factoring large numbers | Sub-exponential time | Polynomial time (Shor's) |
| Unstructured search | O(N) | O(√N) (Grover's) |
| Quantum simulation | Exponential resources | Naturally efficient |
| Optimisation problems | Often intractable | Potential speedups |
| General-purpose computing | Excellent | Not suitable |
Quantum computers aren't "faster classical computers." They're an entirely different model of computation, one that thrives on problems with very particular mathematical structure and shrugs at most others.
The State of the Field Today
As of the mid-2020s, we're firmly in the Noisy Intermediate-Scale Quantum (NISQ) era. Current quantum computers run tens to a few thousand qubits, but they're noisy as anything. Errors stack up fast and cap how deep a circuit you can actually trust the answer of. No quantum computer alive today beats classical hardware on a practically useful task, though Google and others have shown off "quantum supremacy" on problems built specifically to play to quantum strengths.
The path forward runs through three problems at once:
- Quantum error correction — spreading a single logical qubit across many physical qubits so errors can be detected and corrected. The overhead is brutal, potentially thousands of physical qubits per logical one.
- Better qubit hardware — lower error rates, longer coherence times, more qubits per chip.
- Improved algorithms — fresh quantum algorithms and smarter ways to wring useful work out of noisy hardware in the meantime.
Next lesson we get our hands on the quantum gates and circuits that actually manipulate qubits — the quantum counterpart of the classical logic gates from Logic Gates.