{"id":"0db24315-eb27-413f-b409-19d848ffb516","arxiv_id":"2504.14568","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"high","formal_verification":"none","parameter_count":5,"one_line_summary":"A Grover-based gradient-free weight optimizer is described and simulated, but the claimed O(sqrt(N)) speedup over gradient descent is not established by the paper's own algorithm.","lead":"The paper replaces backpropagation with a Grover-search over discretized candidate weights for a classical neural network, reporting large accuracy gains on small datasets. The central quadratic-speedup claim is unsupported because the loss oracle is never implemented and the algorithm's own step 3 evaluates all candidates classically.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Step 3 evaluates all N candidates classically, so the claimed O(sqrt(N)) per-weight speedup and 7-qubit resource bound are unsupported by the paper's own algorithm.","rationale":"The rejection is justified on internal grounds, not by disagreement with an external consensus. The paper's own algorithm, as written in Section III, is a classical grid search: Step 3 enumerates all N candidate values and computes a full loss for each, and Step 4 identifies the minimum. The Grover step in Step 5 is not a substitution for that enumeration, and no oracle is constructed that would make a quantum search meaningful. The 7-qubit resource estimate in Section IV-C is also incomplete: it counts only the index register and a single ancilla, but evaluating a loss in superposition requires coherent storage of inputs, other layer weights, activations, and reversible arithmetic for the forward pass. The experiments, even if their accuracy numbers are accepted, do not test the quantum claim because the simulated quantum circuit for Step 5 is never specified. This matches the reader's weakest_assumption, and I find no independent reason to weaken the rejection.","tokens_in":15014,"tokens_out":4263,"duration_ms":40959,"concrete_test":"Add a counter to the repository's training loop at the point corresponding to Step 3, incrementing on every forward pass and loss evaluation, and dump the quantum circuit constructed in Step 5 with its qubit and gate counts. Run one epoch on the Wine network with N=32 hidden and N=64 output candidates. If the counter reaches E*M*N total evaluations and the Step 5 circuit contains no oracle that computes the MLP loss from a superposition of candidate weights, then the claimed O(E*M*sqrt(N)*Teval) complexity and the 7-qubit bound are contradicted by the actual implementation.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section III's pseudocode invalidates the central complexity claim. Step 3 explicitly loops over k = 0,...,N-1 and, for each candidate, performs a forward pass and loss evaluation. That is N * Teval per weight, giving total cost E*M*N*Teval, not E*M*sqrt(N)*Teval. Step 4 then computes min(L) over all N candidates classically, so the Grover search in Step 5 is either redundant (the minimum index is already known) or undefined: no oracle circuit is provided. An oracle for L(x_ij,k) would need to coherently evaluate the entire MLP forward pass with all other weights fixed, on encoded input data, and accumulate the loss; the claimed 7 logical qubits count only ceil(log2 N) index qubits plus one ancilla and omit those data, weight, and arithmetic registers. Thus the quantum speedup and near-term resource claims depend entirely on an unconstructed oracle that the paper's own algorithm does not use.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","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.","tokens_in":15281,"tokens_out":2552,"duration_ms":25328,"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":[{"comment":"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.","section":"Section III, Step 3 and Step 4; Section V, complexity claim"},{"comment":"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.","section":"Section III, Step 5; Section IV.C, qubit count"},{"comment":"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.","section":"Section III, 'Optimize using Grover\\'s Algorithm' and complexity analysis"},{"comment":"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.","section":"Section IV.B and IV.C, experimental reporting"}],"minor_comments":[{"comment":"The heading 'Exerimental Setup' contains a typo; it should read 'Experimental Setup'.","section":"Section IV.A heading"},{"comment":"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.","section":"Section V / GitHub link"},{"comment":"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.","section":"Section IV.C, statistics"},{"comment":"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.","section":"Section II.A, references [20] and [21]"}],"recommendation":"reject","confidential_remarks":"The central claim is invalidated by the paper's own algorithm: Step 3 performs a full classical enumeration of all candidate losses before any quantum search, so the claimed complexity and the quantum speedup do not hold as stated. The oracle and qubit-count claims are also unsupported. These are not presentation issues but fundamental problems with the paper's core contribution, and they cannot be fixed by a local revision within the current scope. I also note that the arXiv version contains an invalid repository URL, and the experimental reporting practices (best-run selection, post hoc exclusion of resolution 32) would require substantial rework before any future resubmission."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The central claim doesn't survive contact with the paper's own algorithm. Step 3 loops over all N candidate weights, performs a forward pass and loss computation for each, and then Step 4 computes the minimum classically. That is N evaluations per weight before Grover's algorithm is even mentioned. The total cost is O(E * M * N * Teval), not the advertised O(E * M * sqrt(N) * Teval). The Grover step is either redundant—the minimum is already known—or undefined, because no oracle circuit is provided that could coherently evaluate the loss. The 7-qubit resource count is also incomplete: it counts only the index register and one ancilla, but a real oracle would need registers for the input data, the weights, and the arithmetic in the forward pass.\n\nTo give credit where it's due: the idea of using Grover's minimum-finding for classical MLP weight optimization is a natural and worth-testing extension of existing quantum perceptron work. The paper is clearly written, the related work is competently surveyed, and the experiments include a genetic algorithm baseline, multiple activation functions, and a noise sensitivity study. The authors also provide a GitHub repository, which is more than many papers do.\n\nThe soft spots beyond the core flaw are real but secondary. Experiment 1 reports the best-performing run out of ten, which inflates the apparent advantage. Experiment 2 reports results for resolutions 17–31 but excludes resolution 32 after seeing it perform poorly, and the paper offers no pre-registered criterion for that exclusion. There is also no gradient-free classical baseline in Experiment 1, though the genetic algorithm in Experiment 2 helps partly.\n\nWho is this for? Someone curious about whether Grover's algorithm can accelerate discrete weight search might use this as a starting point, but they should not treat it as a valid demonstration. The complexity analysis is internally inconsistent with the pseudocode, and the missing oracle is load-bearing. I would not cite it in my own work. It is not ready for peer review in its current form—the main claim needs either a real oracle construction or an honest complexity statement that removes the speedup claim.","headline":"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.","tokens_in":15740,"tokens_out":2555,"would_cite":false,"duration_ms":25431,"reading_group":"no","serious_thinker":"no","would_accept_peer_review":false},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"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})$.","keywords":["quantum-enhanced machine learning","hybrid quantum-classical neural network","quantum weight optimization","Grover's algorithm","gradient-free optimization","multilayer perceptron","amplitude amplification","weight discretization"],"falsifier":"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.","tokens_in":14837,"feed_emoji":"⚛️","tokens_out":16414,"duration_ms":128515,"temperature":0.7,"pith_summary":"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.","feed_headline":"Quantum search replaces backpropagation in neural nets","feed_subtitle":"Weight grids plus Grover search cut per-weight cost to its square root, using about seven qubits.","key_machinery":"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.","core_discovery":"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.","pith_inferences":["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."],"forward_implications":["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."],"supporting_citations":[{"why":"Supplies the original unstructured-search quadratic speedup that the method exploits.","marker":"[9]"},{"why":"Supplies the minimum-finding variant of Grover used to select the best candidate weight.","marker":"[10]"},{"why":"Formalizes amplitude amplification, the mechanism that gives Grover its quadratic speedup.","marker":"[18]"},{"why":"Provides the bounded-change (continuity) argument used to justify the adaptive candidate interval.","marker":"[34]"},{"why":"Defines ADAM, the classical optimizer whose complexity is the baseline for the claimed speedup.","marker":"[35]"},{"why":"Gives the soft quantum perceptron and its roughly 40-qubit footprint, the comparison behind the seven-qubit advantage.","marker":"[32]"},{"why":"Gives the Grover-accelerated variational quantum perceptron whose reported Iris accuracy is a comparison point for the small-dataset claims.","marker":"[28]"}],"fun_headline_variants":["Grover's algorithm accelerates neural network weight training","Quantum search replaces gradient descent for neural nets","No gradient? Grover's algorithm finds optimal NN weights","Quadratic speedup for neural nets via Grover's search","Quantum weight optimization: few qubits, big accuracy gains"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"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.","fun_headline_variants_meta":{"raw":{"variants":["Grover's algorithm accelerates neural network weight training","Quantum search replaces gradient descent for neural nets","No gradient? Grover's algorithm finds optimal NN weights","Quadratic speedup for neural nets via Grover's search","Quantum weight optimization: few qubits, big accuracy gains"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000218,"raw_usage":{"total_tokens":1509,"prompt_tokens":1085,"completion_tokens":424,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":701,"completion_tokens_details":{"reasoning_tokens":347}},"tokens_in":701,"tokens_out":424,"duration_ms":4058,"temperature":1.0,"reasoning_tokens":347,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T11:45:23.112697+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"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.","supporting_citations":[{"cited_title":"A fast quantum mechanical algorithm for database search,","cited_arxiv_id":null,"evidence_quote":"Supplies the original unstructured-search quadratic speedup that the method exploits."},{"cited_title":"Quantum neural network for quantum neural computing,","cited_arxiv_id":null,"evidence_quote":"Gives the soft quantum perceptron and its roughly 40-qubit footprint, the comparison behind the seven-qubit advantage."}],"review_version":1}