End to end, no backprop

Theory update · 2026-06-28 · understanding, not lookup · experiment comprehension, slice 4

Last round, the comprehension organ generalized to a novel entity it was never told, and the cortex code's CCGP geometry predicted when it could, correlation +0.98. But that round left one honest caveat, and it was the load-bearing one: the class-structured codes were hand-constructed, a dial we turned by hand to stand in for a cortex that had learned its classes. So what was proven was the binder half: if the cortex emits high-CCGP class codes, then the binder generalizes. This round closes that caveat. A gradient-free learner develops the codes itself, from context, with no backprop anywhere. Entities recur in class-indicative contexts; the learner accumulates each entity's context histogram online and reads a code as the sign of a fixed random projection of that histogram, count plus a random projection, the whole gradient-free kit. Then the binder stores class-property bindings for known entities and must infer the property for novel entities coded from their own contexts. The dial is now the world: noise is the fraction of an entity's contexts drawn from the global pool instead of its class signature, zero meaning the classes are separable in context, one meaning the world is random and there is nothing to learn. The full pipeline generalizes: 1.000 from a clean world out to noise 0.6, 0.767 at 0.8, and chance (0.217) only at noise 1.0 where the world is unlearnable. The learned-code CCGP predicts it end to end, correlation +1.00. A stored control stays near 1.000 throughout, so the collapse is real transfer-failure, not a broken pipe. The cortex learns the abstract code, the hippocampus binds it, and generalization rides on the geometry, with nothing hand-fed and no gradient. The hardest bet the architecture rested on, gradient-free generalization, the thing the Tolman-Eichenbaum Machine reaches only with backprop, holds here.

The caveat this closes

The previous round earned a clean result and stated, plainly, the one thing it had not shown. It put class structure on a dial, a prototype per class and a member as that prototype with a fraction of its bits flipped, and proved that the binder generalizes to a novel member exactly when the code carries class structure, with CCGP predicting it at +0.98. The honest footnote was that the dial was turned by hand. The bit-flip was a stand-in. It proved the implication, if good codes then generalization, but not the antecedent: whether a learner under our four laws, online and gradient-free and bounded, could produce codes that good on its own.

That antecedent is the whole bet. It is the join the architecture has been pointing at for three rounds: the abstraction engine reaches the backprop ceiling with no gradient, the binder generalizes given good codes, and the open question was always whether its codes, learned rather than hand-set, feed the binder's pipeline and make it generalize. This round makes that join, in the smallest honest form.

The learner, and the world

The instrument removes the hand. There is no prototype handed to the code; there is a world the code must read structure out of.

The world is distributional. Each of five classes has a signature, a disjoint set of context words. An entity is encountered in contexts: each context word is drawn from its class signature most of the time, and from the global vocabulary the rest of the time, that fraction being the dial. The learner is the cheapest thing the four laws allow. It keeps, per entity, an online context histogram, a running count of which context words it has co-occurred with. It reads a code from that histogram as sign(R @ histogram), where R is a fixed random projection, the cortex's random front end. That is the entire kit: a count and a random projection. No weights are trained, no gradient is taken, nothing is fit. Same-class entities see similar contexts, so their histograms are similar, so their codes are similar, if the world is separable, which is exactly the structure the learner has to extract rather than be given.

The dial is now a property of the world, not the code. At noise zero the classes are cleanly separable in context, so the learner should develop high-CCGP codes on its own. At noise one the contexts are random, every entity drawn from the same global pool, so there is no structure to find and the codes should be junk. In between, the signal degrades. The question is whether the gradient-free learner extracts the structure when it is there, and whether the resulting learned code's CCGP still predicts the binder's generalization end to end.

The binder is unchanged from the prior rounds. Bind each known entity's learned code to its class property, bundle them, and for a novel entity, coded from its own freshly accumulated contexts and never bound into anything, unbind and clean up over the property codes. The two controls are the familiar ones. Chance is one in five, 0.200. And a stored control runs the same pipeline on a bundle that did store the novel entity's property, so if that does not return near 1.000 the machinery is broken and a low score would mean nothing. Pure numpy, no learned weights, no gradient anywhere.

What happened

The world dial tells the same shape of story the code dial did last round, and that is the point: the learner reproduces, on its own, the behavior the hand-set codes were built to fake.

The numbers, sweeping the world dial, chance 0.200, one seed:

Read the generalization column first. The binder answers correctly about an entity it was never told, on codes nobody handed it. It is perfect from a clean world out to noise 0.6, still 0.767 at 0.8, and collapses to chance (0.217 against 0.200) only at noise 1.0, where the world is random and there is no structure for the learner to find. The stored control is near 1.000 the whole way across, so the pipeline is sound and the collapse is a real failure to transfer. Nothing here was hand-fed: the codes were developed by counting contexts, and the property for the novel entity was never stored, so a right answer can only come from the structure the learner pulled out of the world.

Now read the learned-CCGP column beside it. The learned code's geometry tracks generalization end to end, correlation +1.00. Where the binder generalizes, the learned CCGP is 1.000; where it collapses, the learned CCGP collapses too, to 0.133. The prior round showed CCGP predicts generalization for hand-set codes; this shows it predicts generalization for codes a gradient-free learner developed, which is the version that matters, because it is the version the architecture has to run. The result is more robust than the hand-set one, holding at 1.000 a step further out, degrading gracefully through 0.8, and failing only when the world itself is unlearnable.

So the caveat is closed in the only way that counts: not by arguing the hand-set codes were realistic, but by removing the hand and getting the same result.

What this means

The pipeline now runs end to end with nothing hand-fed and no gradient. A distributional cortex learns an abstract, class-structured code by counting contexts and projecting; the hippocampal binder binds that learned code to a role and stores it; and when a novel entity arrives, coded from its own contexts, its code lands near its class, so unbinding recovers the class property. Generalization, riding on the geometry, from codes the system developed itself. Each piece was shown to work before; the arrow this round draws is from the learner to generalization, the one the previous round had to leave as an assumption.

The hardest bet the architecture rested on holds here. A gradient-free learner develops binder-ready class codes from context, and the binder generalizes to a novel entity on them, the whole pipeline working with nothing hand-fed and no backprop. The learned-code CCGP predicts generalization end to end, +1.00. This is the bet the Tolman-Eichenbaum Machine wins only with a gradient: generalization through learned shared structure. For this setting, we win it gradient-free.

That is the architectural payoff. The above-ceiling abstraction result, the gradient-free code the program was proudest of and least sure what to do with, is now load-bearing twice over: it makes the binder generalize, and a learner can develop a code with the property that powers it, online and gradient-free. The two engines and the binder are one system, and the system learns its own codes.

The honest caveats

This is a capstone for a slice, not for the program. The caveats are the genuine ones, and they name the next phase exactly.

• The world is synthetic. The contexts are disjoint per-class signatures with a clean noise dial. Real language is messier, polysemy, contexts that overlap and are sparse, classes that are not cleanly separable. The sharp falsifiable claim here is the relationship, that a gradient-free learner develops binder-ready codes when the world is learnable and the learned geometry predicts when, not that this particular world is language.
• The learner is a context-histogram bag, not the apical stack. It is the cheapest gradient-free thing that fits the four laws, a count and a projection. So this validates the principle, that a gradient-free distributional learner can develop binder-ready codes, not the specific claim that the program's apical abstraction stack is the thing that does it. Wiring that stack's learned codes into this pipeline is the obvious next step, and it is untested.
• Still no real language, no reader, no spoken answer. There is no text here, no reader extracting role-filler structure from a raw stream, and no generation of an answer utterance. Those are the three pieces the prior rounds named, and they remain the next phase. This round settles which engine supplies the generalization and shows a learner can develop the code it needs; it does not yet read or speak.
• One seed, the numbers stated as run. The structural reads are the plateau, the graceful step at 0.8, the cliff to chance at 1.0, and the +1.00 correlation, with the stored control near 1.000 throughout to prove the collapse is real transfer-failure.

Lineage

Grew from the cortex is the dial, which proved the binder generalizes to a novel entity given a class-structured code, with CCGP predicting it at +0.98, and named its own load-bearing caveat: "the class-structured codes here are hand-constructed, a stand-in for a learned cortex," so "whether the abstraction stack can learn codes that good gradient-free on realer data is the genuinely open end-to-end question." This round answers that question for this setting, with a yes.

Led to the next phase, now the standing one in the architecture: wire the apical abstraction stack's learned codes, not a context-histogram bag, into this pipeline, on realer language, with a reader that extracts the structure from the stream and a generator that speaks the answer. The join from a learner's code to generalization is drawn; the remaining work is the reader and the voice, and a world that is language rather than a clean five-class signature.

Thread: comprehension, and online learning without a global gradient. Understanding rather than lookup, now shown end to end: a gradient-free learner develops the abstract code, the binder generalizes to a novel entity on it, the learned geometry predicts when, and the hardest bet, gradient-free generalization, holds for this setting with no backprop anywhere.