An empirical analysis through the time complexity of GE problems

Abstract

Computational complexity analysis on Evolutionary Algorithms can provide crucial insight into how they work. While relatively straight forward for fixed length structures, it is less so for variable length structures, although initial work has already been conducted on tree based Genetic Programming (GP) algorithms. Grammatical Evolution (GE) is a variable length string based Evolutionary Algorithm (EA) that evolves arbitrarily complex programs through complex gene interactions, but thus far, no such analysis has been conducted.

We empirically analyse the time complexity of GE on two well known GP problems: the Santa Fe Ant Trail
and a Symbolic Regression problem. Using a power law, we analyse the time complexity of GE in terms of population size. As a result of this, several observations are made estimating the average terminating generation, actual length and effective lengths of individuals based on the quality of the solution. We show that even with the extra layer of complexity of GE, time increases linearly for GE on Santa Fe Ant Trail problem and quadratic in nature on a symbolic regression problem as the size of simulations (i.e. population size) increase. To the best of our knowledge, this is the first attempt measuring the run-time complexity of GE. This analysis provides a way to produce a reasonably good prediction system of how a particular run will perform, and we provide details of how one can leverage this data to predict the success or otherwise of a GE run in the early generations. with the amount of data collected.

Full text

AN EMPIRICAL ANALYSIS THROUGH THE TIME
COMPLEXITY OF GE PROBLEMS
Gopinath Chennupati, Conor Ryan, R.Muhammad Atif Azad
University of Limerick
Department of Computer Science and Information Systems
Castletroy, Limerick.
Ireland
Gopinath.Chennupati@ul.ie, Conor.Ryan@ul.ie, Atif.Azad@ul.ie
Abstract: Computational complexity analysis on Evolutionary Algorithms can provide crucial insight into how
they work. While relatively straight forward for fixed length structures, it is less so for variable length structures,
although initial work has already been conducted on tree based Genetic Programming (GP) algorithms. Gram-
matical Evolution (GE) is a variable length string based Evolutionary Algorithm (EA) that evolves arbitrarily
complex programs through complex gene interactions, but thus far, no such analysis has been conducted.
We empirically analyse the time complexity of GE on two well known GP problems: the Santa Fe Ant Trail
and a Symbolic Regression problem. Using a power law, we analyse the time complexity of GE in terms of pop-
ulation size. As a result of this, several observations are made estimating the average terminating generation,
actual length and effective lengths of individuals based on the quality of the solution. We show that even with
the extra layer of complexity of GE, time increases linearly for GE on Santa Fe Ant Trail problem and quadratic
in nature on a symbolic regression problem as the size of simulations (i.e. population size) increase. To the best
of our knowledge, this is the first attempt measuring the run-time complexity of GE. This analysis provides a
way to produce a reasonably good prediction system of how a particular run will perform, and we provide details
of how one can leverage this data to predict the success or otherwise of a GE run in the early generations. with
the amount of data collected.
Keywords: Grammatical Evolution, Genetic Programming, Computational Complexity, Execution Time, Power
Law, Empirical Analysis, etc.
1 Introduction
Time complexity analysis is crucial for any search algorithm, as it dictates its general applicability. The more
predictable an algorithm is in terms of time cost, the more useful it is. Execution time has long been a
challenge to the field of Evolutionary Computation (EC). In particular, the stochastic and iterative nature
of the underlying algorithms often arouse suspicion in those more accustomed to dealing with deterministic
algorithms. However, if one could prove that EC methods can provide competitive solutions in less time than
their deterministic counterparts, then their acceptance into more general Computer Science and engineering
fields would be accelerated.
Although there has been much time complexity analysis of general EAs, [4, 12, 3] no such analysis has been
conducted on GE, with most analysis concentrating on the performance impact of operators such as crossover
[15] and search operators [14]. For example, [5] conducted an analysis of GP design through the investigation
of the impact of neutral moves and the importance of a local mutation operator. A simple analysis on mutation
in GE [2] produced interesting results, but with out any computational complexity analysis. Although there
is some work being done in analyzing the computation complexity of GP [9, 23], GE varies from GP with the
introduction of grammars and mapping.
The contribution of this paper is to estimate the time complexity of GE in terms of its population size. We
show, how the time complexity changes with respect to the population size on two GE archetypal problems Santa
Fe Ant Trail and symbolic regression. We produce an empirical study on time complexity of GE using simple
algorithm analysis approaches such as power law and doubling hypothesis. This empirical analysis predicts the
time complexity of GE on Santa Fe Ant Trail as Onand on a symbolic regression problems as On2. As
part of this analysis we make a few interesting observations on the terminating generation, actual length and
effective length of a GE individual on both the problems. These measures describe the number of generations
that the algorithm needs to be run to produce the best solution with respect to the problem. We conclude with
a hope to produce an effective prediction system in future based on the data gathered during this experiments.

The organization of this paper is as follows. We describe the related work in section 2. Next, we introduce
GE in section 3 and, in section 4, we explain the Power Law which we use to estimate the time complexity of
GE. The experimental approach and results are explained in section 5. Next, empirical analysis through the
time complexity of GE on two GE archetypal problems, are presented in section 6. In section 7, we discuss our
findings and, finally, we conclude and provide recommendations for future work in section 8.
2 Related Work
To the best of our knowledge this is the first attempt on calculating the time complexity and execution time
of GE. However, there have been some notable attempts made on analyzing the computational complexity of
evolutionary algorithms. Works such as [4, 12] theoretically showed how to calculate the computational com-
plexity of evolutionary algorithms for combinatorial optimization problems. A general approach was proposed
in [3] which analysed average time complexity of evolutionary algorithms on uni-modal problems by generalizing
the concept of takeover time to EAs with mutation. This showed that EAs with bitwise mutation and elitist
selection strategies, need On ln n +n2/Nand On ln ln n +n ln n/Ngenerations to find the global opti-
mum, respectively. Mathematical models and analysis tools such as Markov chain models [18] and Martingale
models with Stochastic Lyapunov function [6] were presented to analyse the evolutionary algorithms. Markov
chain models summarized the results on the limit and finite time behaviour of EAs with finite search spaces and
discrete time scale, while Martingale models estimated upper and lower bounds of the mean hitting times of
EAs, to provide a general classification of easy and hard problems for EAs. Finally, [1] described how to analyse
evolutionary algorithms to predict the time complexity and showed that the time complexity of an algorithm
basically depends upon the time to complete the execution.
The EC literature contains some examples of measuring and accounting for the execution times of evolu-
tionary algorithms. For example, [8] reduced the execution time of genetic algorithms in real world applications
using fitness prediction, while [16] noted that the run time of GP is the product of the number of runs, the
number of generations, the size of the population, the average size of the programs and the number of fitness
cases. Initial results [9] from a simple analysis of computational complexity of GP showed how design choices
of algorithm components impact its success, while [23] observed maximum tree size as well as population size
in analyzing computational complexity on multi-objective models.
Given that GE has an extra step to GP, in the form of its mapping, it is not clear that these results are
directly transferable to GE, partly due to the extra step, but also, probably more importantly, the complex
relationship between individual (genome) length and time required for mapping shown in [20]. This means that
an individual twice as long in GE will not necessarily take twice as long to map.
In this paper, we take a simple approach to analyse the time complexity of GE using doubling hypothesis and
a power law, a traditional way of empirically analysing algorithms. We take the log value graphs of execution
time to analyse the time complexity of grammatical evolution. Poli et al. [17] state that they expect to see
computational complexity techniques being used to model simple GP systems. The analysis in this paper is a
try towards that prediction, believing GE also needs such an analysis. Based on this analysis we can produce
new methods of prediction systems to optimize the performance of GE execution. Before we describe our work,
we provide an outline of grammatical evolution and power law.
3 Grammatical Evolution
GE [19] is an evolutionary algorithm that can evolve computer programs in an arbitrary language. Unlike
standard GP, GE uses a linear genome representation and the rules of the BNF grammars to govern what
legal structures can be produced. Each individual in the GE population is a variable length binary string and,
typically, the genome is divided into 8 bit codons, which are used to select the possible rules of the grammar.
A step by step procedure of GE is shown in Algorithm 1. The algorithm stops upon reaching a convergence
criterion. Convergence is a value between 0 and 1 as defined in [11]. Convergence of 1 means the nth previous
best solution of generation is equal to the current best solution of generation. Using this criterion as terminating
condition enabled us to find the approximate terminating generation on both the problems.
The GE mapping is an important component of its evolutionary cycle, and is an extra step which does not
occur typically in GP. However, it is a crucial component of its ability to produce code in any programming
language. GE first decodes a variable length binary string to a string of eight bit integer terms known as codons.
These codons are then used to pick rules from a context free grammar with the following mapping function. A
complete description of GE can be found in [13].
Rule = (Codon Integer Value)
MOD
(Number of rules for this non-terminal)

Algorithm 1 An algorithm of Grammatical Evolution
1: procedure GrammaticalEvolution()
2: Randomly initialize population (pop).
3: while (!Converge) do
4: for each integer iin pop.size() do
5: Perform Genetic Operations (selection, crossover, mutation, etc).
6: Map the offspring (Genotypes −> Phenoty pes).
7: Evaluate fitness of offspring.
8: end for
9: Sort the individuals as per their fitness values.
10: Steady state replacement to form new population for next generation.
11: end while
12: return Best Individual.
13: end procedure
4 Power Law
A power law is a commonly used approach [22] to estimate the time complexity of traditional algorithms. It is
a mathematical relationship between two quantities; if the frequency of a quantity varies as power of the other
quantity then it is said to obey a power law [7]. The equation of a power law can be written as follows.
T(N) = aNb(1)
The exponent btypically depends on the algorithm, while Nis the input size. For our experiments, this input is
the population size which will be represented as N. The leading constant adepends on system (i.e. hardware)
and the algorithm, input data. T(N) is the amount of time taken for the given input size N. While equation
(1) is non-linear, applying log on both sides of the equation converts it into linear form.
log(T(N)) = blog(N) + log(a) (2)
Plotting a log-log graph with the given data points will produce a straight line, and the slope of the straight
line drawn can be determined with the formula
b= (logT (N2)−l ogT (N1))/(logN2−logN1)where, N1, N2are dif ferent values of N. (3)
When analyzing algorithms, another frequently used hypothesis is the doubling hypothesis, a way of measuring
the time ratio as the input size gets doubled.
4.1 Doubling Hypothesis
A simple way to develop the doubling hypothesis is to double the input size and observe the effect on execution
time [22]. If a function T(N) obeys power law then, T(2N)/T (N)∼2z. This is the doubling ratio, and z
indicates the exact relationship. For example, if zis 1, then time increases linearly, but if it is larger than 1,
then the increase in time will be more than double. Thus, a simple and a quick way to calculate the doubling
ratio is to find out the ratio of the execution times. For example, if the algorithm is run ntimes doubling the
input size each time then the doubling ratio is
ratio =T ime taken for nth r un/T ime taken for (n−1)th run. Then, log of the ratio gives the order of
growth of the algorithm. For example, if the ratio is 8 then the order of growth of the algorithm would be 3,
which is derived from log28, where 8 is the doubling ratio.
4.2 Empirical Analysis
An empirical analysis is performed by running the program for various input sizes. The output, in our case,
time can then be used to help determine the constants aand b. Usually, such empirical analysis is carried out
in the following manner: an initial hypothesis is made which assumes that the run time obeys the power law
shown in equation (1). Next, the data obtained by plotting a graph between run time vs input size is examined
on a log-log scale. Consequently, a power law yields a straight line with some slope b. Finally, the slope of
the line decides the growth of the running time of an algorithm. For example, if the slope is 3 then, the run
time grows as the cube of the input size: aN3. We determine the time complexity of GE with the help of the
doubling hypothesis and empirical analysis.

5 Experiments
We conducted the experiments on two well known GP problems, the Santa Fe Ant Trail and a Symbolic
Regression problem. The symbolic regression problem we experimented with was Binomial-3 ((1 + x)3). These
two archetypal problems, although relatively simple and well known, are useful because they are representative
of the sort of problems that GE can be used for, that is, control and classification.
0
10
20
30
40
50
50 100 150 200 250 300 350 400
Generation
Population size
Santa Fe Ant Trail(wrap OFF) ATG
100% Success
99% Success
81% Success
71% Success
61% Success
51% Success
41% Success
31% Success
21% Success
0
10
20
30
40
50
50 100 150 200 250 300 350 400
Generation
Population size
Santa Fe Ant Trail(Wrap ON) ATG
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
15
30
45
60
75
90
105
120
135
50 100 150 200 250 300 350 400
Actual length
Population size
Santa Fe Ant Trail(wrap OFF) AAL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
30
45
60
75
90
50 100 150 200 250 300 350 400
Actual length
Population size
Santa Fe Ant Trail(Wrap ON) AAL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
-10
0
10
20
30
40
50
60
50 100 150 200 250 300 350 400
Effective length
Population size
Santa Fe Ant Trail(wrap OFF) AEL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
20
30
40
50
50 100 150 200 250 300 350 400
Effective length
Population size
Santa Fe Ant Trail(Wrap ON) AEL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
Figure 1: Average Terminating Generation (ATG), Average Actual Length (AAL), and Average Effective Length
(AEL) of SantaFeAntTrail wrapping OFF (left), wrapping ON (right) with cumulative probability of successes.
5.1 Experimental Approach
The experiments conducted in this paper are implemented using libGE [10], an open source framework for
Grammatical Evolution in C++. The following properties were kept consistent for each experiment, crossover
(0.9 probability), mutation (0.01 probability), and a random initialiser was used to create an initial population
with minimum genotype size of 15, maximum size of 25, and a steady state replacement strategy [21] with
probability (prepl = 1.0). The experiments were repeated with GE operator wrapping ON and OFF. We consider
the importance of wrapping, as it had some adverse effects as explained in [2]. The fitness of individuals in GE
is calculated by an evaluator, the exact form of which can be chosen at run time. We varied the evaluators,
using Tiny C (TCC) for the Santa Fe Ant Trail problem and S-Lang for the binomial-3 problem.
The experiment exclusively focused on analysing the time complexity of GE on different problems. The

experiment was conducted varying population sizes on both the problems. There was no limit explicitly men-
tioned on the number of generations. Since, we used the convergence criterion as the terminating condition,
to consider the quality of the solution. The experiment was started with a population size (popsize) of 25 and
ran it for 1000 times, then recorded the execution time at the end of 1000 runs. Next, we applied the doubling
hypothesis on the population size. We doubled the value of popsize to 50 and ran it for 1000 times, then the
execution time was recorded. We repeated this process until the population size become 400. This way we
recorded the execution times of GE on Santa Fe Ant Trail, and the symbolic regression problems, both in the
presence and in the absence of wrapping operator.
-10
0
10
20
30
40
50
60
70
80
90
100
0 50 100 150 200 250 300 350 400
Generation
Population size
Binomial-3(wrap OFF) ATG
100% Success
99% Success
81% Success
71% Success
61% Success
51% Success
41% Success
31% Success
21% Success
-10
0
10
20
30
40
50
60
70
80
90
100
110
0 50 100 150 200 250 300 350 400
Generation
Population size
Binomial-3(Wrap ON) ATG
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
-200
-100
0
100
200
300
400
0 50 100 150 200 250 300 350 400
Actual length
Population size
Binomial-3 AAL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
-200
-100
0
100
200
300
400
0 50 100 150 200 250 300 350 400
Actual length
Population size
Binomial-3(Wrap ON) AAL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
-10
0
10
20
30
40
0 50 100 150 200 250 300 350 400
Effective length
Population size
Binomial-3(wrap OFF) AEL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
-10
0
10
20
30
40
50
60
0 50 100 150 200 250 300 350 400
Effective length
Population size
Binomial-3(Wrap ON) AEL
100% success
99% success
81% success
71% success
61% success
51% success
41% success
31% success
21% success
Figure 2: Average Terminating Generation (ATG), Average Actual Length (AAL), and Average Effective Length
(AEL) of Binomial-3, wrapping OFF(left), wrapping ON (right) with cumulative probability of successes.
5.2 Experimental Results
The experiment estimated the average terminating generation at various population sizes with different cumu-
lative probability of success rates. We considered the quality of the solution hence, the average terminating
generation at various success rates are shown in Fig. 1 and Fig. 2. This figure also shows the average actual
length and average effective lengths. These graphs are produced by averaging across 1000 runs at each popu-
lation size. We use these results in the following sections to analyse GE during this process a few interesting
observations were recorded which will be explained in section-7.
We then investigated how the execution time changes with respect to doubling, the population size. Fig. 3

shows the execution times of Santa Fe Ant Trail and the symbolic regression problems on a log-log scale. The
graphs are plotted with log of the population size (25, 50, 100, 200, 400) on x-axis and the log of the total time
to finish 1000 runs at each population size on y-axis. These graphs are drawn to analyse the time complexity
as per the empirical analysis explained in section-4.2. Now, we analyse the computational complexity of GE.
6 Time Complexity Analysis of GE
This section investigates the time complexity of GE using doubling hypothesis and empirical analysis, as de-
scribed in section 4. We assume that the execution time of GE follows power law shown in equation (1),
and empirically record the change in execution time corresponding with a doubling of the input size, i.e., the
population size.
We repeated this process on both the problems. The first step is to collect the total time spent by the
algorithm to complete the 1000 runs at each population size, and the second step is to calculate the time
complexity by plotting the data on a log-log scale. This produces the graphs in figure 3. These plots are almost
-2
-1
0
1
2
3
2.5 3 3.5 4 4.5 5 5.5 6 6.5
log(Time)
log(Popsize)
Santa Fe Ant Trail
Wrap OFF
Wrap ON
3
4
5
6
7
8
2.5 3 3.5 4 4.5 5 5.5 6 6.5
log(Time)
log(Popsize)
Binomial-3
Wrap OFF
Wrap ON
Figure 3: The time complexity graphs of Santa Fe Ant Trail(shown left) and Binomial-3(shown right) problems
both in the presence and in the absence of wrapping on a log-log scale.
straight lines, which exactly satisfies the last step of the empirical analysis described in section 4.2. Hence, we
assume that these lines are in the form of equation (2).
Next, we calculate the slope of the straight line using equation (3) for any two points on the straight lines
shown in Fig. 3 with respect to the problem. The slopes for the problems shown in Fig. 3, when wrapping is OFF
are as follows. The calculated slope of the Santa Fe Ant Trail problem when wrapping disabled is 1.04. With
these mathematical calculations, the power law equation becomes, T(N) = a.N1.04. The slope of the remaining
straight line, when wrapping enabled is calculated as 1.06, making the power law equation T(N) = a.N1.06 .
The slopes both in the presence and in the absence of wrapping converge to 1, meaning that the exponent is
approximately equal to 1. Since, the leading constant ais a multiplication factor, that can be neglected. Hence,
the final equation can be rewritten as T(N)∼N. This shows that the time complexity of GE on Santa Fe
Ant Trail problem is Onin terms of population size.
Similarly, for Binomial-3 problem, the slopes in the absence and in the presence of wrapping are 2.08 and
2.26 respectively. These values produce the following two mathematical equations.
T(N) = a.N2.08, T (N) = a.N2.26
Here also, the slopes are converging to 2. As the leading constant can be neglected, the final equation can be
rewritten as T(N)∼N2. This shows that the time complexity of GE on Binomial-3 problem is On2.
From these calculations the time complexity of GE on Santa Fe Ant Trail problem is stated as On. The
time complexity on the Symbolic Regression problem is On2, in terms of population size. Hence, this analysis
shows that, doubling the population size linearly increases the total execution time of GE on the Santa Fe Ant
Trail, and it increases with a power of 2 for the Binomial-3 symbolic regression problem. The following section
discusses these observations.
7 Discussion
In this section we discuss some observations from the experimental results shown in Fig. 1 and Fig. 2. These
graphs show the average terminating generation(ATG), average actual length(AAL), and average effective

length(AEL) curves with cumulative probability of success on both GE problems, with and without wrap-
ping. Table 1 describes the number of runs that fall into a specified interval of success out of 1000 runs showing
the various observed probabilities at each population size for both instances of wrapping.
Table 1: The number of runs producing results with various success intervals both in the existence and non-
existence of wrapping on Santa Fe Ant Trail and Binomial-3 problems.
Problem % of Success Count at Pop Size (Wrap OFF) Count at Pop Size (Wrap ON)
25 50 100 200 400 25 50 100 200 400
0 - 21% 865 395 227 81 - 726 210 46 2 -
Santa Fe Ant Trail 21 - 51% 83 219 95 18 - 118 169 41 1 -
51 - 81% 52 275 387 348 42 122 386 290 172 5
81 - 100% - 111 291 553 958 34 235 623 825 995
0 - 21% 904 736 379 68 15 844 596 161 12 -
Binomial-3 21 - 51% 63 104 162 98 29 103 153 233 63 6
51 - 81% 33 153 426 719 777 53 214 493 729 773
81 - 100% - 7 33 115 179 - 37 113 196 221
We clearly observe the curves being clustered together in patterns on both problems in both cases of wrap-
ping. On Santa Fe Ant Trail, as shown in Fig. 1, ATG, AAL, and AEL converge towards a particular value in
both the cases of wrapping as population size increases. Although ATG curves terminate at approximately the
same generation at the end, the count of the curves varying significantly as shown in Table 1. AAL at 100%
success is well below the AAL at 99%, 81% and 71% for up to the population size of 200 and approximately
converging to a common point from there onwards. This shows that the entire genome is not always used to
produce the solution. In the presence of wrapping, the AAL curves at 99%, 81%, 71% and 61% record higher
lengths that the AAL at 100% again shows the entire genome is not used. Similar kind of observations can
be seen in case of AEL graphs on Santa Fe Ant Trail problem. Also, as shown in Table 1 the probability
of producing success increases with respect to the population size. One interesting finding in this analysis is
that we can solve (exactly 100% solution) the Santa Fe Ant Trail problem with a probability of 0.924 with out
wrapping and with a probability of 0.977 with wrapping which are counted against 1000 runs when population
size is 400.
On binomial-3 problem, the patterns suggest that ATG, AAL, AEL curves cluster at different regions.
As shown in Fig. 2 ATG has three clusters: the curves with cumulative success rate of 100%, 99%, 81% are
converging to one point, the curves with cumulative success rate of 61%, 51%, 41% and 21% are converging to
another point, while the curve with 71% success rate alone is converging to a different point. We observe the
same phenomena with wrapping ON, this again proves wrapping has no effect on the performance of GE in
case of symbolic regression as explained in [13]. This clustering behaviour suggests strongly that the manner in
which these figures increase early on runs could be used as a predictor of how the eventual success or otherwise
of a run. The patterns suggest that there may be runs that do not have considerable useful contribution hence,
they can be terminated early instead of waiting for that to complete. To determine these useless runs we are
hoping for a predictor which will be generated with the help of a simple GP classifier. Giving the initial changes
in best fitness, average fitness, actual length and effective length as input to the classifier system will help us
to determine the useless runs. This enables us to propose a reasonably good predictor in future.
8 Conclusion and Future Work
In this paper we mainly addressed time complexity of GE on two archetypal problems, the Santa Fe Ant
Trail and a symbolic regression problem. We analysed the time complexity of GE on these two problems and
discovered GE grows linearly on Santa Fe Ant Trail problem and quadratic in nature on symbolic regression
problem. A few other interesting observations such as ATG, AAL and AEL of the genome depending on the
problem with the result of the patterns are shown in the graphs. We find these patterns are encouraging us
to investigate towards producing a best prediction system. Hence, we gathered a large chunk of data from the
results of these experiments. We will progress to use this data as an input to a GP classifier to produce a
prediction system. With the findings of this research work and from the future recommendations we would like
to come up with a reasonably good predictor optimizing the performance of GE and extend that to various
problems.
Acknowledgement: We would like to thank Science Foundation of Ireland (SFI) for supporting this research
work.

References
[1] Beyer, H.-G., Schwefel, H.-P., and Wegener, I., How to analyse evolutionary algorithms. Theor. Comput.
Sci., 287(1):101–130, Sept. 2002.
[2] Byrne, J., O’Neill, M., McDermott, J., and Brabazon, A., An analysis of the behaviour of mutation in gram-
matical evolution. In Proceedings of the 13th European conference on Genetic Programming, EuroGP’10,
pages 14–25, Berlin, Heidelberg, 2010. Springer-Verlag.
[3] Chen, T., He, J., Sun, G., Chen, G., and Yao, X., A new approach for analyzing average time complex-
ity of population-based evolutionary algorithms on unimodal problems. Trans. Sys. Man Cyber. Part B,
39(5):1092–1106, oct 2009.
[4] Chen, T., Tang, K., Chen, G., and Yao, X., Analysis of computational time of simple estimation of distri-
bution algorithms. Evolutionary Computation, IEEE Transactions on, 14(1):1 –22, feb. 2010.
[5] Durrett, G., Neumann, F., and O’Reilly, U.-M., Computational complexity analysis of simple genetic
programming on two problems modeling isolated program semantics. In Proceedings of the 11th workshop
on Foundations of genetic algorithms, FOGA ’11, pages 69–80, New York, NY, USA, 2011. ACM.
[6] He, J., and Yao, X., A study of drift analysis for estimating computation time of evolutionary algorithms.
3(1):21–35, Mar. 2004.
[7] Mitzenmacher, M., The future of power law research. Internet Mathematics, 2(4):pp. 525–534, 2006.
[8] Mutoh, A., Nakamura, T., Kato, S., and Itoh, H., Reducing execution time on genetic algorithm in real-
world applications using fitness prediction: parameter optimization of srm control. In The 2003 Congress
on Evolutionary Computation, 2003. CEC ’03., volume 1, pages 552 – 559, dec. 2003.
[9] Neumann, F., O’Reilly, U.-M., and Wagner, M., Computational complexity analysis of genetic programming
- initial results and future directions. In Riolo, R., Vladislavleva, E., and Moore, J. H., editors, Genetic
Programming Theory and Practice IX, Genetic and Evolutionary Computation, chapter 7, pages 113–128.
Springer, Ann Arbor, USA, 12-14 May 2011.
[10] Nicolau, M., and Slattery, D., libGE - grammatical evolution library. http://bds.ul.ie/libGE/, 2006.
[11] GAlib: programming interface. http://lancet.mit.edu/galib-2.4/API.html#completion, 2007.
[12] Oliveto, P. S., He, J., and Yao, X., Analysis of the (1 + 1)-ea for finding approximate solutions to vertex
cover problems. Trans. Evol. Comp, 13(5):1006–1029, oct 2009.
[13] O’Neill, M., and Ryan, C., Grammatical Evolution: Evolutionary Automatic Programming in an Arbitrary
Language. Kluwer Academic Publishers, Norwell, MA, USA, 2003.
[14] O’Neill, M., Ryan, C., Keijzer, M., and Cattolico, M., Crossover in grammatical evolution: The search
continues. In Miller, J. F., Tomassini, M., Lanzi, P. L., Ryan, C., Tettamanzi, A. G. B., and Langdon, W. B.,
editors, Genetic Programming, Proceedings of EuroGP’2001, volume 2038 of LNCS, pages 337–347, Lake
Como, Italy, 18-20 April 2001. Springer-Verlag.
[15] O’neill, M., Ryan, C., Keijzer, M., and Cattolico, M., Crossover in grammatical evolution. Genetic Pro-
gramming and Evolvable Machines, 4(1):67–93, Mar. 2003.
[16] Poli, R., Langdon, W. B., and McPhee, N. F., A Field Guide to Genetic Programming. Lulu Enterprises,
UK Ltd, 2008.
[17] Poli, R., Vanneschi, L., Langdon, W. B., and Mcphee, N. F., Theoretical results in genetic programming:
the next ten years? Genetic Programming and Evolvable Machines, 11(3-4):285–320, Sept. 2010.
[18] Rudolph, G., Finite markov chain results in evolutionary computation: a tour d’horizon. Fundam. Inf.,
35(1-4):67–89, aug 1998.
[19] Ryan, C., Collins, J. J., and O’Neill, M., Grammatical evolution: Evolving programs for an arbitrary
language. In Banzhaf, W., Poli, R., Schoenauer, M., and Fogarty, T. C., editors, Genetic Programming,
First European Workshop, EuroGP 98, Paris, France, April 14-15, 1998, Proceedings, volume 1391 of
Lecture Notes in Computer Science, pages 83–96. Springer, 1998.
[20] Ryan, C., Keijzer, M., and Nicolau, M., On the avoidance of fruitless wraps in grammatical evolution.
In Proceedings of the 2003 international conference on Genetic and evolutionary computation: PartII,
GECCO’03, pages 1752–1763, Berlin, Heidelberg, 2003. Springer-Verlag.
[21] Ryan, C., and O’Neill, M., Grammatical evolution: A steady state approach. In Koza, J. R., editor,
Late Breaking Papers at the Genetic Programming 1998 Conference, University of Wisconsin, Madison,
Wisconsin, USA, 22-25 July 1998. Stanford University Bookstore.
[22] Sedgewick, R., and Wayne, K., Algorithms, 4th Eds. Addison-Wesley, 2011.
[23] Urli, T., Wagner, M., and Neumann, F., Experimental supplements to the computational complexity
analysis of genetic programming for problems modelling isolated program semantics. In Coello, C. A. C.,
Cutello, V., Deb, K., Forrest, S., Nicosia, G., and Pavone, M., editors, PPSN (1), volume 7491 of Lecture
Notes in Computer Science, pages 102–112. Springer, 2012.