Models of Computation

Models of Computation

Bengt Nordstrom,
Department of Computing Science,
Chalmers and University of Goteborg,
Goteborg, Sweden

1
1.1

November 17, 2009

The primitive recursive functions

Intuitive syntax and semantics

In informal mathematical notation we often define the addition function in the

following way:
0+n=n
m0 + n = (m + n)0
We have used the notation m0 for the successor of the number m. In a functional
language we can use a similar definition:
add 0 n = n
add (s m) n = s (add m n)
We know that this is a meaningful definition since the addition function for the
argument s n is defined using the value of the function for the argument n. This
kind of recursion is well defined since n is smaller than s n. The recursion scheme
is called primitive recursion.
In the simple case that the function being defined has only one argument the
scheme looks like:
f (0) = g
f (y + 1) = h(y, f (y))
where g is a natural number and h is a given primitive recursive function of two
arguments. We notice that in order to define what a primitive recursive function
of one argument is, we have to know what a primitive recursive function of two
arguments is. We therefore have to generalize and define what a primitive function
of n + 1 arguments (for all n) is:
f (0, j1 , . . . , jn ) = g(j1 , . . . , jn )
f (y + 1, j1 , . . . , jn ) = h(y, f (y, j1 , . . . , jn ), j1 , . . . , jn )
where the functions g and h are given primitive recursive functions (of n and n+2
arguments, respectively.
This class of functions is an early example of a computation model, a mathematical model of a computing device (a programming language or a computer).

Models of Computation

Models of Computation

z PRF0
s PRF1
pn (i) PRFn+1 if i n
comp(g, f1 , . . . , fm ) PRFn if g PRFm , fi PRFn , 1 i m
rec(g, h) PRFn+1 if g PRFn , h PRFn+2
Figure 1: Informal syntax

We will give the model by giving a precise description of the syntax and semantics
of the primitive recursive functions.
Let PRFn express the set of all primitive recursive functions of arity n (i.e.
with n arguments). We assume that n N, i.e. we allow the number of arguments to be 0. The intutition is that each program p PRFn denotes a primitive
recursive function f in the set Nn N. We will construct the class by using the
five simple program forming operations showed in figure 1. The simple programs
are z, s och pn (i) and the composite programs are comp and rec. The program
z (which takes no argument) computes always to 0. The program s stands for
the successor function, it adds 1 to its input. The program pn (i) computes to its
(i + 1)-th argument. The program comp(g, f1 , . . . fn ) is a generalization of the
usual functional composition g f . Finally, the program rec(g, h) expresses the
scheme for primitive recursion. The intuitive semantics is shown in figure 7. We

z[] = 0
s[j] = j + 1
pn (i)[j0 , . . . , jn ] = ji
comp(g, f1 , . . . , fm )[j1 , . . . , jn ] = g[f1 [j1 , . . . , jn ], . . . , fm [j1 , . . . , jn ]]
rec(g, h)[0, j1 , . . . , jn ] = g[j1 , . . . , jn ]
rec(g, h)[y + 1, j1 , . . . , jn ] = h[y, rec(g, h)[y, j1 , . . . , jn ], j1 , . . . , jn ]
Figure 2: Informal semantics

notice that we have given the semantics of the programs by telling what value the
programs get when we apply them to an arbitrary input (which in this case always
is a list of natural numbers).
Notice that there are no variables in this model. Instead the projection opera-

Models of Computation

Models of Computation

tion is used. It takes some time to get used to write programs without variables,
we will show some examples in the following section. It can be skipped in the
first reading of this chapter.
1.1.1

The predecessor function in PRF

The predecessor function pred is defined by the following equations:

pred(0) = 0
pred(n + 1) = n
How can we express this in PRF? It seems natural to guess that the general shape
of pred is
pred =def rec(g, h)
where g and h are placeholders for unknown programs. We know that the arity of
pred is 1, this means that g must have arity 0 and h arity 2. From the first equation
for pred it follows that
g =def z
From the second clause it follows that pred(n + 1) = h[n, p(n)], which is
equal to n if we define
h =def p1 (0)
Hence we can define
pred =def rec(z, p1 (0))
1.1.2

The factorial function.

The factorial function is the function factorial(n) = 1 2 n, or if we put it

on primitive recursive form:
factorial(0) = 1
factorial(n + 1) = (n + 1) factorial(n)
Let us try with
factorial =def rec(g, h)
where g PRF0 and h PRF2 . We must have that g[] = 1, which is satisfied if
g =def comp(s, [z]).

Models of Computation

Models of Computation

We know that the following holds for the program h:

f [n + 1] = rec(g, h)[n + 1]
= h[n, f (n)]
= (n + 1) f (n)
Hence, we want to construct a program h in PRF2 such that h[n, f (n)] = (n +
1) f (n). This is fulfilled if h satisfies h[n, m] = mul[n + 1, m], where mul is a
program for multiplication (this can also be expressed in PRF).
Let us try to define h by
h = comp(mul, [e1 , e2 ])
for some (yet unknown) programs e1 and e2 . We know that the following must
hold:
comp(mul, [e1 , e2 ])[n, m] = mul(e1 [n, m], e2 [n, m])
= mul(n + 1, m).
This holds if
e1 [n, m] = n + 1
e2 [n, m] = m.
This is satisfied if e2 is a projection
e2 =def p1 (1)
and if e1 is a composition:
e1 =def comp(s, p1 (0))
since comp(s, p1 (0))[n, m] = s(p1 (0)[n, m]) = n + 1
To conclude, we can define the factorial fucntion by
factorial =def rec(comp(s, z),
comp(mul, [comp(s, p1 (0)),
p1 (1)]))
A more experienced person can write this immediate from the defining equations for the function. It is even possible to write a compiler which translates the
defining equations to a program in PRF.

Models of Computation

1.2

Models of Computation

A more precise syntax

The syntax and semantics which was given before were not very precise. We
have to remove the three dots which we have in the description of the syntax and
semantics. It is always a sign of imprecision to have the dots, different people
interpret them in different ways.
Let us first define the set Am of vectors of lenght m by the following inductive
definition:
nil A0
a.as An+1 if a A and as An
Now, we can give a more precise definition of the abstract syntax of PRFn ,
we give it in figure 6.
z PRF0
s PRF1
pn (i) PRFn+1 if i n
comp(g, f s) PRFn if g PRFm , f s (PRFn )m
rec(g, h) PRFn+1 if g PRFn , h PRFn+2
Figure 3: Abstract syntax of PRF

1.3

Operational semantics

We will give an inductive definition of the computation relation p q, the

program p computes to the value q. We have to decide what kind of things are
computed and what a value is. When we gave the intuitive semantics of what a
program is we expressed this by saying what it means to apply a program to its
input. So, the thing which is computed is an object in PRFn together with their
input. What is then a value? One choice is that we let the values be a natural
number. Hence, in the computation relation p q, p is always a program
together with its input and q is always a natural number.
Let us define the set PRF, of programs together with its input, by the following
inductive definition (with only one clause):

p[t] PRF if p PRFn and t N n

Models of Computation

Models of Computation

We can also express it in the following way:

p PRFn
t Nn
p[t] PRF
We will interpret the definition as that the set PRF has one binary constructor []
whose arguments are a primitive recursive program and a list of numbers.
Now, we can give the operational semantics. We will define the computation
relation p q over the sets PRF and N as an inductive definition in figure 8. In
order to explain the semantics, it is necessary to define another computation relation ps = ns, which expresses that a vector ps of primitive recursive functions
applied to a common input-vector is computed to a vector of natural numbers.
This is done in the obvious way, each primitive recursive function in the list is
applied to the same input list. The function nth(n, i, t) is equal to the i:th element

z[] 0

s[n.nil] n + 1

nth(n, i, t) = v
pn (i)[t] v

f s[t] = ns
g[ns] v
comp(g, f s)[t] v

g[t] v
rec(g, h)[0.t] v

rec(g, h)[n.t] i
h[n.i.t] v
rec(g, h)[(n + 1).t] v

where the relation = is defined by

nil[t] = nil

f [t] k
f s[t] = ks
(f.f s)[t] = k.ks

Figure 4: Operational semantics

of t, if t An+1 and is defined for i n by primitive recursion over its first and
second argument:
nth(0, 0, a.nil) = a
nth(n + 1, 0, a.as) = a
nth(n + 1, m + 1, a.as) = nth(n, m, as)

Models of Computation

Models of Computation

Notice, that we are using primitive recursion in the meta-language. It should not
be confused with the operator for primitive recursion which we are formalizing in
PRFn !

1.4

Denotational semantics

As an alternative way of defining the semantics for a computation model, we can

give the denotational semantics of the programs in it. This is a function which
maps an arbitrary program to its meaning, a mathematical object. The idea is
that you understand a program when you understand what mathematical object it
denotes.
In this case, we will give a function
[[p]] Nn N

if p PRFn

by structural recursion over the abstract syntax of p. This is done in figure 5.

[[z]](nil) = 0
[[s]](j.nil) = j + 1
[[pn (i)]](js) = nth(n, i, js)
[[comp(g, f s)]](js) = [[g]]([[f s]] (js))
[[rec(g, h)]](0.js) = [[g]](js)
[[rec(g, h)]]((y + 1).js) = [[h]](y.([[rec(g, h)]](y.js)).js)
where the semantical function [[f s]] (PRFn )m N m is defined by
[[nil]] (t) = nil
[[f.f s]] (t) = [[f ]](t).[[f s]] (t)
Figure 5: Denotational semantics

1.5 Termination of primitive recursive functions

Now, when we have a precise descripton of the set PRF we can formulate and
prove that all programs in PRF terminate.
We want to show the following theorem:
i N.p PRFi .Term(p)

Models of Computation

Models of Computation

where the predicate Term is defined by

Term(p) ms N i .m N.p[ms] m
The proof is by induction over the abstract syntax, we get one case for each clause
in the inductive defintion of the set PRFi :
We want to prove that Term(z). But the program z[] always terminates
according to the first clause in the operational semantics.
We want to prove that Term(s). This is true according to the second clause
in the operational semantics.
We want to prove Term(p( (n), i)), for n N, i n. This follows from the
third clause.
We want to prove Term(comp(g, f s)), if g terminates and all programs in
f s terminates. We compute the program comp(g, f s)[ms] by first computing the program f s[ms]. According to the induction hypothesis this terminates with a value ns, ns Nm . Finally, we compute the program g[ns],
which also terminates (according to the induction assumption).
We want to prove Term(rec(g, h)) if g terminates and h terminates. We
know that rec(g, h) PRFn+1 , g PRFn and h PRFn+2 . We want to
show that rec(g, h)[m.t] always terminates (we can ignore the case when
the input list is empty since rec(g, h) PRFn+1 .) We will show this by
induction over the natural number m.
We have two cases:
The base case, when m = 0. The program rec(g, h)[0.t] terminates
with the value of g[t], according to one of the clauses in the operational
semantics.
The induction step. Suppose that rec(g, h)[m.t] terminates with the
value i. According to the operational semantics, the program rec(g, h)[(m+
1).t] then terminates with the value of the program h(m.i.t). This
value always exists, since h is a program which always terminates (according to the induction assumption).

1.6

Fast growing functions and big numbers

Since all functions in PRF terminate we can use a diagonalization argument to

show that there exists a computable function which is not in PRF 1 . There is,
however, a more concrete example.
1

Exercise: Explain this in detail!

Models of Computation

Models of Computation

We get multiplication by iterating the addition function:

m n = |m + {z
+ m}
n terms

We use the following primitive recursive definition of multiplication:

mul(m, 0) = 0
mul(m, s(n)) = add(m, mul(m, n))
Similarly, we get exponentiation by iterating multiplication:
mn=m
m}
| {z
n terms

which corresponds to the following primitive recursive definition:

(m, 0) = 1
(m, s(n)) = mul(m, (m, n))
We can continue this process, we get the tower-operation by iterating exponentiation:
m n = m m
|
{z
}
n terms

which corresponds to the following primitive recursive definition:

(m, 0) = 1
(m, s(n)) =(m, (m, n))
We continue to define the -operation by iterating the operation.
Notice that these operations are increasing very fast, for instance already the
number 3 3 is around one million times the number of Swedish inhabitants:
3 3 = 3 3 3
= 3 27
= 7 625 597 484 987
The number denoted by 3 3 becomes difficult to grasp:
3 3 = 3 3 3
= 3 7625597484987
= 3 3 3 3 (with 7 625 597 484 987 terms)
33

=3

33

(with 7 625 597 484 987 exponentiations)

Models of Computation

Models of Computation

33

Notice that already 33 is much bigger than the number of atoms in the universe
12
33
(since 33 = 37 625 597 484 987 > 1010 = 101 000 000 000 000 1070 ).
Now, if 3 3 is difficult to grasp, what about 3 3?
3 3 = 3 (3 3)
= 3 3

33

with 3

33

terms

where we have 7 625 597 484 987 exponentiations in the number of terms.
So if we had 4 (instead of 7 625 597 484 987) number of exponentiations in
the number of terms we could not even write down the expression in the form
3 3 if we used one term for each atom in the universe. And we know
that already 3 3 3 (which is 3 3) was enormous! But as we all know
most numbers are much bigger than 3 3.
We can continue this process and define a whole series of operations , ,
, , . . . . We can now introduce an arbitrary number of operations, one for each
natural number n. We let for instance 5 stand for , so for each k we use
the notation k for the operation with k arrows. Notice that k is not a function
applied to the argument k ! It is only a schematic notation for k repetitions of the
symbol .
We have that
m k+1 n = m k k m
|
{z
}
n terms

It is clear that all these operations are primitive recursive functions. If we have a
definition of the k -operation then we can express the k+1 -operation by primitive
recursion:
k+1 (m, 0) = 1
k+1 (m, s(n)) =k (m, k+1 (m, n))
Notice here that we have a number of operations 1 , 2 , 3 , 4 , 5 , 6 , . . . which all
have a uniform definition. One operation is defined from the previous operation
by using primitive recursion. What happens if we try to look at k as an argument
to the k-th operation? So we will try to look at k as a function applied to the
number k yielding the k-th operation. Let us consider the ternary function which
is defined such that (k, m, n) is equal to the value of k (m, n), for each k, m and
n:
(0, m, n) = mul(m, n)
(k + 1, m, 0) = 1
(k + 1, m, s(n)) =(k, m, (k + 1, m, n))

Models of Computation

Models of Computation

Now something happens. This function is not primitive recursive! A version of

this function is called Ackermanns function after the person who defined it around
70 years ago. It is possible to show that the ternary -function grows faster than
any primitive recursive function. On the other hand it is clear that the function
is computable: If we want to compute (k, m, n) we first compute the value of
the argument k and then construct the operation k . This construction process
is computable, we can use the method above. Then we just compute k (m, n),
which is primitive recursive and hence computable.

1.7

Extending PRF to all partial recursive functions

If we want to extend PRF to the class of all recursive functions we extend it with
an operator min which expresses linear search. We define a new class of functions RFn , the set of all recursive functions of arity n by extending the inductive
definition of the abstract syntax of PRF with one clause:
z RF0
s RF1
pn (i) RFn+1 if i n
comp(g, f s) RFn if g RFm , f s (RFn )m
rec(g, h) RFn+1 if g RFn , h RFn+2
min(f ) RFn if f RFn+1
Figure 6: Abstract syntax of RF

The informal description of the min-function is the following:

min(g)[j1 , . . . , jn ] = k
if k is the least integer for which g[k, j1 , . . . , jn ] = 0
Figure 7: Informal semantics

Intuitively, the function application min(g)[j1 , . . . , jn ] is computed by first

computing g[0, j1 , . . . , jn ]. If the result is 0, the value is 0. Otherwise, if the
result is nonzero, we continue to compute g[1, j1 , . . . , jn ]. If this result is 0 we
return 1. If it is nonzero, we continue to increase the first argument until we reach

Models of Computation

Models of Computation

a function value which is 0. This computation does not have to terminate, since
there is not necessarily a value of the first argument for which the function is 0.
The precise description of the operational semantics is obtained by adding two
clauses to the operational semantics of PRF:
f [0.t] 0
min(f )[t] 0

min(shiftf )[t] i
min(f )[t] i + 1

Figure 8: Operational semantics of RF

In the rules above, the primitive recursive function shift is defined by

(shift f )[a.t] = f [(a + 1).t]

1.8

Historical remarks

The first to write the ordinary primitive recursive definitions of addition and multiplication was probably Hermann Grassmann [3] . It was later rediscovered by
Dedekind [2]. The class of primitive recursive functions were known by Hilbert
[4] in 1926. At that time his student Wilhelm Ackermann had defined the ternary
-function and showed that it is not primitive recursive. This result was not published until 1928 [1].
The founder of the theory of primitive recursive functions was Rozsa Peter
[6], who also coined the term primitive recursive. She simplified Ackermanns
formulation (together with Raphael Robinson) to a function of two arguments:
A(0, y) =y + 1
A(x + 1, 0) =A(x, 1)
A(x + 1, y + 1) =A(x, A(x + 1, y))
which is now the traditional formulation in modern textbooks. This formulation
may look simpler than the original, but is it more understandable?
The notation originates from Knuth in 1976 [5].

References
[1] W. Ackermann. Zum Hilbertschen Aufbau der reellen Zahlen. Mathematical
Annals, 99:118133, 1928.

Models of Computation

Models of Computation

[2] Richard Dedekind. Was sind und was sollen die Zahlen? F. Vieweg, Braunschweig, 1888. Translated by W.W. Beman and W. Ewald in Ewald (1996):
787832.
[3] Hermann Grassmann. Lehrbuch der Mathematik fur hohere Lehranstalten.
Enslin, 1861.

[4] David Hilbert. Uber

das unendliche. Mathematische Annalen, 95:16190,
1926. Translated by Stefan Bauer-Mengelberg and Dagfinn Fllesdal in van
Heijenoort (1967): 36792.
[5] D.E. Knuth. Selected Papers in Computer Science, chapter Mathematics and
computer science: coping with finiteness. Cambridge University Press, 1996.
also published in Science 194, 12351242.
[6] Rozsa Peter. Recursive Functions. Academic Press, 1967.
[7] Jean van Heijenoort. From Frege to Godel: A source book in mathematical
logic 18791931. Harvard University Press, Cambridge MA, 1967.