CMPSCI 601: Theory of Computation

Offered through the PEEAS distance learning program

Solutions to Homework Assignment #1

David Mix Barrington

Assignment posted Thu 11 Sept 2003

Solutions posted Wed 1 October 2003

Questions are in black, solutions in blue.

• Question 1 (20): Let A be a language over a one-letter alphabet, that is, A is a subset of a^*. Prove that A is DFA-recognizable (there exists a DFA D with A = L(D)) if and only if A is regular with an expression of the form: the expression is a union of finitely many terms, and each term is of the form uv^*, where u and v are words in a^*. (Statement corrected 12 September.)

  One half is immediate from Kleene's Theorem -- if the language has a regular expression of this form, it is DFA-recognizable.

  For the other half, assume that A = L(D) for some DFA D. By the Regular Language Pumping Lemma, there is a number k such that for every string a^m in A, with m ≥ k, there are numbers i and j such that j > 0 and a^it+j is in A for all non-negative integers t. (Why? Consider the strings u, v, and x in the lemma where w - uvx. Let v be a^j and ux be aⁱ.

  Now consider all possible i and j with 0 ≤ i ≤ k, 0 < j ≤ k, and a^ti+j in A for all t. The language A is the union of the languages aⁱ(a^j)^* for all such i and j, together with possibly some strings of length less than k. Each such language has a regular expression of the desired form (for the individual strings you can take v to be the empty string) and thus so does their union, A.

• Question 2 (20): Again let A be a language over a one-letter alphabet. Prove that A is a CFL iff it is regular. (Hint: This is an old well-known result so you might find a reference. It might help to use the CFL Pumping Lemma, which simplifies somewhat if there is only one letter in the alphabet.)

  On a one-letter language, the CFL Pumping Lemma turns out to have the same consequence as the regular language Pumping Lemma. We can write any sufficiently long w or a^m = uvxyz where |vy| > 0 and for all t, uv^txy^tz is in A. Letting vy be a^j and letting uxz by aⁱ, we get the same conclusion, that a^it+j is in A for all numbers t.

  But this (all sufficiently long strings are in a set of this type) is the property of A that we used in Question 1 to prove that A had a regular expression of the desired type. Hence A is DFA-recognizable, and A was an arbitrary CFL on one letter.

• Question 3 (10): Let M be a pushdown automaton with the property that its stack never contains more than 17 letters (on any input, on any possible sequence of nondeterministic choices). Prove that L(M) is regular.

  Define a NFA to simulate the PDA in question, using c¹⁷ different states to represent the possible contents of the stack. (Actually an NFA state represents a PDA state and a PDA stack contents.) A possible move of the PDA corresponds to some change in state and stack contents as the PDA reads a letter, and this can be simulated by an NFA move. Since the NFA accepts iff the PDA does, its language is that of the PDA, and so the PDA's language is regular.

• Question 4 (10): Let M be a Turing machine with the property that it never, on any input, looks at any input letter beyond the first 17 letters. Prove that L(M) is regular.

  Consider the c¹⁷ possible length-17 initial segments of strings over this alphabet. Some of these cause M to accept and some cause M to reject, but two strings with the same 17-letter prefix must either both be in or both be out of L(M) because M will never see the difference between them. So L(M) is a union of finitely many languages of the form "u" or "uΣ^*, where u is a string of length at most 17. Hence L(M) is a regular language.

• Question 5 (20): Let M be a deterministic Turing machine. We say that M hangs on input w if when started in the standard position on w, M goes off the left end of its tape before accepting or rejecting. Define the language H(M) to be the set of strings w such that M hangs on w. Prove that for any language A, A is r.e. iff there exists a machine M such that A = H(M).

  Suppose A is r.e., and thus that A = L(N) for some machine N. We must design a Turing machine M such that A = H(M). So M must hang when N halts and not hang when N does not halt.

  To do this, M will first place an endmarker on the leftmost cell of the tape and then begin simulating N. If N tries to hang, M should halt (because N will not halt on that input). If N halts, M should immediately move left until it hangs. If N loops, M can also loop and this is good because N has not halted and M has not hung.

  Now for the other direction, assume that A = H(M) for some machine M. We must prove that A is r.e. by constructing a machine N such that L(N) = H(M), that is, such that N halts iff M hangs. Again, N places an endmarker and then simulates M. If M halts, N will hang, and if M tries to hang, N will halt (and thus not hang). Again, if M loops then N will loop, and this is good because M has not hung and N has not halted. (In fact the same simulation from the first half of the argument also works for the second half.)

• Question 6 (20): Let A be an r.e. language over {0,1} (so that A is a subset of {0,1}^*) with the property that if u and v are any two strings of the same length that differ in exactly one position, then exactly one of u and v is in A.

  • (a,15) Prove that there exists a Turing machine M such that for any nonempty string w, M halts on w and M accepts w if and only if w is in A.

    Let w be any nonempty string. Let v be the string obtained from w by complementing its first letter. We know that there exists a machine M such that A = L(M). Run M simultaneously on w and v by dovetailing. Since exactly one of w and v is in A, one of these two processes will eventually halt. If it is w, then w is in A, and if it is v, then w is not in A.

  • (b,5) Prove that A is recursive. (Note that the machine in part (a) does not necessarily decide A because it need not halt if its input is the empty string. But remember that either the empty string is in A or it isn't -- break into two cases and design a machine to decide A in each case.)

    Case 1: The empty string is in A. Our machine N decides whether w is in A as follows. If w is empty it accepts. Otherwise it creates v and proceeds as in part (a).

    Case 2: The empty string is not in A. Our machine N rejects w if it is empty, and otherwise follows part (a).

    Of course if we are given M, it is undecidable whether we are in Case 1 or Case 2. But either way, an always-halting machine exists that decides A, so A is recursive.

  Last modified 1 October 2003