Primitive Rec, Ackerman’s Function, Decidable, Undeciable, and Beyond

Exposition by William Gasarch

1 Primitive Recursive Functions

We would like to formally define some notion of “computable functions.” We
attempt to define a set of functions that contains only computable functions,
and contains all of them. This attempt will fail, but the reasons for this are
of interest. In a later section we will succeed.
In this attempt to define “computable functions” we try to use only basic
operations (e.g. the operation “add 1”), and basic ways of putting functions
together (e.g. composition). We do this to make the model as simple as
possible, and to guarantee that all functions generated are computable.

Def 1.1 A function f (x1 , . . . , xn ) is primitive recursive if either:

1. f is the function that is always 0, i.e. f (x1 , . . . , xn ) = 0; This is

denoted by Z when the number of arguments is understood. This rule
for deriving a primitive recursive function is called the Zero rule.

2. f is the successor function, i.e. f (x1 , . . . , xn ) = xi + 1; This rule for

deriving a primitive recursive function is called the Successor rule.

3. f is the projection function, i.e. f (x1 , . . . , xn ) = xi ; This is denoted by

πi when the number of arguments is understood. This rule for deriving
a primitive recursive function is called the Projection rule.

4. f is defined by the composition of (previously defined) primitive recur-

sive functions, i.e. if g1 (x1 , . . . , xn ), g2 (x1 , . . . , xn ), . . ., gk (x1 , . . . , xn )
are primitive recursive and h(x1 , . . . , xk ) is primitive recursive, then

f (x1 , . . . , xn ) = h(g1 (x1 , . . . , xn ), . . . , gk (x1 , . . . , xn ))

is primitive recursive. This rule for deriving a primitive recursive func-

tion is called the Composition rule.

1
 5. f is defined by recursion of two primitive recursive functions, i.e. if
g(x1 , . . . , xn−1 ) and h(x1 , . . . , xn+1 ) are primitive recursive then the fol-
lowing function is also primitive recursive
f (x1 , . . . , xn−1 , 0) = g(x1 , . . . , xn−1 )
f (x1 , . . . , xn−1 , m + 1) = h(x1 , . . . , xn−1 , m, f (x1 , . . . , xn−1 , m))

This rule for deriving a primitive recursive function is called the Re-
cursion rule. It is a very powerful rule and is why these functions are
called ‘primitive recursive.’

To show some function is primitive recursive you build it up from these

rules. Such a proof is called a derivation of that primitive recursive function.
We give some examples of primitive recursive functions. These examples
will be given both rather formally (more formal than is really needed) and
less formally. After these examples we shall always be less formal. The only
reason to give the rather formal definition is to show that it can be done. In
practice the informal one is just as informative (actually more so) and has
the intuition that the formal one sorely lacks.
There are two points these examples are making: (1) LOTS of functions
are primitive recursive. Most functions that you have dealt with in your lives
have been primitive recursive. (2) It isn’t that hard to show that functions
are primitive recursive.

Example 1.2 f (x) = x + 5. Very formally we would say:

1. S(x) = x + 1 is primitive recursive by the successor rule.
2. S(S(x)) is primitive recursive by the composition rule, composing the
function defined in 1 with the function defined in 1.
3. S(S(S(x))) is primitive recursive by the composition rule, composing
the function composed in 2 with the function defined in 1.
4. S(S(S(S(x)))) is primitive recursive by the composition rule, compos-
ing the function defined in 3 with the function defined in 1.
5. S(S(S(S(S(x))))) is primitive recursive by the composition rule, com-
posing the function defined in 4 with the function defined in 1.

2
Informally we would say: f (x) = S(S(S(S(S(x))))) is primitive recursive by
successor and several applications of composition.

Example 1.3 f (x, y) = x + y. Very formally we would say

1. g(x) = π1 (x) = x is primitive recursive by the projection rule.
2. π3 (x, y, z) = z is primitive recursive by the projection rule.
3. S(x) = x + 1 is primitive recursive by the successor rule.
4. h(x, y, z) = S(π3 (x, y, z)) = z + 1 is primitive recursive by the compo-
sition rule and composing S and π3 .
5. Define f using the recursion rule and g, h:
f (x, 0) = g(x) = π1 (x) = x
f (x, n + 1) = h(x, n, f (x, n)) = S(π3 (x, n, f (x, n))) = f (x, n) + 1

Informally, just say

f (x, 0) = x
f (x, n + 1) = f (x, n) + 1

The question arises, “how does one think of these definitions?” The key
point is to think recursively. The thought process for defining plus might be
“Well gee, x + 0 = x, that’s easy enough, and x + (y + 1) = (x + y) + 1, so I
can define x + (y + 1) in terms of x + y.” From that point it should be easy
to see how to formalize that f (x, y) = x + y is primitive recursive.
Now that we have plus is primitive recursive, we can use it to define other
primitive recursive functions. Here we use it to define multiplication.
Example 1.4 f (x, y) = xy is primitive recursive via

f (x, 0) = 0
f (x, y + 1) = f (x, y) + x

3
 Now that we have multiplication is primitive recursive, we use it to define
powers.

Example 1.5 f (x, y) = xy is primitive recursive via

f (x, 0) = 1
f (x, y + 1) = xf (x, y)

Subtraction would be a nice operation to have, but primitive recursive

function only go from N to N. We do have a “truncated subtraction” called
“monus”

Example 1.6 In all the above examples we took a well known function and
showed it was primitive recursive. Here we define a function directly. What
this function does is, if x > 0 then it subtracts 1, otherwise it just returns 0.

f (0) = 0
f (x + 1) = x

To do this formally, recall that in the recursion rule the function h can
depend on x and f (x). Henceforth, call this function M (x).

We now use M to define a version of subtraction.

.
Example 1.7 x y. This function is x − y if x − y ≥ 0, otherwise it is 0.

f (x, 0) = x
f (x, y + 1) = M (f (x, y))

Example 1.8 We can now show that |x − y| is primitive recursive. |x − y| =

(x . y) + (y . x).

4
Fact 1.9 Virtually every function you can think of (primality, finding quo-
tients and remainders, any polynomial) is primitive recursive.

Exercise Define a notion of primitive recursive function from (Σ∗ )n to Σ∗ ,

where Σ = {a, b}. Show that concatenation is primitive recursive. (Although
there are many different ways of doing this, some lead to much cleaner defi-
nitions of concatenation than others. We would like a clean definition.)
Exercise Define a notion of primitive recursive function from the integers to
the integers. Show that subtraction is primitive recursive. (Although there
are many different ways of doing this, some lead to much cleaner definitions
of subtraction than others. We would like a clean definition.)
Exercise Show that there is a JAVA program computing the Successor func-
tions, Projection functions, and the Zero function.
We claim that the set of primitive recursive functions are “computable.”
To back this up, we prove the following

Theorem 1.10 Every primitive recursive function can be computed by a

JAVA program

Proof: We prove this by induction on the formation of a primitive recur-

sive function. More formally, by induction on the number of steps used to
derive the primitive recursive function. (WARNING: the name of the thing
we will be inducting on is m, NOT n as is customary. n will be the number of
arguments of the primitive recursive function being discussed.) BASE CASE:
The only primitive recursive functions that can be derived with only one step
are the functions Si (x1 , . . . , xn ), πi (x1 , . . . , xn ), and Z(x1 , . . . , xn ). These are
all computable by a JAVA program by the Exercise above. INDUCTION
STEP: Let f (x1 , . . . , xn ) be a function that is primitive recursive by a deriva-
tion of m + 1 steps.
If the last rule used in the derivation of f (x1 , . . . , xn ) is either the Zero
rule, Projection rule, or Successor rule then f (x1 , . . . , xn ) is one of those
functions, and thus by the exercise f (x1 , . . . , xn ) is primitive recursive.
If the last rule used was composition then there are functions g1 (x1 , . . . , xn ),
g2 (x1 , . . . , xn ), . . ., gk (x1 , . . . , xn ), h(x1 , . . . , xk ) which are primitive recursive
such that each of those function takes ≤ m steps to derive, and

f (x1 , . . . , xn ) = h(g1 (x1 , . . . , xn ), . . . , gk (x1 , . . . , xn ))).

5
Since each of the gi ’s, and h, take m or less steps to derive, BY THE INDUC-
TION HYPOTHESIS they can be computed by a JAVA program. Using this,
we write a JAVA program for f .
begin
input(x1 , . . . , xn );
output(h(g1 (x1 , . . . , xn ), . . . , gk (x1 , . . . , xn ))) ;
end
This program was easy to write because we already knew we had JAVA
programs for g1 , . . . , gk and h.
We leave the last case, where the last rule was recursion, to the reader as
an exercise. It is not hard.
Is EVERY function that is computed by a JAVA program a primitive
recursive functions? We will show the answer is NO.
Exercise Describe a mapping ρ from N onto the set of all primitive recursive
functions of many variable. The function U (x, y) = ρ(x)(y) should be JAVA
computable. Why do you think I chose the letter U ? (The actual details of
the JAVA code aren’t necessary, just argue that it can be done.)

Theorem 1.11 There exists a function that is computed by a JAVA program

that is not primitive recursive.

Proof: Let ρ and U be the functions defined in the above exercise. We

write a JAVA program for the sole purpose of NOT being primitive recursive.
The idea is that the program’s behavior on x will disagree with the primitive
recursive function ρ(x) on the value x. Since the range(ρ) is the set of ALL
primitive recursive functions, this will suffice.
PROGRAM DIAGONALIZE
begin
read(x);
output(U (x, x) + 1) ;
end
Let F be the function computed by the program DIAGONALIZE. We
show that F is not primitive recursive. Assume, by way of contradiction,
that F is primitive recursive. Then by the definition of ρ there exists an n
such that F is ρ(n). Hence

(∀x)[F (x) = ρ(n)(x) = U (n, x)].

6
In particular, take x = n to get

F (n) = U (n, n).

But by the definition of F via the JAVA program

F (n) = U (n, n) + 1.

This is a contradiction! Hence F is not computed by any primitive recursive

function.
How important is Theorem 1.11? The theorem itself seems to just say that
PRIMITIVE RECURSIVE is not the notion we need, and perhaps some other
notions will suffice. However, the proof of Theorem 1.11 was not particular
to primitive recursive functions, or to JAVA. Any formalism that attempts
to capture all the functions that are computable is going to run into the same
kind of problem (namely, an analog of Theorem 1.11) as primitive recursive
functions did. This is formalized in the following exercise.
Exercise Let {f1 , f2 , f3 , . . .} be a set of functions in one variable. Assume
that the function g(i, x) = fi (x) is JAVA computable. Show that there is a
function h that is JAVA computable, but h is not one of the fi .
How to get around this dilemma? We take this point up in the next
section.
Although the function in Theorem 1.11 is not primitive recursive, it is
contrived. It was defined for the sole purpose of not being primitive recursive
and would not arise in practice. Are there “natural” JAVA computable
functions that are not primitive recursive? We define a JAVA-computable
function which is not primitive recursive which we consider “natural.” Since
naturalness is in the eye of the beholder, you should feel free to disagree as
to the naturalness of the function.

Def 1.12 Ackerman’s function is the function defined by

A(0, y) = y + 1
A(x + 1, 0) = A(x, 1)
A(x + 1, y + 1) = A(x, A(x + 1, y))

7
 It is easy to see that Ackerman’s function is JAVA computable. We will
not prove that it is not primitive recursive, but we give an idea by giving a
list of intuitions:
1. Ackerman’s function grows very fast. It grows faster than any primitive
recursive function.

2. Given a primitive recursive function, its derivation used the recursion

rule some finite number of times.

3. Since Ackerman’s function is defined using a recursion which involves

applying the function to itself there is no obvious way to take the
definition and make it primitive recursive. While this is not a proof, it
is an intuition.

2 General Recursive Functions

The primitive recursive functions were an attempt to pin down formally
what it means for a function to be computable. It failed since we could
construct a program that computed a function that was JAVA-computable
(hence computable) but, not primitive recursive (this was Theorem 1.11).
The proof of Theorem 1.11 was not particular to primitive recursive func-
tions, or to JAVA. As noted after the theorem, any formalism that attempts
to capture all the functions that are computable is going to run into the same
kind of problem (namely, an analog of Theorem 1.11) as primitive recursive
functions did.
How to get around this dilemma? One is to give up our hope of pinning
down the set of functions that are computable and defined everywhere, and
instead be content with looking at the partial functions that are computable.
This also takes care of the problem that JAVA programs don’t always halt.

Def 2.1 A partial function is a function whose domain is a subset of N. A

total function is a function whose domain is N. We denote the domain of a
partial function f by domain(f ).

We will add a basic way of generating one function from another which
will allow functions to not always be defined, yet is basic and is something
that machines can really do. Intuitively, we allow the operation of being

8
able to search for a number without having an a priori bound on what the
number may be (in fact, it might not exist). The resulting set of functions
will be called the General Recursive Functions.
Keep in mind our final goal of showing that this model is very powerful-
many functions will turn out to be general recursive.
Notation 2.2 The symbol µ stands for “least number such that.” We il-
lustrate its use. If g(x) is a function then µx[g(x) = 13] is the least num-
ber x such that g(x) = 13. Note that such a number need not exist, in
which case µx[g(x) = 13] is undefined. If g(x1 , . . . , xn , y) is a function
then f (x1 , . . . , xn ) = µy[g(x1 , . . . , xn , y) = 0] is the function that, on in-
put ha1 , . . . , an i returns the least value of y such that g(ha1 , . . . , an i, y) = 0.
Note that such a number need not exist, in which case f (ha1 , . . . , an i) is
undefined. The function f is called the unbounded minimalization of g.

Example 2.3 Let g(x, y) = x + y. Let

f (x) = µy[g(x + y) = 100].
f (0) = 100, f (1) = 99, . . ., f (99) = 1, f (100) = 0, and f is undefined on all
other values.

Def 2.4 A function f (x1 , . . . , xn ) is general recursive if either

1. f is primitive recursive
2. f is defined by unbounded minimization on a (previously defined) gen-
eral recursive function g(x1 , . . . , xn , y), i.e. there is a general recursive
function g and
f (x1 , . . . , xn ) = µy[g(x1 , . . . , xn , y) = 0].

Def 2.5 The general recursive functions are also called the partial com-
putable functions. The subset of the partial computable functions that are
total are called the total computable functions, or just the computable func-
tions. The term “general recursive” will not be used again in this course, but
is included for historical purposes.
We will later see that general recursive functions are very powerful.

9
3 Turing Machines
We will now take a different approach to pinning down what is meant by
“computable.” This definition is motivated by actual computers and resem-
bles a machine. The definition is similar to that of a Deterministic Finite
Automaton, or Push Down Automaton, but it can do much much more.
Keep in mind that our final goal is to show that this model can compute a
lot of functions.
We first give the formal definition, and then explain it intuitively.

Def 3.1 A Turing Machine M is a quintuple (Q, Σ, δ, q0 , h) where

1. Q is a finite set of states

2. Σ is the alphabet (the function computed by the Turing Machine will

go from Σ∗ to Σ∗ ), It contains a special symbol B which stands for
BLANK.

3. δ is the next move function, it goes from (Q − {h}) × Σ to Q × {Σ ∪

{L, R}}

4. q0 ∈ Q is the start state

5. h ∈ Q is the halting state

The machine acts in discrete steps. At any one step it will read the symbol
in the “tape square”, see what state it is in, and do one of the following:
1. write a symbol on the tape square and change state,

2. move the head one symbol to the left and change state,

3. move the head one symbol to the right and change state.
We now formally say how the machine computes a function. This will be
followed by intuition.

Def 3.2 Let M be a Turing Machine. An Instantaneous Description (ID)

of M is a string of the form α1 qα2 where α1 , α2 ∈ Σ∗ , q ∈ Q, and the last
symbol of α2 is not B. Intuitively, an ID describes the current status of the
TM and Tape.

10
Def 3.3 Let M be a Turing Machine. Let α1 , α2 , α3 , α4 ∈ Σ∗ , and q, q 0 ∈ Q.
Let α1 = x1 x2 · · · xk , and α2 = xk+1 xk+2 · · · xn . The symbol α1 qα2 `M α3 q 0 α4
means that one of the following is true:

1. δ(q, xk ) = (q 0 , y), α3 = x1 x2 · · · xk−1 y and α4 = α2 .

2. δ(q, xk ) = (q 0 , L), α3 = x1 x2 · · · xk−1 and α4 = xk xk+1 · · · xn .

3. δ(q, xk ) = (q 0 , R), α3 = x1 x2 · · · xk+1 and α4 = xk+2 xk+3 · · · xn .

Intuitively, the above definition is saying that if the Turing Machine is in

ID C, and C `M D, then after one more move the TM will be in D. The
next definition is about what will happen after many moves.

Def 3.4 If C and D are IDs then C `∗M D means that either C = D or there
exist a finite set of IDs C1 , C2 , . . . , Ck such that C = C1 , for all i, Ci `M Ci+1 ,
and Ck = D.

Def 3.5 Let M be a Turing Machine. Recall that the partial function com-
puted by Turing Machine M is the following partial function: f (x) is the
unique y (if it exists) such that xq0 `∗M yh. If no such y exists then M (y) is
said to diverge.

Intuitively we start out with x laid out on the tape, and the head looking
at the rightmost symbol of x. The machine then runs, and if it gets to the
halt state with the condition that there are only blanks to the right of the
head, then the string to the left of the head is the value f (x).
For examples of Turing machines, and exercises on building them to do
things, see Lewis and Papadimitriou’s text “Elements of the Theory of Com-
putation.”, or the Hopcroft-Ullman White book. Other books also contain
this material.
Note that, just like a computer, the computation of a Turing machine is
in discrete steps.

Def 3.6 Let Me be a Turing Machine and s be a number. The partial

function computed by Me,s is the function that, on input x, runs Me (x) for
s steps and if it has halted by then, outputs whatever Me (x) output, else
diverges.

11
 Note that the function computed by Me,s is intuitively computable. Al-
though it is a partial function we can tell when it will be undefined so we
can think of it as being total.

Notation 3.7 If M (y) is defined we write M (y) ↓. If M (y) diverges then

we write M (y) ↑.

4 Variations of a Turing Machine

There are many variations on Turing Machines that could be defined- allow-
ing extra tapes, extra heads, allowing it to operate on a two dimensional grid
instead of a one dimensional tape, etc. All of these models end up being
equivalent. This adds to the intuition that Turing Machines are powerful.

Def 4.1 A k-tape Turing Machine is a quintuple (Q, Σ, δ, q0 , h) such that Q,

Σ, q0 , and h are as in a normal Turing Machine, but δ is a function from
(Q − {h}) × Σk into Q × {Σ ∪ {L, R}}k . A configuration is a k-tuple of
strings of the form αqβ where q ∈ Q, α, β ∈ Σ∗ the last symbol of β is not B
(where B is the special blank symbol), and all the q in all the tuples are the
same. If the input is x then the standard initial configuration is formed by
assuming that x is on the first tape, the head on the first tape is pointing to
the rightmost symbol of x, and on all other tapes the head is at the leftmost
symbol of the tape.

It turns out that extra tapes do not increase power.

Theorem 4.2 If f can be computed by a k-tape Turing Machine then f can

be computed by an ordinary Turing Machine.

A careful analysis of the proof of the above theorem reveals that the 1-
tape machine is not that much more inefficient then the equivalent 2-tape
machine. In particular, we have actually shown that if the 2-tape machine
halts on inputs of length n in T (n) steps, then the 1-tape machine will halt, on
inputs of length n, in T (n)2 steps. While this is not important for recursion
theory, it will be a significant fact in complexity theory. The best known
simulation of a multitape Turing Machine by a fixed number of tape machine
is that any function f that can be computed by k-tape Turing Machine in

12
T (n) steps on inputs of length n can be computed by a 2-tape machine in
T (n) log T (n). (See Hopcroft-Ullman, the White book.)
Other enhancements to a Turing Machine such as extra heads, two-
dimensionality, allowing a 2-way infinite tape, do not add power. Note that
a Turing Machine with many added features resembles an actual computer.
Exercise Discuss informally how to convert various variants of a Turing
Machine to a 1-tape 1-head 1-dim Turing Machine. Comment on how runtime
and number of states are affected.

5 Godelization
By using variations of Turing Machines it would not be hard to show that
standard functions such as addition, multiplication, exponentiation, etc. are
all computable by Turing Machines. We wish to examine functions that, in
some sense, take Turing Machines as their input. In order to do this, we must
code machines by numbers. In this subsection we give an explicit coding and
its properties. The actual coding is not that interesting or important and
can be skipped, but should at least be skimmed to convince yourself that it
really can be carried out. The properties of the coding are very important. A
more abstract approach to this material would be to DEFINE a numbering
system as having those properties. We DO NOT take this approach, but will
discuss it at the end of this section.

Def 5.1 A Godelization is an onto mapping from N to the set of all Turing
Machines such that given a Turing Machine, one can actually find the number
mapped to, and given a number one can actually find the Turing Machine
that maps to it.

We define a Godelization. Let M = (Q, Σ, δ, q0 , h) be a Turing Machine.

We assume the following:

• there are n + 1 states labeled 1,2,3,. . . , n + 1,

• state n + 1 is the halting state,

• the alphabet is the numbers 3,4,5. . . , m.

13
 • L, R are represented by the numbers 1 and 2. (We still denote L and
R by L and R. Note that L and R have numbers different from those
in the alphabet.)
We first show how to encode a rule as a number:
Let q1 , q2 ∈ Q and σ1 , σ2 ∈ Σ. (By our convention, q1 , q2 , σ1 , σ2 are
numbers). The rule
δ(q1 , σ1 ) = (q2 , σ2 )
is represented by the number 2q1 3σ1 5q2 7σ2 . The representations for rules that
have L or R in the last component are defined similarly. In any case we
denote the rule that says what δ(q, σ) does by c(q, σ).
We now code the entire machine M as a number. Let pi denote the ith
prime. Let h−, −i be such that the map (i, j) → hi, ji is a bijection from
N × N to N which is computable by a Turing Machine. The Turing Machine
M is coded by the number
m
n Y
Y c(i,j)
C(M ) = phi,ji
i=1 j=1

With our current coding, although all Turing Machines correspond to

numbers, not all numbers correspond to Turing Machines. We alleviate this
by convention:

Def 5.2 Turing Machine Mi is the machine corresponding to number i, if

such a machine exists, and is the machine ({q}, {a}, δ, q, q) where δ(q, a) =
(q, a), (i.e. the easiest machine that halts on all inputs) otherwise. The
function computed by Mi is denoted ϕi We may also say that i is the index
of Mi or ϕi .

It is easy to see that a program could be written to, given a Turing

Machine M , find x such that M = Mx . (We will later be assuming that a
Turing Machine could carry out such a task). It is also easy to see that a
program could be written to, given a number x, determine Mx .
The number x codes all the information about Mx that one might wish
to know.
Exercise Informally show that the following functions are computable:
• Given x, determine the number of states in Mx .

14
 • Given x, determine the number of symbols in the alphabet of Mx .

• Given numbers x, y, s, determine if Mx halts on y in less than s steps.

• Given numbers x and y, produce the code for the Turing Machine that
computes the composition of the functions computed by Mx and My .
Our coding has some very nice properties that we now state as theorems.
There is nothing inherently good about the coding we used, virtually any
coding one might come up with has these properties. The properties essen-
tially say that we can treat the indices of a Turing Machines as though they
were programs. We will be using these theorems informally, without explicit
reference to them, for most of this course.

Theorem 5.3 (s-1-1 Theorem) There exists a primitive recursive function

s1-1 such that for all x, y, and z

Mx (y, z) = Ms1-1 (x,y) (z)

Intuitively this is saying that parameters and code are interchangeable. If

JAVA was being used instead of Turing Machines, the s-1-1 function would
merely be replacing a READ statement with a CONST statement.
The above theorem is better known in its generalized form:
Theorem 5.4 (s-m-n Theorem) For every m and n there exists a primitive
recursive function sm-n such that for all x, hy1 , . . . , yn+1 i, and hz1 , . . . , zm i

Mx (hy1 , . . . , yn+1 i, hz1 , . . . , zm i) = Msm−n (x,hy1 ,...,yn+1 i) (hz1 , . . . , zm i)

.
Both the s-1-1 theorem and the s-m-n theorem are proven by actually
constructing such functions. These constructions were of more interest when
they were proven than they are now, since now the notion of treating data
and parameters the same has been absorbed into our culture.
The next theorem says that there is one Turing Machine that can simulate
all others. It is similar to a mainframe: you feed it programs and inputs, and
it executes them.

15
Theorem 5.5 (Universal Turing Machine Theorem, or Enumeration Theo-
rem) There is a Turing Machine M such that M (x, y) is the result of running
Mx on y. (Note that this might diverge.)

Convention 5.6 We will always denote the Universal Turing Machine by

U.

We will be using the s-m-n Theorem and the existence of a Universal

Turing Machine, throughout this course (usually implicitly). A more abstract
approach would have been to build these two properties into definitions:

Def 5.7 An acceptable programming system (henceforth APS) is a list of all

the Turing computable functions ϕ1 , ϕ2 , . . . such that the s-m-n Theorem,
and the enumeration theorem are true relative to that numbering.

One concern might be that if we prove theorems for our particular APS
will it be true for all APS’s. The following theorem says YES, as it says that
all APS’s are essentially the same.

Theorem 5.8 (Rogers isomorphism theorem) Let ϕ1 , ϕ2 , . . . and φ1 , φ2 , . . .

be two APS’s. There exists a bijection f , computable by a Turing Machine,
such that ϕi ≡ φf (i) .

6 Other Models and the Moral of the Story

Many models of computation have been proposed. All of them have a notion
of discrete time steps, as does a Turing Machine.

1. Turing Machines were proposed by Alan Turing in 1936.

2. λ-calculus was proposed by Alonzo Church in 1941. The λ-calculus

enables one to speak of functions from sets of functions to sets of func-
tions. The language LISP is based on λ-calculus.

3. post Systems were proposed by Emil Post in 1943. They are a gener-
alization of Grammars.

4. Wang machines were proposed by Hao Wang in 1957.

16
 5. Markov Algorithms were proposed by Andrei Andreivich Markov in the
1940’s.

6. register machines were proposed by Abraham Robinson and Calvin

Elgot in the 1960’s, and Random Access Machines were proposed by
Steven Cook and Robert Rechow in the 1970’s. Both resemble an actual
computer more than most models.
These models of computation had very different motivations. Now for
the surprise: THEY ALL COMPUTE THE SAME CLASS OF (PARTIAL)
FUNCTIONS! In addition, the time loss in going from one to the other is
(in most cases) only a polynomial e.g. if a Markov algorithm can compute a
function f and use T (n) steps on inputs of length n, then there is a Turing
Machine that can computes f and takes T (n)k steps on inputs of length n.
We have been trying to formalize what it means for a function to be
“intuitively computable.” This seems like a hard concept to define rigorously.
But several people who tried to formalize this notation came to the SAME
class. This leads one to make a leap of faith and conclude that yes indeed,
this class of functions suffices:
Church’s Thesis: Any (partial) function that is intuitively computable (e.g.
we can write down a program for it in some informal language) is computable
by a Turing Machine (thus by the λ-calculus, etc.).
For the remainder of this course we will speak in terms of Turing Ma-
chines, but will virtually never have to worry about the formal details of
a machine. To show a function is computable we will write an informal
program that computes it, and show that it works.
We repeat two definitions that we made earlier, noting that in both the
term “Turing Machine” can be replaced by any of the above models.

Def 6.1 A function computed by a Turing Machine is a partial computable

function. If the function is total then we say it is computable.

We now give examples of computable functions.

1. f (x) is the xth prime, computable.

2. f (x) = x7 + 12x5 , computable.

3. Ackerman’s function is computable.

17
 4. Any JAVA program that halts on all inputs you can think of is com-
puting a computable function.
We give an interesting example of a partial computable function. We
want a function that will, on input e, output some PRIME that Me halts on.
If Me does not halt on any prime, then the function will be undefined.
First attempt (which will fail): run Me (2). If it halts then output 2, else
run Me (3). If it halts then output 3, else run Me (5). This will not work since
you cannot tell if Me (2) halts.
So what to do?
Well, we can try to run Me (2) for a few steps, then try Me (3) for a few
steps, then go back to Me (2) and try out various other primes as we go.
We try Me (p) for s steps for many primes p and numbers s. This process
is known as DOVETAILING. Before presenting the formal algorithm we’ll
need pairing functions.
Def 6.2 Let π1 and π2 be computable function such that the set {(π1 (x), π2 (x)) :
x ∈ N} is all of N × N.
Algorithm for f :
1. Input(e)
2. i := 1
FOUND := FALSE
While NOT FOUND
x := π1 (i)
s := π2 (i)
Run Me (x) for s steps.
If x is prime and Me (x) halts within s steps then
output(x)
FOUND := TRUE
else i := i + 1
The algorithm looks at ALL possible pairs (x, s) and if we find that Me (x)
halts in s steps, and x is prime, then we halt. Note that if Me halts on SOME
prime then f (x) will be such a prime; however, if Me does not halt on any
prime, then the algorithm will diverge (as it should).

18
7 Some strange examples of computable func-
tions
Functions that are almost always 0 are very easy to compute: just store a
table.

Example 7.1 Let f be the function that is f (0) = 12, f (10) = 20, f (14) =
7, f is zero elsewhere. The function f is easily seen to be computable. Just
write a program with a lot of ‘if’ statements in it. It will output 0 on values
that are not 0,10, or 14.

In the above example, the function f was given EXPLICITLY so it was

easy to write the program. Even if a function is not given to us explicitly,
we may be able to show that it is computable.

Example 7.2 Let f be the function that is nonzero on values less than 10,
and on those values always outputs the input squared. From the description
we can deduce that f (1) = 1, f (2) = 4, f (3) = 9, f (4) = 16, f (5) = 25,
f (6) = 36, f (7) = 49, f (8) = 64, f (9) = 81, and f is zero elsewhere.

In the above example, even though we were not given the function ex-
plicitly, we could derive an explicit description from what was given. In the
next example this is no longer the case, but the function is still computable.
INTERESTING EXAMPLE
One needs to know what the Goldbach Conjecture to appreciate this
example: Goldbach’s conjecture is still unknown. It is: every even is the
sum of two primes.

Example 7.3 Let f be the function such that if Goldbach’s conjecture is

true then f is 74 on all numbers less than 4 and zero elsewhere, and if Gold-
bach’s conjecture is false then f is 17 on all less than 3 and zero elsewhere.
Since we don’t know whether or not Goldback’s Conjecture is true, WE DO
NOT KNOW what f is. But we DO know that EITHER

1. f (1) = 74, f (2) = 74, f (3) = 74, f (x) = 0 elsewhere, OR

2. f (1) = 17, f (2) = 17, f (x) = 0 elsewhere.

19
So THERE EXISTS a JAVA program for f . In fact, we can write down two
programs, and know that one of them computes f , but we don’t know which
one. But to show that f is computable WE DO NOT CARE WHICH ONE!
The definition of computability only said THERE EXISTS a JAVA program,
it didn’t say we could find it.

An even more interesting example:

Example 7.4 Let f be the following function: if Goldbach’s conjecture is

false then f is 888 on the the smallest even n such that n cannot be written
as the sum of two primes, and 0 elsewhere. if Goldbach’s conjecture is true
then f is always 0. If Goldbach’s conjecture is false then f is one of the
following.

1. f (2) = 888, f is zero elsewhere

2. f (4) = 888, f is zero elsewhere

3. f (6) = 888, f is zero elsewhere

.
4. etc. ..

The fact that this list is infinite should not bother us. It is still the case
that f is computable since one of the functions on this list is f , or f is always
0.

These functions are computable EVEN THOUGH WE CAN”T FIND

CODE FOR THEM.
If I asked you what a computable function was you might say
f is computable if there exists a TURING MACHINE to compute it.
I might say
f is computable if THERE EXISTS a Turing machine to compute it.
The key thing is that THERE EXISTS a Turing machine, even if I can’t
find it.
AN EXAMPLE OF ‘I DO NOT KNOW AND I DO NOT CARE’, that
is not related to computer science:
Example 7.5 Do there exists two irrational numbers x and y such that xy
is rational? I will show you pairs (a, b), and (c, d) such that either

20
 1. a and b are irrational and ab is rational, OR

2. c and d are irrational and cd is rational.

Even at the √ end of the√proof I won’t

√ √2know which
√ pair works. √
Let a = 2, √ b =√ 2, c = ( 2) , d = 2. We already √ 2 know
√
that 2
2
is irrational. If ( 2) is rational, then (a, b) works. If ( 2) is irrational
then c is irrational, d is irrational, and
√ √ √ √
cd = (( 2)( 2) ) 2 = ( 2)2 = 2
√ √
so the pair (c, d) works. I DO NOT KNOW whether or not ( 2) 2 is irra-
tional, but in either case, I get what I want, so for now I DO NOT CARE.

8 Computable and Computably Enumerable

Sets
Up to this point we have been speaking of functions. Sets are easier to study
and more flexible. Most of the rest of the course will be about sets.

Def 8.1 A set A is computable if there exists a Turing Machine M that

behaves as follows:
1 if x ∈ A,

M (x) =
0 if x ∈/ A.
Computable sets are also called decidable or solvable. A machine such as M
above is said to decide A.

Some examples of computable sets.

1. The primes.

2. The Fibaonoacci numbers (any number in the set 1, 2, 3, 5, 8, 13, ...

where every number is the sum of the previous number). If you want
to know if a number x is a Fib number, just calculate the Fib num-
bers until you either spot x or surpass it. If you spot it then its a Fib
number, if you surpass it, its not.

3. (x, y, s) such that Mx (y) halts within s steps.

21
 4. Most sets you can think of are computable.

Are there any noncomputable sets? Cheap answer: The number of SETS
is uncountable, the number of COMPUTABLE SETS is countable, hence
there must be some noncomputable sets. In fact, there are an uncountable
number of them. I find this answer rather unenlightening.

9 The HALTING Problem

In this subsection we exhibit a concrete example of a set that is r.e. but not
computable. Recall that Mx is the xth Turing Machine in the Godelization
defined earlier.

Def 9.1 The HALTING set is the set

K0 = {hx, yi | Mx (y) halts }.

Let us ponder how we would TRY to determine if a number hx, yi is in

the halting set. Well, we could try RUNNING Mx on y. If the computation
halts, then GOOD, we know that hx, yi ∈ K0 . And if it doesn’t halt then –
WHOOPS– if it never halts we won’t know that!! It seems hard to determine
with certainty that the machine will NOT halt EVER.

Theorem 9.2 The set K0 is not computable.

Proof:
We show that K0 is NOT computable, by using diagonalization. Assume
that K0 is computable. Let M be the Turing Machine that decides K0 . Using
M we can easily create a machine M 0 that operates as follows:
0 if Mx (x) does not halt,

0
M (x) =
↑ if Mx (x) does halt.

Since M 0 is a Turing Machine, it has a Godel number, say e, so Me = M 0 .

We derive a contradiction by seeing what Me does on e.
If M 0 (e) ↓ then by the definition of M 0 , we know that Me (e) does not
halt, but since M 0 = Me , we know that Me (e) does halt. Hence the scenario
that M 0 (e) ↓ cannot happen. (This is not a contradiction yet)

22
 If M 0 (e) ↑ then by the definition of M 0 , we know that Me (e) does halt’;
but since M 0 = Me , we know that Me (e) does not halt. Hence the scenario
that M 0 (e) ↑ cannot happen. (This alone is not a contradiction)
By combining the two above statements we get that M 0 (e) can neither
converge, nor diverge, which is a contradiction.
This proof may look unmotivated— why define M 0 as we did? We now
look at how one might have come up with the halting set if one’s goal was
to come up with an explicit set that is not decidable:
We want to come up with a set A that is not decidable. So we want that
M1 does not decide A, M2 does not decide A, etc. Let’s make A and machine
Mi differ on their value of i. So we can DEFINE A to be

A = {i | Mi (i) 6= 1}.

This set can easily be shown undecidable— for any i, Mi fails to decide it
since A and Mi will differ on i. But looking at what makes A hard intuitively,
we note that the “6= 1” is a red herring, and the set

B = {i | Mi (i) ↓}

would do just as well. This is essentially the Halting problem.

Corollary 9.3 The set K = {e | Me (e) ↓} is undecidable.

Proof: In the proof of Theorem 9.2, we actually proved that K is unde-

cidable.

Note 9.4 In some texts, the set we denote as K is called the Halting set.
We shall later see that these two sets are identical in computational power,
so the one you care to dub THE halting problem is not important. We chose
the one we did since it seems like a more natural problem. Henceforth, we
will be using K as our main workhorse, as you will see in a later section.

10 Computablely Enumerable Sets

K0 and K are not decidable. Well, what CAN we say about K0 that is
positive. Lets look back at our feeble attempt to solve K0 . The algorithm

23
was: on input x, y, run Mx (y) until it halts. The problem was that if hx, yi ∈
/
K0 then the algorithm diverges. But note that if (x, y) ∈ K0 then this
algorithm converges. SO, this algorithm DOES distinguish K0 from K 0 .
But not quite in the way we’d like. The following definition pins this down

Def 10.1 A set A is computablely enumerable (henceforth “r.e.”) if there

exists a Turing Machine M that behaves as follows:
↓ if x ∈ A,

M (x) =
↑ if x ∈
/ A.
Exercise Show that K and K0 are r.e.
Exercise Show that if A and B are computable then A ∩ B, A ∪ B, and A
are computable. Which of these are true for r.e. sets?
There is a definition of r.e. that is equivalent to the one given, and is
more in the spirit of the words “computablely enumerable.”

Theorem 10.2 Let A be any set. The following are equivalent:

1. A is the domain of a partial computable function (i.e. A is r.e.)

2. A is the range of a total computable function or A = ∅ (this definition

is more like enumerating a set).

Proof: We show 1) → 2) → 1).

1) → 2): Let A be the domain of a partial computable function f . Let M
be a Turing Machine whose domain is A. If A is empty, then 2) is established.
Assume that A is nonempty and let a ∈ A. Let g be the (total) computable
function computed by the following algorithm:

1. Input(n).

2. If n = 0 then output a.

3. Compute X = {g(0), g(1), g(2), . . . , g(n − 1)}.

4. Let Y = {0, 1, 2, . . . , n}. If Y − X is empty then output a. If Y − X is

not empty then run M on every element of Y − X for n steps. If there
is some y ∈ Y − X such that M (y) halts within n steps then output
the least such y. Else output a.

24
We show that range(g) =domain(f ). If y is in the range of g then it must be
the case that M (y) halted, so y is in the domain of f . If y is in the domain of
f then let n be the least number such that M (y) halts in n steps and y ≤ n.
If there is some m < n such that g(m) = y then we are done. Otherwise
consider the computation of g(n). In that computation y ∈ Y but might
not be output if there is some smaller element of Y . The same applies to
g(n + 1), g(n + 2), . . .. If there are z elements smaller than y in A then one
of g(n), g(n + 1), . . . , g(n + z) must be y.
2) → 1). Assume that A is either empty or the range of a total computable
function. If A is empty then A is the domain of the partial computable
function that always diverges, and we are done. Assume A is the range of
a total computable function f . Let g be the partial computable function
computed by the following algorithm:

1. Input(n).
2. Compute f (0), f (1), . . . until (if it happens) you discover that there is
an i such that f (i) = n. If this happens then halt. (if it does not, then
the function will end up diverging, which is okay by us).

We show that an element n is in the range of f iff g(n) halts. If n is in the

range of f then there exists an i such that f (i) = n; this i will be discovered
in the computation of g on n, so g(n) will be 1. If g(n) halts then an i was
discovered such that f (i) = n, so n is in the range of f .

Several questions arise at this point:

• Are there any sets that are r.e. but not computable?
• Are there any sets that are NOT r.e.?
• If a set is r.e., then is its complement r.e. ?
The second question can be answered in a cheap way: since there are an
uncountable number of sets and a countable number of r.e. sets (since there
are only a countable number of Turing Machines), there are an uncountable
number non-r.e. sets. While this is true, it is not a satisfying answer. We
will give more concrete answers to all these questions.
First we relate r.e. and computable sets.

25
Theorem 10.3 A set A is computable iff both A and A are r.e.
Proof: If A is computable then A is computable. Since any computable
set is r.e. both are r.e.
Assume A and A are r.e. Let Ma be a Turing Machine that has domain
A and Mb be a Turing Machine that has domain A. The set A is computable
via the following algorithm: on input x run both Ma (x) and Mb (x) simul-
taneously; if Ma (x) halts then output YES, if Mb (x) halts then output NO.
Since either x ∈ A or x ∈ A, one of these two events must happen.
This theorem links two of our questions: there exists an r.e. set that is
not computable iff r.e. sets are not closed under complementation.

10.1 Undecidable problems that are NOT based on

Turing Machines
All the undecidable problems encountered so far have been sets or functions
that deal with Turing machines. The question arises, are there any “NATU-
RAL” undecidable problems. One could argue that HALT actually is natural,
but we seek problems that do not mention Turing machines.
There are some such problems. The proofs that they are unsolvable usu-
ally entail showing that a Turing machine computation can be coded into
them. However they are, on the face of it, natural. We list them but do not
give proofs.
1. POST’S CORRESPONDENCE PROBLEM. Let Σ be a finite alpha-
bet.
INPUT: A = {α , . . . , α }, B = {β , . . . , β } where α , β ∈ Σ∗ .
1 n 1 n i j

OUTPUT: YES if there is a word w and an integer m such that w can

be formed out of m symbols of A (repeats allowed), and also out of m
symbols in B (repeats allowed). NO otherwise. (Formally we say YES
if there exists m, i1 , . . . , im , j1 , . . . jm such that
αi1 αi2 · · · αim = βi1 βi2 · · · βim

2. HILBERT’S TENTH PROBLEM. Given a polynomial in many vari-

ables p(x1 , . . . , xn ) with integer coefficients, does there exist integers
a1 , . . . , an such that p(a1 , . . . , an ) = 0.

26
 3. HILBERT’S TENTH PROBLEM (improvements) Given a polynomial
in just 13 variables p(x1 , . . . , x13 ) with integer coefficients, does there
exist integers a1 , . . . , a13 such that p(a1 , . . . , a13 ) = 0.

4. CFG UNIV. Given a Context Free Grammar, does it generate EVERY-

THING.

5. CFG EQUIV. Given two Context Free Grammars, do they generate

the same set?

6. CFG NON-EMPTYNESS. Given a Context Free Grammar, does it

generate any strings?

7. OPTIMAL DPDA PROBLEM Given a Push Down Automata for a

language, and promised that the language is actually recognizable by
a deterministic Push Down Automata, find the size of the smallest
Deterministic Push Down Automaton that will recognize it.

8. WORD PROBLEM FOR GROUPS (If you do not understand this

problem do not worry, the point is that there are unsolvable problems
in a branch of math called Group theory, which is NOT a branch of
Logic or Recursion Theory.) Given a group by generators and relations,
and then given a word, is it the identity?

9. TRIANGULATION PROBLEM FOR MANIFOLDS (Even if you do

not understand this problem the point is that there are undecidable
problems in Geometry.) Given two triangulations of four-dimensional
manifolds, are those manifolds homeomorphic?

11 Sets that are even harder than HALT

Are there sets that are even “harder to decide” then HALT? We first say
what this means formally:

Def 11.1 If A ≤T B, but B 6≤T A, then B is harder than A.

In this section we exhibit sets that are harder than K but do not prove
this.

27
 Recall that K can be written as

K = {e | (∃s)Me (e) halts in s steps }.

Note that we have one quantifier followed by a COMPUTABLE statement.

How can T OT be written:

T OT = {e | (∀x)(∃s)Me (x) halts in s steps}.

This is two quantifiers followed by a computable statements.

It turns out that T OT cannot be written with only one quantifier and
is harder than K. We can classify sets in terms of how many quantifiers it
takes to describe them. Adjacent quantifiers of the same type can always be
collapsed into one quantifier.

Def 11.2 Σn is the class of all sets A that can be written as

A = {x | (∃y1 )(∀y2 ) · · · (Qyn )R(x, y1 , y2 , . . . , yn )},

where R is a computable relation and Q is ∃ if i is odd, and ∀ if i is even.

Def 11.3 Πn is the class of all sets A that can be written as

A = {x | (∀y1 )(∃y2 ) · · · (Qyn )R(x, y1 , y2 , . . . , yn )},

where R is a computable relation and Q is ∀ is i is odd, and ∃ if i is even.

Def 11.4 A set is Σn -complete if A ∈ Σn and for all sets B ∈ Σn , B ≤m A.

We now state a theorem without proof.

Theorem 11.5 For every i there are sets in Σi −Πi , there are sets in Σi+1 −
Σi , there are Σi -complete sets, and there are Πi -complete sets.

Exercise (You may use the above Theorem.) Show that a Σi -complete set
cannot be in Πi .
Exercise Show that K is Σ1 -complete. Show that K is Π1 -complete.
Exercise Show that if A is Πi -complete then A is Σi -complete.

28
 We show that F IN (the set of indices of Turing machines with finite
domain) is in Σ2 and that COF (the set of Turing machines with cofinite
domains) is in Σ3 . It turns out that F IN is Σ2 -complete, and COF is Σ3 -
complete, though we will not prove this. As a general heuristic, whatever
you can get a set to be, it will probably be complete there.

F IN = {e | (∃x)(∀y, s)[ If y > x then Me,s (y) ↑}

COF = {e | (∃x)(∀y)(∃s)[ If y > x then Me,s (y) ↓}

29