1 Module 28 Context Free Grammars –Definition of a grammar G –Deriving strings and defining L(G)...

transcript

Module 28

• Context Free Grammars– Definition of a grammar G– Deriving strings and defining L(G)

• Context-Free Language definition

Context-Free Grammars

Definition

• A context-free grammar G = (V, , S, P)– V: finite set of variables (nonterminals)

– : finite set of characters (terminals)

– S: start variable• element of V

• role is similar to that of q0 for an FSA or NFA

– P: finite set of grammar rules or production rules• Syntax of a production

• variable --> string of variables and terminals

English Context-Free Grammar

• ECFG = (V, , S, P)– V = {<sentence>, <noun phrase>, <verb phrase>, ... }

• people sometimes use < > to delimit variables

• In this course, we generally will use capital letters to denote variables

– = {a, b, c, ..., z, ;, ,, ., ...}

– S = <sentence>

– P = { <sentence> --> <noun phrase> <verb phrase> <pct>, <noun phrase> --> <article> <adj> <noun>, ...}

{aibi | i>0} CFG

• ABG = (V, , S, P)– V = {S}

– = {a, b}

– S = S

– P = {S --> aSb, S --> ab} or S --> aSb | ab• second format saves some space

Deriving strings, defining L(G), and defining context-free languages

Defining -->, ==> notation• First: --> notation

– This is used to define the productions of a grammar• S --> aSb | ab

• Second: ==>G notation– This is used to denote the application of a production rule

from a grammar G• S ==>ABG aSb ==>ABG aaSbb ==>ABG aaabbb

– We say that string S derives string aSb (in one step)– We say that string aSb derives string aaSbb (in one step)– We say that string aaSbb derives string aaabbb (in one step)

• We often omit the grammar subscript when the intended grammar is unambiguous

Defining ==> continued

• Third: ==>kG notation

– This is used to denote k applications of production rules from a grammar G

• S ==>2ABG aaSbb

– We say that string S derives string aaSbb in two steps

• aSb ==>2ABG aaabbb

– We say that string aSb derives string aaabbb in two steps

• Fourth: ==>*G notation

– This is used to denote 0 or more applications of production rules from a grammar G

• S ==>*ABG S

– We say that string S derives string S in 0 or more steps

• S ==>*ABG aaSbb

– We say that string S derives string aaSbb in 0 or more steps

• aSb ==>*ABG aaSbb

– We say that string aSb derives string aaSbb in 0 or more steps

• aSb ==>*ABG aaabbb

– We say that string aSb derives string aaabbb in 0 or more steps

Defining ==> continued

• Derivation of a string x– The complete step by step derivation of a string x from

the start variable S

– Key fact: each step in a derivation makes only one application of a production rule from G

– Example: Derivation of string aaabbb using ABG• S ==>ABG aSb ==>ABG aaSbb ==>ABG aaabbb

– Example 2: AG= (V, , S, P) where P = S -->SS | a• Deriving string aaa

• S ==> SS ==> Sa ==> SSa ==> aSa ==> aaa

Defining derivations *

• Generating strings– If S ==>G

* x, then grammar G generates string x• Note G generates strings which contain terminals and nonterminals

– aSb contains nonterminals and terminals– S contains only nonterminals– aaabbb contains only terminals

• L(G)– The set of strings over generated by grammar G

• Note we only consider terminal strings generated by G

– {aibi | i > 0} = L(ABG)– {ai | i > 0} = L(AG)

Defining L(G) *

• Context-Free Languages– A language L is a context-free language (CFL) iff there

exists a CFG G such that L(G) = L

• Results so far– {ai | i > 0} is a CFL

• One CFG G such that L(G) = this language is AG

• Note this language is also regular

– {aibi | i > 0} is a CFL• One CFG G such that L(G) = this language is ABG

• Note this language is NOT regular

Context-Free Languages *

Example *

• Let BAL = the set of strings over {(,)} in which the parentheses are balanced

• Prove that BAL is a CFL– To prove this, you need to come up with a CFG BALG

such that L(BALG) = BAL• BALG = (V, , S, P)

– V = {S}– = {(, )}– S = S– P = ?

• Give derivations of ((( ))) and ( )(( )) with your grammar

Module 29

• Parse/Derivation Trees– Leftmost derivations, rightmost derivations

• Ambiguous Grammars– Examples

• Arithmetic expressions

• If-then-else Statements

– Inherently ambiguous CFL’s

Parse Trees

Leftmost/rightmost derivations

Ambiguous grammars

Parse Tree

• Parse/derivation trees are structured derivations– The structure graphically illustrates semantic

information about the string

• Formalization of concept we encountered in regular languages unit– Note, what we saw before were not exactly parse

trees as we define them now, but they were close

Parse Tree Example

• Parse tree for string ( )(( )) and grammar BALG– BALG = (V, , S, P)

• V = {S}, = {(, )}, S = S

• P = S --> SS | (S) | – One derivation of ( )(( ))

• S ==> SS ==> (S)S ==> ( )S ==> ( )(S) ==> ( )((S)) ==> ( )(( ))

– Parse tree

SS( ( ))

Comments about Example *

• Syntax: – draw a unique arrow from each

variable to each character that is a direct child of that variable

• A line instead of an arrow is ok

– The derived string can be read in a left to right traversal of the leaves

• Semantics– The tree graphically illustrates the

nesting structure of the string of parentheses

SS( ( ))

Leftmost/Rightmost Derivations

• There is more than one derivation of the string ( )(( )).– S ==> SS ==> (S)S ==>( )S ==> ( )(S)

==> ( )((S)) ==> ( )(( ))– S ==> SS ==> (S)S ==> (S)(S) ==> ( )(S)

==> ( )((S)) ==> ( )(( ))– S ==> SS ==> S(S) ==> S((S)) ==> S(( ))

==> (S)(( )) ==>( )(( ))

• Leftmost derivation– Leftmost variable is always expanded– Which one of the above is leftmost?

• Rightmost derivation– Rightmost variable is always expanded– Which one of the above is rightmost?

SS( ( ))

Comments

• Fix a string and a grammar– Any derivation corresponds to a

unique parse tree

– Any parse tree can correspond to many different derivations

• Example– The one parse tree corresponds to all

three derivations

• Unique mappings– For any parse tree, there is a unique

leftmost/rightmost derivation that it corresponds to

SS( ( ))

– S ==> SS ==> (S)S ==>( )S ==> ( )(S)

==> ( )((S)) ==> ( )(( ))

– S ==> SS ==> (S)S ==> (S)(S) ==> ( )(S)

==> ( )((S)) ==> ( )(( ))

– S ==> SS ==> S(S) ==> S((S)) ==> S(( ))

==> (S)(( )) ==>( )(( ))

Example *

• S ==> SS ==> SSS ==> (S)SS ==> ( )SS ==> ( )S ==> ( )– The above is a leftmost derivation of the string ( ) from the

grammar BALG

– Draw the corresponding parse tree

– Draw the corresponding rightmost derivation

• S ==> (S) ==> (SS) ==> (S(S)) ==> (S( )) ==> (( ))– The above is a rightmost derivation of the string (( )) from the

grammar BALG

– Draw the corresponding parse tree

– Draw the corresponding leftmost derivation

Ambiguous Grammars

Examples:

Arithmetic Expressions

If-then-else statements

Inherently ambiguous grammars

Ambiguous Grammars

• A grammar G is ambiguous if there exists a string x in L(G) with two or more distinct parse trees– (2 or more distinct leftmost/rightmost derivations)

• Example– Grammar AG is ambiguous

• String aaa in L(AG) has 2 rightmost derivations– S ==> SS ==> SSS ==> SSa ==> Saa ==> aaa

– S ==> SS ==> Sa ==> SSa ==> Saa ==> aaa

2 Simple Examples

• Grammar BALG is ambiguous– String ( ) in L(BALG) has >1 leftmost

derivation• S ==> (S) ==> ( )• S ==> (S) ==> (SS) ==>(S) ==>( )• Give another leftmost derivation of ( ) from BALG

• Grammar ABG is NOT ambiguous– Consider any string x in {aibi | i > 0}

• There is a unique parse tree for x

Legal Arithmetic Expressions

• Develop a grammar MATHG = (V, , S, P) for the language of legal arithmetic expressions– = {0, 1, +, *, -, /, (, )}

– Strings in the language include• 0

• 10

• 10*11111+100

• 10*(11111+100)

– Strings not in the language include• 10+

• 11++101

• )(

Grammar MATHG1

• V = {E, N}• = {0, 1, +, *, -, /, (, )}• S = E• P:

– E --> N | E+E | E*E | E/E | E-E | (E)

– N --> N0 | N1 | 0 | 1

MATHG1 is ambiguous

• Come up with two distinct leftmost derivations of the string 11+0*11– E ==> E+E ==> N+E ==> N1+E ==> 11+E ==>

11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==> 11+0*11

– E ==> E*E ==> E+E*E ==> N+E*E ==> N1+E*E ==> 11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==>11+0*11

• Draw the corresponding parse trees

E --> N | E+E | E*E | E/E | E-E | (E)N --> N0 | N1 | 0 | 1

Corresponding Parse Trees

• E ==> E+E ==> N+E ==> N1+E ==> 11+E ==> 11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==> 11+0*11

• E ==> E*E ==> E+E*E ==> N+E*E ==> N1+E*E ==> 11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==>11+0*11

Parse Tree Meanings

Note how the parse trees captures the semantic meaning of string 11+0*11.More specifically, what number does the first parse tree represent?

What number does the second parse tree represent?

Implications

• Two interpretations of string 11+0*11– 11+(0*11) = 11– (11+0)*11 = 1001

• What if a line in a program is– MSU_Tuition = 11+0*11;– What is MSU_Tuition?

• Depends on how the expression 11+0*11 is parsed.• This is not good.• Ambiguity in grammars is undesirable, particularly if the grammar is

used to develop a compiler for a programming language like C++.

• In this case, there is an unambiguous grammar for the language of arithmetic expressions

If-Then-Else Statements

• A grammar ITEG = (V, , S, P) for the language of legal If-Then-Else statements– V = (S, BOOL)

– = {adv<80, adv>50, grade=3.5, grade=3.0, if, then, else}

– S = S

– P: • S --> if BOOL then S else S | if BOOL then S |grade=3.5 |

grade=3.0

• BOOL --> adv<80 | adv>50

ITEG is ambiguous

• Come up with two distinct leftmost derivations of the string – if adv<80 then if adv>50 then grade=3.5 else grade=3.0– S ==>if BOOL then S else S ==> if adv<80 then S else S ==> if adv<80

then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0

– S ==>if BOOL then S ==> if adv<80 then S ==> if adv<80 then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0

• Draw the corresponding parse trees

S --> if BOOL then S |grade=3.5 | grade=3.0 | if BOOL then S else S BOOL --> adv<80 | adv>50

Corresponding Parse Trees• S ==>if BOOL then S else S ==> if adv<80 then

S else S ==> if adv<80 then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0

• S ==>if BOOL then S ==> if adv<80 then S ==> if adv<80 then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0

if B then S else S

adv<80 if B then S grade=3.0

adv>50 grade=3.5

if B then S

adv<80 else Sif B then S

adv>50 grade=3.5 grade=3.0

Parse Tree Meanings

if B then S else S

if B then Sadv<80

adv>50 grade=3.5

grade=3.0

if B then S

else Sif B then Sadv<80

adv>50 grade=3.5 grade=3.0

If you receive a 90 on advanced points, what is your grade?By parse tree 1

By parse tree 2

Implications

• Two interpretations of string – if adv<80 then if adv>50 then grade=3.5 else grade=3.0

– Issue is which if-then does the last ELSE attach to?

– This phenomenon is known as the “dangling else”

– Answer: Typically, else binds to NEAREST if-then

• In this case, there is an unambiguous grammar for handling if-then’s as well as if-then-else’s

Inherently ambiguous CFL’s

• A CFL L is inherently ambiguous iff for all CFG’s G such that L(G) = L, G is ambiguous

• Examples so far– None of the CFL’s we’ve seen so far are inherently ambiguous

– While the CFG’s we’ve seen ambiguous, there do exist unambiguous CFG’s for those CFL’s.

• Later result– There exist inherently ambiguous CFL’s

– Example: {aibjck | i=j or j=k or i=j=k}• Note i=j=k is unnecessary, but I added it here for clarity

Summary

• Parse trees illustrate “semantic” information about strings

• Ambiguous grammars are undesirable– This means there are multiple parse trees for some string

– These strings can be interpreted in multiple ways

• There are some heuristics people use for taking an ambiguous grammar and making it unambiguous, but this is not the focus of this course

• There are some inherently ambiguous CFL’s– Thus, the above heuristics do not always work

Module 30

• EQUAL language– Designing a CFG– Proving the CFG is correct

EQUAL language

Designing a CFG

• EQUAL is the set of strings over {a,b} with an equal number of a’s and b’s

• Strings in EQUAL include– aabbab– bbbaaa– abba

• Strings in {a,b}* not in EQUAL include– aaa– bbb– aab– ababa

Designing a CFG for EQUAL

• Think recursively• Base Case

– What is the shortest possible string in EQUAL?

– Production Rule:

Recursive Case

• Recursive Case– Now consider a longer string x in EQUAL

– Since x has length > 0, x must have a first character• This must be a or b

– Two possibilities for what x looks like• x = ay

– What must be true about relative number of a’s and b’s in y?

• x = bz – What must be true about relative number of a’s and b’s in z?

Case 1: x=ay

• x = ay where y has one extra b– What must y look like?

• Some examples– b– babba– aabbbab– aaabbbb

• Is there a general pattern that applies to all of the above examples?

• More specifically, show how we can decompose all of the above strings y into 3 pieces, two of which belong to EQUAL.

– Some of these pieces might be the empty string

Decomposing y

• y has one extra b– Possible examples

• b, babba, aabbbab, aaabbbb

– Decomposition• y = ubv where

– u and v both have an equal number of a’s and b’s

• Decompose the 4 strings above into u, b, v– b, aabbbab, babba, aaabbbb

Implication

• Case 1: x=ay – y has one extra b

• Case 1 refined: x=aubv– u, v belong to EQUAL

• Production rule for this case?

Case 2: x=bz

• Case 2: x=bz – z has one extra a

• Case 2 refined: x=buav– u, v belong to EQUAL

• Production rule for this case?

Final Grammar

• EG = (V, , S, P)– V = {S}

– = {a,b}

– S = S

– P:

EQUAL language

Proving CFG is correct

Is our grammar correct?

• How do we prove our grammar is correct?– Informal

• Test some strings

• Review logic behind program (CFG) design

– Formal• First, show every string derived by EG belongs to EQUAL

– That is, show L(EG) is a subset of EQUAL

• Second, show every string in EQUAL can be derived by EG– That is, show EQUAL is a subset of L(EG)

• Both proofs will be inductive proofs– Inductive proofs and recursive algorithms go well together

L(EG) subset of EQUAL

• Let x be an arbitrary string in L(EG)• What does this mean?

– S ==>*EG x

• Follows from definition of x in L(EG)

– We will prove the following• If S ==>1

EG x, then x is in EQUAL

• If S ==>2EG x, then x is in EQUAL

• ...

Base Case

• Statement to be proven:– For all n >= 1, if S ==>n

– Prove this by induction on n

• Base Case:– n = 1

– What is the set of strings {x | S ==>1EG x}?

– What do we need to prove about this set of strings?

Inductive Case

• Inductive Hypothesis:– For 1 <= j <= n, if S ==>j

EG x, then x is in EQUAL• Note, this is a “strong” induction hypothesis

• Traditional inductive hypothesis would take form:– For some n >= 1, if S ==>n

• The difference is we assume the basic hypothesis for all integers between 1 and n, not just n

• Statement to be Proven in Inductive Case:– If S ==>n+1

• Infinite Set of Facts– Fact 1

– Fact 2

– Fact 3

– Fact 4

– Fact 5

– Fact 6

– …

• Base Case– Prove fact 1

• Regular inductive case– For n >= 1,

• Fact n --> Fact n+1

• Strong inductive case– For n >= 1,

• Fact 1 to Fact n --> Fact n+1

“Regular” induction vs Strong induction

Visualization of InductionRegular Induction

Fact 1Fact 2Fact 3Fact 4Fact 5Fact 6Fact 7Fact 8Fact 9

Strong Induction

Fact 1Fact 2Fact 3Fact 4Fact 5Fact 6Fact 7Fact 8Fact 9

… …

Proving Inductive Case

• If S ==>n+1EG x, then x is in EQUAL

– Let x be an arbitrary string such that S ==>n+1EG x

– Examining EG, what are the three possible first derivation steps

• Case 1: S ==> ==>nEG x

• Case 2: S ==> ==>nEG x

• Case 3: S ==> ==>nEG x

– One of the cases is impossible. Which one and why?

Case 2: S ==> ==>nEG x

• This means x has the form aubv where– What can we conclude about u (don’t apply IH)?

– What can we conclude about v (don’t apply IH)?

• Apply the inductive hypothesis– u and v belong to EQUAL– Why do we need the strong inductive hypothesis?

• Conclude x belongs to EQUAL– x = aubv where u and v belong to EQUAL

• Clearly the number of a’s in x equals the number of b’s in x

Case 3: S ==> ==>nEG x

• This means x has the form buav where– What can we conclude about u (no IH)?

– What can we conclude about v (no IH)

• Apply the inductive hypothesis– u and v belong to EQUAL– Why do we need the strong inductive hypothesis?

• Conclude x belongs to EQUAL– x = buav where u and v belong to EQUAL

• Clearly the number of a’s in x equals the number of b’s in x

L(EG) subset of EQUAL

• Wrapping up inductive case– In all possible derivations of x, we have shown that x

belongs to EQUAL

– Thus, we have proven the inductive case

• Conclusion– By the principle of mathematical induction, we have

shown that L(EG) is a subset of EQUAL

EQUAL subset of L(EG)

• Let x be an arbitrary string in EQUAL• What does this mean?

• We will prove the following• If |x| = 0 and x is in EQUAL, then x is in L(G)• If |x| = 1 and x is in EQUAL, then x is in L(G)• If |x| = 2 and x is in EQUAL, then x is in L(G)• If |x| = 3 and x is in EQUAL, then x is in L(G)• ...

• Statement to be proven:– For all n >= 0, if |x| = n and x is in EQUAL, then x is in

L(EG)– Prove this by induction on n

• Base Case:– n = 0– What is the only string x such that |x|=0 and x is in

EQUAL?

– Prove this string belongs to L(EG)

Inductive Case

• Inductive Hypothesis:– For 0 <= j <= n, if |x| =j and x is in EQUAL, then x is

in L(EG)• Again, this is a “strong” induction hypothesis

• Statement to be Proven in Inductive Case:– For n >= 0,

– if |x| = n+1 and x is in EQUAL, then x is in L(EG)

Proving Inductive Case

• If |x|=n+1 and x is in EQUAL, then x is in L(EG)– Let x be an arbitrary string such that |x|=n+1 and x is in

L(EG)– Examining , what are the two possibilities for the first

character in x?• Case 1: first character in x is • Case 2: first character in x is

– In each case, what can we say about the remainder of x?• Case 1: the remainder of x• Case 2: the remainder of x

Case 1: x = ay• What can we say about y in this case?

• This means x has the form aubv where– u is in EQUAL and has length <= n– v is in EQUAL and has length <= n– Proving this statement true

• Consider all the prefixes of string y– length 0: – length 1: y1

– length 2: y1y2

– …– length n: y1y2 … yn = y

Case 1: x = ay• Consider all the prefixes of string y

– length 0: – length 1: y1

– length 2: y1y2

– …

– length n: y1y2 … yn = y

• The first prefix has the same number of a’s as b’s

• The last prefix y has one extra b

• The relative number of a’s and b’s changes in the length i prefix differs by only one from the length i-1 prefix

• Thus, there must be a first prefix t of y where t has one extra b

• Furthermore, the last character of t must be b– Otherwise, t would not be the FIRST prefix of y with one extra b

• Break t into u and b and let the remainder of y be v

• The statement follows

Case 1: x = aubv *• x = aubv

– u is in EQUAL and has length <= n

– v is in EQUAL and has length <= n

• Apply the induction hypothesis– What can we conclude from applying the IH?

– Why did we need a strong inductive hypothesis?

• Conclude x is in L(EG) by constructing a derivation– S ==> aSbS ==>*

EG aubS ==>*EG aubv

Case 2: x = buav• x = buav

– u is in EQUAL and has length <= n

– v is in EQUAL and has length <= n

• Apply the induction hypothesis– What can we conclude about u and v?

• Conclude x is in L(EG) by constructing a derivation– S ==> bSaS ==>*

EG buaS ==>*EG buav

• Justify each of the steps in this derivation

• Wrapping up inductive case– For all possible first characters of x, we have shown

that x belongs to L(EG)

– Thus, we have proven the inductive case

• Conclusion– By the principle of mathematical induction, we have

shown that EQUAL is a subset of L(EG)

Module 31

• Closure Properties for CFL’s– Kleene Closure

• construction• examples• proof of correctness

– Others covered less thoroughly in lecture• union, concatenation

• CFL’s versus regular languages– regular languages subset of CFL

Closure Properties for CFL’s

Kleene Closure

CFL closed under Kleene Closure

• Let L be an arbitrary CFL

• Let G1 be a CFG s.t. L(G1) = L

– G1 exists by definition of L1 in CFL

• Construct CFG G2 from CFG G1

• Argue L(G2) = L*

• There exists CFG G2 s.t. L(G2) = L*

• L* is a CFL

Visualization

CFG’s

• Let G1 be a CFG s.t. L(G1) = L

– G1 exists by definition of L1 in CFL

• Construct CFG G2 from CFG G1

• Argue L(G2) = L*

• There exists CFG G2 s.t. L(G2) = L*

• L* is a CFLG1 G2

Algorithm Specification

• Input– CFG G1

• Output– CFG G2 such that L(G2) = (L(G1))*

CFG G1 CFG G2A

Construction

• Input– CFG G1 = (V1, , S1, P1)

• Output– CFG G2 = (V2, , S2, P2)

• V2 = V1 union {T}

– T is a new symbol not in V1 or

• S2 = T

• P2 = P1 union ??

Kleene Closure Examples

• Input grammar:– V = {S}

– = {a,b}

– S = S

– P: S --> aa | ab | ba | bb

• Output grammar– V = {S, T}

– = {a,b}

– Start symbol is

– P:

Example 1V2 = V1 union {T} T is a new symbol not in V1 or S2 = TP2 = P1 union {T --> ST | }

• Input grammar:– V = {S, T}

– = {a,b}

– Start symbol is T

– P:T --> ST | S --> aa | ab | ba | bb

• Output grammar– V = {S, T, U}

– = {a,b}

– Start symbol is

– P:

Example 2V2 = V1 union {T} T is a new symbol not in V1 or S2 = TP2 = P1 union {T --> ST | }

Kleene Closure Proof of Correctness

Is our construction correct?

• How do we prove our construction is correct?– Informal

• Test some strings

• Review logic behind construction

– Formal• First, show every string derived by G2 belongs to (L(G1))*

– That is, show L(G2) is a subset of (L(G1))*

• Second, show every string in (L(G1))* can be derived by G2

– That is, show (L(G1))* is a subset of L(G2)

• Both proofs will be inductive proofs– Inductive proofs and recursive algorithms go well together

L(G2) is a subset of (L(G1))*

• We want to prove the following– If x in L(G2), then x is in (L(G1))*

• This is equivalent to the following– If T ==>*

G2 x, then x is in (L(G1))*

– The two statements are equivalent because

• x in L(G2) means that T ==>*G2

• We break the second statement down as follows:– If T ==>1

– If T ==>2G2

x, then x is in (L(G1))*

– If T ==>3G2

x, then x is in (L(G1))*

– ...

L(G2) is a subset of (L(G1))*

• Statement to be proven:– For all n >= 1, if T ==>n

– Examining G2, what is the only string x such that T ==>1

G2 x ?

– Prove this string is in (L(G1))*

Inductive Case

• Inductive Hypothesis:– For 1 <= j <= n, if T ==>j

• Note, this is a “strong” induction hypothesis

• Statement to be Proven in Inductive Case:– For n above, if T ==>n+1

• Proving this statement– Let x be an arbitrary string such that T ==>n+1

– Examining G2, what are the two possible first derivation steps?

• Case 1: T ==>G2 ==>n

• Case 2: T ==>G2 ==>n

Case Analysis

• Case 1: T ==>G2 n x is not possible

– Why not?

• Case 2: T ==>G2 ==>n

– This means x has the form uv where• What can we say about u (no IH)?

• What can we say about v (no IH)?

– Applying the inductive hypothesis, what can we conclude?

Concluding Case 2: T ==>G2

==>nG2

– Concluding string u belongs to L(G1)• Follows from S ==>*

G2 u and

• Our construction insures that all strings derived from S in L(G2) are also in L(G1)

– How do we conclude that x belongs to (L(G1))*

• Wrapping up inductive case– In all possible derivations of x, we have shown that x belongs to (L(G1))* – Thus, we have proven the inductive case

• Conclusion– By the principle of mathematical induction, we have shown that L(G2) is

a subset of (L(G1))*

(L(G1))* is a subset of L(G2)

• We want to prove the following– If x is in (L(G1))*, then x is in L(G2)

• This is equivalent to the following– If x is in (L(G1))*, then T ==>*

– The two statements are equivalent because

• x in L(G2) means that T ==>*G2

• We break the second statement down as follows:– If x is in (L(G1))0, then T ==>*

– If x is in (L(G1))1, then T ==>*G2

– If x is in (L(G1))2, then T ==>*G2

– ...

(L(G1))* is a subset of L(G2)

• Statement to be proven:– For all n >= 0, if x is in (L(G1))n, then x is in L(G2)

– What is the only string x in (L(G1))0?

– Show this string belongs to L(G2)

Inductive Case

• Inductive Hypothesis:– For n>=0, if x is in (L(G1))j, then T ==>*

• Note, this is a “normal” induction hypothesis

• Statement to be Proven in Inductive Case:– For n>=0, if x is in (L(G1))n+1, then T ==>*

• Proving this statement– Let x be an arbitrary string in (L(G1))n+1

– This means x = uv where• u in L(G1)• What can we say about v?

Deriving x– x = uv where

• u is a string in L(G1)• v is a string in

– Justify all the steps in the following derivation

– T ==> G2 ST ==>*

G2 Sv ==>*

G2 uv = x

• First step:• Second step:• Third step:

– Thus T ==>* G2

• The inductive case follows• The result is proven by the principle of mathematical

induction

Construction for Set Union

• Input– CFG G1 = (V1, , S1, P1)

– CFG G2 = (V2, , S2, P2)

• Output– CFG G3 = (V3, , S3, P3)

• V3 = V1 union V2 union {T}

– Variable renaming to insure no names shared between V1 and V2

– T is a new symbol not in V1 or V2 or

• S3 = T

• P3 = P1 union P2 union {T --> }

Construction for Set Concatenation

• Input– CFG G1 = (V1, , S1, P1)

– CFG G2 = (V2, , S2, P2)

• Output– CFG G3 = (V3, , S3, P3)

• V3 = V1 union V2 union {T}

– Variable renaming to insure no names shared between V1 and V2

– T is a new symbol not in V1 or V2 or

• S3 = T

• P3 = P1 union P2 union {T --> }

CFL’s and regular languages

CFL Closure Properties

• CFL’s are closed under Kleene closure– Just proven, proof also in book

• CFL’s are closed under set union– Proof in book

• CFL’s are closed under set concatenation– Proof in book

• What can we conclude from these 3 results?– It follows that regular languages are a subset of CFL’s

Regular languages subset of CFL

• Recursive definition of regular languages– Base Case:

• {}, {}, {a}, {b} are regular languages over {a,b}

• P={}, P={S --> }, P={S --> a}, P={S --> b}

– Inductive Case:• If L1 and L2 are are regular languages, then L1*,

L1L2, L1 union L2 are regular languages

• Use previous constructions to see that these resulting languages are also context-free

Other CFL Closure Properties

• We will show that CFL’s are NOT closed under many other set operations

• Examples include– set complement

– set intersection

– set difference

Language class hierarchy

All languages over alphabet

EqualCFLREC

Module 32

• Pushdown Automata (PDA’s)– definition– Example

• We define configurations and computations of PDA’s

• We define L(M) for PDA’s

Pushdown Automata

Definition and Motivating Example

Pushdown Automata (PDA)

• In this presentation we introduce the PDA model of computation (programming language).– The key addition to a PDA (from an NFA-/\) is

the addition of external memory in the form of an infinite capacity stack

• The word “pushdown” comes from the stacks of trays in cafeterias where you have to pushdown on the stack to add a tray to it.

NFA for {ambn | m,n >= 0}

• What strings end up in each state of the above NFA?– I:

– B:

– C:

• Consider the language {anbn | n >= 0}.

• This NFA can recognize strings which have the correct form, – a’s followed by b’s.

• However, the NFA cannot remember the relative number of a’s and b’s seen at any point in time.

PDA for {anbn | n >=0 } *

Imagine we now have memory in the form of a stack which we can use to help remember how many a’s we have seen by pushing onto and popping from the stack

When we see an a in state I, we do the following two actions:1) We push an a on the stack.2) We stay in state I.

When we see a b in state B, we do the following two actions:1) We pop an a from the stack.2) We stay in state B.

From state B, we allow a /\-transition to state C only if1) The stack is empty.

Finally, when we begin, the stack should be empty.

b;popa;push a

/\;only if stack is empty

Initialize stack to empty

Formal PDA definition

• PDA M = (Q, , , q0, Z, A, )

• Modified elements– is the stack alphabet

• Z is a special character that is initially on the stack

• Often used to represent an empty stack

– is modified as follows• Pop to read the top character on the stack

• Stack update action– What to push back on the stack

– If we push /\, then the net result of the action is a pop

Example PDAQ = {I, B, C} = {a,b} = {Z, a}q0 = IZ is the initial stack characterA = {C}:

S a TopSt NS stack update

I a a I push aaI a Z I push aZI /\ a B push aI /\ Z B push ZB b a B push /\B /\ Z C push Z

b;a;/\a;a; aaa;Z; aZ

/\;Z;Z/\;a;a /\;Z;Z

Example PDA

Initialize stack toonly contain Z

Computing with PDA’s *

• Configurations change compared with NFA-/\’s– Configuration components:

• current state• remaining input to be processed• stack contents

• Computations are essentially the same as with NFA-/\’s given the modified configurations– Determining which transitions of a PDA can be

applied to a given configuration is more complicated though

Computation Graph of PDA

Computation graph for this PDA on the input string aabb

(I,aabb,Z)

(C,aabb,Z)

(B,bb,aaZ)

(B,abb,aZ)(I,bb,aaZ)

(I,abb,aZ) (B,aabb,Z)

(B,b,aZ)

(B,/\,Z)

(C,/\,Z)

Q = {I, B, C} = {a,b} = {Z, a}q0 = IZ is the initial stack characterA = {C}:

S a TopSt NS stack updateI a a I push aaI a Z I push aZI /\ a B push aI /\ Z B push ZB b a B push /\B /\ Z C push Z

Definition of |- Input string aabb

(I, aabb, Z) |- (I,abb,aZ)

(I, aabb, Z) |- (B, aabb, Z)

(I, aabb, Z) |-2 (C, aabb, Z)

(I, aabb, Z) |-3 (B, bb, aaZ)

(I, aabb, Z) |-* (B, abb, aZ)

(I, aabb, Z) |-* (B, /\, Z)

(I, aabb, Z) |-* (C, /\, Z)

/\;Z;Z/\;a;a /\;Z;Z

(I,aabb,Z)

(C,aabb,Z)

(B,bb,aaZ)

(B,b,aZ)

(B,/\,Z)

(C,/\,Z)

Acceptance and Rejection

M accepts string x if one of the configurations reached is an accepting configuration

(q0, x, Z) |-* (f, /\),f in A, in *

Stack contents can be anything

M rejects string x if all configurations reached are either not halting configurations or are rejecting configurations

/\;Z;Z/\;a;a /\;Z;Z

Input string aabb

(I,aabb,Z)

(C,aabb,Z)

(B,bb,aaZ)

(B,b,aZ)

(B,/\,Z)

(C,/\,Z)

Not an accepting configuration since input not completely processed

Not an accepting configuration since state is not accepting

An accepting configuration

Defining L(M) and LPDA

• L(M) (or Y(M)) – The set of strings ?

• N(M)– The set of strings ?

• LPDA– Language L is in language

class LPDA iff ?

M accepts string x if one of the configurations reached is an accepting configuration

(q0, x, Z) |-* (f, /\),f in A, in *

Stack contents can be anything

M rejects string x if all configurations reached are either not halting configurations or are rejecting configurations

Deterministic PDA’s

• A PDA is deterministic if its transition function satisfies both of the following properties– For all q in Q, a in union {/\}, and X in ,

• the set (q,a,X) has at most one element

– For all q in Q and X in G,• if (q, /\, X) < > { }, then (q,a,X) = { } for all a in

• A computation graph is now just a path again• Our default assumption is that PDA’s are

nondeterministic

Two forms of nondeterminism

Trans Current Input Top of Next Stack# State Char. Stack State Update-------------------------------------------------------1 q0 a Z q0 aZ2 q0 a Z q0 aa

3 q0 /\ Z q0 aZ4 q0 a Z q0 aa

LPDA and DCFL

• A language L is in language class LPDA if and only if there exists a PDA M such that L(M) = L

• A language L is in language class DCFL (Deterministic Context-Free Languages) if and only if there exists a deterministic PDA M such that L(M) = L

• To be proven– LPDA = CFL – CFL is a proper superset of DCFL

PDA Comments

• Note, we can use the stack for much more than just a counter

• See examples in chapter 7 for some details

Module 33

• Pushdown Automata (PDA’s)– Another example

Palindromes

• Let PAL be the set of palindromes over {a,b}– Let PAL1 be the following related language:

• {wcwr | w consists only of a’s and b’s}– we add c to the input alphabet as a special “marker” character

– Strings in PAL1

» aca, bcb, abcba, aabcbaa, c

– strings not in PAL1

» aaca, aaccaa, abccba, abcb, abba

– Let PAL2 be the set of even length palindromes• {wwr | w consists only of a’s and b’s}

• Lets first construct a PDA for PAL1

• Basic ideas– Have one state remember first “half” of string– Have one state “match” second half of string to

first half– Transition between these two states when the

first c is encountered

PDA for PAL1

• M = (Q, , , q0, Z, A, )

– Q = {q0, qm, qf}

– = {a, b, c}– = {Z, a, b}

– q0 = q0

– Z = Z

– A = {qf}

Transition FunctionTrans Current Input Top of Next Stack# State Char. Stack State Update-------------------------------------------------------1 q0 a Z q0 aZ2 q0 a a q0 aa3 q0 a b q0 ab

4 q0 b Z q0 bZ5 q0 b a q0 ba6 q0 b b q0 bb

7 q0 c Z qm Z8 q0 c a qm a9 q0 c b qm b

10 qm a a qm 11 qm b b qm 12 qm Z qf Z

First three transitions push a on top of the stack

Second three transitions push b on the stack

Third three transitions switch state q0 to qm

No change to stack

Transitions 10 and 11 “match” characters from first and last half of input string

Notation comment

We might represent transition 1 in two other ways

(q0,a,Z) = (q0, aZ)

(q0, a, Z, q0, aZ)

•Question

•Is this PDA deterministic?

Trans Current Input Top of Next Stack# State Char. Stack State Update-------------------------------------------------------1 q0 a Z q0 aZ2 q0 a a q0 aa3 q0 a b q0 ab

Computation Graph 1

(q0, abcba, Z)

(q0, bcba, aZ)

(q0, cba, baZ)

(qm, ba, baZ)

(qm, a, aZ)

(qm, , Z)

(qf, , Z)

Computation Graph 2

(q0, abcab, Z)

(q0, bcab, aZ)

(q0, cab, baZ)

(qm, ab, baZ)

Computation Graph 3

(q0, acab, Z)

(q0, cab, aZ)

(qm, ab, aZ)

(qm, b, Z)

(qf, b, Z)

• Lets now construct a PDA for PAL• What is harder this time?

– When do we switch from putting strings on the stack to matching?

– Example• After seeing aab, should we switch to match mode or

stay in stack mode?

– Solution• Do both using nondeterminism

PDA for PAL2

• M = (Q, , , q0, Z, A, )

– Q = {q0, qm, qf}

– = {a, b}– = {Z, a, b}

– q0 = q0

– Z = Z

– A = {qf}

Transition RelationTrans Current Input Top of Next Stack# State Char. Stack State Update-------------------------------------------------------1 q0 a Z q0 aZ2 q0 a a q0 aa3 q0 a b q0 ab

7 q0 Z qm Z8 q0 a qm a9 q0 b qm b

First three transitions push a on top of the stack

Second three transitions push b on the stack

Third three transitions switch state q0 to qm

Is the PDA deterministic or nondeterministic?

Computation Graph 1

(q0, abba, Z)

(q0, bba, aZ) (qm, abba, Z)

(q0, ba, baZ) (qm, bba, aZ) (qf, abba, Z)

(q0, a, bbaZ) (qm, ba, baZ)

(q0, , abbaZ)(qm, a, bbaZ)

(qm, a, aZ)

(qm, , abbaZ) (qm, , Z)

(qf, , Z)

Computation Graph 2

(q0, aba, Z)

(q0, ba, aZ) (qm, aba, Z)

(q0, a, baZ) (qm, ba, aZ) (qf, aba, Z)

(q0, , abaZ) (qm, a, baZ)

(qm, , abaZ)

• Challenge– Construct a PDA for PAL– First step

• Construct a PDA for odd length palindromes

– Then • Combine PDA’s for odd length and even length

palindromes

Module 34

• CFG --> PDA construction– Shows that for any CFL L, there exists a PDA

M such that L(M) = L– The reverse is true as well, but we do not prove

that here

CFL subset LPDA

• Let G be the CFG such that L(G) = L– G exists by definition of L is CF

• Construct a PDA M such that L(M) = L– M is constructed from CFG G

• Argue L(M) = L

• There exists a PDA M such that L(M) = L

• L is in LPDA– By definition of L in LPDA

Visualization

CFLLPDA

CFG’s PDA’s

•Let L be an arbitrary CFL•Let G be the CFG such that L(G) = L

•G exists by definition of L is CF•Construct a PDA M such that L(M) = L

•M is constructed from CFG G•Argue L(M) = L•There exists a PDA M such that L(M) = L•L is in LPDA

•By definition of L in LPDA

• Input– CFG G

• Output– PDA M such that L(M) = L(G)

CFG G PDA MA

Construction Idea

• The basic idea is to have a 2-phase PDA– Phase 1:

• Derive all strings in L(G) on the stack nondeterministically

• Do not process any input while we are deriving the string on the stack

– Phase 2: • Match the input string against the derived string on the stack

– This is a deterministic process

• Move to an accepting state only when the stack is empty

Illustration

• Input Grammar G– V = {S}– = {a,b}– S = S– P:

S --> aSb |

• What is L(G)?

1. Derive all strings in L(G) on the stack2. Match the derived string against input

(q0, aabb, Z)/* put S on stack */

(q1, aabb, SZ)/* derive aabb on stack */

(q1, aabb, aSbZ)(q1, aabb, aaSbbZ)(q1, aabb, aabbZ)

/* match stack vs input */(q2, aabb, aabbZ)(q2, abb, abbZ)(q2, bb, bbZ)(q2, b, bZ)(q2,, Z)

(q3, , Z)

Illustration of how the PDA might work,though not completely accurate.

Difficulty 1. Derive all strings in L(G) on the stack2. Match the derived string against input

(q0, aabb, Z)/* put S on stack */

(q1, aabb, SZ)/* derive aabb on stack */

(q1, aabb, aSbZ)(q1, aabb, aaSbbZ)(q1, aabb, aabbZ)

/* match stack vs input */(q2, aabb, aabbZ)(q2, abb, abbZ)(q2, bb, bbZ)(q2, b, bZ)(q2,, Z)

(q3, , Z)

What is illegal with the computation graph on the left?

Construction• Input Grammar

– G=(V,, S, P)

• Output PDA – M=(Q, , , q0, Z, F, )

– Q = {q0, q1, q2}

– = – = V union union {Z}

– Z = Z

– q0 = q0

– F = {q2}

• :– (q0, , Z) = (q1, SZ)

– (q1, , Z) = (q2, Z)

– For all productions A --> • q1, , A) = (q1, )

– For all a in • q1, a, a) = (q1, )

Examples

Palindromes• PALG:

– V = {S}

– = {a,b}

– S = S

– P:• S --> aSa | bSb | a | b |

• Output PDA M=(Q,,q0,Z,F,)

– Q = {q0, q1, q2}

– = {a,b,S,Z}

– q0 = q0

– Z = Z

– F = {q2}

– (q0, , Z) = (q1, SZ)

– (q1, , Z) = (q2, Z)

– Production Transitions• q1, , S) = (q1, aSa)

• q1, , S) = (q1, bSb)

• q1, , S) = (q1, a)

• q1, , S) = (q1, b)

• q1, , S) = (q1, )

– Matching transitions• q1, a, a) = (q1, )

• q1, b, b) = (q1, )

Palindrome Transition Table

Transition Current Input Top of Next StackNumber State Symbol Stack State Update--------------------------------------------------------------------------------- 1 q0 Z q1 SZ 2 q1 Z q2 Z 3 q1 S q1 aSa 4 q1 S q1 bSb 5 q1 S q1 a 6 q1 S q1 b 7 q1 S q1 8 q1 a a q1 9 q1 b b q1

Partial Computation Graph(q0, aba, Z) (q1, aba, SZ) (q1, aba, aSaZ) (other branches not shown)(q1, ba, SaZ)(q1, ba, baZ) (other branches not shown)(q1, a, aZ)(q1, , Z)(q2, , Z)

On your own, draw computation trees for other stringsnot in the language and see that they are not accepted.

{anbn | n >= 0}• Grammar G:

– V = {S}

– = {a,b}

– S = S

– P:• S --> aSb |

– Q = {q0, q1, q2}

– = {a,b,S,Z}

– q0 = q0

– Z = Z

– F = {q2}

– (q0, , Z) = (q1, SZ)

– (q1, , Z) = (q2, Z)

– Production Transitions•

– Matching transitions

{anbn | n >= 0} Transition Table

Transition Current Input Top of Next StackNumber State Symbol Stack State Update--------------------------------------------------------------------------------- 1 q0 Z 2 q1 Z 3 q1 S 4 q1 S 5 q1 a a 6 q1 b b

Partial Computation Graph

(q0, aabb, Z) (q1, aabb, SZ) (q1, aabb, aSbZ) (other branch not shown)(q1, abb, SbZ)(q1, abb, aSbbZ) (other branch not shown)(q1, bb, SbbZ)(q1, bb, bbZ) (other branch not shown)(q1, b, bZ)(q1, , Z) (q2, , Z)

{aibj | i = j or i = 2j}• Grammar G:

– V = {S,T,U}

– = {a,b}

– S = S

– P:• S --> T | U

• T --> aTb | • U --> aaUb |

– Q = {q0, q1, q2}

– = {a,b,S,T,U,Z}

– q0 = q0

– Z = Z

– F = {q2}

• – (q0, , Z) = (q1, SZ)

– (q1, , Z) = (q2, Z)

– Production Transitions• q1, , S) = (q1, T)

• q1, , S) = (q1, U)

• q1, , T) = (q1, aTb)

• q1, , T) = (q1, )

• q1, , U) = (q1, aaUb)

• q1, , U) = (q1, )

– Matching transitions• q1, a, a) = (q1, )

• q1, b, b) = (q1, )

{aibj | i = j or i = 2j} Transition Table

Transition Current Input Top of Next StackNumber State Symbol Stack State Update--------------------------------------------------------------------------------- 1 q0 Z q1 SZ 2 q1 Z q2 Z 3 q1 S q1 T 4 q1 S q1 U 5 q1 T q1 aTb 6 q1 T q1 7 q1 U q1 aaUb 8 q1 U q1 9 q1 a a q1 10 q1 b b q1

Partial Computation Graph

(q0, aab, Z) (q1, aab, SZ) (q1, aab, UZ) (other branch not shown)(q1, aab, aaUbZ) (other branch not shown)(q1, ab, aUbZ)(q1, b, UbZ)(q1, b, bZ) (other branch not shown)(q1, , Z) (q2, , Z)

Things you should be able to do

• You should be able to execute this algorithm– Given any CFG, construct an equivalent PDA

• You should understand the idea behind this algorithm– Derive string on stack and then match it against input

• You should understand how this construction can help you design PDA’s

• You should understand that it can be used in answer-preserving input transformations between decision problems about CFL’s.

Module 35

• Attempt to prove that CFL’s are closed under intersection– Review previous constructions– Translate previous constructions to current

setting– Prove modified result

High Level Overview

CFL closed under set intersection

• Let L1 and L2 be arbitrary CFL’s

• Let M1 and M2 be PDA’s s.t. L(M1) = L1, L(M2) = L2

– M1 and M2 exist by definition of L1 and L2 are CFL’s and the fact that for every CFG, there is an equivalent PDA

• Construct PDA M3 from PDA’s M1 and M2

• Argue L(M3) = L1 intersect L2

• There exists a PDA M3 s.t. L(M3) = L1 intersect L2

• L1 intersect L2 is a CFL

Visualization

•Let L1 and L2 be arbitrary CFL’s•Let M1 and M2 be PDA’s s.t. L(M1) = L1, L(M2) = L2

•M1 and M2 exist by definition of L1 and L2 are CFL’s and the fact that for every CFG, there is an equivalent PDA

•Construct PDA M3 from PDA’s M1 and M2

•Argue L(M3) = L1 intersect L2

•There exists a PDA M3 s.t. L(M3) = L1 intersect L2

•L1 intersect L2 is a CFL

L1 intersect L2

PDA’s

• Input– Two PDA’s M1 and M2

• Output– PDA M3 such that L(M3) = L(M1) intersection L(M2)

PDA M1

PDA M2

PDA M3A

Review Previous Results

Underlying Idea

• Previous Results– recursive languages are closed under set intersection

– r.e. languages are closed under set intersection

– regular languages are closed under set intersection

• What is the idea underlying the constructions used to prove these previous results?

Implementation with FSA’s *

• Given the basic idea underlying these constructions, how was this idea implemented in when dealing with FSA’s?

• That is, restate the construction used to prove that the regular languages are closed under set intersection.– Specify the output FSA in terms of the input FSA’s

Applying previous approach to PDA’s

Applying approach to PDA’s *

• Given the basic idea underlying these constructions, try and implement this idea in a construction working with PDA’s rather than FSA’s.

• That is, give a construction specifying how the output PDA is built out of the input PDA’s

Problem

• Describe what goes wrong when applying this idea to PDA’s instead of FSA’s.

• Does this prove that CFL’s are NOT closed under set intersection?

Modified Result *

• What happens if the inputs are 1 FSA and 1 PDA?

• What modified result does the resulting construction prove?

Module 36

• Non context-free languages– Examples and Intuition

• Pumping lemma for CFL’s– Pumping condition– No proof of pumping lemma– Applying pumping lemma to prove that some

languages are not CFL’s

Examples and Intuition

Examples

• What are some examples of nonregular languages?

• Can we build on any of these languages to create a non context-free language?

Intuition

• Try and prove that these languages are CFL’s and identify the stumbling blocks– Why can’t we construct a CFG to generate this language?

– Why can’t we construct a PDA to accept this language?

– Compare to similar CFL languages to try and identify differences.

Pumping Lemma for CFL’s

Comparison to regular language pumping lemma/condition

What’s different about CFL’s than regular languages? *

• In regular languages, a single substring “pumps”– Consider the language of even length strings over {a,b}– We can identify a single substring which can be pumped

• In CFL’s, multiple substrings can “pump”– Consider the language {anbn | n > 0}– No single substring can be pumped and allow us to stay in the

language– However, there do exist pairs of substrings which can be

pumped resulting in strings which stay in the language

• This results in a modified pumping condition

Modified Pumping Condition

• A language L satisfies the regular language pumping

condition if: – there exists an integer n > 0

such that

– for all strings x in L of length at least n

– there exist strings u, v, w such that

• x = uvw and

• |uv| <= n and

• |v| >= 1 and

• For all k >= 0, uvkw is in L

• A language L satisfies the CFL

pumping condition if: – there exists an integer n > 0

such that

– there exist strings u, v, w, y, z such that

• x = uvwyz and

• |vwy| <= n and

• |vy| >= 1 and

• For all k >= 0, uvkwykz is in L

Pumping Lemma

• All CFL’s satisfy the CFL pumping condition

All languages over {a,b}

CFL’s

“Pumping Languages”

Implications

• We can use the pumping lemma to prove a language L is not a CFL– Show L does not satisfy the CFL pumping

condition

• We cannot use the pumping lemma to prove a language is context-free– Showing L satisfies the pumping condition does

not guarantee that L is context-free

Pumping

Pumping Lemma

What does it mean?

Pumping Condition

• A language L satisfies the CFL pumping condition if: – there exists an integer n > 0 such that

– there exist strings u, v, w, y, z such that• x = uvwyz and

• |vwy| <= n and

• |vy| >= 1 and

v and y can be pumped

• Let x = abcdefg be in L• Then there exist 2 substrings v and y in x such that v and y can

be repeated (pumped) in place any number of times and the resulting string is still in L– uvkwykz is in L for all k >= 0

• For example– v = cd and y = f

• uv0wy0z = uwz = abeg is in L• uv1wy1z = uvwyz = abcdefg is in L• uv2wy2z = uvvwyyz = abcdcdeffg is in L• uv3wy3z = uvvvwyyyz = abcdcdcdefffg is in L • …

1) x in L2) x = uvwyz3) For all k >= 0, uvkwykz is in L

What the other parts mean• A language L satisfies the CFL pumping condition if:

– there exists an integer n > 0 such that• Since we skip this proof, we will not see what n really means

– for all strings x in L of length at least n• x must be in L and have sufficient length

– there exist strings u, v, w, y, z such that• x = uvwyz and

• |vwy| <= n and– v and y are contained within n characters of x– Note: these are NOT necessarily the first n characters of x

• |vy| >= 1 and– v and y cannot both be – One of them might be , but not both

Example

• Let L be the set of palindromes over {a,b}– Let x = aabaa

– Let n = 3

– What are the possibilities for v and y ignoring the pumping constraint?

– Which ones satisfy the pumping lemma?

Pumping Lemma

Applying it to prove a specific language L is not context-free

How we use the Pumping Lemma

• We choose a specific language L– For example, {ajbjcj | j > 0}

• We show that L does not satisfy the pumping condition

• We conclude that L is not context-free

Showing L “does not pump”

• A language L satisfies the CFL

pumping condition if: – there exists an integer n > 0

such that

– there exist strings u, v, w, y, z such that

• x = uvwyz and

• |vwy| <= n and

• |vy| >= 1 and

• A language L does not satisfy

the CFL pumping condition if: – for all integers n of sufficient

– there exists a string x in L of length at least n such that

– for all strings u, v, w, y, z such that

• x = uvwyz and

• |vwy| <= n and

• |vy| >= 1

– There exists a k >= 0 such that uvkwykz is not in L

Example Proof

• A language L does not satisfy

the CFL pumping condition if: – for all integers n of sufficient

– there exists a string x in L of length at least n such that

– for all strings u, v, w, y, z such that

• x = uvwyz and

• |vwy| <= n and

• |vy| >= 1

– There exists a k >= 0 such that uvkwykz is not in L

• Proof that L = {aibici | i>0} does not satisfy the CFL pumping condition

• Let n be the integer from the pumping lemma

• Choose x = anbncn

• Consider all strings u, v, w, y, z s.t.• x = uvwyz and

• |vwy| <= n and

• |vy| >= 1

• Argue that uvkwykz is not in L for some k >= 0

– Argument must apply to all possible u,v,w,y,z

– Continued on next slide

Example Proof Continued• Proof that L = {aibici | i>0} does not

satisfy the CFL pumping condition

• Let n be the integer from the pumping lemma

• Choose x = anbncn

• Consider all strings u, v, w, y, z s.t.• x = uvwyz and

• |vwy| <= n and

• |vy| >= 1

• Argue that uvkwykz is not in L for some k >= 0– Argument must apply to all possible

u,v,w,y,z

– Continued next column

• Identify possible cases for vwy• What is impossible for vwy?

• Case 1– vwy contains no a’s

• Case 2– vwy contains no c’s

• Must argue uvkwykz is not in L for both cases described above– Can use different values of k– Continued on next slide

Example Proof Continued

• Identify possible cases for vwy• What is impossible for vwy?

• Case 1– vwy contains no a’s

• Case 2– vwy contains no c’s

• Must argue uvkwykz is not in L for both cases described above– Can use different values of k– Continued next column

• Case 1: vwy contains no a’s– vy contains at least 1 b or c

• follows from – vwy contains no a’s and– |vy| >= 1

– uwz is not in L• uwz has n a’s

– follows from fact vwy contains no a’s and x originally had n a’s

• uwz has fewer than n b’s or fewer than n c’s

– follows from vy contains at least 1 b or c and x originally only had n b’s and n c’s

• Continued next slide

Example Proof Continued

• Case 1: vwy contains no a’s– vy contains at least 1 b or c

• follows from – vwy contains no a’s and– |vy| >= 1

– uwz is not in L• uwz has n a’s

– follows from fact vwy contains no a’s and x originally had n a’s

• uwz has fewer than n b’s or fewer than n c’s

– follows from vy contains at least 1 b or c and x originally only had n b’s and n c’s

• Continued next column

• Case 2: vwy contains no c’s– vy contains at least

– uv2wy2z is not in L• uv2wy2z has n c’s

– follows from fact vwy contains no c’s and x originally had n c’s

• uv2wy2z has more than n a’s or more than n b’s

– follows from vy contains at least 1 a or b and x originally has n a’s and n b’s

• Continued next slide

Example Proof Completed

• For all possible u, v, w, y, z, we have shown there exists a k>=0 such that– uvkwykz is not in L

• Note, we used a different value of k for each case (though we didn’t have to)

• Therefore L does not satisfy the CFL pumping condition

• There L is not a CFL

• Case 2: vwy contains no c’s– vy contains at least

– uv2wy2z is not in L• uv2wy2z has n c’s

– follows from fact vwy contains no c’s and x originally had n c’s

• uv2wy2z has more than n a’s or more than n b’s

– follows from vy contains at least 1 a or b and x originally has n a’s and n b’s

• Continued next column

Other example languages

• TWOCOPIES = {ww | w is in {a,b}* }– abbabb is in TWOCOPIES but abaabb is not

• EQUAL3 = the set of strings over {a, b, c} such that the number of a’s equals the number of b’s equals the number of c’s

• {aibjck | i < j < k}

Pumping Lemma

Two rules of thumb

Two Rules of Thumb

• Try to use blocks of at least n characters in x– For TWOCOPIES, choose x = anbnanbn rather than

anbanb• Guarantees v and y cannot be in more than 2 blocks of x

• Try k=0 or k=2– k=0

• This reduces number of occurrences of v and y

– k=2• This increases number of occurrences of v and y

Summary

• We use the Pumping Lemma to prove a language is not a CFL– Note, does not work for all non CFL languages– Can be strengthened to Ogden’s Lemma

• In book

• Choosing a good string x is first key step

• Choosing a good k is second key step

• Typically have several cases for v, w, y

Module 37

• Showing CFL’s not closed under set intersection and set complement

Nonclosure Properties for CFL’s

CFL’s not closed under set intersection

• How can we prove that CFL’s are not closed under set intersection?

Counterexample

• What is a possible L1 intersect L2?

– What non-CFL languages do we know?

• What could L1 and L2 be?

– L1 =

– L2 =

– How can we prove that L1 and L2 are context-free?

CFL’s not closed under complement

• How can we prove that CFL’s are not closed under complement?

– Another way• Use fact that any language class which is closed

under union and complement must also be closed under intersection

Language class hierarchy

All languages over alphabet

EqualCFLREC

Equal-3

1 Module 28 Context Free Grammars –Definition of a grammar G –Deriving strings and defining L(G)...

Documents