Gene Expression Programming: A New Adaptive Algorithm for Solving Problems

Cândida Ferreira

article2001Complex Systems2,365 citations

Introduces Gene Expression Programming, an evolutionary algorithm that decouples linear genetic chromosomes from functional expression trees to solve complex problems in symbolic regression, boolean concept learning, and automated program generation far more efficiently than traditional genetic programming.

Listen

Traditional evolutionary computation methods, such as genetic algorithms and genetic programming, struggle to balance structural simplicity with functional complexity. Standard approaches often produce syntactically invalid programs when mutated or require massive computing power to navigate constrained search spaces. This computational bottleneck limits the practical deployment of automated program induction in complex problem solving.

The article introduces and evaluates Gene Expression Programming, a novel adaptive technique designed to overcome these limitations. The method separates simple, fixed-length linear genomes (the genotype) from the non-linear expression trees they encode (the phenotype), ensuring that all genetic modifications always produce valid, executable computer programs.

The author evaluated the algorithm across six benchmark tasks: symbolic regression, sequence induction with and without constant generation, block stacking, cellular automata density classification, and boolean concept learning. Testing involved multi-generational simulations comparing performance, population scale, and computational evaluations against conventional techniques across repeated test runs.

The evaluation revealed substantial performance gains. In complex cellular automata density classification, the algorithm generated rules with over 82.5% accuracy while requiring more than four orders of magnitude fewer fitness evaluations—a roughly 10,000 to 70,000-fold reduction in computational effort compared to standard genetic programming. In boolean logic synthesis, the system achieved a 57% success rate on the 11-multiplexer problem using a population of 250 individuals, a task previously requiring thousands of individuals in traditional implementations. Across all domains, multigenic structures reliably assembled modular building blocks into hierarchical solutions without generating invalid syntax.

These findings indicate that separating genetic storage from functional expression dramatically lowers computing overhead, risks, and timelines for solving complex search and optimization problems. By guaranteeing syntactic validity across all genetic modifications, the system enables continuous adaptation without expensive repair mechanisms, allowing complex programs to run effectively on standard personal computers.

Organizations evaluating evolutionary algorithms should consider implementing this genotype-phenotype framework for symbolic modeling, logic synthesis, and planning tasks to reduce infrastructure costs. Further development is recommended to automate linking functions between sub-components and test performance on larger, noisy enterprise datasets. While the results demonstrate strong improvements across multiple benchmarks, evaluations remain focused on established test suites, meaning performance on unstructured real-world data warrants further empirical validation.

Departamento de Ciências Agrárias Gepsoft Universidade dos Açores adaptive algorithms automata cellular gene expression programming genetic programming genetic algorithm

arXiv: cs/0102027

Paper: Genetic algorithms and Machine Learning, D. Goldberg et al. (1988). Reading Goldberg and Holland's foundational 1988 editorial on genetic algorithms provides the essential evolutionary search terminology and schema-theorem background assumed by the source.

Paper: Self-Improving Language Models with Bidirectional Evolutionary Search, Guowei Xu et al. (2026). This book extends the source's evolutionary concepts into modern language model post-training by introducing Bidirectional Evolutionary Search.

Cover for Gene Expression Programming: A New Adaptive Algorithm for Solving Problems

Abstract

Gene expression programming, a genotype/phenotype genetic algorithm (linear and ramified), is presented here for the first time as a new technique for the creation of computer programs. Gene expression programming uses character linear chromosomes composed of genes structurally organized in a head and a tail. The chromosomes function as a genome and are subjected to modification by means of mutation, transposition, root transposition, gene transposition, gene recombination, and one- and two-point recombination. The chromosomes encode expression trees which are the object of selection. The creation of these separate entities (genome and expression tree) with distinct functions allows the algorithm to perform with high efficiency that greatly surpasses existing adaptive techniques. The suite of problems chosen to illustrate the power and versatility of gene expression programming includes symbolic regression, sequence induction with and without constant creation, block stacking, cellular automata rules for the density-classification problem, and two problems of boolean concept learning: the 11-multiplexer and the GP rule problem.

Topics

adaptive algorithms automata cellular cellular automata chromosome classification gene expression programming genetic selection genome genotype

Keywords

gene expression programming genetic programming genetic algorithm expression trees linear genomes gene transposition gene recombination symbolic regression problem cellular automata rules

1. Introduction
2. An overview of gene expression algorithms
3. The genome of gene expression programming individuals
3.1. Open reading frames and genes
3.2. Gene expression programming genes
3.3. Multigenic chromosomes
3.4. Expression trees and the phenotype
3.4.1. Information decoding: Translation
3.4.2. Interactions of sub-expression trees
4. Fitness functions and selection
4.1. Fitness functions
4.2. Selection
5. Reproduction with modification
5.1. Replication
5.2. Mutation
5.3. Transposition and insertion sequence elements
5.3.1. Transposition of insertion sequence elements
5.3.2. Root transposition
5.3.3. Gene transposition
5.4. Recombination
5.4.1. One-point recombination
5.4.2. Two-point recombination
5.4.3. Gene recombination
6. Six examples of gene expression programming in problem solving
6.1. Symbolic regression
6.2. Sequence induction and the creation of constants
6.3. Block stacking
6.4. Evolving cellular automata rules for the density-classification problem
6.4.1. The density-classification task
6.4.2. Two gene expression programming discovered rules
6.5. Boolean concept learning
6.5.1. The genetic programming rule problem
6.5.2. The 11-multiplexer problem
7. Conclusions
Acknowledgments
References

Knowls

Knowl 1 — Structural Invariant and Head-Tail Organization of GEP Genes
equation
In Gene Expression Programming (GEP), each gene in a linear chromosome is divided into two structural segments: a head of fixed length $h$ and a tail of fixed length $t$ .

Let $F$ denote the set of function symbols and $T$ denote the set of terminal symbols (variables and constants). Symbols in the head can be chosen from $F \cup T$ , whereas symbols in the tail are strictly restricted to $T$ .

If $n$ represents the maximum arity (maximum number of arguments) among all functions in $F$ , the tail length $t$ is determined by the equation:

$t = h(n - 1) + 1$

The total length of each gene is $h + t$ .

This mathematical formulation guarantees that regardless of which symbols occupy the head or tail, reading the gene from left to right as an Open Reading Frame (ORF) will always supply enough terminal symbols to terminate every branch of the resulting expression tree before or exactly at the end of the tail. Consequently, any linear genetic sequence conforming to this rule produces a syntactically valid program without requiring repair mechanisms or syntactic penalties.
Knowl 2 — Translation Algorithm of K-Expressions into Expression Trees
algorithm
Translation in GEP converts a linear symbolic gene string (a K-expression in the Karva language) into an Expression Tree (ET) phenotype using a level-order (breadth-first) construction starting at the gene's first position.
Input: A linear gene string $G = [g_0, g_1, \dots, g_{L-1}]$ where each symbol $g_k \in F \cup T$ , function arities $\text{arity}(f)$ for $f \in F$ , and $\text{arity}(t) = 0$ for $t \in T$ .
Output: A rooted Expression Tree $ET$ and the termination index $k_{\text{stop}}$ of the Open Reading Frame (ORF).
Create root node $v_0$ labeled with symbol $g_0$
Initialize queue $Q \leftarrow [v_0]$
$k \leftarrow 0$
while $Q$ is not empty do
     $v \leftarrow \text{dequeue}(Q)$
     $m \leftarrow \text{arity}(\text{label}(v))$
    for $j = 1$ to $m$ do
         $k \leftarrow k + 1$
        Create child node $u$ labeled with symbol $g_k$
        Attach $u$ as the $j$ -th child of $v$
        if $\text{arity}(g_k) > 0$ then
             $\text{enqueue}(Q, u)$
$k_{\text{stop}} \leftarrow k$
return $ET, k_{\text{stop}}$
The coding sequence (the ORF) spans indices $0$ to $k_{\text{stop}}$ . Any positions from $k_{\text{stop}} + 1$ to $L - 1$ downstream within the gene are non-coding regions that do not affect the translated phenotype, acting as a neutral genetic reservoir that can be activated by genetic variation operators in future generations.
Knowl 3 — Multigenic Chromosome Architecture and Sub-ET Linking
model/method
In Gene Expression Programming, complex modular programs are constructed using multigenic chromosomes containing $N_g$ independent genes of equal length ( $h + t$ ). Each gene independently translates into a distinct sub-Expression Tree (sub-ET).

The complete phenotype is assembled posttranslationally by combining the sub-ETs through a designated linking function:
- In numerical and algebraic problems, sub-ETs are typically combined via addition ( $+$ ) or multiplication ( $\times$ ).
- In Boolean logic synthesis, sub-ETs are linked by Boolean connectives such as $\text{OR}$ or conditional operators such as $\text{IF}$ .
- In hierarchical decision structures, sub-ETs can be linked in nested clusters (e.g., grouping sub-ETs 3-by-3 using $\text{IF}$ conditions across multiple hierarchy levels).
- In planning problems, sub-ETs are executed sequentially as ordered subplans.
Because each gene resides at a distinct locus and evolves independently, multigenic chromosomes facilitate the emergence of modular building blocks that combine into complex hierarchical solutions.
Knowl 4 — Gene Expression Algorithm Execution Loop
algorithm
The Gene Expression Algorithm (GEA) evolves populations of candidate solutions through iterative cycles of expression, selection, and reproduction with modification.
Input: Population size $P$ , maximum generations $G_{\text{max}}$ , gene head length $h$ , gene tail length $t$ , function set $F$ , terminal set $T$ , linking function $L_f$ , genetic operator rates ( $p_m, p_{is}, p_{ris}, p_{gt}, p_{1r}, p_{2r}, p_{gr}$ ).
Output: The best evolved chromosome and its phenotype.
Initialize population of $P$ individuals with random linear chromosomes of length $N_g \times (h + t)$
for generation = 1 to $G_{\text{max}}$ do
    for each individual $i = 1$ to $P$ do
        Translate each gene into its corresponding sub-ET
        Link sub-ETs using $L_f$ to form the full ET phenotype
        Evaluate fitness $f_i$ against the set of fitness cases
    Identify the best individual in the population and clone it (elitism)
    if termination criterion is satisfied then
        return best individual and its fitness
    Select $P$ individuals using roulette-wheel selection proportional to fitness
    Apply genetic variation operators to the selected pool:
        Apply mutation with rate $p_m$
        Apply IS transposition with rate $p_{is}$
        Apply RIS transposition with rate $p_{ris}$
        Apply gene transposition with rate $p_{gt}$
        Apply 1-point recombination with rate $p_{1r}$
        Apply 2-point recombination with rate $p_{2r}$
        Apply gene recombination with rate $p_{gr}$
    Form the next generation from the modified offspring and the preserved elitist clone
return best individual found across all generations
Knowl 5 — Genetic Variation Operators in Gene Expression Programming
model/method
GEP introduces genetic variation using operators designed to modify linear chromosomes while maintaining the structural boundaries of genes and ensuring phenotypic validity:
- Point Mutation: Symbols in gene heads can mutate into any symbol from $F \cup T$ . Symbols in gene tails can only mutate into symbols from $T$ .
- Insertion Sequence (IS) Transposition: A sequence randomly chosen anywhere in the chromosome is copied and inserted at a random non-root position in the head of a gene. Upstream symbols remain unchanged; downstream symbols shift right, and excess symbols beyond head length $h$ are dropped.
- Root Insertion Sequence (RIS) Transposition: A fragment starting with a function symbol is identified in a gene head, copied, and inserted at position 0 (the root) of a gene. The entire head shifts right, discarding trailing head symbols beyond length $h$ .
- Gene Transposition: An entire gene is excised from its original position and transposed to the first position of the multigenic chromosome, preserving total chromosome length.
- One-Point Recombination: Two paired parent chromosomes are cut at a shared crossover bond, and genetic material downstream of the cut is exchanged.
- Two-Point Recombination: Two paired parent chromosomes are cut at two independent crossover points, and the intermediate material is swapped between them.
- Gene Recombination: Two paired multigenic chromosomes exchange an entire gene at an identical gene locus.
Unlike traditional genetic programming, a single GEP chromosome can be modified by multiple variation operators simultaneously during reproduction.
Knowl 6 — Ephemeral Random Constant Handling in GEP via the Dc Domain
model/method
To evolve numerical constants without adding static constants directly into the primary terminal set $T$ , GEP extends each gene with an additional domain termed $D_c$ .
1. Gene Structure: A gene with constants consists of three contiguous regions: head (length $h$ ), tail (length $t$ ), and $D_c$ domain (length $d_c = t$ ), giving a total gene length of $h + 2t$ .
2. Alphabets:
  - Heads contain symbols from $F \cup T \cup \{?\}$ , where $?$ represents an ephemeral random constant placeholder.
  - Tails contain symbols from $T \cup \{?\}$ .
  - The $D_c$ domain contains index characters pointing to positions in a pre-generated array $A$ of continuous real numbers.
3. Phenotypic Decoding: The head and tail are first translated into an Expression Tree. Then, all $?$ placeholders appearing in the Expression Tree are visited in level-order (left-to-right, top-to-bottom) and replaced sequentially by the index symbols present in the $D_c$ domain. Each index symbol is dereferenced to its corresponding real value in array $A$ .
4. Variation Operators: A specialized mutation operator and a $D_c$ -specific IS transposition operator act directly on the $D_c$ domain to introduce and shuffle constant indices while preserving region boundaries.
Knowl 7 — Standard Fitness Formulations in Gene Expression Programming
equation
In GEP, fitness functions are formulated to maintain a smooth evolutionary gradient across different problem domains.

For symbolic regression over $C_t$ fitness cases with selection range $M$ , target value $T_j$ , and model prediction $C_{(i,j)}$ for chromosome $i$ on case $j$ :
- Absolute error fitness:
$f_i = \sum_{j=1}^{C_t} \left( M - |C_{(i,j)} - T_j| \right)$

If $|C_{(i,j)} - T_j| \le \epsilon$ (the precision tolerance), $|C_{(i,j)} - T_j|$ is set to $0$ , yielding $M$ fitness points for that case. Perfect fitness corresponds to $f_{\max} = C_t \cdot M$ .
- Relative error fitness:
$f_i = \sum_{j=1}^{C_t} \left( M - \left| \frac{C_{(i,j)} - T_j}{T_j} \right| \cdot 100 \right)$

where relative errors falling within precision tolerance contribute $M$ points.

For Boolean concept learning over $C_t$ fitness cases where an individual correctly classifies $n$ cases, individuals performing at or below chance level are penalized using a threshold function:

$f_i = \begin{cases} n, & \text{if } n \ge \frac{1}{2} C_t \\ 1, & \text{otherwise} \end{cases}$
Knowl 8 — CA Density-Classification Accuracy and Computational Efficiency of GEP vs GP
empirical result
In the density-classification task for a one-dimensional, binary-state cellular automaton with $N = 149$ cells and neighborhood size $2r + 1 = 7$ (search space of $2^{128}$ possible rules), GEP evolved transition rules that surpassed both human-designed rules (such as the GKL rule) and Genetic Programming (GP) rules while requiring significantly fewer evaluations:
- GEP Rule 1 ( $\text{GEP}_1$ ): Evolved using $F = \{AND, OR, NOT, IF\}$ on a single-gene chromosome ( $h=17$ , total length 52). Tested over 100,000 unbiased initial configurations on a $149 \times 298$ lattice, $\text{GEP}_1$ attained an accuracy of $82.513\%$ , exceeding the best GP-evolved rule accuracy of $82.40\%$ .
- GEP Rule 2 ( $\text{GEP}_2$ ): Evolved using $F = \{IF, Majority\}$ on a 3-gene chromosome ( $h=4$ , total length 39) linked by $IF$ . Tested over 100,000 unbiased initial configurations on a $149 \times 298$ lattice, $\text{GEP}_2$ attained an accuracy of $82.550\%$ .
- Evaluation Efficiency: GP required a population of $51{,}200$ across $1{,}000$ initial configurations for 51 generations, totaling $2{,}611{,}200{,}000$ fitness evaluations. GEP evolved $\text{GEP}_1$ using a population of 30 across 25 initial configurations for 50 generations, totaling $37{,}500$ evaluations. This represents a computational speedup of over four orders of magnitude ( $69{,}632\times$ reduction in evaluations).

Knowl 9 — Discovered Cellular Automata Transition Rule Bit-Strings for Density Classification

data/table

The two density-classification cellular automata rules discovered by GEP ( $\text{GEP}_1$ and $\text{GEP}_2$ ) are defined by 128-bit transition lookup tables representing output states for all $2^7 = 128$ neighborhood configurations in lexicographic order from $0000000$ to $1111111$ :

Rule	128-bit Transition Rule Output
$\text{GEP}_1$	00010001 00000000 01010101 00000000 00010001 00001111 01010101 00001111
	00010001 11111111 01010101 11111111 00010001 11111111 01010101 11111111
$\text{GEP}_2$	00000000 01010101 00000000 01110111 00000000 01010101 00000000 01110111
	00001111 01010101 00001111 01110111 11111111 01010101 11111111 01110111
GP rule	00000101 00000000 01010101 00000101 00000101 00000000 01010101 00000101
	01010101 11111111 01010101 11111111 01010101 11111111 01010101 11111111

When evaluated over 100,000 unbiased initial configurations on a $149$ -cell lattice, $\text{GEP}_1$ achieves $82.513\%$ accuracy and $\text{GEP}_2$ achieves $82.550\%$ accuracy, both outperforming the GP rule ( $82.40\%$ ).

Knowl 10 — Benchmark Performance and Parameter Configurations Across Five Problem Domains

data/table

The performance of GEP was evaluated across five benchmark tasks: Symbolic Regression (SR) of $y = a^4 + a^3 + a^2 + a$ , Sequence Induction (SI) of $N = 5a_n^4 + 4a_n^3 + 3a_n^2 + 2a_n + 1$ without ephemeral constants, Sequence Induction with ephemeral random constants (SI*), Block Stacking planning (BS), and the 11-Multiplexer (11-M).

Parameter / Metric	SR	SI	SI*	BS	11-M
Number of runs	100	100	100	100	100
Number of generations	50	100	100	100	400
Population size ( $P$ )	30	50	50	30	250
Number of fitness cases	10	10	10	10	160
Head length ( $h$ )	6	6	7	4	1
Number of genes ( $N_g$ )	3	7	8	3	27
Chromosome length	39	91	184	27	27
Mutation rate ( $p_m$ )	0.051	0.022	0.011	0.074	0.074
One-point recombination rate	0.2	0.7	0.5	0.1	0.7
Two-point recombination rate	0.5	0.1	0.2	–	–
Gene recombination rate	0.1	0.1	0.1	0.7	–
IS transposition rate	0.1	0.1	0.1	0.1	–
IS elements length	1, 2, 3	1, 2, 3	1	1	–
RIS transposition rate	0.1	0.1	0.1	0.1	–
RIS elements length	1, 2, 3	1, 2, 3	1	1	–
Gene transposition rate	0.1	0.1	0.1	–	–
Random constants mutation rate	–	–	0.01	–	–
$D_c$ specific IS transposition rate	–	–	0.013	–	–
Selection range ( $M$ )	100	20%	20%	–	–
Error tolerance	0.01	0.0%	0.0%	–	–
Success rate ( $P_s$ )	1.00	0.83	0.31	0.70	0.57

The benchmark demonstrates that GEP solves symbolic regression with a $100\%$ success rate using small populations ( $P=30$ ). Sequence induction without ephemeral constants yields a higher success rate ( $83\%$ ) than with ephemeral constants ( $31\%$ ). For the 11-multiplexer, GEP achieves a $57\%$ success rate with a population of 250 using 27 one-element genes linked by $\text{IF}$ , whereas standard GP failed with population 500 and required 4,000 individuals.

Coverage note — No substantial contributed material was omitted; all key theoretical constructs, algorithms, genetic variation mechanisms, constant creation extensions, fitness functions, CA density classification results, and empirical benchmark parameters are covered.

References

1.M. Mitchell, An Introduction to Genetic Algorithms (MIT Press, 1996).
2.J. Maynard Smith and E. Szathmáry, The Major Transitions in Evolution (W. H. Freeman, 1995).
3.R. Dawkins, River out of Eden (Weidenfeld and Nicolson, 1995).
4.W. Banzhaf, “Genotype-phenotype-mapping and Neutral variation - A Case Study in Genetic Programming”, in Y. Davidor, H.-P. Schwefel, and R. Männer, eds., Parallel Problem Solving from Nature III, Vol. 866 of Lecture Notes in Computer Science (Springer-Verlag, 1994).
5.R. E. Keller and W. Banzhaf, “Genetic Programming Using Genotype-phenotype Mapping from Linear Genomes into Linear Phenotypes”, in J. R. Koza, D. E. Goldberg, D. B. Fogel, and R. L. Riolo, eds., Genetic Programming 1996: Proceedings of the First Annual Conference (MIT Press, 1996).
6.M. J. Keith and M. C. Martin, “Genetic Programming in C++: Implementation Issues”, in K. E. Kinnear, ed., Advances in Genetic Programming (MIT Press, 1994).
7.W. Banzhaf, P. Nordin, R. E. Keller, and F. D. Francone, Genetic Programming: An Introduction: On the Automatic Evolution of Computer Programs and its Applications (Morgan Kaufmann, San Francisco, 1998).
8.J. H. Holland, Adaptation in Natural and Artificial Systems: An Introductory Analysis with Applications to Biology, Control, and Artificial Intelligence, second edition (MIT Press, 1992).
9.J. R. Koza, Genetic Programming: On the Programming of Computers by Means of Natural Selection, (MIT Press, Cambridge, MA, 1992).
10.D. E. Goldberg, Genetic Algorithms in Search, Optimization, and Machine Learning (Addison-Wesley, 1989).
11.M. Lynch and J. S. Conery, “The Evolutionary Fate and Consequences of Duplicated Genes”, Science, 290 (2000), 1151-1155.
12.M. Mitchell, P. T. Hraber, and J. P. Crutchfield, “Revisiting the Edge of Chaos: Evolving Cellular Automata to Perform Computations”, Complex Systems, 7 (1993), 89-130.
13.M. Mitchell, J. P. Crutchfield, and P. T. Hraber, “Evolving Cellular Automata to Perform Computations: Mechanisms and Impediments”, Physica D, 75 (1994), 361-391.
14.J. P. Crutchfield and M. Mitchell, “The Evolution of Emergent Computation”, Proceedings of the National Academy of Sciences, USA, 82 (1995), 10742-10746.
15.R. Das, M. Mitchell, and J. P. Crutchfield, “A Genetic Algorithm Discovers Particle-based Computation in Cellular Automata”, in Y. Davidor, H.-P. Schwefel, and R. Männer, eds., Parallel Problem Solving from Nature - PPSN III (Springer-Verlag, 1994).
16.J. R. Koza, F. H. Bennett III, D. Andre, and M. A. Keane, Genetic Programming III: Darwinian Invention and Problem Solving (Morgan Kaufmann, San Francisco, 1999).
17.H. Juillé, and J. B. Pollack, “Coevolving the “Ideal” Trainer: Application to the Discovery of Cellular Automata Rules”, in J. R. Koza, W. Banzhaf, K. Chellapilla, M. Dorigo, D. B. Fogel, M. H. Garzon, D. E. Goldberg, H. Iba, and R. L. Riolo, eds., Genetic Programming 1998: Proceedings of the Third Annual Conference (Morgan Kaufmann, San Francisco, 1998).
18.U.-M. O’Reilly and F. Oppacher, “A Comparative Analysis of Genetic Programming”, in P. J. Angeline and K. E. Kinnear, eds., Advances in Genetic Programming 2 (MIT Press, 1996).

Citation

MLA

Ferreira, C. “Gene Expression Programming: A New Adaptive Algorithm for Solving Problems”. Complex Systems, 13(2): 87-129, 2001, 2001, http://arxiv.org/abs/cs/0102027v3.

APA

Ferreira, C. (2001). Gene Expression Programming: a New Adaptive Algorithm for Solving Problems. Complex Systems, 13(2): 87-129, 2001. http://arxiv.org/abs/cs/0102027v3

Chicago

Ferreira, C. 2001. “Gene Expression Programming: A New Adaptive Algorithm for Solving Problems”. Complex Systems, 13(2): 87-129, 2001. http://arxiv.org/abs/cs/0102027v3.

Harvard

Ferreira, C. (2001) “Gene Expression Programming: a New Adaptive Algorithm for Solving Problems”, Complex Systems, 13(2): 87-129, 2001 [Preprint]. Available at: http://arxiv.org/abs/cs/0102027v3.

Vancouver

1. Ferreira C (2001) Gene Expression Programming: a New Adaptive Algorithm for Solving Problems. Complex Systems, 13(2): 87-129, 2001

BibTeX

@article{ferreira2001gene,
  title = {Gene Expression Programming: a New Adaptive Algorithm for Solving Problems},
  author = {Ferreira, Candida},
  year = {2001},
  journal = {Complex Systems, 13(2): 87-129, 2001},
  url = {http://arxiv.org/abs/cs/0102027v3},
  eprint = {cs/0102027}
}

Metadata:arXiv

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF

Gene Expression Programming: A New Adaptive Algorithm for Solving Problems

Abstract

Topics

Keywords

Table of Contents

Knowls

Knowl 1 — Structural Invariant and Head-Tail Organization of GEP Genes

Knowl 2 — Translation Algorithm of K-Expressions into Expression Trees

Knowl 3 — Multigenic Chromosome Architecture and Sub-ET Linking

Knowl 4 — Gene Expression Algorithm Execution Loop

Knowl 5 — Genetic Variation Operators in Gene Expression Programming

Knowl 6 — Ephemeral Random Constant Handling in GEP via the Dc Domain