CMPSCI 601: Theory of Computation

David Mix Barrington

Fall, 2004

Homework Assignment #2 Solutions

Solutions Posted Thu 4 Nov 2004

Covers Lectures 6-10

These problems all concern Turing machines and computability.

Question text is in black, solutions in blue.

• Question 1: Informally describe Turing machines to compute the functions listed in Proposition 7.5 (slide 17 of Lecture 7, Spring 2004).

  Copy: Place a marker on the first character of w. Remember that character, move the head right past w and one blank, and copy the remembered character. Then repeatedly (1) go left to the marker, (2) move the marker right one character, (3) remember the character now marked, if any, (3) move right to the first blank past the second string, (4) copy the remembered character to the space with this blank. Once there is no character of w found in step (3), stop.

  Successor: Move right to the low-order bit of n and change it. If you changed it from 0 to 1, stop, otherwise move left one space and change that character if any. Keep moving left and changing as long as you are changing 1's to 0's. If the 1 you have changed to a 0 is the high-order bit, write a 1, move to the right of the string, and write a new 0. (In this case the input n must have been a string of all 1's.)

  Plus: This is easy on a three-tape machine, where the inputs are originally on the first and second tapes. Starting from the two low-order bits, add them, write the output to the third tape, remember the carry, move left on all three tapes, and repeat the process adding the carry to the two new bits. If you reach the high-order bits of the input and still have a carry, write a 1 and move the whole string written on the third tape one space to the right.

  Times: The simplest thing to do, though not the most efficient, is to execute the code while (y > 0) {out += x, y--;} where out represents the value on the third tape, initially zero. The steps of this algorithm can each be carried out as above.

  Power: Similarly we can initialize out to 1 and execute the code while (y > 0) {out *= x; y--;}, using the solution to Times to implement the *=.

  Even: Assuming n is given in binary, move to its low-order bit and test it for 0.

  Partial even: Same as for even except now halt if the low-order bit is 0 and run right forever if it is 1.

• Question 2: A Turing machine with two-dimensional tape is like an ordinary TM except that its "tape" is a two-dimensional array of cells -- each cell has an address (i,j) where i and j are non-negative integers. It has a single head which reads the contents of the cell where it is, decides what to do based on that cell and its state, and does it -- writing on the tape cell and moving left, right, up, or down. Prove that a Turing machine with two-dimensional tape can be simulated by an ordinary TM.

  The simiulating TM will have a string on its tape to represent the contents of each row of the 2DTM's tape. These strings can be written on the simulating machine's single tape, with a marker between each. A marker on this tape indicates where the head is. To update the simulation for one step of the 2DTM we may have to:

  • Write a character in the head's current location,
  • Move the head left or right in the current row,
  • Move the head up or down, meaning that in the simulation it must move to the string-row to the left or right, and find the location in that row that is the same distance from the left end as was the former had position,
  • Make room to expand a row-string by shifting each row-string that is right of the current one by one character to the right.

• Question 3: We say that a partial function f is computed by a nondeterministic TM N if for every input string x, (1) if f(x) is defined, at least one computation path of N on x gives output f(x), and (2) no two computation paths of N on x halt and output different strings, and (3) if f(x) is not defined, no computation path of f on x halts. Prove that every function computed by a nondeterministic TM is partial recursive. Explain why this definition leads to the same classes of total recursive functions and recursive sets as does the ordinary definition in terms of deterministic TM's.

  If f is computed by N according to this definition, we can build a DTM D that will compute f where it is defined and never halt where it is not. D loops through all strings, testing each one as a choice-string for a run of N on input x. If N halts on one of these runs, D halts and reports N' answer as its answer. This answer is correct because no other run of N on this input produces a different output. If there is no choice-string causing N to halt on this input, D never halts, which is good because f is undefined on this input. Since D exists and has the appropriate relationship to f, f is partial recursive.

  Since the concepts of "NDTM-partial recursive" and "partial recursive" are identical, the subsets of these classes of functions that are total are identical, and the classes of languages that are decided by total "partial recursive" functions are also identical.

• Question 4: The language BTHP (blank tape halting problem) is defined as {n: The TM M_n halts on blank input}. Prove that BTHP is r.e.-complete.

  BTHP is r.e.: Design a machine that on input M, a TM, runs M on blank tape. This machine halts iff M is in BTHP, so BHP is an r.e. language.

  BTHP is r,e.-hard: We reduce K to BTHP. Given a Turing machine M and an input w, define M_w to be a machine that erases its input, writes w on its tape, and runs M on w. Let f be the function that takes the pair (M,w) to the machine M_w. Then f is a reduction from K to BTHP, because (M,W) is in K iff M halts on w iff M_w halts on blank tape iff M_w is in BTHP.

• Question 5: A tiling problem is a finite set of tile types, a set of rules as to which tiles may be adjacent horizontally and vertically, and a designated northwest and southeast tile. The problem is solvable if there exists positive integers m and n such that there is an m by n rectangle of tiles, with the northwest tile on the northwest corner and the southeast tile on the southeast corner, where every adjacent pair of tiles satisfies the rules. Prove that the set of solvable tiling problems is r.e.-complete.

  TILING is r.e.: The following code defines a Turing machine that will halt if a given set of rules has a solution and will not halt otherwise:

  
        for (int n = 0; ; n++)
            for (int m = 0; m <= n, m++)
                for (T cycles through all possible m by n tilings)
                   if (T is a legal tiling) halt;
  

  TILING is r.e.-hard: We reduce BTHP to TILING. Given a one-tape Turing machine M, we design a set of rules such that:

  • A tile represents a tape cell at a particular time, where the TM's head may or may not be present, and the cell contents gives the state if it is,
  • The top row of the tiling represents the TM in the start state at the left end of a blank tape. (The NW tile is fixed, and the rules only allow blanks to the right of this special tile.)
  • Each tile must have the proper relation to the three tiles above it, so that it represent the appropriate tape cell contents (and machine state, if the head is there) based on the TM's situation in the row above.
  • The height n of the rectangle of tiles will represent the time the TM will take to halt, and the width n will represent the amount of tape used.
  • The SW tile represents the TM in a halt state. To make sure the SW corner of the rectangle is reached, we modify M so that it stays in the halt state but moves right forever when it halts.

Last modified 4 November 2004