- Trees contain only `dummy' functions and terminals which are not used to calculate fitness.
- Fitness is assigned arbitrarily of tree shape or content. All individuals have an initial fitness of 1.0 (0.0 is the best fitness).
- An offspring which is the same size or larger than its parent is awarded a small fitness improvement, an offspring which is smaller than its parent is penalised by a small amount. This incorporates the theories and corresponding empirical evidence of code growth.

The model consists of binary trees
that are initially full with 7 nodes.
The algorithm is presented below
(a population size of 100, tournament selection size of 3, and
subtree crossover is used for recombination):

The `P` value indicates the hardness of the
problem. A smaller value denotes the unlikely event that good solutions
are found often and by many individuals (a difficult problem).
The higher probability corresponds to
the situation where many early individuals can easily represent
good solutions, and in each generation more new individuals with the
same good fitness can be found (an easy problem).
The fact that same size or larger individuals are
rewarded represents the general consensus in the community that growth
is seen with improved performance in the canonical algorithm.
Note that it is the *rate of growth* which is investigated here and that
the assignment of ideal fitness is independent of size.

A range of `P` values show
a marked difference between easier and harder instances in
Figure 6.10.
Easier instances (`P` values of 0.2 and 0.1) induce a lower entropy
and more diversity, which both contribute to a slower rate of code
growth.
This effect is similar to the results on symbolic regression instances
presented earlier.
More difficult instances induce higher entropy and lower diversity
that dually contribute toward faster code growth.
These results
support the previous conjecture that reducing the difficulty of instances
in this way leads to lower
selection pressure (via entropy) and more diversity (due to less
selection pressure). These factors cause more different programs to be
recombined to produce less code growth.