Quantum Computing & Machine Learning: Build with Qiskit

Install Python, Jupyter, and Qiskit from a clean machine and run your first notebook cell, assuming no prior setup. You'll verify the whole toolchain works end to end so every later lab runs without environment surprises getting in the way of the quantum code.

Meet the absolute basics of code: variables, the core data types (ints, floats, strings, booleans), and printing output. You'll write and run tiny programs in Jupyter, building the muscle memory that every quantum script later in the course quietly depends on.

Learn the control flow used in every program: lists to hold data, for and while loops to repeat work, and if/else conditionals to make decisions. You'll code small examples that mirror how quantum results later get collected, filtered, and counted.

Package logic into reusable functions with parameters and return values, the backbone of clean, non-repetitive code. You'll refactor repeated statements into functions so building circuits, oracles, and ansatze stays readable as your programs grow.

Use dictionaries to store key-value data, exactly how Qiskit returns measurement counts, and comprehensions to build lists and dicts in one compact line. These structures make quantum code short, and you'll practice reading counts back out of a dict.

Learn just enough NumPy to handle vectors and matrices in code: arrays, dot products, and matrix multiplication. This is the math engine under both quantum states and machine learning, and you'll manipulate the very arrays that soon represent qubits and gates.

Turn raw numbers into readable charts with Matplotlib: bar plots for measurement counts and line plots for training curves. You'll produce the histograms you rely on all course long to interpret what a quantum circuit actually did on each run.

Write your first complete Qiskit program and understand every line: create a QuantumCircuit, add gates, measure, run on a simulator, and read the counts. This ties the setup and Python work into a single working quantum program you fully understand.

See why quantum processors never run alone: a classical computer prepares data, drives the loop, and post-processes results while the QPU handles only the quantum step. Understanding this hybrid model explains the structure of every variational algorithm you code later.

Compare the five major quantum SDKs—Qiskit, Cirq, Q#, PennyLane, and Braket—by who builds them, their design goals, and when each is the right tool. You'll leave able to pick a stack for a given task instead of defaulting to whichever you saw first.

Set up the QML toolkit the industry standardizes on: PennyLane for differentiable quantum circuits wired to PyTorch for gradients and optimization. You'll run a first differentiable circuit, the foundation for every quantum machine learning model later in the course.

Learn the object-oriented ideas used throughout the course: classes, objects, methods, and the DRY principle. You'll model quantum concepts as reusable classes so larger programs—oracles, ansatze, optimizers—stay organized instead of sprawling into copy-paste.

Walk the four-step Qiskit workflow: build a circuit, transpile it to a backend's native gates, verify it, then run on a simulator or QPU. You'll execute the full loop so every later lab follows the same reliable path from idea to measured result.

Run both Qiskit primitives and feel the difference: Sampler returns a distribution of measured bitstrings while Estimator returns the expectation value of an observable. You'll learn which to reach for—counts for algorithms, expectations for variational methods.

Submit a real job to a cloud QPU on IBM Quantum, Braket, or Azure and interpret results shaped by noise. You'll compare the hardware output to the simulator and learn to read how queueing, shots, and gate errors affect what comes back from a genuine device.

Get the minimal math to represent qubits in code: complex numbers with their amplitude and phase, and column vectors for states. You'll connect the abstract |0⟩ and |1⟩ to concrete arrays you can type into NumPy and manipulate directly, the bridge from physics to code.

Read and write quantum states the way the field does with bra-ket notation: kets for states, bras for their conjugates, inner products for overlap, and norms for probability. This notation makes every later algorithm's math legible instead of intimidating.

See how combining qubits uses the tensor product, so two qubits give a four-dimensional space and n qubits give 2^n dimensions. You'll compute small tensor products by hand and understand why 50 qubits already outstrips any classical memory.

Learn the one idea linking linear algebra to circuits: every quantum gate is a unitary matrix that preserves norm and is reversible. You'll check unitarity in code and see how applying a gate is just multiplying a state vector by its matrix.

Do it in code: represent states as NumPy vectors and gates as matrices, then multiply them to compute exactly what a circuit does. Building a Bell state by hand this way demystifies the simulator and confirms the math behind Qiskit's output.

Visualize a single qubit as a point on the Bloch sphere and watch how gates rotate it. You'll plot states in Qiskit and build the geometric intuition that makes later rotation, phase, and superposition gates feel like concrete movements rather than symbols.

Build and inspect the three Pauli gates: X flips the bit, Z flips the phase, and Y does both. You'll apply each in Qiskit, check the resulting statevector and matrix, and see exactly how these one-qubit operations move a state on the Bloch sphere.

Apply the Hadamard gate to create an equal superposition, then measure repeatedly to watch 50/50 randomness emerge from a definite state. You'll read the histogram and connect the outcome probabilities to amplitudes, the core of quantum behavior.

Apply the S and T phase gates and see effects a single measurement hides, then witness phase kickback where a controlled phase lands on the control qubit instead of the target. You'll use interference, via a Hadamard, to reveal phases the computational basis alone can't show.

Use the continuous rotation gates Rx, Ry, and Rz that turn a qubit by a tunable angle. These parametrized gates are the trainable knobs behind every variational and QML model, and you'll see how an angle maps to a point on the Bloch sphere.

Wire up multi-qubit gates—CNOT and CZ—and use them to build linear, circular, and full entanglement patterns across a register. You'll see how two-qubit gates create correlations no product of single-qubit states can, the very source of entanglement.

Build the Bell state in a few lines: a Hadamard plus a CNOT, then measure to find only 00 and 11 with nothing in between. You'll create and confirm entanglement, the first circuit that shows genuinely non-classical correlations between two qubits.

Turn a circuit into statistics: add measurements, choose the number of shots, and read the counts dictionary and histogram. You'll learn how sampling noise shrinks as shots grow and how to interpret probabilities from a finite number of runs.

Understand quantum parallelism: by feeding a superposition into an oracle, one circuit evaluates a function on many inputs at once. You'll learn what an oracle is, how it encodes a problem, and why parallelism alone isn't enough without interference to read out an answer.

Meet phase kickback, the mechanism that makes oracle algorithms work: a controlled operation writes its result into the phase of the control qubit. You'll see how this hidden phase, revealed by interference, is the real engine behind Deutsch-Jozsa, Bernstein-Vazirani, and Grover.

Code Deutsch-Jozsa in Qiskit from scratch: build the oracle, apply Hadamards, measure, and see it decide in one query whether a function is constant or balanced—what classically needs many. You'll read the counts and tie the all-zeros result back to interference.

Build Bernstein-Vazirani and recover a hidden bitstring in a single query. You'll construct the oracle from a secret string, run the circuit, and read that exact string straight out of the measurement, seeing how phase kickback exposes every bit at once.

Implement Simon's algorithm, whose exponential speedup inspired Shor. You'll build the two-register oracle, run it to gather bitstrings constrained by the hidden period, and solve the resulting linear system classically to recover the secret—quantum and classical together.

Understand Grover's search as amplitude amplification: an oracle marks the answer with a phase, then reflecting about the mean grows its probability each iteration. You'll see geometrically why about √N steps suffice for unstructured search that classically needs N.

Code Grover's search hands-on: build the marking oracle and the diffuser, iterate the optimal number of times, and measure to find the target with high probability. You'll watch the histogram peak on the answer and confirm the quadratic speedup for yourself.

Learn what the Quantum Fourier Transform computes—shifting amplitudes into the phase/frequency domain—and why it underlies the field's biggest speedups. You'll build intuition for how the QFT exposes periodicity, the property phase estimation and Shor's algorithm exploit.

Assemble the QFT in Qiskit gate by gate: Hadamards and controlled phase rotations across the register, finished with the qubit-reversing swaps. You'll verify your circuit against NumPy's transform matrix so you can trust it as a building block later.

Implement quantum phase estimation to extract the eigenphase of a unitary acting on an eigenstate. You'll build the controlled-unitary ladder and inverse QFT, read the phase from the counts, and see why QPE is the core subroutine inside Shor and HHL.

See how Shor's algorithm turns factoring into period finding: reduce factoring to finding the period of modular exponentiation, then use phase estimation and the QFT to get that period fast. You'll follow the classical-quantum split that puts RSA at risk.

Run Shor's algorithm on a simulator to factor a small number like 15 and watch the period emerge from the QFT output. You'll extract the factors from the measured period using the classical post-processing and see concretely why a scalable version would break RSA encryption.

Place quantum computing in the complexity landscape: what BQP is, how it relates to P, NP, and BPP, and why quantum is not simply a way to crack NP-complete problems. You'll leave with a grounded sense of where real quantum speedups do and don't apply.

Learn the variational recipe—a parametrized circuit measured for a cost, with a classical optimizer updating the parameters—and why it suits noisy NISQ devices. You'll see how shallow circuits and hybrid loops sidestep the depth that today's hardware can't sustain.

Formulate Max-Cut for a quantum computer: encode the graph in a cost Hamiltonian whose ground state is the best cut, paired with a mixer Hamiltonian that explores solutions. You'll see how a combinatorial problem becomes something QAOA's alternating layers can optimize.

Build and run QAOA on a small graph in Qiskit or PennyLane: prepare the cost and mixer layers, set the parameters, execute, and tune the angles with a classical optimizer. You'll get a working end-to-end variational optimizer you can point at a real graph.

Interpret QAOA output: read the measured bitstring distribution to find the best cut and see how raising the depth p adds layers that can sharpen—or, with harder optimization, hurt—the result. You'll judge solution quality straight from the histogram.

Compare optimizers for variational circuits: SPSA's noise resilience, COBYLA's gradient-free steps, and the parameter-shift rule for exact quantum gradients. You'll learn how to pick an optimizer that keeps converging despite the shot noise of real hardware.

Learn how quantum computers are benchmarked: quantum volume for overall capability, CLOPS for speed, and what advantage or utility claims really mean. You'll leave able to read a vendor's numbers critically instead of taking headline claims at face value.

Understand why simulating chemistry is quantum computing's highest-value near-term application: molecules are themselves quantum systems that classical computers struggle to model as they grow. You'll see why accurate energies and reaction paths are a natural fit for qubits.

Follow the pipeline from a molecule to a qubit Hamiltonian: electronic structure to fermionic operators to qubit operators via mappings like Jordan-Wigner. You'll see how a molecule's energy problem becomes a Hamiltonian a quantum circuit can actually measure.

Run VQE hands-on to compute the ground-state energy of H2: prepare a parametrized ansatz, measure the Hamiltonian's expectation with Estimator, and let a classical optimizer minimize it. You'll build the flagship near-term chemistry algorithm end to end.

Interpret VQE output: plot energy against optimization step to watch convergence and compare the final value to the exact diagonalization. You'll learn to spot when the optimizer has settled and how close the variational answer really is to the truth.

See what makes larger molecules like LiH hard: more orbitals mean more qubits, deeper ansatze, and tougher optimization. You'll learn how active spaces trim the problem and how ansatz choice trades accuracy against circuit depth on real hardware.

Build all four Bell states in Qiskit and verify their correlations by measuring in matched bases. You'll see how each maximally entangled pair differs by a bit or phase flip and confirm the perfect correlations that make entanglement a usable resource.

Build quantum teleportation step by step: entangle a pair, have the sender do a Bell measurement, send two classical bits, and apply the matching corrections to recreate the state. You'll confirm the unknown qubit moves across without ever being copied.

Implement superdense coding: using a shared entangled pair, encode two classical bits into one qubit with a choice of Pauli operations, then decode both after transmission. You'll run it and confirm two bits really do arrive inside a single qubit.

Understand universality: why a small set of gates—like Clifford plus T—can approximate any circuit, and how the Solovay-Kitaev theorem bounds the cost. You'll see why hardware needs only a few well-controlled gates to be fully programmable.