Pith. sign in

REVIEW 4 major objections 6 minor 48 references

PACE: Primitive-Aware Code Evolution for Automated Algorithm Design

T0 review · 4 major / 6 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 PACE treats reusable code components as persistent units, so useful local logic survives discarded algorithms and component-level transfer beats whole-program LLM evolution under the same evaluation budget.

desk verdict PACE is a well-specified and well-documented AAD method; the Thompson sampling credit assignment is more confounded than the paper claims, but the empirical evidence is strong enough to deserve peer review. read the letter →

arxiv 2608.07395 v1 pith:BMTX6LAW submitted 2026-08-07 cs.SE cs.AI

Zhuoliang Xie , Ruihao Zheng , Xiang Xu , Genghui Li , Zhengkun Wang This is my paper · ORCID
classification cs.SEcs.AI
keywords LLM-basedautomatedalgorithmdesignexecutablealgorithmicprimitivescodeevolutionThompsonsamplingprogramsearchgeneticprogrammingheuristiccreditassignment
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

This paper argues that LLM-based automated algorithm design fails when it evolves algorithms as indivisible programs: useful local logic is discarded with its host, and the same snippets must be rediscovered. To fix this, the authors propose PACE, which extracts callable functions called Executable Algorithmic Primitives (EAPs), keeps them in a persistent library, and transfers them across algorithm generations. Four primitive-aware operators constrain how an LLM may insert, replace, refine, or recombine EAPs, and Thompson sampling decides which EAP to expose based on whether the child beat its parent. On continuous control and TSP tasks, PACE finds competitive or better algorithms than whole-program baselines under the same 1,000-evaluation budget, in some cases with large zero-shot gains when the evolved program is applied to larger problem instances. The sympathetic reader takes away that modular persistence, not just prompt engineering, can carry algorithmic search.

What carries the argument

The central object is the Executable Algorithmic Primitive (EAP), a callable function whose implementation stays fixed while it moves between host programs. The machinery that carries the argument has three parts: the persistent EAP set with its retention invariant, four primitive-aware variation operators whose call-set contracts are verified by an AST checker before evaluation, and a Thompson-sampling bandit over EAPs whose posterior is updated by the parent-relative binary reward. Together they turn a whole-program evolutionary loop into a two-level search: complete algorithms are still evaluated by the task evaluator, but the components that survive are chosen by accumulated transfer evidence rather than by the fate of their host program.

What would settle it

Take a control task engineered so that two subroutines are useless alone and highly effective together, such as one subroutine that normalizes a sensor stream that only the other subroutine consumes, and run PACE under a fixed budget against whole-program evolution; if the Thompson posterior promotes individually weak components and the final algorithm is no better than whole-program search, the central persistence claim fails.

Watch

Extended reading notes

Core claim

PACE's central claim is that the unit of evolution in LLM-based algorithm design should be a persistent Executable Algorithmic Primitive, not the complete program. An EAP is a callable function with a fixed implementation and a stable identity; once admitted to the EAP set it is never removed ($e \in E_t$ implies $e \in E_{t+1}$), so it can be called by algorithms generated after its source program is gone. The paper operationalizes this with four structural contracts: insertion adds one focus EAP while preserving all exposed parent EAPs, replacement swaps the weakest EAP for a Thompson-sampled one, refinement rewires the host around a fixed EAP set, and crossover recombines the union of two parents' EAP sets. Each insertion or replacement trial is scored as a binary parent-relative improvement, which updates a Beta posterior for the EAP's transferability; this is what lets PACE credit individual components without any extra evaluation data. The reported results support the claim that this persistence-plus-selection mechanism discovers competitive algorithms on Racing Car, Bipedal Walker, TSP-Construct, and TSP-ACO.

Load-bearing premise

The method assumes that a primitive's value can be judged from isolated transfer trials—that a code component either helps or hurts on its own—whereas in strongly coupled algorithms a primitive may only pay off in the presence of a specific host.

Editorial extensions

If this is right

  • Because EAPs persist by construction, useful code is no longer lost when a low-scoring program is removed, so the search budget is not spent rediscovering the same local logic.
  • The parent-relative reward turns each transfer into a free credit-assignment experiment, so EAP selection improves without any auxiliary validation set or extra evaluation calls.
  • The structural contracts, enforced by an AST verifier, mean that an LLM's failure to actually call the designated EAPs cannot corrupt the Thompson-sampling posterior.
  • Under a fixed budget of 1,000 evaluations, PACE matches or outperforms whole-program LLM-based automated algorithm design baselines on four tasks and generalizes zero-shot to larger TSP instances.
  • Because EAP discovery is decoupled from host generation, upgrading the LLM used only for EAP discovery (about 1.6% of tokens) yields disproportionate performance gains.

Reading between the lines

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

  • If PACE's claim holds, the same two-level structure could transfer to other LLM program-search settings where local logic matters, such as code optimization, symbolic regression, or theorem-proving tactic selection, wherever a component can be given a stable function signature.
  • The independence assumption suggests a stress test: on a task engineered so that two primitives only pay off when called together, the parent-relative reward should misassign credit, and adding pairwise coupling terms to the reward would be the natural fix.
  • EAPs are named functions with textual descriptions, so the library itself is interpretable; one could inspect which EAPs accumulate high posterior means and treat them as discovered design patterns for the task, or seed them into a fresh search.
  • Parent-relative reward favors EAPs that improve a randomly selected parent, so an EAP with high mean gain on weak parents may be preferred over one with moderate gain on strong parents; a quality-normalized reward would be a testable variant.
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 / 6 minor

Summary. The paper proposes PACE, a component-level evolutionary framework for LLM-based automated algorithm design. PACE decouples local algorithmic logic from complete programs by maintaining a persistent library of Executable Algorithmic Primitives (EAPs), each a callable function with a fixed implementation. Four primitive-aware operators (insert, replace, refine, crossover) constrain EAP call sets in generated offspring, and an AST verifier enforces these contracts while allowing structurally invalid offspring to be repaired. EAP selection is guided by Thompson sampling over Beta posteriors updated by parent-relative binary rewards (Eqs. 6-8). The paper reports experiments on Racing Car, Bipedal Walker, TSP-Construct, and TSP-ACO, with ablations on the selection mechanism, operators, EAP discovery modules, the parameter k, and the LLM backbone.

Significance. If the central claims hold, PACE addresses a real limitation of whole-program evolution: reusable local logic is lost when a host program is discarded. The formal state definitions (Eqs. 1-5) and operator contracts (Eqs. 10-13) are internally consistent, and the AST-verifier-based rejection of structurally invalid offspring is a concrete engineering safeguard. The paper also reports k-sensitivity and token consumption, and its reward signal comes from external evaluators rather than from fitting the test data, so there is no circularity. The main risk is that the credit-assignment mechanism--the load-bearing part that supposedly identifies which components are valuable--has not been shown to measure what it claims, and the empirical comparisons lack inferential support.

major comments (4)
  1. [Related Work / Primitive-Aware Operators, Eqs. (6)-(8), (10)-(11)] The parent-relative reward r_e = I[J(A')>J(A)] does not isolate the injected EAP's causal contribution. P1 permits the LLM to reorganize, refine, and adapt all non-EAP code (Eq. 10), and P2 simultaneously removes a target EAP e^- while injecting e^+ (Eq. 11), so a successful trial can be caused by the deletion of e^- or by unrelated LLM edits rather than by e^+. The AST verifier checks only call-set membership, not code equivalence outside those calls. The Related Work claim that PACE 'isolate[s] an EAP's causal impact from host program noise' is therefore unsupported. I request either a revised claim or a controlled test: log non-EAP code changes per trial and re-estimate the posterior conditioned on trials where non-EAP code is unchanged, or run an ablation in which P1/P2 forbid non-EAP edits.
  2. [Adaptive EAP Selection, Eqs. (7)-(9)] Equation (7) defines ρ_e as a fixed Bernoulli success rate, but the conditioning event is incomplete: the probability depends on the specific parent A and on the unconstrained LLM modifications. Because the parent population's baseline quality rises over time, P[J(A')>J(A)] for a fixed EAP is non-stationary, so the Beta-Bernoulli update in Eq. (8) treats observations that are not i.i.d. draws from a common rate. The Thompson sampling draw in Eq. (9) then responds to a posterior that can drift for reasons unrelated to the EAP's transferable value. Reporting time-binned success rates per EAP or using a drift-aware model would make the selection mechanism's validity testable.
  3. [Tables 1-3 and Figure 3] Test scores and out-of-domain results are reported as point estimates without error bars, confidence intervals, or significance tests. Several headline advantages are within one standard deviation of a baseline (Racing Car: PACE 92.40±7.69 vs HSEvo 84.17±5.57; Bipedal Walker: PACE 67.06±72.63; TSP-ACO in-domain: PACE 5.795 vs ReEvo 5.774), and the TSP tables have no variance information at all. The conclusion that PACE 'effectively discovers competitive algorithms' needs per-run test scores and a paired comparison across the three runs (e.g., Wilcoxon signed-rank or bootstrap) before it is supported.
  4. [Limitation and future work] The stated limitation--that primitives may not be independently evaluable under strong coupling--is narrower than the actual confound. Even with additively independent EAPs, Eq. (6) assigns credit to e^+ whenever the whole child improves, including improvements caused by arbitrary LLM edits in P1 or by the deletion in P2. Because the ablation in Table 4 shows that removing Thompson sampling causes a severe drop, the empirical case depends on the posterior being informative; a biased posterior could mean PACE succeeds despite, rather than because of, its credit-assignment mechanism. The authors should address this by showing that the learned posterior correlates with out-of-sample EAP transfer success, for example by holding out a subset of EAPs and comparing Thompson-selected vs randomly selected transfers.
minor comments (6)
  1. [Experimental Setup / Table 8] The statement that 'the only parameter k=3' is an overstatement: Table 8 lists population size, operator-selection probabilities, the one-proposal-per-generation rule, and the three repair attempts as fixed settings; a sentence acknowledging these as fixed defaults would be more accurate.
  2. [Table 4] The text says the w/o EAP Generation difference of 0.009 'falls within natural noise' yet concludes 'confirms the overall necessity'; this should be rephrased to avoid claiming confirmation from a within-noise difference.
  3. [Figure 3] Figure 3 axis labels and some table formatting are corrupted in the manuscript PDF (e.g., 'NumberofEvaluations'); please ensure the camera-ready version renders them correctly.
  4. [Eq. (7)] Equation (7) conditions on e∈C(A') but not on the parent A; since the reward is parent-relative, the notation (or an accompanying sentence) should make it explicit that ρ_e is averaged over the parent distribution.
  5. [Algorithm 1 / Token Usage] Table 11 compares token consumption, but the budget definition in Algorithm 1 counts 'complete-program evaluations'; clarify whether the 1,000-evaluation budget includes the three repair attempts per offspring and whether the EAP discovery LLM calls are charged to any comparable budget for baselines.
  6. [Figure 1 caption and Detailed Methodology] Figure 1 caption 'abstains a better score' should be 'attains a better score'; also 'summary ara shown' in Detailed Methodology should be 'summaries are shown'.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: PACE's transfer utility is measured on external evaluators, and the only overlapping-author citation is a non-load-bearing baseline.

full rationale

PACE's central claim, that Thompson-sampled EAP transfer preserves and reuses valuable algorithmic components, is evaluated empirically against external Gym and TSP evaluators; no equation reduces a fitted parameter to a predicted outcome. The only tunable parameter, k=3, is fixed and its sensitivity is reported in Table 4 (k=1 and k=5 comparisons). EAP utility estimates come from online parent-relative rewards (Eqs. 6-8) on evaluated offspring, not from fitting the test data or from a self-referential score. The EAP persistence invariant (Eq. 5) and the call-set contracts (Eqs. 10-13) are design mechanisms, not empirical predictions: they guarantee call-set membership by construction, and the paper presents them as mechanisms rather than as derived results. The Limitation section explicitly concedes that PACE 'assumes that primitives can be evaluated and selected independently'; this is a correctness caveat about credit assignment under strong coupling, not a circular derivation, because the parent-relative reward could be confounded by unconstrained LLM edits or by P2's removal of a target EAP, but such confounding is an empirical validity risk rather than an equivalence between the input and the output. The only overlapping-author citation is MCTS-AHD (Zheng, Xie, Wang, and Hooi 2025), used as a baseline under the same 1000-evaluation budget; it is not load-bearing support for PACE's mechanism. Therefore the derivation chain is self-contained and no circularity is present.

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

All free parameters, axioms, and invented entities the central claim rests on: one hand-chosen capacity parameter k, four domain assumptions including the author-flagged independence assumption, and the EAP entity itself. The math used is standard Beta-Bernoulli Thompson sampling, not a derivation; there are no fitted constants beyond k, and no additional physical or algorithmic entities beyond EAPs.

free parameters (1)
  • k (maximum EAPs per algorithm and structural generation attempts) = 3
    Hand-chosen capacity bound, varied in the sensitivity experiment (Table 4: k=1 and k=5 both degrade performance).
assumptions (4)
  • domain assumption Parent-relative improvement (Eq. 6, J(A') > J(A)) is a valid estimator of an EAP's transferable utility.
    Invoked in 'Adaptive EAP Selection'. The paper's own Limitation section says that in strongly coupled algorithms, evaluating primitives separately may miss joint interactions, which directly threatens this axiom.
  • domain assumption LLMs can produce offspring that satisfy the operator call-set contracts after at most 3 repair attempts.
    Invoked in Algorithm 1 lines 10-16 and prompts P1 through P4. If compliance is low, invalid trials are discarded and EAP posterior updates become sparse.
  • domain assumption The evaluator J provides a reliable scalar score for each program under the fixed-seed protocol.
    Used throughout the experiments; test scores are reported from a single run of the training-best program, so evaluator noise is not quantified.
  • standard math The Beta-Bernoulli conjugate model with Beta(1,1) prior is the appropriate posterior for EAP success rates.
    Eqs. 7-9; Thompson sampling convergence relies on this Bayesian model, a standard choice.
invented entities (1)
  • Executable Algorithmic Primitive (EAP)
    purpose: A callable function retained independently of host programs, enabling cross-program transfer of local algorithmic logic.
    EAP is a software construct defined by the paper (Eqs. 1-2); its value is demonstrated only by the paper's own experiments, not by an external falsifiable prediction.

how reviews work

0 comments
Cite this review

Pith. "Pith review of PACE: Primitive-Aware Code Evolution for Automated Algorithm Design." pith.science (2026). https://pith.science/paper/BMTX6LAW

@misc{pith2026260807395,
  author       = {Pith},
  title        = {Pith review of: PACE: Primitive-Aware Code Evolution for Automated Algorithm Design},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BMTX6LAW}},
  note         = {Machine review of arXiv:2608.07395}
}
read the original abstract

Large Language Model (LLM)-based automated algorithm design typically evolves algorithms as complete, indivisible programs. While this whole-program perspective simplifies the search space, it fundamentally couples the useful local logic to its host program. Consequently, valuable code snippets vanish when the overall program is discarded, making it highly difficult to assess the contribution of individual algorithmic components.To address this, we propose Primitive-Aware Code Evolution (PACE), which decouples local logic from complete programs by representing it as persistent units called Executable Algorithmic Primitives (EAPs). To enable code-level transfer, PACE maintains a dynamic set of EAPs. Algorithm evolution is driven by primitive-aware operators that structurally guarantee the retention and cross-program transfer of these components. To evaluate them effectively, PACE leverages Thompson sampling based on parent-relative performance improvements, guiding primitive selection from the set without requiring extra evaluation datasets. Experiments on four tasks demonstrate that PACE effectively discovers competitive algorithms while structurally preserving valuable algorithmic components.

Figures

Figures reproduced from arXiv: 2608.07395 by the authors.

Figure 1
Figure 1. (a) Existing AAD methods evaluate whole algo [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Overview of PACE. Complete algorithms follow an evolutionary loop of parent selection, generation, evaluation, [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Convergence curves on three diverse tasks. [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Figure4. The target function receives an RGB observation, [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]
Figure 6
Figure 6. Figure 6: The visualization of task Bipedal Walker. [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

48 extracted references · 20 canonical work pages

  1. [1]

    Nature , volume=

    Mathematical discoveries from program search with large language models , author=. Nature , volume=. 2024 , publisher=

    2024

  2. [2]

    Proceedings of the 41st International Conference on Machine Learning , pages=

    Evolution of heuristics: towards efficient automatic algorithm design using large language model , author=. Proceedings of the 41st International Conference on Machine Learning , pages=

    work page

  3. [3]

    arXiv preprint arXiv:2311.15249 , year=

    Algorithm evolution using large language model , author=. arXiv preprint arXiv:2311.15249 , year=

    arXiv

  4. [4]

    Proceedings of the 38th International Conference on Neural Information Processing Systems , pages=

    ReEvo: large language models as hyper-heuristics with reflective evolution , author=. Proceedings of the 38th International Conference on Neural Information Processing Systems , pages=

    work page

  5. [5]

    2025 , booktitle=

    Monte Carlo Tree Search for Comprehensive Exploration in LLM-Based Automatic Heuristic Design , author=. 2025 , booktitle=

    work page 2025

  6. [6]

    arXiv preprint arXiv:2412.17287 , year=

    Llm4ad: A platform for algorithm design with large language model , author=. arXiv preprint arXiv:2412.17287 , year=

    arXiv

  7. [7]

    ACM Computing Surveys , volume=

    A systematic survey on large language models for algorithm design , author=. ACM Computing Surveys , volume=. 2026 , publisher=

    work page 2026

  8. [8]

    International Conference on Parallel Problem Solving from Nature , pages=

    Understanding the importance of evolutionary search in automated heuristic design with large language models , author=. International Conference on Parallel Problem Solving from Nature , pages=. 2024 , organization=

    work page 2024

Show all 48 references
  1. [9]

    arXiv preprint arXiv:2504.19636 , year=

    Fitness landscape of large language model-assisted automated algorithm search , author=. arXiv preprint arXiv:2504.19636 , year=

    arXiv

  2. [10]

    Proceedings of the AAAI Conference on Artificial Intelligence , number=

    Eoh-s: Evolution of heuristic set using llms for automated heuristic design , author=. Proceedings of the AAAI Conference on Artificial Intelligence , number=

  3. [11]

    arXiv preprint arXiv:2507.10614 , year=

    Fine-tuning large language model for automated algorithm design , author=. arXiv preprint arXiv:2507.10614 , year=

    arXiv

  4. [12]

    arXiv preprint arXiv:2506.13131 , year=

    Alphaevolve: A coding agent for scientific and algorithmic discovery , author=. arXiv preprint arXiv:2506.13131 , year=

    arXiv

  5. [13]

    International Conference on Learning Representations , volume=

    Llm-sr: Scientific equation discovery via programming with large language models , author=. International Conference on Learning Representations , volume=

  6. [14]

    International conference on learning Representations , volume=

    Eureka: Human-level reward design via coding large language models , author=. International conference on learning Representations , volume=

  7. [15]

    arXiv preprint arXiv:2508.05433 , year=

    Multimodal LLM-assisted Evolutionary Search for Programmatic Control Policies , author=. arXiv preprint arXiv:2508.05433 , year=

  8. [16]

    Proceedings of the AAAI Conference on Artificial Intelligence , number=

    Hsevo: Elevating automatic heuristic design with diversity-driven harmony search and genetic algorithm using llms , author=. Proceedings of the AAAI Conference on Artificial Intelligence , number=

  9. [17]

    arXiv preprint arXiv:2412.20694 , year=

    QUBE: Enhancing Automatic Heuristic Design via Quality-Uncertainty Balanced Evolution , author=. arXiv preprint arXiv:2412.20694 , year=

    arXiv

  10. [18]

    arXiv preprint arXiv:2603.19284 , year=

    CDEoH: Category-Driven Automatic Algorithm Design With Large Language Models , author=. arXiv preprint arXiv:2603.19284 , year=

  11. [19]

    arXiv preprint arXiv:2602.08253 , year=

    G-LNS: Generative large neighborhood search for LLM-based automatic heuristic design , author=. arXiv preprint arXiv:2602.08253 , year=

  12. [20]

    arXiv preprint arXiv:2605.23904 , year=

    Skillopt: Executive strategy for self-evolving agent skills , author=. arXiv preprint arXiv:2605.23904 , year=

    arXiv

  13. [21]

    Biometrika , volume=

    On the likelihood that one unknown probability exceeds another in view of the evidence of two samples , author=. Biometrika , volume=. 1933 , publisher=

    1933

  14. [22]

    Foundations and Trends

    A tutorial on thompson sampling , author=. Foundations and Trends. 2018 , publisher=

    2018

  15. [23]

    1990 , publisher=

    Genetic programming: A paradigm for genetically breeding populations of computer programs to solve problems , author=. 1990 , publisher=

    1990

  16. [24]

    Journal of the Operational Research Society , volume=

    Hyper-heuristics: A survey of the state of the art , author=. Journal of the Operational Research Society , volume=. 2013 , publisher=

    2013

  17. [25]

    Conference on learning theory , pages=

    Analysis of thompson sampling for the multi-armed bandit problem , author=. Conference on learning theory , pages=. 2012 , organization=

    2012

  18. [26]

    1992 , publisher=

    Adaptation in natural and artificial systems: an introductory analysis with applications to biology, control, and artificial intelligence , author=. 1992 , publisher=

    1992

  19. [27]

    1994 , publisher=

    Genetic programming II: automatic discovery of reusable programs , author=. 1994 , publisher=

    1994

  20. [28]

    2015 , publisher=

    Introduction to evolutionary computing , author=. 2015 , publisher=

    2015

  21. [29]

    Proceedings of the 19th international conference on World wide web , pages=

    A contextual-bandit approach to personalized news article recommendation , author=. Proceedings of the 19th international conference on World wide web , pages=

  22. [30]

    Proceedings of the 42nd acm sigplan international conference on programming language design and implementation , pages=

    Dreamcoder: Bootstrapping inductive program synthesis with wake-sleep library learning , author=. Proceedings of the 42nd acm sigplan international conference on programming language design and implementation , pages=

  23. [31]

    arXiv preprint arXiv:1504.04909 , year=

    Illuminating search spaces by mapping elites , author=. arXiv preprint arXiv:1504.04909 , year=

    arXiv

  24. [32]

    RefineEvo: Planning-Guided Heuristic Evolution with Bidirectional Experience , author=

  25. [33]

    Foundations and Trends

    Introduction to multi-armed bandits , author=. Foundations and Trends. 2019 , publisher=

    2019

  26. [34]

    Annals of Mathematics and Artificial Intelligence , volume=

    Analyzing bandit-based adaptive operator selection mechanisms , author=. Annals of Mathematics and Artificial Intelligence , volume=. 2010 , publisher=

    2010

  27. [35]

    arXiv preprint arXiv:2512.13857 , year=

    EvoLattice: Persistent Internal-Population Evolution through Multi-Alternative Quality-Diversity Graph Representations for LLM-Guided Program Discovery , author=. arXiv preprint arXiv:2512.13857 , year=

  28. [36]

    arXiv preprint arXiv:2604.12898 , year=

    BEAM: Bi-level Memory-adaptive Algorithmic Evolution for LLM-Powered Heuristic Design , author=. arXiv preprint arXiv:2604.12898 , year=

    arXiv

  29. [37]

    arXiv preprint arXiv:2602.10233 , year=

    ImprovEvolve: Ask AlphaEvolve to Improve the Input Solution and Then Improvise , author=. arXiv preprint arXiv:2602.10233 , year=

    arXiv

  30. [38]

    arXiv preprint arXiv:2310.00656 , year=

    Lego-prover: Neural theorem proving with growing libraries , author=. arXiv preprint arXiv:2310.00656 , year=

    arXiv

  31. [39]

    arXiv preprint arXiv:2401.12869 , year=

    Trove: Inducing verifiable and efficient toolboxes for solving programmatic tasks , author=. arXiv preprint arXiv:2401.12869 , year=

    arXiv

  32. [40]

    International Conference on Learning Representations , volume=

    Lilo: Learning interpretable libraries by compressing and documenting code , author=. International Conference on Learning Representations , volume=

  33. [41]

    arXiv preprint arXiv:2401.16467 , year=

    Regal: Refactoring programs to discover generalizable abstractions , author=. arXiv preprint arXiv:2401.16467 , year=

    arXiv

  34. [42]

    arXiv preprint arXiv:2305.16291 , year=

    Voyager: An open-ended embodied agent with large language models , author=. arXiv preprint arXiv:2305.16291 , year=

    arXiv

  35. [43]

    arXiv preprint arXiv:1606.01540 , year=

    Openai gym , author=. arXiv preprint arXiv:1606.01540 , year=

    arXiv

  36. [44]

    arXiv preprint arXiv:1707.06347 , year=

    Proximal policy optimization algorithms , author=. arXiv preprint arXiv:1707.06347 , year=

    arXiv

  37. [45]

    arXiv preprint arXiv:1312.5602 , year=

    Playing atari with deep reinforcement learning , author=. arXiv preprint arXiv:1312.5602 , year=

    arXiv

  38. [46]

    Advances in neural information processing systems , volume=

    DeepACO: Neural-enhanced ant systems for combinatorial optimization , author=. Advances in neural information processing systems , volume=

  39. [47]

    IEEE computational intelligence magazine , volume=

    Ant colony optimization , author=. IEEE computational intelligence magazine , volume=. 2006 , publisher=

    2006

  40. [48]

    Advances in neural information processing systems , volume=

    Pomo: Policy optimization with multiple optima for reinforcement learning , author=. Advances in neural information processing systems , volume=

Pith tools

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