# [FOM] Hamkins's multiverse and ultrafinitism

Thomas Klimpel jacques.gentzen at gmail.com
Thu Nov 30 05:51:12 EST 2017

```Timothy Y. Chow wrote:
> So if I understand correctly,
> the vagueness of "finite" is *not* that we are worried that we can't "count that high,"
> but we don't have a clear conception of "when to stop"?

This matches well with my own perspective, even so I am pretty sure
that Hamkins' position is completely different from my own perspective
otherwise.

> It still strikes me as difficult to construct a convincing heuristic argument for this point of view.

Let me try to give an intuitive explanation for my own point of view:

(1) Some people like to imagine natural numbers encoded in binary
(least significant bit first) as finite strings of 0s and 1s. Note
that this encoding uses equivalence classes of finite strings, since
for example 10 and 100 both encode the number 1, i.e. the number of
trailing zeros is irrelevant.

(2) But the word "finite" string already presupposes that we know how
to distinguish between finite and infinite strings. So let us assume
instead that we only have infinite strings of 0s and 1s, and that we
want to encode natural numbers as equivalence classes of such strings.

(3) Accepting that working in groups of 8 bits makes sense given
current computer architectures and programming languages, the
following scheme for encoding natural numbers is both relatively
straightforward and successful in practice in terms of size and speed
(taken from 7.2 INTEGERS in
"An **unsigned-integer** is an N-byte (N > 0) integer value. The
low-order byte appears first in the OASIS format. Integer byte length
is variable and integers are represented as *byte-continuations* where
the most significant bit of each byte except the last in the chain is
a 1; the remaining seven bits in each byte are concatenated to form
the actual integer value itself."

(4) The described scheme encodes the number of 7 bit blocks in unary
(0 -> "1 block", 10 -> "2 blocks", 110 -> "3 blocks", ...) and the
number itself in binary. Other schemes used in practice (like UTF8)
basically use the same approach. Slightly generalising those schemes,
we can say that the length is encoded as a prefix-free code, and the
number is encoded in binary in a finite string of 0s and 1s of the
given length.

(5) The vagueness of "finite" comes in because of the prefix-free code
part of the encoding. There are infinite string for which that
prefix-free code part is invalid, i.e. for unary encoding the code
1111111111111111... would be invalid, if no 0 ever occurred. The
prefix-free code part and the finite string part of the encoding can
be mixed as clever as you want, it won't resolve the vagueness of the
prefix-free code part. And using a non-prefix-free encoding for the
length will only create more vagueness, not less.

(6) You might object to the idea that infinite strings of 0s and 1s
are more complicated than finite strings of 0s and 1s. They are not,
because you implicitly required the finite strings of 0s and 1s to
include each and every possible finite string, while you don't expect
the infinite strings of 0s and 1s to include every possible infinite
string. You do expect that every possible finite string is a prefix of
some infinite string, but this requirement is strictly less demanding
than the requirement to only include finite strings.

> In particular, what it means is that what we think of as the standard natural numbers actually include nonstandard numbers, from someone else's point of view. But how can we picture this "someone else"?

In my view above, the infinite strings of this "someone else" might be
given in a different way, and he might prefer a different encoding of
the natural numbers more suited to the way his infinite strings are
given. Your infinite strings might be given by the ability to read one
symbol at a time from left to right, but his strings might be given by
the ability to query for the presence of finite (and infinite)
substrings starting within finite (and infinite) ranges.

> This "someone else" thinks that some of our good ol' finite natural numbers aren't really finite.  Doesn't that mean that that "someone else" is a closet ultrafinitist (at least in our eyes)?

Well, in my picture he rather thinks that he cannot decide (yet)
whether some specific infinite string which we already know to be a
perfectly fine finite number is actually a valid finite number. He
could even have another infinite string which he knows to be a
perfectly fine finite number, and we might already know that this
other infinite string corresponds to exactly the same number as the
infinite string which gives him trouble, but we still can not help him
resolve his uncertainty.

Note however that the above is most certainly not Hamkins' position,
as I already stated in the beginning. (I am influenced by N J
Wildberger's form of ultrafinitism and his arguments against real
numbers and naive platonism.) The purpose of my position is to justify
my own doubts with respect to unbounded quantification over natural
numbers. The source of those doubts was whether we can prove or know
anything for certain without first putting in ontological commitments,
not specifically to doubt natural numbers. The timeline when and why I
asked myself those questions is as follows:

Jul 4 '14 "How is it possible that we can prove the model existence
theorem?" (https://philosophy.stackexchange.com/questions/14101/are-there-any-other-things-like-cogito-ergo-sum-that-we-can-be-certain-of/14461#14461)
Jul 6 '14 "If I am willing to accept the existence of *idealized*
Turing machines, can I then prove things like the model existence
theorem?" (https://philosophy.stackexchange.com/questions/14529/which-ontological-commitments-are-embedded-in-a-straightforward-turing-machine-m)
Mar 20 '16 "Those questions should have answers, at least in a
heuristic form. Or not?"
(https://mathoverflow.net/questions/232905/can-turing-machines-clarify-mathematical-philosophical-and-physical-existence/234133#234133)

My later efforts to try to explain my position to other people would
be a different story. The above approach to directly work with
equivalence classes over infinite strings so as not to presuppose the
existence of finite strings was developed especially for this mail. My
own thinking was rather in terms of a game between two players, or in
terms of an interaction between me (or a Turing machine) and an all
powerful but not trustworthy oracle. But my previous efforts at
explaining my position clearly failed, so I am curious whether the
current approach will be more successful.

Thomas
```