THEORY OF COMPUTATION

Dr.S.Prince Mary M.E.,Ph.D., Associate Professor,

Department of Computer Science and Engineering,
School of Computing

SATHYABAMA
Institute of Science and Technology
Deemed to be University
Chennai.

December 20, 2024 School of Computing 1

 UNIT- III
PUSH DOWN AUTOMATA
 Syllabus
• Pushdown automata
• Introduction
• Definition
• Deterministic pushdown automata
• PDA corresponding to a given context-free
grammar
• Context-free Grammar corresponding to PDA
• Pumping lemma for CFG
 Introduction
• Pushdown automata is a way to implement a CFG in
the same way we design DFA for a regular grammar.
• Drawback of FA:
– can remember a finite amount of information
– No Memory used in FA
Advantages of PDA:
• PDA can remember an infinite amount of information.
• Memory used – Stack
• A PDA is more powerful than FA
• Any language which can be acceptable by FA can also
be acceptable by PDA.
• PDA also accepts a class of language which even
cannot be accepted by FA
PDA
 Formal definition of PDA
• The PDA can be defined as a collection of 7 tuples:
M=( Q, ∑, Γ, q0, Z, F, δ )
Q: the finite set of states
∑: the input set
Γ: a stack symbol which can be pushed and popped from the
stack
q0: the initial state
Z: a start symbol which is in Γ.
F: a set of final states
δ: Transition function which is used for moving from current
state to next state.
δ: Q x {Σ ∪ ε} x Γ -> Q x Γ*
Ex: δ(q,a,x)=(p,α)
from state ‘q’ with a input ‘a’, with stack symbol ‘x’,
goto state ‘p’, x is replaced by string ‘α’.
 Instantaneous Description (ID)
• An instantaneous description is a triple ID
(q, w, α)
where:
– q describes the current state.
– w describes the remaining input.
– α describes the stack contents, top at the left.
Example Derivation: (p, b, T) ⊢ (q, w, α)
 PDA- Construction
1.Design a PDA for accepting a language {a nbn | n>=1}.
Solution:
In this language, n number of a's should be followed by n
number of b’s.
Logic:
• If we read single 'a', we will push a onto the stack.
• As soon as we read 'b' then for every single 'b' only
one 'a' should get popped from the stack.
Define the states:
q0 – push all a’s on to the stack.
q1 – when a ‘b’ encounters, pop ‘a’ from stack.
q2 – accepting state.
• The State Diagram can be constructed as follows:
• Push Operation:
– δ(q0, a, Z) = (q0, aZ)
– δ(q0, a, a) = (q0, aa)
• Pop Operation:
– δ(q0, b, a) = (q1, ε)
– δ(q1, b, a) = (q1, ε)
• Accept
– δ(q1, ε, Z) = (q2, Z) State Diagram
Transition Table
 ID

Derive -aaabbb
δ(q0, aaabbb, Z) ⊢ δ(q0, aabbb, aZ)
⊢ δ(q0, abbb, aaZ)
⊢ δ(q0, bbb, aaaZ)
⊢ δ(q1, bb, aaZ)
⊢ δ(q1, b, aZ)
⊢ δ(q1, ε, Z)
⊢ δ(q2, ε)
 Trace the moves: a3b3 aaabbb

Move No. Resulting state Input Stack

- q0 aabb Z0

1 q0 abb aZ

2 q0 bb aaZ

3 q1 b aZ

4 q1 ε Z

5 q2 ε Z
2. Design PDA to accept L={xCxr / x = {a, b}*}
Solution:
Some string will come followed by one 'c',
followed by reverse of the string before 'c'.
Logic:
– For every a's and b's push them into STACK
– When 'c' comes do nothing.
– Start popping STACK: 'a' for 'a' and 'b' for 'b'.
• State Diagram:

• Transition Fuction:
δ(q0, a, Z) = (q0, aZ)
δ(q0, a, a) = (q0, aa)
δ(q0, b, Z) = (q0, bZ)
δ(q0, b, b) = (q0, bb)
δ(q0, a, b) = (q0, ab)
δ(q0, b, a) = (q0, ba)
// this is decision step
δ(q0, c, a) = (q1, a)
δ(q0, c, b) = (q1, b)
δ(q1, b, b) = (q1, ε)
δ(q1, a, a) = (q1, ε)
δ(q1, ε, Z) = (qf, Z)
 ID

Derive : abCba
δ(q0, abCba, Z) ⊢ δ(q0, bCba, aZ)
⊢ δ(q0, Cba, baZ)
⊢ δ(q1, ba, baZ)
⊢ δ(q1, a, aZ)
⊢ δ(q1, ε, Z)
⊢ δ(qf, ε)
Accept
 ID

Derive : baCba
δ(q0, baCba, Z) ⊢ δ(q0, aCba, bZ)
⊢ δ(q0, Cba, abZ)
⊢ δ(q1, ba, abZ)
⊢Reject
 Trace the moves: abCba

Move No. Resulting state Input Stack

- q0 abCba Z

1 q0 bCba aZ

2 q0 Cba baZ

3 q1 ba baZ

4 q1 a aZ

5 q1 Null Z

6 q2 Null Z (Accepted)
3. Consider the CFG: S->[S] | {S} | ꓥ Generate the CFL
and PDA
w={ꓥ,[],{},{[]},{{}},[[]], [{}],…..}
Language: Balanced Parentheses
Solution:
Open parentheses followed by symbol ‘S’ and then closed
parentheses.
Define the states:
q0 – push all Open parentheses on to the stack.
q1 – when a close parentheses , pop open parentheses from
stack.
q2 – accepting state.
Transition Diagram
Transition Table
 Trace the moves: {[{}]}
Move No. Resulting state Input Stack
- q0 {[{}]} Z0

2 q0 [{}]} {z0

4 q0 {}]} [{z0

6 q0 }]} {[{z0

7 q1 ]} [{z0

10 q1 } {z0

9 q1 Ʌ Z0

11 q2 Ʌ Z0

Accept
Trace the Moves: {[{]
 PDA Acceptance
1. Acceptance by Final State:
– Let P =(Q, ∑, Γ, δ, q0, Z, F) be a PDA. The language
acceptable by the final state can be defined as:
– L(PDA) = {w | (q0, w, Z) ⊢* (p, ε, Z ), p ∈ F}
2. Acceptance by Empty Stack:
– Let P =(Q, ∑, Γ, δ, q0, Z, F) be a PDA. The language
acceptable by empty stack can be defined as:
– N(PDA) = {w | (q0, w, Z) ⊢* (p, ε, ε), p ∈ F}
3. Language Acceptance:
– A language L ⊆ ∑* is said to be accepted by M, if L is
precisely the set of string accepted by M.
L=L(M)
 PDA Corresponding to CFG
Parsing:
– To derive a string using the production rules for a grammar.
– It is used to check whether or not a string is syntactically
correct.
– Parser takes the inputs and builds a parse tree.
Two types of parser:
• Top down Parser- Parsing starts from the top with the
start symbol and derives a string using a parse tree.
• Bottom up parser- Starts from the bottom with the
string and comes to the start symbol using a parse
tree.
 Design of Top down parser:

• Push the start symbol onto the stack.

• If the top of the stack contains a NT, pop it out
of the stack and push its right hand side of the
production.
• If the top of the stack matches with input
symbol being read, pop it.
• If the input string is fully read and the stack is
empty go to final state.
 Top Down Parsing
• Left Most Derivation is used
Input − CFG, G = (V, T, P, S)
Output − Equivalent PDA, P = (Q, ∑, S, δ, q0, I, F)
Step 1−The start symbol of CFG is the start
symbol in the PDA.
Step 2 − All non-terminals of the CFG will be the
stack symbols of the PDA and all the terminals of
the CFG will be the input symbols of the PDA.
Step 3 − For each production in the form A → aX
make a transition δ (q, a, A).
1. Construct PDA corresponding the given
Grammar
L={ x ∈ {a,b}* / Na (x) > Nb(x) }
P: S->a/aS/bSS/SSb /SbS
State Diagram:
Transition Table:
 ID

• Derive: abaa
• δ(q0, abaa, Z) ⊢δ(q1, abaa, SZ)
⊢ δ(q1, abaa, SbSZ)
⊢ δ(q1, abaa, abSZ)
⊢ δ(q1, baa, bSZ) LMD
⊢ δ(q1, aa, SZ)
S=>SbS
⊢ δ(q1, aa, aSZ) =>abS S->a
⊢ δ(q1, a, SZ) =>abaS S->as
=>abaa S->a
⊢ δ(q1, a, aZ)
⊢ δ(q1, ε, Z)
⊢ q2 (Accept)
 Problem 2:

P: S->S+X | X
X->X*X | Y
Y->(S) | id
String: id+id*id
• State Diagram:
Transition Table:
 ID
Example: id*id+id
S=>S+X S->S+X
=>X+X S->X
=>X*X+X X->X*X
=>Y*X+X X->Y
=>id*X+X Y->id
=>id*Y+X X->Y
=>id*id+X Y->id
=>id*id+Y X->Y
=>id*id+id Y->id
 Bottom Up Parsing
• Right Most Derivation in reverse is used.
• Steps:
– Push the current input symbol into the stack.
– Replace the right-hand side of a production at the
top of the stack with its left-hand side.
– If the top of the stack element matches with the
current input symbol, pop it.
– If the input string is fully read and only if the start
symbol ‘S’ remains in the stack, pop it and go to
the final state ‘F’.
• Example
P: S->S+T
S->T
T->T*a
T->a
String: a+a*a RMD in Reverse

Right Most Derivation: a+a*a [T->a]

T+a*a [S->T]
S=>S+T S+a*a [T->a]
S+T*a [T->T*a]
=>S+T*a [T->T*a] S
=>S+a*a [T->a]
=>T+a*a [S->T]
=>a+a*a [T->a]
 Parsing- a+a*a

STACK INPUT ACTION

Z a+a*a -
Za +a*a Shift a
ZT +a*a Reduce [T->a]
ZS +a*a Reduce [S->T]
Z S+ a*a Shift +
Z S+a *a Reduce [t->a]
Z S+T *a Shift *
Z S+T * a Shift a
Z S +T *a ε Reduce [ T->T*a]
Z S +T ε Reduce [ S-> S+T]
ZS ε Accept
 Types of PDA
• Non- Deterministic PDA
• Deterministic PDA
NPDA
NPDA :L={w ∈ {a,b}* | Na(w)>Nb(w)}
DPDA
DPDA L={w ∈ {a,b}* | Na(w)>Nb(w)}
State Diagram
 ID

δ(q0, aba, Z) ⊢ δ(q1,ba, Z )

⊢ δ( q0,a,Z )
⊢ δ(q1,null,Z)
q2
accept
 PUMPING LEMMA FOR CFL:

• Pumping Lemma is used to prove that a language is

not CFL.
• It should never be used to show a language is regular.
• For any language L, we break its strings into five
parts and pump second and fourth substring.
• Let ‘L’ be any CFL. Then there is a constant ‘n’
depending on L, such that if ‘Z’ is in L and |z|>=n,
then we may write,
Z=uvwxy
uviwxiy ↋ L, For all i>0,
|vx|>=1
|vwx|<=n
 Procedure:

• Assume that L is context free.

• It has to have a pumping length(say n)
• Find a string ‘z’ in L such that |z]>=n.
• Divide z into uvwxy.
• Show that uviwxiy∉ L
 Problem 1:

• L={anbncn, n>=0} is not a CFL.

Solution:
• Assume ‘L’ is a CFL.
Let ‘n’ be a natural number obtained by using pumping
lemma.
Let z=anbncn |z|=n+n+n=3n
• Split z into uvwxy such that |vx|>=1, |vwx|<=n
Assume z=an-iaibn-j-kbjbkcn
u=an-i v=ai w=bn-j-k x=bj y=bkcn
• For i=2
=>uv2wx2y =>an-iaiaibn-j-kbjbjbkcn
=>an+ibn+jcn∉L
• Eg) n=4
Z=a4b4c4=>aaaabbbbcccc
u=av=aaw=abbbbcx=cy=cc
Let i=2
uviwxiy =>uv2wx2y=>aaaaaabbbbccccc=>a6b4c5∉L
Therefore the given language is not CFL.
 Problem 2:

L={0p|p is prime is not CFL.

Solution:
• Assume ‘L’ is a CFL.
• Let ‘n’ be a natural number obtained by using pumping lemma.
• Let P be a prime no. such that p>=n
Z=0pϵ L |z|=p>=n
• Split z into uvwxy such that |vx|>=1, |vwx|<=n
Let v=0k x=0l such that k+l>=1 and <=n
Hence |uwy|=p-k-l
If we pump v and x p+1 times
|uvwxy|=|uwy|+|v(p+1).x(p+1)|
=p-k-l+k(p+1)+l(p+1)
=p-k-l+pk+k+pl+l
=p+pk+pl
=p(k+l+1)
Which is not prime.