Bits to Qubits — Why Quantum Computing Exists
Let’s get something out of the way first. Quantum computing is not about making your computer faster. It’s not about running Chrome with more tabs. It won’t make your Python script execute quicker, and it won’t help you mine Bitcoin faster.
Quantum computing is a fundamentally different model of computation. It uses the laws of quantum mechanics — superposition, entanglement, and interference — to process information in ways that classical computers physically cannot. For certain specific problems, this gives an exponential speedup. For most everyday computing, it gives no advantage at all.
The problems where quantum shines happen to include some very important ones: factoring large numbers (which breaks RSA), searching unsorted databases (which weakens AES and hashing), and simulating molecular systems (which could revolutionize drug discovery and materials science).
If you’ve read through the cryptography series on this blog, you already have strong intuition for why this matters. This quantum computing series will build on that foundation.
Let’s start from the beginning.
Classical Bits — What We Know
Every classical computer — from the ENIAC in 1945 to the M4 MacBook you might be reading this on — is built on bits. A bit is the smallest unit of classical information. It has two possible states:
\[\text{bit} \in \{0, 1\}\]A bit is either 0 or 1. Never both. Never something in between. When you’re not looking at it, it’s still 0 or 1 — you just don’t know which one until you check.
Everything a classical computer does — arithmetic, logic, rendering, networking — boils down to manipulating bits. Your AES encryption works by XORing, shifting, and substituting bits. Your CPU fetches, decodes, and executes instructions that are sequences of bits. The entire digital world is bits.
With $n$ bits, you can represent exactly one of $2^n$ possible states at any time. 3 bits can represent one of 8 values: 000, 001, 010, 011, 100, 101, 110, 111. But only one at a time.
This seems obvious. But it’s worth stating explicitly, because qubits break this assumption.
Qubits — The Quantum Bit
A qubit (quantum bit) is the fundamental unit of quantum information. Like a classical bit, it can be measured as 0 or 1. But before measurement, a qubit exists in a superposition — a combination of both states simultaneously.
The Mathematics of a Qubit
A qubit’s state is described by a state vector in a two-dimensional complex vector space. We write it using Dirac notation (bra-ket notation):
\[|\psi\rangle = \alpha|0\rangle + \beta|1\rangle\]Where:
- $|0\rangle$ and $|1\rangle$ are the basis states (analogous to classical 0 and 1)
- $\alpha$ and $\beta$ are complex numbers called probability amplitudes
- $|\alpha|^2 + |\beta|^2 = 1$ (probabilities must sum to 1)
Don’t let the notation intimidate you. Here’s what it means in plain English:
The qubit is described by two numbers, $\alpha$ and $\beta$. When you measure the qubit, you get 0 with probability $|\alpha|^2$ and 1 with probability $|\beta|^2$. That’s it.
Examples
A qubit that is definitely 0:
\[|0\rangle = 1 \cdot |0\rangle + 0 \cdot |1\rangle\]$\alpha = 1$, $\beta = 0$. Probability of measuring 0: $|1|^2 = 100\%$. Probability of measuring 1: $|0|^2 = 0\%$.
A qubit that is definitely 1:
\[|1\rangle = 0 \cdot |0\rangle + 1 \cdot |1\rangle\]A qubit in equal superposition (50/50):
\[|+\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle\]$\alpha = \frac{1}{\sqrt{2}}$, $\beta = \frac{1}{\sqrt{2}}$. Probability of measuring 0: $\left(\frac{1}{\sqrt{2}}\right)^2 = \frac{1}{2} = 50\%$. Probability of measuring 1: also 50%.
This state $|+\rangle$ is created by applying the Hadamard gate to $|0\rangle$ — we’ll cover gates in detail in article 3.
As Vectors
If you prefer linear algebra (and you should, because that’s how quantum computing actually works), a qubit is a column vector in $\mathbb{C}^2$:
\[|0\rangle = \begin{pmatrix} 1 \\ 0 \end{pmatrix}, \quad |1\rangle = \begin{pmatrix} 0 \\ 1 \end{pmatrix}\] \[|\psi\rangle = \alpha|0\rangle + \beta|1\rangle = \begin{pmatrix} \alpha \\ \beta \end{pmatrix}\]The equal superposition state:
\[|+\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}\]Quantum gates are matrices that act on these vectors. The Hadamard gate, for example, is:
\[H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}\]Apply it to $|0\rangle$:
\[H|0\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \end{pmatrix} = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix} = |+\rangle\]Matrix multiplication — the same operation you’d do in any linear algebra course. That’s all quantum computing is at the mathematical level: linear algebra with complex numbers.
Superposition — What It Really Means
This is where most popular science gets it wrong. You’ll often hear “a qubit is 0 and 1 at the same time.” That’s a simplification that leads to misunderstanding.
A more accurate statement: a qubit is in a state that has some amplitude for 0 and some amplitude for 1. When measured, it collapses to one of those states, probabilistically.
Think of it like this. A classical bit is like a coin lying on a table — it’s either heads or tails. A qubit is like a coin spinning in the air. While spinning, it’s not heads and it’s not tails — it’s in a state that has some probability of each. When it lands (measurement), it becomes definitively one or the other.
But even this analogy is imperfect, because the coin’s outcome is determined by physics we just can’t measure precisely (classical probability). A qubit’s superposition is fundamental — the outcome genuinely doesn’t exist until measurement. This is a deep philosophical difference, but practically, what matters is the math.
Why Superposition is Useful
Here’s where the power comes from. Consider $n$ qubits. Classically, $n$ bits represent one of $2^n$ states. But $n$ qubits in superposition represent a state that has amplitudes for all $2^n$ combinations simultaneously.
For 3 qubits:
\[|\psi\rangle = \alpha_{000}|000\rangle + \alpha_{001}|001\rangle + \alpha_{010}|010\rangle + \alpha_{011}|011\rangle + \alpha_{100}|100\rangle + \alpha_{101}|101\rangle + \alpha_{110}|110\rangle + \alpha_{111}|111\rangle\]That’s 8 amplitudes — one for each possible 3-bit string. A quantum gate acting on these 3 qubits transforms all 8 amplitudes simultaneously in a single operation. This is sometimes called “quantum parallelism” — but be careful, it’s not the same as classical parallel processing. You can’t just read out all 8 results. Measurement gives you only one.
The art of quantum algorithms is using interference — making the amplitudes of wrong answers cancel out and correct answers add up — so that when you measure, you’re overwhelmingly likely to get the right answer.
For $n = 300$ qubits, the number of amplitudes is $2^{300}$ — more than the number of atoms in the observable universe. A classical computer can’t even store this state vector, let alone manipulate it. A quantum computer with 300 qubits can represent and transform this state naturally.
This is why quantum computing matters. It’s not about speed — it’s about representational power that grows exponentially with the number of qubits.
Measurement — The Collapse
Here’s the catch. You can put a qubit in any superposition you want, but when you measure it, you get a definitive 0 or 1. The superposition is destroyed.
Given state $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$:
- Measuring gives 0 with probability $|\alpha|^2$
- Measuring gives 1 with probability $|\beta|^2$
- After measurement, the qubit is in the state you measured — $|0\rangle$ or $|1\rangle$. The superposition is gone.
This is called wavefunction collapse and it’s one of the deepest mysteries in physics. We won’t try to explain why it happens (nobody agrees on that). We’ll just use the fact that it does.
The No-Cloning Theorem
You cannot copy a qubit’s state. In classical computing, copying a bit is trivial — just read it and write the value somewhere else. But quantum mechanics forbids copying an unknown quantum state. This is the no-cloning theorem, and it has profound implications:
- You can’t backup a quantum computation mid-way
- You can’t eavesdrop on a quantum communication channel without disturbing it (the basis for quantum key distribution)
- Quantum error correction requires entirely different approaches than classical error correction
The no-cloning theorem isn’t a technology limitation — it’s a fundamental law of physics.
The Bloch Sphere — Visualizing a Qubit
A single qubit’s state can be visualized on the Bloch sphere — a unit sphere where:
- The north pole is $|0\rangle$
- The south pole is $|1\rangle$
- The equator contains equal superposition states like $|+\rangle$ and $|-\rangle$
- Every point on the surface represents a valid qubit state
Where $\theta$ is the polar angle (0 to $\pi$) and $\phi$ is the azimuthal angle (0 to $2\pi$).
|0⟩ (north pole)
●
/|\
/ | \
/ | \
|+⟩ ●───●───● |-⟩ (equator)
\ | /
\ | /
\|/
●
|1⟩ (south pole)
Quantum gates are rotations on the Bloch sphere:
- The Hadamard gate rotates from the north pole ($|0\rangle$) to the equator ($|+\rangle$)
- The Pauli-X gate (quantum NOT) rotates from north to south ($|0\rangle \to |1\rangle$)
- The Pauli-Z gate flips the phase — rotates around the Z axis
The Bloch sphere only works for a single qubit. Multi-qubit states live in higher-dimensional spaces that can’t be easily visualized — which is where the math becomes essential.
Entanglement — Spooky Action
Entanglement is the second quantum phenomenon (after superposition) that powers quantum computing.
Two qubits are entangled when the state of one cannot be described independently of the other. Measuring one instantly determines the state of the other, regardless of distance.
The simplest entangled state is a Bell state:
\[|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)\]This state means: there’s a 50% chance both qubits are 0, and a 50% chance both are 1. But there’s zero chance of getting 01 or 10. The qubits are perfectly correlated.
If you measure the first qubit and get 0, the second qubit is instantly and certainly 0 as well — even if it’s on the other side of the planet. Einstein called this “spooky action at a distance” and thought it proved quantum mechanics was incomplete. Experiments have since confirmed that entanglement is real and not explained by hidden variables (Bell’s theorem).
In quantum computing, entanglement is created using the CNOT gate (Controlled-NOT). We’ll build entangled states hands-on in article 3.
Why Entanglement Matters for Computing
Entanglement creates correlations between qubits that have no classical equivalent. These correlations are what give quantum algorithms their power:
- In Shor’s algorithm (which breaks RSA), entanglement between the input and output registers enables quantum Fourier transform to find the period of a function
- In quantum teleportation, entanglement allows transmitting qubit states using only classical communication + a pre-shared Bell pair
- In quantum error correction, entangled states protect quantum information against noise
Without entanglement, a quantum computer would just be a probabilistic classical computer — powerful superposition alone isn’t enough.
Interference — The Secret Weapon
Interference is what separates quantum computing from mere randomness. Without interference, superposition would just give you random outputs — useless.
Because amplitudes are complex numbers (they have both magnitude and phase), they can be positive or negative (or complex). When two computational paths lead to the same outcome:
- If their amplitudes have the same sign, they add up (constructive interference) — making that outcome more likely
- If their amplitudes have opposite signs, they cancel out (destructive interference) — making that outcome less likely
Constructive:
Path A amplitude: +0.5
Path B amplitude: +0.5
Combined: +1.0 → probability = 1.0 (certain)
Destructive:
Path A amplitude: +0.5
Path B amplitude: -0.5
Combined: 0.0 → probability = 0.0 (impossible)
Every quantum algorithm works by engineering interference so that:
- Correct answers experience constructive interference (amplitudes add up)
- Wrong answers experience destructive interference (amplitudes cancel)
After the interference pattern is set up, you measure — and you’re overwhelmingly likely to get the right answer. This is the fundamental trick of quantum computing.
In Grover’s search algorithm, for example, the “correct” item in an unsorted database gets its amplitude boosted while all other items get their amplitudes reduced. After about $\sqrt{N}$ iterations (instead of $N$ for classical), the correct item has nearly all the probability.
Classical vs Quantum — An Honest Comparison
Let’s be precise about what quantum computers can and can’t do.
| Aspect | Classical | Quantum |
|---|---|---|
| Basic unit | Bit (0 or 1) | Qubit (superposition of 0 and 1) |
| State of n units | One of $2^n$ values | Superposition of all $2^n$ values |
| Operations | Logic gates (AND, OR, NOT) | Unitary matrices (Hadamard, CNOT, etc.) |
| Parallelism | Explicit (multiple cores) | Implicit (superposition) |
| Deterministic? | Yes | No — probabilistic (need multiple runs) |
| Errors | Bit flips (rare, correctable) | Decoherence, gate errors (major challenge) |
| Good at | Everything we do today | Factoring, search, simulation, optimization |
| Bad at | Simulating quantum systems | Most everyday computing tasks |
What Quantum Computers Are NOT Good At
- General speedup — Quantum computers don’t make all algorithms faster. For most software (web servers, databases, operating systems), a classical computer is just as fast or faster.
- Big data processing — Quantum computers currently have very few qubits (~1000) and high error rates. They can’t process large datasets.
- Replacing classical computers — Quantum computers will be co-processors for specific tasks, not replacements for your laptop.
What Quantum Computers ARE Good At
| Problem | Classical Complexity | Quantum Complexity | Speedup |
|---|---|---|---|
| Integer factoring (Shor) | Sub-exponential (best known) | Polynomial | Exponential |
| Unstructured search (Grover) | $O(N)$ | $O(\sqrt{N})$ | Quadratic |
| Quantum simulation | Exponential | Polynomial | Exponential |
| Optimization (QAOA) | NP-hard (varies) | Heuristic speedup | Problem-dependent |
The factoring speedup is what threatens RSA — Shor’s algorithm factors an $n$-bit number in $O(n^3)$ time on a quantum computer, vs the best classical algorithm which takes sub-exponential time. For RSA-2048, that’s the difference between “billions of years” and “hours.”
The search speedup is what affects AES and hashing — Grover’s algorithm searches a key space of $2^n$ in $2^{n/2}$ operations, effectively halving the security. AES-128 drops to 64-bit security under Grover’s, which is why AES-256 is recommended for post-quantum safety.
Where Are We Today? (The NISQ Era)
Current quantum computers are in what John Preskill calls the NISQ era — Noisy Intermediate-Scale Quantum. This means:
-
Intermediate-Scale — Current machines have ~50-1000+ qubits (IBM Eagle: 127, IBM Condor: 1121, Google Sycamore: 53). That’s enough to do interesting things but not enough to run Shor’s algorithm on RSA-2048 (which would need ~4000 error-corrected logical qubits, or millions of physical qubits with current error rates).
-
Noisy — Qubits are extremely fragile. They interact with their environment and lose their quantum state (decoherence) in microseconds to milliseconds. Gate operations have error rates of ~0.1-1%. After ~100-1000 gate operations, the accumulated errors make the result unreliable.
The Error Correction Challenge
Classical error correction is simple: store each bit three times, take a majority vote. Quantum error correction is fundamentally harder because:
- No cloning — You can’t copy a qubit to make redundant copies
- Measurement destroys — You can’t check a qubit’s value without collapsing it
- Continuous errors — Classical bit flips are discrete (0→1). Quantum errors can be continuous rotations in any direction on the Bloch sphere.
Quantum error correction codes (like the surface code) use many physical qubits to encode one logical qubit. Current estimates: ~1000-10000 physical qubits per logical qubit, depending on the error rate.
To factor RSA-2048 with Shor’s algorithm:
- Need: ~4000 logical qubits
- At 1000:1 overhead: ~4,000,000 physical qubits
- Current hardware: ~1000 physical qubits
We’re roughly 3-4 orders of magnitude away. That’s why quantum computing is a threat to watch and prepare for — but not a crisis today. This is exactly why post-quantum cryptography is being standardized now, while we still have time.
Major Players
| Company | Approach | Latest Achievement |
|---|---|---|
| IBM | Superconducting qubits | 1121-qubit Condor processor (2023) |
| Superconducting qubits | “Quantum supremacy” with Sycamore (2019), Willow (2024) | |
| IonQ | Trapped ions | High-fidelity gates, fewer qubits but better quality |
| Quantinuum | Trapped ions (Honeywell) | Best 2-qubit gate fidelity |
| PsiQuantum | Photonics | Different approach — using photons |
| Microsoft | Topological qubits | Still in research — promising but unproven |
| D-Wave | Quantum annealing | Not universal QC — specialized for optimization |
What’s Next in This Series
Now that you understand the foundations — qubits, superposition, measurement, entanglement, and interference — we’re ready to build on them.
Next up: The Math You Need — Linear Algebra for Quantum. We’ll cover the mathematical tools (vectors, matrices, tensor products, Dirac notation) that you need to actually read quantum circuits and understand quantum algorithms. If you’re comfortable with the matrix multiplication we did in AES’s MixColumns, you’re already closer than you think.
After that, we’ll build quantum circuits, create entangled states, implement Grover’s and Shor’s algorithms, and connect everything back to the cryptography you already know.
Thanks for reading!
