Revealing Quantum Information Encoded in Classical Images

Abstract

We study a minimal quantum pre-processing filter for image feature extraction built from angle embeddings and two Control-NOT (CNOT) gates. Our goal is to assess whether such a lightweight quantum front-end can benefit classical classifiers and to investigate whether its induced entanglement—measured via average single-qubit von Neumann entropy—relates to predictive performance. The circuit admits three spatially symmetric layouts (diagonal, vertical, and horizontal), each producing distinct feature transformations. Experiments show that the filter can provide modest gains in shallow learning settings, but it does not consistently outperform strong classical baselines. Notably, we find no reliable relationship between entanglement and classification accuracy: variations in average entropy fail to consistently track performance. These results suggest that the utility of simple quantum filters is determined more by dataset structure and model capacity than by entanglement magnitude, offering practical guidance for the design of hybrid quantum–classical learning pipelines.

1. Introduction

The rapid advancements in both machine learning (ML) and quantum computing have led to the emergence of quantum machine learning (QML), a promising interdisciplinary field that leverages quantum mechanics to enhance computational capabilities [1]. Among the many applications of ML, image classification has seen remarkable progress in recent decades, becoming increasingly crucial across diverse sectors, including medical diagnosis and autonomous driving. Convolutional Neural Networks (CNNs) [2] have played a central role in this success, excelling at hierarchically extracting spatial features from visual data.

Numerous researchers have developed various concepts for QML. Early work explored quantum algorithms for support vector machines (SVMs), demonstrating potential speedups over their classical counterparts [3]. Initial theoretical explorations also investigated how fundamental neural-network components, such as artificial neurons (i.e., the Rosenblatt perceptron [4]), could be realised on quantum hardware [5]. More recently, Tacchino et al. [6] revisited the quantum perceptron using parameterised quantum circuits (PQCs) with hardware-efficient single-qubit gates that can be stacked into trainable networks suitable for Noisy Intermediate-Scale Quantum (NISQ) [7] devices, characterised by a limited number of qubits and susceptibility to noise. The crucial step of encoding classical data into quantum states has been rigorously analysed; concurrently Schuld and Killoran [8] and Havlíček et al. [9] independently formalised these encodings as quantum feature maps that underpin kernel methods and variational classifiers. Cong et al. [10] introduced a Quantum Convolutional Neural Network (QCNN) that uses only $\mathcal{O}(logN)$ variational parameters for N qubits and can recognise quantum phases.

Variational quantum algorithms emerged as a natural progression in this field. Farhi and Neven [11] proposed a quantum neural network suitable for near-term processors. Mitarai et al. [12] introduced quantum circuit learning, demonstrating how parameterised quantum circuits can approximate nonlinear functions. Addressing practical concerns, McClean et al. [13] highlighted barren-plateau trainability issues, and subsequent work demonstrated gradient-preserving circuit designs [14] and noise-resilient optimisation strategies [15].

Recent efforts in QML have focused on integrating quantum components into classical neural network architectures. Liu et al. [16] embedded PQCs into classical convolutional blocks, yielding the hybrid quantum–classical convolutional neural network (QCCNN) and noting its robustness to moderate hardware noise [15]. Henderson et al. [17] developed the Quantum Convolutional (Quanvolutional) Neural Network (QNN) by incorporating quantum layers with arbitrary quantum filters into CNN pipelines, while Mari’s [18] PennyLane demo distilled this idea to a single quantum layer whose outputs feed a shallow artificial neural network. Beyond classification, QML has also been explored for generative modelling [19] and the community has begun to formalise benchmarking practice, e.g., Bowles et al. [20] on the pitfalls and design principles of QML benchmarks.

Building upon the work of Henderson et al. [17] and Mari [18], Riaz et al. [21] introduced the concept of quantum pre-processing filters (QPFs), demonstrating their potential to improve image classification accuracy within a simple quantum kernel filter combined with a small neural network model. However, despite the demonstrated utility of QPFs, the underlying reasons for their variable performance across different datasets, sometimes leading to improved accuracy and other times to degradation, remain largely unexplored. Understanding these influencing factors is critical for the robust development and deployment of hybrid quantum–classical architectures.

To address this knowledge gap, we investigated the factors contributing to the performance of QPFs, with a specific focus on their impact on validation and test accuracy. Our primary hypothesis centred on the role of entanglement. To systematically examine this, we introduced the concept of spatial symmetry within the QPF circuit, which governs the qubit entanglement patterns introduced by combining rotation gates with CNOT gates. We took the exact QPF circuit designed by Riaz et al. [21] and systematically modified the control-target qubit configurations of the CNOT gates. Through experimentation with 24 combinations, we identified three distinct spatial symmetries: diagonal, vertical, and horizontal (see Section 2 for detailed circuit configurations). Furthermore, we explored the relationship between classification accuracy and the degree of entanglement generated by each QPF symmetry for various datasets through the lens of von Neumann entropy [22]. Our approach utilises a hybrid quantum–classical framework suitable for NISQ devices.

This study makes three contributions. First, we perform a controlled sweep of all 24 pixel-to-wire permutations of a fixed four-qubit QPF. Second, we group these permutations into diagonal, vertical, and horizontal symmetry classes based on the spatial pixel pairings induced by the CNOT gates. Third, we compare these symmetry-conditioned feature maps across multiple datasets and analyse whether their average von Neumann entropy correlates with downstream classification performance. This distinguishes our work from earlier quanvolutional and QPF studies by focusing on the behaviour and interpretability of QPF design choices, rather than proposing a new quantum architecture.

This paper presents our findings on the impact of QPF spatial symmetries on image classification performance and their correlation with entanglement levels. We detail the experimental setup and methodology in Section 2, present and discuss the classification results and entanglement analysis in Section 3. Finally, Section 4 concludes the paper with a summary of key insights.

2. Method

2.1. Hybrid Quantum–Classical Architecture and Symmetry Variants

In this section, we describe the proposed hybrid quantum-classical architecture for image classification that we used to verify the existence of intrinsic quantum hidden features from images. It utilises a quantum pre-processing filter and its variations, where permutations of circuit components are explored for quantum feature extraction, followed by a classical neural network for classification.

The filter is designed as a $2\times 2$ quantum kernel, convolved with the image by applying it to non-overlapping $2\times 2$ patches. This enables per-patch quantum feature extraction across the whole image; see Figure 1. To evaluate this architecture, we use open-source grayscale datasets. Each dataset provides grayscale images as $N\times N$ matrices. The images were directly processed for quantum feature extraction.

This study aims to determine whether classical neural networks can learn from features generated by quantum entanglement and investigate how kernel design affects model accuracy. To test this, we systematically analysed a prior quantum circuit design [21] with structural changes to explore entanglement effects. Our version utilises two CNOT gates to establish qubit correlation, potentially capturing relationships between pixels that classical models may overlook. We introduce spatial symmetry to describe rearrangements of CNOT gates. We observed that such an implementation using two CNOT gates has three possible symmetries for spatial pixel entanglement: diagonal, vertical, and horizontal. Figure 2 demonstrates how the circuit can be arranged to extract the entanglement information from the image’s pixels convolved with the quantum kernel.

As shown in the circuit of Figure 2, each pair of qubits is entangled independently, so the kernel can run on hardware with only two qubits, and each $2\times 2$ image patch can be processed in parallel on multiple, identical qubit pairs—an attractive feature for NISQ-era devices where both qubit count and coherence time are limited.

The double-headed arrows in Figure 2 indicate that every entangling pattern can be executed in both control–target directions. Swapping these roles lets us test whether the CNOT gate itself introduces any asymmetry. We confirm that it does not: a circuit that uses $\mathrm{CNOT}(0,3)$ and $\mathrm{CNOT}(1,2)$—linking pixels 0–3 and 1–2—achieves the same validation accuracy as the circuit with the directions reversed, $\mathrm{CNOT}(3,0)$ and $\mathrm{CNOT}(2,1)$.

• Quantum patch pipeline

Each $N\times N$ grayscale image is partitioned into non-overlapping $2\times 2$ patches P (stride 2). Each pixel of a patch, $\mathbf{x}=(x_1,\dots ,x_4)$, is rescaled to $[0,\pi ]$ and used as a rotation angle. We encode the four values on four wires with angle embedding via $R_y\left({\theta }_i\right)$ gates. A fixed entangling layer—$\mathrm{CNOT}(0\to 1)$ and $\mathrm{CNOT}(2\to 3)$—is then applied to introduce pairwise correlations while keeping the device topology constant. To isolate the effect of which pixels are paired under this topology, we sweep all $4!=24$ pixel-to-wire permutations before passing them to the circuit, varying only the assignment $(x_i\mapsto \mathrm{wire}j)$ and leaving the CNOT pairs unchanged. Finally, we measure $\langle Z_0\rangle ,\dots ,\langle Z_3\rangle$ (per patch) and place the results back into the patch grid, producing four quantum feature maps of size $(N/2)\times (N/2)$ per image. In implementation, the patch tensor has shape $B\times P\times 4$ (batch B; patches P), and the permutation sweep is performed along the last axis. Therefore, the 24 permutations yield 24 distinct QPF-transformed datasets; features from different permutations are not averaged, concatenated, or combined before training.

The grouping into three different symmetries is used only at the results-analysis stage: each permutation is trained independently and no fixed random seed is imposed, and the validation results from the eight permutations belonging to the same symmetry class are pooled when presenting symmetry-level comparisons.

All quantum circuits are simulated with the open-source PennyLane software library (v 0.35.1, Xanadu Inc., Toronto, ON, Canada) [23]. The resulting quantum feature channels (see Figure 3) are fed into a fully connected neural network built in TensorFlow for classification. We train for 60 epochs with a batch size of 128; the model is compiled with the Adam optimiser, sparse-categorical cross-entropy loss, and accuracy as the evaluation metric. Training employs the ReduceLROnPlateau callback with a patience of 15 epochs (learning rate reduced by a factor of 0.1 whenever validation accuracy failed to improve).

We also explore the filter’s performance as the neural network’s depth increases. We conducted our experiments with architectures comprising zero, one, two, and three hidden layers. For results, refer to Section 3.

Table 1. Classical neural network models with incremental depth in hidden layers.

Number of Hidden Layers	Model Architecture
0	Input Layer (Flatten)
	Classification Layer [Dense(None, 10), softmax]
1	Input Layer (Flatten)
	Hidden Layer 1 [Dense(None, 512), relu]
	Classification Layer [Dense(None, 10), softmax]
2	Input Layer (Flatten)
	Hidden Layer 1 [Dense(None, 512), relu]
	Hidden Layer 2 [Dense(None, 256), relu]
	Classification Layer [Dense(None, 10), softmax]
3	Input Layer (Flatten)
	Hidden Layer 1 [Dense(None, 512), relu]
	Hidden Layer 2 [Dense(None, 256), relu]
	Hidden Layer 3 [Dense(None, 128), relu]
	Classification Layer [Dense(None, 10), softmax]

summarises the neural network architecture.

• Evaluation protocol

We partitioned each dataset into train/validation/test. The validation split informed training decisions via three Keras callbacks: (i) EarlyStopping, (ii) ModelCheckpoint, and (iii) ReduceLROnPlateau on validation accuracy. Model selection used the checkpoint with the highest validation accuracy. Final numbers are reported on the held-out test set, evaluated once per model. Figure 4, Figure 5 and Figure 6 and

Table 2. Validation accuracy in % by dataset and number of hidden layers, boldface marks the best-performing configuration across all depths and model types (QPF vs. plain NN). (QPF entries correspond to the best symmetry at that depth.). The best performing symmetries are: Diagonal: MNIST, eMNIST Digits; Vertical: Fashion MNIST; Horizontal: PneumoniaMNIST, OCTMNIST, BreastMNIST.

Dataset	Number of Hidden Layers
	0		1		2		3
	QPF	NN	QPF	NN	QPF	NN	QPF	NN
MNIST	95.53	92.87	98.32	98.37	98.55	98.24	98.42	98.36
Fashion MNIST	85.91	85.62	89.45	90.22	89.50	89.85	89.42	90.13
eMNIST Digits	96.84	94.25	99.12	99.06	99.21	99.15	99.26	99.16
PneumoniaMNIST	97.03	96.28	97.35	97.03	97.56	97.77	97.56	96.82
OCTMNIST	69.04	65.77	83.19	81.70	84.51	82.95	84.79	83.02
BreastMNIST	82.73	73.64	86.36	80.00	84.55	82.73	88.18	80.91

visualise validation behaviour;

Table 3. Held-out test accuracy (%) for the checkpoint selected by best validation accuracy at depth 3; ± denotes a 95% binomial proportion confidence interval computed over $N_{test}$ (Wilson). Best QPF per dataset in bold.

Dataset	Baseline	Diagonal	Vertical	Horizontal
MNIST	98.25 ± 0.26	98.26 ± 0.26	98.33 ± 0.25	98.24 ± 0.26
Fashion MNIST	89.75 ± 0.59	88.15 ± 0.63	88.39 ± 0.63	88.54 ± 0.62
eMNIST Digits	99.19 ± 0.09	99.19 ± 0.09	99.20 ± 0.09	99.16 ± 0.09
PneumoniaMNIST	83.33 ± 2.92	85.90 ± 2.73	85.58 ± 2.76	85.74 ± 2.74
OCTMNIST	58.40 ± 3.05	59.60 ± 3.04	60.40 ± 3.03	61.50 ± 3.02
BreastMNIST	75.64 ± 6.74	78.85 ± 6.41	75.64 ± 6.74	75.64 ± 6.74

reports the corresponding test accuracies.

2.2. Entanglement Quantification

We hypothesised that the degree of entanglement generated by the QPF—i.e., entanglement between pixel values within a 2 × 2 patch that the QPF filters and passes as features—correlates with downstream classification accuracy, helping to explain when QPF-enhanced models outperform or underperform the plain NN. To test this hypothesis, we calculated the state vector of the two-qubit system used in the filter as a function of the input parameter from the embedding layer. After the two single–qubit $R_y\left({\theta }_i\right)\otimes R_y\left({\theta }_j\right)$ rotations and the CNOT $(q_i,q_j)$, the algebraic form of the two-qubit state reads

$$\left|\psi \right({\theta }_i,{\theta }_j)\rangle =A|00\rangle +B|01\rangle +C|10\rangle +D|11\rangle ,$$

where the four amplitudes are

$$\begin{array}{cccc}\hfill A& =cos{\displaystyle \frac{{\theta }_i}{2}}cos{\displaystyle \frac{{\theta }_j}{2}},\hfill & \hfill B& =cos{\displaystyle \frac{{\theta }_i}{2}}sin{\displaystyle \frac{{\theta }_j}{2}},\hfill \\ \hfill C& =sin{\displaystyle \frac{{\theta }_i}{2}}sin{\displaystyle \frac{{\theta }_j}{2}},\hfill & \hfill D& =sin{\displaystyle \frac{{\theta }_i}{2}}cos{\displaystyle \frac{{\theta }_j}{2}},\hfill \end{array}$$

and the angles are set by the normalised pixel values, ${\theta }_k=\pi x_k\in [0,\pi ]$. Because the global state is pure, tracing out either qubit gives a $2\times 2$ reduced density matrix that can then be used to define the level of entanglement of our quantum system by using the von Neumann entropy

$$S\left({\rho }_A\right)=-Tr\left[{\rho }_A{log}_2{\rho }_A\right],$$

with ${\rho }_A={Tr}_B|\psi \rangle \langle \psi |$.

For two qubits, S ranges from 0 (separable) to 1 (maximally entangled); it coincides with the entanglement of formation ($E_f{\left(\right|\psi \rangle }_{AB})=S\left({\rho }_A\right)=S\left({\rho }_B\right)$) in this dimension, so no extra conversion factors are needed.  

In this circuit, the entanglement generated by the CNOT should be distinguished from the classical features obtained after measurement. For a two-qubit block with qubit i as the control and qubit j as the target, the single-qubit Z-expectation values after the CNOT are

$$\langle Z_i\rangle =cos\left({\theta }_i\right),\langle Z_j\rangle =cos\left({\theta }_i\right)cos\left({\theta }_j\right).$$

Thus, the control-qubit readout preserves a single-pixel response, whereas the target-qubit readout contains a nonlinear pairwise interaction between the two encoded pixels. The QPF, therefore, acts as a local nonlinear feature map that mixes individual pixel information with pairwise pixel correlations. Importantly, the amount of entanglement in the state and the usefulness of the measured features are not equivalent quantities: a highly entangled state may not necessarily produce the most discriminative single-qubit measurement outputs for a given classification task.

To demonstrate the full levels of entanglement the QPF can extract, we scanned ${\theta }_i,{\theta }_j\in [0,\pi ]$ in $0.01\pi$ steps and plotted the single-qubit von Neumann entropy $S\left({\rho }_A\right)$ over the resulting grid (Figure 7). The 3-D surface shows two pronounced elongated peaks: they occur when the control qubit is near a balanced superposition $({\theta }_i\approx {\displaystyle \frac{\pi }{2}})$ while the target angle is displaced from ${\displaystyle \frac{\pi }{2}}$. Specifically, the points $({\theta }_i,{\theta }_j)=({\displaystyle \frac{\pi }{2}},0)$ and $({\displaystyle \frac{\pi }{2}},\pi )$ both lie on these peaks and correspond to maximally entangled Bell states, ${\displaystyle \frac{1}{\sqrt{2}}}\left(\right|00\rangle +|11\rangle )$; ${\displaystyle \frac{1}{\sqrt{2}}}\left(\right|01\rangle +|10\rangle )$ [24] that can be reached within this QPF designs.

3. Results and Discussion

We tested the 24 QPF permutations in a few different datasets eMNIST Digits [25], Fashion MNIST [26], MNIST [27], PneumoniaMNIST, OCTMNIST, and BreastMNIST [28].

We present boxplots of validation accuracy for two datasets—eMNIST Digits and Fashion MNIST—across hybrid models with QPFs of three symmetry types (diagonal, vertical, and horizontal). These plots exemplify both scenarios: where the QPF enhances validation performance, and where it leads to a decline when compared with the baseline. For each symmetry, we evaluated these models with four different classical architectures, varying the number of hidden layers from 0 to 3.

As described in Section 2.1, each of the 24 pixel-to-wire permutations was treated as a separate QPF configuration and trained independently. For each dataset and network depth, each configuration was trained independently using a newly initialised neural network. The permutations were then assigned to one of the three spatial symmetry classes: diagonal, vertical, or horizontal, with eight configurations per class. For each dataset and network depth, we collected the validation accuracies from the final 15 training epochs of each independently trained configuration. These values were pooled only for visualising symmetry-level performance. Thus, each QPF boxplot contains $8\times 15$ validation accuracy values, corresponding to eight independently trained permutations and 15 late-stage epochs per permutation. The plain neural-network baseline contains 15 validation accuracy values from its final 15 epochs since it has no permutation variants.

Figure 4 shows our results for the eMNIST Digits dataset. With no hidden layers, every symmetry-enhanced model surpasses the plain baseline; the diagonal filter yields the highest validation accuracy, followed by the horizontal and vertical symmetries. Adding a single hidden layer improves all curves, and the baseline briefly surpasses the horizontal and vertical QPF symmetries, although it still lags behind the diagonal symmetry. A second hidden layer raises all accuracies again, where the diagonal symmetry remains ahead. In contrast, the horizontal and vertical accuracies converge, and the baseline edges pass both but cannot match the diagonal. Introducing a third hidden layer yields only marginal gains; the diagonal symmetry remains dominant, and the baseline plateaus above the horizontal and vertical axes.

We occasionally observe step-like increases in validation accuracy. Many occur around epochs where the learning rate is reduced by ReduceLROnPlateau callback, but similar behaviour can also arise from ordinary training variability (e.g., mini-batch noise and checkpointing). We therefore summarise performance using medians and interquartile ranges and maxima/minima, and treat outliers as descriptive only. Outliers in the boxplots reflect epoch-level variability within the last-15-epoch window and should not be over-interpreted.

The pattern in Figure 5 when using Fashion MNIST is noticeably different. With zero hidden layers, using the best validation accuracy as the ranking criterion (the same criterion used for checkpoint selection), the horizontal symmetry performs best among all models, and the diagonal symmetry offers a slight improvement over the baseline, while the vertical symmetry underperforms both the other QPF variants and the plain network.

Once a hidden layer is introduced, overall accuracy climbs, but the plain network now overtakes every QPF symmetry; within the QPF symmetries, the vertical symmetry is the one which has the most impact, a reversal from the 0-hidden layer scenario, which can be seen as an indication that when combining the QPF with the 0-hidden layer, the NN is not able to learn the difference between the QPF symmetries for this specific dataset. A second hidden layer keeps the vertical filter narrowly ahead of the other symmetries, yet the baseline—despite a small dip—remains the overall leader. Depth beyond two layers yields no substantive gains: performance stabilises, the vertical symmetry continues to top the QPF symmetries, and the baseline model finishes with the highest accuracy.

These two behaviours show that the learning process changes depending on the type of symmetry used to extract features. This suggests that the features are not the same and supports the idea that they offer new information that can be utilised to train neural networks.

Figure 6 shows that across datasets, accuracy rises with depth for both curves, but QPFs are most beneficial in shallow regimes: at 0 hidden layers the QPF variants noticeably lift MNIST and eMNIST Digits—and remain competitive on Fashion MNIST—indicating that the filters act as front-end feature extractors that compensate for limited capacity. As depth increases (≥1/2 layers), the curves flatten and dataset-specific preferences persist (diagonal for handwritten digits; vertical the strongest QPF on Fashion MNIST), while the plain baseline can match or surpass QPFs—most clearly on Fashion MNIST. Taken together, the figure shows that symmetry choice is dataset dependent and its benefit interacts with model capacity: QPFs help most when the classifier is shallow, a property that could be exploited in larger architectures by pairing lightweight QPF blocks with deeper downstream modules.

Table 2 distils the box-plot and trend-line results into a single snapshot of peak validation accuracy for every dataset–depth pair. Three patterns emerge. First, diagonal symmetry dominates the handwriting datasets: it edges out both the baseline and the other two symmetries on MNIST and eMNIST Digits, regardless of depth. Second, Fashion MNIST breaks that rule—vertical symmetry gives the highest QPF accuracy once at least one hidden layer is present, though the plain network still finishes on top. Third, the horizontal kernel is consistently best for the three medical-imaging benchmarks (PneumoniaMNIST, OCTMNIST, and BreastMNIST), and its relative gain grows with network depth. These results reinforce the message that each dataset has a “preferred” spatial symmetry during training.

Overall, we observed that most of the datasets used in this study benefit from improved accuracy when leveraging one of the symmetries of the QPF, with the notable exception of Fashion MNIST. We explore a possible explanation for this anomaly in the following sections.

Table 3 shows the evaluation results of the best model for each dataset/symmetry on the test-set (depth $=3$). On handwritten digits (MNIST and eMNIST Digits), QPF variants are comparable with the baseline: differences are well within the reported uncertainty, indicating no measurable gain. On Fashion MNIST, the baseline is clearly higher than all QPF variants, exceeding the uncertainty bands and suggesting that QPFs do not help at this depth for this dataset. For the medical sets, QPFs tend to improve over baseline: PneumoniaMNIST shows an uplift with diagonal (similar for vertical/horizontal), OCTMNIST peaks with horizontal, and BreastMNIST favours diagonal. Because the medical datasets exhibit wider intervals, these gains are suggestive rather than definitive, but they align with the pattern that QPF symmetries can be beneficial on medical imagery while offering little to no improvement on digit recognition and may even underperform on Fashion MNIST. Overall, the table reinforces the dataset-dependent value of QPFs and the absence of a universally best symmetry. For the digit datasets and Fashion MNIST, validation and test accuracies are closely aligned, indicating that validation performance is representative of test-time behaviour. In contrast, the MedMNIST sets show pronounced drops from validation to test. These gaps suggest reduced generalisation on the medical distributions, possibly due to overfitting or a smaller dataset.

3.1. Datasets’ Entanglement Level

To look for correlations between the performance of the NN models that use the QPFs and the level of entanglement generated by these QPFs, we recorded the entropy of the QPF-encoded states for all images in each dataset, then averaged over the entire dataset. We repeated this for every dataset presented in this study. The resulting value for the best-performing configuration for each symmetry is shown in

Table 4. Average single-qubit von Neumann entropy (bits) for the best-performing configuration of each symmetry. Numbers in parentheses are standard deviations across images. The numbers in bold represent the model with the highest validation accuracy in % during training.

Dataset	Diagonal		Vertical		Horizontal
	Entropy (Std)	Accuracy (%)	Entropy (Std)	Accuracy (%)	Entropy (Std)	Accuracy (%)
MNIST	0.106 (0.032)	98.42	0.107 (0.032)	98.20	0.098 (0.028)	98.18
Fashion MNIST	0.286 (0.102)	89.16	0.286 (0.102)	89.42	0.249 (0.090)	89.34
eMNIST Digits	0.154 (0.043)	99.26	0.154 (0.043)	99.16	0.147 (0.045)	99.17
PneumoniaMNIST	0.444 (0.064)	97.35	0.444 (0.064)	97.45	0.438 (0.062)	97.56
OCTMNIST	0.370 (0.068)	83.95	0.361 (0.070)	83.77	0.370 (0.068)	84.79
BreastMNIST	0.422 (0.070)	87.27	0.422 (0.070)	86.36	0.387 (0.069)	88.18

.

Within-dataset analysis shows no clear link between average entanglement and validation accuracy. The three symmetries often differ by only a small amount in average entropy, yet they can lead to different validation accuracies. This indicates that average von Neumann entropy alone is not sufficient to explain QPF performance. Physically, this is expected because the downstream neural network does not receive the complete quantum state generated by the circuit. It receives only the classical measurement outputs, namely the single-qubit expectation values used as features. Therefore, even if two QPF configurations generate similar levels of entanglement, they may still produce different measured feature maps. The usefulness of those features depends on which pixels are paired and whether the resulting single-pixel and pairwise terms align with the spatial structure of the dataset.

This distinction helps explain why higher entropy does not guarantee improved classification. Entanglement entropy quantifies the nonseparability of the quantum state, but it does not directly measure class separability in the final measured feature space. A symmetry may generate slightly higher average entropy while producing measured features that are less useful for the downstream classifier. Conversely, a lower-entropy configuration may preserve more discriminative local intensity information. Therefore, QPF performance depends not only on the amount of entanglement generated but also on how the induced pixel correlations interact with the dataset structure and the architecture’s classical components.

Future research should investigate whether an optimal “sweet spot” for entanglement may exist that balances performance and how this interacts with factors such as dataset complexity and network capacity. While developing a state-of-the-art quantum neural network model is beyond the scope of this work, gaining a deeper understanding of these quantum filters could pave the way for hybrid models that integrate quantum and classical filtering techniques.

• Entropy–performance analysis

For each dataset and symmetry, we computed the mean single-qubit von Neumann entropy on the corresponding split and plotted, along the horizontal axis, that entropy against the vertical-axis measure $\Delta =\mathrm{signed}{log}_{10}\left(1+|{\mathrm{ACC}}_{\mathrm{QPF}}-{\mathrm{ACC}}_{\mathrm{baseline}}|\right)$, which encodes the signed gap between a QPF model and the plain baseline (positive bars: QPF > baseline; negative bars: QPF < baseline) as shown in Figure 8. The left panel reports validation results; the right panel reports test results. This analysis is not about absolute performance but about the effect of feature extraction: how much a symmetry-conditioned QPF helps or hurts relative to no filtering, and whether that effect covaries with the amount of entanglement injected by the filter.

Across datasets, we do not observe a clear global correlation between entropy and $\Delta$: both high and low entanglement can coincide with small positive or negative accuracy gaps. This supports the interpretation that entanglement is not a direct performance predictor in this readout setting. The measured QPF features contain a mixture of single-pixel responses and pairwise interaction terms, and the relevance of these terms varies by dataset. A weak positive pattern appears only within the MedMNIST group (PneumoniaMNIST, OCTMNIST, BreastMNIST), where higher entropies tend to align with larger positive test deltas. This suggests that, for some medical images, local pairwise correlations may provide useful additional structure for generalisation. However, this trend is not universal. Fashion MNIST remains an important counterexample: despite moderate entropy values, all three symmetries produce negative deltas, indicating that the induced pairwise feature map is less useful than the unfiltered representation for this dataset. Overall, entanglement should be understood as one component of the QPF transformation, not as the sole mechanism determining classification accuracy.

• Target–only readout

We also probed whether entanglement could reduce readout dimensionality by measuring only the target qubits at the circuit output, under the premise that correlations would encode control-qubit information into those targets and make the control readouts redundant. The results show that this is not the case. This can be understood from the structure of the measured features: for each CNOT pair, the control-qubit readout preserves a single-pixel response, while the target-qubit readout contains a pairwise interaction term. Measuring only the targets therefore removes part of the local intensity information that remains useful for classification. Empirically, target-only readout showed no advantage over full readout; accuracies were slightly below or above but very close to the baseline across depths. Thus, in our setting, the target measurements do not reliably preserve all discriminative information carried by the control measurements. The model performs better when all qubits are measured, suggesting that useful QPF representations require both single-pixel and pairwise features. As future work, we will investigate entanglement-aware dimensionality reduction, such as joint measurements, learned projective readouts, or redesigned QPF kernels, to concentrate correlated information into fewer measured features without discarding discriminative signal.

3.2. Synthesis and Implications

This study investigated the impact of QPFs, with designs based on spatial symmetries, on hybrid quantum–classical neural networks across multiple image datasets. Increasing model depth consistently improved validation accuracy across all datasets. However, the efficacy of QPF symmetries proved to be highly dataset-dependent. Diagonal symmetry QPFs consistently performed well on simpler datasets like MNIST and EMNIST Digits, suggesting their effectiveness in capturing key features. For medical imaging datasets (PneumoniaMNIST, OCTMNIST, and BreastMNIST), horizontal symmetry consistently yielded the best performance. In contrast, for the more complex Fashion-MNIST dataset, the classical baseline neural network generally outperformed QPF-enhanced models, though the vertical symmetry QPF (for hidden layers $\ge 1$) demonstrated valuable representational power, isolating specific visual features that other symmetries failed to capture.

Our findings also clarify the role of entanglement in this setting. Entanglement is physically present in the QPF and changes the local feature map, but its average magnitude does not by itself determine classification performance. The downstream classifier receives classical measurement outputs, not the full quantum state. Therefore, the relevant question is whether the measurement-induced features improve class separability for a given dataset. This explains why similar entropy values can lead to different accuracies across symmetries, and why higher entropy does not guarantee improvement over the baseline. The results suggest that QPF design should focus not only on generating entanglement but on designing entangling patterns and readout strategies that preserve task-relevant information while introducing useful nonlinear pixel correlations.

3.3. Limitations and Future Work

Our conclusions should be viewed in light of several limitations. First, the experiments were conducted on simulated noise-free circuits; gate errors on NISQ hardware may reduce performance. Second, the entanglement metric was restricted to pairwise von Neumann entropy, leaving multi-qubit correlations unexplored. Addressing these issues—by benchmarking on real devices and by extending the information-theoretic analysis—will be the focus of future work. A promising direction is to develop a selection framework that automatically matches dataset characteristics to the most effective QPF symmetry (or kernel).

4. Conclusions

We investigated a minimal quantum pre-processing filter (two CNOTs on 2 × 2 patches) as an image feature extractor. We asked whether there is a link—i.e., a systematic correlation—between the entanglement it induces (average single-qubit von Neumann entropy) and downstream classification accuracy in a simple classical head. Using a validation-driven checkpointing protocol with a single evaluation on a held-out test set, we found that QPFs can provide consistent enhancements in shallow regimes, where small networks benefit from the additional feature transformations, but they do not generally surpass strong classical alternatives. Importantly, our hypothesis of a correlation between entanglement and performance is not supported: within this design, entanglement magnitude does not reliably predict accuracy. Thus, while QPFs can be helpful at low depth, the entanglement level alone is not a dependable indicator of when they will help.