Ladders of Emergence - juhameskanen/abstract GitHub Wiki

Ladders of Emergence

From Bits to Structure

Take any string of $n$ bits. It can be arranged in $2^n$ ways. Under any fixed reading, almost all of these arrangements describe nothing sensible: fewer than $2^{n-c}$ strings can be generated by a program shorter than $n-c$ bits, so structure is rare.

A small fraction of arrangements describe what we call a Turing machine, that is, code together with data. This is the first selection. Nothing is added to the string. From all of its arrangements we select those that satisfy a filter.

Strings Do Not Say What They Represent

A bit pattern does not carry its own interpretation. The string 11111111 is $255$ read as unsigned, $-1$ read as two's complement, a row of eight lit pixels read as an image. Nothing in the string selects among these readings. In our framework there is no external reader, so the interpretation is not supplied from outside. All readings exist, and each is a member of the equivalence class of the structure it yields.

Endianness: the same function, many strings

Byte order shows a second kind of multiplicity. Consider the 16-bit string 00000001 00000000. Read big-endian it is $256$. Read little-endian it is $1$. Conversely, the same value $256$ is written 00000001 00000000 on a big-endian machine and 00000000 00000001 on a little-endian one. A CPU instruction that computes $2^x$ therefore has two apparent implementations whose bit patterns differ, yet the function is the same.

Byte order is only one of many conventions. A reading of an $n$-bit string can permute bit positions, group bits into words of any width, and choose an encoding (unsigned, two's complement, sign-magnitude, Gray code). Counting bit permutations alone, up to coincidences for symmetric strings, there are $n!$ readings of a single string. Beyond representation, the same function can be computed by entirely different algorithms: $2^x$ by a shift, by repeated squaring, by a lookup table, or by a floating-point routine.

Two directions of multiplicity therefore feed the same equivalence class:

one string admits many readings (interpretation ambiguity);
one meaning is realised by many strings and programs (implementation multiplicity).

By Rice's theorem, deciding whether two programs compute the same function is undecidable in general, so the size of the class of all implementations of a function cannot be computed, only argued to be large. This is the same situation as with Kolmogorov complexity itself.

The Inside--Outside Split as an Interpretation

The same holds for the observer. A bit pattern does not say which part of it is Alice and which part is the world she finds herself in. That boundary is an interpretation too. One reading assigns a region to Alice and the remainder to the observable. Another reading of the same string draws the boundary elsewhere.

An observer-compatible reading is therefore a pair: a way of carving the string into observer and observed, together with a way of decoding each part, such that the inside contains a model of the outside and the boundary persists along the walk of Section~\ref{sec:observer-walk}. As with the first selection, this is a filter on arrangements and interpretations, and nothing is added to the string.

The Observer Is Not a Program

Given sufficiently many bits, the observer emerges as the shortest description that dominates the measure. It is not a single bitstring but an equivalence class: a vast number of microscopic configurations yield the same observer. The shortest description sets the exponent $2^{-m}$ of the-filter. The mass of the class, however, comes from the enormous number of loosely constrained members.

Only a vanishingly small subset of these members are Turing machines. Computation is a tiny part of what a bitstring can describe. The observer's class is not generated by running a program, and mathematics is a compression layer built on top of it, not the ground. This is not a claim that the observer cannot be described mathematically. Our own spectral cost is a mathematical object. The claim is that the universe is not generated by computation, because computation is a vanishingly small slice of the possibilities.

Two Layers

We distinguish two layers.

Layer 1 The full space of arrangements and interpretations of a bitstring. It is massively under-determined: many readings and many continuations are compatible with the same string.
Layer 2 The Turing-describable subset. It is fully determined: given the program and its input, each step is forced.

The observer is a combination of the two. Mathematics belongs to layer 2 and is an additional compression system on top of layer 1.

Where Qualia Can Operate

Qualia is a property we have. Something must select among alternatives wherever the alternatives are under-determined. Layer 2 leaves nothing to select, since each step is forced, so qualia has no room to operate there. Layer 1 is the only layer that is under-determined. By elimination, qualia operates on layer 1.

This does not deny that we experience doing mathematics. Qualia operates in choosing which formal steps to take and in recognising what follows, not in the execution of a step. This matches observation: humans are slow and error-prone at executing algorithms, yet very good at recognising patterns and likely continuations.

Searching layer 1 algorithmically is hopeless, because the search is uncomputable in general. An observer that nevertheless finds high-measure walks must therefore do so by something other than exact search. We conjecture that this is a heuristic compression system, and that qualia is how that system presents itself from the inside. The analogy is a fixed network of weights whose answer to any query is the most probable continuation, with no explicit search. This is an analogy only. It shows that heuristic compression is possible without algorithmic search, and it is not evidence about qualia.

Assumptions

Interpretations are summed over, not chosen, and weighted by the cost of the whole description, interpretation included.
``Nothing sensible'' is relative to a reading. Summed over all readings every string describes something, so the content lies in the measure and the filter.
The observer filter (bounded, persistent, containing a model of its outside) is an input, with tolerance $\varepsilon$.
The ladder is exhaustive: a bitstring offers arrangements, interpretations, and the computable subset, and nothing else. The location argument depends on this.
Layer~2 being fully determined is what leaves qualia no room there.
The function claim (heuristic compression) is a conjecture without derivation or a test yet.
The size of the interpretation space is argued to be large, not computed.

↑ Up | ← Previous | Next →