Chapter 5

Push Down Automata

Sub chapters:

❖ Non-deterministic push down automata

❖ Language accepted by NPDA

❖ Deterministic push down automata(DPDA)

As we have seen, finite automaton cannot recognize all context-free languages. It is because
they have finite memories, where as the recognition of a context free language may require
storing an unbounded amount of information. For example, L={a nbn:n>=0}, since n is
unbounded, this counting cannot be done by finite memory. We want a machine that can
count without a limit. Another example where {ww R} , we need the ability to store and match
a sequence of symbols in reverse order. This suggests that we might try a stack as storage
mechanism, allowing unbounded storage that is restricted to operating like a stack. This gives
us a class of mechanism called pushdown automata or (PDA).

The stack is infinite in size, so can be used as a “memory” to eliminate the weakness of
“finite states” of NFA’s, which cannot accept languages like L = {anbn | n > 1}.

Non deterministic pushdown automata:

Each move of a PDA depends on the current state, input symbol, and top of stack symbol.
Each move consists of change of state and replacing top of stack symbol by a string of stack
symbols. A pushdown automata can accept its input in two ways - either by entering into an
accepting state or when the stack is empty.

1 | Page
A non deterministic pushdown accepter (npda)

Input file or tape

By default a PDA is non deterministic.

M=(Q,I, r, 5, q0,z0,F)

Where

Q is a finite set of internal states of the control unit X is the input alphabet
r is the finite set of symbols called the stack alphabet

5: (Q x (XU{e}) x r)-^ p (Q X r*) finite subsets of Q x r * is the transition

function.

qo c Q is the initial state of the control unit z c r* is the stack start symbol F c Q

is the set of final state

2 | Page
Instantaneous Description: During execution, a PDA goes through a sequence of
configuration. Each configuration, called instantaneous description (ID) consists of 1.
Current state 2. Input yet to be scanned, 3. Stack content and is represented by a triplet (q,x,y)
where q is the current state, x is the input yet to be read(leftmost symbol of x is the current
input) and y is the stack content (leftmost symbol of y is the current top-of-stock symbol, i.e.
current stack contents as a string from top to bottom of stack ).
Move

Each move involves a change from one ID to another. The symbol |-- is used to represent a
move.

represents a sequence of moves.

Languages accepted by a PDA:

PDA can accept a string in two ways-

1. By an accepting state

2. by empty stack

Acceptance by final state *

An input w is said to be accepted by final state iff(qO,w,zO) |— (p,D,D) for some p in F.

(when the input is completely read, PDA is in an accepting state. Do not care about the
stack content)
Languages accepted by PDA M by final state L(M) is defined as:

L(M)= {w| (q0, w, z0)|--(p,e,y) for some p in F)

Acceptance by empty stack: *

An input w is said to be accepted by a PDA by empty stack iff(q0,w,z0)|--(q,s.s)}

(when the input is completely read, the stack is empty. We do not care about the state at
the end of execution).

3 | Page
Languages accepted by a PDA M by empty stack N(M) is defined as:

N(M)= {w|(q0, w,z0) |-- (q, s,s)}

When we design a PDA to recognize a specific language L, we have to

specify the model of acceptance. But both models are equivalent in
their power.

Example 1: As an example, we describe a push-down automata to recognize the

language L={anbn|n>=1}, For this PDA M,

Q={q0,q1,q2}

□ □{a,b}

□ □{z,A}
The arguments of the □ Dare the current state of the control unit, a current input
symbol, and the current symbol on top of the stack.

Let us see the computation on the string : aaabbb

q0 is the start state,

Z is the initial stack symbol F={q2} q2 is the

accepting state.

(q0,aaabbb,z) |-- (q0,aabbb,Az)

|-- (q0,abbb,AAz)

|— (q0,bbb,AAAz)

|- (q1,bb,AAz)

|-- (q1,b,Az)
I-- (ql,D,z)

|— (q2, □, □) Accepts the string.

4 | Page
Explanation: In state q0, PDA reads a’s and pushes A for each a. on reading b, it pops
one A and goes to state q1. In q1, it reads b’s and pops off one A for each b. At the end,
M goes to the accepting state q2 if all A’s are popped off (i.e number of b’s=number of
a’s). PDA halts in q2.

Another computation for a2b2 or w=aabb

□ □q0,a,z)={(q0,Az)}

□ Dq0,a,A)={(q0,AA)}

□ □qO,b,A)={(ql,D)}

□ □ql,b,A)={(ql,Q)}

□ □ ql, □ ,z)={(q2, □)}

Alternative notations for description of PDA: Transition Table:

It has a row for each pair of state and top of stack symbol and a column for each input. For
example, PDA for the above example is given as a transition table below.

state TOS symbol A b □

q0
Z (q0,Az) - -
A (q0,AA) (qi,nn -

q1
A (qi,nn --
Z (q2,DD

q2 No next move

5 | Page
Transition diagram: b,A/s

a,z/Az

Construct a PDA to recognize L={aibj|i<j and i,j>=1}

To solve the problem, we have to keep track of number of a’s and see that
number of b’s are in excess. In the start state q0, PDA pushes the stack symbol
A for each a. On encountering b, PDA changes to q2. In q2, PDA pops off A
for each B. when all A’s are popped off, if there is an input b, PDA goes to the
accepting state q2. It skips further b’s. Formally

M=({q0,ql,q2}, {a,b},{A,Z},D DqO,Z,{q2})

Where □ Ois defined below.

□ Dq0,a,Z)={(q0,AZ)}

□ Dq0,a,A)={(q0,AA)}

□ □qO,b,A)={(ql,Q)}

□ □ql,b,A)={(ql,D)}

□ □q1,b,Z)={(q2,Z)}

□ Dq2,b,Z)={(q2,Z)} q2 is the accepting

state.
Computation of aabbb is shown below

6 | Page
(q0,aabbb,z) |- (q0,abbb,Az)

|- (q0,bbb,AAz)

h (q1, bb,Az)

h (q1,b,z)

h (q2 ,D,z) accepted

Construct a PDA to recognize L={wcwR |w c {0,1}* and wR is reverse of w.

The central idea is to remember the pattern of w in stack and match the right
portion with the pattern already stored. For this purpose, we use two stack
symbols B and G to represent 0 and 1 respectively. In state q1, PDA pushes B
for 0 and G for 1. On scanning c, PDA go to state q2. It can be observed that
after scanning the left portion w, stack content from top to bottom is the
reverse of w. Also, top of stack symbol corresponds to the input to be
matched. In state q2, PDA matches and pops-off B for the input 0 and G for
input 1. At the end, if the input is correct, reverse of left portion (w R) matches
with the input and initial stack symbol R is exposed. Then, PDA empty the
initial stack symbol R to epsilon. If there is a mismatch the PDA halts. A
formal description is given below.

=q q
Q { 1, 2}

Z={0,1,c>

□ □□R,B,GD

7 | Page
M=(Q,X,D □ □ □ □ □ OqO, z,0 □ □ acceptance by empty stack

q1 is the initial state R is the initial stack symbol

□ □q1,0,R)={(q1,BR)}

□ □q1,1,R)={(q1,GR)}

□ □ q1,c,R)={(q2,R)}

□ □q1,0,B)={(q1,BB)}

□ □q1,1,B)={(q1,GB)}

□ □q1,c,B)={(q2,B)}

□ □q1,0,G)={(q1,BG)}

□ □q1,1,G)={(q1,GG)}

□ □q1,c,G)={(q2,G)}

□ □ q2,0,B)={(q2, □)}

□ □q2,l,G)={(q2,D)}

□ □ q2, □ ,R)={(q2, □)}

Let us see the transition table for the above. Computation of strings 011c110.

TOS symbol 0 1 c

state
R (q1,BR) (q1,GR) (q2,R)

B (q1,BB) (q1,GB) (q2,B)

q1 G (q1,BG) (q1,GG) (q2,G)

8 | Page
 B (q2, □)

G
q2 (q2, □) --

R PDA accepts the string by empty stack(q2, □ □ □

Let L = {anbncmdm\n, m > 1}. Find a PDA that accepts L.

M = ({qo, q\, q2, q3, q\}, {a, b, c, d}, {a, c, $}, d, qo, $, {q4})

Transitions are:

S(qo, a, $) contains (q0, a$)

5(q0, a, a) contains (q0, aa)

5(q0, b, a) contains (q1, e)

S(q1, b, a) contains (q1, e)

S(q1, c, $) contains (q2, c$)

S(q2, c, c) contains (q2, cc)

S(q2, d, c) contains (q3, e)

S(q3, d, c) contains (q3, e)

S(q3, e, $) contains (q4, e)

This machine accepts L by empty stack. Taking q 4 as the final state L is accepted by
final state also.
Another example:

- we may replace the top symbol of the stack by any string —

♦ By a single symbol

9 \ Page
 ♦ By a string of symbols

♦ By the empty string epsilon which means the top stack symbol is
“popped up (eliminated).”

Equivalence of two models—Acceptance by empty stack and acceptance by final state.

With respect to push down automata, we had defined two models of acceptance. Depending
on specific situation, one model is more convenient than the other. It can, however, be shown
that both models are equivalent in power. For every language accepted by PDA by empty
stack, there is a PDA which accepts it by final state and vice-versa. Let us prove this: For
every PDA M1, there is a PDA M2 such that N(M1)=L(M2)

Acceptance by Final State:

If P = (Q, I, T, 8, q0, Z0, is a PDA.

Then
L(P), the language accepted by P by
final state, is
{w | (q0, w, Z0) £ (q, s, a), qeF]
10 | Page

for any a.
In the above example the language accepted by P is the set of all strings that can put M
into a final state at the end of the string. The final stack content □ is irrelevant to this
definition of acceptance.
Acceptance by Empty Stack:

If P = ( Q,S, r, 8 q0, Z0, is a PDA. Then

N(P). the language accepted by P by empty
stack, is
{w I (<7o> zo) f- (?, s, s)}
P

for any q.

Deterministic push down automata: A deterministic pushdown accepter (dpda) is a

pushdown automata that never has a choice in its move.

A pushdown automaton M=(Q,£D □ □ □ □ □ Dqo,z,F) is said to be deterministic subject to

the following restrictions.

A pushdown automata is deterministic in nature 1. if D(q,a,b) contains at most one element.

2 If D(q ,D,b) is not empty, then D(q,c,b) must be empty for every cD □ □ □
The first condition requires that for any given input symbol and any stack top, at most
one move can be made.

The second condition is that when a □ Dmove is possible, no input consuming

alternative is available.
Let us see one example below for the deterministic PDA

11 | Page
 The language L={anbn : n>=0}

Is a deterministic context-free language. The Push down automata

M=({q0,ql,q2},{a,b},{0,l}* □ □q0,0,{q0}) with

□(q0,a,0) ={(q1,10)}

□ (q1,a,1) ={(q1,11)}

□ (ql,b,l)={(q2,D)}

□ (q2,b,l)={(q2,D)}

□(q2,D,0) ={(qO,D)}

Accepts the given language.

12 | Page