User Controls
Posts by Bradley
-
2024-08-09 at 1:44 AM UTC in SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTTSEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT
SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT
SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT
SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT
SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT
SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT
SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT
SEVENTH ANNUAL SEX PARTY SATURDAY 10PM EASTERN SEX KITTEN KINKOU & BRADLEYB HOSTESSES, CUM 2 BUTT -
2024-08-09 at 1:40 AM UTC in My dad's clothesya that and after 13 years of drinking and talking shit it's difficult to shift into a kind person in my interactions with everyone.
I hope it doesn't stay that way, I like coming here but it's more important to be a good person.
I'm nice on telegram to everyone and Wariat i stopped tlaking shit to i just don't reply to him when he talk sabout shit i normally would make fun of him for -
2024-08-09 at 1:38 AM UTC in HerringWell that's one opinion. I'm certainly not above eating canned fish.
-
2024-08-09 at 1:37 AM UTC in My dad's clothesI aint got shit from my father except a bald spot and a low desire to stay in the lives of people once I grow to not like them
-
2024-08-09 at 1:34 AM UTC in My dad's clotheshow you doin? :) Sorry i haven't posted much/come back to the thread to chat, I've had a busy day. I got all my stuff in order and my new computer came. Been a combination of different things going on that's kept me from interacting with the forum lately.
As an aside, I feel liek this forum does make me meaner. I used to talk shit to people like I do here in real life but since I quit drinking and stabbing dogs and working on being a less abrasive person, I've really started treating people better.
I really like being here and spending time here but I feel like it does make me quite an unlikeable person and think about things in a manner I don't really in real life feel anymore.
Food for thought, it has me very introspective these days wondering how I can become an even better person and I want some pussy. -
2024-08-09 at 1:30 AM UTC in My dad's clotheskafka is my second favorite poster
\first is candyrein -
2024-08-09 at 12:58 AM UTC in Herring
-
2024-08-08 at 10:42 PM UTC in My dad's clothes
-
2024-08-08 at 2:55 PM UTC in My dad's clothes
-
2024-08-08 at 2:50 PM UTC in My dad's clothesIronically other than socks, my belt and 1 sweatshirt 100% of my clothing has been acquired second hand.
Wearing new clothes is crazy to me. I go to the store and they want 35$ for a button up. I go to a thrift shop, I pay maybe 3-7.
What I am not wearing though is other people's used socks or condoms. -
2024-08-08 at 2:48 PM UTC in My dad's clothesI can't wait to wear these beautiful garments. When I adorn myself with the raiment of your late father I will feel blessed that I was special enough for you to see fit to place them upon.
-
2024-08-08 at 1:17 AM UTC in Black Mold or Gas LeakUnhealthy diet, inactive physically.
-
2024-08-08 at 1:17 AM UTC in Request: A guide on how to pirate games.
-
2024-08-07 at 10:28 PM UTC in What are you thinking about....How I can be more of service to my peers.
-
2024-08-07 at 10:15 PM UTC in Request: A guide on how to pirate games.also the computer came with 3 months of xbox PC gamepass, anyone have any experience with that???
-
2024-08-07 at 10:14 PM UTC in Request: A guide on how to pirate games.oh ok, i can't wait till tomorrow so I can piss blood and burn myself
-
2024-08-07 at 10:12 PM UTC in Dunno what happened to my footya i remember
-
2024-08-07 at 9:55 PM UTC in 🍬🍬Candy~Land🍬🍬
Originally posted by the man who put it in my hood 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†
†Google, Paradigms of Intelligence Team and ‡The University of Chicago
{blaisea, jyrki, benl, moralex, eyvind, etr, veluca}@google.com
jevans@uchicago.edu
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.
K eywords Origins of Life · Artificial Life · Self-replication
1 Introduction
The field of Origins of Life (OoL) has debated the definition of life and the requirements and mechanisms
for life to emerge since its inception [ 1]. Different theories assign varying importance to the phenomena
associated with living systems. Some consider the emergence of RNA as the major turning point [ 2 ], while
others focus on metabolism or chemical networks with autocatalytic properties [ 3, 4]. The question of what
defines life and how it can emerge becomes necessarily more complex if we shift focus from “life as it is” to
“life as it could be”, the central question for the Artificial Life (ALife) community [ 5 ]. While searching for a
general definition of life, we observe a major change in dynamics coincident with the rise of self-replicators,
which seems to apply regardless of substrate. Hence, we may use the appearance of self-replicators as a
reasonable transition to distinguish pre-life from life dynamics [6].
Many systems involve self-replication. RNA [ 7], DNA, and associated polymerases are commonly accepted
self-replicators. Autocatalytic networks are also widely considered self-replicators [8]. Self-replicators are also
widespread in computer simulations by design. Most ALife experiments agents have predetermined methods
of self-replication, but several experiments have also studied the dynamics of lower level and spontaneous self-
arXiv:2406.19108v2 [cs.NE] 2 Aug 2024
Agüera y Arcas et al.
replication. Famously, Cellular Automata (CA) were created to study self-replication and self-reproduction [9 ].
Self-replicating loops with CA have been extensively studied [ 10, 11, 12]. A recent extension of CA, Neural
CA [13 ], can be trained to self-replicate patterns that robustly maintain interesting variation [14 ]. Particle
systems with suitable dynamical laws can also demonstrate self-replicating behaviors [ 15 ]. Neural networks
can be trained to output their own weights while performing auxiliary tasks [ 16 ] and they can be trained to
self-reproduce with meaningful variation in offspring [17]. Finally, self-replicators can exist on computational
substrates in the form of explicit programs that copy themselves, as in an assembly–like programming
language [18, 19], or a LISP-based environment [20], but this area of inquiry remains underexplored, and is
the focus of this paper.
Much research on OoL and ALife focuses on the life period when self-replicators are already abundant. A
central question during this period is: How do variation and complexity arise from simple self-replicators?
Analyses often take the form of mathematical models and simulations [ 21 ]. In ALife, researchers often focus
on selection for complex behaviors [ 22 ], which may include interactions with other agents [ 23 ]. Simulations
may include tens of thousands of parameters and complex virtual ecosystems [ 24 ], but they can rarely
modify the means of self-replication beyond adapting the mutation rate. The two most notable exceptions
use assembly-like languages as computational substrate. In Tierra [ 18], simple assembly programs have
no goals but are given time to execute their program and access and modify nearby memory. This causes
them to self-replicate and manifest limited but interesting dynamics, including the rise of “parasites” that
feed off other self-replicators. Avida [ 19 ] functions similarly: assembly-like programs are left running their
code for a limited time. They can also self-replicate, this time by allocating new memory, writing their
program in the new space, and then splitting. Avida adds a concept of fitness, since performing auxiliary
computation increases a replicator’s allotted execution time. Notably, both Tierra and Avida are seeded with
a hand-crafted self-replicator, called the “ancestor”. This puts them squarely into “life” dynamics, but still
allows for modification of the self-replication mechanism.
But how does life begin? How do we get from a pre-life period devoid of self-replicators to one abundant
with them? We know that several systems, initialized with randomly interacting primitives, can give rise
to complex dynamics that result in selection under pre-life conditions [6]. The OoL field has extensively
studied autocatalysis, chemical reactions where one of the reaction products is also a catalyst for the same
reaction, as well as autocatalytic networks (or sets), groups of chemicals that form a closed loop of catalytic
reactions [ 25]. Autocatalysis appears fundamental to the emergence of life in the biological world. Moreover,
autocatalytic networks arise inevitably with sufficiently distinctive catalysts in the prebiotic “soup” [ 26].
These have also been simulated in computational experiments [8, 27, 20, 28, 29, 30].
Fontana [20 ], for example, simulates the emergence of autocatalytic networks on the computational substrate
of the lambda calculus using LISP programs (or functions). Each element is a function that takes another
function as input and outputs a new function. Thus, a graph of interactions can be constructed which, on
occasion, gives rise to autocatalytic networks. Fontana also performed a “Turing gas” simulation, where a
fixed number of programs randomly interact using the following ordered rule:
f + g −→ f + g + f (g) (1)
Where f and g are some legal lambda calculus functions. To conserve a fixed number of programs, one of the
three right-hand side programs was eliminated using rule-based criteria. Aside from autocatalytic networks,
a very simple solution involves the emergence of an identity function i, yielding:
i + i −→ 3i (2)
This program has strong fitness, and it was often observed that the entire gas converges to the identity. This
can be considered a trivial replicator, which in some experiments is explicitly disallowed by constraint.
In [ 28 ], the authors use combinatorial logic to create an “artificial chemistry” founded upon basic building
blocks. Their system preserves “mass” (operations neither create nor destroy building blocks) and results in
simple autocatalytic behaviors, ever-growing structures, and periods of transient self-replicator emergence.
While lambda calculus and combinatorial logic are related to programming languages in general, they represent
distinct computational substrates. For example, creating RNA-like structures that can self-replicate arbitrary
payloads may involve different approaches, depending on the substrate. Biology is steadily furthering insights
regarding the conditions under which complex replicators such as RNA and DNA could have arisen and
under which conditions. This question is underexplored for the general case, especially on computational
substrates. Given recent advances in Artificial Intelligence, computational substrates could very well form
the foundation for new forms of life and complex, evolving behavior.
In this paper we focus on computational substrates formed atop various programming languages. Here we
highlight some of the most relevant previous investigations of the pre-life period on such substrates [29 , 30 , 31 ].
2
Agüera y Arcas et al.
In all of these investigations, and in ours as well, there is no explicit fitness function that drives complexification
or self-replicators to arise. Nevertheless, complex dynamics happen due to the implicit competition for scarce
resources (space, execution time, and sometimes energy).
In Coreworld [ 29, 30], the authors explore the substrate of programming languages with multiple programs
executed in parallel and sharing the instruction (and data) tape. Programs consume a locally shared resource
(energy) for executing each operation. The authors perform different runs where they observe complex
dynamical systems resembling the pre-life period hypothesized in biology and observed in our experiments
as well. In Coreworld, large structures appear alongside inescapable self-loops. Some simple self-replicators
of two instructions (MOV-SPL) often take over. Interestingly, when the authors seed the environment with a
functioning (more complex) self-replicator, self-replicators do not take over and eventually random mutations
caused by their copy mechanism make them go extinct.
In [31 ], the author observes and quantifies the likelihood of self-replicators to arise with a given environment
and programming language. The rise of self-replicators in this environment is however due to either random
initialization or to random mutations of imperfect self-replicators (whom appearance is in turn due to random
initialization).
While the generation of self-replicators can indeed happen due to random initialization or solely due to
mutations, in this paper we show that, for the majority of the configurations we explore, self-replicators
arise mainly (or sometimes solely) due to self-modification. 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. We primarily investigate extensions to the “Brainfuck” language [32 , 33],
an esoteric language chosen for its simplicity, and show how self-replicators arise in a variety of related
systems. We show experiments undertaken on an isolated system variant of the Turing gas in Fontana [20],
which we informally call “primordial soup”. We then show how spatial extensions to the primordial soup
cause self-replicators to arise with more interesting behaviors such as competition for space between different
self-replicators. We also show how similar results are accomplished by extending the “Forth” [ 34] programming
language in different ways and in varying environments, as well as with real world instruction set of a Zilog Z80
8-bit microprocessor [35] emulator and with the Intel 8080 instruction set. Finally, we show a counterexample
programming language, SUBLEQ [36 ], where we do not observe this transition from pre-life to life. We note
that the shortest length of hand-crafted self-replicators in SUBLEQ-like substrates is significantly larger than
what is observed in previous substrates.
2 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 (213). Note
3
Agüera y Arcas et al.
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”.
2.1 Primordial soup simulations
The main kind of simulations we will use in this paper are a variant of the Turing gas from Fontana [ 20]. In this
gas, a large number of programs (usually 217) form a “primordial soup”. Each program consists of 64 1-byte
characters which are randomly initialized from a uniform distribution. In these simulations, no new programs
are generated or removed – change only occurs through self-modification or random background mutations. In
each epoch, programs interact with one another by selecting random ordered pairs, concatenating them and
executing the resulting code for a fixed number of steps or until the program ends. Because our programming
languages read and write on the same tape, which is the program itself, these executions generally modify both
initial programs. At the end, the programs are separated and returned to the soup for future consideration.
We can interpret the interaction between any two programs (A and B) as an irreversible chemical reaction
where order matters. This can be described as having a uniform distribution of catalysts a and b that interact
with A and B as follows:
A + B a
−→ split(exec(AB)) = A′ + B′ (3)
A + B b
−→ split(exec(BA)) = A′′ + B′′ (4)
Where exec runs the concatenated programs and split divides the result back into two 64 byte strings. As we
will see, just this kind of interaction, even without background noise, is sufficient to generate self-replicators.
In their simplest form, we can see self-replicators as immediate autocatalytic reactions of a program S and
food F that act as follows:
S + F a
−→ split(exec(SF )) = 2 · S (5)
This is because the self-replicator is unaffected by the code written in the other program and it gets repurposed
as available real estate. Note that the behavior of the catalyst b is undefined, but when the pool is full of
self-replicators, this would result in either one of the two strings to self-replicate at random.
While useful for understanding operationally what occurs, we acknowledge that this framing has several
limitations. First, it fails to account for autocatalysis that takes place over more than one step, which could
occur for autocatalytic sets. Second, a self-replicator is generally much smaller than the full 64 byte window.
If it copied itself with a specific offset different from 64, it may still count as a functional self-replication
but it would fail to generate a perfect self-copy. This suggests that a more complete manner of inspection
for the behavior of self-replicators would involve observing substrings, but this is generally computationally
intractable. We therefore will show a mixture of anecdotal evidence and graphs plotting summarizing
complexity metrics.
Complexity metrics In this paper, we introduce a novel complexity metric we call “high-order entropy”.
Theoretically, we define the high-order entropy of a length n string as the difference between (1) its Shannon
entropy (computed over individual tokens – i.e. bytes) and (2) its “normalized” Kolmogorov complexity (i.e.
its Kolmogorov complexity divided by n).
Intuitively, this complexity definition is meant to capture the amount of information that can only be
explained by relations between different characters.
This metric shares similarities with sophistication [ 37 , 38, 39 ] and effective complexity [40 ], because it attempts
to “factor out” information in the string that comes from sampling i.i.d. variables. Nevertheless, we are not
aware of methods to efficiently estimate these metrics. This led us to the construction of this new metric.
Properties of “high-order entropy” that justify its use as a complexity metric and encode the above intuition
include the following:
1. Given a sequence of n i.i.d. characters, its expected high-order entropy converges to 0 as n grows to
infinity.
4
Agüera y Arcas et al.
0 500 1000 1500 2000 2500 3000 3500 4000 4500 5000
104
105
106
first replicator
Epoch
Element count
0
1
2
3
4
5
complexity
unique tokens
unique (no transition)
top32 tokens
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 2).
2. Given a sequence of k i.i.d. characters with distribution D, the expected high-order entropy of the
string formed by concatenating n copies of those characters converges to the Shannon entropy of D
as n grows to infinity.
i agree -
2024-08-07 at 9:51 PM UTC in THE MAN WHO PUT IT IN MY HOODOP did too many drugs (and you can tell).
-
2024-08-07 at 9:48 PM UTC in Dunno what happened to my foot
