Lectu re Notes

in Economics and
Mathematical Systems
Operations Research, Computer Science, Social Science

Edited by M. Beckmann, Providence, G. Goos, Karlsruhe, and

H. P. KUnzi, ZUrich

68

J. Loeckx

Computability and Decidability

An Introduction for Students of Computer Science

Springer-Verlag
,Berlin· Heidelberg· New York 1972
Advisory Board
H. Albach· A. V. Balakrishnan' F. Ferschl . R. E. Kalman' W. Krelle . G. Seegmuller
N. Wirth

Prof. Dr. Jacques Loeckx

Institut fur Informatik
U niversitat des Saarlandes
66 Saarbrucken

AMS Subject Classifications (1970): Primary 68-01

Secondary 02 E 10, 02 E 15, 02 F 15, 02 G OS, 68 A OS, 68 A 10,
68A25,68AC)0

ISBN-13: 978-3-540-05869-4 e-ISBN-13: 978-3-642-80689-6

DOl: 10.1007/978-3-642-80689-6

This work is subject to copyright. All rights' are reserved, whether the whole or part of the material is concerned,
specifically those of translation, reprinting, re:use of illustrations, broadcasting, reproduction by photocopying machine
or similar means, and storage in data banks.
Under § 54 of the German Copyright Law where copies are made for other than private use, a fee is payable to the publisher,
the amount of the fee to be determined by agreement with the publisher.

© by Springer-Verlag Berlin' Heidelberg 1972. Library of Congress Catalog Card Number 72-82761.
Softcover reprint of the hardcover 1st edition 1972
PREFACE

The present Lecture Notes evolved from a course given at the

Technische Hogeschool Eindhoven and later at the Technische Hogeschool Twente.
They are intended for computer science students; more specifically, their goal
is to introduce the notions of computability and decidability, and to prepare
for the study of automata theory, formal language theory and the theory of
computing. Except for a general mathematical background no preliminary knowledge
is presupposed, but some experience in programming may be helpful.
While classical treatises on computability and decidability are
oriented towards the foundation of mathematics or mathematical logic, the present
notes try to relate the subject to computer science. Therefore, the expose is
based on the use of strings rather than on that of natural numbers; the notations
are similar to those in use in automata theory; in addition, according to a
common usage in formal language theory, most of the proofs of computability are
reduced to the semi-formal description of a procedure the constructivity of which
is apparent to anybody having some programming experience.
Notwithstanding these facts the subject is treated with mathematical
rigor; a great number of informal comments are inserted in order to allow a good
intuitive understanding.
I am indebted to all those who drew my attention to some errors
and ambiguities in a preliminary version of these Notes.
I want also to thank Miss L.A. Krukerink for her diligence in
typing the manuscript.

Saarbrucken, March 1972 Jacques Loeckx

TO THE READER

A list of the different notations used throughout

the text may be found in Appendix II.
An alphabetic list of the mathematical concepts
introduced is in Appendix III.
The end of each example is marked by the sign **
in order to clearly separate it from the running text.
CONTENTS

CHAPTER I : SETS AND FUNCTIONS

1.1. The objects

1.2. Ordered sequences and sets
1.3. Further notations and definitions concerning sets 3
I .4. Functions 4
1.5. Particular objects 8

CHAPTER 2 : SETS AND FUNCTIONS OF STRINGS 11

2.1. Definitions 11
2.2. String functions 12
2.3. Further notations and definitions 13
2.4. The interpretation of strings 13
2.5. Alphabetic order 14
2.6. Enumeration of strings and n-tuples of strings 15
2.7. Enumeration functions 17
2.8. Calculating the value of the enumeration functions 21

CHAPTER 3 : COMPUTABLE FUNCTIONS 23

3.1. Historical background 23
3.2. The basic idea of Turing 24
3.3. Physical model 24
3.4. Formal definition of a Turing machine 27
3.5. Examples of Turing machines 35
3.6. Computable functions 39
3.7. The thesis of Turing 39
3.8. Normal Turing machines 40
CHAPTER 4 : THE UNIVERSAL TURING MACHINE 45
4.1. The string description of a Turing machine 45
4.2. The universal Turing machine 48
4.3. Discussion 49
 - VI -

CHAPTER 5 : SOME FUNCTIONS WHICH ARE NOT COMPUTABLE 50

5.1. The halting problem 50
5.2. The blank tape halting problem 53
5.3. The uniform halting problem 54
5.4. The equivalence problem 55
5.5. General remark 56
CHAPTER 6 : EFFECTIVELY ENUMERABLE AND DECIDABLE SETS 58
6.1. Introduction 58
6.2. Definitions 58
6.3. Effectively enumerable sets and the domain of computable functions 59
6.4. Effectively enumerable sets and the range of total computable 59
functions
6.5. A set which is not effectively enumerable 63
6.6. Decidable sets versus effectively enumerable sets 65
6.7. An effectively enumerable set which is not decidable 66
6.B. Some informal comments 68

APPENDIX BIBLIOGRAPHICAL NOTES 71

APPENDIX 2 LIST OF THE MOST IMPORTANT NOTATIONS 72
APPENDIX 3 LIST OF THE MOST IMPORTANT CONCEPTS 74
CHAPTER 1 SETS AND FUNCTIONS

Abstract: Some notions and definitions related to sets and

functions are briefly recalled.

1.1. The objects

This course deals with sets and functions of objects. While in Sections
1.2 to 1.4 the exact nature of the objects is not yet specified, only three dif-
ferent types of objects occur in these Notes:
(i) strings of symbols, such as:
abaa
a
**
(ii) non-negative integers or, abbreviated, nni's such as:
7
4013
o **
(iii) the truth values, viz. true and false.

Actually, the notions of computability and decidability will be defined

for functions and sets of symbol strings; functions and sets of nni's or truth
values will therefore occur only incidentally.

1.2. Ordered sequences and sets

1.2.1. Definitions
-----------
An ordered sequence (of n objects) (or: n-tuple) consists of a number
(viz. n) of objects specified in a certain order; this number may not be zero and
must be finite. A 2-tuple and 3-tuple are also called pair and triple respectively.

A set consists of a collection of elements~ each element being

- an object
- or: an ordered sequence
- or: (another) set (*);
the number of these elements may be zero and must not be finite.

It should be noted that these "definitions" are intuitive descriptions

(*) This definition is recursive: the notion to be defined (viz. "set") appears in
its own definition.
 - 2 -

rather than actual definitions because notions such as "finite" or "collection" have
not been defined. Giving precise definitions for these notions is beyond the scope
of these Notes (*).

1.2.2. Notation
--------
1.2.2.1. Ordered sequence

An ordered sequence is noted:

( objects separated by comma's)
Examples of ordered sequences are
3, 9
b, a, b
a, ab, ba, true **
Counterexamples of ordered sequences are
)
0, I, 4, 9, ••• ) where the dots represent an
infinite sequence **
Note that an object may occur more than once in an ordered sequence, for
instance b in ( b, a, b ).

Note also that by its definition an ordered sequence of one object is the
object itself; in that case the embracing parentheses may, of course, be omitted in
the notation.

1.2.2.2. Sets

There exist two different notations.

The first notation is:

{ the elements separated by comma's}
Examples are
{ 3, 9 }
{ a, b, c }
{ } (**)
{ (a, b) , (b, c) , (c, a) }
{ {} , { a } , { b } , { a, b } } **
Note that an element may be mentioned only once; hence
{ a, b, a }
is an incorrect notation for { a, b } (or, equivalently, for { b, a } ).

(*) Precise definitions should, among others, avoid the Russell paradox for sets.
(**) This set is called the empty set.
 - 3 -

The second notation is:

{ variable I property of that variable }

The elements of the set are those satisfying the property (.). Examples are:

(x, y) I x and yare nni's for which x ~ y }

{ x I there exists an nni y such that x = y2 } **

An important difference between these two notations is that the first
one can only be used for sets with a finite number of elements whereas the second
can be used for arbitrary sets.

It should be noted that by its very definition a set of one element is

different from the element itself. For instance, {b} denotes a set of one element
whereas b denotes an object (or, equivalently, an ordered sequence of one object).

1.3. Further notations and definitions concerning sets

1.3.1. General

a E S means that a is an element of the set S.

a f S means that a is not an element of the set S.

S = T means that a E S implies a E T and vice versa (**) •

means that not S = T (**) •

SeT means that a € S implies a € 1:.

SeT means that S c T and S f T.
------
A set S is a subset of a set T if SeT.

A set S is a proper subset of a set T if SeT.

Two sets Sand 1: are disjoint if a € ~ implies a i 1:.

A set is finite if it consists of a finite number of elements.

In the sequel card (~) denotes the number of elements of the set S
provided ~ is a finite set ( ••• ); note that card (~) is an nni.

(*) It is understood that the variable is ranging over the elements of the set
to be defined.
(*.) and, ~ and not are to be understood as the logical and, or and not (sometimes
denoted as II, v, --, respectively).
( •• *) The mnemonic origin of "card" is cardinal number.
 - 4-

Per definition:
(i) S u! = { a I a £ S or a £ T } (*); S u T is called the union of the sets
Sand !;

(ii) ! n! = { a I a £ S and a £ T } S nTis called the interseation of the

sets! and !;

(iii) ! \ ! = { a I a £ S and a i ! } ! \ ! is called the differenae of the sets

! and!;

(iv) if T is a subset of !. ! - ! = ! \ ! ( •• );~ - ! is called the aompZement of

! with respect to!; if ! is understood. ! - ! may be written 1;
(v) if !I' !2 ••..• ; (n> I) are sets the elements of which are objects. then

a )
n
I a.
1-1
£ S. for each i. 1 ~ i ~ n}

this set is called the aartesian produat of the sets ~I' ~2' ..•• ~; when

!I =!2 = .•• = ~ ~!. the cartesian product may be written Sn.

These definitions may be illustrated by the following examples in which

A = { a. b } and! = { b. c }
Au B ={ a. b. c }

A n B ={ b }

!\!={a}

A - B makes no sense

A x B = {(a. b). (a. c), (b, b), (b, c)} **

1.4. Functions

Let S be the set of all objects considered (e.g. the set of all nni's).

A funation ~ith n arguments (or: n-ary funation~ or: n-ary mapping, or

n-ary operation) is a subset of Sn+1 such that for any two different elements

(*) and, ~ and not are to be understood as the logical and, or and not (sometimes
denoted as A, v,-' respectively)
(**) If T is not a subset of !. ~ - T makes no sense.
 - 5 -

(aI' a 2 , ... , an + l )

and (b l , b 2 , ... , b n + l )

we have not simultaneously al=b l , a 2=b 2 , .•• , an=b n and an+l#b n + l •

If (aI' a 2 , ••• , an + l ) is an element of an n-ary function then an + 1 is called the

value (of the function for the n-tuple (a l • a 2• .•.• an) of arguments).

If there exists no a n + 1 such that (aI' a 2 , ... , an' an + l ) is an element of the

function, then the value (of the function for the n-tuple (a l • a2• .•.• an) of

arguments) is undefined.
The following three examples illustrate these definitions:
(i) the function sum is a set containing the elements:
(0, 0, 0) , (I, 0, I ) , (2, 0, 2) ,
(0, I , I) , ( I , I , 2) , (2, I, 3),
(0, 2, 2), ( I , 2, 3) , (2, 2, 4) ,

(ii) the function sqrt is a set containing the elements:

(0,0), (1,1), (4,2), (9,3), ...
the value of this function is, for instance, 3 for the argument 9 and
undefined for the argument 7.
(iii) the 2-ary function dec defined by lOx + y for ° ~ x ~ 9, ° ~ y ~ 9 is the
finite set:
dec = { (0,0,0), (0, I, I), ••• , (9,9,99)}. **

The domain of an n-ary function F is the set

D
-t1
{ (aI' a 2 ' ... , a )
n 1 there exists a
n+1
such that

(aI' a 2 ' ... , a

n' an + l )
€ F}

the range of this function is

~ {an + 1 1 there exist aI' a 2 , ... , an such that

(aI' a 2 , ... , an' a n + l ) € F}.

One says that F maps D onto R . One also says that F maps D into R where R is any
-r -t1 -t1
set such that R c R.
-r
 - 6 -

If we consider the functions sum and sqrt of Section 1.4.1 and if N

denotes the set of all nni's:

D N2
-sum
R R = N
-Sum -sqrt
2 }
D { x there exists y € N such that x Y **
-sqrt

Note that the value of a function for a given n-tuple of arguments is

defined if and only if this n-tuple is an e~ement of the domain.

1.4.3. Notation

A function is denoted, for instance, by F or sqrt or sin. The value of

the function F for the n-tuple (aI' a 2 , ..• , an) of arguments is denoted by
F(a l , a 2 , ••• , an). Note that this is different from the common mathematical prac-
tice where sin x denotes the function sine as well as the value of this function
for the argument x, the ambiguity in the notation being removed by the context.

The fact that F maps ~ into T is noted

F : S -+- T
the fact that F maps S onto T is noted
F S -+--+- T

The definition of a particular function may be given in two ways:

(i) the function may be defined as a set;
examples:
FI {(x, y, z) I x, y, z are nni's such that z =x + y }

{ (x, I) there exists an nni z such that x

u { (x, 0) I there exists no nni z such that x = z2 } **

(ii) the function may be defined with the help of its value according to the scheme
F : D -+--+-R
-F -F
F(x l , ... , xn )
or
F : D
r'
-+- R : F(x l , ... , xn )
where R is any set such that R
r' =- !~.:
 - 7 -

examples ( ): '"
FI N2 -+ N : FI(x,y) = x + Y
2
F2 N -+ { 0, I } : F2 (x) = if there exists z € N such that x = z

[: if there exists no z € N such that x = z

2

F3 ~ - { 2 } -+ { 0 } : F3 (x) = 0 (the value of this function is 0 for any

argument except for 2; in that case the value of the function is un-
defined) • **

A drawback of the definition of a function as given above is that it

does in general not tell how to obtain the value for a given n-tuple of arguments.
For example, the definition of F2 in Section 1.4.3 does not tell how to obtain its
value for a given x.

Hence a "better" definition would be the following: an n-ary function

is a rule which makes correspond with each element of a set of n-tuples (the domain)
a unique element of another set (the range). Such a definition nevertheless requires
a precise definition of the notion "rule".

It is precisely one of the aims of these Notes to establish such a

definition of "rule". In Chapter 5 it will then appear that the two definitions of
function are not equivalent: the present definition (i.e. the one of Section 1.4.1)
is broader (i.e. defines more functions) than the definition given with the help of
the rule.

An n-ary function is injeotive if for any two different elements

(aI' a 2 , •.. , an' a n + l )

and (b l ,b 2 , ... ,bn,b n + l )

it is not the case that a n + 1 = b n + l . Hence for an injective function there corresponds

a unique element of the domain with each element of the range.

Examples of injective functions are the functions sqrt and dec of Section
1.4.1; a counterexample is the function sum of the same section. **

("') N denotes the set of all nni's.

 - 8 -

The inverse function of an injective 1 -ary function F is the function

F = { (y, x) I (x, y) E F }

Note that the domain and range of F are respectively the range and domain of F.
The inverse function is also a I-ary injective function; in fact, F = F.

As an example, the inverse function of the function "square root of

an nni" is the function "square of an nni". **
The inverse functions of an injective n-ary function F are the n func-
tions

{ (y, xi) I there exist xI' x 2 ' ... , xi_I' x i + I ' ... ,xn

such that (xI' x 2 ' ... , xn ' y) E F}(I ~ i ~ n, n~ 2)

Less formally, the inverse function F(i) restitutes the ith argument of the function
F for a given value of this function. Hence, for any element y of the range of an
injective n-ary function F it is the case that

As an example, the value of the inverse functions dec (I) and dec(2) of
the function dec of Section 1.4. I is illustrated by

dec(I)(49) = 4, dec(2)(49) = 9 **
1.4.6. Note

It is possible to generalize the notion of function by allowing the

arguments and the value to be ordered sequences (of objects) and/or sets (of objects)
instead of merely objects. In these Notes this generalization will not be made,
except for a very particular case mentioned in Section I.S.I.

1.5. Particular objects

The preceding definitions have been given for arbitrary objects. Par-
ticular types of objects or, more precisely, sets the elements of which are
constituted by objects of a particular nature, viz. truth values, nni's and strings,
are now going to be considered.

I.S.I. Truth values

------------
The truth values are true and false.

A predicate is a function the range of which is (a subset of) the set

{ ~, false }.
 - 9 -

A reZation is a 2-ary predicate; example (*):

2
greater: ! + {true, false}:

greater (x, y) = true if x is greater than y

[
false if x is equal to or smaller than y **

The value of a relation is often written with the help of an operator such as > or #;
for instance, one generally writes

x > y

instead of: greater (x, y). **

In the sequel relations will be introduced, the arguments of which are
ordered sequences rather than objects (Sections 3.4.3 and 3.4.4); these relations
correspond to the generalized notion of function indicated in Section 1.4.6.

Let from now on N denote the set of all nni's.

1.5.2.1. N-functions

A naturaZ function (or: !-function) with n arguments is any n-ary

function the domain and range of which are subsets of Nn and! respectively.

Examples of N-functions are the functions F I , F2 and F3 of Section 1.4.3.

Another example is:

diff: (x, y) I x, y € !, x ~ y } + ! : diff (x, y) = x - y **

The value of a 2-ary !-function is often written with the help of an
operator such as + or - ; for instance one writes generally x - y instead of
diff (x, y).

1.5.2.2. Total and partial ~-functions.

An n-ary !-function is totaZ if its domain is !n. Examples of total

N-functions are FI and F2 of Section 1.4.3; counter-examples are F3 of Section 1.4.3

and diff of Section 1.5.2.1.

(*) N is the set of all nni's.

 - 10 -

Sometimes one wants to explicitely state that a given function is not

necessary total; he then says that the function is partial. Note that, strictly
speaking, the label "partial" attached to "function" does not add any information.

1.5.2.3. Complement

The complement of a set S c Nn (n ~ I) is its complement with respect

to -Nn , i.e. is Nn - S.

These objects are treated in the next chapter.

CHAPTER 2 SETS AND FUNCTIONS OF STRINGS

Abstract: Some definitions concerning strings, sequences of strings

and sets of strings are introduced and a few properties are indicated.
Particular attention is paid to the enumeration of all strings or
ordered sequences of strings over a given vocabulary.

2. I. Definitions
A vocabulary is a finite non-empty set; the elements of this set are
called symbols. Examples of vocabularies:

v { a, b } ;

v' 0, I, 2, 3, 4, 5, 6, 7, 8, 9 }

v" {O,I,+,=} **

A string (over a vocabulary V) is the object obtained by concatenating

(i.e. writing one after the other) some symbols of ~ ( * ). Examples:

a, aa, aabab are three strings over V

10+11=101 is a string over V" **

The empty string is the string which consists of no symbols; in the

sequel it is denoted c.

The (free) monoid generated by a vocabulary ~ is the set of all strings

' I u d'~ng t h e empty
V ~nc
over _, ' T h e f ree
str~ng. 'd generate db y _V;s
mono~ ~ denoted y...*(**) ,
Example: V* contains the strings E, a, b, aa, ab, ba, bb, aaa, ." **

A substring ~ of a given string ~ over V is a fraction of ~ or, more

precisely, is a string for which there exist strings WI and w2 in V* such that

('II) A string over ~ is viewed by some authors as an ordered sequence of elements

of V in the notation of which the parentheses and commas are omitted.
('II'll) V* together with the operation cone of Section 2.2 is amonoid in the sense of
modern algebra; the elements of V are the generators of this monoid.
 - 12 -

A substring is proper when wl w2 fE, i.e. when not simultaneously

wI E and w2 = E. Example: aba is a proper substring of ababaa (take wI =E ,

00 2 = baa, or take wI = ab , w2 = a) but a non-proper substring of aba. **

It is important not to confuse a symbol with an occurrence of this symbol

in a string. For instance, there exists only one symbol b {in the vocabulary
~ = { a, b }) but there are two different occurrences of the symbol b in the
string bab. A similar remark holds for a string and its occurrence as a substring
in another string: there is only one string aba but there are two occurrences of
aba in the string ababaa.

As a final remark it should be stressed that E is a string (of zero

symbols), not a symbol! In particular, E should not be confused with the "blank
symbol" which is used to separate the words in a typewritten text. By the way,
the use of such a symbol is avoided in this course or, more precisely, when in
Section 3.4.1 the "blank symbol" is introduced for mnemonic purposes, it is given
a representation similar to that of the other symbols, viz. B.

2.2. String functions

A ~(string) funation with n arguments is a function the domain and

range of which are subsets of V*n and V* respectively.

Examples of ~-string function are:

(i) cone: V*2 ~ V* : cone (x, y) = xy;

examples: cone Cab, ba) = abba, cone (a, E) =a
(ii) head: ~*- {E} ~ ~* : head (x) = the leftmost symbol of x;
examples: head (abab) = a, head (E) is undefined
(iii) delete: ~ x ~* ~ ~* : delete (a,x) = the string x from which all occurrences
of the symbol a are deleted;
examples: delete (a, abab) = bb, delete (a,b) = b
(iv) reverse: *
~ ~ ~ * : reverse (x) = the string x the symbols of which are
written in reverse order;
example: reverse (abb) = bba, reverse (E) = E. In the sequel the notation

x R will replace reverse (x); the letter R may then be considered as a

unary operator.
(v) , d rome:
pa I Ln ~* ~ ~ * .
: palLndrome (x ) = cone (x,x
R) ;
example: palindrome (ab) = abba **
 - 13 -

*n
total when its domain is V
An n-ary !-function is A function which
is not necessarily total is sometimes said to be partial in order to stress this
fact.

2.3. Further notations and definitions

The following notation will be used in the sequel: if a is a symbol

and n an nni, an represents the string of n symbols a. Example : {anbn I n ~ O}
is the set the elements of which are E, ab, aabb, aaabbb, ••. **

The length of a string (over a given vocabulary) is the number of its

symbols. The length of a string, say the string x, is denoted by lex). Examples:
l(ab) = 2, leE) =0 (*). **

The complement of a set S c V*n is its complement with respect to

v*n i.e. V*n - S.

The setproduct of two sets of strings A and B is noted A.B and is by

definition:
!.! = { xy I x E ! ' Y E ! }
It is important not to mix up the notions of setproduct and cartesian product;
remember that the latter is a set of pairs rather than a set of strings:

A x B ={ (x, y) xEA,YEB}.

2.4. The interpretation of strings

When writing about objects (e.g. nni's, truth values, cows) one is
obliged to choose a representation.

This representation may be two-dimensional (e.g. a drawing) but is

often a string (i.e. a quasi-unidimensional representation).

In order to avoid ambiguity these strings must be such that in a given

representation there corresponds with each string a single object.

(*) 1 may also be considered as a function from V* onto N.

 - 14 -

As an example. in the decimal notation the string 12 (which is a

string of { O. I. 2, 3. 4. 5. 6. 7. 8. 9 }*) represents a natural number. viz.
twelve. In the binary notation the string 1101 (which is a string of { O. I }*)
represents the same number. As another example. the string goto L represents a
jump in the programming language Algol-60. **

This correspondence between strings and the objects they represent

may be viewed as a function from the set of strings onto the set of objects. It
is interesting to note that this function is not necessarily injective: in the
decimal notation. for instance. the strings 12 and 012 represent the same number.

Considering the object a string stands for (i.e. the object a string
represents) is said to interprete the string or. equivalently. to consider its
semantics.

These Notes are concerned with the study of strings but their (possible)
interpretation is never referred to. Hence the definitions and properties of (sets
and functions of) strings which are given here and in the sequel are independent
from their interpretation i.e. are valid whatever their interpretation may be.

2.5. Alphabetic order

An aZphabetic order (in a vocabuZary ~ is a function

A : ! -++ { iii € ~ , I ~ i ~ card (!) }

Note that A is finite and injective.

Less formally. providing a vocabulary! with an alphabetic order

consists in listing its symbols in some arbitrary order and associating with them the
numbers I. 2 ••••• card (!) respectively.

Example: An alphabetic order in { a, b. c } is

A = { (a • I) • (b. 2) , (c. 3) };

another alphabetic order in the same vocabulary is

B = { (a. 2) , (b. 3) • (c. I) } **

It is easily seen that the number of different alphabetic orders in a

given vocabulary V is (card (!»!
 - 15 -

2.6. Enumeration of strings and n-tuples of strings

2.6.1. An enumeration of the elements of a monoid

------------------------------------------
Let! be a vocabulary provided with an alphabetic order A.

It is possible to enumerate the elements of !* (i.e. to draw up a list

of an arbitrary large number of elements of !*) according to the following two
rules:

(i) a string of length k (I ~ k) is preceded by all strings of length smaller

than k;
(ii) a string of length k (I ~ k), say SIS2",Sk(SI' S2' ... , Sk € !), is preceded

by all strings nln2 .•• ~(nl' Q2' .•. , ~ € !) of length k for which there

exists h (I ~ h ~ k) such that

Q.
1
S.1. for all i < h

and

Less formally, rule (i) requires that first all strings of length 0 are listed,
then all strings of length I, then all strings of length 2, etc. Rule (ii) requires
that the strings of the same length are listed "alphabetically", i.e. in the same
way as the words in a dictionary.

Example: For! = { a, b } with A { Ca, I) , (b, 2)} the strings of y*

are enumerated as follows:

£, a, b, aa, ab, ba, bb, aaa, aab, aba, •.•

Other example: For Y ={ a, b } with A = reb, I), Ca, 2)} the enumeration is:

£, b, a, bb, ba, ab, aa, bbb, bba, bab, ••. **

2.6.2. Generalization

The method for enumerating the elements of Y* will now be generalized

for y*n , n ~ 1.

Again, suppose that the vocabulary! is provided with an alphabetic

order A. Consider now a symbol C, C t Y and provide the vocabulary Y u {C} with
the alphabetic order

AI A u { (C, card (!) + 1) }

 - 16 -

*n
The enumeration of the elements of ~ may now proceed as follows;

(i) the elements of the monoid (~ U {C})* are enumerated as indicated in

Section 2.6.1;
(ii) the strings which do not contain exactly n-I occurrences of the symbol C
are dropped from the list;
(iii) each string of the list obtained sub (ii), say

is replaced by the n-tuple

It should be clear that the resulting list constitutes an enumeration of the

elements of V*n; moreover, for n = 1 this enumeration coincides with that of
Section 2.6.1.

Example: Consider ~ = {a,b} provided with the alphabetic order

A { (a, 1) (b,2)}. The enumeration of the elements of (~u {c}) * is:

E, a, b, C, aa, ab, aC, ba, bb, bC, Ca, Cb, CC, aaa, aab,

aaC, aba, abb, abC, aCa, aCb, •••

dropping the strings which do not contain exactly one occurrence of the symbol C
yields:
C, aC, bC, Ca, Cb, aaC, abC, aCa, aCb, ..•
hence the enumeration of the elements of V*2 is:

(E, E) , (a, £) , (b, E) , (E, a) , (E, b) , (aa, E) ,

(ab, E) , (a, a) , (a, b) ,

This enumeration is illustrated by Figure 1. **

 - 17 -

x e: a b aa ab ba bb aaa

n
e: --'- --'>- -"'- __"7

I
IJ I
I

a I

-
b ~ I~
I......-

aa 13

ab 14

Fi~ure I: A graphical illustration of the

*2
ba 115 enumeration of the elements (x, y) of V for
'J.. = {a, b} and A = {(a, I) , (b, 2)} ; the
broken line indicates in which order the
bb

---
I~
different locations of the plane are threaded
by the enumeration.
aaa

2.7. Enumeration functions

Several classes of functions will now be introduced. They show how

it is possible to relate in a one-to-one correspondence the non-negative integers,
the strings over a vocabulary and the n-tuples of strings over a vocabulary. These
functions are to be used in the subsequent Chapters.
 - 18 -

2.7.1. The functions V*n_ to- N

Let ~ be a vocabulary provided with an alphabetic order A. Per

definition. for n ~ I:
(~* •nA) -to-! : V*n -- N :

(~
*n • A)-to-!(x • x ••.•• x ) = k. being understood that
i 2 n
(xI' x 2 ••.•• xn ) is the (k+l)th n-tuple in the enumeration

of the elements of V*n.

Less formally. the function (~*n. A)-to-! associates with any n-tuple the number
of its place in the enumeration described in Section 2.6.2.

When A is understood one may write

V*n_ to - N
.
1nstead 0
f (*n
~ ) .
• A -to-! and when n=1 one may wr1te

V* -to-N
instead of V*1 -to-No

Examples: For V = { a. b } and A { (a. I) • (b. 2) } one has. for

instance (lit):
o·,
V* -to-N (a) I',

V*-to N (b) 2',

V*-to-N (aa)= 3;

etc.
and:
V*2 -to-N (E. g) o·,
V*2 -to-N (a. E) I',

V*2 -to-N (b. E) 2',

V*2 -to-N (E, a) 3;

etc. **

(lit) cf. the examples of Section 2.6.1 and 2.6.2.

 - 19 -

It is clear that V*n_ to- N is a total injective function from

V*n onto N. Hence, it makes sense to speak of the inverse functions

(:!.*n ,A) -to-.!:!. (J.) (! ~ j ~ n)

. .!:!.-to- (:!.* ' A) or, shortly, N-to-V* by:

One defines the funct10n
* -.,,*:------
.!:!.-to-(:!. , A) = (:!. ' A)-to-.!:!.

note that this function is a total injective function from N onto V* .

Example: For V and A defined as in the preceding example one has:

N-to-V* (0) = e:
N-to-V* (I) = a

N-to-V* (2) b

N to-V* (3) aa

etc. **

One may consider the function V*-to-N as a generalization of the

alphabetic order A (-); in fact:

A : V ++ { i I I ~ i ~ card (:!.) } : A(x) = :!.*-to-.!:!.(x).

Further properties of the function :!.*n_to-.!:!. and, in particular, a

procedure allowing to compute its value will be indicated in Section 2.8.

2.7.2. The functions V*n_to- W*

If V and Ware vocabularies provided with the alphabetic orders

A and B respectively, then one defines for n ~ I:
(:!.*n ,A)-to-(~,
* B) : V*n ++ W*

(:!.*n ,A)-to-(~, *
B) (xI' x 2 ' .•• , xn )
* *n
.!:!.-to-(~ , B) «:!. ,A)-to-.!:!.(x l , x 2 ' ... , xn ))

Less formally, the function (:!.*n ,A)-to-(~, * B) associates with each n-tuple of V*n

the string of W* which occurs at the same place in the enumeration.

(*) More precisely, V*-to-N is an extension of A, "extension" being used in the

sense of modern algebra.
 - 20 -

Again. when A and B are understood one may write

V*n-to-W*

instead of (y*n. A)-to-(W*. B) and when n=1 one may write

V*-to-W*
instead of V*I_to-W*.

Examples:
(i) V = W = { a. b } A = B = { (a. 1) (b. 2) } n 2; then
• •
V*2 -to-V* (e. e) = e

V*2-to-V* (a. e) = a

V*2 -to-V* (b. e) = b

V*2 -to-V* (e. a) = aa

etc

this may be illustrated by the following table in which the elements of y *2 •

N and V" are enumerated:

N V*

(e. e) o e

(a. e) a

(b. e) 2 b

(e. a) 3 aa

(e. b) 4 ab

(ii) V = { a. b }.
n = I; then:
~ = { a }. A = { (a. I) • (b. 2) } . B { (a. 1) } .
V*-to-W* (e) = e

V*-to-W* (a) = a

V*-to-W* (b) aa

V*-to-W* (aa)= aaa

etc.

or. in general. V* -to-W* (x) is a string of V* -to-N (x) symbols a. **

 - 21 -

It is clear that V*n_to-W* is a total injective (~ u ~)-string

function from V*n onto W* Hence it makes sense to speak of its inverse functions.
Note in particular that

V* -to-W* W* -to-V*

The functions V*n_to-W* do not only allow to replace (the study of)
n-tuples by (that of) strings, but also to replace one vocabulary by another (viz.
~ by How far-reaching the consequences of this are will appear in Chapters 4,
~).
.. . *n *. .
5 and 6; ln partlcular, the functlons ~ -to-~ wlll play an essent1al role in the
proof of the existence of non-computable functions (Section 5.1).

2.8. Calculating the value of the enumeration functions

The enumeration functions have been defined in Section 2.7 but the
way in which their value for given arguments may be obtained has not been stated
explicitly. A procedure will now be described which allows to calculate the value
of the function (~*n, A)-to-~ for an arbitrary given n-tuple of arguments (~ and A
are a vocabulary and an alphabetic order over it, n >, I). The case of the function
(~*n ,A)-to-(~,
* B) and of the inverse functions may be treated in a similar way.

The procedure makes use of two variables, viz. sand cr, to which
respectively an nni and a string may be assigned as a value (*). The principle of
its working consists in the enumeration of the n-tuples of ~*n according to the
method indicated in Section 2.6.2 until the argument shows up. More precisely, when
an n-tup 1e ( xI' x 2 ' ... , xn ) € ~*n.1S presented to 1t,
. t h e proce dure succeSS1ve
. 1y

performs the following steps, C and A' being defined as in Section 2.6.2:

(i) put ( ** ) s =0 and cr = Cn-I ;

(ii) if cr x 1Cx 2C•.. Cxn ' stop; the result is the value of S;

(iii) if cr € {C}* , put

cr = CA'(I»l(cr)+1
and go to step (v);

(*) "Variable" is used here in the same sense as in a programming language.

(**) Put s = 0 means: assign the value 0 to the variable s.

(***) A' is the inverse function of the alphabetic order A', l(cr) is the length
of the (old) value of cr.
 - 22 -

(iv) if a i {C}*. determine d €!, y € (! u {C})*. Z € {C} * such that

a = ydz

put a y A'(A(d)+I) (A'(I»l(z)

(v) if a does not contain exactly n-I occurrences of the symbol C. go to

step (iii);

(vi) if a contains exactly n-I occurrences of the symbol C,increase s by 1(*)

and go to step (ii).

The working of this procedure may be illustrated by the following comments: step (i)
assigns initial values to the variables; step (ii) checks whether the given n-tuple
(xI' x 2 •.••• xn ) is reached and. if so, makes the procedure come to an end; step

(iii) increases the length of the string by one symbol according to rule (i) of
Section 2.6.1; step (iv) determines the alphabetically next string according to
rule (ii) of Section 2.6.1; step (v) corresponds with step (ii) of Section 2.6.2.
*n .
It is clear that for any (xI' x 2 ••••• xn ) €! th~s procedure comes

to an end and that it delivers the value

V*n. A)-to-N
(_ _ (x I' x 2 ' ••• , xn )

as a result.

To a certain extent ;the procedure is of pure theoretical interest because

for non-trivial arguments its execution time increases beyond reasonable limits. It
is then necessary to replace the procedure by a more sophisticated one which avoids
that. at each calculation, one has to work through all "preceding" n-tuples. The
description of such procedures is beyond the scope of this course: it may suffice to
indicate that for n=1 and aI' a 2 ••••• ~ €!. k ~ 0:

(V * • A)-to-!:! ( a l a 2 ••• ~ ) = kE A(a.) x (card (!»k-i (**)

- i=1 ~

and that. consequently, the procedure reduces to the calculation of the right member
of this equality.

(-) i.e. put s = s+l.

(**) This formula shows that (!*, A)-to~is similar to (but not identical with)
the interpretation of a string as a number in base card (!:!); by the way, if
it were identical, (!* , A)-to-!:! would not be injective (see Section 2.4.1).
CHAPTER 3 COMPUTABLE FUNCTIONS

Abstract: The Turing machine is introduced both by describing

its physical model and by giving a formal (algebraic) definition
for it. The notion of computability of (V-string) functions is
derived from it. Finally, it is proved that any Turing machine
may be replaced by a Turing machine of a particular type, called
"normal" Turing machine.

3.1. Historical background

An axiomatic theory such as geometry essentially consists of a set of

axioms and a set of deduction rules. From these axioms one may obtain "automatically"
(Le. by "blindly" applying the deduction rules) all theorems of the theory, e.g.
all theorems of geometry or, in other words, all true statements concerning geometry.

For a long time and, in particular, during the nineteenth century

mathematicians have tried to set up axiomatic theories for branches of mathematics
other than geometry. This was tried in particular for the theory of natural numbers
- which, by the way, contains the predicate calculus as a constituent part.

In 1931 GBdel proved that the theory of natural numbers cannot be

defined by an axiomatic theory. More precisely, he proved that an axiomatic theory
for natural numbers would be either incomplete (i.e. not all true statements are
obtained in the form of a theorem) or inconsistent (i.e. the theory leads to theorems
expressing contradictory statements). He thus showed that there exist sets (viz.
the sets of all true statements concerning natural numbers) which are in some sense
not enumerable or, equivalently, that there exist functions (viz. the functions
which map the true statements concerning natural numbers into the value true and
the false statements concerning natural numbers into the value false) which are in
some sense not computable.
About 1936 Turing, Church and Post gave independently from each other
an apparently different definition for the notion of computability; more precisely,
Turing introduced the Turing machine, Church drew up the recursive function theory
and Post introduced a symbol manipulation system, now called Post system. Actually,
a few years later these three definitions were shown to be mathematically equivalent.
In the two last decades the study of computability developed in two
directions. The first direction tries to gain deeper insight into the notion of
computability and is connected with the study of the foundations of mathematics.
 - 24 -

The second direction is concerned with the study of notions which are less
general than computability such as finite state automata (being a special type
of Turing machines) or context-free grammars (being a special type of Post
systems), and is connected with mathematical linguistics and computer programming.

3.2. The basic idea of Turing

In Section 1.4.1 a function has been defined in a "static" way: the

definition does not (explicitly) give a "rule" (or "constructive procedure", or:
"algorithm", or: "program") for calculating the value of the function. But, as
already indicated in Section 1.4.4, the definition of a function is rather useless
as long as one does not possess such a rule, i.e. as long as one is not given a
"constructive definition" of the function; this is in particular true when the
domain of the function is not finite. Of course, such a rule must be precise;
actually, it has to be so precise that nothing is left to the initiative of the
(human) computer or, equivalently, that a clerk or a machine may execute it.

The idea of Turing is to define a function with the help of a machine.

Each of these machines is defined by a set of "instructions"; the working of the
machine consists in an "application" of these instructions and is interpreted as
being the calculation of the value of the function for given arguments.

Such a machine, called Turing machine, is said to be a "mathematical"

machine: this means that it might be constructed but that no implementation problems
(such as cost, maintenance, etc.) nor efficiency problems (such as speed) are
considered.

A Turing machine is essentially a string manipulating machine, i.e.

for a given vocabulary y it defines ay-string function. These strings may of course
be given an interpretation (e.g. nni's or truth values) and hence Turing machines
may be used for the definition of ~-functions, of predicates, etc. Nevertheless,
as already indicated strings will not be interpreted in this course and hence Turing
machines will exclusively be used for the definition of string functions.
3.3. Physical model

The structure and the working of a Turing machine will now be described
with the help of a physical model. The actual definition of a Turing machine will
be given in Section 3.4 but the (formal) definition given there is rather difficult
to grasp when not having the (informal) physical-model definition in mind.
 - 25 -

3.3.1. The machine

-----------
A Turing machine essentially consists of a "control unit",
a "tape" and a "read-write device" (Figure 2).

read-write device

tape

Control
unit

Figure 2: The physical model of a

Turing machine

The control unit which "makes the machine run" is at each moment in
a certain "state" out of a finite number of possible states; moreover it "contains"
a set of "instructions" which at each moment univocally determine the working of
the Turing machine; by the way, different Turing machines differ from each other
essentially by the nature of these instructions.

The tape is divided into squares; each square is able to contain a

symbol.
The read-write device covers exactly one square of the tape. It can
read the symbol contained by this square; it can also write a symbol on' this square
while erasing (by "overwriting") the symbol contained previously by it; finally the
read-write device can move over one square to the left or to the right, the tape
itself being immovable.
 - 26 -

A Turing machine is started with the control unit in a particular

state called the "start state" and with a string on its tape.

The working consists in the iterative execution of an elementary

step. Each such step consists in:
(i) the reading of a symbol, viz. the symbol under the head of the read-write
device;
(ii) the determination of the applicable instruction; this is done on the base
of the state of the control unit and of the result of the read operation;
(iii) the execution of the applicable instruction which consists in performing
successively the three following operations:
(a) putting the control unit into a new state;
(b) writing a symbol on the tape, - thus overwriting the symbol read
during step (i);
(c) moving the read-write device over one square to the left, moving it
over one square to the right or keeping it fixed.

The Turing machine halts when no instruction is applicable.

A Turing machine defines a (string) function thanks to the following

interpretation of its working.

The string on the tape at the start of the Turing machine is interpreted
as (a particular value for) the arguments of the function. The string on the tape
after halting is interpreted as the value of the function for these arguments. The
fact that the machine does not halt but continues working forever is interpreted
as the value of the function being undefined for the given arguments.

A Turing machine thus constitutes a "rule" which (allows to) calculate

the value of a function for given arguments, i.e. it constitutes a "constructive
defini tion" of a (partial) function.

One may consider a Turing machine as being constituted by two parts:

a control unit which makes the machine run in a step-by-step way, and a memory (*).
The memo.ry is itself constituted by the (current) state of the control unit and by
the contents of the tape. That the state constitutes a memory springs from the
fact that each state depends (among others) on the preceding state and hence tells
"something" about the history of the working. That the tape contents constitutes

(*) Note the similarity with an electronic computer.

 - 27 -

a memory is clear: it is possible to write a symbol on the tape and - after

some moves in one direction followed by some moves in the other direction -
read it at some later moment.

The set of states may Qe considered to provide a finite memory

because there are only a finite number of different possible states; in other
words the control unit can only distinguish between a finite number of classes
of "histories".

On the other hand the tape is said to provide an infinite memory

because it is possible to write symbols on an arbitrary large number of squares;
in fact, the Turing machine is allowed to run off the initially written part of
the tape.

Actually, the tape of a Turing machine has not to be itself of infinite

length but it should be possible to add a new square to it whenever the machine
asks for it or, more precisely, whenever the read-write device moves off the
(existing part of) the tape. The Turing machine may therefore be seen as a device
provided w{th a finite tape together with a paper tape factory rather than as a
device provided with an infinite tape; hence it is more precise to consider the tape
as a memory of unbounded rather than of infinite dimensions. This fact is also
illustrated by the following consideration: at each moment the used fraction of
the tape (or, equivalently, the string contained by the tape) is of finite length.

3.4. Formal definition of a Turing machine

The Turing machine has been defined above informally with the help of
a physical model. It will now be defined formally in a algebraic way.

In this formal definition references will be made to the physical model.

It should be clear that these references are not part of the definition but are mere
comments intended to facilitate the understanding.

A (V-) Turing machine (abbreviated: (Y-)TM) is defined by as-tuple

(Y, g, I, B, qs) in which:
(i) v is a vocabulary;
(ii) g is a finite set of symbols;
(iii) B is a symbol, B , Y;
(iv) qs is an element of g;
(v) I is a finite set of 5-tuples (q, a, q', a', 0) with
 - 28 -

- q, q I € .9.
[ - a, a I € V u {B}

- 6 € {L, R, o} where L, R, 0 are three different arbitrary

symbols
and with the following restriction:
- for any two different elements (ql' aI' qi. ai, 6,)
[ and (q2' a 2 , q2' a 2 , 6 2) of l it is not the case (R)

that simultaneously ql = q2 and a l = a2 •

V is called the voaabulary of the Turing maahine, the elements of .9. are called the
states, B is called the blank symbol, q is called the start state and the elements
s
of I are called the inst~uations. In the sequel an instruction is noted

(q, a) + (q', a ' • 6)

rather than
(q, a, q', ai, 6).

Interpreting these definitions on the physical model leads to the

following considerations. V is the vocabulary used by the arguments and the value
of the function to be defined; in other words, a ~-Turing machine is intended to
define a ~-string function • .9. is the set of states of the control unit. B is a
particular symbol which is supposed to be contained by each new square. q is the
s
state at the start of the Turing machine. Finally, an element

(q, a) + (q', a', 6)

means: when the control unit is in state q and the symbol read is a, then the
control unit has to be put into state q', the symbol a has to be overwritten by
the symbol a ' and the read-write device has to move one square to the left, to move
one square to the right or not to move, according to 6 being L, R or o. The
restriction (R) warrants that for a given state and a given read result at most one
instruction is applicable, i.e. that at each moment the next step of the Turing
machine is univocally defined.
 - 29 -

3.4.2.1. Definition

An instantaneous desoription (abbreviated: ID) of a given Turing

machine (V, Q, I, B, q ) is a triple (q, $, $) with
- - - s
- q is in Q
- $ is in (Y U {B})*
- $ is in (Y U {B})* - {e}

Interpreted on the physical model an ID may be considered as a

snapshot of the Turing machine: q is the state of the control unit, $ is the
left-hand part of the used fraction of the tape, $ is its right-hand part being
understood that it encompasses the symbol under the read-write device (Figure 3);
the condition $ ~ E warrants that there is always a symbol under the read-write
device. ~ ~

Figure 3: The instantaneous description of the Turing machine

is (q, $, $).

(*) Though an ID may have the same form as the right member of an instruction
it has an essentially different meaning!
 - 30 -

3.4.2.2. Applicable instruction

Let a (q A ".) be an arbitrary ID of a Turing machine

0' "'0' "'0
(!, ~, !, B, q s ). The instruction
(q, a) + (q', a', ~)

of I is said to be applicable to the ID a if

and a = head (1/1 0 ) (*)

Note that the restriction (R) of Section 3.4.1 implies that at most
one instruction of I is applicable to a given ID.

3.4.2.3. Initial and final instantaneous description.

An ID (q. $. 1/1) is initial if q = qS and $ = E.

An ID is final if no instruction is applicable to it.

3.4.3. The relation

----------------
~

3.4.3.1. The follower of an ID.

A construction will now be indicated which associates with a given
arbitrary non-final ID (of a given arbitrary Turing machine) another ID called
its follower.

Let T (!. ~, !. B, qs) be such a Turing machine and a = (q. $. a1/l)

with q € ~. a € V u {B}. $, 1/1 € (! U {B})* such a non-final ID. Let further

(q, a) + (q'. a'. ~)

be the applicable instruction of a.

The follower of the ID a is then per definition the ID B obtained as

follows:

(i) if ~ o then B (q', $, a'1/I);

(ii) ift'i R then

(a) if 1/1 +E (q', $a', 1/1)

(b) if 1/1 =E (q', $a', B);

(*) The function head has been introduced in Section 2.2; note that the value
head (1/10) is always defined as 1/10 + E.
 - 31 -

(iii) if 0 =L then

(a) if ~ +E , put ~ = ~ c
o
with c € V u {B} and ~ 0 € (V
-
U {B})*;
then B (q', ~o' ca'1/I);

(b) if ~ =E , B = (q', E, Ba'1/I).

 - 32 -

3.4.3.2. Interpretation on the physical model

Constructing the follower of an ID consists in executing an

elementary step.

The case 6 = 0 is illustrated by the Figure 4a; the cases

6 = R, W~ £ and 6 = R, W= £ are illustrated respectively by the Figures
4b and 4c.

w___
--$ -$

q q'

Figure 4a: 6 o

w ___
---$ ......+--w ___

Figure 4b: 6 R, W ~ £

Figure 4c: 6 R, W = £
 - 33 -

3.4.3.3. The relation ~

The fact that the ID B is the follower of the ID a is written:

or, if the Turing machine T is understood:

One may consider ~ as a relation between ID's. This relation is of

a rather particular nature because for a given ID a there exists at most one ID B
such that a ==-> B.

Per definition the relation

*
a==->B
T

between the ID's a and B holds if either a B or there exists a finite s~quence

of ID's
(n > 1)

such that

and

If T is understood one may also write

instead of *
a7 B.

Interpreted on the physical model the relation ~ represents the

consecutive execution of a certain number (possibly zero) elementary steps.

(*) The relation ~ constitutes the reflexive transitive closure of the relation
~.
 - 34 -

3.4.5. The functions defined

---------------------
The n-ary function fT defined by the -V-Turing machine
,n
T = (y, ~, I, B, qs) is the n-ary y-string function

f T,n- { (xI' x 2 ' ... , X , delete (B, yz»

n
I there exists

q E ~ such that (qs' E, x I Bx 2B.•• Bxn B) *

~(q,y,z), and (q,y,z) is a

final ID }. (*)

Less formally, if there exists a state q such that (q,y,z) is final then

otherwise

The interpretation on the physical model is as follows. The Turing

machine is started with the arguments on its tape, the arguments being separated
one from the other by the symbol B. When the Turing machine halts, the contents
of the tape from which the occurrences of the symbol B are deleted is the value
of the function for the given arguments; if the Turing machine does not halt, the
value of the function for the given arguments is undefined.

A Turing machine T defines an infinity of functions, namely fT I '

,
• It should be clear that a particular Turing machine is generally

designed in order to define one of these functions; the other functions are then
not considered and are, moreover, often trivial.

One may wonder why in the definition of fT the last argument x in

,n n
the initial ID (qs' E, xIB •.. BxnB) is followed by the symbol B. The reason is the

following: for the case n = I, XI = E, the triple (qs' E, xIB •.. Bxn ) is not an ID

because its third element is E.

(*) The function delete is defined in Section 2.2.

 - 35 -

That a Turing machine T = (~, g. !, B. qs) provides a constructive

definition (in the sense of Section 3.2) for the function fT clearly appears
,n
from the comments which accompany the preceding sections and which relate the
formal definitions to the physical model.

The constructive nature of the definition of the function fT also

,n
appears from the following procedure which "simulates" the working of the Turing
machine; this procedure constitutes a constructive definition of f by making
T,n
correspond with an arbitrary n-tuple (xI' x 2 ' ... , X)
n
E V*n the value
-
fT.n(X I , x 2 ' ••• , xn) when it is defined, and by not coming to an end when it is

undefined:

(i) put a = (qs' E, x I Bx 2B••• Bxn B); ( *)

(ii) determine by considering successively the different elements of I whether

or not a has a follower;

(iii) if a has no follower, stop; the result is delete (B, yz), y and z being
defined by a = (q, y, z);

(iv) if a has a follower, construct it and call it B;

(v) put a =B and go to step (ii).

3.5. Examples of Turing machines

3.5.1. ~!!~~_~!~~1~

Consider T = (~, g, !, B, qs) with

V = {a. b}

g {qo' q, qf}
B $ (*W)

(*) a is a variable to which a value may be assigned (cf. a variable in a

programming language).
(**)This equality expresses that the value of the variable B (resp. qs) is the
symbol $ (resp. qo).
 - 36 -

I consists of the following six instructions:

(qo' a) -+ (q, a, R) (I)

(qo' b) -+ (q, b, R) (2)

(qo' $) -+ (qo' $, 0) (3)

(q, a) -+ (q, $, R) (4)

(q, b) -+ (q, $, R) (5)

(q, $) -+ (qf' $, 0) (6)

It is now claimed that fT , ) is the {a,b}-string function head defined

in Section 2.2. (ii). This statement which is not proved here may be illustrated by
the following two examples:

(i) f T ,) (aba) =a because

(qo' e:, aba$)

===> (q, a, ba$) by application of the instruction () )

===> (q, a$, a$) by application of the instruction (5)

===> (q, a$$, $) by application of the instruction (4)

===> (qf' a$$, $) by application of the instruction (6)

(ii) fT , )(e:) is undefined because

(qo' e:, $)
===> (qo' e:, $) by application of the instruction (3)

===> (qo' e:, $) by application of the instruction (3)

etc.

From these two examples the role of the different instructions of I

appears to be as follows:

the instructions (I) and (2) recognize the leftmost symbol;

- the instruction (3) leads into an "infinite loop" for the argument e:;
- the instructions (4) and (5) erase the "tail" of the string;
- the instruction (6) leads to a final ID.
 - 37 -

Note that replacing the instruction (3) by, for instance, the
. instruction
(qo' $) + (qo' a, R)

leads to a Turing machine defining the same I-ary function: for the argument E it
never halts while filling the right fraction of its tape with (an infinite number
of occurrences of) the symbol a.

Consider the function string-subtraction over the vocabulary V = {I}

defined as follows:

The 2-ary function defined by the Turing machine T = (~, ~, !, B, q )

s
described below is claimed to be ssub:

V {J}

~= {qs' q 1 ' q2' q3' q4' q5' q6}

B B (lI!)

q = (lI!)
S qs
I consists of the following 12 instructions the role of which is indicated
to the right:

(qs' 1) + (qs' 1 , R)

1
locate the separating B
(qs' B) + (q 1 ' B, R)

(q 1 ' 1)

(q 1 ' B)
+

+
(q 1 ' I, R)

(q2 ' B, L)
] locate the rightmost 1

(q2 ' I) + (q 3' B, L) ] erase the rightmost 1

(q2 ' B) + (q4 ' B, 0) ] stop

(lI!) This equality expresses that the value of the variable B (resp. q ) is the
s
symbol B (resp. q ). As a difference with the example of Section 3.5.1 (see
s
the footnote of this Section), B (resp. qs) is now used for denoting two
different things: a variable and a value of a variable. This ambiguity in the
notation is not harmful provided the equality B = B (resp. q = q ) is inter-
s s
preted correctly.
 - 38 -

(q3' I)

(q3' B)
-+-

-+-
(q3' I ,

(qs' B,
L)

L) ] locate the separating B

(qs' I)

(qs' B)
-+-

-+-
(qs' I,

(q6 ' B, R)
L)

] locate the leftmost I

(q6 ' I) -+- (qs' B, R) ] erase the leftmost I

(q6 ' B) -+- (q6' B, 0) ] loop

The working of this Turing machine is illustrated by the three following

examples:

(i) ssub (II , I) = I because

(qs' E, IIBIB)
=> (qs' I , IBIB)
==> (qs' II, BIB)
==> (ql' lIB, IB)
=> (ql' IIBI, B)
=> (q2 ' lIB, IB)
=> (q3 ' II, BBB)
=> (qs' I, IBBB)
=> (qs' E, IIBBB)
=> (qs' E, BIIBBB)
=> (q6 ' B, IIBBB)
==> (qs' BB, IBBB)
=> (qs' BBI, BBB)
=> (ql' BBIB, BB)
=> (q2' BBI, BBB)
=> (q4 ' BBI, BBB)
(ii) ssub (E, E) =E because

(qs' E, BB)
==> (ql' B, B)
=> (qz' E, BB)
=> (q4 ' E, BB)
 - 39 -

(iii) ssub (E, I) is undefined because

(qs' E, BIB)
==;>
(ql' B, IB)
"'"""> (ql' BI, B)
=--;>
(q2 ' B, IB)
==;>
(q3' E, BBB)
="> (qs' E, BBBB)
="> (q6' B, BBB)
==;>
(q6' B, BBB)
etc.

3.6. Computable functions

Per definition, a (partial) n-ary ~-string function F is (partiaZ)

computabZe if there exists a ~-Turing machine T such that fT
,n
= F.

Less formally, a function is computable if there exists a Turing

machine defining it.

A totaZ computabZe function is defined similarly.

3.7. The thesis of Turing

Turing emitted the following thesis: each function for which there
exists a "rule" (or: "constructive procedure") to compute its value is a computable
function (~). Note that this thesis cannot be proved because it connects a
mathematical notion (viz. the Turing machine) to an empirical notion (viz. the
"rule"). Hence it bears similarities with a thesis (or: "law") asserting that a
certain mathematical equation is applicable to a physical phenomenon.

Apart from intuition the following facts corroborate the validity of

the thesis of Turing: first, no counterexamples have yet been found; second, other
definitions of computable functions resulting from completely different approaches
(such as the recursive function theory, the Post systems or the Markov algorithms)

(lI!) The notion "rule" has been introduced in Sections 1.4.4 and 3.2. The converse
of Turing's thesis was discussed in Section 3.4.6.
 - 40 -

have all been shown to be mathematically equivalent with the definition of

computable function based on Turing machines (*).

Showing that a function is computable is done by constructing a

,
Turing machine for it. Actually, the construction of a Turing machine is generally
a lengthy task and, moreover, the proof that it actually defines the function
intended is tedious. In the sequel the proof of computability will therefore often
be reduced to the informal description of a procedure for which it is intuitively
clear that it is constructive; the function defined by this constructive procedure
is then computable by virtue of the thesis of Turing.

For instance, the enumeration functions of Section 2.7 (and their

inverse functions) can easily be defined by such constructive procedures; this is
considered to be a sufficient argument for showing that these functions are or,
more precisely, may be proved to be computable.

3.B. Normal Turing machines

Let n ~ I be an integer, T = (V, Q, I, B, q ) a V-Turing machine.

- - - s -
Per definition, the Turing machine T is (n-)normaZ if there exists a
state qf € Q which satisfies the following condition:

for each ID, say (q, ~, W), for which there exist xI' x 2 ' ••• , xn € V*
such that
(qs' E, x I Bx 2 B••• Bxn B) (q, ~, W)

it is the case that:

(i) q F qf when (q, ~, W) is not a final ID;

(ii) q qf' ~ € {B}* and W€ ~*.{B}* when (q, ~, W) is a final ID (**).

Less formally, an n-normal Turing machine calculating the value of an

n-ary function halts if and only if it is in a particular state; moreover, the
value of the function defined is not intermixed with blank symbols and its leftmost
symbol is under the head of the read-write device.

(*) This equivalence between Turing machines and, for instance, Markov algorithms
has to be understood as follows: with each Turing machine it is possible to
associate a Markov algorithm defining the same n-ary function, and vice versa.
( ·*)~*.{B}* denotes the set product of V* and {B}* ( see Sect Lon
. 2 • 3) •
 - 41 -

3.8.2. b~~~_~~l: For any y-TM T one may construct a y-TM S which defines the
same y-string functions and which contains a particular state p such that an ID
of S is final if and only if the state of this ID is p.

Proof·

If T (V, Q, I, B, q ) is the given y-TM, construct the

=
- - - s
V-TM S (_V, Q , I , B, qs) with:
-s -s
g = g u {p}, pig
s
I
-s
= I u { (q, a) + (p, a, 0) I q IE: g, a IE: ~ u {B}

and there exists no q' IE: 9., a' IE: V u {B},

8 IE: {L, R, O} such that

(q, a) + (q', a' , 8) IE: I}.

Less formally, S is obtained by adding to I a set of instructions

transforming q into p for each pair (q, a) which does not occur as a left member
of an instruction of I.

It is clear that S halts if and only if it is in the state p and that

f
S,n
= f
T,n
for any n ~ I.

3.8.3. b~~~_~~~: Let V be a vocabulary, ! and? two symbols not in y and

~ = y u {!, ?}; for any pair (T, n) where T is a V-TM and n ~ I is an integer, one
may construct a W-TM R such that fR,n = {(xI' x 2 ' ... , xn ' ! y ?) I (xI' x 2 ' ... ,

X
n'
y) IE: fT
,n
}(*)

Proof·

The principle of the proof consists in constructing the ~-Turing

machine R in such a way that its working is identical with that of the y-Turing
machine T except that at each moment the used fraction of the tape is embraced by
the symbol pair ! , ?

(*) Note that though R is a ~-Turing machine, the domain of fR ,n is a subset of

V*n: the symbols and ? only appear in the value of fR •
,n
 - 42 -

IfT (V, Q, I, B, q ), put R = (W, Q , I , B, q ) with:

- - - s - """R -R sR

~ = (~ U {r, s, t} u {u. 1 I ~ i ~ n+J} U {V 1 q IE: Q} U {w 1 q IE: Q}(*)

1 q - q -

q = r
sR

,.I is obtained by adding to I the following instructions:

(r, a) + (s, a, L) ( la)

for each a IE: V U {B}

(s, B) + (u I' !, R) (1 b)

(u., a) + (u., a, R) (2a)

1 1

for each a IE: V and ~ i ~ n

(u i ' B) + (u i + I ' B, R) (2b)

for each I ~ i ~ n

(u., c) + (u., c, 0) (3)

1 1

for each c IE: {!, 7} and I ~ i ~ n

(Un + I ' B) + (t, 7, L) (4)

(t, a) + (t, a, L) (5a)

for each a IE: V U {B}

(t, ! ) + (qs' ., , R) (5b)

(q, ! ) + (v , B, L) (6a)
q
for each q IE: ~

(v , B)
q
+ (q, ., , R) (6b)

for each q IE: ~

(q, 7) + (w , B, R) (7a)
q
for each q IE: ~

(w , B) + (q, 7, L) (7b)
q
for each q IE: ~

(*) It is of course supposed that the (notation used for the) states added to ~ is
different from that of the states of~.
 - 4~ -

The working of the ~-Turing machine R is illustrated by the following

~comments. The instructions (Ia) through (Sb) are applied just after the start of
the Turing machine; their effect is to embrace the n arguments by the symbols ! and
7. More precisely, the instructions (Ia) and (Ib) write the symbol! to the left
of the first argument; the instructions (2a) and (2b) locate the symbol B following
the ~ argument; the instruction (3) warrants that the value of the function fR
,n
is undefined when one or more of the arguments is a string of W* - ~*, i.e. warrants
that the domain of fR is a subset of ~*n; the instruction (4) writes the symbol?
,n
to the right of the B following the nth argument; the instructions (Sa) and (Sb)
shift the read-write device to its initial position and start the (simulated working
of) the Turing machine T. The instructions (6a) and (6b) care for a correct working
when the read-write device shifts off the used fraction of the tape to the left; the
instructions (7a) and (7b) do the same for the case of a shift off to the right.

These comments clearly indicate that

3.8.4. !t~~E~~_~~l: For any pair (T, n) where T is a Turing machine and n ~ I is
an integer one may construct a Turing machine P which defines the same n-ary function
as T and which is n-normal.

Proof.

If T (~,~,!, B, qs) is the given ~-Turing machine, consider the

~Turing machine Q = (~, ~, !q' B, qsQ) obtained by applying to T successively the

constructions of Lemma 3.2 and Lemma 3.1. From what precedes it should be clear that
the Turing machine Q may be turned into an n-normal Turing machine defining the same
n-ary function as the Turing machine T if one succeeds in "cleaning" the result with
respect to the blank symbols and erasing the symbols! and ?

Let p be the state of Q , introduced by the construction of Lemma 3.1.

-'Q
Construct the ~Turing machine P = (~, 9?' !p' B, qsQ) with:

w, x} U {Ya I a € ~} U {za I a € ~}

!p is obtained by adding to I the following instructions:

"""Q
 - 44 -

(p, a) .... (p, a, L) (8a)

for each a € V u {B}

(p, ! ) .... (w, ., R)

I
(8b)

(w, B) .... (w, B, R) (9a)

(w, a) .... (y , B, L) (9b)

a
for each a € V

(w, 1) .... (x, B, L) (10)

(y , B)"" (y , B, L) ( Ila)
a a
for each a € V

(y , c) .... (z , c, R) ( lIb)
a a
for each a € V and c € V u {!}
(z , B) .... (w, a, R) (12)
a
(x, a) .... (x, a, L) (l3a)

for each a € V u {B}

(x, ! ) .... (qf' B, R) ( 13b)

The working of the Turing machine P is illustrated by the following

comments. The added instructions are applicable when the state p is entered, i.e.
when the (simulated working of the) Turing machine Q halts. The instructions (8a)
and (8b) locate the symbol !; the instructions (9a) and (9b) locate and erase the
leftmost symbol on the right part of the tape; the instruction (10) erases the
symbol 1; the instructions (1Ia) and (lIb) locate the rightmost symbol on the left
part of the tape while "carrying" the name of the symbol erased by the instruction
(9b); the instruction (12) writes this symbol down; finally, the instructions (13a)
and (13b) erase the symbol I

From these comments it should be clear that the Turing machine P is

n-normal and that f P,n = fT ,n •

3.8.5. ~~~~11!!l: An n-ary !-string function is computable if and only if there

exists an n-normal ~-Turing machine defining it, ~ being the vocabulary! extended
with two supplementary symbols.
CHAPTER 4 THE UNIVERSAL TURING MACHINE

Abstract: The notion of the universal V-Turing machine is

introduced and the thesis of Turing is-reformulated.

4. I. The string description of a Turing ma.chine

Let T = (V, Q, I, B, q ) be an arbitrary V-Turing machine. A little

- - - s -
thought indicates that this Turing machine is univocally defined by the set I of
its instructions, provided the blank symbol and the start state are represented
by two known symbols.

Suppose now that the blank symbol is taken to be the particular symbol B,
B I. ~ (*). Provide the finite set Q with an arbitrary alphabetic order, say Ao'

satisfying A (q )
o s
= 1. Replace each instruction of !, say

(q, a) + (q', a' , 0)

by the string

where Q is an arbitrary symbol with Q I. ~ U {B}. Finally, concatenate in some

arbitrary order the strings thus obtained and call e T the resulting string. It

should be clear that the string e T univocally defines the Turing machine T - except

for the exact names of the states (**); fortunately, this restriction is irrelevant
as far as the working of a Turing machine is concerned, this working being
independent from these names.

(*) cf. the footnote of Section 3.5.2.

(**) A knowledge 0 f these names would .
requ~re the knowledge of the .
alphabet~c

order A •
o
 - 46 -

As a conclusion, if ~ is a vocabulary not containing the symbols B

and Q, an arbitrary ~-Turing machine may be univocally described by a string,
viz. e T , over the (fixed) vocabulary V U {B, Q, L, R, O} (.). As an example,

the string
QaQQaRQbQQbRQBQBOQQaQQBRQQbQQBRQQBQQQBO

univocally describes the {a, b}-Turing machine of Section 3.5.1.

In general, there are several strings e T , describing a given Turing

machine: they differ by the choice for the alphabetic order Ao and by the order

in which the strings deduced from the instructions are concatenated.

On the other hand each string over the vocabulary ~ U {B, Q, L, R, a}

is not a description e T of a ~-Turing machine. To this end it has to be composed

of substrings QmaQna,o with m, n ~ I, a, a' € V U {B}, o € {L, R, a}; moreover,

the restriction CR) of Section 3.4.1 has to be satisfied. Clearly, it is possible
to design a constructive procedure determining whether or not a given arbitrary
string over ~ U {B, Q, L, R, O} is a description e T of a ~-Turing machine.

Let T = (~, ~, !, B, qs)' B, Q and e T be defined as above. Provide now

V with an arbitrary alphabetic order, say A. Moreover, put

~ = ~ U {B, Q, L, R, O}
and provide this vocabulary with the alphabetic order B defined as follows:

B = A U {B, card (~) + I} U {Q, card (~) + 2}

U {L, card (~) + 3} U {R, card (~) + 4}

U {a, card C~) + 5}

C·) The vocabularies ~ U {B, Q} and {L, R, a} need not be disjoint.

C**) This implies that the vocabularies ~ U {B, Q} and {L, R, a} are disjoint;
if this is not the case, the symbols of the latter vocabulary should
previously be "renamed" or, more precisely, replaced by symbols not in
V U {B, Q}.
 - 47 -

Consider now the function

V*-to-V*
~ -
or, more precisely
*
(~, B)-to-(~ *, A).

The string OVer V

d = V*-to-V*(e )
T ~ - T
is called a (~-)string description of the Turing machine T.
As a conclusion an arbitrary ~-Turing machine is univocally described
by a string over ~ (viz. the string description d T) together with an alphabetic

order in V (viz. A). In fact, from the alphabetic order A one may deduce the
alphabetic order B; A and B univocally define the . *
funct~on ~ -to-~;* further

e = V*-to-V*(d )
T - ~ T
and, as indicated in Section 4.1.1, e T univocally describes the ~-Turing machine T.

A Turing machine has in general different ~-string descriptions; they

differ from each other by their correspondent strings e T and/or by the alphabetic

order in V.

For the same reasons as above, each string over ~ is not a ~-string

description of a ~-Turing machine. But again it is possible to design a constructive

procedure determining whether or not an arbitrary given string over ~ is a ~-string

description of a ~-Turing machine; in other words, if a is an arbitrary given

symbol of ~, the ~-string function S defined by:
S ~ * -+- {a, e}

Sex) = if there exists a ~-Turing machine such that x is a

~-string description of it;

otherwise

is computable ( *).

(*) The choice of a and E is arbitrary: any two other strings of V* would do
as well. Note that S is a predicate if a and € are interpreted as true and
false respectively.
 - 48 -

4.2. The universal Turing machine

The procedure (i) to (v) of Section 3.4.6 simulates the working of

a given ~-Turing machine T calculating the value of an n-ary function. Actually,
this procedure may be made to simulate the working of any ~-Turing machine T
calculating the value of an n-ary function: to this effect (a description of) the
Turing machine T should be presented to the procedure in the form of a (supplementary)
argument. More precisely, consider the following procedure to which the (n+I)-tuple
(w, xl' x ' ••• , xn ) of (v*)n+I
_ is presented:
2

(i) compute Sew) (*);

if Sew) e, go to step (i) (**); if Sew) a, proceed;

(ii) determine the ~-Turing machine T of which w is a ~-string description;

(iii) perform steps (i) to (v) of the procedure of Section 3.4.6, being understood
that the Turing machine to be considered is the one determined during step
(ii) above.

It should be clear that this procedure is constructive and that it simulates the
working of an arbitrary ~-Turing machine, a ~-string description of which is
presented to it in the form of an argument. According to the thesis of Turing there
exists a ~-Turing machine, say U, which defines the same ~-string function as this
procedure, i.e. such that:
f
U,n+I few, xl' x 2 ' ••• , X n ' y) I Sew) =a and

(xl' x 2 ' •.. , Xn ' y) € fT,n where T is the ~-Turing

machine of which w is a ~-string

. .
descr~pt~on (***)} • ( 1)

As a conclusion, for a given vocabulary ~ (provided with an alphabetic

order A) there exists a ~-Turing machine U which "simulates" the working of any
other ~-Turing machine calculating the value of an n-ary function, in the sense that
fu,n+I satisfies the equality (1). This Turing machine U is called the universaZ
(
~- . mae h·~ne (****) .
) Tur~ng

(*) S is the function defined in Section 4.1.2; V is supposed to be provided

with a known alphabetic order A.
i.e. enter an infinite loop.
The existence of this Turing machine is implied by Sew) = a.
It is more correct to speak of "a" (rather than "the") universal Turing
machine: if there exists a Turing machine defining a function, there
exists an infinity of them.
 - 49 -

4.3. Discussion

The universal Turing machine is similar to a (general purpose)

computer: its first argument corresponds to the program (calculating the function
sine, for instance), its other arguments to the data (30 0 , for instance) for which
the calculation defined by the program has to be performed.

The definition of a computable function of Section 3.6 may now be

reformulated as follows:

an n-ary ~-string function F is computable if there exists

a string w, w ~ V* such that

F = {(XI' x z' ... , xn' y) I (w, xI' x z' ... , xn' y) ~ fu,n+l}
The thesis of Turing may be restated in a similar way; as a result this thesis
hinges on one machine (viz. the universal Turing machine) only.
CHAPTER 5 SOME FUNCTIONS WHICH ARE NOT COMPUTABLE

Abstract: It is shown that there exist functions which are not

computable. Some of them are of practical interest in computer
programming.

5.1. The halting problem

5.1.1. Introduction

Suppose one wants to calculate the value of the I-ary (*) function fT I
,
defined by a ~-Turing machine T for a given argument x.

Before starting the Turing machine it would be interesting to know

whether it will ever halt or not, i.e. whether fT I(x) is defined or not; in fact,
,
in the latter case it is not worthwhile to start it. It would thus be interesting
to be able to calculate the value of the 2-ary function H defined as follows: its
arguments are respectively a (string description of the) Turing machine T, and x;
its value is some symbol of ~, say a, if fT I(x) is defined, and E if fT I(x) is
, ,
undefined (**).

It is the goal of this section to prove that the ~-string function H

is not computable.

For a given vocabulary ~ the function H may be defined as follows:

provide ~ with an arbitrary alphabetic order, let a be an arbitrary symbol of V and
S be defined as in Section 4.1.2; then H is the 2-ary ~-string function

H : { x I Sex) a} x V* -+ {a, d:

H(x, y) = a if fT , I(Y) is defined, T being the ~-Turing

machine of which x is a string description;

E if fT I(Y) is undefined, T being the ~-Turing

,
machine of which x is a string description.

(*) For the sake of simplicity only I-ary functions are considered.

(**) cf. the last footnote of Section 4.1.2.

 - 51 -

Less formally:

[: if fT , l(y) is defined
H (d T , y)

if fT l(y) is undefined.
,

The principle of the proof consists in assuming the function H is

computable and in showing that this hypothesis leads to a contradiction.

If H is computable there exists a ~-Turing machine, say h, which

defines H, i.e. such that

Introduce now the 1-ary ~string function J:

J : { x I S(x) =a } + {a, g} : J(x) = H(x, x).

This function is identical with H except that it restricts its attention to the
case in which both arguments of H are equal. The function J provides an answer to
the question whether or not an arbitrarily given ~-Turing machine T halts when it
is started with the argument d T ; in other words J restricts its attention to the

working of a Turing machine which is started with its own description on the tape!
It is clear that the value of J is of theoretical interest only. Clearly, J is
computable because H is: a Turing machine j defining J may be identical with h
except that it first makes a copy of its argument (i.e. that it first replaces the
contents xB of its tape by xBxB).

Introduce now the 1-ary ~-string function K:

K : { x I J(x) = g } + {g} : K(x) = J(x).

This function is identical with J except that it is undefined when the value of J
is a. Again, K is computable because J is: the ~-Turing machine k defining K is
identical with j except that, when halts, k determines whether the result is a
or g; in the former case it enters an infinite loop, in the latter case it halts.

Let dk be a ~-string description of the ~-Turing machine k. Question:

is K(d k ) defined or not?
Suppose first that K(d k ) is not defined, i.e. that the ~-Turing machine
k does not halt after having been started with the string dk on its tape. Then, by
definition of the function H:
 - 52 -

Hence

and

i.e. K(d k ) is defined; this contradicts the assumption that K(d k ) is not defined.

Suppose now that K(~) is defined, i.e. that the ~-Turing machine k

halts after having been started with dk • Now

H(dk , dk ) = a

J(dk ) = a

and K(dk ) is undefined. Again this contradicts the assumption that K(d k ) is defined.

Hence both assumptions lead to a contradiction; this is impossible

because K(dk ) is either defined or not. Hence the hypothesis that H is a computable

function can not be verified. This proves the theorem.

5.1.4. Remark

It was just proved that there does not exist a Turing machine h which
for each arbitrarily given ~-Turing machine T and each arbitrarily given string x
in V* determines whether or not T halts after having been started with x.

But this does not exclude the existence of some Turing machine h' which
for each arbitrarily given ~Turing machine T out of some limited class of ~-Turing

machines and/or each arbitrarily given string x of some subset of ~* determines

whether or not T halts after having been started with x. For instance, if our
attention is limited to those ~-Turing machines which contain only one instruction,
it is possible to construct the corresponding Turing machine h'; equivalently, it
is possible to design a constructive procedure which for an arbitrarily given
~-Turing machine of this class and an arbitrarily given string x of ~* determines
whether or not T halts after having been started with x; in fact, if (q, a) +

(q', a', 6) is the (single) instruction of a ~-Turing machine, it does not halt
after having been started with x if and only if

q q', a = a', 6 0, x € {a}.V*

or: q q', a = a' = B, 6 € {R,L}, x = E.

 - 53 -

Another example is obtained if our attention is limited to the class consisting

of the (single) Turing machine of Section 3.5.1; in fact, this Turing machine
halts if and only if the string presented to it is not E.

As a conclusion the non-existence of the Turing machine h is related

to the generality of the function it has to define or, equivalently, to the extent
of the domain of this function; by restricting the domain in such a way as to
exclude all "nasty" cases (such as the case of the function K with the argument d k )

one yields a computable function.

The problem which consists in calculating the value of a total function

is said to be (un)solvable Cor: (un)deaidable) when the function is (not) computable.
For instance, one says that the halting problem for a Turing machine is unsolvable.

The fact that it is not possible to construct the Turing machine h may
- thanks to Turing's thesis - also be formulated as follows: it is not possible to
write a computer program which for an arbitrarily given other program, say P,
determines whether or not the execution time of P is finite. Note that this is not
equivalent to saying that it is not possible to write a computer program determining
whether or not an arbitrarily given other program enters an infinite loop during
its execution: when a program does not halt, this is not necessarily because it
. f'LnLte
enters an Ln . loop C*) •

5.2. The blank tape halting problem

5.2.1. Introduction
------------
The halting problem treated above appeared to be too general to be
solvable (see also Section 5.1.4). Therefore one may hope to be able to solve the
following, less general, problem: determine whether or not an arbitrarily given
~-Turing machine halts after having been started with a blank (**) tape.

(*) While the notion "entering an infinite loop" has never been exactly defined,
it suggests a behaviour of some cyclic nature (see e.g. Section 3.5.1).

( **) L.e.
. . .
contaLnLng .
a strLng of B, s.
 - 54 -

More precisely, the function to be studied now is a I-ary function H';

the argument of this function is a string description of a ~-Turing machine T;
the value of the function is a when fT I(e) is defined, e when fT I(e) is
undefined. (-) , ,

This problem is called the blank tape halting problem and is less
general than the halting problem in that only the ~-Turing machine is arbitrary,
the initial contents of the tape being fixed. Nevertheless, the function H' is not
a computable function neither, as will now be shown.

5.2.2. Proof

The principle of the proof consists in showing that if the blank tape
halting problem were solvable the halting problem would be solvable too.

Associate with each pair (T, x) where T is a ~-Turing machine and x is

a string of ~*, a ~-Turing machine T • This Turing machine T is identical with T
x x
except that after having been started it first writes the string x on its tape
- thus (partially) overwriting its initial contents. Hence, except for some
preliminary operations, the working of T started with a blank tape is identical
x
with the working of T started with x. In particular, Tx halts when started with a

blank tape if and only if T halts when started with the string x on its tape.

Assume now that the blank tape halting problem is solvable. The halting
problem is then solvable too. In fact, suppose it has to be determined whether or not an
arbitrarily given ~-Turing machine T halts when started with an arbitrarily given
string x on its tape. The following constructive procedure would yield the answer:
construct the Turing machine T associated with (T, x) as indicated above; determine
x
whether or not T halts when started with a blank tape (this is possible because
x
the blank tape halting problem is supposed to be solvable); the answer found is the
answer to the question whether or not T halts when started with x.

5.3. The uniform halting problem

The problem is now: determine whether or not an arbitrarily given

~-Turing machine halts whatever be the string of ~* on its tape at the start or,
in other words, determine for an arbitrarily given ~-Turing machine T whether or
not the ~-string function fT,1 is total.

(-) Note that fT,t(e) is defined if and only if f T ,2(e, e), f T ,3(e, e, e), ••• are
defined.
 - 55 -

The function to be studied now is a I-ary function H"; its argument

is a string description of a ~-Turing machine T; its value is a when fT is total,
,1
e: otherwise. Again, H" will be shown not to be computable.

5.3.2. Proof

The proof consists in showing that if the uniform halting problem were
solvable the blank tape halting problem would be solvable too.

To this end associate with each ~-Turing machine T a ~-Turing machine S

identical with T except that after having been started it first erases the contents
of the tape; hence the (second part of the) working of S started with an arbitrary
tape contents is identical with the working of T started with a blank tape. By the
way, S is a rather "uninteresting" Turing machine: the domain of the function fS 1
,
is either t h e empty set or ~ *; . the latter case its value is constant:
moreover, ln
fS , I(x) = fT I(e:) for any x
, € ~*. Anyhow, the function fS , 1 is total if and only if
the Turing machine T halts when started with a blank tape.

Assume now that the uniform halting problem is solvable. The blank tape
halting problem is then solvable too. In fact, suppose it has to be determined
whether or not an arbitrarily given ~-Turing machine T halts when started with a
blank tape. The following constructive procedure would yield the answer: construct
the Turing machine S associated with T; determine whether or not fS 1 is total; the
,
answer is also the answer to the question whether or not T halts when started with
a blank tape.

5.4. The equivalence problem

5.4.1. Introduction
Suppose F is a non-empty ( * ) computable I-ary ~-string function. The
problem is: determine for an arbitrarily given ~-Turing machine T whether or not
fT , 1 = F.
In other words, the function to be studied is a I-ary function ~; its

argument is a string description of a ~-Turing machine T; its value is a when

fT 1 = F, e: otherwise. Again, ~ is not computable.
,

(~) This excludes the trivial case of the function F {}, i.e. the function the
value of which is undefined for any argument.
 - 56 -

5.4.2. Proof

The proof consists in showing that the solvability of the equivalence

problem for the function F implies the solvability of the blank tape halting problem.

As F is a computable ~-string function there exists a ~-Turing machine R

such that fR , I F. Associate now with each ~-Turing machine T a ~-Turing machine P

the working of which, when started with x, consists of two parts executed
successively: the first part is identical with the working of T when started with a
blank tape, the second part is identical with the working of R when started with
x (*). Clearly, fp I
, =F if fT I(e) is defined, and fp I
, , = {} ( # F ) otherwise.

Assume now that the equivalence problem for the function F is solvable.
The blank tape halting problem is then solvable too. In fact, suppose it has to be
determined whether or not an arbitrarily given ~-Turing machine T halts when started
with a blank tape. Construct the associated Turing machine P and determine whether

, = F.
or not fp I The answer is also the answer to the question whether or not T

halts when started with a blank tape.

5.5. General remark

The fact that there exist unsolvable problems may be looked at from
two different points of view.

From a "pragmatic" point of view a problem is unsolvable because it is

too general to allow a solution. Actually, a problem is unsolvable when it includes
peculiar cases such as the one considered in the proof of Section 5.1.3. Hence, if
one restricts the problem such as to include only "normal" cases it should become
solvable. These "normal" cases certainly encompass, for instance, most of the
"daily-life" computer programs because a programmer is generally able to prove,
for instance, whether or not his program halts. Though this argument suggests that

(*) Note that during the first part the tape contents x have to be "saved" in order
to be available at the start of the second part. Though this may put some
"organizational" problems during the design of the Turing machine P, it may be
constructed: in fact, it is clear that there exists a constructive procedure
simulating the working of P.
 - 57 -

the existence of unsolvable problems is of pure theoretical interest, it appears

to be very difficult to clearly define what a "normal" case is; more precisely,
the numerous fruitless results of the last decade seem to indicate that it is
very difficult to restrict an unsolvable problem - such as the halting problem -
in such a way that it becomes solvable while still covering a reasonable amount
of non-trivial cases.

From a "philosophical" point of view a problem is unsolvable (i.e.

the corresponding Turing machine does not exist) because the theory is too "narrow".
This is comparable with the situation occurring in the theory of natural numbers in
which, for instance, the square root of 2 "does not exist". The solution then lies
in a "generalization" of the theory, e.g. in the replacement of the theory of
natural numbers by the theory of real numbers. Unfortunately, in a thus generalized
theory of computable functions the formal notion of computability would no longer
correspond with our intuitive notion of computability. Post expressed this fact by
saying that the existence of non-computable functions indicates the existence of
a "limitation of the mathematicizing power of the homo sapiens".
CHAPTER 6 EFFECTIVELY ENUMERABLE AND DECIDABLE SETS

Abstract: Effectively enumerable and decidable sets are defined

and some of their properties indicated.

6.1. Introduction

This chapter is concerned with sets of strings over a given vocabulary ~.

With the help of the notion of computable function two classes of sets are defined:
the effectively enumerable sets and the decidable sets.

The properties of effectively enumerable and of decidable sets shed

another light on the notion of computability. They are of direct use in the theory
of formal languages and, as a consequence, in mathematical logic and in the theory
of programming languages.

6.2. Definitions

Let V be a vocabulary and a one of its symbols.

With any set S of strings over V are associated two ~-string functions
defined as follows.

The acceptor function of the set S is the I-ary ~-string function

The particularity of this function is that its value is undefined for any argument
belonging to the complement of ~.

The decision function of the set S is the I-ary ~-string function

a if X € S
[
E if X € V* - S

As a difference with the acceptor function, the decision function is a total

~-string function.
 - 59 -

A set of strings over ~ is effectively enumerable when its acceptor

function is computable (~) (~~).

A set of strings over V is decidable when its decision function is

computable ( if).

Most sets one may think of are effectively enumerable as well as

decidable. For instance, it is easy (and even trivial!) to design a constructive
procedure which defines the acceptor or the decision function of the set

{anbn I n ~ I} over the vocabulary {a, b}.

6.3. Effectively enumerable sets and the domain of computable functions

~~~E~~_~~l: A set (of strings over a vocabulary ~) is effectively enumerable if

and only if it is the domain of a partial computable (I-ary ~-string) function.

Proof·
Suppose that S is the domain of the computable I-ary ~-string function F.
As F is computable there exists a ~-Turing machine T such that fT 1 = F. Consider
,
now the Turing machine R identical with T except for the following: when T halts,
R replaces the contents of the tape by the symbol a. Clearly, fR 1 = AS' i.e. the
,
Turing machine R defines the acceptor function of the set S. This proves the first
part of the theorem.

Suppose now that ~ is an effectively enumerable set. Then it is the

domain of its acceptor function which is a computable l-ary ~-string function. This
proves the second part of the theorem.

6.4. Effectively enumerable sets and the range of total computable functions

6.4.1. ~~~_~~l: Let ~ be an effectively enumerable set of strings over a

vocabulary V and d a symbol, d ~ ~; one may associate with this set a total
computable I-ary (~ u {d})-string function F V* ++ S u {d}.

(if) In older literature the terms "recursively enumerable" and "recursive"

replace "effectively enumerable" and "decidable".

( ~"') The term "effectively enumerable" should not be confused with the term
"denumerable" occurring in set theory.
 - 60 -

Proof·
Provide ~ with an alphabetic order, say A.

Consider the I-ary (~ u {d})-string function F defined by the following

constructive procedure which makes correspond with each string of V*, say x, a
string over ~ u {d}:

(i) determine the strings y, z € V* such that

x = ~*2 -to-~* (y, z) ~)

more precisely, compute

y
*2 *(1)
~ -to-~ (x)

*2 *(2)
z = ~ -to-~ (x)

(ii) compute the non-negative integer m defined by:

(iii) let T be a ~-Turing machine defining the acceptor function of the

(effectively enumerable) set Sand q and B its start state and blank
- s
symbol respectively; start T with the initial instantaneous description

(q , E, yB)
s
and (try to) apply successively m instructions;

(iv) distinguish the three following cases:

(1 0 ) it is not possible to apply m instructions because a final

instantaneous description is reached before; put F(x) = d;

(2 0 ) the instantaneous description obtained after having applied

m instructions is a final one; put F(x) = y;

(3 0 ) the instantaneous description obtained after having applied

m instructions is not a final instantaneous description;
put F(x) = d;
(v) stop.

(~) By ~*2_to-V* is meant the function (~*2, A)-to-(~*, A).

(~~) Remember that these functions are computable (section 3.7).

 - 61 -

It is clear that the domain of the I-ary function F defined by this

procedure is ~*; in fact. the procedure comes to an end for any string x. x € V*
The proof is now completed if the range of F is shown to be S u {d}.

If Yo # d is a string of the range of F. it is so by virtue of the

case (2 0 ) of step (iv). Hence it is a string of S by virtue of the definition

of the acceptor function.

Conversely. if y is a string of ~. the Turing machine T will halt

o
after the application of a finite number. say m • of instructions after having
o
been started with (q • E. Y B). Hence the procedure described will deliver y as
s 0 0

the value of the function F for the argument

V*2 -to-V * (y , N-to-V * (m »

- - 0 - - 0

Lemma 6.1 asserts that the elements of an effectively enumerable set

may all be obtained (Le. may be "enumerated") by calculating successively

F(!-to-~
* (0». * (I».
F(!-to-~
* (2» ••••
F(!-to-~

This enumeration is "effective" in the sense that the calculation of any value
F(x) of F takes only a finite amount of time. This property is at the origin of
the name "effective enumerability". ('II)

Note that from a practical point of view the enumeration of the

elements of ~ with the help of the function F has a bad efficiency: most of the
values of F are the symbol d and the acquisition of the elements of ~ proceeds
slowly. This is related to the fact that the arguments x of F are in some sense
in a one-to-one correspondence with the instantaneous descriptions of T (through
y and m). and that only such arguments deliver a string of S which correspond
with a final instantaneous description.

( *) By the way.
* * *
(0). !-to-~ (I). !-to-~ (2) ••••
!-to-~
is an effective enumeration of the elements of V*
 - 62 -

6.4.3. ~~~_~~~: If a set S of strings over ~ is the range of a total computable

I-ary ~-string function F : V* ++ S then S is effectively enumerable.

Proof.

Suppose x is an arbitrarily given string of V*.

Consider now the following procedure: calculate successively

F(~-to-~* (0», F(~-to-~* (I», F(~-to-~* (2»,

until a value equal to x is obtained; in that case, stop with the symbol a as
result.

It is clear that this procedure defines the acceptor function of the

set ~ ( *).

6.4.4. ~~~E~~_~~~: A non-empty set of strings over ~ is effectively enumerable

if and only if it is the range of a non-empty total computable I-ary ~-string
function.

Proof·

The "if" part of the theorem directly follows from Lemma 6.2.

In order to prove the "only if" part, let ~ be a non-empty effectively

enumerable set and F the function of Lemma 6.1. Consider the I-ary function E
defined by the following procedure which makes correspond with each string x of V*
another string of V*:

(i) calculate successively

F(~-to-~ * (0», F(~-to-~* (I», F(~-to-~* (2»,

until a value different from d is obtained; call x this value;
o
(ii) put E(x) = F(X) if F(x) f. d
[
x
o
if F(x) =d
(iii) stop.

It is easy to see that E is a function E : ~

* ++~;
. partLcular,
Ln . the execution
of step (i) takes only a finite amount of time as by hypothesis S is a not-empty
set, i.e. the string x exists.
o

(*) Note in particular that F is total and that, as a consequence, the computation
time of each value of F is finite.
 - 6~ -

6.5. A set which is not effectively enumerable

6.5.1. -------
The set

The goal of this section is to prove that there exist sets which are
not effectively enumerable.

To this end, the following set (of strings over a vocabulary y provided
with an alphabetic order and containing the symbol a) will be proved not to be
effectively enumerable:
p { x I S (x) a and fT,1 is total, T being the Y-Turing machine of which x

is a y-string description }

Less formally, ! is the set of the Turing machines defining a total I-ary function.

Assume that! is effectively enumerable. According to Theorem 6.2

there exists a total computable I-ary y-string function E the range of which is
p (n).

Consider now the I-ary y-string function D defined by

D : V* + V* : D(x) = cone (a, f U,2(E(X), x» ( 1)

where cone is the concatenation function (see Section 2.2) and U the universal
Y-Turing machine (***); that D is a total function directly follows from the fact
that E is a total function and that E(x) is a string description of a y-Turing
machine defining a total I-ary function.

Now, as D is a computable (* ••• ) y-string function there exists a

Y-Turing machine R which defines D. Let dR be a y-string description of it; by

definition of the universal y-Turing machine U any string x of the domain of D, i.e.
any x € V*, satisfies:

D(x) (2)

C·)
( .. )
S is the function of Section 4.1.2.
It is evident that P is not empty.

....
( ••• ) The notation cone (a, f U,2("'» is used instead of af u ,2("') for more
clarity.
( )
That D
.
1S computable
.
1S evident: E, fU 2 and cone are.
,
 - 64 -

But as R is a !-Turing machine defining a total I-ary function its ~string

descriptions and, in particular, the string d R must be elements of P. Hence, by

definition of the function E there must be a string Xo € V* such that

and (2) may be written

for all x € V* (3)

From (I) and (3) it follows that for all x €:!.... * the follow~ng. equality holds:

This leads to a contradiction for x = Xo because for any string y it cannot be

the case that y = cone (a, y). Hence the hypothesis that P is effectively enumerable
cannot be true.

6.5.3. f~E~ll~EI: The set of all effectively enumerable sets of strings over a
vocabulary! is a proper subset of the set of all sets of strings over V.

6.5.4. Comment

The principle of the proof of Section 6.5.2 may be illustrated by the

following (very informal!) proof of a similar property for non-negative integers.

Suppose it is possible to enumerate all total computable ]-ary

~-functions, for instance as

fo' f], f2'

Consider now the function

den) = ] + f (n) (a)

n

As den) is total it must appear somewhere in the list, i.e. for some no

den) = fn (n) (b)

o

The equalities (a) and (b) lead to

and, for n n :
o
 - 65 -

6.6. Decidable sets versus effectively enumerable sets

6.6.1. ~~~~_~~~: A decidable set (of strings over a given vocabulary~) is

effectively enumerable.

Proof·

A Turing machine TD defining the decision function of the set may be

turned into a Turing machine TA defining the acceptor function of the set by the

following modification: when TD halts with the result E, TA enters an infinite

loop.

6.6.2. ~~~~_~~~: The complement (with respect to ~*) of a decidable set (of strings
over a given vocabulary~) is effectively enumerable.

Proof·

A Turing machine TD defining the decision function of the set may be

turned into a Turing machine T' defining the acceptor function of the complement
A
of the set by the following modifications: when TD halts with the result a, TA

enters an infinite loop; when TD halts with the result E, TA halts with the result
a.

6.6.3. ~~~~_~~2: If a set ~ (of strings over ~) and its complement (with respect
to ~* ) are both effectively enumerable, the set S is decidable.
Proof·

Let TA and TA be two ~-Turing machines defining the acceptor function

of S and V* - S respectively.

Consider now the following procedure to which an arbitrary string x

of V* is given:

(i) prepare TA to start the acceptance test of the string x, i.e. make TA have

the instantaneous description (qs' E, xB) ( ); •

(ii) idem as step (i) for TA;

lJ
( ) qs and B are the start state and the blank symbol of TA.
 - 66 -

(iii) apply an instruction to TA; if the resulting instantaneous description is

a final one. stop with the result a;

(iv) apply an instruction to Tl; if the resulting instantaneous description is

a final one. stop with the result e;

(v) go to step (iii).

It is clear that this procedure defines the decision function of the set ~; note
in particular that it halts after a finite time: x is an element either of S or
of V* - S and hence either TA or Tl lead to a final instantaneous description after

a finite time.

6.6.4. !~~~!~~_§~~: A set ~ (of strings over a vocabulary~) is decidable if and

only if ~ and its complement (with respect to ~ *) is effectively enumerable.

Proof·
From Lemma 6.3. 6.4 and 6.S.

6.7. An effectively enumerable set which is not decidable

6.7.1. -------
The set

The goal of this section is to show on the hand of an example that

there exist effectively enumerable sets which are not decidable.

The following set of strings (over a vocabulary ~ provided with an

alphabetic order and containing the symbol a) will be proved to be effectively
enumerable while not being decidable:

Q = { x I there exist y. z € ~
* such that x = ~
*2 -to-~* (y, z).
S(y) = a and fT 1 (z) is defined. T being the ~-Turing
•
machine of which y is a ~-string description}.

Less formally, ~ is equivalent with the set of pairs (d T , z) such that fT,I(z) is
defined.

Consider the following procedure to which an arbitrary string x of V *

is presented:
(i) calculate the strings y and z defined by:
*2 *(1)
y = ~ -to-~ (x)

*2 *(2)
z = ~ -to-~ (x)
 - 67 -

(ii) calculate the value S(y); if S(y) = e, go to step (ii) (*);

(iii) start the !-Turing machine T of which y is a !-string description, with

the string z on its tape; if, after some time, this Turing machine halts,
stop with the result a.

It is clear that this procedure defines the acceptor function of g; note in

particular that step (iii) does not terminate if and only if fT,I(z) is undefined.

Hence the set g is effectively enumerable.

Consider now the following procedure to which an arbitrary pair

( y, )
Z E!
*2.
~s presented:

(i) calculate S(y); if S(y) e, go to step (i);

(ii) calculate the value

where DQ is the decision function of the set g;

(iii) stop with the value obtained during step (ii) as a result.

Clearly, this procedure defines the function H of Section 5.1.2. If the set g
were decidable, this procedure would be constructive and, consequently, the
function H would be computable; less formally, the decidability of Q would imply
the solvability of the halting problem. Hence the set g is not decidable.

6.7.3. g~!~ll~!~: The set of all decidable sets of strings over a vocabulary V
is a proper subset of the set of all effectively enumerable sets of strings over V.

6.7.4. Note

The set V*- g where Q is defined as in Section 6.7.2 is not effectively

enumerable. This directly follows from Theorem 6.3.

(.) i.e. enter an infinite loop.

 - 68 -

6.8. Some informal comments

6.8.1. ~_EE~~!~~~l_~~E~~!

When a set is decidable it is possible to determine whether or not

an arbitrarily given string is one of its elements. This determination may be
done for instance by a Turing machine, or by hand according to a procedure, or
by a computer through execution of a program.

When a set is effectively enumerable its sentences may be enumerated

(by a Turing machine, by hand, by a computer) but is is not necessarily possible
to determine whether or not an arbitrarily given string is an element of this
set. More precisely, when a set is effectively enumerable without being decidable
it is possible to decide (with the help of a Turing machine, by hand, by a
computer) that an arbitrarily given string is an element of the set, if such is
the case; but it is in general not possible to decide that an arbitrarily given
string is not an element of this set: in fact, as long as the Turing machine
defining the acceptor function did not halt one does not know whether it will
halt at some later time or never halt.

A programming language may be considered as the set of all correct

programs written in this language. Clearly, it is highly desirable that such
a language be decidable in order to be able to detect the incorrect programs,
i.e. the programs containing one or more (syntactical) errors.
 - 69 -

The results of Section 6.5 and Section 6.7 may be represented

graphically as follows:

the set of all sets of strings over V

the set of all effectively enumerable

sets of strings over V

the set of all decidable sets of strings over V

A subset of a decidable set is not necessarily decidable: such a

subset may even be not effectively enumerable! For instance, any non effectively
enumerable set of strings over y, such as the set! of Section 6.5.1, is a proper
subset of the decidable set y*(*). This situation may be represented graphically as
follows:

a set which is decidable, e.g. V*

a set which is not effectively enumerable, e.g. P

Note that this figure represents sets of strings whereas the figure of Section
6.8.2 represents sets of sets of strings.

Intuitively, this means that a decidable set differs from a set

which is not decidable by the smaller "variety" of its strings rather than by the
smaller "number" of its strings.

A similar remark holds for the effectively enumerable sets.

(*) The decision function of V*:

D : *
~ ~ {a, £} : D(x) = a
is clearly computable, hence V* is decidable.
 - 10 -

6.8.4. ~~!~~~!!E_~~~£~~~

An axiomatic system defines by construction an effectively

enumerable set of strings. In mathematical logic, for instance, these strings
are interpreted as theorems.

GBdel whose theorem was already mentioned in Section 3.1 has

proved that the set of truths in mathematics is not effectively enumerable
(while the set of truths in geometry is).
 - 71 -

APPENDIX I BIBLIOGRAPHICAL NOTES

As already mentioned in the Preface most treatises on computability

are oriented towards the foundations of mathematics.
A classical and very clearly written book is [I]. Another recommendable
volume is [2] but it is based on recursive functions rather than on Turing machines.
For a good intuitive understanding [3] may be helpful. Note that there exists a
great amount of other books devoted to the same subject.
A treatment of the subject somewhat more oriented towards computer
science is to be found in some chapters of [4, 5, 6]: in [4] the subject is treated
in a rigorous but very concise way; [5] insists on the intuitive understanding;
[6] is in its goals related to the present notes but the study is conducted with
less mathematical rigor.

[I] M. Davis, Computability and Unsolvability, McGraw-Hill, New York, 1958.

[2] Hartley Rogers, Theory of Recursive Functions and Effective Computability,

McGraw-Hill, New York, 1967.

[3] M. Minsky, Computation: Finite and Infinite Machines, Prentice-Hall,

Englewood Cliffs, 1967.

[4] M.A. Arbib, Theories of Abstract Automata, Prentice-Hall, Englewood Cliffs,

1969.

[5] M. Gross, A. Lentin, Notions sur les grammaires formelles, Gauthiers-villars,

Paris, 1967. (An English translation appeared in 1970).

[6] J.E. Hopcroft, J.D. Ullman, Formal Languages and their Relation to Automata,
Addison-Wesley, Reading (Mass.), 1969.
 - 72 -

APPENDIX 2 LIST OF THE MOST IMPORTANT NOTATIONS

The Section Number indicates where the notation has been introduced.

(a, b, c) 1.2.2.1 F{i) 1.4.5.

{a, b, c} 1.2.2.2 £ 2.1

{ } 1.2.2.2 V 2.1

{ x I P{x)} 1.2.2.2 V* 2.1

a € S 1.3.1 conc 2.2

a ~ S I. 3.1 head 2.2

S c T 1.3.1 delete 2.2

SeT 1.3.1 reverse 2.2

R
card(n) 1.3.1 x 2.2
n
S u T 1.3.2 a 2.3

S n T I. 3.2 l(x) 2.3

S \ T 1.3.2 S.T 2.3

S - T 1.3.2 A 2.5

S I. 3.2 ('!...*n, A)-to-!!, 2.7.1

S x T 1.3.2 V*n -to-N 2.7.1

Sn 1.3.2 V*-to-N 2.7.1

*
1.4.2 !!,-to-('!... ' A) 2.7.1
~
1.4.2 N-to-V* 2.7.1
~
*n * 2.7.2
N 1.4.2,1.5.2 ('!... ' A)-to-(~ , B)

F 1.4.3 V*n -to-W* 2.7.2

F(a l , ... , a )
n
1.4.3 V* -to-W* 2.7.2

F S -+ T 1.4.3 9. 3.4.1

F S ++- T 1.4.3 B 3.4.1

F 1.4.5 qs 3.4.1
 -n -
I 3.4. I eT 4.1.1

f3 3.4.3.3 4.1.2
Q=!>
T ~
Q=!> f3 3.4.3.3 dT 4. I .2

Q=!> * f3 3.4.4 S 4.1.2

T

Q=!> * f3 3.4.4 U 4.2

f 3.4.5 AS 6.2. I
T,n

qf 3.8. I DS 6.2. I
 - 74 -

APPENDIX 3 LIST OF THE MOST IMPORTANT CONCEPTS

The Section Number indicates where the concept has been introduced.

acceptor function 6.2.1

alphabetic order 2.5
applicable (instruction) 3.4.2.2

blank symbol 3.4.1

cartesian product 1.3.2

complement 1.3.2, 1.5.2.3, 2.3
computable 3.6
constructive procedure 3.7

decidable (problem) 5.1.5

decidab Ie (set) 6.2.2
decision function 6.2.1
difference (of sets) 1.3.2
disjoint 1.3.1
domain 1.4.2

effectively enumerable 6.2.2

element (of a set) 1.2.1
empty (set) 1.2.2.2
empty (string) 2.1

final (instantaneous description) 3.4.2.3

finite (set) 1.3.1
follower 3.4.3.1
function 1.4.1

ID 3.4.2
initial (instantaneous description) 3.4.2.3
injective 1.4.5
instantaneous description 3.4.2
instruction 3.4.1
interpretation (of a string) 2.4.2
intersection 1.3.2
inverse (function) 1.4.5
 - 75 -

length (of a string) 2.3

mapping 1.4.1
monoid 2.1

n-ary (function) 1.4.1

natural (function) 1.5.2
N-function 1.5.2
nni 1 .1 , 1.5.2
n-normal (Turing machine) 3.8.1
normal (Turing machine) 3.8.1
n-tuple 1.2.1

object 1.1
occurrence 2.1
operation 1.4.1
ordered sequence 1.2.1

pair 1.2.1
partial computable 3.6
partial function 1.5.2.2, 2.2
predicate 1.5.1
procedure 3.2, 3.7
proper (subset) 1.3.1
proper (substring) 2.1

range 1.4.2
relation 1.5.1

set 1.2.1
setproduct 2.3
solvable 5.1.5
start state 3.4.1
state (of a Turing machine) 3.4.1
string 2.1
string description 4.1.2
subset 1.3.1
substring 2.1
symbol 2.1
 - 76 -

TM 3.4.1
total computable 3.6
total (function) 1.5.2.2, 2.2
Turing machine 3.4.1

undecidable (problem) 5.1.5

undefined (value) 1.4.1
union 1.3.2
universal (~-)Turing machine) 4.2
unsolvable 5.1.5

value 1.4.1
vocabulary 2.1
y-string description 4.1.2
y-string function 2.2
V-TM 3.4.1
y-Turing machine 3.4.1
 Lecture Notes in Economics and Mathematical Systems
(Vol. 1-15: Lecture Notes in Operations Research and Mathematical Economics, Vol. 16-59: Lecture Notes in
Operations Research and Mathematical Systems)
Vol. 1: H. Bilhlmann, H. Loeffel, E. Nievergelt, Einfilhrung in die Vol. 36: M. P. J. Magill, On a General Economic Theory of Motion.
Theorie und Praxis der Entscheidung bei Unsicherheit 2. Auflage, VI, 95 pages. 4°. 1970. OM 16,-
IV, 125 Seiten 4°.1969. OM 16,- Vol. 37: H. Milller-Merbach, On Round.()ff Errors in Linear Program-
Vol. 2: U. N. Bhat, A Study of the Queueing Systems M/G/1 and ming. VI, 48 pages. 4°.1970. OM 16,-
GIIM/1. VIII, 78 pages. 4°.1968. OM 16,- Vol. 38: Statistische Methoden I, herausgegeben von E. Walter. VIII,
Vol. 3: A Strauss, An Introduction to Optimal Control Theory. VI, 338 Seiten. 4°. 1970. OM 22,-
153 pages. 4°.1968. OM 16,- Vol. 39: Statistische Methoden II, herausgegeben von E. Walter. IV,
Vol. 4: Einfilhrung in die Methode Branch and Bound. Herausgegeben 155 Seiten. 4°. 1970. OM 16,-
. von F. Weinberg. VIII, 159 Seiten. 4°.1968. OM 16,- Vol. 40: H. Orygas, The Cocrdinate-Free Approach to Gauss-Markov
Vol. 5: Hyvarinen, Information Theory for Systems Engineers. VIII, Estimation. VIII, 113 pages. 4°. 1970. OM 16,-
205 pages. 4°.1968. OM 16,- Vol. 41 : U. Ueing, Zwei Losungsmethoden fOr nichtkonvexe Program-
Vol. 6: H. P. Kilnzi, O. Milller, E. Nieverllelt, Einfilhrungskursus in mierungsprobleme. VI, 92 Seiten. 4°.1971. OM 16,-
die dynamische Programmierung. IV, 103 Seiten. 4°. 1988. OM 16,- Vol. 42:' A V. Balakrishnan, Introduction to Optimization Theory in
Vol. 7: W. Popp, Einfilhrung in die Theorie der Lagerhaltung. VI, 173 a Hilbert Space. IV, 153 pages. 4°.1971. OM 16,-
Seiten. 4°. 1968. OM 16,- Vol. 43: J. A Morales, Bayesian Full Information Structural Analysis.
Vol. 8: J. Teghem, J. Loris'Teghem, J. P. Lambotte, Modeles d'Attente VI, 154 pages. 4°.1971. OM 16,-
MIGl1 et Gr/M/1 a Arrivees et Services en Groupes. IV, 53 pages. Vol. 44: G. Feichtinger, Stochastische Modelle demographischer Pro·
4°.1969. OM 16,- zesse. XIII, 404 pages. 4'. 1971. OM 28,-
Vol. 9: E. Schultze, Einfilhrung in die mathematischen Grundlagen der Vol. 45: K Wendler, Hauptaustauschschritte (Principal Pivoting). II,
Informationstheorie. VI, 116 Seiten. 4°. 1969. OM 16,- 64 pages. 4°. 1971. OM 16,-
Vol. 10: O. Hochstadter, Stochastische Lagerhaltungsmodelle. VI, Vol. 46: C. Boucher, L~ons sur la theorie des automates mathemati-
269 Seiten. 4°. 1969. OM 18,- ques. VIII, 193 pages. 4 .1971. OM 18,-
Vol. 11/12: Mathematical Systems Theory and Economics. Edited by Vol. 47: H. A. Nour Bdin, Optimierung Ii nearer Regelsysteme mit
H. W. Kuhn and G. P. Szego. VIII, IV, 486 pages. 4°. 1969. OM 34,- quadrati scher Zielfunktion. VIII, 163 pages. 4°. 1971. OM 16,-
Vol. 13: Heuristische Planungsmethoden. Herausgegeben von F. Vol. 48: M. Constam, Fortran fOr Anfanger. VI, 143 pages. 4°.1971.
Weinberg und C. A Zehnder. II, 93 Seiten. 4°. 1969. OM 16,- OM 16,-
Vol. 14: Computing Methods in Optimization Problems. Edited by A. Vol. 49: Ch. SchneeweiB, Regelungstechnische stochastische Opti-
V. Balakrishnan. V, 191 pages. 4°.1969. OM 16,- mierungsverfahren. XI, 254 pages. 4°.1971. OM 22,-
Vol. 15: Economic Models, Estimation and Risk Programming: Essays Vol. 50: Unternehmensforschung Heute - Ubersichtsvortrage der
in Honor of Gerhard Tintner. Edited by K A Fox, G. V. L. Naraslm- Zilricher Tagung von SVOR und OGU, September 197':>. Heraus-
ham and J. K Sengupta. VIII, 461 pages. 4°. 1969. OM 24,- gegeben von M. Beckmann. VI, 133 pages. 4°.1971. OM 16,-
Vol. 16: H. P. Kilnzi und W. OetUi, NichtlineareOptimierung: Neuere Vol. 51: Oigitale Simulation. Herausgegeben von K Bauknecht und
Verfahren, Bibliographie. IV, 180 Seiten. 4°.1969. OM 16,- W. Net. IV, 207 pages. 4°.1971. OM 18,-
Vol. 17: H. Bauer und K Neumann, Berechnung optimaler Steuerun· Vol. 52: Invariant Imbedding. Proceedings of the Summer Workshop
gen, Maximumprinzip und dynamische Optimierung. VIII, 188 Seiten. on Invariant Imbedding Held at the University of Southern Californoa,
4°.1969. OM 16,- June - August 1970. Edited by R E. Bellman and E. O. Denman. IV,
Vol. 18: M. Wolff, Optimale Instandhaltungspclitiken in einfachen 148 pages. 4°.1971. OM 16,-
System en. V, 143 Seiten. 4°.1970. OM 16,- Vol. 53: J. Rosenmilller, Kooperative Spiele und Markte.IV, 152 pages.
Vol. 19: L. Hyvarinen, Mathematical Modeling for Industrial Processes. 4°. 1971. OM 16,-
VI, 122 pages. 4°.1970. OM 16,- Vol. 54: C. C. von Weizsacker, Steady State Capital Theory. III, 102
Vol. 20: G. Uebe, Optimale Fahrplane. IX, 161 Seiten. 4°. 1970. pages. 4°.1971. OM 16,-
OM 16,- Vol. 55: P. A. V. B. Swamy, Statistical Inference in Random Coef-
Vol. 21: Th. Liebling, Graphentheorie in Planungs· und Tourenproble· ficient RegreSSion Models. VIII, 209 pages. 4°. 1971. OM 20,-
men am Beispiel des stadtischen StraBendienstes.IX,118 Seiten. 4°. Vol. 56: Mohamed A 8-Hodiri, Constrained Extrema Introduction
1970. OM 16,- to the Differentiable Case with Economic Applications. III, 130 pages.
Vol. 22: W. Eichhorn, Theorie der homogenen Produ ktionsfunktion. 4°.1971. OM 16,-
VIII, 119 Seiten. 4°.1970. OM 16,- Vol. 57: E. Freund, Zeitvariable MehrgrOBensysteme. VII, 160 pages.
Vol. 23: A. Ghosal, Some Aspects of Queueing and Storage Systems. 4°.1971. OM 18,-
IV, 93 pages. 4°. 1970. OM 16,-
Vol. 58: P. B. Hagelschuer, Theorie der linearen Oekornposition.
Vol. 24: Feichtinger, Lernprozesse in stochastischen Automaten. V, VII, 191 pages. 4°.1971. OM 18,-
66 Seiten. 4°.1970. OM 16,-
Vol. 59: J. A Hanson, Growth in Open Economics. IV, 127 pages.
Vol. 25: R Henn und O. Opitz, Konsum· und Produktionstheorie. I. 4'.1971. OM 16,-
11,124 Seiten. 4°.1970. OM 16,-
Vol. 60: H. Hauptmann, Schatz· und Kontrolltheorie in stetigen dy·
Vol. 26: O. Hochstadter und G. Uebe, Okonometrische Methoden. namischen Wirtschaftsmodellen. V, 104 pages. 4°. 1971. OM 16,-
XII, 250 Seiten. 4°. 1970. OM 18,-
Vol. 61: K. H. F. Meyer, Wartesysteme mit variabler Bearbeitungs-
Vol. 27: I. H. Mufti, Computational Methods in Optimal Control Prob· rate. VII, 314 pages. 4°.1971. OM 24,-
lems. IV, 45 pages. 4°.1970. OM 16,-
Vol. 62: W. Krelle u. G. Gabisch unter Mitarbeit von J. Burgermeister,
Vol. 28: Theoretical Approaches to Non·Numerical Problem Solving. Wachstumstheorie. VII, 223 pages. 4°.1972. OM 20,-
Edited by R B. Banerjl and M. O. Mesarovic. VI, 466 pages. 4°. 1970.
OM 24,- Vol. 63: J. Kohlas, Monte Carlo Simulation im Operations Research.
Vol. 29: S. E. Bmaghra'?,Y, Some Network Models in Management VI, 162 pages. 4°. 1972. OM 16,-
Science. III, 177 pages. 4 . 1970. OM 16,- Vol. 64: P. Gessner u. K Spremann, Optimierung in Funktionen·
Vol. 30: H. Noltemeier, Sensitivitatsanalyse bei diskreten Ii nearen raumen.IV, 120 pages. 4°. 1972. OM 16,-.
Optimierungsproblemen. VI, 102 Seiten. 4°.1970. OM 16,-
Vol. 65: W. Everling, Exercises in Computer Systems Analysis.
Vol. 31: M. KUhlmeyer, Die nichtzentrale t-Verteilung. II, 106 Seiten. VIII, 184 pages. 4°.1972. OM 18,-
4°.1970. OM 16,-
Vol. 66: F. Bauer, P. Garabedian und O. Korn, Supercritical Wing
Vol. 32: F. Bartholomes und G. Hotz, Homomorphismen und Reduk- Sections. V, 211 pages. 4°.1972. OM 20,-.
tionen linearerSprachen. XII, 143 Seiten. 4°.1970. OM 16,-
Vol. 67: I. V. Girsanov, Lectures on Mathematical Theory of Extremum
Vol. 33: K Hinderer, Foundations of Non-stationary Dynamic Pro- Problems. V, 136 pages. 4°.1972. OM 16,-.
gramming with Discrete Time Parameter. VI, 160 paRes. 4°. 1970.
OM 16,- Vol. 68: J. Loeckx, Computability and Oecidability. An Introduction
for Students of Computer Science. VI, 76 pages. 4°.1972. OM 16,-
Vol. 34: H. Stormer, Semi-Markoff·Prozesse mit endlich vielen Zu·
standen. Theorie und Anwendungen. VII, 128 Seiten. 4°. 1970.
OM 16,-
Vol. 35: F. Ferschl, Markovketten. VI, 168 Seiten. 4°. 1970. OM 16,-