I don't mind the rambling about "planets, galaxies, galaxy clusters, superclusters… and beyond …." but some technical detail would be nice too!
So in short, the cells are not becoming alive or dead based on the states of their neighbors, but rather on the topology of their neighborhoods.
The details are beyond the scope of a short write up, but are easy to explore in the rule-editor in the GUI of the code.
Here is an example of a rule that is markedly different from a typical "life-like" rule: https://videopress.com/v/lQ5Bghsj
The level of structure and self-organization is striking, to me at least.
Also in all the rules - the links are visible and can have binary or real-valued states as well as the cells. So this enables pretty rich topology which rules can utilize.
Also, consider getting off the grid and maybe doing some topology-based automata in combination with a more traditional network presentation paradigm like a force-directed layout. That would give you a much more 'biological' look which would draw a lot of people's attention.
The amazing part of cellular automata is the emergence of complicated behaviour from simple rules. Life's rules can be written in three sentences, maybe less.
Forgive my quibbling, but I don't understand what this is doing that other projects in this space haven't done before. Adding states and transition rules to edges is new to me...
I did try running your project, but I had to tweak it to get it to work with the instructions in the repo. I seem to be missing a few packages -- mpmath, sympy, typing_extensions. Can you add those to the requirements.txt file?
* Compute the "betweenness" of each living cell, which is 1 divided by its degree. Cells which are not connected to anything have infinite/undefined betweenness, but it doesn't matter.
* Then, for each cell, sum up the betweenness of its connected neighbours.
* If the total betweenness of a dead cell is in the range [(1.3, 3.6)], it is born and becomes alive at the next generation.
* If the total betweenness of a living cell is in the range [(0.9, 2.6)], it survives and remains alive to the next generation.
* Exception: any cell with 0, 1, 7 or 8 neighbours (in total, ignoring betweenness) dies anyway after the rules above were applied.
... That's not quite right, there's some references to "eligibility" that I can't make sense of. What else am I missing?
https://github.com/novaspivack/lace/blob/master/Rule_Explana...
https://github.com/novaspivack/lace/blob/master/Betweenness_...
These cover only one metric and one rule, but give some more info
Here is a more detailed explanation: https://github.com/novaspivack/lace/blob/master/Realm_of_Lac...
The per-cell update mechanism, using "amazing dragons" as an example:
1. Calculate a metric for every cell based on its neighbours
eg: metric = sum(1/degree if degree > 0)
eg: eligible = (state > 0) ? (0.9 <= metric <= 2.6) : (1.4 <= metric <= 7.0)
eg: state = (degree == 1 || degree == 7) ? 0 : degree
Here's an example of that approach: https://www.shadertoy.com/view/wXSyRw
I think for this to live up to the name it would need one or both of the following:
1. edges that mask or gate cells in some way (ie a dynamic neighbourhood) 2. rules that turn edges into other edges without going via cell states
However, your Shadertoy port doesn't produce equivalent behavior to the original rule—I've tried several corrections in your shader and none match.
While you've demonstrated the theoretical point, this actually highlights why the abstraction matters: implementing these dynamics correctly is non-trivial even when the algorithm seems straightforward. The three-phase execution, metric calculations, and mutual eligibility create subtle interactions that are easy to get wrong.
Regarding edge rule tables: LACE has complete UI infrastructure for true edge-to-edge dynamics (edge states evolving based on connection patterns, independent of node eligibility).
The Rule Editor even has a full tab for it. But no rule implements the execution logic yet—it's a dormant feature that would provide the dynamic topology you're suggesting.
Thanks for pushing me to be more precise about what LACE is (network-parameterized CA with sophisticated metrics) vs. what it could be (true network CA with independent edge dynamics).
I was working on GACA with dynamic neighbourhoods in 1997.
Survival conditions: Based on sum of neighbor degrees
Death conditions: Specific degree counts that cause node death
Eligibility: Nodes must meet conditions to form connections
That said a different representation can always reveal new phenomena about an old model.
Although I guess if we play with this too much there is a risk of inventing something like… Bloch's Game of Life or something.
https://github.com/novaspivack/lace/blob/master/Betweenness_...
Yet, as some comments already stated what you do is basically study a subclass of multi-state 2D CAs where specific states from the finite state set have a specific meaning associated.
In general a CA is defined as a dynamical system governed by a local rule operating on the neighborhood configuration and yielding a new state. State set is typically finite. But the actual structure of the states can be anything you like. A valid state can be a tuple of a form (visible state, number of neighbors, sum of neighbors degrees, …). As the maximum neighborhood size is finite and the visible cell states are finite - there is a finite number of such tuples which constitute the state set on which a CA can operate.
Summing up - you are studying CAs in which your multi-state setup has some implied meaning. Still cool and interesting.
(written in python, with optional taichi GPU-powered mode for large-scale simulations)
LACE is a new kind of cellular automata where rules operate on cell states and their links to other cells.
Check out the Gallery in https://www.novaspivack.com/science/introducing-lace-a-new-k... to see the familiar Game of Life rule, but with links.
* Quick Examples **
Game of Life, with links: https://videopress.com/v/lTZ8e4hD
Amazing Dragons (LACE rules): https://videopress.com/v/lQ5Bghsj
** MANY more examples in the Gallery (in the blog post cited above)
Rules can use topological properties of cells and neighborhoods, such as number of connections, neighbor degree, and other metrics.
The added topological dimension enables rules that can have more interesting behavior than traditional "cells-only" CA rules, opening up a fascinating new computational world of new species of stable patterns - oscillators - gliders, puffers, and more.
For details on how these rules work, get the repo and open various rules in the rule editor, where all their parameters are explained. There are many new classes of rules to experiment with.
** You can get the repo and learn more at: https://github.com/novaspivack/lace
How might you increase the overall order and decrease the chaos?
Birth conditions: Based on sum of neighbor degrees Survival conditions: Based on sum of neighbor degrees Death conditions: Specific degree counts that cause node death Eligibility: Nodes must meet conditions to form connections
https://www.pinterest.com/pin/282037995384211853/
(For that second guy, see his earlier stuff. His butterfly origami. It's stronger
Which is to say, rather than building a large system from cells, they start with a large simple system and then differentiate it. Recursively.
Now how that might be applied to your vision is a question
2. Nevertheless in the end this blog shows mostly pretty pictures of computational, complex, emergent, chaotic behavior, which we've all seen before. And the key features that make the difference go something I would call physics-like are still missing. And I guess that would be complex stable patterns that can have complex stable interactions. Who knows maybe there are 10^16-celled patterns that have this but we don't know.
3. If I were you I would cut the whole preamble. It will make people take you less seriously than they should. You don't want to look like a crank.
So, neat, but not exactly mindblowing.
https://youtu.be/gaFKqOBTj9w
I became obsessed with these and made a few videos!
No claim is being made that this is a new kind of computation.
For instance the Game of Life is a subset of 2-d binary state CA, the rule only takes the totals of neighboring cells, and so is a subset of those CAs with rules that care about specific patterns of neighbors.
These rules use very different principles than traditional cell-based rules - for example neighbor degree, number of connections, and eligibility criteria based on connectivity. So the cells are not becoming alive or dead based on the states of their neighbors, but rather on the topology of their neighborhoods.
The details are beyond the scope of a short write up, but are easy to explore in the rule-editor in the GUI of the code.
And preamble pruned of the historical anecdote behind this.
https://github.com/fcdimitr/fglt