Differentiable Logic Cellular Automata: From Game of Life to Pattern Generation

Alexander Mordvintsev; Ettore Randazzo; Eyvind Niklasson; Pietro Miotti

REVIEW 3 major objections 6 minor 1 cited by

Differentiable Logic Cellular Automata: From Game of Life to Pattern Generation

T0 review · 3 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper shows that a recurrent circuit of differentiable binary logic gates can learn Conway's Game of Life exactly and generate checkerboards, a lizard shape, and multicolor patterns from purely local interactions.

desk verdict A genuinely new recurrent logic-gate CA architecture with a solid but unquantified core result; deserves revision, not rejection. read the letter →

arxiv 2506.04912 v1 pith:MMGMNWOU submitted 2025-06-05 cs.AI

Pietro Miotti , Eyvind Niklasson , Ettore Randazzo , Alexander Mordvintsev This is my paper

classification cs.AI

keywords cellularautomatadifferentiablelogicgatenetworksneuralgameoflifepatterngenerationself-organizationfaulttolerancediscretecomputation

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to establish that a cellular automaton rule can be learned as a circuit of differentiable binary logic gates, with every cell running the same circuit and using only local neighbor information. The approach combines Neural Cellular Automata's perception-and-update structure with Differentiable Logic Gate Networks, whose boolean operations are relaxed so gradients can flow during training and then hardened into a deterministic discrete circuit at inference. Reported results include learning Conway's Game of Life perfectly from all 512 possible 3×3 transitions, generating checkerboard patterns that tolerate noise and cell damage, growing a lizard shape from a seed, and producing a multi-color grid. The reason this matters is that it suggests discrete, local, interpretable circuits can replace continuous neural networks in self-organizing systems, pointing toward programmable matter and robust computing machines built from ordinary logic gates.

What carries the argument

The carrying mechanism is the Differentiable Logic Gate Network (DLGN): a fixed sparse wiring of binary gates, where each gate learns which of the 16 two-input boolean operations to perform through a continuous relaxation (for instance, AND becomes $a \cdot b$ and XOR becomes $a + b - 2ab$), allowing gradient-based training. At inference, each gate is replaced by its most probable discrete operation, crystallizing the soft network into a deterministic boolean circuit. In DiffLogic CA this mechanism appears in two roles: perception kernels, small DLGNs that compute the interaction between the central cell and its neighbors channel-wise, and the update network, a larger DLGN that maps the concatenation of the current state and the perception outputs directly to the next state. The design deliberately outputs the new state directly instead of treating the system as a continuous ODE, preserving the discrete nature of cellular automata.

What would settle it

Enumerate all 512 3×3 binary patches, feed each through the hardened inference circuit, and compare the output bit to Conway's rule; any mismatch would refute the claim that the circuit implements Game of Life exactly. Independently, run a trained soft network and its hardened gate-selected circuit from the same random initial states for 30 steps and compare states; divergence over time would indicate that the discrete circuit is not the same function that was trained.

Watch

Extended reading notes

Core claim

The central claim is that recurrent circuits of differentiable logic gates—with learned perception kernels and a learned update network—can discover cellular automaton rules by gradient descent and then run in a fully discrete state space. For Game of Life, training on all 512 possible single-step transitions of 3×3 grids yields a circuit that reproduces Conway's rules exactly; 336 of the 3199 gates are active, and larger-grid simulations show gliders, blocks, loaves, and boats. For pattern generation, a checkerboard circuit trained over 20 steps converges, prunes to five gates, generalizes to a grid four times larger, maintains pattern integrity when cells are permanently disabled, and self-repairs when disabled cells are reactivated. The same recipe grows a lizard outline on a 40×40 grid from a 20×20 training image and generates a multi-color diagonal-stripe grid after 30 steps, with active gate counts scaling from 22 (checkerboard) to 465 (colored grid) to 577 (lizard). The paper also reports that asynchronously trained circuits recover target patterns with lower error under perturbation than synchronously trained ones.

Load-bearing premise

The load-bearing premise is that freezing each gate to its most probable boolean operation preserves the trained soft circuit's behavior over many update steps, so the discrete circuit actually deployed is the same function that was trained and measured.

Editorial extensions

If this is right

Cellular automaton rules can be compiled from data by gradient descent rather than hand-designed or evolved, covering rules with multi-bit states, not just binary ones.
Because inference is fully discrete and sparse, learned circuits can be mapped to FPGAs or ASICs and run in nanoseconds, making them candidates for embedded, low-power pattern generation.
The observed invariance to grid size and cell damage implies that a single learned rule can drive self-repairing, scalable systems without being overfit to boundary conditions or a global clock.
Training with asynchronous updates hardens circuits against perturbation, since the circuit must tolerate neighboring cells being permanently out of step.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If gate hardening proves stable over very long rollouts, the same scheme could synthesize boolean circuits for arbitrary local rules beyond the four demonstrations, such as non-binary or stochastic cellular automata; this is an extension the paper does not test.
Comparing DiffLogic CA against evolved or hand-coded circuits on the same tasks would clarify whether gradient descent finds smaller or more robust circuits than earlier search methods, a comparison the paper leaves implicit.
The checkerboard circuit's bottom-left-to-top-right propagation, despite no built-in directional bias, suggests the fixed wiring itself carries an orientation; analyzing that wiring could reveal boundary-symmetry effects that matter when scaling to much larger grids.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

DiffLogic CA is a real new combination: recurrent differentiable logic gate networks applied to cellular automata. That part is genuine and the paper is the first to train DLGNs in a recurrent spatial-temporal setting. Credit where due: the five-gate checkerboard circuit is a nice interpretability result, the grid-size generalization for the checkerboard is suggestive, and the notebook is available. The authors also admit in the Discussion that training is numerically unstable and requires heavy hyperparameter tuning, which is honest.

The main soft spot is exactly what the stress-test flags: the central claim that Game of Life is learned 'perfectly' is never quantified. Training on all 512 transitions makes in-sample success a fitting task, and that is the right way to define exact rule learning, but the paper never reports how many of the 512 hardened transitions match. The discretization gap from soft to hard inference is asserted, not measured. A circuit that differs on a few transitions could still produce gliders and blocks transiently, and errors compound over repeated steps. A simple table comparing soft vs hard accuracy on the 512 transitions would settle it. The other experiments also lack quantitative metrics and error bars; most conclusions rest on figures.

The flaws are fixable, not fatal. The architecture is sound, the experiments are small but appropriate for a first demonstration, and the robustness claims are plausible. The citation pattern is fine, with Petersen, NCA, and prior CA work properly credited. I would not cite it yet in its current form, but I would read a revised version. It deserves a serious referee, mainly to force the authors to quantify the hardened circuit's exactness and to add basic ablations.

Referee Report

3 major / 6 minor

Summary. The paper introduces Differentiable Logic Cellular Automata (DiffLogic CA), an architecture that replaces the neural-network components of Neural Cellular Automata with Differentiable Logic Gate Networks (DLGNs). The model is trained with continuous relaxations of logic gates and then hardened at inference by selecting the most probable discrete gate. The authors report four experiments: (1) learning Conway's Game of Life from all 512 possible 3x3 transitions, (2) generating a checkerboard pattern with robustness and self-healing demonstrations, (3) growing a lizard shape from a seed, and (4) generating a multi-color grid. The paper claims exact GoL rule learning, successful pattern generation, generalization across scales, and robustness to asynchronous updates and perturbations. Code is provided as a notebook.

Significance. If the central claims are substantiated, DiffLogic CA is a useful step toward interpretable, discrete, locally-computable recurrent systems that can be trained end-to-end and potentially mapped to hardware. The combination of DLGNs with recurrent cellular automata is interesting, and the availability of code is a strength. However, the current evidence is predominantly qualitative: exactness for Game of Life is asserted without quantitative verification, and the pattern-generation experiments lack error metrics, repeated-run statistics, and ablations of the discretization gap. The contribution is promising but needs stronger empirical support to justify the advertised milestones.

major comments (3)

[Experiment 1: Learning Game of Life, Training Dataset and Results] The claim that the model 'learned the Game of Life rules perfectly' is not supported by any quantitative check on the hardened circuit. Since the training set is the complete set of 512 possible 3x3 transitions, perfect in-sample agreement is a curve-fitting statement rather than a generalization result. To make this milestone load-bearing, report the accuracy or exact equivalence of the argmax discrete circuit over all 512 neighborhoods, and, because Life is sensitive to single-cell errors, verify exactness under recurrent application on the larger grid by comparing against a canonical Life oracle over many steps and reporting mismatch counts.
[Differentiable Logic Cellular Automata, inference-time discretization] The paper states that at inference time the network 'crystallizes into a deterministic circuit with each gate performing its most probable operation,' but it provides no evidence that the hardened circuit implements the same function as the trained soft network. With a 23-layer update network and thousands of gates, small differences in gate probabilities can cause argmax flips, and errors can compound over 20 to 30 recurrent steps. Please report the distribution of gate probabilities after training, quantify the discrepancy between soft and hard outputs on the training distribution, and state how many gates are not one-hot.
[Experiments 2, 3, and 4, Results] All pattern-generation results are presented as visual outcomes and active-gate counts, without quantitative accuracy, repeated runs, or error bars. For example, Experiment 2 says the model 'fully converges' to the checkerboard, but no final-step loss or error is given, and the scaled-grid generalization in Figure 8 is a single qualitative demonstration. Add quantitative metrics for each experiment: final-step MSE or L1 error, success rates over multiple random initial seeds, and the error curve of Figure 10 with axis labels and variability. Without these, the claims of robustness, self-healing, and scale invariance are not established.

minor comments (6)

[Equation (1) and Equation (2)] The sum notation 'NX' appears to be missing lower and upper limits; please correct the formatting for both loss equations.
[Figure 8 caption] The caption says '(t=1, t=40, t=80)' while the panels are labeled t=0, t=40, t=80; make the time indices consistent.
[References] The reference 'Games, M. (1970)' is incorrect; Martin Gardner's 1970 Scientific American column on Conway's Life should be cited properly.
[Active gate counts] The paper states that pass-through gates A and B are excluded from active gate counts, but it is unclear whether constant gates TRUE and FALSE are also excluded; please clarify the counting convention.
[Figure 10(b)] The error comparison plot lacks axis labels and error bars, and the error defined in Equation (3) is not normalized; specify the normalization and report variability over repeated damage configurations.
[Discussion and Future Work] The paper acknowledges 'significant numerical instabilities during training, and the resulting need for extensive hyperparameter tuning'; this limitation should be expanded in a dedicated limitations subsection, because it is important for reproducibility.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the DiffLogic CA results are empirical training demonstrations with independent larger-grid and robustness checks, not predictions forced by construction.

full rationale

The paper does not derive a first-principles result from assumptions that already contain it. Experiment 1 trains on all 512 possible 3x3 Game of Life transitions; the statement that correct next states for all training samples 'implies learning the complete Game of Life rule set' is a logical equivalence rather than a circular step, and the larger-grid simulation is an external (if visually reported) generalization check. Experiments 2-4 fit recurrent circuits to target patterns and then test on larger grids, damage, and asynchronous updates; these tests are outside the training objective. The continuous-to-hard inference 'crystallization' is asserted without quantifying the discretization gap, but that is a missing verification, not a reduction of a claimed prediction to its inputs. Self-citations to prior NCA and DLGN work supply standard architectural building blocks, not load-bearing uniqueness or ansatz justifications. No fitted parameter is renamed as a prediction, and no equation is equivalent to its own output by construction.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The paper does not introduce new physical entities. Its load-bearing assumptions are the faithfulness of the continuous-to-discrete hardening step and the sufficiency of the local NCA-style architecture. The free parameters are hand-chosen architecture sizes and rollout lengths, none of which are ablated.

free parameters (3)

Per-experiment architecture sizes = GoL: 16 kernels [8,4,2,1], update layers [128x16, 64,32,16,8,4,2,1]; checkerboard: 16 kernels [8,4,2], update [256x10…
Circuit sizes and depths are chosen by hand per experiment with no ablation or sensitivity analysis. The reported successes may depend on these choices.
Training rollout length = 20 steps (checkerboard), 12 steps (lizard), 30 steps (colors)
Rollout length is chosen per task and is not varied or justified; it directly affects the difficulty of the recurrent learning problem.
Asynchronous update fraction = 60% of cells updated per step in async experiments
The 60% fraction is an arbitrary choice; no study of how it affects convergence or robustness is provided.

assumptions (4)

domain assumption The continuous relaxation of logic gates (Table 1) allows gradients to flow such that the hardened discrete circuit at inference behaves like the trained soft network.
This is the core of the method but is not proven or quantitatively verified. It is invoked in every experiment and is the basis for 'hard inference'.
domain assumption The NCA-style decomposition into a local perception step and an update step is sufficient for the target pattern generation tasks.
The architecture inherits this assumption from prior NCA work; the paper does not compare against other computation structures.
domain assumption A Moore neighborhood (8 neighbors plus center) with channel-wise kernels provides enough information to learn the target rules.
All experiments use 3x3 neighborhoods; no analysis of receptive field sufficiency is given.
domain assumption Randomly connected DLGN layers with a fixed connectivity pattern can express the required update functions after training.
The paper relies on the expressive capacity of random sparse logic circuits, citing Petersen et al., but provides no expressivity guarantee for the recurrent setting.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Differentiable Logic Cellular Automata: From Game of Life to Pattern Generation." pith.science (2026). https://pith.science/paper/MMGMNWOU

@misc{pith2026250604912,
  author       = {Pith},
  title        = {Pith review of: Differentiable Logic Cellular Automata: From Game of Life to Pattern Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MMGMNWOU}},
  note         = {Machine review of arXiv:2506.04912}
}

read the original abstract

This paper introduces Differentiable Logic Cellular Automata (DiffLogic CA), a novel combination of Neural Cellular Automata (NCA) and Differentiable Logic Gates Networks (DLGNs). The fundamental computation units of the model are differentiable logic gates, combined into a circuit. During training, the model is fully end-to-end differentiable allowing gradient-based training, and at inference time it operates in a fully discrete state space. This enables learning local update rules for cellular automata while preserving their inherent discrete nature. We demonstrate the versatility of our approach through a series of milestones: (1) fully learning the rules of Conway's Game of Life, (2) generating checkerboard patterns that exhibit resilience to noise and damage, (3) growing a lizard shape, and (4) multi-color pattern generation. Our model successfully learns recurrent circuits capable of generating desired target patterns. For simpler patterns, we observe success with both synchronous and asynchronous updates, demonstrating significant generalization capabilities and robustness to perturbations. We make the case that this combination of DLGNs and NCA represents a step toward programmable matter and robust computing systems that combine binary logic, neural network adaptability, and localized processing. This work, to the best of our knowledge, is the first successful application of differentiable logic gate networks in recurrent architectures.

Figures

Figures reproduced from arXiv: 2506.04912 by the authors.

**Figure 2.** Diagram of the update step in DiffLogic CA show [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** Temporal evolution of the system dynamics show [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (10 more)

**Figure 4.** Figure 4: Circuit learned by the DiffLogic CA model imple [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]

**Figure 7.** Figure 7: How general is the solution? Training used only a single, fixed, size for the underlying grid. To test how general the solution is, we investigated what happens if we change the grid size: for this purpose we scaled up both the spatial and temporal dimensions by a fact…

**Figure 8.** Figure 8: Temporal evolution on a grid scaled 4× larger than [PITH_FULL_IMAGE:figures/full_fig_p005_8.png]

**Figure 5.** Figure 5: Checkerboard target pattern with 2×2 pixel [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]

**Figure 9.** Figure 9: Fault tolerance demonstration showing pattern [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]

**Figure 10.** Figure 10: Error analysis comparing synchronously and [PITH_FULL_IMAGE:figures/full_fig_p006_10.png]

**Figure 11.** Figure 11: Lizard target pattern [PITH_FULL_IMAGE:figures/full_fig_p006_11.png]

**Figure 12.** Figure 12: Temporal evolution of the lizard growth pattern [PITH_FULL_IMAGE:figures/full_fig_p007_12.png]

**Figure 13.** Figure 13: Multi-color target pattern, colored grid [PITH_FULL_IMAGE:figures/full_fig_p007_13.png]

**Figure 14.** Figure 14: Temporal evolution of the colored grid showing [PITH_FULL_IMAGE:figures/full_fig_p008_14.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Differentiable Weightless Controllers: Learning Logic Circuits for Continuous Control
cs.LG 2025-12 conditional novelty 6.0 of 10

Logic-gate circuits trained with gradient descent can match neural-network policies on most MuJoCo continuous-control tasks and run on FPGAs in a few clock cycles.

Reference graph

Works this paper leans on

22 extracted references · 19 canonical work pages · cited by 1 Pith paper

[1]

Hierarchical Neural Cellular Automata , volume ALIFE 2023: Ghost in the Machine: Proceedings of the 2023 Artificial Life Conference of Artificial Life Conference Proceedings

(2023). Hierarchical Neural Cellular Automata , volume ALIFE 2023: Ghost in the Machine: Proceedings of the 2023 Artificial Life Conference of Artificial Life Conference Proceedings

work page 2023
[2]

H., Cannon, D

Ackley, D. H., Cannon, D. C., and Williams, L. R. (2013). A movable architecture for robust spatial computing. The Computer Journal , 56(12):1450--1468

work page 2013
[3]

Amato, I. (1991). Speculating in precious computronium. Science , 253(5022):856--857

work page 1991
[4]

Games, M. (1970). The fantastic combinations of john conway’s new solitaire game “life” by martin gardner. Scientific American , 223:120--123

work page 1970
[5]

and Schmidhuber, J

Hochreiter, S. and Schmidhuber, J. (1997). Long short-term memory. Neural Comput. , 9(8)

work page 1997
[6]

Kanopoulos, N., Vasanthavada, N., and Baker, R. L. (1988). Design of an image edge detection filter using the sobel operator. IEEE Journal of solid-state circuits , 23(2):358--367

work page 1988
[7]

Langton, C. G. (1986). Studying artificial life with cellular automata. Physica D: Nonlinear Phenomena , 22(1):120--149. Proceedings of the Fifth Annual International Conference

work page 1986
[8]

Li, G. H. Y., Leefmans, C. R., Williams, J., Gray, R. M., Parto, M., and Marandi, A. (2024). Deep learning with photonic neural cellular automata. Light: Science and Applications , 13(1)

work page 2024

Show all 22 references

[9]

Margolus, N. (1995). Cam-8: A computer architecture based on cellular automata. arXiv preprint comp-gas/9509001

1995 arXiv
[10]

Martin, C. (2017). Differentiable cellular automata. arXiv preprint arXiv:1708.09546

2017 arXiv
[11]

P., and Hraber, P

Mitchell, M., Crutchfield, J. P., and Hraber, P. T. (1994). Evolving cellular automata to perform computations: mechanisms and impediments. Physica D: Nonlinear Phenomena , 75(1-3):361--391

1994
[12]

Mordvintsev, A., Randazzo, E., Niklasson, E., and Levin, M. (2020). Growing neural cellular automata. Distill , 5(2):e23

2020
[13]

Niklasson, E., Mordvintsev, A., and Randazzo, E. (2021a). Asynchronicity in neural cellular automata. In The 2021 Conference on Artificial Life , page 116. MIT Press

2021
[14]

Niklasson, E., Mordvintsev, A., Randazzo, E., and Levin, M. (2021b). Self-organising textures. Distill , 6(2):e00027.003

2021
[15]

Petersen, F., Borgelt, C., Kuehne, H., and Deussen, O. (2022). Deep differentiable logic gate networks. In Advances in Neural Information Processing Systems , volume 35

2022
[16]

Petersen, F., Kuehne, H., Borgelt, C., Welzel, J., and Ermon, S. (2024). Convolutional differentiable logic gate networks. arXiv preprint arXiv:2411.04732

2024 arXiv
[17]

Randazzo, E., Mordvintsev, A., Niklasson, E., Levin, M., and Greydanus, S. (2020). Self-classifying mnist digits. Distill , 5(8):e27.002

2020
[18]

Sandler, M., Zhmoginov, A., Luo, L., Mordvintsev, A., Randazzo, E., and Agüera y Arcas, B. (2020). Image segmentation via cellular automata. arXiv preprint arXiv:2008.04965

2020 arXiv
[19]

Tesfaldet, M., Nowrouzezahrai, D., and Pal, C. (2022). Attention-based neural cellular automata. In Oh, A. H., Agarwal, A., Belgrave, D., and Cho, K., editors, Advances in Neural Information Processing Systems

2022
[20]

and Margolus, N

Toffoli, T. and Margolus, N. (1991). Programmable matter: Concepts and realization. Physica D: Nonlinear Phenomena , 47(1-2):263--272

1991
[21]

B., Moreno, R., Faina, A., Stoy, K., and Risi, S

Walker, K., Palm, R. B., Moreno, R., Faina, A., Stoy, K., and Risi, S. (2022). Physical neural cellular automata for 2d shape classification. In 2022 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) , pages 12667--12673

2022
[22]

Wolfram, S. (2002). A New Kind of Science . Wolfram Media

2002

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

Hierarchical Neural Cellular Automata , volume ALIFE 2023: Ghost in the Machine: Proceedings of the 2023 Artificial Life Conference of Artificial Life Conference Proceedings

(2023). Hierarchical Neural Cellular Automata , volume ALIFE 2023: Ghost in the Machine: Proceedings of the 2023 Artificial Life Conference of Artificial Life Conference Proceedings

work page 2023

[2] [2]

H., Cannon, D

Ackley, D. H., Cannon, D. C., and Williams, L. R. (2013). A movable architecture for robust spatial computing. The Computer Journal , 56(12):1450--1468

work page 2013

[3] [3]

Amato, I. (1991). Speculating in precious computronium. Science , 253(5022):856--857

work page 1991

[4] [4]

Games, M. (1970). The fantastic combinations of john conway’s new solitaire game “life” by martin gardner. Scientific American , 223:120--123

work page 1970

[5] [5]

and Schmidhuber, J

Hochreiter, S. and Schmidhuber, J. (1997). Long short-term memory. Neural Comput. , 9(8)

work page 1997

[6] [6]

Kanopoulos, N., Vasanthavada, N., and Baker, R. L. (1988). Design of an image edge detection filter using the sobel operator. IEEE Journal of solid-state circuits , 23(2):358--367

work page 1988

[7] [7]

Langton, C. G. (1986). Studying artificial life with cellular automata. Physica D: Nonlinear Phenomena , 22(1):120--149. Proceedings of the Fifth Annual International Conference

work page 1986

[8] [8]

Li, G. H. Y., Leefmans, C. R., Williams, J., Gray, R. M., Parto, M., and Marandi, A. (2024). Deep learning with photonic neural cellular automata. Light: Science and Applications , 13(1)

work page 2024