Syllabus

The program document itself, rendered live — every written item links straight into the app.

8 terms 38 courses 61/127 lessons written ~654 hours

😺⚛️ Quantum Meowchanics

Quantum Computing: From First Principles to AWS Braket

Where the cat is in a superposition of "understands quantum computing" and "does not" — until you measure it with the exercises.

A self-paced, university-degree-equivalent program that takes you from the postulates of quantum mechanics to professional-level applied quantum computing on AWS Braket, using the amazon-braket-sdk-python.

Level: upper-division undergraduate → early graduate (M.Sc. specialization). Assumed background: linear algebra, calculus, probability/statistics, undergraduate physics, strong Python, and comfort with proofs and abstraction. Total estimated effort: ≈ 480–540 hours of coursework + 40–80 hours capstone (+ ~72 hours for the optional Pre-Term).

How to Use This Program

  1. Read the dependency graph below first. Lessons assume their prerequisites. The spine is linear (Term 0 → 1 → 2 → 3 → 5), with Term 4 branching off after Term 2 and feeding the capstone.
  2. Do the math by hand. Every lesson has derivations and graded exercises (easy → hard) with solutions in collapsible <details> blocks. Attempt before you expand.
  3. Run the code. From Term 1 onward, lessons pair theory with runnable amazon-braket-sdk-python code. Everything defaults to the local simulator (free). On-demand simulators and QPUs cost money — see the ⚠️ cost callouts and Appendix A.
  4. Use the checkpoints. Each lesson ends with self-assessment questions. If you can't answer them, re-read before moving on.
  5. Set up your environment once, early. Work through Appendix A — Braket Setup and Appendix B — Python/NumPy Refresher before Term 1's first hands-on lesson.

Conventions

Element Convention
Math LaTeX: $…$ inline, $$…$$ block (renders on GitHub, Obsidian, MkDocs-Material).
Notation Dirac/bra–ket throughout; see Appendix C — Notation & Glossary.
Code Fenced ```python blocks; self-contained and commented.
Diagrams Mermaid where supported; ASCII circuit diagrams as fallback.
Citations Keyed to Appendix D — References (e.g. [NC] = Nielsen & Chuang).
Cost ⚠️ marks any step that incurs AWS charges. Local simulation is free.

Program-Level Learning Outcomes

On completion you will be able to:

  1. Formalize quantum states, operators, and measurements in Dirac notation over finite-dimensional Hilbert spaces, including density-matrix and open-system formalisms.
  2. Prove core results: no-cloning, the CHSH/Bell bound, and the correctness of Deutsch–Jozsa, Grover, Shor, and the variational principle.
  3. Analyze quantum speedups via query complexity and the BQP landscape — explaining why and when quantum computing helps, and where it does not.
  4. Implement, debug, and benchmark gate-based circuits and variational/hybrid algorithms on amazon-braket-sdk-python across local, on-demand (SV1/DM1/TN1), and QPU backends.
  5. Model noise, apply error mitigation, and reason about quantum error correction and the trade-offs of superconducting, trapped-ion, and neutral-atom hardware.
  6. Deliver a cost-aware, end-to-end project on real Braket infrastructure and report results like a practitioner.

Dependency Graph

flowchart TD
    T0["Term 0\nMath & Computational Foundations"] --> T1["Term 1\nQuantum Mechanics"]
    T1 --> T2["Term 2\nQuantum Computing Core"]
    T2 --> T3["Term 3\nQuantum Algorithms"]
    T1 --> T4["Term 4\nNoise, Hardware & QEC"]
    T2 --> T4
    T2 --> T5["Term 5\nApplied: AWS Braket"]
    T3 --> T5
    T4 --> T5
    T3 --> CAP["Capstone"]
    T5 --> CAP

    PRE["Pre-Term\nClassical → Quantum"] -.-> T1
    PRE -.-> T4

    LAB["Lab thread:\nBraket setup (App. A)"] -.-> T1
    LAB -.-> T2
    LAB -.-> T3
    LAB -.-> T4
    LAB -.-> T5

Key cross-term prerequisites (beyond the linear spine): density matrices (Term 1.5) → noise channels (Term 4.1) · QFT/QPE (Term 2.4) → Shor (Term 3.3) · variational methods (Term 3.5) → Hybrid Jobs (Term 5.5) · harmonic oscillator (Pre-Term P.5) → superconducting qubits (Term 4.4).

The Pre-Term (dotted) is optional: it covers the historical/wave-mechanics route into quantum mechanics (classical mechanics → old quantum theory → Schrödinger equation → hydrogen & spin). It can be taken in parallel with Term 0 and feeds intuition into Terms 1 and 4.

Syllabus

Status legend: ✅ written · 🚧 in progress · ⬜ planned.

Front Matter & Appendices

Pre-Term — From Classical to Quantum Mechanics · optional · 18 lessons, ~72 h

Course P.1 — Theoretical Mechanics c01-theoretical-mechanics/

Course P.2 — Radiation & the Old Quantum Theory c02-radiation-old-quantum/

Course P.3 — Wave–Particle Duality c03-wave-particle-duality/

Course P.4 — The Schrödinger Equation c04-schrodinger-equation/

Course P.5 — Bound States & 1D Potentials c05-bound-states/

Course P.6 — Angular Momentum & Central Potentials c06-angular-momentum/

Term 0 — Mathematical & Computational Foundations · ~16 lessons, ~70 h

Course 0.1 — Linear Algebra for Quantum Mechanics c01-linear-algebra/

Course 0.2 — Probability, Statistics & Information c02-probability-information/

Course 0.3 — Complex Analysis & Fourier Methods c03-fourier-methods/

Course 0.4 — Classical Computation & Complexity c04-computation-complexity/

Term 1 — Quantum Mechanics · ~19 lessons, ~90 h

Course 1.1 — The Postulates of Quantum Mechanics c01-postulates/

Course 1.2 — Qubits, Superposition & the Bloch Sphere c02-qubits-bloch/

Course 1.3 — Measurement c03-measurement/

Course 1.4 — Entanglement & Composite Systems c04-entanglement/

Course 1.5 — Density Matrices & Mixed States c05-density-matrices/

Course 1.6 — Dynamics c06-dynamics/

Term 2 — Quantum Computing Core · ~13 lessons, ~65 h

Course 2.1 — Gates & Circuits c01-gates-circuits/

  • ⬜ Single-Qubit Gates
  • ⬜ Multi-Qubit Gates
  • ⬜ The Circuit Model
  • ⬜ Your First Braket Circuits · Braket deep intro

Course 2.2 — Universality & Circuit Identities c02-universality/

  • ⬜ Universal Gate Sets
  • ⬜ Circuit Identities & Decompositions
  • ⬜ The No-Cloning Theorem

Course 2.3 — Foundational Protocols c03-protocols/

  • ⬜ Superdense Coding
  • ⬜ Quantum Teleportation
  • ⬜ GHZ States & Entanglement Swapping

Course 2.4 — Quantum Fourier Transform & Phase Estimation c04-qft-qpe/

  • ⬜ The Quantum Fourier Transform
  • ⬜ Phase Kickback
  • ⬜ Quantum Phase Estimation

Term 3 — Quantum Algorithms · ~18 lessons, ~95 h

Course 3.1 — Query Algorithms c01-query-algorithms/

  • ⬜ Oracles & the Query Model
  • ⬜ Deutsch–Jozsa
  • ⬜ Bernstein–Vazirani
  • ⬜ Simon's Algorithm

Course 3.2 — Amplitude Amplification & Grover c02-grover/

  • ⬜ Grover's Algorithm
  • ⬜ Amplitude Amplification
  • ⬜ Grover on Braket

Course 3.3 — Shor's Algorithm c03-shor/

  • ⬜ Number Theory for Shor
  • ⬜ Order Finding via QPE
  • ⬜ Shor's Algorithm
  • ⬜ Shor on Braket

Course 3.4 — Quantum Linear Algebra c04-hhl/

  • ⬜ Hamiltonian Simulation & Trotterization
  • ⬜ The HHL Algorithm

Course 3.5 — Variational Quantum Algorithms c05-variational/

  • ⬜ The Variational Principle & VQE
  • ⬜ VQE on Braket
  • ⬜ QAOA
  • ⬜ QAOA on Braket

Course 3.6 — Quantum Complexity Theory c06-complexity/

  • ⬜ BQP & Quantum Complexity

Term 4 — Noise, Hardware & Error Correction · ~14 lessons, ~75 h

Course 4.1 — Open Quantum Systems & Noise c01-open-systems/

  • ⬜ Open Systems & Decoherence
  • ⬜ Kraus Operators & Channels
  • ⬜ Common Noise Channels
  • ⬜ Noise Simulation on Braket

Course 4.2 — Error Mitigation c02-error-mitigation/

  • ⬜ Mitigation Techniques (ZNE, Readout, PEC)
  • ⬜ Mitigation on Braket

Course 4.3 — Quantum Error Correction c03-qec/

  • ⬜ Classical vs. Quantum Codes
  • ⬜ The Stabilizer Formalism
  • ⬜ Shor & Steane Codes
  • ⬜ Surface Code Introduction

Course 4.4 — Qubit Modalities & Hardware c04-hardware/

  • ⬜ Superconducting Qubits
  • ⬜ Trapped-Ion Qubits
  • ⬜ Neutral-Atom & Photonic
  • ⬜ Benchmarking & Metrics

Term 5 — Applied Quantum Computing on AWS Braket · ~18 lessons, ~95 h

Course 5.1 — Braket Fundamentals c01-fundamentals/

  • ⬜ Architecture & Setup
  • ⬜ Circuits, Gates & Result Types
  • ⬜ Program Types & IR

Course 5.2 — Simulators c02-simulators/

  • ⬜ Local Simulators
  • ⬜ On-Demand Simulators (SV1, DM1)
  • ⬜ Tensor-Network Simulator (TN1)

Course 5.3 — Running on QPUs c03-qpus/

  • ⬜ Devices & Paradigms
  • ⬜ Tasks, Shots & Queues
  • ⬜ Cost Awareness & Guardrails
  • ⬜ Compilation & Device Constraints

Course 5.4 — Noise & Mitigation on Braket c04-noise-mitigation/

  • ⬜ Noise Models on Braket
  • ⬜ Mitigation on Hardware

Course 5.5 — Hybrid Jobs c05-hybrid-jobs/

  • ⬜ Braket Hybrid Jobs
  • ⬜ Parametric Compilation & Batching
  • ⬜ Variational Workloads at Scale

Course 5.6 — PennyLane & Quantum ML c06-pennylane-qml/

  • ⬜ The PennyLane–Braket Plugin
  • ⬜ Quantum Machine Learning
  • ⬜ QML on Braket

Capstone — End-to-End Braket Project · ~40–80 h

  • ⬜ Project Brief & Rubric
  • ⬜ Reference Project: QAOA MaxCut, End-to-End
  • ⬜ Alternative Projects

Resources — Supplementary Textbooks · ~32 h

Self-contained lesson sequences built alongside outside textbooks, for a second route up the same mountain. Not a prerequisite for anything in Terms 0–5.

Course R.1 — Introduction to the Quantum World (Freericks) c01-freericks-intro-quantum-world/

Course R.2 — Advanced Quantum Mechanics of Spin (Freericks) c02-freericks-advanced-spin/

Questionnaires

Transcribed practice quizzes for re-study, one file per quiz (questionnaires/YYYY-MM-DD-topic-slug.md, shape defined in questionnaires/TEMPLATE.md). Each entry renders in the app with its own open-study quiz.

Estimated Hours by Term

Term Focus Lessons Hours
Pre From Classical to Quantum Mechanics (optional) 18 ~72
0 Mathematical & Computational Foundations 16 ~70
1 Quantum Mechanics 19 ~90
2 Quantum Computing Core 13 ~65
3 Quantum Algorithms 18 ~95
4 Noise, Hardware & Error Correction 14 ~75
5 Applied Quantum Computing on AWS Braket 18 ~95
— Capstone 4 ~40–80
— Resources — Supplementary Textbooks (optional) 8 ~32
Total ~128 ~636–676

Reference Spine

The program aligns its terminology and notation with these canonical sources (full list and citation keys in Appendix D):

  • [NC] Nielsen & Chuang, Quantum Computation and Quantum Information — primary spine.
  • [Pre] Preskill, Caltech Ph219/CS219 lecture notes — depth, noise, QEC.
  • [Sak] Sakurai & Napolitano, Modern Quantum Mechanics — QM postulates & dynamics.
  • [Gri] Griffiths & Schroeter, Introduction to Quantum Mechanics — Pre-Term wave mechanics.
  • [Wat] Watrous, The Theory of Quantum Information — rigorous quantum info & channels.
  • [KLM] Kaye, Laflamme & Mosca, An Introduction to Quantum Computing — algorithm pedagogy.
  • [Aar] Aaronson, Quantum Computing Since Democritus — complexity intuition.
  • [AWS] Amazon Braket Developer Guide & SDK docs — applied track.

A Note on Time-Sensitive Material

Quantum hardware availability and AWS pricing change frequently. Code targets the current amazon-braket-sdk-python (Python 3.11+) and is verified against the live SDK while each applied lesson is written, but always confirm device availability and pricing in the AWS Braket console before submitting paid tasks. Every charged operation is marked with ⚠️. No lesson submits a paid task automatically.

📱 The Web App

This curriculum ships with a static-first e-learning app (Angular 22) in quantum-meowchanics-app/: a lesson reader with rendered LaTeX and Mermaid, open-study quizzes built from each lesson's exercises, spaced-repetition flashcards, ⌘K full-text search, highlights & notes, a progress dashboard with certification, audio review, and offline/PWA support. Everything is generated from this repo — the syllabus above is the app's source of truth.

cd quantum-meowchanics-app
nvm use && npm install
npm start            # dev server → http://localhost:4200
npm run build        # fully prerendered static site → dist/

Docs live in quantum-meowchanics-app/README.md and quantum-meowchanics-app/docs/ (architecture, content-authoring conventions, features, development, deployment). When adding a lesson: write the .md, add its ✅ line to the syllabus above, then run npm run content:check.