Scribd
Upload
42 views

Formal Languages, Automata and Computability

The document provides information about formal languages, automata, and computability. It discusses how a language generated by a context-free grammar (CFG) is recognized by a pushdown automaton (PDA). Specifically, it explains that given a CFG G, a PDA P can be constructed such that the language generated by G (L(G)) is the same as the language recognized by P (L(P)). It also shows the reverse is true - that given a PDA, a CFG can be constructed recognizing the same language.

Uploaded by

Mahnoor Khandwani
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
42 views

Formal Languages, Automata and Computability

The document provides information about formal languages, automata, and computability. It discusses how a language generated by a context-free grammar (CFG) is recognized by a pushdown automaton (PDA). Specifically, it explains that given a CFG G, a PDA P can be constructed such that the language generated by G (L(G)) is the same as the language recognized by P (L(P)). It also shows the reverse is true - that given a PDA, a CFG can be constructed recognizing the same language.

Uploaded by

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

15-453

FORMAL LANGUAGES,
AUTOMATA AND
COMPUTABILITY
Some Homework 1 Statistics:

Each question was graded out of 20 points.

Max: 100
Mean: 78
Median: 79.02
Std Dev: 15.65
NOTE :
Your 1st Project Report is
Due Tuesday!

Turn in your Homework!

(New Homework on the Web)


PDAs ARE EQUIVALENT TO CFGs

THURSDAY Jan 31
string pop push

ε,ε → $
0,ε → 0

1,0 → ε

ε,$ → ε
1,0 → ε
CONTEXT-FREE GRAMMARS
Production rules

variable terminals

A → 0A1
A→ε  (VΣ)*

A  0A1  00A11  000A111  000111


(yields)
A * 000111
(derives)
A Language L is generated by a CFG

L is recognized by a PDA
Suppose L is generated by a CFG G = (V, Σ, R, S)
Construct P = (Q, Σ, Γ, , q, F) that recognizes L
A Language L is generated by a CFG

L is recognized by a PDA
Suppose L is generated by a CFG G = (V, Σ, R, S)
Construct P = (Q, Σ, Γ, , q, F) that recognizes L
ε,ε → S$ For each rule 'A → w’  R:
ε,A → wR
For each terminal a  Σ:
a,a → ε
ε,$ → ε
S → aTb
T → Ta | ε
ε,ε → $
ε,ε → T

ε,ε → S ε,ε → T

ε,$ → ε
ε,ε → a
ε,T → ε
a,a → ε
b,b → ε
S → aTb S * ab
T → Ta | ε (derives)
ε,ε → $
ε,ε → T

ε,ε → S ε,ε → T

ε,$ → ε
ε,ε → a
ε,T → ε
a,a → ε
b,b → ε
Suppose L is generated by a CFG G = (V, Σ, R, S)
Describe P = (Q, Σ, Γ, , q, F) that recognizes L :

(1) Push $ and then S on the stack


(2) Repeat the following steps forever:
(a) Pop the stack, call the result X.
(b) If X is a variable A, guess a rule that
matches A and push result into the stack
(c) If X is a terminal, read next symbol
from input and compare it to terminal.
If they’re different, reject.
(d) If X is $: then accept iff no more input
A Language L is generated by a CFG

L is recognized by a PDA
A Language L is generated by a CFG
L is recognized by a PDA

Given PDA P = (Q, Σ, Γ, , q, F)


Construct a CFG G = (V, Σ, R, S) such that
L(G) = L(P)
First, simplify P to have the following form:
(1) It has a unique accept state, qacc
(2) It empties the stack before accepting
(3) Each transition either pushes a symbol or
pops a symbol, but not both at the same time
SIMPLIFY
ε,ε → $
q0 q1 0,ε → 0

1,0 → ε

ε,$ → ε
q3 q2 1,0 → ε
SIMPLIFY
ε,ε → E
ε,ε → $
Q q0 q1 0,ε → 0

ε,ε → ε 1,0 → ε

ε,$ → ε
q3 q2 1,0 → ε

ε,ε → ε
q4
ε,E → ε

ε,σ → ε q5
SIMPLIFY
ε,ε → E
ε,ε → $
Q q0 q1 0,ε → 0

ε,ε → D 1,0 → ε
q’0 ε,$ → ε
q3 q2 1,0 → ε
ε,D→ ε

q’3 ε,ε → D

ε,D → ε
q4
ε,E → ε q5
ε,σ → ε
Idea For Our Grammar G:
For every pair of states p and q in PDA P,

G will have a variable Apq whose production


rules will generate all strings x that can take:

P from p with an empty stack


to q with an empty stack

V = {Apq | p,qQ }

S = Aq0qacc
ε,ε → E
ε,ε → $
Q q0 q1 0,ε → 0

ε,ε → D 1,0 → ε
q’0 ε,$ → ε
q3 q2 1,0 → ε

q’3 ε,ε → D
Aq0q1 generates? 
ε,D → ε
q4 Aq1q2 generates?
ε,E → ε {0n1n | n > 0}
q5
Aq1q3 generates? 
ε,σ → ε
WANT: Apq generates all strings that take p
with an empty stack to q with empty stack
WANT: Apq generates all strings that take p
with an empty stack to q with empty stack
Let x be such a string
• P’s first move on x must be a push
• P’s last move on x must be a pop
Two possibilities:
1. The symbol popped at the end is exactly
the one pushed at the beginning

2. The symbol popped at the end is not


the one pushed at the beginning
x = ayb takes p with empty stack to q with empty stack

1. The symbol t popped at the end is exactly


the one pushed at the beginning

stack
height
r s
input a push t pop t b
string p ────x──── q
δ(p, a, ε) → (r, t)
δ(s, b, t) → (q, ε) Apq → aArsb
2. The symbol popped at the end is not
the one pushed at the beginning

stack
height

input
string p r q

Apq → AprArq
Formally:
V = {Apq | p, qQ }
S = Aq0qacc

For every p, q, r, s  Q, t  Γ and a, b  Σε


If (r, t)  (p, a, ε) and (q, ε)  (s, b, t)
Then add the rule Apq → aArsb

For every p, q, r  Q,
add the rule Apq → AprArq

For every p  Q,
add the rule App → ε
For all x, Apq generates x

x can bring P from p with an empty stack


to q with an empty stack
Proof (by induction on the number of steps in
the derivation of x from Apq):
Inductive
Base Case: The derivation has 1 step: App  ε
Step:
Assume true for derivations of length ≤ k and
prove true for derivations of length k+1:
Apq * x in k+1 steps
Apq → AprArq Apq → aArsb
(r,t)  (p,a,ε) and (q, ε)  (s,b,t)

state push state alphabet pop


For all x, Apq generates x

x can bring P from p with an empty stack
to q with an empty stack
Proof (by induction on the number of steps in
the computation of P from p to q with empty
stacks, on input x):

Base Case: The computation has 0 steps


So it starts and end in the same state:
We must show that App * x
But it must be that x = ε, so we are done
Inductive Step:
Assume true for computations of length ≤ k,
we’ll prove true for computations of length k+1
Suppose that P has a computation where x
brings p to q with empty stacks in k+1 steps
Two cases:
1. The stack is empty only at the beginning
and the end of this computation
Write x as ayb. Ars * y by I.H., use Apq → aArsb
2. The stack is empty somewhere in the
middle of the computation
Write x as yz. Apr * y, Arq * z by I.H., Apq → AprArq
A Language L is generated by a CFG

L is recognized by a PDA
Corollary: Every regular
language is context-free
WWW.FLAC.WS

You might also like