see More Picture if you
liked that one.
| NFA | DFA | a | b |
|---|---|---|---|
| {0} | A | B | |
| {1,2,3,5,8} | B | C | D |
| {2,3,4,5,7,8,9} | C | C | D |
| {2,3,5,6,7,8} | D | C | D |
| NFA | DFA | a | b |
|---|---|---|---|
| {0,1,2,4,7} | A | B | C |
| {1,2,3,4,6,7,8,9,11} | B | D | E |
| {1,2,4,5,6,7} | C | B | C |
| {1,2,3,4,6,7,8,9,10,11,13,14,16} | D | F | G |
| {1,2,4,5,6,7,12,13,14,16} | E | H | I |
| {1,2,3,4,6,7,8,9,10,11,13,14,15,16,18} | F | F | G |
| {1,2,4,5,6,7,12,13,14,16,17,18} | G | H | I |
| {1,2,3,4,6,7,8,9,11,15,18} | H | D | E |
| {1,2,4,5,6,7,17,18} | I | B | C |
| state | a | b | ε |
|---|---|---|---|
| 0 | {0,1} | {0} | ∅ |
| 1 | {1,2} | {1} | ∅ |
| 2 | {2} | {2,3} | {0} |
| 3 | ∅ | ∅ | ∅ |
| state | a | b | ε |
|---|---|---|---|
| 0 | {1} | ∅ | {3} |
| 1 | ∅ | {2} | {0} |
| 2 | ∅ | {3} | {1} |
| 3 | {0} | ∅ | {2} |
| state | a | b | ε |
|---|---|---|---|
| 0 | ∅ | ∅ | {1,2} |
| 1 | {2} | ∅ | ∅ |
| 2 | {2} | ∅ | ∅ |
| 3 | ∅ | {4} | ∅ |
| 4 | ∅ | {4} | ∅ |
| NFA State | DFA State | a | b |
|---|---|---|---|
| {0,1,3} | A | B | C |
| {2} | B | B | ∅ |
| {4} | C | ∅ | C |
| NFA State | DFA State | a | b |
|---|---|---|---|
| {0} | A | B | A |
| {0,1} | B | C | B |
| {0,1,2} | C | C | D |
| {0,2,3} | D | C | D |
| NFA State | DFA State | a | b |
|---|---|---|---|
| {0,1,2,3} | A | A | A |
| NFA State | DFA State | a | b |
|---|---|---|---|
| {0,1,2,3,7} | A | B | C |
| {1,2,3,4,6,7} | B | B | C |
| {1,2,3,5,6,7} | C | B | C |
| NFA State | DFA State | a | b |
|---|---|---|---|
| {0,1,2,3,4,5,8,9,10,11} | A | B | C |
| {1,2,3,4,5,6,8,9,10,11} | B | B | C |
| {1,2,3,4,5,7,8,9,10,11} | C | B | C |
| NFA State | DFA State | a | b |
|---|---|---|---|
| {0,1,2,3,4,6,7,9,10} | A | B | C |
| {1,2,3,4,5,6,7,9,10} | B | B | C |
| {1,2,3,4,6,7,8,9,10} | C | B | C |
| NFA State | DFA State | a | b |
|---|---|---|---|
| {0,1,2,4,7} | A | B | C |
| {1,2,3,4,6,7,8} | B | B | D |
| {1,2,4,5,6,7} | C | B | C |
| {1,2,4,5,6,7,9} | D | B | E |
| {1,2,4,5,6,7,10,11,12,14,17} | E | F | G |
| {1,2,3,4,6,7,8,11,12,13,14,16,17} | F | F | H |
| {1,2,4,5,6,7,11,12,13,15,16,17} | G | F | G |
| {1,2,4,5,6,7,9,11,12,14,15,16,17} | H | F | I |
| {1,2,4,5,6,7,10,11,12,14,15,16,17} | I | F | G |
| node n | nullable(n) | firstpos(n) |
|---|---|---|
| n = c_1 ? | true | firstpos(c_1) |
| n = c_1 + | nullable(c_1) | firstpos(c_1) |
| node n | followpos(n) |
|---|---|
| 1 | {1, 2, 3} |
| 2 | {1, 2, 3} |
| 3 | ∅ |
| extended grammar | not extended grammar |
|---|---|
| A -> X[Y]Z | A -> XZ | XYZ |
| A -> X{YZ} | A -> XB B -> YZB | ε |
| 非终结符号 | 输入符号 | ||
|---|---|---|---|
| 0 | 1 | $ | |
| S | S -> 0 A | ||
| A | A -> 0 A 1 | A -> 1 | |
| 非终结符号 | 输入符号 | |||
|---|---|---|---|---|
| + | * | a | $ | |
| S | S -> + S S | S -> * S S | S -> a | |
| 非终结符号 | 输入符号 | ||
|---|---|---|---|
| ( | ) | $ | |
| S | S -> A | S -> A | S -> A |
| A | A -> (S) S A A -> ε |
A -> ε | A -> ε |
| 非终结符号 | 输入符号 | |||||
|---|---|---|---|---|---|---|
| ( | ) | + | * | a | $ | |
| S | S -> TB | S -> TB | ||||
| B | B -> AB | B -> AB | B -> AB | B -> AB | B -> ε | |
| A | A -> TB | A -> +S | A -> \* | A -> TB | ||
| T | T -> (S) | T -> a | ||||
| 非终结符号 | 输入符号 | |||||||
|---|---|---|---|---|---|---|---|---|
| and | or | not | ( | ) | true | false | $ | |
| bexpr | bexpr -> bterm bexpr' | bexpr -> bterm bexpr' | bexpr -> bterm bexpr' | bexpr -> bterm bexpr' | ||||
| bexpr' | bexpr' -> or bterm bexpr' | bexpr' -> ε | bexpr' -> ε | |||||
| bterm | bterm -> bfactor bterm' | bterm -> bfactor bterm' | bterm -> bfactor bterm' | bterm -> bfactor bterm' | ||||
| bterm' | bterm' -> and bfactor bterm' | bterm' -> ε | bterm' -> ε | |||||
| bfactor | bfactor -> not bfactor | bfactor -> (bexpr) | bfactor -> true | bfactor -> false | ||||
| 非终结符号 | 输入符号 | |||
|---|---|---|---|---|
| + | * | a | $ | |
| S | S -> aB | |||
| A | A -> + | A -> * | ||
| B | B -> ε | B -> ε | B -> SAB | B -> ε |
COMS W3261
Computer Science Theory
Lecture 10: October 8, 2012
Properties of Context-Free Languages
Outline
- Eliminating useless symbols
- Eliminating ε-productions
- Eliminating unit productions
- Chomsky normal form
- Pumping lemma for CFL's
- Cocke-Younger-Kasami algorithm
1. Eliminating Useless Symbols from a CFG
- A symbol X is useful for a CFG if there is a derivation of the form S ⇒* αXβ ⇒* w for some string of terminals w.
- If X is not useful, then we say X is useless.
- To be useful, a symbol X needs to be
- generating; that is, X needs to be able to derive some string of terminals.
- reachable; that is, there needs to be a derivation of the form S ⇒* αXβ where α and β are strings of nonterminals and terminals.
- To eliminate useless symbols from a grammar, we
- identify the nongenerating symbols and eliminate all productions containing one or more of these symbols, and then
- eliminate all productions containing symbols that are not reachable from the start symbol.
- In the grammar
S → AB | a
A → bS, A, a, and
b are generating. B is not generating.S → a
A → bA is not reachable from S, so
we can eliminate the second production to getS → aS.2. Eliminating ε-productions from a CFG
- If a language L has a CFG, then L - { ε } has a CFG without any ε-productions.
- A nonterminal A in a grammar is nullable if A ⇒* ε.
- The nullable nonterminals can be determined iteratively.
- We can eliminate all ε-productions in a grammar as follows:
- Eliminate all productions with ε bodies.
- Suppose A → X1X2 ... Xk is a production and m of the k Xi's are nullable. Then add the 2m versions of this production where the nullable Xi's are present or absent. (But if all symbols are nullable, do not add an ε-production.)
- Let us eliminate the ε-productions from the grammar G
S → AB
A → aAA | ε
B → bBB | εS → AB
we add the productions S → A | BA → aAA
we add the productions A → aA | aB → bBB
we add the productions B → bB | bS → AB | A | B
A → aAA | aA | a
B → bBB | bB | b3. Eliminating Unit Productions from a CFG
- A unit production is one of the form
A → Bwhere bothAandBare nonterminals. - Let us assume we are given a grammar G with no ε-productions.
- From G we can create an equivalent grammar H with no unit productions as follows.
- Define (A, B) to be a unit pair if A ⇒* B in G.
- We can inductively construct all unit pairs for G.
- For each unit pair (A, B) in G, we add to H the productions A → α where B → α is a nonunit production of G.
- Consider the standard grammar G for arithmetic expressions:
E → E + T | T
T → T * F | F
F → ( E ) | a(E,E), (E,T), (E,F), (T,T), (T,F), (F,F).E → E + T | T * F | ( E ) | a
T → T * F | ( E ) | a
F → ( E ) | a4. Putting a CFG into Chomsky Normal Form
- A grammar G is in Chomsky Normal Form if each production in G is one of two forms:
- A → BC where A, B, and C are nonterminals, or
- A → a where a is a terminal.
- Every context-free language without ε can be generated by a Chomsky Normal Form grammar.
- Let us assume we have a CFG G with no useless symbols, ε-productions, or unit productions. We can transform G into an equivalent Chomsky Normal Form grammar as follows:
- Arrange that all bodies of length two or more consist only of nonterminals.
- Replace bodies of length three or more with a cascade of productions, each with a body of two nonterminals.
- Applying these two transformations to the grammar H above, we get:
E → EA | TB | LC | a
A → PT
P → +
B → MF
M → *
L → (
C → ER
R → )
T → TB | LC | a
F → LC | a5. Pumping Lemma for CFL's
- For every nonfinite context-free language L, there exists a constant n that depends on L such that for all z in L with |z| ≥ n, we can write z as uvwxy where
- vx ≠ ε,
- |vwx| ≤ n, and
- for all i ≥ 0, the string uviwxiy is in L.
- Proof: See HMU, pp. 281-282.
- One important use of the pumping lemma is to prove certain languages are not context free.
- Example: The language L = { anbncn | n ≥ 0 } is not context free.
- The proof will be by contradiction. Assume L is context free. Then by the pumping lemma there is a constant n associated with L such that for all z in L with |z| ≥ n, z can be written as uvwxy such that
- vx ≠ ε,
- |vwx| ≤ n, and
- for all i ≥ 0, the string uviwxiy is in L.
- Consider the string z = anbncn.
- From condition (2), vwx cannot contain both a's and c's.
- Two cases arise:
- vwx has no c's. But then uwy cannot be in L since at least one of v or x is nonempty.
- vwx has no a's. Again, uwy cannot be in L.
- In both cases we have a contradiction, so we must conclude L cannot be context free. The details of the proof can be found in HMU, p. 284.
6. Cocke-Younger-Kasami Algorithm for Testing Membership in a CFL
- Input: a Chomsky normal form CFG G = (V, T, P, S) and a string w = a1a2 ... an in T*.
- Output: "yes" if w is in L(G), "no" otherwise.
- Method: The CYK algorithm is a dynamic programming algorithm that fills in
a triangular table
Xijwith nonterminals A such that A ⇒* aiai+1 ... aj.
for i = 1 to n do
if A → ai is in P then
add A to Xii
fill in the table, row-by-row, from row 2 to row n
fill in the cells in each row from left-to-right
if (A → BC is in P) and for some i ≤ k < j
(B is in Xik) and (C is in Xk+1,j) then
add A to Xij
if S is in X1n then
output "yes"
else
output "no"
Xij iff there is a
production A → BC in P where B ⇒*
aiai+1 ... ak
and C ⇒*
ak+1ak+2 ... aj.Xij, we examine at most
n pairs of entries:
(Xii, Xi+1,j),
(Xi,i+1, Xi+2,j),
and so on until
(Xi,j-1, Xj,j).7. Practice Problems
- Eliminate useless symbols from the following grammar:
- Put the following grammar into Chomsky Normal Form:
- Show that { anbncn | n ≥ 0 } is not context free.
- Show that { anbnci | i ≤ n } is not context free.
- Show that { ssRs | s is a string of a's and b's } is not context free.
- (Hard) Show that the complement of { ss | ss is a string of a's and b's } is context free.
S → AB | CA
A → a
B → BC | AB
C → aB | b
S → ASB | ε
A → aAS | a
B → BbS | A | bb
C → aB | b
8. Reading Assignment
- HMU: Ch. 7
aho@cs.columbia.edu ================================================ FILE: ch04/4.5/4.5.md ================================================ # 4.5 节的练习 ### 4.5.1 对于练习 4.2.2（a）中的文法 S -> 0 S 1 | 0 1，指出下面各个最右句型的句柄。 1. 000111 2. 00S11 #### 解答 1. 01 2. 0S1 ### 4.5.2 对于练习 4.2.1 的文法 S -> S S + | S S \* | a 和下面各个最右句型，重复练习 4.5.1 。 1. SSS+a\*+ 2. SS+a\*a+ 3. aaa\*a++ #### 解答 1. SS+ 2. SS+ 3. a ### 4.5.3 对于下面的输入符号串和文法，说明相应的自底向上语法分析过程。 1. 练习 4.5.1 的文法的串 000111 。 2. 练习 4.5.2 的文法的串 aaa*a++ 。 #### 解答 1、 000111
| 栈 | 输入 | 句柄 | 动作 |
|---|---|---|---|
| $ | 000111$ | 移入 | |
| $0 | 00111$ | 移入 | |
| $00 | 0111$ | 移入 | |
| $000 | 111$ | 移入 | |
| $0001 | 11$ | 01 | 规约：S -> 01 |
| $00S | 11$ | 移入 | |
| $00S1 | 1$ | 0S1 | 规约：S -> 0S1 |
| $0S | 1$ | 移入 | |
| $0S1 | $ | 0S1 | 规约：S -> 0S1 |
| $S | $ | 接受 |
| 栈 | 输入 | 句柄 | 动作 |
|---|---|---|---|
| $ | aaa*a++$ | 移入 | |
| $a | aa*a++$ | a | 规约: S -> a |
| $S | aa*a++$ | 移入 | |
| $Sa | a*a++$ | a | 规约: S -> a |
| $SS | a*a++$ | 移入 | |
| $SSa | *a++$ | a | 规约: S -> a |
| $SSS | *a++$ | 移入 | |
| $SSS* | a++$ | SS* | 规约: S -> SS* |
| $SS | a++$ | 移入 | |
| $SSa | ++$ | a | 规约: S -> a |
| $SSS | ++$ | 移入 | |
| $SSS+ | +$ | SS+ | 规约: S -> SS+ |
| $SS | +$ | 移入 | |
| $SS+ | $ | SS+ | 规约: S -> SS+ |
| $S | $ | 接受 |
| 状态 | ACTION | GOTO | |||||
|---|---|---|---|---|---|---|---|
| a | + | * | $ | S | A | B | |
| 0 | s2 | s1 | |||||
| 1 | acc | ||||||
| 2 | s4 | r3 | r3 | r3 | s3 | ||
| 3 | r1 | ||||||
| 4 | s4 | r3 | r3 | r3 | s5 | ||
| 5 | s7 | s8 | s6 | ||||
| 6 | s4 | r3 | r3 | r3 | s9 | ||
| 7 | r4 | r4 | |||||
| 8 | r5 | r5 | |||||
| 9 | r2 | r2 | r2 | ||||
| 栈 | 符号 | 输入 | 动作 | |
|---|---|---|---|---|
| 1) | 0 | aa*a+$ | 移入 | |
| 2) | 02 | a | a*a+$ | 移入 |
| 3) | 024 | aa | *a+$ | 根据 B -> ε 规约 |
| 4) | 0245 | aaB | *a+$ | 移入 |
| 5) | 02458 | aaB* | a+$ | 根据 A -> * 规约 |
| 6) | 02456 | aaBA | a+$ | 移入 |
| 7) | 024564 | aaBAa | +$ | 根据 B -> ε 规约 |
| 8) | 0245645 | aaBAaB | +$ | 移入 |
| 9) | 02456457 | aaBAaB+ | $ | 根据 A -> + 规约 |
| 9) | 02456456 | aaBAaBA | $ | 根据 B -> ε 规约 |
| 10) | 024564569 | aaBAaBAB | $ | 根据 B -> aBAB 规约 |
| 11) | 024569 | aaBAB | $ | 根据 B -> aBAB 规约 |
| 12) | 023 | aB | $ | 根据 S -> aB 规约 |
| 13) | 01 | S | $ | 接受 |
| 产生式 | 语法规则 | |
|---|---|---|
| 1) | L -> En | L.val = E.val |
| 2) | E -> TE' | E'.inh = T.val E.val = E'.syn |
| 3) | E' -> +TE_1' | E_1'.inh = E'.inh + T.val E'.syn = E_1'.syn |
| 4) | E' -> ε | E'.syn = E'.inh |
| 5) | T -> FT' | T'.inh = F.val T.val = T'.syn |
| 6) | T' -> *FT_1' | T_1'.inh = T'.inh * F.val T'.syn = T_1'.syn |
| 7) | T' -> ε | T'.syn = T'.inh |
| 8) | F -> (E) | F.val = E.val |
| 9) | F -> digit | F.val = digit.lexval |
| 产生式 | 语法规则 | |
|---|---|---|
| 1) | S -> L_1.L_2 |
L_1.isLeft = true L_2.isLeft = false S.val = L_1.val + L_2.val |
| 2) | S -> L |
L.isLeft = true S.val = L.val |
| 3) | L -> L_1B |
L_1.isLeft = L.isLeft L.len = L_1.len + 1 L.val = L.isLeft ? L_1.val * 2 + B.val : L_1.val + B.val * 2^(-L.len) |
| 4) | L -> B |
L.len = 1 L.val = L.isLeft ? B.val : B.val/2 |
| 5) | B -> 0 | B.val = 0 |
| 6) | B -> 1 | B.val = 1 |
| 产生式 | 语法规则 | |
|---|---|---|
| 1) | S -> L_1.L_2 | S.val = L_1.val + L_2.val/L_2.f |
| 2) | S -> L | S.val = L.val |
| 3) | L -> L_1B | L.val = L_1.val*2 + B.val L.f = L_1.f * 2 |
| 4) | L -> B | L.val = B.val L.f = 2 |
| 5) | B -> 0 | B.val = 0 |
| 6) | B -> 1 | B.val = 1 |
| 产生式 | 语法规则 | |
|---|---|---|
| 1) | E -> E_1 + T | E.type = E_1.type === float || T.type === float ? float : int |
| 2) | E -> T | E.type = T.type |
| 3) | T -> num.num | T.type = float |
| 4) | T -> num | T.type = int |
| 产生式 | 语法规则 | |
|---|---|---|
| 1) | L -> En | L.cleanExpr = E.wrapped ? E.cleanExpr : E.expr |
| 2) | E -> E_1 + T |
E.wrapped = false E.precedence = 0 E.expr = E_1.expr || "+" || T.expr E.cleanExpr = (E_1.wrapped ? E_1.cleanExpr : E_1.expr) || "+" || (T.wrapped ? T.cleanExpr : T.expr) |
| 3) | E -> T |
E.wrapped = T.wrapped E.precedence = T.precedence E.expr = T.expr E.cleanExpr = T.cleanExpr |
| 4) | T -> T_1 * F |
T.wrapped = false T.precedence = 1 T.expr = T_1.expr || "*" || F.expr T.cleanExpr = (T_1.wrapped && T_1.precedence >= 1 ? T_1.cleanExpr : T_1) || * || (F.wrapped && F.precedence >= 1 ? F.cleanExpr : F.expr) |
| 5) | T -> F |
T.wrapped = F.wrapped T.precedence = F.precedence T.expr = F.expr T.cleanExpr = F.cleanExpr |
| 6) | F -> (E) |
F.wrapped = true F.precedence = E.precedence F.expr = "(" || E.expr || ")" F.cleanExpr = E.expr |
| 7) | F -> digit |
F.wrapped = false F.precedence = 3 F.expr = digit F.cleanExpr = digit |
| 1 | id | a | |
| 2 | id | b | |
| 3 | + | 1 | 2 |
| 4 | + | 3 | 3 |
| 1 | id | a | |
| 2 | id | b | |
| 3 | + | 1 | 2 |
| 4 | + | 3 | 1 |
| 5 | + | 4 | 2 |
| 1 | id | a | |
| 2 | + | 1 | 1 |
| 3 | + | 2 | 1 |
| 4 | + | 3 | 1 |
| 5 | + | 3 | 4 |
| 6 | + | 2 | 5 |
| op | arg1 | arg2 | result | |
|---|---|---|---|---|
| 0 | + | b | c | t1 |
| 1 | minus | t1 | t2 | |
| 2 | + | a | t2 | t3 |
| op | arg1 | arg2 | |
|---|---|---|---|
| 0 | + | b | c |
| 1 | minus | (0) | |
| 2 | + | a | (1) |
| op | arg1 | arg2 | |
|---|---|---|---|
| 0 | + | b | c |
| 1 | minus | (0) | |
| 2 | + | a | (1) |
| instruction | |
|---|---|
| 0 | (0) |
| 1 | (1) |
| 2 | (2) |