Outline

• Transforming Grammars
• Chomsky Normal Form
• In-Class Exercise
• The CYK algorithm
• Greibach Normal Form

Methods for Transforming Grammars

• On Monday, we gave techniques for constructing Context Free Grammars and argued why such grammars are useful to describe programming languages.
• We hinted at how recursive descent parsing works, talked about grammar ambiguity, and gave a brute force (usually, except for s-grammars, exponential time) algorithm for parsing.
• We are now going to work towards some normal forms which will be useful in obtaining efficient parsing algorithms for general CFGs.
• To do this we will look at different ways to simplify our grammars.
• To start sometimes it is useful to get rid of the empty strings from our language in order to make our proofs easier. It turns out this won't cause a loss of generality in the statements we can say about CFGs.
• To see this, suppose `L` is a language and let `L'= L -{epsilon}`. Let `G` be a CFG for `L`.
• If `G'=(V,T,P,S)` is a CFG for `L'`, then `G = (V cup {S_0}, T, P cup {S_ 0 ->S | epsilon }, S_0)` will be a CFG for `L`.
• So we will for now restrict our attention to grammars without `epsilon`.

More Methods of Transforming Grammars

• Suppose we have a CFG `G=(V,T,P, S)` and let `A -> x_1Bx_2` be in `P`. Suppose the variable `B` occurs in the following productions in `G: B ->y_1| y_2| ldots |y_n`. Then if `G'` is the CFG obtained by replacing `A -> x_1Bx_2` by `A -> x_1y_1x_2 | x_1y_2x_2 | ldots | x_1y_nx_2` for all rules involving B on the right hand size as above, we will have `L(G')=L(G)`.
• Another technique for simplifying CFGs is just to get rid of useless rules:
  Definition. Let `G=(V,T,P, S)` be a CFG. A variable `A` in `V` is said to be useful iff there is at least one `w in L(G)` such that `S =>^star xAy =>^star w`. Otherwise, `A` is said to be useless. A production is useless if it involves any useless variables.
• For example, consider the grammar with rules `S ->A`, `A -> aA|epsilon`, `B ->bA`. Then `B` is useless as it is not reachable from the start variable. So the production `B -> bA` is useless.
• Given a CFG if we eliminate all its useless productions we still get a smaller CFG with the same language.
• To determine the useful variables and productions we can start with `V_1 = emptyset`. Then repeat the following until there are no more variables added to `V_1`: For each production `A -> x_1 ldots x_n`, with all `x_i`'s that are variables in `V_1`, add `A` to `V_1`. If the start variable is not in `V_1` then we know the language is empty, so we can delete all productions.
• Otherwise, if `S` is in `V_1`, it still might not be the case that every variable in `V_1` is useful, so we set `V_2= {S}`. Then repeat the following until there are no more variables added to `V_2`: For each production `A ->x_1 ldots x_n`, with all `x_i`'s variables in `V_1` and with `A in V_2`, add each variable on the right hand side to `V_2`. After this procedure terminates, take `V_2` to be the set of useful variables. All other variables and production they are involved in are useless.

Removing `epsilon`-rules/productions

• A production (rule) of a CFG of the form `A -> epsilon` is called a `epsilon`-production or `epsilon`-rule. Any variable for which `A=>^star epsilon`, is called nullable.
• Even though a CFG might generate a language not containing `epsilon`, it still might have nullable productions. In which case these productions can be removed.
• For example, in `S -> aCb`, `C -> aCb| epsilon`, the variable C is nullable. We can eliminate the `epsilon`-rule by doing substitutions to get: `S -> aCb|ab`, `C ->aCb| ab`.
• To find the set `N` of nullable variables of a CFG, we can first put all variables `A` which occur in productions of the form `A -> epsilon` into `N`. Then repeat until no new variables are added the following step: if `B` occurs in a production `B ->A_1A_2 ldots A_n` where each `A_i` is in `N`, then add `B` to `N`.
• Once we have the set of nullable variables, we can eliminate any `epsilon`- rules from our grammar and for each rule `C ->C_1C_2 ldots C_n` where a nullable variables occur we add a rule with each possible substitution of a nullable variable by `epsilon`.

Eliminate Unit Productions

• A unit production is a production of the form `A -> B`.
• In general, using the reachability algorithm we can determine if `A=>^star C` for any two variables `A` and `C`.
• If `C` occurs in the rules `C -> y_1|y_2| ldots |y_n`, then we can add the rule `A -> y_1|y_2| ldots |y_n` to our grammar without effecting the strings it generates. If we do this for all variables involved on the right hand side of a unit rule and for each `C` for which `A=>^star C`, then we have eliminated unit rules.

Chomsky Normal Form

• To get an efficient parsing algorithm for general CFGs it is convenient to have them in some kind of normal form.
• Chomsky Normal Form is often used.
• A CFG is in Chomsky Normal Form if every rule is of the form `A ->BC` or of the form `A ->a`, where `A`, `B`, `C` are any variables and `a` is a terminal. In addition the rule `S -> epsilon` is permitted where `S` is the start symbol.

Conversion to Chomsky Normal Form (Chomsky 1959)

Theorem. Any CFL `L` can be generated by a CFG in Chomsky Normal Form

Proof. Let `G` be a CFG for `L`. First we add a new start variable and rule `S_0 ->S`. This guarantees the start variable does not occur on the RHS of any rule. We remove any `epsilon`-rules `A -> epsilon` where `A` is not the start variable. To do this for each occurrence of `A` on the RHS of a rule, say `R -> uAv`, we add a rule `R -> uv`. We do this for each occurrence of an `A`. So for `R -> uAvAw`, we would add the rules `R ->uvAw`, `R -> uAvw`, `R -> uvw`. If we had the rule `R ->A`, add the rule `R -> epsilon` unless we previously removed the rule `R -> epsilon`. This rule will be removed when we perform our steps for the variable `R`. We cycle over variables repeating these steps till all epsilon rules have been eliminated. Next we handle unit rules `A -> B`. To do this, we delete this rule and then for each rule of the form `B -> u`, we add then rule `A ->u`, unless this is a unit rule that was previously removed. We repeat until we eliminate unit rules. Finally, we convert all the remaining rules to the proper form. For any rule `A -> u_1u_2 ldots u_k` where `k geq 3` and where each `u_i` is a variable or a terminal symbol, we replace the rule with `A -> u_1A_1`, `A_1 -> u_2 A_2`, `ldots` `A_(k-2) -> u_(k-1)u_k`. For any rule with `k=2`, we replace any terminal with a new variable `U_i` and a rule `U_i -> u_i`.

Example

• We use the algorithm of the last slide to convert: `S -> Aba`, `A ->aab`, `B -> Ac` to Chomsky Normal Form
• Step 1: Add new start variable to get:
  `S_0 ->S`, `S -> Aba`, `A ->aab`, `B ->Ac`.
• Step 2: Remove `epsilon` rules. In this case, there aren't any so we still have:
  `S_0 ->S`, `S -> Aba`, `A ->aab`, `B ->Ac`.
• Step 3: Remove unit rules. We only have one involving `S_0`. After this step we have:
  `S_0 -> Aba`, `S-> Aba`, `A ->aab`, `B->Ac`.
• Step 4: Split up rules with RHS of length longer than 2:
  `S_0 -> AC_1`, `C_1 ->ba`, `S -> AD_1`, `D_1 ->ba`, `A ->aE_1`, `E_1 ->ab`, `B ->Ac`.
• Step 5: Put each rule with RHS of length 2 into the correct format:
  `S_0 -> AC_1`,
  `C_1 ->B_1A_1`, `B_1 ->b`, `A_1 -> a`,
  `S -> AD_1`,
  `D_1 -> B_2A_2` , `B_2 ->b`, `A_2 -> a`,
  `A ->A_3E_1`, `A_3 -> a`
  `E_1 -> A_4 B_4`, `B_4 ->b`, `A_4 -> a`,
  `B ->AC_2` , `C_2 ->c`.
• The grammar after Step 5 is the final answer.

In-Class Exercise

Convert the CFG with production rules: `S->SS|(S)|a` to Chomsky Normal Form.

Post your solution to the March 18 In-Class Exercise Thread.