Parallel communicating flip pushdown automata systems

International Journal of Computer Engineering (IJCET), ISSN 0976 – 6367(Print),
International Journal of Computer Engineering and Technology
and Technology (IJCET), ISSN 0976 1, May - June (2010), © IAEME
ISSN 0976 – 6375(Online) Volume 1, Number – 6367(Print)
ISSN 0976 – 6375(Online) Volume 1
IJCET
Number 1, May - June (2010), pp. 34-45 ©IAEME
© IAEME, http://www.iaeme.com/ijcet.html

PARALLEL COMMUNICATING FLIP PUSHDOWN
AUTOMATA SYSTEMS COMMUNICATING BY STACKS
M.Ramakrishnan
Research Scholar
Anna University of Technology, Coimbatore
Coimbatore – 641 047

S.Balasubramanian
Research Scholar
Anna University of Technology, Coimbatore
Coimbatore – 641 047

ABSTRACT
In this paper, we introduced parallel communicating flip pushdown automata
communicating by stacks. PCFPA (2) equals the family of recursively enumerable
languages Also we have proved that. RPCFPA (3) equals the family of recursively
enumerable languages.
Key words: Pushdown automata, Flip pushdown automata, finite automata

1. INTRODUCTION
A pushdown automaton is one way finite automaton with a separate
pushdown store, that is first in first – out storage structure, which is manipulating by
pushing and popping. Probably, such machines are best known for capturing the family
of context free languages, which was independently established by Chomsky (Cole
1971). Pushdown automata have been extended in various ways.
The extension of pushdown automata is recently introduced, is called flip
pushdown automata (Border et al 1982). A is an ordinary pushdown with the additional
ability to flip its pushdown push down during the computation. This allows the machine
to push and pop at both ends of the pushdown, therefore, a flip-pushdown is a form of a

34

International Journal of Computer Engineering and Technology (IJCET), ISSN 0976 – 6367(Print),
ISSN 0976 – 6375(Online) Volume 1, Number 1, May - June (2010), © IAEME

dequeue storage structure and it becomes an equally power to Turing machines. A
dequeue automaton com simulate two pushdowns.
DEFINITION 1.1: PARALLEL COMMUNICATING FLIP
PUSHDOWN AUTOMATA
Parallel communicating flip pushdown automata system is of degree n is a
construct
A = (V, Γ , A1, A2,…..,An,K) where V is the input alphabet, Γ is the alphabet
of pushdown symbols, for each 1 ≤ i ≤ n,
Ai = (Qi , V , Γ , fi, ∆ i,qi, Zi, Fi ) where Qi is a finite set of states, Γ i is a finite pushdown
alphabet , fi is a transition mapping from V∪ {ε } × Γ i to finite subsets of Qi × Γ i* is
called transition function , ∆ i is a mapping from Qi to 2Qi, qi ∈ Qi , Zi ∈ Γ i , Fi ⊆ Qi be
the set of final states and K ⊆ {K1, K2,……, Kn } ⊆ Γ is the set of query symbols. The
Flip Pushdown automata A1, A2,…..,An are components of the system A.
If there exists only one component, Ai, 1 ≤ i ≤ n, such that (r, α) ∈ fi (q, a, A)
with α ∈ Γ *, |α|K > 0, for some r, q ∈ Qi, a ∈ V ∪ {∈}, A ∈ Γ , then the system is said
to be centralized and Ai is said to be the master of the system. For the sake of simplicity,
whenever a system is centralized its master is the first component.
A parallel communicating flip pushdown automata system is schematically
represented in Figure 1.1.
As one can see in Figure 1.1, all stacks are connected with each other, each
stack can send its contents to any other stack or receive the contents of any other stack.
In the centralized case all stacks send their contents to a distinguished stack. In the case
of the non-returning strategy, every stack preserves its contents after sending a copy of it
to another component while in the case of the returning strategy the stack returns to its
initial contents after communication.

35


Figure 1.1 parallel communicating flips pushdown automata system
The configuration or instantaneous of a parallel communicating flip pushdown
automata system is defined as a 3n-tuple (s1, x1, α1, s2, x2, α2… sn, xn, αn)
Where for 1 ≤ i ≤ n,
si ∈ Qi is the current state of the component Ai,
xi ∈ V* is the remaining part of the input word which has not yet been read by
Ai, αi ∈ Γ * is the contents of the ith stack, the rightmost symbol being the
topmost symbol on the pushdown store
If a is in V ∪ {∈}, xi ∈ V* , αi , βi ∈ Γ * and Zi is in Γ ,
Then ( si , a xi , αi Zi) ├( pi , xi , αi βi ), if the pair (pi , βi ) is in fi (si , a xi , αi ),
for the ordinary pushdown transitions and ( si , a xi , αi Zi) ├ (pi , xi , Zi αRi ), if pi is in ∆ i (

si ), for the flip pushdown transition or a pushdown reversal transitions. Whenever, there
is a choice between an ordinary pushdown transition or a pushdown reversal of any i,
then the pushdown automaton non-deterministically chooses the next move. We do not

36


want the flip pushdown automaton to move the bottom of pushdown symbol when the
pushdown is flipped.
We define two variants of transition relations on the set of configurations of A in the
following way:
1. (s1, x1, B1α1, ..... s2, xn, Bnαn ) ├ ( p1, y1, β1, …, pn, yn, βn)
Where Bi ∈ Γ , αi, βi ∈ Γ *, 1 ≤ i ≤ n, iff one of the following two conditions holds:
(i) K ∩ {B1, B2, …, Bn} = φ and
xi = aiyi, ai ∈ V ∪ {ε}. {pi, β’i) ∈ fi(si, ai, Bi).
βi = β’iαi, 1 ≤ i ≤ n,
(ii) for all i, 1 ≤ i n such that Bi = Kji and Bji ε Ki βi = Bj αji αi,
for all other r, 1 ≤ r ≤ n, βr = Brαr, and
yt = xt, pt = st, for all t, 1 ≤ t ≤ n.
2. (s1, x1, B1 α1, …., sn, xn, Bn αn) ├ r (p1, y1, β1, ... pn, yn, βn)
Where Bi ∈ Γ , αi, βi ∈ Γ *, 1 ≤ i ≤ n, iff one of the following two conditions holds:
(i) K ∩ {B1, B2, …, Bn} = φ and
xi = aiyi, ai ∈ V ∪ {ε}, {pi, β’i) ∈ fi(si, ai, Bi).
βi = β’iαi, 1 ≤ i ≤ n,
(ii) for all 1 ≤ i ≤ n such that Bi = Kj,, and Bji ∉ K,
for all other r, 1 ≤ r ≤ n, βr = Brαr, and
yt = xt, pt = st, for all t, 1 ≤ t ≤ n.
The two transition relations defined above differ when the topmost symbols of
some stacks are execute a communication step replacing each query symbol with the
requested stack contents of the corresponding component. If the topmost symbol of the
queried stack is also a query symbol, then first this query symbol must be replaced with
the contents of the corresponding stack. The top of each communicated stack must be a
non-query symbol before its contents can be sent to another component. If this condition
cannot be fulfilled, (a circular query appeared), then the work of the automation system is
blocked.
After communication, the stack contents of the sending components remain
the same in the case of relation, whereas it becomes the initial pushdown memory symbol

37


in the case of relation. A parallel communicating flip pushdown automata system whose
computations are based on relation is said to be non-returning; if its computations are
based on relation, it is said to be returning.
The language accepted by a parallel communicating flip automata system A as
above is defined as
Rec(A) = {x ∈ V* | (q1, x, Z1, …, qn, x, Zn) ├* (s1, ε, α1, …, sn, ε, α1, …, sn, ε,
αn), with exactly n pushdown reversals , for any αi∈ Γ * and any si ∈
Fi, 1 ≤ i ≤ n},

Recr(A) = {x ∈ V* | (q1, x, Z1, …, qn, x, Zn) ├ *r (s1, ε, α1, …, sn, ε, α1, …, sn, ε,
αn), with exactly n pushdown reversals , for any αi∈ Γ * and any si ∈
Fi, 1 ≤ i ≤ n},

where ├* and ├ *r , denote the reflexive and transitive closure of ├
and ├ r respectively. In the following we use the notations

rcpcpfa (n) - for returning centralized parallel communicating flip pushdown
automata systems of degree n,

rpcfpa (n) - for returning parallel communicating flip pushdown automata systems
of degree n,

rpcfpa (n) - for centralized parallel communicating flip pushdown automata
systems of degree n,

pcfpa (n) - for parallel communicating flip pushdown automata systems of degree
n.

If x(n) is a type of automata system, then X(n) is the class of languages
accepted by pushdown automata systems of type x(n). For example, RCPCFPA (n) is the
class of languages accepted by automata of type rcpcfpa (n) (returning centralized
parallel communicating flip pushdown automata systems of degree n).

38


The following examples shows to help the better understanding of the notions
defined above.
EXAMPLE1.1
Let us consider the following rpfcpca (4) given by the transition mappings of
its components.
f1(q1, ε, Z1) = {(s1, a)},
f1(s1, ε, Z1) = {(p1, Z1)},
f1(p1, ε, Z1) = {(h1, Z1)},
f1(h1, ε, Z1) = {(r1, Z1), (t1, K3)},
f1(t1, ε, a) = {(s1, a)},
f3(q3, ε, Z3) = {(s3, K1)},
f3(s3, ε, a) = {(p3, K2 a)},
f3(p3, ε, a) = {(h3, a)},
f3(h3, ε, a) = {(q3, a)},
f3(h3, ε, Z3) = {(r3, Z3)},
f3(r3, a, Z3) = {(r3, Z3)},
f2(q2, ε, Z2) = {(s2, K1)},
f2(s2, ε, a) = {(p2, a)},
f2(p2, ε, Z2) = {(h2, Z2)},
f2(p2, ε, Z2) = {(h2, Z2)},
f2(r2, a, Z2) = {(r2, Z2)},
f f4(s4, ε, Z4) = {(h4, Z2)},
4(q4, ε, Z4) = {(s4, Z4)},
f4(h4, ε, Z4) = {(t4, Z4)}, (v4, K3Z4)},
f4(t4, ε, Z4) = {(u4, Z4)},
f4(v4, ε, a) = {(s4, Z4)},
f4(v4, ε, a) = {(p4, a},
f4(p4, a, a = {(p4, ε)},
f4(p4, ε, Z4) = {(r4, Z4)}

39


The final states are F1 = {r1}, F2 = {r2}, F3 = {r3}, F4 = {r4}.
EXAMPLE1.2
A more intricate way of computation can be observed in the following cpcfpa (2).
f1(q1, X, Z1) = {(q1, Z1)}
f1(s1, ε, Z2) = {(p1, ε)}
f1(p1, X, X) = {(p2, ε)}
f1(p2, ε, X) = {(p2, ε)}
f1(p2, ε, Z2) = {(p1, ε)}
f1(p1, ε, Z1) = {(p1, Z1)}
f2(q2, X, Z2) = {(q2, X, Z2)}
f1(q1, c, Z1) = {(s1, K2 Z1)}
f2(s2, X, Y) = {(q2, XY)}
f1(s1, ε, X) = {(s1, K2 X)}
f2(q2, c, X) = {(s2, X)}
f2(s2, ε, X) = {(s2, ε}
f2(s2, ε, Z2) = {(sf, Z2)}
f2(sf, ε, Z2) = {(sf, Z2)}
f2(sf, X, Z2) = {(sf, Z2)}
where X, Y ε {a, b}, and the sets of final states are F1 = {pf}, F2 = {sf}.
LEMMA1.1
1. RCPCFPA(n) ⊆ RPCFPA(n) and
CPCFPA (n) ⊆ PCFPA(n) for all n ≥ 1.
2. X(1) equals the family of context-free languages and
X(n) ⊆ X(n+1) for X ∈ {RCPCFPA, RPCFPA, CPCFPA, PCFPA}, n ≥ 1.
2 COMPUTATIONAL POWER
We start by showing how non-returning parallel communicating pushdown
automata systems can be simulated with returning systems.

40


THEOREM 2.1 PCFPA(n) ⊆ RPCFPA (2n) for all n ≥ 2.
PROOF
Let A = (a, ∆, A1, A2, ..., An, K) be a pcpa(n) with Ai = (Qi, V, ∆, fi, qi, Zi, Fi),
1 ≤ i ≤ n. We construct the rpcpa (2n)
A’ = (V, Γ ’, A’1, A1 , A’2, A 2 , …, A’n, A n , K’),

Where K’ = {K , K , K , ..., K } ∪ K , K , K , ..., Kn}, and
'
1
'
2
'
3
'
n 1 2 3

for all 1 ≤ i ≤ n,

A’1 = (Qi ∪ {q’| q ∈ Qi}, V, Γ ∪ { K i }, f’i, qi, Zi, Fi},
with
(1) f’i (q, a, A) = {(r’, x) | (r, x) ∈ fi(q, a, A)}

(2) f’i (q’, ε, Zi) = {(q, K i )},
where q, r ∈ Qi, a ∈ V ∪ {ε}, A ∈ Γ , and

A i = ({ qi }, V, Γ ∪ {Zi, K’1}, f i , qi , Zi { qi }},

with
(3) f i ( qi , a, Zi } = {( q i , K’1)},

(4) f i ( qi , ε, A} = {( q i , A)},

where a ∈ V ∪ {ε}, A ∈ Γ
As one can easily see, every component of A has a “satellite” component in
A’. Each accepting step in A is simulated by two accepting and two communication
steps in A’ in the following way:
In the first accepting step A’i and A i use the rules (1) and (3), respectively.
Now the stacks of all components A’i have the same contents as the corresponding ones
in A. Moreover, the current states of A’i are copies of the current states of the
corresponding ones in A.

41


THEOREM 2.2
PCFPA (2) equals the family of recursively enumerable languages.
PROOF
Let A = (Q, V, Γ , f, q, B1, B2, F) be a two-stack flip pushdown automaton.
We construct the pcfpa(2)
A = (V, Γ ’, A1, A2, {K1, K2})
with Γ ’ = Γ ∪ {Zi, [q, a, X, Y, α, β]i |q, α, β) ∈ f(r, a, X, Y), q, r, ∈ Q,
a ∈ V ∪ {ε}, X, Y ∈ Γ , 1 ≤ i ≤ 2},
and Ai = {Qi, V, Γ ’, A1, A2, {K1, K2})
with Γ ’ = Γ ∪ {Zi, [q, a, X, Y, α, β]i | (q, α, β) ∈ f(r, a, X, Y),
q, r, ∈ Q,
a ∈ V ∪{ε}, X, Y ∈ Γ , 1 ≤ i ≤ 2},
and Ai = {Qi, V, Γ ’, fi, qi, Zi, F’), 1 ≤ i ≤ 2.
where Qi = {qch, qrec, qw, [q, α], [q, β] | (q, α, β) ∈ f(r, a, X, Y), q, r, ∈ Q,
a ∈ V ∪{ε}, X, Y ∈ Γ } ∪ {〈q, X〉 | q ∈ Q, X ∈ Γ } ∪ {q1, q2}, and
F’ = {qch, qrec | q ∈ F}.
and the transition mappings are defined as follows:
(1) f1(q1, ∈, Z1) = {(qch, B1 Z1)},
f1(q2, ∈, Z2) = {(qrec, B2 Z2)},
This is the initial step in which both components change their states and stack
contents in order to begin the simulation.
(2) f1(qch, a, X) = {〈〈qch, [r, a, X, Y, α, β] 1) | r, α, β) ∈
f(q, a, X, Y),, Y ∈ Γ },
f2(qrec, ∈, X)= {〈〈q, X〉, K1)},
f1(qrec, ε, X = {〈〈q, X〉, K2〉},
f2(qch, a, Y = {〈〈qch, [r, a, X, Y, α, β]2 | (r, α, β) ∈
f(q, a, X, Y), X ∈ ∆},
where a ∈ V ∪ {ε}, X ∈ Γ .

42


The first automaton, being in a state qch, q ∈ Q, reading
a ∈ V ∪ {ε} on its input tape and X from its memory, chooses a possible move of the
two-stack flip pushdown automaton in the same state, reading the same input symbol and
reading X from its first stack. This move is encoded in a flip pushdown memory symbol
and stored in the memory of the first component. The other component, being in state
qrec, q ∈ Q requests the memory contents of the first component without moving its
reading head.
With the second group of transitions of (2) the same process can be done, but
with A2, choosing a possible transition of A to be simulated. In simulation of A1 and A2
take turns in choosing the transitions.
(3) f1 (qch, ε, [r, α, X, Y, α, β]1) = {(rw, α)},
f1(qw, ε, X) = {(qw, X), (qrec, X)},
f2 (q, Y), α, [r, α, X, Y, α, β]1) = {([r, β], ε)},
f2(|q, α], ε, X) = {([q, α], ε)},
f2(|q, α], ε, Z1) = {([qch, α)},
f2 (qch, ε, [r, α, X, Y, α, β]2) = {(rw, β)},
f2(qw, ε, X) = {(qw, X), (qrec, X)},
f1 (〈q, X〉, α, [r, α, X, Y, α, β]2) = {([r, β], ε)},
f1(|q, α], ε, X) = {([q, α], ε)},
f1(|q, α], ε, Z2) = {(qch, α)}
Where q ∈ Q and α ∈ V ∪ {ε}.
as the non-returning variants.
THEOREM 2.3
RPCFPA (3) equals the family of recursively enumerable languages.
PROOF
We first show that for every two-stack flip pushdown automaton.
Construct an rpcfpa system with three components such that the two devices accept
the same language.
Let A = (Q, V, Γ , f, qo, Z1 Z0, F) be a two-stack flip pushdown automaton.
0,
2

43


Let us associate to any transition (r, α, β) ∈ f(q, a, A, B), where
q, r ∈ Q, a ∈ V ∪ {∈}, A, B ∈ Γ , α, β, ∈ Γ * a new symbol
[q, a, A, B, r, α, β] and let us denote the set of these symbols by ∆t.
Moreover, let Q’ = {q’ q ∈ Q} and Qc = {〈q, x, X〉 | q ∈ Q,
x ∈ V ∪ {ε}, X ∈ Γ }.
The simulating rpcfpa A is constructed as follows:
A = (V, Γ , A, A1, A2, A3, {K1}),
Where A = {Z1, Z2, Z3,} ∪ Γ ∪ Γ t, and
A1 = (Q ∪ Q’, V, Γ A, f1, q0, Z1, F)
A2 = (Q ∪ Qc, V, Γ A, f2, q0, Z1 , F)
0

2
A3 = (Q ∪ Qc, V, Γ A, f3, q0, Z0 , F).

We define the transition mappings of the components as follows:
(1) f1(q, a, Z1) = {(r’, [q, a, A, B, r, α, β]) |
[q, a, A, B, r, α, β] ∈ Γ t},
f2(q, a, A) = {(〈q, a, A〉, K1)},
f3(q, a, B) = {(〈q, a, B〉, K1)},
where q ∈ Q, a ∈ V ∪ {ε}, A, B ∈ Γ ,
(2) f1(r’, ε, Z1)= (r, Z1),
f2(〈q, a, A), ε, [q, a, A, B, r, α, β]) = (r, α),
f3(〈q, a, B), ε, [q, a, A, B, r, α, β]) = (r, β),
where r’ ∈ Q’, [q, a, A, B, r, α, β] ∈ Γ t.
3. CONCLUSION
We define a property called communication parallel communicating flip
pushdown automata. Flip pushdown automata are pushdown with the additional ability to
flip or reverse its pushdown. We have proved that RPCFPA equals the family of
recursively enumerable languages.

44


REFERERENCES:
1. Martin-Vide, C., Mateescu, A. and Mitrana, V. (2002), Parallel finite automata
Systems communicating by states, International Journal of the Foundations of
Computing Science 13 (5),pp. 733-749.
2. A.O.Budo , “ Multiprocessor automata ” ,Infor.Process.Lett.25(1977) 257-261.
3. Elena Czeizler and Eugen Czeizler (2006), ‘Parallel Communicating Watson-
Crick Automat Systems, Acta Cybernetica 17 ,685-700.
4. Csuhaj – Varju, E. and Dassow, J. (1990), On cooperating / distributed grammar
systerms, Journal of Information processing and Cybernetics 26, 49-63.
5. Markus Holzer(2003), ‘Flip pushdown automata: Nondeterminism is better than
Determinism, FIG Research Report.

45

Parallel communicating flip pushdown automata systems

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (9)

Similar to Parallel communicating flip pushdown automata systems

Similar to Parallel communicating flip pushdown automata systems (20)

More from iaemedu

More from iaemedu (20)

Parallel communicating flip pushdown automata systems