If I hand you a Bell pair, a noisy backend, and a notebook, you should know what circuit to run, what quantity to estimate, and how to explain what the result means. That is the goal of this course. This course is about learning quantum information science by doing real work, not only by memorizing bra-ket notation. You will still learn the theory in depth, but each lecture is tied to a practical lab, a homework exercise, and a real software surface such as Qiskit, Azure Quantum and Q#, CUDA-Q, QuTiP, or PennyLane. The structure is grounded in Scott Aaronson's lecture notes, expanded with the core entanglement and mixed-state notes you shared, and organized so you can teach it as a practical build-and-experiment course. ## What You Will Learn You will move through this workflow: ```mermaid flowchart TD A["Linear algebra and probability intuition"] --> B["Single-qubit states and circuits"] B --> C["Entanglement, density matrices, and communication protocols"] C --> D["Quantum algorithms and complexity experiments"] D --> E["Hamiltonians, adiabatic methods, and noise studies"] E --> F["Error correction, stabilizers, and hardware-aware capstone work"] ``` By the end, you should be able to move between circuit diagrams, density matrices, algorithmic speedups, noise models, and real SDKs without treating them like separate subjects. ## Course Structure Start with these pages: - [[Roadmap]] - [[Quantum Code Map]] - [[Source Reading Guide]] - [[Resources]] - [[Review Questions]] - [[Glossary]] - [[Final Capstone Workflow]] - [[concepts/Extended Church-Turing Thesis]] - [[concepts/Pure vs. Mixed States]] - [[concepts/Separable vs. Entangled States]] - [[concepts/Quantum Error Correction]] ## How To Use This Course Move through the course in this order: 1. read the lecture note for the concept 2. run the primary lab in Qiskit 3. port or compare the same idea in a second tool when it matters 4. write down what changed between ideal simulation, noisy simulation, and hardware 5. finish the homework by combining derivation, code output, and explanation The practical rhythm for each lecture is: - concept and derivation - circuit or simulation lab - comparison across tools or backends - homework with both math and experiment interpretation > [!info] Practical stack > Use this stack throughout the course. > - Primary path: [IBM Quantum Learning and Qiskit](https://quantum.cloud.ibm.com/learning/en), [IBM Quantum](https://quantum.cloud.ibm.com/) > - Secondary path: [Microsoft Quantum and Azure Quantum documentation](https://learn.microsoft.com/en-us/azure/quantum/), [Copilot in Microsoft Quantum and Q# browser workflows](https://learn.microsoft.com/en-us/azure/quantum/get-started-azure-quantum) > - High-performance simulation: [NVIDIA CUDA-Q](https://developer.nvidia.com/cuda-q) > - Dynamics and open systems: [QuTiP](https://qutip.org/) > - Variational and QML extensions: [PennyLane demonstrations](https://pennylane.ai/qml/demonstrations) > - Optional ecosystem references: [Google Quantum AI](https://quantumai.google/resources), [Classiq](https://www.classiq.io/insights#Algorithms), [Q-CTRL Black Opal](https://q-ctrl.com/black-opal), [Amazon Braket](https://aws.amazon.com/braket/) ## Companion Code Repository The runnable code for this course should live separately from the Obsidian notes: > [!info] Course code > - repo overview: [README.md](https://github.com/montekkundan/quantum-code/blob/main/README.md) > - code map: [COURSE_MAP.md](https://github.com/montekkundan/quantum-code/blob/main/COURSE_MAP.md) > - notebooks: [notebooks/](https://github.com/montekkundan/quantum-code/tree/main/notebooks) > - tested helpers: [qcourse/](https://github.com/montekkundan/quantum-code/tree/main/qcourse) > - tests: [tests/](https://github.com/montekkundan/quantum-code/tree/main/tests) > - Q# comparison lane: [qsharp/](https://github.com/montekkundan/quantum-code/tree/main/qsharp) > - capstone workflow: [capstone/](https://github.com/montekkundan/quantum-code/tree/main/capstone) > - lecture-side map: [[Quantum Code Map]] The public link target is [github.com/montekkundan/quantum-code](https://github.com/montekkundan/quantum-code). ## How The Code Should Be Used Each concept note has a direct `Course code` block near the top. Use it as a three-part reading path: 1. open the per-concept notebook in `notebooks/by_concept/` 2. inspect the matching helper module in `qcourse/` 3. check the matching test file to see which scientific invariant is protected The broad unit notebooks remain the better live-teaching surface: - [state rules](https://github.com/montekkundan/quantum-code/blob/main/notebooks/01_foundations/state_rules.ipynb) - [Bell states](https://github.com/montekkundan/quantum-code/blob/main/notebooks/02_entanglement/bell_states.ipynb) - [teleportation and CHSH](https://github.com/montekkundan/quantum-code/blob/main/notebooks/03_protocols_bell_crypto/teleportation_chsh.ipynb) - [Deutsch-Jozsa, BV, Grover, and QFT](https://github.com/montekkundan/quantum-code/blob/main/notebooks/04_algorithms/deutsch_bv_grover_qft.ipynb) - [Hamiltonians and noise](https://github.com/montekkundan/quantum-code/blob/main/notebooks/05_hamiltonians_noise/hamiltonian_basics.ipynb) - [QEC and stabilizers](https://github.com/montekkundan/quantum-code/blob/main/notebooks/06_qec_stabilizers/qec_starter.ipynb) The course is practical only if the notebook output, helper implementation, and written explanation agree. If they disagree, treat that as a debugging exercise rather than a formatting problem. Use [[Final Capstone Workflow]] after Phase 6. It turns the course into a research-style deliverable: source-backed question, mathematical invariant, runnable implementation, simulator evidence, noise or hardware comparison, and a limitation section. ## Why This Course Exists Most quantum courses either stop at theory or jump into SDK demos without building the mathematical spine carefully enough. This one is meant to connect the two. You should be able to start from amplitudes, interference, tensor products, and density matrices, then move naturally into Bell tests, teleportation, query algorithms, Hamiltonian simulation, and error correction, while still knowing how to run circuits on real tooling. ## The Main Course Path The main path has six layers: ```mermaid flowchart TD A["Probability, amplitudes, and single-qubit mechanics"] --> B["Multi-qubit systems, mixed states, and entanglement"] B --> C["Communication, nonlocality, and cryptography"] C --> D["Universal circuits, query complexity, and core algorithms"] D --> E["Hamiltonians, adiabatic ideas, and realistic noise"] E --> F["Error correction, stabilizers, and capstone experiments"] ``` ## Day-By-Day Plan ### Phase 1: Foundations and Circuit Language | Day | Lecture Focus | Practical Lab | Homework | | --- | --- | --- | --- | | 1 | [[concepts/Extended Church-Turing Thesis]] | Set up Python, Jupyter, Qiskit, and IBM Quantum access. Build a first notebook that compares classical coin flips with Hadamard-based measurements. | Explain locality, local realism, and the Extended Church-Turing Thesis in plain language, then connect them to one concrete experiment. | | 2 | [[concepts/Probability Theory and Quantum Mechanics]] | Simulate single-path vs two-path interference with single-qubit gates and measurement counts. Reproduce constructive and destructive interference in Qiskit. | Derive the Born rule examples by hand and explain why amplitudes violate ordinary monotonicity. | | 3 | [[concepts/Basic Rules of Quantum Mechanics]] | Prepare arbitrary one-qubit states, inspect statevectors, and compare global vs relative phase using Bloch sphere visualizations in Qiskit or Q#. | Compute measurement probabilities for several one-qubit states and explain why global phase is physically invisible. | | 4 | [[concepts/Quantum Gates and Circuits]] | Build a reusable gate notebook with X, Y, Z, H, S, T, and measurement blocks. Add a repeated-measurement experiment that shows a toy Zeno effect. | Write a short derivation of the bomb-testing idea and explain how repeated observation changes evolution. | ### Phase 2: Entanglement, Density Matrices, and Core QIS Structure | Day | Lecture Focus | Practical Lab | Homework | | --- | --- | --- | --- | | 5 | [[concepts/Separable vs. Entangled States]], [[concepts/Density Matrices and Partial Trace]] | Prepare product states and Bell states. Compare statevectors, measurement correlations, and tensor-product factorizations. | For a set of two-qubit states, decide which are separable and which are entangled, and justify each answer mathematically. | | 6 | [[concepts/Pure vs. Mixed States]] | Use Qiskit and QuTiP to construct density matrices, trace out subsystems, and compare a coherent superposition against a classical mixture. | Explain pure vs mixed states using rank, purity, and eigenvalues. Include one example where the diagonals match but the physics does not. | | 7 | [[concepts/Bloch Sphere and No-Cloning Theorem]] | Visualize one-qubit states on the Bloch sphere and try to design a cloning circuit, then show exactly where the linearity argument breaks it. | Prove the no-cloning theorem and explain why it matters for money, communication, and security. | | 8 | [[concepts/Quantum Money and Quantum Key Distribution]] | Implement BB84 in Qiskit, add an eavesdropper, and measure the error-rate signal that reveals interference. | Analyze how the intercept-resend attack changes the protocol statistics and why that exposes Eve. | | 9 | [[concepts/Superdense Coding]] | Build the full superdense-coding protocol, first on a simulator and then on hardware if queue access allows it. | Explain why one transmitted qubit plus shared entanglement can convey two classical bits. | | 10 | [[concepts/Quantum Teleportation]], [[concepts/GHZ States, Entanglement Swapping, and Monogamy]] | Implement teleportation and GHZ-state preparation. Add a second notebook for entanglement swapping and compare ideal vs noisy results. | Derive the teleportation correction rules and explain monogamy using reduced states. | | 11 | [[concepts/Schmidt Decomposition]], [[concepts/Entanglement Entropy]] | Write a NumPy notebook that computes Schmidt coefficients, reduced-density-matrix eigenvalues, Von Neumann entropy, and partial-transpose spectra for sample states. | Solve a full separability-analysis problem set on two-qubit pure and mixed states, including when entropy is and is not a valid entanglement measure. | ### Phase 3: Interpretations, Bell, Nonlocality, and Certified Randomness | Day | Lecture Focus | Practical Lab | Homework | | --- | --- | --- | --- | | 12 | [[concepts/Interpretations of Quantum Mechanics]] | Build a decoherence notebook that shows how coupling to an environment suppresses interference patterns in a toy model. | Write an operational comparison: which predictions are shared, and which parts are interpretation rather than experiment? | | 13 | [[concepts/Bell's Inequality and CHSH]] | Implement the CHSH game in Qiskit and compare the best classical strategy against the Bell-state strategy. | Derive the classical CHSH bound and explain where the quantum advantage enters. | | 14 | [[concepts/Nonlocal Games]] | Extend the CHSH notebook into a nonlocal-game module. Add a numerical exploration of the Tsirelson limit. | Explain why Bell nonlocality is stronger than classical correlation but still does not allow faster-than-light signalling. | | 15 | [[concepts/Einstein-Certified Randomness]] | Use Bell-violation data from simulation or hardware to build a toy randomness-certification notebook. Compare it to pseudorandom and classical noisy sources. | Explain why Bell violation gives stronger randomness evidence than ordinary sampling alone. | ### Phase 4: Universal Circuits, Query Models, and Quantum Algorithms | Day | Lecture Focus | Practical Lab | Homework | | --- | --- | --- | --- | | 16 | [[concepts/Universal Gate Sets]] | Use Qiskit transpilation to decompose unitaries into a native basis. Compare basis-gate choices across Qiskit, Q#, and CUDA-Q where possible. | Show how a small universal gate set can approximate richer operations. | | 17 | [[concepts/Quantum Query Complexity and Deutsch-Jozsa]] | Build oracle-based circuits for constant and balanced functions. Run Deutsch and Deutsch-Jozsa side by side with classical baselines. | Compare classical and quantum query counts and explain what the oracle model is really measuring. | | 18 | [[concepts/Bernstein-Vazirani and Simon's Algorithm]] | Implement BV fully, then Simon on a simulator. Add a notebook that extracts the hidden string or hidden xor relation from measurement results. | Solve the linear-algebra recovery step for Simon's algorithm and explain where the speedup comes from. | | 19 | [[concepts/RSA, Period Finding, and Shor's Algorithm]] | Build a classical RSA notebook first, then reduce factoring to period finding in a way that is transparent before the full quantum machinery appears. | Explain why period finding is the real core problem under the factoring story. | | 20 | [[concepts/Quantum Fourier Transform]] | Implement the QFT and inverse QFT, inspect phase kickback, and compare exact circuits against transpiled versions. | Derive the QFT on small basis states and estimate the gate cost. | | 21 | [[concepts/RSA, Period Finding, and Shor's Algorithm]] | Run a small-N order-finding workflow and use classical post-processing to recover factors. Add an optional Q# resource-estimator pass for the circuit. | Explain which parts of Shor are quantum, which parts are classical, and where noise hurts most. | | 22 | [[concepts/Grover's Algorithm]] | Build Grover search for one marked item, then visualize amplitude amplification over iterations. | Derive the optimal iteration count and explain the geometry of the rotation picture. | | 23 | [[concepts/Grover's Algorithm]] | Extend Grover to multiple marked items and small application-style oracles. Plot classical vs quantum query scaling. | Explain why quadratic speedup is powerful but not exponential, and where the BBBV argument limits black-box gains. | | 24 | [[concepts/Quantum Complexity Theory]] | Build a comparison notebook for search-style problems, collision-style intuition, and complexity-class summaries. | Write a short note on BPP, BQP, NP, and what this course does and does not claim about their relationships. | ### Phase 5: Hamiltonians, Adiabatic Ideas, and Realistic Physical Models | Day | Lecture Focus | Practical Lab | Homework | | --- | --- | --- | --- | | 25 | [[concepts/Hamiltonians]] | Use QuTiP or CUDA-Q to simulate time evolution under simple Hamiltonians, then translate one example back into circuit language. | Work through matrix exponentiation and explain how Hamiltonians generate continuous-time evolution. | | 26 | [[concepts/The Adiabatic Algorithm]] | Build a small two-level adiabatic evolution notebook and compare adiabatic intuition against a circuit-model version of the same task. | Explain the role of the spectral gap and when adiabatic reasoning becomes fragile. | ### Phase 6: Noise, Error Correction, and Fault-Tolerant Structure | Day | Lecture Focus | Practical Lab | Homework | | --- | --- | --- | --- | | 27 | [[concepts/Quantum Error Correction]] | Implement bit-flip and phase-flip codes, then build a syndrome-measurement notebook and a small Qiskit error-correction demo. | Fill in the syndrome table and explain how detection differs from correction. | | 28 | [[concepts/Stabilizer Formalism]] | Use a stabilizer simulator to compare Clifford-only circuits against full statevector simulation. Add a simple stabilizer-code experiment and a final capstone proposal. | Explain why stabilizer methods are classically tractable and how that shapes both simulation and code design. | ## Core Concept Sequence Use these notes as the conceptual spine when reviewing, teaching, or extending the course: - [[concepts/Pure vs. Mixed States]] - [[concepts/Separable vs. Entangled States]] - [[concepts/Density Matrices and Partial Trace]] - [[concepts/Schmidt Decomposition]] - [[concepts/Entanglement Entropy]] - [[concepts/Bell's Inequality and CHSH]] - [[concepts/Quantum Teleportation]] - [[concepts/Superdense Coding]] - [[concepts/Universal Gate Sets]] - [[concepts/Quantum Query Complexity and Deutsch-Jozsa]] - [[concepts/Quantum Fourier Transform]] - [[concepts/Grover's Algorithm]] - [[concepts/Hamiltonians]] - [[concepts/Quantum Error Correction]] - [[concepts/Stabilizer Formalism]] Those first six notes are especially important because they are where many students get lost. They need to be taught in dependency order: 1. pure vs mixed states 2. density matrices and reduced states 3. separable vs entangled 4. Schmidt decomposition 5. Von Neumann entropy 6. entanglement entropy and mixed-state caveats ## Accounts, Tools, and Infrastructure You May Need Later You do not need every tool on day 1. These matter later for the practical path: - [IBM Quantum](https://quantum.cloud.ibm.com/): primary cloud access for circuits, simulators, and hardware runs - [Amazon Braket](https://aws.amazon.com/braket/): optional multi-provider access - [Microsoft Quantum and Azure Quantum](https://learn.microsoft.com/en-us/azure/quantum/): Q#, workspace workflows, and provider comparisons - [NVIDIA CUDA-Q](https://developer.nvidia.com/cuda-q): accelerated simulation and hybrid workflows - [QuTiP](https://qutip.org/): density-matrix dynamics and open-system simulation - [GitHub](https://github.com/): notebooks, lab templates, and homework release workflow ## Suggested Reference Stack ### Primary text - Scott Aaronson, [Introduction to Quantum Information Science lecture notes](https://www.scottaaronson.com/qclec.pdf) ### Optional references - N. David Mermin, *Quantum Computer Science: An Introduction* - Thomas Wong, [Introduction to Quantum and Classical Computing](http://www.thomaswong.net/) - Ryan O'Donnell, [lecture notes](https://www.cs.cmu.edu/~odonnell/quantum15/) - Scott Aaronson, [Quantum Computing Since Democritus](https://www.scottaaronson.com/democritus/) - Scott Aaronson, [MIT notes](https://stellar.mit.edu/S/course/6/fa14/6.845/materials.html) - Scott Aaronson, [Barbados 2016 notes](https://www.scottaaronson.com/barbados-2016.pdf) - John Watrous, [lecture notes](https://cs.uwaterloo.ca/~watrous/QC-notes/) ### Suggested articles and papers - [Recent arXiv paper](https://arxiv.org/abs/2510.19751) - [Ewin Tang blog post](https://ewintang.com/blog/2025/04/22/open/) ### Video lectures and playlists - [MIT Open Learning Library 8.370.1x](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+8.370.1x+1T2018/about) - [MIT Open Learning Library 8.370.2x](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+8.370.2x+1T2018/about) - [MIT Open Learning Library 8.370.3x](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+8.370.3x+1T2018/about) - [MIT Open Learning Library 8.371.1x](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+8.371.1x+2T2018/about) - [MIT Open Learning Library 8.371.2x](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+8.371.2x+2T2018/about) - [MIT Open Learning Library 8.371.3x](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+8.371.3x+2T2018/about) - [MIT 6.845 Quantum Complexity Theory](https://ocw.mit.edu/courses/6-845-quantum-complexity-theory-fall-2010/) ### Blogs, commentary, and community - [Shtetl-Optimized](https://scottaaronson.blog/) - [Quantum Advantage Tracker](https://quantum-advantage-tracker.github.io/) - [IBM Quantum Blog](https://www.ibm.com/quantum/blog/) - [Google Quantum AI learning map](https://quantumai.google/learn/map) ### Simulators and hardware-specific references - Stabilizer circuits: [CHP simulator](https://www.scottaaronson.com/chp/) - Tensor-network and MPS direction: [CUDA-Q docs](https://nvidia.github.io/cuda-quantum/latest/index.html) - Related simulation paper: [arXiv:2512.24390](https://arxiv.org/abs/2512.24390) - Superconducting qubits: [UC Berkeley EE290 notes](https://qudev.notion.site/ee290), [Qiskit Metal](https://qiskit-community.github.io/qiskit-metal/) - Trapped ions: [IonQ docs](https://docs.ionq.com/) - Neutral atoms: [Pulser](https://github.com/pasqal-io/Pulser), [Bloqade](https://www.quera.com/bloqade) ### Hackathon and project ideas - [BlueQubit quantum advantage challenge](https://www.bluequbit.io/quantum-advantage-challenge) ## Optional Advanced Extensions The TA note said some topics were not covered in the original class but are worth adding. They fit naturally as extension weeks after the main path: - noise models and quantum channels - error mitigation beyond error correction - variational quantum algorithms and optimization - quantum machine learning - hardware-aware compilation and pulse-level ideas These are good places to use PennyLane, CUDA-Q, Azure Quantum resource estimation, and provider comparisons across IBM, IonQ, QuEra, and Braket. ## What You Should Know By The End By the end of the course, you should be able to: - explain how amplitudes, interference, and measurement differ from classical probability - move between ket notation, circuit notation, and density-matrix notation - tell pure, mixed, separable, and entangled states apart without hand-waving - compute reduced states, Schmidt coefficients, and entropy-based quantities correctly - implement communication and cryptography primitives such as BB84, teleportation, and superdense coding - build and explain the main textbook algorithms from Deutsch-Jozsa through Grover and Shor - discuss Hamiltonians, adiabatic ideas, and noise without treating them as unrelated topics - implement small error-correction and stabilizer workflows in real SDKs - compare ideal simulation, noisy simulation, and hardware results honestly ## Reading Order Follow [[Roadmap]] for the short navigation view of the course. Use [[Source Reading Guide]] to pair each concept note with the relevant sections of `qclec.pdf` and *Quantum Computing since Democritus*. For the detailed release order, use this page as the main entry point. ## References Behind This Course - Scott Aaronson, [Introduction to Quantum Information Science lecture notes](https://www.scottaaronson.com/qclec.pdf) - Scott Aaronson, *Quantum Computing since Democritus* - The public core-concept notes you shared on separability, entanglement entropy, and pure vs mixed states - IBM Quantum Learning, Microsoft Quantum and Azure Quantum docs, CUDA-Q docs, QuTiP docs, and PennyLane demos