Procedures Versus Algorithms

There are two senses in which a TM accepts a

language.
1. The TM accepts the strings in the language
(by nal state), but does not halt on some of
the strings not in the language.
✦ Thus, we can never be sure whether those
strings are rejected, or eventually will be
accepted.
✦ A language accepted in this way is called
recursively enumerable (RE).
✦ Note: this notion is the normal \accepted
by a TM" notion.
✦ The TM is sometimes referred to as a
procedure.
2. The TM accepts by nal state, but halts on
every string, whether or not it is accepted.
✦ A language accepted this way is called
recursive.
✦ As a problem, the question is called
decidable.
✦ The TM is called an algorithm.

Plan
1. Show a particular language not to be RE.
✦ Like the \hello-world" argument, we
show no TM can tell whether a given TM
halts on a given input | the proof is by
\diagonalization," or self-reference.
2. Use the non-RE language from (1) to show
another language to be RE, but not recursive.
✦ Trick: if a language and its complement
are both RE, then they are both
recursive.
✦ Thus, if a language L is RE, but its
complement is not, then L is not
recursive.
TM's as Integers
We shall focus on TM's whose input alphabet is
f0; 1 . Each such TM can be represented by one or
g

more integers, using the following code:

 Assume the states are q1; q2; : : : . Represent
f g

qi by 0i.

1
 Assume the tape symbols are X1 ; X2 ; : : : ,
f g

where the rst three of these are 0, 1, and B ,

in that order. Represent Xi by 0i.
 Represent directions L and R by 0 and 00,
respectively, and refer to them as L = D1 ,
R = D2 .

 Represent a rule of the TM  (qi; Xj ) =

(qk ; Xl ; Dm ) by 0i10j 10k 10l 10m .
 Represent the whole TM by
111C111C211 11Cn111, where Ci is the

code for one of the  rules, in any order.

✦ This string is some integer in binary, so
we can call the TM Mi , where i is that
integer.
 Conversely, every integer i can be said to
describe some TM Mi .
✦ If i in binary is not of the right form
(111code ), then Mi is the ,TM with

no moves. Thus, H (Mi ) is L 0 + 1) .

✦ Note that many integers represent the
same TM, but that is neither good nor
bad.
The Diagonalization Language
Dene Ld to be the set of binary strings w with
the following properties:
1. First, let i be the integer that is 1w in binary.
✦ Refer to w as the \ith string," or wi .
2. Then wi is in Ld if and only if wi is not in
H (Mi ).

Proof Ld is not RE
Suppose Ld is RE. Then Ld = H (M ) for some TM
M.

 Since the input alphabet of M is 0; 1 , M is

f g

Mj for at least one value of j .

 Let x be the j th string; i.e., 1x is j in binary.

 Question: is x in Ld ?
✦ Suppose so. Then x is not in H (Mj ), by
denition of Ld . But H (Mj ) = H (M ) =
Ld , so x is not in Ld (Contradiction).

✦ Suppose not. Then x is in H (Mj ) by

denition of Ld . But H (Mj ) = H (M ) =
Ld , so x is in Ld (Contradiction).

2
 Since we derive a contradiction in either case,
we conclude that our assumtion H (M ) = Ld
was wrong, and in fact, there is no such TM
M.

Rules About Complements

Let L and L be a language and its complement
with respect to alphabet 0; 1 .
f g

 If L is recursive, so is L.
✦ Proof: Find a TM M that accepts L by
nal state but always halts. Arrange for a
TM M 0 to simulate M , but accept if and
only if M halts before accepting.
 If L and L are RE, then both are recursive.
✦ Proof: Simulate TM's for both L and L
on separate tracks. One or the other is
guaranteed to accept, so the simulating
TM can always be made to halt.
The Universal Language
Lu = the set of binary strings consisting of a code
for some TM Mi followed by some binary string w,
such that w is in H (Mi ).
 Proof in reader that Lu is RE.
✦ In essence: a TM can be treated as a
stored-program device, just like a real
computer.
✦ Hard part of proof: Since Mi may have
any number of states and tape symbols,
one multitape TM M cannot simulate
these states and symbols directly. Rather,
it represents them as strings of 0's (as
in the code we developed) and compares
using scratch tapes.
 Proof Lu is not recursive: show Lu is not RE.
✦ Remember, if Lu were recursive, then Lu
would be recursive, and therefore RE.
 Proof that Lu is not RE:
✦ A reduction from Ld to Lu : Show that if
there is a TM for Lu , then there is a TM
for Ld (which we know there isn't).
✦ Transform w by rst checking that 1w
represents some TM Mi (i.e., it is of the
form 111codes111). If so, produce 1ww
as input to a hypothetical Lu TM. If not,
reject w, since 1w represents a TM that
accepts everything.
3
 ✦ If 1ww is produced, simulate the Lu TM
on this input. If it accepts, then TM Mi
(represented by 1w) does not accept the
ith string, w, so w is in Ld .

✦ If 1ww is not in Lu , then Mi does accept

w, so w is not in Ld .

 Summary:
✦ Ld is undecidable (not recursive), and in
fact not RE.
✦ Lu is undecidable, but RE.
✦ Lu is like Ld , not RE.
✦ Ld is like Lu , RE, although we did not
prove this.
Rice's Theorem
Essentially, any nontrivial property of the language
of a TM is undecidable.
 Note the dierence between a property of
L(M ) from a property about M :

✦ Example: L(M ) = is a property of the

;

language.
✦ Example: \M has at least 100 states" is a
property of the TM itself.
✦ \= " is undecidable; \has 100 states" is
;

easily decidable, just look at the code for

M and count.

Properties
A property of the RE languages is a set of strings,
those that represent TM's in a certain class.
 Example: the property \is context-free" is the
set of codes for all TM's M such that L(M ) is
a CFL.
 The property is \of languages" if TM's whose
languages are the same either all have the
property or none do.
Proof of Rice's Theorem
Let P be any nontrivial property of the RE
languages; i.e., at least one RE language has the
property, and at least one does not.
 We shall prove that P (as a language, i.e., a
set of TM codes) is undecidable.

4
 Assume does not have property P .
;

✦ If it does, consider P . P is decidable if

and only if P is.
 Suppose P is decidable. Assume L is a
language with property P , and is a language
;

without property P . We can decide Lu

(something we know is impossible) as follows.
✦ Given (M; w), test if w is in H (M ) as
follows. First, we shall construct a TM
N to accept either or L, depending on
;

whether M accepts w.
✦ N simulates M on w. Note that w is
not input to N ; rather N writes w on a
scratch tape and simulates M which is
part of N 's own states.
✦ If M accepts w, N then simulates a TM
ML for language L on N 's own input x.
If ML accepts x then N accepts x.
✦ If M never accepts w, N never gets to
simulate ML , and therefore accepts .;

✦ Feed the constructed N to the

hypothetical P tester. Accept (M; w) if
and only if N has property P .
Consequences of Rice's Theorem
We cannot tell if a TM:
 Accepts .;

 Accepts a nite language.

 Accepts a regular language, a context free
language, etc. etc.
Reductions
To prove a problem P1 to be hard in some sense
(e.g., undecidable), we can reduce P2, a known
hard problem, to P1.
 For each instance w (string in) P2, we
construct an instance x of P2, using some
xed algorithm.
✦ The same algorithm must also turn a
string w that is not in P2 into a string
x that is not in P1.

 We can then argue that if P1 were decidable,

we could use the algorithm in which we
transformed w to x and then tested x for
membership in P1 as a way to decide P2.
✦ Since P2 is undecidable, we have a

5
 contradiction of the assumption P1 is
decidable.
 The same idea works for showing P1 not to
be RE, but now P2 must be non-RE, and
the transformation from instances of P2 to
instances of P1 may be a procedure, not
necessarily an algorithm.
 Common error: trying to do the reduction in
the wrong direction.