I think that your characterization would be accurate if you could somehow substitute each and every verb, such as "generate", "execute", "compare", "detect", "create", which depend on some form of transitional temporality with nouns that have a non-temporal connotation, after all all of this computational structure is postulated to exist in a TIMELESS Platonic realm where any notion of temporality and change is non-existent.
I may seem to be a bit too clever by half in this response to your post, but we must be consistent; if we postulate a timeless realm then we are eliminating any notion that depends of change. Time is, after all, the measure of change.
----- Original Message ----- From: ""Hal Finney"" <[EMAIL PROTECTED]>
Sent: Friday, May 06, 2005 12:40 PM
Subject: Re: Everything Physical is Based on Consciousness
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 way.
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.