UNIT-2

Context Free Grammars (CFG)

A Context-Free Grammar (CFG) is a formal grammar used to define the syntax of programming
languages, formal languages, and mathematical logic. It consists of a set of rules that describe how strings
in a language can be generated. In CFG, the production rules are applied to symbols, and the left-hand
side of each rule contains a single non-terminal symbol, which is replaced by a sequence of terminal
and/or non-terminal symbols.

Components of a Context-Free Grammar:

A context-free grammar is defined by the following components:

1. Variables (Non-terminal symbols): These are symbols used to represent patterns or structures
that can be expanded into other symbols. They are typically written in uppercase letters (e.g., S,
A, B).
2. Terminals: These are the basic symbols from which strings are formed. They cannot be replaced
or further expanded. In a programming language, terminals could be characters like a, b, 0, 1, or
keywords like if, while, etc.
3. Start symbol: This is a special non-terminal symbol that represents the start of the production
process. Typically, it is denoted as S.
4. Production rules: These are the rules that define how non-terminal symbols can be replaced by
other non-terminal or terminal symbols. A production rule is generally in the form:
o A → α where A is a non-terminal, and α is a string consisting of both terminals and non-
terminals (e.g., A → aB | b).

Example of a Context-Free Grammar:

Let's consider a simple CFG for a language that generates strings of balanced parentheses:

 Non-terminals: S
 Terminals: (, )
 Start symbol: S
 Production rules:
1. S → (S)
2. S → SS
3. S → ε (where ε denotes the empty string)

This CFG generates strings such as (), ()(), (()), and (()()), which represent balanced
parentheses.

Characteristics of Context-Free Grammars:

 Context-freeness: The term "context-free" means that the rules are applied regardless of the
context in which the non-terminal appears. For example, in the rule A → α, A can be replaced by
α no matter where it appears in the string.
  Generative power: CFGs are powerful enough to describe a wide variety of languages, but they
are not capable of expressing all possible language constructs (e.g., context-sensitive languages,
which require a different class of grammars).

Use of Context-Free Grammars:

 Programming languages: CFGs are widely used to describe the syntax of programming
languages. The syntax of most modern programming languages (like Python, Java, etc.) can be
defined using CFGs.
 Compilers: CFGs play a crucial role in the design of compilers, which use them to parse the
source code into a structure that can be processed further (often using techniques like syntax trees
or abstract syntax trees).
 Natural language processing (NLP): CFGs are used to describe the syntax of natural languages
in computational linguistics.

Example of a CFG for a Simple Arithmetic Expression:

Consider a CFG for a simple arithmetic expression involving addition and multiplication:

 Non-terminals: E (expression), T (term), F (factor)

 Terminals: *+, , (, ), 0, 1, 2, ..., 9
 Start symbol: E
 Production rules:
1. E → E + T
2. E → T
3. T → T * F
4. T → F
5. F → (E)
6. F → number (where number represents any integer)

This CFG allows us to generate expressions like 3 + 4 * (2 + 1).

Limitations of Context-Free Grammars:

While context-free grammars are powerful, they have limitations, particularly in expressing some
complex language structures, such as:

 Context-sensitive languages: CFGs cannot handle languages where the rules depend on the
context in which a symbol appears (e.g., ensuring that variables are declared before they are
used).
 Ambiguity: Some CFGs can be ambiguous, meaning that a string can have multiple parse trees
(derivations). This can be problematic for compilers and parsers, where a unique interpretation is
necessary.

Derivations and Languages in Context-Free Grammars (CFGs)

In the context of Context-Free Grammars (CFGs), derivations and derivation trees are key concepts
used to generate strings in the language defined by a grammar. Understanding the relationship between
them helps clarify how CFGs can generate specific strings and how they relate to the structure of the
language.

1. Derivations

A derivation is a sequence of rule applications starting from the start symbol of the grammar, eventually
leading to a string of terminals (a valid string in the language). In a derivation, you replace non-terminal
symbols with either other non-terminals or terminals according to the production rules of the grammar.

Example of a Derivation:

Consider the following simple CFG for arithmetic expressions:

 Non-terminals: E, T, F
 Terminals: *+, , (, ), 0, 1, 2, ..., 9
 Start symbol: E
 Production rules:
1. E → E + T
2. E → T
3. T → T * F
4. T → F
5. F → (E)
6. F → number

Now, let's derive the string 3 + 4 * 5 using the CFG:

1. Start with E (the start symbol).

2. Apply rule E → E + T.

E+T

3. Apply rule E → T to the first E.

T+T

4. Apply rule T → F to both T symbols.

F+F

5. Apply rule F → number to both F symbols.

number + number
 6. Replace number with the actual numbers 3, 4, and 5.

3+4*5

This is the final derived string, which is a valid string in the language generated by the CFG.

2. Derivation Trees (Parse Trees)

A derivation tree, also known as a parse tree, is a tree-like structure that represents the syntactic
structure of a string derived from a grammar. It shows how the derivation progresses from the start
symbol, breaking down into non-terminals and eventually to terminals.

Each internal node of the tree represents a non-terminal, and each leaf node represents a terminal symbol
in the string. The tree captures the hierarchical structure of the derivation, displaying which production
rules were applied at each step.

Example of a Derivation Tree for the string 3 + 4 * 5:

Using the same CFG as above, let's visualize the derivation tree for the string 3 + 4 * 5:

/ \

E + T

| / \

T T * F

| | |

F F number

| |

number number

| |

3 4 5

Key Points About Derivation Trees:

 Start symbol: The root of the tree is the start symbol of the grammar.
 Non-terminals: Each internal node represents a non-terminal symbol in the grammar.
 Terminals: Each leaf node represents a terminal symbol (an actual symbol in the string).
 Production rules: The branches of the tree represent applications of production rules.
  Uniqueness: A derivation tree is unique for any given string in a grammar, assuming the
grammar is unambiguous.

3. Relationship Between Derivations and Derivation Trees

 Derivations are a sequence of rule applications starting from the start symbol to eventually
produce a string of terminals. The sequence of derivation steps can be represented as a tree
structure, where each step in the derivation corresponds to a subtree in the tree.
 Derivation Trees are the graphical representation of the entire process of derivation. Every string
generated by a CFG has a corresponding derivation tree, where the structure of the tree reflects
the hierarchical relationships between non-terminals and terminals as defined by the grammar's
production rules.

Important Points:

1. Derivation is a textual or linear representation of how a string is produced by applying

production rules.
2. Derivation Tree is a graphical representation that depicts the syntactic structure of the string,
showing the application of rules in a tree format.
3. A single derivation can have multiple derivation trees if the grammar is ambiguous (i.e., the
string can be generated by the grammar in more than one way).
4. If the grammar is unambiguous, there will be exactly one derivation tree for every valid string
generated by the grammar.

Leftmost and Rightmost Derivations

In the context of Context-Free Grammars (CFGs), leftmost and rightmost derivations refer to specific
strategies for replacing non-terminal symbols in a string during the derivation process. These strategies
define the order in which non-terminal symbols are replaced with their corresponding production rules.

1. Leftmost Derivation

In a leftmost derivation, at each step, the leftmost non-terminal is replaced first. That is, you start with
the leftmost non-terminal in the string and apply a production rule to it, then continue this process
iteratively.

Example of Leftmost Derivation:

Consider the following CFG:

 Non-terminals: E (expression), T (term), F (factor)

 Terminals: *+, , (, ), 0, 1, 2, ..., 9
 Start symbol: E
 Production rules:
1. E → E + T
2. E → T
3. T → T * F
4. T → F
5. F → (E)
 6. F → number

We will derive the string 3 + 4 * 5 using a leftmost derivation.

1. Start with the start symbol: E.

2. Replace the leftmost non-terminal (E) using rule E → E + T.

E+T

3. Now, replace the leftmost non-terminal (E) using rule E → T.

T+T

4. Next, replace the leftmost non-terminal (T) using rule T → F.

F+T

5. Replace the leftmost non-terminal (F) using rule F → number.

number + T

6. Replace the leftmost non-terminal (T) using rule T → F.

number + F

7. Replace the leftmost non-terminal (F) using rule F → number.

number + number

8. Replace the number symbols with 3, 4, and 5 to obtain the final string:

3+4*5

Thus, the leftmost derivation produces the string 3 + 4 * 5.

2. Rightmost Derivation

In a rightmost derivation, at each step, the rightmost non-terminal is replaced first. This means that
you focus on the rightmost non-terminal in the string and apply a production rule to it, and repeat this
process until the string consists only of terminal symbols.

Example of Rightmost Derivation:

Using the same CFG, we will derive the string 3 + 4 * 5 using a rightmost derivation.
 1. Start with the start symbol: E.

2. Replace the rightmost non-terminal (E) using rule E → E + T.

E+T

3. Now, replace the rightmost non-terminal (T) using rule T → F.

E+F

4. Replace the rightmost non-terminal (F) using rule F → number.

E + number

5. Replace the leftmost non-terminal (E) using rule E → T.

T + number

6. Replace the rightmost non-terminal (T) using rule T → F.

F + number

7. Replace the rightmost non-terminal (F) using rule F → number.

number + number

8. Replace the number symbols with 3, 4, and 5 to obtain the final string:

3+4*5

Thus, the rightmost derivation produces the same string, 3 + 4 * 5.

Key Differences Between Leftmost and Rightmost Derivations:

 Order of Non-terminal Replacements:

o In leftmost derivation, the leftmost non-terminal is replaced first.
o In rightmost derivation, the rightmost non-terminal is replaced first.
 Parsing Direction:
o Leftmost derivations are typically associated with top-down parsing (e.g., recursive
descent parsers).
o Rightmost derivations are often associated with bottom-up parsing (e.g., shift-reduce
parsers).
 Derivation Tree Structure:
o Both leftmost and rightmost derivations ultimately generate the same derivation tree
for a given string. However, the order in which the rules are applied differs, leading to
different intermediate steps.
Example to Compare Leftmost and Rightmost Derivations:

Given a CFG with the following rules:

1. S → AB
2. A → a
3. B → b

Let's derive ab using both leftmost and rightmost derivations:

Leftmost Derivation:

1. S
2. A B (apply S → AB)
3. a B (apply A → a)
4. a b (apply B → b)

Rightmost Derivation:

1. S
2. A B (apply S → AB)
3. A b (apply B → b)
4. a b (apply A → a)

Both derivations result in the same final string, ab, but the order in which rules are applied differs

Sentential Forms in Formal Language Theory

A sentential form in formal language theory is a string of symbols (both terminals and non-terminals)
that can be derived from the start symbol of a context-free grammar (CFG). It is an intermediate step in
the derivation process, where the string can contain non-terminal symbols, and these non-terminals can
still be replaced using the production rules of the grammar.

In simple terms, a sentential form is any string that can be produced during the derivation process, before
reaching a final string made entirely of terminals (a valid string in the language)

Example:

Consider the following Context-Free Grammar (CFG):

 Non-terminals: S, A, B
 Terminals: a, b
 Start symbol: S
 Production rules:
1. S → AB
2. A → a
3. B → b
We can now illustrate sentential forms and their derivations.

Derivation Process with Sentential Forms:

1. Start symbol: S

The first sentential form is simply the start symbol S.

2. First application of a production rule: Apply S → AB.

The sentential form becomes: AB

3. Second step: Replace A with a using A → a.

The sentential form becomes: aB

4. Third step: Replace B with b using B → b.

The final string (a valid string in the language) is: ab

In this process, each step where non-terminal symbols are replaced by terminal or non-terminal symbols
results in a new sentential form. The last step, when all symbols are terminals, results in a string that
belongs to the language defined by the grammar.

Sentential Forms Overview:

 A sentential form can contain both terminal and non-terminal symbols.

 As you continue applying production rules to non-terminals in a sentential form, you get closer to
a valid string of only terminal symbols.
 Every step in a derivation where a non-terminal is replaced with other symbols generates a new
sentential form.
 Sentential forms represent intermediate steps in the derivation process, whereas the final string
(composed only of terminal symbols) represents the valid string derived from the start symbol.

Parsing and Ambiguity in Formal Language Theory:

Parsing is the process of analyzing a string of symbols (often called an input string) based on a
formal grammar.

Types of Parsing:

 Top-down Parsing: Starts from the start symbol and tries to match the input string by expanding
non-terminals using production rules. Examples: Recursive Descent Parsing.
 Bottom-up Parsing: Starts with the input string and works its way back up to the start symbol,
trying to reduce the string using the grammar's production rules. Examples: Shift-Reduce
Parsing, LR Parsing.
Example of Parsing:

Let's take a simple grammar to explain parsing:

 Non-terminals: S
 Terminals: a, b
 Start symbol: S
 Production rules:
1. S → aSb
2. S → ε (where ε represents the empty string)

To parse the string aabb using this grammar, you would proceed as follows:

1. Start with the start symbol S.

2. Apply the production S → aSb to generate aSb.
3. Apply the production S → aSb again to the inner S, producing aaSbb.
4. Finally, apply S → ε to the inner S, producing aabb.

Thus, the string aabb is derived, and a parse tree would represent this process.

Ambiguity in Parsing

Ambiguity in the context of parsing refers to a situation where a given string can be parsed in multiple
ways, leading to different parse trees. This occurs when a grammar allows more than one valid way to
generate a string, meaning the grammar does not define a unique structure for every string in the
language.

Example of Ambiguity:

Consider the following grammar for simple arithmetic expressions:

 Non-terminals: E (Expression)
 Terminals: +, *, (, ), and a (representing operands)
 Start symbol: E
 Production rules:
1. E → E + E
2. E → E * E
3. E → a

Now, let's parse the string a + a * a.

 First parse tree:

o Apply E → E + E to generate E + E.
o Apply E → a to both the left and right E symbols, leading to the parse tree:

/\
 E + E

| |

a E

This represents the expression a + a, with the remaining * a still to be parsed

Second parse tree:

 Apply E → E * E to generate E * E.
 Apply E → a to both E symbols, leading to the parse tree:

Second parse tree:

 Apply E → E * E to generate E * E.
 Apply E → a to both E symbols, leading to the parse tree:

/\

E * E

| |

a a

 This represents the expression a * a, with the remaining + a still to be parsed.

 The two different parse trees indicate that the grammar is ambiguous because the same string can
be parsed in more than one way, leading to different interpretations.

In this case:

 The first parse tree would represent the expression (a + a) * a (since addition happens
first).
 The second parse tree would represent the expression a + (a * a) (since multiplication
happens first).

Thus, ambiguity arises from the fact that the grammar allows different interpretations of the same string.
Consequences of Ambiguity:

 Uncertainty in Interpretation: Ambiguous grammars can lead to multiple possible meanings for
the same string, which is undesirable in both programming languages and natural languages.
 Parsing Complexity: Ambiguity makes it difficult for parsers to determine a unique syntactic
structure, leading to complexities in parsing and requiring more sophisticated algorithms to
resolve ambiguity.
 Compilation Errors: In programming languages, ambiguity in the grammar could result in
incorrect or inconsistent interpretation of code, leading to compilation errors.

Eliminating Ambiguity:

To make a grammar unambiguous (i.e., to ensure that each string has a unique parse tree), there are
several techniques:

 Rewrite the Grammar: Modify the grammar to ensure that it generates a unique parse tree for
every string. For example, you could introduce precedence and associativity rules for operators to
resolve ambiguity.

Example: Modify the arithmetic grammar to prioritize multiplication over addition:

o E→E+T
o E→T
o T→T*F
o T→F
o F→a
 Use Operator Precedence: In arithmetic expressions, operator precedence can be enforced,
ensuring that multiplication is performed before addition, without requiring ambiguous rules.
 Left-Factoring: This technique involves reorganizing production rules to avoid ambiguity caused
by common prefixes.

Example:

E→E+E

E → E * E ,You could rewrite as:

E→E+T|T

T→T*F|F

F→a

Parentheses for Grouping: Use parentheses to explicitly define the order of operations in expressions,
eliminating ambiguity from the grammar.

Simplification of Context-Free Grammar (CFG)

Simplifying a Context-Free Grammar (CFG) refers to the process of removing unnecessary or
redundant parts of the grammar to make it more efficient and easier to work with, without changing the
language it generates. Simplifying a CFG typically involves removing useless symbols, unreachable
symbols, unit productions, and epsilon (empty) productions, and ensuring that the grammar is in a
more usable form.

Steps for Simplifying a CFG

1. Eliminate Useless Symbols: A symbol is useless if it cannot contribute to generating a string in

the language. There are two types of useless symbols:
o Non-generating symbols: Non-terminals that cannot generate a terminal string.
o Unreachable symbols: Non-terminals that cannot be reached from the start symbol.

Procedure:

o Remove non-generating symbols: Start by identifying all non-terminals that cannot

generate any terminal string. For each non-terminal, check if there's a production that can
eventually lead to a string of terminal symbols.
o Remove unreachable symbols: After removing non-generating symbols, check for any
non-terminals that cannot be reached from the start symbol. These are the unreachable
symbols and can be eliminated.
2. Eliminate Epsilon (ε) Productions: An epsilon production is a production of the form A → ε,
where a non-terminal can generate the empty string ε. Removing these productions is necessary
as they can complicate the grammar and lead to ambiguity.

Procedure:

o Identify non-terminals that can generate the empty string (i.e., A → ε).
o For every production of the form A → X1 X2 ... Xn, if A can derive ε, then add the
productions where any of X1, X2, ..., Xn can be replaced with ε. This creates new
productions.
o Remove the A → ε production after the new rules are added.
3. Eliminate Unit Productions: A unit production is a production of the form A → B, where A is
a non-terminal that produces another non-terminal B directly.

Procedure:

o For every unit production A → B, find all the productions for B, and replace A → B with
those productions. This can eliminate indirect non-terminal dependencies.
o Remove the unit production after the substitution.
4. Eliminate Useless Non-Terminals: These are non-terminals that cannot be derived from the start
symbol or do not contribute to generating any valid strings.

Procedure:

o After eliminating unit productions and epsilon productions, review the grammar and
ensure all non-terminals are either reachable from the start symbol or can generate
terminal strings.
 Example: Simplification of a CFG:

 Production rules:
1. S → AB
2. A → aA | ε
3. B → bB | C
4. C → ε

Step 1: Eliminate Epsilon (ε) Productions

 C → ε and A → ε are epsilon productions.

 We need to replace them in all relevant places.

**For A → aA | ε:

 If A → ε, we can derive S → AB as S → B.
 This gives us the new production S → B.

**For B → bB | C:

 If C → ε, we can replace C with ε in the production B → bB | C to get B → bB | ε.

 Now we have B → bB | ε.

Updated Grammar after removing epsilon productions:

 S → AB | B
 A → aA | ε
 B → bB | ε
 C → ε (to be removed as we will no longer need it)

Step 2: Eliminate Unit Productions

S → B is a unit production, and we need to replace it with the productions of B.

From B → bB | ε, we replace S → B with S → bB | ε.

Updated Grammar after removing unit productions:

 S → AB | bB | ε
 A → aA | ε
 B → bB | ε
Step 3: Eliminate Useless Symbols

 C is a useless non-terminal because it does not generate any terminal string (its only production
is C → ε, which is now removed).
 So, C is removed from the grammar.

Updated Grammar after removing useless symbols:

 S → AB | bB | ε
 A → aA | ε
 B → bB | ε

Final Simplified Grammar:

After applying the above steps, the simplified CFG is:

 Non-terminals: S, A, B
 Terminals: a, b
 Start symbol: S
 Production rules:
1. S → AB | bB | ε
2. A → aA | ε
3. B → bB | ε

This grammar is simplified and does not contain epsilon productions, unit productions, or useless
symbols.

Normal Forms in Context-Free Grammar (CFG)

The two most common normal forms are Chomsky Normal Form (CNF) and Greibach Normal Form
(GNF).

1. Chomsky Normal Form (CNF)

A CFG is in Chomsky Normal Form (CNF) if all of its production rules are of the following forms:

 A → BC where A, B, and C are non-terminal symbols, and B and C are not the start symbol.
 A → a where A is a non-terminal and a is a terminal symbol.
 A → ε is allowed only if the language includes the empty string ε, and A is the start symbol.

Properties of CNF:

 All productions are either of the form A → BC or A → a (except for the production for the empty
string).
  The grammar is highly restrictive, but it helps in algorithms like the CYK (Cocke-Younger-
Kasami) parsing algorithm.

Conversion to CNF:

1. Eliminate ε-productions: Remove epsilon productions (productions where a non-terminal

produces the empty string).
2. Eliminate unit productions: Remove productions of the form A → B, where A and B are non-
terminal symbols.
3. Eliminate useless symbols: Remove non-terminal symbols that do not generate any terminal
string or cannot be reached from the start symbol.
4. Binary production rules: Convert productions with more than two symbols on the right-hand
side into binary rules (i.e., of the form A → BC). For example, if you have a production like A →
XYZ, introduce a new non-terminal D to produce X and Y (i.e., A → DZ and D → XY).
5. Terminal symbols in rules: If a production has both terminals and non-terminals (e.g., A → aB),
replace the terminal with a new non-terminal. For example, replace A → aB with A → XB and
add a new production X → a.

Example:

Consider the CFG:

 S → AB | a
 A→a|ε
 B→b

Step 1: Remove ε-productions (in this case, A → ε):

 S → AB | a | B
 A→a
 B→b

Step 2: Remove unit productions (like S → B):

 Replace S → B with S → b.
 Final Grammar:
o S → AB | a | b
o A→a
o B→b

Step 3: Convert to binary productions:

 S → AB | a | b already satisfies CNF for binary production.

 A → a is also in CNF.

Now, the grammar is in Chomsky Normal Form.

2. Greibach Normal Form (GNF)

A CFG is in Greibach Normal Form (GNF) if all its production rules are of the following form:

 A → aα where A is a non-terminal, a is a terminal symbol, and α is a (possibly empty) string of

non-terminals.

Properties of GNF:

 Every production starts with a terminal symbol, followed by zero or more non-terminal symbols.
 GNF is useful in certain parsing algorithms and helps in generating deterministic top-down
parsers.

Conversion to GNF:

1. Eliminate ε-productions and unit productions as in the CNF conversion.

2. Rearrange productions to make sure that every production starts with a terminal symbol.
3. If the grammar contains productions with multiple non-terminals in the right-hand side (e.g., A
→ BCD), rewrite the grammar to ensure that the first symbol in the right-hand side is a terminal.

Example:

Consider the CFG:

 S → AB
 A→a|ε
 B→b

Step 1: Remove ε-productions:

 S → AB | B
 A→a
 B→b

Step 2: Make the first symbol a terminal:

 The production S → AB is valid for GNF, as it doesn’t start with a terminal.

 We need to modify it such that it starts with a terminal. Since A produces a, we can replace S →
AB with S → aB.

Final grammar in Greibach Normal Form:

 S → aB
 A→a
 B→b
Comparison Between CNF and GNF:

 CNF is more restrictive and is commonly used for algorithms like CYK parsing because of its
binary nature (each production has at most two non-terminals on the right-hand side).
 GNF is more suitable for top-down parsers, as it ensures that every production starts with a
terminal symbol, allowing for easier construction of recursive descent parsers.

Problems Related to Chomsky Normal Form (CNF) and Greibach Normal Form (GNF)

The Membership Problem is a fundamental problem that asks whether a given string belongs to
the language generated by a context-free grammar (CFG). This problem can be addressed using
different techniques depending on whether the grammar is in CNF, GNF, or general form.

The Membership Problem is the problem of determining if a given string w is generated by a context-
free grammar G, i.e., whether w ∈ L(G), where L(G) is the language generated by the CFG G.

 Input: A string w and a context-free grammar G.

 Output: "Yes" if w is in the language generated by G, "No" otherwise.

The problem can be solved using different algorithms depending on the form of the grammar.

The Membership Problem is the problem of determining if a given string w is generated by a context-
free grammar G, i.e., whether w ∈ L(G), where L(G) is the language generated by the CFG G.

 Input: A string w and a context-free grammar G.

 Output: "Yes" if w is in the language generated by G, "No" otherwise.

The problem can be solved using different algorithms depending on the form of the grammar.

CNF and Membership Problem

In the case of Chomsky Normal Form (CNF), the grammar is structured in a way that makes it easier to
implement efficient parsing algorithms for solving the Membership Problem. The two main parsing
techniques used for the Membership Problem in CNF are CYK (Cocke-Younger-Kasami) and Dynamic
Programming (DP).

CYK Algorithm

The CYK (Cocke-Younger-Kasami) algorithm is a bottom-up dynamic programming algorithm that is

specifically designed to work with grammars in CNF. The key feature of CNF is that the right-hand side
of each production is either two non-terminals or a single terminal. This makes the grammar more
suitable for algorithms like CYK, which uses a table-based approach to determine membership.

Steps for CYK Algorithm:

1. Convert the Grammar to CNF: Ensure the grammar is in Chomsky Normal Form.
 2. Create a Parsing Table:
o Let w = w₁w₂...wₖ be the input string with length k.
o Create a table of size k × k where the entry at [i, j] represents the non-terminals that can
generate the substring wᵢ...wⱼ.
3. Fill the Table:
o For each substring length from 1 to k, and for each substring of that length, check which
non-terminals can derive that substring by looking at the production rules.
4. Check for the Start Symbol:
o If the start symbol S appears in the entry [1, k] (the entry representing the entire string
w), then the string w is in the language generated by the grammar. Otherwise, it is not.

Complexity of CYK: The time complexity of CYK is O(k³), where k is the length of the input string w.
This makes CYK an efficient algorithm for solving the Membership Problem for CNF grammars.

Example:

For a simple CNF:

 S → AB
 A→a
 B→b

Let w = ab.

Using CYK, we would fill a table to check if w can be derived from the start symbol S. After filling the
table, we would check if S can generate the entire string, which it does in this case.

3. GNF and Membership Problem

In the case of Greibach Normal Form (GNF), the production rules are structured such that each
production starts with a terminal symbol followed by a sequence of non-terminals. This form is well-
suited for top-down parsers, especially for recursive descent parsing, which can be used to solve the
Membership Problem.

Top-Down Parsing for GNF

For GNF, a top-down recursive descent parser can be employed to determine whether a string w is
generated by a grammar in GNF. Here's how it works:

 Input: A string w and a GNF grammar G.

 Output: "Yes" if w is in the language generated by G, "No" otherwise.

The recursive descent parser will try to match the string w by recursively applying the production rules
starting from the start symbol. The parser attempts to break down w using the terminal symbols followed
by non-terminals, as dictated by the GNF rules.
Complexity of Top-Down Parsing:

 A top-down parser may take exponential time in the worst case, especially if the grammar has a
lot of recursion. However, it is more efficient than brute-force methods when dealing with
grammars in GNF, as each production starts with a terminal symbol.

4. Problems Related to CNF and GNF

1. Conversion to CNF:
o Given a CFG, the process of converting it into Chomsky Normal Form involves
eliminating epsilon-productions, unit-productions, and ensuring all right-hand sides are
either two non-terminals or a single terminal. This can be a complex task for large
grammars.
o Problem: The conversion to CNF may lead to an exponential increase in the size of the
grammar, especially when the grammar has many rules.
2. Conversion to GNF:
o Converting a CFG to Greibach Normal Form can also be challenging because each
production must start with a terminal symbol followed by a sequence of non-terminals.
This conversion may require significant transformations, including handling left
recursion.
o Problem: Left recursion must be removed before converting to GNF, which can be non-
trivial.
3. Ambiguity in CNF and GNF:
o Both CNF and GNF are not immune to ambiguity. A CFG may still generate multiple
parse trees even when it's in CNF or GNF.
o Problem: Determining whether a CFG in CNF or GNF is ambiguous (i.e., generates
multiple parse trees for the same string) is a difficult problem.