1. Lecture 8 Context-Free Grammar- Cont.

2. Formal Definition
A context-free grammar (CFG) G is a quadruple (V, Σ, R, S) where
V: a set of non-terminal symbols
Σ: a set of terminals (V ∩ Σ = Ǿ)
R: a set of rules (R: V → (V U Σ)*)
S: a start symbol.

3. Example V = {q, f,} Σ = {0, 1} R = {q → 11q, q → 00f, f → 11f, f → ε }
S = q
(R= {q → 11q | 00f, f → 11f | ε })
** See example 2.4 P.105

4. Designing CFG Just like designing FA, it requires creativity
FIRST: Some CFLs are union of simpler CFLs, use Divide and Conquer:
Ex: In order to design the grammar for the language {0n1n | n>=0} U {1n0n | n>=0}
First: construct grammar for {0n1n | n>=0}
= S → 0S11 | ε
And for {1n0n | n>=0}
S → 1S20 | ε
Add the rule S → S1 | S2 to give the grammar:
S → S1 | S2
S → 0S11 | ε
S → 0S21 | ε

5. SECOND: Constructing CFG is easy for languages that happen to be regular.
Therefore, first design DFA, the convert the DFA to CFG as follows:
- Make a variable Ri for each state qi
- Add the rule Ri → aRj to the CFG if δ(qi,a)=qj is a transition in DFA.
- Add the rule Ri →ε if qi is an accept state of DFA.
- Make R0 the start variable of the grammar, where q0 is the start state of the machine.
- Verify on your own that the resulting CFG generates the same language that the DFA recognizes.

6. THIRD: remember when the machine – in order to accept a language – it had to memorize an unbounded amount of info. For example, {0n1n | n>=0} where the machine needs to memorize an infinite no. of 0s and 1s!
In order to construct a CFG to handle such situation, the CFG should have the rule
R → vRu

7. Finally: Strings may contain certain structures that appear recursively as part of other structures, such as example 2.4

8. How do we use rules? If A → B, then xAy xBy and we say that
xAy derivates xBy.
If s ··· t, then we write s * t.
A string x in Σ* is generated by G=(V,Σ,R,S)
if S * x.
L(G) = { x in Σ* | S * x}.

9. Example G = ({S}, {0,1}. {S → 0S1 | ε }, S) ε in L(G) because S ε .
01 in L(G) because S 0S
0011 in L(G) because
S 0S1 00S
0 1 in L(G) because S *
L(G) = {0 1 | n > 0} n n n n n n

10. Context-Free Language (CFL)
A language L is context-free if there exists a CFG G such that L = L(G).

11. Theorem For every regular set, there exists a CFG G such that L=L(G).
Proof.
Let L=L(M) for a DFA M=(Q, Σ, δ, s, F).
Construct a CFG G=(V, Σ, R, S) as follows.
V = Q,
Σ = Σ,
R = { q → ap | δ(q,a) = p } U { f → ε | f in F},
S = s. x1 xn
S x1q1 x1x2q2 ···
x1…xnf x1…xn
f=qn s q1

12. There is a path associated with x
from initial state to a final state.
x in L(M)
S * x
Therefore, L(M) = L(G).

13. Corollary Every regular language is a CFL.
The class of regular languages is a proper subclass of CFLs.
CFL
Regular
Why, proper?

14. Regular Grammar
Regular grammar is a CFG (V, Σ, R, S) such that every rule is in form
V→ Σ*(V+ε)
Example
S → aA
A → Sb
S → ε G =? (right it in a formal way)
Remark: Every regular language can be generated by a regular grammar.

15. Theorem Every regular grammar generates a regular language. Proof.
Consider a regular grammar G=(V, Σ, R, S).
Construct a string-labeled digraph with vertex set V U {f}
as follows:
For each rule A → xB, x in Σ* and B in V,
draw an edge A → B. x x
For each rule A → x, x in Σ*, draw an edge A → f

16. G = ({S,A}, {0,1}, {S→0S | 10A, A→00}, S)
Example
G = ({S,A}, {0,1}, {S→0S | 10A, A→00}, S) 10 00 f S A
This string-labeled digraph with initial state S and a final
state f is a state diagram of an NFA M.
There is a path associated with x
from S to f in M.
S * x in Σ*
Therefore, L(G) = L(M).

17. Corollary
A language L is regular if and only if L can be generated by a regular grammar.

18. Right-Linear and Left-Linear
A right regular grammar (also called right linear grammar) is a formal grammar (V, Σ, R, S) such that all the production rules in R are of one of the following forms:
B → a - where B is a non-terminal in N and a is a terminal in Σ
B → aC - where B and C are in N and a is in Σ
B → ε - where B is in N and ε denotes the empty string, i.e. the string of length 0.
In a left regular grammar (also called left linear grammar), all rules obey the forms
A → a - where A is a non-terminal in N and a is a terminal in Σ
A → Ba - where A and B are in N and a is in Σ
A → ε - where A is in N and ε is the empty string.

19. Example
As an example from the area of programming languages, the set of all strings denoting a floating point number can be described by a right regular grammar G with N = {S, A,B,C,D,E,F}, Σ = {0,1,2,3,4,5,6,7,8,9,+,-,.,e}, where S is the start symbol, and R consists of the following rules:

20. Right-Linear and Left-Linear
The regular grammar is also called a right- linear grammar.
A grammar G=(V, Σ, R, S) is left-linear if every rule is in form
V → (V+ε)Σ*.
(e.g., ({S,A}, {0, 1}, {S→A01, A→10}, S)
Remark: Every language generated from a left-linear
grammar is regular.
Why?

21. Why? For left-linear grammar G = (V, Σ, R, S),
construct G = (V, Σ, R , S) where
R = {A→W | A→W in R}.
G is right-linear. Hence, L(G ) is regular.
Therefore, L(G) = L(G ) is regular. R R R R R R R R

22. Example 1 G = ({S,A}, {0, 1}, {S→A01, A→10}, S)
NFA accepts L(G )
L(G )={1001}
L(G)={1001} R R 10 01 S A R

23. Example 2 L(G) = 0*1 L(G ) = 10* NFA accepts 10*
G = ({S,A}, {0,1}, {S →1A, A →0A|ε}, S)
G = ({S,A}, {0,1}, {S →A1, A →A0|ε}, S) R 1 S A R