Lecture 10 CFG Pda 2

Theory of Computation
Lecture 10
CFG & PDA (Cont’d)
Dr. Samar Hesham

Department of Computer Science
Faculty of Computers and AI
Cairo University
Egypt
1
Syllabus and Terminologies
 Regular Languages .. Regular Sets

 REs (Regular Expressions)
 FSMs (or FSA/FA) … Finite State Machines/Automata
 DFSM/DFA vs. NDFSM/NFA … Deterministic vs. Non-deterministic FSM
 Comparison and conversion
 Examples & Closure Operations
 Context Free Languages
 CFGs … Context Free Grammars
 PDA … Push Down Automata
 Some applications
 Turing Machine
5/31/2024 FCI-CU-EG 2
The States
Input Pop Push

symbol symbol symbol
q1 a, b  c q2
Fall 2006 Costas Busch - RPI 3

n
ab:n with Stack Check
PDA M: L( M )  {a b : n  0} n n
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Basic Idea: L( M )  {a b : n  0}
n n
1. Push the a’s 2. Match the b’s on input

on the stack with a’s on stack
3. Match
found
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Execution Example: Time 0
Input
a a a b b b
$
Stack
current a,   a b, a  
state
q0  ,    q b, a   q , $  $ q
1 2 3
Time 1
Input
a a a b b b
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Time 2
Input
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Time 3
Input
a
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Time 4
Input
a
a
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Time 5
a
Input
a
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Time 6
Input
a
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Time 7
Input
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Time 8
Input
a a a b b b
$
Stack
a,   a b, a  
accept
q0  ,    q1 b, a   q2  , $  $ q3
Rejection Example: Time 0
Input
a a b
$
Stack
state
q0  ,    q b, a   q , $  $ q
1 2 3
Input
a a b
$
Stack
state
q0  ,    q1 b, a   q2  , $  $ q3
Input
a
a a b
$
Stack
state
q0  ,    q1 b, a   q2  , $  $ q3
Input a
a
a a b
$
Stack
state
q0  ,    q1 b, a   q2  , $  $ q3
Input a
a
a a b
$
Stack
state
q0  ,    q1 b, a   q2  , $  $ q3
Input a
a
a a b
$
Stack
reject
state
q0  ,    q1 b, a   q2  , $  $ q3
There is no accepting computation for aab
The string aab is rejected by the PDA
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Palindromes with stack checking

PDA M: L( M )  {vv : v  {a, b} } R
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2

Basic Idea: L( M )  {vv : v  {a, b} } R
R
1. Push v v
3. Match on input
2. Guess with v on stack
on stack middle
of input
a,   a a, a   4. Match
found
b,   b b, b  
q0 ,    q1 , $  $ q2
Input
a b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 1
Input
a b b a
a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 2
Input
b
a b b a
a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 3
Input
b
a b b a
Guess the middle a
of string
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 4
Input
b
a b b a
a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 5
Input
a b b a
a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 6
Input
a b b a
$
Stack
a,   a a, a  
b,   b b, b  
accept
q0 ,    q1 , $  $ q2
Input
a b b b
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 1
Input
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 2
Input
b
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 3
Input
b
a b b b
Guess the middle a
of string
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 4
Input
b
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 5
Input There is no possible transition.
a b b b Input is not consumed

a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Another computation on same string:
Input Time 0
a b b b
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 1
Input
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 2
Input
b
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 3
Input b
b
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 4 b
Input b
b
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Time 5 b
Input b
No accept state
is reached b
a b b b a
$
Stack
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
There is no computation
that accepts stringabbb
abbb  L(M )
a,   a a, a  
b,   b b, b  
q0 ,    q1 , $  $ q2
Another PDA example
L( M )  {w  {a, b} : na ( w)  nb ( w)}*
PDA M
a, $  0$ b, $  1$
a, 0  00 b, 1  11
a, 1   b, 0  
q1 , $  $ q2
Input
a b b b a a
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
current
state
q1 , $  $ q2
Time 1
Input
a b b b a a
0
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
q1 , $  $ q2
Time 3
Input
a b b b a a
0
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
q1 , $  $ q2
Time 4
Input
a b b b a a
1
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
q1 , $  $ q2
Time 5
Input
a b b b a a 1
1
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
q1 , $  $ q2
Time 6
Input
a b b b a a 1
1
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
q1 , $  $ q2
Time 7
Input
a b b b a a
1
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
q1 , $  $ q2
Time 8
Input
a b b b a a
$
a, $  0$ b, $  1$ Stack
a, 0  00 b, 1  11
a, 1   b, 0  
accept
q1 , $  $ q2
Formal Definition
Pushdown Automaton (PDA)
M  (Q, Σ, Γ, δ, q0 , z , F ) Accept
states
States
Input
Stack
alphabet
start
Transition Initial symbol
Stack function state
alphabet
Costas Busch - RPI 53
Types of PDA Transitions
 Two types of PDA transitions:
δ(q, a, z) = {(p1,γ1), (p2,γ2),…, (pm,γm)}
 Current state is q a/z/ γ1 p1

 Current input symbol is a
 Symbol currently on top of the stack z q a/z/ γ2 p2
 Move to state pi from q a/z/ γm
 Replace z with γi on the stack (leftmost symbol on top)
 Move the input head to the next input symbol
pm
54
Types of PDA Transitions
 Two types of PDA transitions:
δ(q, ε, z) = {(p1,γ1), (p2,γ2),…, (pm,γm)}
 Current state is q ε/z/ γ1 p1

 Current input symbol is not considered
q ε/z/ γ2 p2
 Symbol currently on top of the stack z
 Move to state pi from q ε/z/ γm
 Replace z with γi on the stack (leftmost symbol on top)

 No input symbol is read
pm
55
a , w1  w2
q1 q2
Transition function:
 (q1 , a ,w1 )  {(q2 ,w 2 )}

a , w1  w2 q2
q1
a , w1  w3 q3
Transition function:
 (q1 , a ,w 1 )  {(q2 ,w 2 ), (q3,w 3 )}

 Example: 0n1n, n>=0
M = ({q1, q2}, {0, 1}, {L, #}, δ, q1, #, Ø)
δ:
(1) δ(q1, 0, #) = {(q1, L#)} // stack order: L on top, then # below
(2) δ(q1, 1, #) = Ø // illegal, string rejected, When will it happen?
(3) δ(q1, 0, L) = {(q1, LL)}
(4) δ(q1, 1, L) = {(q2, ε)}
(5) δ(q2, 1, L) = {(q2, ε)}
(6) δ(q2, ε, #) = {(q2, ε)} // if ε read & stack hits bottom, accept
(7) δ(q2, ε, L) = Ø // illegal, string rejected
(8) δ(q1, ε, #) = {(q2, ε)} // n=0, accept
 Goal: (acceptance)
 Read the entire input string
 Terminate with an empty stack
 Informally, a string is accepted if there exists a computation that uses up all the input
and leaves the stack empty.
58
0011
• (q1, 0 011, #) |-
(q1, 0 11, L#) |-
(q1, 1 1, LL#) |-
(q2, 1, L#) |-
(q2, e, #) |-
(q2, e, e): accept
• 011
• (q1, 0 11, #) |-
(q1, 1 1, L#) |-
(q2, 1, #) |-
Ø : reject
59
 Example: balanced parentheses,
 e.g. in-language: ((())()), or (())(), but not-in-language: ((())
M = ({q1}, {“(“, “)”}, {L, #}, δ, q1, #, Ø)

δ:
(1) δ(q1, (, #) = {(q1, L#)} // stack order: L-on top-then- # lower
(2) δ(q1, ), #) = Ø // illegal, string rejected
(3) δ(q1, (, L) = {(q1, LL)}
(4) δ(q1, ), L) = {(q1, ε)}
(5) δ(q1, ε, #) = {(q1, ε)} // if ε read & stack hits bottom, accept
(6) δ(q1, ε, L) = Ø // illegal, string rejected
// What does it mean? When will it happen?
 Goal: (acceptance)
 Read the entire input string
 Terminate with an empty stack
60
 Example PDA #2: For the language {x | x = wwr and w in {0,1}*}
 Note: length |x| is even
M = ({q1, q2}, {0, 1}, {#, B, G}, δ, q1, #, Ø)
δ:
(1) δ(q1, 0, #) = {(q1, B#)}
(2) δ(q1, 1, #) = {(q1, G#)}
(3) δ(q1, 0, B) = {(q1, BB), (q2, ε)} (6) δ(q1, 1, G) = {(q1, GG), (q2, ε)}
(4) δ(q1, 0, G) = {(q1, BG)} (7) δ(q2, 0, B) = {(q2, ε)}
(5) δ(q1, 1, B) = {(q1, GB)} (8) δ(q2, 1, G) = {(q2, ε)}
(9) δ(q1, ε, #) = {(q2, #)}
(10) δ(q2, ε, #) = {(q2, ε)}
 Notes:
 Rules #3 and #6 are non-deterministic: two options each
 Rules #9 and #10 are used to pop the final stack symbol off at the end of a computation.
61
 Example Computation:
(1) δ(q1, 0, #) = {(q1, B#)} (6) δ(q1, 1, G) = {(q1, GG), (q2, ε)}
(2) δ(q1, 1, #) = {(q1, G#)} (7) δ(q2, 0, B) = {(q2, ε)}
(3) δ(q1, 0, B) = {(q1, BB), (q2, ε)} (8) δ(q2, 1, G) = {(q2, ε)}
(4) δ(q1, 0, G) = {(q1, BG)} (9) δ(q1, ε, #) = {(q2, ε)}
(5) δ(q1, 1, B) = {(q1, GB)} (10) δ(q2, ε, #) = {(q2, ε)}
State Input Stack Rule Applied Rules Applicable

q1 000000 # (1), (9)
q1 00000 B# (1) (3), both options
q1 0000 BB# (3) option #1 (3), both options
q1 000 BBB# (3) option #1 (3), both options
q2 00 BB# (3)option #2 (7)
q2 0 B# (7) (7)
q2 ε # (7) (10)
q2 ε ε (10)
62
Instantaneous Description
( q, u , s )
Current Current
state Remaining stack
input contents
At any time ti

Example: Instantaneous Description
(q1, bbb, aaa$)

a
Time 4: Input
a
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Example: Instantaneous Description
(q2 , bb, aa$)

a
Time 5: Input
a
a a a b b b a
$
Stack
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
We write:
(q1, bbb, aaa$)  (q2 , bb, aa$)

Time 4 Time 5

A computation:
(q0 , aaabbb,$)  (q1, aaabbb,$) 
(q1, aabbb, a$)  (q1, abbb, aa$)  (q1, bbb, aaa$) 
(q2 , bb, aa$)  (q2 , b, a$)  (q2 ,  ,$)  (q3 ,  ,$)
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
(q0 , aaabbb,$)  (q1, aaabbb,$) 
(q1, aabbb, a$)  (q1, abbb, aa$)  (q1, bbb, aaa$) 
(q2 , bb, aa$)  (q2 , b, a$)  (q2 ,  ,$)  (q3 ,  ,$)
For convenience we write:

(q0 , aaabbb,$)  (q3 ,  ,$)

Language of PDA
Language L(M ) accepted by PDA M :

L( M )  {w : (q0 , w, z )  (q f ,  , z )}
Initial state Accept state

Example: 
(q0 , aaabbb,$)  (q3 ,  ,$)
aaabbb  L(M )
PDA M:
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3

(q0 , a b ,$)  (q3 ,  ,$)
n n
a b  L(M )
n n
PDA M:
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
Therefore:
L( M )  {a b : n  0} n n
PDA M :
a,   a b, a  
q0  ,    q1 b, a   q2  , $  $ q3
PDA versus CFLs
A language L is context-free if and only if there is a pushdown

automata M that recognizes L.
Two step proof:
1) Given a CFG G, construct a PDA MG
2) Given a PDA M, make a CFG GM

Theorem:
Context-Free
Languages
(Grammars)
 Languages
Accepted by
PDAs

Proof - Step 1:
Context-Free
Languages
(Grammars)
 Languages
Accepted by
PDAs
Convert any context-free grammar G

to a PDA M
with:
L(G )  L( M )

Proof - Step 2:
Context-Free
Languages
(Grammars)
 Languages
Accepted by
PDAs
Convert any PDA M to a context-free

grammar G
with:
L(G )  L( M )

Proof - step 1
Convert
Context-Free Grammars
to
PDAs

Take an arbitrary context-free grammar G
We will convert G to a PDA M such that:
L(G )  L( M )

Conversion Procedure:
For each For each
production in G terminal in G
Aw a
Add transitions
, A  w a, a  
q0 ,   S q1 , $  $ q2
Grammar
Example
S  aSTb
S b  , S  aSTb
T  Ta , S  b PDA
T   , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Sample Run:
Input a b a b
 , S  aSTb $
Time 0
, S  b Stack
 , T  Ta a, a  
, T   b, b  
,   S , $  $
q0
Fall 2006
q1
Costas Busch - RPI
q2 81
Derivation: S
Input a b a b
S
 , S  aSTb $
Time 1
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Derivation: S  aSTb a
Input S
a b a b T
b
 , S  aSTb $
Time 2
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Derivation: S  aSTb a
Input S
a b a b T
b
 , S  aSTb $
Time 3
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Derivation: S  aSTb  abTb
Input
b
a b a b T
b
 , S  aSTb $
Time 4
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Derivation: S  aSTb  abTb
Input
b
a b a b T
b
 , S  aSTb $
Time 5
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Derivation: S  aSTb  abTb  abTab
Input T
a b a b a
b
 , S  aSTb $
Time 6
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Derivation: S  aSTb  abTb  abTab  abab
Input T
a b a b a
b
 , S  aSTb $
Time 7
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Input a b a b a
b
 , S  aSTb $
Time 8
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Input a b a b
b
 , S  aSTb $
Time 9
, S  b Stack
 , T  Ta a, a  
, T   b, b  
q0 ,   S q1 , $  $ q2
Input a b a b
 , S  aSTb $
Time 10
, S  b Stack
 , T  Ta a, a  
, T   b, b  
accept
q0 ,   S q1 , $  $ q2
PDA simulates leftmost derivations
Grammar PDA Computation
Leftmost Derivation
(q0 ,  1  k k 1  n ,$)
S  (q1 ,  1  k k 1  n , S $)
 
  1  k X 1  X m  (q1 ,  k 1  n , X 1  X m $)
 
  1  k k 1  n  (q2 ,  ,$)
Scanned Stack
Fall 2006
symbols contents
Grammar PDA Computation
Leftmost Derivation
(q0 , abab,$)
S  (q1 , abab, S $)
 aSTb  (q1 , bab, STb$)
 (q1 , bab, bTb$)
 abTb
 (q1 , ab, Tb$)
 abTab  (q1 , ab, Tab$)
 abab  (q1 , ab, ab$)
 (q1 , b, b$)
 (q1 ,  ,$)
 (q2 ,  ,$)

Lecture 10 CFG Pda 2

Uploaded by

Document Informationclick to expand document information

Document Informationclick to expand document information

Copyright:

Available Formats

Lecture 10 CFG Pda 2

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lecture 10 CFG Pda 2

Uploaded by

Copyright:

Available Formats

Theory of Computation

Dr. Samar Hesham

 Regular Languages .. Regular Sets

Input Pop Push

Fall 2006 Costas Busch - RPI 3

1. Push the a’s 2. Match the b’s on input

The string aab is rejected by the PDA

Input There is no possible transition.

a b b b Input is not consumed

 Two types of PDA transitions:

δ(q, a, z) = {(p1,γ1), (p2,γ2),…, (pm,γm)}

 Current state is q a/z/ γ1 p1

 Two types of PDA transitions:

δ(q, ε, z) = {(p1,γ1), (p2,γ2),…, (pm,γm)}

 Current state is q ε/z/ γ1 p1

 Replace z with γi on the stack (leftmost symbol on top)

 (q1 , a ,w1 )  {(q2 ,w 2 )}

Costas Busch - RPI 56

 (q1 , a ,w 1 )  {(q2 ,w 2 ), (q3,w 3 )}

Costas Busch - RPI 57

M = ({q1}, {“(“, “)”}, {L, #}, δ, q1, #, Ø)

State Input Stack Rule Applied Rules Applicable

Fall 2006 Costas Busch - RPI 63

(q1, bbb, aaa$)

(q2 , bb, aa$)

(q1, bbb, aaa$)  (q2 , bb, aa$)

Fall 2006 Costas Busch - RPI 66

For convenience we write:

Fall 2006 Costas Busch - RPI 68

Language L(M ) accepted by PDA M :

Initial state Accept state

Fall 2006 Costas Busch - RPI 69

A language L is context-free if and only if there is a pushdown

Two step proof:

1) Given a CFG G, construct a PDA MG

2) Given a PDA M, make a CFG GM

Fall 2006 Costas Busch - RPI 74

Convert any context-free grammar G

Fall 2006 Costas Busch - RPI 75

Convert any PDA M to a context-free

Fall 2006 Costas Busch - RPI 76

Fall 2006 Costas Busch - RPI 77

We will convert G to a PDA M such that:

Fall 2006 Costas Busch - RPI 78

You might also like