CSCI 3130: Automata theory and formal languages Andrej Bogdanov The Chinese University of Hong Kong NFA to DFA conversion and regular expressions Fall 2011

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

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

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

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 }

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

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 }  , , 1

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 }  , , 1 NFA accepts if it contains a DFA final state

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 } {q 0, q 1, q 2 } {q 1, q 2 } {q 1 } {q 2 }  0 1, , 1 At the end, you can eliminate the unreachable states

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}

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

Eliminating  -transitions q0q0 q1q1 q2q2 ,  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

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

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

Regular expressions

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

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 }

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,...}

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  …

Example L 1 = {0, 01} L10L10 = {  } L1*:L1*: 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 is not in L 1 * L12L12 = {00, 001, 010, 0101} L11L11 = {0, 01} L13L13 = {000, 0001, 0010, 00101, 0100, 01001, 01010, } (plus the empty string)

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)

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 ( )* 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

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 ( )* 01 * + 10 * 1 *(  + 0 )   ( )* 01 ( )*

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

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

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,...

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

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  ✓ ✓✓✓✓✗ 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

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

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)

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) every 0 followed by one or more 1 s maybe a 0 at the end some 1 s at the beginning

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*)*