I suspect there's only one person in the universe who knows for sure. They go by u/protofield on Reddit and @protofield6566 on YouTube, and they've apparently come up with this term (and the mathematics behind it) all by themselves.
They do post occasionally about it in various places (some more appropriate than others) but at least to me, few of their explanations seem coherent enough to actually explain what it means in terms understandable to someone not already familiar with their personal math jargon.
That said, some are a bit more coherent than others. For example, take this Reddit thread where they explain that:
"A Protofield operator is a highly ordered matrix of natural numbers. They perform arithmetic operations on Protofields to alter the field state, a transition. They can be generated using prime number cellular automata which perform modular arithmetic on the states of the CA cells using a multiplicative rule set of natural numbers. Beta series refers to particular families of Protofield operators which can be forward predictable in a single clock cycle. In this example,an advance of 729 frames per iteration was applied and using a rule set matrix of size 46 x 46 the images increased by approximately 33,000 pixels. This Reddit post has some details of prime cellular automata."
The "prime cellular automata" they refer to seems to be another term this person has coined all by themselves. Unfortunately the linked Reddit post that supposedly has more details on them doesn't actually seem to have much of anything (maybe some comments were deleted?), but fortunately they go on to offer a brief explanation further down in the same thread the quote above is from:
"Thanks for the question. Each cell contains a positive whole number, a natural number. The control prime number defines the set of possible numbers, that is, if it is 5 the cells take on values {0,1,2,3,4,5}. To get the next state of a cell you just add up all the values of the neighbours defined in a rule set, the sum, take the modulus of the sum, in this example Sum mod 5."
The comment thread also includes a link to a Google Drive folder containing a file named "RuleSetK5.txt", which contains the following explanation:
You are probably familiar with common CA rule set such as the Moore
neighbourhood which can be represented by a fairly simple rule set
matrix:
111
101
111
where the center is a cell and it says multiply a neighbour value by 1
and add it to a communal sum. Generally the next state will depend on
whether this sum is odd or even. Pretty trivial and the odd even
statement comes from a more general statement that the next state is
sum mod 2. Works for all mod P where P is a prime number. You can have
2D rule sets of any dimension up to infinity and use any prime modulus
in the next state calculation.
Below is the rule set matrix use to create a series os frames, one of
which was used to calculate a scrolling video in the latest post.
This is followed by a "rule set matrix", an 81×81 cell square grid of numbers from 0 to 4. Quoting the full grid here would be impractical, but I can instead convert it to a nice compact picture:
In this picture, the color of each pixel represents a single number from the "rule set matrix" from the "RuleSetK5.txt" file linked and quoted above, with 0 represented by black, 4 by white and 1–3 by shades of gray in between.
FWIW, I have no idea how this "rule set matrix" was generated. It might have been converted from a hand-drawn image, or it might be the result of some unspecified mathematical operation. For all I know, it could even have been handwritten on a sheet of graph paper and then typed in.
Anyway, based on all of this info, I can at least make a pretty good guess at what u/protofield's "prime cellular automata" are:
They are 2D cellular automata on a square lattice. (Apparently there are also variants defined on 3D or higher-dimensional lattices, and of course a 1D variant would also be quite natural.)
The cell states are integers modulo a prime number $p$.
The cell update rule is of the form $$s_{x, y}(t + 1) = \sum_{i=-n}^n \sum_{j=-n}^n k_{i, j} \, s_{x + i, y + j}(t)$$ where $s_{x, y}(t)$ is the state of the cell at coordinates $x, y$ at time $t$, $k_{i, j}$ is the value at coordinates $i, j$ in an $2n+1$ by $2n+1$ element "rule set matrix" (indexed from $-n$ up to $n$), and all arithmetic is done modulo $p$.
This type of update rule can be interpreted as a discrete convolution modulo a prime number $p$, with the "rule set matrix" acting as the convolution kernel.
In particular, the update rule as defined above is a multilinear map over the finite field $\mathrm{GF}(p)$. As such, it can be seen as a generalization of multilinear CA rules like Wolfram's rule 90, and in particular should exhibit the same additivity and superposition properties and consequent "replicator" dynamics, at least if run for long enough.
However, from their posts, it seems that u/protofield is running their rules on an unbounded, non-wrapping grid (probably seeded with a single cell in state 1 on a background of state 0, although I haven't seen explicit confirmation of this) and seems to be using a fairly slow simulation engine written in some high-level programming language. Since the large kernel size makes patterns expand quite fast (and also slows down the update calculation), it doesn't seem like they've simulated their rules for more than a few hundreds or thousands of time steps. Thus, I'm not 100% sure if they're aware that their rules should exhibit the same kind of behavior as Wolfram's rule 90 does, where ordered initial conditions periodically re-emerge from expanding apparent chaos.
They're at least aware of the phenomenon in general, however, as they linked in one of their Reddit posts to a Twitter / X thread illustrating it.
Ps. While u/protofield seems to consider it important for the modulus $p$ to be prime, without experimenting on the subject myself I can't tell how much that really matters.
While using a prime modulus ensures that the addition and multiplication rules form a finite field, the integers modulo a non-prime modulus $m$ still form a commutative ring, which is enough for multilinearity to be well defined. In particular, even with a non-prime modulus, CA with this type of update rule still satisfy the same additivity property as Rule 90, i.e. that if $q(t_0)$ and $r(t_0)$ are two different initial states of the CA lattice at time $t_0$, and if $s_{x,y}(t_0) \equiv q_{x,y}(t_0) + r_{x,y}(t_0) \pmod m$, then the congruence $s_{x,y}(t) \equiv q_{x,y}(t) + r_{x,y}(t) \pmod m$ will continue to hold for all $t ≥ t_0$ as the patterns $q$, $r$ and $s$ are updated according to the same multilinear CA rule modulo $m$. Or, in other words, the update rule still distributes over addition modulo $m$.
The biggest difference between prime and non-prime moduli is that the integers modulo a non-prime modulus have zero divisors. In practice this is likely to mean more chances for cancellation and thus likely larger preimage sets for any particular configuration. But since even Rule 90 isn't fully bijective anyway, I'm not sure how much practical difference that actually makes to the dynamics of the rule.
Of course, even if the lack of zero divisors is deemed desirable, one could still generalize the concept to e.g. multilinear CA rules over arbitrary finite fields $\mathrm{GF}(p^k)$ for some prime $p$ and any $k ≥ 1$. Those could well have interesting dynamics too.
Pps. As you may have noticed, even after all this analysis, I still have no real idea what a "protofield operator" is. It might be simply an alternative name for the type of multilinear CA update rule over the integers modulo a prime $p$ that I described above, but I'm not really sure about that.
But at least CA rules like that, with a suitable kernel, should be able to generate pretty patterns like the one you included in your question.
