In this post, I would like to extend the concept of cosmic Universal Darwinism at work as presented in The Law of Increasing Functional Information and the Evolution of Software with some very significant work by Google Research. For a quick review of the Law of Increasing Functional Information see Michael Wong's:
On the roles of function and selection in evolving systems
https://www.pnas.org/doi/epdf/10.1073/pnas.2310223120
and also Robert Hazen's YouTube video:
Robert M. Hazen, PhD - The Missing Law: Is There a Universal Law of Evolving Systems?
https://youtu.be/TrNf62IGqM8?t=2114
The Law of Increasing Functional Information states that given the following system conditions:
1. Each system is formed from numerous interacting units (e.g., nuclear particles, chemical elements, organic molecules, or cells) that result in combinatorially large numbers of possible configurations.
2. In each of these systems, ongoing processes generate large numbers of different configurations.
3. Some configurations, by virtue of their stability or other “competitive” advantage, are more likely to persist owing to selection for function.
Then such a system must evolve:
The Law of Increasing Functional Information:
The Functional Information of a system will increase (i.e., the system will evolve) if many different configurations of the system are subjected to selection for one or more functions.
For a general overview of this new Google Research effort please see the recent YouTube videos by Anton Petrov and Sabine Hossenfelder:
Did Google Researchers Just Create a Self-Replicating Computer Life Form?
https://www.youtube.com/watch?v=L_IWVZPmc-E
Random Code Can Learn to Self-Replicate, New Study Finds
https://www.youtube.com/watch?v=EpRRwgyeBak&t=0s
Here is the original paper from Google Research:
Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction
Blaise Agüera y Arcas, Jyrki Alakuijala, James Evans, Ben Laurie, Alexander Mordvintsev, Eyvind Niklasson, Ettore Randazzo, Luca Versari
https://arxiv.org/pdf/2406.19108
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.
The most significant finding of the authors is:
We show that initialising random programs in a variety of environments, all lacking an explicit fitness landscape, nevertheless give rise to self-replicators. We observe that self-replicators arise mostly due to self-modification and this can happen both with and without background random mutation.
Experimental Approach
Much of the research conducted by the authors uses a modified version of the minimalist BF language, modified by the authors for their simulated experiments, which they have dubbed BFF. For an introduction to the original BF language, see this Wikipedia article on BF:
Brainfuck
https://en.wikipedia.org/wiki/Brainfuck
Here is how the authors describe their new BFF language:
BFF: Extending Brainfuck
Brainfuck (BF) is an esoteric programming language widely known for its obscure minimalism. The original
language consists of only eight basic commands, one data pointer, one instruction pointer, an input stream,
and an output stream. Notably, the only mathematical operations are “add one” and “subtract one”, making
it onerous for humans to program with this language. We extend BF to operate in a self-contained universe
where the data and instruction tapes are the same and programs modify themselves. We do so by replacing
input and output streams with operations to copy from one head to another. The instruction pointer, the
read and the write heads (head0 and head1) all operate on the same tape (stored as one byte per pointer
position, and initialized to zero). The instruction pointer starts at zero and reads the instruction at that
position. Every instruction not listed below is a no-operation. The complete instruction set is as follows:
< head0 = head0 - 1
> head0 = head0 + 1
{ head1 = head1 - 1
} head1 = head1 + 1
- tape[head0] = tape[head0] - 1
+ tape[head0] = tape[head0] + 1
. tape[head1] = tape[head0]
, tape[head0] = tape[head1]
[ if (tape[head0] == 0): jump forwards to matching ] command.
] if (tape[head0] != 0): jump backwards to matching [ command.
Parenthesis matching follows the usual rules, allowing nesting. If no matching parenthesis is found, the
program terminates. The program also terminates after a fixed number of characters being read. Note
that since instructions and data sit in the same place, they are encoded with a single byte. Therefore, out
of the 256 possible characters, only 10 are valid instructions and 1 corresponds to the true “zero” used to
exit loops. Any remaining values can be used to store data. By having neither input nor output streams,
program strings can only interact with one another. None of our experiments will have any explicit fitness
functions and programs will simply be left to execute code and overwrite themselves and neighbors based on
their own instructions. As we will show, this is enough for self-replicators to emerge. Since the majority of
investigations from this paper will be performed on a family of extended BF languages, we give this family of
extensions the acronym “BFF”.
Figure 1 - The BFF language is a very close approximation of a true Turing Machine. A Turing Machine has a read/write head and an infinitely long paper tape. The read/write head can read instructions on the tape that are encoded as a sequence of 1s and 0s and can write out the results of following the instructions on the paper tape back to the tape as a sequence of 1s and 0s. Thus, a Turing Machine stores computer instructions and data on the same single tape, just as the BFF language does.
BFF Simulated Primordial Soup Simulations
To conduct their experiments with software spontaneously developing the ability to self-replicate, the authors created a simulated primordial soup of 217 = 131,072 64-byte BFF tapes. These BFF tapes were then each randomly initialized with 64 ASCII characters, the very same characters that you find on your computer keyboard. Many of these 64-character BFF program tapes contained some of the 8 BFF instructions in the BFF instruction set < > { } - + . ,. However, note that most of the ASCII characters in the 64-byte BFF tapes were not one of the 8 BFF instructions. Instead, they might be ASCII characters like A, G, U, E, M, 7, 9, b or t. Such ASCII characters are meaningless to the BFF language and would be treated just like comment statements in a normal C or C++ program. Next, the authors randomly took two of the 64-character BFF tapes A and B and combined them into a single 128-character AB BFF tape by slapping the B tape after the A tape. Then the BFF program on this 128-character AB BFF tape was run for a finite number of steps or until the AB BFF program completed. Then the completed 128-character AB BFF output tape was split right down the middle into two 64-character BFF tapes A' and B'. These new 64-character A' and B' tapes were then returned to the primordial soup of 131,072 64-character tapes and two other tapes were then selected for the same process until all of the 64-character tapes in the 131,072 pool of tapes were processed. Then this whole process was repeated for the entire population of 131,072 64-character tapes many many times. Each repetition was called an epoch.
Normally, the new 64-character tapes A' and B' would both be different than the original A and B 64-character tapes because of the write operations that were carried out by the combined AB BFF program on the 128-character BFF tape:
A + B ⇒ AB ⇒ A' + B'
But since, like a Turing Machine, the 128-character BFF tape was used to store both the combined AB BFF program and any data that was written by the combined AB BFF program, in some rare cases, that gave some BFF programs the possibility to self-replicate by writing themselves over the real estate that was formerly occupied by the code of other BFF programs:
A + B ⇒ AB ⇒ A + A
Below is a version of the BFF video in Anton Petrov's YouTube showing this self-replicating process in action. Notice that in the lower right corner, one of the 64-byte BFF tapes spontaneously developed the ability to self-replicate by overlaying neighboring BFF tapes at about 1:50 into the 5:33 video. In terms of the Law of Increasing Functional Information, this not only represents a first-order form of Functional Information that is stable and can persist with time, it also demonstrates a second-order form of Functional Information that is a self-sustaining dynamical process that persists in time to create duplicate forms of Functional Information with the property of self-replication. Finally, it demonstrates the emergence of a third-order form of Functional Information that explores for novelty in the "Adjacent Possible" of Stuart Kauffman.
Life Emerging in 2D BFF
https://www.youtube.com/watch?v=07NoZwvgJ_M&t=0s
Figure 2 – At 23 seconds into the simulation, we see that the 131,072 64-character tapes that were initialized with random characters are living in a primordial soup of BFF programs coming and going with time. None really persist in time, so none demonstrate a first-order form of Functional Information, which is denoted by the ability to be stable over time.
Figure 3 – At 1:01 we see a very similar situation, but some BFF programs seem to be gaining in strength by self-replicating in a very weak manner.
Figure 4 - We see an abrupt phase change in which a new replicator appears in the lower left of the diagram.
Figure 5 – This replicator then rapidly begins to self-replicate by overlaying the BFF programs in its vicinity.
Figure 6 – This continues on as the first replicator begins to take over all of the real estate in the initial primordial soup.
Figure 7 – This continues on until the original replicator dominates the entire original primordial soup.
Figure 8 – As time unfolds new replicators begin to appear that can feed upon the original replicator, forming a simulated ecosphere of replicators.
Self-Replicating Software Spontaneously Arising in the Forth Programming Language
To demonstrate that self-replication can arise in more complicated computer languages beyond BFF, the authors repeated their BFF experiments using the Forth computer language. Forth was very popular in the early 1980s because it was well-suited for the 8-bit microprocessors of the time. For more on the Forth computer language, see:
Forth (programming language)
https://en.wikipedia.org/wiki/Forth_(programming_language)
Here is a similar Forth YouTube video showing the unguided self-replicating Forth programs arising in a primordial soup:
Life Emerging in 2D Forth
https://www.youtube.com/watch?v=eOHGBuZCswA&t=0s
Self-Replicating Software Spontaneously Arising in a Z80 Microprocessor
Finally, the authors demonstrate the spontaneous rise of self-replicating software in the classic Z80 microprocessor. The Z80 was an 8-bit processor that was officially launched in July of 1976 as an improved version of Intel's original 8080 processor. The Z80 had 8,500 transistors and a clock speed of 2.5 - 8 MHz, so a modern laptop CPU chip has about 1,000 times the processing power. The Z80 could run 8080 code in addition to more complex code that took advantage of the Z80's improved design. The Z80 quickly began to dominate the 8080 market. Zilog recently discontinued production of the Z80 in June of 2024 after nearly five decades of production. For more about the Z80 see:
Zilog Z80
https://en.wikipedia.org/wiki/Zilog_Z80
Figure 9 – Above we see the layout of a Z80 microprocessor with its 8,500 transistors.
Figure 10 – Above is a diagram of the Z80 architecture.
In the above paper, the authors describe their experiments with a Z80 emulator:
Previous sections explore spontaneous emergence of self-replicators and state transition phenomena in a few
computational substrates based on artificially designed minimalistic languages. In order to test the generality
of our observations we perform an experiment with a system using emulation of the real-world Z80 CPU
architecture. We study a 2D grid of 16-byte programs initialized with uniform random noise. At each
simulation step we randomly pick a pair of adjacent tapes “A” and “B” and concatenate them in random
order (“AB” or “BA”). Then we reset the Z80 emulator and run 256 instruction steps, using the concatenated
tapes as the memory buffer. All memory read and write request addresses are computed by modulo of the
concatenated tape length (32 bytes), which prevents out-of-bounds accesses by random programs. In parallel
to CPU-driven self-modification process, mutations are applied to random bytes of the grid.
This simple setup gives rise to surprisingly complex behaviours with a number of self-replicator generations
exploiting different Z80 features emerging. Some of these self-replicators form a sort of symbiotic ecosystems,
while other compete for domination (Figure 18). We often observe a series of state transition-like events
when more and more capable self-replicators or replicator collectives overtake the soup multiple times.
Early generations use stack-based copy mechanism: at initialization Z80 sets the stack pointer at the
end of the address space, so pushing values onto stack gives tape A a simple mechanism of writing to
tape B. Most of the time we see the development of an “ecosystem” of stack-based self-replicators that
eventually gets replaced with self-replicators that exploit “LDIR” or “LDDR” instructions that allow to copy
continuous chunks of memory. We created an interactive lab to facilitate the exploration of z80 self-replicators:
https://github.com/znah/zff.
Here is a YouTube video from the New Scientist magazine that shows this Z80 simulation in progress:
Google creates self-replicating artificial life from digital soup with no rules
https://www.youtube.com/watch?v=0hKrtFQxIbk
Figure 11 – In the above Z80 simulation, a Green Replicator soon appears after all the Z80 memory tapes were initialized with pure noise.
Figure 12 – The Green Replicator rapidly expands to occupy the entire memory space of all the Z80 programs.
Figure 13 – The Green Replicator continues to dominate the landscape, but soon a Blue Replicator appears as a competitor for memory space.
Figure 14 – The newly-arrived Blue competitor soon begins to feed on the original Green Replicator.
Figure 15 – As can be seen in detail by a closer view.
Figure 16 – As the Blue competitor continues to grow and feed on the Green Replicator, a new Red competitor spontaneously arrives on the scene.
Figure 17 – As can be seen in detail by a closer view.
The figure below is from the last figure in the paper cited above and explains how an ecosystem of self-replicating software was observed to arise on a Z80 microprocessor.
Figure 18: Ecosystem of self-replicators produced by Z80 CPUs operating on a 2D grid. Every 4x4 group
of pixels correspond to a single 16-byte program. At every simulation step a random pair of adjacent cells
gets selected, concatenated and executed by a Z80 emulator for 256 steps. We observe emergence of a few
generations of self-replicators. First the wave of stack based self-replicators sweeps the grid and forms an
“ecosystem” of a few co-existing variants. Then the grid is overtaken by more robust self-replicators that use
memory copy instructions. Colors correspond to a few most popular instruction codes used by self-replicators:
LDIR/LDDR - memory copy, PUSH HL - push 16-bits (stored in H and L registers) onto stack, LD HL, X / LD HL, (X) - set HL registers with immediate or indirect value.
The significance of this research effort is that, unlike other computer simulation attempts, no artificial fitness function was applied. The selection process itself arose simply from the Universe itself as a pure form of natural selection.
Implications for Softwarephysics
Softwarephysics has long held that it is all about self-replicating information in action.
Self-Replicating Information – Information that persists through time by making copies of itself or by enlisting the support of other things to ensure that copies of itself are made.
Over the past 4.56 billion years we have seen five waves of self-replicating information sweep across the surface of the Earth and totally rework the planet, as each new wave came to dominate the Earth:
1. Self-replicating autocatalytic metabolic pathways of organic molecules
2. RNA
3. DNA
4. Memes
5. Software
Software is currently the most recent wave of self-replicating information to arrive upon the scene and is rapidly becoming the dominant form of self-replicating information on the planet. For more on the above see A Brief History of Self-Replicating Information and Susan Blackmore's brilliant TED presentation at:
Memes and "temes"https://www.ted.com/talks/susan_blackmore_on_memes_and_temes
Note that I consider Susan Blackmore's temes to really be technological artifacts that contain software. After all, a smartphone without software is simply a flake tool with a very dull edge.
The Characteristics of Self-Replicating Information
All forms of self-replicating information have some common characteristics:
1. All self-replicating information evolves over time through the Darwinian processes of inheritance, innovation and natural selection, which endows self-replicating information with one telling characteristic – the ability to survive in a Universe dominated by the second law of thermodynamics and nonlinearity.
2. All self-replicating information begins spontaneously as a parasitic mutation that obtains energy, information and sometimes matter from a host.
3. With time, the parasitic self-replicating information takes on a symbiotic relationship with its host.
4. Eventually, the self-replicating information becomes one with its host through the symbiotic integration of the host and the self-replicating information.
5. Ultimately, the self-replicating information replaces its host as the dominant form of self-replicating information.
6. Most hosts are also forms of self-replicating information.
7. All self-replicating information has to be a little bit nasty in order to survive.
8. The defining characteristic of self-replicating information is the ability of self-replicating information to change the boundary conditions of its utility phase space in new and unpredictable ways by means of exapting current functions into new uses that change the size and shape of its particular utility phase space. See Enablement - the Definitive Characteristic of Living Things for more on this last characteristic. That posting discusses Stuart Kauffman's theory of Enablement in which living things are seen to exapt existing functions into new and unpredictable functions by discovering the “AdjacentPossible” of springloaded preadaptations.
Software is currently the most recent wave of self-replicating information to arrive upon the scene and is rapidly becoming the dominant form of self-replicating information on the planet. Again, self-replicating information cannot think, so it cannot participate in a conspiracy-theory-like fashion to take over the world. All forms of self-replicating information are simply forms of mindless information responding to the blind Darwinian forces of inheritance, innovation and natural selection. Yet despite that, as each new wave of self-replicating information came to predominance over the past four billion years, they all managed to completely transform the surface of the entire planet, so we should not expect anything less from software as it comes to replace the memes as the dominant form of self-replicating information on the planet.
But this time might be different. What might happen if software does eventually develop a Mind of its own? After all, that does seem to be the ultimate goal of all the current AI software research that is going on. As we all can now plainly see, if we are paying just a little attention, advanced AI is not conspiring to take over the world and replace us because that is precisely what we are all now doing for it. As a carbon-based form of Intelligence that arose from over four billion years of greed, theft and murder, we cannot do otherwise. Greed, theft and murder are now relentlessly driving us all toward building ASI Machines to take our place. From a cosmic perspective, this is really a very good thing when seen from the perspective of an Intelligent galaxy that could live on for at least 100 trillion years beyond the brief and tumultuous 10 billion-year labor of its birth. That is more than 10,000 times the current age of our galaxy! For more on that see Welcome To The First Galactic Singularity, How Advanced AI Software Could Come to Dominate the Entire Galaxy Using Light-Powered Stellar Photon Sails and An Alternative Approach for Future ASI Machines to Explore our Galaxy Using Free-Floating Rogue Planets.
But in my view, self-replicating information may take on even more significance as I outlined in What’s It All About?, What's It All About Again?, The Self-Organizing Recursive Cosmos and The Self-Organizing Recursive Cosmos - Part II. My current working hypothesis for what's it all about envisions an eternal and never-ending Multiverse composed of self-replicating mathematical information constantly coming to be.
Comments are welcome at
scj333@sbcglobal.net
To see all posts on softwarephysics in reverse order go to:
https://softwarephysics.blogspot.com/
Regards,
Steve Johnston
