What is an algorithm?

Yuri Gurevich
Microsoft Research

Technical Report
MSR-TR-2011-116, July 2011

Microsoft Research
Microsoft Corporation
One Microsoft Way
Redmond, WA 98052
0 Preamble
We present a two-part exposition on the notion of algorithm and foun-
dational analyses of computation. The first part is below, and the sec-
ond is here: http://research.microsoft.com/en-us/um/people/gurevich/
Opera/210.pdf. This preamble was added in February 2012.
In the first part, after a short introduction, we clarify some common
misconceptions related to Turing’s analysis of computation, consider whether
the notion of algorithm can be rigorously defined in full generality, discuss
what kind of entities algorithms are, and examine two approaches to the
title problem in the literature. The first part appeared in “SOFSEM 2012:
Theory and Practice of Computer Science,” Springer LNCS 7147, 31–42.
The second part is devoted entirely to fundamental analyses of computa-
tions in the literature, by Turing and by others including this author. It will
appear in the proceedings of “Turing Centenary Conference, CiE 2012: How
the World Computes,” to be held in Cambridge, England, in June 2012.

1
 What is an algorithm?
Yuri Gurevich
Microsoft Research

We must, incidentally, make it clear from the beginning

that if a thing is not a science, it is not necessarily bad.
For example, love is not a science. So, if something is said
not to be a science, it does not mean that there is something
wrong with it; it just means that it is not a science.
–Richard Feynman

1 Introduction
Two articles in a recent book [10] present two approaches to the title problem
and offer different answers. Article [19] presents an approach developed by
Yiannis Moschovakis. “A characteristic feature of this approach is the adop-
tion of a very abstract notion of algorithm that takes recursion as a primitive
operation and is so wide as to admit ‘non-implementable’ algorithms” [19,
p.87]. The article starts thus.

In the sequence of articles . . . , Moschovakis has proposed a math-

ematical modeling of the notion of algorithm — a set-theoretic
“definition” of algorithms, much like the “definition” of real num-
bers as Dedekind cuts on the rationals or that of random variables
as measurable functions on a probability space.

We discuss this definition of algorithms in §6.

Article [22] presents an approach originally developed by Robin Gandy, a
student of Alan Turing, in a 1980 article [9]. Gandy intended to complement
Turing’s analysis of human computers with an analysis of computation by
mechanical devices. He came up with an axiomatically defined class of com-
putation devices, later named Gandy machines. The approach was adopted

2
by Wilfried Sieg. In article [22], Sieg uses Gandy machines to “dispense with
[Church’s and Turing’s] theses”. The article starts thus.

Church’s and Turing’s theses dogmatically assert that an infor-

mal notion of effective calculability is adequately captured by a
particular mathematical concept of computability. I present an
analysis of calculability that . . . dispenses with theses. . . . The
analysis leads to axioms for discrete dynamical systems (repre-
senting human and machine computations) and allows the reduc-
tion of models of these axioms to Turing machines.

We discuss this axiomatization of discrete dynamical systems and dispensing

with the theses in §4.
In §2, we discuss whether it is possible at all to define algorithms. (There
is also a question why bother to define algorithms. Well, understanding
what algorithms are should — and does — have practical applications, to
software specification and model-based testing in particular, as well as theo-
retical application, like semantics of software or algorithmic completeness of
computation models. But that is a different issue to be addressed elsewhere.)
In §3, we discuss and clarify a couple of misconceptions related to Turing’s
analysis of computations. In §4 we discuss Gandy machines. In §5, we discuss
what kind of entities algorithms are; this discussion is closely related to §6
where we discuss Moschovakis’s recursor theory.
This article can be seen as a companion to our older article [5].

Acknowledgments
Many thanks to Andreas Blass for numerous illuminating discussions, and to
Serge Grigorieff and Oron Shagrir for useful suggestion.

3
2 Can the notion of algorithm be rigorously
defined?
Two articles [19] and [22], mentioned in §1, give different answers to the
title question. The two answers are not at all equivalent. A question arises
whether the notion of algorithm can be defined at all. The answer is yes and
no. Let us explain.

The negative answer

In our opinion, the notion of algorithm cannot be rigorously defined in full
generality, at least for the time being. The reason is that the notion is
expanding.
Concerning the analogy of algorithms to real numbers, mentioned in §1,
Andreas Blass suggested a better analogy: algorithms to numbers. Many
kinds of numbers have been introduced throughout history: positive integers,
natural numbers, rationals, reals, complex numbers, quaternions, infinite car-
dinals, infinite ordinals, etc. Similarly many kinds of algorithms have been
introduced. In addition to classical sequential algorithms, in use from antiq-
uity, we have now parallel, interactive, distributed, real-time, analog, hybrid,
quantum, etc. algorithms. New kinds of numbers and algorithms may be
introduced. The notions of numbers and algorithms have not crystallized
(and maybe never will) to support rigorous definitions.

The positive answer

But the problem of rigorous definition of algorithms is not hopeless. Not
at all. Some strata of algorithms have matured enough to support rigorous
definitions.
This applies to classical (or classical sequential or just sequential) algo-
rithms, essentially the only algorithms in use from antiquity to the 1950s.
“Algorithms compute in steps of bounded complexity”, wrote Andrei Kol-
mogorov in 1953 [14]. This is a good informal definition of sequential algo-
rithms.
An axiomatic definition of sequential algorithms have been given in [12].
That definition was used to derive the Church-Turing thesis from first prin-
ciples in [8]. The derivation presumes that, at the time, Church and Turing

4
(and Gödel and other experts) had in mind only sequential algorithms, which
we believe they did. The axiomatic definition was extended to synchronous
parallel algorithms in [3] and to interactive sequential algorithms in [6, 7].

The status of the Church-Turing thesis

As far as the input-output relation is concerned, synchronous parallel al-
gorithms and interactive sequential algorithms can be simulated by Turing
machines. This gives additional confirmation of the Church-Turing thesis.
None of the other known kinds of algorithms seem to threaten the thesis
but the thesis has not been dispensed with and probably never will be. The
question whether some algorithm of a currently unknown kind would allow
us to compute a function from natural numbers to natural numbers that is
not Turing computable remains open, possibly forever. And even if we had
a satisfactory axiomatic definition of algorithms in full generality, the thesis
would not be dispensed with. It would be just reduced to the first principles
enshrined in the axioms.

3 Remarks on Turing’s analysis of computa-

tion
Turing’s analysis of computation [24] was a stroke of genius. The analysis is
extremely famous, and yet it is often misunderstood.
Some people think that every computable function, total or partial, can
be computed by a Turing machine. This is not so, and here are some counter-
examples. Consider Euclid’s algorithm for computing the greatest common
divisor d = gcd(a, b) of two natural numbers a, b.
let M = max(a, b), m = min(a, b)
while M > m do
M, m := max(M − m, m), min(M − m, m)
d := M .
The gcd function on natural numbers is of course Turing computable, but the
algorithm was also applied — in theory and in practice — to the lengths of
segments of a straight line, which gives rise to a computable partial function
(the algorithm does not terminate if the two given lengths are incommensu-
rate) that is not Turing computable because you cannot place an arbitrary

5
length on the Turing tape. More generally, the functions computed by ruler-
and-compass algorithms are not Turing computable. And let us emphasize
that ruler and compass were practical tools in ancient Greece and that a
number of ruler-and-compass algorithms were practical algorithms.
It is common in mathematics to consider algorithms that work on abstract
objects. The functions computed by these algorithms may not be Turing
computable. One example is Gaussian elimination. Here is another example:
a bisection algorithm that, given a real ε > 0 and a continuous function f on
a real segment [a, b] with f (a) < 0 < f (b), computes a point c ∈ [a, b] with
|f (c)| < ε.
while |f ((a + b)/2)| ≥ ε do
if f ((a + b)/2) < 0 then a := (a + b)/2 else b := (a + b)/2
c := (a + b)/2
One can argue that these functions are not truly computable, that in
practice we can only approximate them. But then there are analog computers
in practical use that work in real time and compute functions that are not
Turing computable.
Of course Turing would not be surprised by our examples. He explicitly
restricted his analysis to “symbolic” (symbol-pushing, digital) algorithms.
He implicitly restricted his analysis to sequential algorithms, essentially the
only algorithms in his time. It is interesting that it turned out easier to
axiomatize all sequential algorithms [12], whether symbolic or not, including
the ruler-and-compass algorithms, Gaussian elimination and the bisection
algorithm (but excluding analog algorithms which are not sequential in our
sense).
What about quantum algorithms? Do they compute functions that are
not Turing computable? Erich Grädel and Antje Nowack checked that the
quantum computing models in the literature can be faithfully simulated by
parallel abstract state machines [11]. And, as we mentioned above, functions
computed by parallel ASMs are Turing computable.
There is also a rather common misunderstanding that Turing defined the
notion of algorithm, albeit restricted to symbolic sequential algorithms. Let
us restrict attention to such algorithms for a moment. Suppose that your
computation model (e.g. a programming language) is Turing complete. Does
it mean that the model allows you to express all algorithms? Not necessarily.
Turing machines simulate faithfully only the input-output behavior of algo-
rithms. But there may be much more to algorithms than their input-output

6
behavior. Turing completeness does not mean algorithmic completeness. It
means only that, for every Turing computable function f , the language allows
you to program an algorithm that computes f .
For illustration consider Turing machines with one tape that may be mul-
tidimensional. The model is obviously Turing complete. On any such ma-
chine, the problem of palindrome recognition requires Θ(n2 / log n) time [2].
But the problem is trivially solvable in linear time on a Turing machine with
two one-dimensional tapes. For a deeper dive into algorithmic completeness,
see [26, §3].

4 Gandy’s analysis of mechanisms

Robin Gandy argues in [9] that “Turing’s analysis of computation by a hu-
man being does not apply directly to mechanical devices.” The reason is
that humans compute sequentially but machines can perform parallel com-
putations. In this connection, Gandy analyzed computations by mechanical
devices and introduced (what we call now) Gandy machines.

A set-theoretic form of description for discrete deterministic ma-

chines is elaborated and four principles (or constraints) are enun-
ciated, which, it is argued, any such machine must satisfy. . . . It
is proved that if a device satisfies the principles then its successive
states form a [Turing] computable sequence. [9, p. 123]

Note “successive states”. Gandy machines work in sequential time. This type
of parallelism is called synchronous. In the rest of this section, parallelism
will by default be synchronous.
Gandy pioneered the use of axioms in the analysis of computation. He
came up with four principles (or constraints, or axioms) satisfied, he claimed,
by all discrete deterministic machines. Contrast this with Turing’s analysis.
While Turing’s analysis was convincing, it is hard to isolate first principles
that, in Turing’s opinion, are satisfied by all symbolic sequential computa-
tions.
Wilfried Sieg adopted Gandy’s approach and reworked Gandy’s axioms;
see [23] and references there.

7
Critical remarks
In a 2002 article [20], Oron Shagrir suggests that “there is an ambiguity re-
garding the types of machines that Gandy was postulating”. He offers three
interpretations: “Gandy machines as physical machines”, “Gandy machines
as finite-physical machines”, and “Gandy machines as a mathematical no-
tion”. Shagrir concludes that none of the three interpretations “provides the
basis for claiming that Gandy characterized finite machine computation.”
This agrees with our own analysis. By the way, for our purposes, there is no
difference between Gandy’s original axioms and Sieg’s versions of the axioms.
So we will just speak about Gandy’s axioms.

• What real-world devices satisfy Gandy’s axioms? Probably very

few do. One problem is the form of the states of Gandy machines: a collection
of hereditary finite sets. Another problem is the requirement that state
transitions are synchronous. You, the reader, may say that we have not
proved our point. Well, the burden of proof is on the proponents of the
approach. And there are precious few examples in the papers of Gandy and
Sieg, and none of the examples is a real-world device. The most prominent
example in Gandy’s paper is the cellular automaton known as Conway’s game
of life. Note that a cellular automaton can grow without any bound. In the
real-world, such a cellular automaton would not stay synchronous.
It seems obvious that Gandy abstracts from material and views discrete
deterministic machines as algorithms, abstract algorithms. So Gandy’s claim
can be restated thus: parallel algorithms satisfy the axioms.

• What algorithms satisfy Gandy’s axioms? Typical parallel or even

sequential algorithms do not satisfy the axioms. Consider for example a fac-
torial algorithm. The state of the algorithm is naturally infinite and consists
of natural numbers. There is of course a Gandy machine that simulates the
factorial algorithm. Note that, in addition to simulating the factorial algo-
rithm, the simulating machine may be forced to construct set representations
of additional numbers.
In our view, Gandy’s axioms are really used just to define another parallel
computation model. (By the way, it is our ambition in [3] that parallel
algorithms, on their natural abstraction levels, satisfy our axioms.)

8
• How does Gandy’s parallel computation model compare to other
parallel computation models? By now, there are numerous models of
synchronous parallelism in the literature, e.g. parallel random access ma-
chines, circuits, alternating Turing machines, first-order logic with the least
fixed-point operator, and parallel abstract state machines. What are the ad-
vantages, if any, of Gandy’s model over the other models? Neither Gandy
nor Sieg addressed this question. Gandy’s model seems quite awkward for
programming or specifying algorithms.

• Dispensing with the Church-Turing thesis Gandy proved that his

machines can be simulated by Turing machines. This is another confirmation
of the Church-Turing thesis. But is it a good ground for dispensing with
the thesis? We do not think so, even if we restrict attention to parallel
algorithms and forget other kinds of algorithms. By the first two bullets
above, Gandy’s theorem does not imply that his axioms are satisfied by any
discrete mechanical device or by any parallel algorithm.

5 What kind of entities are algorithms?

One point of view is that the question about algorithm entities is of no
importance. We quoted already in §1 that “Moschovakis has proposed . . .
a set-theoretic ‘definition’ of algorithms, much like the ‘definition’ of real
numbers as Dedekind cuts” [19]. The quotation marks around the word defi-
nition make good sense. There is another familiar definition of real numbers,
as Cauchy sequences. Dedekind cuts and Cauchy sequences are different en-
tities, yet the two definitions are equivalent for most mathematical purposes.
The question of importance in mathematics is not what kind of entities real
numbers are but what structure they form. Either definition allows one to
establish that real numbers form a complete Archimedean ordered field.
The analogy in the quotation is clear: concentrate on mathematical prop-
erties of algorithms rather than on what kind of entities they are. The anal-
ogy makes good sense but it is far from perfect because much more is known
about algorithm entities than real-number entities. Let us sketch another
point of view on algorithm entities.
Consider algorithms that compute in sequential time. This includes se-
quential algorithms as well as synchronous parallel algorithms. A sequential-
time algorithm is a state transition system that starts in an initial state and

9
transits from one state to the next until, if ever, it halts or breaks. The very
first postulate in our axiomatizations of sequential and synchronous parallel
algorithms [12, 3] is that the algorithms in question are sequential time.
The question arises what kind of entities states are. In our view, rather
common in computer science, algorithms are not humans or devices; they are
abstract entities. According to the second postulate in the axiomatizations
of sequential and synchronous parallel algorithms, the states are (first-order)
structures, up to isomorphism. This admittedly involves a degree of mathe-
matical modeling and even arbitrariness. A particular form of structures is
used; why this particular form? But this is a minor detail. Structures are
faithful representations of states, and that is all that matters for our purposes.
It is convenient to declare that states are structures, up to isomorphism; but
there is no need to do so.
The point of view that sequential-time algorithms are state transi-
tion systems extends naturally to other classes of algorithms. In particu-
lar, a sequential-time interactive algorithm (until now we considered non-
interactive algorithms) is a state transition system where a state transition
may be accompanied by sending and receiving messages. A distributed al-
gorithm is an ensemble of communicating sequential-time interactive algo-
rithms.

6 Moschovakis’s recursion-based approach

We start with basics. In recursion-based approaches you write recursive
equations that specify a function. Typically the equations define a monotone
operator, and semantics is given by means of the least fixed point of the
operator. For example, equations

exp(x + 1, 0) = 1
(
0 if x = 0
exp(x, y + 1) =
x × exp(x, y) if x > 0

specify exponentiation exp(x, y) = xy on natural numbers. The equations

define a monotone operator on extensions of the standard arithmetical struc-
ture with partial binary function exp. Accordingly the following process
gives meaning to exponentiation. Initially exp is nowhere defined. Apply the
equations, obtaining exp(x, 0) = 1 for every x > 0; then apply the equations

10
again, obtaining additionally exp(x, 1) = x for all x, and so on. After ω steps
(where ω is the first infinite ordinal), you reach a fixed point; now exp(x, y)
is defined for all x, y except x = y = 0. Often the evolution toward the fixed
point involves not only the function that you are computing but also some
auxiliary functions.
In 1934, Gödel formulated a recursion-based calculus of (in general par-
tial) numerical functions. Gödel’s calculus can be seen as a specification
language where a specification of a function f is a system of recursive equa-
tions that, taking into account some global conventions, suggests a particular
(possibly inefficient) way to compute f . Church’s thesis (extended to partial
functions by Kleene) asserts that every “effectively calculable”, that is com-
putable by an algorithm, function on natural numbers is programmable in
Gödel’s calculus.
Recursive specification of functions has much appeal. It is declarative and
abstracts from computation details. It is often concise. There has been much
progress since the 1930s. Logicians developed recursion theory. McCarthy
created a functional (that is recursion-based) programming language LISP,
and many other functional languages followed.
The key ideas of Moschovakis’s approach appear already in the 1984 ar-
ticle [16] that seems to be the very first publication on the subject.

If, by Church’s Thesis the precise, mathematical notion of recur-

sive function captures the intuitive notion of computable function,
then the precise, mathematical notion of recursion . . . should
model adequately the mathematical properties of the intuitive
notion of algorithm. [16, p. 291]

Moschovakis discusses Euclid’s algorithm for the greatest common divisor of

two natural numbers. Then he says:

Following the drift of the discussion, we might be expected at

this point to simply identify the Euclidean algorithm with the
functional gcd. We will not go quite that far, because the time-
honored intuitive concept of algorithm carries many linguistic and
intensional connotations (some of them tied up with implemen-
tations) with which we have not concerned ourselves. Instead we
will make the weaker (and almost trivial) claim that the func-
tional gcd embodies all the essential mathematical properties of
the Euclidean algorithm. [16, p. 295]

11
 He gives recursive equations for the mergesort algorithm on a set X and
proceeds to prove that at most n · log2 (n) comparisons are required to sort
n elements.
Moschovakis’s views have been evolving.

When algorithms are defined rigorously in Computer Science lit-

erature (which only happens rarely), they are generally identified
with abstract machines, mathematical models of computers. . . .
My aims here are to argue that this does not square with our
intuitions about algorithms and the way we interpret and apply
results about them; to promote the problem of defining algo-
rithms correctly; and to describe briefly a plausible solution, by
which algorithms are recursive definitions while machines model
implementations, a special kind of algorithms. [17, p. 919].

The main technical notion in Moschovakis’s approach is that of recursor

which is a generalization of function specification in Gödel’s calculus. The
most recent published definition of recursor is found in [19, p. 95]. Semantics
is given by means of the least fixed point of a monotone operator. In some
cases, the least fixed point is not achieved in ≤ ω steps; then the recursor is
infinitary and cannot be implemented by abstract machines. For illustration,
see “the infinitary Gentzen algorithm” in [18]. Moschovakis formulates this
slogan:

The theory of algorithms is the theory of recursive equations. [18,

p. 4]

Critical remarks
• Recursors vs. algorithms We think that Moschovakis was right the
first time around, in [16, p. 295] when he refrained from identifying (what
he later called) recursors with algorithm “because the time-honored intuitive
concept of algorithm carries many linguistic and intensional connotations”
which are contrary to such identification.
Consider the system of two recursive equations (and thus a recursor) for
the exponentiation in the beginning of this section. Is it an algorithm or not?
The recursor certainly looks like an algorithm, and in many functional pro-
gramming languages, this recursor would be a legitimate program (modulo

12
syntactic details of no importance to us here). Typically exp(xy ) would be
interpreted as a function call and, for example, the evaluation of 32 would
proceed thus:

32 = 3 · 31 = 3 · (3 · 30 ) = 3 · (3 · 1)) = 3 · 3 = 9.

But the recursor theory is different. The meaning of a recursor is given by

the least fixed point construction, and there is nothing else. In the case
of the exponentiation recursor, the only “computation” is the process that
we described above: start with the nowhere defined exp function, compute
exp(x0 ) for all x > 0, compute x1 for all x, etc. What should we do in order
to compute 32 ? Should we wait until the “computation” of exp is completed
and then apply exp, or should we wait only to the end of stage 3 when all x2
are computed? The recursor theory says nothing about that.
It is not our goal to make the recursor theory look ridiculous. In fact
we agree that recursors are useful for mathematical analysis of algorithms.
We just see no good reason to identify them with algorithms. Paraphrasing
Richard Feynman, if thing is not an algorithm, it is not necessarily bad.

• The abstraction level of imperative algorithms It seems to us that

recursor theorists underestimate the abstraction capabilities of imperative
programming. Imperative programs, and in particular abstract state ma-
chines, can be as abstract as needed. We addressed this point once [4]. Here
let us just quickly say this. Yes, an algorithm comes with a program for
executing the algorithm. But this does not mean that the program necessar-
ily addresses low-level computational details. Every algorithm operates on
its natural level of abstraction. This level may be very low but it may be
arbitrarily high.

• Declarative specifications Recursion is appealing. A part of the ap-

peal comes from the declarative nature of recursion. That declarative nature
is by itself a limitation for software specification; and note that every piece
of software is an algorithm. Declarative specification of software was very
popular in the 1980s and 1990s, but it was discredited to a large extent.
As software is developed, it evolves. A book with a declarative specifica-
tion quickly becomes obsolete. If specification is not executable, you cannot
experiment with it.

13
• Recursion is but one aspect of an algorithm The theory of algo-
rithms does not reduce to recursion. For one thing, there are clever data
structures. For many linear-time algorithms, for example, it is crucially im-
portant that an algorithm does not manipulate large objects directly; instead
it manipulates only pointers to those objects. Such aspects of complexity
analysis seem below the abstraction level of recursors.

• Distributed algorithms The recursor approach does not seem to extend

to distributed algorithms, and the number of useful distributed algorithms
is large and growing.

• Monotonicity limitation Here is something that the recursor theory

should be able to cover but doesn’t. The current recursor theory is limited
to recursors with semantics given by the least fixed point of a monotone
operator. That is a serious limitation.
For a simple example consider Datalog with negation [1]. The opera-
tor defined by a Datalog-with-negation program is not monotone but it is
inflationary, and semantics is given by the inflationary fixed point [13].
For illustration, here is a Datalog-with-negation program computing the
complement C of the transitive closure T of a nonempty binary relation R
on a finite domain [1, Example 3.3].

T (x, y) ← R(x, y)
T (x, y) ← R(x, z), T (z, y)
U (x, y) ← T (x, y)
V (x, y) ← T (x, y), R(x0 , z 0 ), T (z 0 , y 0 ), ¬T (x0 , y 0 )
C(x, y) ← ¬T (x, y), U (x0 , y 0 ), ¬V (x0 , y 0 )

Explanation. At every step all rules are fired. By the first two rules, the
computation of T proceeds in the usual way. Since the domain is finite, the
computation of T completes after some number k of steps. The pairs of T
are stored in U with a delay of one step, so the computation of U completes
after k + 1 steps. The computation of V is identical to that of U , except that
at the step k + 1, when U is completed, the last batch of pairs from T is not
stored in V . The final rule is idle during the first k steps but on step k + 1
it stores the complement of T into C.

14
• More examples, please. It would be much useful to have more example
of recursors of interest to computer scientists. All current examples of that
sort seem to be present already in the 1984 article [16].

References
[1] Serge Abiteboul and Victor Vianu, “Datalog extensions for database
queries and updates”, J. of Computer and System Sciences 43 (1991)
62–124.

[2] Therese Biedl, Jonathan F. Buss, Erik D. Demaine, Martin L. Demaine,

Mohammadtaghi Hajiaghayi, Tomáš Vinař, “Palindrome recognition us-
ing a multidemensional tape”, Theoretical Computer Science 302 (2003)
475–480.

[3] Andreas Blass and Yuri Gurevich, “Abstract state machines capture par-
allel algorithms,” ACM Transactions on Computational Logic 4:4 (2003)
578–651. Correction and extension, same journal, 9:3 (2008) article 19.

[4] Andreas Blass and Yuri Gurevich, “Algorithms vs. machines”, Bull. Eu-
ropean Association for Theoretical Computer Science 77 (2002), 96–118.

[5] Andreas Blass and Yuri Gurevich, “Algorithms: A quest for absolute
definitions”; in Current Trends in Theoretical Computer Science, World
Scientific, 2004, 195–225; also in Church’s Thesis after 70 Years (eds. A.
Olszewski et al.), Ontos Verlag, 2006, 24–57.

[6] Andreas Blass and Yuri Gurevich, “Ordinary interactive small-step algo-
rithms”, ACM Trans. Computational Logic 7:2 (2006) 363–419 (Part I),
plus 8:3 (2007), articles 15 and 16 (Parts II, III).

[7] Andreas Blass, Yuri Gurevich, Dean Rosenzweig, and Benjamin Ross-
man, “Interactive small-step algorithms, Logical Methods in Computer
Science 3:4 (2007), papers 3 and 4 (Part I and Part II).

[8] Nachum Dershowitz and Yuri Gurevich, “A natural axiomatization of

computability and proof of Church’s thesis”, Bull. of Symbolic Logic
14:3 (2008) 299–350.

15
 [9] Robin Gandy, “Church’s thesis and principles for mechanisms”, In The
Kleene Symposium (eds. J. Barwise et al.), North-Holland, 1980, 123–
148.

[10] S. Barry Cooper, Benedict Löwe and Andrea Sorbi, editors, “New Com-
putational Paradigms: Changing Conceptions of what is Computable”,
Springer, 2008.

[11] Erich Grädel and Antje Nowack, “Quantum computing and abstract
state machines”, Springer Lecture Notes in Computer Science 2589
(2003), 309–323.

[12] Yuri Gurevich, “Sequential Abstract State Machines Capture Sequential

Algorithms”, ACM Transactions on Computational Logic 1:1 (2000) 77–
111.

[13] Yuri Gurevich and Saharon Shelah, “Fixed-point extensions of first-

order logic”, Annals of Pure and Applied Logic 32 (1986) 265–280.

[14] Andrei N. Kolmogorov, “On the concept of algorithm”, Uspekhi Mat.

Nauk 8:4 (1953) 175–176, Russian. English translation in [25, p. 18–19].

[15] John McCarthy, “A basis for a mathematical theory of computation”,

in Computer Programming and Formal Systems (eds. P. Brafford and
D. Herschberg), North-Holland, 1963, 33–70.

[16] Yiannis N. Moschovakis, “Abstract recursion as a foundation of the the-

ory of algorithms”, in Computation and Proof theory, Springer Lecture
Notes in Mathematics 1104 (1984) 289–364.

[17] Yiannis N. Moschovakis, “What is an algorithm?”, in Mathematics Un-

limited — 2001 and beyond (eds. B. Engquist and W. Schmid), Springer,
2001, 919–936.

[18] Yiannis N. Moschovakis, “Algorithms and implementations”,

Tarski Lecture 1, March 3, 2008,
http://www.math.ucla.edu/~ynm/lectures/tlect1.pdf.

[19] Yiannis N. Moschovakis and Vasilis Paschalis, “Elementary algorithms

and their implementations”, in [10], 87–118.

16
[20] Oron Shagrir, “Effective computation by humans and machines”, Minds
and Machines 12 (2002) 221–240.

[21] Wilfried Sieg, “Calculations by man & machine: Mathematical presen-

tation”, in Proceedings of the Cracow International Congress of Logic,
Methodology and Philosophy of Science, Kluwer, 2002, 245–260.

[22] Wilfried Sieg, “Church without dogma – Axioms for computability”, in

[10], 139–152.

[23] Wilfried Sieg, “On Computability”, in Handbook of the Philosophy of

Mathematics (A. Irvine, editor), Elsevier, 2009, 535-630.

[24] Alan M. Turing, “On computable numbers, with an application to the

Entscheidungsproblem”, Proceedings of London Mathematical Society,
series 2, vol. 42 (1936–1937), 230–265. Correction, same journal, vol. 43,
544–546.

[25] Vladimir A. Uspensky and Alexei L. Semenov, “Algorithms: Main Ideas

and Applications”, Kluwer, 1993.

[26] Pierre Valarcher, “Habilitation à Diriger des Recherches”, Université

Paris Est Créteil, LACL (EA 4219), Département d’Informatique, IUT
Fontainebleau, France, May 30, 2010. http://www.paincourt.net/
perso/Publi/hdr.pdf

17