Pith. sign in

REVIEW 4 major objections 4 minor 21 references

Advanced For-Loop for QML algorithm search

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

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

Pith's one-line read AI agent loop turns classical ML algorithms into quantum code

desk verdict A thin but honest proof-of-concept that never shows the claimed iteration loop in action; the new application is real but the evidence is not. read the letter →

arxiv 2506.18260 v1 pith:XZSG6TDT submitted 2025-06-23 cs.AI

FuTe Wong This is my paper · ORCID
classification cs.AI
keywords LLM-basedmulti-agentsystemsquantummachinelearningforward-forwardalgorithmbackpropagationcircuitprogramsearchagenticframeworkproofofconcept
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 argues that a multi-agent system built on large language models can take the name and a sketch of a classical machine learning algorithm and evolve it into a quantum implementation through an iterative loop of code generation, validation, and reward-driven optimization. It presents this as a proof of concept, reporting quantum versions of the multi-layer perceptron, the forward-forward algorithm, and backpropagation. The result that makes the claim worth caring about is that the generated quantum forward-forward algorithm reaches test accuracy close to a human-crafted quantum neural network baseline on a 10-class digit task, while the other two generated algorithms also learn but lag behind. If the conversion loop is reliable, it would give researchers an automated pipeline from the large legacy of classical machine learning concepts to candidate quantum algorithms without hand-designing circuits.

What carries the argument

The carrying mechanism is the agentic evolution loop, structured as a for-loop over classical machine learning concepts. A set of agents with distinct roles (a theorist/algorithm generator, a coder, a validator, and an investor/reward-function generator) generate, evaluate, and refine code; in the abstraction equation $A = \sum_{ij}\alpha_{ij} L_j$, the system $A$ is a composition of language-model lobes $L_j$ with interaction weights $\alpha_{ij}$, and applying it to a classical algorithm $C_{ML}$ is posed as $\mathrm{argmin}_\pi Q^\pi_{ML}$, a search for an optimized quantum algorithm. The loop is what distinguishes the approach from one-shot prompting: each iteration feeds feedback from validation and reward signals back into the agents, so the quantum program evolves. The search occurs in program-code space rather than directly in gate sets of parameterized quantum circuits, which the paper argues allows more expressive resulting architectures.

What would settle it

Attempt to execute the snippets exactly as printed: if they contain undefined variables, missing imports, or no complete training loop, the proof of concept cannot be reproduced. Alternatively, re-run the 10-class digit classification with the described agentic pipeline and check whether the generated quantum forward-forward reliably reaches accuracy near 15.17% against the same baseline; failure to reproduce Table 1 would settle the claim.

Watch

Extended reading notes

Core claim

The central claim is that a large-language-model multi-agent for-loop can perform cross-domain transformation: given a classical algorithm name, the system first generates program code of the classical algorithm as an initial condition, then runs an evolution loop of searching and optimization until it obtains a quantum counterpart. Concretely, the system produced three such counterparts: a quantum MLP, a quantum forward-forward layer in which the positive and negative passes are quantized with quantum circuits, and a quantum backpropagation in which error backpropagation is replaced by the parameter-shift rule for computing gradients. The paper's headline empirical evidence is a table comparing average test accuracy: the human-crafted baseline QNN scores 15.55%, the generated quantum forward-forward scores 15.17%, quantum backprop scores 12.37%, and quantum MLP scores 9.40%. The author reads the 15.17% versus 15.55% result as showing that the agentically generated algorithm performs similarly to the human baseline, while acknowledging that training steps were limited because the work is a proof of concept.

Load-bearing premise

The whole proof of concept rests on the assumption that the code snippets shown in Figures 4a, 6, and 8 are correct, complete, runnable quantum implementations of MLP, forward-forward, and backpropagation, and that Table 1 reports actual runs of that code; the paper provides no full source, execution logs, or test harness.

Editorial extensions

If this is right

  • If the loop works as claimed, any named classical deep-learning algorithm becomes a candidate input to an automated search for its quantum analogue, without manual circuit design.
  • The quantum forward-forward result suggests that at least one generated algorithm can be competitive with a human-crafted quantum neural network on the same task.
  • Because the search space is program code rather than fixed gate sets, the framework can propose architectures that a gate-level quantum architecture search might miss.
  • The same for-loop could screen many classical machine learning concepts, making the bottleneck the conceptual translation rather than per-algorithm human effort.
  • With planning mechanisms and Monte-Carlo tree search added, the framework would move from translating one algorithm to actively choosing which classical concepts to translate.

Reading between the lines

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

  • A stronger test than the reported accuracy table would be to compare learning curves and run the same generated code in a real quantum or high-fidelity simulator backend, since the reported accuracies are close to random chance for a 10-class task (10%).
  • The framework's real target may not be matching human baselines on toy tasks but discovering quantum implementations whose structure differs qualitatively from human-designed circuits; the snippets could be systematically inspected for such structural novelty.
  • One could test the loop's reliability by feeding it multiple classical algorithms with known correct quantum analogues and checking that generated programs are functionally equivalent, not merely similar in accuracy.
  • If the generated code is verified and released, the approach becomes a reproducible benchmark for agentic quantum machine learning discovery; until then, the strongest available evidence is the figure snippets, not an executable artifact.
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 manuscript proposes an LLM-based multi-agent system, inspired by FunSearch, that takes a classical machine learning algorithm name, generates an initial quantum implementation, and then runs an iterative evolution loop with Theorist, Coder, and Validator roles to refine the implementation. As a proof of concept, it reports quantum versions of the multi-layer perceptron, the forward-forward algorithm, and backpropagation, with accuracy results in Table 1 compared against a human-crafted quantum neural network baseline. The paper concludes that the framework can serve as a 'for-loop' over classical ML concepts to produce quantum counterparts.

Significance. If substantiated, the framework would be a genuinely useful tool for automating the translation of classical ML algorithms into quantum implementations, and the choice of three well-known algorithms is a sensible starting point. The authors honestly acknowledge in Section 2.4 that training was not extensive and that the work is a proof of concept, which is a strength in framing. However, the paper is an extended abstract rather than a complete research report: there is no reproducible code, no execution logs, no search trajectories, and no statistical analysis. The only quantitative evidence is a four-row accuracy table with values near the random-chance floor for a 10-class task, so the central demonstration does not currently support the abstract's claim of iterative generation and refinement. The conceptual idea has potential, but the evidence presented is anecdotal and not yet at the standard of a research paper.

major comments (4)
  1. [Section 2, Figures 4a, 6, and 8] The central claim that the agentic loop generates runnable quantum implementations is unsupported because the displayed snippets are cropped, unlabeled, and not accompanied by the full source, tests, execution logs, or a repository link; without these, a reader cannot verify that the positive and negative passes in the quantum forward-forward implementation or the parameter-shift gradient in the quantum backpropagation implementation behave as described.
  2. [Table 1 and Section 2.4] The only quantitative evidence is a four-row accuracy table with no error bars, seeds, number of runs, hyperparameters, or statistical tests; since a 10-class random classifier attains 10% and every reported value (9.40% to 15.55%) is near that floor, the statement that QFF (15.17%) is 'similar' to the baseline QNN (15.55%) is not supported, and in fact the baseline itself is also near chance.
  3. [Section 2 and Figure 2] The abstract's claim that the system 'iteratively generates and refines' is not evidenced: no search trajectory, version history, validator feedback, or ablation is shown, so every displayed result is consistent with one-shot LLM generation followed by manual selection, and the evolution loop is asserted rather than demonstrated.
  4. [Section 2.4 and Figure 4b] The paper's own caveat that models were not trained with massive training steps, combined with the absence of a labeled convergence curve, means the statement that the quantum MLP is 'learning during the training steps' is not verifiable; a proof of concept needs at least one training curve with clearly labeled axes, loss values, and training configuration.
minor comments (4)
  1. [Title] The title contains a typo: 'For-L oop' should be 'For-Loop'.
  2. [Section 3, equation] The formalization A = sum_ij alpha_ij L_j and A(CML) = argmin_pi Q^pi_ML introduces symbols alpha_ij, L_j, and pi without definitions, and the equation is not connected to the experiments or to the agent architecture described earlier.
  3. [Figure 1 caption] The caption says 'adapted form Guo et al., 2024' and should be 'adapted from Guo et al., 2024', and several figure captions refer to 'snippets' that are too small or too cropped to read in the PDF.
  4. [Table 1] Table 1 should specify the dataset size, preprocessing steps, number of evaluation runs, and the exact evaluation protocol so that the reported accuracies can be interpreted.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper makes no formal derivation whose output reduces to fitted inputs; the agentic translation claim is empirical and unsupported, but unsupported is not circular.

full rationale

The paper's central claim is that an LLM-based multi-agent system can generate quantum implementations of classical ML algorithms (Section 2). This is an empirical pipeline claim, not a mathematical derivation: the generated code snippets and Table 1 accuracies are outputs of the system, not quantities defined in terms of the inputs. No equation of the paper sets the output equal to a fitted parameter or to a self-cited theorem. The only reference involving the author (Nakaji et al., 2024) appears in a general list of quantum architecture search related work and is not load-bearing. Section 2.4 explicitly concedes the models were not trained with massive steps and the reported accuracies are near random-chance levels; that is a weakness of evidence for the claim, not a circularity. Consequently, no circular step can be exhibited, and the appropriate finding is no significant circularity.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

The paper contains no theoretical derivation with fitted constants. The central claim rests instead on unverified capabilities of LLM agents, the asserted superiority of program-space search, and a table of near-random accuracies treated as proof of concept.

assumptions (3)
  • domain assumption LLM-based multi-agent systems can generate correct, runnable quantum code for arbitrary classical algorithms given only a name or snippet.
    The whole pipeline in Section 2 assumes the LLM outputs in Figures 4a, 6, and 8 are correct quantum implementations; no verification or tests are shown.
  • domain assumption The program-code search space yields more expressive architectures than parametrized quantum circuit search.
    Stated in Section 1 without evidence: 'search in program coding space allows agents to build more expressive resultant model architecture'.
  • ad hoc to paper Near-random accuracy on a 10-class digit task is sufficient evidence of a working proof of concept.
    Section 2.4 interprets Table 1 (baseline 15.55%, QFF 15.17%, etc.) as supporting the framework despite low absolute accuracy and no comparison above chance.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Advanced For-Loop for QML algorithm search." pith.science (2026). https://pith.science/paper/XZSG6TDT

@misc{pith2026250618260,
  author       = {Pith},
  title        = {Pith review of: Advanced For-Loop for QML algorithm search},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XZSG6TDT}},
  note         = {Machine review of arXiv:2506.18260}
}
read the original abstract

This paper introduces an advanced framework leveraging Large Language Model-based Multi-Agent Systems (LLMMA) for the automated search and optimization of Quantum Machine Learning (QML) algorithms. Inspired by Google DeepMind's FunSearch, the proposed system works on abstract level to iteratively generates and refines quantum transformations of classical machine learning algorithms (concepts), such as the Multi-Layer Perceptron, forward-forward and backpropagation algorithms. As a proof of concept, this work highlights the potential of agentic frameworks to systematically explore classical machine learning concepts and adapt them for quantum computing, paving the way for efficient and automated development of QML algorithms. Future directions include incorporating planning mechanisms and optimizing strategy in the search space for broader applications in quantum-enhanced machine learning.

Figures

Figures reproduced from arXiv: 2506.18260 by the authors.

Figure 1
Figure 1. The architecture of the LLM-based Multi-Agent systems for QML search with dynamic role updating. (Figure [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Flow chart of QML searching process. 2.1 Multi-Layer Perceptron Firstly, we did an experiment on classical multilayer perceptron as given input to the agentic system. For example, given specification of classical machine learning algorithm, which is Multi-Layer Perceptron (MLP) with the following sample snippet: 2 [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. A snippet of Python implementation of MLP [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (4 more)
Figure 5
Figure 5. Figure 5: Forward-Forward Algorithm The transformed quantum version of the forward-forward algorithm is shown in the following figure. Noticed the implementation of the positive and negative pass is quantized with quantum circuits [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]
Figure 6
Figure 6. Figure 6: A snippet of simplified Quantum Forward-Forward layer [PITH_FULL_IMAGE:figures/full_fig_p004_6.png]
Figure 7
Figure 7. Figure 7: Backpropagation Algorithm When specified with backpropagation algorithm, the agentic system would generate a quantum version of the back￾propagation algorithm, which is shown in [PITH_FULL_IMAGE:figures/full_fig_p005_7.png]
Figure 8
Figure 8. Figure 8: A snippet of the Quantum backpropagation with gradient [PITH_FULL_IMAGE:figures/full_fig_p005_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

21 extracted references · 2 canonical work pages

  1. [1]

    (2024, April 5).Large Language Models for Mathematical Reasoning: Progresses and Challenges

    Ahn, J., Verma, R., Lou, R., Liu, D., Zhang, R., & Yin, W. (2024, April 5).Large Language Models for Mathematical Reasoning: Progresses and Challenges. arXiv: 2402.00157 [cs]. https://doi.org/10.48550/arXiv.2402.00157 AI4Science, M. R., & Quantum, M. A. (2023, December 8). The Impact of Large Language Models on Scientific Discovery: A Preliminary Study us...

    arXiv doi:10.48550/arxiv.2402.00157 2024

  2. [2]

    (2024, June 18)

    Dong, Q., Li, L., Dai, D., Zheng, C., Ma, J., Li, R., Xia, H., Xu, J., Wu, Z., Chang, B., Sun, X., Li, L., & Sui, Z. (2024, June 18). A Survey on In-context Learning. arXiv: 2301.00234 [cs]. https://doi.org/10.48550/arXiv.2301. 00234

    arXiv doi:10.48550/arxiv.2301.00234 2024

  3. [3]

    Du, Y ., Huang, T., You, S., Hsieh, M.-H., & Tao, D. (2022). Quantum circuit architecture search for variational quantum algorithms. npj Quantum Information, 8(1), 1–8. https://doi.org/10.1038/s41534-022-00570-y

    doi:10.1038/s41534-022-00570-y 2022

  4. [4]

    V ., Wiest, O., & Zhang, X

    Guo, T., Chen, X., Wang, Y ., Chang, R., Pei, S., Chawla, N. V ., Wiest, O., & Zhang, X. (2024, April 19). Large Language Model based Multi-Agents: A Survey of Progress and Challenges . arXiv: 2402 . 01680 [cs]. https://doi.org/10.48550/arXiv.2402.01680

    arXiv doi:10.48550/arxiv.2402.01680 2024

  5. [5]

    (2022, December 26).The Forward-Forward Algorithm: Some Preliminary Investigations

    Hinton, G. (2022, December 26).The Forward-Forward Algorithm: Some Preliminary Investigations. arXiv: 2212.13345 [cs]. https://doi.org/10.48550/arXiv.2212.13345

    arXiv doi:10.48550/arxiv.2212.13345 2022

  6. [6]

    (2023, November 6)

    Ran, C., Xiao, L., Wu, C., & Schmidhuber, J. (2023, November 6). MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework. arXiv: 2308.00352 [cs]. https://doi.org/10.48550/arXiv.2308.00352

    arXiv doi:10.48550/arxiv.2308.00352 2023

  7. [7]

    T., Foerster, J., Clune, J., & Ha, D

    Lu, C., Lu, C., Lange, R. T., Foerster, J., Clune, J., & Ha, D. (2024, August 12). The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery. arXiv: 2408.06292 [cs]. https://doi.org/10.48550/arXiv.2408. 06292

    arXiv doi:10.48550/arxiv.2408.06292 2024

  8. [8]

    (2023, July 10)

    Mandi, Z., Jain, S., & Song, S. (2023, July 10). RoCo: Dialectic Multi-Robot Collaboration with Large Language Models. arXiv: 2307.04738 [cs]. https://doi.org/10.48550/arXiv.2307.04738

    arXiv doi:10.48550/arxiv.2307.04738 2023

Show all 21 references
  1. [9]

    B., Campos-Gonzalez-Angulo, J

    Nakaji, K., Kristensen, L. B., Campos-Gonzalez-Angulo, J. A., Vakili, M. G., Huang, H., Bagherimehrab, M., Gorgulla, C., Wong, F., McCaskey, A., Kim, J.-S., Nguyen, T., Rao, P., & Aspuru-Guzik, A. (2024, January 17).The generative quantum eigensolver (GQE) and its application ...

    2024 doi

  2. [10]

    (2024, June 5)

    Sun, M. (2024, June 5). ChatDev: Communicative Agents for Software Development. arXiv: 2307.07924 [cs]. https://doi.org/10.48550/arXiv.2307.07924

    2024 doi arXiv

  3. [11]

    D., & Finn, C

    Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C. D., & Finn, C. (2023, December 13). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. arXiv: 2305.18290 [cs]. https://doi.org/10. 48550/arXiv.2305.18290

    2023 doi arXiv

  4. [12]

    Wang, P., Fawzi, O., Kohli, P., & Fawzi, A. (2024). Mathematical discoveries from program search with large language models. Nature, 625(7995), 468–475. https://doi.org/10.1038/s41586-023-06924-6

    2024 doi

  5. [13]

    E., Hinton, G

    Rumelhart, D. E., Hinton, G. E., & Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533–536. https://doi.org/10.1038/323533a0

    1986 doi

  6. [14]

    L., McDougall, C., MacDiarmid, M., Freeman, C

    Templeton, A., Conerly, T., Marcus, J., Lindsey, J., Bricken, T., Chen, B., Pearce, A., Citro, C., Ameisen, E., Jones, A., Cunningham, H., Turner, N. L., McDougall, C., MacDiarmid, M., Freeman, C. D., Sumers, T. R., Rees, E., Batson, J., Jermyn, A., . . . Henighan, T. (2024). ...

    2024 doi arXiv

  7. [15]

    (2024, February 28).Rethinking the Bounds of LLM Reasoning: Are Multi-Agent Discussions the Key? (1)

    Wang, Q., Wang, Z., Su, Y ., Tong, H., & Song, Y . (2024, February 28).Rethinking the Bounds of LLM Reasoning: Are Multi-Agent Discussions the Key? (1). arXiv: 2402.18272 [cs]. https://doi.org/10.48550/arXiv.2402.18272

    2024 doi arXiv

  8. [16]

    Wu, W., Yan, G., Lu, X., Pan, K., & Yan, J. (2023). QuantumDARTS: Differentiable Quantum Architecture Search for Variational Quantum Algorithms. Proceedings of the 40th International Conference on Machine Learning, 37745–37764. Retrieved July 3, 2024, from https://proceedings....

    2023

  9. [17]

    (2024, February 16)

    Yan, S.-Q., Gu, J.-C., Zhu, Y ., & Ling, Z.-H. (2024, February 16). Corrective Retrieval Augmented Generation. arXiv: 2401.15884 [cs]. https://doi.org/10.48550/arXiv.2401.15884

    2024 doi arXiv

  10. [18]

    V ., Zhou, D., & Chen, X

    Yang, C., Wang, X., Lu, Y ., Liu, H., Le, Q. V ., Zhou, D., & Chen, X. (2024, April 15).Large Language Models as Optimizers. arXiv: 2309.03409 [cs]. https://doi.org/10.48550/arXiv.2309.03409

    2024 doi arXiv

  11. [19]

    L., Cao, Y ., & Narasimhan, K

    Yao, S., Yu, D., Zhao, J., Shafran, I., Griffiths, T. L., Cao, Y ., & Narasimhan, K. (2023, December 3).Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv: 2305.10601 [cs]. https://doi.org/10.48550/ arXiv.2305.10601 7 Advanced For-Loop for QML algor...

    2023 doi arXiv

  12. [20]

    B., Shu, T., & Gan, C

    Zhang, H., Du, W., Shan, J., Zhou, Q., Du, Y ., Tenenbaum, J. B., Shu, T., & Gan, C. (2024, February 17).Building Cooperative Embodied Agents Modularly with Large Language Models . arXiv: 2307.02485 [cs]. https: //doi.org/10.48550/arXiv.2307.02485

    2024 doi arXiv

  13. [21]

    R., Desai, N., Bae, J., Lorraine, J., & Ba, J

    Zhang, M. R., Desai, N., Bae, J., Lorraine, J., & Ba, J. (2023, December 7). Using Large Language Models for Hyperparameter Optimization. arXiv: 2312.04528 [cs]. https://doi.org/10.48550/arXiv.2312.04528 8

    2023 doi arXiv

Pith tools

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