Minimizing Evolution-Communication P Systems and Automata
1
Minimizing Evolution-Communication P
Systems and Automata
Artiom ALHAZOV
Research Group on Mathematical Linguistics
Rovira i Virgili University
Pl. Imperial Tàrraco 1, 43005 Tarragona, Spain, and
Institute of Mathematics and Computer Science
Academy of Sciences of Moldova
Str. Academiei 5, Chişinău, MD 2028, Moldova
[email protected], [email protected]
Received 8 April 2003
Abstract
Evolution-communication P systems are a variant of P
systems allowing both rewriting rules and symport/antiport rules, thus
having separated the rewriting and the communication. The purpose of
this paper is to solve an open problem stated in 1) , namely generating
the family of Turing computable sets of vectors of natural numbers instead of the family of Turing computable sets of natural numbers. The
same construction also reduces the 3-membrane non-cooperative case and
the 2-membrane 1-catalyst case to the 2-membrane non-cooperative case.
Also, EC P automata are introduced and it is proved that 2-membrane
EC P automata with a promoter can accept all recursively enumerable
languages. Finally, a definition of an extended system is given, and its
universality is proved using the rules of more restricted types.
Keywords Membrane Computing, EC P Systems, EC P Automata,
Turing Computability
§1
Introduction
This paper investigates the class of evolution-communication P systems
(EC P systems), which were recently proposed in 1) . The motivation to introduce this class of P systems is to separate the evolutive mechanism (rewriting,
2
Artiom ALHAZOV
chemical reactions) from the communicative one (symport/antiport, transporting molecules inside/outside of a membrane). These processes happen in nature
simultaneously. Models containing either mechanism are known to be universal,
however using both in the same model allows simpler rewriting rules, as well as
simpler transport rules; other restrictions/simplifications can also be studied.
Besides the generative case, we also consider here the automata-like
case, where strings are recognized by a P system, as first considered in 2) . Also
in this case we get the universality: any recursively enumerable language can
be recognized by an EC P automaton with two membranes, and with a promoter (a symbol) associated with part of the evolution rules (but not with the
communication rules).
Finally, a definition of an extended system is given, and the universality
is proved with binary context-free evolution rules, antiport rules of weight 1, no
symport rules, and 2 membranes.
§2
Definitions
Let us recall a few formal language theory definitions and notations.
For an alphabet (a finite nonempty set) V = {a1 , · · · , am }, we denote by V ∗
the set of all words over V . For w ∈ V ∗ we denote the length of w by |w| and
the number of occurrences of a letter a ∈ V in w by |w|a . We call the Parikh
vector of w a vector ΨV (w) = (|w|a1 , · · · , |w|am ) of number of occurrences of the
letters of V in w. Consider a language L ⊆ V ∗ . We use the following notations:
N (L) = {|w| | w ∈ L}, P s(L) = {ΨV (w) | w ∈ L} for the length set and the
Parikh image of L, respectively.
For the basic elements of membrane computing, we refer the reader to
the monograph 6) . We start by recalling from 1) the definition of an EC P system.
Definition 2.1
An evolution-communication P system of degree m ≥ 1 is defined as
′
Π = (O, µ, w1 , · · · , wm , R1 , · · · , Rm , R1′ , · · · , Rm
, i0 ),
where O is the alphabet of objects, µ is a membrane structure with m regions,
labeled with 1, · · · , m, and i0 ∈ {0, · · · , m} is the output region (the environment
if i0 = 0). Every region i ∈ {1, · · · , m} has
•
•
wi ∈ O∗ – a string representing a multiset of objects from O;
Ri – a finite set of evolution rules over O of the form u → v, for u ∈ O+
and v ∈ O∗ (hence without target indications associated with the objects
Minimizing Evolution-Communication P Systems and Automata
3
from v);
•
Ri′ – a finite set of symport/antiport rules over O, of the forms
(a, in), (b, out), (b, out; a, in), for a, b ∈ O.
The evolution rules of the form u → v mean to replace u by v, in the
region this rule is associated to. These rules change the objects without moving them to a different region, as opposed to the communication rules, moving
the objects without changing them. The symport/antiport rules are associated
to membranes, rather than to regions. Rule (a, in) means to bring a inside
the membrane, rule (b, out) means to take b out of the membrane, and rule
(b, out; a, in) means to bring a inside the membrane in exchange for b, which is
taken out of the membrane (both a in the external region and b in the internal
region must be present for the rule to be applicable, and both are used by the
rule if it is applied). Both evolution and communication rules are applied in
parallel.
The definition above is slightly different from the one given in 1) : here
the communication rules are restricted to symport/antiport rules of weight one.
The basic variant assumes that all rules are applied in a nondeterministic, maximally parallel way and that there is no priority among the evolution
and communication rules. The result of a halting computation consists of the
vector/number of objects present in the halting configuration in membrane i0 .
(The so-called evolutive approach and the communicative approach were also
proposed, where the evolution rules and the communication rules, respectively,
are applied with priority, but we do not consider here such versions.)
The notation N ECPm (i, j, α) (P sECPm (i, j, α)), for α ∈ {ncoo, coo} ∪
{catk | k ≥ 0}, is used for the family of natural number sets (the family of natural
number vector sets) generated by EC P systems with at most m membranes,
using symport rules of weight at most i, antiport rules of weight at most j, and
cooperative evolution rules (coo), non-cooperative rules (ncoo), or catalytic rules
with at most k catalysts (catk ).
In the proofs below we will essentially use programmed grammars with
appearance checking.
Definition 2.2
A (context-free) programmed grammar with appearance checking is a system
G = (N, T, S, P ), where N is a finite set of nonterminal symbols, T is a finite set
of terminal symbols (N ∩ T = ∅), S ∈ N is the start symbol, and P is a finite
4
Artiom ALHAZOV
set of triples of the form
(r : A → u, σ(r), ϕ(r)),
where r is a label of the rewriting rule A → u, lab(P ) = {r | (r : A →
u, σ(r), ϕ(r)) ∈ P } is the set of labels of rules in P and σ, ϕ : lab(P ) −→ 2lab(P ) ;
σ(r), ϕ(r) are called the success field and the failure field of r, respectively.
Definition 2.3
Let (r : A → u, σ(r), ϕ(r)) ∈ P . We say that w′ is derived from w in one step
by applying or skipping the rule r : A → u, and we write w ⇒r w′ , if either w =
xAy, w′ = xuy or w = w′ , |w|A = 0. In the derivation, pairs of labels and words
are considered: (r, w) ⇒ (r′ , w′ ) if w ⇒r w′ for (r : A → u, σ(r), ϕ(r)) ∈ P , and
either |w|A > 0 and r′ ∈ σ(r), or |w|A = 0 and r′ ∈ ϕ(r).
In other words, if A is present in the sentential form, then the rule is
used and the next rule to be applied is chosen from those with the label in σ(r),
otherwise, the sentential form remains unchanged and we choose the next rule
from the rules labeled by some element of ϕ(r). Let ⇒∗ be the reflexive and
transitive closure of ⇒. The language generated by the programmed grammar
G is L(G) = {x ∈ T ∗ | (r, S) ⇒∗ (r′ , w′ ), and w′ ⇒r′ x}.
In this definition we have used w′ ⇒r′ x rather than (r′ , w′ ) ⇒ (r′′ , x)
because we do not need to specify the next rule to apply after we have obtained
the terminal string. This definition is family-equivalent to the one from 3) , with
(r′ , w′ ) ⇒ (r′′ , x). We take advantage of this fact in the universality proof.
If ϕ(r) = ∅ for each r ∈ Lab(P ), then the grammar is said to be without
appearance checking. If σ(r) = ϕ(r) for each r ∈ Lab(P ), then the grammar is
said to be with unconditional transfer: in such grammars the next rule is chosen
irrespective of whether the current rule can be effectively used or not.
§3
Universality
In the theorems in this paper, we refer to the first, the second, etc.
rules having the same line number (n) as (n, a), (n, b), etc. We use the following
standard notations: P R is the family of languages generated by context-free programmed grammars without appearance checking, N RE is the family of (Turing)
computable sets of natural numbers and P sRE is the family of computable sets
of vectors of natural numbers. In general, for a family F L of languages, we
denote by N F L (P sF L) the family of length sets (Parikh images) of languages
5
Minimizing Evolution-Communication P Systems and Automata
in F L, respectively.
•
Some generative capacity results were obtained in 1) , namely
P sP R ⊆ P sECP2 (1, 1, ncoo),
•
•
N ECP2 (1, 1, cat1 ) = N RE,
N ECP3 (1, 1, ncoo) = N RE.
We improve these results by showing that P sECP2 (1, 1, ncoo) = P sRE. We
start by recalling a universality result about programmed grammars.
Lemma 3.1 (Theorem 1.2.5 in
3)
)
The class of programmed grammars with appearance checking generates exactly
the family of recursively enumerable languages.
Theorem 3.1
P sECP2 (1, 1, ncoo) = P sRE.
Proof
Let us consider a programmed grammar G = (N, T, P, S) with ap-
pearance checking, where every nonterminal appears on the left-hand side of
some rule. Let h be a new symbol. We define N ′ = N ∪ {h}.
For each x ∈ N ′ we consider a new symbol x̄, we define the set N̄ = {x̄ |
x ∈ N ′ }, and the morphism γ : (N ′ ∪ T )∗ −→ (N̄ ∪ T )∗ defined by γ(x) = x̄ for
x ∈ N ′ , and γ(x) = x for x ∈ T .
We construct the EC P system
Π1 = (O, µ, w1 , w2 , R1 , R2 , R1′ , R2′ , 0), with:
O = T ∪ N ′ ∪ N̄ ∪ {bi , b′i , di , d′i , ei | i ∈ lab(P )}
∪ {c, c′ , f, f ′ , F, d′0 , #},
(1)
µ = [ 1[ 2 ] 2] 1,
w1 = c, w2 = Shd′0 ,
(2)
R1 = {X → γ(x)dk | (k : X → x, σ(k), ϕ(k)) ∈ P }
∪ {X → # | X ∈ N }
(3)
∪ {h → h̄bi ei f, di → #, bi → # | i ∈ lab(P )},
(4)
∪ {c′ → c, c′ → F, # → #},
(5)
′
R2 = {Ȳ → Y | Y ∈ N }
(6)
∪ {di → d′i , bi → b′i | i ∈ lab(P )}
′
′
′
∪ {c → c , f → f , f → #, F → #, # → #},
(7)
(8)
6
Artiom ALHAZOV
R1′ = {(a, out) | a ∈ T },
R2′
(9)
′
= {(X, out; ek , in), (f , out; ek , in) |
(k : X → x, σ(k), ϕ(k)) ∈ P }
(10)
′
∪ {(Ȳ , in), (Y, out; c, in), (Y, out; F, in) | Y ∈ N }
(11)
∪ {(f, in), (c′ , out)}
(12)
{(d′j , out; di , in),
(d′j , out; bi , in)
| i ∈ σ(j)}
(13)
∪ {(b′j , out; di , in), (b′j , out; bi , in) | i ∈ ϕ(j)}
(14)
∪
∪
{(d′0 , out; di , in),
(d′0 , out; bi , in)
| i ∈ lab(P )}.
(15)
The system Π1 simulates the programmed grammar G (see also 1) ) using
the following idea. We use objects associated with each terminal (T ), associated
with each non-terminal (N ′ ), including also the rule application failure symbol
(h), their birth versions (N̄ ), control sequence symbols (bi , b′i if the rule was
skipped and di , d′i if the rule was applied), appearance checking symbols (ei ).
Objects c and c′ are used to sequentialize the application of the rules, f and
f ′ block the computation in case of invalid control sequence, F checks that all
nonterminals were rewritten at the end, d′0 is the starting point of the control
sequence, and # is the trap symbol.
In region 1 (the outer one) we simulate the application of the context-free
rules of G, using evolution rules (3,a), while the rules (13), (14), (15) enforce the
“control sequence”, i.e., transitions from an application of (or from the failure to
apply) a rule of G to the next one. During the simulation, the nonterminals to
be rewritten are brought into region 1 by rules (11,b), and the result is returned
by rules (11,a), except the terminal symbols, ejected into the environment by
(9). Rules (6) remove the bars. The failure to apply a rule is simulated by (4).
The appearance checking is enforced by the rules (10,b). Rules (5,b), (11,c),
and (8,d) make sure that the computation halts, and that when it does, no
nonterminals are present in region 2.
We will now proceed to a more detailed explanation of why this construction works. Applying or skipping a rule is simulated in four stages, each
stage consisting of one transition of Π1 . In the first stage some nonterminal X
(or h for skipping the rule) is brought in the outer membrane by the antiport
rule in (11,b). In the second stage some rewriting rule k is either applied for
X (X → x) by (3,a), producing γ(x) and dk , or skipped, rewriting h by (4,a),
Minimizing Evolution-Communication P Systems and Automata
7
producing bk . At the same time, c changes to c′ by (8,a). In case the rule application is simulated, in the third stage the barred versions of nonterminals
of x are returned to the inner membrane by (11,a) and the terminals of x are
output into the environment by (9). Also in the third stage dk or bk should enter
the inner membrane (otherwise the computation is blocked by (4,b) or (4,c)) by
(13-15,a) or (13-15,b), respectively, according to the given success and failure
functions σ(j) and ϕ(j) of the rule j, applied or skipped at the previous step of
the simulated derivation. At the same time, c′ exits the inner region by (12,b).
In the fourth stage the barred nonterminals lose the bars by (6) and
dk or bk are rewritten with their primed versions. At the same time, c′ changes
to c by (5,a), and the process can repeat. At the end of computation, c′ can
change to F instead. The rule (11,c) makes sure that no nonterminal is present
in the inner region: if there is one, then this antiport rule is applied, bringing
F to the inner region, where it would block the computation by (8,d). In the
case the computation continues after no nonterminals remain in the inner region, the skipping of the rule will be used, either blocking the computation, or
eventually rewriting c′ with F , leading to the same result as that of finishing the
computation immediately after no nonterminals remain.
The terminal configuration occurs at stage 1 with F without nonterminals. Region 2 will have h, one element of {b′i , d′i | i ∈ lab(P )}, and zero or more
elements of {ei | i ∈ lab(P )}. Region 1 will then have F and some elements of
{b′i , d′i , | i ∈ lab(P )} ∪ {f ′ }. The environment will contain the Parikh set of (any)
word in the language L(G). No more rules can be applied.
Finally, we explain the appearance checking. Suppose region 2 contains
a nonterminal X, and the P system is simulating skipping the rule (k : X → x,
σ(k), ϕ(k)) ∈ P . At stage 1, h is introduced in the outer region. At stage 2, h is
rewritten and ek appears together with f . At stage 3, f enters the inner region,
and so does ek by the antiport rule (10,a). At stage 4, f changes to f ′ , and then
the computation is blocked by (8,c). If region 2 contained no X, then ek would
remain in region 1, and f ′ could exit region 2 by rule (10,b).
This way, Π1 generates exactly the Parikh image of the language L(G),
and the theorem statement follows immediately by the lemma above.
The above result improves Theorems 3.1, 4.1, 5.1 of 1) , generating the
family of Turing computable sets of vectors of natural numbers rather than sets
of numbers, with a more restricted system, in a more efficient way (in terms of
number of objects, number of rules, minimal number of derivation steps).
8
Artiom ALHAZOV
§4
EC P Automata
A few variants of P automata were given in 4) . We are going to use a
simple variant, namely accepting P systems, similar to those introduced in 5) .
Let us recall this definition, but in the framework of evolution-communication.
Definition 4.1
An evolution-communication P automaton of degree m ≥ 1 is defined as
′
Π = (O, V, µ, w1 , · · · , wm , R1 , · · · , Rm , R1′ , · · · , Rm
),
where O is the alphabet of objects, V ⊆ O is the input alphabet, µ is a membrane
structure with m regions, labeled with 1, · · · , m. Like in the definition of an EC
P system, for every region i ∈ {1, · · · , m} we specify:
• wi ∈ O∗ – a string representing a multiset of objects from O;
•
Ri – a finite set of simple evolution rules over O of the forms u → v,
u → v|p , for u ∈ O+ , v ∈ O∗ , p ∈ O;
•
Ri′ – a finite set of symport/antiport rules of the forms (a, in), (b, out),
(b, out; a, in), (a, in)|p , (b, out)|p , (b, out; a, in)|p , for a, b, p ∈ O.
Multisets p of objects in rules above are called promoters (see also 6) ). A rule
with a promoter p is only applicable if p is present in the corresponding region.
The P automaton accepts or rejects words in V ∗ . Given a word w ∈ V ∗ ,
the system starts working in the empty environment, and at every step k,
1 ≤ k ≤ |w|, the k-th letter of w appears in the environment. A word w is
accepted if two conditions hold: each letter of w is brought into the outer membrane immediately after introducing it in the environment (in 4) , this is called
the initial mode of accepting a string), and the system eventually halts. The
language LA (Π) ⊆ V ∗ , accepted by a P system Π, is the set of accepted words.
The notation AI ECPm (i, j, α), α ∈ {ncoo, coo} ∪ {catk | k ≥ 0}, is used
for the family of languages accepted by the EC P automata with at most m
membranes, using symport rules of weight at most i, antiport rules of weight
at most j, and cooperative (coo), catalytic with at most k catalysts (catk ) or
non-cooperative (ncoo) evolution rules. If p1 precedes i, j or α, then a promoter
of length 1 is allowed in the symport, antiport or evolution rules, respectively.
We are now going to prove that EC P automata accept all recursively
enumerable languages.
Let us consider a language L ∈ V ∗ , V = {a1 , · · · , ak }. Every word
w = am1 · · · am|w| ∈ L corresponds to the number valk+1 (w), which is the value
9
Minimizing Evolution-Communication P Systems and Automata
of m1 · · · m|w| in base k + 1 (a number, whose digits are the subscripts mi of
letters ami of w). If L ∈ RE, then valk+1 (L) ∈ N RE, hence the following holds.
Lemma 4.1
Let L ∈ V ∗ and L′ = {avalk+1 (w) | w ∈ L} for a given symbol a. If L ∈ RE,
then L′ is a one-letter RE language.
Theorem 4.1
AI ECP2 (1, 1, p1 ncoo) = RE.
Proof
Let us consider a language L ∈ V ∗ , V = {a1 , · · · , ak }. Let us define
L′ as in lemma above, and let G = (N, T, P, S), T = {a}, be a programmed
grammar with appearance checking which generates L′ , where every nonterminal
appears on the left-hand side of some rule. We now construct a P automaton as
follows.
Let h be a new symbol and define N ′ = N ∪ {h}. For each x ∈ N ′ we
construct a new symbol x̄, we define the set N̄ = {x̄ | x ∈ N ′ }, and the morphism
γ : (N ′ ∪ T )∗ −→ (N̄ ∪ T )∗ defined as γ(x) = x̄, x ∈ N ′ , and γ(x) = x, x ∈ T .
We construct the EC P automaton
Π2 = (O, V, µ, w1 , w2 , R1 ∪ Q1 , R2 ∪ Q2 , Q′1 , R2′ ∪ Q′2 ),
where R1 , R2 , and R2′ are as in the proof of the previous theorem, and
O = T ∪ N ′ ∪ N̄ ∪ {bi , b′i , di , d′i , ei | i ∈ lab(P )}
∪ {c, c′ , f, f ′ , F, d′0 , #}
∪ {ai | 1 ≤ i ≤ k} ∪ {b, b′ , d, e, e′ , g, g ′ , I},
µ
(16)
= [ 1[ 2 ] 2] 1,
w1 = cI, w2 = Shd′0 g,
i
(17)
i ′ ′
Q1 = {ai → b e|e , ai → b e g |e , ai → #, b → b
k+1
∪ {e → f ′ , b → b′ |e′ , a → a, I → e, I → g ′ },
′
Q2 = {b → d, d → d, g → g},
′
(18)
(19)
(20)
Q′1 = {(ai , in) | ai ∈ V },
Q′2
|e }
(21)
′
= {(b , in), (d, out; a, in), (g, out; g , in)}.
(22)
The system Π2 has all the elements and all the rules of the system Π1
in the previous theorem, except (9). This part of Π2 simulates the programmed
grammar G of L′ in the way described in the previous theorem, except the
10
Artiom ALHAZOV
terminal symbols do not leave the system, because the symport rule (a, out) is
absent. The other objects used are: the alphabet {ai | 1 ≤ i ≤ k} of the input
language, I is the initializer, b is used for calculating a unary representation of
the input word, b′ transports this number to the inner membrane, and d stores it.
Objects e and e′ control the processing of the input (they are used as promoters),
g and g ′ are used to make sure that the computation is blocked if the input word
is not decoded correctly.
Suppose Π2 is processing the input w. Rules (18,d) and (18,a) enforce
calculation of valk+1 (w), performing multiplication and addition, respectively.
The rule (18,b) does the last addition. The rule (18,c) blocks the computation
if the rule (18,b) was applied before the last input letter. The rule (19,a) erases
e in the outer region, (19,b) stops the computation of v = valk+1 (w), (19,c)
keeps the terminals a busy. The initializer I makes a guess and either produces
e by (19,d) to process the input, or g ′ by (19,e) to examine the case of the
empty word. If it produces e and the word is empty, then the system never halts
because of the rule (20,c) (g cannot escape by (22,c) because neither (18,b) nor
(19,e) were applied to produce g ′ ). If I produces g ′ and the word is not empty,
then there is no promoter e for the rules (18,a), (18,b), and the input symbol
will block the computation by (18,c).
In region 2, the rule (20,a) transforms (b′ )v into dv ; (20,b) keeps d’s
busy, and (20,c) requires that g is brought into the outer region by (22,c) when
(and only if) the value v is calculated correctly.
The rule (21) brings the symbols of the input string into region 1. (22,a)
transports (b′ )v into the region 2; the rule (22,b) is used for decrementing multiplicities of d in region 2 and of a in region 1, and the decrementation is used
for comparing the numbers.
We will now proceed to a more detailed explanation of why this construction works. At first, we discuss the computation of v. In case of the empty
word, v = 0 as described in the work of the initializer. Assume |w| > 0. Let
vj = valk+1 (am1 · · · amj ). Then vj+1 = vj ∗(k+1)+mj+1 , j < |w|. Two “wrong”
things can possibly happen in simulation: if (18,b) is applied not for the last
symbol of w, then the computation will be blocked by (18,c); also if (18,b) is
never applied, then g ′ will never appear, and (20,c) will block the computation.
These cases produce no results.
After all the input is successfully converted to v objects b, the symbols e′
and g ′ appear. The first one promotes bv to (b′ )v by (19,b), the latter removes g
11
Minimizing Evolution-Communication P Systems and Automata
from the inner region by (22,c). Then, (b′ )v comes to the inner region by (22,a),
and transform into dv by (20,a).
Also, the derivation of G is simulated, producing some number x of
molecules a in the outer region. The terminal configuration can be achieved for
any (and only for such) v, that x = v can be produced (without blocking). The
comparison is done by (22,b). If the numbers are not equal, then either (19,c)
or (20,b) produce an endless computation.
This way, Π2 accepts the language L(G) modulo the empty string, and
the theorem statement follows immediately by Lemma 3.1.
§5
Extended EC P Systems
Let us now extend the alphabet of an EC p system by a distinguished
object which we call “water”; water is present in the environment in an unbounded quantity, and can be brought inside the skin membrane in exchange
for the output (in the non-extended model, all communications with the environment were limited to outputting the result). This simple change allows us to
obtain the universality without using symport rules and with binary evolution
rules, that is, rules of the form a → bc. We denote the corresponding families of
languages by EECPm (i, j, ncoo2 ), with the obvious meaning.
The following counterpart of Theorem 3.1 holds:
Theorem 5.1
P sEECP2 (1, 0, ncoo2 ) = P sRE.
Proof
The idea does not essentially differ from that of the proof of Theorem
3.1. The symbol $ denotes the water. This time we start from a programmed
grammar G = (N, T, S, P ) in the normal form, i.e., for all (k : X → x, σ(k), ϕ(k))
∈ P the length of x is at most 2 (see 3) for the equivalence result). By x1 we
will denote the first symbol of x, or $ if |x| = 0, and by x2 the second symbol of
x, or $ if |x| < 2. Also, M = {mk | k ∈ lab(P )} and γ is extended by γ($) = $.
We construct the system
Π3 = (O ∪ {$}, µ, w1 , w2 , R1 , R2 , R1′ , R2′ , 0), with:
O = T ∪ N ′ ∪ M ∪ N̄ ∪ {bi , b′i , di , d′i , ei | i ∈ lab(P )}
∪ {c, c′ , c′′ , f, f ′ , F, d′0 , #, h′ , h′′ },
µ = [ 1[ 2 ] 2] 1,
(23)
12
Artiom ALHAZOV
w1 = c$, w2 = Shd′0 $$,
(24)
R1 = {X → mk dk , mk → γ(x1 )γ(x2 ) |
(k : X → x, σ(k), ϕ(k)) ∈ P }
∪ {X → #$ | X ∈ N }
′ ′′
(25)
′
′′
∪ {h → h h , h → f h̄, h → bi ei ,
di → #$, bi → #$ | i ∈ lab(P )},
′
′′
′′
′′
∪ {c → c $, c → c$, c → F $, # → #$},
R2 = {Ȳ → Y $ | Y ∈ N ′ }
∪ {di →
d′i $,
bi →
b′i $
(26)
(27)
(28)
| i ∈ lab(P )}
(29)
∪ {c → c′ $, f → f ′ $, f ′ → #$,
F → #$, # → #$},
(30)
R1′ = {(a, out; $, in) | a ∈ T },
R2′
(31)
′
= {(X, out; ek , in), (f , out; ek , in) |
(k : X → x, σ(k), ϕ(k)) ∈ P }
(32)
∪ {($, out; Ȳ , in), (Y, out; c, in), (Y, out; F, in) |
Y ∈ N ′}
(33)
∪ {($, out; f, in), (c′ , out; $, in)}
∪
{(d′j , out; di , in),
(d′j , out; bi , in)
(34)
| i ∈ σ(j)}
(35)
∪ {(b′j , out; di , in), (b′j , out; bi , in) | i ∈ ϕ(j)}
(36)
∪
{(d′0 , out; di , in),
(d′0 , out; bi , in)
| i ∈ lab(P )}.
(37)
This construction works in a way similar to the construction in the
proof of Theorem 3.1. The evolution rules (3,a) and (4,a) from Theorem 3.1 are
simulated in a series of binary steps. All rules which produce a single object,
now also produce water. Symports are replaced by antiports, exchanging for
water. At the initial configuration, region 1 has two copies of $ and region 1
has one. This is needed for the first application of the rules (33,a) and (34,a) or
(34,b). After this, enough water is produced, so the antiport rules act exactly
like symport rules in Theorem 3.1.
§6
Concluding Remarks
One can notice that considering EC P systems/automata with a priority
of communication over evolution, the theorems remain valid with the same con-
Minimizing Evolution-Communication P Systems and Automata
13
structions. No results for the case of priority of evolution over communication
was obtained.
The first result obtained in this paper is the universality of (generating
P sRE by) EC P systems with 2 membranes, non-cooperative evolution rules and
symport/antiport of weight 1. The second result is about accepting RE by EC P
automata with 2 membranes, non-cooperative evolution rules with promoters of
weigth 1, symport/antiport of weight 1. The third result is the universality of the
extended model (the environment contains an infinity of objects of a fixed type)
with 2 membranes, binary (i.e., of type a → bc) evolution rules and antiport
rules weight 1 (of type (d, out; e, in)).
Many questions and research topics can be formulated with respect to
EC P systems and EC P automata, for instance, concerning the optimality of
the previous results (in what concerns the number of membranes, the weight of
rules, the use of promoters), further descriptional complexity issues (e.g., the
number of rules in each membrane), determinism, etc. We hope to return to
such topics in a forthcoming work.
References
1)
2)
3)
4)
5)
6)
Cavaliere, M., “Evolution-Communication P Systems,” in Membrane Computing. International Workshop, WMC-CdeA 2002 (Păun, Gh., Rozenberg G.,
Salomaa A., Zandron C., eds.), LNCS 2597, Springer-Verlag, Berlin, pp. 134145, 2003.
Csuhaj-Varjú, E. and Vaszil, G., “P automata or Purely Communicating Accepting P Systems,” in Membrane Computing. International Workshop, WMCCdeA 2002 (Păun, Gh., Rozenberg G., Salomaa A., Zandron C., eds.), LNCS
2597, Springer-Verlag, Berlin, pp. 219-233, 2003.
Dassow, J., Păun, Gh., Regulated Rewriting in Formal Language Theory,
Springer-Verlag, Berlin, Heidelberg, 1989.
Freund, R., Martı́n-Vide, C., Obtulowicz, A. and Păun, Gh., “On Three Classes
of Automata-Like P Systems,” Developments in Language Theory, Szeged, Hungary, 2003.
Freund, R. and Oswald, M., “A Short Note on Analysing P Systems with
Antiport Rules,” Bulletin of the EATCS, 78 (October 2002), pp. 231-236.
Păun, Gh., Membrane Computing. An Introduction, Springer-Verlag, Berlin,
Heidelberg, 2002.