480 likes | 1.01k Vues
Western Michigan University CS6800 Advanced Theory of Computation Spring 2014 By Abduljaleel Alhasnawi & Rihab Almalki. Normal Forms. Grammar: G = (V,  , R, S).  = { a, b }. Terminals. Terminals and Non terminals. V = {A , B, C , a ,b, c}. S. Start Symbol. R = S → A.
 
                
                E N D
Western Michigan University CS6800 Advanced Theory of Computation Spring 2014 By AbduljaleelAlhasnawi & RihabAlmalki Normal Forms
Grammar: G = (V, , R, S) • = { a, b } Terminals Terminals and Nonterminals V = {A, B, C , a ,b, c} S Start Symbol R = S → A Rules Introduction
Rules: X Y , where: • X V- • Ex: S  aS • Y: , a, A, aB • G1: R= S aS |  ......? • G2: R= S aSa | bSb |  ....? • G3: R= S  SS | (S) |  ......? Regular Grammar
Rules: X Y , where: • X V-  and |X| = 1 • Ex: S aS • YV* • Ex:S  S aSb • A  a AbBBa • A  B S  SS • A aBS ABCD Context Free Grammar (CFG)
A grammar G is ambiguous iff there is at least one string in L(G) for which G produces more than one parse tree. • Ex: • Bal = { w {),(}*: the parentheses are balanced} • G = {{S,),(}, {),(}, R, S} , where: • R = S SS | (S) |  Ambiguity
For a string (())() , we have more than one parse trees Ambiguity
Chomsky Normal Form (CNF) • Def.: A context-free grammar G = (V, Σ, R, S) is said to be in Chomsky Normal Form (CNF), iff every rule in R is of one of the following forms: • X  a where a   , or • X  BC where B and C  V- • Greibach Normal Form (GNF) • Def.:GNF is a context free grammar G = (V, , R, S), where all rules have one of the following forms: • X  awhere a   and  (V-)* Normal Forms
There exists 5-steps algorithm to convert a CFG G into a new grammar Gc such that: L(G) = L(Gc) – {} • convertChomsky(G:CFG) = • 1- G' = removeEps(G:CFG) S  • 2- G'' = removeUnits(G':CFG) A  B • 3- G'''= removeMixed(G'':CFG) A aB • 4- G'v= removeLong(G''' :CFG) S  ABCD • 5- G'v : L(G) = L(G'v) – {} Gv= atmostoneEps(G'v:CFG) S* S, S   Converting to Chomsky Normal Form
Find the set N of nullable variables in G. • X is nullable iff either X  or • (X  A , A ) : X • Ex1: G: S  aACa • A  B | a • B  C | c • C  cC |  • Now,since C , C is nullable • since B  C , B is nullable • since A  B , A is nullable • ThereforeN = { A,B,C} Remove Epsilon
According to N, the rules will be: • S  aACa • A  B | a |  • B  C | c |  • C  cC |  • Now,removeEps returns G': • S  aACa | aAa | aCa | aa • A  B | a • B  C | c • C  cC | c Remove Epsilon
Def.: unit production is a rule whose right hand side consists of a single nonterminal symbol. Ex: A  B • Remove any unit production from G'. • Consider the remain rules • Ex1(continue), G‘: • S  aACa | aAa | aCa | aa • A  B | a • B  C | c • C  cC | c Remove Unit Productions
Now by apply removeUnits(G':CFG) : • Remove A B But B  C | c, so Add A  C | c • Remove B CAdd B cC(B  c, already there) • Remove A CAdd A cC(A c, already there) • SoremoveUnits returns G'': • SaACa | aAa | aCa | aa • A a | c | cC • B c | cC • CcC | c Remove Unit Productions
Def.: mixed is a rule whose right hand side consists of combination of terminals or terminals with nonterminal symbol. • Create a new nonterminal Ta for each terminal a   • For each Ta , add the rule Ta  a • Ex1(continue), G'': • SaACa | aAa | aCa | aa • A a | c | cC • B c | cC • CcC | c Remove Mixed
Now, by apply removeMixed(G'':CFG), G''': • STaACTa | TaATa | TaCTa | TaTa • A a | c | TcC • B c | TcC • CTcC | c • Ta a • Tc c Remove Unit Productions
Def.: long is a rule whose right hand side consists of more than two nonterminal symbol. • R: A  BCDE • By remove long, it will be: • A BM2 • M2 CM3 • M3 DE • Ex1(continue), G'': • SaACa | aAa | aCa | aa • A a | c | cC • B c | cC • CcC | c Remove Long
Ex1(continue), G''' : • STaACTa | TaATa | TaCTa | TaTa • A a | c | TcC • B c | TcC • CTcC | c • Ta a • Tc c Remove Long
Now, by apply removeLong(G''' :CFG), G'v: • S TaS1 |TaS3 |TaS4 |TaTa • S1AS2 S2CTaS3ATa S4CTa • A  a | c | TcC • B  c | TcC • C TcC | c • Ta a • Tc c Remove Long
Finally,atmostoneEps(G'v:CFG)does not apply in Ex1,Gv= G'vsince L does not contain  (Sisnotnullable). • S TaS1 |TaS3 |TaS4 |TaTa • S1AS2 S2CTaS3ATa S4CTa • A  a | c | TcC • B  c | TcC • C TcC | c • Ta a • Tc c Add Epsilon
Convert the following CFG to CNF: • SABC • AaC | D • BbB |  | A • CAc |  | Cc • Daa Example2
N = {A,B,C} So • add S  AB|BC|AC, A  a, B  b, C  c • delete B , C  • The result is: • S  ABC| AB|BC|AC • A aC | D|a • B bB | A|b • C  Ac | Cc| c • D aa 1-Remove epsilon
S  ABC| AB|BC|AC • A aC | D |a (A  D, D aa) remove A  D add A aa • B bB | A|b (B  A, A aC|aa|a) remove B A add B aC|aa|a • C  Ac | Cc|c • D aa 2- Remove units
SABC| AB|BC|AC • AaC | aa |a • BbB | aC|aa|a|b • CAc | Cc|c • Daa 2- Remove units
SABC| AB|BC|AC • ATaC | TaTa |a • BTbB | TaC| TaTa |a|b • CATc | CTc|c • DTaTa 3- Remove Mixed
SAM2|M2| AC|AB • M2BC • ATaC | TaTa |a • BTbB | TaC| TaTa |a |b • CATc | CTc|c • DTaTa • Ta a • Tb b • Tc c 4- Remove Long
S  AM2|M2| AC|AB • M2 BC • A TaC | TaTa |a • B TbB | TaC| TaTa |a |b • C ATc | CTc|c • D TaTa • Ta a • Tb b • Tc c 5- Add Epsilon: N/A
Convert the following CFG to CNF: • A → BAB | B | ε • B → 00 | ε • 1- remove epsilon: • A → BAB | B | BB | AB | BA • B → 00 • 2- remove units: • A → BAB | 00 | BB | AB | BA • B → 00 Example3
3- remove mixed • A → BC | T0T0 | BB | AB | BA • C → AB, B → T0T0, T0 → 0 • 4- Add epsilon • A → BC | T0T0 | BB | AB | BA |  • C → AB • B → T0T0 • T0→ 0
Not Chomsky Normal Form Chomsky Normal Form
Convert the following CFG to CNF: Example5
Introduce new intermediate variable to break first production:
Final grammar in Chomsky Normal Form: Initial grammar
Convert the following CFG to CNF: • E  E + T • E T • T  T  F • T  F • F  (E) • F id Example6
Remove E  T , add E  T  F |F • Remove E  F , add E  (E) | id • Remove T  F , add T  (E) | id • The result: • E  E + T | T  F | (E) | id • T  T  F | (E) | id • F  (E) | id 1- Remove units
E  E T+ T | T T F | T(E T)| id • T  T T F | T(E T)| id • F  T(E T)| id • T( ( • T) ) • T+ + • T* * 2- Remove Mixed
E  E M2 | T M3 | T( M4 | id • T  T M3 | T(M4 | id • F  T( M4 | id • M2 T+ T • M3 T* F • M4  E T) • T( ( • T) ) • T+ + • T* * 3- Remove Long
E  E M2 | T M3 | T( M4 | id • T  T M3 | T(M4 | id • F  T( M4 | id • M2 T+ T • M3 T* F • M4  E T) • T( ( • T) ) • T+ + • T* * 5- Add Epsilon: N/A
Elaine A. Rich (2008)Automata, Computability, and Complexity: Theory and Applications, Pearson Prentice Hall. • https://cs.wmich.edu/~elise/courses/cs680/presentations.htm References