I have uploaded a new paper to the arXiv, “Counting number-conserving cellular automata with radius 1“ (https://arxiv.org/abs/2605.31157).

The text is both a semi-brute-force calculation of the number of one-dimensional cellular automata with radius 1 and up to seven states, and an exercise in literate programming.

I call this a “semi-brute-force” calculation because, while it relies on my theory of one-dimensional number-conserving automata to speed up the calculation, there still remains an enormous number of individual cases that need to be computed and added up. It is by no means fast. The algorithm is also very specialised and works only for radius 1.

And literate programming means that the source code is a mixture of LaTeX and Haskell code, so that it (a) can be directly compiled by the Haskell compiler and (b) in the generated PDF, I can see each source code fragment together with the mathematical explanation what it does and why it does it. I did this in order to be (almost) absolutely sure that the program does what it was intended to do. The literate programming method works, but it is still quite an effort.

I do not think there is a journal that publishes such a text, but at least it is now in the arXiv.

#CellularAutomata #NumberConservation #LiterateProgramming #EnumerativeCombinatorics #Mathematics

Counting number-conserving cellular automata with radius 1

This text is also a program that computes the number of one-dimensional number-conserving cellular automata with radius 1. At the end of the text, the numbers of such automata with up to 7 cell states are shown.

arXiv.org

I _think_ this is all simple paths on a 4x3 rectangular lattice, up to symmetry (including swapping start and end.)

But it took me long enough to get the symmetry conditions right that I should probably double-check by enumerating them w/o symmetry and then compute the orbits directly.

#Combinatorics #MathArt #EnumerativeCombinatorics

What Every Programmer Should Know About Enumerative Combinatorics

A Programmer's Guide to Exact Counting and Enumeration of Integer Compositions

LeetArxiv

Now, our techniques to solve this combinatorics problem:
We studied an operad (the operad of posets), and then we studied power series indexed by posets.

Since the power series are indexed by posets, endomorphisms of posets can be extended to endomorphisms of those power series. That is, if we have a series $F(P)$ for every poset $P$, and we have $Q$ a function taking $P_1,...,P_n$ posets to a poset $Q(P_1,...P_n)$, then we define $Q(F(P_1),...,F(P_n)):=F(Q(P_1,...P_n))$.

If we work with sets, then we dont have to worry too much about the properties of this induced functions. They are just set theoretical functions.

Now, the correct language here is the language of #operads. Since we work with the operad of posets, this are topological operads. It is just that the topological spaces are finite but with a topology distinct from the discrete topology!.

Returning to the problem of enumerating shuffles between a tree and a linear tree. If we consider the series $F(P)$ whose $n$ coefficient enumerates shuffles between a poset $P$ and the linear order with $n$ cards, here $P$ is the poset of vertices of the input tree,
then we have an action of the operad of posets of the form $Q(F(P_1),...,F(P_n)):=F(Q(P_1,...P_n))$.
Now, the difficult part is to compute the actions of the posets. But in the paper https://doi.org/10.1007/s10801-025-01386-7 we were able to compute the action of the posets $\{x,y\}$ and $\{x<y\}$, this is enough to compute the series of any series parallel poset, which includes trees.

Sometimes, the action of the operad preserves the combinatorial / enumerative property of the series. That is, the operad sends series solving a problem to series solving the same problem. #EnumerativeCombinatorics 2/3