loci

Recall is a chain, and every link has known statistics. A cue becomes coefficients over the stored items whose first two moments are exact; the place-cell input is Gaussian by the central limit theorem over the cue’s bits; the ReLU is moment-matched; the grid input is then Gaussian over all grid cells; and recall is the probability that every module’s argmax lands on the right phase. Nothing is fitted and no cue is drawn.

It was developed on 180 conditions, where its mean error was 0.010. Then it was frozen and hashed, and run on 156 held-out runs — 14 new settings, each with its placements, on 3 seeds — that change something it had not seen: new content, scaffolds, noise types and sizes. The predictions were hashed before the bars were written and before any measurement; results/oos/FROZEN.txt logs the order, including a first measurement launch that crashed and wrote nothing. Re-running the frozen code reproduces the hashed predictions exactly.

The error law alone fails. Project the coefficients through the phase indicators instead of the scaffold’s templates and the mean error on the same conditions is 0.187. The law ranks placements; the magnitudes live in the scaffold.

The error law changes by exact amounts when an item moves. For a new item, the cheapest free address is the one where its own recall coefficients are largest: store where your recall points. For a stored item, recall with its own trace set aside is exact coordinate descent on the law: move it to where that recall points. That is replay.

Encoded then replayed, the rule beats k-means on five kinds of content, by 0.05–0.15 at the headline condition. Replay does most of the optimising: replay from random addresses gets within 0.04 of it. The encoding’s value is that the memory is organised from the first item on, 0.68 against 0.44 before any replay.

What the rule needs, the network cannot yet do. The rule needs K and every stored pattern, together more state than the memory’s 840,000 weights. In pilots the network’s own read-out delivers the rule’s choice for 78–86% of new items; run through it end to end, filing recalls 0.57–0.69 after replay, above random and below k-means (3 seeds, exploratory).

For each value of one factor, one partner of another is never experienced with it. Asked for the gist of that combination, does the memory construct it: land on an empty address whose read-out carries every factor? Two read-outs are compared, the paper’s snap and the nearest of all 3,600 place codes, a read-out the paper’s network does not have. Filed by the true factors, the memory constructs 0.95–1.00 of the combinations. Filed by the recall rule, it constructs 0.24–0.31, while recalling as well through the nearest read-out and 0.05 worse through the snap. Filed at random, none.

This is a failure of search, not of the objective. The error law strongly prefers the aligned filing (0.78 against 1.38). Recall accuracy barely distinguishes the two, so it cannot guide search there.

A recollection check separates imagining from remembering. Through the nearest read-out, familiarity tells recombined events from studied ones less than half as well as when empty states are not valid (d′ 3.1 against 7.5); recollection, which checks the cue’s detail against the read-out, separates them almost perfectly (d′ 10.2; 4.6 through the snap).

A disclosure: these criteria were registered after the previous experiment had run on the same seeds, and one clause was registered on the decoder where a known gap vanishes. The table gives both read-outs; under the paper’s own snap, four of seven bars are missed.

Round 1 established the setting. With the paper’s write rule, noisy recall collapses when the items stored reach the cue dimension: the pseudo-inverse’s minimum sits at exactly P = Ns for every Ns and every kind of noise, and past it the scaffold snaps to a valid but wrong address. A noise-matched ridge removes the dip. None of this is new as mathematics; it is double descent. What is new is where it sits: in the cue map, at the right-hand edge of every capacity plot in the paper.

A memory that files itself

The first round-2 write-up said so. The rule is computed from more state than the memory holds, and through the network’s own read-out it files below k-means.

Accuracy is silent about structure

Overstated. Through the paper’s snap, the recall-filed memory recalls worse than the oracle-filed one at 20% flips. What holds is narrower: recall barely distinguishes the two, so it does not guide search there.

The price of imagination is recall

Treating never-stored states as valid costs nothing under aligned placement, with a decoder that admits every address. The apparent cost belonged to the paper’s per-module snap. The price is false memory, for decoders that read place activity alone.

Consolidation discovers structure

No recall-driven procedure tried aligned the modules with the factors at full phase resolution. It happened when a granularity was supplied from outside.