Rules Made of Rules: A Composable Operator Library

This is a small, self-contained result out of a much longer continual-learning research program, so I’m writing it up on its own. The question: can a network summarize the rules behind its experience — rather than just fit them — so that a brand-new combination of known rules costs it zero new parameters to explain? The answer here is a clean, pre-registered yes, with a paired anti-cheat control and a robustness sweep to back it up. It also comes with an equally clean no: the moment the rules have to be learned from raw, per-trial-scrambled observations instead of a clean latent space, the whole thing collapses to chance. I’ll show both, with the numbers that killed and confirmed each claim, and six interactive demos so you can watch the mechanism instead of trusting my prose.

1. Not “fit a function” — “summarize the rules”

Most of what deep nets do is approximate a function: give me enough $(x,y)$ pairs and I’ll fit $f$. That’s not what I wanted to test here. I wanted a setting where the right answer is a small set of reusable rules, and where the honest measure of success is: when a new situation is literally a known rule composed with another known rule, does the model need new capacity to explain it, or does it already have what it needs?

If a system has genuinely summarized “rule A” and “rule B” as distinct, reusable objects, then “first A, then B” should be free — it’s just running the two things you already have, in sequence. If instead the system has only learned to recognize twelve separate surface patterns, a thirteenth pattern (even one built cleanly from pieces it knows) is a cold start.

That’s the whole experiment. Everything below is in service of making that question answerable with a number instead of an intuition.

2. A world built from four moves

The world (neural_drift/comp_world.py, CompWorld) has 4 primitives — four basic transformations of a set of entities. It also has 12 compounds: every ordered pair of distinct primitives, $(a,b)$ with $a\neq b$, so $(0,2)$ and $(2,0)$ are different rules, applying $a$ then $b$ is not the same as $b$ then $a$.

One data point is a trajectory: 17 frames (16 steps plus the start), $N\in{3,4}$ entities, 16 dimensions each — shape (17, N, 16). Balancing is baked into the generator, not patched on afterward: every (rule × entity-count) cell gets an equal number of episodes, and episode order is shuffled before the model ever sees it — otherwise the index itself would leak the label, a mistake this project has made and re-caught more than once.

The critical design choice: training only ever shows depth-1 episodes — a single primitive, run for 16 steps. The 12 compounds never appear during training, not once. At test time the model gets a depth-2 trajectory and has to say which two primitives produced it, and in what order — a 12-way classification, chance $= 1/12 \approx 0.083$.

Play with the world below before you see any results — step through a primitive, then watch what a compound trajectory looks like next to it.

Four primitives, and the 12 ordered compounds built from them. Step through a trajectory and watch how a compound’s path through state space differs depending on which primitive runs first.

3. One operator, shared by every entity

The whole rule library is two matrices per primitive:

\[s' = \mathrm{normalize}\Big(\tanh\big(g\,(sW_p + \beta\,\overline{sV_p})\big)\Big)\]

$s$ is the $(N,16)$ state of all entities, $p$ indexes the primitive, $g$ is a fixed gain, $\overline{sV_p}$ is the mean across entities of $sV_p$. That mean term is what makes the operator permutation-equivariant and entity-count-independent: the same $(W_p,V_p)$ works whether there are 3 entities or 300, because every entity only ever sees the average influence of the others, not a fixed-size list of them. normalize projects the state back onto the unit sphere after every step, which is what keeps 16 repeated applications of a nonlinear map from either blowing up or collapsing to a point.

Count the parameters: 4 primitives × 2 matrices × 16 × 16 = 2,048. That’s the entire rule library. There’s no separate “compound” module — a compound is just two primitive steps run back to back, with zero new parameters.

Watch a single learned operator step act on 3 entities, then on 8, with no change to the matrices. Permute the entity order and the output permutes with it — nothing else moves.

4. An algebra, not a lookup table

Two mathematical claims are doing the real work here, and both are checkable rather than aesthetic.

Closure. The set of primitives, closed under composition, forms an algebra: $F_{p_2}\circ F_{p_1}$ is itself a rule the system can run, using nothing but the primitives it already has. This is what licenses calling the 12 compounds “the same kind of object” as the 4 primitives rather than 12 unrelated new things to be memorized.

Non-commutativity. Because $(a,b)\neq(b,a)$ by construction, order has to matter for the model to succeed — this is a falsifiable prediction, not an assumption. A model that only identified which two primitives were present, with no signal about order, would already have narrowed the 12 candidates down to the correct unordered pair — but then has nothing to break the tie between the two orderings, so exact-match accuracy caps at $1/2$, not lower (checked by a 200,000-trial Monte Carlo: 0.5006). The results in §6 land well above that $1/2$ ceiling, which is what shows order is in fact being used, not just pair membership.

There’s a second, less obvious property worth naming: operators here can be executed and reordered independently of the training graph. Nothing in training ever ran $F_2\circ F_0$ — the two matrices for primitive 0 and primitive 2 were each updated only from their own single-primitive episodes. At test time those two independently-trained objects get composed for the first time, in an order neither ever saw during training, and the composition still means what it should. That’s a different thing from a function being factored into sub-computations inside one forward pass — I’ll come back to exactly why in §7.

5. Inference is analysis-by-synthesis

There’s no classifier head that outputs “compound 7.” Recognition works by replaying every candidate and seeing which one matches:

Given a depth-2 trajectory, form all 12 candidate pairs $(a,b)$, $a\neq b$. For each one, take the trajectory’s starting state, roll it forward under $F_b\circ F_a$ (learned operators, unchanged from training), and measure the reconstruction error against the real trajectory. The candidate with the smallest error wins.

This is the concrete meaning of “recognizing a new rule costs zero new capacity.” The 12 candidates are not 12 things the model was trained to distinguish — they’re 12 replays of the same 2,048-parameter library, scored against reality. Adding a 13th, 100th, or 132nd compound (going to 12 primitives instead of 4) means adding more candidates to the search, never a new parameter to the model.

All 12 candidate compounds replayed against one held-out trajectory. Watch the reconstruction error bars settle — the true pair should pull ahead of the rest, including the one with the same two primitives in the wrong order.

6. The numbers

Exact decomposition of unseen compounds: 0.894 ± 0.051 (3 seeds), against chance 0.083 and a same-pipeline permutation null of 0.152 — the null matters here because Hungarian-style matching over 12 candidates isn’t automatically at chance, so the honest floor to beat isn’t $1/12$, it’s 0.152.

The number that actually earns the claim, though, is the paired anti-cheat control. COMPOSE_random runs the identical search — same 12 candidates, same replay-and-score procedure — but over a primitive library that was never trained, just randomly initialized:

arm (3 seeds)	exact pair accuracy	permutation null	at-least-one-right
COMPOSE_learned	0.894 ± 0.051	0.152	0.977
COMPOSE_random (random primitives, same search)	0.097	0.152	0.824

Paired difference +0.797 ± 0.066, win in 3/3 seeds; with only 3 seeds the 95% CI needs Student’s $t$ rather than the normal approximation ($t_{0.975,\,df=2}=4.303$), which gives a lower bound of +0.513 — still comfortably clear of zero. COMPOSE_random sits right at chance — meaning the win is entirely attributable to what the primitives learned, not to the fact that the model gets to search over 12 candidates. That distinction matters more than it might look: a system that could win this test purely by having a flexible enough search procedure would tell you nothing about whether it understood the primitives at all.

Three aggregate bar views: the headline 0.894 result, COMPOSE_learned against COMPOSE_random (checkbox reveals the random-primitive bar), and the forgetting comparison against the no-library baseline. These are the same aggregate numbers as the tables in this section, not per-seed points — expand “show the numbers” in the demo for the raw figures.

One real held-out episode, ground truth $(0,2)$: replaying the correct candidate $(0,2)$ gives reconstruction error 0.06009; replaying the same two primitives in the wrong order, $(2,0)$, gives 0.11486 — almost double. The next-best wrong candidates aren’t close either: $(0,1)$ scores 0.11907, $(2,3)$ scores 0.12397, $(3,2)$ scores 0.12541. That’s the non-commutativity prediction from §4 landing on an actual example: getting the order wrong isn’t a rounding error, it’s a qualitatively worse fit, which is exactly what you’d expect from a model that learned dynamics rather than a model doing feature matching on which primitives are “present.” Script: experiments/exp_comp_single_episode.py, results: results/comp_single_episode_20260812_202703/results.json, reproduce with python experiments/exp_comp_single_episode.py — it’s a 12-line output, worth actually running.

Robustness. The learned operator’s functional form matches the world’s by construction, and it’s handed the world’s true nonlinearity gain $g=3.0$ — two gifts worth checking. Sweeping the model’s assumed gain away from the true value:

model gain (world truth = 3.0)	seeds	exact decomposition	verdict
1.5 (2× under-estimate)	3	0.936	better than matched
3.0 (matched)	3	0.894	pass
6.0 (2× over-estimate)	8	0.361	still degraded, but passes the gate (≥0.35) — paired diff vs random-primitive control +0.274, $t$-CI lower bound +0.186, 8/8

(The gain-6.0 row was rerun at 8 seeds after an independent audit caught that the original 3-seed run’s CI used the wrong distribution — see the correction below; the other two rows are still 3 seeds.) Under-estimating the nonlinearity is harmless, even slightly helpful. Over-estimating it is not: at gain 6.0, exact decomposition falls from 0.894 to 0.361, a drop of roughly 60%, even though it now clears the 0.35 gate rather than failing it as I originally reported. A too-powerful operator still eats a large share of the expressive burden that composition is supposed to carry — this shows up again as the central warning in §7, just not as a hard gate failure.

Forgetting. This next result comes from a sibling architecture in the same research line — a Lie-generator library (neural_drift/lgm.py, tested via experiments/exp_lgm_stream.py) rather than the tanh-operator library above — but it tests the same underlying structural claim: does having a shared, reusable rule library, on its own, resist catastrophic forgetting? Across a 4-stage stream, 3 seeds: a model with the shared library forgets 0.101 ± 0.016; an equivalent model fine-tuned with no shared library forgets 0.444 ± 0.010. Paired difference +0.343 ± 0.019, 3/3 seeds (0.379 / 0.317 / 0.333), $t$-CI lower bound (same $t_{0.975,\,df=2}=4.303$ correction as above) +0.263 — forgetting cut by 4–5×. Mechanistically this isn’t mysterious: new experience that lands on an existing generator costs zero new capacity and doesn’t overwrite old parameters, so interference stays inside the gate rather than spreading across the whole weight matrix.

Learning window. A parameter-free reason to prefer the compositional world over a plain linear-system world (OpWorld) I’d tried earlier: with 16 rules total (4 primitives + 12 compounds, chance 0.0625 for this separate probe), sweeping the nonlinearity gain and the multiplicative gate on/off, 3 seeds per row:

gain	gate	closed-form escape hatch	analytic supervised	MLP ceiling	learning window
1.0	0	0.478	0.522	0.610	0.133
3.0	0	0.428	0.494	0.558	0.130
3.0	1	0.414	0.488	0.568	0.155
6.0	1	0.343	0.407	0.497	0.154

Against the earlier plain-linear world (OpWorld: escape hatch 0.70, ceiling 0.77, window 0.07), the window here sits at 0.13–0.155 — roughly double, not the 3.5× I originally wrote (see the correction box below for why). That “closed-form escape hatch” column matters as its own discipline: this project has repeatedly found that a zero-training, closed-form spectral method matches or beats a trained model on synthetic dynamical-systems tasks, because pairwise second moments are an almost-sufficient statistic for identifying linear systems — no amount of observation-side nuisance breaks that. Composition is what finally makes the escape hatch lose its footing, because $F_b\circ F_a$ is not any single linear system.

These are 3-seed means, and the per-seed spread is large enough to matter — e.g. the gain=1.0 row’s escape hatch ranges 0.422–0.527 across its 3 seeds; see results/comp_learning_window_20260812_202810/results.json for the full per-seed breakdown. Don’t read a single seed’s window off this table and trust it.

Correction, caught while writing this up. The first version of this table had gain=3.0/gate=0 at window 0.251, and I’d written “widens the window 3.5×.” That number doesn’t reproduce. Two compounding mistakes: (a) partway through this work I added shared-nuisance-family support to comp_world.py, and the new nuis_fam draw shifted the RNG consumption order — the same seed number silently stopped generating the same world; (b) the original sweep was single-seed, and the window turns out to be noisy enough across seeds that one draw isn’t a number, it’s a sample. Script: experiments/exp_comp_learning_window.py, results: results/comp_learning_window_20260812_202810/results.json. The table above is the 3-seed re-run; the 0.251 figure is retracted.

A methodological note this is worth stating plainly. A number computed in an ad-hoc exploration script isn’t data — it’s a scratch note. It only becomes citable once it has a checked-in script, a results.json, and a reproduce command someone else can run. This post has one number that failed exactly that test: the 0.251 above only got caught because I went back to attach a repro path for this write-up and the script wouldn’t reproduce it. If I hadn’t gone looking for the command, it would still be sitting in this post as fact. A second, independent audit caught a subtler version of the same discipline problem: every confidence interval in this post’s first draft used $\mathrm{mean}\pm1.96\cdot\mathrm{SEM}$, the normal-distribution formula — but $n=3$ isn’t large enough for that approximation, it needs Student’s $t$ ($t_{0.975,\,df=2}=4.303$, more than double the multiplier). $n=3$ is neither enough to compute a defensible CI nor enough to declare a gate passed or failed — which is exactly why the two figures in this post that moved under re-audit (the gain-6.0 robustness row just above, and the globally-fixed-nuisance tier in §8) got resolved by collecting more seeds rather than by arguing about which formula to use.

7. Where this sits next to KAN

Kolmogorov-Arnold Networks reparametrize a layer so every edge carries a learnable 1-D function instead of a scalar weight:

\[f(x_1,\dots,x_n)\approx\sum_q \Phi_q\Big(\sum_p \phi_{q,p}(x_p)\Big)\]

The pitch is that composing simple, interpretable 1-D functions can approximate complex multivariate functions with fewer, more legible parameters than a dense layer. It’s a genuinely useful idea, and it’s the closest existing thing to what I’m doing here — close enough that the differences are worth being precise about.

	KAN	this work
composes what	simple functions	simple operators (state transitions)
composed where	inside one forward pass’s computation graph	across time, as function composition
approximates	a static function $y=f(x)$	a transition operator $F_p: s_t\to s_{t+1}$
reorderable at test time	not natively	yes — train $F_0,F_2$ separately, at test time run $F_2\circ F_0$, or even $F_0\circ F_2\circ F_0\circ F_3$
does the composition carry meaning	no — it’s just two layers	yes — $F_2\circ F_0$ means “rule 0 happened, then rule 2”

Three things are genuinely shared, and I don’t want to erase them: both approaches break a model’s knowledge into small atomic pieces instead of one dense tensor; both let composition generate far more distinct functions than the parameter count would suggest; both carry the same inductive bias — that the underlying primitives are meant to be reused, over and over, rather than relearned per task.

The short version: KAN asks how a single function factors internally. This work asks how a set of functions in a rule-based system forms an algebra and gets composed, again and again, across time. The second question buys you one thing the first doesn’t have to answer for: composition that carries semantics — $F_2\circ F_0$ isn’t just “layer 2 applied after layer 0,” it’s a claim about what happened in the world.

Play with the two side by side below — same underlying idea of atomic reusable pieces, different thing being composed and a different place the composition happens.

Left: a KAN edge, a learnable 1-D function composed inside one layer’s forward pass. Right: an operator, composed across time steps, reorderable after training. Toggle to see the same “atomic, reusable piece” framing applied to two different objects.

A future direction, with a warning that’s already backed by data. The natural next step is Operator-KAN: make each $F_p$ itself a KAN, $s_j’ = \sum_i \phi^{(p)}_{ij}(s_i)$, giving two nested layers of composition — micro-composition of 1-D functions inside one operator, macro-composition of operators across time. That’s an appealing architecture on paper. But §6’s robustness sweep is already a data point against doing this carelessly: when I gave the operator too much expressive power (model gain 6.0 against a true gain of 3.0), exact decomposition fell from 0.894 to 0.361 — a roughly 60% drop. What happens mechanistically is that $F_0$ becomes flexible enough to quietly represent some of what should only be representable by $F_2\circ F_0$ — it starts absorbing the compound’s behavior into a single primitive, which destroys the very identifiability that made the primitives distinct, reusable objects in the first place. A KAN-ified operator is, almost by definition, a more expressive operator. Build one, and check for exactly this failure mode before trusting the result.

8. The wall, honestly

Everything in §6 has one precondition I haven’t flagged yet: the model sees a clean latent state directly. That’s a real gift, and I want to show exactly what happens when it’s taken away, rather than footnote it.

Switch to learning end-to-end from raw observations that have been scrambled, and exact decomposition drops to 0.077 — chance. Not “worse.” Chance. To see why, I ran a three-tier ladder, changing nothing but how the scrambling works:

nuisance setting	seeds	exact decomposition of unseen compounds	vs random-primitive control (paired)
none (clean latent, §6’s result)	3	0.894 ± 0.051	+0.797 ± 0.066, $t$-CI low +0.513, 3/3
globally fixed — one shared rotation for every episode	8	0.233 ± 0.040	+0.154 ± 0.037, $t$-CI low +0.067, 8/8
per-episode random — a fresh rotation every episode	3	0.077 ± 0.008	+0.001 ± 0.016 (exactly chance)

Monotone, and the middle tier is significantly above random — but still short of the gate. The paired win over the random-primitive control is real down to the $t$-corrected lower bound (8 seeds this time, rerun after an audit found the original 3-seed CI used the wrong distribution), and the per-seed spread is wide — 0.135 to 0.458 across the 8 seeds. But 0.233 is still below the 0.35 accuracy threshold GATE-R requires, so the honest read is “clearly better than nothing, not a pass”: composition compounds the encoder’s error across 2 primitives × 16 steps, so it demands far more representational precision than single-step prediction ever did, and this tier doesn’t reach it.

The math behind the collapse: the raw observation is $x=[s;d]Q_g^\top$, where $Q_g$ is a random rotation applied to the true state plus distractor dimensions — and in the “per-episode random” tier, $Q_g$ is different every single episode. A fixed encoder cannot undo a rotation that changes every time it’s asked to undo it. The only thing that can undo it is an invariant (something like a Gram matrix, which is blind to the rotation) — but the invariant throws away exactly the frame information composition needs to work with. This isn’t a failure of model capacity or training budget. Under this nuisance design, the end-to-end task is mathematically unsolvable for any fixed encoder. That’s a strong claim, so it’s worth being precise: it isn’t “the model didn’t manage to learn it,” it’s “there is no fixed function from these observations to a usable frame.”

The same operator library, the same composition search, three different nuisance regimes. Slide between them and watch exact decomposition fall off a cliff between “fixed” and “per-episode” — that’s the exact point where a fixed encoder stops being able to undo the rotation at all.

For what it’s worth, I tried the theoretically-motivated fix — a shared finite family of $M=4$ nuisance rotations, with $M$ encoder heads and per-episode hard selection of the best-fitting one — and it made things worse, not better (0.094 at 3 seeds, vs the single-fixed-rotation tier’s 0.233 at 8 seeds — that 0.094 hasn’t been re-audited at higher $n$, so take it as directionally right rather than precise). The joint discrete inference (which head, which primitive) collapsed early in training: hard selection dumped most episodes onto one head almost immediately and never recovered. Identifiability in theory (“the family can in principle be told apart”) is not the same thing as optimizability in practice. That’s this project’s cleanest recent lesson, and it belongs here rather than buried in a lab notebook.

9. Where this leaves things

The result I’d keep from this post, stated at the size it deserves: a small, shared library of composable operators can summarize a set of rules well enough that a brand-new, unseen composition of two known rules is recognized correctly 89% of the time, at zero new parameters — and this is not the search procedure winning by itself, since the identical search over a random library sits at chance. That’s a real answer to the question in §1.

The result I’d hold with more caution: the moment the composition has to be learned from observations rather than handed a clean latent space, the specific way nuisance enters the data decides whether the problem is hard or literally unsolvable. That’s not a soft “needs more data” caveat — the per-episode-random tier isn’t underfit, it’s mathematically closed off to any fixed encoder. The globally-fixed tier shows the door isn’t shut in general, just narrower than I’d like, and finding the right way to make nuisance learnably identifiable across episodes — without the joint-discrete-inference collapse from §8 — is the open problem this post leaves on the table.

Scope, so the two paragraphs above don’t outrun what was actually measured: 4 primitives, 16-dimensional state, entity counts of 3–4, 3 seeds per arm, one synthetic world. I have no evidence yet that any of this holds at the primitive counts or state dimensionalities where it would actually matter for a real system. The forgetting number in §6 is from a related but distinct architecture, not the exact operator library described in §3 — I’ve tried to be clear about that inline rather than letting the two blur together.