Complexity-preserving simulations among three variants of accepting networks of evolutionary...

Complexity-Preserving Simulations Among Three

Variants of Accepting Networks of Evolutionary

Processors ∗

Paolo Bottoni and Anna LabellaDepartment of Computer Science, “Sapienza” University of RomeVia Salaria 113, 00198 Rome, ItalyE-mail: {bottoni,labella}@di.uniroma1.itFlorin Manea‡Faculty of Computer Science, Otto-von-Guericke UniversityP.O. Box 41 20, D-39016 Magdeburg, GermanyE-mail: [email protected]

Victor MitranaFaculty of Mathematics, University of BucharestStr. Academiei 14, 010014 Bucharest, RomaniaE-mail: [email protected]

Ion PetreDepartment of Information Technologies, Abo Akademi UniversityICT-building, Joukahaisenkatu 3-5 A, FIN-20520 Turku, FinlandE-mail: [email protected]

Jose M. SempereDepartment of Information Systems and Computation, Technical University ofValencia,Camino de Vera s/n. 46022 Valencia, SpainE-mail: [email protected]

Abstract. In this paper we consider three variants of accepting networks of evolu-tionary processors. It is known that two of them are equivalent to Turing machines.We propose here a direct simulation of one device by the other. Each computationalstep in one model is simulated in a constant number of computational steps inthe other one while a translation via Turing machines squares the time complexity.We also discuss the possibility of constructing simulations that preserve not onlycomplexity, but also the shape of the simulated network.

Keywords: evolutionary processor, uniform evolutionary processor, network ofevolutionary processors, filtered connection

‡ On leave of absence from the University of Bucharest∗ Work supported by the Academy of Finland, projects 132727, 122426, and

108421. F. Manea acknowledges the support from the Alexander von HumboldtFoundation. J Sempere acknowledges the support from the Spanish Ministerio deEducacion y Ciencia project TIN2007-60769.

c© 2009 Kluwer Academic Publishers. Printed in the Netherlands.

NaCo.tex; 27/10/2009; 22:06; p.1

2 P. Bottoni, A. Labella, F. Manea, V. Mitrana, I. Petre, J. Sempere

1. Introduction

A basic architecture for parallel and distributed computing consists ofseveral processors, each of them being placed in a node of a virtualcomplete graph, which are able to handle data associated with therespective node. Each node processor acts on the local data in accor-dance with some predefined rules. Local data are then sent throughthe network according to well-defined protocols. Only that data whichare able to pass a filtering process can be communicated. This filteringprocess may require to satisfy some conditions imposed by the sendingprocessor, by the receiving processor or by both of them. All the nodessend simultaneously their data and the receiving nodes handle alsosimultaneously all the arriving messages, according to some strategies.This general architecture may be met in several areas of ComputerScience like Artificial Intelligence (Hillis, 1985; Fahlman et al., 1983),Symbolic Computation (Errico and Jesshope, 1994), Grammar Systems(Paun and Santean, 1989), Bio-inspired Computing (Paun, 2000).

The origin of accepting networks of evolutionary processors (ANEPfor short) is such an architecture in connection with the work (Csuhaj-Varju and Salomaa, 1997), where a distributed computing device callednetwork of language processors is proposed. A network of languageprocessors consists of several language generating devices associatedwith nodes of a virtual graph that rewrite words (representing thecurrent state of the nodes) according to some prescribed rewritingmode and communicate the obtained words along the network usinginput and output filters defined by the membership condition to regularlanguages.

In (Castellanos et al., 2001) the concept (considered from a formallanguage theory point of view in (Csuhaj-Varju and Salomaa, 1997))was modified in the following way inspired from cell biology (see also(Csuhaj-Varju and Mitrana, 2000) that considers a computing modelinspired by the evolution of cell populations, which might model someproperties of evolving cell communities at the syntactical level). Eachprocessor placed in a node is called evolutionary processor, i.e. anabstract processor which is able to perform very simple operations,namely point mutations in a DNA sequence (insertion, deletion orsubstitution of a pair of nucleotides). More generally, each node may beviewed as a cell having genetic information encoded in DNA sequenceswhich may evolve by local evolutionary events, that is point mutations.Each node is specialized just for one of these evolutionary operations.Furthermore, the data in each node is organized in the form of mul-tisets of words (each word may appear in an arbitrarily large numberof copies), and all copies are processed in parallel such that all the

NaCo.tex; 27/10/2009; 22:06; p.2

Complexity-Preserving Simulations Between Three Variants of ANEPs 3

possible events that can take place do actually take place. Further,all the nodes send simultaneously their data and the receiving nodeshandle also simultaneously all the arriving messages, according to somestrategies modeled as permitting and forbidding filters and filtering cri-teria, see (Margenstern et al., 2005). A series of papers was devoted todifferent variants of this model viewed as language generating devices;a few rather recent works investigating this model are (Alhazov et al.,2009a; Alhazov et al., 2009b; Dassow and Truthe, 2007). The work(Martın-Vide and Mitrana, 2005) is an early survey in this area.

The reader interested in a more detailed discussion about the accept-ing model is referred to (Margenstern et al., 2005; Manea et al., 2007).In (Margenstern et al., 2005) it is shown that this model is computation-ally complete and presents a characterization of the complexity classNP based on accepting networks of evolutionary processors (ANEP forshort).

It is clear that filters associated with each node of an ANEP allowa strong control of the computation. Indeed, every node has an inputand output filter; two nodes can exchange data if it passes the outputfilter of the sender and the input filter of the receiver. Moreover, if somedata is sent out by some node and not able to enter any node, then itis lost. The ANEP model considered in (Margenstern et al., 2005) issimplified in (Dragoi et al., 2007) by moving the filters from the nodesto the edges. Each edge is viewed as a two-way channel such that theinput and output filters, respectively, of the two nodes connected by theedge coincide. Clearly, the possibility of controlling the computationin such networks seems to be diminished. For instance, there is nopossibility to discard data during the communication steps. In spiteof this fact, in the aforementioned work one proves that these new de-vices, called accepting networks of evolutionary processors with filteredconnections (ANEPFC) are still computationally complete. This meansthat moving the filters from the nodes to the edges does not decreasethe computational power of the model. Although the two variantsare equivalent from the computational power point of view, no directproof for this equivalence has been proposed until the work (Bottoniet al., 2009), where direct simulations between the two variants arepresented. Moreover, both simulations are time efficient, namely eachcomputational step in one model is simulated in a constant numberof computational steps in the other. This is particularly useful whenone wants to translate a solution from one model into the other. Atranslation via a Turing machine squares the time complexity of thenew solution. The aim of this paper is to consider another variant whichsimplifies the general ANEP model such that filters remain associatedwith nodes but the input and output filters of every node coincide. This

NaCo.tex; 27/10/2009; 22:06; p.3


variant called accepting networks of uniform evolutionary processors(UANEP) is situated somehow in between the aforementioned ones.This paper is along the same lines of (Bottoni et al., 2009) and extendsthe results from (Bottoni et al., 2009) with a new simulation betweenANEP and UANEP that is still complexity-preserving. Moreover andrather unexpected, this simulation preserves also the completeness ofthe simulated network, property that does not always hold for the othertwo simulations.

2. Basic Definitions

We start by summarizing the notions used throughout the paper. Analphabet is a finite and nonempty set of symbols. The cardinality of afinite set A is written card(A). Any finite sequence of symbols froman alphabet V is called word over V . The set of all words over V isdenoted by V ∗ and the empty word is denoted by ε. The length of aword x is denoted by |x| while alph(x) denotes the minimal alphabetW such that x ∈ W ∗.

We say that a rule a → b, with a, b ∈ V ∪ {ε} and ab 6= ε is asubstitution rule if both a and b are not ε; it is a deletion rule if a 6= εand b = ε; it is an insertion rule if a = ε and b 6= ε. The set ofall substitution, deletion, and insertion rules over an alphabet V aredenoted by SubV , DelV , and InsV , respectively.Given a rule σ as above and a word w ∈ V ∗, we define the followingactions of σ on w:– If σ ≡ a → b ∈ SubV , then

σ∗(w) ={ {ubv : ∃u, v ∈ V ∗ (w = uav)},{w}, otherwise

Note that a rule as above is applied to all occurrences of the lettera in different copies of the word w. An implicit assumption is thatarbitrarily many copies of w are available.

– If σ ≡ a → ε ∈ DelV , then σ∗(w) ={ {uv : ∃u, v ∈ V ∗ (w = uav)},{w}, otherwise

σr(w) ={ {u : w = ua},{w}, otherwise σl(w) =

{ {v : w = av},{w}, otherwise

– If σ ≡ ε → a ∈ InsV , then σ∗(w) = {uav : ∃u, v ∈ V ∗ (w = uv)},σr(w) = {wa}, σl(w) = {aw}.

α ∈ {∗, l, r} expresses the way of applying a deletion or insertion ruleto a word, namely at any position (α = ∗), in the left (α = l), or

NaCo.tex; 27/10/2009; 22:06; p.4


in the right (α = r) end of the word, respectively. For every rule σ,action α ∈ {∗, l, r}, and L ⊆ V ∗, we define the α-action of σ on L

by σα(L) =⋃

w∈L

σα(w). Given a finite set of rules M , we define the

α-action of M on the word w and the language L by:

Mα(w) =⋃

σ∈M

σα(w) and Mα(L) =⋃

w∈L

Mα(w),

respectively. In what follows, we shall refer to the rewriting operationsdefined above as evolutionary operations since they may be viewed aslinguistic formulations of local DNA mutations.

For two disjoint subsets P and F of an alphabet V and a word wover V , we define the predicates:

ϕ(s)(w;P, F ) ≡ P ⊆ alph(w) ∧ F ∩ alph(w) = ∅ϕ(w)(w; P, F ) ≡ alph(w) ∩ P 6= ∅ ∧ F ∩ alph(w) = ∅.

The construction of these predicates is based on random-context con-ditions defined by the two sets P (permitting contexts/symbols) and F(forbidding contexts/symbols). Informally, the first condition requiresthat all permitting symbols are present in w and no forbidding symbolis present in w, while the second one is a weaker variant of the first,requiring that at least one permitting symbol appears in w and noforbidding symbol is present in w. For every language L ⊆ V ∗ andβ ∈ {(s), (w)}, we define:

ϕβ(L,P, F ) = {w ∈ L | ϕβ(w;P, F )}.An evolutionary processor over V is a tuple (M, PI, FI, PO, FO), where:

− M is a set of substitution, deletion or insertion rules over the al-phabet V . Formally: (M ⊆ SubV ) or (M ⊆ DelV ) or (M ⊆ InsV ).The set M represents the set of evolutionary rules of the processor.As one can see, a processor is “specialized” in one evolutionaryoperation, only.

− PI, FI ⊆ V are the input permitting/forbidding contexts of theprocessor, while PO, FO ⊆ V are the output permitting/forbiddingcontexts of the processor. Informally, the permitting input/outputcontexts are the set of symbols that should be present in a word,when it enters/leaves the processor, while the forbidding contextsare the set of symbols that should not be present in a word inorder to enter/leave the processor.

An evolutionary processor as above with PI = PO = P and FI =FO = F is called a uniform evolutionary processor and is defined

NaCo.tex; 27/10/2009; 22:06; p.5


as the triple (M, P, F ). We denote the set of (uniform) evolutionaryprocessors over V by (U)EPV . Obviously, the (uniform) evolutionaryprocessor described here is a mathematical concept similar to that ofan evolutionary algorithm, both being inspired by the Darwinian evolu-tion. The rewriting operations we have considered might be interpretedas mutations and the filtering process described above might be viewedas a selection process. Recombination is missing but it was assertedthat evolutionary and functional relationships between genes can becaptured by taking only local mutations into consideration (Sankoffet al., 1992). Furthermore, we are not concerned here with a possiblebiological implementation of these processors, though a matter of greatimportance.

An accepting network of evolutionary processors (ANEP for short)is a 7-tuple Γ = (V, U,G,N , α, β, xI , xO), where:

• V and U are the input and network alphabets, respectively, V ⊆ U .

• G = (XG, EG) is an undirected graph without loops, with the setof nodes XG and the set of edges EG. Each edge is given in the formof a binary set. G is called the underlying graph of the network.

• N : XG −→ EPU is a mapping which associates with each nodex ∈ XG the evolutionary processor N (x) = (Mx, PIx, FIx, POx,FOx).

• α : XG −→ {∗, l, r}; α(x) gives the action mode of the rules ofnode x on the words existing in that node.

• β : XG −→ {(s), (w)} defines the type of the input/output filtersof a node. More precisely, for every node, x ∈ XG, the followingfilters are defined:

input filter: ρx(·) = ϕβ(x)(·;PIx, F Ix),output filter: τx(·) = ϕβ(x)(·;POx, FOx).

That is, ρx(w) (resp. τx) indicates whether or not the word w canpass 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.

• xI and xO ∈ XG are the input node, and the output node, respec-tively, of the ANEP.

An accepting network of uniform evolutionary processors (UANEPfor short) is an ANEP with uniform evolutionary processors only.

An accepting network of evolutionary processors with filtered connec-tions (ANEPFC for short) is a 8-tuple Γ = (V, U,G,R,N , α, β, xI , xO),where:

NaCo.tex; 27/10/2009; 22:06; p.6


♦ V, U,G, α, xI , and xO have the same meaning as for ANEPs.

♦ R : XG −→ 2SubU ∪ 2DelU ∪ 2InsU is a mapping which associateswith each node the set of evolutionary rules that can be applied inthat node. As above, each node is associated only with one typeof evolutionary rules.

♦ N : EG −→ 2U × 2U is a mapping which associates with each edgee ∈ EG the disjoint sets N (e) = (Pe, Fe), Pe, Fe ⊂ U .

♦ β : EG −→ {(s), (w)} defines the filter type of an edge.

ÁÀ

Â¿

ÁÀ

Â¿x y

?

6

POx FOx PIy FIy

PIx FIx POy FOy

Processors connected in an ANEP

ÁÀ

Â¿

ÁÀ

Â¿x y-¾

Px Py

Fx Fy

Processors connected in an UANEP.The two filters of each node in an ANEP collapsed into only one.

ÁÀ

Â¿

ÁÀ

Â¿x y-¾

P{x,y}

F{x,y}

Processors connected in an ANEPFCThe filters in the ends of each edge of an UANEP collapsed into only one.

Figure 1.

Figure 1 makes clearer the differences between the three variants aswell as the gradual way of passing from the (intuitively) more complexvariant to the simplest one. In this figure, there are represented twoconnected nodes (by circles) in every variant and the filters associatedwith them or with their connection.

For all three variants we say that card(XG) is the size of Γ. Whenwe want to refer to any of the three variants we use the notation[U]ANEP[FC].

NaCo.tex; 27/10/2009; 22:06; p.7


A configuration of an [U]ANEP[FC] Γ as above is a mapping C :XG −→ 2V ∗ which associates a set of words with every node of thegraph. A configuration may be understood as the sets of words whichare present in any node at a given moment. A configuration can changeeither by an evolutionary step or by a communication step.

An evolutionary step is common to all models. When changing byan evolutionary step each component C(x) of the configuration C ischanged in accordance with the set of evolutionary rules Mx associatedwith the node x and the way of applying these rules α(x). Formally,we say that the configuration C ′ is obtained in one evolutionary stepfrom the configuration C, written as C =⇒ C ′, if and only if

C ′(x) = Mα(x)x (C(x)) for all x ∈ XG.

A communication step is common to ANEP and UANEP. Whenchanging by a communication step, each node processor x ∈ XG ofan [U]ANEP sends one copy of each word it has (without keeping anycopy of it), which is able to pass the output filter of x, to all thenode processors connected to x and receives all the words sent by anynode processor connected with x provided that they can pass its inputfilter. Formally, we say that the configuration C ′ is obtained in onecommunication step from configuration C, written as C ` C ′, if andonly if

C ′(x) = (C(x)− τx(C(x))) ∪⋃

{x,y}∈EG

(τy(C(y)) ∩ ρx(C(y)))

for all x ∈ XG. Note that words which leave a node are eliminated fromthat node. If they cannot pass the input filter of any node, they arelost.

When changing by a communication step, each node processor x ∈XG of an ANEPFC sends one copy of each word it has to every nodeprocessor y connected to x, provided they can pass the filter of the edgebetween x and y. It keeps no copy of these words but receives all thewords sent by any node processor z connected with x providing thatthey can pass the filter of the edge between x and z.

Formally, we say that the configuration C ′ is obtained in one com-munication step from configuration C, written as C ` C ′, iff

C ′(x) = (C(x) \ (⋃

{x,y}∈EG

ϕβ({x,y})(C(x),N ({x, y}))))

∪(⋃

{x,y}∈EG

ϕβ({x,y})(C(y),N ({x, y})))

for all x ∈ XG. Note that a copy of a word remains in the sending nodex only if it not able to pass the filter of any edge connected to x.

NaCo.tex; 27/10/2009; 22:06; p.8


Let Γ be an [U]ANEP[FC], the computation of Γ on the input wordz ∈ V ∗ is a sequence of configurations C

(z)0 , C

(z)1 , C

(z)2 , . . ., where C

(z)0 is

the initial configuration of Γ defined by C(z)0 (xI) = {z} and C

(z)0 (x) = ∅

for all x ∈ XG, x 6= xI , C(z)2i =⇒ C

(z)2i+1 and C

(z)2i+1 ` C

(z)2i+2, for all

i ≥ 0. By the previous definitions, each configuration C(z)i is uniquely

determined by the configuration C(z)i−1. A computation as above is said

to be an accepting computation if there exists a configuration in whichthe set of words existing in the output node xO is non-empty. Thelanguage accepted by Γ is

L(Γ) = {z ∈ V ∗ | the computation of Γ on z is an accepting one}.We define a time complexity measure on [U]ANEP[FC]s. To this aim

we consider an [U]ANEP[FC] Γ with the input alphabet V . The timecomplexity of the halting computation C

(z)0 , C

(z)1 , C

(z)2 , . . . C

(z)m of Γ on

z ∈ V ∗ is denoted by TimeΓ(z) and equals m. The time complexityof Γ is the function from IN to IN , TimeΓ(n) = max{TimeΓ(z) | z ∈L(Γ), |z| = n}. In other words, TimeΓ(n) delivers the maximal numberof computational steps done by Γ for accepting an input word of lengthn.

For a function f : IN −→ IN we define:

Time[U ]ANEP [FC](f(n)) = {L | there exists an [U]ANEP[FC] Γ whichaccepts L, and n0 such that ∀n ≥ n0(TimeΓ(n) ≤ f(n))}.

In the following sections we show that

TimeANEP (f(n)) = TimeUANEP (f(n)) = TimeANEPFC(f(n))

for any function f : IN −→ IN . The proofs are based on direct simula-tions of each variant by the others and these simulations preserve thecomputational complexity.

3. Direct Simulations between ANEPs and UANEPs

As each UANEP can be immediately transform into an ANEP, we have

PROPOSITION 1. TimeUANEP (f(n)) ⊆ TimeANEP (f(n)) for anyfunction f : IN −→ IN .

The converse is also true, namely:

PROPOSITION 2. TimeANEP (f(n)) ⊆ TimeUANEP (f(n)) for anyfunction f : IN −→ IN .

NaCo.tex; 27/10/2009; 22:06; p.9


Proof. Let Γ = (V,U,G,N , α, β, x1, xn) be an ANEP with the under-lying graph G = (XG, EG) and XG = {x1, x2, . . . , xn} for some n ≥ 1.Let further dom(Mxi) = {X ∈ U | X → Y ∈ Mxi}. We construct theUANEP Γ′ = (V, U ′, G′,N ′, α′, β′, x0

1, x0n), where

U ′ = U ∪ UN ∪ UH ∪ T , UN = {XN | X ∈ U},UH = {XH | X ∈ U}, T = {£} ∪ {$i, #i, ¢i, Ui | 1 ≤ i ≤ n},

and the nodes and edges of G′ are defined as follows:

Node M P F α′ β′

x01 {ε → £} {£} (UH ∪ UN ∪ T ) \ {£} ∗ (s)

xstart1 {£ → #1} ∅ (UH ∪ UN ∪ T ) \ {£, #1} ∗ (s)

Table 1.and {x0

1, xstart1 } ∈ EG′ .


xcheck−ini {$i → #i} PIxi (FIxi ∪ UH ∪ T )\ ∗ β(xi)

{$i, #i}

x1i {Y → XH | {#i} {¢i} α(xi) (s)

Y → X ∈ Mxi}

x2i {#i → ¢i} UH T \ {¢i, #i} ∗ (w)

x2i (Y ), {#i → ¢i} {#i} ({Y } ∪ T ∪ UH)\ ∗ (w)

Y ∈ dom(Mxi) {¢i, #i}

x3i {XH → X | {¢i} ∅ ∗ (s)

X ∈ U}

xcheck−outi {¢i → Ui} POxi FOxi ∪ UH∪ ∗ β(xi)

(T \ {¢i, Ui})

xcontinuei {Ui → $j | ∅ T \ ({Ui} ∪ {$j | ∗ (s)

{xi, xj} ∈ EG} {xi, xj} ∈ EG})

xreturn1i {¢i → #i} FOxi UH ∪ {$j , Uj | ∗ (w)

1 ≤ j ≤ n}

xreturn2i {¢i → #i} ∅ POxi ∪ {$j , Uj | ∗ (s)

1 ≤ j ≤ n} ∪ UH

Table 2.

NaCo.tex; 27/10/2009; 22:06; p.10


Case 1. Let xi, 1 ≤ i ≤ n − 1, be a substitution node. If β(xi) = (w),then the nodes defined in Table 2 belong to XG′ .

All the edges– {xstart

1 , x11},

– {xcheck−ini , x1

i }, 1 ≤ i ≤ n− 1,– {x1

i , x2i }, {x1

i , x2i (Y )}, Y ∈ dom(Mxi), 1 ≤ i ≤ n− 1,

– {x1i , x

return1i }, {x1

i , xreturn2i }, 1 ≤ i ≤ n− 1,

– {x2i , x

3i }, 1 ≤ i ≤ n− 1,

– {x3i , x

check−outi }, {x3

i , xreturn1i }, {x3

i , xreturn2i }, 1 ≤ i ≤ n− 1,

– {xcheck−outi , xcontinue

i }, {xcheck−outi , x2

i (Y )}, Y ∈ dom(Mxi),1 ≤ i ≤ n− 1,

– {xcontinuei , xcheck−in

j }, {xi, xj} ∈ EG, 1 ≤ i 6= j ≤ n− 1,– {x2

i (Y ), xreturn1i }, {x2

i (Y ), xreturn2i }, Y ∈ dom(Mxi),

1 ≤ i ≤ n− 1belong to EG′ . For a better visualization we refer to Figure 2.

¶µ

³´

ÁÀ

Â¿

ÁÀ

Â¿

ÁÀ

Â¿

º

¹

·

¸

¶

µ

³

´

º

¹

·

¸

¶

µ

³

´

¶

µ

³

´

xcheck−ini

x1i

x2i

x3i

xcheck−outi

xcontinuei

x2i (Y )

xreturn2i

xreturn1i

Figure 2.

NaCo.tex; 27/10/2009; 22:06; p.11


If β(xi) = (s), then xreturn2i is replaced by p ≥ 1 nodes of the

form xreturnk

2i , 1 ≤ k ≤ p, where POxi = {Z1, Z2, . . . , Zp}, p ≥ 1.

They are presented in Table 3. Furthermore, if POxi = ∅, then xreturn2i

is removed. Now an edge between x1i , x3

i and each node x2i (Y ), Y ∈

dom(Mxi), on the one hand, and each node xreturnk

2i , on the other hand,

is added to EG′ .

Case 2. If xi, 1 ≤ i ≤ n − 1, is an insertion node, then all the nodes,except for x2

i (Y ), Y ∈ dom(Mxi), defined in Tables 2 and 3 belongto XG′ . Also all the edges, except for those incident to x2

i (Y ), Y ∈dom(Mxi), belong to EG′ .


xreturnk

2i {¢i → #i} POxi \ {Zk} {Zk} ∪ UH∪ ∗ (w)

{$j , Uj | 1 ≤ j ≤ n}

Table 3.

Case 3. Let xi, 1 ≤ i ≤ n− 1, be a deletion node. If β(xi) = (w), thenthe following modifications regarding the nodes defined in Table 2 haveto be done:

– UH is replaced by UN in the filters of the nodes xcheck−ini , x2

i ,xreturn1

i , xreturn2i and xcheck−out

i .– Nodes x1

i and x3i are replaced by the nodes in Table 4.


x1i {Y → Y N | Y → ε ∈ Mxi} {#i} {¢i} ∗ (s)

x3i {Y N → ε | Y ∈ U} {¢i} ∅ α(xi) (s)

Table 4.

If β(xi) = (s), then UH is replaced by UN in all filters of the nodes

xreturnk

2i from Table 3. Furthermore, if POxi = ∅, then xreturn2

i isremoved. All the corresponding edges in EG′ are modified accordingly.

The output node x0n is defined as follows: Mx0

n= Mxn , Px0

n= PIxn

and Fx0n

= FIxn , with α′(x0n) = α(xn), β′(x0

n) = β(xn). Finally, we addall the edges {xcontinue

i , x0n}, 1 ≤ i ≤ n− 1, to EG′ .

NaCo.tex; 27/10/2009; 22:06; p.12


We now analyze a computation of Γ′ on an input word, say z. Inthe input node x0

1, the symbol £ is inserted at all positions of z indifferent copies of z. All these words enter xstart

1 where the symbol £is replaced by #1. We start now a simulation of the first evolutionarystep executed by Γ on the input word z. More generally, we may assumethat the current word is z = z1#iz2, for some 1 ≤ i ≤ n− 1, placed inx1

i , and z1z2 ∈ U∗ is placed in xi.We fix up that xi is a substitution node in Γ and β(xi) = (w).

The analysis for the case when xi is a substitution node in Γ andβ(xi) = (s) is identical. In x1

i , an occurrence of some symbol Y inz1#iz2 is replaced by XH iff the same occurrence of Y in z1z2 can bereplaced by X in the node xi ∈ XG. Let y1#iy2 be one word obtainedafter a substitution rule has been applied to z1#iz2 in x1

i . Note that ifthere exists Y ∈ dom(Mxi) such that Y /∈ alph(z1z2), then z1#iz2 maygo out from x1

i and enter the following nodes:• xcheck−in

i , provided that z1z2 can pass the input filter of xi fromΓ,• xreturn1

i and xreturn2i , provided that z1z2 cannot pass the output

filter of xi from Γ,• x2

i (Y ).It is worth mentioning that in this case also z1z2 can stay unchangedone evolutionary step in xi ∈ G. We analyze all cases. If z1#iz2 goesout from x1

i and enters xcheck−ini , then the ”ping-pong” process be-

tween x1i and xcheck−in

i may continue either forever or until the wordcontains a symbol from UH. If z1#iz2 goes out from x1

i and entersxreturn1

i or xreturn2i , then a similar ”ping-pong” process takes place

between xreturn1i or xreturn2

i on the one hand, and x1i and x2

i (Y ), onthe other hand. If z1#iz2 goes out from x1

i and enters x2i (Y ), then #i

is replaced by ¢i; the new word z1¢iz2 is simultaneously sent to allnodes xcheck−out

i , xreturn1i and xreturn2

i . If it enters xcheck−outi , then ¢i

is replaced successively by Ui (in xcheck−outi ) and some $j (in xcontinue

i

such that {xi, xj} ∈ EG. The obtained word z1$jz2 is sent to xcheck−inj .

This situation resembles exactly the situation when z1z2 is sent to xj

after staying unchanged for one evolutionary step in xi. The case whenz1¢iz2 enters any of the nodes xreturn1

i and xreturn2i is considered above.

The only case remaining to be analyzed is when z1#iz2 is trans-formed into y1#iy2 (either y1 = z1 or y2 = z2) after applying asubstitution rule in x1

i . Then y1#iy2 is sent out. Its itinerary throughthe network is as follows: x2

i , where #i is replaced by ¢i, then x3i , where

XH is replaced by X. After leaving x3i , the new word, say z′, can enter

either xcheck−ini or at least one of xreturn1

i and xreturn2i . If it enters

xcheck−ini and consequently xcontinue

i , then the following computational

NaCo.tex; 27/10/2009; 22:06; p.13


step in Γ was simulated in Γ′: z1z2 was transformed into z′, by applyinga substitution rule Y → X in xi ∈ XG and z′ was sent to all the nodesconnected to xi. The situation when z′ enters one of the nodes xreturn1

iand xreturn2

i corresponds to the situation when z′ cannot pass the out-put filter of xi and a new evolutionary step in xi is to be considered.Note that every such evolutionary step in Γ can be simulated by Γ′ in6 evolutionary steps and 5 communication steps.

The last case treated above works entirely well for an insertion nodexi in Γ no matter its filters type, while the whole discussion above isstill valid for a deletion node xi.

By all the above considerations, we conclude that L(Γ) = L(Γ′) andTimeΓ′(n) ∈ O(TimeΓ(n)). 2

4. Direct Simulations between ANEPs and ANEPFCs

PROPOSITION 3. TimeANEP (f(n)) ⊆ TimeANEPFC(f(n)) for anyfunction f : IN −→ IN .

Proof. Let Γ = (V,U,G,N , α, β, x1, xn) be an ANEP with the under-lying graph G = (XG, EG) and XG = {x1, x2, . . . , xn} for some n ≥ 1.We construct the ANEPFC Γ′ = (V, U ′, G′,R,N ′, α′, β′, xs

1, xsn), where

U ′ = U ∪ {Xi, Xd | X ∈ U, i ∈ {1, . . . , n}} ∪

{$i | i ∈ {1, . . . , n}} ∪ {#, $}.The nodes of the graph G′ = (X ′

G, E′G), the sets of rules associated

with them and the way in which they are applied, as well as the edgesof E′

G together with the filters associated with them are defined in thefollowing.

First, for every pair of nodes xi, xj from XG such that {xi, xj} ∈ EG

we have the following nodes in Γ′

x1i,j : R(x1

i,j) = {ε → $}, α′(x1i,j) = l,

x2i,j : R(x2

i,j) = {$ → ε}, α′(x2i,j) = l,

and the following edges

{xfi , x1

i,j}: P = PO(xi), F = FO(xi) ∪ {$}, β′ = β(xi),{x1

i,j , x2i,j}: P = PI(xj), F = FI(xj), β′ = (w),

{x2i,j , x

sj}: P = PI(xj), F = FI(xi) ∪ {$, $j}, β′ = β(xj).

For each node xi in Γ we add a subnetwork to Γ′ according to the casesconsidered in the sequel.

NaCo.tex; 27/10/2009; 22:06; p.14


Case 1. For an insertion or a substitution node xi ∈ XG with weakfilters we have the following subnetwork in Γ′.

{ε → $i}α′(xs

i ) = r

{$i → #}α′(x2

i ) = ∗

{Y → Xi |

α′(x1i ) = α(xi)

Y → X ∈ Mxi ,

Y ∈ U ∪ {ε}}

{# → ε}α′(x3

i ) = ∗{Xi → X |X ∈ U}

α′(xfi ) = ∗

P = {$i}F = {Xi |X ∈ U}β = (w)

P = U ′F = {#}

β = (w)

P = {#} F = {$i}β = (w)

P = U ′F = {#}

β = (w)

P = U ′, F

β′ = (w)

xsi

x1i

x2i

x3ixf

i

Figure 2.

The set of forbidden symbols F on the edge {xfi , xs

i} is defined by:

F ={

FO(xi) ∪ PO(xi) ∪ {$i}, if xi is an insertion nodePO(xi) ∪ {$i}, if xi is a substitution node

Case 2. If xi is an insertion or a substitution node with strong filterswe just add the following nodes to the construction above:

xs,Zi : R(xs,Z

i ) = {ε → $i}, α′(xs,Zi ) = ∗,

and the edges

{xs,Zi , x1

i } : P = {$i}, F = {Xi | X ∈ U}, β′ = (w),

{xfi , xs,Z

i } : P = U ′, F ={

FO(xi) ∪ {Z, $i}, if xi is an insertion node{Z, $i}, if xi is a substitution node

and β′ = (w), for all Z ∈ PO(xi).

Case 3. If xi ∈ XG is a deletion node, then the construction in Case1 is modified as follows:– The way of applying the rules in node xs

i is changed to l if α(xi) = r.– Parameters of the node x1

i are now R(x1i ) = {X → Xd | X → ε ∈

Mxi}, α′(x1i ) = ∗.

– A new node is added: x4i with R(x4

i ) = {Xd → ε}, α′(x4i ) = α(xi).

NaCo.tex; 27/10/2009; 22:06; p.15


– Parameters of the node xfi are now R(xf

i ) = {Xd → X | X ∈ U},α′(xf

i ) = ∗.In this case, the edges are:

{xsi , x

1i }: P = {$i}, F = {Xd | X ∈ U}, β′ = (w),

{x1i , x

2i }: P = U ′, F = {#}, β′ = (w),

{x2i , x

3i }: P = {#}, F = {$i}, β′ = (w),

{x3i , x

4i }: P = U ′, F = {#}, β′ = (w),

{x4i , x

si}: P = U ′, F = ∅, β′ = (w),

{xfi , xs

i}: P = FO(xi), F = {$i}, β′ = (w).

Let us follow a computation of Γ′ on the input word w ∈ V ∗. Letus assume that w lies in the input node xs

1 of Γ′. In the same time, weassume that w is found in x1, the input node of Γ. Inductively, we mayassume that a word w is found in some xi, a node of Γ, as well as in xs

i

from Γ′.In the sequel we consider two cases: xi is a substitution or a deletion

node. Since the reasoning for an insertion node is pretty similar to thatfor a substitution node, it is left to the reader. Let xi be a substitutionnode, where a rule Y → X is applied to w producing either w1Xw2, ifw = w1Y w2 or w, if w doesn’t contain Y . Here is the first differencewith respect to an insertion node where every rule that could be appliedis actually applied. In Γ′, the word w is processed as follows. First wbecomes w$i in xs

i , then it can enter x1i only. Here it may become

w1Xiw2$i, if w = w1Y w2, or it is left unchanged. Further, w$i cango back to xs

i , where another $i symbol is added to its righthand end.Then it returns to x1

i and the situation above is repeated. When xi is aninsertion node, then this “ping-pong” process cannot happen. On theother hand, w1Xiw2$i enters x2

i . It is worth mentioning that any wordarriving in x2

i contains at most one occurrence of Xi for some X ∈ U .In x2

i , all the symbols $i are replaced by # which is to be deleted inx3

i . Finally, the current word enters xfi where the symbol Xi, if any, is

rewritten into X. Thus, in node xfi we have obtained the word w1Xw2,

if w = w1Y w2, or w if w doesn’t contain Y ; all the other words thatmay be obtained during these five steps either lead to the same wordin xf

i or have no effect on the rest of the computation.The second case to be considered is when xi is a deletion node

containing a rule Y → ε; we will assume that this node is a left deletionnode, all the other cases being treated similarly. In this node, the wordw is transformed into w′, if w = Y w′, or is left unchanged, otherwise. InΓ′ the word is processed as follows. First, in xs

1 a symbol $i is insertedin the rightmost end of the word. Then the word enters x1

i , where

NaCo.tex; 27/10/2009; 22:06; p.16


it is transformed into w1Ydw2$i (if w = w1Y w2, for all the possible

w1, w2 ∈ U∗) or w$i (if Y doesn’t occur in w). After this step, w$i

goes back to xsi , where another $i symbol is added. It then returns to

x1i and the situation above is repeated. On the other hand, all words

w1Ydw2$i enter x2

i . Again, we mention that every word arriving in x2i

contains at most one occurrence of Xd for some X ∈ U . Here all thesymbols $i are replaced by #. The words can now enter x3

i only, whereall the symbols # are deleted. Further they go to node x4

i , where thesymbol Xd is deleted, provided that it is the leftmost one. Otherwise,they are left unchanged. Then each obtained word goes to xf

i , whereit is transformed back into w, if the symbol Xd was not deleted inthe previous node, or can be left unchanged. If the word still containsXd, then it goes back to node x4

i and the above considerations can beapplied again. If the word obtained doesn’t contain any Xd, then it iseither w′, where w = Y w′, or w; all the other words that we may obtainduring these six steps either lead to the same word in xf

i or have noeffect on the rest of the computation.

In conclusion, if w ∈ U∗ is a word in the nodes xi of Γ and xsi of

Γ′, then we can obtain w′ ∈ U∗ in one processing step of Γ if and onlyif we can obtain w′ in the node xf

i of Γ′ in 5 processing steps (if xi isan insertion or substitution node) or in 6 processing steps (if xi is adeletion node). At this point we note that w′ can leave xi and enters xj

in Γ if and only if w′ can leave xfi and enters xs

j via the nodes x1i,j and

x2i,j . If w′ can leave xi but cannot enter xj in Γ, then it is trapped in

x1i,j in Γ′. Finally, if w′ cannot leave node xi, then it is resent by xf

i toxs

i (in the case of deletion nodes, and insertion and substitution nodeswith weak filters) or to the nodes xs,Z

i , for all Z ∈ PO(xi) (in the caseof insertion and substitution nodes with strong filters); from this pointthe process described above is repeated, with the only difference thatin the case of insertion and substitution nodes with strong filters, therole of node xs

i is played by the nodes xs,Zi .

From the above considerations, it follows that Γ′ simulates in at most6 processing steps and 5 communication steps a processing step of Γ,and in another 2 processing steps and 3 communication steps a com-munication step of Γ. We conclude that L(Γ) = L(Γ′) and TimeΓ′(n) ∈O(TimeΓ(n)). 2

The converse of the previous theorem holds.

PROPOSITION 4. TimeANEPFC(f(n)) ⊆ TimeANEP (f(n)) for anyfunction f : IN −→ IN .

Proof. Let Γ = (V, U,G,R,N , α, β, x1, xn) be an ANEPFC with G =(XG, EG), XG having n nodes x1, x2, . . . , xn. We construct the ANEP

NaCo.tex; 27/10/2009; 22:06; p.17


Γ′ = (V, U ′, G′,N ′, α′, β′, xI , xO), where

U ′ = V ∪X ∪ {Y }, X = {Xi,j | 1 ≤ i 6= j ≤ n, i 6= n,

and {xi, xj} ∈ EG}G′ = (X ′

G, E′G),

X ′G = {xI , xO} ∪ {xi,j , x

′i,j | 1 ≤ i 6= j ≤ n, i 6= n, and {xi, xj} ∈ EG},

E′G = {{xI , x1,i} | 2 ≤ i ≤ n} ∪ {{xi,j , x

′i,j} | 1 ≤ i 6= j ≤ n, i 6= n} ∪

{{x′i,j , xj,k} | 1 ≤ i 6= j ≤ n, 1 ≤ j 6= k ≤ n} ∪{{x′i,n, xO} | 1 ≤ i ≤ n− 1},

and the other parameters defined as follows:

• node xI : M = {ε → X1,i | 2 ≤ i ≤ n},– PI = V , FI = X, PO = X, FO = ∅,– α′ = ∗, β′ = (w).

• nodes xi,j , 1 ≤ i 6= j ≤ n, i 6= n: M = R(xi),– PI = {Xi,j}, FI = X \ {Xi,j}, PO = P{xi,xj}, FO = F{xi,xj},– α′ = α(xi), β′ = β({xi, xj}).

• nodes x′i,j , 1 ≤ i 6= j ≤ n, i 6= n:

– M ={ {Xi,j → Xj,k | 1 ≤ k ≤ n, k 6= j}, if j < n{Xi,j → Y }, if j = n

– PI = {Xi,j}, FI = X\{Xi,j}, PO = (X∪{Y })\{Xi,j}, FO = ∅,– α′ = ∗, β′ = (w).

• node xO: M = ∅, PI = {Y }, FI = ∅, PO = ∅, FO = ∅,– α′ = ∗, β′ = (s).

Any computation in Γ′ on an input word w ∈ V + produces in xI allwords w1X1,iw2 with w1, w2 ∈ V ∗ such that w = w1w2 and 2 ≤ i ≤ nprovided that {x1, xi} ∈ EG. Each word containing X1,i enters x1,i. Ina more general setting, we assume that a word y1Xi,jy2, y1, y2 ∈ V ∗,enters xi,j at a given step of the computation of Γ′ on w. This meansthat y = y1y2 enters xi at a given step of the computation of Γ onw. Let y be transformed into z = z1z2 in node xi and z can passthe filter on the edge between xi and xj . Let us further assume thatyp is transformed into zp, p = 1, 2. This easily implies that y1Xi,jy2

is transformed into z1Xi,jz2 in node xi,j and z1Xi,jz2 can pass theoutput filter of xi,j . Note that the converse is also true. Now, z1Xi,jz2,j 6= n, enters x′i,j where all words z1Xj,kz2, with 1 ≤ k 6= j ≤ n and{xj , xk} ∈ EG, are produced. Each word z1Xj,kz2 enters xj,k and theprocess of simulating the computation in Γ resumes. On the other hand,

NaCo.tex; 27/10/2009; 22:06; p.18


z1Xi,nz2 enters x′i,n where Xi,n is replaced by Y . All words producedin x′i,n, for some 1 ≤ i ≤ n − 1, enter xO and the computation ends.Note that by the considerations above, a word enters x′i,n if and only ifa word from xi was able to pass the filter on the edge between xi andxn in Γ.

Note that two consecutive steps (evolutionary and communication)in Γ are simulated by four steps (two evolutionary and two communi-cation) in Γ′. Therefore, L(Γ) = L(Γ′) and TimeΓ′(n) ∈ O(TimeΓ(n)).hold 2

As a direct consequence of the results presented in the previous twosections we can state the main result of this paper:

THEOREM 1.

TimeANEP (f(n)) = TimeUANEP (f(n)) = TimeANEPFC(f(n))

for any function f : IN −→ IN .

5. Simulations Preserving Complexity and the Shape

The simulations presented above may lead to underlying graphs of thesimulating networks that differ very much from the underlying graphsof the simulated networks. However, it looks like there is some form ofduality between edges and nodes in the simulations. In network theory,some types of underlying graphs are common like rings, stars, grids, etc.Networks of evolutionary words processors, seen as language generatingor accepting devices, having underlying graphs of these special formshave been considered in several papers, see, e.g., (Martın-Vide and Mi-trana, 2005) for an early survey. On the other hand, in almost all worksreported so far ANEPs and ANEPFCs have a complete underlyinggraph.

Simulations preserving the type of the underlying graph of the simu-lated network (together with its computational complexity) represent,in our view, a matter of interest. We briefly discuss here the case ofnetworks with a complete underlying graph. Starting from the obser-vation that every ANEPFC can be immediately transformed into anequivalent ANEPFC with a complete underlying graph (the edges thatare to be added are associated with filters which make them useless), wemay immediately state that Proposition 3 holds for complete ANEPsand ANEPFCs as well.

THEOREM 2. If a language is accepted by a complete ANEP in O(f(n))time, then it is accepted by a complete ANEPFC in O(f(n)), for anyfunction f : IN −→ IN .

NaCo.tex; 27/10/2009; 22:06; p.19


A stronger result that can be obtained directly from the proof ofProposition 2 is:

THEOREM 3. For any function f : IN −→ IN , a language is acceptedby a complete ANEP in O(f(n)) time, if and only if it is accepted bya complete UANEP in O(f(n)).

Proof. It suffices to complete the underlying graph G′ of Γ′ in the proofof Proposition 2. Apart from the considerations in that proof, it shouldbe mentioned that the following situation may happen. Although aword, say z, enters at some moment xi in Γ and cannot leave xi

unchanged, the corresponding word in Γ′ can go out from xcheck−ini ,

enters some x2i (Y ), then xcheck−out

i , xcontinuei , and finally xcheck−in

j forsome 1 ≤ j 6= i ≤ n−1. However, if this may happen, then z should bein xi and xj at the same time because Γ is a complete ANEP. Therefore,this fact does not influence the accepted language of Γ′. 2

Although it is true that every ANEP is equivalent to a completeANEP (every Turing machine can be simulated by a complete ANEP),we do not know a simple and direct transformation as that for ANEPFCs.Therefore, a direct simulation of complete ANEPFC by complete ANEPremains open. Furthermore, simulations preserving complexity as wellas the type of the underlying graph remain to be further investigated.

6. Final Remarks

The language decided by an ANEP and ANEPFC is defined in (Mar-genstern et al., 2005) and (Dragoi et al., 2007), respectively. In a similarway the language decided by an UANEP can be defined. It is easy tonote that the construction in the proof of Proposition 4 works for thedecided languages as well. However, in the proofs of Propositions 2 and3, Γ′ does not detect the non-accepting halting computations of Γ, sinceconfigurations obtained in consecutive processing steps of Γ are not ob-tained here in consecutive processing steps. Thus Γ′ doesn’t necessarilydecide the language decided by Γ. It is known from the simulation ofTuring machines by ANEPs and ANEPFCs (Manea et al., 2007; Dragoiand Manea, 2008) that the languages decided by ANEPs can be alsodecided by ANEPFCs. By a similar construction to those from (Maneaet al., 2007; Dragoi and Manea, 2008), one may prove that any recursivelanguage can be decided by UANEPs. Under these circumstances, thefollowing problem is legitimate: Can the constructions from the proofsof Propositions 3 and 2 be modified for a direct simulation of ANEPshalting on every input? Finally, as the networks of evolutionary picture

NaCo.tex; 27/10/2009; 22:06; p.20


processors introduced in (Bottoni et al., 2009) do not have insertionnodes, it would be of interest to find direct simulations for these devices.In other words, can we simulate networks having all nodes of just oneor two types out of the three ones without introducing nodes of themissing type(s)?

References

Alhazov, A., Bel Enguix, G., Rogozhin, Y. (2009). Obligatory Hybrid Networks ofEvolutionary Processors. In International Conference on Agents and ArtificialIntelligence (ICAART 2009), 613-618.

Alhazov, A., Csuhaj-Varj, E., Martn-Vide, C., Rogozhin, Y. (2009). On the Sizeof Computationally Complete Hybrid Networks of Evolutionary Processors.Theoretical Computer Science 410:3188–3197.

Bottoni, P.,Labella, A., Manea, F., Mitrana, V., Sempere, J. (2009). Filter Po-sition in Networks of Evolutionary Processors Does Not Matter: A DirectProof. In Proc. 15th International Meeting on DNA Computing and MolecularProgramming. June 8-11, 2009, Fayetteville, Arkansas

Bottoni, P., Labella, A., Mitrana, V., Sempere, J. (2009). Networks of EvolutionaryPicture Processors. Submitted.

Castellanos, J., Martın-Vide, C., Mitrana, V., Sempere, J. (2001). Solving NP-complete Problems with Networks of Evolutionary Processors. In InternationalWork-Conference on Artificial and Natural Neural Networks (IWANN 2001),LNCS 2084:621–628.

Csuhaj-Varju, E., Salomaa, A. (1997) Networks of Parallel Language Processors. InNew Trends in Formal Languages, LNCS 1218:299–318.

Csuhaj-Varju, E., Mitrana, V. (2000). Evolutionary Systems: A Language Gen-erating Device Inspired by Evolving Communities of Cells. Acta Informatica,36:913–926.

Dassow, J., Truthe, B. (2007). On the Power of Networks of Evolutionary Processors.In Machines, Computations, and Universality (MCU 2007), LNCS 4667:158–169.

Dragoi, C., Manea, F., Mitrana, V. (2007). Accepting Networks of EvolutionaryProcessors With Filtered Connections Journal of Universal Computer Science,13:1598–1614.

Dragoi, C., Manea, F. (2008). On the Descriptional Complexity of AcceptingNetworks of Evolutionary Processors With Filtered Connections. InternationalJournal of Foundations of Computer Science, 19:1113–1132.

Errico, L., Jesshope, C. (1994). Towards a New Architecture for Symbolic Pro-cessing. In Artificial Intelligence and Information-Control Systems of Robots 94,World Scientific, Singapore, 31-40.

Fahlman, S. E., Hinton, G.E., Seijnowski, T.J. (1983). Massively Parallel Archi-tectures for AI: NETL, THISTLE and Boltzmann Machines. In Proc. of theNational Conference on Artificial Intelligence, 109–113.

Hillis, W. (1985). The Connection Machine. MIT Press, Cambridge, 1985.Manea, F., Martin-Vide, C., Mitrana, V. (2007). On the Size Complexity of Universal

Accepting Hybrid Networks of Evolutionary Processors. Mathematical Structuresin Computer Science, 17:753–771.

Margenstern, M., Mitrana, V., Perez-Jimenez, M. (2005). Accepting Hybrid Net-works of Evolutionary Systems. DNA Based Computers 10 LNCS 3384:235–246.

NaCo.tex; 27/10/2009; 22:06; p.21


Martın-Vide, C., Mitrana, V. (2005). Networks of Evolutionary Processors: Re-sults and Perspectives. In Molecular Computational Models: UnconventionalApproaches, Idea Group Publishing, Hershey, 78-114.

Paun, G., Santean, L. (1989). Parallel Communicating Grammar Systems: TheRegular Case. Annals of University of Bucharest, Ser. Matematica-Informatica38:55–63.

Paun, G. (2000). Computing with Membranes. Journal of Computer and SystemSciences 61:108–143.

Rozenberg, G., Salomaa, A. (eds.) (1997). Handbook of Formal Languages. Springer–Verlag, Berlin.

Sankoff, D. et al. (1992). Gene Order Comparisons for Phylogenetic Infer-ence: Evolution of the Mitochondrial Genome. Proc. Natl. Acad. Sci. USA89:65756579.

NaCo.tex; 27/10/2009; 22:06; p.22

Complexity-preserving simulations among three variants of accepting networks of evolutionary...

Documents

Transcript of Complexity-preserving simulations among three variants of accepting networks of evolutionary...