CS 3240 – Chapter 6

 6.1: Simplifying Grammars  Substitution  Removing useless variables  Removing λ  Removing unit productions  6.2: Normal Forms  Chomsky Normal (CNF)  6.3: A Membership Algorithm  CYK Algorithm  An example of bottom-up parsing CS Normal Forms for Context-Free Languages2

 Variables in CFGs can often be eliminated  If they are not recursive, you can substitute their rules throughout  See next slide CS Normal Forms for Context-Free Languages3

4 A ➞ a | aaA | abBc B ➞ abbA | b Just substitute directly for B: A ➞ a | aaA | ababbAc | abbc

 A variable is useless if:  It can’t be reached from the start state, or  It never leads to a terminal string ▪ Due to endless recursion  Both problems can be detected by a dependency graph  See next slide CS Normal Forms for Context-Free Languages5

6 S ➞ aSb | A | λ A ➞ aA A is useless (non-terminating): S ➞ aSb | λ

CS Normal Forms for Context-Free Languages7 S ➞ A A ➞ aA | λ B ➞ bA B is useless (non-reachable): S ➞ A A ➞ aA | λ

CS Normal Forms for Context-Free Languages8 Simplify the following: S ➞ aS | A | C A ➞ a B ➞ aa C ➞ aCb

CS Normal Forms for Context-Free Languages9

10 Simplify the following grammar: S ➞ AB | AC A ➞ aAb | bAa | a B ➞ bbA | aaB | AB C ➞ abCa | aDb D ➞ bD | aC

 Any variable that can eventually terminate in the empty string is said to be nullable  Note: a variable may be indirectly nullable  In general: if A ➞ V 1 V 2 …V n, and all the V i are nullable, then A is also nullable ▪ See Theorem 6.3 CS Normal Forms for Context-Free Languages11

CS Normal Forms for Context-Free Languages12 Consider the following grammar: S ➞ a | Xb | aYa X ➞ Y | λ Y ➞ b | X Which variables are nullable? How can we substitute the effect of λ before removing it?

 First find all nullable variables  Then substitute (A + λ) for every nullable variable A, and expand  Then remove λ everywhere from the grammar  What’s left is equivalent to the original grammar  except the empty string may be lost  we won’t worry about that CS Normal Forms for Context-Free Languages13

CS Normal Forms for Context-Free Languages14 Consider the following grammar (again): S ➞ a | Xb | aYa X ➞ Y | λ Y ➞ b | X How can we substitute the effect of λ before removing it?

S → aSbS | bSaS | λS → aSa | bSb | X X → aYb | bYa Y → aY | bY | λ CS Normal Forms for Context-Free Languages15

 Unit Productions often occur in chains  A ➞ B ➞ C  Must maintain the effect of B and C when substituting for A throughout  Procedure:  Find all unit chains  Rebuild grammar by: ▪ Keeping all non-unit productions ▪ Keeping only the effect of all unit productions/chains CS Normal Forms for Context-Free Languages16

CS Normal Forms for Context-Free Languages17 S ➞ A | bb A ➞ B | b B ➞ S | a Note that S ⇒ * {A,B}, A ⇒ * {B,S}, B ⇒ * {S,A} Giving: S ➞ bb | b | a// Added non-unit part of A and B A ➞ b | a | bb// Added non-unit part of B and S B ➞ a | bb | b// Added non-unit part of S and A

 1) Determine all variables reachable by unit rules for each variable  2) Keep all non-unit rules  3) Substitute non-unit rules in place of each variable reachable by unit productions CS Normal Forms for Context-Free Languages18

CS Normal Forms for Context-Free Languages19 S ➞ aA A ➞ BB B ➞ aBb | λ Now remove nulls and see what happens…. (Also see the solution for #15 in 6.1)

CS Normal Forms for Context-Free Languages20 S ➞ AB A ➞ B B ➞ aB | BB | λ

 Do things in the following recommended order:  Remove nulls  Remove unit productions  Remove useless variables  Simplify by substitution as desired CS Normal Forms for Context-Free Languages21

 Very important for our purposes  All CNF rules are of one of the following two forms:  A ➞ c(a single terminal)  A ➞ XY(exactly two variables)  Must begin the transformation after simplifying the grammar (removing λ, all unit productions, useless variables, etc.) CS Normal Forms for Context-Free Languages22

CS Normal Forms for Context-Free Languages23 Convert to CNF: S ➞ bA | aB A ➞ bAA | aS | a B ➞ aBB | bS | b (NOTE: already has no nulls or units)

CS Normal Forms for Context-Free Languages24 Convert the following grammar to CNF: S ➞ abAB A ➞ bAB | λ B ➞ BAa | A | λ

CS Normal Forms for Context-Free Languages25 Convert the following grammar to CNF: S ➞ aS | bS | B B ➞ bb | C | λ C ➞ cC | λ

 Single terminal character followed by zero or more variables (cV *, c ∈ Σ )  V → a  V → aBCD…  λ allowed only in S → λ  Sometimes need to make up new variable names CS Normal Forms for Context-Free Languages26

CS Normal Forms for Context-Free Languages27 S → AB A → aA | bB | b B → b Substitute for A in first rule (i.e., add B to each rule for A): S → aAB | bBB | bB The other rules are okay

CS Normal Forms for Context-Free Languages28 S → abSb |aa Add rules to generate a and b: S → aBSB |aA A → a B → b

 The “parsing” problem  How do we know if a string is generated by a given grammar?  Bottom-up parsing (CYK Algorithm)  An Example of Dynamic Programming  Requires Chomsky Normal Form (CNF)  Start by considering A ➞ c rules  Build up the parse tree from there CS Normal Forms for Context-Free Languages29

CS Normal Forms for Context-Free Languages30 S ➞ XY X ➞ XA | a | b Y ➞ AY | a A ➞ a Does this grammar generate “baaa”?

CS Normal Forms for Context-Free Languages31 CNF yields binary trees. (Can you find a third parse tree?)

CS Normal Forms for Context-Free Languages32 S ➞ XY X ➞ XA | a | b Y ➞ AY | a A ➞ a Stage 1: b ⇐ X a ⇐ X, Y, A Stage 2: ba ⇐ X(X,Y,A) = XX, XY, XA ⇐ S, X aa ⇐ (X,Y,A)(X,Y,A) = XX, XY, XA, YX, YY, YA, AX, AY, AA ⇐ S, X, Y Stage 3: baa ⇐ ba a ⇐ (S,X)(X,Y,A) = SX, SY, SA, XX, XY, XA = S, X baa ⇐ b aa ⇐ X(S,X,Y) = XS, XX, XY = S aaa ⇐ aa a ⇐ (S,X,Y)(X,Y,A) = _________ aaa ⇐ a aa ⇐ (X,Y,A)(S,X,Y) = _________ Stage 4: (you finish…) baaa: b aaa ⇐ __________

CS Normal Forms for Context-Free Languages33

CS Normal Forms for Context-Free Languages34

CS Normal Forms for Context-Free Languages35

CS Normal Forms for Context-Free Languages36

CS Normal Forms for Context-Free Languages37 Does the following grammar generate “abbaab”? S ➞ SAB | λ A ➞ aA | λ B ➞ bB | λ