universal-physics-tensor 0.45.2 → 0.46.0

package/dist/atlas/path-bound.js

@@ -0,0 +1,268 @@
+/**
+ * Routes through an atlas family, and the error bound a route carries.
+ *
+ * Two functions, and the second is the one that can do damage:
+ *
+ * - {@link findPath} is pure graph search. It answers "is there a chain of
+ *   bridges from A to B", and nothing more. A path existing says NOTHING about
+ *   whether that path supports a claim.
+ * - {@link boundPath} answers "what error bound does this chain carry", and its
+ *   default answer is NO BOUND. `docs/planning/Atlas-Phase-2-Design.md` §3:
+ *
+ *   > A path containing any edge whose relation composes to
+ *   > `'no-composite-claim'` has NO bound. It must return an explicit no-claim,
+ *   > never a number. A composed number over an undefined composite would be
+ *   > the most dangerous output this library could produce: precise-looking and
+ *   > unfounded.
+ *
+ * So {@link boundPath} returns a DISCRIMINATED UNION, not a number. A caller
+ * cannot read `.bound` off a no-claim, because a no-claim has no `.bound` — the
+ * refusal is enforced by the type rather than by a documented convention.
+ *
+ * ## Norms — why an exact edge does not compose for free
+ *
+ * `./error-algebra.ts` states the rule this module obeys, and it is narrower
+ * than it first reads:
+ *
+ * > An exact equivalence contributes `IDENTITY_BOUND` **in the norms these
+ * > Phase 0 bridges state** — not in every norm.
+ *
+ * An `exact-equivalence` bridge carries no `bound`, hence states no `norm`. It
+ * therefore contributes `IDENTITY_BOUND` in NO norm, and a path that mixes it
+ * with a normed bound cannot claim the composite holds in that norm. That is a
+ * `'norm-not-stated'` no-claim. The composed NUMBER would be unchanged —
+ * composing with the identity is arithmetically a no-op — which is exactly what
+ * makes the error invisible without this gate: the danger is not a wrong
+ * magnitude, it is a right magnitude attached to the wrong norm.
+ *
+ * ⚠ **Correction to the S2.2 brief.** The brief states that no field records a
+ * norm and that Phase 2 must add `norm?` to `ApproximationBound`. That is
+ * out of date: `ApproximationBound.norm` already exists as a MANDATORY
+ * `string` (Phase 0, `./types.ts`). No type change was needed, and this module
+ * reads the field that is already there.
+ *
+ * **Uniformity is gated here, at use.** `ApproximationBound.uniformity` may
+ * be `null` (or empty — the same state) so a real bound can be recorded
+ * before anyone has analysed what the error is uniform in. Composing such a
+ * bound would attach a number to an unanalysed claim, so {@link boundPath}
+ * returns `'uniformity-unanalysed'` and does not compute one.
+ * `propagateUncertainty` does not read the field and does not fold `delta`
+ * into `sigma`: it stays a statistical-sigma function.
+ *
+ * Pure: no I/O, no registry reads.
+ *
+ * @module atlas/path-bound
+ */
+import { composeBoundPath, IDENTITY_BOUND } from './error-algebra.js';
+import { composeRelation, NO_COMPOSITE_CLAIM } from './composition-table.js';
+import { ATLAS_FAMILIES } from './families.js';
+/**
+ * Families {@link findPath} can search: every registered family. This was the
+ * oscillator family alone, which made the diffusion and wave families
+ * unsearchable once they existed. A route stays INSIDE one family: a bridge
+ * that ends in another family's model is not followed across (stated, not
+ * hidden — cross-family routes are out of this function's scope).
+ *
+ * @internal
+ */
+const FAMILIES = Object.fromEntries(ATLAS_FAMILIES.map((f) => [f.family, f]));
+/** Expand a family's bridges into directed edges. Single-premise chains only. */
+function directedEdges(family) {
+    const edges = [];
+    for (const bridge of family.bridges) {
+        // Sprint 2 scope: a multi-premise bridge is a JOIN, not a link in a chain,
+        // and is skipped rather than silently reduced to its first premise.
+        if (bridge.premises.length !== 1)
+            continue;
+        const from = bridge.premises[0];
+        edges.push({ from, to: bridge.conclusion, bridge });
+        if (bridge.relation === 'exact-equivalence') {
+            edges.push({ from: bridge.conclusion, to: from, bridge });
+        }
+    }
+    return edges;
+}
+/**
+ * Shortest chain of bridges from `from` to `to`, or `null` if none exists.
+ *
+ * Breadth-first, so the result is a shortest path by edge count. Ties are
+ * broken by `family.bridges` order, which is the design note's order and is
+ * therefore stable across runs.
+ *
+ * A returned path is a ROUTE, not a warrant: ask {@link boundPath} what the
+ * route supports.
+ *
+ * @throws RangeError if `family` is not a known family, or an endpoint is not
+ *   one of its models. An unknown endpoint returning `null` would be
+ *   indistinguishable from a genuinely disconnected pair.
+ * @internal
+ */
+export function findPath(family, from, to) {
+    const fam = FAMILIES[family];
+    if (fam === undefined) {
+        throw new RangeError(`findPath: unknown family '${family}'`);
+    }
+    const models = new Set(fam.models.map((m) => m.id));
+    for (const endpoint of [from, to]) {
+        if (!models.has(endpoint)) {
+            throw new RangeError(`findPath: '${endpoint}' is not a model of family '${family}'`);
+        }
+    }
+    if (from === to)
+        return [];
+    const outgoing = new Map();
+    for (const edge of directedEdges(fam)) {
+        const bucket = outgoing.get(edge.from);
+        if (bucket === undefined)
+            outgoing.set(edge.from, [edge]);
+        else
+            bucket.push(edge);
+    }
+    const cameBy = new Map();
+    const seen = new Set([from]);
+    const queue = [from];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        for (const edge of outgoing.get(node) ?? []) {
+            if (seen.has(edge.to))
+                continue;
+            seen.add(edge.to);
+            cameBy.set(edge.to, edge);
+            if (edge.to === to) {
+                const path = [];
+                for (let at = to; at !== from;) {
+                    const step = cameBy.get(at);
+                    path.unshift(step.bridge);
+                    at = step.from;
+                }
+                return path;
+            }
+            queue.push(edge.to);
+        }
+    }
+    return null;
+}
+/**
+ * The error bound a chain of bridges carries — or an explicit no-claim.
+ *
+ * Four gates, in this order. Each one is a reason to refuse, and the FIRST
+ * reason found is the one reported; none of them is skippable by a caller.
+ *
+ * 1. **Relation.** `composeRelation` is folded along the path. The moment the
+ *    running composite is `'no-composite-claim'`, the path has no bound. This
+ *    is design note §3 constraint 1 and it is checked before any arithmetic,
+ *    so no number is ever computed for a path that cannot carry one.
+ * 2. **Uniformity.** Any bound whose `uniformity` is `null` or empty is not
+ *    yet analysed. The path returns `'uniformity-unanalysed'` and no Lipschitz
+ *    arithmetic runs. An edge with no `bound` — an exact equivalence, or an
+ *    unbounded coarse-graining — does not fail this gate.
+ * 3. **Lipschitz.** `composeBoundPath` folds the per-edge pairs. A `null` — an
+ *    edge that is neither bounded nor exact — is tolerated only as the LAST
+ *    entry, where it terminates the claim (`terminal: true`); anywhere else it
+ *    throws `MissingLipschitzError` rather than inventing a constant.
+ * 4. **Norm.** Every stated norm on the path must be the SAME norm, and no
+ *    unnormed exact map may carry a normed claim. An `exact-equivalence`
+ *    states no norm (it has no `bound`), so a path mixing one with a normed
+ *    bound is `'norm-not-stated'` — see the module note.
+ *
+ * @throws RangeError on an empty path. Returning `IDENTITY_BOUND` for "no
+ *   edges" would be a bound asserted about nothing.
+ * @throws MissingLipschitzError via {@link composeBoundPath}; see gate 3.
+ * @internal
+ */
+export function boundPath(bridges) {
+    if (bridges.length === 0) {
+        throw new RangeError('boundPath: an empty path composes nothing; there is no bound to state');
+    }
+    // ── Gate 1: the relation must compose all the way along ───────────────────
+    let relation = bridges[0].relation;
+    for (let i = 1; i < bridges.length; i++) {
+        const next = bridges[i];
+        // The loop RETURNS on the first silent cell, so `relation` is always a
+        // real `RelationType` here — no re-check is needed, and TypeScript proves
+        // it (a guard here is flagged as having no overlap).
+        relation = composeRelation(relation, next.relation);
+        if (relation === NO_COMPOSITE_CLAIM) {
+            return {
+                kind: 'no-claim',
+                reason: NO_COMPOSITE_CLAIM,
+                detail: `'${bridges[i - 1].id}' (${bridges[i - 1].relation}) then '${next.id}' ` +
+                    `(${next.relation}) composes to no relation, so the path carries no bound`,
+            };
+        }
+    }
+    // ── Gate 2: an unanalysed uniformity yields no number ─────────────────────
+    // Before any Lipschitz arithmetic. `null` and `[]` are the same state: an
+    // empty list is a universal over nothing, and counting it as analysed is
+    // the convention-checked empty-object defect. An edge with no bound states
+    // no error, so it does not fail this gate.
+    for (const bridge of bridges) {
+        if (bridge.bound === undefined)
+            continue;
+        const uniformity = bridge.bound.uniformity;
+        if (uniformity === null || uniformity.length === 0) {
+            const how = uniformity === null ? 'null' : 'empty';
+            return {
+                kind: 'no-claim',
+                reason: 'uniformity-unanalysed',
+                detail: `'${bridge.id}' has uniformity ${how} (not yet analysed), so the path carries no numeric bound`,
+            };
+        }
+    }
+    // ── Collect the per-edge pairs the remaining gates read ───────────────────
+    // What each edge contributes. The split that matters: an `exact-equivalence`
+    // with no `bound` is EXACT — it contributes `IDENTITY_BOUND`, not an unknown
+    // constant. Any OTHER relation with no bound has an unknown Lipschitz
+    // constant, and `null` is what says so. Conflating the two would either
+    // invent a constant for a lossy map or throw on an exact one.
+    const pairs = [];
+    const norms = new Set();
+    const unnormedIdentities = [];
+    for (const bridge of bridges) {
+        if (bridge.bound !== undefined) {
+            pairs.push({ K: bridge.bound.K, delta: bridge.bound.delta });
+            norms.add(bridge.bound.norm);
+        }
+        else if (bridge.relation === 'exact-equivalence') {
+            pairs.push(IDENTITY_BOUND);
+            unnormedIdentities.push(bridge.id);
+        }
+        else {
+            pairs.push(null);
+        }
+    }
+    // ── Gate 3: an unknown Lipschitz constant, anywhere but last, is fatal ────
+    // Delegated to `composeBoundPath`, which throws `MissingLipschitzError`
+    // rather than inventing a constant. Run BEFORE the norm gate: an unbounded
+    // composite is a harder failure than an unstatable norm, and reporting the
+    // softer one would mask it.
+    const composed = composeBoundPath(pairs);
+    // ── Gate 4: one norm, and no unnormed map carrying a normed claim ─────────
+    if (norms.size > 1) {
+        return {
+            kind: 'no-claim',
+            reason: 'norm-mismatch',
+            detail: `the path states ${norms.size} different norms (${[...norms].map((n) => `'${n}'`).join(', ')}); ` +
+                'bounds in different norms do not compose',
+        };
+    }
+    if (unnormedIdentities.length > 0 && norms.size > 0) {
+        return {
+            kind: 'no-claim',
+            reason: 'norm-not-stated',
+            detail: `${unnormedIdentities.map((id) => `'${id}'`).join(', ')} state no norm, so they ` +
+                `contribute IDENTITY_BOUND in no norm; the composite cannot be claimed in ` +
+                `'${[...norms][0]}'`,
+        };
+    }
+    return {
+        kind: 'bound',
+        bound: composed.bound,
+        terminal: composed.terminal,
+        relation,
+        norm: [...norms][0] ?? null,
+    };
+}
+/** Re-exported so a caller need not reach into the algebra module. @internal */
+export { IDENTITY_BOUND };
+//# sourceMappingURL=path-bound.js.map

package/dist/atlas/path-bound.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-bound.js","sourceRoot":"","sources":["../../src/atlas/path-bound.ts"],"names":[],"mappings":"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"}

package/dist/atlas/poster/associations.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Atlas Phase 3 — the poster's two association-only lines.
+ *
+ * An `Association` (`../association.ts`) records that two things SHARE
+ * something and asserts **no relation**, **no composite claim**, and **no
+ * graph edge**. `ROADMAP.md` Phase 3 puts exactly two of its fifteen lines in
+ * that category, and both are here:
+ *
+ * - **`7 ↔ 16` — the historical link ONLY.** `kind: 'historical-influence'`,
+ *   which is the value that says "influence, not derivation". The derivation
+ *   route to 16 exists and is recorded as a hyperedge from the FULL Maxwell
+ *   system in `./derivations.ts`; this record exists so the resemblance
+ *   between one Maxwell equation and special relativity stops being
+ *   re-surfaced as if it were that route.
+ * - **`3, 14 → *` — association only.** The line states no target, so the
+ *   target is recorded as {@link UNSPECIFIED_TARGET} rather than guessed. Two
+ *   records, one per entry: the line says each of 3 and 14 is association-only,
+ *   NOT that 3 and 14 are associated with each other — pairing them would be a
+ *   claim no source makes.
+ *
+ * `kind` is assigned the way `../association.ts` insists: mechanically, from
+ * what the line says, never as a fresh per-pair physics judgement.
+ * `ASSOCIATIONS` in that module is seeded from the `'decoy'` adjudications and
+ * is pinned by test against the live ledger, so these records live here rather
+ * than being appended to it.
+ *
+ * @module atlas/poster/associations
+ */
+import type { Association } from '../association.js';
+import type { StatementId } from '../statement.js';
+/**
+ * The second member of a `3, 14 → *` association: the line's `*`, which names
+ * no target.
+ *
+ * A sentinel rather than a real id, because inventing a target would invent
+ * the association. Any consumer that draws these edges must treat it as "no
+ * target recorded" and not resolve it.
+ *
+ * @internal
+ */
+export declare const UNSPECIFIED_TARGET = "*";
+/**
+ * The poster's association records.
+ *
+ * `citation` is `ROADMAP.md` with its Phase 3 section, because that is the
+ * source these came from — `../association.ts` requires the note's origin, and
+ * the adjudication ledger is not it.
+ *
+ * @internal
+ */
+export declare const POSTER_ASSOCIATIONS: readonly Association[];
+/**
+ * Statement pairs that may NEVER appear as a derivation, in either direction.
+ *
+ * Derived from the records above rather than restated, so the guard and the
+ * data cannot drift apart: adding an association adds the prohibition.
+ * Pairs whose second member is {@link UNSPECIFIED_TARGET} are excluded —
+ * there is no second statement to forbid an edge to, and a sentinel in a
+ * pair-matcher would silently match nothing while looking like a guard.
+ *
+ * Consumed by `validatePosterRelations` in `./derivations.ts`.
+ *
+ * @internal
+ */
+export declare const ASSOCIATION_ONLY_PAIRS: readonly (readonly [StatementId, StatementId])[];
+//# sourceMappingURL=associations.d.ts.map

package/dist/atlas/poster/associations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"associations.d.ts","sourceRoot":"","sources":["../../../src/atlas/poster/associations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,WAAW,EA6BrD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,CAAC,SAAS,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,EAGhF,CAAC"}

package/dist/atlas/poster/associations.js

@@ -0,0 +1,90 @@
+/**
+ * Atlas Phase 3 — the poster's two association-only lines.
+ *
+ * An `Association` (`../association.ts`) records that two things SHARE
+ * something and asserts **no relation**, **no composite claim**, and **no
+ * graph edge**. `ROADMAP.md` Phase 3 puts exactly two of its fifteen lines in
+ * that category, and both are here:
+ *
+ * - **`7 ↔ 16` — the historical link ONLY.** `kind: 'historical-influence'`,
+ *   which is the value that says "influence, not derivation". The derivation
+ *   route to 16 exists and is recorded as a hyperedge from the FULL Maxwell
+ *   system in `./derivations.ts`; this record exists so the resemblance
+ *   between one Maxwell equation and special relativity stops being
+ *   re-surfaced as if it were that route.
+ * - **`3, 14 → *` — association only.** The line states no target, so the
+ *   target is recorded as {@link UNSPECIFIED_TARGET} rather than guessed. Two
+ *   records, one per entry: the line says each of 3 and 14 is association-only,
+ *   NOT that 3 and 14 are associated with each other — pairing them would be a
+ *   claim no source makes.
+ *
+ * `kind` is assigned the way `../association.ts` insists: mechanically, from
+ * what the line says, never as a fresh per-pair physics judgement.
+ * `ASSOCIATIONS` in that module is seeded from the `'decoy'` adjudications and
+ * is pinned by test against the live ledger, so these records live here rather
+ * than being appended to it.
+ *
+ * @module atlas/poster/associations
+ */
+/**
+ * The second member of a `3, 14 → *` association: the line's `*`, which names
+ * no target.
+ *
+ * A sentinel rather than a real id, because inventing a target would invent
+ * the association. Any consumer that draws these edges must treat it as "no
+ * target recorded" and not resolve it.
+ *
+ * @internal
+ */
+export const UNSPECIFIED_TARGET = '*';
+/**
+ * The poster's association records.
+ *
+ * `citation` is `ROADMAP.md` with its Phase 3 section, because that is the
+ * source these came from — `../association.ts` requires the note's origin, and
+ * the adjudication ledger is not it.
+ *
+ * @internal
+ */
+export const POSTER_ASSOCIATIONS = [
+    {
+        id: 'a-7-16-historical',
+        kind: 'historical-influence',
+        between: ['poster-7', 'poster-16'],
+        note: 'Historical link only. Entry 7 influenced special relativity historically; it does ' +
+            'NOT derive it. The derivation route is the hyperedge {full Maxwell system, spacetime ' +
+            'structure} → 16, never from 7 alone.',
+        citation: 'ROADMAP.md § Phase 3 — Hyperedges, models, and the poster as a typed index',
+    },
+    {
+        id: 'a-3-association-only',
+        kind: 'shared-structure',
+        between: ['poster-3', UNSPECIFIED_TARGET],
+        note: 'Association only. ROADMAP.md Phase 3 states "3, 14 → * association only" and names ' +
+            'no target; the target is recorded as unspecified rather than guessed.',
+        citation: 'ROADMAP.md § Phase 3 — Hyperedges, models, and the poster as a typed index',
+    },
+    {
+        id: 'a-14-association-only',
+        kind: 'shared-structure',
+        between: ['poster-14', UNSPECIFIED_TARGET],
+        note: 'Association only. ROADMAP.md Phase 3 states "3, 14 → * association only" and names ' +
+            'no target; the target is recorded as unspecified rather than guessed.',
+        citation: 'ROADMAP.md § Phase 3 — Hyperedges, models, and the poster as a typed index',
+    },
+];
+/**
+ * Statement pairs that may NEVER appear as a derivation, in either direction.
+ *
+ * Derived from the records above rather than restated, so the guard and the
+ * data cannot drift apart: adding an association adds the prohibition.
+ * Pairs whose second member is {@link UNSPECIFIED_TARGET} are excluded —
+ * there is no second statement to forbid an edge to, and a sentinel in a
+ * pair-matcher would silently match nothing while looking like a guard.
+ *
+ * Consumed by `validatePosterRelations` in `./derivations.ts`.
+ *
+ * @internal
+ */
+export const ASSOCIATION_ONLY_PAIRS = POSTER_ASSOCIATIONS.filter((a) => a.between[1] !== UNSPECIFIED_TARGET).map((a) => [a.between[0], a.between[1]]);
+//# sourceMappingURL=associations.js.map

package/dist/atlas/poster/associations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"associations.js","sourceRoot":"","sources":["../../../src/atlas/poster/associations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAEtC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAA2B;IACzD;QACE,EAAE,EAAE,mBAAmB;QACvB,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC;QAClC,IAAI,EACF,oFAAoF;YACpF,uFAAuF;YACvF,sCAAsC;QACxC,QAAQ,EAAE,4EAA4E;KACvF;IACD;QACE,EAAE,EAAE,sBAAsB;QAC1B,IAAI,EAAE,kBAAkB;QACxB,OAAO,EAAE,CAAC,UAAU,EAAE,kBAAkB,CAAC;QACzC,IAAI,EACF,qFAAqF;YACrF,uEAAuE;QACzE,QAAQ,EAAE,4EAA4E;KACvF;IACD;QACE,EAAE,EAAE,uBAAuB;QAC3B,IAAI,EAAE,kBAAkB;QACxB,OAAO,EAAE,CAAC,WAAW,EAAE,kBAAkB,CAAC;QAC1C,IAAI,EACF,qFAAqF;YACrF,uEAAuE;QACzE,QAAQ,EAAE,4EAA4E;KACvF;CACF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,sBAAsB,GACjC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,kBAAkB,CAAC,CAAC,GAAG,CACxE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAU,CAC7C,CAAC"}

package/dist/atlas/poster/derivations.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Atlas Phase 3 — the poster's typed edges.
+ *
+ * `ROADMAP.md` Phase 3 states FIFTEEN bridge lines. This module records all
+ * fifteen, each in the container its type demands, and {@link POSTER_LINES} is
+ * the table that makes "all fifteen, correctly typed" a checkable claim rather
+ * than a reading of the source.
+ *
+ * ## Three containers, because the lines are three different acts
+ *
+ * - **{@link POSTER_DERIVATIONS}** — a `Derivation` asserts `premises ⊢
+ *   conclusion`. Most lines are this.
+ * - **`./associations.ts`** — `7 ↔ 16` is an **association for the historical
+ *   link only**, and `3, 14 → *` is association only. An `Association` makes
+ *   no composite claim and is not a graph edge (`../association.ts`), which is
+ *   exactly the content of those two lines.
+ * - **{@link POSTER_CONSTRAINTS}** — `5, 16 → 8` *"constrain but do not
+ *   determine"*. Neither of the other two containers can say that. A
+ *   `Derivation` would assert that 5 and 16 YIELD 8, which is the claim the
+ *   line explicitly denies; an `Association` would say only that the three
+ *   resemble each other, which drops the constraint. **This third container is
+ *   a correction to the S3.3 brief**, which allows only derivations and
+ *   associations; recording `5, 16 → 8` as a derivation would have been the
+ *   overclaim the sprint exists to prevent. The variational route the line
+ *   names — Einstein–Hilbert — IS a derivation, and it is recorded as one.
+ *
+ * ## One derivation has no premises, and that is the honest form
+ *
+ * `d-4-commutator` records the line *"`4` derivation from the commutator and
+ * Cauchy–Schwarz, no time-dependent equation needed"*. Its two inputs are not
+ * poster entries, and they are not among the five hidden nodes `ROADMAP.md`
+ * names. Inventing `statement-canonical-commutator` to fill the premise slot
+ * would be the invention §5 of the design note forbids, so the inputs are
+ * recorded as `sideConditions` and the premise set is empty. The empty set
+ * does not assert that entry 4 follows from nothing — `sideConditions` carries
+ * what it follows from — and {@link validatePosterRelations} pins that this is
+ * the ONLY empty-premise record, so a second one cannot appear unnoticed.
+ *
+ * ## Witnesses
+ *
+ * `Derivation` has no `witnesses` field (`../derivation.ts` is Wave 1's and is
+ * not mine to widen), so {@link POSTER_WITNESSES} is a side table keyed by
+ * derivation id. The two Sprint 0 witnesses land where `ROADMAP.md` puts them:
+ * W4 (chirped Gaussian) on `13 ↔ 4`, W5 (Wick rotation) on `6 ↔ 13`.
+ *
+ * @module atlas/poster/derivations
+ */
+import type { Derivation, DerivationId } from '../derivation.js';
+import type { StatementId } from '../statement.js';
+import type { Witness } from '../types.js';
+/**
+ * `5, 16 → 8`: premises that CONSTRAIN a target without determining it.
+ *
+ * It has no `relation`, no `conclusion` and no context union, because it
+ * concludes nothing. `alternativeRoute` names what does determine the target,
+ * so the record cannot be read as "and nothing else does".
+ *
+ * @internal
+ */
+export interface PosterConstraint {
+    readonly id: string;
+    readonly premises: readonly StatementId[];
+    /** What the premises constrain. NOT a conclusion. */
+    readonly constrains: StatementId;
+    /** Why the premises fall short of determining it. */
+    readonly note: string;
+    /** The derivation id that DOES reach the target, when one is recorded. */
+    readonly alternativeRoute?: DerivationId;
+}
+/** Where a poster line is recorded. @internal */
+export type LineContainer = 'derivation' | 'association' | 'constraint';
+/**
+ * One of the fifteen `ROADMAP.md` Phase 3 bridge lines, and the records that
+ * carry it.
+ *
+ * @internal
+ */
+export interface PosterLine {
+    /** `'L1'` … `'L15'`, in the order `ROADMAP.md` lists them. */
+    readonly id: string;
+    /** The line as `ROADMAP.md` writes it, in substance. */
+    readonly line: string;
+    /** Every container this line lands in. */
+    readonly containers: readonly LineContainer[];
+    /** Ids of the records, across those containers. */
+    readonly records: readonly string[];
+}
+/**
+ * The poster's derivation hyperedges.
+ *
+ * Each `relation` is the type `ROADMAP.md` names for its line, and each
+ * `sideConditions` list carries that line's qualifications — including the
+ * ones that say what the edge does NOT give, because a qualification dropped
+ * here is a claim widened silently.
+ *
+ * @internal
+ */
+export declare const POSTER_DERIVATIONS: readonly Derivation[];
+/**
+ * `5, 16 → 8` — the one line that asserts a constraint and denies a
+ * derivation. See the module note for why it gets its own container.
+ *
+ * @internal
+ */
+export declare const POSTER_CONSTRAINTS: readonly PosterConstraint[];
+/**
+ * The Sprint 0 witnesses, attached where `ROADMAP.md` Phase 3 puts them.
+ *
+ * A side table rather than a field, because `Derivation` is Wave 1's record
+ * and widening it is not this brief's scope.
+ *
+ * @internal
+ */
+export declare const POSTER_WITNESSES: Readonly<Record<DerivationId, readonly Witness[]>>;
+/**
+ * The fifteen lines, and where each one is recorded.
+ *
+ * The table is the deliverable "all fifteen, correctly typed" in checkable
+ * form: {@link validatePosterRelations} resolves every `records` id in every
+ * `containers` entry, so a line that lost its record, or a record that moved
+ * to the wrong container, is a failure rather than a reading.
+ *
+ * @internal
+ */
+export declare const POSTER_LINES: readonly PosterLine[];
+/** One defect {@link validatePosterRelations} found. @internal */
+export interface PosterProblem {
+    readonly kind: 'unknown-statement' | 'no-context-union' | 'association-typed-as-derivation' | 'missing-record' | 'wrong-container' | 'unexpected-empty-premises';
+    readonly detail: string;
+}
+/**
+ * Every defect this index can have that a type cannot catch.
+ *
+ * Six checks, and the third is the one the S3.3 brief singles out:
+ *
+ * 1. **Unknown statement.** Every premise and conclusion resolves in
+ *    `POSTER_REGISTRY`.
+ * 2. **No context union.** A derivation whose premises do not pool states no
+ *    claim; `makeDerivation` records that rather than throwing, so a record
+ *    carrying a refusal would otherwise sit in the list looking like an edge.
+ * 3. **An association typed as a derivation.** `7 ↔ 16` and `3, 14 → *` are
+ *    associations. If a derivation ever links either pair — in either
+ *    direction — the distinction has been lost, and it is the distinction
+ *    that carries the physics: the route to 16 runs from the full Maxwell
+ *    system, *never from 7 alone*.
+ * 4. **Missing record / 5. wrong container.** Every id in
+ *    {@link POSTER_LINES} exists, in one of the containers its line declares.
+ * 6. **Unexpected empty premises.** Exactly one record may have none.
+ *
+ * Returns problems rather than throwing, so a caller sees ALL of them at once
+ * — a thrown first defect hides the rest, and this list is checked as a whole.
+ *
+ * @internal
+ */
+export declare function validatePosterRelations(): readonly PosterProblem[];
+//# sourceMappingURL=derivations.d.ts.map

package/dist/atlas/poster/derivations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivations.d.ts","sourceRoot":"","sources":["../../../src/atlas/poster/derivations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAI3C;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,qDAAqD;IACrD,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,YAAY,CAAC;CAC1C;AAED,iDAAiD;AACjD,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,aAAa,GAAG,YAAY,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAWD;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,UAAU,EAyKnD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,gBAAgB,EAUzD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,OAAO,EAAE,CAAC,CAY/E,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAqG7C,CAAC;AAEF,kEAAkE;AAClE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EACT,mBAAmB,GACnB,kBAAkB,GAClB,iCAAiC,GACjC,gBAAgB,GAChB,iBAAiB,GACjB,2BAA2B,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAYD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,IAAI,SAAS,aAAa,EAAE,CAqElE"}