Properties of Context-Free

Languages
Closure Properties
Decision Properties

1
 Closure Properties of CFL’s
CFL’s are closed under union,
concatenation, and Kleene closure.
Also, under reversal, homomorphisms
and inverse homomorphisms.
But not under intersection or
difference.

2
 Closure of CFL’s Under Union
Let L and M be CFL’s with grammars G
and H, respectively.
Assume G and H have no variables in
common.
 Names of variables do not affect the
language.
Let S1 and S2 be the start symbols of G
and H.
3
 Closure Under Union – (2)
Form a new grammar for L  M by
combining all the symbols and
productions of G and H.
Then, add a new start symbol S.
Add productions S -> S1 | S2.

4
 Closure Under Union – (3)
In the new grammar, all derivations
start with S.
The first step replaces S by either S1 or
S2.
In the first case, the result must be a
string in L(G) = L, and in the second
case a string in L(H) = M.

5
 Closure of CFL’s Under
Concatenation
Let L and M be CFL’s with grammars G
and H, respectively.
Assume G and H have no variables in
common.
Let S1 and S2 be the start symbols of G
and H.

6
Closure Under Concatenation – (2)
Form a new grammar for LM by starting
with all symbols and productions of G
and H.
Add a new start symbol S.
Add production S -> S1S2.
Every derivation from S results in a
string in L followed by one in M.

7
 Closure Under Star
Let L have grammar G, with start symbol S1.
Form a new grammar for L* by introducing
to G a new start symbol S and the
productions S -> S1S | ε.
A rightmost derivation from S generates a
sequence of zero or more S1’s, each of which
generates some string in L.

8
 Closure of CFL’s Under
Reversal
If L is a CFL with grammar G, form a
grammar for LR by reversing the right
side of every production.
Example: Let G have S -> 0S1 | 01.
The reversal of L(G) has grammar
S -> 1S0 | 10.

9
 Closure of CFL’s Under
Homomorphism
Let L be a CFL with grammar G.
Let h be a homomorphism on the
terminal symbols of G.
Construct a grammar for h(L) by
replacing each terminal symbol a by
h(a).

10
 Example: Closure Under
Homomorphism

G has productions S -> 0S1 | 01.

11
Nonclosure Under Intersection
Unlike the regular languages, the class
of CFL’s is not closed under .
We know that L1 = {0n1n2n | n > 1} is
not a CFL (use the pumping lemma).
However, L2 = {0n1n2i | n > 1, i > 1} is.
 CFG: S -> AB, A -> 0A1 | 01, B -> 2B | 2.
So is L3 = {0i1n2n | n > 1, i > 1}.
But L1 = L2  L3.
12
 Nonclosure Under Difference
We can prove something more general:
 Any class of languages that is closed under
difference is closed under intersection.
Proof: L  M = L – (L – M).
Thus, if CFL’s were closed under
difference, they would be closed under
intersection, but they are not.

13
 Interesting examples
L1 = {anbncn | n >= 1} is not a CFL, but
complement of L is.

L2 = {wwR | w in {0,1}*} is a CFL

L3 = {ww | w in {0,1}*} is NOT a CFL,

L4 = {aibjck | i > j, i,j,k  1} is a CFL

S  XC
C  cC | c
X  YZ
Y  aY | a
Z  aZb | ab

15
L5 = {xy | |x| = |y|, x not identical to y}

S0 -> 0 | 1 S0 1 | 1 S0 0 | 0 S0 1 | 0 S0 0
S1 -> 0 | 1 S1 1 | 1 S1 0 | 0 S1 1 | 0 S1 0

S -> S0 S1 | S1 S0

16
 Decision Properties
 As usual, when we talk about “a CFL”
we really mean “a representation for
the CFL, e.g., a CFG or a PDA
accepting by final state or empty stack.
 There are algorithms to decide if:
1. String w is in CFL L.
2. CFL L is empty.
3. CFL L is infinite.
17
 Non-Decision Properties
Many questions that can be decided for
regular sets cannot be decided for CFL’s.
Example: Are two CFL’s the same?
Example: Are two CFL’s disjoint?
 How would you do that for regular languages?
Need theory of Turing machines and
decidability to prove no algorithm exists.
18
 Testing Emptiness
We already did this.
We learned to eliminate variables that
generate no terminal string.
If the start symbol is one of these, then
the CFL is empty; otherwise not.

19
 Testing Membership
Want to know if string w is in L(G).
Assume G is in CNF.
 Or convert the given grammar to CNF.
 w = ε is a special case, solved by testing if
the start symbol is nullable.
Algorithm (CYK ) is a good example of
dynamic programming and runs in time
O(n3), where n = |w|.
20
 Testing Infiniteness
The idea is essentially the same as for
regular languages.
Use the pumping lemma constant n.
If there is a string in the language of
length between n and 2n-1, then the
language is infinite; otherwise not.

21
 Intersection with a Regular
Language
Intersection of two CFL’s need not be
context free.
But the intersection of a CFL with a
regular language is always a CFL.
Proof involves running a DFA in parallel
with a PDA, and noting that the
combination is a PDA.
 PDA’s accept by final state.
22
DFA and PDA in Parallel

DFA
Accept
Input
if both
PDA accept

S
t Looks like the
a state of one PDA
c
k
23
 Formal Construction
Let the DFA A have transition function δA.
Let the PDA P have transition function δP.
States of combined PDA are [q,p], where
q is a state of A and p a state of P.
δ([q,p], a, X) contains ([δA(q,a),r], ) if
δP(p, a, X) contains (r, ).
 Note a could be , in which case δA(q,a) = q.

24
 Formal Construction – (2)
Accepting states of combined PDA are
those [q,p] such that q is an accepting
state of A and p is an accepting state of
P.
Easy induction: ([q0,p0], w, Z0)⊦*
([q,p], , ) if and only if δA(q0,w) = q
and in P: (p0, w, Z0)⊦*(p, , ).

25
Closure of CFL’s Under Inverse
Homomorphism
Here, grammars don’t help us.
But a PDA construction serves nicely.
Intuition: Let L = L(P) for some PDA P.
Construct PDA P’ to accept h-1(L).
P’ simulates P, but keeps, as one
component of a two-component state a
buffer that holds the result of applying
h to one input symbol.
26
Architecture of P’

Input: 0 0 1 1
h(0)

Buffer Read first remaining

Stack
of P
27
 Formal Construction of P’
 States are pairs [q, b], where:
1. q is a state of P.
2. b is a suffix of h(a) for some symbol a.
 Thus, only a finite number of possible values
for b.
 Stack symbols of P’ are those of P.
 Start state of P’ is [q0 ,ε].

28
 Construction of P’ – (2)
Input symbols of P’ are the symbols to
which h applies.
Final states of P’ are the states [q, ε]
such that q is a final state of P.

29
 Transitions of P’
1. δ’([q, ε], a, X) = {([q, h(a)], X)} for
any input symbol a of P’ and any stack
symbol X.
 When the buffer is empty, P’ can reload it.
2. δ’([q, bw], ε, X) contains ([p, w], ) if
δ(q, b, X) contains (p, ), where b is
either an input symbol of P or ε.
 Simulate P from the buffer.
30
 Proving Correctness of P’
We need to show that L(P’) = h-1(L(P)).
Key argument: P’ makes the transition
([q0, ε], w, Z0)⊦*([q, x], ε, )
if and only if P makes transition
(q0, y, Z0) ⊦*(q, ε, ), h(w) = yx, and x
is a suffix of the last symbol of w.
Proof in both directions is an induction
on the number of moves made.
31