Reduction and Elimination in Philosophy and the Sciences

Algorithms and Ontology
Walter Dean, New York, USA
This purpose of this note is to advertise — but not answer
— a question which is of significant foundational
importance to both mathematics and computer science but
which has been largely overlooked within philosophy of
mathematics. Succinctly stated it is as follows:
58
(A) Are the mathematical procedures conventionally
termed algorithms themselves mathematical objects?
1
I will assume that some general notion of algorithm — i.e.
of a practical method for solving a mathematical problem
— is already implicit in mathematical practice. This seems
reasonable since algorithms for simple arithmetic operations
(e.g. the “grade school” long division algorithm) have
long been commonplaces of our informal computational
practice. Specific algorithms (e.g. Euclid's algorithm) are
well known not only because of their antiquity but also
because of the ways in which they have contributed to
modern mathematics (e.g. in the definition of Euclidean
domain or in the proof of Sturm's theorem). Finally, a great
many other algorithms have been developed in conjunction
with specific subfields of mathematics — e.g. Brent’s
method in numerical analysis, Gosper’s algorithm in combinatorics,
Strassen’s algorithm in matrix algebra — and
will thus be known to specialists in these fields.
Mathematicians have traditionally been most
interested in applying algorithms to solve mathematical
problems such as determining whether a given number is
prime or that a function has a root in a given interval. This
flags two important observations about the role of
algorithms in contemporary mathematics: 1) that many of
the individual mathematical statements which we now take
ourselves to know (e.g. that certain numbers are prime)
have been derived by the application of specific
algorithms; and 2) that mathematical interest has generally
been focused on the results of applying these methods
rather than on the computational properties of the methods
themselves. 2
The situation is quite different in contemporary
computer science. In this context, algorithms are regarded
as abstract objects in their own right whose properties may
be directly studied and compared. This is evident from the
sort of language used to describe individual algorithms, of
which the following observations are typical:
I) Individual algorithms are referred to by proper
names — e.g. “Euclid's algorithm”, MERGESORT,
1 Although it appears that this question has not been systematically investigated
by philosophers, the technical proposals of (Moschovakis 1998) and
(Gurevich 1999) both seek to establish positive solutions. However, both of
these approaches arguably fall victim to the problem of “computational artifacts”
which is discussed below.
2 This is not, of course, to say that properties of algorithms are completely
ignored by mathematicians. For in particular, it is acknowledged that prior to
claiming that the fact that the application of an algorithm A to a value a yields b
as output is a proof that the value of a function f at a is equal to b, A must be
proven correct with respect to f -- i.e. it must be shown that ∀x[f(x) = A(x)].
Such proofs generally proceed by constructing a mathematical model M of A --
i.e. a purely mathematical representation of its mode of operation. The availability
of such representations might be taken to suggest that mathematical
practice is already committed to some version of (A). However, since mathematicians
are not generally interested in the computational properties of individual
algorithms (e.g. their running time), they will generally accept correctness
proofs based on models M which only weakly reflect the operation of the
algorithms which they are introduced to represent.
HEAPSORT, etc.
II) Such names are used to predicate computational
properties directly of individual algorithms — e.g.
“MERGESORT” has running-time O(nlog2(n)).”
III) General results are stated using quantifiers ranging
over algorithms — e.g. “There is a polynomial
time algorithm for primality”, “If P ≠ NP, then there is
no polynomial time algorithm for deciding propositional
satisfiability”, “There is no comparison sorting
algorithm with running-time less than O(nlog2(n)).”
If we apply conventional standards of ontological commitment
to I)-III), we are led to the conclusion that computer
science is committed to regarding algorithms realistically
— i.e. as forming a class of objects to which algorithmic
names (such as those in I)) refer, and over which quantifiers
(such as those in III)) range.
To get an impression of what is at stake in our
interpretation of such claims, it will be useful to consider
the developments which led to the adoption of the idiom
exemplified by I)-III). Statements of this sort are
characteristic of a field known as algorithmic analysis
which was established in the late 1950s by (Knuth 1973).
Knuth proposed a means of measuring and comparing the
efficiency of algorithms in terms of their so-called big-O
running-time complexity — i.e. the asymptotic rate of
growth of the number of steps O(tA(|x|)) it takes algorithm
A to return a value on an input x as a function of its size.
The development of this theory was motivated by the dual
observations that i) there exist intuitively distinct algorithms
A1 and A2 which compute the same function but which
differ in their asymptotic running-time and ii) the relative
efficiency of A1 and A2 in practice is often invariant with
respect to how they are implemented relative to a
particular formal model of computation M (e.g. as RAM
machines).
The first of these observations illustrates that within
computer science, algorithms are treated intensionally.
This is to say that an algorithm A is generally not identified
with the function fA it computes, but rather with a
procedure or method whose operation induces this
function. That algorithms are indeed individuated in this
manner may be illustrated by observing that a
computational predicate like “A has running-time O(t(|x|))”
creates a context in which the substitution of names for
algorithms which compute the same function need not
preserve truth value. 3 The second observation records the
fact that it is conventional to treat algorithms as the
intrinsic bearers of asymptotic complexity theoretic
properties. For not only is it often difficult to reason
mathematically about the complexity of an algorithm if we
are forced to work with a particular mathematical
representation (e.g. RAM machine), but the combinatorial
features of such representations often turn out to be
irrelevant for comparing the behavior of different
algorithms in practice.
These observations shed some light on why it is
useful to adopt an idiom which treats algorithms as
3 For instance, it does not follow from the fact that 1) MERGESORT has running-time
O(|x|log2(|x|)), and 2) that MERGESORT and SELECTIONSORT compute
the same function that 3) SELECTIONSORT has running-time
O(|x|log2(|x|)).