Hybrid networks of evolutionary processors are computationally complete.

Full text

Page 1

Hybrid Networks of Evolutionary Processors
Are Computationally Complete
Erzs´ ebet Csuhaj-Varj´ u1∗
Carlos Mart´ ın-Vide2
Victor Mitrana2†
1Computer and Automation Research Institute, Hungarian Academy of Sciences,
Kende u. 13-17, H-1111 Budapest, Hungary.
csuhaj@sztaki.hu
2Research Group in Mathematical Linguistics, Rovira i Virgili University
P¸ ca. Imperial T` arraco 1, 43005 Tarragona, Spain
{cmv,vmi}@correu.urv.es
Abstract
A hybrid network of evolutionary processors (an HNEP) consists of several language
processors which are located in the nodes of a virtual graph and able to perform only
one type of point mutations (insertion, deletion, substitution) on the words found in that
node, according to some predefined rules. Each node is associated with an input and an
output filter, defined by some random-context conditions. After applying in parallel a
point mutation to all the words existing in every node, the new words which are able to
pass the output filter of the respective node navigate simultaneously through the network
and enter those nodes whose input filter they are able to pass. We show that even the so-
called elementary HNEPs are computationally complete. In this case every node is able
to perform only one instance of the specified operation: either an insertion, or a deletion,
or a substitution of a certain symbol. We also prove that in the case of non-elementary
networks, any recursively enumerable language over a common alphabet can be obtained
with an HNEP whose underlying structure is a fixed graph depending on the common
alphabet only.
1Introduction
This paper is a continuation of the investigations started in [1] and continued in [2] and
[12], where a computing model inspired by cell biology, namely, a network of evolutionary
∗Work supported in part by a grant from the NATO Scientific Committee in Spain and Hungarian Scientific
Research Fund ”OTKA” Grant No. T 042529
†Work supported by the Centre of Excellence in Information Technology, Computer Science and Control,
ICA1-CT-2000-70025, HUN-TING project, WP5.
1

Page 2

processors (a NEP), is introduced and studied. The nodes of these networks are very sim-
ple language processors (language determining devices) which are able to perform one type
of point mutations, namely an insertion, a deletion or a substitution of a symbol. These
nodes are endowed with filters which are defined by some membership or random-context
conditions. The processors of the network apply the above operations to the words found
in their respective nodes and communicate these words to each other through the filters.
Another source of inspirations for introducing this concept was an architecture for parallel
and distributed symbolic processing, related to the Connection Machine [10] as well as the
Logic Flow paradigm [5]. This architecture consists of several processors, each of them being
placed in a node of a virtual complete graph. Each node processor acts on the local data
associated with the respective node, in accordance with some predefined rules, and then lo-
cal data become mobile agents which are able to navigate in the network, following a given
protocol. Only data that are able to pass a filtering process can be communicated. This
process requires the fulfillment of some conditions imposed by the sending processor, by the
receiving processor or by both of them. All the nodes send simultaneously their local data
and the receiving nodes handle also simultaneously all the arriving data, according to some
strategies, see, e.g., [6, 10].
Starting from the premise that data can be given in the form of words, [3] introduced
a concept, called networks of (parallel) language processors, with the aim of investigating
the above architectures in the framework of formal grammars and languages. According
to this general framework, the processors are represented by arbitrary language generating
devices (grammars, Lindenmayer systems, etc.), and the filters are defined by different types
of context conditions. Networks of evolutionary processors, introduced in [1] and [2, 12]
represent a variant of a network of language processors with as simple language theoretic
operations as possible. Furthermore, the way of applying these operations is very different
and the context conditions which the definition of filters is based on are more general. Thus,
a very simple processor, called an evolutionary processor, is placed in each node of the
network. Each processor is able to perform only a simple rewriting operation, namely, either
an insertion of a symbol, or a substitution of a symbol by another one, or a deletion of
a symbol. We call the respective nodes an insertion, a deletion, or a substitution node,
respectively.
Although these mechanisms consist of extremely simple components, they are very pow-
erful. It is shown that NEPs with at most six nodes having regular filters defined by the
membership condition - to pass a regular filter, the word must be an element of the regular
language given by the condition - are able to generate all recursively enumerable languages,
irrespective the underlying graph structure [2]. However, this result is not surprising, since
similar characterizations can be found in the literature, see, e.g., [4, 8, 9, 11]. If we consider
these networks with nodes having filters defined by random-context conditions, which seems
to be closer to the recent possibilities of biological implementation, then still rather complex
languages, as non-context-free ones, can be generated. Moreover, using these simple mecha-
nisms we can solve NP-complete problems in linear time. Such solutions are presented for the
Bounded Post Correspondence Problem in [1], for the “3-colorability problem” in [2] (with
simplified networks), and for the Common Algorithmic Problem in [12]. As a further step,
in [12] the so-called hybrid networks of evolutionary processors are considered. In this case
2

Page 3

each deletion node or insertion node has its own working mode (performs the operation at
any position, in the left-hand end, or in the right-hand end of the word) and different nodes
are allowed to use different ways of filtering. Thus, the same network may have nodes where
the deletion operation can be performed at arbitrary position and nodes where the deletion
can be done only at the right-hand end of the word.
Since the computational power of these networks remained unsettled in [12], the goal
of our paper is to fill this gap. As for the networks of evolutionary processors, we obtain
that HNEPs are computationally complete devices. Moreover, we prove that all recursively
enumerable languages over an n-letter alphabet can be generated by hybrid networks of evo-
lutionary processors having the same underlying structure. The computational completeness
can also be obtained if we restrict the networks to the so-called elementary hybrid networks
of evolutionary processors, where the nodes cannot perform more than one instance of the
specified operation, for example, the insertion of a certain symbol.
Hybrid networks of evolutionary processors can be viewed as bio-computing models in
the following sense: each node represents a cell having a genetic information encoded in
DNA sequences which may evolve by local evolutionary events, that is, point mutations
(insertion, deletion or substitution of a pair of nucleotides). Each node is specialized just
for one of these evolutionary operations.Furthermore, the biological data in each node
is organized in the form of arbitrarily large multisets of words (each word appears in an
arbitrarily large number of copies), all copies are processed in parallel such that all the
possible events that can take place do actually take place. Obviously, the computational
process described here is not exactly an evolutionary process in the Darwinian sense. But the
rewriting operations we have considered might be interpreted as mutations and the filtering
process might be viewed as a selection process. Recombination is missing but it was asserted
that evolutionary and functional relationships between genes can be captured by taking only
local mutations into consideration [13]. In this paper, we are not concerned with a possible
biological implementation, though a matter of great importance, we demonstrate that HNEPs
are powerful and simple bio-inspired computational devices.
2Preliminaries
We first summarize the notions we shall use throughout the paper. An alphabet is a finite
and nonempty set of symbols. The cardinality of a finite set A is written as card(A). A
sequence of symbols from an alphabet V is called a word over V . The set of all words over
V is denoted by V∗and the empty word is denoted by ε; we use V+= V∗−{ε}. The length
of a word x is denoted by |x|, while we denote the number of occurrences of a letter a in a
word x by |x|a. For each nonempty word x, alph(x) is the minimal alphabet W such that
x ∈ W∗. We say that a rule a → b, with a,b ∈ V ∪ {ε} is a substitution rule if both a and
b are different from ε; it is a deletion rule if a ?= ε and b = ε; and, it is an insertion rule if
a = ε and b ?= ε. The set of all substitution, deletion, and insertion rules over an alphabet
V are denoted by SubV, DelV, and InsV, respectively. Given a rule σ, as above, and a word
w ∈ V∗, we define the following actions of σ on w:
3

Page 4

- If σ ≡ a → b ∈ SubV, then
σ∗(w) =
?
{ubv : ∃u,v ∈ V∗(w = uav)},
{w}, otherwise
?
{w}, otherwise
{u : w = ua},
{w}, otherwise
- If σ ≡ ε → a ∈ InsV, then
σ∗(w) = {uav : ∃u,v ∈ V∗(w = uv)}, σr(w) = {wa}, σl(w) = {aw}.
- If σ ≡ a → ε ∈ DelV, then σ∗(w) =
{uv : ∃u,v ∈ V∗(w = uav)},
σr(w) =
?
σl(w) =
?
{v : w = av},
{w}, otherwise
Symbol α ∈ {∗,l,r} denotes the way of applying an insertion or deletion rule to a word,
namely, at any position (α = ∗), in the left-hand end (α = l), or in the right-hand end (α = r)
of the word, respectively. Note that a substitution rule can be applied at any position only.
For every rule σ, action α ∈ {∗,l,r}, and L ⊆ V∗, we define the α-action of σ on L by
σα(L) =?
Mα(w) =
σ∈M
respectively.
In the following we shall refer to the rewriting operations defined above as evolutionary
operations, since they may be viewed as formulations of local gene mutations in terms of
formal languages. For two disjoint subsets P and F of an alphabet V and a word over V , we
define the predicates ϕ(1)and ϕ(2)as follows:
w∈Lσα(w). For a given finite set of rules M, we define the α-action of M on a
word w and on a language L by:
?
σα(w)and
Mα(L) =
?
w∈L
Mα(w),
ϕ(1)(w;P,F) ≡ P ⊆ alph(w) ∧ F ∩ alph(w) = ∅
and
ϕ(2)(w;P,F) ≡ alph(w) ∩ P ?= ∅ ∧ F ∩ alph(w) = ∅.
The construction of these predicates is based on random-context conditions defined by the
two sets P (permitting contexts) and F (forbidding contexts). In [12] other types of predicates
are also defined:
ϕ(3)(w;P,F) ≡
ϕ(4)(w;P,F) ≡
However, the first two predicates are sufficient for our goals so that the last two predicates
will not be used in the sequel. For every language L ⊆ V∗and β ∈ {(1),(2))}, we define:
ϕβ(L,P,F) = {w ∈ L | ϕβ(w;P,F)}.
An evolutionary processor over V is a 5-tuple (M,PI,FI,PO,FO) where:
alph(w) ⊆ P
P ⊆ alph(w)
∧
F ?⊆ alph(w)
4

Page 5

- Either M ⊆ SubV or M ⊆ DelV or M ⊆ InsV. The set M represents the set of
evolutionary rules of the processor. Note that every processor is dedicated to one type
of the above evolutionary operations only.
- PI,FI ⊆ V are the input permitting/forbidding contexts of the processor, while
PO,FO ⊆ V are the output permitting/forbidding contexts of the processor.
We denote the set of evolutionary processors over V by EPV.
A hybrid network of evolutionary processors is a 7-tuple Γ = (V , G, N, C0, α, β, i0),
where the following conditions hold:
• V is an alphabet.
• G = (XG,EG) is an undirected graph with the set of vertices XGand the set of edges
EG, each edge is given in the form of a set of two nodes. G is called the underlying
graph of the network.
• N : XG−→ EPVis a mapping which associates with each node x ∈ XGthe evolutionary
processor N(x) = (Mx,PIx,FIx,POx,FOx).
• C0: XG−→ V∗is a mapping which identifies the initial configuration of the network.
It associates a finite set of words with each node of the graph G.
• α : XG−→ {∗,l,r}; α(x) gives the action mode of the rules of node x on the words
occurring in that node.
• β : XG −→ {(1),(2)} defines the type of the input/output filters of a node. More
precisely, for every node, x ∈ XG, we define the following filters: the input filter is
given as
ρx(·) = ϕβ(x)(·;PIx,FIx),
and the output filter is defined as
τx(·) = ϕβ(x)(·;POx,FOx).
That is, ρx(w) (resp. τx) indicates whether or not the word w can pass the input (resp.
output) filter of x. More generally, ρx(L) (resp. τx(L)) is the set of words of L that
can pass the input (resp. output) filter of x.
• i0∈ XGis the output node of the HNEP.
We say that card(XG) is the size of Γ. If α(x) = α(y) and β(x) = β(y) for any pair of nodes
x,y ∈ XG, then the network is said to be homogeneous. Note that in a homogeneous HNEP,
the way of applying the evolutionary rules is ∗ for all nodes. If the set of rules in every node
consists of at most one rule, then the network is said to be elementary. In the theory of
networks some types of underlying graphs are common, these are for example, rings, stars,
grids, etc. We shall investigate networks of evolutionary processors with these underlying
graphs. Thus, an HNEP is said to be a star, ring, or complete HNEP if its underlying graph
5

Page 6

is a star, ring, grid, or complete graph, respectively. The star, ring, and complete graph with
n vertices is denoted by Sn, Rn, and Kn, respectively.
A configuration of an HNEP Γ as above is a mapping C : XG−→ V∗which associates
a set of words with each node of the graph. A component C(x) of a configuration C is the
set of words that can be found in the node x in this configuration, hence a configuration can
be considered as the sets of words which are present in the nodes of the network at a given
moment. A configuration can change either by an evolutionary step or by a communication
step. When changing by an evolutionary step, each component C(x) of the configuration C is
changed in accordance with the set of evolutionary rules Mxassociated with the node x and
the way of applying these rules α(x). Formally, we say that the configuration C?is obtained
in one evolutionary step from the configuration C, written as C =⇒ C?, iff
C?(x) = Mα(x)
x
(C(x)) for all x ∈ XG.
When changing by a communication step, each node processor x ∈ XGsends a copy of each
of its words to every node processor which is connected with x, provided that this word is
able to pass the output filter of x, and receives all the words which are sent by the node
processors connected with x, providing that these words are able to pass the input filter of
x. Formally, we say that the configuration C?is obtained in one communication step from
configuration C, written as C ? C?, iff
C?(x) = (C(x) − τx(C(x))) ∪
{x,y}∈EG
Let Γ an HNEP, a computation in Γ is a sequence of configurations C0, C1, C2, ..., where
C0is the initial configuration of Γ, C2i=⇒ C2i+1and C2i+1? C2i+2, for all i ≥ 0. If the
sequence is finite, we have a finite computation. If we use HNEPs as language generating
devices, then the generated language is the set of all words which appear in the output node
under a finite computation in the network. Formally, the language generated by Γ is
?
?
(τy(C(y)) ∩ ρx(C(y))) for all x ∈ XG.
L(Γ) =
s≥0
Cs(i0).
3Computational Completeness
We show that elementary HNEPs are as powerful as Turing machines. Then we prove that
in the case of non-elementary networks any recursively enumerable language over a common
fixed alphabet can be obtained with HNEPs with the same underlying graph structure.
Theorem 1 Any recursively enumerable language can be generated by an elementary com-
plete HNEP or an elementary star HNEP.
Proof. Let G = (N,T,P,S) be a phrase-structure grammar in the Geffert normal form ([7]),
namely with N = {S,A,B,C} and rules of the form S → x, x ∈ (N ∪ T)+, and ABC → ε.
We construct an elementary complete HNEP
Γ = (U,Ks,N,C0,α,β,Nfinal)
6

Page 7

which simulates the derivations in G by the so-called rotate-and-simulate method. The al-
phabet U of the network and the network size s are defined as follows:
U
=
N ∪ T ∪ {$} ∪ {ZX,X?| X ∈ (N ∪ T ∪ {$})} ∪ {Yr| 1 ≤ r ≤ m} ∪
{WA,WB,WC} ∪ {x(r,k)
28 + 2m + 2
r=1
k
| r : S → x1x2...xpr,1 ≤ k ≤ pr}
pr+ 4 · card(T).s
=
m
?
The rotate-and-simulate method means that the words found in the nodes are involved
into either the rotation of the rightmost symbol (the rightmost symbol of the word is moved to
the beginning of the word) or a simulation of a rule of P. To guarantee the correct simulation,
a marker symbol, $, is introduced for indicating the beginning of simulated word under the
rotation, which is removed at the end of the computation provided it is the leftmost symbol.
Let N?= N ∪ {$}. The constructed network consist of three parts which do not interfere
with each other, despite that all nodes of the network are connected with each other. Each
part, consisting of groups of nodes, is dedicated to exactly one type of tasks, that is, the
rotation of a symbol, the simulation of a rule S → x or the simulation of the rule ABC → ε.
Assume that the rules S → x ∈ P are labelled in a one-to-one manner by 1,2,...,m. We
first define that part of Γ which makes possible the rotation of symbols in N?∪ T. The
following table gives the description of the group of nodes which realize the rotation of a
symbol X ∈ (N?∪ T), Γ contains such a group of nodes for each X in (N?∪ T).
Node
MPI
N1
{X → ZX}
N2
{ε → X?}
N3
{ZX→ ε}
N4
{X?→ X}
FIPO
{ZX}
∅
{X?}
∅
FO
∅
∅
{ZX}
{X?}
C0
{$S}
∅
∅
∅
α
∗
l
r
∗
β
rot(X)
rot(X)
rot(X)
rot(X)
{$}
U \ (N?∪ T)
{X?}
∅
{ZX}
(1)
(1)
(1)
(1)
{ZX,$}
{ZX,X?,$}
{X?,$}
Table 1.
If a word enters the node N1
its rightmost symbol. First, an arbitrary occurrence of X is replaced by ZX. If the word
has no occurrence of X, then it will never leave this node, since it cannot pass the output
filter. Once the word has the symbol ZX, then it is sent out, but only node N2
to receive it. In N2
the new word leaves the node through the output filter, and it is able to pass only the input
filter of N3
forever. Otherwise, this rightmost symbol is deleted and the word can leave this node. It can
pass only the input filter of N4
symbol X has been rotated.
Table 2 describes a group of nodes of Γ which simulate one application of the rule r : S →
x, x = x1x2...xprfor some pr≥ 1. Γ has such a group of nodes for any rule of the form
r : S → x, 1 ≤ r ≤ m. In Table 2, k ranges from 1 to prand the set Ekis defined by
?
pr−k+2
rot(X) with the aim of rotating symbol X, then X has to be
rot(X) is able
rot(X) symbol X?is appended to the word as its leftmost symbol. Then,
rot(X). Here, if its rightmost symbol is not ZX, the word will remain in the node
rot(X), where X?is restored into the original symbol X. Thus,
Ek=
∅, if k = 1
{x(r,pr−k+2)
,x(r,pr−k+3)
pr−k+3
,...,x(r,pr)
pr
}, if k > 1
7

Page 8

Node
N1
Nk+1
MPI
∅
FIPO
{Yr}
∅
FO
∅
∅
C0
{$S}
∅
α
∗
l
β
sim(r)
sim(r)
{S → Yr}
{ε → x(r,pr+1−k)
U \ (N?∪ T)
{x(r,pr+1−k)
(1)
(1)
pr+1−k
}{Yr}∪
Ek
{Yr}∪
Epr+1
{x(r,k)
pr+1−k
}
Npr+2
sim(r)
{Yr→ ε}∅
Epr+1
{Yr}∅
r
(1)
Npr+2+k
sim
(r)
{x(r,k)
k
→ xk}
k
}{Yr}∅{x(r,k)
k
}∅∗
(1)
Table 2.
The idea behind this construction is as follows: the simulation works only for words
which enter the node N1
is replaced by Yr and then, by means of nodes Nk+1
x(r,pr−1)
pr−1
all these symbols have been added, symbol Yris deleted (it must be the rightmost symbol).
In the obtained words, symbols x(r,k)
k
are restored into the original symbols xk, no matter
the order. These words are communicated among the nodes Npr+k+2
symbols x(r,k)
k
are restored. Note that these nodes of the network can interfere neither with
nodes which simulate the application of any other rule nor with the nodes simulating the
rotation of any symbol.
We present now the simulation of an application of the rule ABC → ε. Table 3 describes
the simulating nodes of Γ.
sim(r) having S as their rightmost symbol. This occurrence of S
sim(r), k = 1,2,...,pr, symbols x(r,pr)
are appended in turn, in this order, to the beginning of the words. After
pr
,
,...,x(r,1)
1
sim
, 1 ≤ k ≤ pr, until all
Node
N1
del
N2
del
N3
del
N4
del
N5
del
N6
del
M PI
∅
FIPO
∅
∅
∅
∅
∅
∅
FO
∅
∅
∅
{WB}
{WC}
{WA}
C0
∅
∅
∅
∅
∅
∅
α
∗
∗
∗
r
l
r
β
{B → WB}
{C → WC}
{A → WA}
{WB→ ε}
{WC→ ε}
{WA→ ε}
U \ (N?∪ T)
{WC}
{WA}
∅
{WB}
{WC}
(1)
(1)
(1)
(1)
(1)
(1)
{WB}
{WB,WC}
{WA,WB,WC}
{WA,WC}
{WA}
Table 3.
We briefly explain the simulation which works for words of the form CαAB, where α ∈
(N?∪ T)∗. Since the symbols can be rotated, such a form can easily be obtained from words
having ABC as a subword (factor). First, the word in the form CαAB arrives in node N1
where an occurrence of B is replaced by WB. If this occurrence is not the rightmost symbol,
then the word will be lost later. Having an occurrence of WB, the word can enter only
node N2
leftmost letter, otherwise the word will be lost later. Then the new word is forwarded to the
node N3
be the second rightmost letter. The only possible continuation is to send the word to the
node N4
the successful deletion the word can enter node N5
letter, otherwise the word remaining in N5
del
del, where an occurrence of C is rewritten to WC. Again this occurrence must be the
delwhere an occurrence of A is replaced by WA. As we shall see, this occurrence must
del, where WBis removed provided that it is the rightmost letter of the word. After
del, where WCis removed if it is the leftmost
delforever. Finally, in the node N6
delletter WAis
8

Page 9

deleted from the word. Now, WAmust be the rightmost letter, therefore when an occurrence
of A was replaced by WAin the node N3
to the construction of this part of the network, this is the only way of successfully deleting
a subword ABC from the word, moreover, during this phase of the work no rotation of a
symbol or simulation of an application of a rule of the form S → x is possible.
Finally, Γ has two more nodes, node Nc
non-terminal letter different from $, and it cancels the marker $ supposing that it is the
leftmost symbol. The other node, Nfinalis the output node. These nodes are described by
Table 4.
delit had to be the second rightmost letter. Due
$checks whether the word does not contain any
Node
Nc
Nfinal
MPI
∅
∅
FI PO
∅
∅
FO
T
T
C0
∅
∅
α
l
∗
β
$
$ → ε
∅
U \ (T ∪ {$})
U \ T
(1)
(1)
Table 4.
The reader can easily verify that Γ simulates all the derivations in G and nothing else.
To obtain an elementary star HNEP generating the same language, we add one more node,
Ninitial, defined as follows: the set of rules is empty, C0(Ninitial) = {$S}, all the permit-
ting/forbidding condition sets are empty, α(Ninitial) = ∗ and β(Ninitial) = (1), and connects
all the nodes defined above to this node in a star graph.
2
By the above proof, rotation of symbols is accomplished with insertion and deletion nodes
using working modes l and r, only.
In [12] the authors show how to construct an HNEP which generates a given regular
(linear) language and whose underlying structure does not depend on the mode of generating
or accepting the given language, but only on the number of the letters in the alphabet. In
other words, any regular (linear) language over the same alphabet can be generated by an
HNEP of the same size and underlying structure. A natural question arises: Is it possible
to give a similar construction for any recursively enumerable language? We give a positive
answer to this question in the next theorem.
Theorem 2 1. Any recursively enumerable language over an alphabet V can be generated
by a complete HNEP of size 27 + 3 · card(V ).
2. Any recursively enumerable language over an alphabet V can be generated by a star
HNEP of size 28 + 3 · card(V ).
Proof. The basic idea of the proof is the same as that of Theorem 1. For the same grammar
G, in the Geffert normal form from the previous proof, we construct the following complete
HNEP:
Γ = (U,K27+3·card(T),N,C0,α,β,Nfinal)
with
U
=
N ∪ T ∪ {$} ∪ {ZX,X?,X??,X???| X ∈ (N ∪ T ∪ {$})} ∪ {[x],[˜ x] | x ∈ (N ∪ T)≤k} ∪
{WA,WB,WC},
9

Page 10

where k = max{|x| | S → x ∈ P} and (N ∪ T)≤kis the set of all words over N ∪ T of length
smaller than or equal to k. Let, as above, N?= N ∪ {$}. The part of Γ which simulates the
rotation of an arbitrary symbol in N?∪ T is modified as shown in Table 5. Here Y ranges in
the alphabet N?∪ T.
Node
M PIFI
N1
rot
{X → ZX|
X ∈ N?∪ T}
N2
rot
{ε → X?|
X ∈ N?∪ T}
N3
{ZY → ε}
N4
rot
{X?→ X |
X ∈ N?∪ T}
PO
∅
FO
∅
C0
{$S}
α
∗
β
{$}
U \ (N?∪ T)(1)
{$} ∪ {ZX|
X ∈ N?∪ T}
{Y?,$}
{$} ∪ {X?|
X ∈ N?∪ T}
{X?|
U
∅∅
l
(2)
X ∈ N?∪ T}
∅
{ZX|
X ∈ N?∪ T}
rot(Y )
{Y?}
U
{ZY}
{X?|
∅
∅
r
∗
(1)
(2)
X ∈ N?∪ T}
Table 5.
As one can easily see, we put together in the same node, the rules of the nodes N1
N2
change does not affect the rotation, since the words leaving the node N1
can enter only the node N2
ZX for some X ∈ N?∪ T. Notice that all nonempty words in N1
during the evolutionary step. In N2
word. Nodes N3
ZY in the right-hand end, in the sense that only these words are able to leave N3
the rightmost symbol ZY was removed. These words arrive in N4
restored.
rot(X),
rot(X), and N4
rot(X), for X ∈ N?∪ T, from the proof of Theorem 1, respectively. This
rotof this network
rot, and this is possible only if they have an occurrence of a symbol
rotwill get such a symbol
rota symbol Y?is appended to the left-hand end of each
rot(Y ) “select” those words in which Y?was appended in N2
rotand have had
rot(Y ) after
rot, where symbols Y?are
Node
N1
sim
MPI
∅
FI PO
∅
FO
∅
C0
{$S}
α
∗
β
{S → [x] |
S → x ∈ P}
{ε → X??}
{[αX] → [˜ α]}
{X??→ X???}
{[˜ α] → [α] |
α ?= ε}
{[˜ ε] → ε}
{X??→ X,
X???→ X}
U \ (N ∪ T) (1)
N2
N3
sim(X)
sim(X)
N4
sim
N5
sim
{[αX]}
{X??}
{[˜ α]}
{X???}
∅
∅
∅
U
∅
U
U
∅∅
∅
∅
∅
l
∗
∗
∗
(2)
(1)
(2)
(2)
{[α]}
{X??}
{[˜ α]}{X??}
N6
N7
sim
{[˜ ε]}∅∅
U
{[˜ ε]}∅
∅
r
∗
(1)
(2)
sim
{X??,X???}{[α],[˜ α]}{X??,X???}
Table 6.
Now we describe that part of Γ which simulates the application of any rule S → x ∈ P.
In Table 6, X is a generic letter in N ∪T, and α is a generic word in (N ∪T)≤k. We present
some brief explanations about the way of simulation. All occurrences of S in all copies of
word z in node N1
in P. Later we shall see that only those words in which the rightmost occurrence of S was
substituted will not disappear. From N1
for some α ∈ (N ∪T)≤k, enter N2
simare substituted by symbols [x] for all x, provided that S → x is a rule
simthe words having an occurrence of symbol [αX],
sim(X), where X??is appended to their left-hand end. Then,
10

Page 11

these words enter N3
X ∈ N ∪ T, enter node N4
which contain [˜ ε] will also be communicated to N6
the rightmost symbol of the word. The words which leave N4
replaced by [α] for all nonempty α ∈ (N ∪ T)≤k. Now the aforementioned process resumes
with the nodes N2
Let us follow the further itinerary of the words from N6
remain until all symbols X??and X???are restored. The obtained words represent the result of
our simulation. The simulation of the rule ABC → ε is accomplished by the nodes described
in Table 7.
sim(X), where [αX] is replaced by [˜ α]. Now all the words above, for all
sim, where each X??is replaced by X???. Copies of those of them
sim, where [˜ ε] is deleted, provided that it is
simwill enter N5
sim, where [˜ α] is
sim(X).
sim. They enter N7
sim, where they
Node
N1
del
MPI
∅
FI POFO
∅
C0
∅
α
∗
β
{A → WA,
{B → WB,
{C → WC,
{WB→ ε}
{WC→ ε}
{WA→ ε}
U \ (N?∪ T)
{WA,WB,WC}
(1)
N2
N3
N4
del
{WA,WB,WC}
{WA,WC}
{WA}
∅∅
∅
∅
{WB}
{WC}
{WA}
∅
∅
∅
r
l
r
(1)
(1)
(1)
del
{WB}
{WC}
del
Table 7.
Clearly, a word which goes out from the node N1
any symbol WA,WB,WC. Such a word arrives in N2
WBwhich is deleted. If, before entering N2
the word is lost as soon as it leaves N2
that the underlying graph has no loop. After a successful deletion in N2
N3
letter. When the new word goes out it must have no further occurrence of WC. Now, the
word enters N4
rightmost letter. No further occurrence of WAis allowed, otherwise the word is lost.
Finally, we keep unchanged the description of the nodes in Table 4. In order to obtain
a star HNEP generating the same language, we add the same node Ninitialdefined in the
previous proof.
delmust have at least one occurrence of
delwhere the rightmost letter must be
del, the word has more than one occurrence of WB,
delsince it cannot pass any input filter. Remember
del, the word enters
delwhere an occurrence of WC is removed provided that this occurrence is the leftmost
delwhere an occurrence of WAis deleted provided that this occurrence is the
2
The following result gives a general view, still incomplete, of the computational power of
HNEPs.
Theorem 3 1. Every language generated by an HNEP of size one is regular.
2. There exist context-free non-regular (even non-linear) languages which can be generated
by elementary, complete, and free HNEPs of size 2.
3. There exist context-sensitive non-context-free languages which can be generated by
complete HNEPs of size 4.
4. There exist non-recursive languages which can be generated by complete HNEPs of size
27.
5. There exist non-recursive languages which can be generated by complete HNEPs of size
28.
11

Page 12

Proof. 1. If the network has only one node, say x, which is a deletion or a substitution node,
then the generated language is finite. Let us consider that the node is an insertion node ;
we assume that it contains the rules ε → ai, 1 ≤ i ≤ n, for some n ≥ 1. If α(x) is l or r,
then the generated language is {a1,a2,...,an}∗C0(x) or C0(x){a1,a2,...,an}∗, respectively.
If α(x) = ∗, then the generated language is ? ⊥ ({a1,a2,...,an}∗,C0(x)), where the operation
? ⊥ is the shuffle operation defined on two words x,y ∈ V∗by
? ⊥ (x,y) = {x1y1x2y2...xnyn| n ≥ 1,xi,yi∈ V∗,x = x1x2...xn,y = y1,y2...yn}.
This operation may be naturally extended to languages by
? ⊥ (L1,L2) =
?
x∈L1,y∈L2
? ⊥ (x,y).
2. We consider the free HNEP defined in the following table
Node
x1
x2
M PI
∅
∅
FI
∅
∅
PO
∅
∅
FO
∅
∅
C0
{ε}
∅
α
∗
∗
β
{ε → a}
{ε → b}
(1)
(1)
Table 8.
If we take x1as the output node, then the language generated by this network is {w ∈
{a,b}∗: (|w|a= |w|b) ∨ (|w|a= |w|b+ 1)} which is context-free but not linear. Note that
this HNEP is both elementary and homogeneous.
3. We define the following HNEP:
Node
x1
x2
x3
x4
M PI
∅
{a?}
{b?}
FIPO
∅
∅
∅
∅
FO
∅
∅
∅
C0
{ε}
∅
∅
∅
α
∗
∗
∗
∗
β
{ε → a?}
{ε → b?}
{ε → c?}
{b?,c?}
{c?}
∅
∅
(1)
(1)
(1)
(1)
{a?→ a,b?→ b,c?→ c}{a?,b?,c?}{a?,b?,c?}
Table 9.
We give some explanations about the working mode of this network. In node x1the word
a?is obtained; this word is forwarded to x2which is the only node which is able to receive it.
Here, two words, a?b?and b?a?, are produced. Both can leave this node but cannot pass any
other input filter than that of x3where c?is inserted to any position in both words. All these
new words leave x3and enter x4. Here, a?, b?, and c?are replaced by a, b, c, respectively. All
these three letters must be replaced in each word, the output filter of x4prevents the words
to leave the node before all the three letters have been replaced. Now, the process resumes
from x1. Then, the intersection of the language generated by this network in the output
node x1with the regular language {a,b,c}∗is {w ∈ {a,b,c}∗: |w|a= |w|b= |w|c} which
is not context-free. Unlike in the previous example, this HNEP is homogeneous. It is worth
mentioning that the aforementioned explanations can be carried to a ring HNEP of size four.
12

Page 13

4. It is known that there exist non-recursive languages over one-letter alphabet. We
consider a phrase-structure grammar in the Geffert normal form generating such a language
L and construct the complete HNEP from the proof of Theorem 2 but removing the symbol
$ together with the corresponding node in the part dedicated to symbol rotation as well as
the node having the role of deleting of $. We also discard the node Nfinaland take N1
the output node. Let us denote this HNEP of size 27 by Γ. Then, the intersection of the
language generated by Γ with language {a}∗is exactly L. Therefore, L(Γ) is non-recursive.
5. A similar construction works for star HNEPs.
simas
2
We finish this section with two open problems:
1. Is it possible to generate an arbitrary recursively enumerable language over an alphabet
V with a complete/star HNEP of a smaller size than 27 + 3 · card(V )?
2. What is the size of the smallest complete/star/ring HNEP which generates a non-
context-sensitive or non-recursive language?
standard proof, which is now omitted, shows that one needs deletion nodes in order to
generate non-context-sensitive languages.
As it was expected, the next result with a
Theorem 4 If Γ is an HNEP having no deletion node, then L(Γ) ∈ NSPACE(n).
References
[1] J. Castellanos, C. Martin-Vide, V. Mitrana, J. Sempere, Solving NP-complete problems
with networks of evolutionary processors, IWANN 2001 (J. Mira, A. Prieto, eds.), LNCS
2084, Springer-Verlag, 2001, 621–628.
[2] J. Castellanos, C. Martin-Vide, V. Mitrana, J. Sempere, Networks of evolutionary pro-
cessors, Acta Informatica, 39 (2003), 517-529..
[3] E. Csuhaj-Varj´ u, A. Salomaa, Networks of parallel language processors. In New Trends
in Formal Languages (Gh. P˘ aun, A. Salomaa, eds.), LNCS 1218, Springer Verlag, 1997,
299–318.
[4] E. Csuhaj-Varj´ u, V. Mitrana, Evolutionary systems: a language generating device in-
spired by evolving communities of cells, Acta Informatica 36(2000), 913–926.
[5] L. Errico, C. Jesshope, Towards a new architecture for symbolic processing. In Artificial
Intelligence and Information-Control Systems of Robots ’94 (I. Plander, ed.), World Sci.
Publ., Singapore, 1994, 31–40.
[6] S. E. Fahlman, G. E. Hinton, T. J. Seijnowski, Massively parallel architectures for
AI: NETL, THISTLE and Boltzmann machines. In Proc. AAAI National Conf. on AI,
William Kaufman, Los Altos, 1983, 109–113.
[7] V. Geffert, Normal forms for phrase-structure grammars. RAIRO/Theoretical Informat-
ics and Applications, 25, 5(1991), 473–496.
[8] L. Kari, Gh. P˘ aun, G. Thierrin, S. Yu, At the crossroads of DNA computing and for-
mal languages: Characterizing RE using insertion-deletion systems. Proc. 3rd DIMACS
Workshop on DNA Based Computing, Philadelphia, 1997, 318–333.
13

Page 14

[9] L. Kari, G. Thierrin, Contextual insertion/deletion and computability. Information and
Computation 131, 1(1996), 47–61.
[10] W. D. Hillis, The Connection Machine, MIT Press, Cambridge, 1985.
[11] C. Martin-Vide, Gh. P˘ aun, A. Salomaa, Characterizations of recursively enumerable
languages by means of insertion grammars. Theoretical Computer Science 205, 1-2(1998),
195–205.
[12] C. Martin-Vide, V. Mitrana, M. Perez-Jimenez, F. Sancho-Caparrini, Hybrid networks
of evolutionary processors, In: Proc. of GECCO 2003, LNCS 2723, 2003, 401–412.
[13] D. Sankoff et al. Gene order comparisons for phylogenetic inference: Evolution of the
mitochondrial genome. Proc. Natl. Acad. Sci. USA, 89(1992) 6575–6579.
14