Jesse Mazer writes:
> Hal Finney wrote:
> >However, I prefer a model in which what we consider equally likely is
> >not patterns of matter, but the laws of physics and initial conditions
> >which generate a given universe. In this model, universes with simple
> >laws are far more likely than universes with complex ones.
> Why? If you consider each possible distinct Turing machine program to be
> equally likely, then as I said before, for any finite complexity bound there
> will be only a finite number of programs with less complexity than that, and
> an infinite number with greater complexity, so if each program had equal
> measure we should expect the laws of nature are always more complex than any
> possible finite rule we can think of. If you believe in putting a measure on
> "universes" in the first place (instead of a measure on first-person
> experiences, which I prefer), then for your idea to work the measure would
> need to be biased towards smaller program/rules, like the "universal prior"
> or the "speed prior" that have been discussed on this list by Juergen
> Schimdhuber and Russell Standish (I think you were around for these
> discussions, but if not see
> http://www.idsia.ch/~juergen/computeruniverse.html and
> http://parallel.hpc.unsw.edu.au/rks/docs/occam/occam.html for more details)
No doubt I am reiterating our earlier discussion, but I can't easily find it right now. I claim that the universal measure is equivalent to the measure I described, where all programs are equally likely.
Feed a UTM an infinite-length random bit string as its program tape. It will execute only a prefix of that bit string. Let L be the length of that prefix. The remainder of the bits are irrelevant, as the UTM never gets to them. Therefore all infinite-length bit strings which start with that L-bit prefix represent the same (L-bit) program and will produce precisely the same UTM behavior.
Therefore a UTM running a program chosen at random will execute a program of length L bits with probability 1/2^L. Executing a random bit string on a UTM automatically leads to the universal distribution. Simpler programs are inherently more likely, QED.
I don't follow this argument (but I'm not very well-versed in computational theory)--why would a UTM operating on an infinite-length program tape only execute a finite number of bits? If the UTM doesn't halt, couldn't it eventually get to every single bit?
> If the "everything that can exist does exist" idea is true, then every > possible universe is in a sense both an "outer universe" (an independent > Platonic object) and an "inner universe" (a simulation in some other > logically possible universe).
This is true. In fact, this may mean that it is meaningless to ask whether we are an inner or outer universe. We are both. However it might make sense to ask what percentage of our measure is inner vs outer, and as you point out to consider whether second-order simulations could add significantly to the measure of a universe.
What do you mean by "add significantly to the measure of a universe", if you're saying that all programs have equal measure?
> If you want a measure on universes, it's
> possible that universes which have lots of simulated copies running in
> high-measure universes will themselves tend to have higher measure, perhaps
> you could bootstrap the global measure this way...but this would require an
> answer to the question I keep mentioning from the Chalmers paper, namely
> deciding what it means for one simulation to "contain" another. Without an
> answer to this, we can't really say that a computer running a simulation of
> a universe with particular laws and initial conditions is contributing more
> to the measure of that possible universe than the random motions of
> molecules in a rock are contributing to its measure, since both can be seen
> as isomorphic to the events of that universe with the right mapping.
We have had some discussion of the implementation problem on this list, around June or July, 1999, with the thread title "implementations".
I would say the problem is even worse, in a way, in that we not only can't tell when one universe simulates another; we also can't be certain (in the same way) whether a given program produces a given universe. So on its face, this inability undercuts the entire Schmidhuberian proposal of identifying universes with programs.
However I believe we have discussed on this list an elegant way to solve both of these problems, so that we can in fact tell whether a program creates a universe, and whether a second universe simulates the first universe. Basically you look at the Kolmogorov complexity of a mapping between the computational system in question and some canonical representation of the universe. I don't have time to write more now but I might be able to discuss this in more detail later.
Thanks for the pointer to the "implementations" thread, I found it in the archives here:
Are you the same person as "hal" who posted the second message on that thread? That post suggested some problems with the idea of looking at the Kolmogorov complexity of the mapping:
However I think there is a worse problem. That is that K. complexity is not uniquely defined. K. complexity is defined only with regard to some specific universal Turing machine (UTM). Two different UTMs will give a different answer for what the K. complexity is of a string or program. In fact, given any particular string, you can construct a UTM which gives it an arbitrarily large or small K. complexity as measured by that UTM.
I think this objection is probably fatal to Jacques' idea. We need the SMA to be uniquely defined. But this cannot be true if there exist UTMs which disagree about which mapping algorithm is simplest. Within the mathematical framework of K. complexity, all UTMs are equally valid. So there is no objective preference of one over the other, hence there can be no objective meaning to the SMA.
In order to fix this, we have to identify a particular UTM which we will use to measure the K. complexity. There has to be some particular Turing machine which is preferred by the universe. You could choose one and produce an "objective theory of consciousness", but this would be yet another ad hoc rule which would make the theory less persuasive.
Reading the thread, a different idea occurred to me--what if, instead of just looking at abstract properties of different possible mappings, you looked at how often the mappings themselves were "implemented", ie you looked at the measure of the programs which actually do the mapping? If you have some program A whose output, when fed as input to a mapping program M, reproduces the output of a program B, then perhaps the degree to which A contributes to B's measure would be given by something like (measure of A)*(measure of M). There is potentially something a little circular about deriving B's measure from the measure of all possible programs which map other programs to it, since B itself could be a "mapping program" in another context, but I'm attracted to circular definitions of measure, since my hope is that the true universal measure will turn out to be a unique self-consistent solution to some set of constraints, a bit like solving a set of simultaneous equations (this would resolve the "arbitrariness problem" of introducing a global measure that I discussed at http://www.escribe.com/science/theory/m2606.html )
Rethink your business approach for the new year with the helpful tips here. http://special.msn.com/bcentral/prep04.armx