Typed, grounded, and true

Theory update · 2026-06-28 · from compression to comprehension · experiment comprehension, slice 2

Last round the program landed its first positive of the new architecture: a gradient-free binder answered "what color is the apple?" where counting is provably at chance. Counting cannot bind made the smallest version of talking to the system work, one fact, one question, one answer. The honest question that left open is whether the binder is a real comprehension organ or a one-trick toy that happens to pass one task. This round answers it across three more capabilities, each with the same per-episode randomization control that pins any counting model at chance, each gradient-free, pure numpy, scored on held-out questions. The binder is typed: give each thing a color and a size, and "what color" returns the color, not the size (1.000), where an untyped bag of the same facts confuses the two classes half the time (wrong-class 0.504). The binder is cortex-grounded: bind the codes the neocortex would emit (derived from the spelling) rather than fresh random atoms, and it comprehends exactly as well (1.000), so the neocortex-to-hippocampus wiring the author's notes call for works. The binder tracks truth: "is the box red?" gets a NO when the box is blue, even though the episode said "it is not red" first so red co-occurs with the box (1.000), where an association reader says yes to the negated color and fails every no-case (0.000). Three more rungs, all clean. The binder is a validated comprehension organ, not a demo. And the honest forward-look is the whole point of writing this down: the organ is built, and the next work is the architecture that reads and answers on its own, not more synthetic rungs.

The question this round answers

The pivot is settled. Six rounds on prediction said the next symbol is a local game counting already wins, so the program changed the question from compression to comprehension, and the first positive showed a gradient-free vector-symbolic binder, the engineering form of the hippocampus the program's two neocortical engines lacked, answering a binding question that counting provably cannot. A statement binds a role to a filler, a question unbinds the role, the answer is cleanup to the nearest stored item, no gradient anywhere.

But one passing task is not an organ. A hash map passes one task. The honest worry after the first positive was that the binder might be narrow: it answers "what color" when color is the only property, on independent random codes, with no notion of true or false. So this round asks the harder version three ways. Does it keep two kinds of fact apart? Does it work on the codes a real cortex would hand it, not idealized orthogonal atoms? And does it know the difference between a fact that is stated and a fact that is true? Each is a rung even strong neural models stumble on, and each carries the same control that makes a pass mean binding rather than frequency-guessing: the property is resampled every episode, so corpus-wide every entity is equally often every value, and any count or co-occurrence reader sits at chance by construction. Only reading this episode's structure can answer.

What happened

The picture is the three tests side by side: the binder against the cheap strategy the control defeats.

Typed: color, not size

Give every entity two properties, a color and a size, and ask "what color is the apple?" The trap is that a binder which only remembers "the apple goes with green and small" can hand back small when asked for color. The fix the brain uses, and the one the binder gets, is a typed binding: each fact binds the entity and a role for its class to the filler, so unbinding the entity-and-color-role recovers the color specifically. The control reads the answer back by cleaning up over all property atoms, color and size together, so the model has to pick the right class, not just the right entity. The discriminating arm is an untyped bag that binds entity to filler with no class role; queried by entity alone it returns either bound property.

The numbers, scored on ten thousand held-out questions, color chance 0.250 and size chance 0.500:

The typed binder is perfect, color and size both, wrong-class zero. The untyped bag, holding the very same facts, answers the wrong class 0.504 of the time, a coin flip between the two properties. That is the load-bearing contrast: the per-class role is what makes the binding typed. Without it the structure is there but unreadable; with it the binder separates the kinds of fact cleanly. And the corrupt-store control collapses to chance, so the store does the work, not a leak.

Cortex-grounded: binding the codes the neocortex emits

The first positive bound random codes, one fresh orthogonal atom per word. That tests the binding mechanism but skips a fact the author's notes insist on: the hippocampus does not bind raw input, it binds cortical codes, the representations the neocortex has already computed. So this slice swaps the random atoms for content-derived codes: the code for a word is the sign of a fixed random projection of its character bigrams, so similar spellings produce similar codes, a minimal stand-in for a cortex with similarity structure. The binder is unchanged; only the codes change.

The integration works: binding the cortex's own codes comprehends exactly as well as binding independent random atoms, 1.000 against 1.000, wrong-class zero on both. So the neocortex-to-hippocampus flow, encode in the cortex, then bind the cortical code in the hippocampus, holds. That is the wiring the architecture has been pointing at, shown to function end to end.

The honest part, stated plainly: the question of whether code similarity costs or helps came back inconclusive here, and it should. The distinct entity spellings project to near-orthogonal codes (a mean pairwise cosine of 0.014, essentially zero), so there is no interference to measure, which is why accuracy is unchanged. The payoff of similarity, similar entities generalizing to each other, needs genuine semantic structure that the cortex would have to learn, and these spelling-derived codes do not carry it. That is a Phase 2 question, the one where the abstraction engine's above-ceiling code becomes the generalization dial. It is not shown here, and this round does not claim it.

Truth: the box is not red

The sharpest test is negation, because it pits truth against association directly. Each episode states a false fact and then the true one: "here is the box, it is not red, it is blue." So the word red co-occurs with the box. Then "is the box red?" must answer NO, and "is the box blue?" must answer YES. A reader that answers from co-occurrence, did this color appear with this entity, says yes to the negated color and gets every no-case wrong. Only a store that retrieves the true value, blue, and compares it to the probe answers correctly.

Co-occurrence scores a perfect 1.000 on the yes-cases and a perfect 0.000 on the no-cases: it says yes to both the true color and the negated one, exactly the failure association predicts. Its overall 0.500 is not noise, it is the average of getting the easy half right and the sharp half wrong every time. The binder is 1.000 across the board, yes and no alike, because it retrieves the box's true color and checks the probe against it. That is truth-tracking over propositions, not association. The binder knows the box is not red even though "red" was in the sentence.

What this means

Three rungs, three clean passes, each against the cheap strategy the control was built to defeat. Put together they change what we can say about the binder. After the first positive it was a working mechanism that answered one question. Now it keeps two kinds of fact apart, runs on the codes a real cortex would emit, and distinguishes a stated fact from a true one. It is a comprehension organ, validated on the apple/cup world, not a one-task demo. The neocortex the program already had still cannot do any of this by counting; the hippocampal binder it lacked does all three, gradient-free, online, bounded.

It is worth being precise about what each test rules out, because the controls are the point. Typed binding rules out "it just remembers the entity" (the untyped bag does that, and confuses the classes half the time). Cortex-grounding rules out "it only works on idealized orthogonal atoms" (the content-derived codes work identically). Negation rules out "it is association with extra steps" (co-occurrence fails every no-case; the binder compares to the truth). The same four operations the brain's fast system is theorized to run, bind, bundle, unbind, clean up, executed on sparse codes with no gradient and a bounded store, now answer typed, grounded, and truth-valued questions about a small world.

The binder, last round's first positive, is now a validated comprehension organ. Across three more tests, all gradient-free, all under the per-episode randomization control that pins counting at chance: typed binding returns the color and not the size (1.000) where an untyped bag confuses the classes (wrong-class 0.504); binding the neocortex's own content-derived codes comprehends as well as random atoms (1.000 vs 1.000), so the cortex-to-hippocampus wiring works; and the binder tracks truth, answering NO to "is the box red?" when the box is blue (1.000) where co-occurrence says yes to the negated color and fails every no-case (0.000). The honest bound: the cortex-code similarity dial is inconclusive here because distinct spellings project near-orthogonal, so the generalization payoff waits on learned semantic structure (Phase 2). We have built the missing organ; the next work is the system that reads and answers on its own.

The honest forward-look

This is the north-star steer, and it is the reason to stop here rather than climb another synthetic rung. The binder is now a validated comprehension organ on the apple/cup world. But every test in this round and the last is hand-parsed, with hand-coded comparators: a Python reader turns the stream into role-filler triples, and a hand-written rule does the yes/no compare for negation. The binder is real; the scaffolding around it is not the architecture yet.

So the next work is the architecture, not more rungs on this ladder. Three pieces, in order. A reader that extracts the role-filler structure from the stream itself, the cortex's prediction and abstraction engines doing the segmentation and role identification that the hand-parser does now, and feeding the binder. Generation of the answer, producing "blue" rather than scoring a retrieved atom against a key, wiring this organ to the production loop the generation track has been building. And realer language, past the closed apple/cup vocabulary toward text that was not generated to be parsed. We have built the missing organ across two rounds; the job now is to wire it into a system that reads and answers on its own.

The honest caveats

• Hand-parsed, hand-compared. As above: the role-filler structure is extracted by a Python reader, and negation's compare is a hand-coded rule. This round validates the organ, not an end-to-end system. That gap is the next phase's whole agenda, not a footnote.
• The cortex-code similarity dial is inconclusive, by construction. Distinct spellings project to near-orthogonal codes (cosine 0.014), so there was no interference to measure and the integration result is "it works," not "similarity helps." The similarity payoff needs learned semantic structure (Phase 2), and is not claimed here.
• The synthetic apple/cup world, still. Closed vocabulary, balanced queries, two property classes. Each rung is harder than the last and each carries the randomization control, but none of this is open-domain language.
• One seed, the numbers stated as run. The discriminations are the structural reads: the untyped bag at a coin-flip wrong-class, co-occurrence at zero on the no-cases, the binder perfect across all three. Those are where the controls bite, and they are exactly where the theory says they should.

Lineage

Grew from counting cannot bind, the first positive of the pivot from compression to comprehension, which built the gradient-free binder and showed it answering one question counting provably cannot. That round named the open ladder, typed binding, relations, negation, novel-entity fast-mapping, as the untested rungs ahead; this round climbs three of them and reframes the next step as architecture rather than ladder.

Led to the named next phase now recorded in the architecture: a reader that extracts role-filler structure from the stream (the neocortical engines feeding the hippocampal binder), generation of the answer, and realer language, the system that reads and answers on its own. The validated organ is the part we now build into that system.

Thread: comprehension, and online learning without a global gradient. A validated comprehension organ, typed, cortex-grounded, and truth-tracking, with the controls that make each pass mean binding rather than counting, and an honest forward-look that points at the architecture, not the next synthetic rung.