![23
BNF Notation: Optional Elements
Surround one or more symbols by […]
to make them optional.
Example: <statement> ::= if
<condition> then <statement> [; else
<statement>]
Translation: replace [] by a new
variable A with productions A -> | ε.](https://image.slidesharecdn.com/unit-2contextfreegrammer-221215142845-ecf02032/85/Context-free-grammer-ppt-23-320.jpg)
![25
BNF Notation – Grouping
Use {…} to surround a sequence of
symbols that need to be treated as a
unit.
Typically, they are followed by a … for “one
or more.”
Example: <statement list> ::=
<statement> [{;<statement>}…]](https://image.slidesharecdn.com/unit-2contextfreegrammer-221215142845-ecf02032/85/Context-free-grammer-ppt-25-320.jpg)
![27
Example: Grouping
L -> S [{;S}…]
Replace by L -> S [A…] A -> ;S
A stands for {;S}.
Then by L -> SB B -> A… | ε A -> ;S
B stands for [A…] (zero or more A’s).
Finally by L -> SB B -> C | ε
C -> AC | A A -> ;S
C stands for A… .](https://image.slidesharecdn.com/unit-2contextfreegrammer-221215142845-ecf02032/85/Context-free-grammer-ppt-27-320.jpg)
Context free grammer.ppt
- 1. Theory of Computation 1 Theory of Computation UNIT – II
- 2. Vision of the Department To become renowned Centre of excellence in computer science and engineering and make competent engineers & professionals with high ethical values prepared for lifelong learning. Mission of the Department M1- To impart outcome based education for emerging technologies in the field of computer science and engineering. M2 - To provide opportunities for interaction between academia and industry. M3 - To provide platform for lifelong learning by accepting the change in technologies M4 - To develop aptitude of fulfilling social responsibilities. Theory of Computation 2
- 3. Course Objectives CO1: Examine Finite Automata and Regular Expression. CO2: Classify regular sets of Regular Grammars. CO3: Categorize Context Free Language and Design Pushdown automata. CO4: Design Turing machine, compare Chomsky hierarchy languages and analyze Linear bounded automata. Theory of Computation 3
- 4. CO PO Mapping Seme ster Course Objectiv es P O 1 P O2 P O 3 P O 4 P O 5 P O 6 P O 7 P O 8 P O 9 P O 10 P O 11 P O 12 IV CO1 H L M H M L L M L L L L CO2 H M H H L L M M H M L M CO3 H M H H L L M L M M M L CO4 L M L H M L H M L L H H Theory of Computation 4
- 5. 5 Context-Free Grammars Formalism Derivations Backus-Naur Form Left- and Rightmost Derivations
- 6. 6 Informal Comments A context-free grammar is a notation for describing languages. It is more powerful than finite automata or RE’s, but still cannot define all possible languages. Useful for nested structures, e.g., parentheses in programming languages.
- 7. 7 Informal Comments – (2) Basic idea is to use “variables” to stand for sets of strings (i.e., languages). These variables are defined recursively, in terms of one another. Recursive rules (“productions”) involve only concatenation. Alternative rules for a variable allow union.
- 8. 8 Example: CFG for { 0n1n | n > 1} Productions: S -> 01 S -> 0S1 Basis: 01 is in the language. Induction: if w is in the language, then so is 0w1.
- 9. 9 CFG Formalism Terminals = symbols of the alphabet of the language being defined. Variables = nonterminals = a finite set of other symbols, each of which represents a language. Start symbol = the variable whose language is the one being defined.
- 10. 10 Productions A production has the form variable -> string of variables and terminals. Convention: A, B, C,… are variables. a, b, c,… are terminals. …, X, Y, Z are either terminals or variables. …, w, x, y, z are strings of terminals only. , , ,… are strings of terminals and/or variables.
- 11. 11 Example: Formal CFG Here is a formal CFG for { 0n1n | n > 1}. Terminals = {0, 1}. Variables = {S}. Start symbol = S. Productions = S -> 01 S -> 0S1
- 12. 12 Derivations – Intuition We derive strings in the language of a CFG by starting with the start symbol, and repeatedly replacing some variable A by the right side of one of its productions. That is, the “productions for A” are those that have A on the left side of the ->.
- 13. 13 Derivations – Formalism We say A => if A -> is a production. Example: S -> 01; S -> 0S1. S => 0S1 => 00S11 => 000111.
- 14. 14 Iterated Derivation =>* means “zero or more derivation steps.” Basis: =>* for any string . Induction: if =>* and => , then =>* .
- 15. 15 Example: Iterated Derivation S -> 01; S -> 0S1. S => 0S1 => 00S11 => 000111. So S =>* S; S =>* 0S1; S =>* 00S11; S =>* 000111.
- 16. 16 Sentential Forms Any string of variables and/or terminals derived from the start symbol is called a sentential form. Formally, is a sentential form iff S =>* .
- 17. 17 Language of a Grammar If G is a CFG, then L(G), the language of G, is {w | S =>* w}. Note: w must be a terminal string, S is the start symbol. Example: G has productions S -> ε and S -> 0S1. L(G) = {0n1n | n > 0}. Note: ε is a legitimate right side.
- 18. 18 Context-Free Languages A language that is defined by some CFG is called a context-free language. There are CFL’s that are not regular languages, such as the example just given. But not all languages are CFL’s. Intuitively: CFL’s can count two things, not three.
- 19. 19 BNF Notation Grammars for programming languages are often written in BNF (Backus-Naur Form ). Variables are words in <…>; Example: <statement>. Terminals are often multicharacter strings indicated by boldface or underline; Example: while or WHILE.
- 20. 20 BNF Notation – (2) Symbol ::= is often used for ->. Symbol | is used for “or.” A shorthand for a list of productions with the same left side. Example: S -> 0S1 | 01 is shorthand for S -> 0S1 and S -> 01.
- 21. 21 BNF Notation – Kleene Closure Symbol … is used for “one or more.” Example: <digit> ::= 0|1|2|3|4|5|6|7|8|9 <unsigned integer> ::= <digit>… Note: that’s not exactly the * of RE’s. Translation: Replace … with a new variable A and productions A -> A | .
- 22. 22 Example: Kleene Closure Grammar for unsigned integers can be replaced by: U -> UD | D D -> 0|1|2|3|4|5|6|7|8|9
- 23. 23 BNF Notation: Optional Elements Surround one or more symbols by […] to make them optional. Example: <statement> ::= if <condition> then <statement> [; else <statement>] Translation: replace [] by a new variable A with productions A -> | ε.
- 24. 24 Example: Optional Elements Grammar for if-then-else can be replaced by: S -> iCtSA A -> ;eS | ε
- 25. 25 BNF Notation – Grouping Use {…} to surround a sequence of symbols that need to be treated as a unit. Typically, they are followed by a … for “one or more.” Example: <statement list> ::= <statement> [{;<statement>}…]
- 26. 26 Translation: Grouping You may, if you wish, create a new variable A for {}. One production for A: A -> . Use A in place of {}.
- 27. 27 Example: Grouping L -> S [{;S}…] Replace by L -> S [A…] A -> ;S A stands for {;S}. Then by L -> SB B -> A… | ε A -> ;S B stands for [A…] (zero or more A’s). Finally by L -> SB B -> C | ε C -> AC | A A -> ;S C stands for A… .
- 28. 28 Leftmost and Rightmost Derivations Derivations allow us to replace any of the variables in a string. Leads to many different derivations of the same string. By forcing the leftmost variable (or alternatively, the rightmost variable) to be replaced, we avoid these “distinctions without a difference.”
- 29. 29 Leftmost Derivations Say wA =>lm w if w is a string of terminals only and A -> is a production. Also, =>*lm if becomes by a sequence of 0 or more =>lm steps.
- 30. 30 Example: Leftmost Derivations Balanced-parentheses grammmar: S -> SS | (S) | () S =>lm SS =>lm (S)S =>lm (())S =>lm (())() Thus, S =>*lm (())() S => SS => S() => (S)() => (())() is a derivation, but not a leftmost derivation.
- 31. 31 Rightmost Derivations Say Aw =>rm w if w is a string of terminals only and A -> is a production. Also, =>*rm if becomes by a sequence of 0 or more =>rm steps.
- 32. 32 Example: Rightmost Derivations Balanced-parentheses grammmar: S -> SS | (S) | () S =>rm SS =>rm S() =>rm (S)() =>rm (())() Thus, S =>*rm (())() S => SS => SSS => S()S => ()()S => ()()() is neither a rightmost nor a leftmost derivation.
- 33. 33 Parse Trees Definitions Relationship to Left- and Rightmost Derivations Ambiguity in Grammars
- 34. 34 Parse Trees Parse trees are trees labeled by symbols of a particular CFG. Leaves: labeled by a terminal or ε. Interior nodes: labeled by a variable. Children are labeled by the right side of a production for the parent. Root: must be labeled by the start symbol.
- 35. 35 Example: Parse Tree S -> SS | (S) | () S S S S ) ( ( ) ( )
- 36. 36 Yield of a Parse Tree The concatenation of the labels of the leaves in left-to-right order That is, in the order of a preorder traversal. is called the yield of the parse tree. Example: yield of is (())() S S S S ) ( ( ) ( )
- 37. 37 Parse Trees, Left- and Rightmost Derivations For every parse tree, there is a unique leftmost, and a unique rightmost derivation. We’ll prove: 1. If there is a parse tree with root labeled A and yield w, then A =>*lm w. 2. If A =>*lm w, then there is a parse tree with root A and yield w.
- 38. 38 Proof – Part 1 Induction on the height (length of the longest path from the root) of the tree. Basis: height 1. Tree looks like A -> a1…an must be a production. Thus, A =>*lm a1…an. A a1 an . . .
- 39. 39 Part 1 – Induction Assume (1) for trees of height < h, and let this tree have height h: By IH, Xi =>*lm wi. Note: if Xi is a terminal, then Xi = wi. Thus, A =>lm X1…Xn =>*lm w1X2…Xn =>*lm w1w2X3…Xn =>*lm … =>*lm w1…wn. A X1 Xn . . . w1 wn
- 40. 40 Proof: Part 2 Given a leftmost derivation of a terminal string, we need to prove the existence of a parse tree. The proof is an induction on the length of the derivation.
- 41. 41 Part 2 – Basis If A =>*lm a1…an by a one-step derivation, then there must be a parse tree A a1 an . . .
- 42. 42 Part 2 – Induction Assume (2) for derivations of fewer than k > 1 steps, and let A =>*lm w be a k-step derivation. First step is A =>lm X1…Xn. Key point: w can be divided so the first portion is derived from X1, the next is derived from X2, and so on. If Xi is a terminal, then wi = Xi.
- 43. 43 Induction – (2) That is, Xi =>*lm wi for all i such that Xi is a variable. And the derivation takes fewer than k steps. By the IH, if Xi is a variable, then there is a parse tree with root Xi and yield wi. Thus, there is a parse tree A X1 Xn . . . w1 wn
- 44. 44 Parse Trees and Rightmost Derivations The ideas are essentially the mirror image of the proof for leftmost derivations. Left to the imagination.
- 45. 45 Parse Trees and Any Derivation The proof that you can obtain a parse tree from a leftmost derivation doesn’t really depend on “leftmost.” First step still has to be A => X1…Xn. And w still can be divided so the first portion is derived from X1, the next is derived from X2, and so on.
- 46. 46 Ambiguous Grammars A CFG is ambiguous if there is a string in the language that is the yield of two or more parse trees. Example: S -> SS | (S) | () Two parse trees for ()()() on next slide.
- 47. 47 Example – Continued S S S S S ( ) S S S S S ( ) ( ) ( ) ( ) ( )
- 48. 48 Ambiguity, Left- and Rightmost Derivations If there are two different parse trees, they must produce two different leftmost derivations by the construction given in the proof. Conversely, two different leftmost derivations produce different parse trees by the other part of the proof. Likewise for rightmost derivations.
- 49. 49 Ambiguity, etc. – (2) Thus, equivalent definitions of “ambiguous grammar’’ are: 1. There is a string in the language that has two different leftmost derivations. 2. There is a string in the language that has two different rightmost derivations.
- 50. 50 Ambiguity is a Property of Grammars, not Languages For the balanced-parentheses language, here is another CFG, which is unambiguous. B -> (RB | ε R -> ) | (RR B, the start symbol, derives balanced strings. R generates strings that have one more right paren than left.
- 51. 51 Example: Unambiguous Grammar B -> (RB | ε R -> ) | (RR Construct a unique leftmost derivation for a given balanced string of parentheses by scanning the string from left to right. If we need to expand B, then use B -> (RB if the next symbol is “(” and ε if at the end. If we need to expand R, use R -> ) if the next symbol is “)” and (RR if it is “(”.
- 52. 52 The Parsing Process Remaining Input: (())() Steps of leftmost derivation: B Next symbol B -> (RB | ε R -> ) | (RR
- 53. 53 The Parsing Process Remaining Input: ())() Steps of leftmost derivation: B (RB Next symbol B -> (RB | ε R -> ) | (RR
- 54. 54 The Parsing Process Remaining Input: ))() Steps of leftmost derivation: B (RB ((RRB Next symbol B -> (RB | ε R -> ) | (RR
- 55. 55 The Parsing Process Remaining Input: )() Steps of leftmost derivation: B (RB ((RRB (()RB Next symbol B -> (RB | ε R -> ) | (RR
- 56. 56 The Parsing Process Remaining Input: () Steps of leftmost derivation: B (RB ((RRB (()RB (())B Next symbol B -> (RB | ε R -> ) | (RR
- 57. 57 The Parsing Process Remaining Input: ) Steps of leftmost derivation: B (())(RB (RB ((RRB (()RB (())B Next symbol B -> (RB | ε R -> ) | (RR
- 58. 58 The Parsing Process Remaining Input: Steps of leftmost derivation: B (())(RB (RB (())()B ((RRB (()RB (())B Next symbol B -> (RB | ε R -> ) | (RR
- 59. 59 The Parsing Process Remaining Input: Steps of leftmost derivation: B (())(RB (RB (())()B ((RRB (())() (()RB (())B Next symbol B -> (RB | ε R -> ) | (RR
- 60. 60 LL(1) Grammars As an aside, a grammar such B -> (RB | ε R -> ) | (RR, where you can always figure out the production to use in a leftmost derivation by scanning the given string left-to-right and looking only at the next one symbol is called LL(1). “Leftmost derivation, left-to-right scan, one symbol of lookahead.”
- 61. 61 LL(1) Grammars – (2) Most programming languages have LL(1) grammars. LL(1) grammars are never ambiguous.
- 62. 62 Inherent Ambiguity It would be nice if for every ambiguous grammar, there were some way to “fix” the ambiguity, as we did for the balanced-parentheses grammar. Unfortunately, certain CFL’s are inherently ambiguous, meaning that every grammar for the language is ambiguous.
- 63. 63 Example: Inherent Ambiguity The language {0i1j2k | i = j or j = k} is inherently ambiguous. Intuitively, at least some of the strings of the form 0n1n2n must be generated by two different parse trees, one based on checking the 0’s and 1’s, the other based on checking the 1’s and 2’s.
- 64. 64 One Possible Ambiguous Grammar S -> AB | CD A -> 0A1 | 01 B -> 2B | 2 C -> 0C | 0 D -> 1D2 | 12 A generates equal 0’s and 1’s B generates any number of 2’s C generates any number of 0’s D generates equal 1’s and 2’s And there are two derivations of every string with equal numbers of 0’s, 1’s, and 2’s. E.g.: S => AB => 01B =>012 S => CD => 0D => 012
- 65. 65 Normal Forms for CFG’s Eliminating Useless Variables Removing Epsilon Removing Unit Productions Chomsky Normal Form
- 66. 66 Variables That Derive Nothing Consider: S -> AB, A -> aA | a, B -> AB Although A derives all strings of a’s, B derives no terminal strings (can you prove this fact?). Thus, S derives nothing, and the language is empty.
- 67. 67 Testing Whether a Variable Derives Some Terminal String Basis: If there is a production A -> w, where w has no variables, then A derives a terminal string. Induction: If there is a production A -> , where consists only of terminals and variables known to derive a terminal string, then A derives a terminal string.
- 68. 68 Testing – (2) Eventually, we can find no more variables. An easy induction on the order in which variables are discovered shows that each one truly derives a terminal string. Conversely, any variable that derives a terminal string will be discovered by this algorithm.
- 69. 69 Proof of Converse The proof is an induction on the height of the least-height parse tree by which a variable A derives a terminal string. Basis: Height = 1. Tree looks like: Then the basis of the algorithm tells us that A will be discovered. A a1 an . . .
- 70. 70 Induction for Converse Assume IH for parse trees of height < h, and suppose A derives a terminal string via a parse tree of height h: By IH, those Xi’s that are variables are discovered. Thus, A will also be discovered, because it has a right side of terminals and/or discovered variables. A X1 Xn . . . w1 wn
- 71. 71 Algorithm to Eliminate Variables That Derive Nothing 1. Discover all variables that derive terminal strings. 2. For all other variables, remove all productions in which they appear either on the left or the right.
- 72. 72 Example: Eliminate Variables S -> AB | C, A -> aA | a, B -> bB, C -> c Basis: A and C are identified because of A -> a and C -> c. Induction: S is identified because of S -> C. Nothing else can be identified. Result: S -> C, A -> aA | a, C -> c
- 73. 73 Unreachable Symbols Another way a terminal or variable deserves to be eliminated is if it cannot appear in any derivation from the start symbol. Basis: We can reach S (the start symbol). Induction: if we can reach A, and there is a production A -> , then we can reach all symbols of .
- 74. 74 Unreachable Symbols – (2) Easy inductions in both directions show that when we can discover no more symbols, then we have all and only the symbols that appear in derivations from S. Algorithm: Remove from the grammar all symbols not discovered reachable from S and all productions that involve these symbols.
- 75. 75 Eliminating Useless Symbols A symbol is useful if it appears in some derivation of some terminal string from the start symbol. Otherwise, it is useless. Eliminate all useless symbols by: 1. Eliminate symbols that derive no terminal string. 2. Eliminate unreachable symbols.
- 76. 76 Example: Useless Symbols – (2) S -> AB, A -> C, C -> c, B -> bB If we eliminated unreachable symbols first, we would find everything is reachable. A, C, and c would never get eliminated.
- 77. 77 Why It Works After step (1), every symbol remaining derives some terminal string. After step (2) the only symbols remaining are all derivable from S. In addition, they still derive a terminal string, because such a derivation can only involve symbols reachable from S.
- 78. 78 Epsilon Productions We can almost avoid using productions of the form A -> ε (called ε-productions ). The problem is that ε cannot be in the language of any grammar that has no ε– productions. Theorem: If L is a CFL, then L-{ε} has a CFG with no ε-productions.
- 79. 79 Nullable Symbols To eliminate ε-productions, we first need to discover the nullable variables = variables A such that A =>* ε. Basis: If there is a production A -> ε, then A is nullable. Induction: If there is a production A -> , and all symbols of are nullable, then A is nullable.
- 80. 80 Example: Nullable Symbols S -> AB, A -> aA | ε, B -> bB | A Basis: A is nullable because of A -> ε. Induction: B is nullable because of B -> A. Then, S is nullable because of S -> AB.
- 81. 81 Proof of Nullable-Symbols Algorithm The proof that this algorithm finds all and only the nullable variables is very much like the proof that the algorithm for symbols that derive terminal strings works. Do you see the two directions of the proof? On what is each induction?
- 82. 82 Eliminating ε-Productions Key idea: turn each production A -> X1…Xn into a family of productions. For each subset of nullable X’s, there is one production with those eliminated from the right side “in advance.” Except, if all X’s are nullable, do not make a production with ε as the right side.
- 83. 83 Example: Eliminating ε- Productions S -> ABC, A -> aA | ε, B -> bB | ε, C -> ε A, B, C, and S are all nullable. New grammar: S -> ABC | AB | AC | BC | A | B | C A -> aA | a B -> bB | b Note: C is now useless. Eliminate its productions.
- 84. 84 Why it Works Prove that for all variables A: 1. If w ε and A =>*old w, then A =>*new w. 2. If A =>*new w then w ε and A =>*old w. Then, letting A be the start symbol proves that L(new) = L(old) – {ε}. (1) is an induction on the number of steps by which A derives w in the old grammar.
- 85. 85 Proof of 1 – Basis If the old derivation is one step, then A -> w must be a production. Since w ε, this production also appears in the new grammar. Thus, A =>new w.
- 86. 86 Proof of 1 – Induction Let A =>*old w be an n-step derivation, and assume the IH for derivations of less than n steps. Let the first step be A =>old X1…Xn. Then w can be broken into w = w1…wn, where Xi =>*old wi, for all i, in fewer than n steps.
- 87. 87 Induction – Continued By the IH, if wi ε, then Xi =>*new wi. Also, the new grammar has a production with A on the left, and just those Xi’s on the right such that wi ε. Note: they all can’t be ε, because w ε. Follow a use of this production by the derivations Xi =>*new wi to show that A derives w in the new grammar.
- 88. 88 Proof of Converse We also need to show part (2) – if w is derived from A in the new grammar, then it is also derived in the old. Induction on number of steps in the derivation. We’ll leave the proof for reading in the text.
- 89. 89 Unit Productions A unit production is one whose right side consists of exactly one variable. These productions can be eliminated. Key idea: If A =>* B by a series of unit productions, and B -> is a non-unit- production, then add production A -> . Then, drop all unit productions.
- 90. 90 Unit Productions – (2) Find all pairs (A, B) such that A =>* B by a sequence of unit productions only. Basis: Surely (A, A). Induction: If we have found (A, B), and B -> C is a unit production, then add (A, C).
- 91. 91 Proof That We Find Exactly the Right Pairs By induction on the order in which pairs (A, B) are found, we can show A =>* B by unit productions. Conversely, by induction on the number of steps in the derivation by unit productions of A =>* B, we can show that the pair (A, B) is discovered.
- 92. 92 Proof The the Unit-Production- Elimination Algorithm Works Basic idea: there is a leftmost derivation A =>*lm w in the new grammar if and only if there is such a derivation in the old. A sequence of unit productions and a non-unit production is collapsed into a single production of the new grammar.
- 93. 93 Cleaning Up a Grammar Theorem: if L is a CFL, then there is a CFG for L – {ε} that has: 1. No useless symbols. 2. No ε-productions. 3. No unit productions. I.e., every right side is either a single terminal or has length > 2.
- 94. 94 Cleaning Up – (2) Proof: Start with a CFG for L. Perform the following steps in order: 1. Eliminate ε-productions. 2. Eliminate unit productions. 3. Eliminate variables that derive no terminal string. 4. Eliminate variables not reached from the start symbol. Must be first. Can create unit productions or useless variables.
- 95. 95 Chomsky Normal Form A CFG is said to be in Chomsky Normal Form if every production is of one of these two forms: 1. A -> BC (right side is two variables). 2. A -> a (right side is a single terminal). Theorem: If L is a CFL, then L – {ε} has a CFG in CNF.
- 96. 96 Proof of CNF Theorem Step 1: “Clean” the grammar, so every production right side is either a single terminal or of length at least 2. Step 2: For each right side a single terminal, make the right side all variables. For each terminal a create new variable Aa and production Aa -> a. Replace a by Aa in right sides of length > 2.
- 97. 97 Example: Step 2 Consider production A -> BcDe. We need variables Ac and Ae. with productions Ac -> c and Ae -> e. Note: you create at most one variable for each terminal, and use it everywhere it is needed. Replace A -> BcDe by A -> BAcDAe.
- 98. 98 CNF Proof – Continued Step 3: Break right sides longer than 2 into a chain of productions with right sides of two variables. Example: A -> BCDE is replaced by A -> BF, F -> CG, and G -> DE. F and G must be used nowhere else.
- 99. 99 Example of Step 3 – Continued Recall A -> BCDE is replaced by A -> BF, F -> CG, and G -> DE. In the new grammar, A => BF => BCG => BCDE. More importantly: Once we choose to replace A by BF, we must continue to BCG and BCDE. Because F and G have only one production.
- 100. 100 CNF Proof – Concluded We must prove that Steps 2 and 3 produce new grammars whose languages are the same as the previous grammar. Proofs are of a familiar type and involve inductions on the lengths of derivations.