Qubits are the universe's way of saying "yes and no" at the same time. Over five phases — fourteen weeks, two spine texts, one proof per week — you will learn to speak that language, and to prove exactly why it is more powerful than ours.
If you think you understand quantum mechanics, you don't understand quantum mechanics.— Richard Feynman
The bible of the field — comprehensive and rigorous. Your spine text: §1–2 for foundations, Ch. 4–6 for circuits and algorithms, Ch. 8–12 for information, Ch. 10 for codes.
Sharp, modern, free — by an ILLC / QuSoft professor. Ch. 1–7 carry the entire algorithms phase. The algorithmic voice of the program you want.
Selective chapters, for physical intuition where N&C stays formal — density operators and error correction especially.
Turn the math into circuits you can actually run. One lab notebook per phase, no exceptions.
Two weeks to internalize the four sentences the entire field rests on. Every algorithm, every code, every bound in the next twelve weeks is a corollary of the postulates — so here you build the vocabulary (Dirac notation), the geography (the Bloch sphere), and the one genuinely alien ingredient (entanglement) until they are reflexes, not references.
Quantum mechanics is four axioms: a closed system is a unit vector in a Hilbert space; it evolves by unitary operators; measurement is a family of operators whose outcome statistics obey the Born rule; and composite systems combine by tensor product. That is the entire rulebook — no interpretation required, and none of it negotiable. The discipline of this phase is learning to see every protocol in the course as a sequence of moves, each licensed by exactly one postulate.
Bras, kets, inner and outer products, the completeness relation Σᵢ|i⟩⟨i| = I, and the spectral theorem for normal operators — the shorthand the whole literature is written in, and it must become as automatic as arithmetic. The notation is not decoration: outer products let you assemble operators from vectors, and spectral decomposition lets you take functions of them — e^{iA} is how Hamiltonians become gates. Two weeks of deliberate drill here buys you five phases of never stopping to translate.
Normalization spends one real degree of freedom and global phase is unobservable — it multiplies every amplitude equally, so no Born-rule probability can ever detect it — which leaves exactly two: |ψ⟩ = cos(θ/2)|0⟩ + e^{iφ}sin(θ/2)|1⟩, a point on the unit sphere. The half-angle is the tell: orthogonal states sit at antipodes, not at right angles, and single-qubit gates become literal rotations of the sphere. This picture is how you will reason about every gate in Phase 2 without touching a matrix.
Measurement operators {Mₘ} give p(m) = ⟨ψ|Mₘ†Mₘ|ψ⟩ and a renormalized post-measurement state — the single bridge between quantum amplitudes and classical data. Projective measurements are the special case you will use daily; POVMs are the general one, and they matter whenever you care about outcome statistics rather than what survives. This is also where irreversibility enters the theory: measurement is the one non-unitary move in the game.
Composite systems live in the tensor product — which is why n qubits carry 2ⁿ amplitudes, and why some joint states, the entangled ones, refuse to factor into anything the parts own separately. Prove it on |Φ⁺⟩ = (|00⟩+|11⟩)/√2: a product state (α|0⟩+β|1⟩)⊗(γ|0⟩+δ|1⟩) would need αγ and βδ nonzero while αδ = βγ = 0 — contradiction. The four Bell states are the currency of Phases 2 and 4 (teleportation, superdense coding, purification); learn to mint them with one H and one CNOT.
You're learning to speak the language the universe uses to say "yes and no" at once. Read the postulates slowly. Everything that follows is commentary.
Two weeks to learn that every quantum computation is choreography — a finite sequence of rotations of very high-dimensional spheres. You will prove that a shockingly small repertoire suffices for everything, learn the rewrite rules that make circuits legible, and run your first real protocols: teleportation and superdense coding, entanglement spent two opposite ways.
X, Y, Z square to the identity, anticommute in pairs, and multiply by the cyclic rule XY = iZ — a four-element algebra you should compute in without ever writing a matrix. Exponentiating them yields the rotation gates Rn̂(θ) = e^{−iθ n̂·σ/2}, and the Z–Y decomposition U = e^{iα}Rz(β)Ry(γ)Rz(δ) says every single-qubit unitary is three rotations and a phase. After this week H, S and T stop being symbols and become specific turns of the Bloch sphere from Phase 1.
The universality proof is a chain of three reductions: any d-dimensional unitary factors into two-level unitaries; any two-level unitary is built from CNOTs plus single-qubit gates (Gray codes route the two levels together); and single-qubit gates come from the continuous set. Then the Solovay–Kitaev theorem makes it practical: a finite set like {H, T, CNOT} approximates any unitary to precision ε with only O(log^c(1/ε)) gates. This theorem is why "quantum computer" is one well-defined notion rather than a zoo of incomparable machines.
HXH = Z, HZH = X, Hadamards on both wires flip a CNOT's control and target, and the Pauli-propagation rules tell you how errors move through circuits — a small algebra of rewrites that makes circuit reasoning fast instead of forensic. Add the two structural principles: deferred measurement (measurements commute to the end of a circuit) and implicit measurement (unterminated wires may be assumed measured). These identities are the difference between reading circuits and re-deriving them, and they return in force in the stabilizer formalism of Phase 5.
One shared Bell pair, spent two opposite ways: teleportation moves an unknown qubit using two classical bits, and superdense coding moves two classical bits using one qubit — dual protocols that fix the exchange rate between ebits, qubits and bits. Track the algebra honestly and you will see that teleportation neither clones (measurement destroys the original) nor signals faster than light (nothing is readable until the classical bits arrive). These ten lines of algebra are the "hello, world" of quantum information — and your first nontrivial Qiskit run.
Every computation is a rotation. Learn to choreograph the dance — and to prove that four moves suffice for all of them.
Four weeks, five algorithms, and the two ideas — Fourier sampling and amplitude amplification — behind every known quantum speedup. The arc is deliberate: toy separations (Deutsch–Jozsa) grow into an exponential one (Simon), Simon's structure mutates into Shor, and Grover closes the phase with the rare pleasure of an algorithm proved exactly optimal.
The function you interrogate is packaged as a reversible unitary Of|x⟩|b⟩ = |x⟩|b ⊕ f(x)⟩, and cost is counted in queries, not gates. The model matters because it is where quantum advantage can actually be proven: nobody can yet prove P ≠ BQP, but exact query separations are theorems — polynomial for Grover, exponential for Simon. Every algorithm in this phase, and both lower bounds, lives inside this frame; get its rules straight before trusting any speedup claim.
Feed the oracle a target qubit in |−⟩ and the answer never lands in the register at all — it lands in the sign: Of|x⟩|−⟩ = (−1)^{f(x)}|x⟩|−⟩. Data becomes phase, and phase is exactly what interference can act on; that one-line identity is the mechanism inside Deutsch–Jozsa, Bernstein–Vazirani, Grover's oracle, and — in its controlled-U, eigenvalue form — phase estimation. Learn it as a lemma and cite it as a lemma; half the derivations this month collapse to it.
Promise: f is constant or balanced. One quantum query decides which, with certainty; a deterministic classical algorithm needs 2^{n−1}+1. The whole computation is three moves — H^{⊗n}, kickback query, H^{⊗n} — and the entire answer sits in the amplitude of |0…0⟩: magnitude 1 if constant, exactly 0 if balanced. Be equally fluent in the fine print: a randomized classical algorithm does almost as well, so the promise is doing real work — knowing what a separation does not show is part of owning it.
f is 2-to-1 with a hidden XOR mask: f(x) = f(y) exactly when y = x ⊕ s. Each run of the circuit returns a uniformly random y with y·s = 0 (mod 2); after about n runs, linear algebra over 𝔽₂ recovers s — expected O(n) quantum queries against a provable classical Ω(2^{n/2}) (a birthday-collision argument). This is the first exponential separation, and it inspired Shor directly: swap XOR-period for multiplicative period, swap H^{⊗n} — the Fourier transform over ℤ₂ⁿ — for the QFT over ℤ_N, and factoring falls.
|x⟩ ↦ (1/√N) Σy e^{2πixy/N}|y⟩ — and the miracle is the product formula: the N-point transform factors into n unentangled single-qubit states, so Hadamards plus controlled phase rotations implement it in O(n²) gates, against the classical FFT's O(n2ⁿ) for the same vector. The catch that keeps this from trivializing everything: the Fourier coefficients live in amplitudes you cannot read out. The QFT is not a fast Fourier calculator — it is a periodicity detector, a subroutine whose killer application is phase estimation.
Given U and an eigenstate |u⟩ with U|u⟩ = e^{2πiφ}|u⟩, controlled-U^{2^j} powers kick the phases 2^jφ onto a t-qubit control register, and the inverse QFT converts that pattern into the binary expansion of φ. When φ has exactly t bits the answer is certain; in general t = n + ⌈log(2 + 1/2ε)⌉ control qubits give n-bit accuracy with probability at least 1 − ε. This is the engine of the exponential speedups: Shor is phase estimation on modular multiplication, and quantum counting is phase estimation on the Grover iterate.
Two classical reductions frame one quantum step. Factoring N reduces to order-finding: for random x, if the order r of x mod N is even and x^{r/2} ≢ −1 (mod N), then gcd(x^{r/2} ± 1, N) is a nontrivial factor — and number theory guarantees that good case with probability ≥ 1/2. The quantum step is phase estimation on U: |y⟩ ↦ |xy mod N⟩, whose eigenphases are the fractions s/r; the continued fractions algorithm then extracts r from the measured approximation. End to end: factoring in polynomial time, and the reason RSA carries an expiry date.
Draw the plane spanned by the marked state |w⟩ and the uniform state |s⟩: the oracle is a reflection about the unmarked axis, the diffusion operator a reflection about |s⟩, and two reflections compose to a rotation by 2θ, where sin θ = 1/√N. Each iteration turns the state 2θ closer to |w⟩, so ⌊(π/4)√N⌋ iterations land almost exactly on it — and overshooting is real, which is why the count matters. Then the BBBV theorem closes the door: a hybrid argument shows any quantum algorithm needs Ω(√N) queries. Grover is optimal, and quantum brute force against NP buys a square root — no more.
Shor's algorithm is why cryptographers lose sleep. Understand the order-finding reduction end to end, and you understand the stakes.
Three weeks in which the state vector gives way to the density matrix — the honest description of a qubit that is noisy, watched, or entangled with something you cannot see. This is the mathematics of imperfection, and it ends in two of the field's sharpest theorems: what a qubit can never carry (Holevo) and what no machine can ever do (clone).
When you don't know which pure state you hold — or your qubit is entangled with something offstage — the density matrix ρ = Σᵢ pᵢ|ψᵢ⟩⟨ψᵢ| is the complete description: positive, unit trace, with tr(ρ²) = 1 exactly for pure states. The partial trace is the only consistent way to describe a subsystem, and it delivers the phase's first shock: each half of a Bell pair, taken alone, is I/2 — pure noise, every trace of the correlation invisible locally. And distinct ensembles producing the same ρ are physically indistinguishable, the fact that keeps quantum cryptography honest.
Every mixed state ρA is the partial trace of some pure state |ψ⟩AB on a larger system — mixedness is never fundamental, it is entanglement with somewhere you are not looking. The tool is the Schmidt decomposition |ψ⟩ = Σᵢ √λᵢ|iA⟩|iB⟩, which hands you both reduced states at once (same spectrum!) and a clean entanglement measure for pure states. All purifications of a given ρ differ only by a unitary on the ancilla — a small theorem that does heavy lifting throughout quantum information.
Open-system dynamics — noise — is a completely positive trace-preserving map, and the operator-sum representation makes it concrete: ε(ρ) = Σₖ EₖρEₖ† with Σₖ Eₖ†Eₖ = I. The physical picture and the algebraic one are the same theorem: couple to an environment, evolve unitarily, trace the environment out, and the Kraus operators fall out of the environment basis. Learn the three canonical channels — depolarizing, amplitude damping, phase damping — as fluently as the Paulis; they are the enemies Phase 5's codes are built to fight.
S(ρ) = −tr(ρ log ρ): zero exactly on pure states, maximal log d on the maximally mixed state, concave, subadditive — Shannon's entropy inherited by density matrices. Its teeth show in the Holevo bound: the classical information extractable from an ensemble is at most χ = S(ρ) − Σᵢ pᵢS(ρᵢ), hence n qubits carry at most n classical bits, however cleverly you encode. A continuum of amplitudes, one retrievable bit per qubit — the theorem that disciplines every breathless headline about quantum bandwidth.
Suppose a unitary copies: U|ψ⟩|0⟩ = |ψ⟩|ψ⟩ for all |ψ⟩. Apply it to two states and take inner products — ⟨ψ|φ⟩ = ⟨ψ|φ⟩², so ⟨ψ|φ⟩ ∈ {0, 1}: cloning works only for states you could have distinguished classically anyway. Equivalently, cloning is quadratic in |ψ⟩ while unitaries are linear — contradiction in three lines, and consequences everywhere: quantum key distribution is secure, teleportation must destroy its input, unknown states cannot be amplified, and Phase 5's error correction must protect a state it is forbidden to copy.
Information is physical. Here you learn exactly how much — and exactly what you are forbidden to copy.
Three weeks against the strongest objection to the whole enterprise: real qubits decohere, and you may neither copy them nor look at them. The escape route runs from a three-qubit toy to Shor's nine, through the stabilizer language that modern hardware speaks, and ends at the threshold theorem — the result that turned quantum computing from a thought experiment into an engineering program.
Classical error correction copies; quantum cannot (no-cloning). Classical errors are discrete flips; quantum errors are continuous rotations. And you may not even look — measurement destroys the state you are protecting. The 3-qubit bit-flip code threads all three needles at once: encode α|0⟩+β|1⟩ as α|000⟩+β|111⟩, then measure only the parities Z₁Z₂ and Z₂Z₃ — the syndrome names the error while revealing nothing about α and β. Conjugating by Hadamards turns the same construction against phase flips.
Concatenate: guard against phase flips with the 3-qubit phase code, then guard each of its qubits against bit flips — nine qubits that correct any single-qubit X, Z, or Y = iXZ. Then the theorem that makes QEC possible at all: an arbitrary error — any rotation, any environmental coupling, even partial decoherence — is a linear combination of {I, X, Y, Z}, and the syndrome measurement projects onto exactly one of those discrete cases. You correct a continuum by correcting four things; the measurement itself discretizes the error.
Stop tracking 2ⁿ amplitudes; track symmetries instead. A stabilizer code is the joint +1 eigenspace of an abelian subgroup of the Pauli group: n − k independent generators fix a 2^k-dimensional code space, and an error is detected exactly when it anticommutes with some generator — the syndrome is just that pattern of anticommutations. The formalism turns Phase 2's circuit identities into a decoding machine, and the Gottesman–Knill theorem adds a sharp philosophical lesson: stabilizer circuits are classically simulable, so quantum power does not live where you'd first guess.
Calderbank–Shor–Steane: take classical codes C₂ ⊂ C₁ with the right dual-containment, and you inherit a quantum code — X errors are caught by one classical parity check, Z errors by the other, because Hadamard swaps the two pictures. The showpiece is Steane's [[7,1,3]] code, built from the classical [7,4] Hamming code, correcting an arbitrary single-qubit error with two fewer qubits than Shor's nine. CSS is the bridge that imports fifty years of classical coding theory into the quantum world — and the ancestor of the surface codes real hardware runs today.
Codes assume perfect machinery — but the correction circuitry is itself noisy, and a careless syndrome extraction spreads errors faster than it heals them. Fault tolerance is the discipline of transversal gates and verified ancillas that keeps one fault one fault; concatenation then maps error rate p to cp², and each level squares the improvement. The result is the threshold theorem: below a constant physical error rate pth, arbitrarily long quantum computation is possible at polylogarithmic overhead. This statement — not any algorithm — is why the field is an engineering program rather than a bet.
To protect a fragile thing, you must first understand exactly how it breaks. This is where quantum computing stops being a thought experiment.
Every week ships three artifacts, without exception: one problem set (~10–12 exercises from the current phase's assigned ranges), one LaTeX proof write-up destined for the vault, and one Qiskit lab notebook that turns the week's mathematics into a running circuit. The vault checklist above is the semester's ledger — seven entries, weeks 1–14.
This is the primary path to UvA's Quantum Computing Science master's and the research at QuSoft / ILLC. De Wolf's notes aren't just a text — they're the voice of the program you're aiming at. Linear algebra feeds it; the physics track gives it a soul; the BBBV proof gives it teeth.