A Few More PDAs Examples Equivalence of PDAs and ...bchor/CM/Compute5.pdfComputational Models– Lecture 5 A Few More PDAs Examples Equivalence of PDAs and CFLs Pumping Lemma for Context

Computational Models– Lecture 5

A Few More PDAs Examples

Equivalence of PDAs and CFLs

Pumping Lemma for Context Free Languages

Non Context Free Languages

Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.1

Another Example

A PDA that accepts{

aibjck|i, j, k > 0 and i = j or i = k}

Informally:

read and push a’s

either pop and match with b’s

or else pop and match with c’s

non-deterministic choice!

Note: non-determinism essential here!Unlike finite automata, non-determinismdoes add power


Another Example

A PDA that accepts{


Informally:

read and push a’s






Another Example

A PDA that accepts{


Informally:

read and push a’s






Another Example

A PDA that accepts{


Informally:

read and push a’s






Another Example

A PDA that accepts{


Informally:

read and push a’s






Another Example (2)

ε,ε $

1q

q2

q3 q4ε,$ ε

q5 q0 q7ε,ε

ε

εb,a εc, ε

εa, a εb, ε c,a ε

ε,ε ε ε,ε ε ε,ε ε

This PDA accepts{



Yet Another Example

A palindrome is a string w satisfying w = wR.

“Madam I’m Adam”

“Dennis and Edna sinned”

“Red rum, sir, is murder”

“Able was I ere I saw Elba”

“In girum imus nocte et consumimur igni”

“νιψoν ανoµηµατα µη µoναν oψιν”

Palindromes also appear in nature. For example asDNA sites (short strings over {A,C, T,G}) being cutby restriction enzymes.


Yet Another Example










Yet Another Example










Yet Another Example










Yet Another Example










Yet Another Example










Yet Another Example










Yet Another Example

ε,ε $1q q2

q3q4 ε,$ ε

0,ε 0ε1, 1

ε,ε ε

ε1,1ε0,0

This PDA accepts binary palindromes of even length.


Equivalence Theorem

Theorem: A language is context free if and only ifsome pushdown automata accepts it.

This time, the proofs of both the “if” part and the

“only if” part are interesting.


Equivalence Theorem

Theorem: A language is context free if and only ifsome pushdown automata accepts it.

This time, the proofs of both the “if” part and the

“only if” part are interesting.


If Part

Theorem: If a language is context free, then somepushdown automaton accepts it.

Let A be a context-free language.

By definition, A has a context-free grammar Ggenerating it.

On input w, the PDA P should figure out if thereis a derivation of w using G.

Question: How does P figure out which substitutionto make?

Answer: It guesses.


If Part






Answer: It guesses.


If Part






Answer: It guesses.


If Part






Answer: It guesses.


If Part






Answer: It guesses.


CFL Implies PDA

Informally:

P pushes start variable S on stack

keeps making substitutions, storing intermediatestrings

when only terminals remain . . .

tests whether derived string equals input


CFL Implies PDA

Informally:






CFL Implies PDA

Informally:






CFL Implies PDA

Informally:






CFL Implies PDA (2)Where do we keep the intermediate string?

Can’t put it all on the stack

Keep on stack only symbols after first variable

Terminal symbols before first variable matchedimmediately to input string symbols.

read unread

pop

push

A1A0$

011001

intermediate string: A1A001






read unread

pop

push

A1A0$

011001







read unread

pop

push

A1A0$

011001







read unread

pop

push

A1A0$

011001

intermediate string: A1A001Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.9

CFL Implies PDA (3)

Informal description:

push S$ on stack

if top of stack is a variable A,non-deterministically select rule and substitute.

if top of stack is terminal, a, read next input andcompare. If they differ, reject on this branch ofthe nondeterminism.

if top of stack is $, enter accept state (here weaccept only if input has all been read, as acceptstate will have no exits labeled with inputsymbols!).


CFL Implies PDA (3)


push S$ on stack





CFL Implies PDA (3)


push S$ on stack





CFL Implies PDA (3)


push S$ on stack





CFL Implies PDA (4)

Need shorthand to push entire string onto stack (inthis example the pushed string is w = xyz).

(r, w) ∈ δ(q, a, s)

Easy to do by introducing intermediate states.

q

r

q

r

a,s xyz

a,s z

ε,ε y

ε,ε x


CFL Implies PDA (5)

States of P are

start state, qs

accept state, qaloop state, qÈ states, shorthand for pushing entire strings


CFL Implies PDA (5)

States of P are

start state, qsaccept state, qa

loop state, qÈ states, shorthand for pushing entire strings


CFL Implies PDA (5)

States of P are

start state, qsaccept state, qaloop state, q`

E states, shorthand for pushing entire strings


CFL Implies PDA (5)

States of P are

start state, qsaccept state, qaloop state, qÈ states, shorthand for pushing entire strings


Transition FunctionInitialize stack – δ(qs, ε, ε) = {q`, S$}

Top of stack is variable –δ(q`, ε, A) = {(q`, w)| where A→ w is a rule }Top of stack is terminal – δ(q`, a, a) = {(q`, ε)}End of Stack – δ(q`, ε, $) = {(qa, ε)}


Transition FunctionInitialize stack – δ(qs, ε, ε) = {q`, S$}Top of stack is variable –δ(q`, ε, A) = {(q`, w)| where A→ w is a rule }

Top of stack is terminal – δ(q`, a, a) = {(q`, ε)}End of Stack – δ(q`, ε, $) = {(qa, ε)}


Transition FunctionInitialize stack – δ(qs, ε, ε) = {q`, S$}Top of stack is variable –δ(q`, ε, A) = {(q`, w)| where A→ w is a rule }Top of stack is terminal – δ(q`, a, a) = {(q`, ε)}

End of Stack – δ(q`, ε, $) = {(qa, ε)}


Transition FunctionInitialize stack – δ(qs, ε, ε) = {q`, S$}Top of stack is variable –δ(q`, ε, A) = {(q`, w)| where A→ w is a rule }Top of stack is terminal – δ(q`, a, a) = {(q`, ε)}End of Stack – δ(q`, ε, $) = {(qa, ε)}


Transition Function

ε,$ ε

qs

qa

ql

ε,ε S$

εa,aε,A w


Example

S → aTb|bT → Ta|ε

Initialization:qs

qa

ql

ε,ε S$


Example (2)


Rules for Sqs

qa

ql

ε,ε S$Sε, b

Tε,ε

ε,ε a

Sε, b


Example


Rules for Tqs

qa

ql

ε,ε S$Sε, b

Tε,ε

ε,ε a

ε, aT ε,ε a

Sε, bε,T ε


Example (2)


Rules for terminalsqs

qa

ql

ε,ε S$

Sε, b

Tε,ε

ε,ε a

ε, aT ε,ε a

Sε, bε,T ε

εaaεbb


Example (3)


Termination:qs

qa

ql

ε,ε S$

Sε, b

Tε,ε

ε,ε a

ε, aT ε,ε a

Sε, bε,T ε

εaaεbbε, ε$


Only If Part

Theorem: If a PDA accepts a language, L, then L iscontext-free.

Given a pushdown automata P , we want to design acontext-free grammar G that “simulates” it:

The strings generated byG should be exactly those that

cause P to go from the start state to an accepting state.


Only If Part


Given a pushdown automata P , we want to design acontext-free grammar G that “simulates” it:

The strings generated byG should be exactly those that

cause P to go from the start state to an accepting state.


Only If Part


For each pair of states p and q in P , we will havea variable Apq in the grammar G.

This variable, Apq, generates all strings that takeP from p with an empty stack to q with emptystack.

Same string also takes p with any stack to q withsame stack!


Only If Part






Only If Part






PDA Implies CFL

To make things easier, we slightly modify P

Has single accept state qa.

It empties stack before accepting.

Each transition either pushes a symbol on stack,or pops a symbol from stack, but not both.


PDA Implies CFL






PDA Implies CFL






PDA Implies CFL (2)

Modify P to make things easier

single accept state qa

ε,ε ε

ε,ε ε

empties stack before accepting

each transition pushes or pops, but not both.


PDA Implies CFL (2)



ε,ε ε

ε,ε ε


each transition pushes or pops, but not both.


PDA Implies CFL (2)



ε,ε ε

ε,ε ε


each transition pushes or pops, but not both.Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.23

PDA Implies CFL (3)Modify P to make things easier

single accept state qa√


ε,ε ε

ε,ε ε

ε,ε ε

ε,ε ε

εε,a

ε,ε ε

transition either pushes or pops, but not both.





ε,ε ε

ε,ε ε

ε,ε ε

ε,ε ε

εε,a

ε,ε ε

transition either pushes or pops, but not both.





ε,ε ε

ε,ε ε

ε,ε ε

ε,ε ε

εε,a

ε,ε ε

transition either pushes or pops, but not both.Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.24



empties stack before accepting√

transition either pushes or pops, but not botha,b c

a,b ε cε,ε






a,b ε cε,ε






a,b ε cε,ε


Proof IdeaSuppose string x takes P from p with empty stack to qwith empty stack.

First move that touches the stack must be a push, lastmust be a pop.In between, two possibilities:

Stack is empty only at start and finish, but not inmiddle.

Stack was also empty at some point in between.












Proof Idea (2)

Suppose string x takes P from p with empty stack to qwith empty stack.First move that touches the stack must be a push, lastmust be a pop.In between, two possibilities:

Stack is empty only at start and finish, but not inmiddle.Simulate by: Apq → aArsb, where a, b are firstand last symbols in x (shorter x will be taken careof too), r follows p, and s precedes q.

Stack was also empty at some point in between.Simulate by: Apq → AprArq, r is intermediatestate where P has empty stack.


Proof Idea (2)





Proof Idea (2)





Details of Simulating Grammar

Given PDA P = (Q,Σ,Γ, δ, q0, {qa}), constructgrammar G. Variables are {Apq | p, q ∈ Q}.

Start variable is Aq0qa.

Rules:

For p, q, r, s ∈ Q, t ∈ Γ, and a, b ∈ Σ, if(r, t) ∈ δ(p, a, ε) and (q, ε) ∈ δ(s, b, t),add rule Apq → aArsb .

for every p, q, r ∈ Q, add rule Apq → AprArq .

for each p ∈ Q, add rule App → ε .





Rules:








Rules:





Overall StructureWill now prove

Claim: Apq generates x if and only if x brings Pfrom p with empty stack to q with empty stack.


First PartClaim: If Apq generates x, then x takes P from pwith empty stack to q with empty stack.

If generates thenApq x, x takes

with empty stack toP from p q

with empty stack.

basis1−step derivation

induction stepk−step derivations

first derivation first derivationApq Arsa b Apq Apr Arq


First Part (2)

Claim: If Apq generates x, then x takes P from pwith empty stack to q with empty stack.



with empty stack.





BasisClaim: If Apq generates x, then x takes P from pwith empty stack to q with empty stack.

Proof by induction on number of steps in derivation.

Basis: The only single-step derivation is App → ε.

Reminder: This is a rule in G,

for each p ∈ Q, we’ve added the rule

App → ε .


BasisClaim: If Apq generates x, then x takes P from pwith empty stack to q with empty stack.

Proof by induction on number of steps in derivation.

Basis: The only single-step derivation is App → ε.

Reminder: This is a rule in G,

for each p ∈ Q, we’ve added the rule

App → ε .


Induction Step




with empty stack.





ProofClaim: If Apq generates x, then x takes P from pwith empty stack to q with empty stack.

Induction Step: Assume claim for k steps, and letApq

∗⇒ x in k + 1 steps.

Two cases:

1. first derivation is Apq → aArsb.

2. first derivation is Apq → AprArq.



Induction Step: Assume claim for k steps, and letApq

∗⇒ x in k + 1 steps.

Two cases:

1. first derivation is Apq → aArsb.

2. first derivation is Apq → AprArq.


Induction Step, case I




with empty stack.






Induction Step: Assume claim for k-step, and letA

∗⇒ w.

Assume first derivation is Apq → aArsb.

x = ayb, where Ars∗⇒ y in k steps.

P starts in p with empty stack

reads a, pushes t, enters r.

by induction hypothesis, P reaches s with t onstack

finally P pops t and reaches q with empty stack.




∗⇒ w.










∗⇒ w.










∗⇒ w.










∗⇒ w.










∗⇒ w.






finally P pops t and reaches q with empty stack.Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.36

Induction Step, case II




with empty stack.







∗⇒ w.

First derivation is Apq → AprArq.

x = yz, where Apr∗⇒ y and Arr

∗⇒ z in ≤ ksteps.

induction hypothesis: y carries P from q withempty stack to r with empty stack

induction hypothesis: z carries P from r withempty stack to q with empty stack.

This completes proof of claim. ♣




∗⇒ w.

First derivation is Apq → AprArq.x = yz, where Apr

∗⇒ y and Arr∗⇒ z in ≤ k

steps.







∗⇒ w.



steps.







∗⇒ w.



steps.



This completes proof of claim. ♣Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.38

Other DirectionClaim: If x brings P from p with empty stack to qwith empty stack, then Apq generates x.

Induction on number of steps in computation.

Base Case: zero-step computation.√

Induction Step: k-step computation.Two cases:

1. stack never empty during computation.

2. stack empty at intermediate state r.
















Other Direction (2)

Claim: If x brings P from p with empty stack to qwith empty stack, then Apq generates x.

basis1−step computation

induction step

If x P with empty stack tofrom pq with empty stack,

carriesApq generates x.

k−step computation

stack empty onlyat beginning and end

stack empty atintermediate state


BasisClaim: If x brings P from p with empty stack to qwith empty stack, then Apq generates x.


induction step







BasisClaim: If x brings P from p with empty stack to qwith empty stack, then Apq generates x.

Proof by induction on number of steps incomputation.

Basis: In any zero-step computation, P reads only ε.

Reminder: this is a rule in G –

For each p ∈ Q, add rule

App → ε.


Induction Step

Assume claim for k-step computation.

Suppose x brings P from p with empty stack to q withempty stack in k + 1 steps.

Two cases:




Induction Step

Assume claim for k-step computation.


Two cases:




Induction Step


induction step







Induction Step


induction step







ProofClaim: If x brings P from p with empty stack to qwith empty stack, then Apq generates x.


If stack never empty during computation then

first symbol pushed, t, is last symbol popped.

let a be input read in first move

let r be the state state after first move

let s be the state before last move

(r, t) ∈ δ(p, a, ε) and (q, ε) ∈ δ(s, b, t) so

Apq → aArsb is a rule.


















































Apq → aArsb is a rule.Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.46

Induction Step


induction step







Induction StepClaim: If x brings P from p with empty stack to qwith empty stack, then Apq generates x.

Again, induction on number of steps in computation.Suppose x brings P from p with empty stack to q withempty stack in k + 1 steps.Suppose stack empty at intermediate state r.

Computations from p to r and from r to q each contain ≤ k

steps.

Let y be input in first portion, and z in second.

Induction hypothesis says that Apr∗⇒ y and Arq

∗⇒ z.

But we have rule Apq → AprArq.

This completes the proof of equivalence theorem. ♣





steps.



∗⇒ z.







steps.



∗⇒ z.







steps.



∗⇒ z.







steps.



∗⇒ z.


This completes the proof of equivalence theorem. ♣Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.48

Corollary

Every regular language is context-free.

context freelanguages

regularlanguages


Non-Context-Free Languages

pumping lemma for finite automata is our(almost) only tool for showing that languagesare not regular.

we will now do the same for context-freelanguages.

it’s slightly more complicated . . .

















Pumping Lemma for CFL

Also known as the uvxyz Theorem.

Theorem: If A is a CFL , there is an ` (criticallength), such that if s ∈ A and |s| ≥ `, thens = uvxyz where

for every i ≥ 0, uvixyiz ∈ A

|vy| > 0, (non-triviality)

|vxy| ≤ `.





for every i ≥ 0, uvixyiz ∈ A|vy| > 0, (non-triviality)

|vxy| ≤ `.





for every i ≥ 0, uvixyiz ∈ A|vy| > 0, (non-triviality)

|vxy| ≤ `.


Basic IntuitionLet A be a CFL and G its CFG.

Let s be a “very long” string in A.

Then s has a “tall” parse tree.

And some root-to-leaf path must repeat a symbol.ahmmm,. . . why is that so?

T

R

u v x y z

R


Basic IntuitionLet A be a CFL and G its CFG.

Let s be a “very long” string in A.

Then s has a “tall” parse tree.

And some root-to-leaf path must repeat a symbol.ahmmm,. . . why is that so?

T

R

u v x y z

R


Prooflet G be a CFG for CFL A.

let c be the max number of symbols inright-hand-side of any rule.

no node in parse tree has > c children.

at depth d, no more than cd leaves.

let |V | be the number of variables in G.

let ` = c|V |+2.







let ` = c|V |+2.







let ` = c|V |+2.







let ` = c|V |+2.







let ` = c|V |+2.







let ` = c|V |+2.


Proof (2)

let s be a string where |s| ≥ `

let τ be parse tree for s with fewest nodes

τ has height ≥ |V |+ 2

some path in τ has length ≥ |V |+ 2

that path repeats a variable R


Proof (2)







Proof (2)







Proof (2)







Proof (2)







Proof (3)

Split s = uvxyz

T

R

u v x y z

R

each occurrence of R produces a string

upper produces string vxy

lower produces string x


Proof (3)

Split s = uvxyz

T

R

u v x y z

R





Proof (3)

Split s = uvxyz

T

R

u v x y z

R





Proof (3)

Split s = uvxyz

T

R

u v x y z

R



lower produces string xSlides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.55

ProofReplacing smaller by larger yields uvixyiz, for i > 0.

T

R

u v x y z

R

v yx

R


Proof (4)

Replacing larger by smaller yields uxz.

T

R

u

x

zTogether, they establish:

for i ≥ 0, uvixyiz ∈ ASlides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.57

Proof (5)

Next condition is:

|vy| > 0

If v and y are both ε, thenT

R

u

x

z

is a parse tree for s with fewer nodes.Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.58

Proof (6)

Final condition is |vxy| ≤ `:T

R

u v x y z

R |V|+2

b |V|+2

the upper occurrence of R generates vxy.

can choose symbols such that both occurrences ofR lie in bottom |V |+ 1 variables on path.

subtree where R generates vxy is ≤ |V |+ 2 high.

strings by subtree at most b|V |+2 = ` long.


Proof (6)


R

u v x y z

R |V|+2

b |V|+2






Proof (6)


R

u v x y z

R |V|+2

b |V|+2






Proof (6)


R

u v x y z

R |V|+2

b |V|+2






Proof (6)


R

u v x y z

R |V|+2

b |V|+2




strings by subtree at most b|V |+2 = ` long.Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.59

Example

Theorem: B = {anbncn} is not a CFL.Proof: By contradiction.

Let ` be the critical length.

Consider s = a`b`c`.If s = uvxyz, neither v nor y can contain

both a’s and b’s, or

both b’s and c’s, because

uv2xy2z would have out-of-order symbols.But if v and y contain only one symbol, then uv2xy2zhas an imbalance!


Example

Theorem: B = {anbncn} is not a CFL.Proof: By contradiction.

Let ` be the critical length.

Consider s = a`b`c`.If s = uvxyz, neither v nor y can contain

both a’s and b’s, or

both b’s and c’s, because

uv2xy2z would have out-of-order symbols.But if v and y contain only one symbol, then uv2xy2zhas an imbalance!


Example (2)

The language C ={

aibjck|0 ≤ i ≤ j ≤ k}

is notcontext-free.Let ` be the critical length, and s = a`b`c`.

Let s = uvxyz

neither v nor y contains contains two distinct symbols,

because uv2xy2z would have out-of-order symbols.

vxy not all b’s (why?)

vxy < `, so either

v contains only a’s and y contains only b’s, but then

uv2xy2z has too few c’s.

v contains only b’s and y contains only c’s. but then

uv0xy0z has too many a’s.


Example (2)

The language C ={



Let s = uvxyz




vxy < `, so either






Example (2)

The language C ={



Let s = uvxyz




vxy < `, so either






Example (2)

The language C ={



Let s = uvxyz




vxy < `, so either






Example (2)

The language C ={



Let s = uvxyz




vxy < `, so either




uv0xy0z has too many a’s.Slides modified by Benny Chor, based on original slides by Maurice Herlihy, Brown University. – p.61

Example (2)

The language C ={



Let s = uvxyz




vxy < `, so either





Example (2)

The language C ={



Let s = uvxyz




vxy < `, so either





Example (2)

The language C ={



Let s = uvxyz




vxy < `, so either





Example (3)

The language D = {ww|w ∈ {0, 1}∗} is notcontext-free.Let s = 0`1`0`1` As before, suppose s = uvxyz .

Recall that |vxy| ≤ `.

if vxy is in the first half of s, uv2xy2z moves a 1 into the

first position in second half.

if vxy is in the second half, uv2xy2z moves a 0 into the last

position in first half.

if vxy straddles the midpoint, then pumping down to uxz

yields 0`1i0j1` where i and j cannot both be `.


Example (3)










Example (3)










Documents

A Few More PDAs Examples Equivalence of PDAs and ...bchor/CM/Compute5.pdfComputational Models– Lecture 5 A Few More PDAs Examples Equivalence of PDAs and CFLs Pumping Lemma for Context