Pith. sign in

REVIEW 4 major objections 5 minor 49 references

Kozax: Flexible and Scalable Genetic Programming in JAX

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

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

Pith's one-line read Kozax claims that standard tree-based genetic programming becomes GPU-scalable when every candidate expression tree is encoded as a fixed-size matrix, letting one library handle symbolic regression, control policy search, and…

desk verdict Kozax is a genuinely useful JAX GP library with a clean matrix encoding and honest reporting, but the runtime evidence under-supports the headline scalability claim because population scaling is never isolated and memory costs are unanalyzed. read the letter →

arxiv 2502.03047 v2 pith:AGDXDBBH submitted 2025-02-05 cs.NE cs.AI

Sigur de Vries , Sander W. Keemink , Marcel A. J. van Gerven This is my paper · ORCID
classification cs.NEcs.AI MSC 68W5068W10
keywords geneticprogrammingsymbolicregressionGPUparallelizationmatrixrepresentationoftreesconstantoptimizationcontrolpolicyevolutionobjectivefunctionlearningjust-in-timecompilation
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 presents Kozax, a genetic programming library that encodes candidate expression trees as fixed-size matrices and evaluates the whole population at once on CPU or GPU. The authors aim to show that a single framework can cover symbolic regression of natural laws and dynamical systems, symbolic control policy search, and evolving loss functions for neural networks, rather than requiring a separate implementation per task. If the central claim holds, users get GPU-scaled evolution for any fitness function that can be expressed in a vectorized numerical-computing stack, with constant optimization and multi-tree evolution included. The paper reports competitive equation discovery, successful acrobot control, and an evolved loss function that trains a network to 98.3 percent test accuracy, with runtime scaling that favors GPU for large datasets.

What carries the argument

The central object is the matrix representation of a parse tree: a fixed-size matrix whose rows are nodes, with columns for a function index, child node indices, and a stored computed value; constants and variables are represented as special function indices, empty rows are zeros, and the root is the last row. This representation lets every tree in the population share the same shape, so fitness evaluation, initialization, and reproduction can be written as vectorized operations over the whole population and compiled once, removing the structural variability that normally forces sequential evaluation of differently shaped trees.

What would settle it

Take a problem whose fitness function calls an external simulator with Python-level control flow and data-dependent shapes, keep population size and generations fixed, and compare Kozax's per-generation wall-clock time on GPU against a sequential genetic programming implementation; if the GPU advantage disappears or runtime grows linearly with population size, the claimed general scalability is refuted for that problem class.

Watch

Extended reading notes

Core claim

The core claim is that the main computational bottleneck of genetic programming, evaluating many candidate programs of different shapes, can be removed without abandoning standard tree-based GP. Kozax represents every parse tree as a matrix of fixed size: each row stores a function index, the indices of its child rows, and a value slot set to zero before execution; the root sits in the last row, and evaluation solves the matrix row by row so children are computed before parents. Because the matrix is the same size for every candidate, initialization, fitness evaluation, crossover, and mutation can all be vectorized and compiled, which lets a population of thousands run in parallel on GPU hardware. The authors demonstrate the resulting system on seven tasks: rediscovering Kepler's, Newton's, and Bode's laws, recovering Lotka-Volterra dynamics in both fully and partially observed settings, solving the acrobot swing-up with a compact symbolic policy, and evolving an objective function that trains a neural network. On the largest objective-function setting, the evolved loss reaches 98.3% test accuracy on the XOR benchmark.

Load-bearing premise

The load-bearing premise is that a user's fitness function and simulation environment can be expressed inside a just-in-time compiled, vectorized computation graph; the demonstrations all use numerical integrators or JAX-compatible environments, so problems with Python control flow, data-dependent shapes, or external non-differentiable simulators may fall back to slow sequential evaluation, and that boundary is not characterized.

Editorial extensions

If this is right

  • With the matrix representation, the entire generational loop can be JIT-compiled and run on GPU, so wall-clock time for fixed population and generations scales down as dataset size grows, as shown in the 100,000-point symbolic regression benchmark.
  • Kozax can evolve several trees simultaneously with different operator and variable sets, enabling tasks such as partially observed dynamical-systems regression where two equations must be integrated together.
  • Users can define custom operators and fitness functions while retaining compiled execution, which is what lets the same library switch between equation discovery, control policy search, and objective-function learning.
  • The two included constant-optimization schemes let users tune how many candidates receive gradient-based or genetic constant fitting, trading compute against solution accuracy.
  • The objective-function experiments show an evolved loss that trains a small neural network to 98.3% test accuracy on XOR, a task outside the reach of standard symbolic regression tools.

Reading between the lines

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

  • Inference: Because trees are padded to a fixed matrix size, large populations with sparse or shallow trees waste compute on empty rows; a benchmark varying tree depth limits would quantify this overhead, which the paper does not report.
  • Inference: The reported speed advantage depends on the fitness function itself being vectorizable; a natural stress test is evolving policies in a simulator that must be stepped one episode at a time, where the GPU parallelization would only help if multiple episodes are batched.
  • Inference: The same matrix representation could be extended to directly evolve recurrent or multi-output programs, since the authors note that higher-dimensional inputs and outputs and automatically defined functions are future work.
  • Inference: The most direct next application suggested by the results is end-to-end meta-learning on GPU, where many neural networks are trained in parallel under evolved losses, an experiment the paper approximates with batched training in the large XOR setting.
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 / 5 minor

Summary. The paper introduces Kozax, a genetic programming library implemented in JAX that represents parse trees as fixed-size matrices, enabling vectorized and JIT-compiled evaluation of whole populations on CPU and GPU. The authors claim that this design makes fitness evaluation scalable to large populations or datasets while retaining flexibility through custom operators, custom fitness functions, constant optimization, and simultaneous evolution of multiple trees. Seven experiments are reported: rediscovery of three physical laws, fully and partially observable Lotka-Volterra dynamics, an acrobot swing-up control policy, and evolved objective functions for training small neural networks, with comparisons against PySR and DEAP. Runtime measurements in Figure 6 are used to support claims of GPU scalability.

Significance. If the central claims hold, Kozax would fill a real gap: a general, tree-based GP framework that runs on GPU and is applicable beyond symbolic regression, including control and meta-learning tasks. The paper has notable strengths: the code and reproduction data are publicly available, the seven experiments cover several problem classes, Table 1 gives a useful feature comparison, and the partially observable Lotka-Volterra and objective-function experiments demonstrate functionality that is difficult to realize in PySR and DEAP. The runtime experiments are a reasonable first step, but, as detailed below, the evidence for the central scalability claim is incomplete, and the claimed generality for 'arbitrary problems' is not fully characterized. These issues are fixable and do not undermine the basic soundness of the library design.

major comments (4)
  1. [§5.2, Fig. 6a] The central scalability claim is not isolated by the reported experiments. Figure 6a varies only the number of data points, while population size, number of generations, tree matrix size, operator set, and the exact fitness function are not reported in the text. Figure 6b changes dataset size, population size, and device simultaneously. As a result, the reader cannot determine whether the speedup comes from vectorization over the population or over the data, and the claim that Kozax scales to 'large populations or datasets' is not separately supported for both axes. Please report the full configuration for every runtime run and include separate sweeps over population size and dataset size, with the memory footprint noted at each setting.
  2. [§4.2 and §6] The matrix-tree representation stores an intermediate value for every node, for every individual, and for every data point, giving O(N * M * D) memory in the population size N, matrix size M, and dataset size D, in addition to intermediate arrays created by operator evaluation. No batching strategy for the data axis is described. The abstract's phrasing 'large populations or datasets' is therefore accurate only as an 'or', while the Discussion's claim that Kozax 'scales efficiently to large populations, datasets and difficult problems' needs a memory qualification. Please state the memory model explicitly and explain how users should batch or limit D when N and M are large.
  3. [§4.1 and §5.1] The 'arbitrary problems' generality claim is stronger than the evidence supports. Section 4.1 states that custom operators and fitness functions remain compatible with JIT compilation, but all seven experiments use JAX-native operations or a JAX-based environment (Gymnax for acrobot). The paper does not characterize behavior for Python control flow, data-dependent shapes, or non-JAX external simulators, where the speed advantage of vectorized evaluation disappears. Please add an explicit statement of the JIT/vectorization boundary and, ideally, a small experiment or benchmark showing what happens when a fitness function cannot be JIT-compiled.
  4. [Table 2 and §5.1] The cross-library performance comparison is confounded by per-task tuning. The operator sets are 'empirically determined for each experiment' for Kozax, and the number of constant-optimization steps is applied only to Kozax, while the paper does not state whether PySR and DEAP received comparable tuning or their default configurations. This makes the fitness comparisons in Table 3 a comparison of tuned Kozax against default baselines rather than a controlled benchmark. Please report which hyperparameters were tuned for each library and justify that the chosen settings are representative rather than cherry-picked.
minor comments (5)
  1. [§5.2] The runtime plots in Figure 6 show averages over three runs but no error bars or confidence intervals; given that the reported GPU times jump from 72.3 s to 127.0 s for a 10x increase in data points, run-to-run variability could affect the claimed crossover point. Please add error bars or per-run values.
  2. [§5.2] The paragraph following Figure 6a repeats the same text twice, with the second copy ending in the same sentence as the first. Please remove the duplicated passage.
  3. [§6] There is a typo in the Discussion: 'Kozax runs op GPU' should be 'Kozax runs on GPU'. Also, 'A big advantages' should be 'A big advantage'.
  4. [§5.1.4] The objective-function experiment compares only against DEAP; adding a standard loss function (e.g., binary cross-entropy) as a baseline would help interpret the reported 98.3% test accuracy and better position the evolved loss.
  5. [Table 3] The partially observable Lotka-Volterra row and the 'loss function (big)' row have '--' entries for PySR and DEAP; a brief note in the table caption explaining why these entries are not applicable would improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: Kozax is an empirical systems paper whose claims rest on external benchmarks and known laws, not on self-referential definitions or fitted predictions.

full rationale

The paper's central claims — that the matrix-tree representation parallelizes fitness evaluation and that Kozax can rediscover known equations, control policies, and loss functions — are supported by external benchmarks against PySR and DEAP and by comparison with known physical laws, not by a derivation from the framework's own assumptions. I inspected the load-bearing steps: the vectorized tree interpreter in Section 4.2 is a mechanism description rather than a derived prediction; the runtime analysis in Section 5.2 reports measured wall-clock times against independent libraries; and the symbolic regression results in Section 5.1 are scored against known targets (Kepler, Newton, Bode, Lotka-Volterra). The only self-citation, reference [46], is listed in the introduction and related work as one of several prior applications of GP to control policies and is not invoked to justify any theorem, uniqueness claim, or parameter setting. The 'set of operators was empirically determined for each experiment' (Section 5.1) is experiment configuration, not a fitted parameter that is then reported as a prediction; the target laws are external ground truths. The generality boundary that arbitrary fitness functions must remain JAX/JIT-compatible is described in Section 4.1 and is a limitation of applicability, not a circular step. Under-powered or configuration-dependent benchmarks would be a correctness or evidence concern, not circularity. Accordingly, no claim in the paper reduces to its own inputs by construction.

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

No new physical entities, forces, or conserved quantities are introduced; Kozax is a software artifact. The central claims rest on the JAX runtime behaving as specified, the matrix encoding matching standard GP, and per-task hyperparameter choices that are reported but not systematically justified.

free parameters (3)
  • per-experiment operator set = Different subsets of +, -, *, /, power, sin, cos, log, exp (Table 2)
    The operator set was empirically determined for each experiment (Section 5.1), so comparisons are tuned per task, complicating the claim of a general off-the-shelf framework.
  • constant optimization steps (CO steps) = 0 to 100000 per generation (Table 2)
    The number of constant optimization steps per generation is tuned per experiment and is a major computational budget; it differs between libraries (only Kozax has it) and affects both runtime and fitness.
  • population size and generations = 250 to 2000 population, 50 to 100 generations (Table 2)
    Standard GP hyperparameters, chosen per experiment; not a fitted scientific constant but relevant to runtime and performance comparisons.
assumptions (5)
  • domain assumption The fixed-size matrix representation can represent any parse tree up to a user-defined number of nodes, and empty rows do not affect the output.
    Section 4.2 describes the row encoding; the equivalence to standard GP trees is asserted but not formally proven.
  • domain assumption JAX just-in-time compilation and vectorization work for arbitrary user fitness functions.
    Section 4.1 claims custom fitness functions remain JIT-compatible; this is necessary for the 'arbitrary problems' claim.
  • domain assumption The finite-difference approximation provides accurate derivative targets for Lotka-Volterra symbolic regression.
    Section 5.1.2 uses finite differences to compute derivatives from one integrated trajectory.
  • domain assumption Gymnax's acrobot simulation is a faithful implementation of the acrobot swing-up task.
    Section 5.1.3 uses Gymnax to evaluate policies; fidelity of the simulator is assumed.
  • ad hoc to paper Operator sets chosen per experiment do not invalidate cross-library comparisons.
    Section 5.1 says the operator set was empirically determined for each experiment; these hand-picked sets differ across tasks and were given to the libraries where possible.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Kozax: Flexible and Scalable Genetic Programming in JAX." pith.science (2026). https://pith.science/paper/AGDXDBBH

@misc{pith2026250203047,
  author       = {Pith},
  title        = {Pith review of: Kozax: Flexible and Scalable Genetic Programming in JAX},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AGDXDBBH}},
  note         = {Machine review of arXiv:2502.03047}
}
read the original abstract

Genetic programming is an optimization algorithm inspired by evolution which automatically evolves the structure of interpretable computer programs. The fitness evaluation in genetic programming suffers from high computational requirements, limiting the performance on difficult problems. Consequently, there is no efficient genetic programming framework that is usable for a wide range of tasks. To this end, we developed Kozax, a genetic programming framework that evolves symbolic expressions for arbitrary problems. We implemented Kozax using JAX, a framework for high-performance and scalable machine learning, which allows the fitness evaluation to scale efficiently to large populations or datasets on GPU. Furthermore, Kozax offers constant optimization, custom operator definition and simultaneous evolution of multiple trees. We demonstrate successful applications of Kozax to discover equations of natural laws, recover equations of hidden dynamic variables, evolve a control policy and optimize an objective function. Overall, Kozax provides a general, fast, and scalable library to optimize white-box solutions in the realm of scientific computing.

Figures

Figures reproduced from arXiv: 2502.03047 by the authors.

Figure 1
Figure 1. We introduce Kozax as a general framework for genetic programming, utilizing JAX for fast and paralleliz [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Overview of trees and reproduction in genetic programming. (a) An example of the parse tree representation used in genetic programming. (b) An example of crossover on a pair of trees, where the blue and orange subtrees are swapped. (c) An example of mutation on a tree, where the operator in blue is replaced with the new operator in orange. between runtime and the number of subpopulations. To parallelize the evaluati… view at source ↗
Figure 3
Figure 3. Step-by-step mapping of a tree to a matrix. The node added in the tree and the corresponding row in the matrix are marked blue at every step. The references to child nodes are added to the relevant rows once the child node itself has been added to the tree. The matrix is inverted, as the execution starts with the leaf nodes. Lastly, Kozax can parallelize the fitness evaluation and candidate evolution on both CPU cor… view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Processing of a matrix in Kozax. The matrix is iteratively solved with the input values: y1 = π 2 and y2 = 1. A blue row in the matrix corresponds to a blue node in the tree, where the computed value of the node is stored in the last column. The final value of the tree…
Figure 5
Figure 5. Figure 5: Evolution of new trees in Kozax. (a) Crossover applied to a pair of trees, producing two new trees. A random node is selected in both trees and the corresponding subtrees are swapped, indicated by the blue and orange subtrees. The matrix shows the representation of the…
Figure 6
Figure 6. Figure 6: b presents the wall clock time of DEAP and Kozax for the objective function optimization task. The objective function optimization was performed only with DEAP and Kozax with the small and large dataset described in Section 5.1.4. Here, Kozax was only tested on GPU. Gi…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

49 extracted references · 45 canonical work pages

  1. [1]

    A parallel implementation of genetic programming that achieves super-linear performance

    David Andre and John R Koza. “A parallel implementation of genetic programming that achieves super-linear performance”. In: Information Sciences 106.3-4 (1998), pp. 201–218

    work page 1998

  2. [2]

    Meta learning via learned loss

    Sarah Bechtle et al. “Meta learning via learned loss”. In: 25th International Conference on Pattern Recognition (ICPR). IEEE. 2021, pp. 4161–4168

    work page 2021

  3. [3]

    Use of genetic programming for the search of a new learning rule for neural networks

    Samy Bengio, Yoshua Bengio, and Jocelyn Cloutier. “Use of genetic programming for the search of a new learning rule for neural networks”. In: Proceedings of the First IEEE Conference on Evolutionary Computation. IEEE World Congress on Computational Intelligence . IEEE. 1994, pp. 324–327

    work page 1994

  4. [4]

    Automated reverse engineering of nonlinear dynamical systems

    Josh Bongard and Hod Lipson. “Automated reverse engineering of nonlinear dynamical systems”. In: Proceed- ings of the National Academy of Sciences 104.24 (2007), pp. 9943–9948

    work page 2007

  5. [5]

    Contemplation de la Nature

    Charles Bonnet. Contemplation de la Nature . Vol. 4. De l’imprimerie de Samuel Fauche, libraire du roi, 1781

    work page

  6. [6]

    JAX: composable transformations of Python+NumPy programs

    James Bradbury et al. JAX: composable transformations of Python+NumPy programs . Version 0.3.13. 2018. url: http://github.com/jax-ml/jax

    work page 2018

  7. [7]

    Basic Concepts of Linear Genetic Programming

    Markus F Brameier and Wolfgang Banzhaf. Basic Concepts of Linear Genetic Programming . Springer, 2007

    work page 2007

  8. [8]

    Operon C++ an efficient genetic program- ming framework for symbolic regression

    Bogdan Burlacu, Gabriel Kronberger, and Michael Kommenda. “Operon C++ an efficient genetic program- ming framework for symbolic regression”. In: Proceedings of the 2020 Genetic and Evolutionary Computation Conference Companion. 2020, pp. 1562–1570

    work page 2020

Show all 49 references
  1. [9]

    GPU-parallel subtree interpreter for genetic programming

    Alberto Cano and Sebasti´ an Ventura. “GPU-parallel subtree interpreter for genetic programming”. In: Pro- ceedings of the Genetic and Evolutionary Computation Conference Companion . 2014, pp. 887–894

    2014

  2. [10]

    Evolutionary modeling of systems of ordinary differential equations with genetic pro- gramming

    Hongqing Cao et al. “Evolutionary modeling of systems of ordinary differential equations with genetic pro- gramming”. In: Genetic Programming and Evolvable Machines 1 (2000), pp. 309–337

    2000

  3. [11]

    GSGP-C++ 2.0: A geometric semantic genetic programming framework

    Mauro Castelli and Luca Manzoni. “GSGP-C++ 2.0: A geometric semantic genetic programming framework”. In: SoftwareX 10 (2019), p. 100313

    2019

  4. [12]

    Faster GPU-based genetic programming using a two-dimensional stack

    Darren M Chitty. “Faster GPU-based genetic programming using a two-dimensional stack”. In: Soft Computing 21 (2017), pp. 3859–3878

    2017

  5. [13]

    Interpretable machine learning for science with PySR and SymbolicRegression.jl

    Miles Cranmer. “Interpretable machine learning for science with PySR and SymbolicRegression.jl”. In: arXiv preprint arXiv:2305.01582 (2023)

    2023 arXiv

  6. [14]

    DEAP: Evolutionary algorithms made easy

    F´ elix-Antoine Fortin et al. “DEAP: Evolutionary algorithms made easy”. In: The Journal of Machine Learning Research 13.1 (2012), pp. 2171–2175

    2012

  7. [15]

    On the Volterra and other nonlinear models of interacting populations

    Narendra S Goel, Samaresh C Maitra, and Elliott W Montroll. “On the Volterra and other nonlinear models of interacting populations”. In: Reviews of Modern Physics 43.2 (1971), p. 231

    1971

  8. [16]

    Fast genetic programming on GPUs

    Simon Harding and Wolfgang Banzhaf. “Fast genetic programming on GPUs”. In: Genetic Programming: 10th European Conference, EuroGP 2007, Valencia, Spain, April 11-13, 2007. Proceedings 10 . Springer. 2007, pp. 90–101

    2007

  9. [17]

    Interpretable policies for reinforcement learning by genetic programming

    Daniel Hein, Steffen Udluft, and Thomas A Runkler. “Interpretable policies for reinforcement learning by genetic programming”. In: Engineering Applications of Artificial Intelligence 76 (2018), pp. 158–169

    2018

  10. [18]

    EvoX: A Distributed GPU-accelerated Framework for Scalable Evolutionary Computa- tion

    Beichen Huang et al. “EvoX: A Distributed GPU-accelerated Framework for Scalable Evolutionary Computa- tion”. In: IEEE Transactions on Evolutionary Computation (2024)

    2024

  11. [19]

    Evolving interpretable plasticity for spiking networks

    Jakob Jordan et al. “Evolving interpretable plasticity for spiking networks”. In: Elife 10 (2021), e66273

    2021

  12. [20]

    The Harmony of the World

    Johannes Kepler. The Harmony of the World . Vol. 209. American Philosophical Society, 1997

    1997

  13. [21]

    Genetic programming as a means for programming computers by natural selection

    John R Koza. “Genetic programming as a means for programming computers by natural selection”. In: Statistics and Computing 4 (1994), pp. 87–112. 11

    1994

  14. [22]

    Genetic programming: A Paradigm for Genetically Breeding Populations of Computer Programs to Solve Problems

    John R Koza. Genetic programming: A Paradigm for Genetically Breeding Populations of Computer Programs to Solve Problems . Vol. 34. Stanford University, Department of Computer Science Stanford, CA, 1990

    1990

  15. [23]

    Automatic programming of robots using genetic programming

    John R Koza and James P Rice. “Automatic programming of robots using genetic programming”. In: AAAI. Vol. 92. 1992, pp. 194–207

    1992

  16. [24]

    Contemporary symbolic regression methods and their relative performance

    William La Cava et al. “Contemporary symbolic regression methods and their relative performance”. In: Advances in neural information processing systems 2021.DB1 (2021), p. 1

    2021

  17. [25]

    A many threaded CUDA interpreter for genetic programming

    William B Langdon. “A many threaded CUDA interpreter for genetic programming”. In: European Conference on Genetic Programming. Springer. 2010, pp. 146–158

    2010

  18. [26]

    A SIMD interpreter for genetic programming on GPU graphics cards

    William B Langdon and Wolfgang Banzhaf. “A SIMD interpreter for genetic programming on GPU graphics cards”. In: European Conference on Genetic Programming. Springer. 2008, pp. 73–85

    2008

  19. [27]

    evosax: Jax-based evolution strategies

    Robert Tjarko Lange. “evosax: Jax-based evolution strategies”. In: Proceedings of the Companion Conference on Genetic and Evolutionary Computation . 2023, pp. 659–662

    2023

  20. [28]

    gymnax: A JAX-based Reinforcement Learning Environment Library

    Robert Tjarko Lange. gymnax: A JAX-based Reinforcement Learning Environment Library. Version 0.0.4. 2022. url: http://github.com/RobertTLange/gymnax

    2022

  21. [29]

    Cartesian genetic programming

    Julian Miller and Andrew Turner. “Cartesian genetic programming”. In: Proceedings of the Companion Publi- cation of the 2015 Annual Conference on Genetic and Evolutionary Computation . 2015, pp. 179–198

    2015

  22. [30]

    Strongly typed genetic programming

    David J Montana. “Strongly typed genetic programming”. In: Evolutionary Computation 3.2 (1995), pp. 199– 230

    1995

  23. [31]

    Naturally interpretable control policies via graph-based genetic programming

    Giorgia Nadizar, Eric Medvet, and Dennis G Wilson. “Naturally interpretable control policies via graph-based genetic programming”. In: European Conference on Genetic Programming. Springer. 2024, pp. 73–89

    2024

  24. [32]

    Philosophiæ naturalis principia mathematica (Mathematical principles of natural philosophy)

    Isaac Newton. “Philosophiæ naturalis principia mathematica (Mathematical principles of natural philosophy)”. In: London (1687) 1687.1687 (1987), p. 1687

    1987

  25. [33]

    Grammatical evolution

    Michael O’Neill and Conor Ryan. “Grammatical evolution”. In: IEEE Transactions on Evolutionary Compu- tation 5.4 (2001), pp. 349–358

    2001

  26. [34]

    Parallel genetic programming and its application to trading model induction

    Mouloud Oussaidene et al. “Parallel genetic programming and its application to trading model induction”. In: Parallel Computing 23.8 (1997), pp. 1183–1198

    1997

  27. [35]

    Explainable reinforcement learning: A survey

    Erika Puiutta and Eric MSP Veith. “Explainable reinforcement learning: A survey”. In: International Cross- Domain Conference for Machine Learning and Knowledge Extraction . Springer. 2020, pp. 77–95

    2020

  28. [36]

    Fast and efficient local-search for genetic programming based loss function learning

    Christian Raymond et al. “Fast and efficient local-search for genetic programming based loss function learning”. In: Proceedings of the Genetic and Evolutionary Computation Conference . 2023, pp. 1184–1193

    2023

  29. [37]

    Genetic programming on graphics processing units

    Denis Robilliard, Virginie Marion-Poty, and Cyril Fonlupt. “Genetic programming on graphics processing units”. In: Genetic Programming and Evolvable Machines 10 (2009), pp. 447–471

    2009

  30. [38]

    Accelerating genetic pro- gramming using gpus

    Vimarsh Sathia, Venkataramana Ganesh, and Shankara Rao Thejaswi Nanditale. “Accelerating genetic pro- gramming using gpus”. In: arXiv preprint arXiv:2110.11226 (2021)

    2021 arXiv

  31. [39]

    Distilling free-form natural laws from experimental data

    Michael Schmidt and Hod Lipson. “Distilling free-form natural laws from experimental data”. In: Science 324.5923 (2009), pp. 81–85

    2009

  32. [40]

    Evolving neural networks through augmenting topologies

    Kenneth O Stanley and Risto Miikkulainen. “Evolving neural networks through augmenting topologies”. In: Evolutionary Computation 10.2 (2002), pp. 99–127

    2002

  33. [41]

    Generalization in reinforcement learning: Successful examples using sparse coarse coding

    Richard S Sutton. “Generalization in reinforcement learning: Successful examples using sparse coarse coding”. In: Advances in Neural Information Processing Systems 8 (1995)

    1995

  34. [42]

    Evojax: Hardware-accelerated neuroevolution

    Yujin Tang, Yingtao Tian, and David Ha. “Evojax: Hardware-accelerated neuroevolution”. In: Proceedings of the Genetic and Evolutionary Computation Conference Companion . 2022, pp. 308–311

    2022

  35. [43]

    Faster genetic programming based on local gradient search of numeric leaf values

    Alexander Topchy, William F Punch, et al. “Faster genetic programming based on local gradient search of numeric leaf values”. In: Proceedings of the Genetic and Evolutionary Computation Conference . Vol. 155162. Morgan Kaufmann San Francisco, CA. 2001

    2001

  36. [44]

    Gymnasium: A Standard Interface for Reinforcement Learning Environments

    Mark Towers et al. “Gymnasium: A Standard Interface for Reinforcement Learning Environments”. In: arXiv preprint arXiv:2407.17032 (2024). 12

    2024 arXiv

  37. [45]

    Gsgp-cuda—a cuda framework for geometric semantic genetic programming

    Leonardo Trujillo et al. “Gsgp-cuda—a cuda framework for geometric semantic genetic programming”. In: SoftwareX 18 (2022), p. 101085

    2022

  38. [46]

    Discovering Dynamic Symbolic Policies with Genetic Programming

    Sigur de Vries, Sander Keemink, and Marcel van Gerven. “Discovering Dynamic Symbolic Policies with Genetic Programming”. In: arXiv preprint arXiv:2406.02765 (2024)

    2024 arXiv

  39. [47]

    Heuristiclab: A generic and extensible optimization environment

    Stefan Wagner and Michael Affenzeller. “Heuristiclab: A generic and extensible optimization environment”. In: Adaptive and Natural Computing Algorithms: Proceedings of the International Conference in Coimbra, Portugal, 2005 . Springer. 2005, pp. 538–541

    2005

  40. [48]

    Scientific discovery in the age of artificial intelligence

    Hanchen Wang et al. “Scientific discovery in the age of artificial intelligence”. In: Nature 620.7972 (2023), pp. 47–60

    2023

  41. [49]

    EvoGP: A GPU-accelerated Framework for Tree-Based Genetic Programming

    Lishuang Wang et al. “EvoGP: A GPU-accelerated Framework for Tree-Based Genetic Programming”. In: arXiv preprint arXiv:2501.17168 (2025). 13

    2025

Pith tools

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