Content uploaded by Julian Francis Miller
Author content
All content in this area was uploaded by Julian Francis Miller
Content may be subject to copyright.
Self Modifying Cartesian Genetic Programming:
Fibonacci, Squares, Regression and Summing
Simon Harding1, Julian F. Miller2, and Wolfgang Banzhaf1
1Department of Computer Science, Memorial University, Canada
{simonh,banzhaf}@cs.mun.ca
http://www.cs.mun.ca
2Department Of Electronics, University of York, UK
jfm7@ohm.york.ac.uk
http://www.elec.york.ac.uk
Abstract. Self Modifying CGP (SMCGP) is a developmental form of
Cartesian Genetic Programming(CGP). It is able to modify its own phe-
notype during execution of the evolved program. This is done by the
inclusion of modification operators in the function set. Here we present
the use of the technique on several different sequence generation and re-
gression problems.
Keywords: Genetic programming, developmental systems.
1 Introduction
In biology, the process whereby genotypes gives rise to a phenotype can be
regarded as a form of self-modification. At each decoding stage, the expressed
genes, the local environment and the cellular machinery influence the subsequent
genetic expression [1,2]. The concept of self-modification can be a unifying way of
looking at development that allows the inclusion of genetic regulatory processes
inside single cells, graph re-writing and multi-cellular systems.
In evolutionary computation self-modification has not been widely considered,
but Spector and Stoffel examined its potential in their ontogenetic programming
paper [3]. It also has been studied in the the graph re-writing system of Gruau [4]
and was implicitly considered in Miller [5]. However, recently, much work in com-
putational development has concentrated at a multi-cellular level and the aim has
been to show that evolution could produce developmental cellular programs that
could construct various cellular pattern [6]. A common motivation for evolvingde-
velopmental programs is that they may allow the evolution of arbitrarily large sys-
tems which are infeasible to evolve using a direct genetic representation. However
many of the proposed developmental approaches are not explicitly computational
in that often one must apply some other mapping process from the developed cel-
lular structure into a computation. Further discussion of our motivation, and how
it relates to previous work, can be found in [7].
In our previous work, we showed that by utilizing self-modification opera-
tions within an existing computational method (a form of genetic programming,
L. Vanneschi et al. (Eds.): EuroGP 2009, LNCS 5481, pp. 133–144, 2009.
c
Springer-Verlag Berlin Heidelberg 2009
134 S. Harding, J.F. Miller, and W. Banzhaf
called Cartesian Genetic Programming, CGP) we could obtain a system that
(a) could develop over time in interaction with environmental inputs and (b)
would at every stage provide a computational function [7]. It could stop its own
development, if required, without external input. Another interesting feature of
the approach is that, in principle, programs could be evolved which allow the
replication of the original code.
Here we demonstrate SMCGP on a number of different tasks. The problems
illustrate different aspects and capabilities of SMCGP, and are intended to be
representative of the types of problems we will investigate in future.
2SelfModifyingCGP
2.1 Cartesian Genetic Programming (CGP)
Cartesian Genetic Programming represents programs as directed graphs [8].
Originally CGP used a program topology defined by a rectangular grid of nodes
with a user defined number of rows and columns. However, later work on CGP
always chose the number of rows to be one, thus giving a one-dimensional topol-
ogy, as used in this paper. In CGP, the genotype is a fixed-length representation
and consists of a list of integers which encode the function and connections of
each node in the directed graph.
CGP uses a genotype-phenotype mapping that does not require all of the
nodes to be connected to each other, resulting in a bounded variable length
phenotype. This allows areas of the genotype to be inactive and have no influence
on the phenotype, leading to a neutral effect on genotype fitness called neutrality.
This type of neutrality has been investigated in detail [8,9,10] and found to be
beneficial to the evolutionary process on the problems studied.
2.2 SMCGP
In this paper, we use a slightly different genotype representation to previously
published work using CGP.
Fig. 1. The genotype maps directly to the initial graph of the phenotype. The genes
control the number, type and connectivity of each of the nodes. The phenotype graph
is then iterated to perform computation and produce subsequent graphs.
Self Modifying Cartesian Genetic Programming 135
Fig. 2. Example program execution. Showing the DUP(licate) operator being acti-
vated, and inserting a copy of a section of the graph (itself and a neighboring functions
on either side) elsewhere in the graph in next iteration. Each node is labeled with a
function, the relative address of the nodes to connect to and the parameters for the
function (see Section 2.4).
As in CGP an integer gene (in our case the first) encodes the function the node
represents. This is followed by a number of integer connection genes that indicate
the location in the graph where the node takes its inputs from. However in SMCGP
there are also three real-valued genes that encode parameters required for the node
function. Also there is a binary gene that indicates if the node should be used as
an program output. In this paper all nodes take two inputs, hence each node is
specified by 7 genes. An example genotype is shown in Figure 1.
Like CGP, nodes take their inputs in a feed-forward manner from either the
output of a previous node or from a program input (terminal). The actual num-
ber of inputs to a node is dictated by the arity of its function. However, unlike
previous implementations of CGP, nodes are addressed relatively and specify
how many nodes back in the graph they are connected to. Hence, if the connec-
tion gene is 1 it means that the node will connect to the previous node in the
list, if the gene has value 2 then the node connects 2 nodes back and so on. All
such genes are constrained to be greater than 0, to avoid nodes referring directly
or indirectly to themselves.
If a gene specifies a connection pointing outside of the graph, i.e. with a
larger relative address than there are nodes to connect to, then this is treated as
connecting to zero value. Unlike classic CGP, inputs arise in the graph through
special functions. This is described in section 2.3. The relative addressing of
connection genes allows sub-graphs to be placed or duplicated elsewhere in the
graph whilst retaining their semantic validity.
This encoding is demonstrated visually in Figure 2.
The three node function parameter genes are primarily used in performing
modification to the phenotype. In the genotype they are represented as real
numbers but be cast (truncated) to integers if certain functions require it.
Section 4 details the available functions and any associated parameters.
2.3 Inputs and Outputs
The way we handled inputs in our original paper on SMCGP was flawed. We
found, it did not scale well as sub-graphs became disconnected from inputs, as
136 S. Harding, J.F. Miller, and W. Banzhaf
self-modifying functions moved them away from the beginning of the graph and
they lost their semantic validity. The new input strategy required two simple
changes from conventional CGP and our previous work in SMCGP.
The first, was to make all negative addressing return false (or 0 for non-binary
versions of SMCGP). In previous work [7], we used negative addresses to connect
nodes to input values.
The second was to change how the INPUT function works. When a node is of
type INP (shorthand for INPUT), each successive call gets the next input from
the available set of inputs. If the INP node is called more times than there are
inputs, the counting starts from the beginning again, and the first node is used.
Outputs are handled slightly differently to inputs. We added another gene to
the SMCGP node that decides whether the phenotype could use that node as
an output. In previous work, we used the last n-nodes in the graph to represent
the n-outputs. However, as with the inputs, we felt this approach did not scale
as the graph changes size. When an individual is evaluated, the first stage is to
identify the nodes in the graph that have their output gene set to 1. Once these
are found, the graph can be evaluated from each of these nodes in a recursive
manner.
If no nodes are flagged as outputs, the last n nodes in the graph are used as
the n-outputs. Essentially, this reverts the system back to the previous approach.
If there are more nodes flagged as outputs than are required, then the leftmost
nodes that have flagged outputs are used until the required number of outputs
is reached. If there are fewer nodes in the graph than required outputs, the
individual is deemed to be corrupt and it is not evaluated (it is given a bad
fitness score to ensure that it is not selected for).
2.4 Evaluation of the SMCGP Graph
From a high level perspective, when a genotype is evaluated the process is as
follows. The initial phenotype graph is a copy of the genotype graph. This graph
is then executed, and if there are any modifications to be made, they alter the
phenotype graph.
The genotype is invariant during the entire evaluation of the individual. All
modifications are made to the phenotype which starts out as a copy of the
genotype. In subsequent iterations, the phenotype will usually gradually diverge
from the genotype.
The encoded graph is executed in the same manner as standard CGP, but
with changes to allow for self-modification. The graph is executed by recursion,
starting from the output nodes down through the functions, to the input nodes.
In this way, nodes that are unconnected (’junk’) are not processed and do not
affect the behavior of the graph at that stage.
For non-self modification function nodes the output value, as in GP in general,
is the result of the mathematical operation on input values.
On executing a self-modification node, a comparison is made of the two input
values. If the second value is less than the first, the second value is passed
through. Otherwise, the node is activated and the first value passed through
Self Modifying Cartesian Genetic Programming 137
and the self-modification function in that node is added to a “To Do” list of
pending modifications. This makes the execution of the self modifying function
dependent on the data passing through the program.
After each iteration, the “To Do” list is parsed, and all manipulations are
performed (provided they do not exceed the number of operations specified in the
user defined “To Do” list length). The parsing is done in order of the instructions
being appended to the list, i.e. first in is first to be executed.
The length of the list can be limited as manipulations are relatively compu-
tationally expensive to perform. Here, we limit the length to just 2 instructions.
All graph manipulation functions require a number of parameters, as described
in section 4.
3 Evolutionary Algorithm and Parameters
We use an (1+4) evolutionary strategy for the experiments in this paper. We
bootstrap the process by testing a population of 50 random individuals. We
then select the best individual and generate four offspring. We test these new
individuals, and use the best of these to generate the next population. If there is
more than one best in the population and one of these is the parent, we always
choose the offspring to encourage neutral drift (see section 2.1).
We have used a relatively high (for CGP) mutation rate of 0.1. This means
that each gene has a probability of 0.1 of being mutated. Mutations for the
function type and relative addresses themselves are unbiased; a gene can be
mutated to any other valid value.
For the real-valued genes, the mutation operator can choose to randomize the
value (with probability 0.1) or add noise (normally distributed, sigma 20).
Evolution is limited to 10,000,000 evaluations. Trials that fail to find a solution
in this time are considered to have failed.
The evolutionary parameter values have not been optimized, and we would
expect performance increases if more suitable values were used.
4 Function Set
The function set is defined in two parts. The first is a set of modification opera-
tors, as shown in table 1. These are common to all data types used in SMCGP.
The functions chosen are intended to give coverage to as many modification
operations as possible. The remainder of the set are the computational opera-
tions. The data type these functions manipulate is determined by the problem
definition. Table 2 contains definitions for all the numerical (i.e. non-modifying)
operators that are available. Depending on the experiment, different sub-sets of
this set are used.
The way self modifying functions act is defined by 4 variables. The three genes
that are double precision numbers, here we call them “parameters” and denote
them P0,P1,P2. The other variable is the integer position of the node in the
phenotype graph that contained the self modifying function (i.e. the leftmost
138 S. Harding, J.F. Miller, and W. Banzhaf
Table 1 . Self modification functions
Function name Description
Duplicate and scale ad-
dresses (DU4)
Starting from position (P0+x)copy(P1)nodesand
insert after the node at position (P0+x+P1). During
the copy, cij of copied nodes are multiplied by P2.
Shift Connections
(SHIFTCONNECTION)
Starting at node index (P0+x), add P2to the values of
the cij of next P1nodes.
Shift By Mult Connec-
tions (MULTCONNEC-
TION)
Starting at node index (P0+ x), multiply the cij of the
next P1nodes by P2nodes.
Move (MOV) Move the nodes between (P0+x)and(P0+x+P1)and
insert after (P0+x+P2).
Duplication (DUP) Copy the nodes between (P0+x)and(P0+x+P1)and
insert after (P0+x+P2).
Duplicate, Preserving
Connections (DU3)
Copy the nodes between (P0+x)and(P0+x+P1)and
insert after (P0+x+P2). When copying, this function
modifies the cij of the copied nodes so that they continue
to point to the original nodes.
Delete (DEL) Delete the nodes between (P0+x)and(P0+x+P1).
Add (ADD ) Add P1new random nodes after (P0+x).
Change Function (CHF) Change the function of node P0to the function associ-
ated with P1.
Change Connection
(CHC)
Change the (P1mod3)th connection of node P0to P2.
Change Parameter (CHP) Change the (P1mod3)th parameter of node P0to P2.
Overwrite (OVR) Copy the nodes between (P0+x)and(P0+x+P1)
to (P0+x+P2), replacing existing nodes in the target
position.
Copy To Stop (COPY-
TOSTOP)
Copy from xto the next “COPYTOSTOP” function
node, “STOP” node or the end of the graph. Nodes are
inserted at the position the operator stops at.
node is position 0), we denote this x. In the definitions of the SM functions we
often need to refer to the values taken by node connection genes (which are all
relative addresses). We denote the jth connection gene on node at position i,
by cij .
There are several rules that decide how addresses and parameters are
treated:
–When Piare added to the x, the result is treated as an integer.
–Address indexes are corrected if they are not within bounds. Addresses below
0 are treated as 0. Addresses that reach beyond the end of the graph are
truncated to the graph length.
–Start and end indexes are sorted into ascending order (if appropriate).
–Operations that are redundant (e.g. copying 0 nodes) are ignored, however
they are taken into account in the ToDo list length.
Self Modifying Cartesian Genetic Programming 139
Table 2 . Numeric and other functions
Function name Description
No operation (NOP) Passes through the first input.
Add, Subtract, Multiply,
Divide (DADD, DSUB,
DMULT, DDIV)
Performs the relevant mathematical operation on the two
inputs.
Const (CONST) Returns a numeric constant as defined in parameter P0.
√x,1
√xCos, Sin, TanH,
Absolute (SQRT, DRCP,
COS, SIN, TANH, DABS)
Performs the relevant operation on the first input (ig-
noring the second input).
Average (AVG) Returns the average of the two inputs.
Node index (INDX) Returns the index of the current node. 0 being the first
node.
Input count (INCOUNT) Returns the number of program inputs.
Min, Max (MIN, MAX) Returns the minimum/maximum of the two inputs.
5 Experiments
5.1 Mathematical Functions and Sequences
We can use SMCGP to produce numeric sequences, where the program provides
the first number on the first iteration, the 2nd on the next and continues to
generate the next number in a sequence as we iterate the program. For these
sequences, the input value to the program is fixed to 1. This forces the program
to modify itself to produce a new program that produces the next digit. We
demonstrate this ability on two sequences of integers; Fibonacci and a list of
square numbers.
Squares. In this task, a program is evolved that generates a sequence of squares
0,1,2,4,9,16,25,... without using multiplication or division operations. As Spector
(who first devised this problem) points out, this task can only be successfully
performed if the program can modify itself - as it needs to add new function-
ality in the form of additions to produce the next integer in the sequence [3].
Hence, conventional genetic programming, including CGP, will be unable to find
a general solution to this problem.
The function set for this experiment includes all the self modification functions
and DADD, CONST, INP, MIN, MAX, INDX, SORT and INCOUNT.
Table 3 shows a summary of results for the squares problem (based on 110
runs). Programs were evolved to produce the first 10 terms in the sequence,
with the fitness score being the number of correctly produced numbers. After
successfully evolving a program that generates this sequence, the programs were
tested on their ability to generalize to produce the first 100 numbers in the
sequence. It was found that 84.3% of solutions generalised.
We found that as the squaring program iterates, the length of the phenotype
graph increased linearly. However, the number of active nodes inside the graph
fluctuated a lot on early iterations but stabilized after about 15 iterations.
140 S. Harding, J.F. Miller, and W. Banzhaf
Table 3 . Evaluations required to evolve a program that can generate the squares
sequence
Avg. Evaluations Std. dev. Min. evaluations Max. evaluation % generalize
141,846 513,008 392 3,358,477 84.3
Table 4 . Success and evaluations required to evolve programs that generate the Fi-
bonacci sequence. The starting condition and the length appear to have little influence
on the the success rate of time taken. Percentage of solutions that generalize to solve
up to 74 terms.
Start Max. Iterations % Success Avg Evals % Generalise
01 12 89.1 1,019,981 88.6
01 50 87.4 774,808 94.5
12 12 86.9 965,005 90.4
12 50 90.8 983,972 94.4
Fibonacci. Koza demonstrated that recursive tree structures could be evolved
that generate the Fibonacci sequence [11]. Huelsbergen evolved machine lan-
guage programs in approximately 1 million evaluations, and found that all his
evolved programs were able to generalise [12]. Nishiguchi [13] successfully evolved
recursive solutions with a success rate of 70%. The algorithm quickly evolves
solutions in approximately 200,000 evaluations. However, the authors do not ap-
pear to test for generalisation. More recently, Agapitos and Lucas used a form
of object oriented GP to solve this problem [14]. They tested their programs on
the first 12 numbers in the sequence, and tested for generality. Generalization
was achieved with 25% success and on average required 20 million evaluations.
In addition, they note that their approach is computationally expensive. In [15]
a graph based GP (similar to CGP) was demonstrated on this problem, however
the approach achieved a success rate of only 8% on the training portion (first
12 integers) of the sequence. Wilson and Heywood evolved recursive programs
using Linear GP that solved up to order-3 Fibonacci sequences [16]. On average
solutions were discovered in 2.12 ×105evaluations, with a generalization rate of
83%. We evolve for both the first 12 and 50 numbers in the sequence and test
for generality to 74 numbers (after which the value exceeds a long int).
Table 4 shows the success rate and number of evaluations required to evolve
programs that produce the Fibonacci sequence (based on 287 runs). As with
the squares problem, the fitness function is the number of correctly outputted
numbers. The starting condition (either 0,1 or 1,2) and the length of the target
sequence appear to have little influence on the success rate of time taken. The
results show that sequences that are evolved to produce the first 50 numbers
do better at generalizing to produce the first 74 numbers. However, the starting
condition again makes no difference.
Sum of numbers. Here we wished to evolve a program that could sum an
arbitrarily long list of numbers. At the n-th iteration, the evolved program should
Self Modifying Cartesian Genetic Programming 141
Table 5 . Evaluations required to evolve a program that can add a set of numbers
Average Minimum Maximum Std. Deviation
6,922 2,27 2,9603 4,998
Table 6 . Evaluations required to evolve a SMCGP program that can add a set of
numbers of a given size. 100% of SMCGP experiments were successful. The % success
rate for conventional CGP is also shown.
Size of set Average Minimum Maximum Std. dev %CGP
250 50 50 0100
3618 54 3,248 566 80
41,266 64 9,334 1,185 95.8
51,957 116 9,935 1,699 48
62,564 120 11,252 2,151 38.1
73,399 130 17,798 2,827 0
84,177 184 17,908 3,208 0
95,138 190 18,276 3,871 0
10 5,918 201 22,204 4,401 0
be able to take n inputs and compute the sum of all the inputs. We devised this
problem because we thought it would be difficult for genetic programming, but
relatively easy for a technique such as neural networks. The premise being, that
neural networks appear to perform well when combining input values and genetic
programming seems to prefer feature selection on the inputs.
Input vectors consist of random sequences of integers. The fitness is defined
as the absolute cumulative error between the output of the program and the
expected sum of the values. We evolved programs which were evaluated on input
sequences of 2 to 10 numbers. The function sets consists of the self modifying
functions and just the ADD operator.
Table 5 summarizes the results this problem. All experiments were found to
be successful, in that they evolved programs that could sum between 2 and 10
numbers (depending on the number of iterations the program is iterated). Table
6 shows the number of evaluations required to reach the nth sum (where n is
from 2 to 10).
After evolution, the best individual for each run was tested to see how well
it generalized. This test involved summing a sequence of 100 numbers. It was
found that most solutions generalized, however in 0.07% of cases, they did not.
We also tested the ability of conventional CGP to sum a set of numbers.
Here CGP could only be evolved for a given size of set of input numbers. The
results (based on 500 runs) are also shown in table 6. It is revealed that CGP
is able to solve this problem only for a smaller sets of numbers. This shows
a clear benefit of the self-modification approach in comparison with the direct
encoding.
142 S. Harding, J.F. Miller, and W. Banzhaf
5.2 Regression and Classification
Bioinformatics Classification. In this experiment, SMCGP is applied to the
protein classification problem described in [17]. The task is to predict the location
of a protein in a cell, from the amino acids in the particular protein. The entire
dataset was used for the training set. The set consisted of 2,427 entries, with
19 variables each and 1 output. The function set for SMCGP includes all the
mathematical operators in addition to the self modifying command set. The
CGP function set contained just the mathematical operators (see section 4). For
this type of problem, it is not clear that a self-modification approach would have
advantages compared with classic CGP. Also, we added the number of iterations
to the genotype so that the phenotype is iterated that many times before being
executed on the training set.
Table 7 shows the summary of results for this problem (based on 100 runs of
each representation). Both CGP and SMCGP perform similarly. The addition of
the self modification operations does not appear to hinder evolvability - despite
the increase in search space size.
Table 7. Results summary for the bio informatics classification problem
-CGP SMCGP
Average fitness (training) 66.81 66.83
Std. dev. fitness (training) 6.35 6.45
Average fitness (validation) 66.10 66.18
Std. dev. fitness (validation) 5.96 6.46
Avg. evaluations to best fitness (training) 7,679 7,071
Std. dev. evaluations to best fitness (training) 2,452 2,644
Avg. evaluations to best fitness (validation) 7,357 7,161
Std. dev. evaluations to best fitness (validation) 2,386 2,597
Powers Regression. A problem was devised that tests the ability of SMCGP
to learn a ‘modular’ regression problem. The task is to evolve a program that,
depending on the iteration, approximates the expression xnwhere n is the itera-
tion number. The fitness function applies x as integers from 0 to 20. The fitness
is defined as the number of wrong outputs (i.e. lower is better).
The function set contains all the modification operators (section 4) and NOP,
DADD, DSUB, NOP, DADD, DSUB, DMULT, DDIV, CONST, INDX and IN-
COUNT from the numeric operations (section 4).
Programs are evolved to n= 10 and then tested for generality up to n= 20.
As with other experiments, the program is evolved incrementally. Where it first
tries to solves n=1 and if successful, is evaluated and evolved for n=1 and n=2
until eventually it is evaluated on n=1 to 10.
Table 8 shows the results summary for the powers regression problem. All 337
runs were successful. In this instance, there is an interesting difference between
the two starting conditions. If the fitness function starts with n= 1 to 5, it is
found that that fewer evaluations are required to reach n= 10. However, this
Self Modifying Cartesian Genetic Programming 143
Table 8 . Summary of results for the powers regression problem
Number of Initial Test Sets Average Evaluations Std Dev. Percentage Generalize
1687,156 869,699 60.4
5527,334 600,800 55.6
leads to reduced generalization. Using a Kolmogorov-Smirnov test, it was found
that the difference in the evaluations required is statistically significant (p=0.0).
6 Conclusions
We have examined and discussed a developmental form of Cartesian Genetic
Programming called Self Modifying CGP and evaluated and compared it with
classic CGP on a number of diverse problems. We found that it is more efficient
than classic CGP at solving four of the test problems: Fibonacci sequence, se-
quence of squares, sum of inputs, and a power function. In addition it appears
that it was able to obtain general solutions for all these problems, although
full confirmation of this will require further analysis of evolved programs. On a
fourth problem, classification it performed no worse than CGP despite a larger
search space.
Other approaches to solving problems, such as Fibonacci, produce a com-
puter program. Instead, at each iteration we produce a structure that produces
the output. This could be considered as unrolling the loops (or recursion) in a
program. In a related paper [18], we use this structure building approach to con-
struct digital circuits. In future work, we will investigate SMCGP when used as
a continuous program. We believe combining both approaches will be beneficial.
References
1. Banzhaf, W., Beslon, G., Christensen, S., Foster, J.A., K´ep`es, F., Lefort, V., Miller,
J.F., Radman, M., Ramsden, J.J.: From artificial evolution to computational evo-
lution: A research agenda. Nature Reviews Genetics 7, 729–735 (2006)
2. Kampis, G.: Self-modifying Systems in Biology and Cognitive Science. Pergamon
Press, Oxford (1991)
3. Spector, L., Stoffel, K.: Ontogenetic programming. In: Koza, J.R., Goldberg, D.E.,
Fogel, D.B., Riolo, R.L. (eds.) Genetic Programming 1996: Proceedings of the First
Annual Conference, pp. 394–399. MIT Press, Stanford University (1996)
4. Gruau, F.: Neural network synthesis using cellular encoding and the genetic al-
gorithm. Ph.D. dissertation, Laboratoire de l’Informatique du Parall´elisme, Ecole
Normale Sup´erieure de Lyon, France (1994)
5. Miller, J.F., Thomson, P.: A developmental method for growing graphs and circuits.
In: Tyrrell, A.M., Haddow, P.C., Torresen, J. (eds.) ICES 2003. LNCS, vol. 2606,
pp. 93–104. Springer, Heidelberg (2003)
6. Kumar, S., Bentley, P.: On Growth, Form and Computers. Academic Press, London
(2003)
144 S. Harding, J.F. Miller, and W. Banzhaf
7. Harding, S.L., Miller, J.F., Banzhaf, W.: Self-modifying cartesian genetic program-
ming. In: Thierens, D., Beyer, H.-G., et al. (eds.) GECCO 2007: Proceedings of
the 9th annual conference on Genetic and evolutionary computation, vol. 1, pp.
1021–1028. ACM Press, London (2007)
8. Miller, J.F., Thomson, P.: Cartesian genetic programming. In: Poli, R., Banzhaf,
W., Langdon, W.B., Miller, J., Nordin, P., Fogarty, T.C. (eds.) EuroGP 2000.
LNCS, vol. 1802, pp. 121–132. Springer, Heidelberg (2000)
9. Vassilev, V.K., Miller, J.F.: The advantages of landscape neutrality in digital circuit
evolution. In: Miller, J.F., Thompson, A., Thompson, P., Fogarty, T.C. (eds.) ICES
2000. LNCS, vol. 1801, pp. 252–263. Springer, Heidelberg (2000)
10. Yu, T., Miller, J.: Neutrality and the evolvability of boolean function landscape.
In: Miller, J., Tomassini, M., Lanzi, P.L., Ryan, C., Tetamanzi, A.G.B., Langdon,
W.B. (eds.) EuroGP 2001. LNCS, vol. 2038, pp. 204–217. Springer, Heidelberg
(2001)
11. Koza, J.: Genetic Programming: On the Programming of Computers by Natural
Selection. MIT Press, Cambridge (1992)
12. Huelsbergen, L.: Learning recursive sequences via evolution of machine-language
programs. In: Koza, J.R., Deb, K., et al. (eds.) Genetic Programming 1997: Pro-
ceedings of the Second Annual Conference, pp. 186–194. Morgan Kaufmann, Stan-
ford University (1997)
13. Nishiguchi, M., Fujimoto, Y.: Evolution of recursive programs with multi-niche
genetic programming (mnGP). In: Evolutionary Computation Proceedings, 1998.
IEEE World Congress on Computational Intelligence, pp. 247–252 (1998)
14. Agapitos, A., Lucas, S.M.: Learning recursive functions with object oriented genetic
programming. In: Collet, P., Tomassini, M., Ebner, M., Gustafson, S., Ek´art, A.
(eds.) EuroGP 2006. LNCS, vol. 3905, pp. 166–177. Springer, Heidelberg (2006)
15. Shirakawa, S., Ogino, S., Nagao, T.: Graph structured program evolution. In: Pro-
ceedings of the 9th annual conference on Genetic and evolutionary computation,
pp. 1686–1693. ACM, London (2007)
16. Wilson, G., Heywood, M.: Learning recursive programs with cooperative coevolu-
tion of genetic code mapping and genotype. In: GECCO 2007: Proceedings of the
9th annual conference on Genetic and evolutionary computation, pp. 1053–1061.
ACM Press, New York (2007)
17. Langdon, W.B., Banzhaf, W.: Repeated sequences in linear genetic programming
genomes. Complex Systems 15(4), 285–306 (2005)
18. Harding, S., Miller, J.F., Banzhaf, W.: Self modifying cartesian genetic program-
ming: Parity. In: CEC 2009 (2009) (submitted)
