How PRA works

Prediction is the test of understanding: a model understands a world exactly as far as it can say what happens next, given what it does. That requires acting. Language describes the world secondhand; the triplet is the world answering you directly.

encoder:     h  = tanh(W1·obs + b1);   pose = W2·h + b2
decoder:     hd = tanh(D1·pose + d1); recon = D2·hd + d2
transition:  th = tanh(T1[a]·pose + tb1[a]); pred_pose = T2[a]·th + tb2[a]   (one net per action)

fit_quality      = ‖recon − obs‖ / (‖obs‖ + 1e-6)
prediction_error = ‖decode(pred_pose) − next_obs‖ / (‖next_obs‖ + 1e-6)   ← observation space!
effort           = ‖pred_pose − pose‖

learning: plain gradient descent, every gradient element clipped to ±gradient_clip.

The load-bearing rule: prediction error is measured in observation space — the predicted pose is decoded back into a claimed observation and compared with reality. A collapsed frame can make its own pose trivially predictable; it cannot fake predicting the world. Never let a frame invent the ruler it is measured with.

fit = ‖recon − obs‖ / (‖obs‖ + 1e-6)
recon_err_ema ← ema_decay·recon_err_ema + (1 − ema_decay)·fit     ← on EVERY exposed event
if fit < fit_gate:  frame maps → contributes pose, learns          ← "sparsity by pull"

This split — sparse learning, total judgment — is the entire reason dimensionality selection works. A cheating frame narrows its gate, learns a tiny comfortable niche, and reports a beautiful score while explaining almost nothing. The coverage-fair EMA makes that strategy fatal instead of dominant.

survival_score = w_explain·recon_err_ema + w_predict·pred_err_ema
               + w_effort·effort_ema + w_complexity·dim        (lower = better)

At scale the error curve has no knee at all — it just keeps falling to the capacity ceiling. So the penalty isn't detecting the world's true size; selection simply keeps buying dimensions while the marginal error-gain exceeds the price, and stops there. The ecology lands at the price-optimal operating point — stably, at every scale measured.

each consolidation cycle:
  1. age everyone; candidates mature at age ≥ min_age_cycles
  2. apply pending anatomy changes
  3. evict: threshold = base / (1 + coeff · max(0, pop − baseline))   ← falls with crowding
     remove unprotected frames scoring above it, worst first (never below min_frames)
     hard cap: still too many → cull worst to max_frames
  4. spawn candidates: dim = best_dim ± 1 (mostly), sometimes explore
  5. snapshot

Note the division: crowding tightens the tolerated-error bar. A bar that loosened instead would let eviction vanish and the population slam into the hard cap. And this is the system's whole memory story — it keeps running structure, not stored episodes. No scrapbook required.

curiosity  = w_progress·LP + w_novelty·novelty
  LP        = max(0, mean(older errors) − mean(recent errors))   ← rewards error going DOWN
  novelty   = unfamiliarity vs a bounded memory of recent observations
competence = mastery + familiarity
  mastery   = max(0, 1 − mean(recent prediction error))
  familiarity = 1 − novelty

The anti-noise-trap property: on static, error is high but flat, so LP ≈ 0. On mastered ground, error is low and flat — LP ≈ 0 again. Only a live learning frontier scores. Honesty note from the measurements: at scale, novelty-directed curiosity performed worse than random (−0.062); the inverted preference — competence — is what beat it (+0.067). The perfect drive is still an open problem, and PRA says so out loud.

per step:  m ← β·m + (1−β)·obs;  d = obs − m
           v ← β·v + (1−β)·d²
           cov ← β·cov + (1−β)·d·(prev_obs − m)
recompute: ρ̂ = clip(cov/(v+1e-6), 0, 1)
           w  = clip(ρ̂ / max(ρ̂), floor, 1)      (unready channels stay at 1)
apply:     judging  → ‖(recon − obs)⊙w‖ / (‖obs⊙w‖ + 1e-6)
           learning → encoder sees w⊙obs; placement backprops (recon − obs)⊙w

The transport argument: weighting unit static at 0.2 makes every computation operation-for-operation equivalent to running at static amplitude 0.2 — an operating point already measured as a clean PASS. The remedy doesn't hope; it transports the system into a regime known to work. Off means off: floor = 0 → byte-identical pinned behavior, zero extra float work. (Demo uses a faster β than the shipping 0.995 so you don't wait 200 steps.)