EvaluatedApplications.Prism 1.3.4

Prism

Beta. The public API may change between versions while we improve it. Breaking changes always come with a new major version, and the release notes say what changed.

EvaluatedApplications.Prism — the AlgFormer/HoloFormer production standard: a stamped, append-only lineage journal that answers "what was true when this happened" without ever re-deriving history from current state, plus the canonical confidence-gated decode policy a real HoloFormer/AlgFormer host runs in production. Built to stop one class of bug that has hit a real training hot path three times — a value recomputed from a live constant/field instead of read from a fact stamped at the time it happened. This page is comprehensive: every public type and member is documented below, because this package ships binary-only (no source, no separate docs site).

dotnet add package EvaluatedApplications.Prism

Depends on EvaluatedApplications.AlgFormer (resolved automatically). Namespaces: Prism.Lineage, Prism.Inference, Prism.Growth.

Table of contents

1. Quick start
2. Why this exists — the invariant every type here protects
3. Prism.Lineage — the stamped journal
4. Prism.Growth — grow a model correctly, with the journal stamped automatically
5. Prism.Inference — the confidence-gated decode
6. Gotchas and invariants
7. License

Quick start

using Prism.Lineage;
using Prism.Growth;
using Prism.Inference;
using PrismFormer;

// 1) A model and a lineage journal to go with it (JSONL on disk, or MemoryLineageStore for no filesystem).
var model = new HoloFormer(vocab: 10, shifts: 3, layers: 1, maxContext: 6, dModel: 8, frozenPrefix: 0);
var journal = new LineageJournal(new MemoryLineageStore());
var inForce = new InForce(IterWarm: 8, StackK: 2, CtxCeiling: 64, LayerCeiling: 8);
journal.AppendGenesis(round: 0, layers: model.Layers, inForce);

// 2) Grow it through Prism.Growth so the journal is stamped automatically.
var grown = Grow.AddLayers(model, extra: 1, atRound: 10, journal, inForce);
double rampedAlpha = journal.AlphaAt(round: 12, layerIndex: grown.Model.Layers - 1);
Console.WriteLine($"grew to {grown.Model.Layers} layers; new layer's alpha at round 12 = {rampedAlpha:F3}");

// 3) Decode with the canonical confidence gate instead of hand-rolling softmax + a threshold.
double[] logits = grown.Model.LogitsFor(new[] { 1, 2, 3 });
var decision = Gate.Evaluate(logits, vocab: model.Vocab, DecodePolicy.Holographic);
int picked = Gate.Pick(logits, vocab: model.Vocab, DecodePolicy.Holographic, new Random(1));
Console.WriteLine($"greedy={decision.Greedy} top={decision.Top} picked={picked}");

Why this exists

A fact about what happened is stamped when it happens, and is never re-derived from current state. Every LineageJournal derivation (AlphaAt, DepthAt, LastGrowthRound, AddRoundOf) walks stamped history up to the round in question; none of them ever reads an ambient/live constant or field. Three real production incidents in a HoloFormer/AlgFormer training host shared exactly this root cause before this package existed:

1. Alpha computed live from a constant. A per-layer ramp read the current warm-up constant instead of the constant that was in force when that layer was added — hand-bumping the constant as a stopgap, then reverting it, made every already-ramped layer's alpha jump discontinuously.
2. A regrow-ramp boundary invented from a schedule. A formula guess kept recomputing a "boundary" after growth had already stopped, crushing the learning rate forever.
3. Serving depth read live from the wrong knob. A diagnostic hardcoded an old depth value after the live value had moved on, silently evaluating a checkpoint at the wrong depth.

A fourth, same-family trap: a layer index is also state that moves once front-insert growth exists (index i names a different layer after every later front grow) — LineageJournal resolves indices by replaying stamped events, never by looking an index up against a range frozen at grow time.

If you build your own derivation on top of Prism.Lineage, ask "does this read anything from the stamped event list, or does it reach for a live field/constant instead?" — the second answer is the bug this package exists to prevent.

Prism.Lineage

Types

LineageJournal members

using Prism.Lineage;

var journal = new LineageJournal(new MemoryLineageStore());
var inForce0 = new InForce(IterWarm: 10, StackK: 1, CtxCeiling: 32, LayerCeiling: 4);
journal.AppendGenesis(round: 0, layers: 1, inForce0);

var inForce1 = new InForce(IterWarm: 10, StackK: 2, CtxCeiling: 32, LayerCeiling: 4);
journal.AppendGrowLayers(round: 20, fromLayers: 1, toLayers: 2, inForce1);   // append (default)

double alphaNewLayerEarly = journal.AlphaAt(round: 22, layerIndex: 1);   // 2 rounds into its own 10-round ramp
double alphaOldLayer      = journal.AlphaAt(round: 22, layerIndex: 0);   // settled long ago -> 1.0
var (stackK, alpha) = journal.DepthAt(round: 22);
Console.WriteLine($"newLayerAlpha={alphaNewLayerEarly:F2} oldLayerAlpha={alphaOldLayer:F2} " +
                   $"StackKAt22={stackK} LastGrowthRound(25)={journal.LastGrowthRound(25)}");

// Idempotent re-append (e.g. a resumed process re-checking "should this have fired") is a safe no-op:
var again = journal.AppendGrowLayers(round: 20, fromLayers: 1, toLayers: 2, inForce1);
Console.WriteLine($"idempotent: {journal.Events.Count} events after a duplicate append");

Prism.Growth

A growth surface over HoloFormer (package AlgFormer) that makes each axis correct by construction and stamps the LineageJournal as it goes. Prism.Growth.Grow is the only sanctioned way to grow a model you're tracking with a LineageJournal — calling HoloFormer.GrowLayers/GrowShifts/HoloUpgrade.* directly and hand-stamping reopens exactly the "forgot to record it" bugs this package exists to prevent.

All four methods: are a no-op (same model reference, Event:null, an informational Warnings entry) when the requested size already matches the model's current size on that axis; throw ArgumentException on any shrink request (a live checkpoint cannot shrink in place).

using Prism.Lineage;
using Prism.Growth;
using PrismFormer;

var model = new HoloFormer(vocab: 10, shifts: 3, layers: 1, maxContext: 6, dModel: 8, frozenPrefix: 0);
var journal = new LineageJournal(new MemoryLineageStore());
var inForce = new InForce(IterWarm: 8, StackK: 1, CtxCeiling: 32, LayerCeiling: 8);
journal.AppendGenesis(0, model.Layers, inForce);

var layersResult = Grow.AddLayers(model, extra: 2, atRound: 5, journal, inForce);
var shiftsResult = Grow.ToShifts(layersResult.Model, newShifts: 5, atRound: 8, journal, inForce);
var ctxResult    = Grow.ToContext(shiftsResult.Model, newContext: 10, atRound: 10, journal, inForce);

Console.WriteLine($"layers={layersResult.Model.Layers} (event={layersResult.Event != null}) " +
                   $"shifts={shiftsResult.Model.Shifts} ctx={ctxResult.Model.Context} " +
                   $"warnings={ctxResult.Warnings.Count}");

// No-op: requesting the current size records no event and returns the SAME model instance.
var noop = Grow.ToShifts(shiftsResult.Model, newShifts: 5, atRound: 20, journal, inForce);
Console.WriteLine($"no-op same instance: {ReferenceEquals(noop.Model, shiftsResult.Model)} event={noop.Event is null}");

Prism.Inference

The confidence-gated decode a HoloFormer/AlgFormer host actually runs: commit greedily when the top token is confident, otherwise sample — either over a resonance-filtered subset (the holographic core's real behaviour) or the whole vocabulary (the plain-softmax core's real behaviour) — plus a degeneracy guard.

using Prism.Inference;

var rng = new Random(1);
double[] logits = { 0.1, 5.0, 0.2, 0.05, 0.3 };   // index 1 clearly dominant -> should decode greedy

var decision = Gate.Evaluate(logits, vocab: logits.Length, DecodePolicy.Holographic);
int picked = Gate.Pick(logits, vocab: logits.Length, DecodePolicy.Holographic, rng);
var top3 = Gate.TopK(logits, vocab: logits.Length, count: 3);
Console.WriteLine($"greedy={decision.Greedy} top={decision.Top} topProb={decision.TopProb:F3} picked={picked} " +
                   $"top3=[{string.Join(",", top3.Select(t => $"{t.Index}:{t.Percent:F1}%"))}]");

// A non-holographic ("Dense") host explicitly opts out of the resonance floor:
var denseDecision = Gate.Evaluate(logits, vocab: logits.Length, DecodePolicy.Dense);
Console.WriteLine($"Dense OverFloor (whole vocab, no floor)={denseDecision.OverFloor}");

// Degeneracy guard:
var guard = new DegenGuard(DecodePolicy.Holographic);
bool collapsed = false;
foreach (var tok in new[] { 1, 1, 1, 1 }) collapsed = guard.Observe(tok, greedy: true);
Console.WriteLine($"collapsed after 4 repeats (threshold 4)={collapsed}");

Gotchas

• FloorMode.None, ResonanceSigma, and TopP are all real, for different callers. Don't silently default every caller to one — that is exactly the copy-drift this package exists to end. Holographic (= Default) and Dense name the two real production choices explicitly.
• ResonanceSigma is structurally a top-1 filter at most below-confidence positions (measured: 77.7%– 83.9% of real FINAL-face logit positions on a production-shaped checkpoint). The min(mean+FloorK·sigma, max) cap means the admitted set is never empty, but mean/sigma are computed over the full vocab including every already-suppressed token, so sigma measures the rejected bulk's spread, not the real candidates' — no retune of FloorK fixes this (it's a tail-shape problem). FloorMode.TopP fixes it by admitting on softmax probability mass instead, which has no suppressed-tail term to inherit the bug from. ResonanceSigma itself is unchanged by this fact — switching a host to TopP is a separate, deliberate decision you make per-host, not a default this package silently changes for you.
• DegenGuard must keep both triggers. Dropping the non-greedy-run trigger reopens a real closed gap (a port that implemented only the repeat trigger missed it).
• LineageJournal.Append's idempotency key is (Round, Kind, Field). A duplicate GrowLayers at the same round/kind/field collapses to the first record — including its LayerInsertIndex — so a second call with a different insert index silently returns the first record unchanged. Don't call Append-family methods speculatively expecting the latest call to win.
• An older Prism build reading a front-grown journal misreads it as an append. LifecycleEvent has no catch-all extension-data bag for unknown fields, so a pre-front-insert reader silently drops LayerInsertIndex and replays a front grow as if it were an append. Upgrade every reader of a shared journal file before writing a front grow into it.
• InForce's four fields are a snapshot you provide, never a live binding. Read your current knob values at the moment you call an Append*/Grow.* method and pass them in explicitly — there is no "always fresh" wiring, by design (that's the whole point of the package).
• FileLineageStore.Append throws InvalidOperationException if the serialized event contains a raw newline — this guards the one-event-per-line JSONL contract. Keep any free-text fields you might add to a future event newline-free, or escape them before they reach the store.
• Nothing here is license-gated. Every type and member on this page works identically regardless of any license key; see License for what the commercial-use terms actually are.

License

Proprietary — this package ships the compiled library only; see LICENSE for the full terms. Installing and using unmodified copies for internal evaluation and non-commercial development or testing is licensed; commercial, production, or revenue-generating use requires a separate commercial licence from the owner. No feature on this page is gated behind a tier or a licence key — every capability described works identically with or without one. Copyright (c) 2026 Dongyang Stephen Chen, trading as Evaluated Applications. All rights reserved.