设计一个图灵机来接受 {1^n: n is prime number}

Question

Design a Turing Machine to accept {1^n: n is prime number}.

I have this homework to make a recognizer Turing Machine that will be accepted if the occurrences of 1 are equal to any prime number. As of now, I still got no idea how to find the solution related to this prime number.

How should I go about this?

Answer 1

Because we're making a Turing machine and we haven't explicitly said we care about performance, odds are we just care about showing that TMs can solve this problem - so, any solution, no matter how dumb, should suffice. What is a correct, if needlessly tedious, way to show that a number in unary format (eg, 1^p) is a prime number? One way is to check whether the number of p's is evenly divisible by any number between 2 and p - 1, inclusive. This is actually pretty easy to do for a Turing machine. Since the problem doesn't tell us not to, we can make it even simpler by using a multi-tape Turing machine for our construction.

Let the input be on tape #1 and use tape #2 to record the current thing we are trying to divide the input by. Before we begin, we can verify that our p is greater than 2, as follows:

• see if the current tape square is 1, if so, move right, else halt-reject since 0 is not prime
• see if the current tape square is 1, if so, move right, else, halt-reject since 1 is not prime
• see if the current tape square is 1, if so, reset the tape head and continue on with our division process, knowing p > 2; else, halt-accept since 2 is prime.

If we're continuing at this point, that means we've verified we are looking at the unary encoding of a number greater than 2. We need to do this because 2 is the first number for which we need to check divisibility, and we don't want to say 2 is composite since 2 divides it. At this stage, we can write 11 (unary 2) on tape #2. If you like, you can do this as you are resetting the tape head as mentioned above. Otherwise, you can use some new states specifically for that part of the setup.

We are now looking at a TM configuration like this:

#1111111111111111111111#
 ^
#11#
 ^

We want to see if the number represented on the second tape evenly divides the number represented on the first tape. To do this, we can "cross out" numbers on the first tape repeatedly, in groups the size of the second tape, until we run out of numbers on the first tape. If we run out in the middle of crossing out a whole group, then the number represented on the first tape is not evenly divisible by the number represented on the second tape, and we can proceed to check increasing numbers on the second tape. If we run out after having crossed out an entire group, then it is evenly divisible by a number other than 1 and itself, so we can halt-reject as the number is not prime. Processing our example would look like:

=>   #1111111#   =>   #x111111#   =>   #xx11111#   =>   #xx11111#
      ^                 ^                 ^                ^
     #11#             #11#             #11#             #11#
      ^                 ^                 ^               ^

=>   #xx11111#   =>   #xx11111#   =>   #xx11111#   =>   #xxx1111#
        ^                ^                ^                 ^
     #11#             #11#             #11#             #11#
      ^               ^                 ^                 ^

=>   #xxxx111#   =>  ... reset    =>   #xxxx111#   =>   ... cross
          ^           tape 2                ^            off another
     #11#             back to          #11#              pair of 1s
        ^             head ...          ^               ...

=>   #xxxxxx1#   =>   #xxxxxxx#
            ^                 ^
     #11#             #11#
      ^                 ^

At this stage we see a 1 on the second tape and a blank on the first tape; this means the number was not divisible by our current guess. If we had seen blank/blank, we could have halt-rejected immediately. Instead, we need to continue checking larger possible divisors. At this stage we need to:

1. reset the first tape head to the beginning of the input, replacing x's with 1's again.
2. add an extra 1 to the second tape head to increment its value, then reset the head to the beginning of its value.
3. repeat the divisibility check described above.

If we continue this process, we will eventually find a divisor of the number represented on the input tape, if that number is composite. As it is, however, we will currently halt-reject on prime numbers when the second tape increases to the same number as the input. We will then find that the prime number evenly divides itself. We need to check for this; a good place would be between steps 2 and 3 in the last set of 3 steps above, we can compare tapes #1 and #2 and see if they match exactly. this would be just like the divisibility check, but it would only cross off at most one copy of tape #2 from tape #1, and it would halt-accept if it got to blank/blank rather than halt-rejecting.

Obviously, there are a lot of details to fill out if you want to formally define the TM by giving its transition table. But, it can be done and a procedure like the one outlined here can be used to solve this problem. Again, this is not the most efficient way to solve this, but it is a way to solve it, which generally is good enough when looking for TMs for some problem.