Quantum Convolutions: Patterns & Applications

• Quantum convolutions are a family of quantum operations that generalize classical convolution by leveraging locality and repeated structure.
• They enable advanced quantum architectures, including QCNNs and neural layers, through techniques like QFT, LCU, and amplitude encoding.
• Research in quantum convolutions addresses resource challenges, state-preparation complexities, and seeks to unify operator theory with neural methods.

Quantum convolutions are not a single construction but a family of quantum operations that instantiate, approximate, reinterpret, or generalize convolution across several domains. In the literature, the term denotes at least four recurring objects: classical convolutions implemented as quantum linear operators or inner-product estimators; quantum neural layers acting on local image patches or channel vectors; convolution–pooling circuits on quantum many-body states; and bilinear or operator-valued convolutions defined directly on quantum states, channels, signals, or graphs (Roshanshah et al., 25 Jul 2025, Ning et al., 2024, Yang et al., 16 Mar 2026, Castelazo et al., 2021, Sander et al., 2024, Bistroń et al., 2023). The common thread is locality combined with repeated structure: a kernel, unitary block, shift family, or graph motif is reused across positions, channels, or algebraic indices.

1. Scope and main meanings

The contemporary usage of the term is best understood taxonomically.

Setting	Convolved object	Representative mechanism
Classical data on quantum hardware	Images, signals, group-indexed functions	DBT/Toeplitz reshaping, LCU, QFT, SWAP-based inner products
Quantum neural layers	Local patches or channel vectors	PQCs, randomized circuits, ancilla-mediated channel mixing
QCNNs on quantum states	Many-body lattice states	Local translationally invariant unitaries plus pooling
State- or graph-level convolution	Density matrices, channels, walk graphs	Tristochastic channels, Weyl-phase-space convolution, graph reduction

In the first sense, convolution remains a linear operator on classical data but is executed through quantum arithmetic, block-encodings, modular adders, or overlap estimation. In the second, the classical notion of a trainable local kernel is replaced by a parameterized or randomized quantum circuit whose measurement outputs become feature maps. In the third, QCNNs use “convolution” in a renormalization-like sense: repeated local unitaries and pooling compress many-body states while preserving phase information. In the fourth, convolution is defined intrinsically on quantum states or on graph/Hamiltonian structures, rather than on classical tensors (Roshanshah et al., 25 Jul 2025, Orduz et al., 30 Aug 2025, Qu et al., 11 Apr 2025, Bu et al., 2023, Abramov et al., 21 Jul 2025).

A frequent source of confusion is the assumption that all quantum convolutions are quantum analogues of the same classical CNN primitive. The literature instead spans exact operator realizations of circular or group convolution, learned patchwise feature extractors, and non-neural constructions such as convolutions of density operators or graph reductions preserving continuous-time quantum-walk dynamics (Wei et al., 2021, Castelazo et al., 2021, Bistroń et al., 2023, Abramov et al., 21 Jul 2025).

2. Operator-theoretic formulations

A large strand of work treats convolution as a structured linear map. For discrete circular convolution over $\mathbb{Z}/N\mathbb{Z}$, the operator viewpoint writes

$C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$

where $L_{i,N}$ are cyclic shift operators. In amplitude encoding, $C_N(\mathbf{b})|\mathbf{a}\rangle$ is exactly the convolved output. An asymmetric LCU construction realizes this operator as the postselected block of a circuit whose SELECT unitary is modular addition, $\mathrm{ADD}_N=\mathrm{SELECT}_L$, and whose ancilla treatment is deliberately asymmetric so that the coefficients $b_i$ are preserved rather than replaced by $|b_i|^2$ (Yang et al., 16 Mar 2026). The same paper introduces a reversal layer $J_n=X^{\otimes n}$ and reflected shifts $\widetilde{L}_{i,n}=L_{i,n}J_n$, producing a symmetrized operator $H_n(\mathbf{b})=\sum_i b_i\widetilde{L}_{i,n}$ that is Hermitian for real kernels and therefore directly compatible with QSVT-based spectral transformations (Yang et al., 16 Mar 2026).

On finite groups, convolution and cross-correlation are written as linear combinations of left or right regular representations,

$C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$0

with analogous formulas for cross-correlation. Block-encodings arise either from LCU in the “real regime” or from group Fourier transform block-diagonalization in the “Fourier regime,” yielding runtimes polylogarithmic in $C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$1 under efficient state preparation, oracle access, and favorable conditioning (Castelazo et al., 2021). For abelian groups, the convolution operator is diagonal in the Fourier basis; for non-abelian groups it becomes block diagonal over irreducible representations (Castelazo et al., 2021).

QFT-based signal-processing constructions specialize the same idea. One line computes 1-D circular convolution of length-$C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$2 signals encoded in 3-qubit superpositions by taking the QFT of one signal, multiplying by a pre-known filter spectrum $C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$3 via controlled phase operations and a non-unitary magnitude operator $C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$4, and then applying the IQFT; ideal low-pass and high-pass filters are presented explicitly in this framework (Grigoryan et al., 2022). Another line uses “processing through encoding”: after encoding $C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$5 and $C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$6 onto ancilla amplitudes, the pointwise product $C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$7 appears in the coefficient of an ancilla basis state, and inverse QFT yields $C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$8 (Papageorgiou et al., 12 Dec 2025). The success probability in that construction is determined by the postselection probability on the ancilla subspace carrying the desired product (Papageorgiou et al., 12 Dec 2025).

A distinct but related formulation appears in sparse matrix encoding of CNN convolution. There, a 2D convolution is rewritten as

$C_N(\mathbf{b}) := \sum_{i=0}^{N-1} b_i\, L_{i,N},$9

where $L_{i,N}$0 is a doubly block-Toeplitz matrix obtained from the kernel tensor, $L_{i,N}$1 is the flattened input, and $L_{i,N}$2 is the flattened output (Roshanshah et al., 25 Jul 2025). The structural point is that all redundancy is pushed to the kernel side, and the resulting DBT matrix is highly sparse and structured, enabling sparsity-aware state preparation and low-depth inner-product estimation rather than dense patch-matrix multiplication (Roshanshah et al., 25 Jul 2025).

3. Patchwise and channelwise quantum neural layers

A second strand uses the term for trainable or fixed quantum circuits that replace a classical convolutional kernel on local classical data. In the sparse-DBT formulation, the quantum layer prepares states $L_{i,N}$3 for DBT rows and $L_{i,N}$4 for flattened inputs, and estimates inner products through a low-depth SWAP-test variant. The ancilla outcome probability

$L_{i,N}$5

encodes the convolutional response, while superposition over many $L_{i,N}$6 pairs yields a generalized SWAP circuit for batched convolution across positions, filters, and inputs (Roshanshah et al., 25 Jul 2025). The same work emphasizes that preprocessing is $L_{i,N}$7 for DBT kernel construction and that state-preparation cost depends on $L_{i,N}$8 under augmented QRAM assumptions, rather than on dense input dimension (Roshanshah et al., 25 Jul 2025).

Quantum pointwise convolution targets the $L_{i,N}$9 CNN primitive. For each pixel, the channel vector is amplitude-encoded, acted on by a strongly entangling PQC

$C_N(\mathbf{b})|\mathbf{a}\rangle$0

and measured in the Pauli-$C_N(\mathbf{b})|\mathbf{a}\rangle$1 basis to produce one output feature per qubit (Ning et al., 2024). In the reported implementation, 6 qubits and 2–4 strongly entangling blocks are used, gradients are computed by the parameter-shift rule, and the layer is inserted as a drop-in replacement for classical pointwise convolution in hybrid CNNs (Ning et al., 2024). The experiments report that the model stabilizes above 95% accuracy on FashionMNIST and reaches approximately 90% accuracy on CIFAR10, while the classical baseline stabilizes around 80% on the latter; deeper entangling stacks perform better in the reported ablation (Ning et al., 2024).

Several other constructions keep the patchwise-CNN intuition but alter the mechanism. In quanvolutional autoencoders, local image patches such as $C_N(\mathbf{b})|\mathbf{a}\rangle$2 windows are angle-encoded by $C_N(\mathbf{b})|\mathbf{a}\rangle$3 rotations on 16 qubits, processed by a fixed randomized circuit $C_N(\mathbf{b})|\mathbf{a}\rangle$4, and measured to produce feature maps consumed by a classical convolutional autoencoder (Orduz et al., 30 Aug 2025). The quantum layer is explicitly non-trainable; the downstream autoencoder is trained with binary cross-entropy, and the reported results show performance comparable to classical autoencoders, with accelerated early convergence in some latent-space regimes (Orduz et al., 30 Aug 2025). QuCNN instead treats both data patches and filters as quantum states and defines the convolution output by SWAP-test overlap,

$C_N(\mathbf{b})|\mathbf{a}\rangle$5

together with an ancilla-based procedure for backpropagating $C_N(\mathbf{b})|\mathbf{a}\rangle$6 through the overlap computation (Stein et al., 2022).

For multi-channel classical data, QCNN kernels can be made channel-aware without scaling qubit count with the number of channels. Channel Overwrite, Parallel Channel Overwrite, and related ansatzes reuse a common ancilla or multiple ancillae to accumulate inter-channel phase information while working registers are overwritten or processed in parallel; on CIFAR-10 and synthetic multi-channel datasets these architectures outperform existing QCNN baselines in the reported experiments, with circuit widths and depths explicitly tabulated for RGB and higher-channel settings (Smaldone et al., 2023). A different NISQ-oriented QCNN realizes classical image filters directly as LCUs of unitary blocks $C_N(\mathbf{b})|\mathbf{a}\rangle$7 so that smoothing, sharpening, edge detection, and MNIST recognition can be implemented with convolution parameters independent of input size (Wei et al., 2021).

4. QCNNs on quantum many-body states

In many-body physics, “quantum convolution” refers to local translationally invariant quantum circuits that act directly on quantum states rather than on classical tensors. A general QCNN is written as

$C_N(\mathbf{b})|\mathbf{a}\rangle$8

where each layer combines convolution and pooling, and the final output is obtained by measuring a small number of qubits (Sander et al., 2024). In a 2D toric-code setting, the convolution $C_N(\mathbf{b})|\mathbf{a}\rangle$9 is built from the inverse of an exact toric-code ground-state preparation circuit, supplemented by SWAP and CNOT layers so that plaquette and star stabilizers are mapped to dedicated qubits on two sublattices (Sander et al., 2024). Pooling then acts on periodically chosen target qubits using CNOT and Toffoli structures, reducing the number of qubits while preserving topological information (Sander et al., 2024).

This architecture is used for phase recognition in two dimensions: the network identifies the transition from a Toric Code phase with $\mathrm{ADD}_N=\mathrm{SELECT}_L$0 topological order to the paramagnetic phase, and the reported simulations show a noise threshold up to which topological order is recognized (Sander et al., 2024). The same paper gives an explicit output statistic,

$\mathrm{ADD}_N=\mathrm{SELECT}_L$1

whose expectation approaches 1 in the topological phase and 0 in the non-topological phase after the prescribed post-processing (Sander et al., 2024).

A complementary interpretation analyzes QCNNs as models using hidden feature maps generated by quantum data. For cluster-type Hamiltonians, ground-state preparation itself is a feature map $\mathrm{ADD}_N=\mathrm{SELECT}_L$2, and QCNN layers adapt the measurement so that a few-qubit observable implements a sharp decision boundary at the critical point (Umeano et al., 2023). The analysis attributes the performance of QCNN phase recognition to the generation of an effective basis set with sharp features at critical points, while the variational circuit learns a measurement that selects those features (Umeano et al., 2023).

Another theoretical line claims that convolution is inherent to QNNs. For an $\mathrm{ADD}_N=\mathrm{SELECT}_L$3-qubit gate acting on an amplitude-encoded state, the paper proves equivalence to a convolutional layer with kernel size $\mathrm{ADD}_N=\mathrm{SELECT}_L$4, stride $\mathrm{ADD}_N=\mathrm{SELECT}_L$5, and $\mathrm{ADD}_N=\mathrm{SELECT}_L$6 output channels; gate position determines dilation, and sequential local gates yield stacked convolutional layers (Qu et al., 11 Apr 2025). This is not a patch-encoding construction but a reinterpretation of local gate action on amplitude vectors as block-diagonal application of shared kernels (Qu et al., 11 Apr 2025). A plausible implication is that some QCNN designs can be specified directly by desired classical convolutional attributes—kernel size, dilation, and channel count—and then mapped to gate locality and qubit position.

5. Convolutions defined directly on quantum states and other non-classical objects

A more intrinsic notion defines convolution as an operation on quantum states themselves. For discrete-variable systems, one construction uses Weyl operators and a two-register Clifford unitary $\mathrm{ADD}_N=\mathrm{SELECT}_L$7 associated with an invertible matrix $\mathrm{ADD}_N=\mathrm{SELECT}_L$8 over $\mathrm{ADD}_N=\mathrm{SELECT}_L$9, and defines

$b_i$0

On characteristic functions, this satisfies a convolution–multiplication duality: the characteristic function of $b_i$1 is the pointwise product of transformed characteristic functions of $b_i$2 and $b_i$3 (Bu et al., 2023). Within this framework, stabilizer states are “discrete quantum Gaussians”: convolution of two stabilizer states yields another stabilizer state, MSPSs extremize Rényi entropies, and repeated convolution of a zero-mean state converges exponentially to a stabilizer state, with rate bounded by the “magic gap” (Bu et al., 2023).

A related but distinct framework starts from tristochastic tensors and higher-order Markov chains. Classically, a cubic tensor $b_i$4 induces

$b_i$5

and the paper analyzes commutativity, associativity, identities, inverses, reducibility, and generalized eigenvectors for such operations (Bistroń et al., 2023). Quantumly, a binary channel $b_i$6 with tripartite Choi matrix $b_i$7 defines

$b_i$8

and coherification promotes a classical tristochastic tensor to a CPTP map whose diagonal reproduces the classical convolution on diagonal states (Bistroń et al., 2023). The paper proposes this as a quantum analogue of probability-vector convolution and discusses possible uses in error mitigation and as a building block in QCNNs (Bistroń et al., 2023).

The term also appears outside state and tensor calculus. In graph-theoretic quantum walks, “convolution” denotes reduction of high-dimensional structured graphs—hypercubes, hypercycles, lattices—to smaller graphs preserving continuous-time quantum-walk dynamics. Hypercubes map to weighted line graphs with couplings $b_i$9, hypercycles map to line or lattice graphs via Kronecker-product structure, and numerical experiments compare hitting probabilities and classical-versus-quantum walk speed on original and convolved graphs (Abramov et al., 21 Jul 2025). This is a Hamiltonian-level notion of convolution rather than a neural or signal-processing one.

6. Resource assumptions, misconceptions, and open directions

Across these formulations, the decisive technical issue is rarely the abstract existence of a “quantum convolution,” but the surrounding resource model. Sparse DBT approaches rely on QRAM or augmented QRAM and claim state-preparation costs such as $|b_i|^2$0 for multiple copies under preprocessing assumptions; they are low depth because the inner-product circuit is essentially a Hadamard-controlled state preparation plus SWAP-like interference, but repeated sampling is still required (Roshanshah et al., 25 Jul 2025). Pointwise and patchwise PQC layers reduce qubit count through amplitude encoding or shallow patch encodings, yet their practical bottlenecks include state preparation, CPU–GPU communication in simulation, and noise on real hardware (Ning et al., 2024, Orduz et al., 30 Aug 2025). QFT- and LCU-based exact operator formulations can be polylogarithmic in signal size or group size, but their guarantees depend on efficient preparation of input and kernel states, oracle access, favorable postselection probabilities, and well-conditioned linear maps (Yang et al., 16 Mar 2026, Castelazo et al., 2021, Papageorgiou et al., 12 Dec 2025).

A recurring misconception is that quantum convolution necessarily implies a quantum speedup for classical CNN workloads. The literature is more cautious. Some proposals are exact operator implementations whose asymptotic advantages are tied to oracle and conditioning assumptions; some are feature-extraction modules whose empirical benefits are reported on simulators; and some are phase-recognition circuits for genuinely quantum data, where the gain is low sampling cost and direct access to many-body structure rather than classical-image acceleration (Castelazo et al., 2021, Ning et al., 2024, Orduz et al., 30 Aug 2025, Sander et al., 2024). Another misconception is that the kernel must always be trainable: several works use fixed randomized circuits or exact operator embeddings of prescribed filters, and others interpret local gates themselves as convolutional kernels without patch re-encoding (Orduz et al., 30 Aug 2025, Wei et al., 2021, Qu et al., 11 Apr 2025).

The present literature suggests several stable research directions. One is unification between operator-centric convolutions and neural constructions: block-encoded or sparse linear convolutions can serve as quantum feature-extraction modules inside hybrid pipelines (Roshanshah et al., 25 Jul 2025, Yang et al., 16 Mar 2026). Another is extending channelwise and pointwise quantum layers to larger backbones without losing NISQ-feasible depth (Ning et al., 2024, Smaldone et al., 2023). A third is the use of convolution-like operations as renormalization, coding, or denoising primitives on quantum states, where the relation between pooling, error correction, and phase structure is already explicit (Sander et al., 2024, Umeano et al., 2023, Bistroń et al., 2023). This suggests that “quantum convolution” is best treated not as a single primitive, but as a structured design pattern linking locality, repeated symmetry, and compressed readout across quantum linear algebra, quantum signal processing, and quantum machine learning.