0% found this document useful (0 votes)

875 views290 pages

Lectures Examples and Solutions of CFG&RE

This document provides examples and solutions for context-free grammars (CFGs) and regular expressions (REs). It begins by giving CFGs that generate languages of strings with even lengths, odd lengths, signed integers in C++, and palindromes. It then gives CFGs and REs for languages containing strings that begin with a and end with b, contain a specified number of c, or where the number of a's equals the number of b's. The document concludes by providing solutions to generate languages involving nested parentheses, integer identifiers, real numbers in Pascal, and other context-sensitive problems. Overall, the document demonstrates how to write CFGs and REs to describe various formal languages.

Uploaded by

Anutaj Nagpal

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

875 views290 pages

Lectures Examples and Solutions of CFG&RE

Uploaded by

Anutaj Nagpal

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 290

Lectures examples and solutions of CFG&RE

1- Write a CFG that accepts even length of statements over ∑= {a}.

L={λ, aa,aaaa,…}
S-> aaS|λ
2- Write a CFG that accepts odd length sentences over ∑={a} .
L={a,aaa,aa aaa,…}
S-> aaS|a
Hint: λ is even so we didn’t include it in L.
3- Write CFG that accepts signed integer in C++
S-> x N
x-> +|-|λ
N-> A N |A
A-> 0|1|…|9
4- Write a CFG that accepts all palindrome sentences over ∑={a,b}.
L={λ,a,b,aa,bb,aba,bab,…}
S -> aSa|bSb|a|b|λ
5- Write a CFG that generates all sentences that begin with a , and end with b and contain :
- One C
- One or more C

Contain one C Contain one or more c

L={acb,aabcb,…} S->ax c xb
S -> ax c xb x-> ax|bx|cx|λ
x->ax |bx|λ
Another solution : Another solution :
S-> aA S-> aA
A-> aA|bA|cB A-> aA|bA|cB
B->ab|bB|b B->aB|bB|cB|b

6- Write CFG for L(G)= { a^n b^n c^m | n,m>=0 } Over ∑={a,b,c}
L= {λ,abc,aabbc,abccc,…}
S-> AB
A->aAb|λ
B->cB|λ
7- Describe in English the following grammar
S-> aS|Sb|b
This grammar generates:
- Set of a’s followed by b
- a’s followed by set of b’s
- one b
8- Describe in English :
S-> aS|bB
B->aB|λ

This grammar generates: Set of a’s followed by b followed by set of a’s.

9- Write a CFG for Grammar of integer identifier , Over ∑={a,b,c}
Example: int ab,ba, aa ;
S->TDx
x->;
T->int
D->D,V|V
V> aV|bV|cV|a|b|c
10- Write CFG for nested parentheses ( ( ( ) ) ) .
S-> (S)|()
11- Write CFG for Multiplied parentheses () () () .
S -> ()S | ()
12- Write a CFG for well-formed parentheses
Like : ()() (()) ()
S-> SS|(S)|()
13- Write CFG for language that has
# a’s = # b’s
L={λ,ab,aabb,baab,bbaaab,…}
S-> SS|bSa|aSb|λ
14- Write a CFG for : L(G)= { b^n a^m b^2n | m,n>=0}
L={λ,babb,a,bbb,…}
S-> bsbb|A
A-> aA|λ
15- Write a CFG for L(G)={a^m b^n a^n b^m | m,n>=0}
S-> aSb|x
x->bxa|λ
16- Write a CFG for L(G)={a^m b^n a^m+2 |m,n>=0}
To simplify L(G)= { a^m b^n a^m aa | m,n>=0}
S-> Maa
M-> aMa|x
x->bx|λ
17- Write a CFG for real numbers in pascal
Ex. 345.678 E (+ or – or λ) 569
<real> -> <digit> <digits> <decimal Part> <exp>
<digit > -> 0|1|2|...|9
<digits> -> <digit><digits> | λ
<decimal Part> -> <Dot> <digit> <digits> |λ
<Dot> -> .
<exp> - > <E> <sign> <digit> >digits> |λ
<E> -> E
<sign> -> +|-|λ
18- Write a CFG for language that doesn’t have bb , over ∑={a,b}
S-> aS|baS|xb|λ
x-> bax|ax|λ
19- Write the last example in Regular expression
(a ∪ ba)* ∪ (a ∪ ba)* b
20- L(G) = { a^n b^n c^n | n>=1}
This problem solved using
L= {abc , aabbcc,…} context sensitive
S-> aSBc |abc grammar only, we can’t
cB->Bc solve it using CFG

bB->bb

21- Write RE for all sentences over ∑={a,b,c} , such that all sentences has one c .

RE = (a ∪ b)* c (a∪ b)*

In CFG
S-> NcN
N->aN|bN|λ

In regular grammar
S-> aS|bS|cA
A-> aA|bA|λ

22- Write the same sentences in the last example but contain at least 2’c adjacent.

L = {accb,bcaccb,acbbccccbac,…}
RE = ( a ∪ b ∪ c )* c c ( a ∪ b ∪ c )*

In CFG
S-> NccN
N-> aN|bN|cN|λ

23- Write a CFG over Z={a,b} , such that each b followed by a , and # of a’s are twice the # of b’s .

L={ baa,aba,aababa,…}
S-> aSba| baSa|SS|λ

24- L(G)= {a^n b^m C^n+m | n,m>=0}

To simplify L(G)= a^n b^m c^m C^n

CFG
S-> aSc|x
x->bxc|λ

25- L(G)= { am bn+2 cm+2 | m,n>=0 }

To simplify
L(G)= a^m b^n bb c^m cc
S-> aSc|A
A->B bb cc
B->bB|λ
Solution2
S-> aSc|bbx
x-> bx|cc

26- L(G) = a* a+ b* b+
Simplify = L(G)= a+ b+
CFG
S->AB
A-> aA|a
B->bA|b
Converting CFGs to CNF (Chomsky Normal Form)
Richard Cole
October 17, 2007

A CNF grammar is a CFG with rules restricted as follows.

The right hand side of a rule consists of:

i. Either a single terminal, e.g. A → a.

ii. Or two variables, e.g. A → BC,
iii. Or the rule S → , if is in the language.

iv. The start symbol S may appear only on the left hand side of rules.

Given a CFG G, we show how to convert it to a CNF grammar G0 generating the same
language.
We use a grammar G with the following rules as a running example.

S → ASA | aB; A → B | S; B → b |
We proceed in a series of steps which gradually enforce the above CNF criteria; each step
leaves the generated language unchanged.

Step 1 For each terminal a, we introduce a new variable, Ua say, add a rule Ua → a, and
for each occurrence of a in a string of length 2 or more on the right hand side of a rule,
replace a by Ua . Clearly, the generated language is unchanged.
Example: If we have the rule A → Ba, this is replaced by Ua → a, A → BUa .
This ensures that terminals on the right hand sides of rules obey criteria (i) above.
This step changes our example grammar G to have the rules:

S → ASA | Ua B; A → B | S; B → b | ; Ua → a

1
2

Step 2 For each rule with 3 or more variables on the righthand side, we replace it with a
new collection of rules obeying criteria (ii) above. Suppose there is a rule U → W1 W2 · · · Wk ,
for some k ≥ 3. Then we create new variables X2 , X3 , · · · , Xk−1 , and replace the prior rule
with the rules:

U → W1 X2 ; X2 → W2 X3 ; · · · ; Xk−2 → Wk−2 Xk−1 ; Xk−1 → Wk−1 Wk

. Clearly, the use of the new rules one after another, which is the only way they can be used,
has the same effect as using the old rule U → W1 W2 · · · Wk . Thus the generated language is
unchanged.
This ensures, for criteria (ii) above, that no right hand side has more than 2 variables.
We have yet to eliminate right hand sides of one variable or of the form .
This step changes our example grammar G to have the rules:

S → AX | Ua B; X → SA; A → B | S; B → b | ; Ua → a

Step 3 We replace each occurrence of the start symbol S with the variable S 0 and add the
rule S → S 0 . This ensures criteria (iv) above.
This step changes our example grammar G to have the rules:

S → S 0 ; S 0 → AX | Ua B; X → S 0 A; A → B | S 0 ; B → b | ; Ua → a

Step 4 This step removes rules of the form A → , as follows. First, we determine
all variables that can generate in one or more moves. We explain how to do this two
paragraphs down. Then for each such variable A, for each occurrence of A in a 2-variable
right hand side, we create a new rule with the A omitted; i.e. if there is a rule C → AB we
create the new rule C → B, and if there is a rule C → DA we create the new rule C → D
(if there is a rule C → AA, we create the new rule C → A). Then we remove all rules of the
form A → , apart from S → , if present (i.e. we keep rule S → , if present).
The new rules serve to shortcut a previously generatable instances of , i.e. if previously
we had used a rule A → BC, and then in a series of steps had generated from B, which
has the net effect of generating C from A, we could instead do this directly by applying the
new rule A → C. Consequently, the generated language is unchanged.
To find the variables that can generate , we use an iterative rule reduction procedure.
First, we make a copy of all the rules. We then modify the rules by removing from the right
hand sides all instances of variables A for which there is a rule A → . We keep iterating
this procedure so long as it creates new reduced rules with on the right hand side. (An
efficient implementation keeps track of the lengths of each right hand side, and a list of the
locations of each variable; the new rules with on the right hand side are those which have
newly obtained length 0. It is not hard to have this procedure run in time linear in the sum
of the lengths of the rules.)
This step changes our example grammar G to have the rules:
3

S → S 0 ; S 0 → AX | X | Ua B; X → S 0 A | S 0 ; A → B | S 0 ; B → b; Ua → a

Step 5 This step removes rules of the form A → B, which we call unit rules. We form
the directed graph defined by these rules, i.e. for each rule A → B, we create a directed
edge (A, B). For each strong component in this graph, we replace the variables it contains
with a single one of these variables in all the rules in which these variables occur. So if
U1 , U2 , · · · , Uk form a strong component (and so any one of these variables can be replaced,
in a sequence of applications of unit rules, by any other of these variables) then we replace
every occurrence of Ui , 2 ≤ i ≤ k with U1 in every rule in which they occur.
In the example grammar, the one non-trivial strong component contains the variables
{S , X}. We replace S 0 with X yielding the rules:
0

S → X; X → AX | X | Ua B; X → XA | X; A → B | X; B → b; Ua → a
We can remove the unnecessary rule X → X also.
Next, we traverse the resulting acyclic graph, in reverse topological order (i.e. starting at
nodes with no outedges and working back from these nodes); for each traversed edge (E, F ),
which corresponds to a rule E → F , for each rule F → CD, we add the rule E → CD,
and then remove the rule E → F . Any derivation which had used the rules E → F and
F → CD in turn can now use the rule E → CD instead. So the same strings are derived
with the new set of rules. (This can be implemented via a depth first search on the acyclic
graph.)
This step changes our example grammar G to have the rules:

S → AX | Ua B | XA; X → AX | Ua B | XA; A → b | AX | Ua B | XA; B → b; Ua → a

Steps 4 and 5 complete the observance of criteria (ii), and thereby creates a CNF grammar
generating the same language as the original grammar.
CS 360
Naomi Nishimura

State elimination
Note: this information is meant to cover some material used in class but absent from the
textbook. This is not intended to be comprehensive or a replacement for attending lecture.
This handout is based on material developed by Jeff Shallit for CS 360, in turn based on
material developed by Eric Bach of the University of Wisconsin.
In Section 3.2.2 of the textbook, an algorithm is given for constructing a regular expression
from a DFA. The algorithm presented here (and in class) is simpler to understand, and applies
to NFA’s and -NFA’s as well.
As in the textbook, we will remove states from the automaton, replacing labels of arcs, so
that in the end a single regular expression is formed. The single regular expression will be the
label on an arc that goes from the start state to the accepting state, and this will be the only
arc in the automaton.
The algorithm forms the simpler automaton as follows. In step 1, we modify the automaton
to have a start state that is not an accepting state and has no transitions in (either self-loops or
from other states). In step 2, we create an equivalent automaton that has a single accepting state
with no transitions out. These will be the two states that remain at the end of the algorithm.
In step 3, the other states are eliminated, in any order. Details of the algorithm follow, along
with a running example, illustrated below.

b
b
a b

1 2 3 4
!
a a

Step 1
If the start state is an accepting state or has transitions in, add a new non-accepting start
state and add an -transition between the new start state and the former start state.

b
b
a b

1 2 3 4
!
a a
! a

0
CS 360: State elimination 2

Step 2
If there is more than one accepting state or if the single accepting state has transitions out,
add a new accepting state, make all other states non-accepting, and add an -transition from
each former accepting state to the new accepting state.

b
b
a b

1 2 3 4
!
a a

!
!

!
0 0
5

Step 3
For each non-start non-accepting state in turn, eliminate the state and update transitions
according to the procedure given on page 99 of the textbook, Figures 3.7 and 3.8. The following
illustrations depict the removal of states 1, 2, 3, and 4 in that order.

b
b b

2 ab + ! 3 4

!
a
!
0 0
5
CS 360: State elimination 3

b
b

b + a(aa)∗ (ab + !)
3 4

a + a(aa)∗ (ab + !)
!

!
0 0
5

(a + a(aa)∗ (ab + !))b∗ b

(b + a(aa)∗ (ab + !))b∗ b 4

! + (a + a(aa)∗ (ab + !))b∗

(b + a(aa)∗ (ab + !))b∗

0 0
5

(b + a(aa)∗ (ab + !))b∗ +

((b + a(aa)∗ (ab + !))b∗ b)((a + a(aa)∗ (ab + !))b∗ b)∗ (! + (a + a(aa)∗ (ab + !))b∗ )

0 0
5
CS 208: Automata Theory and Logic
Lecture 6: Context-Free Grammar

Ashutosh Trivedi

b a a

start A ∀x(La (x) → ∃y.(x < y) ∧ Lb (y))

b
Department of Computer Science and Engineering,
Indian Institute of Technology Bombay.

Ashutosh Trivedi – 1 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Context-Free Grammars

Pushdown Automata

Properties of CFLs

Ashutosh Trivedi – 2 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Context-Free Grammars

Noam Chomsky
(linguist, philosopher, logician, and activist)
“ A grammar can be regarded as a device that enumerates the sentences of a language. We
study a sequence of restrictions that limit grammars first to Turing machines, then to two
types of systems from which a phrase structure description of a generated language can be
drawn, and finally to finite state Markov sources (finite automata). ”
Ashutosh Trivedi – 3 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Grammars
A (formal) grammar consists of
1. A finite set of rewriting rules of the form

φ→ψ

where φ and ψ are strings of symbols.

Ashutosh Trivedi – 4 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Grammars
A (formal) grammar consists of
1. A finite set of rewriting rules of the form

φ→ψ

where φ and ψ are strings of symbols.

2. A special “initial” symbol S (S standing for sentence);
3. A finite set of symbols stand for “words” of the language called
terminal vocabulary;
4. Other symbols stand for “phrases” and are called non-terminal
vocabulary.
Given such a grammar, a valid sentence can be generated by
1. starting from the initial symbol S,
2. applying one of the rewriting rules to form a new string φ by
applying a rule S → φ1 ,
3. and apply another rule to form a new string φ2 and so on,
4. until we reach a string φn that consists only of terminal symbols.
Ashutosh Trivedi – 4 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Examples

Consider the grammar

S → AB (1)
A → C (2)
CB → Cb (3)
C → a (4)

where {a, b} are terminals, and {S, A, B, C} are non-terminals.

Ashutosh Trivedi – 5 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Examples

Consider the grammar

S → AB (1)
A → C (2)
CB → Cb (3)
C → a (4)

where {a, b} are terminals, and {S, A, B, C} are non-terminals.

We can derive the phrase “ab” from this grammar in the following way:

S → AB, from (1)

→ CB, from (2)
→ Cb, from (3)
→ ab, from (4)

Ashutosh Trivedi – 5 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Examples

Consider the grammar

S → NounPhrase VerbPhrase (5)

NounPhrase → SingularNoun (6)
SingularNoun VerbPhrase → SingularNoun comes (7)
SingularNoun → John (8)

We can derive the phrase “John comes” from this grammar in the
following way:

S → NounPhrase VerbPhrase, from (1)

→ SingularNoun VerbPhrase, from (2)
→ SingularNoun comes, from (3)
→ John comes, from (4)

Ashutosh Trivedi – 6 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Types of Grammars
Depending on the rewriting rules we can characterize the grammars in the
following four types:
1. type 0 grammars with no restriction on rewriting rules;
2. type 1 grammars have the rules of the form

αAβ → αγβ

where A is a nonterminal, α, β, γ are strings of terminals and

nonterminals, and γ is non empty.
3. type 2 grammars have the rules of the form

A→γ

where A is a nonterminal, and γ is a string (potentially empty) of

terminals and nonterminals.
4. type 3 grammars have the rules of the form

A → aB or A → a

where A, B are nonterminals, and a is a string (potentially empty) of

terminals. Ashutosh Trivedi – 7 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Types of Grammars
Depending on the rewriting rules we can characterize the grammars in the
following four types:
1. Unrestricted grammars with no restriction on rewriting rules;
2. Context-sensitive grammars have the rules of the form
αAβ → αγβ
where A is a nonterminal, α, β, γ are strings of terminals and
nonterminals, and γ is non empty.
3. Context-free grammars have the rules of the form
A→γ
where A is a nonterminal, and γ is a string (potentially empty) of
terminals and nonterminals.
4. Regular grammars have the rules of the form
A → aB or A → a
where A, B are nonterminals, and a is a string (potentially empty) of
terminals.
Ashutosh Trivedi – 8 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Types of Grammars
Depending on the rewriting rules we can characterize the grammars in the
following four types:
1. Unrestricted grammars with no restriction on rewriting rules;
2. Context-sensitive grammars have the rules of the form
αAβ → αγβ
where A is a nonterminal, α, β, γ are strings of terminals and
nonterminals, and γ is non empty.
3. Context-free grammars have the rules of the form
A→γ
where A is a nonterminal, and γ is a string (potentially empty) of
terminals and nonterminals.
4. Regular grammars have the rules of the form
A → aB or A → a
where A, B are nonterminals, and a is a string (potentially empty) of
terminals. (also left-linear grammars)
Ashutosh Trivedi – 8 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Do regular grammars capture regular languages?

– Regular grammars to finite automata

– Finite automata to regular grammars

Ashutosh Trivedi – 9 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Context-Free Languages: Syntax
Definition (Context-Free Grammar)
A context-free grammar is a tuple G = (V, T, P, S) where
– V is a finite set of variables (nonterminals, nonterminals vocabulary);
– T is a finite set of terminals (letters);
– P ⊆ V × (V ∪ T)∗ is a finite set of rewriting rules called productions,
– We write A → β if (A, β) ∈ P;
– S ∈ V is a distinguished start or “sentence” symbol.

Ashutosh Trivedi – 10 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Context-Free Languages: Syntax
Definition (Context-Free Grammar)
A context-free grammar is a tuple G = (V, T, P, S) where
– V is a finite set of variables (nonterminals, nonterminals vocabulary);
– T is a finite set of terminals (letters);
– P ⊆ V × (V ∪ T)∗ is a finite set of rewriting rules called productions,
– We write A → β if (A, β) ∈ P;
– S ∈ V is a distinguished start or “sentence” symbol.

Example: G0n 1n = (V, T, P, S) where

– V = {S};
– T = {0, 1};
– P is defined as

S → ε
S → 0S1

– S = S.
Ashutosh Trivedi – 10 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Context-Free Languages: Semantics
Derivation:
– Let G = (V, T, P, S) be a context-free grammar.
– Let αAβ be a string in (V ∪ T)∗ V(V ∪ T)∗
– We say that αAβ yields the string αγβ, and we write αAβ⇒αγβ if

A → γ is a production rule in G.

– For strings α, β ∈ (V ∪ T)∗ , we say that α derives β and we write

∗
α=⇒ β if there is a sequence α1 , α2 , . . . , αn ∈ (V ∪ T)∗ s.t.

α → α1 → α2 · · · αn → β.

Ashutosh Trivedi – 11 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Context-Free Languages: Semantics
Derivation:
– Let G = (V, T, P, S) be a context-free grammar.
– Let αAβ be a string in (V ∪ T)∗ V(V ∪ T)∗
– We say that αAβ yields the string αγβ, and we write αAβ⇒αγβ if

A → γ is a production rule in G.

– For strings α, β ∈ (V ∪ T)∗ , we say that α derives β and we write

∗
α=⇒ β if there is a sequence α1 , α2 , . . . , αn ∈ (V ∪ T)∗ s.t.

α → α1 → α2 · · · αn → β.

Definition (Context-Free Grammar: Semantics)

The language L(G) accepted by a context-free grammar G = (V, T, P, S) is
the set
∗
L(G) = {w ∈ T∗ : S = ⇒ w}.

Ashutosh Trivedi – 11 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
CFG: Example

Recall G0n 1n = (V, T, P, S) where

– V = {S};
– T = {0, 1};
– P is defined as

S → ε
S → 0S1

– S = S.
∗
The string 000111 ∈ L(G0n 1n ), i.e. S =
⇒ 000111 as

S ⇒ 0S1 ⇒ 00S11 ⇒ 000S111 ⇒ 000111.

Ashutosh Trivedi – 12 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Prove that 0n 1n is accepted by the grammar G0n 1n .

The proof is in two parts.

– First show that every string w of the form 0n 1n can be derived from S
using induction over w.
– Then, show that for every string w ∈ {0, 1}∗ derived from S, we have
that w is of the form 0n 1n .

Ashutosh Trivedi – 13 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
CFG: Example
Consider the following grammar G = (V, T, P, S) where
– V = {E, I}; T = {a, b, 0, 1}; S = E; and
– P is defined as

E → I | E + E | E ∗ E | (E)
I → a | Ia | Ib | I0 | I1
∗
The string (a1 + b0 ∗ a1) ∈ L(G), i.e. E =
⇒ (a1 + b0 ∗ a1) as
∗
E ⇒ (E) ⇒ (E + E) ⇒ (I + E) ⇒ (I1 + E) ⇒ (a1 + E) =
⇒ (a1 + b0 ∗ a1).

Ashutosh Trivedi – 14 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
CFG: Example
Consider the following grammar G = (V, T, P, S) where
– V = {E, I}; T = {a, b, 0, 1}; S = E; and
– P is defined as

E → I | E + E | E ∗ E | (E)
I → a | Ia | Ib | I0 | I1
∗
The string (a1 + b0 ∗ a1) ∈ L(G), i.e. E =
⇒ (a1 + b0 ∗ a1) as
∗
E ⇒ (E) ⇒ (E + E) ⇒ (I + E) ⇒ (I1 + E) ⇒ (a1 + E) =
⇒ (a1 + b0 ∗ a1).
∗
E ⇒ (E) ⇒ (E + E) ⇒ (E + E ∗ E) ⇒ (E + E ∗ I) =
⇒ (a1 + b0 ∗ a1).

Leftmost and rightmost derivations:

1. Derivations are not unique
2. Leftmost and rightmost derivations
3. Define ⇒lm and ⇒rm in straightforward manner.
4. Find leftmost and rightmost derivations of (a1 + b0 ∗ a1).
Ashutosh Trivedi – 14 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Exercise

Consider the following grammar:

S → AS | ε.
S → aa | ab | ba | bb

Give leftmost and rightmost derivations of the string aabbba.

Ashutosh Trivedi – 15 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Parse Trees

– A CFG provide a structure to a string

Ashutosh Trivedi – 16 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Parse Trees

– A CFG provide a structure to a string

Ashutosh Trivedi – 16 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Parse Trees

– A CFG provide a structure to a string

– Such structure assigns meaning to a string, and hence a unique
structure is really important in several applications, e.g. compilers
– Parse trees are a successful data-structures to represent and store such
structures
– Let’s review the Tree terminology:
– A tree is a directed acyclic graph (DAG) where every node has at most
incoming edge.
– Edge relationship as parent-child relationship
– Every node has at most one parent, and zero or more children
– We assume an implicit order on children (“from left-to-right”)
– There is a distinguished root node with no parent, while all other nodes
have a unique parent
– There are some nodes with no children called leaves—other nodes are
called interior nodes
– Ancestor and descendent relationships are closure of parent and child
relationships, resp.

Ashutosh Trivedi – 16 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Parse Tree

Given a grammar G = (V, T, P, S), the parse trees associated with G has
the following properties:
1. Each interior node is labeled by a variable in V.
2. Each leaf is either a variable, terminal, or ε. However, if a leaf is ε it is
the only child of its parent.
3. If an interior node is labeled A and has children labeled X1 , X2 , . . . , Xk
from left-to-right, then

A → X1 X2 . . . Xk

is a production is P. Only time Xi can be ε is when it is the only child

of its parent, i.e. corresponding to the production A → ε.

Ashutosh Trivedi – 17 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Reading exercise

– Give parse tree representation of previous derivation exercises.

Ashutosh Trivedi – 18 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Reading exercise

– Give parse tree representation of previous derivation exercises.

– Are leftmost-derivation and rightmost derivation parse-trees always
different?

Ashutosh Trivedi – 18 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Reading exercise

– Give parse tree representation of previous derivation exercises.

– Are leftmost-derivation and rightmost derivation parse-trees always
different?
– Are parse trees unique?

Ashutosh Trivedi – 18 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Reading exercise

– Give parse tree representation of previous derivation exercises.

– Are leftmost-derivation and rightmost derivation parse-trees always
different?
– Are parse trees unique?
– Answer is no. A grammar is called ambiguous if there is at least one
string with two different leftmost (or rightmost) derivations.

Ashutosh Trivedi – 18 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Reading exercise

– Give parse tree representation of previous derivation exercises.

L = {an bn cm dm : n, m ≥ 1} ∪ {an bm cn dm : n, m ≥ 1}.

Write a grammar accepting this language. Show that the string

a2 b2 c2 d2 has two leftmost derivations.

Ashutosh Trivedi – 18 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Reading exercise

– Give parse tree representation of previous derivation exercises.

L = {an bn cm dm : n, m ≥ 1} ∪ {an bm cn dm : n, m ≥ 1}.

Write a grammar accepting this language. Show that the string

a2 b2 c2 d2 has two leftmost derivations.
– There is no algorithm to decide whether a grammar is ambiguous.

Ashutosh Trivedi – 18 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Reading exercise

– Give parse tree representation of previous derivation exercises.

L = {an bn cm dm : n, m ≥ 1} ∪ {an bm cn dm : n, m ≥ 1}.

Write a grammar accepting this language. Show that the string

a2 b2 c2 d2 has two leftmost derivations.
– There is no algorithm to decide whether a grammar is ambiguous.
– What does that mean from application side?

Ashutosh Trivedi – 18 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
In-class Quiz

Write CFGs for the following languages:

1. Strings ending with a 0
2. Strings containing even number of 1’s
3. palindromes over {0, 1}
4. L = {ai bj : i ≤ 2j} or L = {ai bj : i < 2j} or L = {ai bj : i 6= 2j}
5. L = {ai bj ck : i = k}
6. L = {ai bj ck : i = j}
7. L = {ai bj ck : i = j + k}.
8. L = {w ∈ {0, 1}∗ : |w|a = |w|b }.
9. Closure under union, concatenation, and Kleene star
10. Closure under substitution, homomorphism, and reversal

Ashutosh Trivedi – 19 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Syntactic Ambiguity in English

Ashutosh Trivedi – 20 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Syntactic Ambiguity in English

—Anthony G. Oettinger

Ashutosh Trivedi – 20 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Context-Free Grammars

Pushdown Automata

Properties of CFLs

Ashutosh Trivedi – 21 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Pushdown Automata

0, X 7→ 0X 0, 0 7→ ε

ε, X 7→ X ε, ⊥ 7→ ⊥
start q0 q1 q2

1, X 7→ 1X 1, 1 7→ ε

Anthony G. Oettinger – Introduced independently by Anthony G. Oettinger

in 1961 and by Marcel-Paul Schützenberger in 1963
– Generalization of ε-NFA with a “stack-like” storage
mechanism
– Precisely capture context-free languages
– Deterministic version is not as expressive as
non-deterministic one
– Applications in program verification and syntax
M. P. Schutzenberger analysis
Ashutosh Trivedi – 22 of 45
Ashutosh Trivedi Lecture 6: Context-Free Grammar
Example 1: L = {ww : w ∈ {0, 1}∗ }

input tape 1 1 1 0 0 1 1 1

pushdown stack
0, X 7→ 0X 0, 0 7→ ε

ε, X 7→ X ε, ⊥ 7→ ⊥
start q0 q1 q2

⊥
1, X 7→ 1X 1, 1 7→ ε