Module 3

Context Free Grammars

3.1 CFG

A CFG is a formal grammar used to describe the syntax or structure of a language in terms of
production rules. These rules define how strings of symbols can be generated in the language.
Context-free grammars are widely used in computer science for tasks such as defining the syntax
of programming languages, parsing natural language, and modeling biological sequences.

Components of CFG:

Symbols (Terminals):

These are basic units of language being generated. Terminals are symbols that appear in strings
generated by CFG.

Non-terminals (Variables):

Non-terminals are placeholders representing syntactic categories or groups of symbols.

Production Rules:

Production rules specify how non-terminals can be expanded into sequences of terminals and/or
other non-terminals. Each production rule consists of a non-terminal symbol (left-hand side) and
a sequence of symbols (right-hand side).

Start Symbol:

It is a special non-terminal that represents initial symbol from which derivation of strings begin.
It serves as root of derivation tree and indicates starting point for generating strings in language.

Formal Definition of a CFG:

Context-free grammars are used in parsing algorithms to analyze and recognize the syntactic
structure of strings according to the CFG rules. Parsing involves determining whether given
string can be generated by CFG and constructing a derivation tree to represent syntactic structure
of string.

3.2 Parse trees

Parse trees play a crucial role in understanding and analyzing the syntactic structure of strings
generated by formal grammars.

A parse tree (PT), also known as a derivation tree, illustrates the syntactic structure of a string
according to the production rules of a formal grammar. Each node in PT corresponds to a symbol
in the input string, and each edge represents one production rule application during derivation
process.

Components of PT:

Root Node:

The topmost node of PT represents start symbol of CFG, from which derivation of string begins.
Internal Nodes:

Internal nodes of parse tree represent non-terminal symbols of CFG. Each internal node is
labeled with a non-terminal symbol. PT’s children correspond to the symbols derived from that
non-terminal.

Leaf Nodes:

Leaf nodes of PT are terminal symbols of CFG. Each leaf node is a terminal symbol from input
string.

Edges:

Edges connecting nodes in PT represent application of production rules during derivation

Construction of Parse Trees:

Start Symbol: It forms the root node.

Expansion: Apply productions recursively to expand non-terminal symbols into sequences of

Terminal Placement: Label leaf nodes with corresponding terminal symbols from input.

Derivation Path: Each path from root to any leaf in PT represents a derivation of input from start
symbol.
3.3 Applications of CFG

Language Recognition:

PTs are used in parsing algorithms to recognize whether a given string belongs to the language
generated by CFG.

Ambiguity Detection:

PTS help identify ambiguity in grammars by revealing multiple valid interpretations or

Syntax Analysis:

Parse trees provide insights into the syntactic structure of strings, aiding in the understanding and
analysis of programming languages and natural languages.

Compiler Design:

PTs are utilized in syntax analysis phase of compilers. The purpose is to validate and parse
source code a/c grammar of PL.

Context-free grammars (CFGs) find applications in various fields, primarily in computer science,
linguistics, and related areas. Here are some of the key applications of context-free grammars:

Programming Languages:

CFGs are extensively used to define syntax of PLs. The structure of valid programs is described
by the rules for constructing statements, expressions, and other language constructs.
Parser generators like Yacc/Bison and ANTLR use CFGs to generate parsers for programming
languages, allowing developers to write compilers, interpreters, and other language-processing
tools.

Compiler Design:

In compiler construction, CFGs are used in the syntax analysis phase (parsing) to analyze
structure of source code in order to build PT.

PT which is intermediate representation of source code, is subsequently used in later phases of

Natural Language Processing (NLP):

CFGs are employed in NLP to model the syntax of natural languages. They describe the
grammatical rules governing the formation of sentences, phrases, and other linguistic structures.

CFG-based parsers can be used to parse and analyze text for tasks.

Syntax Highlighting and Code Analysis:

Text editors and integrated development environments (IDEs) use CFG-based grammars to
perform syntax highlighting, which visually distinguishes different language constructs in source
code based on their syntactic roles.

CFG-based static analysis tools can analyze source code for potential errors, code smells, and
style violations by parsing the code and checking it against predefined grammar rules.

Data Validation and Parsing:

CFGs are employed in data validation and parsing tasks across various domains, including
markup languages (e.g., XML, HTML), configuration files, log files, and network protocols.

By defining a grammar for the expected structure of data formats, CFG-based parsers can
validate input data for correctness and extract relevant information for further processing.

3.4 Ambiguity in grammars and languages

Ambiguity in grammars refers to situations where a single string in the language can be derived
by more than one PT. This can lead to confusion in parsing and interpretation, as there may be
multiple valid interpretations of the same input. Ambiguity can arise in both natural and formal
languages.
Parse Tree 1:

/ \

* 4

/ \

2 3

According to this interpretation, "2 * 3" is evaluated first, resulting in 6, which is then added to 4
to produce the final result of 10.

Parse Tree 2:

/ \

2 +

/ \

3 4
In this interpretation, "3 + 4" is evaluated first, resulting in 7, which is then multiplied by 2 to
produce the final result of 14.

To resolve ambiguity, the grammar can be modified to explicitly specify the precedence and
associativity of operators. For example, adding separate production rules for addition and
multiplication with appropriate precedence levels can clarify the intended parsing behavior:

In this grammar:

S represents a statement.

E represents an expression.

a represents some arbitrary terminal symbol.

Ambiguity: Let's look at the sentence "if E1 then if E2 then a else a". This sentence can be parsed
in two different ways:

Parse Tree 1:

/ | \

if E1 S

/ | | \

then if S else

/ \ | |
 E2 a a a

In this interpretation, the "else" clause belongs to the inner "if" statement.

In this interpretation, the "else" clause belongs to the outer "if" statement.

The ambiguity arises because the grammar does not specify the associativity of the "if-then-else"
construct. As a result, there are multiple valid ways to interpret the nesting of "if-then-else"
statements, leading to different parse trees and interpretations of the sentence.

To resolve ambiguity, the grammar can be modified to explicitly specify the associativity of the
"if-then-else" construct. For example, adding parentheses to indicate the associativity can clarify
the intended parsing behavior:

With this modified grammar, the ambiguity in parsing the sentence "if E1 then if E2 then a else
a" would be eliminated, as the parentheses would enforce a specific grouping of the "if-then-
else" constructs.
Example:

Consider the following context-free grammar for arithmetic expressions with explicit precedence
rules:

Sentence:

Let's consider the sentence "2 * 3 + 4".

Parse Tree:

The unambiguous parse tree for the sentence "2 * 3 + 4" would be as follows:

/\

* 4

/\

2 3

In this parse tree, the multiplication operation ("2 * 3") is evaluated first, and then the addition
operation ("result of 2 * 3 + 4") is performed. This unambiguous interpretation follows the
precedence rules specified in the grammar, where multiplication takes precedence over addition.

This grammar specifies explicit precedence rules for + and * operations. * has higher precedence
than +, which means that * operations are evaluated before + operations. Additionally, the
grammar enforces left associativity for both operations, meaning that when there are multiple
operators of the same precedence level, they are evaluated from left to right.

Benefits:

Using an unambiguous grammar with explicit precedence rules ensures that there is only one
valid interpretation of a given sentence, eliminating ambiguity and ensuring predictable parsing
behavior. This clarity is crucial for language processing tasks such as compiler design, syntax
analysis, and natural language processing, where unambiguous interpretations are essential for
correct program execution or understanding of natural language expressions.

3.5 Normal forms for CFG

CFGs can be transformed into various normal forms to simplify their analysis and processing.

The two most common normal forms for context-free grammars are the Chomsky Normal Form
(CNF) and the Greibach Normal Form (GNF).

Chomsky Normal Form (CNF):

C -> XY | a

X -> AB

Y -> AB

D -> FF

E -> FF

F -> C

Resulting CNF Grammar is:

S -> XY | BC

A -> BA | a

B -> FF | b

C -> XY | a

X -> AB

Y -> AB

D -> FF

E -> FF

F -> C
Example:

Let's consider the language L={anbncn ∣ n≥0}, which consists of strings of the form anbncn . We
can use the pumping lemma to prove that L is not context-free.

Assume L is context-free.

Let p be the pumping length given by the pumping lemma.

Consider the string s=apbpcp in L.

According to the pumping lemma, s can be divided into five substrings:

u,v,w,x,y, satisfying the conditions of the lemma.

Pumping down or up by one (i.e., setting i=0 or i=2) leads to a string that does not belong to

L, since the number of a's, b's, and c's will no longer be equal.

Therefore, L cannot be context-free.