Hubbry Logo
Wolfram codeWolfram codeMain
Open search
Wolfram code
Community hub
Wolfram code
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Wolfram code
Wolfram code
Wolfram code
View on Wikipedia
from Wikipedia

Wolfram code is a widely used[1] numbering system for one-dimensional cellular automaton rules, introduced by Stephen Wolfram in a 1983 paper[2] and popularized in his book A New Kind of Science.[3]

The code is based on the observation that a table specifying the new state of each cell in the automaton, as a function of the states in its neighborhood, may be interpreted as a k-digit number in the S-ary positional number system, where S is the number of states that each cell in the automaton may have, k = S2n + 1 is the number of neighborhood configurations, and n is the radius of the neighborhood. Thus, the Wolfram code for a particular rule is a number in the range from 0 to SS2n + 1 − 1, converted from S-ary to decimal notation. It may be calculated as follows:

  1. List all the S2n + 1 possible state configurations of the neighbourhood of a given cell.
  2. Interpreting each configuration as a number as described above, sort them in descending numerical order.
  3. For each configuration, list the state which the given cell will have, according to this rule, on the next iteration.
  4. Interpret the resulting list of states again as an S-ary number, and convert this number to decimal. The resulting decimal number is the Wolfram code.

The Wolfram code does not specify the size (nor shape) of the neighbourhood, nor the number of states — these are assumed to be known from context. When used on their own without such context, the codes are often assumed to refer to the class of elementary cellular automata, two-state one-dimensional cellular automata with a (contiguous) three-cell neighbourhood, which Wolfram extensively investigates in his book. Notable rules in this class include rule 30, rule 110, and rule 184. Rule 90 is also interesting because it creates Pascal's triangle modulo 2. A code of this type suffixed by an R, such as "Rule 37R", indicates a second-order cellular automaton with the same neighborhood structure.

While in a strict sense every Wolfram code in the valid range defines a different rule, some of these rules are isomorphic and usually considered equivalent. For example, rule 110 above is isomorphic with the rules 124, 137 and 193, which can be obtained from the original by left-right reflection and by renumbering the states. By convention, each such isomorphism class is represented by the rule with the lowest code number in it. A disadvantage of the Wolfram notation, and the use of decimal notation in particular, is that it makes such isomorphisms harder to see than some alternative notations. Despite this, it has become the de facto standard way of referring to one-dimensional cellular automata.

Generalized cellular automata

[edit]

The number of possible rules, R, for a generalized cellular automaton in which each cell may assume one of S states as determined by a neighborhood size of n, in a D-dimensional space is given by: R=SS(2n+1)D

The most common example has S = 2, n = 1 and D = 1, giving R = 256. The number of possible rules has an extreme dependence on the dimensionality of the system. For example, increasing the number of dimensions (D) from 1 to 2 increases the number of possible rules from 256 to 2512 (which is ~1.341×10154).

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Wolfram code

View on Grokipedia
from Grokipedia
Wolfram code is a binary numbering that uniquely labels the 256 possible evolution rules for elementary cellular automata, the simplest class of one-dimensional cellular automata where each cell holds one of two states (0 or 1) and updates based solely on the states of its two nearest neighbors from the previous time step. Introduced by in his 1983 paper on the of cellular automata, this scheme represents each rule as an 8-bit from 0 to 255, derived from the binary outputs for the eight possible configurations of three adjacent cells (left, center, right). The code's binary digits directly correspond to the next-state values for inputs ordered from 111 (most significant bit) to 000 (least significant bit), enabling compact notation and systematic exploration of rule behaviors. These elementary rules produce diverse dynamical patterns, classified by Wolfram into four universality classes: fixed points, periodic structures, uniform propagation, and chaotic evolution, highlighting cellular automata's capacity to model complex phenomena from simple local interactions. Notable examples include , known for its chaotic, aperiodic patterns resembling random noise and used in pseudorandom number generation within the , and , which generates Sierpiński triangle-like fractals through exclusive-or operations on neighbors. While there are 256 rules in total, only 88 are fundamentally distinct up to reflections and state complements, underscoring the system's inherent symmetries. The Wolfram code has become a foundational tool in , influencing studies in complexity theory, , and emergent behavior, as detailed in Wolfram's 2002 book , where it underpins analyses of natural and artificial systems. Its simplicity facilitates implementations in programming languages and simulations, revealing how minimal rules can yield unpredictable, computationally universal outcomes akin to Turing machines.

Fundamentals of Cellular Automata

Elementary Cellular Automata

Cellular automata are discrete computational models consisting of a lattice of cells, each in one of a finite number of states, that evolve over discrete time steps according to a set of local rules derived from the states of neighboring cells. These models simulate complex global patterns emerging from simple local interactions, with the lattice typically forming a such as a one-dimensional line or higher-dimensional array. The evolution occurs synchronously, meaning all cells update their states simultaneously based on the current configuration. Elementary cellular automata (ECA) represent the simplest form of one-dimensional cellular automata, where each cell assumes one of two binary states: 0 or 1. The neighborhood for each cell comprises exactly three cells: the cell itself and its two immediate nearest neighbors (left and right). This restricted setup, with a neighborhood radius of 1, defines the local rule as a function mapping the binary tuple of these three cells to the next state of the central cell. In the evolution process, an initial configuration of the lattice serves as the starting point (often called generation 0), and each subsequent generation is computed by applying the local rule to every cell based solely on its three-cell neighborhood from the previous generation. There are 23=82^3 = 8 possible neighborhood configurations, each of which can map to either 0 or 1 in the next state, yielding a total of 28=2562^8 = 256 distinct possible ECA rules. Wolfram codes provide a binary labeling system to uniquely identify each of these 256 rules. To illustrate the evolution, consider a simple one-dimensional lattice with under a generic , where a cell's next state is 1 if at least two of its three-neighbor cells (including itself) are 1 in the current generation, and 0 otherwise. The following table depicts the evolution of an initial configuration over four time steps, with the lattice wrapping around for edge cells:
TimeCell Positions (1 to 5)
00 1 0 1 0
10 0 1 0 0
20 0 0 0 0
30 0 0 0 0
40 0 0 0 0
This example shows how local interactions can lead to pattern stabilization across the lattice.

Neighborhood and Rules

In elementary cellular automata, the neighborhood of a cell consists of the cell itself and its two immediate neighbors, one to the left and one to the right, forming a three-cell tuple represented as binary values (0 or 1). This local structure captures all relevant information for determining the cell's next state, with the eight possible configurations ranging from 000 (all inactive) to 111 (all active). A rule in these automata functions as a deterministic mapping that assigns a binary output (0 or 1) to each of the eight possible neighborhood inputs, specifying the state of the central cell in the subsequent time step. This mapping ensures that the evolution of the entire grid proceeds synchronously and locally, with no direct interaction between non-adjacent cells. The rule can be fully represented as a enumerating all inputs and their corresponding outputs, allowing any specific behavior to be defined by selecting 0 or 1 for each case. For clarity, the table below shows the standard ordering of neighborhoods from 111 to 000, with generic outputs denoted as variables b7b_7 to b0b_0, where each bib_i is either 0 or 1:
NeighborhoodOutput
111b7b_7
110b6b_6
101b5b_5
100b4b_4
011b3b_3
010b2b_2
001b1b_1
000b0b_0
This enumeration highlights how the rule is completely specified by the choice of outputs, forming the basis for all possible evolutions. Initial conditions define the starting configuration of , which profoundly influences the pattern's development under a given ; for instance, a common setup is a single active cell (1) embedded in a field of inactive cells (0s). To illustrate, consider a simple with the outputs [0,1,0,1,1,0,1,0] for neighborhoods 111 through 000, respectively (equivalent to ). Starting from a nine-cell row 000010000 (centered single 1), the evolution over five steps with open boundaries (cells outside the lattice fixed at 0) proceeds as follows, where each row represents a generation:
  • Step 0: 000010000
  • Step 1: 000101000
  • Step 2: 001000100
  • Step 3: 010101010
  • Step 4: 100000001
  • Step 5: 010000010
This progression demonstrates how local updates generate spreading patterns from the initial seed. These rules are inherently deterministic and operate solely on local neighborhoods, yet they can produce strikingly complex global behaviors and emergent patterns, such as ordered structures or apparent randomness, depending on the mapping chosen. The Wolfram code provides a compact numerical encoding of such truth tables for efficient reference and analysis.

The Wolfram Code System

Construction of the Code

The construction of the Wolfram code begins with the output table for an elementary cellular automaton rule, which specifies the next state (0 or 1) of the central cell for each of the eight possible three-cell neighborhoods, ranging from 111 to 000 in binary notation. These neighborhoods are ordered in descending binary value: 111, 110, 101, 100, 011, 010, 001, 000, with the outputs forming an 8-bit binary string where the most significant bit (MSB) corresponds to the neighborhood 111 and the least significant bit (LSB) to 000. This binary string is then interpreted as a base-2 integer and converted to its decimal equivalent, yielding the unique Wolfram code number between 0 and 255. Mathematically, the Wolfram code rr is given by the formula r=∑k=07ok⋅2k,r = \sum_{k=0}^{7} o_k \cdot 2^k, where oko_k is the output (0 or 1) for the kk-th neighborhood in the reversed order (with k=0k=0 for neighborhood 000 as the LSB, and k=7k=7 for 111 as the MSB). This directly computes the value from the binary representation, ensuring a systematic encoding. For example, consider a rule with outputs 0 for 111, 1 for 110, 0 for 101, 1 for 100, 1 for 011, 0 for 010, 1 for 001, and 0 for 000. The resulting binary string is 01011010, which converts to 90 (since 0⋅27+1⋅26+0⋅25+1⋅24+1⋅23+0⋅22+1⋅21+0⋅20=64+16+8+2=900 \cdot 2^7 + 1 \cdot 2^6 + 0 \cdot 2^5 + 1 \cdot 2^4 + 1 \cdot 2^3 + 0 \cdot 2^2 + 1 \cdot 2^1 + 0 \cdot 2^0 = 64 + 16 + 8 + 2 = 90). Thus, this rule is designated as Rule 90. This mapping is bijective, as there are exactly 28=2562^8 = 256 possible output combinations, each corresponding to a unique binary string and thus a distinct integer from 0 to 255, providing a complete and non-overlapping labeling for all elementary rules.

Interpretation of the Number

To interpret a Wolfram code, which is a decimal number between 0 and 255 representing an elementary cellular automaton rule, the process begins by converting the decimal value to its 8-bit binary equivalent, padding with leading zeros if necessary to ensure exactly eight bits. This binary string directly encodes the rule's output for each of the eight possible neighborhood configurations in a one-dimensional cellular automaton with two states (0 or 1) and a three-cell neighborhood (left, center, right). The bits of the binary representation are assigned to the neighborhood patterns in decreasing order of their binary value, starting from the most significant bit (MSB, bit 7) for the pattern 111 and ending with the least significant bit (LSB, bit 0) for the pattern 000. Each bit specifies the output state (1 for "on" or , 0 for "off" or ) for the center cell in the next generation when that neighborhood occurs. This mapping allows reconstruction of the full rule table, which is the reverse of the encoding process where outputs are combined into a . For example, consider Wolfram code 90. Converting 90 to binary yields 01011010 (or 9010=01011010290_{10} = 01011010_2). The bits map as follows:
NeighborhoodBinary ValueBit PositionOutput
11177 (MSB)0
110661
101550
100441
011331
010220
001111
00000 (LSB)0
This rule, known for producing a Sierpinski triangle pattern under certain initial conditions, can be equivalently expressed as the XOR of the left and right neighbors, ignoring the center. To verify the decoded rule, simulate a small number of evolution steps using the reconstructed table on a simple initial configuration, such as a single 1 surrounded by 0s, and compare the output to known patterns for that code. For , starting with ...0001000... evolves to a symmetric modulo 2 after a few steps, confirming the mapping. Common errors in interpretation include misaligning bit positions during binary conversion or reversing the neighborhood order, such as assigning higher bits to lower binary values instead of strictly decreasing from 111 to 000. Always ensure the binary string is read from MSB to LSB in alignment with the neighborhood sequence to avoid incorrect rule tables.

Analysis and Classification

Rule Equivalence Classes

In elementary cellular automata, rule equivalence classes arise from symmetries in the rule space that preserve the essential dynamical behaviors up to spatial mirroring or color inversion. The primary symmetries are reflection, which swaps the left and right neighbors in the neighborhood, and , which flips the output values between 0 and 1. These operations, along with their composition, generate a group of four transformations: the identity, reflection alone, negation alone, and the combination of reflection and negation. Applying these transformations to the 256 possible rules partitions them into equivalence classes, where rules within the same class produce patterns that are either identical, mirrored versions, or color-inverted variants of each other. This symmetry-based grouping reduces the number of distinct behavioral classes to 88, significantly aiding in the systematic classification and analysis of the rule space. The transformation inverts all bits in the binary representation of the rule number NN, yielding the equivalent rule N⊕255N \oplus 255 (where ⊕\oplus denotes bitwise XOR), as this flips the output for every possible neighborhood. Reflection, in contrast, rearranges the bits of the rule table to account for the left-right swap: if the original rule table is represented by the binary string t7t6t5t4t3t2t1t0t_7 t_6 t_5 t_4 t_3 t_2 t_1 t_0 (where t7t_7 is the output for neighborhood 111 and t0t_0 for 000), the reflected rule has table t7t3t5t1t6t2t4t0t_7 t_3 t_5 t_1 t_6 t_2 t_4 t_0. The combined reflection- applies to the reflected table. Some rules are invariant under these operations; for instance, (binary 01011010) is self-reflective, as its table remains unchanged under the reflection mapping, producing symmetric patterns like the Sierpinski triangle. Rules fixed under or both symmetries further highlight the structure, with 64 amphichiral rules (invariant under reflection) among the 256. A notable subset within these equivalence classes consists of additive rules, which are linear over the field GF(2) and correspond to outputs that are modulo-2 sums (XOR) of the input bits. These rules exhibit particularly simple algebraic properties and are closed under the symmetry operations. For example, computes the new cell state as the XOR of the left and right neighbors (ignoring the center), generating additive patterns that evolve predictably under superposition. Other additive rules include Rule 0 (all-zero), Rule 60 (left XOR center), Rule 150 (left XOR center XOR right), and Rule 170 (center XOR right). Equivalence classes facilitate the study of these rules by identifying redundancies, such as how 's class includes its negated counterpart Rule 165, which produces inverted but structurally similar evolutions. This framework underscores how symmetries reveal underlying redundancies, enabling focused exploration of unique computational behaviors without exhaustive enumeration of all 256 codes.

Computational Behaviors

Wolfram classified the dynamical behaviors of one-dimensional elementary cellular automata into four qualitative classes based on their long-term evolution patterns observed in space-time diagrams. These classes emerge from simple local rules but exhibit distinct global structures, ranging from uniformity to complexity. Class 1 rules evolve to a homogeneous state regardless of initial conditions, quickly damping any perturbations to uniformity. For example, Rule 0, which outputs 0 for all neighborhood configurations, immediately sets all cells to 0 from any starting state. Starting from a single live cell (state 1), the space-time over 50 steps shows an isolated black at time 0, followed by all white pixels thereafter, illustrating rapid convergence to the all-0 fixed point. Class 2 rules produce simple, localized periodic or stable structures that persist without spreading extensively. Rule 60 serves as a representative, where the next state is the XOR of the left and center neighbors. From a single live cell initial condition, the space-time over 50 steps reveals a repeating diagonal of black cells shifting rightward, forming periodic stripes with period 2 in the vertical direction, confined to a linear without chaotic expansion. Class 3 rules generate chaotic, seemingly random patterns with nested structures and sensitivity to initial conditions. exemplifies this, where the next state is the XOR of the left neighbor and the OR of the center and right neighbors. Evolving from a single live cell over 50 steps, the displays a triangular filled with irregular black regions, resembling nested triangles that become denser and more unpredictable, propagating leftward at speed 1 cell per step. Class 4 rules develop complex, localized interacting structures, such as gliders, that can sustain information flow and computation. is the canonical example, with output 1 unless the neighborhood is 000, 100, or 111. From a single live cell, the space-time over 50 steps shows an asymmetric pattern: a leftward-propagating periodic structure of period 14 emerges around step 10, interacting with rightward signals to form glider-like objects that move and collide, creating evolving complexity within a bounded region. Key metrics distinguish these classes: Class 1 and 2 exhibit zero temporal and propagation speed, indicating periodicity detectable via short simulations; Class 3 shows positive (e.g., spatial ≈1.5 for ) and sensitivity where small initial changes amplify exponentially; Class 4 features glider-like structures with irregular transmission speeds (e.g., 0.2–0.4 cells/step in ) and high irreversibility, measured by converging state arcs in the . A hallmark of Class 4 is computational universality, as demonstrated by , which is Turing-complete and can simulate any algorithmic process given appropriate initial conditions. This was rigorously proven by constructing cyclic tag systems within Rule 110's evolution, enabling emulation of universal Turing machines. The classification remains qualitative, relying on visual inspection of diagrams rather than strict mathematical boundaries, and some rules like (additive, outputting XOR of left and right neighbors) produce Sierpinski triangle patterns from a single cell—regular yet self-similar—blurring lines between Classes 2 and 3 due to underlying linearity over finite fields.

Applications and Significance

In Scientific Modeling

Wolfram codes, particularly those defining elementary cellular automata, have found applications in scientific modeling by simulating emergent behaviors in physical, biological, and chemical systems through simple rules that generate complex global patterns. These models leverage the discrete, iterative nature of cellular automata to approximate continuous phenomena, providing insights into processes where traditional differential equations may be computationally intensive or analytically intractable. For instance, the computational behaviors classified in Wolfram's framework—such as uniform, nested, random, and complex patterns—serve as the foundation for selecting rules that mimic real-world dynamics. In modeling, Rule 184 has been employed as a paradigmatic example of the asymmetric simple exclusion process (ASEP), where sites represent segments and states indicate occupied (particle/) or empty positions. Particles hop rightward to empty neighboring sites with probability 1, capturing unidirectional dynamics like jamming transitions and waves. This rule accurately reproduces fundamental diagrams of , such as the relationship between and , observed in empirical studies of congestion. For diffusion and reaction processes, exemplifies linear cellular automata that produce patterns akin to , where each cell's state is the XOR of its two neighbors, leading to Sierpinski triangle fractals under specific initial conditions. This rule models binomial distributions in probabilistic , such as random walks on lattices, and simulates wave propagation in conservative systems without dissipation. Applications include approximating reaction- equations in , where the rule's additive structure mirrors the in linear wave equations. In biological , Rule 30 is valued for its pseudorandom output, which approximates the irregularity seen in certain natural systems. The rule's left-biased evolution from a single "on" cell generates aperiodic, chaotic-like sequences that can model growth processes. Physical systems exhibiting complexity are modeled using Rule 110, a computationally universal that displays persistent structures and class 4 behavior. This has been applied to geophysical phenomena, capturing aspects of that align with observed data in complex systems. A notable example in particle physics analogs is Rule 54, which supports glider guns—periodic structures that emit solitary waves (gliders) at constant speed—enabling simulations of interacting particles and soliton-like behaviors. Post-2000 studies have demonstrated its utility in modeling lattice gases and quantum walks, with configurations fitting experimental results from optical lattices where glider collisions mimic scattering events in fermionic systems.

In Computer Science

In computer science, Wolfram codes for elementary cellular automata have found applications in generating pseudorandom sequences, particularly through Rule 30, whose chaotic evolution from a single initial "on" cell produces bit streams that exhibit high-quality randomness. These sequences have been evaluated using rigorous statistical test suites, such as the Diehard battery, where Rule 30 demonstrates strong performance by passing a substantial portion of the tests, outperforming many traditional linear congruential generators in entropy and uniformity metrics. This property has led to practical implementations, including its historical use in Mathematica's pseudorandom number generation for certain functions, highlighting the efficiency of cellular automata in producing unpredictable outputs with minimal computational overhead. A landmark contribution to theoretical is the demonstration of in , proven by in , which establishes that this can simulate any given an appropriate periodic background pattern and initial configuration. This universality implies that supports arbitrary computation, including universal constructors and glider-based logic gates, bridging simple local rules to the full expressive power of general-purpose models. The proof reduces the simulation of cyclic tag systems to 's dynamics, confirming Wolfram's 1985 and underscoring the computational depth hidden within elementary rules. Wolfram codes also inspire algorithmic techniques in optimization and search problems, where the evolutionary patterns of cellular automata inform heuristics in genetic algorithms. For instance, cellular automata rules can define crossover operators that evolve binary chromosome populations by applying local update rules akin to or 90, enhancing diversity and convergence in solving tasks like the traveling salesman problem. This approach leverages the rules' ability to generate complex behaviors from simple interactions, reducing the search space through equivalence classes that group isomorphic rules and avoid redundant explorations. Software implementations facilitate these applications; Mathematica provides the built-in CellularAutomaton function for simulating any Wolfram rule with customizable initial conditions and steps, while Python libraries such as cellpylib and cellular-automaton offer efficient tools for rule execution, visualization, and integration into pipelines. The linearity of , defined over the GF(2) as the exclusive-or of its two neighbors, enables advanced analytical techniques for predicting long-term patterns without full simulation. This property allows efficient decomposition using Fourier transforms adapted to binary fields, where the automaton's matrix can be diagonalized to forecast spatial correlations and periodic structures in O(n log n) time for grids of size n. Such analysis is particularly valuable in cryptographic applications and , where linear rules like 90 provide tractable models for verifying system behaviors under .

History and Development

Invention by

In the early 1980s, pursued research on cellular automata while serving as a faculty member at the (Caltech) from 1979 to 1982 and subsequently as a long-term member at the Institute for Advanced Study in . His investigations centered on elementary cellular automata (ECAs) as discrete mathematical models for studying , , and complex systems behavior. The Wolfram code emerged in 1983 amid Wolfram's systematic classification of all 256 possible rules for one-dimensional ECAs, which consist of two states per cell and a neighborhood of three cells (yielding 2^8 configurations). This numbering system assigns each rule a unique integer from 0 to 255, derived from the decimal equivalent of an eight-bit binary string that specifies the output state for every possible input neighborhood, with the most significant bit for the all-ones (111) configuration and the least significant bit for the all-zeros (000) configuration. Wolfram personally enumerated and simulated all 256 rules on early computers, enabling a comprehensive analysis that revealed patterns in their dynamical behaviors and informed his four-class classification scheme. The primary motivation for inventing this code was the need for a compact, systematic labeling mechanism to catalog and distinguish the rules' complexities, surpassing informal or ad-hoc naming approaches and supporting rigorous studies. It was first introduced in Wolfram's paper "Statistical Mechanics of Cellular Automata," published in Reviews of (volume 55, pages 601–644). Although elaborated retrospectively in his 2002 book , the code's origins lie in the computational experiments of the early that laid the groundwork for broader explorations of computational universality.

Evolution and Extensions

Following the initial formulation of elementary cellular automata in the , researchers extended the Wolfram code framework to multi-state systems, where cells can adopt more than two states, and to higher-al grids beyond one . These generalizations allow for richer dynamics, such as in two-dimensional automata used to model complex spatial patterns. For instance, in the Wolfram Physics Project, initiated in 2020, rules are generalized to operate on hypergraphs—multi-al structures that evolve via rewriting rules analogous to cellular automata updates, enabling simulations of emergence. A landmark advancement in understanding Wolfram codes came in 2004 with Matthew Cook's formal proof that Rule 110 is universal, capable of Turing-complete computation through the construction of logic gates and memory structures from its glider-like particles. This confirmed Wolfram's earlier conjecture and elevated Rule 110 as a minimal example of computational universality in simple rules. Post-2015 research has further explored hybrids integrating classical Wolfram-style automata with quantum mechanics, such as entangled quantum cellular automata that preserve unitarity while exhibiting emergent complexity akin to classical classes. Software tools have evolved to facilitate exploration of Wolfram codes, with the incorporating the CellularAutomaton function since Mathematica 2.0 in , allowing users to simulate and analyze rules programmatically. Open-source alternatives like Golly, released in and actively maintained, support efficient simulation of elementary rules alongside higher-dimensional variants, enabling large-scale pattern discovery. Criticisms of the original four-class classification scheme, proposed by Wolfram, emerged in the 1990s, with refinements by James Crutchfield emphasizing to identify structured regularities and phase transitions more precisely than rigid categories. In the 2020s, AI techniques have advanced rule discovery, as in AutomataGPT models that infer rulesets from observed evolutions with over 96% accuracy on two-dimensional automata. By 2025, Wolfram codes continue to influence the Wolfram Physics Project's hypergraph models, which simulate phenomena like horizons and particle interactions through multiway evolution systems.

References

  1. https://mathworld.wolfram.com/ElementaryCellularAutomaton.html
  2. https://mathworld.wolfram.com/CellularAutomaton.html
  3. https://www.sciencedirect.com/science/article/pii/S0304397516000050
  4. http://www.scholarpedia.org/article/Cellular_automata
  5. https://natureofcode.com/cellular-automata/
  6. https://content.wolfram.com/sw-publications/2020/08/statistical-mechanics-cellular-automata.pdf
  7. https://mathworld.wolfram.com/Rule90.html
  8. https://content.wolfram.com/sites/13/2018/02/04-3-3.pdf
  9. https://content.wolfram.com/sw-publications/2020/07/universality-complexity-cellular-automata.pdf
  10. https://wpmedia.wolfram.com/sites/13/2018/02/15-1-1.pdf
  11. https://content.wolfram.com/sw-publications/2020/07/cellular-automaton-properties.pdf
  12. https://files.wolframcdn.com/pub/www.wolframscience.com/nks/nks-ch6.pdf
  13. https://wpmedia.wolfram.com/sites/13/2018/02/16-3-4.pdf
  14. https://content.wolfram.com/sites/13/2019/04/28-1-5.pdf
  15. https://mathworld.wolfram.com/Rule30.html
  16. https://mathworld.wolfram.com/Rule110.html
  17. https://wpmedia.wolfram.com/sites/13/2018/02/17-4-5.pdf
  18. https://www.wolframscience.com/nks/notes-2-1--self-similarity-of-rule-90/
  19. https://www.moshesipper.com/pubs/quality_random.pdf
  20. https://mathematica.stackexchange.com/questions/3208/quality-of-random-numbers
  21. https://www.complex-systems.com/abstracts/v15_i01_a01/
  22. https://www.mdpi.com/2076-3417/15/15/8750
  23. https://reference.wolfram.com/language/ref/CellularAutomaton.html
  24. https://github.com/lantunes/cellpylib
  25. https://pypi.org/project/cellular-automaton/
  26. https://arxiv.org/pdf/1607.02291
  27. https://link.aps.org/doi/10.1103/RevModPhys.55.601
  28. https://www.wolframscience.com/nks/notes-3-2--history-of-numbering-scheme/
  29. https://www.wolframphysics.org/technical-introduction/basic-form-of-models/the-representation-of-rules/
  30. https://writings.stephenwolfram.com/2020/04/finally-we-may-have-a-path-to-the-fundamental-theory-of-physics-and-its-beautiful/
  31. https://iopscience.iop.org/article/10.1088/2058-9565/ac1c41
  32. https://golly.sourceforge.io/
  33. https://www.santafe.edu/research/results/working-papers/computational-mechanics-of-cellular-automata-an-ex
  34. https://arxiv.org/abs/2506.17333
  35. https://writings.stephenwolfram.com/2021/04/the-wolfram-physics-project-a-one-year-update/
Add your contribution
Related Hubs
User Avatar
No comments yet.