Quantum Incremental Learning with Mixed State Prototypes

Quantum Incremental Learning with Mixed State Prototypes

Abstract

Incremental learning models are required to learn new classes sequentially without catastrophic forgetting, while operating under parameter and memory constraints. In the Noisy Intermediate-Scale Quantum (NISQ) era, although quantum neural networks offer advantages in feature mapping, hardware limitations restrict circuit width. Furthermore, traditional quantum classifiers are constrained by the number of orthogonal basis states, limiting their capacity to accommodate a continually growing number of categories. Thus, we introduce a novel quantum incremental learning framework based on trainable mixed-state prototypes. Its original design incorporates new classes by adding class prototypes rather than increasing the circuit width of the shared quantum backbone. The use of mixed-state prototypes is another key contribution, since they have representation capabilities to represent information than a single pure-state prototype. And the decomposable mixed-state calculation provides lower production costs and a convenient Hilbert–Schmidt (HS) distance metric for classification. Simulation results show that our model achieves high-dimensional feature concentration using a minimal number of qubits, while demonstrating lower computational complexity and robust representation in incremental learning tasks compared with classical baselines.

Introduction

Deep learning has achieved remarkable success under the assumption that all training data is available at once. However, real-world data typically arrives in a continuous, ever-changing stream. Iteratively retraining a model from scratch to integrate new classes is computationally exorbitant and inefficient for resource-constrained applications. Consequently, incremental learning has emerged to continuously update models with new knowledge while minimizing storage and computing overhead.

In incremental learning, the fundamental challenge is catastrophic forgetting, where neural networks erase previously learned representations upon adapting to new tasks. Early works introduced memory replay to explicitly rehearse a small buffer of historical exemplars, alongside parameter regularization and knowledge distillation to constrain critical weight updates. As storing raw data is often restricted by memory limits or privacy concerns, research subsequently explored exemplar-free statistical prototype matching, extracting and freezing abstract representations to avoid iterative retraining. More recently, dynamic networks have been proposed to mitigate forgetting by expanding architectural branches. Despite these diverse efforts, classical incremental learning still confronts the bottleneck of computational overhead and residual representational drift, which limits their real-world scalability.

Harnessing quantum mechanics, quantum computing introduces a fundamentally distinct paradigm for information processing, catalyzing the rapid exploration of quantum machine learning. In the NISQ era, hybrid architectures based on variational quantum circuits (VQC) have shown immense promise. By projecting classical data into an exponentially expansive Hilbert space, VQCs facilitate the efficient manipulation of highly non-linear features. Thus, quantum models achieve competitive accuracy with significantly reduced parameters compared to classical networks. Moreover, quantum entanglement captures non-local correlations, providing a physical foundation for enhancing model expressiveness.

Despite these theoretical merits, classical incremental learning strategies cannot be directly quantized, as the structural differences between quantum and classical networks. In classical deep learning, accommodating new classes is often as straightforward as expanding the final linear layer. However, a large class of commonly used quantum classifiers constructs class scores from a fixed set of basis-state probabilities or expectation values. As the label space grows, these classifiers may require an expanded measurement or readout rule, additional observables, or more class-dependent parameters. In basis-state encoding schemes, accommodating additional classes may also require additional qubits. Crucially, unlike modular classical expansion, appending a qubit fundamentally alters the global quantum state and the underlying Hilbert space. This structural shift disrupts previously learned entanglement correlations, exacerbating catastrophic forgetting. Furthermore, blindly increasing the circuit width or depth inevitably triggers the barren plateau phenomenon, rendering the quantum network untrainable.

To circumvent this structural expansion dilemma, quantum metric learning emerges as a promising paradigm. By classifying instances based on state distances rather than relying on explicit parameterized classification heads, it naturally bypasses the need for circuit widening. Its effectiveness heavily depends on exploring advanced quantum information representations. In quantum feature mapping, pure states encode individual inputs into single unit state vectors in the Hilbert space. Consequently, they lack the statistical capacity to represent a diverse distribution compared to mixed states. By formulating information as a convex combination of orthogonal states, mixed states encapsulate data randomness and complex intra-class variance. Compared to classical information representations, this quantum method exponentially broadens the representation dimensionality. Furthermore, it provides physically grounded distance metrics, such as the HS distance, trace distance, and Bures distance. Ultimately, these comprehensive advantages help to solve the problems in incremental learning tasks.

Motivated by the representational power of mixed states and the physical constraints of quantum circuits, this paper proposes a novel quantum incremental learning framework based on mixed-state prototypes. To transcend the capacity bottleneck of traditional quantum classifiers, our design shifts from explicit softmax regression classification to an implicit, distance-based prototype matching mechanism. Moreover, recognizing the difficulty of dynamically altering quantum network, we design a hybrid architecture: we append a lightweight, expandable classical module (i.e., an MLP) to manage the incremental class adjustments without disrupting the underlying quantum states.

The main contributions of this work are summarized as follows:

(1) A quantum prototype framework with an expandable module that avoids the capacity constraint associated with orthogonal basis states.

(2) Mixed-state prototypes via dynamic weighting of pure states avoid redundant qubits and provide PCA-like noise-filtering properties.

(3) Experiments on static and incremental classification tasks demonstrate high-dimensional semantic concentration, exhibiting parameter advantages and noise robustness.

Preliminaries

Incremental learning strategies: Incremental learning requires a model to sequentially learn new classes from a continuous data stream without catastrophically forgetting previously acquired knowledge. Current classical incremental learning frameworks generally rely on three fundamental strategies:

1. Exemplar replay strategy: Replay mechanisms mitigate forgetting by preserving a bounded memory of old data. A prominent example is iCaRL, which utilizes a herding algorithm to select and store a small set of highly representative samples, for each observed class.

2. Regularization techniques: Instead of directly reusing raw data, regularization methods impose mathematical constraints on the network’s optimization trajectory. Parameter-based regularization approaches like EWC evaluate the importance of individual network weights for past tasks and penalize drastic deviations in these critical parameters. Furthermore, knowledge distillation techniques such as LwF mitigate the representational drift of the network.

3. Prototype-based classification: Due to the data imbalance between old and new classes, traditional classifiers suffer from task-recency bias in incremental learning. To address this, prototype-based inference relies on distance metrics within the embedding space. Methods like the nearest-mean-of-exemplars classifier in iCaRL or centroid-based classifiers in FeTrIL and FeCAM represent each class by a global prototype. An input instance is classified by assigning it to the nearest class prototype. This decoupling of feature extraction from explicit classification effectively alleviates the inherent prediction bias and serves as a theoretical cornerstone for our proposed quantum prototype design.

Quantum mixed state compiling: Quantum state compilation aims to learn a parameterized quantum circuit that can prepare a reliable approximation of target state. While early works primarily focused on pure states, compiling mixed states provides a more generalized framework for handling classical probabilities, noise, and complex data distributions in the NISQ era.

1. Density matrix and mixed state representation: In quantum mechanics, a closed quantum system with complete information is described by a pure state, denoted by a state vector ψ⟩ in a Hilbert space. However, in practical open quantum systems, particularly within the NISQ era, a principal system inevitably interacts with its environment and undergoes decoherence. Tracing out the environment produces a reduced mixed state. A mixed state is described with a density matrix ρ. It is a positive-semidefinite Hermitian operator with a unit trace Tr(ρ) = 1. According to the spectral decomposition theorem, any mixed state ρ can be expressed as a probabilistic ensemble of orthogonal pure states.

2. Convex Combination of Pure States ansatz: State-purification ansatzes prepare a larger pure state and trace out ancillary registers, which increases the required circuit width. The convex combination of pure states (CCPS) ansatz avoids this overhead by representing a rank-R mixed state as a probabilistic mixture of transformed basis states. Under HS-distance optimization, a rank-R CCPS state provides a variational low-rank approximation of the target mixed state, yielding a PCA-like procedure that retains its leading components. It controls the prototype rank without introducing ancillary qubits and can suppress low-contribution components. These properties make CCPS suitable for constructing the class prototypes in our framework.

3. Distance measurement via HS distance and SWAP test: The HS distance is used to measure the distance between two quantum states, and also to describe the quantum distance in quantum geometry. Using the Frobenius norm, the squared HS distance is L = ∥ρ − σ∥2F, which can be decomposed into state purities and their quantum overlap. The HS distance can be decomposed into classical probability evaluations and a series of quantum SWAP tests between mixed and pure states. The SWAP test requires one 0⟩ initialized ancillary qubit, utilizing a controlled-swap gate sandwiched between two Hadamard gates. By measuring the ancilla, the probability of observing the state 0⟩, denoted as P(0), is represented as P(0) = 1/2 + 1/2 Tr[ρψi(θ)⟩⟨ψi(θ)]. Thus, the required quantum state overlap can be directly expressed from the measurement statistic as Fi(θ) = 2P(0) − 1. This decomposition is the main reason for using the HS distance in our framework. In dense-matrix simulation, evaluating the HS distance between two d × d states requires O(d2) operations. The trace distance, fidelity, Bures distance, and quantum Jensen–Shannon divergence generally require O(d3) operations because they involve spectral decompositions or matrix square roots. Therefore, the HS distance is more suitable for repeated prototype fitting and comparison.

Mixed-State Based Quantum Prototype Classifier

Overview of the quantum prototype classifier: The core architecture of our proposed framework is a mixed-state quantum prototype classifier. A large class of commonly used quantum classifiers constructs class scores from a fixed set of measured basis-state probabilities or expectation values. Their measurement or readout structures may need to be expanded as the label space grows. Our design instead performs distance-based prototype matching within a shared density-matrix space. Formally, given an input instance x ∈ X, the quantum feature extraction backbone acts as a parameterized mapping function Fq(·; Θbb). It encodes and processes x to output an intermediate quantum mixed state, represented by a density matrix ρ(x) ∈ Cd×d, where d = 24 = 16 for our 4-qubit subsystem. In parallel we construct an independent mixed-state quantum prototype circuit for each category c ∈ Y. This circuit generates a class prototype ρc residing in the identical d × d Hilbert space. The classification prediction ŷ is then determined by identifying the class prototype that yields the minimum HS distance to the query instance. This design decouples representation learning from prototype classification. The backbone learns characteristic information, while the prototype circuit learns the characteristic distribution of specific categories within the same density matrix space.

Quantum feature extraction backbone: The quantum feature extraction backbone serves as a hybrid classical-quantum bridge, mapping high-dimensional classical inputs into compact quantum density matrices. This backbone mainly consists of a classical pre-processing module and a subsequent quantum evolution network. Initially, a classical neural network is employed to extract high-level semantic features from the raw input data. To bridge the dimensional gap between classical feature spaces and the quantum Hilbert space, the extracted features undergo a dimension reduction and normalization process. The resulting compact vector is then embedded into the initial pure state of the quantum system using amplitude encoding, translating classical data into probability amplitudes. The embedded pure quantum state is processed by the quantum backbone, which typically employs a sequence of parameterized unitary operations interleaved with dimensionality reduction mechanisms, such as quantum pooling. The primary objective of these reduction operations is to achieve semantic concentration, extract robust features, and filter out uncorrelated noise. However, operations that discard redundant degrees of freedom, such as partial tracing, inevitably induce information loss regarding the global pure state. That means the retained subsystem is taken into a quantum mixed state. Therefore, the emergence of a mixed-state representation is a physical consequence of performing feature abstraction and denoising within a quantum architecture. The resulting density matrix ρ(x) intrinsically encapsulates the structural uncertainty and hierarchical semantic information of the input, serving as a highly robust, noise-resilient foundational input for the subsequent prototype-based classification.

Mixed quantum prototype preparation circuit: For each class, the model maintains an independent parameterized prototype circuit. The purpose of this circuit is to generate a mixed quantum state in the identical density-matrix space as the backbone’s quantum feature output. Following the CCPS architecture, the prototype for class c is constructed as a probabilistic mixture of transformed basis states. By selecting a subset of k computational basis states i⟩, the prototype density matrix ρc is formulated as a convex mixture of transformed basis states. This convex mixture allows a single class prototype to encapsulate complex intra-class variations, thereby circumventing the representational bottleneck of forcing an entire diverse class into a rigid, singular pure state. To ensure high expressivity, the circuit Uc is constructed using a hierarchical multi-layer structure. Within each layer, generic two-qubit unitary blocks are applied in an alternating entanglement topology. This configuration enables the prototype circuit to span a highly expressive transformation space, maintaining both representation capacity and parameter efficiency. A challenge in optimizing the CCPS ansatz lies in the constraints of the mixture weights wc,i, which must satisfy the constraints of a valid probability simplex (i.e., wc,i ≥ 0 and Σi wc,i = 1). To address this, we introduce softmax parameterization for the mixture weights. We define a set of unconstrained trainable logits sc,i ∈ R for each class, and the valid probabilities can be represented as the softmax function. Both theory and experiments have shown that softmax parameterization has a smoother and more stable optimization process.

Prototype-based classification algorithm: Our prototype-based classifier operates on a decoupled two-stage training paradigm. In the first stage, the quantum feature extraction backbone is optimized via an auxiliary head and subsequently frozen. In the second stage, the mixed-state prototypes are fitted without altering the backbone. During the evaluation phase, predictions are executed through a direct quantum overlap measurement. The classifier determines the label by finding the nearest mixed-state prototype ρc among all currently visible classes. While the objective is to minimize the HS distance Dc(x) = ∥ρ(x) − ρc∥2F. The measurement is reduced to a weighted sum of pure-state overlaps, since the query purity Tr[ρ(x)2] is identical across all classes, and the prototype purity Σi wc,i2 can be pre-computed classically. The overlap term Fc,i(x) = Tr[ρ(x)ψc,i⟩⟨ψc,i] can be efficiently and directly evaluated on quantum hardware using SWAP test. Therefore, the overall matching score for class c is simply the weighted sum of these Swap Test results, using the trained classical probabilities wc,i. To integrate this quantum measurement with classical evaluation metrics, we formulate the classification logit as logitc(x) = Oc(x) − 1/2 Σi wc,i2, which is mathematically equivalent to −1/2 Dc(x) (ignoring the constant query purity). The final prediction selects the class with the maximum logit.

Quantum Incremental Learning Framework

Problem formalization: In incremental learning, the model learns from a continuous stream of data delineated by a sequence of tasks T = T0, T1,..., TT. At the initial task T0, the model is trained on a base dataset D0 comprising an initial set of classes C0. For each subsequent incremental task Tt (t > 0), the model receives a new dataset Dt containing instances from a disjoint set of novel classes Ct. At any given task t, the currently visible class set is the union of all classes encountered so far. Due to strict memory constraints, the model cannot access previous datasets directly. Instead, it is only permitted to maintain a limited memory buffer M containing a small number of exemplars from the old classes. The purpose is to incrementally update the model using only Dt ∪ M, maximizing the classification accuracy over all visible classes without catastrophically forgetting the old ones.

Details of quantum Incremental Learning Framework: The overall architecture is composed of four primary components: a classical pre-processing module, a quantum feature extraction backbone, an auxiliary MLP head for representation learning, and a set of mixed-state prototype networks.

1. Classical pre-processing module: The classical pre-processing module acts as the initial semantic extractor and the dimensional bridge between raw input data and the quantum computational space. Given an input instance x ∈ X from the current incremental task, it is first augmented and normalized to x′. Then the module maps the high-dimensional raw image into a dense semantic feature vector for quantum embedding. Firstly, we employ a ResNet adapted to different input sizes, denoted as fres(·; θres). After that, the network outputs a robust dres-dimensional feature vector, where dres = 512 in our implementation. In order to map the dimension of h to that of the quantum embedding, we append a linear reducer. It compresses the 512-dim representation into dq-dim, where dq = 2n = 256 as we chose the quantum circuit with width n = 8. For quantum embedding, a valid pure quantum state must reside in a Hilbert space with a unit norm. Therefore, the L2-normalized vector a can be represented as a = z/∥z∥2. Through amplitude embedding, this normalized classical vector is mapped onto the probability amplitudes of an n-qubit initial pure state.

2. Quantum feature extraction backbone: The initial pure state ψ(x)⟩ prepared by the classical pre-processing module serves as the direct input to the quantum feature extraction backbone. Defining the initial density matrix as ρin = ψ(x)⟩⟨ψ(x), the backbone adopts a quantum convolutional neural network (QCNN) architecture to distill high-level quantum semantic features. The QCNN adopts the pyramidal structure of classical CNNs to the quantum paradigm. It alternately stacks quantum convolutional and pooling layers. In the quantum convolutional layer, the network emulates the principles of local receptive fields and weight sharing. It applies a parameterized global unitary operator Uc(θc), which is composed of multiple two-qubit unitary blocks acting on adjacent qubit pairs. This operation entangles local qubits to capture complex spatial and feature correlations within the high-dimensional Hilbert space, mapping linearly inseparable classical data into an exponentially expansive quantum feature space. Following the convolution, a quantum pooling layer is applied to compress the feature representation and improve robustness. The pooling operation first applies parameterized controlled rotations Up(θp) between adjacent retained and discarded qubits, gathering information into the retained wires. Subsequently, a subset of qubits, S, is traced out. The retained subsystems are in a mixed state. In our 8-qubit implementation, the pooling layer traces out exactly half of the qubits, reducing the system to 4 wires. Thereafter, a group of quantum convolutional layers, Uc2(θc2), continues to be stacked on this reduced 4-qubit subsystem. The final intermediate feature representation is thus formulated as ρ(x) = Uc2(θc2)ρpool Uc2†(θc2). Consequently, ρ(x) emerges as a 16 × 16 complex-valued density matrix. The partial trace operation in the pooling layer naturally abstracts structural uncertainty and discards redundant noise.

3. Auxiliary MLP head for representation learning: To ensure that the intermediate density matrix ρ(x) is highly discriminative over the currently visible classes, we append an auxiliary classical MLP head during the initial representation learning stage. This design is crucial when the number of visible classes Cvis exceeds the dimension of the measured basis states (i.e., 24 = 16). Specifically, we perform projective measurements on the 4 retained qubits in the computational basis. The resulting 16-dim probability distribution vector p(x) ∈ R16 is extracted by calculating the diagonal elements of the output density matrix. This 16-dimensional probability vector is then mapped to the class logits ŷ(x) ∈ RCvis via a two-layer MLP. To optimize the classical-quantum backbone, we compute the standard cross-entropy loss between the predicted logits ŷ(x) and the ground-truth one-hot label ytrue. This auxiliary MLP head is utilized exclusively to provide supervised gradients for shaping a discriminative quantum density matrix space. Once the optimal feature representation is learned, this classical head is completely discarded during the subsequent mixed-state prototype fitting and decision.

4. Mixed-state prototype and prototype classification: To align with the backbone’s output, the mixed-state prototype preparation circuit is instantiated on a 4-qubit system, intrinsically operating within the identical 16 × 16 density-matrix space. Concretizing the CCPS ansatz, the prototype circuit adopted the hardware efficient tiling. Specifically, we constructed three layers of VQC. And each layer consists of four two-qubit SU(4) blocks arranged in an alternating ring topology. Since each SU(4) block consumes exactly 15 parameters, a single class prototype circuit requires a footprint of 4 × 3 × 15 = 180 trainable parameters. Given the unitary operator Uc(θc), the circuit transforms the first K (K ≤ 16) computational basis states i⟩ into a set of parameterized pure state components. To form a valid mixed state, these pure states are probabilistically mixed using classical weights wc,i. To ensure the adherence to the probability simplex constraint, we map a set of unconstrained trainable weights sc,i ∈ R via the softmax function. The class-specific mixed-state prototype ρc is thus formally assembled as the weighted sum of these orthogonal pure states. During the prototype fitting phase, the objective is to align ρc with the distribution of the training data. For a batch of N training samples xn Nn=1 belonging to class c, the quantum backbone extracts their corresponding intermediate density matrices ρn Nn=1. The overlap between each sample ρn and the prototype’s pure state component ψc,i⟩ can be efficiently estimated on quantum hardware using the SWAP test. By minimizing the mean squared Hilbert-Schmidt distance Σn ∥ρn − ρc∥2F and discarding the constant target purity Tr[ρ2n], the empirical loss function for optimizing the class prototype elegantly simplifies to Lcproto(θc, sc) = Σi wc,i2 − (2/N) Σn Σi wc,i Fc,i(n). By directly optimizing this loss, the 180-parameter circuit and the K weights are jointly updated to make the prototype fit the centroid of the samples. Optimizing this loss can be interpreted as applying the QMSC-based variational quantum PCA procedure to the class-level mean density matrix.

Quantum incremental learning algorithm: The quantum incremental learning algorithm is a multi-stage process. Assuming a continuous data stream divided into sequential tasks t ∈ 0, 1,..., T, let Yt denote the set of all visible classes up to task t. At task t, the model receives a new dataset Dt and has access to a limited replay memory Et−1 containing exemplars from old classes. The incremental learning procedure follows a four-step algorithmic pipeline:

1. Step 1: Backbone representation learning: The training batch is constructed as Dtrain = Dt ∪ Et−1. The classical preprocessing module and the quantum feature extraction backbone are jointly updated. During this phase, the intermediate density matrix ρ(x) is mapped to class logits via the auxiliary MLP head. The entire backbone is optimized by minimizing loss Lrep over all visible classes in Yt.

2. Step 2: Mixed-state prototype fitting: Once the shared representation is learned, the auxiliary MLP head is detached. For each class c ∈ Yt, the parameters (θc, sc) of the class-specific prototype circuit are then independently optimized by minimizing loss Lcproto, guided by the hardware-efficient SWAP test.

3. Step 3: Replay memory management: After prototype fitting, the exemplar set Et is updated. For each class, evaluate the squared HS distance between the sample density matrix ρ(x) and the fitted prototype ρc via SWAP test. Samples yielding the minimum distance are stored in Et. The memory budget is distributed equally across classes.

4. Step 4: Prototype-based global inference: Any query instance xtest is passed through the frozen backbone to extract its density matrix ρ(xtest) in the form of quantum states. The prediction is determined by identifying the nearest mixed-state prototype across all visible classes Yt: ŷ = arg min Dc(xtest). In practical implementation, the negative distance −Dc(xtest) directly serves as the output logit.

Experiments

Experimental Setup: To evaluate the performance of the proposed framework, we conduct experiments on CIFAR-100 and TinyImageNet. For CIFAR-100, we construct three fixed and mutually disjoint 32-class subsets, denoted as Split A, Split B, and Split C, which cover 96 classes in total. TinyImageNet comprises 200 classes. For each CIFAR-100 split and TinyImageNet, we selected 32 categories and divided them into 16 initial classes and 4 groups of 4 categories for incremental tasks. Experiments resulted in five tasks from the 16 to 32 classes. This study utilizes the PyTorch and PennyLane frameworks for hybrid model construction and quantum circuit simulation. All experiments are executed on an x86 platform equipped with a single NVIDIA GeForce RTX 3090 (24GB) GPU. In the statistical significance experiments, we randomly select four seeds and report the results as mean ± standard deviation. For all other experiments, the random seed is fixed to 1993. All experiments used a validation split of 10%. We used ResNet18 preprocessing adapted to the image resolution, followed by a 256-dimensional MLP projection and an 8-qubit quantum backbone. To avoid dataset-specific hyperparameter selection, we fix the prototype rank to K = 7 for every dataset and class split. The initial task was trained for 240 epochs with a batch size of 128 and a learning rate of 0.01. Incremental tasks used prototype-nearest exemplar replay with a fixed memory budget of 640 samples, allocated in a per-class manner (approximately 20 samples per class after all 32 classes are observed). The prototype branch was trained for 60 epochs with a learning rate of 0.04 and a density batch size of 16, while the incremental finetuning stage was trained for 36 epochs with a learning rate of 0.01. We used SGD with momentum 0.9 and weight decay 1e-4 for backbone/classifier training, and Adam for prototype optimization. A warm-up cosine scheduler was used for the initial task, and a cosine scheduler was used for incremental finetuning. Due to the constraints of current quantum resources, the quantum classification backbone is implemented with an 8-qubit circuit, while the mixed-state prototype circuit for each class is instantiated on a 4-qubit system. We use the HS distance between density matrices, rather than constructing an entire 13-qubit circuit, when the SWAP test will also introduce an auxiliary qubit. By disassembling the modules, a significant amount of storage was saved. The 8-qubit quantum classifier exposes an intermediate 4-qubit density matrix on the retained wires after the partial QCNN transformation, and each CCPS prototype is also represented as a 16 × 16 density matrix in the same 4-qubit Hilbert space. We evaluate our method and the baselines using two primary metrics: average accuracy (Avg Acc) and last accuracy (Last Acc). Last Acc measures the final performance of the model after the entire sequence of incremental learning is completed. Avg Acc reflects the historical performance and the robustness of the model against catastrophic forgetting throughout the entire continual learning process.

Effectiveness of the Quantum Prototype Classifier: We evaluate the effectiveness of the mixed-state quantum prototype classifier. We compare our method with four simple classical classifiers and four quantum classifiers. Linear Softmax and Cosine Classifier use parametric classification heads. Nearest Centroid and RBF-SVM are fitted on normalized features extracted by independently trained backbones. The quantum baselines retain the ResNet-18 preprocessing and use 8-qubit amplitude encoding. HEA-VQC applies RY-RZ layers and ring CNOT gates, followed by direct five-qubit probability measurement for 32-class prediction. QCNN uses SU(4) convolution and quantum pooling, followed by the same direct probability measurement. TTN-QNN uses a hierarchical 8-qubit tree circuit and a 16-to-32 classical readout layer. Fidelity Classifier represents each class using a trainable pure-state prototype and performs classification based on state fidelity. Our method instead represents each class using a mixed-state prototype and performs classification based on the HS distance. All methods are evaluated under the same non-incremental setting on the same 32 selected classes. The results are reported as mean ± standard deviation over four runs. Our method achieves mean accuracies of 0.8323, 0.7766, 0.8222, and 0.6997 on the four datasets. It obtains the highest mean accuracy among the compared quantum classifiers on all four datasets. It also achieves the highest accuracy among all compared classifiers on Split A and TinyImageNet. On Split B and Split C, it is 1.63 and 0.23 percentage points lower than the strongest classical classifier, respectively. Its average accuracy over the four datasets is 0.7827, which is the highest among the compared methods. Compared with the direct-measurement QCNN, our method improves the mean accuracy by 15.83, 15.07, 14.41, and 12.88 percentage points, respectively. These results demonstrate that directly relying on the measured output of the quantum backbone is insufficient for robust multi-class classification because the measured probability vector is constrained by the retained quantum basis states. It assigns the same fixed Hilbert space size to each category and therefore cannot effectively handle uneven feature distributions. In contrast, our approach is to adaptively divide the feature space into different ranges for different classes.

Effectiveness on Incremental Learning: This section evaluates the effectiveness of the proposed method under the incremental learning setting. The purpose is not to claim state-of-the-art performance over all classical methods, but to verify whether the proposed quantum method has an effective incremental learning capability. Since the model operates with a limited-width quantum circuit and a fixed memory budget, the key question is whether it can alleviate catastrophic forgetting. We follow the fixed incremental protocol. The model starts from 16 initial classes and then learns four incremental tasks, each containing 4 new classes, resulting in five evaluation stages from 16 to 32 classes. For comparison, we organize the representative baselines into four categories. Replay-based methods include FOSTER, iCaRL, and PODNet; BiC, SSRE, and DER; and LUCIR. Prototype-based methods include FeTrIL, PASS, and NCM, as well as Eucl-NCM and TOPIC+. Statistics-based methods include FeCAM, SDC, and DeeSIL. Regularization-based methods include ABD, MUC-LwF, and LwF-MC, as well as EWC. Finetune is included as a conventional sequential baseline. Our method combines mixed-state prototype classification with exemplar replay and is therefore included in both tables as a common reference. All baseline results were reproduced using their official open-source implementations. The same class subsets and class order were used for all methods. Each baseline used either the same ResNet backbone as ours or the backbone provided by its official implementation. All methods are evaluated by the final accuracy after the last task, denoted as Last Acc, and the average accuracy over all incremental stages, denoted as Avg Acc. With the same fixed rank K = 7 on all datasets, the proposed method achieves 0.5728 Last Acc and 0.7178 Avg Acc on CIFAR-100 Split A. Although it does not outperform the strongest classical baselines, its average accuracy is higher than that of BiC, Eucl-NCM, NCM, MUC-LwF, SSRE, DeeSIL, TOPIC+, SDC, and LUCIR. The corresponding Avg Acc values are 0.6465 and 0.7097 on Split B and Split C, respectively, showing that the method remains sensitive to class selection even under a uniform rank. On TinyImageNet, the same K = 7 configuration obtains 0.3838 Last Acc and 0.5371 Avg Acc. The stage-wise curves further show that the proposed method exhibits a gradual accuracy decline comparable to several prototype and statistics baselines, rather than an abrupt collapse. These results demonstrate meaningful class-incremental learning capability without selecting a separate rank for each benchmark. More importantly, this result is achieved under a compact quantum setting. The quantum backbone only uses 8 qubits, and the prototypes use 4 qubits. The trainable quantum backbone contains only a small number of quantum parameters, while each class prototype uses 180 circuit parameters and K mixture weights. Despite this limited quantum width and fixed memory budget, the model shows a gradual decline in accuracy over the five incremental stages. These results suggest that mixed-state quantum prototypes and prototype-guided replay can mitigate forgetting to a certain extent and provide a feasible direction for quantum incremental learning under NISQ-era resource constraints.

Ablation Studies: We conduct ablation studies on two core designs: the mixed-state prototype representation and the exemplar replay mechanism. The former is used to improve the representation capacity of class prototypes by modeling each class as a density matrix rather than a single pure state. The latter is used to preserve old-class information during incremental updates by replaying a small number of representative exemplars. For the mixed-state prototype ablation, we replace the proposed CCPS mixed-state prototype with a pure-state prototype, denoted as w/o Mixed State. This variant keeps the same incremental learning protocol but represents each class using a single pure state. For the backbone ablation, we freeze the shared backbone and only fit new-class prototypes, denoted as Fixed Backbone. For the replay ablation, we remove the exemplar replay mechanism, denoted as w/o Replay. This variant updates the model using only new-task data. On CIFAR-100 Split A, replacing the fixed-rank (K = 7) mixed-state prototype with a pure-state prototype leads to a clear performance drop. The Last Acc decreases from 0.5728 to 0.5450, and the Avg Acc drops from 0.7178 to 0.6668. This demonstrates that a single pure state is not sufficient to represent complex intra-class variations in the incremental setting. In contrast, the proposed mixed-state prototype uses a convex combination of multiple pure-state components, which provides a more flexible representation for each class. The full model also retains the highest Avg Acc among the compared variants on Split B, Split C, and TinyImageNet. The Fixed Backbone variant obtains only 0.4788 Last Acc and 0.6586 Avg Acc on Split A. The w/o Replay variant improves the result to 0.5122 Last Acc and 0.6735 Avg Acc, but it still performs worse than the fixed-K = 7 full model. This shows that directly updating the model with only new-task data is insufficient for maintaining a stable prototype space. By replaying exemplars nearest to the learned quantum prototypes, the full method provides old-class constraints during incremental training and helps different prototype positions remain appropriately matched.

Effect of Prototype Rank: This section further investigates the PCA-like property of the proposed mixed-state prototype. The CCPS prototype represents each class as a convex combination of multiple transformed basis states. The number of retained basis states K controls the effective rank of the prototype density matrix. Therefore, K plays a role similar to the number of principal components in PCA: a small K may discard useful class information, while an excessively large K may introduce redundant or noisy components. This experiment evaluates whether an appropriate rank selection can improve the robustness of the mixed-state prototype. We conduct a rank sweep by varying K in the CCPS prototype while keeping the other incremental learning settings unchanged. Specifically, we evaluate K from 1 to 16 under the same 16-to-32 class-incremental protocol. When K = 16, the prototype uses all basis states in the 4-qubit Hilbert space, corresponding to a full-rank representation. Smaller values of K force the prototype to retain only a subset of basis components, which can be regarded as a low-rank approximation of the class density distribution. The performance does not monotonically improve as K increases. Although K = 16 provides the largest representational capacity, it does not consistently obtain the best Avg Acc. This suggests that using all basis components may preserve redundant or noisy variations in the class density matrix, which weakens the robustness of the prototype. In contrast, moderate-rank settings generally achieve better performance. The retrospective sweep reaches its best Avg Acc at K = 12, K = 7, and K = 15 on Split A, Split B, and Split C, respectively, while TinyImageNet reaches its best Avg Acc at K = 7. Importantly, these sweep maxima are not used to choose a separate setting for each dataset: all main results in the preceding sections use the same prespecified value, K = 7. The sweep is reported only as a sensitivity analysis. This protocol avoids selecting the rank according to test performance and provides a consistent basis for cross-dataset comparison. When K is too small, the prototype only keeps a few dominant components, which may remove noise but also risks discarding useful intra-class variations. When K is too large, especially at the full-rank setting K = 16, the prototype absorbs more low-contribution components, increasing the fluctuation across incremental tasks and reducing the denoising effect. The middle range of K provides a better trade-off: it preserves the main class structure while suppressing redundant components. These results support the PCA-like interpretation of the mixed-state prototype. By controlling the rank K, the CCPS prototype can filter out low-contribution components that are regarded as noise. Thus, it can focus on the dominant structure of the class distribution. Therefore, the mixed-state prototype is not merely a higher-capacity representation than a pure state, but also provides a controllable low-rank approximation mechanism that improves robustness under incremental learning.

Conclusion

In this paper, we introduced a mixed-state quantum prototype framework for class-incremental learning. Within constrained circuit width, our method matches quantum features with class prototypes to classify. We utilized CCPS ansatz to construct the mixed-state prototypes. It shows higher representational ability than classic single pure state. Furthermore, we designed a prototype-guided replay strategy to achieve incremental learning on quantum hardware. Simulation results indicate that the mixed-state classifier outperforms direct measurement-based quantum classification. And the prototype rank analysis further supported its PCA-like noise-filtering properties. For future work, we will explore more hardware-efficient prototype circuits and investigate noise-aware training methodologies on real quantum devices. Additionally, extending this framework to larger-scale incremental scenarios is a promising direction. Accommodating more diverse datasets will further advance quantum models in continual class learning.

Based on this paper, here are the specific improvements you can make to AI systems:

• Improvement: Replace single-point (pure-state) class prototypes with mixed-state density matrix prototypes that represent each class as a probabilistic convex combination of multiple transformed basis states.

• What the improved system can do: Capture complex intra-class variations and multi-modal distributions that single prototypes miss. The system can model uncertainty and statistical spread within each class, leading to more robust classification, especially when class distributions overlap or have high variance.

• Improvement: Introduce a tunable rank parameter (K) in the prototype representation that controls how many basis components are retained, analogous to principal component analysis.

• What the improved system can do: Automatically filter out low-contribution, noisy components in the feature space while preserving dominant structural patterns. This provides built-in denoising and regularization, improving generalization on noisy or high-dimensional data without explicit noise modeling.

• Improvement: Replace explicit softmax classification heads with a distance-based matching mechanism using the Hilbert-Schmidt distance between density matrices.

• What the improved system can do: Avoid the capacity bottleneck of fixed-size output layers. The system can handle an arbitrarily growing number of classes without modifying the network architecture, making it naturally suited for open-set or incremental scenarios where new categories appear over time.

• Improvement: Train the feature extraction backbone first (with an auxiliary head), then freeze it and independently fit class prototypes without altering the shared representation.

• What the improved system can do: Prevent catastrophic forgetting during incremental learning by ensuring the feature space remains stable. The system can add new classes by only fitting new prototypes, avoiding the need to retrain the entire network, which reduces computational cost and memory overhead.

• Improvement: Select replay exemplars based on their proximity (Hilbert-Schmidt distance) to the learned class prototypes, rather than random or herding-based selection.

• What the improved system can do: Store the most representative samples that best align with the class distribution, maximizing the information retained per memory unit. This improves old-class preservation under tight memory budgets and reduces the risk of biased sampling.

• Improvement: Use a compact quantum backbone for feature extraction and a lightweight, expandable classical module (MLP) for handling class count changes.

• What the improved system can do: Scale to larger label spaces without increasing quantum circuit width, which is critical for NISQ-era hardware constraints. The system achieves high-dimensional feature concentration with minimal qubits, making it practical for resource-limited quantum devices.

• Improvement: Parameterize the convex combination weights of the mixed-state prototype using a softmax function over unconstrained logits.

• What the improved system can do: Ensure valid probability simplex constraints are automatically satisfied during training, leading to smoother and more stable optimization. The system avoids manual constraint handling and converges more reliably.

• Improvement: Decompose the Hilbert-Schmidt distance into pre-computable purities and a series of SWAP tests, avoiding expensive spectral decompositions.

• What the improved system can do: Achieve O(d2) complexity for distance evaluation instead of O(d3), enabling faster training and inference. The system can scale to larger state dimensions and more classes while maintaining computational efficiency.

• Improvement: Accommodate new classes by adding class prototypes rather than expanding the quantum circuit width or output layer.

• What the improved system can do: Avoid the catastrophic forgetting caused by structural changes to the network. The system maintains previously learned entanglement correlations and representations, preserving old knowledge while seamlessly integrating new categories.

• Improvement: Use quantum pooling layers that partially trace out qubits, naturally inducing mixed-state representations that capture structural uncertainty.

• What the improved system can do: Filter out uncorrelated noise and redundant information during feature extraction, producing more robust representations that are less sensitive to input perturbations. The system inherently handles noisy or incomplete data better than pure-state approaches.