1. INTRODUCTION
Design is a major activity of practicing engineers. Engineers are often called upon to design complex structures (e.g., electrical circuits, controllers, antennas, aerodynamic shapes, optical lens systems, and mechanical systems) that satisfy prespecified high-level design and performance goals. Some designs are sufficiently creative that they are considered to be inventions.
In designing complex structures, human engineers typically employ logic and previously known domain knowledge about the field of interest. Conventional approaches to automated design (such as those employing artificial intelligence) are typically knowledge intensive, logically sound, and deterministic.
Two of the most successful approaches to design, namely, the evolutionary process (occurring in nature) and the invention process (performed by creative humans), have characteristics that are significantly different from conventional approaches to automated design employing artificial intelligence. The evolutionary process in nature is not logical, deterministic, or knowledge intensive. The invention process (performed by creative humans) is not logical or deterministic. The fact that these two highly successful approaches to design are significantly different from conventional artificial intelligence approaches suggests that the evolutionary process and the invention process may contain significant lessons for the field automated design.
In nature, solutions to design problems are discovered by means of evolution and natural selection. Evolution is not deterministic. It does not rely on a knowledge base. In addition, evolution is certainly is not guided by mathematical logic. Indeed, one of the most important characteristics of the evolutionary process is that it actively generates and encourages the maintenance of inconsistent and contradictory alternatives throughout the entire duration of the process. Logically sound systems do not do that. They never entertain either inconsistency or contradictions. In contrast, the generation and maintenance of inconsistent and contradictory alternatives (called genetic diversity) is a known precondition for the success of the evolutionary process.
Likewise, the invention process (performed by creative humans) is a nondeterministic process, and it is not governed by logic. The invention process is typically characterized by a singular moment when the prevailing thinking concerning a longstanding problem is, in a “flash of genius,” overthrown and replaced by a new approach that could not have been logically deduced from what was previously known. That is, inventions are characterized by a logical discontinuity that distinguishes the creative new design from that which can be logically deduced from what was previously known. In this connection, it is noteworthy that a purported invention is not considered to be worthy of a patent if the new idea can be logically deduced from facts that are well known in a field by means of transformations that are well known in the field. A new idea is patentable only if there is an “illogical step,” that is, a logically unjustified step. In the patent law, this legally required illogical step is sometimes referred to as a flash of genius, and it is the essence of inventiveness and creativity.
In short, both the invention process and the evolutionary process in nature and are very different from conventional artificial intelligence approaches to automated design.
Genetic programming is a method for getting computers to automatically solve problems. Genetic programming starts from a high-level statement of what needs to be done and automatically creates a computer program to solve the problem. Genetic programming is patterned after the evolutionary process in nature. Specifically, genetic programming employs the Darwinian principle of natural selection and analogs of recombination (crossover), mutation, gene duplication, gene deletion, and certain mechanisms of developmental biology to progressively breed, over a series of many generations, an improved population of candidate solutions to a problem. As will be demonstrated here, genetic programming can be employed to automatically synthesize designs for complex structures: it can be used to automate the design process. When genetic programming is so used, the process starts from a high-level specification of the structure's desired performance, which is the structure's characteristics and behavior. The outcome of a successful run of genetic programming is a structure that satisfies the user's prespecified performance requirements.
The automatic synthesis of the designs described in this paper is done ab initio, that is, without starting from a preexisting good design and without prespecifying the number of components in the structure being designed or the topological relationship among the components. The designs were created in a substantially similar and routine way, suggesting that the approach described in the paper can be readily applied to other similar design problems. The genetically evolved designs are instances of human-competitive results produced by genetic programming in the field of design.
Section 2 provides general background on genetic programming utilizing an automated design and invention technique patterned after the evolutionary process in nature.
Section 3 lists sources of additional information about genetic programming.
2. BACKGROUND ON GENETIC PROGRAMMING
The goal of getting computers to automatically solve problems is central to artificial intelligence, machine learning, and the broad area encompassed by what Turing called “machine intelligence” (Turing, Reference Turing1948, Reference Turing1950).
In his 1983 talk entitled “AI: Where It Has Been and Where It Is Going,” machine learning pioneer Arthur Samuel (1983) stated the main goal of the fields of machine learning and artificial intelligence: “[T]he aim [is] to get machines to exhibit behavior, which if done by humans, would be assumed to involve the use of intelligence.”
Genetic programming is a systematic method for getting computers to automatically solve a problem starting from a high-level statement of what needs to be done. Genetic programming is a domain-independent method that genetically breeds a population of computer programs to solve a problem. Specifically, genetic programming iteratively transforms a population of computer programs into a new generation of programs by applying analogs of naturally occurring genetic operations. Genetic programming uses the Darwinian principle of natural selection along with analogs of recombination (crossover), mutation, gene duplication, gene deletion, and mechanisms of developmental biology to breed an ever-improving population of programs (Koza, Reference Koza1989, Reference Koza1990, Reference Koza1992, Reference Koza1994a, Reference Koza1994b; Koza & Rice, Reference Koza and Rice1992; Banzhaf et al., Reference Banzhaf, Nordin, Keller and Francone1998; Koza, Bennett, Andre, & Keane, Reference Koza, Bennett, Andre and Keane1999; Koza, Bennett, Andre, Keane, & Brave, 1999; Koza et al., Reference Koza, Keane, Yu, Bennett and Mydlowec2000; Koza, Keane, & Streeter, Reference Koza, Keane and Streeter2003; Koza, Keane, Streeter, Mydlowec, Yu, & Lanza, Reference Koza, Keane, Streeter, Mydlowec, Yu and Lanza2003; Koza, Keane, Streeter, Mydlowec, Yu, Lanza, & Fletcher, Reference Koza, Keane, Streeter, Mydlowec, Yu, Lanza and Fletcher2003).
Genetic programming is an extension of John Holland's genetic algorithm (Holland, Reference Holland1975) to the arena of computer programs. Current concepts of genetic programming developed from the seminal work of numerous researchers in the 1970s and 1980s. Holland discussed the possibility of using the genetic algorithm to evolve sequences of assembly code. In 1978, Holland also proposed a broadcast language in which the genetic algorithm operated on structures more complex than fixed-length character strings. Holland and Reitman (Reference Holland, Reitman, Waterman and Hayes-Roth1978) introduced the genetic classifier system in which sets of if–then logical production rules were evolved by means of a genetic algorithm. In 1980, Stephen F. Smith introduced the variable-length genetic algorithm and applied it to populations consisting of a hierarchy of if–then rules (Smith, Reference Smith1980). In 1981, Forsyth introduced a highly innovative system called BEAGLE (Biological Evolutionary Algorithm Generating Logical Expressions) in which logical expressions were evolved in an evolutionary process (Forsyth, Reference Forsyth1981). In the mid-1980s Nichael Cramer described highly innovative experiments in program induction employing Smith's crossover operation (Cramer, Reference Cramer1985); Hicklin (a student of John Dickinson at the University of Idaho) described a system with mutation and reproduction of programs (Hicklin, Reference Hicklin1986); Fujiki (another student of Dickinson) applied all genetic operations to logical programs (Fujiki, Reference Fujikil986); Fujiki and Dickinson (Reference Fujiki and Dickinsonl987) performed induction of if–then clauses for playing the iterated prisoner's dilemma game; Antonisse and Keller (Reference Antonisse and Keller1987) applied genetic methods to higher level representations; and Bickel and Bickel (Reference Bickel and Bickel1987) applied genetic methods to if–then expert system rules.
Recent work on genetic programming is reported in the annual Genetic and Evolutionary Computation Conference (GECCO; Deb et al., Reference Deb, Poli, Banzhaf, Beyer, Burke, Darwen, Dasgupta, Floreano, Foster, Harman, Holland, Lanzi, Spector, Tettamanzi, Thierens and Tyrrell2004), the annual Euro-Genetic Programming conference (Keijzer et al., Reference Keijzer, Tettamanzi, Collet, van Hemert and Tomassini2005), the annual Genetic Programming Theory and Applications workshop (Yu et al., Reference Yu, Worzel and Riolo2005), the annual Asia-Pacific Workshops on Genetic Programming (Cho et al., Reference Cho, Nguyen and Shan2003), and in various other conferences and journals in the field of genetic and evolutionary computation, such as Genetic Programming and Evolvable Hardware. Additional sources of information about genetic programming, including links to available software for implementing genetic programming, can be found at www.genetic-programming.org.
2.1. Preparatory steps of genetic programming
Genetic programming starts from a high-level statement of the requirements of a problem and attempts to produce a computer program that solves the problem.
The human user communicates the high-level statement of the problem to the genetic programming algorithm by performing certain well-defined preparatory steps.
The five major preparatory steps for the basic version of genetic programming require the human user to specify
• the set of terminals (e.g., the independent variables of the problem, zero-argument functions, and random constants) for each branch of the program to be evolved,
• the set of primitive functions for each branch of the program to be evolved,
• the fitness measure (for explicitly or implicitly measuring the fitness of individuals in the population),
• certain parameters for controlling the run, and
• the termination criterion and method for designating the result of the run.
The first two preparatory steps specify the ingredients that are available to create the computer programs. A run of genetic programming is a competitive search among a diverse population of programs composed of the available functions and terminals.
The identification of the function set and terminal set for a particular problem (or category of problems) is usually a straightforward process. For some problems (such as symbolic regression), the function set may consist of merely the arithmetic functions of addition, subtraction, multiplication, and division as well as a conditional branching operator. The terminal set may consist of the program's external inputs (independent variables) and numerical constants.
For many other problems, the ingredients include specialized functions and terminals. For example, if the goal is to get genetic programming to automatically program a robot to mop the entire floor of an obstacle-filled room, the human user must tell genetic programming what the robot is capable of doing. For example, the robot may be capable of executing functions such as moving, turning, and swishing the mop. If the goal is the automatic creation of a controller, the function set may consist of integrators, differentiators, leads, lags, gains, adders, subtractors, and the like, and the terminal set may consist of signals such as the reference signal and plant output. If the goal is the automatic synthesis of an analog electrical circuit, it is necessary to provide ingredients that will enable genetic programming to construct circuits consisting of electrical components such as transistors, capacitors, and resistors, and to make connections among the components and the circuit's input and output ports.
The third preparatory step concerns the fitness measure for the problem. The fitness measure specifies what needs to be done. The fitness measure is the primary mechanism for communicating the high-level statement of the problem's requirements to the genetic programming system. For example, if the goal is to get genetic programming to automatically synthesize an amplifier, the fitness function is the mechanism for telling genetic programming to synthesize a circuit that amplifies an incoming signal (as opposed to, say, a filter circuit that suppresses the low frequencies of an incoming signal or a computational circuit that computes the square root of the incoming signal). The first two preparatory steps define the search space, whereas the fitness measure implicitly specifies the search's desired goal.
The fourth and fifth preparatory steps are administrative. The fourth preparatory step entails specifying the control parameters for the run. The most important control parameter is the population size. Other control parameters include the probabilities of performing the genetic operations, the maximum size for programs, and other details of the run.
The fifth preparatory step consists of specifying the termination criterion and the method of designating the result of the run. The termination criterion may include a maximum number of generations to be run as well as a problem-specific success predicate. The single best-so-far individual is usually then harvested and designated as the result of the run.
2.2. Executional steps of genetic programming
After the user has performed the preparatory steps for a problem, the run of genetic programming can be launched. Once the run is launched, a series of well-defined, problem-independent steps is executed.
Genetic programming typically starts with an initial population of randomly generated computer programs composed of the available programmatic ingredients (as provided by the human user in the first and second preparatory steps). These programs are typically generated by recursively generating a rooted point-labeled program tree composed of random choices of the primitive functions and terminals. The initial individuals are usually generated subject to a preestablished maximum size (specified by the user as a minor parameter in the fourth preparatory step). In general, the programs in the population are of different size (number of functions and terminals) and of different shape (the particular graphical arrangement of functions and terminals in the program tree).
Genetic programming iteratively transforms a population of computer programs into a new generation of the population by applying analogs of naturally occurring genetic operations. These operations are applied to individual(s) selected from the population. The individuals are probabilistically selected to participate in the genetic operations based on their fitness (as measured by the fitness measure provided by the human user in the third preparatory step). The iterative transformation of the population is executed inside the main loop (called a generation) of a run of genetic programming. The basic genetic operations are reproduction, crossover, and mutation. Architecture-altering operations and domain-specific operations are sometimes also used (although they are not used for the particular work described in this paper).
Specifically, genetic programming breeds computer programs to solve problems by executing the following three steps:
1. Generate an initial set (called the population) of compositions (typically random) of the functions and terminals appropriate for the problem.
2. Iteratively perform the following group of substeps (called a generation) on the population of programs until the termination criterion has been satisfied:
a. Execute each program in the population and assign it a fitness value using the problem's fitness measure.
b. Create a new population (the next generation) of programs by applying the following operations to program(s) selected from the population with a probability based on fitness (with reselection allowed).
i. Reproduction: copy the selected program to the new population.
ii. Crossover: create a new offspring program for the new population by recombining randomly chosen parts of two selected programs.
iii. Mutation: create one new offspring program for the new population by randomly mutating a randomly chosen part of the selected program.
iv. Architecture-altering operations: create one new offspring program for the new population by applying an operation to the selected program that alters the arrangement of the program's branches (e.g., subroutines, result-producing branches), the number of arguments possessed by each branch, and the nature of the hierarchical references allowed among the branches.
v. Domain-specific operations: domain-specific operations are sometimes added to take advantage of design principles that are known to be helpful in a particular domain.
3. Designate an individual program (e.g., the individual with the best fitness) as the run's result.
This result may be a solution (or approximate solution) to the problem.
Genetic programming is problem independent in the sense that the above sequence of executional steps is not modified for each new run or each new problem. There is usually no discretionary human intervention or interaction during a run of genetic programming (although a human user often exercises judgment as to when to terminate a run).
2.3. Developmental genetic programming
The vast majority of the work applying genetic programming to design problems (including the work in this paper) employs a developmental process. When developmental genetic programming is used, the individuals that are genetically bred during the run of genetic programming are not themselves candidate structures in the domain involved. Instead, the individuals are computer programs consisting of instructions that transform a very simple initial structure (called the embryo) into a fully developed structure. For example, when developmental genetic programming is used to automatically design electrical circuits, the individuals in the population are not circuits but, instead, computer programs that specify how to construct a circuit, step by step, from some simple initial structure (often just a single wire).
The developmental representations used to apply genetic programming to design problems arise from early work in the field of genetic algorithms and genetic programming. In 1987 Wilson stated the following (Wilson, Reference Wilson and Grefenstette1987, pp. 247–251):
The genetic algorithm observes the genotype–phenotype distinction of biology: the algorithm's variation operators act on the genotype and its selection mechanisms apply to the phenotype. In biology, the genotype–phenotype difference is vast: the genotype is embodied in the chromosomes whereas the phenotype is the whole organism that expresses the chromosomal information. The complex decoding process that leads from one to the other is called biological development and is essential if the genotype is to be evaluated by the environment. Thus to apply the genetic algorithm to natural evolution calls for a representational scheme that both permits application of the algorithm's operators to the genotype and also defines how, based on the genotype, organisms are to be “grown,” i.e., their development.
Kitano (Reference Kitano, Sanchez and Tomassini1996) used a developmental process in conjunction with genetic algorithms to design neural networks using a graph generation system in 1990.
In 1992 Gruau described a technique in which genetic programming is used to concurrently evolve the architecture of a neural network, along with the weights, thresholds, and biases of each neuron in the neural network (Gruau, Reference Gruau1992a). In Cellular Encoding of Genetic Neural Networks, each individual program tree in the population of the run of genetic programming is a program for developing a complete neural network from a starting point consisting of a single embryonic neuron. In cellular encoding (sometimes also called “developmental genetic programming”), the developmental process for a neural network starts from an embryonic neural network consisting of a single neuron. The functions in the program tree specify how to develop the embryonic neural network into a full neural network. Certain functions permit a particular neuron to be subdivided in a parallel or sequential manner. Other functions can change the threshold of a neuron, the weight of a connection, or the bias of a neuron. Genetic programming is then used to breed populations of network-constructing program trees to evolve a neural network that is capable of solving particular problems. Gruau also described a version of his system using recursion (Gruau, Reference Gruau, Schaffer and Whitley1992b, Reference Gruau and Forrest1993, Reference Gruau1994a, Reference Gruau and Kinnear1994b; Gruau & Whitley, Reference Gruau and Whitley1993). Whitley et al. (Reference Whitley, Gruau, Preatt and Eshelman1995) applied developmental genetic programming to neurocontrol problems.
In 1993, Koza used genetic programming to evolve developmental rewrite rules (Lindenmayer system rules) using a “turtle” to create shapes such as the quadratic Koch island (Koza, Reference Koza1993).
In 1994 Dellaert and Beer described “the synthesis of autonomous agents using evolutionary techniques” and presented “a simplified yet biologically defensible model of the developmental process” (Dellaert & Beer, Reference Dellaert, Beer, Brooks and Maes1994).
In 1994 Hemmi et al. noted, “Using a rewriting system, the system introduces a program development process that imitates the natural development process from the pollinated egg to adult and gives the HDL-program flexible evolvability” (Hemmi et al., Reference Hemmi, Mizoguchi, Shimohara, Brooks and Maes1994).
In 1994 Sims describes a system in which the morphological and behavioral components of virtual creatures are represented by directed graphs that evolve through the use of a graph-based genetic algorithm (Sims, Reference Sims, Brooks and Maes1994).
In 1996 Koza, Bennett, Andre, and Keane used developmental genetic programming to automatically synthesize a large body of analog electrical circuits, including several previously patented circuits (Koza et al., Reference Koza, Bennett, Andre, Keane, Langton and Shimohara1996a, Reference Koza, Bennett, Andre and Keane1996b, Reference Koza, Bennett, Andre, Keane, Gero and Sudweeks1996c, Reference Koza, Bennett, Andre, Keane, Koza, Goldberg, Fogel and Riolo1996d). Circuit-constructing functions in the program tree specified how to develop a simple embryonic circuit (often containing just a single modifiable wire) into a fully developed circuit (containing transistors, capacitors, resistors, and other electronic components). Their method permitted distant connectivity within circuits by using vias. Koza and colleagues (Reference Koza, Bennett, Andre, Keane, Higuchi, Iwata and Liu1996e) provided for reuse of portions of circuits (by means of subroutines and iterations), parameterized reuse, and hierarchical reuse of substructures in evolving circuits.
In 1996 Brave used developmental genetic programming to evolve finite automata (Brave, Reference Brave, Koza, Goldberg, Fogel and Riolo1996).
In 1996 Tunstel and Jamshidi used developmental methods for fuzzy logic systems (Tunstel & Jamshidi, Reference Tunstel and Jamshidi1996).
In 1996 Spector and Stoffel extended the notion of development to what they called “ontogenetic programming” (Spector & Stoffel, Reference Spector, Stoffel, Koza, Goldberg, Fogel and Riolo1996a, Reference Spector, Stoffel, Maes, Mataric, Meyer, Pollack and Wilson1996b).
In nature, the structure and behavior of a mature organism is determined not only by its genetic endowment, but also by complex developmental processes that the organism undergoes while immersed in its environment (ontogeny). …
Biologists refer to the developmental progression of an individual through its life span as ontogeny. In this paper we describe how rich ontogenetic components can be added to genetic programming systems, and we show how this can allow genetic programming to produce programs that solve more difficult problems. …
Various morphological systems have been used in previous genetic programming systems to allow programs to “grow” into more complex forms prior to evaluation. Runtime memory mechanisms allow evolved programs to acquire information from their environments while they solve problems, and to change their future behavior on the basis of such information.
Ontogenetic programming combines these ideas to allow for runtime modification of program structure. In particular, an ontogenetic programming system includes program self-modification functions in the genetic programming function set, thereby allowing evolved programs to modify themselves during the course of the run. …
[W]e show how ontogenetic programming can be used to solve problems that would otherwise not be solvable. …
We have shown that it is possible to use genetic programming to produce programs that themselves develop in significant, structural ways over the course of a run. We use the term “ontogenetic programming” to describe our technique for achieving this effect, which involves the inclusion of program self-modification functions in the genetic programming function set.
In 1996 Spector and Stoffel applied their methods to a symbolic regression problem (Spector & Stoffel, Reference Spector, Stoffel, Koza, Goldberg, Fogel and Riolo1996a), a sequence prediction problem (Spector & Stoffel, Reference Spector, Stoffel, Koza, Goldberg, Fogel and Riolo1996a), and a robotic agents problem (Spector & Stoffel, Reference Spector, Stoffel, Maes, Mataric, Meyer, Pollack and Wilson1996b). They also describe how their methods can be used in conjunction with both tree and linear representations (Spector & Stoffel, Reference Spector, Stoffel, Maes, Mataric, Meyer, Pollack and Wilson1996b).
In 1996 Luke and Spector described yet another variation on the developmental process (Luke & Spector, Reference Luke, Spector and Koza1996):
Like a cellular encoding, an edge encoding is a tree-structured chromosome whose phenotype is a directed graph, optionally with labels or functions associated with its edges and nodes. …
Edge encoding, like cellular encoding, allows one to use standard S-expression-based Genetic Programming techniques to evolve arbitrary graph structures. The resulting graphs may be employed in various ways, for example as neural networks, as automata, or as knowledge-base queries. Each encoding scheme biases genetic search in a different way; for example, cellular encoding favors graphs with high edge/node ratios while edge encoding favors graphs with low edge/node ratios. For this reason, we believe that certain domains will be much better served by one scheme than by the other.
2.4. Human-competitive results produced by genetic programming
Genetic programming can be applied to problems in a variety of fields, including design problems.
We say that a result produced by an automated method is “human-competitive” if it satisfies one of the following eight criteria (Koza et al., Reference Koza, Keane, Yu, Bennett and Mydlowec2000; Koza, Keane, Streeter, Mydlowec, Yu, & Lanza, Reference Koza, Keane, Streeter, Mydlowec, Yu and Lanza2003):
1. The result was patented as an invention in the past, is an improvement over a patented invention, or would qualify today as a patentable new invention.
2. The result is equal to or better than a result that was accepted as a new scientific result at the time when it was published in a peer-reviewed scientific journal.
3. The result is equal to or better than a result that was placed into a database or archive of results maintained by an internationally recognized panel of scientific experts.
4. The result is publishable in its own right as a new scientific result, independent of the fact that the result was mechanically created.
5. The result is equal to or better than the most recent human-created solution to a long-standing problem for which there has been a succession of increasingly better human-created solutions.
6. The result is equal to or better than a result that was considered an achievement in its field at the time it was first discovered.
7. The result solves a problem of indisputable difficulty in its field.
8. The result holds its own or wins a regulated competition involving human contestants (in the form of either live human players or human-written computer programs).
Focusing on patented inventions, there are at least 28 instances in which genetic programming has duplicated the functionality of a previously patented invention, infringed a previously issued patent, or created a patentable new invention (Koza, Keane, Streeter, Mydlowec, Yu, & Lanza, Reference Koza, Keane, Streeter, Mydlowec, Yu and Lanza2003). Specifically, there is one instance where genetic programming has created an entity that either infringes or duplicates the functionality of a previously patented 19th century invention, 15 instances where genetic programming has done the same with respect to a previously patented 20th century invention, 6 instances where genetic programming has done the same with respect to a previously patented 21st century invention, and 2 instances where genetic programming has created a patentable new invention (discussed in Section 6).
Table 1 provides information on these 28 human-competitive results that relate to previously patented inventions. Twelve of the results in Table 1 infringe previously issued patents and 10 duplicate the functionality of previously patented inventions in a noninfringing way.
Table 1. Twenty-eight previously patented inventions reinvented by genetic programming
It should also be mentioned that there are over a dozen additional known instances where genetic programming has produced a human-competitive result that are not patent related, including the design of an X-Band Antenna for NASA's Space Technology 5 Mission by Jason Lohn and his group at NASA Ames (Lohn et al., Reference Lohn, Hornby, Linden, O'Reilly, Riolo, Yu and Worzel2004), Lee Spector's quantum computing elements (Spector, Barnum, & Bernstein, Reference Spector, Barnum, Bernstein and Koza1998, 1999; Spector, Barnum, Bernstein, & Swamy, Reference Spector, Barnum, Bernstein and Swamy1999; Spector, Reference Spector2004), a sorting network (Koza, Bennett, Andre, & Keane, Reference Koza, Bennett, Andre and Keane1999), game-playing strategies (Luke, Reference Luke and Koza1998; Andre & Teller, Reference Andre, Teller, Asada and Kitano1999), algorithms for cellular automata (Andre et al., Reference Andre, Bennett, Koza, Koza, Goldberg, Fogel and Riolo1996), and algorithms for protein segment classification (Koza, Bennett, Andre, & Keane, Reference Koza, Bennett, Andre and Keane1999). Starting in 2004, GECCO began giving awards for human-competitive results and many of these results were achieved by means of genetic programming (http://www.human-competitive.org).
3. ADDITIONAL SOURCES OF INFORMATION ABOUT GENETIC PROGRAMMING
In addition to the earlier citations, additional information about genetic programming may be obtained from books such as Genetic Programming and Data Structures: Genetic Programming + Data Structures = Automatic Programming! (Langdon, Reference Langdon1998); Automatic Re-engineering of Software Using Genetic Programming (Ryan, Reference Ryan1999); Data Mining Using Grammar Based Genetic Programming and Applications (Wong & Leung, Reference Wong and Leung2000); Principia Evolvica: Simulierte Evolution mit Mathematica (Jacob, Reference Jacob1997); Illustrating Evolutionary Computation with Mathematica (Jacob, Reference Jacob2001); Genetic Programming (Iba, Reference Iba1996, in Japanese); Evolutionary Program Induction of Binary Machine Code and Its Application (Nordin, Reference Nordin1997); Foundations of Genetic Programming (Langdon & Poli, Reference Langdon and Poli2002); Emergence, Evolution, Intelligence: Hydroinformatics (Babovic, Reference Babovic1996); Theory of Evolutionary Algorithms and Application to System Synthesis (Blickle, Reference Blickle1997); and Automatic Quantum Computer Programming: A Genetic Programming Approach (Spector, Reference Spector2004).
Additional information about genetic programming may be obtained from edited collections of papers such as the three Advances in Genetic Programming books from MIT Press (Kinnear, Reference Kinnear1994; Angeline & Kinnear, 1996; Spector et al., Reference Spector, Langdon, O'Reilly and Angeline1999) and the proceedings of the Genetic Programming Conferences held between 1996 and 1998 (Koza, Goldberg, et al., 1996; Koza et al., Reference Koza, Deb, Dorigo, Fogel, Garzon, Iba and Riolo1997, Reference Koza, Banzhaf, Chellapilla, Deb, Dorigo, Fogel, Garzon, Goldberg, Iba and Riolo1998).
John R. Koza is a Consulting Professor in the Biomedical Informatics Program in the Department of Medicine and the Department of Electrical Engineering at Stanford University. He is the author of the 1992 book Genetic Programming: On the Programming of Computers by Means of Natural Selection, three subsequent books on genetic programming, and over 250 papers on genetic programming, genetic algorithms, and artificial life.
