1. CSCI 3130: Automata theory and formal languages Andrej Bogdanov http://www.cse.cuhk.edu.hk/~andrejb/csc3130 The Chinese University of Hong Kong NFA to DFA conversion and regular expressions Fall 2011

2. NFAs are as powerful as DFAs An NFA can do everything a DFA can do How about the other way? Every NFA can be converted into a DFA for the same language. YES

3. NFA → DFA in two easy steps We do this first ➊ Eliminate  -transitions ➋ Convert simplified NFA

4. NFA → DFA: intuition 1 0 0, 1 qq qq qq NFA: DFA: 1 qq q 0 or q 1 1 q 0 or q 2 1 0 0 0

5. NFA → DFA: intuition 1 0 0, 1 qq qq qq NFA: DFA: 1 qq {q 0, q 1 } 1 {q 0, q 2 } 1 0 0 0

6. NFA → DFA: states 1 0 0, 1 qq qq qq NFA: DFA: {q 0, q 1 } {q 0, q 2 }{q 0, q 1, q 2 } {q 1, q 2 } {q 0 } {q 1 } {q 2 }  DFA has a state for every subset of NFA states

7. NFA → DFA: transitions 10 0, 1 qq qq qq NFA: DFA: {q 0, q 1 } {q 0, q 2 }{q 0, q 1, q 2 } {q 1, q 2 } {q 0 } {q 1 } {q 2 }  0 1 0 1 0, 1 0 1 0 1 0 1 0 1 0, 1

8. NFA → DFA: accepting states 10 0, 1 qq qq qq NFA: DFA: {q 0, q 1 } {q 0, q 2 }{q 0, q 1, q 2 } {q 1, q 2 } {q 0 } {q 1 } {q 2 }  0 1 0 1 0, 1 0 1 0 1 0 1 0 1 0, 1 NFA accepts if it contains a DFA final state

9. NFA → DFA: dead state elimination 10 0, 1 qq qq qq NFA: DFA: {q 0, q 1 } {q 0, q 2 } {q 0 } 0 1 0 1 0 1 {q 0, q 1, q 2 } 0 1 0 {q 1, q 2 } {q 1 } {q 2 }  0 1, 1 0 1 0, 1 At the end, you can eliminate the unreachable states

10. General method NFADFA states q 0, q 1, …, q n  q 0 }, {q 1 }, {q 0,q 1 }, …, {q 0,…,q n } one for each subset of states in the NFA initial state q0q0 q0}q0} transitions  ’({q i1,…,q ik }, a) =  (q i1, a) ∪ … ∪  (q ik, a) accepting states F  Q F’ = {S: S contains some state in F}

11. NFA → DFA in two easy steps ➊ Eliminate  -transitions ➋ Convert simplified NFA ✔

12. Eliminating  -transitions q0q0 q1q1 q2q2 , 1 0 0  NFA: NFA without  s: {q 1, q 2 } 0 1 q0q0 q1q1 q2q2 {q 0, q 1, q 2 }    Accepting states: q2q2, q 1, q 0

13. Eliminating  -transitions NFA: new NFA: q0q0 q1q1 q2q2 , 1 0 0  q0q0 q1q1 q2q2 0, 1 0 0 0 0 {q 1, q 2 } 0 1 q0q0 q1q1 q2q2 {q 0, q 1, q 2 }   

14. Eliminating  -transitions Paths with  s are replaced by a single transition States that can reach final state by  are all accepting q5q5 q0q0 q2q2 q0q0 q3q3  a q4q4 q3q3 q5q5 a   q5q5 q3q3 a q3q3 a   q9q9 q7q7 q3q3 q2q2

15. Regular expressions

16. String concatenation st = abbbab s = abb t = bab s = x 1 …x n st = x 1 …x n y 1 …y m t = y 1 …y m ts = bababb ss = abbabb sst = abbabbbab

17. Operations on languages The concatenation of languages L 1 and L 2 is The n -th power of L n is The union of L 1 and L 2 is L 1 L 2 = {st: s  L 1, t  L 2 } L n = {s 1 s 2...s n : s 1, s 2,..., s n  L} L 1  L 2 = {s: s  L 1 or s  L 2 }

18. Example L 1 = {0, 01} L 2 = { , 1, 11, 111, …} L1L2L1L2 L12L12 L22L22 L 1  L 2 = {0, 01, 011, 0111, …}  {01, 011, 0111, …} = {0, 01, 011, 0111, …} 0 followed by any number of 1 s = L 2 L2nL2n (n ≥ 1) = {00, 001, 010, 0101} any number of 1 s = {0, 01, ,  1, 11, 111,...}

19. Operations on languages The star of L are all strings made up of zero or more chunks from L : Example: L 1 = {01, 0}, L 2 = { , 1, 11, 111, …}. What is L 1 * and L 2 * ? L * = L 0  L 1  L 2  …

20. Example L 1 = {0, 01} L10L10 = {  } L1*:L1*: 00100001 00110001 is in L 1 * is not in L 1 * L 1 * are all strings that start with 0 and do not contain consecutive 1 s 10010001 is not in L 1 * L12L12 = {00, 001, 010, 0101} L11L11 = {0, 01} L13L13 = {000, 0001, 0010, 00101, 0100, 01001, 01010, 010101} (plus the empty string)

21. Example L 2 = { , 1, 11, 111, …} L20L20 = {  } L21L21 = L 2 any number of 1 s L2*L2* = L 2 0  L 2 1  L 2 2  … = {  }  L 2 1  L 2 2  … = L 2 L2* = L2L2* = L2 L22L22 L2nL2n (n ≥ 1)

22. Combining languages We can construct languages by starting with simple ones, like {0}, {1} and combining them {0}({0}  {1})* ({0}{1}*)  ({1}{0}*) 0 ( 0 + 1 )* 01 * + 10 * all strings that start with 0 0 followed by any number of 1 s, or 1 followed by any number of 0 s

23. Regular expressions A regular expression over  is an expression formed using the following rules: –The symbols  and  are regular expressions –Every a in  is a regular expression –If R and S are regular expressions, so are R+S, RS and R*. A language is regular if it is represented by a regular expression 0 ( 0 + 1 )* 01 * + 10 * 1 *(  + 0 )   ( 0 + 1 )* 01 ( 0 + 1 )*

24. Analyzing regular expressions 01* (01*)(01) 0 followed by any number of 1 s = 0(1*)= {0, 01, 011, 0111, …} = {001, 0101, 01101, 011101, …} 0 followed by any number of 1 s and then 01  = {0, 1}

25. Analyzing regular expressions (0+1)* = { , 0, 1, 00, 01, 10, 11, …} any string 0+1= {0, 1} (0+1)*01(0+1)* strings of length 1 any string that contatins the pattern 01 (0+1)*010 any string that ends in 010

26. Analyzing regular expressions (0+1)(0+1) (0+1)(0+1)(0+1) strings of length 2 strings of length 3 ((0+1)(0+1))*+((0+1)(0+1)(0+1))* ((0+1)(0+1))* strings of even length ((0+1)(0+1)(0+1))* strings of length a multiple of 3 all strings whose length is even or a mutliple of 3 = strings of length 0, 2, 3, 4, 6, 8, 9, 10, 12,...

27. Analyzing regular expressions ((0+1)(0+1)+(0+1)(0+1)(0+1))* (0+1)(0+1) (0+1)(0+1)(0+1) strings of length 2 strings of length 3 (0+1)(0+1)+(0+1)(0+1)(0+1) strings of length 2 or 3 strings that can be broken in blocks, where each block has length 2 or 3

28. Analyzing regular expressions ((0+1)(0+1)+(0+1)(0+1)(0+1))* strings that can be broken in blocks, where each block has length 2 or 3 0011010011  1011010110 ✓ ✓✓✓✓✗ this includes all strings except those of length 1 ((0+1)(0+1)+(0+1)(0+1)(0+1))* = all strings except 0 and 1

29. Analyzing regular expressions (1+01+001)*(  +0+00) ends in at most two 0 s there can be at most two 0 s between consecutive 1 s Guess: (1+01+001)*(  +0+00) = {x: x does not contain 000} there are never three consecutive 0 s 0110010110 001001000 

30. Writing regular expressions Write a regular expression for all strings with two consecutive 0 s.  = {0, 1} (0+1)*00(0+1)* (anything) 00 (anything else)

31. Writing regular expressions Write a regular expression for all strings that do not contain two consecutive 0 s.  = {0, 1}... every middle 0 followed by one or more 1 s... and at most one 0 in the last block (011*) (  + 0) 1*(011*)*(  + 0) 1110110101101010 every 0 followed by one or more 1 s maybe a 0 at the end some 1 s at the beginning

32. Writing regular expressions Write a regular expression for all strings with an even number of 0 s.  = {0, 1} even number of zeros = ( two zeros )* two zeros = 1*01*01* (1*01*01*)*