Hands-on labs

Compute $w=(1+i)\,e^{i\pi/4}$ in Cartesian form, using Euler's formula and polar multiplication.

Express $v=(3+i)\lvert0\rangle+(1-i)\lvert1\rangle$ in the basis $\{\lvert+\rangle,\lvert-\rangle\}$ of $\mathbb{C}^2$.

Orthonormalise $v_1=(1,i,0)^T$ and $v_2=(1,0,1)^T$ with Gram–Schmidt, using the conjugate-linear inner product $\langle u\vert v\rangle=\sum_k\overline{u_k}v_k$.

Write the matrix of $P=\lvert{+i}\rangle\langle{+i}\rvert$ using $(\lvert a\rangle\langle b\rvert)_{jk}=a_j\overline{b_k}$.

Represent the Hadamard operator in the ordered basis $(\lvert+\rangle,\lvert-\rangle)$ using matrix elements $A_{ab}=\langle a\rvert H\lvert b\rangle$.

Diagonalise the Hermitian matrix $A=\begin{pmatrix}2 & 1-i\\ 1+i & 3\end{pmatrix}$: find its real eigenvalues from the characteristic polynomial, then the normalised eigenvector for the largest eigenvalue.

Use $X^2=I$ to sum the power series of $e^{-i\alpha X}$ in closed form and write the matrix of $R_X(\pi/3)=e^{-i(\pi/3)X/2}$.

Use single-qubit gates only to prepare $\lvert+\rangle\otimes\lvert1\rangle=\tfrac{1}{\sqrt2}(\lvert01\rangle+\lvert11\rangle)$ on two qubits, and see why the Kronecker order (qubit $0$ is the left factor) decides which qubit gets which gate.

Prepare the exact vector $\tfrac{1}{\sqrt2}(1,-1)^T$ from $\lvert0\rangle$. Physically $e^{i\gamma}\lvert-\rangle$ is the same state, but this lab compares vectors component by component, so the global phase must be $\gamma=0$.

Solve the Schrödinger equation for $H=\tfrac{\omega}{2}X$ (with $\hbar=1$): $U(t)=e^{-iHt}=e^{-i(\omega t/2)X}=R_X(\omega t)$. Set the rotation angle for $\omega t=\pi/2$ and reproduce the exact state, phases included.

Use $\langle X\rangle=\sin\theta\cos\phi$, $\langle Y\rangle=\sin\theta\sin\phi$, $\langle Z\rangle=\cos\theta$ to prepare a qubit with $\langle Z\rangle=\tfrac12$, $\langle X\rangle=\tfrac{\sqrt3}{2}$, $\langle Y\rangle=0$.

Prepare a product state $\lvert a\rangle\otimes\lvert b\rangle$ whose joint distribution is $P(00)=P(01)=\tfrac38$, $P(10)=P(11)=\tfrac18$, using the factorisation $P(q_0,q_1)=P_A(q_0)P_B(q_1)$ and the big-endian ordering (qubit 0 is the leftmost bit).

Read the Bloch vector $\vec r=(r_x,r_y,r_z)$ with $r_j=\mathrm{Tr}(\rho\sigma_j)$ and the purity $\gamma=\mathrm{Tr}\rho^2=\tfrac12(1+\lVert\vec r\rVert^2)$ directly off the entries of a $2\times2$ density matrix, using the Bloch-ball form $\rho=\tfrac12(I+r_xX+r_yY+r_zZ)$.

Prepare a two-qubit pure state $\lvert\psi\rangle_{01}$ whose reduced state on qubit 0 is the mixed state $\rho_0=\mathrm{Tr}_1\lvert\psi\rangle\langle\psi\rvert=\mathrm{diag}(\tfrac34,\tfrac14)$. Mixedness of a marginal cannot come from a single-qubit gate: it must come from entanglement with qubit 1.

Compute the entanglement entropy $S(\rho_A)=-\sum_k\lambda_k\log_2\lambda_k$ of a Schmidt state from its Schmidt coefficients, then prepare a three-qubit state whose marginals $\rho_{\{0\}}$, $\rho_{\{0,1\}}$ and $\rho_{\{2\}}$ each carry exactly one bit of entropy. All entropies are in bits; qubit 0 is the leftmost bit.

Normalise $(1+i)\lvert0\rangle+2\lvert1\rangle$ and read off its Born probability $P(1)$.

Place the state $\lvert{+i}\rangle=\tfrac1{\sqrt2}(\lvert0\rangle+i\lvert1\rangle)$ on the Bloch sphere, first by choosing $(\theta,\phi)$ directly and then by preparing it from $\lvert0\rangle$ with at most two gates from $\{H,S\}$.

Multiply two Pauli matrices by hand to see $XY=iZ$ (and why the order matters), then expand a Hermitian $2\times2$ matrix in the Pauli basis using $a_P=\tfrac12\mathrm{Tr}(PA)$.

Implement the bit flip $X=\begin{pmatrix}0&1\\1&0\end{pmatrix}$ on one qubit, up to a global phase, using only the Hadamard gate $H$ and the phase gate $S=\mathrm{diag}(1,i)$, with at most four gates.

Use the identity $R_Z(\phi)R_Y(\theta)\lvert0\rangle=e^{-i\phi/2}\big(\cos\tfrac\theta2\lvert0\rangle+e^{i\phi}\sin\tfrac\theta2\lvert1\rangle\big)$ to prepare the state with Bloch angles $\theta=\tfrac{2\pi}3$, $\phi=\tfrac\pi4$ from $\lvert0\rangle$ with at most two rotation gates.

Build the two-qubit SWAP gate, which exchanges the states of the two wires, using only CNOT gates and at most three of them.

Build the Toffoli gate $\mathrm{CCX}\lvert a,b,c\rangle=\lvert a,b,c\oplus ab\rangle$ (controls $0,1$, target $2$) on three qubits from the Clifford+$T$ set $\{H,T,T^\dagger,\mathrm{CNOT}\}$ with at most six CNOTs and fifteen gates in total.

Starting from $\lvert00\rangle$, prepare the singlet $\lvert\Psi^-\rangle=\tfrac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)$ with at most four gates from $\{H,X,Z,\mathrm{CNOT}\}$. The grader checks the state fidelity and, separately, the perfectly anti-correlated measurement statistics, so it can tell a wrong relative sign from a wrong pair of basis states.

The CNOT gate maps $\lvert0\rangle\lvert0\rangle\mapsto\lvert00\rangle$ and $\lvert1\rangle\lvert0\rangle\mapsto\lvert11\rangle$, so it copies basis states perfectly. Compute its copy fidelity $F=\lvert\langle\psi\psi\vert\,\mathrm{CNOT}\,\vert\psi0\rangle\rvert^2$ for the superpositions $\lvert+\rangle$ and $\cos\tfrac\pi6\lvert0\rangle+\sin\tfrac\pi6\lvert1\rangle$.

Teleport the state $\lvert\psi\rangle=R_Z(0.6)R_Y(1.1)\lvert0\rangle\simeq\cos0.55\,\lvert0\rangle+e^{0.6i}\sin0.55\,\lvert1\rangle$ from Alice's qubit $0$ to Bob's qubit $2$ through the pre-shared pair $\lvert\Phi^+\rangle_{12}$. First implement the protocol with the corrections moved before measurement (principle of deferred measurement), then with real mid-circuit measurements and classically conditioned corrections. The grader compares Bob's reduced density matrix with $\sigma=\lvert\psi\rangle\langle\psi\rvert$ in trace distance.

Alice (qubit $0$) and Bob (qubit $1$) share $\lvert\Phi^+\rangle=\tfrac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)$, prepared by a locked $H(0);\ \mathrm{CNOT}(0,1)$. Encode the two-bit message $b_1b_2=11$ with Pauli gates on Alice's qubit only, then decode with the inverse Bell circuit $(H\otimes I)\,\mathrm{CNOT}$ so that the register ends in $\lvert11\rangle$. The grader checks the joint distribution and each bit separately, so it can tell which of the two bits went wrong.

Surround a black-box oracle $U_f\lvert x_0x_1\rangle\lvert y\rangle=\lvert x_0x_1\rangle\lvert y\oplus f(x_0x_1)\rangle$ with gates from $\{H,X,Z\}$ so that a single query decides whether $f:\{0,1\}^2\to\{0,1\}$ is constant or balanced. The grader runs your circuit four times, once for each of the oracles $f\equiv0$, $f\equiv1$, $f=x_0\oplus x_1$ and $f=x_0$, and inspects the measurement distribution of the two input qubits.

Build the quantum Fourier transform on three qubits, $F\lvert j\rangle=\tfrac1{\sqrt8}\sum_{k=0}^{7}e^{2\pi ijk/8}\lvert k\rangle$, from Hadamard gates, controlled-phase gates $\mathrm{CP}(\varphi)=\mathrm{diag}(1,1,1,e^{i\varphi})$ and one SWAP, using at most seven gates.

Complete a three-qubit phase-estimation circuit around the controlled powers $C\text{-}U$, $C\text{-}U^2$, $C\text{-}U^4$ of a black-box phase gate $U=P(2\pi\varphi)=\mathrm{diag}(1,e^{2\pi i\varphi})$, whose eigenvector is $\lvert1\rangle$ with eigenvalue $e^{2\pi i\varphi}$. For $U=T$ the phase is $\varphi=1/8$. The grader substitutes $\varphi=1/8$, $3/8$, $5/8$ and $1/2$ and requires the counting register to read $\lvert m\rangle$ with $\varphi=m/8$ with certainty.

Build Grover's algorithm for $N=8$ items and one marked item $w$: the uniform superposition $\lvert s\rangle=H^{\otimes3}\lvert000\rangle$ followed by two iterations of the phase oracle $O_f=I-2\lvert w\rangle\langle w\rvert$ and the diffuser $D=2\lvert s\rangle\langle s\rvert-I$. The grader substitutes three different oracles ($w=101$, $010$, $111$) into the placeholder and requires the distribution $P(w)=\sin^2(5\theta)=\tfrac{121}{128}$ with $\sin\theta=\tfrac1{\sqrt8}$, every other outcome having probability $\tfrac1{128}$.

Solve $A\vec x=\vec b$ for $A=\begin{pmatrix}1&-\tfrac13\\-\tfrac13&1\end{pmatrix}$ and $\vec b=(1,0)^T$ with the HHL algorithm on four qubits: read the clock values produced by phase estimation, then choose the controlled-$R_Y$ angles that divide each eigencomponent by its eigenvalue, so that post-selection yields $\lvert x\rangle=(3,1)/\sqrt{10}$.

Implement the vectorised gradient of the mean-squared-error loss $\mathcal L(w,b)=\tfrac1m\sum_{i=1}^m(w^\top x_i+b-y_i)^2$ of a linear model, namely $\nabla_w\mathcal L=\tfrac2m\sum_i r_ix_i=\tfrac2mX^\top r$ and $\partial_b\mathcal L=\tfrac2m\sum_ir_i$ with residuals $r_i=w^\top x_i+b-y_i$. The function is graded on one visible worked example and five hidden random problems with up to $50$ samples and $5$ features, to absolute tolerance $10^{-9}$.

Implement the Gram matrix $K_{ij}=k(x_i,x_j)=e^{-\gamma\lVert x_i-x_j\rVert^2}$ of the Gaussian (RBF) kernel, the matrix that the SVM dual and every kernel method consume. The grader checks your values on a visible three-point example and on three hidden sets of $20$ random points in $[-2,2]^2$ ($\gamma=0.5,1,2$), and verifies the two structural properties that every valid Gram matrix has: symmetry and positive semidefiniteness.

Read off the explicit feature space of the inhomogeneous quadratic kernel $k(x,x')=(x^\top x'+1)^2$ on $\mathbb{R}^2$ and evaluate the kernel at a pair of points, confirming that the kernel trick and the explicit inner product $\phi(x)^\top\phi(x')$ give the same number.

Prepare the basis encoding $\lvert1011\rangle=X\otimes I\otimes X\otimes X\,\lvert0000\rangle$ of the bit string $x=1011$ on four qubits, using at most three $X$ gates. Qubit 0 is the leftmost (most significant) bit, so the target is the basis vector with index $k=8+2+1=11$ of $\mathbb C^{16}$.

Prepare the amplitude encoding $\lvert x\rangle=\tfrac1{\sqrt{30}}\big(\lvert00\rangle+2\lvert01\rangle+3\lvert10\rangle+4\lvert11\rangle\big)$ of $x=(1,2,3,4)$ on two qubits with at most five gates from $\{R_Y,\mathrm{CNOT}\}$: one rotation for the split on qubit $0$ and a uniformly controlled $R_Y$ on qubit $1$, compiled into two rotations and two CNOTs.

Write the angle-encoding feature map $\lvert\phi(x)\rangle=R_Y(x_0)\lvert0\rangle\otimes R_Y(x_1)\lvert0\rangle$ for a datum $x=(x_0,x_1)$ as a circuit that uses the data symbols $x_0,x_1$, so that it works for every datum. The grader re-binds the symbols to three data points and checks $\langle Z_j\rangle=\cos x_j$ and $\langle X_j\rangle=\sin x_j$ on both qubits.

Implement the two-qubit evolution $e^{-i\frac{0.7}{2}Z\otimes Z}=\mathrm{diag}(e^{-0.35i},e^{0.35i},e^{0.35i},e^{-0.35i})$ exactly, using at most three gates from $\{\mathrm{CNOT},R_Z\}$. This is the elementary building block of every diagonal (IQP-type) feature map, including the ZZ feature map of Havlíček et al.

Compute one entry of a quantum kernel matrix by hand: the fidelity kernel $K(x,x')=\lvert\langle\phi(x)\vert\phi(x')\rangle\rvert^2$ of the two-qubit $R_X$ product encoding at $x=(0.3,1.2)$ and $x'=(1.0,0.4)$, using the closed form $\prod_j\cos^2\frac{x_j-x'_j}{2}$ derived in the lesson.

Build the SWAP test on three qubits and read the fidelity of two one-qubit states from the ancilla alone: with $\lvert\psi\rangle=R_Y(\pi/3)\lvert0\rangle$ and $\lvert\phi\rangle=\lvert0\rangle$ the overlap is $F=\lvert\langle\psi\vert\phi\rangle\rvert^2=\cos^2\frac\pi6=\frac34$, so the ancilla must return $0$ with probability $P(0)=\frac12(1+F)=\frac78$.

Build the compute–uncompute circuit $U(x')^\dagger U(x)$ of the two-qubit $R_X$ product encoding for $x=(0.3,1.2)$ and $x'=(1.0,0.4)$ with $R_X$ gates only, and read the kernel value $K(x,x')=\cos^2(0.35)\cos^2(0.4)\approx0.7486$ off the probability of the outcome $00$.

Build the complete quantum-kernel classifier of the lesson in Python. First implement the fidelity kernel $K(x,x')=\lvert\langle\phi(x)\vert\phi(x')\rangle\rvert^2$ of the two-qubit ZZ feature map with one repetition by simulating its circuit with NumPy; the grader compares your matrices with the platform's statevector engine and checks symmetry and positive semidefiniteness. Then train scikit-learn's SVC(kernel="precomputed", C=1.0) on the $70\times70$ training Gram matrix of the two-moons data scaled to $[0,\pi]$ and predict the $30$ held-out points; the grader computes the test accuracy from your predictions and requires at least $0.90$ (the reference pipeline reaches $28/30$).

The circuit $R_Y(\theta)R_Y(x)\lvert0\rangle$ with observable $Z$ is the smallest variational quantum classifier: feature map $U(x)=R_Y(x)$, ansatz $W(\theta)=R_Y(\theta)$, model output $f_\theta(x)=\langle Z\rangle=\cos(x+\theta)$ and prediction $\hat y=\mathrm{sign}\,f_\theta(x)$. Choose the single weight $\theta$ so that all four training points are classified correctly.

The circuit is a fixed hardware-efficient ansatz on $3$ qubits with $2$ layers: in each layer every qubit gets $R_Y$ then $R_Z$, followed by the CNOT ladder $\mathrm{CNOT}(0,1)$, $\mathrm{CNOT}(1,2)$. All $12$ angles start at $0$, where the circuit outputs $\lvert000\rangle$. Choose angle values so that the output is the GHZ state $\tfrac1{\sqrt2}(\lvert000\rangle+\lvert111\rangle)$, using the identity-at-zero and basis-state tracking arguments of the lesson.

Implement PennyLane-convention strongly entangling layers as a list of Circuit-IR operations: on every wire the general rotation $\mathrm{Rot}(\phi,\theta,\omega)=R_Z(\omega)R_Y(\theta)R_Z(\phi)$, then the cyclic CNOT block $\mathrm{CNOT}(i,(i+r_\ell)\bmod n)$ with the layer-dependent range $r_\ell=(\ell\bmod(n-1))+1$. The grader compares the unitary of your circuit with the reference unitary on $7$ weight tensors of shapes $(1,2,3)$, $(1,3,3)$, $(2,3,3)$ and $(3,4,3)$, requiring process fidelity at least $1-10^{-9}$.

The three-qubit W state $\lvert W_3\rangle=\tfrac1{\sqrt3}(\lvert001\rangle+\lvert010\rangle+\lvert100\rangle)$ has bond dimension $\chi=2$ at both cuts, so a short sequential circuit prepares it. In the first step you build such a circuit from $R_Y$, $X$, controlled-$R_Y$ and CNOT gates. In the second step you compute the entanglement entropy of one qubit from its Schmidt spectrum.

Compare the two gradient estimators available on quantum hardware for $f(\theta)=\langle Z\rangle=\cos\theta$ of the state $R_Y(\theta)\lvert0\rangle$: the central finite difference with step $h=0.01$ and the parameter-shift rule. Both use two circuit evaluations of $N=1000$ shots; you compute the exact shot-noise variance of each and see a factor $h^{-2}=10^4$ between them.

Implement the parameter-shift gradient of a variational circuit using only a black-box evaluate(params) that returns the exact expectation value $f(\theta)=\langle\psi(\theta)\vert H\vert\psi(\theta)\rangle$. Every parameter sits in a single Pauli rotation $R_P(\theta_j)=e^{-i\theta_jP/2}$, so $\partial_jf(\theta)=\tfrac12\big[f(\theta+\tfrac\pi2e_j)-f(\theta-\tfrac\pi2e_j)\big]$ is exact. The grader checks the values on one visible and four hidden random three-qubit circuits, separately checks that your function calls evaluate exactly $2P$ times, and finally checks that the values are exact to $10^{-12}$, which no finite-difference quotient achieves.

Compute the Fubini–Study metric of the single-qubit model $\lvert\psi(\theta,\phi)\rangle=R_Z(\phi)R_Y(\theta)\lvert0\rangle$ at $\theta=\pi/3$, then use it to take one quantum-natural-gradient step on the loss $L=\langle Z\rangle$ and compare it with the vanilla gradient step.

Quantify the barren plateau of the exactly solvable product model $V(\theta)=\bigotimes_jR_X(\theta_j)$ on $\lvert0\cdots0\rangle$. First compute the exact gradient variances of the global cost $C_G=1-\prod_j\cos^2\frac{\theta_j}2$ and the local cost $C_L=1-\frac1n\sum_j\cos^2\frac{\theta_j}2$ at $n=6$; then estimate them by Monte Carlo from a black-box cost function, using the parameter-shift rule with exactly two circuit evaluations per random parameter vector.

Compute the energy-relaxation probability $\gamma=1-e^{-t/T_1}$ of an idling qubit and its surviving excited population, then build a one-qubit noisy circuit that prepares the mixed state $\rho=\begin{pmatrix}0.5&0.3\\0.3&0.5\end{pmatrix}$ from $\lvert0\rangle$ with one gate and noise channels simulated on the density-matrix backend.

An expectation value was measured at the noise scale factors $\lambda=1,3,5$ produced by global unitary folding. Combine the three measurements with the Richardson (Lagrange) weights into an estimate of the noiseless value $E_0$.

A qubit's readout flips $0\to1$ with probability $p_{01}=0.05$ and $1\to0$ with probability $p_{10}=0.10$. Undo this classical noise on a measured distribution by inverting the $2\times2$ confusion matrix.

Train the 4-qubit quantum convolutional neural network of the lesson, with $12$ shared weights, on $2\times2$ images of horizontal and vertical bars. Your TypeScript function receives $40$ training images and returns the weights p0 to p11. You write the loss, the gradient and the optimiser. For the gradient, the engine's parameterShiftGradient applies the two-term rule to the $R_Y$ weights and the four-term rule to the $CR_Z$/$CR_X$ pooling weights. The grader binds your weights into the fixed QCNN circuit and classifies $100$ held-out images by $\mathrm{sign}\langle Z_3\rangle$; at least $90\%$ must be correct.

The $4$-qubit quantum reservoir of the lesson is fixed: its Ising Hamiltonian, the input injection on qubit $0$ and the $5$ virtual nodes per input are never trained. Only the linear readout is learned. Your TypeScript function receives the $600\times21$ feature matrix of the training window (the $20$ expectation values $\langle Z_q\rangle$ plus a bias column) and the targets of a short-term memory task, and returns the ridge-regression weights $w=(X^\top X+\lambda I)^{-1}X^\top y$. The grader recomputes the reservoir and scores your weights on $400$ unseen time steps: recalling the input of one step ago must reach $\mathrm{NMSE}\le0.03$, recalling the input of two steps ago $\mathrm{NMSE}\le0.08$.

The capstone of the course: train the two-qubit data re-uploading classifier of the lesson to tell points inside a circle from points outside it. Your TypeScript function receives $100$ labelled training points, chooses the depth $L\in\{3,4,5,6\}$, computes the gradient with your own parameter-shift rule, runs an optimiser of your choice and returns the trained $4L$ weights. The grader binds them into the chosen circuit and classifies $100$ held-out points by $\mathrm{sign}\langle Z_0Z_1\rangle$; at least $85\%$ must be correct.