Fact-checked by Grok 2 weeks ago

Zero-player game

A zero-player game, also known as a no-player game, is a simulation or game mechanic that evolves autonomously without requiring any ongoing decisions or actions from human participants after an initial configuration, relying instead on predefined rules to determine its progression.^[1] These games are typically categorized into several types, including those determined solely by initial states, such as cellular automata; AI-versus-AI competitions where algorithms play against each other; solved games with predetermined outcomes under optimal conditions; and hypothetical constructs used for theoretical exploration.^[1] The concept was first articulated in 2009 by researcher Rodney P. Carlisle in reference to simulations like Conway's Game of Life, emphasizing that "once the board has been initially set up, there is no player intervention."^[1] The quintessential example is Conway's Game of Life, invented by British mathematician John Horton Conway around 1970 while at Cambridge University, and popularized through Martin Gardner's Scientific American column in October of that year.^[2] In this two-dimensional cellular automaton, cells on an infinite grid follow four simple rules based on their eight neighbors: a live cell with fewer than two live neighbors dies (underpopulation), one with two or three lives on, one with more than three dies (overpopulation), and a dead cell with exactly three live neighbors becomes alive (reproduction).^[2] This setup produces emergent behaviors, including stable patterns (still lifes), oscillators, and moving structures like gliders, demonstrating complex self-organization from minimal rules; the system is Turing-complete, capable of simulating any computation.^[2] Other notable instances include AI-driven matches, such as programs competing in chess or Go without human oversight, which highlight advancements in computational game theory.^[1] Solved games further exemplify the category, as in checkers (also known as draughts), where exhaustive analysis by computer scientists in 2007 proved that perfect play by both sides always results in a draw, effectively eliminating strategic variability.^[3] Zero-player games challenge traditional definitions of play by decoupling agency from outcomes, influencing fields like artificial life, algorithm design, and philosophy of computation, while early precursors trace back to 1970s programming experiments like RobotWar.^[1]

Definition and Fundamentals

Core Definition

A zero-player game is defined as a game or simulation that requires no human involvement or player decisions after its initial configuration, with all subsequent evolution governed solely by a set of predefined rules applied to the starting conditions.^[4] This setup-only interaction means the system operates autonomously, producing outcomes independent of ongoing player agency. Unlike traditional games, which rely on player interactivity, strategic choices, and often explicit win or lose conditions tied to human actions, zero-player games eliminate such elements, focusing instead on the emergent behavior of the rules themselves.^[4] The absence of player-centric agency shifts the emphasis from competition or decision-making to observation of self-sustaining processes, challenging conventional notions of gameplay that presuppose human participation. The conceptual boundaries of zero-player games center on deterministic evolutions, where the trajectory is fully predictable from the initial state and rules, though some implementations may incorporate probabilistic elements while still precluding any form of real-time human intervention. These systems align closely with automata theory, where abstract machines or rule-based models evolve without external control.

Key Characteristics

Zero-player games typically exhibit a deterministic nature in many instances, such as cellular automata, where outcomes are predictable given an initial state and a fixed set of rules, though implementations like AI-versus-AI interactions may introduce variability through probabilistic algorithms.^[1] This distinguishes zero-player games from those involving player decisions that introduce variability.^[5] In contrast to traditional player-influenced games, zero-player systems operate solely on predefined mechanics, eliminating agency during execution.^[1] A core characteristic is autonomy, achieved through self-sustaining rule application that propagates changes across the game's state without requiring ongoing input.^[6] This allows the simulation to run indefinitely or until a stable configuration is reached, embodying a closed-loop process where the system governs its own evolution.^[5] Complementing autonomy is emergence, wherein intricate patterns and behaviors arise from the iterative application of simple, local rules, often yielding unexpected complexity from minimal initial conditions.^[6] For instance, basic neighborhood-based updates can produce lifelike structures or oscillations, illustrating how global phenomena emerge from localized interactions. The mechanics of zero-player games revolve around discrete state transitions, where each iteration updates the entire system based on current conditions, forming cycles of computation that advance temporally without external variables.^[5] These transitions are typically synchronous, applying rules uniformly to all elements in parallel, ensuring consistency across iterations.^[7] Fixed parameters, such as grid dimensions or predefined rule sets, are essential to preserving the zero-player essence, as they delimit the environment and mechanics, preventing any deviation that might necessitate player oversight.^[1] By constraining variability to the initial setup, these parameters maintain the game's self-contained progression.^[8]

Historical Development

Early Mathematical Foundations

The foundations of zero-player games trace back to 19th-century developments in automata theory, where mechanical devices capable of autonomous operation began to conceptualize self-sustaining processes. Charles Babbage's Analytical Engine, proposed in 1834, represented a pivotal precursor as a programmable mechanical computer featuring a "Store" for memory and a "Mill" for processing, enabling iterative loops and conditional operations without external intervention once initiated.^[9] This design, inspired by the Jacquard loom's punched cards, allowed the machine to execute sequences of instructions independently, laying early groundwork for systems that evolve deterministically from an initial configuration.^[9] Parallel advancements in recursion further supported these ideas by providing mathematical tools for self-referential definitions. In the mid-19th century, Hermann Grassmann introduced recursive definitions for basic arithmetic operations like addition and multiplication in 1861.^[10] This approach was formalized by Richard Dedekind in 1888, who coined "definition by recursion" in his work Was sind und was sollen die Zahlen?, using it to define functions such as exponentiation through inductive steps that build upon prior values.^[10] Giuseppe Peano adopted and extended these in 1889 for his axiomatization of natural numbers, emphasizing effective procedures for computation.^[10] Such recursive methods enabled the modeling of processes where outcomes depend on previous states, a core principle for self-evolving mathematical structures. Mathematical puzzles of the era also influenced concepts of autonomous evolution. The Tower of Hanoi, devised by Édouard Lucas in 1883, exemplifies a deterministic state-transition system solvable via recursion: to move n disks from one peg to another, the top n-1 disks are recursively shifted to an auxiliary peg, the largest disk moved, and the n-1 disks then transferred atop it.^[11] This recursive algorithm can be executed "without memory" using finite automata, highlighting how initial conditions drive irreversible progression without ongoing input.^[11] Similarly, David Hilbert's 23 problems, presented in 1900, spurred foundational work in logic and computability—particularly the 10th problem on decision procedures—that underpinned self-referential systems by exploring the limits of algorithmic solvability.^[12] By the 1940s, these threads converged in John von Neumann's theory of self-replicating automata. Motivated by biological reproduction and working at the Los Alamos National Laboratory, von Neumann collaborated with Stanisław Ulam in 1948 to develop a cellular automaton model on an infinite two-dimensional grid, where each cell has 29 states and interacts with four orthogonal neighbors.^[13] Outlined in his 1948 Hixon Symposium lecture and posthumously published as Theory of Self-Reproducing Automata in 1966, the design demonstrated a universal constructor capable of interpreting instructions to fabricate replicas of itself, propagating genetic-like information across generations.^[13] This framework formalized self-replication in discrete structures, bridging abstract recursion to dynamic, emergent behaviors observable in later computational realizations.^[13]

Emergence in Computing

The transition of zero-player game concepts into computational frameworks gained momentum in the mid-20th century, as theoretical models of self-evolving systems became feasible to simulate digitally. Building briefly on the early mathematical foundations of automata theory, researchers leveraged emerging computing power to instantiate and observe deterministic evolutions without player intervention.^[14] A pivotal milestone arrived in the 1970s with John Horton Conway's invention of the Game of Life, a cellular automaton designed to exhibit lifelike patterns through local rules, which marked the first widespread computational exploration of zero-player dynamics. Devised in 1970 and popularized through print media, the model was rapidly adapted for simulation on early computers, with Bill Gosper implementing it on a PDP-6 at MIT's Artificial Intelligence Laboratory that same year to uncover unbounded growth patterns like the glider gun. This enabled real-time visualization of emergent complexity, transforming abstract mathematics into interactive digital phenomena and inspiring further algorithmic studies.^[14]^[15] The 1980s and 1990s witnessed accelerated adoption driven by personal computing's rise, which democratized access to software for running rule-based evolutions and fostering experimentation among hobbyists and academics. Chris Langton's ant, proposed in 1986 as a simple two-dimensional Turing machine, exemplified this era's focus on agent-driven self-organization, where an automaton traversed a grid according to fixed instructions, producing highways and chaotic phases observable on standard PCs. Such implementations proliferated through open-source tools and educational programs, highlighting zero-player games' utility in demonstrating computational universality and pattern formation. By the 2000s, artificial intelligence research profoundly shaped zero-player games by prioritizing fully automated systems that evolved independently to probe questions of emergence and adaptability. Drawing from the artificial life paradigm, developments in evolutionary computation and swarm intelligence enabled simulations of multi-agent interactions in virtual environments, such as those explored at International Conference on the Synthesis and Simulation of Living Systems (ALIFE) gatherings, where algorithms optimized rules without human tuning to yield lifelike behaviors. This integration underscored zero-player frameworks' role in AI's broader quest to model open-ended complexity.

Types and Classifications

Initial State-Driven Games

Initial state-driven zero-player games constitute a primary category where the entire progression and outcome are predetermined by an initial configuration, or "seed," and a fixed set of rules applied iteratively without any external intervention. In these systems, the state evolves autonomously through discrete time steps, often resulting in fixed patterns, cycles, or unbounded growth depending on the rules and starting setup. This mechanism draws from early mathematical foundations in automata theory, where simple local interactions generate global complexity.^[2] A key subtype involves one-dimensional cellular automata, such as elementary rules operating on linear arrays of cells, each typically in binary states (alive or dead). For instance, Rule 30, defined by the binary encoding 00011110, updates each cell based on its own state and its two immediate neighbors, producing intricate, aperiodic patterns from even simple initial seeds like a single active cell. These one-dimensional models exemplify how minimal rules can yield emergent behaviors, contrasting with more structured outcomes in other rules. In multi-dimensional variants, such as two-dimensional grids, evolution occurs across a plane where each cell's next state depends on its eight neighbors, as in Conway's Game of Life, leading to diverse outcomes like stable oscillators or gliders from varied initial configurations.^[16] Theoretically, these games highlight sensitivity to initial conditions, a hallmark of chaos theory, where minute changes in the seed can produce vastly divergent trajectories, as observed in Rule 30's chaotic class of behavior under Wolfram's classification. This sensitivity underscores the deterministic yet unpredictable nature of the evolution, mirroring nonlinear dynamics in physical systems. Furthermore, predicting long-term outcomes poses significant computational challenges; for general cellular automata, determining whether a configuration reaches a quiescent state is undecidable, akin to the halting problem, with complexity growing non-decreasingly over time in many rules. Such properties position initial state-driven games as models for studying computational limits and emergent complexity.^[17]^[18]

Automated Agent Interactions

In zero-player games featuring automated agent interactions, multiple artificial intelligence (AI) entities or rule-based agents operate autonomously within a bounded simulation environment, engaging in competition, cooperation, or optimization without any human intervention beyond initial configuration. These agents, often programmed as software constructs or virtual entities, follow predefined decision-making rules or learning mechanisms to interact dynamically, generating outcomes through their collective behaviors. This subtype of zero-player game emphasizes active agency among the simulated participants, distinguishing it from purely deterministic evolutions driven solely by initial conditions. Examples include AI programs competing in games like chess or Go without human oversight.^[4] A foundational mechanism in such games involves agents competing in resource-limited arenas, where success is measured by survival, replication, or dominance, as seen in early programming battles like Core War. In Core War, introduced in 1984, autonomous "warrior" programs—simple assembly-like code snippets—battle for control of a shared memory space called the core, overwriting opponents' instructions to eliminate them while defending their own code. These agents execute moves based on hardcoded strategies, leading to battles that unfold independently once initiated, with outcomes determined by the efficacy of the programs' interactions.^[19]^[4] Subtypes of automated agent interactions frequently incorporate evolutionary algorithms, where populations of agents undergo selection, mutation, and crossover processes to optimize performance in closed-loop simulations. Genetic algorithms, a core subtype, treat agents as candidate solutions (individuals) that "compete" through fitness evaluations, evolving over generations toward goals like maximization of utility or adaptation to environmental pressures; this process runs autonomously, mimicking natural selection without external guidance. For instance, in optimization tasks, agents representing parameter sets interact via simulated tournaments, where superior performers propagate traits, yielding emergent solutions to complex problems.^[20] Neural network evolutions represent another subtype, where agents' decision-making architectures—modeled as neural networks—are iteratively refined through evolutionary processes, enabling adaptation in dynamic environments. In such systems, networks encoding agent behaviors compete or cooperate, with genetic operators modifying connection weights and topologies to enhance survival or task completion, as demonstrated in simulations of virtual creatures navigating physical worlds. These evolutions produce agents capable of locomotion or interaction strategies that emerge from the interplay of neural mutations and environmental feedback. A key distinction in these games arises from non-determinism introduced by agent decisions, such as stochastic selection in evolutionary steps or probabilistic outputs in neural policies, which foster emergent strategies not predictable from rules alone. Unlike deterministic zero-player games reliant on fixed initial states, agent-driven interactions allow for adaptive responses and co-evolutionary dynamics, where one agent's strategy influences others' evolution, potentially leading to stable equilibria or chaotic oscillations in behavior. This non-determinism enhances the simulation's complexity, simulating real-world phenomena like ecological balances or strategic arms races.^[20]^[4]

Solved Games

Solved games form another category of zero-player games where the outcome is predetermined under optimal play, eliminating strategic variability and rendering the game autonomous in its resolution once rules and perfect strategies are known. In these cases, exhaustive analysis, often via computational methods, proves the result—such as a win for one side, a loss, or a draw—regardless of initial positions in fully analyzed variants. This classification highlights games where human or AI intervention is unnecessary post-solving, as the end state is fixed.^[1] A prominent example is checkers (also known as draughts), solved in 2007 by Jonathan Schaeffer and colleagues through a massive computational search involving approximately 500 billion billion positions. The analysis demonstrated that with perfect play from both sides, the game always ends in a draw, confirming its theoretical equilibrium.^[3] Other solved games include tic-tac-toe, which is a draw under optimal play, and certain endgames in chess, though full chess remains unsolved as of 2025.

Hypothetical Constructs

Hypothetical constructs in zero-player games refer to theoretical models or simulations designed for exploration in fields like mathematics, computation, or philosophy, where outcomes evolve without player input to probe concepts such as universality or self-organization. These are often abstract and used pedagogically or in research rather than as playable entities.^[1] An example is Langton's ant, a cellular automaton proposed in 1986 by Christopher Langton, consisting of a virtual ant moving on a grid according to simple rules: at a white square, turn 90° right, flip the color, and move forward; at a black square, turn 90° left. Starting from an all-white grid, the ant's path exhibits phases of ordered behavior followed by chaotic "highway" construction, illustrating emergent complexity from basic instructions. Such constructs aid in studying artificial life and computational boundaries.

Notable Examples

Cellular Automata Instances

One prominent example of a cellular automaton functioning as a zero-player game is Conway's Game of Life, a two-dimensional grid-based system where each cell is either alive or dead, evolving according to simple local rules applied simultaneously to all cells.^[21] The rules, devised by John Horton Conway and first detailed in a 1970 Scientific American article, are as follows: a live cell survives to the next generation if it has exactly two or three live neighbors (Moore neighborhood of eight adjacent cells); it dies otherwise due to underpopulation (fewer than two live neighbors) or overpopulation (more than three); an empty cell becomes alive (birth) if it has exactly three live neighbors, remaining dead otherwise.^[21] These rules give rise to diverse emergent behaviors without external input, classifying it as an initial state-driven zero-player game.^[15] In Conway's Game of Life, patterns exhibit remarkable variety, including still lifes such as the block (a 2x2 square of live cells that remains unchanged) and the beehive (a stable hexagonal formation), which persist indefinitely due to balanced neighbor counts.^[22] Oscillators, like the blinker (three live cells in a vertical line that cycles every two generations between vertical and horizontal orientations), demonstrate periodic repetition, while spaceships such as the glider (a five-cell configuration that translates diagonally across the grid every four generations) move through the space, interacting with other patterns to produce complex evolutions.^[22] Certain initial configurations enable infinite growth, where patterns expand without bound, as seen in breeder mechanisms that produce unbounded streams of spaceships, highlighting the automaton's capacity for unbounded computation from finite seeds.^[23] Another notable instance is Wireworld, a four-state cellular automaton introduced by Brian Silverman in 1987, designed to simulate digital signal propagation along wire-like structures.^[24] Cells occupy one of four states—empty (background), electron head, electron tail, or conductor (wire)—with evolution rules that mimic electron flow: an electron head advances to become an electron tail, an electron tail reverts to conductor, a conductor becomes an electron head if adjacent to exactly one or two electron heads (propagating the signal), and empty cells remain unchanged.^[24] This setup allows signals to travel at a constant speed along predefined wire paths, enabling the construction of logic gates, clocks, and even Turing-complete computers, where initial wire layouts dictate perpetual circuit operations like AND/OR gates or memory storage without player intervention.^[25] Brian's Brain, also created by Brian Silverman, extends the three-state paradigm to model neural firing patterns in a two-dimensional grid, evolving autonomously from an initial configuration.^[26] The states are off (inactive), on (firing), and dying (refractory); rules stipulate that on cells transition to dying, dying cells to off, and off cells to on only if exactly two neighboring cells are on, fostering wave-like propagations and chaotic bursts.^[26] This leads to formations resembling pulsars—oscillating clusters of firing cells that pulse rhythmically amid broader diagonal waves and gliding structures, illustrating self-sustaining neural-inspired dynamics.^[27] Across these cellular automata instances, pattern diversity manifests in stable, periodic, and migratory forms, with still lifes providing equilibrium, oscillators and spaceships enabling temporal and spatial dynamics, and select configurations demonstrating infinite growth potential through self-replicating or expansive mechanisms that fill the grid over time.^[23]

Digital Simulation Examples

One prominent example of a zero-player digital simulation is Langton's Ant, a two-dimensional Turing machine invented by Christopher G. Langton in 1986 to study emergent behavior in simple rule-based systems.^[28] The simulation features a single "ant" agent that moves on an infinite grid of cells, initially all white, following path-tracing rules: at a white cell, the ant turns 90 degrees clockwise, flips the cell to black, and advances one unit forward; at a black cell, it turns 90 degrees counterclockwise, flips the cell to white, and moves forward.^[28] For the first approximately 10,000 iterations, the ant's path appears chaotic, filling the grid with irregular patterns of black and white cells, but it then transitions into an ordered "highway" phase, constructing a repeating 104-step cycle that extends a bidirectional trail indefinitely in one direction, demonstrating spontaneous emergence of structure from uniform initial conditions.^[29] Another key example is the Tierra system, developed by ecologist Thomas S. Ray in 1991 as an artificial life platform for evolving digital organisms through open-ended processes.^[30] In Tierra, self-replicating computer programs, termed "digital organisms," inhabit a virtual computer memory space and compete for limited CPU time and memory resources; these organisms execute machine-like instructions, mutate during replication, and undergo natural selection based on replication efficiency, leading to evolutionary dynamics such as parasitism, symbiosis, and speciation without any external intervention.^[30] The simulation runs autonomously, with populations diversifying over generations—early runs showed ancestral strains giving way to faster-replicating variants and complex interdependencies, illustrating software-based evolution akin to biological processes.^[30] AI versus AI scenarios provide further illustrations of zero-player games through self-play mechanisms, as seen in the training of AlphaGo Zero by DeepMind researchers in 2017.^[31] This system learns to master Go entirely from scratch using reinforcement learning, where two instances of the neural network-based agent play against each other iteratively, generating millions of self-play games to refine policies and value functions without human data or supervision; after three days of training on specialized hardware, AlphaGo Zero surpassed prior versions trained with human expertise, achieving superhuman performance by exploring vast game spaces autonomously.^[31] Such self-play aligns with automated agent interactions by enabling emergent strategies through repeated, unbiased contests.^[31]

References

[1]
Zero-Player Games - Jesper Juul
... zero-player game when the computer takes the role of the single human player ... The game definition of Suits demands engagement in activities but ...
[2]
Game of Life - Scholarpedia
Jun 12, 2015 · The Game of Life was first published in the Martin Gardner's column in October 1970 issue of Scientific American, resulting in the greatest ...Rules · History · Game of Life using Go stones · Patterns
[3]
Checkers Is Solved - Science
This paper announces that checkers is now solved: Perfect play by both sides leads to a draw. This is the most challenging popular game to be solved to date.
[4]
None
### Summary of Zero-Player Games (Björk & Juul, 2012)
[5]
[PDF] Lecture 20: PSPACE-Complete problems, Complexity as Games
(Letting this game play out by itself, will it lead to a “win” or not?) Example of a Zero-Player Game: Conway's Game of Life. Complexity Theory as Games ...<|control11|><|separator|>
[6]
[PDF] Emergence from Symmetry: A New Type of Cellular Automata - arXiv
Jul 25, 2010 · This model is also a zero-player game. The evolution is determined by applying the above rules repeatedly to each cell in the former generation.
[7]
(PDF) Game of Life: simple interactions ecology - ResearchGate
Jan 13, 2016 · ... emergence of new patterns is one of the properties of Conway's ... zero player game, that is, it is a. L. Caballero, G. Cocho & S. Hern ...
[8]
(PDF) Koopman-based Data-driven Soft Artificial Life - ResearchGate
May 22, 2025 · ... zero-player game, i.e. the evolution depends wholly on the. initial condition and is governed by a set of rules. The state-space of the GOL ...
[9]
Synthesis of Procedural Models for Deterministic Transition Systems
... zero-player game, deﬁned as a collection. of ﬁnite-domain variables, called cells, that are situated on a grid of. a deﬁned shape; the grid can be deﬁned ...
[10]
The Engines | Babbage Engine - Computer History Museum
Babbage began in 1821 with Difference Engine No. 1, designed to calculate and tabulate polynomial functions. The design describes a machine to calculate a ...Missing: automata theory
[11]
Recursive Functions (Stanford Encyclopedia of Philosophy)
Summary of each segment:
[12]
[PDF] The Tower of Hanoi and Finite Automata
Abstract Some of the algorithms for solving the Tower of Hanoi puzzle can be applied “with eyes closed” or “without memory”. Here we survey the solution for.
[13]
Hilbert's Program - Stanford Encyclopedia of Philosophy
Jul 31, 2003 · It calls for a formalization of all of mathematics in axiomatic form, together with a proof that this axiomatization of mathematics is consistent.
[14]
John von Neumann's Cellular Automata
Jun 14, 2010 · In the 1940s John von Neumann formalized the idea of cellular automata in order to create a theoretical model for a self-reproducing machine. ...
[15]
Cellular Automata - Stanford Encyclopedia of Philosophy
Mar 26, 2012 · In 1970 the mathematician John Conway introduced his aforementioned Life game (Berkelamp, Conway, & Guy 1982), arguably the most popular ...
[16]
The Lasting Lessons of John Conway's Game of Life
Dec 28, 2020 · In March of 1970, Martin Gardner opened a letter jammed with ideas for his Mathematical Games column in Scientific American.
[17]
Rule 30 -- from Wolfram MathWorld
Rule 30 is a cellular automaton rule that specifies the next color in a cell based on its color and neighbors, encoded as 30=00011110_2. It is chaotic.
[18]
Elementary Cellular Automaton -- from Wolfram MathWorld
Rule 30 is of special interest because it is chaotic (Wolfram 2002, p. 871), with central column given by 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, ...
[19]
Computation Theory of Cellular Automata - Project Euclid
This complexity is usually found to be non-decreasing with time. The limit sets generated by some classes of cellular automata correspond to regular languages.
[20]
Computer Recreations, May 1984 | Scientific American
May 1, 1984 · In the game called Core War hostile programs engage in a battle of bits. By A. K. Dewdney. Join Our Community of Science Lovers!
[21]
Algorithms, games, and evolution - PNAS
Algorithms, games, and evolution. Erick Chastain, Adi Livnat, Christos Papadimitriou christos@cs.berkeley.edu, and Umesh VaziraniAuthors Info & Affiliations.Algorithms, Games, And... · Abstract · Sign Up For Pnas Alerts
[22]
[PDF] The fantastic combinations of John Conway's new solitaire game "life"
Conway's new solitaire game "life" by Martin Gardner. Scientific American 223 (October 1970): 120-123. Most of the work of John Horton Conway, a ...Missing: URL | Show results with:URL
[23]
What Can We Learn about Engineering and Innovation from Half a ...
Mar 18, 2025 · ... Game of Life that remain constant are normally called “still lifes”.) Beyond structures that just remain constant, there are “oscillators ...
[24]
[PDF] Growth Phenomena in Cellular Automata - UC Davis Math
Sep 6, 2015 · A finite set A0 for which ∪tAt is infinite is said to generate persistent growth. Further, a CA for which any set that generates persistent ...
[25]
WireWorld -- from Wolfram MathWorld
WireWorld is a two-dimensional four-color cellular automaton introduced by Brian Silverman in 1987. The rule for the automaton uses the cell's old value a ...Missing: signal propagation source
[26]
[PDF] Wireworld++: A Cellular Automaton for Simulation of Nonplanar ...
Introduction 1. Wireworld is a cellular automaton that can simulate digital electronic circuits. It was invented by Silverman in 1987 (e.g., [1]) and later pop ...
[27]
Brian's Brain Cellular Automaton - Arne Vogel
Apr 3, 2018 · Rules: There are three cell types. Dead (white), alive (black) and dying (gray). A alive cell always goes into dying and a dying cell always ...Missing: pulsar formations original source
[28]
[PDF] Exercise 2 Variations of Cellular Automata 1 Oscillators, Spaceships ...
Brian's Brain is a cellular automaton that consists of an infinite two- dimensional grid of cells. Each cell may be in one of three states: on, dying, or off.Missing: pulsar source
[29]
Studying artificial life with cellular automata - ScienceDirect
Physica D: Nonlinear Phenomena · Volume 22, Issues 1–3, October–November 1986, Pages 120-149. Physica D: Nonlinear Phenomena. Studying artificial life with ...
[30]
[PDF] Further Travels with My Ant - arXiv
These central symmetries stop occurring eventually and after about 10,000 time-units the ant settles into a periodic “highway-building” behavior, heading off to ...
[31]
[PDF] An Approach to the Synthesis of Life - Tom Ray
This paper presents a methodology and some first results. Here was a world of ... for the Tierra Simulator can be obtained by contacting the author by mail.
[32]
Mastering the game of Go without human knowledge - Nature
Oct 19, 2017 · The neural network in AlphaGo Zero is trained from games of self-play by a novel reinforcement learning algorithm. In each position s, an MCTS ...