CSE 355 Homework One Sample Solutions

Transcription

1 CSE 355 Homework One Sample Solutions Question Give a transition diagram and the transition table, for a DFA to recognize. Part (a) {w {, } : w contains an even number of s and an odd number of s} Solution: q e,e q o,e q e,o q o,o q e,e (start) q o,e q e,o q e,o (final) q o,o q e,e q o,e q e,e q o,o q o,o q e,o q o,e.2 Part (b) {w {, } : w contains an odd number of s and an even number of s} Solution: This is exactly the same DFA as in part (a) except that F = {q o,e } here instead of {q e,o } as in part (a)..3 Part (c) {w {, } : w either contains an even number of s and an odd number of s or contains an odd number of s and an even number of s} using the product construction on the solutions for (a) and (b). Solution: We form the DFA for the product construction. For compactness, the state names are of the form abcd where the first machine was in state q a,b and the second was in q c,d.

2 eeee eeeo eeoe eeoo eoee eoeo eooe eooo oeee oeeo oeoe oeoo ooee ooeo oooe oooo The table is given below. eeee (start) oeoe eoeo eeeo oeoo eoee eeoe (final) oeee eooo eeoo oeeo eooe eoee (final) oooe eeeo eoeo (final) oooo eeee eooe (final) ooee eeoo eooo (final) ooeo eeoe oeee eeoe ooeo oeeo eeoo ooee oeoe (final) eeee oooo oeoo oeeo eooe ooee eooe oeeo ooeo eooo oeee oooe (final) eoee oeoo oooo eoeo oeoe.4 Part (d) The same language as (c), with as few states as you can. Solution: Note that when the product construction was performed in part (c), it was on the same DFA (apart from the final states). This means that for all states in part (c) of the form abcd where (a, b) (c, d), 2

3 it is not possible to reach that state from the start state. Therefore, all of those states can be removed to obtain the following DFA: eeee eoeo oeoe oooo However, this DFA can still be simplified. Note that if an odd number of characters has been processed, the DFA is in one of its two final states; if an even number has been processed, then the DFA is in one of the other two states. Therefore, we can just make the DFA on two states for checking if the input length is odd or not: even,, odd even (start) odd odd odd (final) even even 2 Question 2 Give a transition diagram for an NFA with as few states as you can to recognize 2. Part (a) {w {, } : w has as a substring} Solution:,, q q q 2 q Part (b) {w {, } : w does not have as a substring} Solution: This was not necessary, but I converted the above NFA to a DFA, complemented the final states, and removed all unneeded states (of which there was ). Note that this is the smallest possible NFA for this language, since we need to accept strings that have but not as a substring. 3

4 q q q Part (c) {w {, } : w has as a substring or w does not have as a substring} Solution: This is just {, }., q 3 Question 3 Which languages are accepted by Note that for Questions 3 and 4, we can use the GNFA method (initially) on 5 states even if the original DFA/NFA had or 2 states, we can add a dummy state(s). When the GNFA is built, it corresponds to exactly 6 transitions (some of which are ). We then rip out the intermediate states to obtain a (large) regular expression on variables that correspond to all of the possible transitions of the original DFA/NFA. We get all of the languages in each part by filling in all possible choices of subsets of Σ to all transitions in all possible ways. 3. Part (a) a DFA with state with alphabet Σ = {,, 2}? Solution: For all 3 parts, note that since we are dealing with DFAs, if a language L is listed, then L is also possible because of closure under complement. The only languages can be, and as a result, {,, 2}. Since the machine is a DFA, every state must have a transition on,, and 2. But there is only one state, so all three transitions have to be self-loops. The only choices of final states are having this state be final or not, which give us those two languages. 3.2 Part (b) a DFA with 2 states with alphabet Σ = {, }? Solution: Per the discussion of Question 5 below, there are 64 possible DFAs with 2 states and 2 input symbols. However, this can be reduced as follows: we do not list the DFAs with both states final, since it has language the complement of the DFA with neither state final. There are 32 DFAs that fit into these two categories. Also, we do not list the DFAs with the start state non-final and the second state final, since we will list the DFAs with the start state final and the second state non-final (and hence has the complemented language). This cuts our list down to 6 DFAs to consider. For both states neither final, the language must be. Because of this, the language {, } is also possible (for when both states are final). For the first state final and the second state non-final, we create a table of languages as follows, where Q = {q, q }, q is the start state, and F = {q }. The fifth column lists the language as given by the DFA given in the previous four columns. 4

5 For simplicity, let # a (w) be the number of occurrences of the character a in w. Define the following languages: L = {w {, } : # (w) =, # (w) is even}, L 2 = {w {, } : w ends in followed by even number of s} L 3 = {w {, } : w ends in }, L 4 = {w {, } : # (w) is even} L 5 = {w {, } : # (w) =, # (w) is even}, L 6 = {w {, } : w ends in followed by even number of s} L 7 = {w {, } : # (w) is even} L 8 = {w {, } : w ends in } L 9 = {w {, } : w is even} L = {w {, } : w ends in followed by odd number of s} L = {w {, } : w ends in followed by odd number of s} δ(q, ) δ(q, ) δ(q, ) δ(q, ) Language q q q q {, } q q q q {, } q q q q {, } q q q q {, } q q q q L L 2 q q q q L 3 {ε} q q q q L 4 q q q q {} q q q q L 5 L 6 q q q q L 7 q q q q L 8 {ε} q q q q {} q q q q L 9 q q q q L 5 L q q q q L 5 L q q q q {ε} Therefore, the languages presented in this table, their complements, as well as and {, } are the languages accepted by 2-state DFAs on 2 symbols. 3.3 Part (c) a DFA with 3 states with alphabet Σ = {}? Solution: There are 8 ways to choose the set of final states. For each, there are three ways to choose the transition labeled leaving a state, so there are 3 3 = 27 ways to choose the three transitions. Hence there are 26 DFAs to consider. However, as in part (b), we can make simplifications. If no state is final, then the language is, and if all are final, then the language is {}. If two states are final, then that language is the complement of if the other state was the only final state. Define the following languages: 5

6 L = {w {} : w is even}, L 2 = {w {} : w, when divided by 3, has a remainder of }, L 3 = {w {} : w, when divided by 3, has a remainder of }, L 4 = {w {} : w, when divided by 3, has a remainder of 2}, L 5 = {ε}, L 6 = {ε, }, L 7 = {}, L 8 =, Brute forcing all the DFAs, as in part (b), reveals that the languages are the ones listed above as well as their complements. 4 Question 4 Which languages are accepted by 4. Part (a) an NFA with state with alphabet Σ = {,, 2}? Solution: Note that we cannot apply the closure under complement idea from Question 3 here because swapping final and non-final states does not necessarily work for NFAs. There are 2 3 = 8 possible sets of transitions from the (only) state to itself. If the state is non-final, the language is. If the state is final, the possible languages are S where S P({,, 2}) (i.e., S is any subset of {,, 2}). 4.2 Part (b) an NFA with 2 states with alphabet Σ = {, }? Solution: Because there are so many possible NFAs, a Python program was written to compute all possible languages (written as regular expressions for convenience). There are 8 subsets of {,, ε} as to transitions that can be made between both states. If both states are non-final, the language is. Let q be the start state, and q the other state. Let the transitions from q to q be A; from q to q be B; from q to q be C; and from q to q be D. Now suppose q is final, and q is not. Then the language of the NFA is (A BD C). If q is final and q is not, the language is A B(D CA B). If both states are final, the language is (A BD C) (ε BD ). So for all possible choices of 8 transitions for A, B, C, D and for all 4 combinations of the states being final, we generate all possible NFAs. We can make simplifications. If A or D include ε, then we can ignore that case because there is no reason to include ε for a self-loop. Suppose we have a candidate language L (written as a regex). In the generation of the expressions, a number of substitutions can be made. One example is replacing X with where X is anything. We perform substitutions or simplifications until no more can be performed. Note that some languages are equivalent to others on the list. Also, the languages are listed in sorted order of the produced string. The operator + represents union, and * is star, as usual. 6

7 ((+)(+))* ((+)(+))*(+) ((+)(+)*(+))* ((+)(+)*(+))*((+)(+)*) ((+)(+)*) ((+)(+)*)* ((+)(+)*)*((+)(+)*) ((+)(+)*)* ((+)(+)*)*((+)(+)*) ((+)(+)*)* ((+)(+)*)*((+)(+)*) ((+)*(+))* ((+)*(+))*(+)* ((+)*)* ((+)*)*(+)* ((+)*)* ((+)*)*(+)* ((+)+(+)(+))* ((+)+(+)(+))*(+) ((+)+(+)(+)*(+))* ((+)+(+)(+)*(+))*((+)(+)*) ((+)+(+)(+)*)* ((+)+(+)(+)*)*((+)(+)*) ((+)+(+)(+)*)* ((+)+(+)(+)*)*((+)(+)*) ((+)+(+)(+)*)* ((+)+(+)(+)*)*((+)(+)*) ((+)+(+))* ((+)+(+))*(+) ((+)+(+)*(+))* ((+)+(+)*(+))*(+)* ((+)+(+)*)* ((+)+(+)*)*(+)* ((+)+(+)*)* ((+)+(+)*)*(+)* ((+)+(+)*)* ((+)+(+)*)*(+)* ((+)+(+))* ((+)+(+))*(+) ((+)+(+)*(+))* ((+)+(+)*(+))*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+))* ((+)+(+))*(+) ((+)+(+)*(+))* ((+)+(+)*(+))*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+))* ((+)+(+))* ((+)+(+)*(+))* ((+)+(+)*(+))*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+)* ((+)+)* ((+)+*(+))* ((+)+*(+))** ((+)+*)* ((+)+*)** ((+)+*)* ((+)+*)** ((+)+*)* ((+)+*)** ((+)+)* ((+)+)* ((+)+*(+))* ((+)+*(+))*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+)+)* ((+)+)* ((+)+*(+))* ((+)+*(+))*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+)+(+))* ((+)+(+))* ((+)+(+)*(+))* 7

8 ((+)+(+)*(+))*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+(+)*)* ((+)+(+)*)*((+)*) ((+)+)* ((+)+)* ((+)+*(+))* ((+)+*(+))** ((+)+*)* ((+)+*)** ((+)+*)* ((+)+*)** ((+)+*)* ((+)+*)** ((+)+)* ((+)+)* ((+)+*(+))* ((+)+*(+))*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+)+)* ((+)+)* ((+)+*(+))* ((+)+*(+))*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+)+*)* ((+)+*)*(*) ((+))* ((+))*(+) ((+)*(+))* ((+)*(+))*((+)*) ((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) ((+))* ((+))*(+) ((+)*(+))* ((+)*(+))*((+)*) ((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) ((+))* ((+))* ((+)*(+))* ((+)*(+))*((+)*) ((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) (*(+))* (*(+))** (*)* (*)** (*)* (*)** (+(+)(+))* (+(+)(+))*(+) (+(+)(+)*(+))* (+(+)(+)*(+))*((+)(+)*) (+(+)(+)*)* (+(+)(+)*)*((+)(+)*) (+(+)(+)*)* (+(+)(+)*)*((+)(+)*) (+(+)(+)*)* (+(+)(+)*)*((+)(+)*) (+(+)*(+))* (+(+)*(+))*(+)* (+(+)*)* (+(+)*)*(+)* (+(+)*)* (+(+)*)*(+)* (+(+)*)* (+(+)*)*(+)* (+(+))* (+(+))*(+) (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) 8

9 (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+))* (+(+))*(+) (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+))* (+(+))* (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+*(+))* (+*(+))** (+*)* (+*)** (+*)* (+*)** (+*)* (+*)** (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+(+))* (+(+))* (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+) (+)((+)(+))* (+)((+)+(+)(+))* (+)((+)+(+))* (+)((+)+(+))* (+)((+)+(+))* (+)((+))* (+)(+(+)(+))* (+)(+(+))* (+)(+(+))* (+)(+)* (+)((+))* (+)(+(+)(+))* (+)(+(+))* (+)(+(+))* (+)* (+)*((+)(+)*) (+)*((+)(+)*)* (+)*((+)+(+)(+)*)* (+)*((+)+(+)*)* (+)*((+)+(+)*)* (+)*((+)+(+)*)* (+)*((+)*) (+)*((+)*) (+)*((+)*) (+)*((+)*)* (+)*(+(+)(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+) (+)*(+)((+)(+)*(+))* (+)*(+)((+)*(+))* (+)*(+)((+)+(+)(+)*(+))* (+)*(+)((+)+(+)*(+))* (+)*(+)((+)+(+)*(+))* (+)*(+)((+)+(+)*(+))* (+)*(+)((+)*(+))* 9

10 (+)*(+)(+(+)(+)*(+))* (+)*(+)(+(+)*(+))* (+)*(+)(+(+)*(+))* (+)*(+)(+(+)*(+))* (+)*(+)(+)* (+)*(+)((+)*(+))* (+)*(+)(+(+)(+)*(+))* (+)*(+)(+(+)*(+))* (+)*(+)(+(+)*(+))* (+)*(+)(+(+)*(+))* (+)*(+)* (+)*(+)* (+)*(+)* (+)*(*) (+)*(*) (+)*((+)*) (+)*((+)*)* (+)*(+(+)(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(*) (+)*(*) (+)* (+)*((+)(+)*)* (+)*((+)*)* (+)*((+)+(+)(+)*)* (+)*((+)+(+)*)* (+)*((+)+(+)*)* (+)*((+)+(+)*)* (+)*((+)*)* (+)*(+(+)(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+)* (+)*((+)*)* (+)*(+(+)(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)** (+)** (+)** (+)* (+)*((+)(+)*)* (+)*((+)*)* (+)*((+)+(+)(+)*)* (+)*((+)+(+)*)* (+)*((+)+(+)*)* (+)*((+)+(+)*)* (+)*((+)*)* (+)*(+(+)(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+)* (+)*((+)*)* (+)*(+(+)(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)*(+(+)*)* (+)** (+)** (+)** (+)* (+)* (+*(+))* (+*(+))** (+*)* (+*)** (+*)* (+*)** (+*)* (+*)** (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) ()* ()* (*(+))* (*(+))*(*) (*)

11 (*)* (*)*(*) (*)* (*)*(*) (*)* (*)*(*) ()* ()* (*(+))* (*(+))*(*) (*) (*)* (*)*(*) (*)* (*)*(*) (*)* (*)*(*) ((+))* ((+))* ((+)*(+))* ((+)*(+))*((+)*) ((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) ((+)*)* ((+)*)*((+)*) (*(+))* (*(+))** (*)* (*)** (*)* (*)** (+(+)(+))* (+(+)(+))*(+) (+(+)(+)*(+))* (+(+)(+)*(+))*((+)(+)*) (+(+)(+)*)* (+(+)(+)*)*((+)(+)*) (+(+)(+)*)* (+(+)(+)*)*((+)(+)*) (+(+)(+)*)* (+(+)(+)*)*((+)(+)*) (+(+)*(+))* (+(+)*(+))*(+)* (+(+)*)* (+(+)*)*(+)* (+(+)*)* (+(+)*)*(+)* (+(+)*)* (+(+)*)*(+)* (+(+))* (+(+))*(+) (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+))* (+(+))*(+) (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+))* (+(+))* (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+*(+))* (+*(+))** (+*)* (+*)** (+*)* (+*)** (+*)* (+*)** (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*)

12 (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+(+))* (+(+))* (+(+)*(+))* (+(+)*(+))*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+(+)*)* (+(+)*)*((+)*) (+*(+))* (+*(+))** (+*)* (+*)** (+*)* (+*)** (+*)* (+*)** (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+)* (+)* (+*(+))* (+*(+))*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) (+*)* (+*)*(*) ()* ()* (*(+))* (*(+))*(*) (*) (*)* (*)*(*) (*)* (*)*(*) (*)* (*)*(*) ()* ()* (*(+))* (*(+))*(*) (*) (*)* (*)*(*) (*)* (*)*(*) (*)* (*)*(*) ((+)+(+))* ((+)+)* ((+)+)* ((+)+)* ((+))* (+(+))* (+)* (+)* (+)* ()* (+(+))* (+)* (+)* ()* * *((+)(+)*) *((+)+(+)*)* *((+)+*)* *((+)+*)* *((+)+*)* *((+)*) *((+)*)* *((+)*) *((+)*) *(+(+)*)* *(+*)* *(+*)* *(+) *(+)((+)+(+)*(+))* 2

13 *(+)((+)+*(+))* *(+)((+)+*(+))* *(+)((+)+*(+))* *(+)((+)*(+))* *(+)(*(+))* *(+)(+(+)*(+))* *(+)(+*(+))* *(+)(+*(+))* *(+)(+)* *(+)(+*(+))* *(+)(*(+))* *(+)(+(+)*(+))* *(+)(+*(+))* *(+)(+*(+))* *(+)(+*(+))* *(+)(*(+))* *(+)* *(+)* *(+)* *(+*)* *(*) *(*)* *(*) *((+)*) *(+(+)*)* *(+*)* *(+*)* *(+*)* *(*) *(*)* *(*) * *((+)+(+)*)* *((+)+*)* *((+)+*)* *((+)+*)* *((+)*)* *(*)* *(+(+)*)* *(+*)* *(+*)* *(+)* *(+*)* *(*)* *(+(+)*)* *(+*)* *(+*)* *(+*)* *(*)* ** ** * *((+)+(+)*)* *((+)+*)* *((+)+*)* *((+)+*)* *((+)*)* *(*)* *(+(+)*)* *(+*)* *(+*)* *(+)* *(+*)* *(*)* *(+(+)*)* *(+*)* *(+*)* *(+*)* *(*)* ** ** ** * * ((+)+(+))* ((+)+)* ((+)+)* ((+)+)* ((+))* (+(+))* (+)* (+)* (+)* ()* (+(+))* (+)* (+)* ()* * *((+)(+)*) *((+)+(+)*)* *((+)+*)* *((+)+*)* *((+)+*)* *((+)*) *((+)*) *((+)*)* *((+)*) *(+(+)*)* 3

14 *(+*)* *(+) *(+)((+)+(+)*(+))* *(+)((+)+*(+))* *(+)((+)+*(+))* *(+)((+)+*(+))* *(+)((+)*(+))* *(+)(+(+)*(+))* *(+)(+*(+))* *(+)(+)* *(+)(+*(+))* *(+)(+*(+))* *(+)(*(+))* *(+)(*(+))* *(+)(+(+)*(+))* *(+)(+*(+))* *(+)(+*(+))* *(+)(+*(+))* *(+)(*(+))* *(+)* *(+)* *(+)* *(+*)* *(+*)* *(*) *(*) *(*)* *((+)*) *(+(+)*)* *(+*)* *(+*)* *(+*)* *(*) *(*) *(*)* * *((+)+(+)*)* *((+)+*)* *((+)+*)* *((+)+*)* *((+)*)* *(+(+)*)* *(+*)* *(+)* *(+*)* *(+*)* *(*)* *(*)* *(+(+)*)* *(+*)* *(+*)* *(+*)* *(*)* ** ** ** * *((+)+(+)*)* *((+)+*)* *((+)+*)* *((+)+*)* *((+)*)* *(+(+)*)* *(+*)* *(+)* *(+*)* *(+*)* *(*)* *(*)* *(+(+)*)* *(+*)* *(+*)* *(+*)* *(*)* ** ** * * ε 4.3 Part (c) an NFA with 3 states with alphabet Σ = {}? Solution: We proceed in the same way as in part (b). Suppose the states are q, q, q 2. Let the transitions from q to q be A; from q to q be B; from q to q 2 be C; from q to q be D; from q to q be E; from q to q 2 be F ; from q 2 to q 2 be G; from q 2 to q be H; and from q 2 to q be I. Although this is not strictly necessary, one can find a regular expression for the language of this NFA by using the GNFA process described in the text. If that process was followed (as was in generating the 4

15 output below), one such regex is: (R R 3 R 2R 4 ) (R 5 R 3 R 2R 6 ) where R = A CG H, R 2 = D F G H, R 3 = B CG I, R 4 = E F G H, R 5 = J HG L, R 6 = K F G L, where J, K, L are ε if q, q, q 2 are final respectively, and are if they are not final, respectively. Again many simplifications are possible here, as was in part (b). Note that there are many simplifications that can still be done and that there are many languages repeated. ((+)()*) ((+)()*) ((+)()*)*((+)()*) ((+)()*)*((+)()*) ((+)+(+)()*(+))*((+)()*) ((+)+(+)()*(+))*(+(+)()*) ((+)+(+)()*())*((+)()*) ((+)+(+)()*())*(+(+)()*) ((+)+(+))*(+(+)) ((+)+(+))*(+) ((+)+(+))* ((+)+(+)*(+))*((+)*) ((+)+(+)*(+))*(+(+)*) ((+)+(+)*())*((+)*) ((+)+(+)*())*(+(+)*) ((+)+(+)*)*((+)*) ((+)+(+)*)*(+(+)*) ((+)+(+)*)* ((+)+()()*(+))*(()()*) ((+)+()()*(+))*(+()()*) ((+)+()()*())*(()()*) ((+)+()()*())*(+()()*) ((+)+())*(+()) ((+)+())*() ((+)+())* ((+)+()*(+))*(()*) ((+)+()*(+))*(+()*) ((+)+()*())*(()*) ((+)+()*())*(+()*) ((+)+()*)*(()*) ((+)+()*)*(+()*) ((+)+()*)* ((+)+(+))*(+) ((+)+(+))* ((+)+())*(+) ((+)+())* ((+)+)* ((+)+*(+))*(*) ((+)+*(+))*(*) ((+)+*())*(*) ((+)+*())*(*) ((+)+*)*(*) ((+)+*)* ((+))*(+) ((+)*) ((+)*)*((+)*) ((+)*) ((+)*)*((+)*) ((+)*)*((+)*) (()()*) (()()*) (()()*)*(()()*) (()()*)*(()()*) (()+(+)()*(+))*((+)()*) (()+(+)()*(+))*(+(+)()*) (()+(+)()*())*((+)()*) (()+(+)()*())*(+(+)()*) (()+(+))*(+(+)) (()+(+))*(+) (()+(+))* (()+(+)*(+))*((+)*) (()+(+)*(+))*(+(+)*) (()+(+)*())*((+)*) (()+(+)*())*(+(+)*) (()+(+)*)*((+)*) (()+(+)*)*(+(+)*) (()+(+)*)* (()+()()*(+))*(()()*) (()+()()*(+))*(+()()*) (()+()()*())*(()()*) (()+()()*())*(+()()*) (()+())*(+()) (()+())*() (()+())* (()+()*(+))*(()*) (()+()*(+))*(+()*) (()+()*())*(()*) (()+()*())*(+()*) (()+()*)*(()*) (()+()*)*(+()*) (()+()*)* (()+(+))*(+) (()+(+))* (()+())*(+) 5

16 (()+())* (()+)* (()+*(+))*(*) (()+*(+))*(*) (()+*())*(*) (()+*())*(*) (()+*)*(*) (()+*)* (())*() (()*) (()*)*(()*) (()*) (()*)*(()*) (()*)*(()*) ((*)(*)(*)) ((*)(*)) ((*)(*))*((*)(*)(*)) ((*)(*))*((*)(*)) ((*)) ((*))* ((*))*((*)) ((*))*((*)+*) ((*))*((*)*) ((*))*((*)) ((*))*((*)*) ((*))*(*+(*)) ((*))*(*) ((*))* ((*))** ((*)+(*)(*)(*))*((*)(*)) ((*)+(*)(*)(*))*((*)+(*)(*)(*)) ((*)+(*))* ((*)+(*))*(*+(*)) ((*)+(*))*((*)) ((*)+(*))** ((*)+(*)*(*))*((*)+(*)*) ((*)+(*)*(*))*((*)*) ((*)+(*)*(*))*(*+(*)*(*)) ((*)+(*)*)*((*)) ((*)+(*)*)*((*)*) ((*)+(*)*)*(*+(*)*) ((*)+(*)*)** ((*)+(*)(*)(*))*((*)(*)) ((*)+(*)(*)(*))*(*+(*)(*)(*)) ((*)+(*))*((*)) ((*)+(*))** ((*)+(*)*)*((*)*) ((*)+(*)*)*(*+(*)*) ((*)+(*)*)** ((*)+(*))*((*)+*) ((*)+(*))*(*+(*)) ((*)+(*))* ((*)+(*))*((*)+(*)) ((*)+(*))* ((*)+)*((*)) ((*)+)* ((*)+)** ((*)+*(*))*((*)+*) ((*)+*(*))*(*+*(*)) ((*)+*(*))*(*) ((*)+*(*))*((*)+*(*)) ((*)+*(*))*(*) ((*)+*)*((*)) ((*)+*)*(*+*) ((*)+*)* ((*)+*)** ((*)+*)*((*)) ((*)+*)*(*+*) ((*)+*)*(*) ((*)+*)** ((*))*((*)) ((*)*(*)) ((*)*) ((*)*) ((*)*)*((*)*(*)) ((*)*)*((*)*) ((*)*)*((*)*) ((*)(*)(*)) ((*)(*)) ((*)(*))*((*)(*)(*)) ((*)(*))*((*)(*)) ((*)) ((*))* ((*))*((*)) ((*))*((*)+(*)) ((*))*((*)*) ((*))*((*)) ((*))*((*)*) ((*))*(*) ((*))* ((*)+(*))*((*)) ((*)+(*)*(*))*((*)+(*)*) ((*)+(*)*(*))*((*)*) ((*)+(*)*(*))*((*)+(*)*(*)) ((*)+(*)*(*))*((*)*) ((*)+(*)*)*((*)) ((*)+(*)*)*((*)*) ((*)+(*)(*)(*))*((*)+(*)(*)(*)) ((*)+(*)(*)(*))*((*)(*)) ((*)+(*))* 6

17 ((*)+(*))*((*)+(*)) ((*)+(*))*((*)) ((*)+(*))*((*)) ((*)+(*)*(*))*((*)+(*)*) ((*)+(*)*(*))*((*)*) ((*)+(*)*)*((*)) ((*)+(*)*)*((*)*) ((*)+(*))*((*)+*) ((*)+(*))* ((*)+(*))*((*)+(*)) ((*)+(*))* ((*)+)*((*)) ((*)+)* ((*)+*(*))*((*)+*) ((*)+*(*))*(*) ((*)+*(*))*((*)+*(*)) ((*)+*(*))*(*) ((*)+*)*((*)) ((*)+*)*(*) ((*))*((*)) ((*)*) ((*)*) ((*)*)*((*)*) ((*)*)*((*)*) ((+))*(+) ((+))* (())*(+) (())* (()*(+))*(()*) (()*(+))*(+()*) (()*())*(()*) (()*())*(+()*) (()*) (()*) (()*)*(()*) (()*)*(()*) ((*)) ((*))*((*)+*) ((*))*(*+(*)) ((*))* ((*)(*)) ((*)(*))*((*)) ((*)(*))*(*+(*)(*)) ((*)(*))*((*)+(*)(*)) ((*)(*))*((*)) ((*)) ((*))*((*)+(*)) ((*))* ((*))*((*)(*)) ((*))*((*)) (*(+))*(*) (*(+))** (*())*(*) (*())** (*+(*)(*)(*))*((*)(*)) (*+(*)(*)(*))*(*+(*)(*)(*)) (*+(*))*((*)) (*+(*))** (*+(*)*)*((*)*) (*+(*)*)*(*+(*)*) (*+(*)*)** (*+(*))*(*+(*)) (*+(*))* (*+)* (*+)** (*+*(*))*(*+*(*)) (*+*(*))*(*) (*+*)*(*+*) (*+*)* (*+*)** (*+*)*(*+*) (*+*)*(*) (*+*)** (+(+)()*)*((+)()*) (+(+)()*)*((+)()*) (+(+))* (+(+))*(+) (+(+))* (+(+))*(+) (+(+)*)*((+)*) (+(+)*)*((+)*) (+(+)*)*((+)*) (+()()*)*(()()*) (+()()*)*(()()*) (+())* (+())*() (+())* (+())*() (+()*)*(()*) (+()*)*(()*) (+()*)*(()*) (+(*)(*))*((*)(*)(*)) (+(*)(*))*((*)(*)) (+(*))* (+(*))*((*)+*) (+(*))*(*+(*)) (+(*))*((*)) (+(*)*)*((*)*(*)) (+(*)*)*((*)*) (+(*)*)*((*)*) 7

18 (+(*)(*))*((*)(*)(*)) (+(*)(*))*((*)(*)) (+(*))* (+(*))*((*)+(*)) (+(*))*((*)) (+(*)*)*((*)*) (+(*)*)*((*)*) (+(+))*(+) (+(+))* (+())*(+) (+())* (+()*(+))*(()*) (+()*(+))*(+()*) (+()*())*(()*) (+()*())*(+()*) (+()*)*(()*) (+()*)*(()*) (+(*))*((*)+*) (+(*))*(*+(*)) (+(*))* (+(*)(*))*((*)) (+(*)(*))*(*+(*)(*)) (+(*)(*))*((*)+(*)(*)) (+(*)(*))*((*)) (+(*))*((*)+(*)) (+(*))* (+(*))*((*)(*)) (+(*))*((*)) (+*(+))*(*) (+*(+))** (+*())*(*) (+*())** (+) (+*(+))*(*) (+*(+))*(*) (+*())*(*) (+*())*(*) (+*(*))*((*)+*) (+*(*))*(*+*(*)) (+*(*))*(*) (+*(*))*((*)+*(*)) (+*(*))*(*) () ()* ()*((+)*) ()*(()*) ()*((*)) ()*((*)) ()*(+(+)) ()*(+(+)*) ()*(+()) ()*(+()*) ()*(+) ()*() ()*(*) ()* ()** (*(+))*(*) (*(+))*(*) (*())*(*) (*())*(*) (*(*)) (*(*))*((*)+*) (*(*))*(*+*(*)) (*(*))*(*) (*(*))*((*)+*(*)) (*(*))*(*) (*) (*) (*)((*)) (*)(*+*) (*)(*(*)) (*)(*) (*)(*) (*) (*)* (empty set) * *((+)()*) *((+)()*) *((+)*) *((+)*) *(()()*) *(()()*) *(()*) *(()*) *((*)(*)(*)) *((*)(*)) *((*)) *((*)*(*)) *((*)*) *((*)*) *((*)(*)(*)) *((*)(*)) *((*)) *((*)*) *((*)*) *(()*) *(()*) 8

19 *((*)) *((*)(*)) *((*)) *(*+*) *(*+*) *(+(+)) *(+(+)*) *(+()) *(+()*) *(+) *() *(*(*)) *(*) *(*) * ε 5 Question 5 My friend the entrepreneur knows that everyone gets tired of building DFAs for every new problem they encounter. He is about to launch a marketing campaign for the Universal DFA, claiming it can recognize every regular language in {, } by rewiring itself to implement any transition function. The amazing udfa uses a binary input alphabet and, to keep costs low, only uses states. I am skeptical that such a udfa can exist. Please help me justify my skepticism (explain carefully why such a universal DFA cannot exist). Solution: Let s = be the number of states in the udfa. There are 2 s possible configurations of which of the states is accepting. For transitions, each state has s 2 different choices of states for which of the two symbols it transitions on. Overall, there are (s 2 ) s different transition tables. Here we do not need to track where the start state is because the transition tables keep track of that; so let any of the states be the start state. Finally, there are (at most) 2 s (s 2 ) s different possible languages that a udfa can have. Since s = is fixed, this quantity is a finite, albeit massive, number. However, there are infinitely many regular languages that are subsets of {, }. Therefore, there must be some language that a hypothesized udfa cannot recognize, which finishes the proof. However, we can improve listing an infinite number of languages to an explicit finite set of small languages for which we guarantee at least one of them cannot be recognized by this udfa. Consider the languages L i = { i } for i. For the languages L, L, L 2,, L 2 s (s 2 ) s, there are 2 s (s 2 ) s + different languages listed. But a udfa can only recognize 2 s (s 2 ) s of them, so there must be some L i that it cannot recognize (in fact, the example below shows that many of these cannot be recognized). For an explicit example of a language that cannot be recognized, consider the language P, where P k = {w {, } : w k} (to fully prove this, one needs to show that for any DFA with language P k, it must have at least k + states). 9