Curriculum
0 → Hero
Follow the tracks in order, or jump to whatever scratches your itch. Every tutorial includes working code, intuitive explanations, and exercises.
foundations
What Is a Qubit? From Classical Bits to Quantum States
A ground-up introduction to qubits for developers who already know code. Bloch sphere, Dirac notation, the normalization constraint, and why a qubit is not just a probabilistic bit — with runnable Qiskit code.
Superposition, Measurement, and the Born Rule
Measurement turns amplitudes into probabilities and destroys superposition. This tutorial walks through the Born rule, measurement in different bases, the no-cloning theorem, and why you can't just peek at a qubit without breaking it — with runnable Qiskit code.
Multi-Qubit Systems and Entanglement
Tensor products, the 2ⁿ-dimensional state space, separable vs entangled states, the four Bell states, and why entanglement is the real secret ingredient of quantum computing. With runnable Qiskit code and a measurement-correlation experiment.
Bell's Theorem and the CHSH Inequality: How We Know the Universe Isn't Locally Realistic
Bell's theorem (1964) is the most-cited result in the foundations of quantum mechanics. It proves that no theory based on local hidden variables can reproduce all the predictions of quantum mechanics — and the CHSH form gives a quantitative inequality that experiments can test. Every loophole-free Bell test since 2015 has confirmed quantum mechanics. This tutorial derives the CHSH inequality, explains the Tsirelson bound, and covers what 'loophole-free' actually means.
The No-Cloning Theorem: Why Quantum Information Cannot Be Copied
The no-cloning theorem (Wootters-Zurek 1982; Dieks 1982) is the structural reason quantum information behaves differently from classical bits. There is no unitary operation that takes an unknown qubit and outputs two identical copies. This single result underlies quantum error correction's complexity, quantum cryptography's security, and the impossibility of quantum signal repeaters that simply amplify their input. This tutorial proves the theorem in three lines and walks through its consequences.
Density Matrices and Mixed States: The Formalism for Real Quantum Systems
Pure-state quantum mechanics ($|\psi\rangle$ vectors) is enough for textbook quantum computing but not for real hardware. Real qubits are noisy, partially-known, or part of larger entangled systems whose other parts you've ignored. The density matrix is the formalism that handles all three cases. This tutorial defines density matrices, derives their properties, covers the partial trace and the purification theorem, and shows why density matrices are the natural language of quantum-information theory.
The Bloch Sphere: Every Single-Qubit State Is a Point in Three Dimensions
The Bloch sphere is the geometric picture that makes single-qubit quantum mechanics intuitive. Every pure single-qubit state is a point on the surface of a unit sphere; every mixed state is a point inside. Single-qubit gates are rotations of this sphere. This tutorial constructs the Bloch sphere from the density-matrix formulation, derives the geometry of common gates, and shows how the picture extends (and fails to extend) to multi-qubit systems.
gates and circuits
Unitary Operators and the Universal Gate Set
Quantum gates are unitary matrices — reversible, norm-preserving operations on state vectors. This tutorial proves why, derives the universal {H, T, CNOT} set, and shows why any quantum computation decomposes into these primitives. With full Qiskit verification.
Pauli, Phase, and Rotation Gates
Every single-qubit gate is a rotation of the Bloch sphere. This tutorial derives the Pauli matrices, the phase gates (S, T), and the continuous Rx/Ry/Rz rotation family — and shows how to decompose any single-qubit unitary into three Euler-angle rotations. With visualizations and Qiskit verification.
Multi-Qubit Gates: CNOT, CZ, SWAP, Toffoli, and Controlled Everything
CNOT is the workhorse of entanglement, but the two-qubit gate zoo is richer than that. This tutorial walks through CZ, SWAP, iSWAP, Toffoli, and arbitrary controlled unitaries — plus the decomposition theorems that turn them all into CNOT + single-qubit primitives for real hardware.
OpenQASM 3 and Your First Real Hardware Run
Qiskit circuits are a convenience. OpenQASM 3 is the portable assembly language underneath — and what you actually send to hardware. This tutorial walks through the OpenQASM 3 syntax that matters, IBM Quantum's free tier, transpilation, and how to interpret noisy results honestly on your first real-hardware run.
The Solovay-Kitaev Theorem: Approximating Any Single-Qubit Unitary with Clifford+T
The Solovay-Kitaev theorem says any single-qubit unitary can be approximated to accuracy ε by a sequence of Clifford and T gates of length polylogarithmic in 1/ε. This is the structural reason fault-tolerant quantum computing can use a finite gate set without losing expressivity. The original proof gives O(log^3.97(1/ε)) gates; modern algorithms achieve nearly optimal O(log(1/ε)) for restricted classes. This tutorial covers the theorem, the algorithm, and the practical compilation tooling that descends from it.
Toffoli Decomposition and T-Count Optimization: How Reversible Logic Becomes Fault-Tolerant
The Toffoli gate (controlled-controlled-NOT) is the universal classical reversible gate, the building block of every quantum arithmetic circuit, and the dominant non-Clifford operation in most fault-tolerant algorithms. Naive Toffoli decomposition uses 7 T gates; Selinger's 2013 optimization uses 4; Jones-Glassman's measurement-based variant uses 3 with a small probability of failure. This tutorial covers the standard decomposition, the optimized variants, and the T-count optimization passes that follow.
Controlled-Unitary Synthesis: How to Build C-U for Arbitrary U
Quantum phase estimation, amplitude amplification, and block encoding all rely on controlled-unitary operations C-U for arbitrary U. The naive construction is via phase kickback through the eigenbasis; practical constructions go through Barenco-style multi-control decomposition, lazy controlled-U for amplitude amplification, and qubitization-style controlled block-encodings. This tutorial covers the standard constructions and their gate-count costs.
ZX-Calculus: A Visual Quantum Calculus for Circuit Optimization
ZX-calculus is a graphical rewriting language for quantum circuits, introduced by Coecke and Duncan in 2008. Quantum circuits become diagrams of green and red 'spiders'; circuit equivalences become diagrammatic rewrites. The 2017 completeness result and the PyZX 2019 toolchain made ZX a practical T-count optimization framework, and 2022-2024 results extend it to mixed states, error correction, and ground-state algorithms. This tutorial covers the core diagrammatic rules, the rewriting strategy, and what ZX delivers in production compilers.
algorithms
Deutsch-Jozsa: The First Quantum Speedup
The Deutsch-Jozsa algorithm separates constant from balanced Boolean functions in a single query, where classical deterministic algorithms need up to 2ⁿ⁻¹ + 1. This tutorial derives the algorithm from first principles, explains phase kickback, and walks through the full Qiskit implementation plus the Deutsch n=1 special case.
Bernstein-Vazirani and Simon: Learning Hidden Structure in One (or O(n)) Queries
Bernstein-Vazirani learns a hidden bit string in a single query. Simon's algorithm learns a hidden shift with O(n) queries where classical algorithms need exponentially many — and was the direct inspiration for Shor's factoring algorithm. This tutorial derives both from scratch with complete Qiskit implementations.
Grover's Search and Amplitude Amplification
Grover's algorithm finds a marked element in an unstructured list of N items with O(√N) queries — a provable quadratic speedup. This tutorial derives the algorithm geometrically as a rotation in a 2D subspace, gives the exact optimal iteration count, and shows how amplitude amplification generalizes the trick far beyond search.
Quantum Fourier Transform and Phase Estimation
The QFT is the quantum cousin of the classical discrete Fourier transform — but it runs in O(n²) instead of O(n·2ⁿ), which is where many quantum speedups ultimately come from. This tutorial derives the QFT circuit, explains Quantum Phase Estimation (the subroutine inside Shor, HHL, and VQE), and delivers complete Qiskit implementations.
Shor's Algorithm: Factoring, Order-Finding, and the End of RSA
Shor's factoring algorithm reduces integer factorization to the problem of finding the multiplicative order of a random element mod N — and uses quantum phase estimation to solve that in polynomial time. This tutorial derives the full algorithm, runs a small instance in Qiskit, and honestly assesses the real-world resource requirements to break RSA-2048.
Block Encoding: How Modern Quantum Algorithms Get Arbitrary Matrices Into Quantum Circuits
Block encoding is the most important quantum-algorithm primitive of the past decade. It is the technique that lets you embed an arbitrary matrix A into a unitary U so a quantum computer can act with A on a state — making Hamiltonian simulation, linear-system solvers, and the entire QSVT framework possible. This tutorial defines block encoding precisely, gives the key constructions (LCU, qubitization, sparse-matrix), and shows why this is the abstraction that ate quantum algorithms after 2015.
Quantum Singular Value Transformation: The Framework That Unified Modern Quantum Algorithms
QSVT is the algorithmic technique that takes a block encoding of A and produces a block encoding of p(A) for any low-degree polynomial p — turning matrix arithmetic on quantum computers into a uniform framework. Hamiltonian simulation, linear-system solvers, eigenvalue estimation, and ground-state preparation are all polynomial choices in QSVT. This tutorial builds the construction from qubitization and shows the four-line argument that makes QSVT the most cited quantum-algorithm technique of the late 2010s.
Hamiltonian Simulation: From Trotter to Qubitization, the Modern Picture
Hamiltonian simulation — computing the quantum dynamics e^(-iHt) for a chemistry, materials, or condensed-matter Hamiltonian — is the original quantum-computing application Feynman pitched in 1981 and arguably the application most likely to deliver real value first. This tutorial covers the four standard algorithm families (product formulas, LCU/Taylor series, qubitization, QSVT-based simulation), their cost scalings, and when to reach for each.
Amplitude Estimation: The Quadratic-Speedup Primitive Behind Quantum Monte Carlo
Amplitude estimation extends Grover's algorithm from 'find a marked element' to 'estimate the probability of a marked element' with quadratic precision speedup. It is the primitive that powers quantum Monte Carlo, financial pricing, and any algorithm that needs to estimate an expectation value to high precision. This tutorial covers the canonical Brassard-Hoyer-Mosca-Tapp construction, the modern iterative and maximum-likelihood variants, and the hard truth about whether real applications hit the quadratic speedup in practice.
Quantum Walks: Discrete and Continuous Time
Quantum walks are the quantum analog of classical random walks — and they spread quadratically faster on simple graphs, a polynomial speedup that underlies Grover, Shor's discrete-log, and several recent quantum algorithms. This tutorial covers discrete-time quantum walks (Szegedy and coined walks), continuous-time quantum walks, the speedup origin in interference, and where quantum walks turn into algorithmic primitives in 2026.
HHL: The Quantum Algorithm for Linear Systems and What Survived Dequantization
The Harrow-Hassidim-Lloyd algorithm (HHL, 2009) was the first quantum algorithm with exponential speedup over the best classical methods for solving sparse linear systems. It also became the most-discussed algorithm in machine learning, finance, and many applied domains — until Tang's 2018 dequantization revealed the exponential speedup depended critically on QRAM-like input access. This tutorial covers the algorithm, what HHL actually computes, the dequantization story, and the remaining regimes where HHL gives genuine speedups.
LCU: The Linear Combination of Unitaries Framework
Linear combination of unitaries (LCU) is a quantum-algorithm framework that lets you implement non-unitary linear operations on a quantum state, with cost proportional to the number of unitary terms. Together with block encoding (tutorial 29) and qubitization (tutorial 30), LCU is the structural backbone of modern Hamiltonian simulation, HHL-style algorithms, and many other quantum-algorithm primitives. This tutorial covers the LCU lemma, the cost structure, and where LCU shows up in production algorithms.
Quantum Phase Estimation Precision: How Many Qubits, How Many Queries
Quantum phase estimation (QPE) is the workhorse of quantum factoring, HHL, quantum chemistry, and more. The precision-resource tradeoff is exactly: t bits of phase precision require 2^t controlled-U queries. This tutorial covers the resource analysis, the Heisenberg limit, the iterative QPE variant that uses fewer ancilla qubits, and the modern QSVT-based replacement that beats QPE for many applications.
variational
Variational Quantum Eigensolver (VQE) From Scratch
VQE finds ground-state energies of quantum Hamiltonians using a hybrid classical-quantum loop. This tutorial derives the variational principle, explains Jordan-Wigner fermion encoding, builds an H₂ ground-state computation end-to-end in Qiskit, and honestly discusses barren plateaus and why the ansatz choice makes or breaks the algorithm.
QAOA for Combinatorial Optimization
QAOA encodes a combinatorial problem as a cost Hamiltonian, prepares a variational state by alternating cost and mixer evolutions, and uses a classical optimizer to find approximate solutions. This tutorial derives the MaxCut case from scratch, runs it in Qiskit, and honestly compares QAOA to classical baselines like Goemans-Williamson.
Barren Plateaus: Why Most Variational Quantum Algorithms Fail at Scale
Barren plateaus are the dominant theoretical limit on variational quantum algorithms. Past a modest qubit count, the gradients of typical parameterized quantum circuits vanish exponentially in the system size, making training infeasible. This tutorial covers the McClean 2018 result, the cost-function-dependent and noise-induced extensions, and the four mitigation strategies that have moved the field — and gives an honest verdict on whether variational quantum computing has a future at scale.
ADAPT-VQE: Building the Ansatz One Operator at a Time
ADAPT-VQE is the most-cited barren-plateau mitigation strategy in quantum chemistry. Instead of a fixed ansatz, ADAPT grows the ansatz adaptively, adding one operator at a time from a problem-defined pool, picking the operator with the largest gradient. The resulting ansatz is shorter than UCCSD, more accurate at modest qubit counts, and structurally easier to train. This tutorial covers the algorithm, the operator-pool design, the qubit-ADAPT variant, and the regimes where ADAPT wins versus where it doesn't.
The Parameter-Shift Rule: Computing Exact Quantum Gradients on Real Hardware
The parameter-shift rule is the standard exact-gradient method for variational quantum algorithms. Unlike finite differences, the rule produces unbiased gradient estimates with no truncation error, on real hardware, using only two extra circuit evaluations per parameter. This tutorial derives the rule from first principles, covers the generalized and stochastic variants for non-Pauli generators, and gives a decision rule for when parameter shift is the right gradient method.
Quantum Natural Gradient: Geometry-Aware Optimization for Variational Quantum Algorithms
Standard gradient descent ignores the geometry of the parameter space. Quantum natural gradient (Stokes 2020) uses the quantum Fisher information matrix to rescale parameter updates by the local curvature, reaching minima with fewer iterations and partially mitigating some barren-plateau-adjacent training pathologies. This tutorial covers the math, the block-diagonal approximation that makes it tractable, and a decision rule for when QNG is worth the per-step overhead.
Imaginary-Time Evolution: How Quantum Algorithms Find Ground States
Imaginary-time evolution is a classical numerical technique for finding ground states: replace t with -i*t in the Schrödinger equation, and the wavefunction projects onto the ground state exponentially fast. Quantum analogs — variational imaginary-time evolution (VITE), quantum imaginary time evolution (QITE), and the deep connection to quantum natural gradient (tutorial 40) — are now central to ground-state quantum algorithms. This tutorial covers the math, the algorithms, and the regimes where each variant shines.
Hamiltonian Variational Ansatz: How to Build Trainable Ansätze from the Problem Itself
The Hamiltonian variational ansatz (HVA) builds variational circuits directly from the structure of the target Hamiltonian. Unlike generic hardware-efficient ansätze, HVA inherits problem symmetries, often avoids barren plateaus, and naturally connects to adiabatic quantum computing. This tutorial covers HVA construction, the connection to the quantum approximate optimization algorithm (QAOA, tutorial 14), and the design principles that make problem-tailored ansätze the production choice for variational chemistry and optimization.
Warm-Start Strategies: Initializing Variational Quantum Algorithms in the Right Region
Random initialization of variational parameters typically lands in the barren-plateau region of the cost landscape. Warm-start strategies — initializing from classical solutions, adiabatic schedules, parameter transfer from smaller systems, or other principled choices — sidestep this. The 2024-2025 evidence shows warm-started VQE and QAOA routinely achieve 10-100× faster convergence than random initialization, and reach better local minima. This tutorial covers the main strategies and the regimes where each wins.
quantum ml
Quantum ML Foundations: Encoding, Variational Circuits, and the Parameter-Shift Rule
Quantum machine learning trains parameterized quantum circuits as models for classical data. This tutorial covers the three classical-to-quantum encoding strategies, the parameter-shift rule that makes gradient-based training possible, and a complete PennyLane example training a variational classifier on a real dataset.
Quantum Kernels and Feature Maps
Quantum kernels sidestep variational training entirely: they embed data into a quantum Hilbert space via a fixed feature map and use the inner product as a kernel for a classical SVM. This tutorial builds the ZZ feature map from Havlíček et al. 2019, implements a quantum SVC in Qiskit, and explains the reproducing-kernel view that unifies the approach.
Is QML Worth It? A Skeptic's Benchmark
Most published QML results test against toy baselines that serious classical ML would demolish. This tutorial runs a bake-off — variational QML, quantum kernels, XGBoost, and a small MLP — on real tabular data, surveys the 'dequantization' results that have taken quantum advantages back, and gives an honest recommendation on when to reach for QML vs not.
Tang Dequantization: How a Grad Student Took Back Years of Quantum-ML Speedups
In 2018, then-undergraduate Ewin Tang showed that a famous quantum-machine-learning algorithm (Kerenidis-Prakash recommendation systems) had a polynomial-time classical analog. Within two years, the same dequantization template had taken back claimed exponential speedups for several flagship QML algorithms. This tutorial covers the dequantization framework, what it does and doesn't take back, and the residual quantum-advantage candidates that survived.
Quantum Convolutional Neural Networks: Cong-Choi-Lukin and the Quantum-Data QML Story
Quantum convolutional neural networks (QCNNs) — Cong, Choi, and Lukin 2019 — are the QML architecture with the cleanest structural advantage on quantum-data inputs. They have a tree structure that avoids barren plateaus by construction, naturally implement renormalization-group-style coarse-graining, and are most useful for classifying quantum states (phases of matter, error syndromes, sensor outputs). This tutorial covers the architecture, the trainability proof, and the regimes where QCNNs actually win.
The Data-Loading Bottleneck: Why Quantum Machine Learning on Classical Data Rarely Delivers
The data-loading bottleneck is the structural reason most quantum machine learning on classical data does not deliver speedups. Loading $N$ classical bits into a quantum register typically costs $O(N)$ time — eating any algorithm's hoped-for $O(\log N)$ speedup. This tutorial covers the encoding options (amplitude, basis, angle), the QRAM construction and its open hardware question, and the regimes where the bottleneck is and is not binding.
Quantum Generative Models: Born Machines, Quantum GANs, and the Sampling-Class Advantage
Quantum generative models — born machines, quantum generative adversarial networks (QGANs) — sample from probability distributions defined by quantum states. Unlike classification or regression QML, generative QML has a clean structural quantum-advantage argument: there exist distributions that quantum circuits can efficiently sample from but classical algorithms cannot. This tutorial covers born machines, QGANs, the sampling-class complexity argument, and the regimes where quantum generative models can plausibly beat classical alternatives.
error correction
Noise and Decoherence: What Actually Goes Wrong on Real Qubits
Every tutorial up to here pretended qubits are perfect. They aren't. This tutorial covers the four main noise processes every quantum dev should know cold — relaxation, dephasing, depolarization, and readout error — with their Kraus operator forms, their T₁/T₂ signatures, and a runnable Qiskit experiment that measures them on a real device.
The Surface Code and Willow: What Below-Threshold Actually Means
Google's Willow chip (December 2024) was the first demonstration of a quantum error-correcting code with errors that decrease as you add qubits — the 'below threshold' result the field had chased for 30 years. This tutorial explains what the surface code is, why the threshold theorem matters, and what Willow's numbers imply for the path to fault-tolerant quantum computing.
Magic State Distillation: Where Fault-Tolerant Quantum Computers Actually Spend Their Qubits
The surface code makes Clifford gates cheap and T gates expensive — and a real fault-tolerant machine spends most of its qubits manufacturing the T gates. This tutorial builds magic state distillation from Bravyi-Kitaev 2005, walks through the 15-to-1 factory and what it actually costs in resource estimates, and dates the 2024-2026 frontier where the textbook story finally meets logical hardware.
The Clifford Group: The Easy Half of Quantum Computing
Half of the standard quantum gate library — H, S, CNOT, and everything they generate — is in a special set called the Clifford group. Clifford circuits are universal-looking but classically simulable, transversal on stabilizer codes, and the reason fault-tolerant quantum computing splits cleanly into 'easy' and 'expensive' work. This tutorial defines the group, proves the simulation result, and shows why this asymmetry shapes every real fault-tolerant roadmap.
The Eastin-Knill Theorem: Why No Quantum Code Can Have a Universal Transversal Gate Set
Eastin-Knill is the structural reason fault-tolerant quantum computing is hard. It proves that no error-correcting code admits a universal set of transversal gates — so every code architecture has at least one universal-gate-set member that is non-transversal and must be implemented by a fault-tolerant workaround. This tutorial states the theorem precisely, gives the dimensional-argument proof sketch, and surveys the four workarounds that fill the gap.
Resource Estimation: How to Compute the Qubit-Time Cost of a Fault-Tolerant Algorithm
Resource estimation is the practical discipline that turns a logical-circuit description into a concrete physical-qubit and wall-clock-time budget. This tutorial walks through the standard methodology — logical gate count, Toffoli decomposition, magic-state factory sizing, surface-code overhead — and rebuilds the canonical Gidney-Ekerå RSA-2048 estimate from first principles, with a working Python calculator you can adapt to your own algorithm.
qLDPC Codes: The Surface Code Successor That Already Cuts Qubit Overhead by 10x
The surface code's d² qubit overhead is the dominant constant in every fault-tolerant resource estimate. Quantum low-density parity check codes — qLDPC — achieve the same logical error rates with overhead that scales like d, often translating to 10x fewer physical qubits per logical qubit at useful code sizes. This tutorial covers the 2021-2024 breakthroughs (Panteleev-Kalachev, Bravyi-Cross IBM bicycle codes), the connectivity tradeoffs, and IBM's Starling roadmap built around them.
hardware
Quantum Hardware Compared: Superconducting vs Trapped-Ion vs Photonic vs Neutral-Atom
The four leading qubit modalities have wildly different tradeoffs: gate speed, connectivity, coherence time, scalability, and cost. This tutorial is an opinionated side-by-side based on 2026 hardware numbers — what each modality is best at, where each hits walls, and how to pick the right backend for a given benchmark.
Transmon Qubits: How the Most-Deployed Superconducting Qubit Actually Works
Transmons are the single most-deployed qubit type in quantum computing — every IBM, Google, and Rigetti processor as of 2026 is built on transmons or close cousins. This tutorial builds the transmon from the underlying Cooper-pair-box physics, explains why the design tradeoff matters, surveys current 2026 hardware numbers (T1, T2, two-qubit gate error, the Willow below-threshold result), and gives an honest verdict on what the platform's hard scaling problems actually are.
Trapped Ion Quantum Computing: The Platform with the Best Gate Fidelities and the Slowest Gates
Trapped ions hold the published-fidelity records on essentially every quantum-hardware metric. They have the longest coherence times, the cleanest two-qubit gates, and the most natural all-to-all connectivity. They are also the slowest platform by orders of magnitude, with system architectures that are harder to scale than superconducting alternatives. This tutorial covers the physics, the leading systems (Quantinuum H2/Helios, IonQ Tempo), the QCCD architecture, and where the trapped-ion advantage actually matters.
Neutral Atom Quantum Computing: The Platform That Closed the Gap in Three Years
Neutral-atom quantum computers — Rydberg arrays of laser-trapped atoms — went from research curiosity to flagship-tier platform between 2022 and 2025. Atom Computing crossed 1,000 qubits in 2023; QuEra and Pasqal demonstrated logical qubits in 2024-2025; the 2025 Sales Rodriguez logical magic-state distillation experiment was on neutral atoms. This tutorial covers the optical-tweezer / Rydberg architecture, current 2026 numbers, and why neutral atoms are the most-improved platform of recent quantum-computing history.
Photonic Quantum Computing: The Dark Horse Architecture That Skips Cryogenics
Photonic quantum computers use photons as qubits and measurements as the source of nonlinearity — a fundamentally different architecture from transmon, ion, and neutral-atom platforms. PsiQuantum, Xanadu, ORCA, Quandela, and QuiX are the leading commercial efforts; the fusion-based quantum computing model gives photonics a credible path to fault tolerance without ever needing a long-lived coherent quantum state. This tutorial covers the architecture, the leading companies, and where the gamble actually pays off.
Cryogenic Control Electronics: The Unsung Bottleneck of Scaling Superconducting Quantum Computers
Every superconducting qubit needs control wires running from room-temperature electronics through a dilution refrigerator down to ~10 mK. Naively, scaling to a million qubits would require a million wires through cryostats — physically impossible. The solution is cryogenic control electronics: classical control logic operating at 4 K or 10 mK, multiplexed control of many qubits per wire. This tutorial covers the hardware, the heat-budget engineering, and why this is one of the harder scaling problems of fault-tolerant quantum computing.
Quantum Control Theory: GRAPE, CRAB, and the Pulse Engineering of High-Fidelity Gates
A quantum gate is, on real hardware, a shaped microwave pulse. Designing pulses that produce desired unitaries while suppressing leakage, decoherence, and crosstalk is the discipline of quantum optimal control. GRAPE (Khaneja 2005) is the gradient-based workhorse; CRAB (Caneva 2011) is the gradient-free alternative; modern automatic-differentiation methods extend the toolkit. This tutorial covers the methods, the cost functions, and the engineering tradeoffs.
Randomized Benchmarking: How to Measure Gate Fidelity Without Tomography
Randomized benchmarking (RB) is the standard protocol for measuring gate fidelities on real quantum hardware. Run random Clifford sequences of varying length, measure how the survival probability decays, fit an exponential, and extract the per-gate error. RB is fast, scalable, and produces a single robust fidelity number that is the standard quoted hardware metric. This tutorial covers the protocol, the math behind why exponential decay happens, the variants (interleaved, simultaneous, mirror), and the limitations.
Gate-Set Tomography: The Detailed-and-Expensive Twin of Randomized Benchmarking
Gate-set tomography (GST) is the most detailed hardware-characterization protocol available. Unlike randomized benchmarking which gives one number per gate, GST returns a full description of every gate's action including coherent errors, incoherent errors, and SPAM errors. The price: a much larger data set, hundreds-to-thousands of distinct circuits, and complex post-processing. This tutorial covers what GST measures, why it differs from RB, and when the extra detail is worth the cost.
post quantum crypto
Post-Quantum Cryptography: The Threat Model
Shor's algorithm doesn't break all cryptography — it breaks the specific subset built on integer factoring and discrete logarithms, which happens to be nearly every public-key system in production. This tutorial lays out the precise threat model, the 'harvest now, decrypt later' attack, NIST's standardization response, and exactly which of your primitives to replace first.
ML-KEM and ML-DSA in Practice
NIST's FIPS 203 and FIPS 204 are the new cryptographic standards replacing RSA and ECDSA. This tutorial explains the math behind lattice-based key encapsulation and signatures, shows how to use them with real code (Python cryptography library + OpenSSL 3.5), and walks through hybrid TLS 1.3 — the production-grade migration deployment.
Auditing a Codebase for Y2Q Readiness
A hands-on tutorial that walks through building a crypto-agility scanner for any codebase — Python, JavaScript, Go, Rust, Java, C/C++. Identifies every place RSA, ECDSA, ECDH, and DH are used, produces a prioritized migration report, and is the exact deliverable that PQC consulting engagements sell.
Falcon (FN-DSA): The Compact Lattice Signature Standard
Falcon — standardized as FN-DSA in NIST FIPS 206 — is a post-quantum signature scheme built from NTRU lattices and floating-point Gaussian sampling. It produces signatures roughly 5x smaller than ML-DSA at comparable security, but at the cost of a much harder implementation (constant-time Gaussian sampling is notoriously subtle). This tutorial covers the math, the implementation pitfalls, and when Falcon is the right post-quantum signature choice.
SPHINCS+ (SLH-DSA): Hash-Based Signatures for Conservative Long-Term Security
SPHINCS+ — standardized as SLH-DSA in NIST FIPS 205 — is the only NIST-standardized post-quantum signature whose security depends only on hash-function security, not on lattice or other algebraic problems. Its signatures are large (~8 KB) and signing is slow, but it is the most conservative quantum-resistant signature available. This tutorial covers Merkle trees, the FORS few-time signature, the hyper-tree construction, and when SPHINCS+ is the right choice over lattice schemes.
Hybrid TLS with Post-Quantum KEMs: How the Internet Is Migrating in 2026
The 2026 production migration to post-quantum cryptography on the public internet uses hybrid key exchange — combining classical X25519 with post-quantum ML-KEM in TLS 1.3. The hybrid approach protects against both quantum break-throughs (ML-KEM saves you) and unforeseen lattice-cryptanalysis breakthroughs (X25519 saves you). This tutorial covers the IETF-standardized hybrid groups, deployment status across browsers and CDNs, and the open performance and policy questions.
Harvest-Now-Decrypt-Later: The Threat Model That Drives Post-Quantum Migration Timelines
An adversary who captures and stores encrypted traffic in 2026 can decrypt it in 2036 — assuming quantum computers exist by then and the data was encrypted under classical (non-post-quantum) cryptography. This is the harvest-now-decrypt-later threat model, and it is the structural reason post-quantum cryptography migration must precede the actual quantum threat by 5-15 years. This tutorial covers the threat model, who is doing the harvesting, what data is at risk, and how to assess your organization's timeline exposure.