Learning quantum computing on my own: what worked

I’ve been learning quantum computing on my own, outside of any class. Over the last couple of months I’ve written up the pieces as I got them: what a qubit actually is, Grover’s algorithm, Shor’s algorithm, and why error correction costs so many qubits. This post is the one underneath all of those. What resources worked, what order I’d do them in if I started over, and where I got stuck.

I want to be upfront about one thing. I’m a high school student, not a physicist. Everything here is “what worked for someone with high school math and a lot of curiosity,” not a curriculum. If you have a physics background, some of this will be too slow for you.

The trap I’d warn you about first

A common introduction to quantum computing starts with a sentence like this: a qubit is 0 and 1 at the same time, so a quantum computer tries every answer at once. It sounds like understanding. It isn’t.

Scott Aaronson has spent years pushing back on that exact framing, and I went through his version of the argument in the qubit post.

The reason this matters for learning is practical. If you start with “it tries everything at once,” every real algorithm will look like it’s cheating or doing something mysterious. Once you replace that picture with “a quantum state is a list of numbers called amplitudes, and algorithms arrange for the wrong answers’ amplitudes to cancel out,” the algorithms start to look like clever bookkeeping. That’s the version you can actually work with.

So my first piece of advice is negative. Don’t spend much time on popular-science videos that lean on “both at once.” That shorthand can make the later algorithms harder to understand.

The order I’d learn it in

Step 1: linear algebra, before anything quantum

This is the part I’d push hardest on. Quantum computing, at the level of algorithms, is linear algebra with complex numbers. That is enough to begin working through small circuits, though mixed states, noise, and measurement need more machinery later.

Here is a single qubit:

state = a|0> + b|1>        where |a|^2 + |b|^2 = 1

That’s a 2D vector [a, b]. A gate is a 2x2 matrix that keeps the vector’s length at 1 (a unitary matrix). Running a gate is a matrix times a vector. The Hadamard gate, the one you’ll see everywhere, is:

H = (1/sqrt(2)) * [[1,  1],
                   [1, -1]]

H [1, 0] = [1/sqrt(2), 1/sqrt(2)]      # |0> becomes an even mix
H [1/sqrt(2), 1/sqrt(2)] = [1, 0]      # apply it again and you're back at |0>

That second line is the whole trick of quantum computing in miniature. Two equal amplitudes went in, and the -1 in the bottom corner made the |1> parts cancel. That’s interference, and you can’t see it unless you’re comfortable multiplying a matrix by a vector without thinking about it.

Two qubits means a 4-entry vector, built with something called a tensor product. Three qubits means 8 entries. n qubits means 2^n. If you can do these by hand for 1 and 2 qubits, you’re ready.

What I’d use for this step:

• 3Blue1Brown’s “Essence of linear algebra” series.¹ It’s not about quantum at all, which is the point. It builds the geometric picture of vectors and matrices that everything later depends on.
• Chapter 2 of Nielsen and Chuang, which opens with a linear algebra review written specifically for quantum computing: inner products, unitary matrices, tensor products, the notation.² It’s dense, but it’s exactly the subset you need.
• Complex numbers, just the basics. Multiplying them, the magnitude |z|, and e^(i*theta) as a rotation. You need less than you’d think at the start, but you do need it.

Quantum Country, which I’ll get to below, says it directly on its front page: you’ll need familiarity and comfort with the basics of linear algebra and complex numbers.³ I’d take that seriously.

Step 2: qubits, gates, and measurement

Once the math is comfortable, the actual quantum rules are short. There are really three:

1. A state is a unit vector of complex amplitudes.
2. Gates are unitary matrices acting on that vector.
3. When you measure, you get outcome x with probability |amplitude_x|^2, and the state collapses to that outcome.

Everything else is consequences. I wrote these up properly in the qubit post, including the Bloch sphere, which is the standard way to picture a single qubit as a point on a sphere.

The resources that fit this step:

Quantum Country by Andy Matuschak and Michael Nielsen.³ It’s a free set of essays that explains quantum computing from the ground up and covers a search algorithm and teleportation. The unusual part is that it has review questions built into the text and brings them back over the following days and weeks, so you actually remember the definitions. For a subject where the vocabulary stacks on itself, that helps a lot.

IBM’s “Basics of quantum information” course by John Watrous.⁴ It’s free on IBM Quantum Learning, with video lessons plus written text. It goes from single systems to multiple systems to circuits, and finishes with entanglement examples like teleportation and the CHSH game. Watrous is very careful. Nothing gets hand-waved. The same material is also available as a long written text on arXiv if you prefer reading.⁵

A note on “the Qiskit textbook,” since a lot of older advice points there. IBM retired it. In late 2023 the textbook’s home page started redirecting to IBM Quantum Learning, and the old pages moved to an archived GitHub repo that isn’t maintained anymore.⁶ The old pages still work and plenty of them are good, but they may use outdated Qiskit code. If you want the current IBM material, use the Learning platform.

Quirk, Craig Gidney’s drag-and-drop circuit simulator, is the tool I’d pair with all of this.⁷ It runs in the browser, needs no install, and updates the state display live as you drag gates onto wires. Put an H on one wire and watch the amplitudes split. Put a second H on it and watch them come back together. That’s the interference example from Step 1, and it’s very different to see it happen than to read about it.

Step 3: Grover

Grover’s algorithm is the right first real algorithm, in my opinion. It’s useful (unstructured search), it’s short, and the smallest case is small enough to do with a pencil.

This was the one that humbled me. For a while I could recite the circuit and say “it searches in sqrt(N) steps,” and I could not explain why it worked. That’s a bad place to be.

What fixed it was doing the 4-entry case by hand: start with all amplitudes at 0.5, flip the target’s sign, reflect every amplitude about the mean, and the target lands at exactly 1.0. Seeing the target land at exactly 1.0 on paper is what turned Grover from a recited circuit into something I understood. The full walkthrough, plus the geometric picture where each step is a rotation, is in the Grover post.

Two resources that helped for this step specifically:

• 3Blue1Brown’s video on Grover’s algorithm from April 2025.⁸ It opens by going after the “tries everything in parallel” misconception and builds up the state vector before getting to the algorithm. If you’ve done Steps 1 and 2, it lands really well. If you haven’t, it’s still good, but you’ll get less out of it.
• Chapter 6 of Nielsen and Chuang, on quantum search.² This is where the “two reflections make a rotation” picture is laid out cleanly, and it’s what explains why the answer is a square root and not something better.

Then run it. I ran the 2-qubit version in Qiskit and got the target on every shot of the simulator. It’s about fifteen lines of code. There’s a version of understanding that only shows up when the code prints the number you predicted by hand.

Step 4: Shor

Shor’s algorithm is the famous one, and it’s a big step up. It needs everything above plus some number theory (modular arithmetic, why finding the period of a^x mod N helps you factor N) plus the quantum Fourier transform.

The reason I’d put Shor after Grover is that Grover teaches you the core move, interference that boosts the right answer, in a setting with almost no other math in the way. Shor uses the same move, but it’s buried under number theory and the Fourier transform. If you meet it first, it’s hard to tell which part is the quantum part.

What I’d read:

• Shor’s original paper.⁹ Surprisingly readable in places, especially the early sections that explain the reduction from factoring to period finding. You don’t have to follow every proof.
• Nielsen and Chuang, Chapter 5, which covers the quantum Fourier transform and its applications, including order finding and factoring.²
• N. David Mermin’s “Quantum Computer Science: An Introduction.”¹⁰ It’s short, written for computer scientists, assumes no physics background, and covers Shor, Grover, and error correction. If Nielsen and Chuang feels like too much, this is the gentler version.

My summary of Shor, and how it connects to RSA and why banks care, is here.

Step 5: error correction

After Shor, the natural question is “so why can’t we run this yet?” The answer is noise, and the answer to noise is error correction. That’s where you find out why a useful machine needs so many physical qubits per logical one. My attempt at explaining it is here.

The big-picture book: Aaronson

There’s one resource I’d keep running alongside all five steps instead of slotting into one: Scott Aaronson.

His book “Quantum Computing Since Democritus” is not a textbook in the usual sense.¹¹ It wanders through computability, complexity, cryptography, and quantum mechanics, and it’s opinionated and funny. What it’s good for is the “why should anyone care” layer: what problems quantum computers are and aren’t expected to help with, and why. That’s the context that keeps you from overhyping what you just learned.

He also has free lecture notes from his undergraduate course at UT Austin, “Introduction to Quantum Information Science.”¹² They cover qubits, gates, entanglement, Shor, Grover, and error correction, in a much more structured way than the book. If you want one free document that walks the whole path from Step 2 to Step 5, that’s a good candidate.

What confused me

Some of this was confusing for a while. Listing it in case you hit the same walls.

Amplitudes versus probabilities. For a while I kept thinking of amplitudes as “probabilities with extra steps.” They aren’t. Probabilities are always positive, so they can only add up. Amplitudes can be negative (or complex), so they can cancel. Interference only exists because of that, and every algorithm depends on it.

Global phase. A state multiplied by -1 is physically the same state. But a -1 on just one part of the state is a huge deal, because that’s exactly what Grover’s oracle does. It took me a bit to separate “a sign on everything” from “a sign on one piece.”

Tensor products and qubit ordering. Different sources order the qubits differently. Qiskit, for example, writes bitstrings with qubit 0 as the rightmost bit.¹³ If you’re comparing a hand calculation to Qiskit output and the bits look reversed, that’s probably why.

Why measurement ruins everything. You can’t peek at the amplitudes. You get one outcome per run and the state is gone. Once that really sinks in, you understand why algorithms work so hard to push nearly all the probability onto the right answer before measuring.

Habits that helped

The resources matter less than how you use them. These are the habits I’d recommend, roughly in order of how much they helped.

Do the smallest case by hand. One qubit, then two. Grover with 4 entries. Shor with N = 15. Doing the tiny case on paper is a useful check on what a fluent explanation might be hiding.

Predict, then run. Before you hit run in Quirk or Qiskit, write down what you expect. When the simulator disagrees with you, that’s the most useful moment in the whole process, because it points straight at the thing you don’t get yet.

Explain it in writing. Writing these blog posts did more for my understanding than reading did. Every time I tried to explain something and couldn’t write the next sentence, I’d found a gap. That’s honestly a big part of why this blog has a quantum section at all.

Don’t skip ahead to the famous algorithm. I know Shor is the exciting one. But going straight to Shor without the earlier steps means memorizing a diagram you can’t reason about. For me, the earlier steps make Shor easier to reason about.

If I started over

I’d start with one qubit, calculate a few gate operations by hand, and check them in a simulator. Once that felt familiar, I’d move to two qubits and then work through a small algorithm. The books and courses above would still be useful, but I’d give myself a concrete calculation to return to whenever the explanation became too abstract.

What I like about learning this way is that I can try something before I feel ready to understand the whole subject. A sign changes, an outcome disappears, and suddenly there is a specific thing to figure out. I’d like to keep following those moments into harder examples, because they make the next question feel worth asking.

Sources