WorksPhysics and Astronomy
Enhanced Variational Quantum Kolmogorov-Arnold Network
Abstract
The Kolmogorov-Arnold Network (KAN) places the trainable functions on the synapses rather than on the neurons. Existing quantum implementations either lack accuracy (Variational Quantum KAN, VQKAN) or rely on block encoding and Quantum Signal Processing, which demand many control gates and ancillae. We propose the Enhanced Variational Quantum Kolmogorov-Arnold Network (EVQKAN), a variational ansatz that emulates a -dimensional KAN layer matrix by tiling controlled rotations through a sum-operator construction, using only trainable spline functions per layer. On the fitting of an elementary function, EVQKAN attains a significantly lower test error than Quantum Neural Networks (QNN), VQKAN and Adaptive VQKAN (Mann-Whitney , Cliff's over ten attempts; EVQKAN beats VQKAN on every attempt), though classical KAN is more accurate still. On a two-dimensional classification task the ordering reverses: under a leak-free protocol introduced here, EVQKAN classifies above chance (accuracy , ) but is significantly less accurate than a QNN carrying one fifth as many parameters (accuracy , ; AUC , ). We withdraw the classification results of an earlier version of this work: their encoding placed the target label into the circuit as a feature for EVQKAN but not for the methods it was compared against. The dominant error source is overfitting from an under-determined training set; enlarging that set closes the train-test gap by (Spearman ). We also report the circuit cost in full — three layers emit operations, or two-qubit gates once the multi-controlled gates are decomposed — so the construction is simulator-scale and fault-tolerant-era rather than NISQ-ready, with block encoding and qubitization the route to reducing it.
Introduction
The rapid advancements in artificial intelligence (AI) have been largely driven by neural network models inspired by the structure of the human brain [1]. These models, composed of interconnected artificial neurons or perceptrons [2, 3], have demonstrated remarkable success in a wide range of applications, including image recognition and natural language processing [4]. However, conventional neural networks face significant challenges in terms of scalability and computational efficiency when processing large-scale data, which limits the continued advancement of AI technologies.
To address these issues, alternative network architectures have been explored. One particularly promising approach is the Kolmogorov–Arnold Network (KAN), recently proposed by Tegmark’s group [5].
KAN enhances computational efficiency by directly optimizing the functions of synaptic weights, instead of neuron parameters, using matrix operations for streamlined computation.
Moreover, its architecture can be naturally interpreted and implemented as a quantum circuit, paving the way for integration with quantum computing.
As a result, KAN has attracted growing global interest, with numerous studies exploring its theoretical foundations and practical applications. Despite some critical perspectives [6], a broad range of research has been reported on KAN, including its application to image analysis [7], time-dependent data [8], and physical modeling tasks [9, 10]. KAN has also been applied in domains such as spacecraft control and medical diagnostics [11, 12].
Since its introduction, efforts have been made to implement KAN on quantum computers. Quantum computers, first proposed by Richard P. Feynman [13], exploit quantum superposition and entanglement to solve complex problems exponentially faster than classical computers. The computational power of a quantum system comes from its ability to represent data in a -dimensional Hilbert space, where is the number of qubits. This makes KAN a strong candidate for efficient implementation on quantum hardware, particularly for large multi-layer networks.
Several quantum implementations of KAN have been proposed. Variational Quantum KAN (VQKAN) [14] adapts KAN to a variational quantum framework, using qubit measurements as neuron activations and quantum gates as synaptic functions. Another approach, Quantum KAN [15], leverages Quantum Signal Processing [16] and block encoding techniques [17] to represent KAN layers in quantum circuits.
Additionally, methods like Quantum Architecture Search [18] have been proposed to optimize the quantum circuit structure of KAN. However, current implementations face several limitations. VQKAN suffers from insufficient accuracy for practical use, while Quantum KAN requires a large number of control gates and ancillary qubits, making it unsuitable for today’s noisy intermediate-scale quantum (NISQ) devices. Moreover, the optimization of Quantum KAN becomes increasingly demanding with network size, due to the need to train a number of parameters proportional to the number of elements in each layer matrix.
To address these challenges, we propose a novel quantum extension of KAN called Enhanced VQKAN (EVQKAN), designed within the framework of Variational Quantum Algorithms (VQAs). VQKAN reformulates the KAN structure using parametric quantum gates and feedback loops, emulating the original architecture within a VQE-style scheme. EVQKAN improves upon VQKAN by employing matrix-based layers that mimic KAN behavior, requiring only trainable spline functions for a -dimensional layer. This is the sense in which EVQKAN is parameter-efficient: the number of trainable functions grows as the square root of the layer dimension, whereas Quantum KAN trains a number of parameters proportional to the number of elements of the layer matrix.
We stress at the outset that this parameter economy does not translate into a small circuit. The tiled sum-operator construction is realised with multi-controlled rotations, and for a three-layer EVQKAN emits 1017 operations, of which 684 are Toffoli gates; decomposing each Toffoli into six CNOTs and nine one-qubit gates gives 4110 two-qubit gates and 10593 gates in total. Circuits of this depth are beyond the reach of present-day hardware. EVQKAN is therefore best understood as a simulator-scale and fault-tolerant-era construction, and all results reported below are noiseless state-vector simulations. Reducing the gate count — for which block encoding and qubitization are the natural tools — is the principal obstacle between the present work and hardware deployment, and we return to it in § 5.
Quantum computing algorithms, particularly VQAs, have advanced rapidly in recent years. Foundational work by Aspuru-Guzik and collaborators [19] has led to the development of widely used algorithms such as the Variational Quantum Eigensolver (VQE) [20], Adaptive VQE [21], and Multiscale Contracted VQE (MCVQE) [22], among others [23, 24]. These algorithms are well-suited for NISQ devices and have been successfully applied to quantum machine learning tasks [25, 26, 27, 28, 29, 30, 31, 32, 33].
We evaluate EVQKAN on two tasks. On the fitting of elementary functions EVQKAN attains a significantly lower test error than QNN [34], VQKAN and Adaptive VQKAN, with large effect sizes over ten independent attempts, while classical KAN remains more accurate than every quantum method we tested. On a two-dimensional classification task the ordering reverses and EVQKAN falls significantly behind QNN. We report both outcomes, because the contrast between them is itself the most informative result: the advantage the tiled ansatz confers on function fitting does not transfer, and we have not been able to attribute the failure to the readout, the parameter count or the optimiser budget.
The contribution of this paper is therefore an architecture that makes variational quantum KAN competitive among quantum models on function fitting, a leak-free protocol and a set of standard metrics under which quantum KAN variants can be compared honestly, and a quantitative account of what currently limits the method — overfitting from an under-determined training set, and a circuit cost dominated by multi-controlled gates.
§ 1 is the introduction, § 2 describes the method detail of EVQKAN and the optimization method, § 3 describes the results of the fitting and classification problems, § 5 is the discussion of results, and § 6 is the concluding remark.
Method
In this section, we describe the method and implementation of the Enhanced Variational Quantum Kolmogorov-Arnold Network (EVQKAN). VQKAN is the variational quantum algorithm version of KAN, a multi-layer network based on the connection of synapses in neurons. First, initial state is
for each input . is degrees angle rotation gate for y-axis on qubit . is the input vector at layer for -th input data. We will describe later that the Loss function is calculated similarly to Subspace-search VQE [35], and multiple points are calculated at once. The rotation angles fed into the ansatz are generated by trainable spline functions, as in classical KAN. This is the point at which EVQKAN departs from VQKAN, and it is the source of its parameter economy, so we state it precisely.
Layer carries trainable spline functions , , each defined on and represented by control points ,
where the are the B-spline basis functions and the are initialised to zero. The layer receives readout values , and the angle applied in tile at position is obtained by evaluating the -th spline at the -th readout,
with and the extrema of over , which keep the argument of arccos inside its domain.
Two consequences are worth making explicit, because they are easy to misread. First, the angle carries two indices and a layer therefore consumes angles — sixteen for the , configuration used throughout this paper — but the trainable coefficients carry only the single index . A layer holds free parameters, not . Second, only one element of enters each , in contrast to VQKAN where the angle sums over all elements of the input vector.
For , and three layers this gives trainable parameters in total. We note that an earlier version of this work optimised a 384-component vector for the same model, of which only these 96 components were ever read; the redundant coordinates left the objective exactly invariant while consuming the optimiser’s budget. All results below use the 96-dimensional parameterisation.
is the Fermi-Dirac expectation energy-like value of the distribution. The component of is the expectation value of the given observable for the calculated states of qubits. The layer corresponds to the quantum circuit to make a superposition state called ansatz. EVQKAN uses the tiled matrices by the elements of gate operation matrices made by the sum operator and block encoding technics. We use the method of sum operator for tiling, like,
Then, is the k-qubit controlled y-axis rotation gate with 0 th qubit as target qubit that acts y-axis rotation gate when the control qubits are state for the decimal expression of binary state of qubits and is the number of qubits, respectively.
The entire ansatz is,
We implement the technique for implementation of sum operators by the manners on paper [36]. Then, indicates the measurement of all qubits and deriving the s.
The illustrated circuit of a single layer is as Figure 1. We will demonstrate solving fitting problems of elementary equations using the example of . Sum operators are gained in case the measurement result of ancillary qubits are all zero state. For working qubits, the state of the qubits is destroyed after measurement, and calculations commence from scratch using the measured input vector, omitting gates in case calculations are done on real devices. We save the states for easiness because the demonstrations on the paper are all numerical simulations.
Figure 1. Simplified picture of our ansatz on EVQKAN. White circle indicates that connected operators are acted on the circuit in case the qubits that the circle exists is state and black circle indicates that connected operators are acted on the circuit in case the qubits that the circle exists is state, respectively.
Others are the same as ordinary VQKAN [14].
The result is readout as a form of the Hamiltonian expectation value , and the loss function is calculated as follows,
where is the aimed value of sampled point m and is the loss function (absolute distance) of point m, respectively. Hamiltonian takes the form for the product of the Pauli matrix , consisting of the Pauli matrix . is the number of in Hamiltonian.
The condition of convergence is the default of scipy for all methods. We assume , , , and , respectively.
The spline defined by the control points is sampled on a fixed grid of points before the value at is read off by nearest-neighbour lookup. We hold fixed for the whole optimisation. This is worth stating because an earlier version of this work incremented on every optimiser callback, which changes the objective function between iterations and invalidates the trust-region model that COBYLA builds; the results reported here do not do this, and all arms of every comparison are optimised against the same fixed function.
We use blueqat SDK [37] for numerical simulation of quantum calculations and COBYLA of scipy to optimize parameters unless the use of another optimizer is declared.
All results in this paper are noiseless state-vector simulations, and we assume that the number of shots is infinite. No noise model of any kind is applied. Consequently nothing reported here constrains the behaviour of EVQKAN under decoherence or finite sampling; see the limitations discussed in § 5.
All calculations except where declared are performed in Jupyter notebook with Anaconda 3.9.12 and Intel Core i7-9750H.
Result
In this section, we show the EVQKAN result on fitting the elemental equation. Each layer consumes 16 angles generated from 4 trainable spline functions, giving 96 trainable parameters for the three-layer network, and the number of qubits, including ancillae, is 8. We performed the EVQKAN of the following equation on 10 sampled points and predicted the values of 50 test points after optimization by sampled points.
Throughout, every method is run for ten independent attempts. We report the mean, the sample standard deviation and the 95% confidence interval of the mean, and we test differences with the two-sided Mann-Whitney test, quoting Cliff’s as the effect size. The attempts are independent runs rather than paired seeds, which is why an unpaired test is appropriate. We adopt this convention because the ranges of the methods compared here overlap substantially, so a comparison of means alone cannot distinguish a real separation from run-to-run scatter.
Fitting problem
First, we describe the result of the fitting problem. The target function is defined as:
in all cases is . Here, and which the range is normalized in for the state calculated by n-th layer , with and for all layers and calculations, and the Hamiltonian is . The initial state for the fitting problem packs two input components onto each qubit,
so that with the encoding occupies qubits 0 and 1 only. Qubit 2 is initialised in and carries no input; it participates in the ansatz as a control and is not read out by the Hamiltonian . Note that the product runs to and not to , since the latter would require input components.
In advance, we show the result for QNN, VQKAN, Adaptive VQKAN[38], respectively.
The QNN ansatz consists of three layers, as shown in Figure 2, with a total of 24 parameters initialized randomly. The initial state is .
Figure 2. Ansatz structure of the Quantum Neural Network (QNN) with parameterized rotation gates controlled by trainable parameters . Inputs encode classical data into the quantum circuit, enabling learning through optimization of to minimize the cost function.
Figure 3 (a) shows the convergence of the loss function over the number of trials for 10 attempts, while Figure 4 (blue line) presents the fitting results on the test points of QNN.
Figure 3. Number of trials vs. loss functions for optimization of the fitting problem by (a) QNN, (b) VQKAN, (c) Adaptive VQKAN, and (d) Enhanced VQKAN, respectively.
Figure 4. (Right) Number of test points vs. average and median of loss functions (absolute distances) in log10 scale of test points on ( blue line ) QNN, ( green line ) VQKAN, ( orange line ) Adaptive VQKAN, and ( red line ) Enhanced VQKAN optimization, respectively. The line of QNN, VQKAN, and Adaptive VQKAN, are moved right 0.375, 0.25, and 0.125, respectively.
The loss functions of half of ten attempts reached below 0.5. However, the average sum of the difference between the absolute value of aimed and calculated value of points (absolute distances) is over 25 as also shown in Table 1. According to the values of the loss function, QNN is not good at fitting the equation using the same encoding as EVQKAN and is trapped by overfitting because the average of the absolute distances on each point is nearly 1 even though their minimums are small.
Table 1 Sum of absolute distances over the 50 test points on the fitting problem, for QNN, VQKAN, Adaptive VQKAN, EVQKAN, classical KAN and LSTM, with for all methods, over 10 attempts using COBYLA. Uncertainties are sample standard deviations and brackets give the 95% confidence interval of the mean. Raw per-attempt values for the four quantum methods are provided with the code.
| Method | Mean ± SD | 95% CI | Med. | Min. | Max. |
| QNN | 25.688 | 14.535 | 35.562 | ||
| VQKAN | 22.957 | 19.876 | 24.682 | ||
| AVQKAN | 21.934 | 16.904 | 28.294 | ||
| EVQKAN | 15.119 | 13.121 | 18.640 | ||
| KAN | 13.497 | — | 13.549 | 9.588 | 18.891 |
| LSTM | 18.455 | — | 17.128 | 16.302 | 24.840 |
Table 1.
Figure 3 (b) and (c) shows the convergence of the loss function over the number of trials for 10 attempts, while Figure 4 (green line) and (orange line) presents the fitting results on the test points of VQKAN and Adaptive VQKAN, respectively.
The ansatz of VQKAN is 3 layer canonical ansatz and the initial absatz of Adaptive VQKAN is , respectively. The initial parameters are all zero and the same as EVQKAN, and the number of epochs of Adaptive VQKAN is 15 which the number of trials of optimizer for each epoch is 1000, respectively. Absolute distances are entirely smaller than those of QNN and a little larger than those of EVQKAN even though the loss functions are larger than that of QNN.
Next, we show the result of fitting by EVQKAN on Figure 3 (d) and 3 (red line).
Figure 3 (d) shows the convergence of the loss function over the number of trials for 10 attempts, while Figure 4 (red line) presents the fitting results on the test points. The values loss functions on seven of ten attempts are below 0.5 even though they had not converged yet. The average of the sum of the absolute distances is nearly 15 which is about 10 smaller than that of QNN. The result of fitting on test points shows a little overfitting because the absolute distances on some test points are below 0.01, and some are above 0.1, even though the averages on test points are entirely smaller than those of QNN. The EVQKAN is supposed to be good at predicting learned points in optimization.
Table.Table 1 shows the detail of the sum of absolute distances for QNN, VQKAN, EVQKAN, classical KAN, and Long short term memory (LSTM) with parameters and Adam as an optimizer for 25 trials.
EVQKAN attains a mean of , and Table 2 shows that its advantage over each quantum baseline is statistically significant: against QNN, against VQKAN and against Adaptive VQKAN. The effect sizes are large in every case, and against VQKAN the separation is complete — , meaning every one of the ten EVQKAN attempts produced a smaller error than every one of the ten VQKAN attempts. EVQKAN is also more accurate than LSTM.
Table 2 Significance of the differences in Table 1. Two-sided Mann-Whitney test over the 10 attempts of each method, with Cliff’s as the effect size; negative favours EVQKAN and means every EVQKAN attempt beat every attempt of the comparison method.
| Contrast | mean | Cliff’s | |
| EVQKAN vs. QNN | −10.877 | 0.0013 | −0.860 |
| EVQKAN vs. VQKAN | −7.521 | 0.00018 | −1.000 |
| EVQKAN vs. AVQKAN | −7.293 | 0.00025 | −0.980 |
Table 2.
The comparison with QNN deserves a remark on variance rather than on means alone. QNN has by far the widest spread of the four (SD = against for EVQKAN ), with three of ten attempts exceeding 30 and a best attempt of 14.535 that is competitive with EVQKAN’s mean. EVQKAN is thus not only more accurate on average but markedly more reliable from run to run, which matters in a setting where one cannot afford many restarts.
Classical KAN, at 13.497, remains more accurate than EVQKAN. We state this plainly: on this task the quantum model does not match the classical model it emulates, and the result reported here is a separation among quantum methods.
The fitting task was optimised on only sampled points against 96 trainable parameters. § 5 takes up the question of whether this is what limits the accuracy.
Classification problem
We next apply EVQKAN to a two-dimensional classification task. A point carries the label if it lies above the curve and if it lies below, where
and the are random coefficients in drawn once per seed. For every sampled the generator emits one point above the curve and one below, so the labels are exactly balanced by construction.
Protocol
The results in this subsection supersede those of an earlier version of this work [39], which are withdrawn; § 5 explains why. Two changes to the protocol matter.
First, every method is now run through a single shared harness. Previously each method had its own driver, and the drivers did not agree on which columns of the sample array were features: the EVQKAN driver encoded all three columns, so the target label reached the circuit as an input, while the VQKAN driver excluded it. Here all arms share the same three-qubit working register, the same encoding of the two features and only the two features, the same observable , the same loss with the same weighting , the same data and the same optimiser. Only the ansatz differs.
Second, we report standard classification metrics — accuracy, and the area under the ROC curve — alongside the summed distance used previously. On balanced labels that distance has fixed reference points: 0 for a perfect predictor, 50 for the constant predictor and 100 for a perfectly wrong one. It is not, however, a measure of classification quality, because it rewards confident output as much as correct output. Table 3 contains a direct demonstration: logistic regression classifies more accurately than every quantum method (0.790) yet scores a worse summed distance (43.84) than VQKAN (40.08), simply because its predicted probabilities sit near 0.5. We therefore treat accuracy and AUC as the primary metrics.
Table 3. Leak-free classification comparison. Every arm uses the same encoding, observable, loss, data and optimiser; only the ansatz differs. Ten seeds per arm, 10 training points, 50 held-out test points, uncertainties are sample standard deviations. LogReg and MLP are classical references trained on the same features and split. The summed distance column is retained for comparability with earlier work; see the text for why it should not be read as a measure of classification quality.
| Method | Par. | Iter. | Accuracy | AUC | ||
| QNN | 18 | 400 | 0.754 ± 0.07 | 0.737 ± 0.07 | 0.893 ± 0.03 | 33.45 ± 3.43 |
| EVQKAN | 96 | 768 | 0.620 ± 0.07 | 0.503 ± 0.11 | 0.641 ± 0.11 | 42.89 ± 4.15 |
| EVQKAN-ZY | 96 | 768 | 0.596 ± 0.05 | 0.454 ± 0.14 | 0.674 ± 0.06 | 43.99 ± 2.91 |
| VQKAN | 216 | 1728 | 0.658 ± 0.05 | 0.710 ± 0.04 | 0.735 ± 0.09 | 40.08 ± 3.36 |
| LogReg | — | — | 0.790 ± 0.05 | 0.777 ± 0.05 | 0.866 ± 0.05 | 43.84 ± 1.01 |
| MLP | — | — | 0.802 ± 0.08 | 0.805 ± 0.07 | 0.886 ± 0.06 | 20.75 ± 7.80 |
| chance | — | — | 0.500 | — | 0.500 | 50.00 |
Because COBYLA requires evaluations merely to construct its initial simplex, a fixed iteration budget would penalise whichever ansatz carries more parameters. We allocate iterations per arm, so QNN receives 400, EVQKAN 768 and VQKAN 1728. Ten independent seeds are run per arm, each trained on 10 points and evaluated on 50 held-out points.
Results
Table 3 gives the outcome and Table 4 the pairwise tests.
Table 4. Pairwise comparison of the arms in Table 3, two-sided Mann-Whitney over the ten seeds. Negative differences favour the first-named method.
| Contrast | acc. | (acc.) | AUC | (AUC) |
| EVQKAN vs. QNN | −0.134 | 0.0014 | −0.252 | 0.0002 |
| EVQKAN vs. VQKAN | −0.038 | 0.3042 | −0.093 | 0.1211 |
| EVQKAN vs. EVQKAN-ZY | +0.024 | 0.3605 | −0.032 | 0.7913 |
| QNN vs. VQKAN | +0.096 | 0.0062 | +0.159 | 0.0011 |
All three quantum methods classify above chance: EVQKAN reaches an accuracy of 0.620 against a chance level of 0.5 (one-sample -test, ). The ordering among them, however, runs against EVQKAN. QNN attains 0.754 accuracy and 0.893 AUC, and the gap to EVQKAN is significant on both metrics ( and ). EVQKAN and VQKAN are statistically indistinguishable ( and ). QNN achieves this with 18 trainable parameters against EVQKAN’s 96 and VQKAN’s 216.
We tested the most obvious explanation for the discrepancy with the fitting task and it did not hold. The classification variant of the ansatz feeds its four splines from the readout vector , which contains only two distinct values, whereas the fitting variant uses and contains four. Restoring the four-valued readout (row EVQKAN-ZY) changes nothing: accuracy 0.596 against 0.620, , and AUC 0.674 against 0.641, . The degenerate readout is not the cause.
Both classical references outperform every quantum method on accuracy, by roughly 15 percentage points over EVQKAN.
The honest summary is that the advantage the tiled ansatz confers on function fitting does not transfer to this classification task. We have not identified the mechanism, and we regard this as the most important open question raised by the present work: an architecture whose benefit is confined to one task family is of limited interest, and establishing whether the boundary is intrinsic or an artefact of the encoding would materially change how EVQKAN should be understood.
Discussion
In this section, we discuss the key findings in this work, focusing on the accuracy and time required to calculate EVQKAN for the fitting problem, and on what the classification result implies. Firstly, we discuss the accuracy and time of fitting problems, including the reason and the way to improve them. Figure 5 (Left) shows the average of the sum of absolute distances of 50 test points; those are the result of prediction after optimization of EVQKAN on the fitting problem for the number of layers, while (Right) shows the calculation time. The average is a little smaller than that of QNN when the number of layers is 1 and declines drastically as the number of layers increases. The average may be nearly zero when the number of layers is above 6. However, the calculation time increases nearly exponentially before saturating. The reason is the gate cost of the sum-operator construction, which we now quantify exactly, since this is the principal practical limitation of the method.
Figure 5. (Left) Number of layers vs. sum of absolute distances using EVQKAN on fitting problem with and COBYLA.(Right) Number of layers vs. elapsed time.
Counting the operations the ansatz emits for , a single EVQKAN layer contains 339 operations, of which 228 are Toffoli gates, together with 74 , 33 , 2 and 2 controlled- gates. Three stacked layers — the configuration of Table 1 — emit 1017 operations including 684 Toffoli gates, on 8 qubits including ancillae. Decomposing each Toffoli into six CNOTs and nine one-qubit gates, the three-layer circuit requires 4110 two-qubit gates and 10593 gates in total. The multi-controlled Toffoli helper alone accounts for 7 Toffoli gates per invocation and is called eight times per tile.
This is a large circuit by any current standard, and it must be weighed against the parameter economy that motivates the construction. EVQKAN trains parameters per layer, which for the present configuration is 32 per layer and 96 in total; Quantum KAN instead trains a number of parameters proportional to the number of elements of the layer matrix. The saving is therefore in the classical optimisation problem, not in the quantum circuit. A circuit of 4110 two-qubit gates cannot be executed coherently on present-day hardware, and we make no claim that EVQKAN as constructed here is deployable on NISQ devices. Peephole optimisation of the emitted circuit — cancelling the adjacent Toffoli pairs inside each tile and folding the X-conjugation patterns — would reduce these figures by a modest factor, but not by the order of magnitude that hardware execution would require.
Reducing this cost is the central open problem for the method. Block encoding and qubitization simplify the circuit for computing matrix functions on quantum computers and are the natural tools; tensor product decomposition [40] may also accelerate the calculation and reduce the qubit count. Establishing how the gate count of EVQKAN scales with , which we have not done here, is a prerequisite for judging whether the parameter economy survives at larger layer dimensions. Our ansatz includes one input vector element per row. Hence, the state vectors of EVQKAN include only one input vector element per element. The transposed ansatz includes all their elements; hence, the accuracy of EVQKAN can improve. Figure 6 (Left) shows the convergence of the loss function over the number of trials for 10 attempts in case the ansatz is transposed and the number of layers is only 1, while Figure 6 (Right) presents the fitting results on the test points.
Figure 6. (Left) Number of trials vs. loss functions for optimization attempts on the fitting problem by EVQKAN in case the ansatz is transposed and the number of layers is 1. (Right) Number of test points vs. average and median of loss functions (absolute distances) in log10 scale of test points on EVQKAN optimization.
Though the loss functions are larger than that of ordinary ansatz, the absolute distances of test points have smaller values entirely than those of ordinary ansatz, even if the number of layers is only 1.
Furthermore, the average of the sum of the absolute distances on fitting of is smaller than that in case the ansatz is ordinary and the number of layers is 1, and QNN in case the number of layers is 3 as shown in Tables.Table 1, Table 5 and Figure 5 (Left). In addition, they are as small as those of VQKAN and Adaptive VQKAN.
| Ave. | Med. | Min. | Max. | ||
| Eq. 9 | EVQKAN | 15.088392 | 15.118825 | 13.120516 | 18.640238 |
| QNN | 25.965271 | 25.688473 | 14.535198 | 35.561974 | |
| EVQKAN | 29.217728 | 28.199258 | 25.958048 | 34.785128 | |
| QNN | 26.846101 | 25.881893 | 17.682263 | 40.463479 | |
| EVQKAN | 1.957241 | 2.005758 | 1.255589 | 2.670427 | |
| QNN | 11.266087 | 11.300752 | 8.653199 | 14.404135 | |
| EVQKAN | 27.452014 | 27.740392 | 24.718224 | 29.842958 | |
| QNN | 20.399586 | 20.862449 | 12.623779 | 24.732792 | |
| EVQKAN | 12.407651 | 12.595418 | 10.90763 | 14.011901 | |
| QNN | 18.851256 | 18.31309 | 14.915787 | 28.090903 |
Table 5. Averages, medians, minimums, and maximums of the sum of absolute distances of EVQKAN which the number of layers is 1 and ansatz is transposed and QNN which the number of layers is 3 for eq. 9, exponential function, logarithmic function, fractional function and radius from zero point for 10 attempts using COBYLA. The range of is the same as that of eq. 9.
EVQKAN of transposed ansatz has more prediction accuracy than QNN on fitting of logarithmic and radius of sphere which the center is zero point. However, it has low prediction accuracy than QNN on exponential and fractional function. It is supposed to be because normalized exponential function is almost flat due to too large maximum and the number of layer is too small to optimize accurately.
What limits the accuracy: an under-determined training set
The experiment in § 3 was optimised on sampled points against 96 trainable parameters, that is 9.6 parameters per sample. The overfitting we observed is what one would expect from a model fitted in that regime, and the question is whether it is a property of the ansatz or of the experimental protocol. To settle this we swept the training-set size over , scoring each run on a test set of 50 points held fixed within each seed so that the numbers are comparable across , with four independent seeds per value and all other settings unchanged.
Table 6 shows the outcome. The generalisation gap — the difference between test and training mean absolute error — falls monotonically from 0.243 at to 0.101 at , a reduction of 58%, and the trend against is strong (, over the 16 runs). The overfitting is therefore driven by the size of the training set and not by the ansatz.
| par./sample | train MAE | test MAE | gap | test sum | |
| 10 | 9.6 | 0.092 ± 0.042 | 0.335 ± 0.019 | 0.243 | 16.745 |
| 25 | 3.8 | 0.161 ± 0.031 | 0.328 ± 0.011 | 0.168 | 16.415 |
| 50 | 1.9 | 0.183 ± 0.033 | 0.328 ± 0.017 | 0.145 | 16.380 |
| 100 | 1.0 | 0.204 ± 0.020 | 0.305 ± 0.016 | 0.101 | 15.261 |
| KAN | — | — | 0.270 | — | 13.497 |
Table 6. Training-set size sweep for EVQKAN with , and 96 trainable parameters, over four seeds per row, scored on 50 held-out test points. MAE is the mean absolute error per test point and the gap is the difference between test and training MAE. The last column rescales the test MAE to the sum over 50 points used in Table 1.
The consequence for test accuracy is more modest, and we are careful not to overstate it. The test mean absolute error falls from 0.335 to 0.305, an improvement of 9%, improving in three of the four seeds; the trend is marginal (, , with a regression slope of per doubling of at ). Even at , where the model has one training sample per parameter, EVQKAN remains 13% less accurate than classical KAN. One caveat applies: the optimiser budget was held fixed at 400 COBYLA iterations across all , and the training error rises with (from 0.092 to 0.204), which is consistent with the larger runs not having converged. The sweep may therefore understate the benefit of additional data.
The practical reading is that enlarging the training set is a real but bounded lever. It reliably closes the train-test gap, and it should be the first thing changed in any future EVQKAN experiment, but on this task it does not by itself bring the quantum model level with its classical counterpart.
Limitations
Three limitations bound the scope of these results and we state them together rather than leaving them implicit.
All calculations are noiseless state-vector simulations with an infinite number of shots. We have not simulated depolarising or dephasing noise, nor finite sampling, and we therefore make no claim about the behaviour of EVQKAN under either. Combined with the gate counts reported above, this means the present work says nothing about NISQ-era performance.
All experiments use , a single target function per task, and 10 training points. How the accuracy and the gate count of EVQKAN scale with is untested, and it is the scaling rather than the point that would determine whether the construction is useful.
We do not know why the tiled ansatz helps on fitting and hurts on classification. We ruled out the degenerate readout of the classification variant by restoring the four-valued readout, which changed nothing ( on accuracy). The parameter count and the optimiser budget both favour EVQKAN over the QNN that beats it, so neither explains the gap either. Until this is understood, the fitting result should be read as task-specific rather than as a general property of the architecture.
Classical methods outperform every quantum method considered here: classical KAN on the fitting task, and both logistic regression and a small MLP on the classification task. The separation we establish is among quantum models. Demonstrating a regime in which a quantum KAN is preferable to a classical one remains open, and nothing in this paper bears on it.
Finally, a note on scope. An earlier version of this work [39] also reported a two-dimensional classification experiment. We have since found that the input encoding used in those runs read the number of columns of the sample array directly, and that the classification sample array carries the target label as its third column alongside the two features. The label was therefore encoded into the third qubit as an input feature while also serving as the regression target of the loss. Because the third qubit acts as a control in the tiled rotations, it influences the measured observable: flipping only the encoded label, with the features and parameters held fixed, changes the prediction by 0.37 on average on a scale. Retraining with the label removed from the encoding lowers the test AUC from 0.79 to 0.64 ( over six seeds). The defect is also asymmetric: the VQKAN and Adaptive VQKAN runs against which EVQKAN was compared excluded the label column correctly, so the comparison did not treat the methods alike. We therefore withdraw those classification results in full and replace them with the leak-free re-run of § 3, in which every arm shares one harness and is scored with standard metrics. That re-run reverses the earlier conclusion: EVQKAN is significantly less accurate than QNN rather than comparable to it. The diagnostic scripts that establish all of the above, and the re-run itself, are included in the code release.
Concluding Remarks
In this paper we introduced EVQKAN, a variational ansatz that emulates a -dimensional KAN layer by tiling controlled rotations through a sum-operator construction, and that requires only trainable spline functions per layer.
On the fitting task EVQKAN is significantly more accurate than QNN, VQKAN and Adaptive VQKAN, with in every comparison and effect sizes ranging from large to complete separation over ten independent attempts; it is also markedly more reproducible from run to run than QNN, whose standard deviation is four times larger. On the classification task, re-run under a leak-free protocol that supersedes our earlier report, the ordering reverses: EVQKAN classifies above chance but falls significantly behind QNN on both accuracy and AUC. Classical methods are more accurate than every quantum method we tested on both tasks.
We identified two concrete limits on the method. The accuracy is bounded by overfitting arising from an under-determined training set: enlarging the training set closes the train-test gap by 58%, though the resulting gain in test accuracy is a more modest 9%. The circuit cost is dominated by multi-controlled gates, with three layers requiring 4110 two-qubit gates after decomposition, which places the present construction outside the reach of NISQ hardware.
The next objective is therefore to simplify the circuit, including reducing the number of qubits, by block encoding and qubitization, and to establish how the gate count scales with . Benchmarking accuracy and resilience under simulated noise and finite sampling, which we have not attempted here, is equally important before any claim about hardware performance can be made.
Data and code availability
The implementation of EVQKAN, the scripts that reproduce every table and figure in this paper, and the per-attempt raw values underlying Table 1, Table 2, Table 3, Table 4 and Table 6 are openly available at https://github.com/ [ repository URL to be inserted on acceptance ] and archived with a DOI at Zenodo. The gate counts quoted in § 5 are produced by the script resource_count.py in that repository, the statistical tests by published_stats.py, the label-encoding diagnostics by leakage_test.py, and the leak-free classification comparison by classification_rerun.py, so that every number reported here can be regenerated from the code.
Author Declarations
Conflict of Interest
The authors have no conflicts to disclose.
Author Contributions
Hikaru Wakaura : Conceptualization (lead); Data curation (lead); Formal analysis (lead); Investigation (lead); Methodology (lead); Project administration (equal); Visualization (equal); Writing – original draft (lead); Writing – review&editing (equal). Rahmat Mulyawan : Visualization (equal); Writing – review&editing (equal). Andriyan B. Suksmono : Project administration (equal); Writing – review&editing (equal).
References
- [1]Yu, Y., Si, X., Hu, C., Zhang, J.: A Review of Recurrent Neural Networks: LSTM Cells and Network Architectures. Neural Computation 31(7), 1235–1270 (2019) https://doi.org/10.1162/neco_a_01199 https://direct.mit.edu/neco/article-pdf/31/7/1235/1053200/neco_a_01199.pdf
- [2]Masood, A., Naseem, U., Rashid, J., Kim, J., Razzak, I.: Review on enhancing clinical decision support system using machine learning. CAAI Transactions on Intelligence Technology n/a(n/a) (2024) https://doi.org/10.1049/cit2.12286 https://ietresearch.onlinelibrary.wiley.com/doi/pdf/10.1049/cit2.12286
- [3]Xing, Y., Zhu, J.: Deep learning-based action recognition with 3d skeleton: A survey. CAAI Transactions on Intelligence Technology 6(1), 80–92 (2021) https://doi.org/10.1049/cit2.12014 https://ietresearch.onlinelibrary.wiley.com/doi/pdf/10.1049/cit2.12014
- [4]Ghosh, A., Chakraborty, D., Law, A.: Artificial intelligence in internet of things. CAAI Transactions on Intelligence Technology 3(4), 208–218 (2018) https://doi.org/10.1049/trit.2018.1008 https://ietresearch.onlinelibrary.wiley.com/doi/pdf/10.1049/trit.2018.1008
- [5]Liu, Z., Wang, Y., Vaidya, S., Ruehle, F., Halverson, J., Soljačić, M., Hou, T.Y., Tegmark, M.: KAN: Kolmogorov-Arnold Networks. arXiv e-prints, 2404–19756 (2024) https://doi.org/10.48550/arXiv.2404.19756 arXiv:2404.19756 [cs.LG]
- [6]Cang, Y., Iiu, Y.h., Shi, L.: Can KAN Work? Exploring the Potential of Kolmogorov-Arnold Networks in Computer Vision. arXiv e-prints, 2411–06727 (2024) https://doi.org/10.48550/arXiv.2411.06727 arXiv:2411.06727 [cs.CV]
- [7]Han, D., Li, Y., Denzler, J.: KAN See Your Face. arXiv e-prints, 2411–18165 (2024) https://doi.org/10.48550/arXiv.2411.18165 arXiv:2411.18165 [cs.CV]
- [8]Kim, T., Girard, A., Kolmanovsky, I.: CIKAN: Constraint Informed Kolmogorov-Arnold Networks for Autonomous Spacecraft Rendezvous using Time Shift Governor. arXiv e-prints, 2412–03710 (2024) https://doi.org/10.48550/arXiv.2412.03710 arXiv:2412.03710 [eess.SY]
- [9]Bandyopadhyay, Y., Avlani, H., Zhuang, H.L.: Kolmogorov-Arnold Neural Networks for High-Entropy Alloys Design. arXiv e-prints, 2410–08452 (2024) https://doi.org/10.48550/arXiv.2410.08452 arXiv:2410.08452 [cond-mat.mtrl-sci]
- [10]Kou, W., Chen, X.: Machine Learning Insights into Quark-Antiquark Interactions: Probing Field Distributions and String Tension in QCD. arXiv e-prints, 2411–14902 (2024) https://doi.org/10.48550/arXiv.2411.14902 arXiv:2411.14902 [hep-ph]
- [11]Jahin, M.A., Akmol Masud, M., Mridha, M.F., Aung, Z., Dey, N.: KACQ-DCNN: Uncertainty-Aware Interpretable Kolmogorov-Arnold Classical-Quantum Dual-Channel Neural Network for Heart Disease Detection. arXiv e-prints, 2410–07446 (2024) https://doi.org/10.48550/arXiv.2410.07446 arXiv:2410.07446 [cs.LG]
- [12]Tang, T., Chen, Y., Shu, H.: 3D U-KAN Implementation for Multi-modal MRI Brain Tumor Segmentation. arXiv e-prints, 2408–00273 (2024) https://doi.org/10.48550/arXiv.2408.00273 arXiv:2408.00273 [eess.IV]
- [13]Feynman, R.P.: Simulating physics with computers. International Journal of Theoretical Physics 21(6), 467–488 (1982) https://doi.org/10.1007/BF02650179
- [14]Wakaura, H., Bayu Suksmono, A., Mulyawan, R.: Variational quantum kolmogorov-arnold network. Research Square (2024) https://doi.org/10.21203/rs.3.rs-4504342/v3 . PREPRINT (Version 3)
- [15]Ivashkov, P., Huang, P.-W., Koor, K., Pira, L., Rebentrost, P.: QKAN: Quantum Kolmogorov-Arnold Networks. arXiv e-prints, 2410–04435 (2024) https://doi.org/10.48550/arXiv.2410.04435 arXiv:2410.04435 [quant-ph]
- [16]Motlagh, D., Wiebe, N.: Generalized Quantum Signal Processing. PRX Quantum 5(2), 020368 (2024) https://doi.org/10.1103/PRXQuantum.5.020368 arXiv:2308.01501 [quant-ph]
- [17]Sünderhauf, C., Campbell, E., Camps, J.: Block-encoding structured matrices for data input in quantum computing. Quantum 8, 1226 (2024) https://doi.org/10.22331/q-2024-01-11-1226
- [18]Kundu, A., Sarkar, A., Sadhu, A.: KANQAS: Kolmogorov-Arnold Network for Quantum Architecture Search. EPJ Quantum Technology 11(1), 76 (2024) https://doi.org/10.1140/epjqt/s40507-024-00289-z arXiv:2406.17630 [quant-ph]
- [19]Kassal, I., Whitfield, J.D., Perdomo-Ortiz, A., Yung, M.-H., Aspuru-Guzik, A.: Simulating chemistry using quantum computers. Annual Review of Physical Chemistry 62(1), 185–207 (2011) https://doi.org/10.1146/annurev-physchem-032210-103512 https://doi.org/10.1146/annurev-physchem-032210-103512
- [20]McClean, J.R., Romero, J., Babbush, R., Aspuru-Guzik, A.: The theory of variational hybrid quantum-classical algorithms. New Journal of Physics 18(2), 023023 (2016) https://doi.org/10.1088/1367-2630/18/2/023023
- [21]Grimsley, H.R., Economou, S.E., Barnes, E., Mayhall, N.J.: An adaptive variational algorithm for exact molecular simulations on a quantum computer. Nature Communications 10, 3007 (2019) https://doi.org/10.1038/s41467-019-10988-2 arXiv:1812.11173 [quant-ph]
- [22]Parrish, R.M., Hohenstein, E.G., McMahon, P.L., Martinez, T.J.: Hybrid Quantum/Classical Derivative Theory: Analytical Gradients and Excited-State Dynamics for the Multistate Contracted Variational Quantum Eigensolver. arXiv e-prints, 1906–08728 (2019) arXiv:1906.08728 [quant-ph]arxiv.org/abs/1906.08728
- [23]Wakaura, H., Bayu Suksmono, A.: Tangent Vector Variational Quantum Eigensolver: A Robust Variational Quantum Eigensolver against the inaccuracy of derivative. arXiv e-prints, 2105–01141 (2021) https://doi.org/10.48550/arXiv.2105.01141 arXiv:2105.01141 [quant-ph]
- [24]Wakaura, H., Tomono, T.: Genetic-Multi-initial Generalized VQE: Advanced VQE method using Genetic Algorithms then Local Search. arXiv e-prints, 2109–02009 (2021) https://doi.org/10.48550/arXiv.2109.02009 arXiv:2109.02009 [quant-ph]
- [25]Rebentrost, P., Mohseni, M., Lloyd, S.: Quantum Support Vector Machine for Big Data Classification. Phys. Rev. Lett. 113(13), 130503 (2014) https://doi.org/10.1103/PhysRevLett.113.130503 arXiv:1307.0471 [quant-ph]
- [26]Khoshaman, A., Vinci, W., Denis, B., Andriyash, E., Sadeghi, H., Amin, M.H.: Quantum variational autoencoder. Quantum Science and Technology 4(1), 014001 (2019) https://doi.org/10.1088/2058-9565/aadalf arXiv:1802.05779 [quant-ph]
- [27]Havlíček, V., Córcoles, A.D., Temme, K., Harrow, A.W., Kandala, A., Chow, J.M., Gambetta, J.M.: Supervised learning with quantum-enhanced feature spaces. Nature 567(7747), 209–212 (2019) https://doi.org/10.1038/s41586-019-0980-2 arXiv:1804.11326 [quant-ph]
- [28]Abel, S., Criado, J.C., Spannowsky, M.: Completely quantum neural networks. Phys. Rev. A 106(2), 022601 (2022) https://doi.org/10.1103/PhysRevA.106.022601 arXiv:2202.11727 [quant-ph]
- [29]Kwak, Y., Yun, W.J., Pyŏung Kim, J., Cho, H., Choi, M., Jung, S., Kim, J.: Quantum Distributed Deep Learning Architectures: Models, Discussions, and Applications. arXiv e-prints, 2202–11200 (2022) arXiv:2202.11200 [quant-ph]arxiv.org/abs/2202.11200
- [30]Benedetti, M., Coyle, B., Fiorentini, M., Lubasch, M., Rosenkranz, M.: Variational Inference with a Quantum Computer. Physical Review Applied 16(4), 044057 (2021) https://doi.org/10.1103/PhysRevApplied.16.044057 arXiv:2103.06720 [quant-ph]
- [31]Wang, Z.T., Ashida, Y., Ueda, M.: Deep Reinforcement Learning Control of Quantum Cartpoles. Physical Review Letters 125(10), 100401 (2020) https: //doi.org/10.1103/PhysRevLett.125.100401 arXiv:1910.09200 [quant-ph]DOI
- [32]Yang, D., Xiao, Z., Yu, W.: Boosting the Adversarial Transferability of Surrogate Model with Dark Knowledge. arXiv e-prints, 2206–08316 (2022) arXiv:2206.08316 [cs.LG]arxiv.org/abs/2206.08316
- [33]Mitarai, K., Negoro, M., Kitagawa, M., Fujii, K.: Quantum circuit learning. Phys. Rev. A 98, 032309 (2018) https://doi.org/10.1103/PhysRevA.98.032309
- [34]McClean, J.R., Boixo, S., Smelyanskyi, V.N., Babbush, R., Neven, H.: Barren plateaus in quantum neural network training landscapes. Nature Communications 9(1), 4812 (2018) https://doi.org/10.1038/s41467-018-07090-4
- [35]Nakanishi, K.M., Mitarai, K., Fujii, K.: Subspace-search variational quantum eigensolver for excited states. arXiv e-prints, 1810–09434 (2018) arXiv:1810.09434 [quant-ph]DOI
- [36]Kosugi, T., Matsushita, Y.-i.: Linear-response functions of molecules on a quantum computer: Charge and spin responses and optical absorption. Phys. Rev. Res. 2, 033043 (2020) https://doi.org/10.1103/PhysRevResearch.2.033043
- [37]Kato, T.: https://github.com/Qaqarot. Opensource software development kit (2018). https://blueqat.com/
- [38]Wakaura, H., Mulyawan, R., Suksmono, A.B.: Adaptive Variational Quantum Kolmogorov-Arnold Network. arXiv e-prints, 2503–21336 (2025) arXiv:2503.21336 [quant-ph]
- [39]Wakaura, H., Mulyawan, R., Suksmono, A.B.: Enhanced Variational Quantum Kolmogorov-Arnold Network. Version 3. The classification results of that version are withdrawn; see Section 4.2 (2025)
- [40]Sengupta, R., Adhikary, S., Oseledets, I., Biamonte, J.: Tensor networks in machine learning. arXiv e-prints, 2207–02851 (2022) https://doi.org/10.48550/arXiv.2207.02851 arXiv:2207.02851 [quant-ph]