Quantum Machine Learning Models

A quantum machine learning model is what you get when you replace the tunable function at the heart of ordinary machine learning — a neural network, a kernel, a probabilistic model — with a quantum circuit. Classical data $x$ is written into qubits by a feature-encoding circuit $S(x)$ , a trainable unitary $U(\theta)$ processes the resulting state, and the prediction is read out as the expectation value of an observable, $f_\theta(x)=\langle 0|S^\dagger(x)U^\dagger(\theta)\,M\,U(\theta)S(x)|0\rangle$ . Training adjusts $\theta$ to lower an empirical loss over a dataset, exactly as in classical supervised learning; what changes is the hypothesis class — the set of functions is now whatever a quantum circuit can realize. This deep-tier synthesis sits atop the near-term learning chapter, assembling the ansatz machinery of aq-qci-parameterized-quantum-circuits-ansatze, the encodings and Gram matrices of aq-qci-quantum-feature-maps-kernels, the hardware gradients of aq-qci-parameter-shift-rules-gradients, and the measurement statistics of aq-qci-cost-function-measurement-estimation into a single learner. Three ideas organize it. First, three paradigms share one skeleton: explicit variational models train the circuit, implicit kernel models freeze it and fit a classical separator in Hilbert space, and generative Born machines read the measurement distribution as the thing to be learned. Second, a single theorem ties them together — a model with data re-uploaded across layers is a truncated Fourier series in $x$ , and the accessible frequencies are fixed by the data encoding, not by circuit depth. Third, expressive power is not free: the randomness that makes a circuit reach everywhere flattens its landscape into a barren plateau and concentrates its kernel toward the identity, so useful quantum learning is a story about structure and inductive bias, not about the size of Hilbert space.

Key takeaways

A quantum machine learning (QML) model is a parameterized circuit whose output expectation defines a trainable function $f_\theta(x)=\langle\psi(x,\theta)|M|\psi(x,\theta)\rangle$ with $|\psi(x,\theta)\rangle=U(\theta)S(x)|0\rangle$ , for classification, regression, or generation.
The pipeline is encode–process–measure: a feature map $S(x)$ embeds the data, a variational ansatz $U(\theta)$ transforms the state, and a measured observable $M$ yields the prediction; gradients come from the hardware-native parameter-shift rule.
A central theorem: a data-re-uploading model is a truncated Fourier series in $x$ , and its frequency spectrum $\Omega$ is fixed by the eigenvalue differences of the encoding generators — $L$ re-uploadings give integer frequencies $\{-L,\dots,L\}$ .
Three model families share this skeleton: explicit (variational) classifiers, implicit quantum-kernel methods that estimate $\kappa(x,x')=|\langle\phi(x)|\phi(x')\rangle|^2$ , and generative Born machines that sample $p_\theta(x)=|\langle x|\psi(\theta)\rangle|^2$ .
Expressibility fights trainability: a circuit random enough to be a unitary 2-design has a barren-plateau gradient variance $\sim 2^{-n}$ , and an over-expressive encoding drives every off-diagonal kernel entry to $2^{-n}$ , collapsing the Gram matrix to the identity.
No unconditional advantage over classical learning is proven; a provable separation exists only for engineered, structured data (a discrete-log quantum kernel), so QML models are best read as a distinct, physically grounded hypothesis class.
Key idea: a QML model is the map $x\mapsto f_\theta(x)=\langle\psi(x,\theta)|M|\psi(x,\theta)\rangle$ with $|\psi(x,\theta)\rangle=U(\theta)S(x)|0\rangle$ ; learning optimizes $\theta$ over data, and the model's reach is a truncated Fourier series whose frequencies are fixed by the data encoding.

The core insight

A QML model is the map $x\mapsto f_\theta(x)=\langle\psi(x,\theta)|M|\psi(x,\theta)\rangle$ with $|\psi(x,\theta)\rangle=U(\theta)S(x)|0\rangle$ ; learning means optimizing $\theta$ over data, and the model's reach is a truncated Fourier series whose accessible frequencies are fixed by the data encoding — not by the depth of the trainable block.

Where this lives today

Quantum machine learning models are the daily currency of the NISQ-era software stack. Every major framework — PennyLane, Qiskit, TensorFlow Quantum — is built around the encode–process–measure model and the parameter-shift gradient, and small variational classifiers, quantum kernels, and Born machines run routinely on superconducting and trapped-ion hardware, with the 2019 IBM feature-map experiment still the canonical demonstration. But the frontier is sober. Hsin-Yuan Huang and co-workers reframed the advantage question in terms of the power of data, showing that classical models with training-data access match many quantum models once thought hard. A parallel dequantization programme, following Ewin Tang's classical algorithms for low-rank problems, has matched quantum kernel and generative claims on structured data, so any advertised speedup must now survive a classical shadow of itself. The open problems are structural: designing encodings whose Fourier spectrum and inductive bias match a real dataset (Kübler, Buchholz, Schölkopf); building symmetry-aware, equivariant models that dodge barren plateaus while staying classically hard; and testing whether discrete-log-style separations extend beyond engineered problems. The live tension — that the structure making a model trainable often makes it classically simulable — is the through-line to aq-qci-barren-plateaus and aq-qci-expressibility-trainability-tradeoffs.

The physical picture

Think of a quantum model as a sandwich. The bread is the data encoding $S(x)$ : it decides which flavours — which frequencies of $x$ — the model can ever taste. The filling is the trainable block $U(\theta)$ : it decides how strongly each flavour contributes. No amount of training can add a frequency the encoding did not put in, which is why the encoding, not the depth, is the architectural decision that matters most. A measurement then reads one number out of an exponentially large space — a lossy readout where all the subtlety of advantage hides. The first figure lays out this encode–process–measure skeleton.

Figure

The encode process measure pipeline of a quantum model: a feature map S(x) writes data into n qubits, a trainable block U(θ) transforms the state, and an observable M is read out as f_θ(x) — the expectation of M in the state U(θ)S(x) acting on the all-zeros register. The encoding fixes which frequencies of x the model can represent, and the trainable block only sets their weights

The three paradigms are three ways of using this skeleton. In an explicit or variational model you train the circuit $U(\theta)$ itself — a flexible, neural-network-like learner with a hard, non-convex landscape. In an implicit or kernel model you freeze the encoding, let the device only estimate inner products $\kappa(x,x')$ , and hand the Gram matrix to a classical machine that solves a convex problem in the fixed geometry the encoding chose. In a generative Born machine you discard the observable and read the measurement distribution $p_\theta(x)$ itself as the model, sampling bitstrings the way a generative network samples images. The tension underneath all three is identical: the Hilbert space is exponentially large, but the model reaches it only through a low-dimensional readout, and making the circuit expressive enough to fill that space is exactly what flattens its landscape and washes out its kernel. The second figure is the quantitative heart of the subject — how data re-uploading builds a frequency comb, and why the encoding sets a hard error floor no training can cross.

Figure

Data re-uploading builds a frequency comb: L layers of a Pauli-Z encoding give exactly the integer frequencies Ω = {−L, …, L}, so a single-feature model is a truncated Fourier series of bandwidth L. To fit a target of frequency K the model needs L ≥ K — a bandwidth-3 target such as cos 3x has zero overlap with the reachable frequencies at L = 2, so its best mean-squared error is 0.5 no matter how the trainable block is tuned, and drops to 0 only at L = 3

The core equations

Everything starts from the model function: the encoded state, transformed by the trainable block, read out through an observable. This one line is the object training will shape and the object the Fourier theorem will unpack.

|\psi(x,\theta)\rangle = U(\theta)\,S(x)\,|0\rangle^{\otimes n},\qquad f_\theta(x)=\langle\psi(x,\theta)|\,M\,|\psi(x,\theta)\rangle \qquad (1)

where: $S(x)$ — data-encoding (feature-map) circuit embedding classical input $x$ into a state; $U(\theta)$ — trainable variational ansatz with parameters $\theta\in\mathbb{R}^p$ ; $M$ — Hermitian measurement observable defining the readout; $f_\theta(x)$ — scalar model output for input $x$ ; $n$ — number of qubits. The encoding chooses the geometry, the ansatz rotates within it, and $M$ collapses the result to one learnable number. Training is classical in spirit: choose $\theta$ to minimize an empirical loss over the dataset, optionally regularized. The device only supplies the values of $f_\theta$ and its gradient; a classical optimizer drives the loop.

\mathcal{L}(\theta)=\frac{1}{N}\sum_{i=1}^{N}\ell\big(f_\theta(x_i),\,y_i\big)+\lambda\,R(\theta) \qquad (2)

where: $\{(x_i,y_i)\}$ — training dataset of $N$ labelled pairs; $\ell$ — per-sample loss (squared error, cross-entropy, hinge); $R(\theta)$ — regularizer; $\lambda\ge 0$ — its weight. Nothing here is quantum except the evaluation of $f_\theta$ — the outer loop is ordinary empirical risk minimization. The structural theorem of the field says the function class realized by (1) is not arbitrary — it is a truncated Fourier series in $x$ , and the accessible frequencies are fixed entirely by the encoding.

f_\theta(x)=\sum_{\omega\in\Omega} c_\omega(\theta)\,e^{i\,\omega\cdot x} \qquad (3)

where: $\Omega$ — frequency spectrum, fixed by the eigenvalue differences of the encoding generators; $c_\omega(\theta)$ — complex Fourier coefficients set by the trainable block $U(\theta)$ and the observable $M$ ; $\omega\cdot x$ — dot product of a frequency vector with the input. The split is absolute: $\Omega$ is the encoding's alone, $c_\omega$ is the ansatz's alone. To train on hardware you need gradients, and for a gate generated by a Pauli the gradient is not a finite difference but an exact analytic identity — the parameter-shift rule.

\frac{\partial f_\theta(x)}{\partial\theta_k}=\frac{1}{2}\Big[f_{\theta+\frac{\pi}{2}e_k}(x)-f_{\theta-\frac{\pi}{2}e_k}(x)\Big] \qquad (4)

where: $e_k$ — unit vector selecting the $k$ -th parameter; $\pi/2$ — the exact shift for a gate generated by an involutory (Pauli) generator with eigenvalues $\pm\tfrac12$ . Each derivative costs two ordinary circuit evaluations at macroscopically shifted angles — no step size, no truncation bias. Freeze the encoding instead of training it, and the natural object is the fidelity kernel: the squared overlap of two encoded states, which the device estimates as the probability of returning to the all-zeros string.

\kappa(x,x')=\big|\langle 0|S^\dagger(x')\,S(x)\,|0\rangle\big|^2 \qquad (5)

where: $\kappa(x,x')$ — Gram-matrix entry, the squared overlap of the feature states $|\phi(x)\rangle=S(x)|0\rangle$ ; $S^\dagger(x')S(x)$ — the circuit whose all-zeros outcome probability equals $\kappa$ . Feed the matrix $\kappa(x_i,x_j)$ to a classical support-vector machine and the decision function is $\sum_i\alpha_i y_i\kappa(x_i,x)+b$ . Discard the observable altogether and the measurement distribution itself is the model: a Born machine samples bitstrings with probabilities given by the Born rule, a natively generative primitive.

p_\theta(x)=\big|\langle x|\psi(\theta)\rangle\big|^2,\qquad |\psi(\theta)\rangle=U(\theta)\,|0\rangle \qquad (6)

where: $p_\theta(x)$ — model probability of bitstring $x$ ; $|\psi(\theta)\rangle$ — the prepared state; sampling the computational basis draws generated data. Because the Born rule can encode distributions believed hard to sample classically, this is a candidate venue for advantage. Born machines give no likelihood gradient by default, so they are trained against a sample-based distance — most often the squared maximum mean discrepancy in some classical kernel.

\mathrm{MMD}^2(p_\theta,q)=\mathbb{E}_{x,x'\sim p_\theta}[\kappa]-2\,\mathbb{E}_{x\sim p_\theta,\,y\sim q}[\kappa]+\mathbb{E}_{y,y'\sim q}[\kappa] \qquad (7)

where: $q$ — the empirical data distribution to be matched; $\kappa$ — a classical kernel between samples; $\mathbb{E}$ — expectation over the indicated draws. The loss vanishes exactly when the model and data distributions agree on every kernel moment, and its gradient is again a parameter-shift of sampled expectations.

Derivation AEvery quantum model is a truncated Fourier series in the data

The goal is to prove the theorem that reorganizes the whole subject: a model re-uploading one scalar feature $x$ through $L$ identical Pauli-rotation encoding layers, interleaved with arbitrary trainable blocks, produces an output that is exactly a Fourier series with the integer frequencies $\{-L,\dots,L\}$ — so the representable functions in $x$ are set by the encoding and the number of re-uploadings, while the trainable block can only move coefficients inside that fixed spectrum. We diagonalize the encoding, stack $L$ layers to accumulate a diagonal phase, expand the expectation into a bra–ket double sum, and read off the frequencies as eigenvalue differences.

Step 1. Take a single-qubit encoding gate $S(x)=e^{-i\frac{x}{2}Z}$ ; in the $Z$ -eigenbasis it is diagonal, $\mathrm{diag}(e^{-ix/2},e^{+ix/2})$ , with eigenvalues $\pm\tfrac12$ . Why: a diagonal generator turns the data into pure phases, so the whole $x$ -dependence of the circuit lives in exponentials $e^{i\lambda x}$ and nothing else.

Step 2. Interleave $L$ such encoding gates with trainable blocks. The combined data-dependent phase acquired along any computational path is $e^{-i\frac{x}{2}\sum_{l=1}^{L}z_l}$ with each $z_l\in\{+1,-1\}$ , so the accumulated eigenvalue $\Lambda=\tfrac12\sum_l z_l$ ranges over $\{-\tfrac{L}{2},\dots,\tfrac{L}{2}\}$ in unit steps. Why: the trainable blocks reshuffle amplitudes among paths but never touch the data phases, so all $x$ -dependence is still carried by these path eigenvalues.

Step 3. The prediction is a sandwich $f_\theta(x)=\langle\psi(x,\theta)|M|\psi(x,\theta)\rangle$ , which pairs a ket phase $e^{-i\Lambda x}$ with a bra phase $e^{+i\Lambda' x}$ , giving $f_\theta(x)=\sum_{\Lambda,\Lambda'}e^{\,i(\Lambda'-\Lambda)x}\,c_{\Lambda\Lambda'}(\theta)$ . The frequencies are the differences $\omega=\Lambda'-\Lambda$ , which populate every integer in $\{-L,\dots,L\}$ . Why: expectation values are quadratic in the state, so it is eigenvalue differences — not the eigenvalues themselves — that appear, exactly as absorption spectra show differences of energy levels.

Step 4. Collect terms of equal frequency into a coefficient $c_\omega(\theta)=\sum_{\Lambda'-\Lambda=\omega}c_{\Lambda\Lambda'}(\theta)$ . The trainable blocks and $M$ set these $c_\omega$ freely (up to the reality constraint $c_{-\omega}=c_\omega^\ast$ ), but they cannot create any $\omega$ outside $\Omega$ . Why: to fit a target of bandwidth $K$ you therefore need $L\ge K$ re-uploadings; a deeper trainable block on a fixed encoding changes the fit's coefficients but never its bandwidth.

f_\theta(x)=\sum_{\omega=-L}^{L} c_\omega(\theta)\,e^{i\omega x},\qquad \Omega=\{-L,\dots,L\} \tag{re-uploading spectrum}

A single Pauli- $Z$ layer gives $\Omega=\{-1,0,1\}$ ; $L$ layers give $\{-L,\dots,L\}$ ; equally-spaced encoding spectra give integer harmonics, which is why the frequency comb in the second figure is uniform.

Go deeper · Derivation B · 1 minThe parameter-shift rule is an exact gradient, not a finite difference

Derivation BThe parameter-shift rule is an exact gradient, not a finite difference

The aim is to show that for a gate generated by a Pauli operator the model's dependence on that gate's angle is a pure single-frequency sinusoid, so the exact derivative equals half the difference of two circuit evaluations shifted by the macroscopic angle $\pm\pi/2$ — an identity, not an approximation, which is what makes gradient training viable on noisy hardware where a small finite-difference step would drown in shot noise. We use the involutory property of Pauli generators to get a closed-form gate, expand to first harmonic, and evaluate the two shifted points.

Step 1. Write the differentiated gate as $U_k(\theta_k)=e^{-i\theta_k P/2}$ with $P$ a Pauli string, $P^2=\mathbb{1}$ . The involutory property gives the closed form $U_k=\cos(\theta_k/2)\,\mathbb{1}-i\sin(\theta_k/2)\,P$ . Why: because $P^2=\mathbb{1}$ , the exponential truncates to a single cosine plus sine, so no higher harmonics of $\theta_k$ can ever appear.

Step 2. Insert this into $f_\theta(x)=\langle\psi|U_k^\dagger M U_k|\psi\rangle$ and expand. Every term is a product of two factors each drawn from $\{\cos(\theta_k/2),\sin(\theta_k/2)\}$ , and the half-angle products collapse via $2\sin\!\tfrac{\theta}{2}\cos\!\tfrac{\theta}{2}=\sin\theta$ and $\cos^2\!\tfrac{\theta}{2}-\sin^2\!\tfrac{\theta}{2}=\cos\theta$ to give $f_\theta(x)=A+B\cos\theta_k+C\sin\theta_k$ . Why: the dependence on this one angle is exactly a first-harmonic sinusoid, with constants $A,B,C$ absorbing everything else in the circuit.

Step 3. Evaluate at the shifted points using $\cos(\theta\pm\tfrac\pi2)=\mp\sin\theta$ and $\sin(\theta\pm\tfrac\pi2)=\pm\cos\theta$ : $f_{\theta+\frac\pi2 e_k}=A-B\sin\theta_k+C\cos\theta_k$ and $f_{\theta-\frac\pi2 e_k}=A+B\sin\theta_k-C\cos\theta_k$ . Their difference is $-2B\sin\theta_k+2C\cos\theta_k=2\,\partial_{\theta_k}f_\theta$ . Why: the two large shifts sample the sinusoid symmetrically, and because the function is a pure sinusoid the finite-shift secant equals the exact tangent — the discretization error that plagues finite differences is identically zero.

\frac{\partial f_\theta(x)}{\partial\theta_k}=\frac{1}{2}\Big[f_{\theta+\frac{\pi}{2}e_k}(x)-f_{\theta-\frac{\pi}{2}e_k}(x)\Big] \tag{parameter shift}

The algebra checks by inspection: $A+B\cos\theta+C\sin\theta$ has derivative $-B\sin\theta+C\cos\theta$ , and $\tfrac12$ of the two-point difference returns exactly this.

Go deeper · Derivation C · 2 minThe fidelity kernel and why over-expressive encodings stop generalizing

Derivation CThe fidelity kernel and why over-expressive encodings stop generalizing

The purpose is to derive the quantum kernel as the physical overlap of encoded states and then show its dark side: if the encoding is expressive enough that $S^\dagger(x')S(x)$ behaves like a Haar-random unitary for distinct inputs, every off-diagonal Gram entry concentrates to $2^{-n}$ , the matrix collapses to the identity, and the model memorizes with zero inductive bias — the kernel analogue of the barren plateau, and the reason raw Hilbert-space dimension buys nothing on its own. We define the feature map, identify the kernel as a return probability, average the overlap with the first Weingarten moment, and read off the consequence for the classifier.

Step 1. The encoding defines a feature map $x\mapsto|\phi(x)\rangle=S(x)|0\rangle$ , and the natural inner product in this feature space is the fidelity $\kappa(x,x')=|\langle\phi(x')|\phi(x)\rangle|^2=|\langle 0|S^\dagger(x')S(x)|0\rangle|^2$ . This is exactly the probability of measuring the all-zeros string after running $S^\dagger(x')S(x)$ on $|0\rangle$ . Why: overlaps are not directly observable, but their modulus squared is a return probability, so the device estimates $\kappa$ by counting all-zeros outcomes.

Step 2. For $x\ne x'$ let $W=S^\dagger(x')S(x)$ and suppose the encoding is expressive enough that $W$ averages like the Haar measure on $d=2^n$ dimensions. The first Weingarten moment gives $\mathbb{E}_{\mathrm{Haar}}|\langle 0|W|0\rangle|^2=1/d=2^{-n}$ . Why: a Haar-random unitary sends $|0\rangle$ to a nearly uniform vector, whose overlap with any fixed state is of order $1/\sqrt d$ in amplitude and $1/d$ in probability.

Step 3. Concentration of measure makes this an equality for almost every pair, not just on average: the fluctuations about $2^{-n}$ are themselves exponentially small, so the Gram matrix is $K\approx\mathbb{1}+2^{-n}(\text{off-diagonal})$ — essentially the identity. Why: distinct data points map to states that are near-orthogonal with overwhelming probability, so the kernel can no longer tell any two of them apart by anything but their labels.

Step 4. A kernel machine trained on $K\approx\mathbb{1}$ returns dual weights $\alpha_i\propto y_i$ : it reproduces the training labels exactly and predicts the mean on anything unseen. Worse, resolving an off-diagonal $\kappa\sim 2^{-n}$ above shot noise needs of order $2^{n}$ measurement shots. Why: high capacity with no inductive bias is memorization, and a useful quantum kernel must therefore keep its overlaps structured — reflecting genuine similarity in the data — rather than merely large-dimensional.

\kappa(x,x')\;\xrightarrow[\ \text{2-design encoding}\ ]{}\;2^{-n}\ \ (x\ne x')\ \Longrightarrow\ K\to\mathbb{1} \tag{kernel concentration}

The $\mathbb{E}_{\mathrm{Haar}}|\langle 0|W|0\rangle|^2=1/d$ first moment is a standard result of Haar-measure integration; the exponential concentration of quantum kernels mirrors the $2^{-n}$ gradient variance seen in barren plateaus.

Limiting cases

The behaviour of a quantum model is governed by three levers: the encoding spectrum, whether the circuit is trained or frozen, and how close the circuit or encoding comes to a unitary 2-design.

Case	Result	Meaning
Single-qubit Pauli encoding, $L$ re-uploadings	$f_\theta(x)=a_0+\sum_{k=1}^{L}\big(a_k\cos kx+b_k\sin kx\big)$	Expressivity in $x$ grows linearly with re-uploadings, not with qubit count; bandwidth is the encoding's choice.
Frozen encoding (implicit / kernel limit)	convex training of $\alpha$ , geometry fixed by $\kappa$	The quantum device only estimates overlaps; optimization is convex but the feature geometry is chosen once and cannot adapt.
Expressive global ansatz ( $\to$ 2-design)	$\mathrm{Var}_\theta[\partial_k f]\sim 2^{-n}$	Deep hardware-efficient explicit models hit a barren plateau: gradient variance vanishes exponentially in $n$ (see aq-qci-barren-plateaus).
Over-expressive encoding ( $\to$ 2-design)	$\kappa(x,x')\to 2^{-n}$ for $x\ne x'$	Off-diagonal kernel entries concentrate, the Gram matrix tends to the identity, and the model memorizes with no generalization.
Low-rank / smooth kernel limit	classically dequantizable	If the kernel is effectively low-rank or bandlimited, a classical algorithm reproduces it — no quantum advantage survives.

Common trapMore qubits and deeper circuits automatically mean a more powerful learner

This is the single most expensive misconception in QML. Expressibility without trainability is useless, and raw dimension without inductive bias is worse. Deepening an explicit model until it approaches a 2-design flattens the landscape to gradient variance $\sim 2^{-n}$ — a barren plateau no optimizer can descend. Pushing a kernel encoding to the same limit drives every off-diagonal overlap to $2^{-n}$ , so the Gram matrix becomes the identity and the model memorizes and generalizes to nothing. And a large Hilbert space is not itself an advantage: many quantum kernels have been dequantized once their structure was understood. The encoding spectrum sets the representable functions, and matching that spectrum and the circuit's inductive bias to real structure in the data — not stacking gates — sets useful learning.

Worked examples

1 · The re-uploading bandwidth and its error floor (fully worked)

A single-qubit model encodes one scalar feature $x$ with $L$ layers of $S(x)=R_Z(x)=e^{-ixZ/2}$ , interleaved with trainable blocks. Show that fitting the target $T(x)=\cos 3x$ has an error floor set by the encoding, not by training.

Step 1. By the Fourier theorem, $L$ re-uploadings give $\Omega=\{-L,\dots,L\}$ , so the model is a trigonometric polynomial $f_\theta(x)=a_0+\sum_{k=1}^{L}(a_k\cos kx+b_k\sin kx)$ of bandwidth $L$ . The representable bandwidth equals the number of re-uploadings.

Step 2. The target $\cos 3x$ is a single mode at $\omega=3$ . A model with $L=2$ has $\Omega=\{-2,\dots,2\}$ , which excludes $\pm3$ , and since Fourier modes are orthogonal over a period, no choice of $\theta$ can place any weight there. The best $L=2$ fit is zero on the $\omega=3$ component.

Step 3. Then the residual is all of $\cos 3x$ , whose mean-squared value over a period is $\langle\cos^2 3x\rangle=\tfrac12$ , so $\mathrm{MSE}_{L=2}=\mathbf{0.5}$ no matter how long you train or how many parameters the block carries. The floor is a property of the encoding.

Step 4. At $L=3$ , $\Omega=\{-3,\dots,3\}$ contains $\pm3$ , and $a_3=1$ with all else zero reproduces the target: $\mathrm{MSE}_{L=3}=\mathbf{0}$ . Enlarging the encoding — not the trainable depth — unlocked the fit, which is why data encoding is the dominant architectural choice.

2 · Concentration of a product feature-map kernel (fully worked)

A quantum kernel encodes $n$ real features with $S(x)=\bigotimes_{j=1}^{n}R_Y(x_j)$ , so $|\phi(x)\rangle=\bigotimes_j(\cos\tfrac{x_j}{2}|0\rangle+\sin\tfrac{x_j}{2}|1\rangle)$ . Compute the fidelity kernel and show how it concentrates as $n$ grows.

Step 1. For one qubit the overlap is $\cos\tfrac{x-x'}{2}$ , so $\kappa_1(x,x')=\cos^2\tfrac{x-x'}{2}=\tfrac12(1+\cos(x-x'))$ . Anchors: $\kappa_1(0,0)=1$ , $\kappa_1(0,\tfrac\pi2)=\mathbf{0.5}$ , $\kappa_1(0,\pi)=\mathbf{0}$ (orthogonal). A smooth, well-behaved similarity in one dimension.

Step 2. The states factorize, so $\kappa(x,x')=\prod_{j=1}^{n}\cos^2\tfrac{x_j-x'_j}{2}$ , and each factor averages to $\tfrac12$ over random distinct inputs. Independent features multiply the overlaps.

Step 3. For a typical distinct pair each factor is about $\tfrac12$ , so $\kappa\approx(\tfrac12)^n=2^{-n}$ : at $n=10$ , $2^{-10}\approx\mathbf{9.8\times10^{-4}}$ ; at $n=20$ , $2^{-20}\approx\mathbf{9.5\times10^{-7}}$ . Off-diagonal similarity decays exponentially in the feature count.

Step 4. So the Gram matrix is the identity to within a part in a million by $n=20$ : the classifier sees every distinct sample as orthogonal and memorizes, and resolving one entry above shot noise needs $N\sim1/\kappa\sim2^{n}\approx\mathbf{10^{6}}$ shots. A product encoding of independent features is over-expressive — high dimension, zero inductive bias, the barren-plateau wall seen through the kernel.

Physics of the portrait

The quantum machine learning model is a synthesis node, not the invention of any one person: it is where feature maps, variational circuits, hardware gradients, and generative sampling were recognized as one family of learners with one governing theorem.

Origins · 1 minquantum machine learning model and how this was discovered

quantum machine learning model

the trainable circuit f_θ(x) = ⟨ψ(x,θ) · M

The quantum machine learning model is a concept assembled over a single fast decade. Its kernel branch begins in 2014, when Patrick Rebentrost, Masoud Mohseni, and Seth Lloyd proposed a quantum support vector machine that reads data into quantum states and classifies by overlap. The variational branch crystallized in 2018: Kosuke Mitarai, Makoto Negoro, Masahiro Kitagawa, and Keisuke Fujii introduced quantum circuit learning with the parameter-shift rule that makes gradients hardware-native, while Edward Farhi and Hartmut Neven framed near-term classification as a quantum neural network. In 2019 two papers reframed the enterprise as geometry: Vojtěch Havlíček and colleagues at IBM, and independently Maria Schuld and Nathan Killoran, showed that a quantum encoding is a feature map into Hilbert space and that supervised learning there is kernel learning — demonstrated on superconducting hardware (Nature 567, 209). Adrián Pérez-Salinas and co-workers introduced data re-uploading in 2020, and in 2021 Maria Schuld, Ryan Sweke, and Johannes Jakob Meyer proved the theorem that organizes this article — a data-encoding model is a truncated Fourier series whose spectrum the encoding fixes (Phys. Rev. A 103, 032430). The same year Yunchao Liu, Srinivasan Arunachalam, and Kristan Temme gave the field its one rigorous learning speedup, a discrete-logarithm kernel classifying what no efficient classical learner can. Marco Cerezo, Zoë Holmes, Patrick Coles and others then supplied the cautionary half — barren plateaus, kernel concentration, dequantization — turning a collection of demos into a discipline organized around the expressibility–trainability trade-off.

History

2014

— Rebentrost, Mohseni, and Lloyd propose the quantum support vector machine

2018

— Mitarai, Negoro, Kitagawa, and Fujii introduce quantum circuit learning with the parameter-shift rule

2019

— Havlíček et al. and Schuld–Killoran recast supervised learning as quantum feature-space methods

2020

— Pérez-Salinas and co-workers introduce data re-uploading for a universal classifier

2021

— Schuld, Sweke, and Meyer prove the Fourier-series theorem; Liu, Arunachalam, and Temme give a provable kernel speedup

Going further

Texts and reviews. Schuld and Petruccione, Machine Learning with Quantum Computers, Springer (2021) · Nielsen and Chuang, Quantum Computation and Quantum Information, 10th anniv. ed., Ch. 4 (circuits) and Ch. 2 (measurement) · Preskill, Ph219 lecture notes and "Quantum Computing in the NISQ era and beyond," Quantum 2, 79 (2018) · Watrous, The Theory of Quantum Information (Haar measure, Weingarten calculus) · Cerezo et al., "Variational Quantum Algorithms," Nature Reviews Physics 3, 625 (2021) · Schuld, Sweke, Meyer, "Effect of data encoding on the expressive power of variational quantum machine learning models," Phys. Rev. A 103, 032430 (2021) · Havlíček et al., "Supervised learning with quantum-enhanced feature spaces," Nature 567, 209 (2019) · Mitarai, Negoro, Kitagawa, Fujii, "Quantum circuit learning," Phys. Rev. A 98, 032309 (2018). Key results to keep in mind: the model map $|\psi(x,\theta)\rangle=U(\theta)S(x)|0\rangle$ yields a Fourier representation with a single Pauli- $Z$ encoding giving $\Omega=\{-1,0,1\}$ and $L$ layers giving $\{-L,\dots,L\}$ ; the parameter-shift rule for Pauli-generated gates rests on the first-harmonic dependence $A+B\cos\theta_k+C\sin\theta_k$ and the exact $\pm\pi/2$ two-point identity; the fidelity-kernel concentration gives $\mathbb{E}_{\mathrm{Haar}}|\langle 0|W|0\rangle|^2=1/d=2^{-n}$ ; the worked numbers are $\langle\cos^2 3x\rangle=\tfrac12$ so $\mathrm{MSE}_{L=2}=0.5$ and $\mathrm{MSE}_{L=3}=0$ ; $\kappa_1(0,\tfrac\pi2)=0.5$ , $\kappa_1(0,\pi)=0$ ; and $2^{-10}\approx9.8\times10^{-4}$ , $2^{-20}\approx9.5\times10^{-7}$ . The discrete-log separation is Liu, Arunachalam, and Temme, Nature Physics 17, 1013 (2021).

Prerequisites. Parameterized Quantum Circuits and Ansatz Design · Quantum Feature Maps and Kernel Methods · Parameter-Shift Rules and Quantum Gradients · Cost-Function and Measurement Estimation in Variational Algorithms. Leads to. Barren Plateaus in Variational Landscapes · Expressibility, Entangling Capability, and Trainability Trade-offs · Classical Optimizers for Variational Quantum Algorithms.

Ask the tutor: Ask me to derive the re-uploading Fourier spectrum for your encoding, work the parameter-shift gradient or the kernel-concentration bound for a circuit of your size, or map out when an explicit, implicit, or generative model is the right choice for your data.

What is the difference between an explicit and an implicit quantum model?

They are two ends of one spectrum. In an explicit (variational) model you train the circuit $U(\theta)$ itself: the device prepares states and measures observables for every prediction and gradient, and the optimization is non-convex and can hit barren plateaus. In an implicit (kernel) model you fix the encoding, use the device only to estimate inner products $\kappa(x,x')$ , and hand the Gram matrix to a classical support-vector machine that solves a convex problem. Explicit models are more flexible but harder to train; implicit ones train convexly but are stuck with the geometry the fixed encoding chose. Both use the same feature map — they differ only in whether the quantum part is trained.

Does adding more qubits or more depth make a quantum model more powerful?

Not by itself, and often the opposite. The functions of $x$ a model can represent are fixed by the encoding's frequency spectrum, so a deeper trainable block only reshuffles Fourier coefficients — it never adds a frequency the encoding left out. Worse, pushing an explicit model toward maximal expressibility drives it into a barren plateau with gradient variance $\sim2^{-n}$ , and pushing a kernel encoding the same way collapses its Gram matrix to the identity. Power comes from matching the encoding and the circuit's inductive bias to structure in the data, not from stacking qubits. Bigger is usually less trainable, not more capable.

Why is the data encoding the most important design choice?

Because it alone fixes what the model can represent. The Fourier theorem says a re-uploading model is a truncated Fourier series in $x$ whose frequencies $\Omega$ are the eigenvalue differences of the encoding generators; the trainable block and observable only set the coefficients. So the encoding is a hard bandwidth limit: fitting a target of bandwidth $K$ needs at least $K$ re-uploadings, and no training on a too-narrow encoding can cross that floor — a bandwidth-3 target keeps mean-squared error $0.5$ on a bandwidth-2 model. The encoding is the QML analogue of a neural network's architecture, and it dominates everything downstream.

Is the parameter-shift rule just a finite-difference gradient in disguise?

No, and the distinction is what makes hardware training feasible. For a Pauli-generated gate the expectation is exactly a first-harmonic sinusoid $A+B\cos\theta_k+C\sin\theta_k$ , so evaluating at $\theta_k\pm\pi/2$ and halving the difference returns the exact analytic derivative, with no discretization error. A finite difference needs a small step $h$ that trades truncation bias against amplified shot noise as $h\to0$ . The parameter-shift rule uses a macroscopic $\pi/2$ shift and is unbiased, so it is far more robust to the finite-shot noise that dominates real devices. It is an identity, not an approximation.

Do quantum machine learning models have a proven advantage over classical ones?

Only in narrow, engineered cases. The one rigorous result is a quantum kernel built from the discrete-logarithm problem (Liu, Arunachalam, Temme 2021) that provably classifies data no efficient classical learner can — but it relies on cryptographic structure, not generic data. For unstructured problems there is no such guarantee, and several lines push the other way: barren plateaus block training, kernel concentration destroys generalization, and dequantization has matched many quantum claims on low-rank data. Huang and co-workers showed that access to training data closes many supposed gaps. QML models are a distinct hypothesis class whose advantage, where it exists, comes from genuinely quantum structure in the data.

What is data re-uploading and why does it matter?

Data re-uploading means encoding the same input $x$ several times, interleaved with trainable blocks, instead of once. It is the knob that sets the model's bandwidth: a single Pauli-rotation encoding contributes only frequencies $\{-1,0,1\}$ , while re-uploading $L$ times enlarges the spectrum to all integers in $\{-L,\dots,L\}$ , making the model a Fourier series of bandwidth $L$ . This is how a single qubit becomes a universal function approximator in one variable — not by widening the register but by repeating the encoding. It turns an encoding's otherwise fixed expressivity into something you can dial up, which is why it is now standard in variational classifiers.

Are quantum kernels always better than classical kernels?

No. A quantum kernel is a similarity measure computed by overlap of encoded states, useful only if that similarity reflects real structure in the data. If the encoding is too expressive the kernel concentrates — every off-diagonal entry falls to $2^{-n}$ , the Gram matrix becomes the identity, and the model memorizes without generalizing, the failure the third derivation quantifies. If the kernel is instead effectively low-rank, a classical algorithm often reproduces it (dequantization), erasing any advantage. A quantum kernel wins only when its similarity is both hard to compute classically and genuinely informative about the labels — much sharper than merely mapping data into a large Hilbert space.