Normal Forms for Context-Free Grammars

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 3240 - Normal Forms for Context-Free Languages 2

Variables in CFGs can often be eliminated If they are not recursive, you can

substitute their rules throughout See next slide



A ➞ a | aaA | abBcB ➞ 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



S ➞ aSb | A | λA ➞ aA

A is useless (non-terminating):

S ➞ aSb | λ


S ➞ AA ➞ aA | λB ➞ bA

B is useless (non-reachable):

S ➞ AA ➞ aA | λ


Simplify the following:

S ➞ aS | A | CA ➞ aB ➞ aaC ➞ aCb

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 ➞ V1V2…Vn, and all the Vi

are nullable, then A is also nullable▪ See Theorem 6.3



Consider the following grammar:

S ➞ a | Xb | aYaX ➞ Y | λY ➞ b | X

Which variables are nullable?

How can we substitute the effect of λ before removing it?

First find all nullable variablesThen substitute (A + λ) for every

nullable variable A, and expand Then remove λ everywhere from the

grammarWhat’s left is equivalent to the

original grammar except the empty string may be lost we won’t worry about that



Consider the following grammar (again):

S ➞ a | Xb | aYaX ➞ Y | λY ➞ b | X

How can we substitute the effect of λ before removing it?

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


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



S ➞ aAA ➞ BBB ➞ aBb | λ

Now remove nulls and see what happens….

(Also see the solution for #15 in 6.1)


S ➞ ABA ➞ BB ➞ aB | BB | λ

Do things in the following recommended order: Remove nulls Remove unit productions Remove useless variables Simplify by substitution as desired


Very important for our purposesAll 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.)



Convert the following grammar to CNF:

S ➞ abABA ➞ bAB | λB ➞ BAa | A | λ


Convert the following grammar to CNF:

S ➞ aS | bS | BB ➞ bb | C | λC ➞ cC | λ

Single terminal character followed by zero or more variables (cV*, c ∈ Σ )

V → aV → aBCD…λ allowed only in S → λSometimes need to make up new

variable names



S → ABA → aA | bB | bB → 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


S → abSb |aa

Add rules to generate a and b:

S → aBSB |aAA → aB → 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



S ➞ XYX ➞ XA | a | bY ➞ AY | aA ➞ a

Does this grammar generate “baaa”?


CNF yields binary trees.(Can you find a third parse tree?)


Does the following grammar generate “abbaab”?

S ➞ SAB | λA ➞ aA | λB ➞ bB | λ

Normal Forms for Context-Free Grammars

Documents

Transcript of Normal Forms for Context-Free Grammars