Parallel communicating flip pushdown automata systems communicating by stacks

International Journal of Computer Engineering and Technology (IJCET), ISSN 0976 – 6367(Print),

ISSN 0976 – 6375(Online) Volume 1, Number 1, May - June (2010), © IAEME

34

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

International Journal of Computer Engineering

and Technology (IJCET), ISSN 0976 – 6367(Print)

ISSN 0976 – 6375(Online) Volume 1

Number 1, May - June (2010), pp. 34-45

© IAEME, http://www.iaeme.com/ijcet.html

IJCET

© I A E M E



35

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 2Q

i, 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.



36

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 αR

i ), 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



37

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



38

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).



39

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)}



40

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.



41

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, 1A , A’2, 2A , …, A’n, nA , K’),

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

for all 1 ≤ i ≤ n,

A’1 = (Qi ∪ {q’| q ∈ Qi}, V, Γ ∪ { iK }, 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, iK )},

where q, r ∈ Qi, a ∈ V ∪ {ε}, A ∈ Γ , and

iA = ({i

q }, V, Γ ∪ {Zi, K’1}, if , i

q , iZ {i

q }},

with

(3) if (i

q , a, iZ } = {(i

q , K’1)},

(4) if (i

q , ε, A} = {(i

q , 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 iA 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.



42

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 ∈ Γ .



43

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, 1 2

0, 0,Z Z F) be a two-stack flip pushdown automaton.



44

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, 1

0Z , F)

A3 = (Q ∪ Qc, V, Γ A, f3, q0, 2

0Z , 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.



45

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.

Documents

Parallel communicating flip pushdown automata systems communicating by stacks