In Chaos as Foundation, I proposed that the space of all infinite bitstrings might provide a minimal starting point for understanding physical reality. Every possible finite description exists within that space, including descriptions of every computable physical law. Descriptions alone, though, do not explain how lawful worlds arise.
I have been developing a programming language called Knot to investigate the mathematical machinery behind that proposal. Knot is small, computationally universal, and reflective: it can interpret programs written in its own language, including the empty program. Every finite bitstring has a defined interpretation, although some computations never terminate.
Recently I used Knot to simulate Rule 30, a cellular automaton whose simple deterministic rule produces intricate patterns. The complete simulation, including iteration through successive generations, fits in a 2,042-bit program. The Knot decoder is a separate 261-bit implementation.
Any computable physical dynamics can be expressed the same way, given an appropriate representation of the model’s state and inputs. A finite program specifies the laws of a universe, additional bits supply initial conditions or stochastic inputs, and together they determine a mathematical history. That connects arbitrary information to lawful structure and exposes the central difficulty of the Chaos proposal: what makes a mathematical history a physically existing world?
How Little Does Computation Require?
Modern programming languages carry variables, functions, data structures, control flow, type systems, and libraries. We associate computation with this machinery because it makes programs comprehensible and useful. Mathematically, almost all of it is dispensable.
In the 1920s Moses Schönfinkel showed that functions could be built without variables from a small collection of combinators, and Haskell Curry developed the idea into combinatory logic. The resulting SK calculus needs two primitive combinators and the operation of applying one expression to another. K takes two arguments and returns the first: K x y = x. S takes three and distributes the third across the first two: S x y z = x z (y z). Every computable function can be built from these. Variables, loops, arithmetic, and data types are all constructions, none of them primitive.
Knot builds on John Tromp’s Binary Combinatory Logic, which encodes combinator expressions as binary strings, and extends that encoding with rules for completing unfinished expressions and a reflective interpretation of the empty program. Three of its properties bear on the Chaos proposal.
Syntactic totality. Every finite bitstring receives a program interpretation, so no binary description is excluded for failing to parse. The guarantee is that every source string denotes an expression, not that the expression terminates or yields a usable output.
Computational universality. Knot preserves the SK calculus, so every computable function has a representation.
Reflection. Knot can interpret programs written in its own language. Under its reflective semantics the empty source denotes the interpreter itself, so interpretation becomes an object of computation.
Each property is familiar from computability theory. Combined, they give a compact setting in which to study how arbitrary binary descriptions acquire computational meaning, how those descriptions generate histories, and how interpretation can be represented inside the system that performs it.
A Universe of Thirteen Cells
Rule 30 comes from Stephen Wolfram’s investigations of cellular automata. Picture a row of cells, each black or white, all updating simultaneously from the states of their immediate neighbors. A cell’s new value is the exclusive OR of its left neighbor with the logical OR of itself and its right neighbor.
Start from a single active cell and apply the rule repeatedly. A triangular pattern grows. Its left side develops recognizable structure, while its right side produces irregular patterns that resemble randomness. Nothing random enters the calculation.
My Knot implementation starts from thirteen cells and computes five further generations. The program reads an update count and an initial row, computes each successive row, and returns the whole history as a single bitstring. Python constructs the input and splits the output into rows for display. It calculates no generations and feeds nothing back into Knot.
The 2,042 and 261 bits measure particular implementations under particular encoding conventions rather than theoretical minimums. They still make the abstraction tangible: a finite description generates a history whose structure is far less obvious than the rule that produced it.
Nothing about Rule 30 is special. Particle simulations, field approximations, ecological models, and artificial agents need only a computable state representation and a computable transition, whether the description is exact, approximate, or fed random inputs.
Physical Laws as Programs
A finite description of the laws does not guarantee a finite description of the universe. Dynamics can be computable while the initial conditions contain algorithmically incompressible information, and exact evolution then needs an unbounded input sequence.
A finite Knot program can fix the laws while an infinite binary sequence supplies the information that picks out a particular history. The same program generates different histories from different inputs, and different programs define different laws. Provided each update terminates and the procedure has access to the input stream, it can compute any requested finite portion of the history, though no finite computation outputs the whole. The input itself may be incompressible, in which case no finite program generates it. Chaos supplies the information and Knot supplies computable transformations of it.
Whether a history follows consistently from specified laws is a question about the model. Whether those laws describe our universe is an empirical question. A program can define a coherent universe whose dynamics bear no resemblance to ours.
The Chaos Reservoir
The Chaos Reservoir is the space of all infinite binary sequences. Under the fair-coin measure, almost every such sequence is algorithmically random: the prefix complexity of its initial segments never falls more than a constant below their length. The computable sequences form a measure-zero subset. Yet the whole space has a compact definition.
The Reservoir holds finite descriptions as prefixes. Every finite Knot program begins uncountably many infinite sequences, whose continuations may supply inputs, arbitrary data, or bits the program never reads. A program computing Newtonian trajectories to any requested precision is there. So is a discretized quantum field theory, and so are programs for fictional universes with different particles, forces, dimensions, and symmetries.
Their presence follows from the definition of the space and the universality of the language, and it privileges none of them. The same sequence can be read as text, numerical data, executable instructions, or an encoding of something else entirely. Knot supplies one explicit interpretation, under which some descriptions define transition functions, some generate histories, some interpret other programs, and some never finish.
In Coherence Filters, I distinguished exclusion filters, which select sequences satisfying specified constraints, from semantic filters, which assign lawful interpretations to those sequences. Knot gives both operations a concrete setting. One program generates a history from a transition rule. Another inspects a finite history and checks that each transition obeys the rule. More elaborate programs check computable conservation conditions, boundary constraints, or other invariants.
The limits are real. Verifying a finite history differs from proving that an arbitrary computation will preserve an invariant forever, and Rice’s theorem rules out a general decision procedure for any nontrivial property of the functions programs compute. Substantial classes of coherence conditions can still be represented and evaluated, so the relationships among binary descriptions, interpreters, computational laws, and admissible histories can be constructed explicitly.
The Interpreter Inside the System
A bitstring becomes a program only relative to rules specifying how its contents are interpreted. Knot makes those rules compact, but it cannot eliminate them. Its empty program is a self-interpreter because Knot’s semantics assign it that role. Under different semantics, the same empty string could mean something else.
That introduces an apparent circularity into the Chaos proposal. If Chaos contains every possible interpretation rule, which rule interprets Chaos?
One answer is to represent interpreters within the same computational space as the programs they interpret, and Knot shows this can be done. An interpreter is encoded as a program that can interpret other programs, including descriptions of interpreters, and the empty source supplies a compact self-interpreter. Representing interpretation at successive levels requires no infinite hierarchy of distinct interpreter programs.
Call this representational closure: the system can represent the machinery responsible for interpreting its own descriptions. Knot’s formal meaning is still fixed by its semantics, and self-reference does not establish why those semantics should be physically realized, or why they should be privileged over alternatives. Call that missing property ontological closure: an account in which the existence and operation of the relevant interpretations require no additional realization principle. Knot establishes the first. Whether the second is possible is the Chaos proposal’s question.
One route treats interpretation as a relationship among structures rather than an operation requiring an external interpreter. A coherent computational world would then be characterized by relationships among descriptions, interpretation rules, and resulting histories, with the interpreters represented inside those relationships. The construction is mathematically intelligible. It does not show that the resulting structures physically exist, but it puts the problem in terms of explicit mathematical objects.
When Does a Simulation Become a Universe?
Imagine a Knot program specifying the complete computational dynamics of a universe containing stars, planets, organisms, and intelligent agents. Its description is exact, and every state and transition follows the stipulated laws. Within the resulting history, organisms form models of their surroundings, predict events, and act on those predictions.
Do those organisms exist?
That depends on what physical realization requires. Computational functionalism holds that the relevant mental properties depend on functional or computational organization, so an appropriate physical implementation of the computation could instantiate the corresponding minds. Other physicalist accounts require causal or material properties beyond abstract organization, in which case a mathematical description of a process cannot establish its realization. More expansive mathematical ontologies assign existence to mathematical structures themselves, possibly without any further physical substrate.
Knot’s semantics fix the relationship between a program and its output, and nothing in them runs anything. You’re Not a Random Copy separates a simulation’s represented history from its realizing history. On the computationalist reading that essay adopts, a suitably organized simulated observer is real if the computation runs, and the computation is a physical process in some base universe, carrying that universe’s Measure and no other. A Knot program written on paper has a represented history and no realizing one. The same program executed on hardware has both, and the realization comes from the hardware’s physics rather than from the program.
That makes the Chaos proposal’s difficulty precise. Chaos is offered as the foundation, so there is no base universe beneath it to do the running. Some relationship among structures inside Chaos plays the role that execution plays for an ordinary simulation, or Chaos contains only represented histories and realization comes from somewhere else, or realization is taken as primitive. The last is coherent, but it spends the economy that motivated starting from Chaos. The first is the ontological closure question from the previous section, restated so that it names what would answer it: an account of what counts as running when nothing lies underneath.
Agency is where this matters most. A model can represent self-maintenance, environmental modeling, evaluation of alternatives, and causal intervention, and whether the modeled system is an agent depends on whether that organization is actually realized. The broader Axionic project asks under what conditions agency exists at all. The Chaos proposal asks whether the structures supporting it are coherent relationships within a maximally inclusive possibility space.
Postscript
Three questions survive the construction.
Selection. If infinitely many incompatible interpretations are available, why should any particular interpretation or collection of histories be privileged?
Realization. Under what conditions does a computational description or mathematical history constitute an actual physical process?
Measure. If multiple histories are realized, what determines their relative significance? Chaos comes with a candidate. Knot’s totalized source language cannot carry it, since 00 and 000 both denote K, and length-based weights over such sources would count overlapping events. Complete BCL expressions do form a prefix-free code, though, and almost every infinite sequence begins with exactly one of them, so on Chaos the completion rules never fire. Read a fair-coin sequence that way, treating the remaining bits as input, and each complete expression p is drawn with probability 2^-|p|. The induced weighting is Solomonoff’s universal semimeasure: shorter laws receive more weight, and no one has to count descriptions.
The weighting belongs to the interpreter, down to the framing convention that splits program from input. The invariance theorem bounds how far two universal interpreters can disagree about a program’s length, but only up to a constant on the order of a translator between them, and for programs as short as the ones built here that constant is comparable to the program. The Rule 30 history is 470 bits as Binary Lambda Calculus source and 2,042 bits once compiled to SK combinators, so those two codewords for the same function differ in weight by a factor of 2^1,572. The universal probability of an output sums over every program that produces it, and neither codeword is the shortest, so the factor measures encoding dependence rather than a ratio of universal probabilities. A weighting over descriptions is also not yet the physical Measure of the anthropic essays, and identifying the two is a further claim that nothing here establishes. A measure induced by Chaos is well defined once an interpreter is fixed, and fixing the interpreter is the selection problem again.
Universality and self-interpretation settle none of these, but Knot lets them be posed precisely. It replaces unspecified filters extracting order from randomness with interpreters, coherence conditions, and histories that can be constructed and run, and only constructions of that kind expose which conclusions follow from the premises and which must still be assumed.
The next step is to build self-referential coherence filters in Knot: programs that interpret descriptions, generate finite histories, evaluate specified invariants, and classify computational structures by their properties. Further experiments could test which relationships stay invariant across different universal interpreters and which depend on arbitrary encoding choices. These are mathematical questions with definite answers in particular formal settings. Whether any such relationships suffice for physical realization is the metaphysical question they leave behind.