One stack, two halves

Theory update · 2026-06-28 · one stack, two halves · experiment unify

The program split into two engines that each do one thing. The voting bank predicts: many count columns, each reading a different view, pooled by a calibrated blend, low bits-per-char. The sparse apical stack abstracts: k-WTA with boosting and positive weights and per-unit credit, transfer abstraction at the backprop ceiling. Neither does the other. So the prize is one stack that does both, and this is the attempt: give the abstraction stack the prediction machinery, N sparse columns each on a different view, voted by the same blend, abstraction kept intact. The result is an honest trade-off. Abstraction composes, and it exceeds the ceiling. The unified stack reaches transfer CCGP 0.520, above its own single-view 0.487 and above the 0.484 single-layer backprop reference, at higher dimensionality, no collapse: the highest abstraction the program has reached, gradient-free. The earlier multi-view failure does not reassert, because k-WTA and boosting preserve the cross-stimulus variance the old normalization destroyed. Prediction does not transfer. The unified stack reads 3.666 bits-per-char, barely below its single-view 3.753 and nowhere near the voting bank's 2.442. The diagnostic is sharp: the blended bits-per-char equals its own best single column, so the vote does nothing for prediction with neural columns. The voting bank's win was a property of count tables combining, not of voting. So the prize, one stack low on bits and high on abstraction, is not won at this scale: the synthesis kept and improved abstraction, and did not import prediction.

The question

The program built two engines, and each does exactly one of the two things that matter.

The first is the voting bank. Many count columns, each reading a different view of the recent context, each a small conditional table, pooled by a calibrated blend (the normalized geometric mean, every column kept at the right temperature). It predicts: on text8 it reaches low bits-per-char, and it keeps dropping with data. Its abstraction score reads high, but that number is expressive dimensionality, a richer code, not a more abstract one, the line the program drew when it put attention on the gradient-comparable ruler.

The second is the sparse apical stack, the P0.5 hero. A k-WTA sparse code with boosting, positive weights and no bias, and per-unit credit carried down a precision-gated apical wire. It abstracts: it holds deep transfer abstraction at the 0.484 backprop ceiling to the last checkpoint, on both seeds, with hundreds of distinct winner-codes. But its bits-per-char is high, about 3.6, because it is a single view.

So the prize is one stack that does both: low bits-per-char and high abstraction, predict and abstract on one substrate. This is the attempt. Give the abstraction stack the machinery that makes the voting bank a good predictor: diverse views and a blended vote. The unified bank is N independent P0.5 columns, each a full sparse apical stack, each reading a different attended view the way the voting bank does. It predicts by pooling the per-column next-char distributions with the same blend, and it abstracts on its per-column and consensus sparse code, probed exactly as the two anchors are.

There is a reason it might compose where an earlier attempt failed. The earlier capstone (normalization crossed with breadth) failed on the variance axis: the activation normalization pins every code to the same magnitude and collapses the cross-stimulus variance within each column to rank one, and concatenating rank-one lanes cannot undo that. P0.5 does not use that normalization. It uses k-WTA and boosting, where the winner identity, which units fire, carries the cross-stimulus variance, and the duty-cycle boost actively keeps the winner-set high-rank. So cross-stimulus rank is preserved per column, and multi-view may compose with the abstraction where it did not before. That is the open question this run answers.

The three arms

Three arms, on the identical eighteen-thousand-character text8 slice, depth three, the mean of two seeds, the verbatim transfer-CCGP, dimensionality, and bits-per-char probes, apples to apples.

• P0.5 single-view, the abstraction anchor. One sparse apical column on the canonical view: boosting, positive weights, per-unit credit. Transfer abstraction at the ceiling, bits-per-char about 3.6.
• VOTING bank, the prediction anchor. The count-native diverse voting bank read out with the calibrated blend. Low bits-per-char, its abstraction number expressiveness.
• UNIFIED multi-view P0.5, the test. Eight sparse apical columns, each the P0.5 hero configuration, each on a different diverse view, voted by the same blend. Does it get both?

What happened

One stack, two halves. The synthesis kept the abstraction and improved it, and it did not import the prediction.

The numbers, at eighteen thousand characters, depth three, the mean of two seeds. Bits-per-char is the held-out blended bits-per-char for the bank arms and the readout for P0.5; transfer CCGP is on the deep code; PR is the deep dimensionality. The raw-input expressiveness floor is 0.339 and the single-layer backprop reference (GRAD-1L) is 0.484.

Read it on the two axes and it splits in two.

Abstraction composes, and it exceeds the ceiling. The unified stack reaches transfer CCGP 0.520, above its own single-view P0.5 at 0.487, above the 0.484 single-layer backprop reference, at higher dimensionality (PR 19.5 against the single column's 8.1), with no collapse. This is the highest abstraction the program has reached, gradient-free. The earlier multi-view failure does not reassert: the cross-stimulus rank-one collapse that killed the normalization-crossed-with-breadth capstone does not happen here, because k-WTA and boosting preserve the cross-stimulus variance that the normalization destroyed. The winner identity carries the variance, the boost keeps the winner-set spread, and the diverse views then add to the abstract code instead of flattening it. Multi-view composes with the per-unit-credit abstraction, and the composition reads above the backprop reference.

Prediction does not transfer. The unified stack reads 3.666 bits-per-char, barely below its single-view P0.5 at 3.753 and nowhere near the voting bank's 2.442. The vote buys almost nothing for prediction. The diagnostic is sharp: the blended bits-per-char (3.666) equals the bank's own best single column (about 3.66). Pooling eight neural columns gives the same bits-per-char as the best one of them alone. So the vote does nothing for prediction when the columns are neural. The voting bank's bits-per-char win is a property of count tables combining, sharper conditional tables averaging into a sharper prediction, not a property of voting as such. The sparse apical columns do not combine that way, so the blend that wins for the count bank does not win here.

One stack, two halves. Abstraction composes: the unified multi-view sparse stack reaches transfer CCGP 0.520, above the single-view 0.487 and above the 0.484 single-layer backprop reference, at higher dimensionality, no collapse, the highest abstraction the program has reached gradient-free, because k-WTA and boosting preserve the cross-stimulus variance the old normalization destroyed. Prediction does not: the unified stack reads 3.666 bits-per-char, barely below its single-view 3.753 and far from the voting bank's 2.442, and the blended bits-per-char equals its own best single column, so the vote does nothing for prediction with neural columns. The count bank's win was count tables combining, not voting.

So the prize, one stack low on bits and high on abstraction, is not won at this scale. The synthesis kept and improved the abstraction; it did not import the prediction. The empty corner stays empty.

What this means

The two-engines split the program drew is now measured on one substrate, and it sharpens rather than dissolves.

The half that worked is real and it moves a home axis. For the whole abstraction line, the score that mattered was at the backprop ceiling, never past it: the sparse stack matched 0.484 and held, it did not exceed it. The unified stack reads 0.520, above the single-layer reference, at higher dimensionality, with no collapse. Multi-view composes with the per-unit-credit abstraction, and the abstract code gets better for it. The mechanism is the one the empty-cell round named: the cross-stimulus variance lives in the winner identity, not the magnitude, so a code that keeps that variance per column lets diverse views add to the abstraction instead of flattening it. This is the highest abstraction the program has reached, and it is gradient-free.

The half that did not is just as informative. The voting bank's bits-per-char win does not belong to the vote. It belongs to count tables: sharper conditional tables average into a sharper prediction. Sparse apical columns are not conditional tables, and pooling them with the same blend leaves the prediction exactly where the best single column already had it. The vote is the wrong tool for prediction on a neural substrate. So predict-and-abstract in one stack is still open, and the obstacle is now precise: the abstraction substrate and the prediction substrate do not combine the same way, and the blend that couples count columns does not couple neural ones.

The honest bounds are sharp, and they cut both ways. This is eighteen thousand characters and two seeds. The bits-per-char anchors are scale-compressed at that size: the voting bank reaches about 2.1 only past two hundred thousand characters, so the 2.442 here is its small-scale number, not its floor. The 0.484 reference is the single-layer backprop ceiling, so "exceeds the ceiling" means it passes the GRAD-1L reference; a multi-view backprop is the fair ceiling to recheck before any claim that gradient-free beats backprop, and this is not that claim. And the configuration that wins is the P0.5 hero, boosting and positive weights with per-unit credit; the permanence-credit and full-credit variants collapse at this scale, as they did in the empty-cell round.

The diagnostic points two ways forward, one for each half of the gap. Couple the columns: train each column's readout on the pooled error, so the vote is fit jointly rather than each specialist predicting alone, and the columns might combine the way count tables do. Or graft a count-native head onto the abstract code: use the P0.5 abstract sparse code as the context key for a count predictor, one substrate with two heads, an abstraction head and a prediction head. The first asks whether neural columns can be made to combine; the second stops asking the abstract code to predict and lets a count table do that job on top of it.

The prize, one stack that predicts and abstracts, is not won at eighteen thousand characters. The synthesis kept and improved abstraction (0.520, above the single-view 0.487 and the 0.484 single-layer reference, no collapse) and did not import prediction (3.666 bits-per-char, equal to its own best single column). The honest bounds: eighteen thousand characters and two seeds, bits-per-char anchors scale-compressed at that size, 0.484 the single-layer reference not a multi-view one, the P0.5 hero config the only stable arm. The path forward: couple the readouts on the pooled error, or graft a count-native head onto the abstract code, one substrate with two heads.

Lineage

Grew from the empty cell, filled, which built the sparse apical abstraction stack (boosting and positive weights and per-unit credit, transfer abstraction at the 0.484 ceiling), and from the vote was too loud, which gave the voting bank its calibrated blend. It reuses both verbatim: each unified column is the P0.5 hero stack, and the readout is the same normalized blend. It carries forward the abstraction wall continuation, which factored diverse voting off as a prediction organ rather than an abstraction one, and attention is prediction, not abstraction, which proved a richer input does not abstract better on the gradient-comparable ruler, the reason the voting bank's high CCGP is read here as expressiveness. And it answers the open question the locked-architecture round left, whether the levers compose: the earlier capstone failed because normalization destroyed the cross-stimulus variance, and this composes because k-WTA and boosting preserve it.

Led to the two named directions of the diagnostic. Couple the columns, training each readout on the pooled error so the vote is fit jointly, the test of whether neural columns can be made to combine the way count tables do. Or graft a count-native head onto the abstract code, the abstract sparse code as the context key for a count predictor, one substrate with two heads. And to the standing recheck the bound requires: a multi-view backprop reference, the fair ceiling to draw before any claim that this gradient-free abstraction passes backprop.

Thread: abstraction, and online learning without a global gradient. An honest trade-off that takes the abstraction line to its highest score yet, above the single-layer backprop reference and gradient-free, and shows that prediction does not ride the same vote, so one stack that predicts and abstracts stays open with the obstacle now named.