![](bg2.png)
tial equations with polynomial coefficients. As ex-
amples, polynomials, exponential functions, trigono-
metric functions on some particular intervals and, in
general, analytic algebraic functions are Pfaffian. The
main outcome of this work is a penalty term for the
fitness function of a genetic programming strategy
based on slp’s to solve inductive learning problems.
Experimental results point out that the slp structure,
if suitably regularized, may result in a robust tool for
supervised learning.
2 STRAIGHT LINE PROGRAM
GENETIC PROGRAMMING
Straight line programs have a large history in the
field of Computational Algebra. A particular class
of straight line programs, known in the literature as
arithmetic circuits, constitutes the underlying compu-
tation model in Algebraic Complexity Theory ((Bur-
guisser et al., 1997)). Arithmetic circuits with the
standard arithmetic operations {+,−,∗,/} are the
natural model of computation for studying the com-
putational complexity of algorithms solving problems
with an algebraic flavor. They have been used in lin-
ear algebra problems ((Berkowitz, 1984)), in quan-
tifier elimination ((Heintz et al., 1990)) and in alge-
braic geometry ((Giusti and Heinz, 1993) and (Giusti
et al., 1997)). Also, slp’s constitute a promising alter-
native to the trees in the field of Genetic Programming
(see (Alonso et al., 2008)). The formal definition of
the straight line program structure is as follows: Let
F = {f
1
,..., f
n
} be a set of functions, where f
i
has
arity a
i
, for 1 ≤i ≤ n, and let T = {t
1
,...,t
m
} be a set
of terminals. A straight line program (slp) over F and
T is a finite sequence of computational instructions
Γ = {I
1
,...,I
l
} where
I
k
≡ u
k
:= f
j
k
(α
1
,...,α
a
j
k
); with f
j
k
∈ F,
α
i
∈T for all i if k = 1 and α
i
∈T ∪{u
1
,...,u
k−1
} for
1 < k ≤ l.
Terminal set T is of the form T = V ∪C, where
V = {x
1
,...,x
n
} is a finite set of variables and C =
{c
1
,...,c
q
} is a finite set of constants. The number of
instructions l is the length of Γ.
Note that if we consider the sl p Γ as the code of a
program, then a new variable u
i
is introduced at each
instruction I
i
. We will denote by Γ = {u
1
,...,u
l
} a
slp. Each of the non-terminal variables u
i
can be con-
sidered as an expression over the set of terminals T
constructed by a sequence of recursive compositions
from the set of functions F. The set of all slp’s over F
and T is denoted by SLP(F,T ).
An output set of a slp Γ = {u
1
,...,u
l
} is any
set of non-terminal variables of Γ, that is, O(Γ) =
{u
i
1
,...,u
i
t
}, i
1
< ··· < i
t
. Provided that V =
{x
1
,...,x
p
} ⊂ T is the set of terminal variables, the
function computed by Γ, denoted by Φ
Γ
: I
p
→ O
t
,
is defined recursively in the natural way and satisfies
Φ
Γ
(a
1
,...,a
p
) = (b
1
,...,b
t
), where b
j
stands for the
value of the expression over V of the non-terminal
variable u
i
j
when we replace the variable x
k
with a
k
;
1 ≤ k ≤ p.
For computing the initial population, the well
known methods for trees (see (Koza, 1992)) can be
easily adapted to slp’s. In order to compute the fitness
function in a GP process to solve a particular prob-
lem, the computation of the function Φ
Γ
, considering
its own definition, would be often necessary.
2.1 SLP Crossover and Mutation
For slp-GP, 1-point crossover and in general k-point
crossover are easily defined. However, a new spe-
cific crossover operation that produces another type of
information exchange between the two selected par-
ents, has been designed. The objective is to carry
subexpressions from one parent to the other. A subex-
pression is captured by an instruction u
i
and all the
instructions that are used to compute the expression
over the set of terminals represented by u
i
. Now fol-
lows a description of this crossover with a clarifying
example.
Given two slp’s, Γ
1
and Γ
2
, first a position k en Γ
1
is randomly selected. Let S
u
k
be the set of all instruc-
tions related to the computation of the subexpression
associated to node u
k
. We obtain the first offspring by
randomly selecting an allowed position t in Γ
2
and
making the substitution of a part of its instructions by
those instructions in S
u
k
suitably renamed. For the
second offspring we symmetrically repeat the strat-
egy.
Example: Consider F = {∗,+}, L = 5 and T =
{x,y}. Let Γ
1
and Γ
2
be the following two slp’s:
Γ
1
≡
u
1
:= x + y
u
2
:= u
1
∗u
1
u
3
:= u
1
∗x
u
4
:= u
3
+ u
2
u
5
:= u
3
∗u
2
Γ
2
≡
u
1
:= x ∗x
u
2
:= u
1
+ y
u
3
:= u
1
+ x
u
4
:= u
2
∗x
u
5
:= u
1
+ u
4
If k = 3 then S
u
3
= {u
1
,u
3
}, and t must be selected in
{2,...,5}. If for instance t = 3, then the first offspring
is as follows.
Γ
0
1
≡
u
1
:= x ∗x
u
2
:= x + y
u
3
:= u
2
∗x
u
4
:= u
2
∗x
u
5
:= u
1
+ u
4
IJCCI2013-InternationalJointConferenceonComputationalIntelligence
26