# Re: Is the universe computable

```Pete Carlton writes:
> Imagine a Life universe that contains, among other things, two SASes
> talking to each other (and showing each other pictures, and in general
> having a very lucid, conscious, conversation.)  Imagine that instead of
> being implemented on a computer, it's implemented by a large 2d array
> timestep, the coins are flipped over in concordance with the Life
> rules.
> Does this setup implement a universe?```
```
Let's say it does.

>   If you say it does, how about the next step:
> Instead of doing flipping operations on one set of coins, each new
> generation is laid down in the proper configuration on top of the
> preceding one with a new set of coins.  Does this >process< of laying
> down coins also implement a universe?

Yes, it would seem that laying down coins isn't conceptually different
from flipping them, from the point of view of performing a calculation.

> If you say it does, then what about the stack itself?  (One can imagine
> pointing to each layer in succession, saying "This is the current
> step", "Now this is the current step", etc..) Does the stack's bare
> existence suffice for the implementation of a universe?

The problem with this example is that you can't create the stacks without
laying them down first.  So there has definitely been an implementation
during the lay-down phase.  What you have to be asking is, in some sense,
is the implementation still going on?

This assumes a certain time-bound nature to the concept of implementation
which may not be valid.  You are assuming that the region of our universe
where the implementation occurs can be bounded in time, and asking if
the boundary only encloses the active lay-down phase, or also encloses
the passive stack phase.

You get the same problems if you try to describe the exact physical
boundaries of the implementation in space.  Does the implementation
encompass the spaces between the coins, for example?  Assuming you also
need some small calculator to compute how to flip each coin (a simple
lookup table for the 512 possibilities of 9 coins in a square), is that
part of the implementation?  What about the space between the coins and
the calculator?  Or perhaps the coins themselves don't have well-defined
boundaries, etc.

These questions suggest that it is difficult to consider "whether
a particular implementation is going on" to be a yes-or-no question
that can be asked at each point-event in space-time.  So it may not be
meaningful to ask whether the stack is also an implementation.

> If not, then can you say what it is about the active process of
> flipping or laying down that "counts" as computation but does not count
> when the stack is a static block?

In the philosophical literature on implementation (a good jumping-off
point is David Chalmers paper at
http://www.u.arizona.edu/~chalmers/papers/rock.html) it is considered that
a mere "trace" of a program execution does not count as an implementation,
for two reasons: first, there are no causal connections between the
layers, they're just sitting there; and second, the trace does not
represent counterfactuals, i.e. if you were to change a cell's value,
what would happen is not clear from the trace.

> If you think the static block "counts" as the implementation of a
> universe, then I think you can go all the way to abstract Platonism.
> Because since the stack's just sitting there, why not knock it down?
> Or melt it into a big ball?  Or throw it into a black hole...the two
> SASes won't care (will they?)

On the other hand, if I apply what I have been calling the Wei Dai
heuristic (about which I wrote a few messages in the past few days; BTW
Wei suggested the idea but it's not necessarily something he advocates),
I'd say that the presence of the stack does increase the measure of
the simulated universe, because it increases the percentage of our
universe's resources which are used by the simulation.  More precisely,
its presence would allow a shorter program to locate the implementation
among all the vastness of our universe.

However, in that case, knocking down or destroying the stack would
eliminate this property; the stack would no longer contain the
information which would allow shortening the program which would localize
the implementation.

Hal Finney

```