Scribd
Upload
85 views35 pages

CS5371 Theory of Computation: Lecture 8: Automata Theory VI (Pda, Pda CFG)

The document describes automata theory and pushdown automata (PDA). It begins by stating the objectives of discussing PDA and showing that PDA are equivalent to context-free grammars (CFG). It then introduces PDA by comparing them to non-deterministic finite automata (NFA) with an unlimited size stack. Several examples of PDA are provided, including their formal definition and conditions for accepting strings. The document proves that any language generated by a CFG can be recognized by a PDA and vice versa by constructing equivalent PDA and CFG.

Uploaded by

Kamal Walia
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
85 views35 pages

CS5371 Theory of Computation: Lecture 8: Automata Theory VI (Pda, Pda CFG)

The document describes automata theory and pushdown automata (PDA). It begins by stating the objectives of discussing PDA and showing that PDA are equivalent to context-free grammars (CFG). It then introduces PDA by comparing them to non-deterministic finite automata (NFA) with an unlimited size stack. Several examples of PDA are provided, including their formal definition and conditions for accepting strings. The document proves that any language generated by a CFG can be recognized by a PDA and vice versa by constructing equivalent PDA and CFG.

Uploaded by

Kamal Walia
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 35

CS5371

Theory of Computation
Lecture 8: Automata Theory VI
(PDA, PDA = CFG)
Objectives
•Introduce Pushdown Automaton (PDA)
•Show that PDA = CFG
–In terms of descriptive power
Pushdown Automaton (PDA)
•Roughly speaking, PDA = NFA + stack with
unlimited size
•How does a PDA operate?
•In each step, it can read a character from
the input string, can pop (remove) a
symbol from the stack
•Then, depending on the character and the
symbol, the PDA enters another state and
can push (place) a symbol to the stack

A stack is a “
last in, first out”storage device
Stack is powerful
•Recall that an NFA cannot recognize the
language {0n1n | n 0}
•However, a PDA can do so (informally):
–Read the characters from input
–For any 0 it reads, push it onto the stack
–As soon as 1s are seen**, pop a 0 off the stack for
each 1 read
** after this point, if we read a 0 again, we
reject the string immediately
- Accept the string if the stack is just empty after
the last 1 is read; Reject the string otherwise
PDA (Example)
•The following state diagram gives the
PDA that recognizes {0n1n | n 0}.
,  $
 0,  0

1, 0  
1, 0  
,$

The notation a, b  c means that the machine reads a


from input, replace b by c from the top of stack. That
is, pop b then push c.
PDA (Formal Definition)
•A PDA is a 6-tuple (Q, , , 
, q0, F)
–Q is a finite set of states
–is a finite set of characters
–is a finite set of stack symbols
–is the transition function of the form:
: Q x ’ x ’  2Q x ’
,
where ’ = [ { } and ’= [ {}
–q0 is the start state
–F is the set of accept states
Acceptance by PDA
•A PDA M = (Q, , , 
, q0, F) accepts the
input string w if
–w can be written as w1 w2…wm where wi in ’,
–there exist states r0, r1, …, rm in Q, and
–there exist strings s0, s1, …, sm in *
satisfying the following three conditions:
(see next slide)
Intuitively, ri denotes the sequence of states visited by
the PDA, and si denotes the corresponding contents in
the stack (reading from top to bottom)
Acceptance by PDA (cont.)
•Condition 1: r0 = q0, s0 = 
This ensures that PDA starts at q0, with an empty stack
•Condition 2: For i = 0, 1, …, m-1, we have
(ri+1, b) 2 
(ri, wi+1, a),
where si = at, si+1 = bt for some a, b in ’
This ensures that PDA moves properly according to the
state, the input character, and the stack

•Condition 3: rm 2 F
This ensures PDA accepts only when the PDA is in an
accept state after processing the whole input string
PDA (example 1)
•Recall that the following PDA
recognizes {0n1n | n 0}
,  $
 0,  0

1, 0  
1, 0  
,$

PDA (example 1)
Some points to notice:
–The formal definition of PDA does not allow us to
test if the stack is empty
–The previous PDA tries to get the same effect by
first placing $ to the stack, so that if it ever sees
$ again, it knows the stack is empty
–Similarly, PDA cannot test if the input has all
been processed
–The previous PDA can have the same effect
because it can stay at the accept states only at
the end of the input
PDA (example 1)
•We can also write the formal definition of
the previous PDA, call it M, as follows:
M = ({q1,q2,q3,q4}, {0,1}, {0,$}, 
, q1, {q1,q4}),
where is given by
(q1, 
 , ) = { (q2, $) }, 
(q2, 0,  ) = { (q2, 0) }
(q2, 1, 0) = { (q3, 
 ) }, (q3, 1, 0) = { (q3, )}
(q3, 
 , $) = { (q4, ) },
and for the remaining combinations of (q, x, y),
 (q, x, y) = { }
PDA (example 2)
Give a PDA that recognizing the language
{ aibjck | i,j,k 0 and i=j or i=k }
How to construct it?
•First, for each ‘ a’read, we should push it
onto the stack (for later matching)
•Then, we guess whether ‘ a’should be
matched with ‘ b’or matched with ‘ c’

We can guess because of the non-deterministic


nature of PDA
PDA (example 2)
b, a   c,  

,$


,  
,  $


,   
,   ,$

a,  a b,   c, a  
PDA (example 3)
Give a PDA recognizing { wwR | w in {0,1}* }
How to construct it?
•First, the PDA should match the first
character with the last character, the second
character with the second last character, and
so on…So, we push each character that is read
to the stack in case it will be matched later
•At each point, we guess the middle of the
string has been reached. We match the
remaining characters with those stored in the
stack (how?)
CFG = PDA
Theorem: (1) If a language is generated by a
CFG, it can be recognized by some PDA. (2)
If a language is recognized by a PDA, it can
be generated by some CFG.

Proof: We shall prove both statements by


construction.
Proof of (1)
(1) If a language is generated by a CFG, it
can be recognized by some PDA.

•Let L be a language generated by a CFG G.


We show how to convert G into an
equivalent PDA.
•Our PDA will do the following:
–For an input string w, it can determine whether
there is a derivation for w by G

Recall that a derivation for w = a sequence of


substitutions in the grammar that generates w
Proof of (1)
•The difficulty in testing whether
there is a derivation for w is to
figure out which substitutions to
make
–PDA can do so by guessing the sequence
of correct substitutions
Proof of (1)
•Informally, our PDA does the following:
–Place the mark symbol $ and then the
start variable S (of G) on the stack
–Repeat
•If the top of stack is a variable, say A, guess a
rule A  u and substitute A by the string u
•If the top of stack is a terminal, say a, read
the next symbol from the input and compare it
with a. If they match, repeat. Otherwise,
reject this branch of non-determinism
•If the top of stack is $, enter the accept
state
An Example Run
Input: 1100
CFG: S  SS | 1S0 | 10

1100 1100 1 100


S S
Next char S Next char 0 Next char 0
$ $ $
At the beginning PDA uses the rule Input char is
S  1S0 matched
An Example Run (cont.)
Input: 1100
CFG: S  SS | 1S0 | 10

100 1 00 0
0 0
Next char 0 Next char 0 Next char 0
$ $ $
PDA uses the rule Input char is Input char is
S  10 matched matched
An Example Run (cont.)
Input: 1100
CFG: S  SS | 1S0 | 10

Next char Next char


$
Whole input string The $ in the top of stack tells
is processed PDA the stack is empty. PDA
accepts the string
Another Example Run
Input: 1100
CFG: S  SS | 1S0 | 10

1100 1100 100


1
Next char S Next char 0 Next char 0
$ $ $
At the beginning PDA uses the rule Input char is
S  10 matched
Another Example Run (cont.)
Input: 1100
CFG: S  SS | 1S0 | 10

100 Input char cannot match


top of stack. What will
PDA do?

Next char 0 It stops exploring this


branch of computation
$
Implementation Details
•We can see that, an input string w is
accepted by our PDA if and only if there is
a derivation from S to w
•What remains is to show that such a PDA
can be constructed
•Pushing $, pushing S, or matching input
chars with terminals in the stack is easy
•Difficulty: How to replace a variable in the
top of stack by right side of a
corresponding rule? (E.g., top of stack is A
and we have with a rule A  xyz. How to
replace A by xyz?) By using dummy states
Using dummy states

,Az

,  y
 , A  xyz

,  x

Using two dummy states to A shorthand notation


replace A by xyz at the top
of the stack
PDA for Proof of (1)
start shorthand notation used here

,  S$

, A  xyz for rule A  xyz


a, a   for terminal a

, $ 

Example of Conversion
•Convert the following CFG into an
equivalent PDA

S  aTb | b
T  Ta | 
Proof of (2)
(2) If a language is recognized by a PDA,
it can be generated by some CFG.

• We show how to convert a PDA into an


equivalent CFG.
• Let L be the language, and P be the PDA
recognizing L.
Proof of (2)
•We first change P slightly so that: first and
second
–It has a single accept state, qaccept changes
–It empties the stack before accept are easy

–Each transition either pushes a symbol on


the stack, or pops a symbol off the stack,
but not both
For the third change, we replace each transition in P that
(i) pushes and pops at the same time with a two transition
sequence that goes through a new state,
(ii) neither pushes or pops with a two-transition sequence
that pushes then pops a dummy stack symbol
Proof of (2)
•Next, for each pair of states p, q in P,
we create a CFG variable Apq
•Our target is to make Apq generate
exactly those strings that can bring P
from p with an empty stack to q with
an empty stack

•How to do so?
Creating Apq
•Note that PDA can get from p (with an
empty stack) to q (with an empty stack) in
two ways:
(1) The stack gets empty before reaching q
–This implies we get from p to some r (with
empty stack) and then to q
(2) The stack never gets empty before
reaching q
–This implies at p, we push some char t in stack,
and then at q, we pop the same char t
Creating Apq (cont.)
•For each p, q, r, add the rule
Apq  AprArq
That is, if we can get from p to r, and also from r to q, then we can
get from p to q (Here, all starts and ends are with empty stack)
•For each p, q, r, s with (r, t) 2 
(p, a, 
)
and (q, 
)2 
(s, b, t), add the rule
Apq  aArsb
That is, if we can get from p to r by reading a and pushing t, and
we can get from s to q by reading b and popping t, then, if we
start with p with an empty stack, we can reach q with an empty
stack by reading a, going from r to s, then reading b.
Creating Apq (cont.)
•For each p, we also add the rule
App  
That is, if we can get from p to p by reading nothing

If Apq really generates exactly those strings


that brings P from p to q (with empty stacks),
then what is Aq ,q ?
start accept

where qstart denotes the start state of PDA


Proof of (2)
•So, in our grammar, we will have all the rules
Apq and set Aq , q as the start variable
start accept
•What remains is to prove Apq generates
exactly those strings that brings P from p to
q (with empty stacks)
•That is, we need to prove
–If Apq generates x, x brings P from p to q (with
empty stacks)
–If x brings P from p to q (with empty stacks, Apq
generates x

Exercise: Prove the above two statements (Hint: by induction)


Next Time
•Pumping Lemma for CFL
•Non-CFL

You might also like