airesearcher

Without human scientific and mathematical intuition you can bet that AI will always take the road most travelled and miss the genuinely new and interesting breakthroughs - in fact it will not even think of them or try them without a human rider whipping it constantly to go down paths it would normally not consider.

And I think that is true in the case of the recent OpenAI blow-up -- it is alleged that even in this case AI did not come up with the winning technique without some human guidance.

I have never - across perhaps many thousands of chats with AI - seen AI push beyond the edge of what is known by itself, without being forced by a human to think outside the box.

I do think it might be possible to encode this process with prompting and agent orchestration methodologies - but even then - without a human - and human intuition - in the loop, I am skeptical.

Therefore I think a more accurate view of AI for math and science today is that it is an extremely powerful tool in the hands of a skilled operator with a strong intuition and roadmap of where to go, and rather boring when left to its devices.

Whether that will change in the future is a question. Nothing says that in principle AI could never do what a human driver does - but I still doubt that AI will replicate the life history and experience that real scientific and mathematical intuition is really made of.

AI trains on a lot of stuff - but it doesn't have hallway conversations, office-hours with teachers, or hard-won experience from all the things that failed that are NOT in the training data...

AI trains mainly on the record of what worked, not what didn't work and never even got published (and only lives in peoples heads) - and what didn't work is arguably as or more important for making breakthroughs and forming real intuition.

SocioLife is written in javascript and runs in your browser. It's graphics and compute intensive, so it's best run on a modern multicore PC.

Read more here: https://www.novaspivack.com/science/sociolife-a-socio-econom...

Run it here: https://www.novaspivack.com/wp-content/uploads/2025/11/Socio...

Learn about the Game Mechanics in the About page.

perhaps also make a version that starts from random initial condition as well?

looks promising

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.

Why the shader port doesn't work:

I've successfully implemented this same rule in Taichi (also GPU-based), and comparing the two reveals the issue.

The three-phase execution model requires intermediate storage between phases that Shadertoy's ping-pong buffer architecture can't provide.

In my Taichi implementation, each phase has its own buffer:

- Phase 1 reads node_degree (previous state) and writes to node_next_eligible

- Phase 2 reads node_next_eligible and writes to node_next_degree

- Phase 3 reads node_next_degree and writes back to node_degree

Shadertoy only has two buffers (previous frame read-only, current frame write-only), so the shader tries to collapse all three phases into one pass. But this breaks the execution model: when Phase 2 checks if a neighbor is eligible, it needs the neighbor's just-computed eligibility from Phase 1 of the current step, not the previous frame's data.

To properly implement this in a shader, you'd need either:

- A multi-pass setup with three separate render passes and intermediate textures

- Clever state packing to encode multiple values (eligibility + degree) in one buffer

The fact that the algorithm works correctly in Taichi but requires careful buffer management even on GPU demonstrates that "theoretical equivalence to traditional CA" doesn't mean "trivial to implement."

The three-phase execution model with intermediate states is a real architectural requirement, not just an abstraction.

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 (which appears if a rule implements rule tables). 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 all this though :)

https://github.com/novaspivack/lace/blob/master/Betweenness_...

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...

No claim is being made that this is a new kind of computation.

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.

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.

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

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

(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