Rice's theorem

Another way of stating this problem that is more useful in computability theory is this: suppose we have a set of languages S. Then the problem of deciding whether the language of a given Turing machine is in S is undecidable, provided that there exists a Turing machine that recognizes a language in S and a Turing machine that recognizes a language not in S. Effectively this means that there is no machine that can always correctly decide whether the language of a given Turing machine has a particular nontrivial property. Special cases include the undecidability of whether a Turing machine accepts a particular string, whether a Turing machine recognizes a particular recognizable language, and whether the language recognized by a Turing machine could be recognized by a nontrivial simpler machine, such as a finite automaton.

It is important to note that Rice's Theorem does not say anything about properties of machines, only of functions and languages. For example, asking whether a machine runs for more than 100 steps on some input, whether it has more than 5 states, or whether it ever moves its tape head to the left are all nontrivial but decidable properties. They are not properties of the language because it is possible to find two machines recognizing exactly the same language, one which has the property and one which does not.

Using Rogers' characterization of acceptable programming systems, this result may essentially be generalized to most computer programming languages: there exists no automatic method that decides with generality non-trivial questions on the black-box behavior of computer programs. This is one explanation of the difficulty of debugging.

As an example, consider the following variant of the
halting problem: Take the property a partial function F has if F
is defined for argument 1. It is obviously non-trivial, since there
are partial functions that are defined for 1 and others that are
undefined at 1. The 1-halting problem is the problem of deciding
of any algorithm whether it defines a function with this property,
i.e., whether the algorithm halts on input 1. By Rice's theorem, the
1-halting problem is undecidable.

Proof

Proof sketch

Suppose, for concreteness, that we have an algorithm for examining a
program p and determining infallibly whether or not p is an
implementation of the squaring function, which takes an integer d and
returns d². The proof works just as well if we have an
algorithm for deciding any other nontrivial property of programs, and
will be given in general below.

The claim is that we can convert our algorithm for identifying
squaring programs into one which identifies functions that halt. We
will describe an algorithm which takes inputs a and i and determines
whether program a halts when given input i.

The algorithm is simple: we construct a new program t which (1) temporarily ignores its input while it tries to
execute program a on input i, and then, if that halts, (2) returns the square of its input. Clearly, t is a function for computing squares if and only if step (1) halts. Since we've assumed that we can infallibly identify program for computing squares, we can determine whether t is such a program, and therefore whether program a halts on input i. Note that we needn't actually execute t; we need only decide whether it is a squaring program, and, by hypothesis, we know how to do this.

t(n) { a(i) return n×n } This method doesn't depend specifically on being able to recognize functions that compute squares; as long as some program can do what we're trying to recognize, we can add a call to a to obtain our t. We could have had a method for recognizing programs for computing square roots, or programs for computing the monthly payroll, or programs that halt when given the input "Abraxas", or programs that commit array bounds errors; in each case, we would be able to solve the halting problem similarly.

There is one problem with the above proof, however: say that the function that never halts has the property we wish to decide. For example, we may wish to decide if a function never halts. In this case, t will have the property whether or not a(i) halts. Luckily, by our assumptions, there is some function which does not have the property. Simply add a call to a(i) to the beginning of this function. The resulting function has the property if and only if a(i) does not halt.

Formal proof

For the formal proof, algorithms are presumed to define partial
functions over strings and are themselves represented by
strings. The partial function computed by the algorithm represented by
a string a is denoted F_a. This proof proceeds
by reductio ad absurdum: we assume that there is a non-trivial
property that is decided by an algorithm, and then show that it
follows that we can decide the halting problem, which is not
possible, and therefore a contradiction.

Let us now assume that P(a) is an algorithm that decides some
non-trivial property of F_a. Without loss of
generality we may assume that P(no-halt) = "no", with
no-halt being the representation of an algorithm that never
halts. If this is not true, then this will hold for the negation of
the property. Since P decides a non-trivial property, it follows
that there is a string b that represents an algorithm and
P(b) = "yes". We can then define an algorithm H(a,
i) as follows:

1. construct a string t that represents an algorithm T such that
:* T first simulates the computation of F_a(i)
:* then T simulates the computation of F_b(d) and returns its result.
:2. return P(t)

• Assume that the algorithm represented by a halts on input i. In this case F_t = F_b and, because P(b) = "yes" and the output of P(x) depends only on F_x, it follows that P(t) = "yes" and, therefore H(a, i) = "yes".

• Assume that the algorithm represented by a does not halt on input i. In this case F_t = F_no-halt, i.e., the partial function that is never defined. Since P(no-halt) = "no" and the output of P(x) depends only on F_x, it follows that P(t) = "no" and, therefore H(a, i) = "no".