Properties of Context-Free Languages

Slides:



Advertisements
Similar presentations
&& Department of nskinfo-i educationwww.nsksofttch.com CS2303-THEORY OF COMPUTATION uChapter: Closure.
Advertisements

6.2 Closure Properties of CFL's
The Pumping Lemma for CFL’s
Theory of Computation CS3102 – Spring 2014 A tale of computers, math, problem solving, life, love and tragic death Nathan Brunelle Department of Computer.
Closure Properties of CFL's
1 Parse Trees Definitions Relationship to Left- and Rightmost Derivations Ambiguity in Grammars.
Simplifying CFGs There are several ways in which context-free grammars can be simplified. One natural way is to eliminate useless symbols those that cannot.
1 Chomsky Normal Form of CFG’s Definition Purpose Method of Constuction.
1 More Undecidable Problems Rice’s Theorem Post’s Correspondence Problem Some Real Problems.
1 Introduction to Computability Theory Lecture12: Decidable Languages Prof. Amos Israeli.
Introduction to Computability Theory
1 Introduction to Computability Theory Lecture7: PushDown Automata (Part 1) Prof. Amos Israeli.
1 Positive Properties of Context-Free languages. 2 Context-free languages are closed under: Union is context free is context-free.
Conversion of CFG to PDA Conversion of PDA to CFG
Lecture Note of 12/22 jinnjy. Outline Chomsky Normal Form and CYK Algorithm Pumping Lemma for Context-Free Languages Closure Properties of CFL.
Courtesy Costas Busch - RPI1 NPDAs Accept Context-Free Languages.
Normal Forms for CFG’s Eliminating Useless Variables Removing Epsilon
The Pumping Lemma for CFL’s
CS Master – Introduction to the Theory of Computation Jan Maluszynski - HT Lecture 4 Context-free grammars Jan Maluszynski, IDA, 2007
1 Context-Free Grammars Formalism Derivations Backus-Naur Form Left- and Rightmost Derivations.
Nondeterministic Finite Automata
Normal forms for Context-Free Grammars
Transparency No. P2C5-1 Formal Language and Automata Theory Part II Chapter 5 The Pumping Lemma and Closure properties for Context-free Languages.
January 23, 2015CS21 Lecture 81 CS21 Decidability and Tractability Lecture 8 January 23, 2015.
Definitions Equivalence to Finite Automata
Today Chapter 2: (Pushdown automata) Non-CF languages CFL pumping lemma Closure properties of CFL.
Decision Properties of Regular Languages
1 Closure Properties of Regular Languages Union, Intersection, Difference, Concatenation, Kleene Closure, Reversal, Homomorphism, Inverse Homomorphism.
Nathan Brunelle Department of Computer Science University of Virginia Theory of Computation CS3102 – Spring 2014 A tale.
INHERENT LIMITATIONS OF COMPUTER PROGAMS CSci 4011.
Undecidability Everything is an Integer Countable and Uncountable Sets
CSE 3813 Introduction to Formal Languages and Automata Chapter 8 Properties of Context-free Languages These class notes are based on material from our.
Introduction to CS Theory Lecture 3 – Regular Languages Piotr Faliszewski
1 CD5560 FABER Formal Languages, Automata and Models of Computation Lecture 11 Midterm Exam 2 -Context-Free Languages Mälardalen University 2005.
Pushdown Automata Chapters Generators vs. Recognizers For Regular Languages: –regular expressions are generators –FAs are recognizers For Context-free.
Context-Free and Noncontext-Free Languages Chapter 13 1.
Closure Properties Lemma: Let A 1 and A 2 be two CF languages, then the union A 1  A 2 is context free as well. Proof: Assume that the two grammars are.
Review for final pm. 2 Review for Midterm Induction – On integer: HW1, Ex 2.2.9b p54 – On length of string: Ex p53, HW2, HW3.
1 Decision Properties of Regular Languages General Discussion of “Properties” The Pumping Lemma Minimizing DFA.
Foundations of (Theoretical) Computer Science Chapter 2 Lecture Notes (Section 2.2: Pushdown Automata) Prof. Karen Daniels, Fall 2010 with acknowledgement.
Context-Free and Noncontext-Free Languages Chapter 13.
Pumping Lemma for CFLs. Theorem 7.17: Let G be a CFG in CNF and w a string in L(G). Suppose we have a parse tree for w. If the length of the longest path.
1 Closure Properties of Regular Languages Union, Intersection, Difference, Concatenation, Kleene Closure, Reversal, Homomorphism.
1 CD5560 FABER Formal Languages, Automata and Models of Computation Lecture 9 Mälardalen University 2006.
Grammars A grammar is a 4-tuple G = (V, T, P, S) where 1)V is a set of nonterminal symbols (also called variables or syntactic categories) 2)T is a finite.
Chapter 8 Properties of Context-free Languages These class notes are based on material from our textbook, An Introduction to Formal Languages and Automata,
CSCI 2670 Introduction to Theory of Computing October 13, 2005.
Donghyun (David) Kim Department of Mathematics and Physics North Carolina Central University 1 Chapter 2 Context-Free Languages Some slides are in courtesy.
CSCI 4325 / 6339 Theory of Computation Zhixiang Chen Department of Computer Science University of Texas-Pan American.
Grammar Set of variables Set of terminal symbols Start variable Set of Production rules.
Theory of Languages and Automata By: Mojtaba Khezrian.
 2005 SDU Lecture11 Decidability.  2005 SDU 2 Topics Discuss the power of algorithms to solve problems. Demonstrate that some problems can be solved.
1 Use the pumping theorem for context-free languages to prove that L= { a n b a n b a p : n, p ≥ 0, p ≥ n } is not context-free. Hint: For the pumping.
Lecture 16 Cocke-Younger-Kasimi Parsing Topics: Closure Properties of Context Free Languages Cocke-Younger-Kasimi Parsing Algorithm June 23, 2015 CSCE.
General Discussion of “Properties” The Pumping Lemma Membership, Emptiness, Etc.
Closed book, closed notes
Properties of Context-Free Languages
Closure Properties of Regular Languages
7. Properties of Context-Free Languages
PDAs Accept Context-Free Languages
Decision Properties of Regular Languages
COSC 3340: Introduction to Theory of Computation
4. Properties of Regular Languages
7. Properties of Context-Free Languages
Deterministic PDAs - DPDAs
Closure Properties of Context-Free languages
Closure Properties of Regular Languages
The Pumping Lemma for CFL’s
Properties of Context-Free languages
Closure Properties of Regular Languages
Presentation transcript:

Properties of Context-Free Languages Decision Properties Closure Properties

Summary of Decision Properties As usual, when we talk about “a CFL” we really mean “a representation for the CFL, e.g., a CFG or a PDA accepting by final state or empty stack. There are algorithms to decide if: String w is in CFL L. CFL L is empty. CFL L is infinite.

Non-Decision Properties Many questions that can be decided for regular sets cannot be decided for CFL’s. Example: Are two CFL’s the same? Example: Are two CFL’s disjoint? How would you do that for regular languages? Need theory of Turing machines and decidability to prove no algorithm exists.

Testing Emptiness We already did this. We learned to eliminate variables that generate no terminal string. If the start symbol is one of these, then the CFL is empty; otherwise not.

Testing Membership Want to know if string w is in L(G). Assume G is in CNF. Or convert the given grammar to CNF. w = ε is a special case, solved by testing if the start symbol is nullable. Algorithm (CYK ) is a good example of dynamic programming and runs in time O(n3), where n = |w|.

CYK Algorithm Let w = a1…an. We construct an n-by-n triangular array of sets of variables. Xij = {variables A | A =>* ai…aj}. Induction on j–i+1. The length of the derived string. Finally, ask if S is in X1n.

CYK Algorithm – (2) Basis: Xii = {A | A -> ai is a production}. Induction: Xij = {A | there is a production A -> BC and an integer k, with i < k < j, such that B is in Xik and C is in Xk+1,j.

Example: CYK Algorithm Grammar: S -> AB, A -> BC | a, B -> AC | b, C -> a | b String w = ababa X12={B,S} X23={A} X34={B,S} X45={A} X11={A,C} X22={B,C} X33={A,C} X44={B,C} X55={A,C}

Example: CYK Algorithm Grammar: S -> AB, A -> BC | a, B -> AC | b, C -> a | b String w = ababa X13={} Yields nothing X12={B,S} X23={A} X34={B,S} X45={A} X11={A,C} X22={B,C} X33={A,C} X44={B,C} X55={A,C}

Example: CYK Algorithm Grammar: S -> AB, A -> BC | a, B -> AC | b, C -> a | b String w = ababa X13={A} X24={B,S} X35={A} X12={B,S} X23={A} X34={B,S} X45={A} X11={A,C} X22={B,C} X33={A,C} X44={B,C} X55={A,C}

Example: CYK Algorithm Grammar: S -> AB, A -> BC | a, B -> AC | b, C -> a | b String w = ababa X14={B,S} X13={A} X24={B,S} X35={A} X12={B,S} X23={A} X34={B,S} X45={A} X11={A,C} X22={B,C} X33={A,C} X44={B,C} X55={A,C}

Example: CYK Algorithm Grammar: S -> AB, A -> BC | a, B -> AC | b, C -> a | b String w = ababa X15={A} X14={B,S} X25={A} X13={A} X24={B,S} X35={A} X12={B,S} X23={A} X34={B,S} X45={A} X11={A,C} X22={B,C} X33={A,C} X44={B,C} X55={A,C}

Testing Infiniteness The idea is essentially the same as for regular languages. Use the pumping lemma constant n. If there is a string in the language of length between n and 2n-1, then the language is infinite; otherwise not. Let’s work this out in class.

Closure Properties of CFL’s CFL’s are closed under union, concatenation, and Kleene closure. Also, under reversal, homomorphisms and inverse homomorphisms. But not under intersection or difference.

Closure of CFL’s Under Union Let L and M be CFL’s with grammars G and H, respectively. Assume G and H have no variables in common. Names of variables do not affect the language. Let S1 and S2 be the start symbols of G and H.

Closure Under Union – (2) Form a new grammar for L  M by combining all the symbols and productions of G and H. Then, add a new start symbol S. Add productions S -> S1 | S2.

Closure Under Union – (3) In the new grammar, all derivations start with S. The first step replaces S by either S1 or S2. In the first case, the result must be a string in L(G) = L, and in the second case a string in L(H) = M.

Closure of CFL’s Under Concatenation Let L and M be CFL’s with grammars G and H, respectively. Assume G and H have no variables in common. Let S1 and S2 be the start symbols of G and H.

Closure Under Concatenation – (2) Form a new grammar for LM by starting with all symbols and productions of G and H. Add a new start symbol S. Add production S -> S1S2. Every derivation from S results in a string in L followed by one in M.

Closure Under Star Let L have grammar G, with start symbol S1. Form a new grammar for L* by introducing to G a new start symbol S and the productions S -> S1S | ε. A rightmost derivation from S generates a sequence of zero or more S1’s, each of which generates some string in L.

Closure of CFL’s Under Reversal If L is a CFL with grammar G, form a grammar for LR by reversing the right side of every production. Example: Let G have S -> 0S1 | 01. The reversal of L(G) has grammar S -> 1S0 | 10.

Closure of CFL’s Under Homomorphism Let L be a CFL with grammar G. Let h be a homomorphism on the terminal symbols of G. Construct a grammar for h(L) by replacing each terminal symbol a by h(a).

Example: Closure Under Homomorphism G has productions S -> 0S1 | 01. h is defined by h(0) = ab, h(1) = ε. h(L(G)) has the grammar with productions S -> abS | ab.

Closure of CFL’s Under Inverse Homomorphism Here, grammars don’t help us. But a PDA construction serves nicely. Intuition: Let L = L(P) for some PDA P. Construct PDA P’ to accept h-1(L). P’ simulates P, but keeps, as one component of a two-component state a buffer that holds the result of applying h to one input symbol.

Architecture of P’ Input: 0 0 1 1 h(0) Buffer Read first remaining symbol in buffer as if it were input to P. State of P Stack of P

Formal Construction of P’ States are pairs [q, b], where: q is a state of P. b is a suffix of h(a) for some symbol a. Thus, only a finite number of possible values for b. Stack symbols of P’ are those of P. Start state of P’ is [q0 ,ε].

Construction of P’ – (2) Input symbols of P’ are the symbols to which h applies. Final states of P’ are the states [q, ε] such that q is a final state of P.

Transitions of P’ δ’([q, ε], a, X) = {([q, h(a)], X)} for any input symbol a of P’ and any stack symbol X. When the buffer is empty, P’ can reload it. δ’([q, bw], ε, X) contains ([p, w], ) if δ(q, b, X) contains (p, ), where b is either an input symbol of P or ε. Simulate P from the buffer.

Proving Correctness of P’ We need to show that L(P’) = h-1(L(P)). Key argument: P’ makes the transition ([q0, ε], w, Z0)⊦*([q, x], ε, ) if and only if P makes transition (q0, y, Z0) ⊦*(q, ε, ), h(w) = yx, and x is a suffix of the last symbol of w. Proof in both directions is an induction on the number of moves made.

Nonclosure Under Intersection Unlike the regular languages, the class of CFL’s is not closed under . We know that L1 = {0n1n2n | n > 1} is not a CFL (use the pumping lemma). However, L2 = {0n1n2i | n > 1, i > 1} is. CFG: S -> AB, A -> 0A1 | 01, B -> 2B | 2. So is L3 = {0i1n2n | n > 1, i > 1}. But L1 = L2  L3.

Nonclosure Under Difference We can prove something more general: Any class of languages that is closed under difference is closed under intersection. Proof: L  M = L – (L – M). Thus, if CFL’s were closed under difference, they would be closed under intersection, but they are not.

Intersection with a Regular Language Intersection of two CFL’s need not be context free. But the intersection of a CFL with a regular language is always a CFL. Proof involves running a DFA in parallel with a PDA, and noting that the combination is a PDA. PDA’s accept by final state.

DFA and PDA in Parallel DFA Accept Input if both accept PDA S t a Looks like the state of one PDA DFA Accept if both accept Input PDA S t a c k

Formal Construction Let the DFA A have transition function δA. Let the PDA P have transition function δP. States of combined PDA are [q,p], where q is a state of A and p a state of P. δ([q,p], a, X) contains ([δA(q,a),r], ) if δP(p, a, X) contains (r, ). Note a could be , in which case δA(q,a) = q.

Formal Construction – (2) Accepting states of combined PDA are those [q,p] such that q is an accepting state of A and p is an accepting state of P. Easy induction: ([q0,p0], w, Z0)⊦* ([q,p], , ) if and only if δA(q0,w) = q and in P: (p0, w, Z0)⊦*(p, , ).