Quantum-kernel SVM on two moons

Write the Python function zz_kernel``(X1, X2) that returns the $m_1\times m_2$ NumPy array

$K_{ij}=\big\lvert\langle\phi(a_i)\vert\phi(b_j)\rangle\big\rvert^2,\qquad a_i=\texttt{X1[i]},\quad b_j=\texttt{X2[j]}\in\mathbb R^2,$

for the two-qubit ZZ feature map with one repetition,

$\lvert\phi(x)\rangle=\mathrm{CNOT}_{01}\,P_1\big(2(\pi-x_0)(\pi-x_1)\big)\,\mathrm{CNOT}_{01}\,P_0(2x_0)\,P_1(2x_1)\,(H\otimes H)\lvert00\rangle,$

where the rightmost gate acts first, $P_q(\lambda)$ is the phase gate on qubit $q$ and $\mathrm{CNOT}_{01}$ has control $0$ and target $1$:

$H=\frac1{\sqrt2}\begin{pmatrix}1&1\\1&-1\end{pmatrix},\qquad P(\lambda)=\begin{pmatrix}1&0\\0&e^{i\lambda}\end{pmatrix},\qquad \mathrm{CNOT}_{01}=\begin{pmatrix}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{pmatrix}.$

Qubit $0$ is the most significant bit of the basis index $\lvert q_0q_1\rangle$, so a gate $U$ on qubit $0$ is np.kron(U, I2) and a gate $V$ on qubit $1$ is np.kron(I2, V). Use NumPy only (import numpy as np).

Visible test two-by-two: $A=\{(0.3,\,1.2),\,(1.0,\,0.4)\}$ and $B=\{(0.3,\,1.2),\,(2.5,\,2.9)\}$. Since $b_0=a_0$, $K_{00}=1$; the reference matrix is

$K\approx\begin{pmatrix}1.0000000000&0.4095983911\\ 0.2754859933&0.1050335728\end{pmatrix},$

compared entrywise with absolute tolerance $10^{-9}$.

Hidden tests (the arguments reach your browser, the expected values do not): three pairs of point sets in $[0,\pi)^2$ of sizes $4\times3$, $5\times5$ and $3\times6$, each compared with the engine's kernel at tolerance $10^{-9}$.

Structural tests symmetric-6 and psd-6: for six points $X$, the matrix $K(X,X)$ must satisfy $\max_{ij}\lvert K_{ij}-K_{ji}\rvert\le10^{-9}$ and have smallest eigenvalue at least $-10^{-9}$. Both hold automatically for a correct fidelity kernel; the lesson proves it.

The platform's engine builds the same map with $R_Z(\lambda)=e^{-i\lambda/2}P(\lambda)$ instead of $P(\lambda)$; the states differ by the global phase $e^{-i(x_0+x_1+\varphi_{01})}$ and the kernels are identical, so either gate gives full marks.

Write train_and_predict``(X_train, y_train, X_test) that trains a soft-margin support vector machine on the precomputed ZZ kernel and returns the predicted labels of the test points as a NumPy array (or list) of $0/1$ values:

1. $K_{\text{train}}=$ zz_kernel(X_train, X_train), the $70\times70$ Gram matrix $K(x_i,x_j)$;
2. $K_{\text{test}}=$ zz_kernel(X_test, X_train), the $30\times70$ matrix whose row $t$ holds $K(x^\ast_t,x_i)$ for all training points;
3. fit SVC(kernel="precomputed", C=1.0) from sklearn.svm on $(K_{\text{train}},y_{\text{train}})$ and return predict on $K_{\text{test}}$.

The classifier is $\hat y(x)=\mathbb 1\big[f(x)>0\big]$ with $f(x)=\sum_i\alpha_iy_iK(x_i,x)+b$, where scikit-learn internally maps the labels $0/1$ to $\mp1$, solves the dual problem for $\alpha$ and fixes $b$ from the Karush–Kuhn–Tucker conditions.

Each step runs its own source, so define zz_kernel again in this step (copy your passing function from step 1); the starter shows both signatures.

Data (passed as arguments): the two-moons sample make_moons(n_samples=100, noise=0.1, random_state=0) of scikit-learn, each feature min–max scaled over all $100$ rows to $[0,\pi]$; rows $0$–$69$ are X_train, y_train, rows $70$–$99$ are X_test.

Hidden test moons: the grader compares your $30$ predictions with the true test labels, which never leave the server, and requires a test accuracy of at least $0.90$, i.e. at least $27$ of $30$ correct. The reference pipeline reaches $28/30\approx0.9333$.