Towards the Automatic Programming of NEPs - Foundations on Natural and Artificial Computation - page 306

A given configuration of a NEP can change either by an evolutionary step or by
a communicating step. When changing by an evolutionary step, each component
L i of the configuration is changed in accordance with the evolutionary rules
associated with the node i .
When changing by a communication step, each node processor N i sends all
the copies of the strings it has, able to pass its output filter, to all the node
processors connected to N i , and receives all the copies of the strings sent by any
node processor connected with N i , if they can pass its input filter.

4 Automatic Programming of NEPs

According to the general methodology previously outlined, we have decided to
use a Java NEP simulator (jNEP 1

[6] ). The grammar and the fitness function

depend on this choice.
jNEP uses as inputs XML files describing the NEP being simulated. Our in-
dividuals will be valid XML descriptions of the NEPs 2 . This paper shows the
context free grammar we are currently using to generate the initial population.
It will be the kernel for the Christiansen grammar we will finally use in further
experiments. AGE/CGE are able to include semantic constraints when gener-
ating the populations to ensure that only syntactically and semantically valid
individuals belong to them. When we design AGE/CGE experiments, we have
to tune also the amount of semantic constraints we add to the grammar. We
have seen that toomuchsemantics converts the genetic process into a random
search. This is the reason why we have decided to remove these restrictions and
use a context free grammar in our first proofs.
In this work we have not used all the options available for describing NEPs
by means of jNEP XML files. jNEP accepts all the variants and constructs
found in the literature. In order to reduce the huge search space defined by
the full grammar, we have decided to force some structural and functioning
characteristics of NEPs. In the future we will test the system with more general
NEPs. The features of the NEPs generated are explained in the following section.
Our goal is to solve a moderately complex problem presented and solved in
[4]. This paper shows how NEPs simulate the application of context free rules
( A V ∗ for alphabet V ) in three steps. The first one (that is our

goal) rotates the string where the rule is being applied until placing A in one of
the string ends. In [4], this taks is performed by means of a NEP with 4 nodes
sequentially connected.
The evolution of this NEP can be summarized as follows: let us call “s”
the symbol being rotated. The first node of the NEP receives a word where the
symbol “s” is at the end. This node substitutes “s” by an auxiliary copy (“s a1”).
Then, the new word is sent to the second node, where a new auxiliary symbol
(“s a2”) is added to the beginning of the word. The last two nodes remove “s a1”
and substitute “s a2” by the original“s”. These nodes use filters that reject those

→ α, A ∈ V, α ∈

1 The jNEP code is freely available in http://jnep.e-delrosal.net
2 See the jNEP User Guide in http://jnep.e-delrosal.net