Context-Free Grammars, and Parsing Introduction (2025 Edition) Automata

AUTOMATA AND
COMPILER THEORIES
AND FORMAL
LANGUAGES
Prepared by: Maxil S. Urocay MSCS ongoing

“Prayer to the Holy Spirit by St. Augustine”
Breathe in me, O Holy Spirit,
That my thoughts may all be holy.
Act in me, O Holy Spirit,
That my work, too may be holy.
Draw my heart, O Holy Spirit.
That I love but what is holy.
Strengthen me, O Holy Spirit,
To defend all that is holy.

CONTEXT-FREE GRAMMARS

A Context-Free
Grammar (CFG) is a type of
formal grammar used to
define the syntax of
programming languages
and natural languages.
WHAT IS A CONTEXT-FREE GRAMMAR
(CFG)?

In CFGs, the rules
(called production rules)
are used to replace non-
terminal symbols with a
string of terminals and/or
non-terminals.
(CFG)?

This process helps to
generate strings that
belong to a certain
language. These strings
are structured and can be
parsed or understood in a
recursive manner.
(CFG)?

Non-Terminals (Variables)
V:
These are symbols
that can be replaced by
other symbols. They
represent concepts or
structures in the
language.
COMPONENT OF CFGs

Terminals Σ:
These are the actual
content symbols of the
language, like words in
natural language or
characters in
programming.
COMPONENT OF CFGs

Production Rules R:
These define how
non-terminals can be
replaced by a combination
of terminals and non-
terminals.
COMPONENT OF CFGs

Start Symbol S:
This is the initial non-
terminal from which all
derivations begin. It
represents the entire
structure of the language.
COMPONENT OF CFGs

Example Grammar (G):
S aSb | bSa | SS |
→ ε
S is the start symbol.
a and b are terminals.
S is also a non-terminal.
CONTEXT-FREE GRAMMAR

S aSb | bSa | SS |
→ ε
Step 1:
Start with the start
symbol, S.

S aSb | bSa | SS |
→ ε
Step 2:
Use production rules to
replace S with one of the
options. For example, S →
aSb. Now we have "aSb".

S aSb | bSa | SS |
→ ε
Step 3:
Repeat the process for
the non-terminal S inside the
string. This will give us
something like "aabSb", and
so on.

The production rules
define how to form larger
strings from smaller building
blocks (the terminals).

In Compiler Design:
CFGs are used to
describe the syntax of
programming languages.
When writing a program, the
compiler uses a CFG to check
if the syntax is correct.
IMPORTANCE OF CFGS IN LANGUAGE
DESIGN

In Compiler Design:
Example: A simple
programming language with
if-else statements can be
represented using CFGs.
DESIGN

In Natural Language
Processing (NLP):
CFGs are used to model
the structure of sentences in
languages like English,
French, etc.
DESIGN

In Natural Language
Processing (NLP):
Example: The sentence
"The cat sleeps" can be
broken down into a structure
where "The cat" is a noun
phrase (NP), and "sleeps" is a
verb phrase (VP).
DESIGN

A Context-Free Grammar
(CFG) can be categorized into
two types based on whether it
produces a unique or multiple
ways to derive a string.
Unambiguous CFG and
Ambiguous CFG.
CONTEXT-FREE GRAMMARS

Grammar for Arithmetic
Expressions:
E E + T | T
→
T T * F | F
→
F id | (E)
→
CFG FOR ARITHMETIC EXPRESSIONS

Expressions:
E E + T | T
→
T T * F | F
→
F id | (E)
→
E (Expression) can be another
expression plus a term (E E +
→
T) or just a term (E T).
→

Expressions:
E E + T | T
→
T T * F | F
→
F id | (E)
→
T (Term) can be another term
multiplied by a factor (T T * F)
→
or just a factor (T F).
→

Grammar for Arithmetic Expressions:
E E + T | T
→
T T * F | F
→
F id | (E)
→
F (Factor) can be an identifier (a
number or variable, represented as id)
or a complete expression enclosed in
parentheses (F (E)).
→

What Does This Grammar Represent?
E E + T:
→
This rule says that an expression
can be the sum of another expression
and a term (like a + b).

T T * F:
→
This rule says that a term can be
the product of another term and a
factor (like b * c).

F id:
→
A factor can simply be an
identifier (like a variable or number,
such as a, b, 5).

F (E):
→
A factor can also be an entire
expression wrapped in parentheses,
which means the operations inside the
parentheses are evaluated first.

Operators in Arithmetic:
Addition (+) and Multiplication (*)
are arithmetic operators.
ARITHMETIC OPERATORS AND
PRECEDENCE

Operator Precedence:
In mathematics, multiplication has
higher precedence than addition. This
means that in expressions like a + b *
c, we first calculate b * c and then add
a.
PRECEDENCE

The CFG captures this precedence
naturally, as multiplication (*) is
handled in the T T * F rule, whereas
→
addition (+) is handled in the E E + T
→
rule.
PRECEDENCE

In the CFG for a + b * c, the
multiplication is handled before the
addition, just as in standard arithmetic.
Multiplication First: We expand T * F
first (b * c) before adding a to the
result.
PRECEDENCE

Left-to-Right Associativity:
Most arithmetic operators
(including + and *) are left-associative,
which means expressions are
evaluated from left to right.
For example, a + b + c is evaluated as (a
+ b) + c.
ASSOCIATIVITY IN ARITHMETIC
EXPRESSIONS

How CFGs Work with Associativity:
Addition:
The CFG will apply the addition
rules left-to-right.
Multiplication:
Similarly, multiplication is
handled before addition because of
the order of rules.
ASSOCIATIVITY IN ARITHMETIC
EXPRESSIONS

E E + T | T
→
T T * F | F
→
F id | (E)
→ String: a+b*c
Start with E:
Apply E E + T: The expression is
→
now E + T.
This is an addition expression, so we
now need to expand both parts of it.
CFG ARITHMETIC EXPRESSIONS
EXAMPLE

E E + T | T
→
T T * F | F
→
F id | (E)
→ String: a+b*c
Expand E (the left side of the addition):
Apply E T: The left side is now a term.
→
Apply T F: The term is a factor.
→
Apply F id (left side terminal, a): We
→
get a.
EXAMPLE

E E + T | T
→
T T * F | F
→
F id | (E)
→ String: a+b*c
Expand T (the right side of the addition):
Apply T T * F: The right side is now a
→
term multiplied by a factor.
Apply T F: The term is a factor.
→
EXAMPLE

E E + T | T
→
T T * F | F
→
F id | (E)
→ String: a+b*c
Apply F id (right side terminal, b): We
→
get b.
Apply F id (for the second factor, c):
→
We get c.
EXAMPLE

An unambiguous CFG is
a grammar in which every
string derived from the start
symbol has only one valid
parse tree.
WHAT IS AN UNAMBIGUOUS CFG?

This means that there is
no ambiguity in how a string
is derived, and it has a single
interpretation.
WHAT IS AN UNAMBIGUOUS CFG?

An ambiguous CFG is a
grammar where some strings
have multiple valid parse
trees.
WHAT IS AN AMBIGUOUS CFG?

This means the
grammar does not specify a
unique way to derive a string.
WHAT IS AN AMBIGUOUS CFG?

Ambiguity creates
uncertainty about the
structure of a string, which
can lead to confusion in
parsing and interpretation.
WHY AMBIGUITY IS A PROBLEM

In programming languages,
this could result in syntax errors or
unpredictable behavior.
In the expression a + b * c, if the
grammar is ambiguous, it’s unclear
whether the multiplication or
addition should be performed first.

Problem in Programming:
int result = a + b * c;
If the grammar is ambiguous,
the program could be interpreted
as:
a + (b * c) (multiplication first,
correct behavior in most
languages).

Problem in Programming:
int result = a + b * c;
If the grammar is ambiguous,
the program could be interpreted
as:
(a + b) * c (addition first, which
changes the meaning completely).

Ambiguity in CFGs must be
resolved in programming
languages to ensure that
operations are performed in the
correct order.

Disambiguating CFGs:
One solution to resolve
ambiguity is to introduce
precedence rules or associativity.
HOW TO SOLVE AMBIGUITY?

Disambiguating CFGs:
Precedence: Operators like *
have higher precedence than +.
Associativity: Some operators (like
+ and *) are left-associative,
meaning operations are performed
from left to right.
HOW TO SOLVE AMBIGUITY?

A derivation is the process of
applying production rules step-by-
step to derive a string from the
start symbol.
WHAT IS A DERIVATION?

There are two methods for
choosing which non-terminal to
replace first during the derivation
process:
Leftmost and Rightmost
Derivations
WHAT IS A DERIVATION?

In leftmost derivation, at each
step, you always replace the
leftmost non-terminal first.
This method expands the grammar
from left to right.
WHAT IS LEFTMOST DERIVATION?

E E + T | T
→
T T * F | F
→
F id | (E)
→
String: a + b * c

Start with the start symbol: E
Initial string: E
Apply the production rule E E + T:
→
We replace E with E + T.
Now, we have: E + T

Apply the production rule E T
→
(since E is now the leftmost non-
terminal):
We replace the first E with T.
Now, we have: T + T

Apply the production rule T F for
→
the first T (the leftmost non-
terminal):
We replace the first T with F.
Now, we have: F + T

Apply the production rule F id for
→
the first F (the leftmost non-
terminal):
We replace F with id (which
represents a in this case).
Now, we have: id + T

Apply the production rule T T * F
→
for the second T (the leftmost non-
terminal):
We replace T with T * F.
Now, we have: id + T * F

→
the T (the leftmost non-terminal):
We replace T with F.
Now, we have: id + F * F

→
both F (representing b and c):
We replace both F symbols with id
(representing b and c).
Now, we have: id + id * id

In leftmost derivation, we
always replace the leftmost non-
terminal first until the entire string
is derived.

In rightmost derivation, at
each step, you always replace the
rightmost non-terminal first.
This method expands the grammar
from right to left.
WHAT IS RIGHTMOST DERIVATION?

E E + T | T
→
T T * F | F
→
F id | (E)
→
String: a + b * c

Start with the start symbol: E
Initial string: E
Apply the production rule E E + T:
→
We replace E with E + T.
Now, we have: E + T

→
the T (the rightmost non-terminal):
Now, we have: E + F

Apply the production rule F T*F
→
for the F (the rightmost non-
terminal):
We replace F with T * F.
Now, we have: E + T * F

→
the F (the rightmost non-terminal):
We replace F with id (representing c
in this case).
Now, we have: E + T * id

→
the left T:
Now, we have: E + F * id

→
the left F:
We replace F with id (representing
b in this case).
Now, we have: E + id * id

Apply the production rule E T for
→
the left E:
We replace E with T.
Now, we have: T + id * id

→
the left T:
Now, we have: F + id * id

→
the left F:
We replace F with id (representing
a in this case).
Now, we have: id + id * id

In rightmost derivation, we
always replace the rightmost non-
terminal first until the entire string
is derived.

CFGs are not just theoretical
concepts; they are widely used in
computational linguistics,
programming languages, and
parsing techniques.
APPLICATIONS OF CONTEXT-FREE
GRAMMARS (CFGS)

Understanding the
applications of CFGs helps us see
how these grammars are used to
define the syntax of languages and
guide language processing.
GRAMMARS (CFGS)

Compilers:
CFGs are used in compilers to
define the syntax of programming
languages.
A compiler translates source code
written in a high-level language (like C,
Java, Python) into machine code.
During this process, CFGs are used to
ensure the correct syntax of the code.
GRAMMARS (CFGS)

Compilers:
Example: A simple arithmetic
expression in code, like a + b * c, needs
to be parsed according to operator
precedence rules (multiplication first,
then addition). The CFG will ensure
that the expression is correctly
understood.
GRAMMARS (CFGS)

Parsing Sentences:
CFGs are used in Natural
Language Processing (NLP) to model
sentence structures in human
languages.
GRAMMARS (CFGS)

Parsing Sentences:
Example: In NLP, CFGs are used to
parse sentences into noun phrases
(NP) and verb phrases (VP), which
helps in understanding the meaning of
the sentence.
GRAMMARS (CFGS)

Mathematical Expression Parsers:
CFGs are used to define the
syntax of mathematical expressions
and ensure that operators like +, -, *,
and / are applied in the correct order.
GRAMMARS (CFGS)

Mathematical Expression Parsers:
Example: For the expression a + b
* c, the CFG ensures that multiplication
happens before addition (due to
precedence rules).
GRAMMARS (CFGS)

Configuration Files:
CFGs are used to define the syntax of
configuration files in software
applications, ensuring that the files are
structured correctly.
GRAMMARS (CFGS)

Database Query Parsing:
In databases, SQL queries are parsed
using CFGs to ensure they are
syntactically correct before execution.
GRAMMARS (CFGS)

A parse tree is a tree
structure that visually
represents how a string can
be derived from a Context-
Free Grammar (CFG).
WHAT IS A PARSE TREE?

The root of the tree is the
start symbol, and the leaves
are the terminals (actual
symbols in the string).

The internal nodes
represent non-terminals that
are further replaced by other
non-terminals or terminals.

Why is it important?
A parse tree helps us
understand the structure of
the string and how it is
derived.

Why is it important?
It shows exactly how
production rules are applied
step-by-step.

Start with the start symbol.
Begin with the root node
labeled with the start symbol.
Example:
If our CFG is S aSb |
→
bSa | SS | ε, the start symbol
is S.
HOW TO CREATE A PARSE TREE - THE
BASIC STEPS

Use the production rules
To expand the start
symbol and non-terminal
symbols.
Production rules are used to
replace non-terminals with
combinations of non-
terminals and terminals.
BASIC STEPS

Expand Non-Terminals
Continue expanding the
non-terminals until only
terminal symbols are left.
Terminal symbols are the
symbols that appear in the
string and cannot be replaced
further.
BASIC STEPS

Terminate with Terminals:
Stop expanding once all
symbols in the tree are
terminals.
The leaves of the tree are the
actual symbols from the
string.
BASIC STEPS

Example:
Let’s take the string abab
and the following CFG:
S aSb | bSa | SS |
→ ε
PARSE TREE EXAMPLE

A parse tree shows the
derivation order, which non-
terminal is replaced first, and
how the structure develops
step by step.
DERIVATION ORDER IN PARSE TREES

Leftmost Derivation (LMD):
Always replace the leftmost
non-terminal first.
Example: For S aSb |
→ ε:
S aSb ab
→ →

Rightmost Derivation (RMD):
Always replace the rightmost
non-terminal first.
Example: For S aSb |
→ ε:
S aSb ab
→ →

Syntax Checking:
Parse trees are essential
in compilers for checking
whether a string (like a
program) follows the correct
syntax.
IMPORTANCE OF PARSE TREES

Language Understanding:
In natural language
processing (NLP), parse trees
help break down sentences
into their grammatical
components (e.g., noun
phrase, verb phrase).

Visualizing the Structure:
Parse trees allow us to
visually understand how a
complex string is constructed
from smaller building blocks.

What is Ambiguity?:
A grammar is ambiguous
if there are multiple parse
trees for the same string.
AMBIGUITY IN PARSE TREES

Why is Ambiguity a Problem?:
Ambiguity can cause
confusion in parsing and
interpreting strings. In
programming, this could lead
to syntax errors or incorrect
behavior in compilers.
AMBIGUITY IN PARSE TREES

Syntax Trees for Compilers:
Parse Trees (also called
syntax trees) are used by
compilers to check the
structure of the program as it
is parsed.
HOW PARSE TREES ARE USED IN
APPLICATIONS

Syntax Trees for Compilers:
A syntax tree allows the
compiler to understand how
the language rules are
applied to the source code,
ensuring correctness.
APPLICATIONS

Visualizing Expressions in
Compilers:
Parse trees are also used
in intermediate
representations of code,
which are then used for
optimization or machine code
generation.
APPLICATIONS

Language Models in NLP:
In NLP, parse trees help
computers understand
human language by breaking
sentences down into
constituent parts (subject,
verb, object).
APPLICATIONS

Language Models in NLP:
Example: In speech
recognition systems, parse
trees are used to break down
spoken sentences into a form
that the computer can
process.
APPLICATIONS

Machine Translation:
Parse trees are essential
in machine translation (e.g.,
translating from English to
French), as they break down
the structure of a sentence in
one language, then help
rebuild it in the target
language.
APPLICATIONS

Top-Down Parsing:
Parse trees are used in
top-down parsing (a type of
predictive parsing) to check if
the syntax of a string matches
the grammar.
APPLICATIONS OF PARSE TREES IN
PARSING ALGORITHMS

Top-Down Parsing:
The parser begins with
the start symbol and applies
rules recursively to break
down the string.
PARSING ALGORITHMS

Bottom-Up Parsing:
Parse trees are also used in
bottom-up parsing to construct
the syntax tree from the leaves
up to the root. This type of
parsing builds the tree by
combining smaller parts of the
input into larger units, following
grammar rules.
PARSING ALGORITHMS

Syntax Checking Example
Example: In a C program,
the statement int result = a + b *
c; is checked for correct syntax.
The CFG for arithmetic
expressions is used to check
whether the expression adheres
to the rules of precedence and
associativity.
PARSING ALGORITHMS

A well-formed language begins with a
solid grammar, and its structure is
revealed through parse trees, guiding
us toward clarity in both computation
and communication.

THANK
YOU

SHORT QUIZ

Context-Free Grammars, and Parsing Introduction (2025 Edition) Automata

More Related Content

Similar to Context-Free Grammars, and Parsing Introduction (2025 Edition) Automata

More from MaxilUrocay1

Recently uploaded

Context-Free Grammars, and Parsing Introduction (2025 Edition) Automata

Editor's Notes