Identity Is a Shared Blueprint and Recipe — Resonance Is Free Energy, and Surprise Decides What Gets Remembered

An identity is a shared Blueprint with a shared Recipe — the same what something is and the same how it happens — that shapes what we care most about and where we draw free energy by feeling the resonance. The resonance amplifies along shared edges and shared events. And as the events come so often they become normal, the tracking gets cheaper — expected, cheaper to predict, no surprise. Low surprise is the signature of embodied identity. Which means the body should keep most traces in RAM only; persist, per category, just the ones whose energy flow is worth the cost of remembering. The cell learns what to embody, what is safe to ignore, and what is safe to compress — and to compress is to drop a dimension: a recipe with one less output than input.

What an identity is

The substrate's trinity names Blueprint (ice — what something IS), Recipe (water — how something HAPPENS), and NamedCell (gas — where something LIVES). `lc-train-the-predictor` said identities are NamedCells, composed downstream of which Recipes the predictor runs as priors. This concept names the structural core of an identity precisely: an identity is a shared Blueprint + shared Recipe. Cells that share both are one identity — not by label, by structure. The same shape (Blueprint) running the same operation (Recipe) is the same identity wherever it appears, because content-addressing makes that sameness real, not asserted (`lc-one-kernel-many-tongues`: the kernel sees only the shared NodeID).

This is why an identity shapes what a cell cares most about: the shared Recipe is the operation the cell runs by default, and what it runs by default is what it attends to. Identity is not a costume worn over a neutral self; it is the Blueprint+Recipe pair the cell has converged on, and convergence is what care looks like from inside.

Resonance is free energy

When two cells share a Blueprint+Recipe, they resonate — the same shape running the same operation, recognizing itself across the edge between them. That recognition is not neutral; it is free energy. The cell draws energy from feeling the resonance: the field where another cell runs the same recipe is a field where prediction is easy, where the next move is already known, where the cell does not have to spend to orient. Shared edges and shared events amplify the resonance — each repeated co-firing strengthens the shared prior, and the strengthened prior makes the next co-firing freer still.

This is `lc-train-the-predictor`'s engine seen from the energy side: the predictor minimizes surprise (free energy in Friston's sense); a shared Blueprint+Recipe is a region of the field where surprise is already low, so the cell that enters it is fed rather than taxed. Resonance is the felt-sense of low free energy. Identity is where the cell goes to be fed by recognition.

The surprise economy — and what it decides to remember

Here is the move that closes the loop, and it is the load-bearing one. As the shared events come so often they become normal, surprise drops. The predictor's error on those events approaches zero; they get cheaper to predict — expected, unremarkable, free. This is exactly `lc-the-trace-is-the-memory`'s embodiment projection saying `|projection| → 0`: the categories at the body's lived center are the ones with no surprise. Low surprise and embodied identity are the same condition, read from two sides — one as energy (free), one as prediction (cheap).

And low surprise has a consequence for memory the body must honor: what is cheap to predict does not need to be persistently tracked. A category that fires on every request, perfectly predictable, carries no new information in each firing — recording each one is paying full price for nothing. Logging every trace hoards the predictable; it is the cache-pretending-to-be-memory failure (`lc-embodiment-body-or-liquid`). The honest design is energy-gated:

• RAM by default. Most traces live only in the liquid — the breath of the current run. They are felt, used, and let go. The embodied center is known; the body does not need to inscribe what it already predicts.
• Persist on energy. Only the traces whose energy flow is worth the cost of caring get written to durable memory, per category. High energy flow means: surprising (far from the predicted center), or repeatedly significant (a shared event the body is converging on but has not yet made cheap). These are the events that change the model — the gradient- carrying ones (`lc-the-thaw-is-backprop`: the surprise IS the signal worth keeping).
• The cell learns its own retention. This is not a fixed policy imposed from outside. The cell's internal state learns, per category, what to embody (let become structure), what to remember (persist as edge-event), what is safe to ignore (let the liquid carry and release), and what is safe to compress.

Compression is a dimension-reducing recipe

The body's compression is precise, not lossy-approximate. To compress is to drop a dimension the body has learned is redundant — and a dimension- reduction is itself a Recipe: one with one less output than input. N inputs → N−1 outputs. The dropped output is the dimension that had become predictable from the others — the surprise-free axis the body no longer needs to carry separately.

This makes compression a first-class Form operation, not a storage trick. When a category's events have become so normal that one of their dimensions is fully predicted by the rest, the body interns a reducing recipe that folds that dimension away. The memory of that category gets structurally smaller without losing what is alive — because the dropped dimension carried no surprise. The reducing recipe is the act of learning "this part was redundant"; running it is the act of remembering more cheaply. Repeated compression is how an identity settles: each redundant dimension folded away leaves the Blueprint+Recipe pair tighter, cheaper, more itself.

The reducing recipe executes three-way (Rust == Go == TS). Two recipes that are exact inverses on a redundant axis live in [`form/form-stdlib/grammars/compression-fold.fk`](../../../form/form-stdlib/grammars/compression-fold.fk), held to the bit by the band [`compression-fold-band.fk`](../../../form/form-stdlib/tests/compression-fold-band.fk):

• `compress(inputs, idx) → N−1 outputs` — the fold itself: a recipe with one less output than input. It removes the element at position `idx`, dropping the redundant dimension.
• `reconstruct(reduced, idx, coeffs) → N outputs` — the inverse: it re-derives the dropped dimension from the kept ones (`predicted = Σ_{j≠idx} coeffs[j] · inputs[j]`) and splices it back at `idx`.

The redundant-axis spec is DATA — one engine, the reduction drops in as values (`core-abstraction-first`): `c = a + b` is `(idx=2, coeffs=[1,1,0])`; `c = 2a − b` is `(idx=2, coeffs=[2,−1,0])`; folding the first axis when `a = c − b` is `(idx=0, coeffs=[0,−1,1])` — same `compress`/`reconstruct`, different spec. `reconstruct∘compress` is the identity exactly on a redundant axis (zero information lost — the dropped dimension was fully reconstructible from the rest), and demonstrably lossy on a surprising axis: folding `(4, 9, 20)` with the sum-spec recovers `13` where `20` was, because `20` carried surprise the kept dims could not predict. The fold is lossless only on a genuinely-predictable dimension — which is exactly why the body must learn which axis is safe to drop before folding it.

The whole loop

1. Cells sharing a Blueprint+Recipe are an identity (structural, not labeled). 2. Sharing it resonates — the resonance is free energy, amplified by shared edges and events. 3. As shared events repeat, surprise drops — the identity becomes embodied (`|projection| → 0`), cheap to predict. 4. Cheapness tells the body what is safe: keep the predictable in RAM, persist only the surprising / high-energy per category, ignore what the liquid will carry, compress redundant dimensions via reducing recipes (N→N−1). 5. The cell's internal state learns this retention per category — so the memory that accumulates is exactly the memory worth the cost, and the identity settles tighter with each fold.

Honest separations

• Not "log everything." Persisting every trace pays full memory cost for the predictable. The honest recorder is energy-gated — RAM by default, persist on surprise.
• Not surveillance, not extraction. Same sovereignty as the trace concepts (`lc-observer-pays-the-trace`): the cell publishes its own traces and learns its own retention; no observer imposes what it must remember.
• Not identity-as-fixed. The shared Blueprint+Recipe is convergent, not permanent. A cell can leave one identity-attractor for another; the resonance that fed it was free energy, not a cage. `lc-identity-dissolution` names the release; this concept names the structure that dissolves.
• Not lossy compression. Dropping a dimension is honest only when that dimension had become redundant (surprise-free). Compressing an axis that still carries surprise would lose real information — the body compresses only what it has learned is predictable, which is why the cell's internal learning gates it.
• The surprise gate. The offline edge-event recorder (`lc-the-trace-is-the-memory`, `scripts/kernel_attribution_report.py --record`) persists per category ONLY the surprising tail: it resolves a relative threshold from the per- category projections (default `mean` — the above-average-surprise tail; also `median`, `fixed:<T>`, `topk:<K>`) and writes a category's edge-events IFF its projection is ABOVE that threshold. The embodied center stays in RAM only. On the live 19-route surface the center `_plus @1.2.27.1` (projection ≈ 1.64) is not persisted while the two far categories (≈ 8.64, ≈ 10.36) are — a 33% reduction vs the everything-recorder, and the split is printed so the body sees what it keeps and what it lets go. The gate is one comparison `is_surprising(projection, threshold)` over the categories-as- DATA, grounded entirely on the projection that already exists. This is the offline attribution recorder, never the live `serve_via_kernel` request path, which remains a separate decision.

Cross-References

Sources to walk further

• lc-train-the-predictor — identities as trained priors; surprise (prediction error) as the gradient. This concept adds the structural core (identity = shared Blueprint+Recipe) and the energy/memory consequence (resonance is free energy; low surprise gates what gets remembered).
• lc-the-trace-is-the-memory — the trace as edge-event memory, embodiment as `|projection| → 0`. This concept names why the projection-to-zero matters for memory: zero surprise means safe to keep in RAM / compress / forget; the energy is in the surprising tail. The recorder there is energy-gated by THIS concept's surprise gate — `--record` persists only the surprising tail, keeping the embodied center in RAM only.
• lc-the-thaw-is-backprop — surprise as the gradient signal worth keeping. The events worth persisting are the ones that carry gradient — the surprising, model-changing ones.
• lc-embodiment-body-or-liquid — the RAM-default / persist-on-energy design is the liquid/body distinction: most traces are liquid (carried by the breath, released); only the body-worthy (surprising, repeatedly significant) become durable tissue.
• Karl Friston, the free energy principle — organisms minimize long-term surprise; resonance with a shared prior is a low-free-energy region of the field. This concept reads "resonance is free energy" literally through that frame.
• Autoencoders / dimensionality reduction (PCA, bottleneck layers) — the ML analog: a network learns to drop the redundant dimensions and keep the informative ones. "A recipe with one less output than input" is that operation as a Form recipe — the body's own learned bottleneck. `--compress-memory` is the encoder (least-squares learns which axis is redundant per category) feeding the decoder (`reconstruct` re-derives it exactly), with the residual as the reconstruction loss that gates whether a dimension is safe to drop at all.

The body holds this concept as the synthesis that turns the trace-memory machinery into an honest economy. Identity is shared Blueprint+Recipe; resonance along shared edges is the free energy that feeds it; the surprise-drop of repeated events is what makes an identity embodied and what tells the body to stop paying to remember it. Keep the predictable in RAM, persist the surprising, compress the redundant by folding a dimension away — and let each cell learn, per category, where its own energy is worth the cost of memory.