Pith. sign in

REVIEW 5 major objections 5 minor 44 references

Discovering Algorithms with Computational Language Processing

T0 review · 5 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read The paper claims that treating algorithms as grammatically chained tokens lets a reinforcement-learning-guided search rediscover, improve, and invent algorithms that match or beat Gurobi on 389 of 390 hard instances, halve Grover's…

desk verdict A genuinely interesting framework for instance-adaptive algorithm discovery, but the headline QAP claims rest on weak baselines and missing variance, so the paper needs major revision and code/data release before its central claims carry weight. read the letter →

arxiv 2507.03190 v2 pith:GN7B33EF submitted 2025-07-03 cs.AI cs.DScs.LG

Theo Bourdais , Abeynaya Gnanasekaran , Houman Owhadi , Tuhin Sahai This is my paper · ORCID
classification cs.AIcs.DScs.LG MSC 90C2768Q1268T20
keywords algorithmdiscoverycomputationallanguageprocessingMonteCarlotreesearchreinforcementlearningquadraticassignmentproblemquantumapproximateoptimizationbyte-pairencoding
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 show that algorithm discovery can be automated by treating algorithms as sequences of elementary operations, or tokens, chained together under a grammar — in effect, sentences in a computational language. It claims that an ensemble Monte Carlo tree search guided by reinforcement learning, paired with a byte-pair-style step that merges frequent token sequences into new composite tokens, can explore this language well enough to rediscover classical heuristics (Frank–Wolfe, k-OPT), improve them with instance-specific adaptations (random restarts, a new cyclic step-size schedule), and generate novel circuits and solvers. On the Quadratic Assignment Problem, the discovered policies match or beat all tested baselines, including the commercial solver Gurobi, on 389 of 390 instances and solve 41% of QAPLIB benchmarks to optimality; for quantum search the framework finds a Grover circuit whose depth is reduced by $(\pi/2)\sqrt{N}-1$ layers, and for QAOA it beats ADAPT-QAOA by an average of 34.62% on MAX-CUT instances. The wider interest is that the approach abstracts away from code and from the specific problem, so the same machinery could in principle be pointed at any domain with a tokenizable operation set — the authors' own conclusion points toward systems engineering and mathematical discovery.

What carries the argument

The load-bearing machinery is the computational language itself. Its alphabet is a set of primitives — for the QAP, matrix-level operations (identity, gradient, negative, linear-sum assignment via the Hungarian method) plus special control-flow wrappers (k-iteration loops, residual updates, parallel random permutations, parallel 2-city swaps, and an early-stopping token), all constrained by a grammar that keeps special primitives acting on a single primitive at a time. The search engine is an ensemble variant of the AlphaZero-style MCTS in which tree edges are tokens, each node stores an ensemble of computational states, and lightweight transformer policy and value networks score sequences of actions; a computational-cost budget is fed into the search and into the networks. The vocabulary grows through Algorithmic Byte-Pair Encoding, which merges frequently co-occurring token pairs into single composite tokens, expanding 8 primitives into more than 100 tokens over successive rounds and thereby making higher-complexity algorithms such as Frank–Wolfe expressible. Alternating babbling (MCTS rollouts) with word-formation (BPE merges) is what lets the framework climb from elementary steps to full algorithms.

What would settle it

Run CLP on a held-out family of quadratic assignment instances with known optima that comes from neither the CQAP nor the PQAP generator, for example instances built from uniformly random flow and distance matrices, with Gurobi given the same wall-clock budget, and then inspect the learned token chains: if the optimality-gap advantage over Gurobi disappears on this distribution, or if removing the A-BPE-created composite tokens leaves performance unchanged, the claim that the framework generates genuinely new and generalizable algorithms rather than tuned recombinations of the supplied primitives would be settled against it.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that algorithm design can be reframed as search over a computational language, and that this reframing pays off across very different domains. An algorithm is a sentence: a grammatically valid chain of primitives — identity, gradient, negative, linear-sum assignment (Hungarian), and special control-flow wrappers such as loops, residual updates, parallel random permutations, parallel 2-city swaps, and early stopping. New words are formed by Algorithmic Byte-Pair Encoding, which merges frequently co-occurring token pairs into single composite tokens, growing the initial vocabulary of 8 primitives to more than 100 tokens and thereby making higher-complexity algorithms expressible. The search engine is an ensemble variant of the AlphaZero-style MCTS in which edges are tokens, nodes hold ensembles of computational states (Gibbs-averaged losses) to cope with stochastic actions, and lightweight transformer networks predict policy and value from the action history under an explicit compute budget. With this machinery the paper reports rediscovering Frank–Wolfe and k-OPT, learning random-restart strategies that push success rates above 90% on CQAP instances of size 40, discovering a cyclic step-size schedule that outperforms the scipy line-search baseline, and producing instance-adapted policies that reach global optima on all tested CQAP instances with $n \le 80$, stay within a 1% optimality gap on PQAP, match or beat every tested baseline on 389 of 390 instances, and solve 41% of QAPLIB instances to optimality. In the quantum domain it finds a Grover circuit, mathematically equivalent to the standard one up to a global phase, whose depth is reduced by $(\pi/2)\sqrt{N}-1$ layers (initializing in $|1\rangle^{\otimes n}$ and implementing the diffusion step as $H^{\otimes n}\,\mathrm{MCZ}\,H^{\otimes n}$, removing the per-iteration X gates), and QAOA mixer circuits that beat ADAPT-QAOA by an average 34.62% on unseen MAX-CUT instances.

Load-bearing premise

The load-bearing premise is that the hand-chosen primitive vocabulary and the grammar governing valid chains are expressive enough to contain a genuinely better algorithm, and that ensemble MCTS with a lightweight transformer can find it within the compute budget — the paper itself notes this trade-off when it restricts special primitives to act on a single primitive at a time, which leaves algorithms like Frank–Wolfe unexpressible until Byte-Pair expansion adds new tokens.

Editorial extensions

If this is right

  • Practitioners facing a strongly NP-hard problem could generate instance-adapted solvers on demand instead of hand-tuning heuristics; the paper reports quadratic scaling and roughly a 10,000-fold reduction in computational effort (in FLOPS) for size-100 QAP instances relative to tested baselines.
  • Any application that uses Grover's algorithm as a subroutine, including brute-force-resistance analyses in cryptography, would inherit a circuit with depth reduced by $(\pi/2)\sqrt{N}-1$ layers built from only H, X, and oracle gates, which the paper argues is easier to realize on hardware and exponentially more error-tolerant since noise scales with depth.
  • The automatic rediscovery of Frank–Wolfe and k-OPT from eight low-level primitives, together with the discovered cyclic step-size schedule that beats the scipy line-search baseline, suggests that composing and tuning known algorithmic building blocks is itself automatable and not limited to the QAP.
  • Because CLP operates at the computational level rather than the code level, its discovered token chains are platform-independent descriptions that downstream code generators could compile into running programs; the paper's conclusion points toward automated engineering-system design and agent-based real-time algorithm development.

Reading between the lines

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

  • A test the paper does not run is whether A-BPE tokens learned on QAP instances transfer to other problems; an editor would expect the high-level composite tokens to transfer while the instance-specific adaptations do not, and checking that would show where the genuine discovery actually happens.
  • The paper proves the discovered Grover circuit is the standard algorithm up to a global phase introduced by a different initial state, so the quantum result is best read as compressibility of a known strategy; a sharper novelty test, not in the paper, would be to run CLP on a quantum search task where no such symmetry exists.
  • The paper notes that the QAP specializes to the Traveling Salesman Problem and to graph matching, so a natural extension is to reuse the same grammar and tokens on those problems; success there without modification would strengthen the claim that this is a universal computational language.
  • The discovered cyclic step-size schedule echoes the cyclical learning-rate phenomenon in deep learning that the paper cites, which suggests CLP's token search could be pointed at optimizer and learning-rate schedule discovery for neural network training, with validation loss playing the role of the QAP objective.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

5 major / 5 minor

Summary. The manuscript introduces computational language processing (CLP), a framework in which algorithms are represented as token chains over a primitive vocabulary constrained by a grammar, and discovered by an ensemble variant of Monte Carlo tree search guided by reinforcement learning, with algorithmic byte-pair encoding used to grow the vocabulary. The authors report three application studies: the Quadratic Assignment Problem, quantum search (Grover), and QAOA. The reported highlights are optimal or near-optimal results on CQAP/PQAP instances, 41% optimality on a QAPLIB subset, a Grover circuit with roughly half the depth of the standard one, and an average 34.62% improvement over ADAPT-QAOA on 21 MAX-CUT graphs. The paper also shows that low-level primitives can be recombined to rediscover Frank-Wolfe and 2-OPT/TSP-style heuristics.

Significance. If the empirical claims are upheld, CLP would be a valuable contribution to automated algorithm discovery, particularly the combination of a token grammar, ensemble MCTS, and algorithmic BPE in a single framework, together with instance-adaptive policy generation. The paper ships detailed token decompositions and a supplementary table for QAPLIB comparisons, and the rediscovery of Frank-Wolfe and 2-OPT from elementary primitives is a concrete, checkable demonstration of the babbling-plus-BPE mechanism. I also note that the evaluation is not circular in the sense flagged by the reader: the QAP comparison is against external benchmarks with known optima, and the rediscovered algorithms are not used as predictions. The main weakness is that the strength of the reported evidence is not yet commensurate with the breadth and strength of the claims: the QAP baselines are weak and under-reported, one headline statement is contradicted by the paper's own supplementary table, and the quantum 'discovery' is a re-coordinatization of Grover's algorithm rather than a new algorithm.

major comments (5)
  1. [Main text, 'Results on the QAP'; Table S4] The statement that 'CLP outperforms all baselines—including commercial solvers such as Gurobi' is contradicted by Table S4. On chr25a, chr22a, chr20a, chr18a, chr15c, and tai64c, Gurobi reports a strictly smaller relative gap than CLP (e.g., tai64c: CLP 1.2% vs. Gurobi 0.4%; chr15c: CLP 4.6% vs. Gurobi 0.0%). The SI statement that 'Gurobi beats our method in only one test problem of size larger than 25' is also incorrect because tai64c has size 64. The aggregate phrase 'beats or equals' also counts ties (many rows show CLP and Gurobi both at 0.0), so the abstract's wording overstates the tables. The authors should replace aggregate win rates with per-instance win/tie/loss counts, reconcile the main text with Table S4, and temper the abstract accordingly.
  2. [SI §1.2.3 and Table S4] The comparison protocol is not strong enough to support 'substantially outperform existing methods' for the QAP. The baseline set is limited to simulated annealing, a simple branch-and-bound with the Gilmore-Lawler bound, and Gurobi on an MIQP formulation with runtime set equal to CLP; no state-of-the-art QAP heuristics (tabu search, iterated local search, hybrid genetic/GRASP, FANT) and no exact solvers with strong bounds are included. The SA baseline is described as run 'for many more iterations' (i.e., not resource-matched), while no seeds, per-instance run-to-run variance, hardware, solver parameters, or time limits are reported for any method. Because the central QAP claim is empirical, this is a load-bearing gap: the authors should add strong baselines under matched compute, report multiple seeds with standard deviations, and state the exact QAPLIB subset and success criterion used for the 41% and 94.8% figures.
  3. [SI §1.3 and §2.6] The quantum search result is a known equivalence rather than a newly generated algorithm. The SI analysis shows that the optimized circuit starts from |1>^⊗n and uses D' = H^⊗n(2|1><1|-I)H^⊗n, and that after each iteration the state differs from standard Grover only by a global phase (-1)^{|w|}. This is a valid circuit optimization, but it is a re-coordinatization of Grover's algorithm within the same gate set, not a new quantum search procedure. Moreover, SI §2.6 states that the method reduces 'the required number of qubits by a factor of two,' which is false—the circuit uses the same n qubits—and is inconsistent with the depth-reduction claim in the main text. The main text should either present this result as rediscovery/optimization of an existing algorithm (with correct metrics) or remove the 'new algorithms' language for this example.
  4. [SI §1.4 and Table S2] The QAOA result is reported without sufficient experimental detail to be verified. The 21 test graphs are not described (sizes, degree of the p-regular graphs, number of qubits), the maximum circuit depth and optimization protocol are not specified, and no variance or number of independent runs is given. The 'average improvement of 34.62%' is a point estimate over a single table with no confidence interval or statistical test. Since the abstract's claim of substantial improvement over 'foundational quantum computing approaches' rests in part on this result, the authors should provide the full protocol and error bars, or explicitly mark the result as preliminary.
  5. [SI §1.2.1] The grammar that defines valid token chains is never formally specified. The text describes constraints (e.g., special primitives operate on a single primitive, input/output type compatibility) and gives examples, but no production rules or type system are provided. Since the grammar is a core component of CLP and directly determines the expressivity of the search space, its absence makes the framework difficult to reproduce or extend. The authors should provide a formal grammar (or a precise algorithmic description of the type-checking step) in the supplementary material.
minor comments (5)
  1. [Main text, 'Computational Language Processing' section] The phrase 'serves as the the alphabet' contains a duplicated article; also correct 'independant' in SI §1.1 and 'Additionaly' in the main text.
  2. [Figure 4 and SI §1.2.1] The x-axis label 'Iterations' is ambiguous; it should state that one round of BPE occurs every 10 self-play iterations and clarify whether the success rate is computed over a fixed set of instances or over a distribution of instances.
  3. [SI §1.2.3] The sentence 'our achieves 1% optimality gap' is missing a word; more importantly, the exact time limits for Gurobi and branch-and-bound are not reported numerically, so the resource-matching claim cannot be checked.
  4. [Main text, 'Results on the QAP'; SI §2.6] The 'scaling quadratically' statement and the SI §2.6 estimates of '10,000-fold reduction in FLOPS' and 'thousand-fold quality improvement' are asserted without a derivation or a benchmark protocol; they should be removed or substantiated with profiling data.
  5. [General] The paper does not include a data/code availability statement. For an empirical algorithm-discovery claim, releasing the token vocabularies, trained checkpoints, and evaluation scripts would substantially strengthen verifiability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claims rest on external benchmarks and on equivalence proofs that do not assume their conclusions.

full rationale

The CLP paper's central claims are empirical and are evaluated against external benchmarks; I found no load-bearing circular step. The QAP results (389/390 instances, 41% QAPLIB optimality, 94.8% beats-or-equals) are compared with CQAP/PQAP instances having known optima and with QAPLIB best-known values; these are not quantities fitted inside the derivation, so no prediction reduces to an input by construction. The low-level rediscovery of Frank-Wolfe and k-OPT is a search outcome: the primitive vocabulary (gradient, LSA, FOR, residual update, 2SWAP) is admittedly expressive enough to contain these algorithms, but the paper does not define the discovered algorithm as its own input, and the same vocabulary permits many non-FW chains; the RL/MCTS exploration and held-out success rates provide independent empirical content. The Grover section is an equivalence analysis (SI 1.3) showing that the shortened circuit is the standard Grover iteration after a basis change (start in |1>, D'=H MCZ H); this is a mathematical identity proven from stated definitions rather than a derivation whose conclusion is assumed. At most this raises a novelty or overclaim concern (the optimized circuit is a re-coordinatization of a known construction), which is not circularity. Similarly, the SI 2.6 statement about reducing the required number of qubits by a factor of two is inconsistent with the depth-reduction result, but this is an internal consistency issue, not a circular one. Self-citations (refs 9, 10, 20, 43) are background context or definitions of relaxation primitives; none is invoked as a uniqueness theorem or as the sole justification of a central premise. Benchmarking limitations (weak baselines, missing seeds and variance, Gurobi MIQP time-limit details) are correctness and evidence concerns and are explicitly out of scope for the circularity pass.

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

The central claims rest primarily on empirical evaluations with hand-chosen hyperparameters (ensemble size, Gibbs temperature, BPE threshold, training rounds) rather than on a parameter-free derivation. The quantum circuit result is a re-coordinatization of Grover's algorithm, which is a basis change rather than a new physical entity. No new particles, forces, or dimensions are introduced.

free parameters (5)
  • MCTS ensemble size = 5 to 10
    Number of candidate solutions maintained per node to handle stochasticity; set by hand in Sec 1.1, affects value estimates and search quality.
  • Gibbs sampling inverse temperature beta
    Used in the Boltzmann average of losses at each node (Sec 1.1); value not reported, influences node quality estimates.
  • A-BPE merge frequency threshold = 10 occurrences
    Pairs are merged only if they appear at least 10 times in the corpus (Sec 1.2.1); controls vocabulary growth and is chosen by hand.
  • Self-play iterations per babbling round = 10 iterations, 3 rounds
    Babbling runs 10 iterations of self-play per round, with A-BPE rounds on problem sizes 15 and 40 (Sec 1.2.1); impacts search depth and discovery time.
  • Learning rate discretization in step-size experiment = 20 equidistant values on [0,1]
    The step-size optimization (Sec 1.2.2) defines 20 discrete tokens; the discovered cyclic schedule is a fitted output, but the discretization constrains the result.
assumptions (5)
  • standard math QAP objective and gradient as defined in Eq. (1) with real-valued matrices D, F, C.
    Basis for all QAP loss computations; standard formulation.
  • ad hoc to paper The grammar restricts special primitives to operate on a single primitive at a time.
    Stated in Sec 1.2.1 as a trade-off to manage expressivity; this restriction bounds the algorithm space and is a design choice that could exclude efficient algorithms requiring nested special primitives.
  • ad hoc to paper Reward shaping in quantum search assigns partial credit and balances positive/negative samples during training.
    Sec 1.3: failures receive v = -1 + (#targets achieved)/N and batches are balanced to approximately 50% positive samples; these choices bias the search toward shorter circuits and are not derived from first principles.
  • domain assumption No-free-lunch theorem motivates instance-adaptive algorithm search.
    Invoked in the introduction to justify instance-specific algorithms; accepted as a theorem.
  • domain assumption The transformer policy/value network can generalize across problem sizes.
    Required for the claim that tokens are size-independent and that the learned policy transfers to unseen QAPLIB instances; not proven, only empirically asserted.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Discovering Algorithms with Computational Language Processing." pith.science (2026). https://pith.science/paper/GN7B33EF

@misc{pith2026250703190,
  author       = {Pith},
  title        = {Pith review of: Discovering Algorithms with Computational Language Processing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/GN7B33EF}},
  note         = {Machine review of arXiv:2507.03190}
}
read the original abstract

Algorithms are the engine for reproducible problem-solving. We present a framework automating algorithm discovery by conceptualizing them as sequences of operations, represented as tokens. These computational tokens are chained using a grammar, enabling the formation of increasingly sophisticated procedures. Our ensemble Monte Carlo tree search (MCTS) guided by reinforcement learning (RL) explores token chaining and drives the creation of new tokens. This methodology rediscovers, improves, and generates new algorithms that substantially outperform existing methods for strongly NP-hard combinatorial optimization problems and foundational quantum computing approaches such as Grover's and Quantum Approximate Optimization Algorithm. Operating at the computational rather than code-generation level, our framework produces algorithms that can be tailored specifically to problem instances, not merely classes.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

44 extracted references · 36 canonical work pages

  1. [1]

    Owhadi, C

    H. Owhadi, C. Scovel, Operator Adapted Wavelets, Fast Solvers, and Numerical Homoge- nization, from a game theoretic approach to numerical approximation and algorithm design , Cambridge Monographs on Applied and Computational Mathematics (Cambridge University Press) (2019)

    work page 2019

  2. [2]

    Fawzi, et al., Discovering faster matrix multiplication algorithms with reinforcement learn- ing

    A. Fawzi, et al., Discovering faster matrix multiplication algorithms with reinforcement learn- ing. Nature 610 (7930), 47–53 (2022)

    work page 2022

  3. [3]

    Novikov, et al., AlphaEvolve: A coding agent for scientific and algorithmic discovery.arXiv preprint arXiv:2506.13131 (2025), white paper

    A. Novikov, et al., AlphaEvolve: A coding agent for scientific and algorithmic discovery.arXiv preprint arXiv:2506.13131 (2025), white paper

    arXiv 2025

  4. [4]

    Lehman, et al

    J. Lehman, et al. , Evolution through large models, in Handbook of evolutionary machine learning (Springer), pp. 331–366 (2023)

    work page 2023

  5. [5]

    Romera-Paredes, et al., Mathematical discoveries from program search with large language models

    B. Romera-Paredes, et al., Mathematical discoveries from program search with large language models. Nature 625 (7995), 468–475 (2024)

    work page 2024

  6. [6]

    Liu, et al., Evolution of heuristics: Towards efficient automatic algorithm design using large language model

    F. Liu, et al., Evolution of heuristics: Towards efficient automatic algorithm design using large language model. arXiv preprint arXiv:2401.02051 (2024)

    arXiv 2024

  7. [7]

    D. H. Wolpert, W. G. Macready, No free lunch theorems for optimization. IEEE transactions on evolutionary computation 1 (1), 67–82 (1997)

    work page 1997

  8. [8]

    T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein, Introduction to Algorithms (MIT Press), 3rd ed. (2009)

    work page 2009

Show all 44 references
  1. [9]

    Owhadi, Computational graph completion

    H. Owhadi, Computational graph completion. Research in the Mathematical Sciences 9 (2), 1–33 (2022)

    2022

  2. [10]

    T. Bourdais, et al., Codiscovering graphical structure and functional relationships within data: A Gaussian Process framework for connecting the dots.Proceedings of the National Academy of Sciences 121 (32), e2403449121 (2024). 13

    2024

  3. [11]

    Guizzo, Closing In On The Perfect Code

    E. Guizzo, Closing In On The Perfect Code. IEEE Spectrum 41 (3), 36–42 (2004), feature on turbo codes

    2004

  4. [12]

    Gage, A new algorithm for data compression

    P. Gage, A new algorithm for data compression. The C Users Journal 12 (2), 23–38 (1994)

    1994

  5. [13]

    C. B. Browne, et al., A survey of Monte Carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in games 4 (1), 1–43 (2012)

    2012

  6. [14]

    Silver, et al., Mastering the game of Go without human knowledge

    D. Silver, et al., Mastering the game of Go without human knowledge. Nature 550 (7676), 354–359 (2017)

    2017

  7. [15]

    Silver, et al., A general reinforcement learning algorithm that masters Chess, Shogi, and Go through self-play

    D. Silver, et al., A general reinforcement learning algorithm that masters Chess, Shogi, and Go through self-play. Science 362 (6419), 1140–1144 (2018)

    2018

  8. [16]

    Schrittwieser, et al., Mastering Atari, Go, Chess and Shogi by planning with a learned model

    J. Schrittwieser, et al., Mastering Atari, Go, Chess and Shogi by planning with a learned model. Nature 588 (7839), 604–609 (2020)

    2020

  9. [17]

    Korbak, E

    T. Korbak, E. Perez, C. L. Buckley, RL with KL penalties is better viewed as Bayesian inference. arXiv preprint arXiv:2205.11275 (2022)

    2022 arXiv

  10. [18]

    Vassoyan, N

    J. Vassoyan, N. Beau, R. Plaud, Ignore the KL Penalty! Boosting Exploration on Critical Tokens to Enhance RL Fine-Tuning.arXiv preprint arXiv:2502.06533 (2025)

    2025 arXiv

  11. [19]

    R. E. Burkard, S. E. Karisch, F. Rendl, QAPLIB–a quadratic assignment problem library. Journal of Global optimization 10, 391–403 (1997)

    1997

  12. [20]

    Sahai, A

    T. Sahai, A. Ziessler, S. Klus, M. Dellnitz, Continuous relaxations for the traveling salesman problem. Nonlinear Dynamics 97, 2003–2022 (2019)

    2019

  13. [21]

    H. W. Kuhn, The Hungarian method for the assignment problem. Naval research logistics quarterly 2 (1-2), 83–97 (1955)

    1955

  14. [22]

    Munkres, Algorithms for the assignment and transportation problems

    J. Munkres, Algorithms for the assignment and transportation problems. Journal of the Society for Industrial and Applied Mathematics 5 (1), 32–38 (1957)

    1957

  15. [23]

    M. M. Drugan, Generating QAP instances with known optimum solution and additively de- composable cost function. Journal of Combinatorial Optimization 30, 1138–1172 (2015). 14

    2015

  16. [24]

    Palubeckis, An algorithm for construction of test cases for the quadratic assignment problem

    G. Palubeckis, An algorithm for construction of test cases for the quadratic assignment problem. Informatica 11 (3), 281–296 (2000)

    2000

  17. [25]

    J. T. Vogelstein, et al., Fast approximate quadratic programming for graph matching. PLOS one 10 (4), e0121002 (2015)

    2015

  18. [26]

    L. K. Grover, A fast quantum mechanical algorithm for database search, in Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing (1996), pp. 212–219, doi:10.1145/237814.237866

    1996

  19. [27]

    Farhi, J

    E. Farhi, J. Goldstone, S. Gutmann, A Quantum Approximate Optimization Algorithm. arXiv preprint arXiv:1411.4028 (2014)

    2014 arXiv

  20. [28]

    Zhu, et al., Adaptive quantum approximate optimization algorithm for solving combinatorial problems on a quantum computer

    L. Zhu, et al., Adaptive quantum approximate optimization algorithm for solving combinatorial problems on a quantum computer. Physical Review Research 4 (3), 033029 (2022)

    2022

  21. [29]

    L. N. Smith, Cyclical learning rates for training neural networks, in 2017 IEEE winter confer- ence on applications of computer vision (WACV) (IEEE) (2017), pp. 464–472

    2017

  22. [30]

    T. Peng, W. Huanchen, Z. Dongme, Simulated annealing for the quadratic assignment problem: A further study. Computers & industrial engineering 31 (3-4), 925–928 (1996)

    1996

  23. [31]

    R. E. Burkard, S. E. Karisch, F. Rendl, QAPLIB – A Quadratic Assignment Problem Library (1997), https://qaplib.mgi.polymtl.ca/

    1997

  24. [32]

    P. E. Farrell, C. H. Beentjes, ´A. Birkisson, The computation of disconnected bifurcation diagrams. arXiv preprint arXiv:1603.00809 (2016)

    2016 arXiv

  25. [33]

    Gilliam, M

    A. Gilliam, M. Pistoia, C. Gonciulea, Optimizing quantum search using a generalized version of Grover’s algorithm. arXiv preprint arXiv:2005.06468 (2020)

    2020 arXiv

  26. [34]

    Wu, et al., Circuit optimization of Grover quantum search algorithm.Quantum Information Processing 22 (1), 69 (2023)

    X. Wu, et al., Circuit optimization of Grover quantum search algorithm.Quantum Information Processing 22 (1), 69 (2023)

    2023

  27. [35]

    Zhang, V

    K. Zhang, V. E. Korepin, Depth optimization of quantum search algorithms beyond Grover’s algorithm. Physical Review A 101 (3), 032346 (2020). 15

    2020

  28. [36]

    Piron, M

    R. Piron, M. I. Habibie, C. Goursaud, Mixed Grover: A Hybrid Version to Improve Grover’s Algorithm for Unstructured Database Search. IEEE Transactions on Quantum Engineering (2025)

    2025

  29. [37]

    T. C. Koopmans, M. Beckmann, Assignment problems and the location of economic activities. Econometrica: journal of the Econometric Society pp. 53–76 (1957)

    1957

  30. [38]

    E. M. Loiola, N. M. M. De Abreu, P. O. Boaventura-Netto, P. Hahn, T. Querido, A survey for the quadratic assignment problem.European journal of operational research176 (2), 657–690 (2007)

    2007

  31. [39]

    M. R. Garey, D. S. Johnson, Computers and Intractability: A Guide to the Theory of NP- Completeness (W.H. Freeman, San Francisco) (1979), https://dl.acm.org/doi/book/ 10.5555/578533

    1979 doi

  32. [40]

    D. L. Applegate, The traveling salesman problem: a computational study , vol. 17 (Princeton university press) (2006)

    2006

  33. [41]

    L. Livi, A. Rizzi, The graph matching problem.Pattern Analysis and Applications16, 253–283 (2013)

    2013

  34. [42]

    W. J. Cook, W. H. Cunningham, W. R. Pulleyblank, A. Schrijver,Combinatorial Optimization (John Wiley & Sons) (1998)

    1998

  35. [43]

    explore disruptive capabilities in computer-aided algorithm discovery via optimization

    T. Sahai, Dynamical systems theory and algorithms for NP-hard problems.Advances in Dynam- ics, Optimization and Computation: A volume dedicated to Michael Dellnitz on the occasion of his 60th birthday pp. 183–206 (2020). Acknowledgments The authors thank Prof. Yannis Kevrekidi...

    2020

  36. [44]

    hardest of the NP-hard problems

    After one round of babbling, the majority of rollouts end with a 2-city swap and identity, i.e. the best flip (denoted 2FLIP, defined as 2 𝑆𝑊𝐴𝑃◦𝐼𝐷 ). After one round of A-BPE concatenates 2FLIP into a single token, the composition of 2FLIP with a for loop becomes feasible, the...

Pith tools

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