1. State of the Art [Online]

For each of the following, create an NFA that recognizes exactly the language described.

• Binary strings with at least three 1s or an odd number of 0s.
• Binary strings with at least three 1s and ending in 010.

2. Regular as Clockwork [Online]

For each of the following regular expressions, create an NFA that recognizes the same language. (a) ((0 11)00)

(b) (1 01 001)( 0 00)

3. States Evidence [Online]

Use the construction from lecture to convert each of the following NFAs to DFAs.

Label each state of the DFA with the corresponding states of the NFA. For example, if the state corresponds to {q₀,q₁,q₃}, then label the state q₀,q₁,q₃. The empty state can be labeled empty set or similar. (a) The NFA below, which we get by applying the construction described in class^[1] to the regular

(b) The NFA below:

4. Enemy of the State

Use the algorithm for minimization that we discussed in class to minimize the each of the following DFAs.

• Your solution to Problem 3 (a), which should be a DFA. (Make sure you first submit your solution to that problem and ensure that it is correct before solving this problem.)

You may want to start by renaming the states of that machine since we originally gave them large names, corresponding to the subset of NFA states that they represent.

5. Not Again

Let A = {,p,q,r,} be a fixed set of atomic propositions. We then define the set Prop as follows:

Basis Elements For any p A, Atomic(p) Prop.

Recursive Step If A,B Prop, then NOT(A) Prop and XOR(A,B) Prop.

The set Prop represents parse trees of propositions that use only the operations of negation (represented by NOT) and exclusive or (represented by XOR).

Next, we define a function T that takes a parse tree (an element of Prop) as input and returns the proposition that it represents. Formally, we define

T (XOR(A,B)) = (T (A)) (T (B)) for any A,B Prop

(Note that this setup is very similar to that of Problem 5 from Section 8. The only differences are that these parse trees support rather than and .)

Now, let p A be any atomic proposition. The function neg_p takes a parse tree as input and returns another parse tree with all nodes representing p replaced by nodes representing p instead:

neg_p(Atomic(q)) = NOT(Atomic(q)) if q = p neg_p(Atomic(q)) = Atomic(q) for any q A with q 6= p neg_p(NOT(A)) = NOT(neg_p(A)) for any A Prop

neg_p(XOR(A,B)) = XOR(neg_p(A),neg_p(B)) for any A,B Prop

• Prove the following: for any A Prop and any p A, we have either T (neg_p(A)) T (A) or T (neg_p(A)) T (A).

Note that some facts proven in Problem 4 of Section 2 may be useful here.

• Let A Prop be an expression using only the atomic variables p,q A. What do we know about the truth table of T (A) in the case that T (neg_p(A)) = T (A)? How about if T (neg_p(A)) = T (A)?
• ] We saw in lecture that , , and together can express any proposition (e.g., by writing it in sum-of-products form). De Morgans Law tells us that can be written instead with , so any proposition can be expressed with only and . Prove that the same is not true of and .

Specifically, use the results of the earlier parts to show that p q cannot be represented by any expression using only and .

6. Just Irregular Guy

Use the method described in lecture to prove that each of the following languages is not regular.

• The set of binary strings of the form {0^x1^m0^y | x,m,y > 1 and x y (mod m)}.
• Unicode strings that are syntactically valid Java Script Object Notation (JSON). (This simple language does not include arithmetic expressions but is already irregular.)

7. Extra Credit: Pratt-Pratt-Pratt

Suppose we want to determine whether a string x of length n contains a string y = y₁y₂ y_m with .

To do so, we construct the following NFA:

0,1 0,1

(where the includes states s₃,,s_m2). We can see that this NFA matches x iff x contains the string y.

We could check whether this NFA matches x using the parallel exploration approach, but doing so would take O(mn) time, no better than the obvious brute-force approach for checking if x contains y. Alternatively, we can convert the NFA to a DFA and then run the DFA on the string x. A priori, the number of states in the resulting DFA could be as large as 2^m, giving an (2^m + n) time algorithm, which is unacceptably slow. However, below, you will show that this approach can be made to run in O(m^[2]+ n) time.

• Consider any subset of states, S, found while converting the NFA above into a DFA. Prove that, for each 1 j < m, knowing s_j S functionally determines whether s_i S or not for each 1 i < j.
• Explain why this means that the number of subsets produced in the construction is at most 2m.
• Explain why the subset construction thus runs in only O(m²) time (assuming the alphabet size is O(1)).
• How many states would this reduce to if we then applied the state minimization algorithm?
• Explain why part (c) leads to a bound of O(m²+ n) for the full algorithm (without state minimization).
• Briefly explain how this approach can be modified to count (or, better yet, find) all the substrings matching y in the string x with the same overall time bound.

Note that any string matching algorithm takes (m + n) = (n) time in the worst case since it must read the

[1] The only simplification performed was using three states rather than four to represent the sub-expression 00.

[2] = O(n), or equivalently, m = O(n), which entire input. Thus, the above algorithm is optimal whenever m is the case for normal inputs circumstances.