Bruno Marchal writes:
> The problem is that from the first person point of view, the arbitrary
> delays, introduced by the UD, cannot be taken into account, so that
> big programs cannot be evacuated so easily. This does not mean little
> programs, or some little programs, does not win in the limit, just that
> something more must be said. Sorry for not explaining more because I
> have a lot of work to finish (I'm still not connected at home, but in this
> case I'm not sure I will find the time to go home...). See you next week.
As I understand the explanation, what happens is that as the UD generates
programs, it inherently and unintentionally generates multiple copies of
each program. The reason is that each program has only a finite size.
If we think of the program as written in some kind of programming
language, only a finite number of the characters will be used.
Any characters beyond this ending point are never executed.
This means that as the UD generates all character strings and begins
to execute them, a program which is n bits long gets created any time
the UD generates a string that starts with those particular n bits.
Each string which has those n bits as its prefix (the bits starting at
the beginning) will represent the same program.
The UD can't detect this because a priori there is no way to tell how
long a particular program will turn out to be. This is a corollary of
the Halting Problem, there is no way to tell by inspection how long a
program is. So it has no choice but to multiply create programs in this
The result is that if we compare two programs, one n bits long and one
m bits long, where m > n, we will find that the n bit one gets created
proportionally more times than the m bit one. And in fact the constant
of proportionality is 2^(m-n). This lets us define a "measure" for each
program that tells what fraction of all programs the UD creates are that
particular program. That measure is 2^(-n) for an n bit program.
Therefore, each program gets created an infinite number of times by the
UD, and the fraction of the whole ensemble of programs which consists
of a particular n bit program is 2^(-n).
Note that this does not depend on any slowdown effect for larger programs;
that effect is not considered significant in this model because it is only
noticeable from outside and not from within the program being executed.
Rather, it depends on multiple creations of each program, and the fraction
of the whole infinite ensemble that each program represents.