Pith. sign in

REVIEW 4 major objections 4 minor 39 references

Quantum-Enhanced Weight Optimization for Neural Networks Using Grover's Algorithm

T0 review · 4 major / 4 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper claims that Grover's algorithm can replace backpropagation by searching a discrete grid of candidate weight values, turning per-weight evaluation from $O(N)$ into $O(\sqrt{N})$.

desk verdict The paper's own algorithm evaluates every candidate classically, so the claimed O(sqrt(N)) speedup is unsupported; the experimental work is fine but cannot rescue the core claim. read the letter →

arxiv 2504.14568 v1 pith:FQ2QBUCW submitted 2025-04-20 quant-ph cs.LG

Stefan-Alexandru Jura , Mihai Udrescu This is my paper · ORCID
classification quant-phcs.LG
keywords quantum-enhancedmachinelearninghybridquantum-classicalneuralnetworkquantumweightoptimizationGrover'salgorithmgradient-freemultilayerperceptronamplitudeamplificationdiscretization
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to establish that a classical neural network can be trained without gradients by replacing the backpropagation update with Grover's quantum search. Each weight's update range is discretized into $N$ candidate values, the loss of each candidate is evaluated, and a Grover minimum-finding routine is used to select the best candidate; the claimed effect is that candidate evaluation drops from $O(N)$ to $O(\sqrt{N})$ per weight. The authors report that this gradient-free scheme reaches 100% test accuracy on the Wine dataset and a mean accuracy of 97.7% on the Digits dataset with a three-hidden-layer network, while the whole search needs only about seven logical qubits. If the speedup holds, it would offer a path around vanishing and exploding gradients and make near-term quantum devices useful for training classical architectures. The claim is conditional on a quantum oracle that can evaluate the network's loss for superposed candidate weights in roughly one forward pass, something the paper does not construct.

What carries the argument

The central object is Grover's algorithm in its minimum-finding form, applied to a discrete grid of candidate weights rather than to a database or a quantum neural network. The load-bearing identity is the Grover speedup: searching $N$ unordered candidates costs $O(\sqrt{N})$ oracle calls instead of $O(N)$. The grid is built from a local search interval $I_{ij}$ centered on the current weight, whose width is controlled by $\alpha_t\sigma_t$; the paper's bounded-change argument justifies why narrowing that interval when loss decreases stays reliable. The tolerance ratio $\tau$ defines the set of near-optimal candidates that the oracle marks, and amplitude amplification boosts the probability of measuring the best one. The same machinery is reused layer by layer, with the index register reset between layers, which is what keeps the qubit count near the claimed seven. The adaptive $\alpha_t$ update acts as the analogue of a learning-rate schedule, narrowing the grid when loss improves and widening it when it does not.

What would settle it

Run the proposed QEWO procedure with a simulated Grover oracle on a small network and compare the number of oracle calls and circuit depth against a classical exhaustive scan of the same $N$ candidates; if the actual oracle requires more than a constant multiple of one forward pass or more than about seven logical qubits, the central $O(\sqrt{N})$ and qubit-count claims are refuted for that implementation. Alternatively, on real hardware, measure the per-weight wall-clock time for $N=17$ and $N=32$ candidate grids: the promised quadratic speedup over classical exhaustive search would show up as a characteristic scaling in quantum circuit depth, not in simulated classical loss evaluations.

Watch

Extended reading notes

Core claim

The paper's central claim is that weight optimization in a classical multilayer perceptron can be formulated as a sequence of unstructured searches and accelerated with Grover's algorithm. For each weight $w_{ij}^{(t)}$, the method builds a search interval $I_{ij} = [w_{ij}^{(t)} - \alpha_t \sigma_t,\, w_{ij}^{(t)} + \alpha_t \sigma_t]$, where $\sigma_t$ is the standard deviation of the layer's weights and $\alpha_t$ is an adaptive scale; the interval is discretized into $N$ candidates. The authors select candidates whose loss lies within a tolerance of the current best, apply Grover's minimum-finding to identify the best candidate, and then shrink or expand $\alpha_t$ depending on whether the loss decreased. They state that this reduces per-weight candidate evaluation from $O(N)$ to $O(\sqrt{N})$, giving an overall complexity of $O(E \cdot M \cdot \sqrt{N} \cdot T_{\text{eval}})$, and that the layer-by-layer search uses at most seven logical qubits. The reported experiments show faster convergence than ADAM and a mean test accuracy of 97.7% on Digits with three hidden layers, with accuracy remaining above 97% under simulated depolarizing noise.

Load-bearing premise

The method's speedup depends on assuming that one quantum circuit can compute the network's loss for many candidate weights at once in about the same time a single classical check would take, but the paper does not build or test such a circuit.

Editorial extensions

If this is right

  • If the complexity claim holds, training a classical MLP becomes gradient-free, so the failure modes of backpropagation - vanishing gradients, exploding gradients, and getting stuck in poor local minima - are bypassed by construction.
  • The same classical architecture can be reused; only the weight update rule changes, so the method is a drop-in substitute for the optimizer rather than a new kind of quantum neural network.
  • Because layers are optimized one at a time and the quantum register is recycled, the hardware requirement stays at roughly seven logical qubits, well below the tens of qubits reported for comparable quantum perceptron proposals.
  • The claimed speedup grows with the candidate grid size $N$, but the paper's own experiments show that very fine grids (32 candidates per hidden layer) degrade accuracy, so the practical benefit is bounded by the noise and instability of dense discretization.
  • Under simulated NISQ noise with 0.5% single-qubit and 2% two-qubit error rates, the method still reaches 97.22% mean accuracy on Digits, above a classical MLP at around 95%, suggesting headroom for near-term hardware.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A direct way to test the central speedup would be to construct the missing oracle circuit that evaluates the forward pass and cross-entropy loss in superposition; the reported $O(\sqrt{N})$ per-weight complexity is only real if such a circuit exists and runs in roughly the time of one classical evaluation.
  • The adaptive interval mechanism is functionally a quantum-accelerated local random search; connecting it to established step-size schedules (like learning-rate decay or line search) might yield convergence guarantees that the paper does not provide.
  • Because the method optimizes weights one layer at a time, it is naturally suited to block-coordinate or layer-wise training strategies, and a classical baseline with the same layer-wise greedy search would show how much of the reported gain comes from Grover versus from the search strategy itself.
  • If a future implementation can run the oracle on real hardware, the accuracy-versus-resolution cliff at 32 candidates is a clean experimental signature: it predicts that performance should drop sharply once discretization becomes too fine, independent of the optimizer.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper proposes a gradient-free neural-network weight optimization method called QEWO. For each weight, the update range is discretized into N candidate values; the authors then claim to use Grover's algorithm to find the candidate minimizing the loss, giving a per-weight speedup from O(N) to O(sqrt(N)) and a total complexity O(E*M*sqrt(N)*Teval). They report experiments on the Wine and Digits datasets, including a deep network with three hidden layers achieving a mean test accuracy of 97.7% on Digits, and claim the quantum search requires at most 7 logical qubits. The paper presents pseudocode for the algorithm, experimental comparisons with ADAM and a genetic algorithm, and a noise-sensitivity study. The central claims hinge on (i) the complexity reduction, (ii) the existence of a small loss-evaluation oracle for Grover's algorithm, and (iii) the reported experimental improvements.

Significance. If the core claims were valid, the idea of using Grover search for gradient-free neural-network weight optimization would be a potentially interesting contribution at the intersection of quantum search and classical ML training. The manuscript has some strengths: it provides a self-contained algorithmic description, reports multiple experiments, includes statistical confidence intervals for the Digits results, and makes a repository link available. However, the central speedup claim is invalidated by the paper's own pseudocode, and the resource claims depend on an oracle that is never constructed. The experimental section also uses reporting practices that undermine the quantitative conclusions. Because the main theoretical proposition is not supported, the significance of the work as it stands is limited; a corrected version would require a substantially different algorithm and analysis.

major comments (4)
  1. [Section III, Step 3 and Step 4; Section V, complexity claim] The claimed O(sqrt(N)) speedup is contradicted by the algorithm's own pseudocode. Step 3 explicitly loops over k = 0, ..., N-1 and performs a forward pass and loss evaluation for every candidate x_{ij,k}^{(t)} classically, which costs N*Teval per weight. Step 4 then computes min(L) over all N candidates classically, so the total cost is O(E*M*N*Teval), not O(E*M*sqrt(N)*Teval). The Grover search in Step 5 operates on a set M whose elements and minimum are already known from the classical enumeration; it is therefore either redundant or undefined. This is a load-bearing error in the paper's central complexity claim.
  2. [Section III, Step 5; Section IV.C, qubit count] No oracle circuit is provided for the loss-evaluation step. A Grover oracle for 'candidate is within tol_ratio of the minimum' would need to coherently evaluate the full MLP forward pass and the loss function on a superposition of candidate weights, with all other weights of the network fixed and the input data encoded. The claimed 7 logical qubits in Section IV.C count only ceil(log2 N) index qubits plus one ancilla and omit the data qubits, the weight registers for the remaining weights, and the arithmetic/ancilla registers needed to compute activations, the loss, and the comparison with the current minimum and tolerance. The near-term resource claim is therefore unsupported.
  3. [Section III, 'Optimize using Grover\'s Algorithm' and complexity analysis] The search problem is not unstructured. The loss as a function of the candidate x_{ij,k} is determined by a full forward pass through the network, and the authors themselves argue in Section III that this loss is Lipschitz continuous and varies predictably with the candidate. Grover's quadratic speedup applies to unstructured search over an arbitrary oracle; applying it to an oracle that computes a structured, classically evaluable function does not by itself establish a speedup over classical evaluation of that function. Since Step 3 already evaluates every candidate, no speedup is demonstrated.
  4. [Section IV.B and IV.C, experimental reporting] The experimental claims are weakened by the reporting protocol. Section IV.B states that 'the best-performing run was retained for the plots and tables,' so the 100% accuracy and the loss reductions in Tables I-IV are best-of-10 results rather than typical or mean results. In Section IV.C, the reported mean accuracy of 97.7% is computed over resolutions 17-31 only, while Figure 4 shows that resolution 32 drops to about 91%; excluding this point post hoc without a principled justification makes the 'mean accuracy' claim misleading as a characterization of the method. Similarly, Figure 8 compares the quantum model to 'the one with the best results after training 10 times' for the classical MLP, which does not support a claim that the quantum method outperforms classical optimization in expectation.
minor comments (4)
  1. [Section IV.A heading] The heading 'Exerimental Setup' contains a typo; it should read 'Experimental Setup'.
  2. [Section V / GitHub link] The repository link 'https://github.com/stephanjura27/quantum optimized mlp' contains spaces and is not a valid URL; the authors should provide a corrected, working link.
  3. [Section IV.C, statistics] The 95% confidence interval is computed over 15 different hidden-resolution values, not 15 independent training runs; the text should clarify that the interval describes variation across resolutions, not across random seeds.
  4. [Section II.A, references [20] and [21]] The citation of [20] (Morse and Stanley, evolutionary optimization) as a general reference for 'a pool P' is not obviously apt, and [21] (Hadamard transforms) seems unrelated to the quantum minimum-search discussion; the authors should verify and correct these references.

Circularity Check

1 steps flagged · score 6.0 of 10

Step 3 evaluates all N candidates classically; Step 5 defines Grover's output as that same precomputed min(L), so the O(sqrt(N)) speedup claim reduces by construction to the classical search.

  1. self definitional [Section III, Quantum-Enhanced Weight Optimization (QEWO), Steps 3–5]
    "3. Evaluate the candidate weights. 1) For each candidate weight x(t)ij,k ... a. Perform the forward pass ... b. Compute the loss L(x(t)ij,k) ... 4. Select promising candidates. Define the set of candidate indices: M := {k | L(x(t)ij,k) ≤ min(L)+τ} ... 5. Optimize using Grover’s Algorithm. Apply Grover’s algorithm to the candidates in M to identify the optimal candidate index k∗ such that L(x(t)ij,k∗) := min(L)."

    Step 3 is an explicit classical loop over k = 0,...,N−1: every candidate's forward pass and loss are computed before any quantum step. Step 4 then builds M using min(L), which is 'the smallest loss among all candidates' and is therefore already known from Step 3. Step 5 gives Grover the task of returning the index whose loss equals this same min(L); the output is fixed by the classical enumeration, not discovered by the quantum search. The paper's complexity claim O(E·M·√N·Teval) presupposes that a quantum oracle can evaluate the loss in superposition, but the only evaluation procedure actually defined is the Step 3 loop, which costs N·Teval per weight.

full rationale

Step 3 of QEWO explicitly loops over all N candidate values for each weight, performing a forward pass and loss computation for every candidate; Step 4 computes min(L) from that complete classical enumeration; Step 5 then stipulates that the Grover-selected index k* is the one satisfying L(x_k*) = min(L). The oracle that would let Grover evaluate the loss coherently is never constructed, and the 7-qubit count omits the data, weight, and arithmetic registers such an oracle would require. Consequently the claimed O(sqrt(N)) per-weight speedup and the 'quantum-optimized' experimental numbers are, on the paper's own algorithm, the results of a classical exhaustive search renamed as a Grover search. No load-bearing self-citation chain or imported uniqueness theorem is present; the circularity is internal to Steps 3–5 and the complexity analysis. Score 6 reflects that Grover's quadratic speedup is a genuine external result that would apply if a suitable oracle existed, but the paper's own implementation never invokes it, so the central prediction reduces by construction to the classical enumeration.

Assumptions & free parameters 5 free parameters · 4 assumptions · 1 invented entities

The ledger captures the hand-tuned hyperparameters (alpha, tol_ratio, grid sizes, initialization range, dropout) and the implicit oracle assumption. The oracle is the most consequential entry because the entire quadratic-speedup claim rests on it, yet the paper never constructs it.

free parameters (5)
  • Search interval scale alpha (with gamma_up, gamma_down, alpha_min, alpha_max) = alpha=0.1 initially; gamma_down=0.95; gamma_up=1.05; bounds not reported
    Controls the width of candidate intervals around each weight and is adjusted based on loss decrease; chosen manually and not swept.
  • tol_ratio = 0.05 for hidden layers, 0.1 for output layer
    Defines the tolerance band M around the best candidate loss; chosen based on empirical testing, as stated in Section IV-A.
  • Candidate grid size N = 17 to 32 per hidden layer, 64 for output layer
    Discretization resolution of each weight interval; the range 17-31 was selected post hoc after resolution 32 degraded accuracy.
  • Weight initialization range = uniform in [-1,1]
    Paper argues a broader random initialization helps this search method; this choice is tuned to the method.
  • Dropout probability and L2 regularization strength = dropout p=0.2; L2 coefficient not reported
    Used to stabilize training; values chosen without sensitivity analysis.
assumptions (4)
  • domain assumption Loss is Lipschitz continuous on the compact search interval I, giving predictable loss changes for nearby candidates.
    Invoked in Section III around Eq. (1) to justify stable loss changes for nearby candidates; true for many MLP losses on compact sets but does not guarantee escape from local minima.
  • ad hoc to paper A quantum oracle can compute the MLP forward pass and loss for a superposition of candidate weights at a cost comparable to one classical forward pass.
    No circuit or resource estimate is given for encoding the forward pass, activations, softmax, and L2 loss into a Grover oracle; central to the speedup claim.
  • standard math Grover minimum-finding works on candidate set M with the loss oracle.
    Grover's quadratic speedup and minimum-finding are standard, conditioned on oracle access; cited from [9], [10].
  • domain assumption Greedy per-weight coordinate descent over candidate grids escapes local optima.
    The method updates one weight at a time with a widening interval; the paper claims avoidance of local optima without a proof.
invented entities (1)
  • Implicit loss-evaluation oracle for Grover's algorithm
    purpose: Marks candidate weights with low loss so amplitude amplification can find the minimum.
    The oracle is not implemented or described; no falsifiable handle outside the paper is provided. The claimed speedup depends entirely on its existence.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Quantum-Enhanced Weight Optimization for Neural Networks Using Grover's Algorithm." pith.science (2026). https://pith.science/paper/FQ2QBUCW

@misc{pith2026250414568,
  author       = {Pith},
  title        = {Pith review of: Quantum-Enhanced Weight Optimization for Neural Networks Using Grover's Algorithm},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FQ2QBUCW}},
  note         = {Machine review of arXiv:2504.14568}
}
read the original abstract

The main approach to hybrid quantum-classical neural networks (QNN) is employing quantum computing to build a neural network (NN) that has quantum features, which is then optimized classically. Here, we propose a different strategy: to use quantum computing in order to optimize the weights of a classical NN. As such, we design an instance of Grover's quantum search algorithm to accelerate the search for the optimal parameters of an NN during the training process, a task traditionally performed using the backpropagation algorithm with the gradient descent method. Indeed, gradient descent has issues such as exploding gradient, vanishing gradient, or convexity problem. Other methods tried to address such issues with strategies like genetic searches, but they carry additional problems like convergence consistency. Our original method avoids these issues -- because it does not calculate gradients -- and capitalizes on classical architectures' robustness and Grover's quadratic speedup in high-dimensional search spaces to significantly reduce test loss (58.75%) and improve test accuracy (35.25%), compared to classical NN weight optimization, on small datasets. Unlike most QNNs that are trained on small datasets only, our method is also scalable, as it allows the optimization of deep networks; for an NN with 3 hidden layers, trained on the Digits dataset from scikit-learn, we obtained a mean accuracy of 97.7%. Moreover, our method requires a much smaller number of qubits compared to other QNN approaches, making it very practical for near-future quantum computers that will still deliver a limited number of logical qubits.

Figures

Figures reproduced from arXiv: 2504.14568 by the authors.

Figure 1
Figure 1. Our proposed method’s architecture, which can be extended to an arbitrary number of hidden layers. The dataset is split into [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Evolution of training and test loss over 10 epochs, comparing [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Comparison between training and improvement in test accuracy [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Illustration on how the final test accuracy changes as we vary the [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Illustration on how the final test loss evolves as the hidden resolution [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 8
Figure 8. Figure 8: Comparing the mean test accuracy per epoch across three models, [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: Evolution of the mean test accuracy per epoch for 3 initialization [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

39 extracted references · 27 canonical work pages

  1. [1]

    A generalized convergence theorem for neural networks,

    J. Bruck and J. W. Goodman, “A generalized convergence theorem for neural networks,” IEEE Transactions on Information Theory , vol. 34, no. 5, pp. 1089–1092, 1988

    work page 1988

  2. [2]

    Artificial neural networks: fundamentals, computing, design, and application,

    I. Basheer and M. Hajmeer, “Artificial neural networks: fundamentals, computing, design, and application,” Journal of Microbiological Meth- ods, vol. 43, no. 1, pp. 3–31, 2000

    work page 2000

  3. [3]

    Gradient Descent based Optimization Algorithms for Deep Learning Models Training

    J. Zhang, “Gradient descent based optimization algorithms for deep learning models training,” arXiv preprint arXiv:1903.03614 , 2019

    work page Pith review arXiv 1903

  4. [4]

    Backpropagation and stochastic gradient descent method,

    S. Amari, “Backpropagation and stochastic gradient descent method,” Neurocomputing, vol. 5, no. 4-5, pp. 185–196, 1993

    work page 1993

  5. [5]

    Understanding the difficulty of training deep feedforward neural networks,

    X. Glorot and Y . Bengio, “Understanding the difficulty of training deep feedforward neural networks,” in Proceedings of the Thirteenth Inter- national Conference on Artificial Intelligence and Statistics (AISTATS) , 2010, pp. 249–256, chia Laguna Resort, Sardinia, Italy, May 13–15, 2010

    work page 2010

  6. [6]

    D. P. Bertsekas, Nonlinear Programming. Athena Scientific, 1999

    1999

  7. [7]

    BGADAM: Boosting based Genetic-Evolutionary ADAM for Neural Network Optimization

    J. Bai, Y . Ren, and J. Zhang, “Bgadam: Boosting-based genetic- evolutionary adam for neural network optimization,” arXiv preprint arXiv:1908.08015, 2019

    work page Pith review arXiv 1908

  8. [8]

    Genetic algorithms,

    D. E. Goldberg, “Genetic algorithms,” ACM Computing Surveys (CSUR), vol. 28, no. 1, pp. 77–80, 1996

    work page 1996

Show all 39 references
  1. [9]

    A fast quantum mechanical algorithm for database search,

    L. K. Grover, “A fast quantum mechanical algorithm for database search,” in Proceedings of the 28th Annual ACM Symposium on the Theory of Computing , 1996, pp. 212–219

    1996

  2. [10]

    A quantum algorithm for finding the maxi- mum,

    A. Ahuja and S. Kapoor, “A quantum algorithm for finding the maxi- mum,” arXiv preprint arXiv:quant-ph/9911082 , 1999

    1999 arXiv

  3. [11]

    Multilayer perceptron (mlp),

    H. Taud and J. F. Mas, “Multilayer perceptron (mlp),” in Lecture Notes in Geoinformation and Cartography , 2017, pp. 451–455

    2017

  4. [12]

    Rectified linear units improve restricted boltz- mann machines,

    V . Nair and G. E. Hinton, “Rectified linear units improve restricted boltz- mann machines,” in Proceedings of the 27th International Conference on Machine Learning (ICML) , 2010, pp. 807–814

    2010

  5. [13]

    Learning repre- sentations by back-propagating errors,

    D. E. Rumelhart, G. E. Hinton, and R. J. Williams, “Learning repre- sentations by back-propagating errors,” Nature, vol. 323, no. 6088, pp. 533–536, 1986

    1986

  6. [14]

    Uci machine learning repository,

    D. Dua and C. Graff, “Uci machine learning repository,” http://archive. ics.uci.edu/ml, 2019, irvine, CA: University of California, School of Information and Computer Science

    2019

  7. [15]

    Implementing grover’s al- gorithm on the ibm quantum computers,

    A. Mandviwalla, K. Ohshiro, and B. Ji, “Implementing grover’s al- gorithm on the ibm quantum computers,” in 2018 IEEE International Conference on Big Data (Big Data) , 2018

    2018

  8. [16]

    Developing mathematical ora- cle functions for grover quantum search algorithm,

    C. B. Pronin and A. V . Ostroukh, “Developing mathematical ora- cle functions for grover quantum search algorithm,” arXiv preprint arXiv:2109.05921, 2021

    2021 arXiv

  9. [17]

    Chuang and M

    I. Chuang and M. Nielsen, Quantum Computation and Quantum Infor- mation. Cambridge University Press, 2000, chapter 6.1.2

    2000

  10. [18]

    Quantum amplitude amplification and estimation,

    G. Brassard, P. Hoyer, M. Mosca, and A. Tapp, “Quantum amplitude amplification and estimation,” arXiv preprint arXiv:quant-ph/0005055 , 2000

    2000 arXiv

  11. [19]

    Hirvensalo, Quantum Computing

    M. Hirvensalo, Quantum Computing . Springer Science and Business Media, 2013

    2013

  12. [20]

    Simple evolutionary optimization can rival stochastic gradient descent in neural networks,

    G. Morse and K. O. Stanley, “Simple evolutionary optimization can rival stochastic gradient descent in neural networks,” in Proceedings of the Genetic and Evolutionary Computation Conference 2016 (GECCO ’16) . New York, NY , USA: Association for Computing Machinery, 2016, pp. 477–484

    2016

  13. [21]

    Hadamard transforms,

    S. S. Agaian, H. Sarukhanyan, K. Egiazarian, and J. Astola, “Hadamard transforms,” in SPIE Conference Proceedings, August 2011

    2011

  14. [22]

    Implementing quantum ge- netic algorithms: a solution based on grover’s algorithm,

    M. Udrescu, L. Prodan, and M. Vl ˘adut ¸iu, “Implementing quantum ge- netic algorithms: a solution based on grover’s algorithm,” inProceedings of the 3rd Conference on Computing Frontiers , May 2006, pp. 71–82

    2006

  15. [23]

    Variational quantum algorithms,

    M. Cerezo, A. Arrasmith, R. Babbush, S. C. Benjamin, S. Endo, K. Fujii, J. R. McClean, K. Mitarai, X. Yuan, L. Cincio, and P. J. Coles, “Variational quantum algorithms,” Nature Reviews Physics, vol. 3, no. 9, pp. 625–644, 2021

    2021

  16. [24]

    The theory of variational hybrid quantum-classical algorithms,

    J. R. McClean, J. Romero, R. Babbush, and A. Aspuru-Guzik, “The theory of variational hybrid quantum-classical algorithms,” New Journal of Physics, vol. 18, no. 2, p. 023023, 2016

    2016

  17. [25]

    A variational eigenvalue solver on a photonic quantum processor,

    A. Peruzzo, J. McClean, P. Shadbolt, M. H. Yung, X. Q. Zhou, P. J. Love, A. Aspuru-Guzik, and J. L. O’Brien, “A variational eigenvalue solver on a photonic quantum processor,” Nature Communications, vol. 5, no. 1, p. 4213, 2014

    2014

  18. [26]

    A quantum approximate optimization algorithm,

    E. Farhi, J. Goldstone, and S. Gutmann, “A quantum approximate optimization algorithm,” arXiv preprint arXiv:1411.4028 , 2014

    2014 arXiv

  19. [27]

    The power of quantum neural networks,

    A. Abbas, D. Sutter, C. Zoufal, A. Lucchi, A. Figalli, and S. Wo- erner, “The power of quantum neural networks,” arXiv preprint arXiv:2011.00027, 2020

    2011 arXiv

  20. [28]

    A variational quantum perceptron with grover’s algorithm for efficient classification,

    N. Innan and M. Bennai, “A variational quantum perceptron with grover’s algorithm for efficient classification,” Physica Scripta, vol. 99, no. 5, p. 055120, 2024

    2024

  21. [29]

    A grover-search based quantum learning scheme for classification,

    Y . Du, M. H. Hsieh, T. Liu, and D. Tao, “A grover-search based quantum learning scheme for classification,” New Journal of Physics , vol. 23, no. 2, p. 023020, 2021

    2021

  22. [30]

    Quan- tum neural networks in practice: A comparative study with classical models from standard data sets to industrial images,

    D. Basilewitsch, J. F. Bravo, C. Tutschku, and F. Struckmeier, “Quan- tum neural networks in practice: A comparative study with classical models from standard data sets to industrial images,” arXiv preprint arXiv:2411.19276, 2024

    2024

  23. [31]

    Zhang, Z

    A. Zhang, Z. C. Lipton, M. Li, and A. J. Smola, Dive into Deep Learning. Cambridge University Press, 2020, available at https://d2l.ai

    2020

  24. [32]

    Quantum neural network for quantum neural computing,

    M. G. Zhou, Z. P. Liu, H. L. Yin, C. L. Li, T. K. Xu, and Z. B. Chen, “Quantum neural network for quantum neural computing,” Research, vol. 6, p. 0134, 2023

    2023

  25. [33]

    Quantum perceptron models,

    N. Wiebe, A. Kapoor, and K. M. Svore, “Quantum perceptron models,” arXiv preprint arXiv:1602.04799, 2016, available at https://arxiv.org/abs/ 1602.04799

    2016 arXiv

  26. [34]

    Goodfellow, Y

    I. Goodfellow, Y . Bengio, and A. Courville, Deep Learning. MIT Press, 2016

    2016

  27. [35]

    Adam: A method for stochastic optimization,

    D. P. Kingma and J. Ba, “Adam: A method for stochastic optimization,” arXiv preprint arXiv:1412.6980 , 2014

    2014 arXiv

  28. [36]

    Plot digits last image,

    “Plot digits last image,” https://scikit-learn.org/1.5/auto examples/ datasets/plot digits last image.html, scikit-learn Example

  29. [37]

    Iris dataset,

    “Iris dataset,” https://archive.ics.uci.edu/dataset/53/iris, uCI Machine Learning Repository

  30. [38]

    sklearn-moons-data-set,

    “sklearn-moons-data-set,” https://www.kaggle.com/datasets/berkayalan/ sklearn-moons-data-set, kaggle Dataset

  31. [39]

    Characterization of addressability by simultaneous randomized benchmarking,

    J. M. Gambetta, A. D. C ´orcoles, S. T. Merkel, B. R. Johnson, J. A. Smolin, J. M. Chow, C. A. Ryan, C. Rigetti, S. Poletto, T. A. Ohki et al. , “Characterization of addressability by simultaneous randomized benchmarking,” Physical review letters , vol. 109, no. 24, p. 240504, 2012

    2012

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.