1. CSCI 3130: Formal languages and automata theory Tutorial 4 Chin

2. Reminder Homework 3 is due on next Thursday. You can get back homework 1 after this tutorial.

3. Context Free Grammar A → 0A1 A → B B → # A  0A1  00A11  000A111  000B111  000#111 derivation = a sequence of productions that results a string productions variables terminals start variable

4. Context Free Grammar Regular languages are context free Context free languages NOT necessarily regular CFG describes the recursive structure of languages

5. Context Free Grammar Design a CFG that represents the following.  = {a, b} L 1 = {wyw R : y, w ∈  *} L 2 = {a i b j : i < j}

6. Context Free Grammar L 1 = {wyw R : y, w ∈  *} Consider a simpler CFG L 1 ’ = {ww R : w ∈  *} e.g. z = aabaabaa First character and the last character are the same z = aabaabaa = ax 1 a x 1 = abaaba = ax 2 a x 2 = baab = bx 3 b x 3 = aa = ax 4 a S → aSa | bSb ? How to stop? base case? S → aSa | bSb |  recursive

7. Context Free Grammar L 1 = {wyw R : y, w ∈  *} Consider a simpler CFG L 1 ’ = {ww R : w ∈  *} S → aSa | bSb |  How to turn it into a CFG for L 1 ? e.g. aabaaababaa? S → aSa | bSb |  < change this How to write a CFG for {y : y ∈  *}? T → aT | bT |  Replace  by T → aT | bT |  S → aSa | bSb | T T → aT | bT | 

8. Context Free Grammar L 2 = {a i b j : i < j} Consider a simpler CFG L 2 ’ = {a i b j : i = j} e.g. z = aaaabbbb First character must be a and the last character must be b z = aaaabbbb = ax 1 b x 1 = aaabbb = ax 2 b x 2 = aabb = ax 3 b x 3 = ab = ax 4 b S → aSb ? Base case again… S → aSb |  recursive

9. Context Free Grammar L 2 = {a i b j : i < j} Consider a simpler CFG L 2 ’ = {ww R : w ∈  *} S → aSb |  How to turn it into a CFG for L 2 ? need at least 1 more b in bb…b e.g. aaaabbbbbb? S → aSb |  < change this. insert b’s in front of bb…b How to write a CFG for {b i : i > 0}? T → bT | b Replace  by T → bT | b S → aSb |  | T T → bT | b

10. Parse Trees Representation of derivations e.g.S → AB | ba A → aA | a B → b Derivation of aab S → AB → aAB → aaB → aab S B b a Aa A

11. Ambiguity A CFG is ambiguous if the deviation of some string has two different parse trees. Removing ambiguity is impossible for some CFG.

12. Ambiguity Show that the following CFG is ambiguous. E → E * E | E / E | (A) | N A → A + A | N N → 6 | 1 | 2 Find a string in the CFG and show that it has two different parse trees.

13. Ambiguity E → E * E | E / E | (A) | N A → A + A | N N → 6 | 1 | 2 6 / 2 * (1 + 2) * E + A A 1 N 2 N E / E E 6 N 2 N A E ( ) E E * 6 N E / EE 2 N + A A 1 N 2 N A ( )

14. Parsing - Preprocessing 1.Eliminate  productions 2.Eliminate unit productions Do the steps in order (1 then 2)

15. Parsing - Preprocessing 1.Eliminate  productions i. Identify nullable variables (N   ) Let Q be the queue containing the nullable variables. Repeat the following: If X  , push X into Q If X  YZ…W and XZ…W are all in Q, push X into Q If start variable S nullable, add S’ → S |  *

16. Parsing - Preprocessing 1.Eliminate  productions i. Identify nullable variables (N   ) e.g.S → XY X →  Y →  Q = (X, Y, S) but not (S, X, Y) S’ → S S → XY X →  Y →  * Repeat the following: If X  , push X into Q If X  YZ…W and XZ…W are all in Q, push X into Q

17. Parsing - Preprocessing 1.Eliminate  productions ii. Remove nullable variables Repeat the following until Q is empty: Let N be the first element in Q a) For each X →  N , add X →  b) Remove all N →  Remove N from Q Caution!: S → NTN becomes S → NTN | NT | TN | T

18. Parsing - Preprocessing 1.Eliminate  productions ii. Remove nullable variables e.g.Q = (Y, X) S → XY X → XY | YZY | Y Y →  After one step, Q = (X) S → XY | X X → XY | X | YZY | YZ | ZY | Z | Y |  Y → 

19. Parsing - Preprocessing Eliminate  productions for the following CFG S → ASA | aB A → B | S B → b | 

20. Parsing - Preprocessing S → ASA | aB A → B | S B → b |  1.B → , Q = (B) 2.A → B and B is in Q, Q = (B, A) i. Identify nullable variables (N   ) Let Q be the queue containing the nullable variables. Repeat the following: If X  , push X into Q If X  YZ…W and XZ…W are all in Q, push X into Q *

21. Parsing - Preprocessing S → ASA | aB A → B | S B → b |  Q = (B, A) N = B S → ASA | aB | a A → B | S |  B → b |  ii. Remove nullable variables Repeat the following until Q is empty: Let N be the first element in Q a) For each X →  N , add X →  b) Remove all N →  Remove N from Q.

22. Parsing - Preprocessing S → ASA | aB A → B | S B → b |  Q = (A) N = A S → ASA | aB | a | SA | AS | S A → B | S |  B → b ii. Remove nullable variables Repeat the following until Q is empty: Let N be the first element in Q a) For each X →  N , add X →  b) Remove all N →  Remove N from Q.

23. Parsing - Preprocessing 2.Eliminate unit productions i. If there is a cycle of unit productions A → B →... → C → A delete it and replace everything with A e.g.S → T | X | Y T S → U | X | Y U S → S | Y | a

24. Parsing - Preprocessing 2.Eliminate unit productions ii. Replace every chain A → B →... → C →  by A → , B → ,..., C →  e.g.S → T AX | a | XY | YZ T → U AX | a | BY U → AX | a

25. Parsing - Preprocessing S → ASA | aB | a | SA | AS | S A → B | S B → b S → ASA | aB | a | SA | AS | S A → B | S B → b i. If there is a cycle of unit productions A → B →... → C → A delete it and replace everything with A

26. Parsing - Preprocessing S → ASA | aB | a | SA | AS A → B | S B → b S → ASA | aB | a | SA | AS A → B b | S ASA | aB | a | SA | AS B → b ii. Replace every chain A → B →... → C →  by A → , B → ,..., C → 

27. Parsing - Preprocessing Eliminate  productions and unit productions for the following CFG S → ASA | aB A → B | S B → b |  Ans:S → ASA | aB | a | SA | AS A → b | ASA | aB | a | SA | AS B → b

28. CYK Algorithm 1.Eliminate  productions 2.Eliminate unit productions CYK Algorithm 1. More preprocessing – Chomsky normal form 2. Dynamic Programming

29. CYK Algorithm - Preprocessing 1.Chomsky normal form every production has the form A → BC orA → a Allow S →  for start variable A → BCDE C → c A → BX X → CDE C → c A → BX X → CY Y → DE C → c A → BcDE

30. Parsing - Preprocessing Convert the CFG to Chomsky normal form S → ASA | aB | a | SA | AS A → b | ASA | aB | a | SA | AS B → b

31. Parsing - Preprocessing S → ASA | aB | a | SA | AS A → b | ASA | aB | a | SA | AS B → b S → AX | UB | a | SA | AS X → SA U → a A → b | ASA | aB | a | SA | AS B → b

32. Parsing - Preprocessing S → AX | UB | a | SA | AS X → SA U → a A → b | ASA | aB | a | SA | AS B → b S → AX | UB | a | SA | AS A → b | AX | UB | a | SA | AS X → SA U → a B → b

33. Parsing - Preprocessing Convert the CFG to Chomsky normal form S → ASA | aB | a | SA | AS A → b | ASA | aB | a | SA | AS B → b Ans:S → AX | UB | a | SA | AS A → b | AX | UB | a | SA | AS X → SA U → a B → b

34. Parsing CYK algorithm Dynamic Programming (taught in CSCI3160) Let s = s 1 s 2 s 3 s 4 …s n be a string Let s(i, j) be the substring s i …s j of s e.g.s = abcde, s(2,4) = bcd s(i, j) can be construct by s(i, k) + s(k + 1, j) for some k. e.g.s = abcde s = “a” + “bcde”, “ab” + “cde”, …, “abcd” + “e”

35. Parsing CYK algorithm Dynamic Programming (taught in CSCI3160) s(i, j) can be construct by s(i, k) + s(k + 1, j) for some k. Main Idea: If A derives s(i, k) and B derives s(k + 1, j), and S → AB. Then S derives s(i, j) e.g. A derives “ab”, B derives “cde”, S → AB. Then S derives “abcde”

36. Cocke-Younger-Kasami algorithm Use the CYK algorithm to parse abbab for the CFG S → ASA | aB A → B | S B → b | 

37. Cocke-Younger-Kasami algorithm baabb ----- ---- --- -- - Chomsky Normal Form: S → AX | UB | SA | AS | a A → AX | UB | SA | AS | a | b X → SA U → a B → b x = abbab

38. Cocke-Younger-Kasami algorithm baabb ABSAU AB ---- --- -- - S,A,U can derive a A,B can derive b S → AX | UB | SA | AS | a A → AX | UB | SA | AS | a | b X → SA U → a B → b

39. Cocke-Younger-Kasami algorithm baabb ABSAU AB -SAX SA --- -- - If we can derive “a”(SAU) and “b”(AB), then we can derive “ab”. SAU derives “a”, AB derives “b”. Look for variables that produce SA, SB, AA, AB, UA, or UB S → SA, A → SA, X → SA similarly for “bb”, “ba”, “ab” S → AX | UB | SA | AS | a A → AX | UB | SA | AS | a | b X → SA U → a B → b

40. Cocke-Younger-Kasami algorithm baabb ABSAU AB -SAX SA SAX -- - If we can derive “ab”(SAX) and “b”(AB), or “a”(SAU) and “bb”(-), then we can derive “abb”. 1. SAU derives “a”, nothing derives “b” 2. SAX derives “ab”, AB derives “b”. Look for variables that produce SA, SB, AA, AB, XA, or XB S → SA, A → SA, X → SA similarly for “bba” and “bab” S → AX | UB | SA | AS | a A → AX | UB | SA | AS | a | b X → SA U → a B → b

41. Cocke-Younger-Kasami algorithm baabb ABSAU AB -SAX SA SAX - If we can derive “a”(SAU) and “bba”(SA), or “ab”(SAX) and “ba”(SA), or “abb”(SAX) and “a”(SAU), then we can derive “abba”. SAX derives “ab”, SA derives “ba”. Look for variables that produce SS, SA, AA, AS, XS, or XA S → SA, A → SA, X → SA similarly for “bbab” S → AX | UB | SA | AS | a A → AX | UB | SA | AS | a | b X → SA U → a B → b

42. Cocke-Younger-Kasami algorithm baabb ABSAU AB -SAX SA SAX If we can derive “a”(SAU) and “bbab”(SAX), or “ab”(SAX) and “bab”(SAX), or “abb”(SAX) and “ab”(SAX), then we can derive “abbab”. SAU derives “a”, AB derives “bbab”. Look for variables that produce SA, SB, AA, AB, UA, or UB S → SA, A → SA, X → SA If S is on the top left cell, then x can be derived. S → AX | UB | SA | AS | a A → AX | UB | SA | AS | a | b X → SA U → a B → b

43. Starting from S in the top left, there must be some k such that s(i, j) = s(i, k) + s(k+1, j) Then there must be some l 1, l 2 such that s(i, k) = s(i, l 1 ) + s(l 1 +1, k) s(i, k) = s(k+1, l 2 ) + s(l 2 +1, j) Do the rest recursively. Parse tree reconstruction baabb ABSAU AB -SAX SA SAX

44. Starting from S in the top left, there must be some k such that s(i, j) = s(i, k) + s(k+1, j) Then there must be some l 1, l 2 such that s(i, k) = s(i, l 1 ) + s(l 1 +1, k) s(i, k) = s(k+1, l 2 ) + s(l 2 +1, j) Do the rest recursively. Parse tree reconstruction baabb ABSAU AB -SAX SA SAX

45. Starting from S in the top left, there must be some k such that s(i, j) = s(i, k) + s(k+1, j) Then there must be some l 1, l 2 such that s(i, k) = s(i, l 1 ) + s(l 1 +1, k) s(i, k) = s(k+1, l 2 ) + s(l 2 +1, j) Do the rest recursively. Parse tree reconstruction baabb ABSAU AB -SAX SA SAX

46. End Questions?