A Framework For Tree-Adjunct Grammar Guided Genetic Programming N. X. Hoai* and R.I. Bob McKay** *Department of Information Technology, Military Technical Academy, 100th Hoang Quoc Viet st., Ha noi, Vietnam. E-mail:
[email protected] **School of Computer Science, University College, The University of New South Wales, Australian Defence Force Academy, Canberra, ACT2600, Australia. E-mail:
[email protected] Abstract In this paper we propose the framework for a grammar-guided genetic programming system called Tree-Adjunct Grammar Guided Genetic Programming (TAGGGP). Some intuitively promising aspects of the model compared with other grammar-guided evolutionary methods are also highlighted.
1 Introduction Genetic programming (GP) is considered to be a machine learning method, which induces a population of computer programs by evolutionary means ([Banzhat et al, 1998]). Genetic programming has been used successfully in generating computer programs for solving a numbers of problems from various areas. In this paper, we propose a framework for a grammar-guided genetic programming system called Tree-Adjunct Grammar Guided Genetic Programming (TAGGGP), which uses tree-adjunct grammars to guide genetic programming. The use of tree-adjunct grammars can be seen as a process of building grammar guided programs in the two dimensional space. The organization of the remainder of the paper is as follows. In section 2, we will give a brief on genetic programming, grammar-guided genetic programming, and tree-adjoining grammars. The main theme of TAGGGP will be given in section 3. The paper concludes with section 4, which contains the discussion on some intuitively promising aspects of TAGGGP in compared with other grammar-guided genetic programming schemes and future work.
2 Background Genetic Programming Genetic programming can be classified as an evolutionary algorithm, in which computer programs are targets to evolve. The original definition, model, techniques and problems of genetic programming can be found in [Koza, 1992]. For a good survey of genetic programming, [Banzhat et al, 1998] is recommended. A basic genetic programming system consists of five basic components ([Koza, 1992]): program representation (called genome structure), procedure to initialize a population of programs, fitness evaluation, genetic operators, and parameters. In [Koza, 1992] the structure of programs is the parse tree of S-expressions; fitness of a program is evaluated by its performance; main genetic operators are selection and crossover (in this book, Koza stated that mutation is nearly unnecessary); parameters are population size, maximum number of generations and probabilities for genetic operators. In this paper, we will refer genetic programming in [Koza, 1992] as canonical genetic programming. Grammar-guided Genetic Programming One of the limitations of canonical GP is the closure requirement, which expresses that all variables, constants, arguments of function, and return value from function must be of the same data type so that crossover can take place at any point of a program structure.
One of the early attempts to overcome this limitation was carried out by Montana ([Montana,1994]). In his report, Montana proposed a strongly typed genetic programming system, in which all variables, constants, arguments of functions, return values of functions are given data types beforehand. The initialization and genetic operators are designed with respect to data type of each node in genome structure to ensure only legal genomes are generated. The genome structure in [Montana, 1994] is also tree. Another promising way to cope with closure is using syntactical constraints. Syntactical constraints is originally seeded by Koza ([Koza,1992]); however, he did not give an explicit formalism for defining syntactical constraints. Using grammar as a formalism for syntactical constraints was first introduced by Whigham ([Whigham, 1995]), in which context-free grammars are used to define the target language of programs. The definition and properties of context-free grammars can be found in [Harrison, 1978] or [Hopcroft and Ullman, 1979]. For example, to define the language of simple expression with one variable one (of many) context-free grammar can be defined as in example 1. Example 1. The context-free grammar for generating one variable expressions G= (T, V, P, EXP). Where T={x, sin, cos, +, -, (, )} is a set of terminal symbols; V= {EXP, OP, PREOP, VAR} is a set of non-terminal symbols; the production rule set P is written in Backus-Naur form (BNF) as follows: EXP → EXP OP EXP | PREOP (EXP) | VAR OP →+|PREOP → sin | cos VAR → x In Whigham’s context-free grammar-guided genetic programming system, the genome structure is the derivation tree. For example, the genome for expression sin (x) + cos (cos (x) ) in the language generated by grammar G in example 1 is its derivation tree as in figure 1: EXP EXP
OP
PREOP ( EXP ) sin
VAR x
+
EXP PREOP ( EXP ) cos
PREOP cos ( EXP ) VAR x
Figure 1. The derivation tree for expression sin (x) + cos (cos (x )). Moreover, Whigham (1996) has incorporated domain knowledge to change grammars in order to bias the search process; and he has archived positive results on 6-multiplexer problem.
Gruau ([Gruau, 1996]) formally proved that using syntactical constrains does reduce the size of search space. He also used context-free grammars to describe target languages but he did not limit the depth of derivation trees, which can lead to the severe growth in tree size ([Ratle and Sebag, 2000]). Wong and Leung ([Wong and Leung, 1996]) use logic grammars to combine inductive logic programming and genetic programming. They have succeeded in incorporating domain knowledge into logic grammars to guide the evolutionary process of logic programs. However, because they did not maintain explicitly parse trees, their system suffers from ambiguity when it tries to generate programs from parse trees ([Ryan et al, 1998]). Moreover, their system just generates functional or logic programs (such as LISP, PROLOG) not in arbitrary programming languages. Ryan et al ([Ryan et al, 1998]) propose a system called grammatical evolution (GE), which can evolve programs in an arbitrary language, provided that this language can be described by a context-free grammar. Their system differs from Whigham’s system in a way that they do not evolve derivation trees directly. Instead, genomes in GE are binary strings representing eight-bit numbers; each number is used to make the choice of the production rule for the non-terminal symbol being processed. For example, the genome 0, 1, 0, 2, 0, 1, 1, 1, 1, 2 generates expression sin (x)+ cos (cos (x)) in the previous example. GE starts with the string consisting of only the start symbol of the context-free grammar. It, then, picks up the first gene from the genome to decide what production rule will be used to rewrite the start symbol. Next, the string is rewritten according to the production rule chosen. The process is repeated for next non-terminal symbol in the string until the string is completed (it contains only terminal symbols). If the gene (the eight-bit integer number) for the non-terminal symbol being processed is bigger than the number of production rules for that symbol in the context-free grammar, the modulus operation takes place. For instance, the genome 6, 1, 0, 2, 0, 1, 1, 1, 1, 2 will produce the same expression sin (x)+cos (cos (x) ) as in the previous example. GE has been proved to outperform canonical GP in quite a few problems ([O’Neil and Ryan, 1999a]; [O’Neil, 1999]). One of the great advantages of GE is the linear (variant-length) genome structure, which allows GE to employ well-studied operators of genetic algorithm. Moreover, the implementation of GE above provides a type of genotype-phenotype mapping, which can provide neutral evolution in the genome space (thanks to the modulus operation). On the other hand, one main weak point of GE is it can not guarantee to generate legal genomes. It creates some problems. The first problem is if the there are too many genes than necessary in the genome then the system will suffer from introns ([Ryan et al, 1998]). For instance, the genome using grammar in example 1 like 2,... will result in too many useless genes (introns). To cope with this case, Ryan et al ([Ryan et al, 1998]) add another genetic operator: pruning to chop off the redundant genes in genomes with probabilities. However, the problem here is due to the representation nature of GE; so introns will still appear in evolutionary process of GE. The more difficult problem to cope is when a genome runs out of genes. In ([Ryan et al, 1998]) wrapping is used. It means that, when a genome runs out of genes GE will turn back to the first gene of the genome to continue the process of generating the corresponding phenome. However, the multiple usage of a gene in wrapping is unnatural ([Ryan et al, 1998]). Furthermore, the effect of wrapping is unclear and different from problem to problem ([O’Neil and Ryan, 1999b]). Worse, in a
GE system using the grammar in example 1, a genome like 1, 1, 1 will never generate a legal phenome (expression) even wrapping is used. In the next sub-section, we will give a brief on tree-adjoining grammars and theirs equivalent forms tree-adjunct grammars, which we will use to guide our genetic programming system. Tree-Adjoining Grammars Tree-adjoining grammars (TAGs) were first introduced in [Joshi et al, 1975]. In that paper, the substitution was not used and TAGs was named tree-adjunct grammars. Treeadjoining grammars have been used successfully in natural language processing; and a comprehensive survey of TAGs can be found in [Joshi et al, 1996]. A tree-adjoining grammar can be defined as follows ([Joshi et al, 1996]): Definition 1: A tree-adjoining grammar comprises of 5-tuple (T, V, I, A, S), where (i) T is a finite set of terminal symbols. (ii) V is a finite set of non-terminal symbols; and T ∩ V = ∅. (iii) S ∈ V is a distinguished symbol called the start symbol. (iv) I is a finite set of finite trees called initial trees. An initial tree is defined as follows: - All interior nodes are labeled by non-terminal symbols. - Each node on the frontier is either labeled by a terminal or non-terminal symbol; if it is lalebled by a terminal symbol then it must be marked for substitution (we will also use a down arrow (↓) as in [Joshi et al, 1996] to denote a mark for substitution). (v) A is a finite set of finite trees called auxiliary trees, which can be defined as follows: - Internal nodes are labelled by non-terminal symbols. - A node on the frontier is labeled by a terminal or non-terminal symbol. All the nodes that labeled by non-terminal node on the frontier are marked for substitution except for one node called foot node. The requirement for a foot node is it must be labeled by the same (non-terminal) symbol with the root node of the tree. We will also follow the convention in [Joshi et al, 1996] to mark a foot node with an asterisk (*). The trees in E= I ∪ A are called elementary trees. In literature, initial trees and auxiliary trees are named as α and β respectively; and a node labeled by a non-terminal symbol (resp. terminal symbol) is some time called non-terminal node (resp. terminal node). A elementary tree is called X-type if its root is labeled by the non-terminal symbol X. Operations in a tree-adjoining grammar is the compositions of trees; and a tree built by composition of other trees is called a derived tree. Two types of composition are used in a TAG: substitution and adjunction. Substitution can take place on a non-terminal node A of the frontier of an elementary tree γ1 if and only if this node is marked for substitution and there is another elementary tree γ2 that is of A-type. Substitution is then simply done by attaching γ2 to node A of γ1. substitution is illustrated in figure 2. Adjunction can build a new tree γ from an auxiliary tree β and a tree α (initial, auxiliary or derived). If tree α has a non-terminal node labeled A that is not marked for substitution and β is an A-type tree then the adjunction of β and α to produce γ is as follows. First, the
A
A↓
A
Figure 2. substitution subtree α1 rooted at A is temporarily disconnected from α. Next, β is attached to α to replace this subtree. Finally, α1 is attached back to the foot node of β. γ is the final tree achieved from this process. Adjunction is illustrated in figure x: A
A
A A*
A Figure 3. Adjunction A derivation tree in TAG is defined as an object tree, which describes how a derived tree is constructed. Example 2. If we have a TAG A=(T,V,A,I,EXP), where T={+,x,y, cos, (, )}, V={EXP, OP, PREOP, VAR }, I ∪ A are as in figure 4: α 1 : EXP VAR x
α 2 : EXP VAR y
α 3 : EXP EXP↓ OP EXP↓
α 4 : PREOP cos
β 1: EXP PREOP↓ ( EXP* )
+ Figure 4. Elementary trees of TAG A. The derived tree α 5 (in figure 5) which yields the sentence cos (x+y) has the derivation tree as in figure 6.
EXP PREOP ( cos
EXP
EXP OP VAR
+
x
) EXP VAR y
Figure 5. Derived tree α 5 for: cos ( x + y ). α3 α 1 (2.1)
α 2 (2.3)
β 1 (0)
α 4 (1) Figure 6. The derivation tree for cos (x + y). The derivation tree in figure 6 above can be translated as a sequence of tree compositions. First, the tree α 1 is substituted into α 3 at address (2.1). Next, α 2 is substitued into α 3 at address (2.3). Then, α 4 is substitued into β 1 at address (1). Finally, β 1 is adjoined to α 3 at address (0). Here, we use the Gorn addresses to address tree nodes in a tree: (0) means the root node; (k) means the kth (from left to right) child node of the root node; and (p.q) is address of qth child node of the node that has address p. The tree set of a TAG can be defined as follows ([Joshi, 1996]): TG = { t / t is completed and t is derived from some initial S-type trees} Where a tree t is said to be completed if t is an initial tree and t has no terminal node marked for substitution. The language LG generated by a TAG is then defined as the set of yields of all trees in TG. LG = {w ∈ T* / w is the yield of some tree t ∈ TG} The set of languages generated by TAGs (called TAL) is a superset of context-free languages; and it properly includes in indexed languages ([joshi, 1996]). More properties of TAL can be found in ([joshi, 1996]). If there is no node marked for substitution in elementary trees of a tree-adjoining grammar (therefore, substitution is not used) it becomes a tree-adjunct grammar as originally defined in ([joshi, 1975]). Tree-adjunct grammars are as formally powerful as tree-adjoining grammars. It means that, they generate the same set of languages though substitution is not used in tree adjunct grammars. Moreover, in a tree-adjunct grammar, the derivation trees become linear sequences since the adjunction only takes place at one node at a time. From this point, we will only mention tree-adjunct grammars and we will still use the notation TAGs to denote tree-adjunct grammars. One special class of tree-adjunct grammars (TAGs) is lexicalized tree-adjunct grammars (LTAG) where each elementary tree of a LTAG must have at least one terminal node (called anchor). A general definition of lexicalized grammars is defined in [joshi, 1996] as follows: Definition 2: A grammar is called ‘lexicalized’ if it consists of:
(i)
A finite set of structure each associated with a lexical item; each lexical item is called the anchor of the corresponding structure. (ii) An operation or operations for composing the structures. In fact, not all grammars are lexicalized, which raises a question of finding a grammar Glex for a given grammar G so that Glex is lexicalized and Glex generates the same language and tree set with G. The process of finding such a Glex is called lexicalization of G; and Glex (if exists) is called (strong) lexicalized version of G. The problem of finding Glex for a finitely ambiguous context-free grammar is decidable ([Joshi et al,1996]).By saying a finitely ambiguous grammar, we mean every finite sentence in the language generated by this grammar can not be analyzed in a infinite numbers of ways. It turn out to be that for every context-free grammar G that does not generate empty, there is an efficient algorithm to find out a LTAG Glex which is a strong lexicalized version of G ([joshi et al, 1975] or [joshi et al, 1996]). Note that, for any context-free grammar G, the Greibach normal form ([Harrison, 1978]) Gb of G is also a lexicalized grammar; and it generates the same language with G. However, Gb does not generate the same tree set with G. In that case, Gb is called weak lexicalized version of G ([joshi et al, 1996]). For example, the tree-adjunct grammar in the example below is the strong lexicalized version of the context-free grammar in example 1: Example 3. A LTAG G1 = {N, T, I, A, EXP}. N and T are the same as in example 1. I and A are showed in the figure 7. One can show that G1 is strong lexicalized version of G. β 1:
EXP
β 2:
EXP
EXP OP EXP*
EXP OP EXP*
VAR +
VAR -
x
β 3: EXP PREOP ( EXP* ) sin
β 4: EXP PREOP ( EXP* ) cos
x
α 1: EXP VAR x Figure 7. The elementary trees of G1 in example 3. For example, the parse tree of the expression sin (x) + cos (cos (x)) can be generated by the derivation sequence: α 1 β 4 (0) β 4 (0) β 1 (0) β 3 (1) with the order of adjunctions is from right to left. Generally, a context-free grammar G lexicalized by a LTAG Glex, the construction of a parse tree of G can be done by adjoining all elementary trees in the corresponding derivation sequence of Glex using the right-to-left order. 3 The main theme of Tree Adjunct Grammar Guided Genetic Programming To solve any problem with a TAGGGP system, some preparation steps need to be done. The first step is to find out a (finitely ambiguous) context-free grammar G describing the target language of computer programs that are going to be evolved. Secondly, the
lexicalized version of G, a LTAG Glex, is created (using the algorithm in ([joshi et al, 1996]). For each non-terminal node in an elementary tree we can attach a list of elementary trees that can adjoin into that node. Then five basic components of TAGGGP can be determined as follows: Representation A genome in TAGGGP is represented as a derivation sequence: α j β i1 (a1) β i2 (a2)... β in (an). (1) Where n is arbitrary finite natural number; α j, β ik / k=1,2,..,n are elementary trees of Glex, ah /h=1,2,..,n are node addresses where adjunctions take place (any addressing scheme can be employed). The order of adjunction is the right-to-left order. According to the algorithm in [joshi et al, 1996], all initial trees in Glex are S-type which leads to the conclusion that for every finite derivation tree of G there is a unique corresponding derivation sequence of type (1) in Glex which builds that derivation tree. Therefore, our presentation is sufficient to cover all finite derivation trees of G. Since n is arbitrary, genomes in TAGGGP are (linear and) length-variant genomes. Initialization A population of genomes can be generated at random by the following procedure: PROCEDURE InitTAG3P BEGIN FOR I=1 TO POP_SIZE (1) Generate a natural number n ∈ {MIN_LENGTH..MAX_LENGTH} at random. (2) Pick up at random an initial tree α that can adjoined by some auxilary trees β. (3) Set β 0 = α. (4) Set genome I = α. FOR J=0 TO n-1 DO (5) Pick up a non-terminal node N of β j that can be adjoined by some elementary trees. (6) Choose one elementary tree β j+1 in these elementary trees at random. (7) Add β j+1 (ad(N)) into genome I; (where ad(N) is the address of N). ENDFOR ENDFOR END. There is always at least an α that can be adjoined by β because if there is no such α then, according to the algorithm in [joshi, 1996], the number of sentences of the language generated by G will be less than the number of non-terminal symbols in G, which will generally not happen in any problem targeted by grammar-guided genetic programming. Therefore, (2) is always successful in picking up an initial tree α. For an auxiliary tree β, there is always at least one auxiliary tree can adjoin into it (one obviously is itself). Hence, (5), (6), (7) always succeed; that means the inner loop always produces a legal genome with a prescribed length. Overall, the procedure InitTAG3P guarantees to generate only legal genomes with different lengths. Fitness Evaluation Fitness evaluation in TAGGGP is the same as in the canonical genetic programming ([koza, 1992]) and other grammar-guided genetic programming models.
Genetic operators We will describe two main genetic operators in TAGGGP: crossover and mutation, the selection is similar to canonical GP and other grammar-guided GP. In TAGGGP we can have at least two types of crossovers: one-point crossover and two-point crossover. Onepoint crossover can be done by the following steps: 1. Choose two genomes g1= α j β i1 (a1) β i2 (a2)... β in (an) and g2 = α h β k1 (b1) β k2 (b2)... β km (bm) based on a selection strategy. 2. Randomly choose a β it (at) in g1. 3. Select at random a β kr (br) in g2, which is compatible with β it (at); where a β kr (br) in g2 is said to be compatible with β it (at) in g1 if and only if there is two nonterminal nodes A of β it-1 (at-1) and B of β kr-1 (br-1) so that β kr can adjoin into A and β it can adjoin in to B (when t=1, β it-1 (at-1)= α j; when r=1, β kr (br)= α h). The addresses of A and B are denoted as br* and at* respectively. 4. If such β kr (br) does not exist, go to step 1. 5. Swap two parts of genomes at β it (at) and β kr (br) like the way that one-point crossover is done in genetic algorithms. The children will be c1 = α j β i1 (a1) β i2 (a2)... β it-1 (at-1) β kr (br*)... β km (bm), c2 = α h β k1 (b1) β k2 (b2)... β kr-1 (br-1) β it (at*)... β in (an). Two-point crossover can be done in a similar way, but the number of points chosen is two. It is easy to show that crossover in TAGGGP always produces legal genomes. In some specific problems (eg. symbolic regression), crossover without requirement of compatibility at crossover points can be implemented. However, repair operators are needed to ensure legal genomes are produced. Generally, we believe that such operators are not difficult to design since the number of elementary tree is finite, the terminal node in an elementary tree is attached to a finite list elementary trees that can adjoin into that node. Therefore, one repair operator could be implemented by searching through all elementary trees and non-terminal nodes to find out correct replacements of misplaced elementary trees and adjoining addresses in a genome. For TAGGGP, there could be a numbers of mutation operators; and we will describe three main ones: deletion, insertion and replacement. In deletion, one β it (at) will be randomly chosen to be removed from g1, provided that β it+1 can adjoin into β it-1 (at). Insertion is done by inserting an elementary tree β between β it-1 (at-1) and β it (at) if β it can adjoin into β; and β itself can adjoin into β it-1 (at-1). In this case, the address at will be modified. When replacement takes place, an elementary tree in a genome is randomly selected. Then, replacement can be the change of the adjoining address or the elementary tree itself. The different point between replacement and the two other mutation operators is replacement can be carried out on α-tree (the first gene of genomes). One can see that replacement on β-tree is just a combination of deletion and insertion. Parameters The parameters in TAGGGP are minimum length of genomes - MIN_LENGTH, maximum length of genomes MAX_LENGTH, size of population - POP_SIZE, and maximum number of generations – MAX_GEN.
4 Discussion and Future Work In this part, we highlight some intuitively promising aspect of TAGGGP and some work for the future. One of the advantages of TAGGGP compared with other grammar-guided genetic programming system is it combined the advantages of them. It has linear genome (like in GE); therefore it is easier to handle than tree genomes in models of Whigham, Wong and Leung.It can be used to evolve programs in an arbitrary language (like in models of Whigham, Ryan and O’Neil) as long as this language can be described in a (finitely ambiguous) context-free grammar that does not generate empty (these requirements are always satisfied in computer programming languages). In comparison with GE, a linear genome-based system, TAGGGP has an obvious advantage that it always guarantees to produce only legal genomes. Also, it is easy to control the size of derivation trees of programs produced by the original context-free grammar in TAGGGP, which is not in other context-free grammar based genetic programming systems ([Ratle and Sebag, 2000]). Since the size of every elementary tree is fixed, the control of size of derivation tree in a the original context-free grammar can be done by controlling the length of the corresponding derivation sequences in the corresponding LTAG. In future, we will implement TAGGGP on some problems to see whether the above advantages of TAGGGP can help TAGGGP perform better than other grammar-guided genetic programming systems. We will also investigate wether some linguistic relevance of TAG such as extended domain of locality (ELD) and factoring recursion from the domain of dependencies (FRD), which claimed to be crucial for the out-performance of TAGs over context-free grammars in natural language processing ([Joshi, 1996]), will benefit in the genetic programming context. Acknowledgement (Bob, I think we should give Acknowledgement to people who have done some work on grammar-guided genetic programming and the inventers of TAG). REFERENCES
1. [Banzhat et al, 1998] W. Banzhat, P. Nordin, R. E. Keller, and F. D. Francone. Genetic Programming: An Introduction. Morgan Kaufmann Pub, 1998. 2. [Gruau, 1996] F. Gruau. On Using Syntactic Constraints with Genetic Programming. In P. J. Angeline and K. E. Kinnear Jr. (eds), Advances in Genetic Programming, pages 377-394, The MIT Press, 1996. 3. [Harrison, 1978] M. A. Harrison. Introduction to Formal Language Theory. Addison-Wesley Pub, 1978. 4. [Hopcroft and Ullman, 1979] J. E. Hopcroft and J. D. Ullman. An Introduction to Automata Theory, Languages and Computation. Addison-Wesley Pub, 1979. 5. [Joshi and Schabes, 1996] A. K. Joshi and Y. Schabes. Tree Adjoining Grammars. In Grzegorz Rozenberg and Arto Saloma (eds), Handbook of Formal Laguages, Vol 3, pages 69-123. Springer-Verlag, NY, USA, 1996. 6. [Joshi et al, 1975]. A. K. Joshi, L. S. Levy, and M. Takahashi. Tree Adjunct Grammars. Journal of Computer Science and System Sciences, 10 (1).
7. [Koza, 1992] J. Koza. Genetic Programming. MIT Press, 1992. 8. [Montana, 1994] D. J. Montana. Strongly Typed Genetic Programming. BNN Technical Report #7866, 1994. 9. [O’Neill and Ryan, 1999a]. M. O’Neill and C. Ryan. Genetic Code Degeneracy: Implication for Grammatical Evolution and Beyond. Proceedings of the European Conference on Artificial Life, 1999. 10. [O’Neil and Ryan, 1999b] M. O’neil and C.Ryan. Under the Hood of Grammatical Evolution. In W. Banzhat, J.Daida, A. E. Eiben, M. H. Garzon, V. Hovana, M. Jakiela, and R. E. Smith (eds). GECCO-99, Morgan Kaufmann Pub, 1999. 11. [O’Neill and Ryan, 1998] M. O’Neill and C. Ryan. Grammatical Evolution: A Steady State Approach. Proceedings of the Second International Workshop on Frontiers in Evolutionary Algorithms 1998, pages 419-423. 12. [O’Neill, 1999] M. O’Neill. Automatic Programming with Grammatical Evolution. Proceedings of the Genetic and Evolutionary Computation Conference Workshop Program, July 13-17,1999, Orlando, Florida USA. 13. [Ryan et al, 1998] C. Ryan, J. J. Collin, and M. O’Neill. Grammatical Evolution: Elvoving Programs for an Arbitrary Language. Lecture Note in Computer Science 1391, Proceedings of the First European Workshop on Genetic Programming, pages 83-95, Springer-Verlag, 1998. 14. [Whigham, 1995] P. Whigham. Grammatically-based Genetic Programming. Proceedings of the Workshop on Genetic Programming: From Theory to RealWorld Applications, pages 33-41, Morgan Kaufmann Pub, 1995. 15. [Whigham, 1996] P. Whigham. Search Bias, Language Bias and Genetic Programming. Genetic Programming 1996, pages 230-237, MIT Press, 1996. 16. [Wong and Leung, 1996] M. L. Wong and K. S. Leung. Evolving Recursive Functions for Even-Parity Problem Using Genetic Programming. In P. J. Angeline and K. E. Kinnear Jr. (eds), Advances in Genetic Programming, pages 221-240, The MIT Press, 1996. 17. [Ratle and Sebag, 2000] A. Ratle and M. Sebag. Genetic Programming and Domain Knowledge: Beyond the Limitations of Grammar-Guided Machine Discovery. Ecole Polytechnique, France. Available at: www.researchindex.com. Accessed: 30, May, 2001.
