Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction

TL;DR

The paper investigates how well-formed self-replicating programs emerge from simple local interactions across substrates including BFF (an extended Brainfuck), Forth, SUBLEQ, and real-world CPU emulations. It demonstrates that self-modification and program interactions can spontaneously yield self-replicators without explicit fitness signals, across primordial soups with $2^{17}$ tapes of $64$-byte programs, 2D spatial grids, and long-tape settings; complexity, measured by high-order entropy, rises during replication and reorganizes as replicator ecosystems form. A counterexample SUBLEQ-like language suggests that replication may be constrained by minimal equivalence classes and length requirements. The study provides a general framework for studying the origin of life in computation, offering public code and open questions about open-ended evolution, complexity growth, and the conditions under which more complex dynamics can arise in computing substrates.

Abstract

The fields of Origin of Life and Artificial Life both question what life is and how it emerges from a distinct set of "pre-life" dynamics. One common feature of most substrates where life emerges is a marked shift in dynamics when self-replication appears. While there are some hypotheses regarding how self-replicators arose in nature, we know very little about the general dynamics, computational principles, and necessary conditions for self-replicators to emerge. This is especially true on "computational substrates" where interactions involve logical, mathematical, or programming rules. In this paper we take a step towards understanding how self-replicators arise by studying several computational substrates based on various simple programming languages and machine instruction sets. We show that when random, non self-replicating programs are placed in an environment lacking any explicit fitness landscape, self-replicators tend to arise. We demonstrate how this occurs due to random interactions and self-modification, and can happen with and without background random mutations. We also show how increasingly complex dynamics continue to emerge following the rise of self-replicators. Finally, we show a counterexample of a minimalistic programming language where self-replicators are possible, but so far have not been observed to arise.

Figures (12)

• Figure 1: Tracer tokens and high-order entropy open a simple way to detect a state transition: we observe a rapid drop in the number of unique tokens, while the soup becomes dominated by a few most popular tokens. This is aligned with a state transition in complexity. Note that this particular state transition happened in two steps because of the "zero-poisoning" period (see Figure \ref{['fig:history']}).
• Figure 2: The story of one state transition through the story of one tape. The left part of the figure shows snapshots of a single tape at different epochs. The selected tape is the one where the first (non-zero-tolerant) replicator emerges at epoch 2355 (see Figure \ref{['fig:first_replicator']}). The emergence is followed by a "zero-poisoning" period, after which a new family of replicators takes over the soup. Only BF-code characters and zeros are printed. Lines connect consecutive character boxes if tokens match between the adjacent tape snapshots (which most often means that this place was not overwritten between snapshots). Colorful boxes correspond to the tokens that were present on the "chosen tape" at epoch 2355, this allows us to see where they came from and what happened to them later. The right part shows overall soup statistics: complexity ("high-order entropy"), number of zeros and number of tokens that match tokens of the "chosen tape".
• Figure 3: Emergence of the self replicator at epoch 2354 of the case-study BFF run. Lines connect tokens that are copied from one tape to another.
• Figure 4: Example execution for a functioning self-replicator. See video of this run at: https://asciinema.org/a/nXW8NFxiUtHiNtteJwXAXraFa
• Figure 5: Distribution of complexity over time across 1000 different runs, with $0.024\%$ mutation rate. Each shade of red represents a different quantile range. 40% of runs show a state transition within 16k epochs.