322 CSE - Introduction to Formal Methods in Computer Science Closure Properties of Context-Free Languages
Dave Bacon
Department of Computer Science & Engineering, University of Washington
Previously we showed how regular operations were closed under certain operations: union, intersection, the operation, concatenation, etc. Do similar results hold for CFLs? Well it will turn out for some of these operations, CFLs are indeed closed. Lets see how we can get at a few of these by introduction the a notion called substitution. Let be some alphabet. Suppose that for every symbol a , we choose a language La . Now La can be a language over any alphabet, it doesn't have to be over the alphabet . The alphabets of La do not have to match for different as. By choosing such a set of languages we have in effect defined a function on . We call this a substitution. Lets call this function s, so that s(a) is the language La . If w is a string from such that w = a1 a2 . . . an , where ai , then we define s(w) as the language of all strings x1 x2 xn such that xi s(ai ). Extending this even more we can define s(L) as the union of all s(w) for all strings w in L. Example: Let s(0) = {an bn cn |n 1} and s(1) = {aaa, bbb, ccc}. Let w = 01. Then s(01) = {an bn cn |n 1} {aaa, bbb, ccc} which is just s(01) = {an bn cn s3 |n 1, s {a, b, c}}. If L = L(0 ) is the language of all strings made up of no 1s, then s(L) = (s(0)) . This is s(L) = {an1 bn1 cn1 an2 bn2 cn2 . . . ank bnk cnk |k 0, 1 i k, ni 1} Okay having defined substitution we can now turn to our main result. We claim that if L is a context-free language over an alphabet , and s is a substitution on such that s(a) is a context-free language for all a , then s(L) is a context-free language. The basic idea behind how this work is that we can take the CFG for L and replace the terminals in this CFG with the start variables of relevant substitutions. In other words if the CFG for L has a terminal a, then we replace this terminal by the start symbol for s(a) in all rules of the CFG. Let's be a little more formal about this. Let G = (V, , R, S) be a CFG for the language L and Ga = (Va , a , Ra , Sa ) be a CFG for the languages s(a), where a . Since we can call variables whatever we like, let us assume that all of the variables in V and Va , a are different. That is V and Va , a are all disjoint. Okay so now we will construct a new grammar G = (V , , R , S ) for s(L). This new grammar will have 1. V = 2. =
a a
Va a
V
3. R is made up of the union of all rules from every Ra , unioned with all rules from R, but with each terminal a replaced by Sa everywhere that a occurs in R. 4. S = S. Okay so now a formal proof would proceed by showing that a string is in L(G ) if and only if w is in s(L). If w is in s(L), then there is some string x = a1 a2 . . . an in L and strings xi in s(ai ) such that w = x1 x2 . . . xn . Then we can see that G will generate this string. The portion of G that comes from the rules of G with Sa substitute for each a which generate a string Sa1 Sa2 . . . San . Then the part of the derivation for each Sai xi proceeds from the second part of the derivation. If w is in L(G ), then the parse tree for w must be a tree which has an upper structure made up entirely of derivations from G with the old terminals replaced by trees made up entirely of derivations from the relevant Ga . This implies that if w is in L(G ) we can find Sa1 Sa2 . . . San in the derivation of the top part of the tree and then proceeding downwards each of these must derive a string in s(ai ). Okay so now lets apply this substitution theorem to show how CFLs are closed under union, concatenation and . Union: Let L1 and L2 be CFLs. Then L1 L2 be the language s(L) where L is the language {1, 2} and s is the substitution defined by s(1) = L1 and s(2) = L2 . By the theorem s(L) is a CFL. Concatenation: Let L1 and L2 be CFLs. Then L1 L2 is the language s(L) where L is the language {12} and s is the substitution defined by s(1) = L1 and s(2) = L2 . By the theorem s(L) is a CFL. The operation: Let L1 be a CFL. L Then is the language L where L is the language {0} and the substitution 1 s is defined by s(0) = L1 . It is interesting to think about the above and ask the question of whether CFLs are closed under intersection. After you think about it for a while you'll conclude that you can't use a construction like the one above, if this were true. Which is good, because it turns out that it is not true! CFLs are not closed under intersection (we will see an example of this later.)
2
I. A DIFFERENT EXAMPLE
In class we talked about the following problem If L is a language, and a is a symbol, then L/a i, the quotient of L and a, is the set of strings w such that wa is in L. For example if L = {a, aab, baa}, then L/a = {, ba}. Prove that is L is a CFL then L/a is CFL. Hint: it might help to have the CFG for L in Chomsky normal form. How to solve this problem? We want to show that if L is a CFL then L/a is a CFG. Now since L is a CFG, there must exists some CFG G = (V, , R, S) such that L(G) = L. In order to show that L/a is a CFL, we will show how to convert this CFG, G into a new grammar, call it G1 = (V1 , , R1 , S1 ), such that this grammar has the language L/a, i.e. L(G1 ) = L/a. First of all we may assume, without loss of generality, that the grammar G has rules expressed in Chomsky normal form (if it isn't we can always convert this to a grammar in this form, which is why we can assume this without loss of generality.) To understand how to construct G1 , lets think about derivations using G. Since G is in Chomsky normal form, the parse tree for our derivation will be a binary tree, with the exception that for the variables which turn into terminals, these variables will only have single children. From the definition of L/a we see that we would like to be able to construct a grammar which allows similar derivations with the property that when the rightmost character in the parse tree is derived, if it is an a we would like to strip this a from the string for our new grammar. Thus it seems that need a way to keep track of the rightmost variable in our derivation. We will do this by adding to our grammar a variable for every variable in V but with this variable indicating that the variable is currently the rightmost string. Formally, let let Ai denote all of the variables in V (1 i |V |). Then we will define a new set of variables Ai for our grammar G1 . In particular we let V1 = V {Ai |1 i |V |}. To be clear, our new grammar has ...