Pushdown Automata (PDA) ( )
Reading: Chapter 6
PDA - the automata for CFLs
What is?
FA to Reg Lang, Lang PDA is to CFL
PDA == [ -NFA + a stack ] Wh a stack? Why t k?
Input string -NFA Accept/reject
A stack filled with stack symbols
2
Pushdown Automata Definition
A PDA P := ( Q,,, ,q0,Z0,F ):
Q: : : : q0: Z0: F:
states of the -NFA input alphabet stack symbols transition function start state Initial stack top s symbol mbol Final/accepting states
: Q x x => Q x
old state
Stack top
input symb.
new state(s) new Stack top(s)
: The Transition Function
(q,a,X) = {(p,Y), } 1. state transition from q to p 2. a is the next input symbol 3. X is the current stack top symbol 4. Y is the replacement for X; it is in * (a string of stack symbols) i. Set Y = for: Pop(X) ii. If Y=X: stack top is unchanged iii. If Y=Z1Z2Zk: X is popped and is replaced by Y in reverse order ( (i.e., , Z1 will be the new stack top) q
a
Y=?
X p Action Pop(X) Pop(X) Push(X)
i) ii) iii)
Y= Y=X Y=Z Y Z1Z2..Z Zk
Pop(X) Push(Zk) Push(Zk-1) Push(Z2) Push(Z1)
4
Example
Let Lwwr = {wwR | w is in (0+1)*} CFG for Lwwr : S==> 0S0 | 1S1 | PDA for Lwwr : P := ( Q,, , ,q0,Z0,F ) = ( {q0, q1, q2},{0,1},{0,1,Z0},,q0,Z0,{q2})
Initial state of the PDA: Stack St k top Z0
First symbol push on stack
PDA for Lwwr
1. 2.
q0
(q0,0, Z0)={(q0,0Z0)} (q0,1, Z0)={(q0,1Z0)} (q0,0, 0 0)={(q 0) {(q0,00)} 00)} (q0,0, 1)={(q0,01)} (q0,1, 0)={(q0,10)} (q0,1, 1)={(q0,11)} (q0, , 0)={(q1, 0)} (q0, , 1)={(q1, 1)} (q0, , Z0) )={(q {(q1, Z0)} (q1,0, 0)={(q1, )} (q1,1, 1)={(q1, )} (q1, , Z0)={(q2, Z0)}
3. 4. 5. 6.
Grow the stack by pushing new symbols on top of old ( (w-part) t) Switch to popping mode (boundary between w and wR) Shrink the stack by popping matching symbols y (w ( R-part) p ) Enter acceptance state
6
7. 8. 9 9.
10. 11.
12.
PDA as a state diagram
(qi,a, X)={(qj,Y)}
Current state
Next input symbol
Current Stack stack Top top Replacement (w/ string Y)
a, X / Y
qi
qj
Next state
PDA for Lwwr: Transition Diagram
Grow stack
0, Z0/0Z0 1, Z0/1Z0 0, 0/00 0, 1/01 1, 0/10 1, 1/11
Pop stack for matching symbols
0, 0/ 1, 1/
= {0, 1} = {Z0, 0, 1} Q = {q0,q q1,q q2}
, Z0/Z0
q0
, Z0/Z0 , 0/0 , 1/1
q1
, Z0/Z0
q2
G to acceptance Go
Switch to popping mode This would be a non-deterministic PDA
Example p 2: language g g of balanced paranthesis
Grow stack (, Z0 / ( Z0 (, ( / ( ( , Z0 / Z0
q0
Pop stack for matching symbols
= { (, ) } = {Z0, ( } Q = {q0,q q1,q q2}
), ( / ), ( / , Z0 / Z0
q1
, Z0 / Z0
q2
Switch to popping mode
(, ( / ( ( (, Z0 / ( Z0
Go to acceptance (by G (b fi final l state) ) when you see the stack bottom symbo
To allow adjacent blocks of nested paranthesis
Example 2: language of balanced paranthesis (another design)
(,Z0 / ( Z0 (,( / ( ( ), ( / start ,Z0/ Z0 ,Z0/ Z0
= { (, ) } = {Z0, ( } Q = {q0,q q1}
q0
q1
10
PDAs Instantaneous Description (ID)
A PDA has a configuration at any given instance: (q,w,y)
q - current state w - remainder of the input (i.e., unconsumed part) y - current stack contents as a string from top to bottom of f stack t k
If (q,a, X)={(p, A)} is a transition, then the following are also true: (q, a, X ) |--- (p,,A) (q, ( aw, XB ) | |--- (p,w,AB) ( )
|--- sign is called a turnstile notation and represents one move |---* sign represents a sequence of moves
11
How does the PDA for Lwwr work on input 1111?
All moves made by the non-deterministic PDA
(q0,1111,Z0) (q0,111,1Z0) (q0,11,11Z 11 11Z0) (q0,1,111Z0) (q0,,1111Z0) ( 1, ,1111Z (q 1111Z0) Path dies (q1,1111,Z0) (q1,111,1Z 111 1Z0) (q1,11,11Z0) (q1,1,111Z0) (q1, ,11Z 11Z0) Path dies (q1,1,1Z0) (q1, ,Z Z0) (q2, ,Z0) Acceptance by final state: = empty t input i t AND final state
12
Path dies Path dies dies
Principles about IDs
Theorem 1: If for a PDA, (q, x, A) |---* (p, y, B), then for any string w * and d *, * it i is also l t true th that: t
(q, x w, A ) |---* (p, y w, B )
Theorem 2: If for a PDA, (q, x w, , A) ) |---* | (p, y w, , B), ), then it is also true that:
(q, x, A) |---* (p, y, B)
13
There are two types of PDAs that one can design: those that accept by final state or by empty stack
Acceptance by
PDAs that accept by final state:
For a PDA P, the language accepted by P, d denoted t db by L(P) by b final fi l state t t , is: i Checklist:
{w | (q0,w,Z0) |---* (q,, A) }, s.t., q F
- input exhausted? - in a final state?
PDAs that accept by empty stack:
For a PDA P, the language accepted by P, denoted by N(P) by empty stack, is:
{w | (q0, { ,w,Z , 0) | |---* (q, , ) }, for any yqQ Q.
- is the stack empty? 14
Checklist: Q) Does a PDA that accepts by empty stack need any final state specified in the design? - input exhausted?
Example: p L of balanced parenthesis
PDA that accepts by final state PF:
(,Z0 / ( Z0 (,( / ( ( ), ( / ,Z0/ Z0
An equivalent PDA that accepts by empty stack PN:
(,Z ( Z0 / ( Z0 (, ( / ( ( ), ( / ,Z0 / start
start ,Z Z0/ Z0
q0
q1
,Z Z0/ Z0
q0
How will these two PDAs work on the input: ( ( ( ) ) ( ) ) ( )
15
PDA for Lwwr: Proof of correctness
Theorem: The PDA for Lwwr accepts a string x by final state if and only if x is of the form wwR. Proof:
(if-part) (if part) If the string is of the form wwR then there exists a sequence of IDs that leads to a final state: (q0,wwR,Z0) |---* (q0,wR,wZ0) |---* (q1,wR,wZ0) |---* (q1, ,Z Z0) |--| * (q2, ,Z Z0) (only-if part)
Proof by induction on |x|
16
PDAs accepting by final state and empty stack are equivalent
PF <= PDA accepting by final state
PF = (QF,, , F,q0,Z0,F) PN = (QN,, , N,q0,Z0)
PN <= PDA accepting by empty stack
Th Theorem:
(PN==> PF) For every PN, there exists a PF s.t. L(PF)=L(PN) (PF==> PN) For every PF, there exists a PN s.t. L(PF)=L(PN)
17
How to convert an empty stack PDA into a final state PDA?
PN==> PF construction
Whenever PNs stack becomes empty, make PF go to a final state without consuming any addition symbol To detect empty stack in PN: PF pushes a new stack symbol X0 (not in of PN) initially before simultating PN
PN: q0
PF:
New start , X0 / X0
, X0/Z0X0
p0
, X0/ X0 , X0/
, X0/ X0 , X0/ X0
X0 18
pf
N U {X }, , p , X , {p }) PF = (QN U {p0,pf}, , P 0 F 0 0 f
Example: Matching parenthesis ( )
PN: N : ( {q0}, {(,)}, {Z0,Z1}, N, q0, Z0 ) N(q0,(,Z0) = { (q0,Z1Z0) } N(q0,(,Z ( Z1) = { (q0, Z1Z1) } N(q0,),Z1) = { (q0, ) } N(q0, ,Z0) = { (q0, ) } Pf: f: ( {p0,q0 ,pf}, {(,)}, {X0,Z0,Z1}, f, p0, X0 , pf) f(p0, ,X0) = { (q0,Z0) } f(q0,(,Z ( Z0) = { (q0,Z Z1 Z0) } f(q0,(,Z1) = { (q0, Z1Z1) } f(q0,),Z1) = { (q0, ) } f(q0, ,Z0) = { (q0, ) } f(p0, ,X0) = { (pf, X0 ) }
(,Z0/Z1Z0 (,Z1/Z1Z1 ),Z1/ ,Z Z0/ start q0
(,Z0 /Z1Z0 (,Z1 /Z1Z1 ),Z1 / ,Z0 / start
p0
,X /Z X
0 0
q0
,X / X
0
pf
Accept by empty stack
Accept by final state
19
How to convert an final state PDA into an empty stack PDA?
PF==> PN construction
Main idea:
Whenever PF reaches a final state, just make an -transition into a new end state, clear out the stack and accept Danger: What if PF design is such that it clears the stack midway without entering a final state? to address this, , add a new start symbol y X0 ( (not in of PF)
PN = (Q U {p0,pe}, , U {X0}, N, p0, X0)
PN:
New start
, X0/Z0X0
p0 q0
, any/ , any/ , any/
, any/
pe
PF 20
Equivalence of PDAs and CFGs
21
CFGs == PDAs ==> CFLs
PDA by final state PDA by empty stack
?
CFG
22
This is same as: implementing a CFG using a PDA
Converting CFG to PDA
Main idea: The PDA simulates the leftmost derivation on a given
w, and upon consuming it fully it either arrives at acceptance (by empty stack) or non non-acceptance. acceptance PDA ( (acceptance by empty stack) implements CFG
23
reject
OUTP PUT
INPU UT
accept
This is same as: implementing a CFG using a PDA
Converting a CFG into a PDA
Main idea: The PDA simulates the leftmost derivation on a given w, and upon consuming it fully it either arrives at acceptance (by empty p y stack) ) or non-acceptance. p
Steps:
1.
2.
3.
Push the right hand side of the production onto the stack, with leftmost symbol at the stack top If stack top is the leftmost variable, then replace it by all its productions (each possible substitution will represent a distinct path taken by the non non-deterministic deterministic PDA) If stack top has a terminal symbol, and if it matches with the next symbol in the input string, then pop it
S State i i is inconsequential i l( (only l one state i is needed) d d)
24
Formal construction of PDA Note: Initial stack symbol (S) from CFG same as the start variable
Before: A
Given: G= (V,T,P,S) Output: PN = ({q} ({q}, T T, V U T T, , q, q S) :
i th in the grammar
For all F ll A V , add dd th the f following ll i transition(s) in the PDA:
After:
Before: a
(q, (q ,A) A) = { (q, (q ) | A A ==> P}
For all a T, add the following transition(s) in the PDA:
After:
a pop
(q,a,a)= { (q, ) }
25
Example: CFG to PDA
G = ( {S,A}, {0,1}, P, S) P:
S ==> AS | A ==> 0A1 | A1 | 01
1,1 / 0,0 / ,A / 01 ,A / A1 ,A / 0A1 ,S S/ ,S / AS ,S / S q
PDA = ({q}, ({ } {0,1}, {0 1} {0 {0,1,A,S}, 1 A S} , q, S) :
(q, (q , S) = { (q (q, AS) AS), (q (q, )} (q, , A) = { (q,0A1), (q,A1), (q,01) } (q, 0, 0) = { (q, ) } (q, 1, 1) = { (q, ) } How will this new PDA work?
Lets simulate string 0011
26
Simulating g string g 0011 on the new PDA Leftmost deriv.:
PDA (): (q, , S) = { (q, AS), (q, )} (q, , A) = { (q,0A1), (q,A1), (q,01) } (q, 0, 0) = { (q, ) } (q, 1, 1) = { (q, ) }
,S / S 1,1 1 1/ 0,0 / ,A / 01 ,A / A1 ,A / 0A1 ,S / ,S / AS
S => AS => 0A1S => 0011S => 0011
Stack moves (shows only the successful path):
A S
0 A 1 S
A 1 S
0 1 1 S
1 1 S
1 S
0 S =>AS =>0A1S =>0011S
=> 0011
Accept by empty stack
27
Proof of correctness for CFG ==> PDA construction
Claim: A string is accepted by G iff it is accepted (by empty stack) by the PDA Proof:
(only-if part)
Prove by induction on the number of derivation steps
(if part)
If (q, ( wx, S) |-| * (q,x,B) ( B) then th S =>*lm wB B
28
Converting a PDA into a CFG
Main idea: Reverse engineer the productions from transitions If (q,a,Z) => (p, Y1Y2Y3Yk):
1. 2. 3.
State is changed from q to p; Terminal a is consumed; Stack top symbol Z is popped and replaced with a sequence of k variables.
Action: Create a g grammar variable called [qZp] which includes the following production:
[qZp] => a[pY1q1] [q1Y2q2] [q2Y3q3] ] [qk-1Ykqk]
29
Proof discussion (in the book)
Example: Bracket matching
To avoid confusion, we will use b=( and e=)
0. 1 1. 2. 3. 4. S => [q0Z0q0] [q0Z0q0] => b [q0Z1q0] [q0Z0q0] [q0Z1q0] => b [q0Z1q0] [q0Z1q0] [q0Z1q0] => e [q0Z0q0] =>
PN: 1. 2. 3. 4.
( {q0}, {b,e}, {Z0,Z1}, , q0, Z0 ) (q0,b,Z0) = { (q0,Z1Z0) } (q0,b,Z1) = { (q0,Z1Z1) } (q0, , ,Z0) = { (q0, ) } (q0,e,Z1) = { (q0, ) }
Let A=[q0Z0q0] Let B=[q0Z1q0] If you were to directly write a CFG: S => b S e S | 0. 1. 2. 3. 4. S => A A => b B A B => b B B B => e A =>
Simplifying, 0. 1. S => b B S | B => b B B | e
30
Two ways to build a CFG
Build a PDA Construct CFG from PDA (indirect)
Derive CFG directly Similarly Two ways to build a PDA Construct Derive a CFG PDA f from CFG Design a PDA directly
(direct)
(indirect)
(direct)
31
Deterministic PDAs
32
This PDA for Lwwr is non-deterministic
Grow stack
0, Z0/0Z0 1, Z0/1Z0 0, 0/00 0, 1/01 1, 0/10 1, 1/11
Pop stack for matching symbols 0, 0/ 1, , 1/
, Z0/Z0 , 0/0 , 1/1
Why does it have to be nondeterministic?
q0
q1
, Z0/Z0
q2
A Accepts b by fi final l state To remove guessing, impose the user to insert c in the middle
Switch to popping mode
33
Example shows that: Nondeterministic PDAs D-PDAs
D PDA for Lwcwr = {wcwR | c is some D-PDA special symbol not in w}
Note: Grow stack
0, Z0/0Z0 1, Z0/1Z0 0, 0/00 0, 1/01 1, 0/10 1, 1/11
Pop stack for matching symbols
1, 1/ 0, 0/
all transitions have become deterministic
q0
c, Z0/Z0 c, 0/0 c, 1/1
q1
, Z0/Z0 Accepts b A by final state
q2
Switch to popping mode
34
Deterministic PDA: Definition
A PDA is deterministic if and only if:
1 1.
(q,a,X) (q a X) has at most one member for any a U {}
If (q,a,X) is non-empty for some a, then (q (q, ,X) X) must be empty empty.
35
PDA vs DPDA vs Regular g languages
Lwcwr Lwwr
Regular languages
D-PDA
non-deterministic PDA
36
Summary
PDAs for CFLs and CFGs
Non-deterministic Deterministic
1. 2.
PDA acceptance types
By final state By empty stack
PDA
IDs, Transition diagram
Equivalence of CFG and PDA
CFG => PDA construction PDA => CFG construction
37
