Chapter 1: Why Quantum Computing Isn’t Just “Faster Classical Computing” (And Why That Matters)

If you’ve read any tech news in the past five years, you’ve probably heard the hype: quantum computers will revolutionize medicine, break the internet, and solve climate change overnight. But if you’ve also dug a little deeper, you’ve likely run into a mess of conflicting claims: some experts say we’re 10 years away from practical quantum computing, others say it’s already here. Some say quantum computers will replace your laptop within a decade, others say they’ll never be more than lab curiosities. So what’s the truth? Let’s cut through the noise, starting with the most fundamental misconception of all: that quantum computing is just a faster version of the classical computing you use every day.

To understand why that’s wrong, we first need to ground ourselves in the actual differences between how classical and quantum systems process information. You already know that classical bits are binary: they exist in one of two states, 0 or 1, like a light switch that’s either off or on. All the computing you do today—from scrolling TikTok to running a climate model—relies on flipping these switches in carefully choreographed sequences, following the rules of Boolean logic. A quantum bit, or qubit, by contrast, can exist in a *superposition* of both 0 and 1 at the same time, described by the state vector $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$, where $\alpha$ and $\beta$ are complex numbers called probability amplitudes, and $|\alpha|^2 + |\beta|^2 = 1$. When you measure the qubit, it collapses to either 0 or 1, with probabilities $|\alpha|^2$ and $|\beta|^2$ respectively.

This is where the first common myth takes root: people hear “superposition” and assume quantum computers can just “try all possible solutions at once” to any problem. That sounds like a free lunch, but it’s not how quantum computation actually works. To see why, let’s take a concrete example: imagine you’re trying to find a specific name in a phone book with 1 million entries. A classical computer would have to check entries one by one (or in small parallel batches) in the worst case, taking up to 1 million checks—this is an $O(N)$ algorithm, where $N$ is the number of entries. A quantum computer using Grover’s algorithm can find the entry in roughly $\sqrt{N} = 1000$ checks, a quadratic speedup that’s very real for large $N$. But it’s not “checking all 1 million entries at once”: it’s using interference between probability amplitudes to amplify the chance of measuring the correct entry, while canceling out the amplitudes for incorrect entries. You still only get one result per run of the algorithm, just like a classical search. The parallelism of quantum computing is not a free pass to access all possible outcomes simultaneously; it’s a constrained, interference-driven parallelism that only gives you a speedup for problems with specific structural properties.

This distinction matters more than it sounds. For decades, quantum computing hype has relied on the “try all solutions at once” line, which makes the technology sound like a magic bullet for every computational problem. It’s not. To understand what quantum computing *is* good for, we first need to define what “quantum advantage” actually means—and just as importantly, what it doesn’t mean.

> Sidebar: What Exactly Is “Quantum Advantage”? > > The term “quantum advantage” (sometimes still called “quantum supremacy” in older literature, though that term has fallen out of favor due to its political connotations) refers to a clear, experimentally verified demonstration that a quantum processor can perform a specific, well-defined task *faster, more accurately, or at lower cost* than the best possible classical supercomputer. It does not mean the quantum computer is better at *all* tasks, or even most tasks. The first demonstrations of quantum advantage in 2019 (Google’s Sycamore processor) and 2020 (China’s Jiuzhang photonic computer) used artificial, practically useless tasks: random circuit sampling for Sycamore, Gaussian boson sampling for Jiuzhang. These tasks were chosen specifically because they are extremely hard for classical computers to simulate, but they have no real-world application. The far more important goal of the field is *practical quantum advantage*: demonstrating a speedup or accuracy gain on a task that matters, like drug discovery, materials design, or financial risk modeling. That milestone has not yet been reached, but it is the core focus of nearly all quantum computing research today.

So why does quantum computing offer an advantage for *some* problems, but not others? The answer lies in the fundamental structure of the problems themselves. Classical computers are extremely good at solving problems with *polynomial complexity*: problems where the time or memory needed to solve them grows as a polynomial function of the input size (e.g., $O(n)$, $O(n^2)$, $O(n^3)$). Sorting a list of $n$ numbers, for example, can be done in $O(n \log n)$ time with a classical algorithm, and no known quantum algorithm can beat this bound. For these problems, even a massive quantum computer won’t give you a meaningful speedup, because the classical solution is already efficient enough.

The problems where quantum computing shines are those with *exponential complexity* for classical computers: problems where the time or memory needed grows as an exponential function of the input size (e.g., $O(2^n)$, $O(3^n)$). For these problems, even a modest increase in input size makes the classical solution completely intractable. Simulating the quantum behavior of a molecule is the canonical example: for a molecule with $N$ electrons, the full quantum wavefunction describing all their interactions has $3^N$ dimensions. Simulating a molecule with just 50 electrons would require storing $3^{50} \approx 7 \times 10^{23}$ complex numbers—more than the total number of bytes of storage on every computer on Earth combined. A quantum computer, by contrast, can simulate this system with just $N$ qubits, because each qubit naturally encodes the quantum state of one electron. This is not a trick or a hack: it’s a direct consequence of the fact that quantum computers are themselves quantum systems, so they can natively represent and manipulate quantum states in a way classical computers never can.

Another class of problems where quantum computing offers an advantage are combinatorial optimization problems: problems where you need to find the best solution out of a huge number of possible combinations. The traveling salesman problem (TSP) is the most famous example: given a list of cities and the distances between them, find the shortest possible route that visits each city exactly once and returns to the starting city. For 20 cities, there are $19! \approx 1.2 \times 10^{17}$ possible routes. Even the fastest classical supercomputer would take weeks to check all of them. A sufficiently large, fault-tolerant quantum computer running an algorithm like the Quantum Approximate Optimization Algorithm (QAOA) could find the optimal route in a fraction of that time, with a speedup that grows exponentially as the number of cities increases.

It’s important to emphasize that these speedups are not guaranteed for *all* combinatorial problems, and for many practical problems, the best known quantum algorithms only offer modest speedups over classical heuristics. But for a small but extremely valuable set of problems, the potential gain is so large that it justifies the enormous investment the field has seen over the past two decades.

Now that we’ve established what quantum computing *is* good for, let’s talk about what it’s *not* good for—and clear up the other most common myths that cloud public understanding of the field.

Myth 1: Quantum computers will replace classical computers entirely

This is perhaps the most pervasive misconception, and it’s also the easiest to debunk. Classical computers have been optimized for 70 years, f