ArticlePDF Available

Genetic Programming and Autoconstructive Evolution with the Push Programming Language


Abstract and Figures

Push is a programming language designed for the expression of evolving programs within an evolutionary computation system. This article describes Push and illustrates some of the opportunities that it presents for evolutionary computation. Two evolutionary computation systems, PushGP and Pushpop, are described in detail. PushGP is a genetic programming system that evolves Push programs to solve computational problems. Pushpop, an autoconstructive evolution system, also evolves Push programs but does so while simultaneously evolving its own evolutionary mechanisms.
Content may be subject to copyright.
A preview of the PDF is not available
... While there exist approaches towards more directed generation of offspring (e.g. building probabilistic models of high-performing programs [25], evolving reproduction operators [26], or applying less-impactful mutation operators [24]), the problem remains at core unsolved. ...
... For Tiny GP, The mutation rate was tuned by hand for each problem. While many more sophisticated mutation operators in GP exist [25,26], the motivation for these experiments is mainly to highlight the potential for LLM-based directed mutation operators to make sophisticated movements along the manifold of code. ...
... CPPN-Fixed does not allow the core functionality of the CPPN encoding (encapsulated in the query cppn function) to change, whereas CPPN-Mutable includes the source code for that function, thereby enabling the CPPN encoding itself also to evolve. wc.add_muscle(sides [3], sides[0]) 24 25 # one prong of the square is a distance muscle 26 wc.add_muscle(sides [3], center) 27 28 # the other prongs from the center of the square are active ...
This paper pursues the insight that large language models (LLMs) trained to generate code can vastly improve the effectiveness of mutation operators applied to programs in genetic programming (GP). Because such LLMs benefit from training data that includes sequential changes and modifications, they can approximate likely changes that humans would make. To highlight the breadth of implications of such evolution through large models (ELM), in the main experiment ELM combined with MAP-Elites generates hundreds of thousands of functional examples of Python programs that output working ambulating robots in the Sodarace domain, which the original LLM had never seen in pre-training. These examples then help to bootstrap training a new conditional language model that can output the right walker for a particular terrain. The ability to bootstrap new models that can output appropriate artifacts for a given context in a domain where zero training data was previously available carries implications for open-endedness, deep learning, and reinforcement learning. These implications are explored here in depth in the hope of inspiring new directions of research now opened up by ELM.
... PushGP evolves programs in the language Push, a stack-based programming language built specifically for use in genetic programming [62,63]. Every data type has its own stack, and each Push instruction acts by pushing and popping various Table 3 Instructions and data types used in our PushGP implementation of each problem. ...
Full-text available
For the past seven years, researchers in genetic programming and other program synthesis disciplines have used the General Program Synthesis Benchmark Suite (PSB1) to benchmark many aspects of systems that conduct programming by example, where the specifications of the desired program are given as input/output pairs. PSB1 has been used to make notable progress toward the goal of general program synthesis: automatically creating the types of software that human programmers code. Many of the systems that have attempted the problems in PSB1 have used it to demonstrate performance improvements granted through new techniques. Over time, the suite has gradually become outdated, hindering the accurate measurement of further improvements. The field needs a new set of more difficult benchmark problems to move beyond what was previously possible and ensure that systems do not overfit to one benchmark suite. In this paper, we describe the 25 new general program synthesis benchmark problems that make up PSB2, a new benchmark suite. These problems are curated from a variety of sources, including programming katas and college courses. We selected these problems to be more difficult than those in the original suite, and give results using PushGP showing this increase in difficulty. We additionally give an example of benchmarking using a state-of-the-art parent selection method, showing improved performance on PSB2 while still leaving plenty of room for improvement. These new problems will help guide program synthesis research for years to come.
In this paper we investigate why the running time of lexicase parent selection is empirically much lower than its worst-case bound of O(N·C). We define a measure of population diversity and prove that high diversity leads to low running times O(N+C) of lexicase selection. We then show empirically that genetic programming populations evolved under lexicase selection are diverse for several program synthesis problems, and explore the resulting differences in running time bounds.
Full-text available
This article compares basic genetic programming, genetic programming with automatically defined functions (ADFs), and genetic programming with ADFs using a restricted form of recursion on a planning problem involving tree search. The results show that evolution of a recursive program is possible and further that, of the three techniques explored, genetic programming with recursive ADFs performs the best for the tree search problem. Additionally, genetic programming using ADFs (recursive and non-recursive) outperforms genetic programming without ADFs. The scalability of these techniques is also investigated. The computational effort required to reach a solution using ADFs with recursion is shown to remain essentially constant with world size, while genetic programming with non-recursive ADFs scales linearly at best, and basic genetic programming scales exponentially. Finally, many solutions were found using genetic programming with recursive ADFs which generalized to any world size. Iterative structures are an essential component in programming. Iteration and recursion lead to more compact programs and, in many cases, facilitate generalization. Since genetic programming is a genetic algorithm which evolves programs, iterative and recursive capability is desirable. Additionally, the ability to create simpler programs means that an evolved solution may take less computational effort to find. The evolution of iteration and recursion using genetic programming was first explored by Koza(1992). To allow the evolution of iterative solutions to the block stacking problem, Koza introduced the Do Until (DU) operator. The DU operator takes two arguments: the first specifies the work to be iteratively executed, and the second specifies a predicate which when satisfied will end the iteration. To prevent infinite loops, an upper limit on the number of iterations is externally imposed. Variations of this form of restricted iteration have proven useful in several problem domains including protein sequencing and optical character recognition (Koza 1994), (Andre 1994a), (chapter 8). Koza(1992) also investigates a very limited form of recursion for sequence induction. Programs capable of producing the Fibonacci sequence are achieved by allowing the S- expression to reference previously computed values in the sequence. Although much work has been done in the synthesis of recursive functional programs using other machine learning methods (see (Banerjee 1987), (Hutchinson 1994)), little has been done to explore the evolution of recursion using genetic programming (see (Nordin 1995)). This article investigates a method for evolving recursive programs for tree search. Many techniques used in AI systems, including those for game-playing and planning, depend on an agent's ability to search tree structures (Nilsson 1971), but are not optimal. These systems are thus prime candidates for genetic programming. Similar to restricted
Genetic programming is a powerful method for automatically generating computer programs via the process of natural selection (Koza, 1992). However, in its standard form, there is no way to restrict the programs it generates to those where the functions operate on appropriate data types. In the case when the programs manipulate multiple data types and contain functions designed to operate on particular data types, this can lead to unnecessarily large search times and/or unnecessarily poor generalization performance. Strongly typed genetic programming (STGP) is an enhanced version of genetic programming that enforces data-type constraints and whose use of generic functions and generic data types makes it more powerful than other approaches to type-constraint enforcement. After describing its operation, we illustrate its use on problems in two domains, matrix/vector manipulation and list manipulation, which require its generality. The examples are (1) the multidimensional least-squares regression problem, (2) the multidimensional Kalman filter, (3) the list manipulation function NTH, and (4) the list manipulation function MAPCAR.
Genetic Programming (GP) automatically generates computer programs to solve specified problems. It develops programs through the process of a “create-test-modify” cycle which is similar to the way a human writes programs. There are various functional programming techniques that human programmers can use to accelerate the program development process. This research investigated the applicability of some of the functional techniques to GP and analyzed their impact on GP performance. Among many important functional techniques, three were chosen to be included in this research, due to their relevance to GP. They are polymorphism, implicit recursion and higher-order functions. To demonstrate their applicability, a GP system was developed with those techniques incorporated. Furthermore, a number of experiments were conducted using the system. The results were then compared to those generated by other GP systems which do not support these functional features. Finally, the program search space of the general even-parity problem was analyzed to explain how these techniques impact GP performance. The experimental results showed that the investigated functional techniques have made GP more powerful in the following ways: 1) polymorphism has enabled GP to solve problems that are very difficult for standard GP to solve, i.e. nth and map programs; 2) higher-order functions and implicit recursion have enhanced GP’s ability in solving the general even-parity problem to a greater degree than with any other known methods. Moreover, the analysis showed that these techniques directed GP to generate program solutions in a way that has never been previously reported. Finally, we provide the guidelines for the application of these techniques to other problems.
Introduction: Adaptive and Self-Adaptive Evolutionary ComputationsEvolutionary computations have proven to be powerful yet general methods for searchand optimization. As with most search and optimization techniques, evolutionarycomputations include a number of operational parameters whose values significantly alterthe behavior of the algorithm on a given problem, and usually in unpredictable ways.Typically, the optimal parameter values are not only problem dependent but population...