A Map of This Track

A 211-chapter track is long. If you are standing at chapter 3 and looking ahead, the honest question is: is this going to turn into an endless parade of definitions, or does it go somewhere? This article is the one-page answer. It shows you the shape of the journey before you start walking it, names the four big arcs the 21 parts group into, tells you what you need and what you do not, and offers three different routes depending on what you actually want from quantum computing.

Treat this page as a reference. Come back to it if you lose track of where you are — every article in the track links back here. If you are a linear reader, click "Feynman's Argument" at the bottom and start. If you are a reader who wants to dive straight into Shor, the "Algorithm hunters" path below tells you exactly which chapters you can skip.

The promise, before the map

After 211 chapters, you will be able to do four things. This is the concrete return on the time investment.

You will be able to read a research paper on Shor's algorithm — follow every line, know why every step is there, and notice when an author is glossing over a subtlety. Quantum algorithms research is not a closed club. Once you have the language and the machinery, the frontier papers are surprisingly readable.

You will be able to read an IBM or Google circuit diagram and tell what it does — including the specific hardware constraints (native gates, connectivity, noise model) that shape real-world quantum programs. You will know why a circuit that looks identical on paper behaves differently on two different devices.

You will be able to derive an error-correcting code from first principles — the repetition code, the Shor code, the Steane code, and the surface code. The arithmetic of stabilizers is not hard; it just needs the foundations this track lays.

You will be able to build a simulator — a small Python program that takes a quantum circuit as input, tracks the 2^n amplitudes, applies gates as matrix multiplications, and samples measurement outcomes according to Born's rule. Five hundred lines of code. That is the entire stack of a NISQ-era research tool, and by chapter 60 you will have the knowledge to write it.

Those four capabilities are the concrete goals. Everything in the map below is aimed at one or more of them.

The shape of the journey — four narrative arcs

The 21 parts of this track are not a flat list. They group into four arcs, each with its own character.

Arc 1: Foundations (Parts 1–3)

The first three parts set up the vocabulary and the worldview before any serious computation happens.

• Part 1 — Setting the Stage (3 chapters). What a quantum computer is, Feynman's argument for why the field exists, and this map.
• Part 2 — Dirac Notation and Tensor Products (6 chapters). The symbolic language physicists use. Kets, bras, inner products, outer products, tensor products. Pure bookkeeping, no physics yet.
• Part 3 — Quantum Mechanics for Computer Scientists (12 chapters). The four postulates of quantum mechanics, rephrased in linear-algebra terms for someone who has not taken a physics course.

By the end of Arc 1 you have the language of the field, but no algorithms yet.

Arc 2: The computational model (Parts 4–7)

Next, you build the machine itself, gate by gate.

• Part 4 — The Qubit and Single-Qubit Gates (10 chapters). The Bloch sphere. The Pauli gates. The Hadamard. Rotation gates. Single-qubit measurement.
• Part 5 — Multi-Qubit Systems (10 chapters). Two qubits, entanglement, the CNOT gate, Bell states, the no-cloning theorem.
• Part 6 — Quantum Circuits (8 chapters). Circuit diagrams, gate decomposition, universal gate sets, a first look at Qiskit/Cirq.
• Part 7 — Foundational Protocols (8 chapters). Superdense coding, teleportation, entanglement swapping — the "toy" protocols that expose the physics without the algorithmic overhead.

By the end of Arc 2, you understand the model of computation itself. You can read any small circuit and compute what every qubit does at every step.

Arc 3: Algorithms (Parts 8–12)

Now the classic algorithms arrive in chronological and conceptual order.

• Part 8 — Early Quantum Algorithms (8 chapters). Deutsch, Deutsch–Jozsa, Bernstein–Vazirani, Simon's algorithm. The first proofs of quantum advantage, on structured oracle problems.
• Part 9 — The Quantum Fourier Transform (8 chapters). The mathematical engine of Shor's algorithm and much else. The QFT is the single most powerful primitive in the algorithm builder's toolbox.
• Part 10 — Shor's Algorithm (10 chapters). The factoring algorithm, from period-finding to the full arithmetic of modular exponentiation to resource estimates.
• Part 11 — Grover and Amplitude Amplification (10 chapters). The quadratic speedup for unstructured search, and its generalisations.
• Part 12 — Quantum Complexity Theory (10 chapters). BQP, QMA, QAOA, the Church–Turing thesis. The formal place where quantum computing sits inside complexity theory.

By the end of Arc 3, the classic quantum algorithms are a reflex. You can derive Grover's algorithm on paper without looking. You can explain Shor's to someone else.

Arc 4: Beyond the ideal (Parts 13–21)

The last nine parts leave the Platonic world of perfect gates and unlimited qubits, and confront the real one.

• Part 13 — Density Matrices and Quantum Channels (10 chapters). Mixed states, noise, the density-matrix formalism needed to describe real hardware.
• Part 14 — Quantum Error Correction (15 chapters). The repetition code, stabilizer codes, the Shor and Steane codes, the surface code. This is the longest part of the track because it is the hardest and the most central.
• Part 15 — Hamiltonian Simulation (8 chapters). Trotterisation, LCU methods, qubitisation. The algorithmic version of Feynman's argument.
• Part 16 — NISQ-Era Algorithms (14 chapters). VQE, QAOA, warm-start algorithms, quantum machine learning. What a real quantum computer in 2025 can actually run.
• Part 17 — Quantum Cryptography and Post-Quantum Crypto (11 chapters). BB84, E91, device-independent QKD, and the post-quantum classical cryptography that Shor's algorithm makes necessary.
• Part 18 — Physical Implementations (14 chapters). Superconducting, trapped-ion, neutral-atom, photonic, topological. Each platform's physics, strengths, and engineering trade-offs.
• Part 19 — Alternative Computational Models (12 chapters). Measurement-based quantum computing, adiabatic quantum computing, continuous-variable systems.
• Part 20 — Quantum Information Theory (12 chapters). Entanglement measures, the Holevo bound, quantum channel capacities, the no-communication theorem.
• Part 21 — Frontiers and How We Got Here (12 chapters). The history of the field, open problems, the long-term outlook, and the India-specific landscape.

Arc 4 is the longest, and most readers will dip into it selectively rather than reading it linearly. Error correction (Part 14) is the part you should read linearly if you read nothing else from Arc 4 — it is the part that decides whether the rest of the field becomes a useful engineering reality.

Prerequisites — a short, honest list

You need three things from mathematics. That is all.

Complex numbers. You need to know what a complex number is (a + bi with i^2 = -1), what its modulus |z| = \sqrt{a^2 + b^2} is, what its complex conjugate \bar{z} = a - bi is, and Euler's formula e^{i\theta} = \cos\theta + i\sin\theta. If you have met complex numbers in a Class 11 or Class 12 chapter, you have enough. If not, read the introduction to complex numbers before continuing; the algebra in this track uses them constantly.

Vectors and matrices. You need 2-dimensional column vectors (single-qubit states live here), 4-dimensional column vectors (two-qubit states), and occasionally 8-dimensional ones. You need to multiply a 2\times 2 matrix by a column vector, multiply two 2 \times 2 matrices, compute transposes, and take the inner product of two vectors (a row times a column). You do not need to invert matrices by hand, compute determinants of anything larger than 2 \times 2, or diagonalise anything bigger than 4 \times 4.

Basic probability. You know what P(\text{heads}) = 0.5 means. You know that probabilities of mutually exclusive events add, and probabilities of independent events multiply. That is enough for the first half of the track. For the second half you will want conditional probability and Bayes' rule, which you can pick up on the fly.

That is the floor. Anything beyond that — group theory, Fourier analysis, algebraic geometry, quantum mechanics — is either not needed or will be built up from scratch inside the track.

What you do NOT need

Three things people think they need, but do not.

Prior quantum mechanics. This track builds quantum mechanics from scratch in Part 3. If you took a physics course and remember the postulates, great — Part 3 will be review. If you did not, you will learn it in 12 chapters, from the ground up, in the minimum-sufficient form for a computer scientist. No partial differential equations, no Hermite polynomials, no hydrogen atom. The postulates are short: states are unit vectors, evolution is unitary, measurement is projective, composite systems are tensor products. That is what Part 3 teaches.

Qiskit, Cirq, PennyLane, or any installed software. Part 6 introduces Qiskit and walks through installation (inside a Docker container or a Colab notebook, for readers without Python on their phone). Before Part 6, you need a pencil, paper, and the web page. Every circuit diagram, every matrix calculation, every algorithm — worked out by hand. This is deliberate. The intuition only lands if you run the math yourself at least once.

A physics degree. The field is genuinely half physics, half computer science, and this track is written for the CS half. There is no Lagrangian mechanics, no field theory, no Schrödinger equation in its partial-differential form. The full physics version of quantum mechanics is much richer than the subset this track uses, and readers who want it should pair this track with a standard textbook like Griffiths or Sakurai. But for quantum computing specifically, the CS subset is enough.

How to use this track — three paths

The 211 chapters can be walked in more than one order.

Path 1 — The linear reader

Start at chapter 1, finish at chapter 211. One article per evening, seven months. This is the recommended path if you are not in a hurry and want the deep version. Each chapter is designed to be a single sitting; you should never have to read two articles to understand the third.

This path takes you through every arc in order. You will arrive at Shor's algorithm (Part 10) having derived the QFT (Part 9) from scratch. You will arrive at error correction (Part 14) having seen why entanglement matters (Part 5). The linear path maximises retention because the story builds.

Path 2 — The algorithm hunter

You want to understand Shor and Grover as quickly as possible. The shortest honest path:

• Parts 1–4 (chapters 1–34) — foundations, notation, QM for CS, single-qubit gates. You cannot skip these.
• Part 5 (chapters 35–44) — multi-qubit systems and entanglement. You cannot skip these either.
• Part 6 (chapters 45–52) — circuits. Skim, if you are comfortable with the notation from Part 5.
• Part 9 (chapters 69–76) — the quantum Fourier transform.
• Part 10 (chapters 77–86) — Shor's algorithm.
• Part 11 (chapters 87–96) — Grover and amplitude amplification.

That is about 80 chapters for the algorithm core. You can skip Parts 7, 8, 12 on a first pass and return if you need them.

Path 3 — The hardware engineer

You want to know how real quantum computers are built. After the foundations (Parts 1–4), jump directly to:

• Part 13 (chapters 131–140) — density matrices and quantum channels (the formalism of noise).
• Part 14 (chapters 141–155) — quantum error correction.
• Part 18 (chapters 176–189) — physical implementations.
• Part 19 (chapters 190–201) — alternative computational models.

This is about 80 chapters with a hardware focus. You will skip most of the algorithmic content and pick up the specific algorithms (Shor, Grover) later only if they become relevant to your engineering work.

Path 4 — The cryptographer

You care about the migration to post-quantum cryptography. After Parts 1–4:

• Part 9 — the QFT (needed for Shor).
• Part 10 — Shor's algorithm (the threat).
• Part 17 (chapters 161–171) — quantum cryptography and post-quantum crypto (the response).

Around 50 chapters and you will know what cryptographic systems quantum computers threaten, what they do not, what post-quantum cryptography replaces them with, and what the India-specific timeline looks like for UIDAI and NPCI.

The time budget — honestly

One article per evening is the design target. Each chapter is written to be completable in roughly 60–90 minutes, including the worked examples. Multiply by 211 and you get about seven months of reading at a weeknight pace, or three to four months if you are reading both weeknights and weekends.

Most readers will not read all 211 chapters. The point is that every chapter stands alone — you can dip in, read one, and leave. The article that teaches the Hadamard gate (chapter 23) does not assume you have read chapter 17. It links backward where it needs to, and it gives you what you need inline where the link is not practical.

A smaller, more realistic target for a student with one or two other subjects competing for time: 3–5 articles per week, for a full academic year. That gets you through the foundations and the algorithms with time to spare, and is probably the path most readers actually take.

If you are using the track to prepare for JEE Advanced — not directly, since QC is not on the syllabus, but as cover for the Class 12 physics and math you want stronger — the early parts (Arcs 1 and 2) are the ones to read. Complex numbers, vectors, probability all get a rigorous workout.

Common confusions about the track

• "I need to learn quantum mechanics first." You do not. Part 3 builds quantum mechanics from scratch for CS readers in 12 chapters. If you prefer the physics-heavy version (with Lagrangian mechanics, the hydrogen atom, angular momentum), you can read Griffiths or Sakurai alongside — but the track is self-contained.

• "I need to install Qiskit before I start." No. Installation and code arrive in Part 6 (chapter 45). For chapters 1–44, you use pencil and paper (and the KaTeX-rendered math on the page). Installing Qiskit before Part 6 is not wrong, but is not required, and in fact many readers find that holding off until they have the theoretical foundation makes the code land better.

• "I should skip to Shor's algorithm." You can — Shor is Part 10, and the "Algorithm hunter" path above is exactly this. But skipping to Shor without Part 9 (the quantum Fourier transform) is painful: every line of Shor uses the QFT, and a reader who does not understand the QFT is left memorising rather than understanding. Do Part 9 before Part 10. It is short.

• "Error correction is too advanced for me." It is not. Part 14 is the longest part of the track (15 chapters) because the concepts are layered, but each individual chapter is no harder than any other. The arithmetic of stabilizer codes is just linear algebra modulo 2. Do not skip Part 14 because it looks scary; do skip it only if you have no intention of ever caring about fault-tolerant quantum computing — which is a defensible choice for a reader who only wants to learn the algorithms.

• "Quantum computing is just hype and this track is a waste of time." This is worth naming because it comes up. The honest position: useful fault-tolerant quantum computing is probably a decade or more away, but the mathematical and physical ideas are beautiful, intellectually serious, and already yielding practical tools (post-quantum cryptography standards, quantum-inspired classical algorithms, quantum sensing). If you read the track for the ideas, it is not a waste of time even if your hardware never arrives. If you read it because you think you will be writing production quantum code in 2027, adjust expectations.

Going deeper

What this track does not cover

The field of quantum is bigger than the field of quantum computing, and this track is narrow. It does not cover:

• Advanced quantum field theory — path integrals, renormalisation, gauge theory. Needed for particle physics, not for quantum computing.
• Black-hole thermodynamics and holographic entanglement — a live research area at the boundary of quantum gravity and quantum information, but adjacent rather than central to the computing side.
• String theory and its quantum-information cousins — beautiful mathematics, not relevant to programming a quantum computer.
• Detailed experimental physics — the track's Part 18 covers the computational essentials of each platform; the full experimental setup of a superconducting qubit fridge or a trapped-ion chamber is graduate-level experimental physics and is outside scope.
• Quantum-flavoured LinkedIn hype — the field has more promotional content than almost any other in CS. This track does not engage with marketing claims beyond the hype-check framing of chapter 1. If a commercial vendor's brochure contradicts something here, trust this.

How this track compares to other resources

There are four other major quantum-computing resources that a serious reader will eventually encounter.

Nielsen and Chuang — Quantum Computation and Quantum Information, Cambridge, 2010. The bible of the field. Rigorous, comprehensive, 700 pages. If this track is a walking tour, N&C is the definitive atlas. Read it after Part 6 as a companion. Not suitable as a first introduction unless you already have a strong math background.

John Preskill's Caltech lecture notes — freely online, graduate-level. Deep, elegant, demanding. Best for readers who have finished this track and want the research-level version. Preskill's chapter on quantum error correction is particularly good and complements Part 14.

The Qiskit textbook (online) — accessible, code-centric, IBM-produced. Excellent hands-on companion; weaker on the mathematical foundations than either this track or N&C. Read Part 6 of this track in parallel with the Qiskit textbook's introduction.

IBM Quantum Learning portal — interactive, modular, focused on Qiskit. Good for picking up a specific skill quickly. Not a substitute for a structured track.

This track is positioned between the Qiskit textbook (too code-centric, not enough math) and Nielsen-and-Chuang (too comprehensive for a first pass). The closest comparable in approach is Preskill, but written for a younger and less-prepared audience.

The pedagogical philosophy

Three design decisions are worth naming.

History first, postulates second, gates third. This track does not start with the postulates of quantum mechanics. It starts with a walk-through of why the postulates are what they are — Feynman's argument, the hype-calibration, and a concrete example (factoring 15) before any formal framework. The intent is that by the time Part 3 arrives with the postulates, the reader already has a picture in their head that the postulates are simply codifying. Tall and Vinner's research on concept image versus concept definition motivates this choice: students who build a concept image first absorb the formal definition more successfully.

Shor before Grover, despite Grover being easier. The standard textbook ordering is "Grover first because it is simpler, Shor second because it is harder." This track inverts that. The reason: Shor is structurally more illustrative. It shows why quantum matters — the exponential speedup from exploiting periodicity — in a way that Grover's quadratic speedup does not. A reader who has seen Shor first understands what "quantum advantage" actually means, and Grover becomes a much more comprehensible story afterwards. The cost is that Shor is harder; the mitigation is the eight chapters of Part 9 on the QFT that prepare you for it.

Chapters are one article each, not one section each. Some tracks break their material into many short pieces (the Qiskit textbook) or a few long ones (N&C). This track sits in between: each chapter is one complete idea, done to the level the gold-standard article sets. A chapter is not a paragraph of definition; it is a full exposition with a hook, two worked examples, common confusions, and a going-deeper layer. This is slower per chapter but produces readers who understand rather than recognise.

Contributing and feedback

If you find an error, a confusing passage, or a misconception this track perpetuates — the wiki is open to correction. Each article has an edit link (coming soon — at the moment, the feedback channel is email to the project lead). The most valuable feedback is: "I got stuck at this specific sentence because I did not know what X meant." That kind of report is what lets the track keep getting sharper.

Where this leads next

• Feynman's Argument — chapter 2, the 2^n-amplitude argument that founded the field. Read this if you have not already.
• Why Dirac Notation — chapter 4, the start of Arc 1's second leg. The symbolic language of quantum computing.
• What is Quantum Computing? — chapter 1, if you skipped it.
• The Bloch Sphere — chapter 14, the picture that single-qubit quantum computing revolves around.
• The Hadamard Gate — chapter 23, the gate that opens almost every quantum algorithm.

References

1. Nielsen and Chuang, Quantum Computation and Quantum Information — Cambridge University Press. The canonical QC textbook this track is built to complement.
2. John Preskill, Lecture Notes on Quantum Computation — theory.caltech.edu/~preskill/ph229. Free, deep, and the first reference once N&C feels too light.
3. Qiskit Textbook, Introduction to Quantum Computing — the circuit-and-simulator companion to any theory track.
4. IBM Quantum Learning, Courses and paths — hands-on hardware access and guided modules.
5. Wikipedia, Quantum computing — the one-page orientation to the field.
6. Government of India, National Quantum Mission — the Indian policy and funding landscape for quantum work.