universal-physics-tensor 0.45.2 → 0.47.0

package/dist/atlas/statement.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Atlas Phase 3 — `Statement`, `Context`, and the CHECKED context union.
+ *
+ * A `Statement` is a claim IN A CONTEXT, not a string. Design note
+ * `docs/planning/Atlas-Phase-3-Design.md` §1: two statements that render
+ * identically can be claims about different things when their gauge, frame or
+ * assumption set differs, and the poster index will place exactly such pairs
+ * next to each other. `context` is therefore the reason this type exists at
+ * all rather than reusing `CanonicalEquation`.
+ *
+ * ## `ast?` is optional ON PURPOSE
+ *
+ * The poster's hidden supporting nodes — the action principle, Noether, the
+ * full Maxwell set, the Lorentz group, the central limit theorem — are
+ * valuable because they are NAMED and LINKED, not because they are evaluable.
+ * Requiring an `ast` would force either a fabricated encoding or their
+ * exclusion, and both are worse than an honest `sourceExpression` with no
+ * `ast` (design note §1). Do not make it required.
+ *
+ * ## The union is CHECKED, never computed
+ *
+ * {@link contextUnion} does not MERGE contexts. It asks whether a union
+ * EXISTS, and returns an explicit refusal when it does not. Two refusals
+ * matter, and neither is an error condition:
+ *
+ * 1. **Convention conflict** — delegated to `checkConventions`, whose contract
+ *    is that `undefined` means UNKNOWN and is never a mismatch. An absent
+ *    declaration must not read as agreement, so the asymmetry is preserved
+ *    here rather than re-derived.
+ * 2. **Contradictory assumptions** — Blueprint v2 §5.2 step 2: incompatible
+ *    assumptions are NEVER POOLED. A derivation whose premises assume mutually
+ *    exclusive conditions has no context union, therefore no composite.
+ *
+ * The result is a DISCRIMINATED UNION, mirroring `boundPath`'s no-claim
+ * (`./path-bound.ts`): a caller cannot read `.context` off a refusal, because
+ * a refusal has no `.context`. That is the whole point — the refusal is
+ * enforced by the type, so no caller can read a conclusion off a union that
+ * was never formed.
+ *
+ * Pure: no I/O, no registry reads.
+ *
+ * @module atlas/statement
+ */
+import type { Conventions } from './types.js';
+import type { ModelId } from './model.js';
+import type { ExprNode } from '../dimensional/ast-types.js';
+/** A {@link Statement} id — `'statement-noether'`, … . @internal */
+export type StatementId = string;
+/**
+ * The context a claim is made in: what it quantifies over, which choices it
+ * fixes, and what it assumes.
+ *
+ * Every field but `assumptions` and `excludes` is optional, and the SAME
+ * asymmetry `checkConventions` documents applies to each: a context that
+ * declares no `gauge` has not chosen the Lorenz gauge, it has not said.
+ * Absence is unknown, never disagreement.
+ *
+ * `assumptions` and `excludes` are required (possibly empty) because they are
+ * the pair that decides poolability, and an optional one would let a caller
+ * omit the field that makes a refusal possible.
+ *
+ * @internal
+ */
+export interface Context {
+    /** Canonical quantity types the claim ranges over — `['energy', 'time']`. */
+    readonly quantityTypes?: readonly string[];
+    /** `'Lorenz'`, `'Coulomb'` — a fixed gauge choice, when the claim depends on one. */
+    readonly gauge?: string;
+    /** `'comoving'`, `'lab'` — a fixed frame choice, when the claim depends on one. */
+    readonly frame?: string;
+    /** Sign and unit choices. Compared by `checkConventions`. */
+    readonly conventions?: Conventions;
+    /** Stated assumptions — `'isolated system'`, `'weak field'`. */
+    readonly assumptions: readonly string[];
+    /**
+     * Assumption strings this context is INCOMPATIBLE with.
+     *
+     * Declared per context rather than inferred, because no rule in this repo
+     * can decide that `'weak field'` and `'strong field'` exclude each other
+     * from the strings alone. A guess here would manufacture refusals out of
+     * vocabulary rather than physics.
+     *
+     * Matching is exact string equality against another context's
+     * `assumptions`, and it is SYMMETRIC in effect: it is enough for one side
+     * to declare the exclusion.
+     */
+    readonly excludes: readonly string[];
+}
+/**
+ * A claim in a context.
+ *
+ * @internal
+ */
+export interface Statement {
+    /** `'statement-noether'`, `'statement-l1-maxwell'`, … */
+    readonly id: StatementId;
+    /** The load-bearing field — see the module note. */
+    readonly context: Context;
+    readonly model: ModelId;
+    /** OPTIONAL BY DESIGN — see the module note. Absent ⇒ named-and-linked only. */
+    readonly ast?: ExprNode;
+    /** `'dS = 0'` — the source form, always present even when `ast` is not. */
+    readonly sourceExpression: string;
+    /** Rendered form for the poster index. */
+    readonly display: string;
+}
+/** Why a set of contexts has NO union. @internal */
+export type NoUnionReason = 
+/** Two contexts DECLARE different values for a convention key. */
+'convention-conflict'
+/** One context excludes an assumption another one states. */
+ | 'contradictory-assumptions'
+/** Two contexts DECLARE different gauges or frames. */
+ | 'choice-conflict';
+/** The contexts DO pool, and this is the pooled context. @internal */
+export interface ContextUnionFormed {
+    readonly kind: 'union';
+    readonly context: Context;
+}
+/** The contexts do NOT pool, and this is why. @internal */
+export interface ContextUnionRefused {
+    readonly kind: 'no-union';
+    readonly reason: NoUnionReason;
+    /** Human-readable specifics: which key, which assumption. */
+    readonly detail: string;
+}
+/**
+ * The result of {@link contextUnion}: a pooled context, or an explicit refusal.
+ *
+ * @internal
+ */
+export type ContextUnionResult = ContextUnionFormed | ContextUnionRefused;
+/**
+ * The union of `contexts`, or an explicit refusal.
+ *
+ * Three gates, in this order; the FIRST refusal found is the one reported.
+ *
+ * 1. **Conventions.** Every PAIR is compared with `checkConventions`. Pairwise
+ *    rather than folded, because folding would compare each context against a
+ *    running merge and a merge has already lost which side declared what —
+ *    the exact information the `undefined`-is-unknown rule needs.
+ * 2. **Assumptions.** A context's `excludes` entry matching any context's
+ *    stated `assumption` refuses the pool. Blueprint v2 §5.2 step 2.
+ * 3. **Gauge / frame.** Two DECLARED and different values refuse; one declared
+ *    and one absent does not, mirroring gate 1's asymmetry.
+ *
+ * An empty list has no union: a union over nothing would be a context
+ * asserted about no claim, the same reason `boundPath` throws on an empty
+ * path. It is a `RangeError`, not a refusal, because it is a caller bug rather
+ * than a physical incompatibility.
+ *
+ * @throws RangeError when `contexts` is empty.
+ * @internal
+ */
+export declare function contextUnion(contexts: readonly Context[]): ContextUnionResult;
+/**
+ * The context union of a set of STATEMENTS, by id, resolved through `registry`.
+ *
+ * @throws RangeError if an id does not resolve. An unresolved id silently
+ *   dropped would narrow the union and could turn a refusal into a pool —
+ *   precisely the direction that manufactures a false claim.
+ * @internal
+ */
+export declare function statementContextUnion(ids: readonly StatementId[], registry: ReadonlyMap<StatementId, Statement>): ContextUnionResult;
+//# sourceMappingURL=statement.d.ts.map

package/dist/atlas/statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement.d.ts","sourceRoot":"","sources":["../../src/atlas/statement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,oEAAoE;AACpE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,OAAO;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,mFAAmF;IACnF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,oDAAoD;AACpD,MAAM,MAAM,aAAa;AACvB,kEAAkE;AAChE,qBAAqB;AACvB,6DAA6D;GAC3D,2BAA2B;AAC7B,uDAAuD;GACrD,iBAAiB,CAAC;AAEtB,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,2DAA2D;AAC3D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;AAe1E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,kBAAkB,CAwF7E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,SAAS,WAAW,EAAE,EAC3B,QAAQ,EAAE,WAAW,CAAC,WAAW,EAAE,SAAS,CAAC,GAC5C,kBAAkB,CAUpB"}

package/dist/atlas/statement.js

@@ -0,0 +1,176 @@
+/**
+ * Atlas Phase 3 — `Statement`, `Context`, and the CHECKED context union.
+ *
+ * A `Statement` is a claim IN A CONTEXT, not a string. Design note
+ * `docs/planning/Atlas-Phase-3-Design.md` §1: two statements that render
+ * identically can be claims about different things when their gauge, frame or
+ * assumption set differs, and the poster index will place exactly such pairs
+ * next to each other. `context` is therefore the reason this type exists at
+ * all rather than reusing `CanonicalEquation`.
+ *
+ * ## `ast?` is optional ON PURPOSE
+ *
+ * The poster's hidden supporting nodes — the action principle, Noether, the
+ * full Maxwell set, the Lorentz group, the central limit theorem — are
+ * valuable because they are NAMED and LINKED, not because they are evaluable.
+ * Requiring an `ast` would force either a fabricated encoding or their
+ * exclusion, and both are worse than an honest `sourceExpression` with no
+ * `ast` (design note §1). Do not make it required.
+ *
+ * ## The union is CHECKED, never computed
+ *
+ * {@link contextUnion} does not MERGE contexts. It asks whether a union
+ * EXISTS, and returns an explicit refusal when it does not. Two refusals
+ * matter, and neither is an error condition:
+ *
+ * 1. **Convention conflict** — delegated to `checkConventions`, whose contract
+ *    is that `undefined` means UNKNOWN and is never a mismatch. An absent
+ *    declaration must not read as agreement, so the asymmetry is preserved
+ *    here rather than re-derived.
+ * 2. **Contradictory assumptions** — Blueprint v2 §5.2 step 2: incompatible
+ *    assumptions are NEVER POOLED. A derivation whose premises assume mutually
+ *    exclusive conditions has no context union, therefore no composite.
+ *
+ * The result is a DISCRIMINATED UNION, mirroring `boundPath`'s no-claim
+ * (`./path-bound.ts`): a caller cannot read `.context` off a refusal, because
+ * a refusal has no `.context`. That is the whole point — the refusal is
+ * enforced by the type, so no caller can read a conclusion off a union that
+ * was never formed.
+ *
+ * Pure: no I/O, no registry reads.
+ *
+ * @module atlas/statement
+ */
+import { checkConventions } from './conventions.js';
+/** Distinct declared values of one optional choice field, across contexts. */
+function declaredChoices(contexts, key) {
+    const seen = new Set();
+    for (const c of contexts) {
+        const v = c[key];
+        if (v !== undefined)
+            seen.add(v);
+    }
+    return [...seen];
+}
+/**
+ * The union of `contexts`, or an explicit refusal.
+ *
+ * Three gates, in this order; the FIRST refusal found is the one reported.
+ *
+ * 1. **Conventions.** Every PAIR is compared with `checkConventions`. Pairwise
+ *    rather than folded, because folding would compare each context against a
+ *    running merge and a merge has already lost which side declared what —
+ *    the exact information the `undefined`-is-unknown rule needs.
+ * 2. **Assumptions.** A context's `excludes` entry matching any context's
+ *    stated `assumption` refuses the pool. Blueprint v2 §5.2 step 2.
+ * 3. **Gauge / frame.** Two DECLARED and different values refuse; one declared
+ *    and one absent does not, mirroring gate 1's asymmetry.
+ *
+ * An empty list has no union: a union over nothing would be a context
+ * asserted about no claim, the same reason `boundPath` throws on an empty
+ * path. It is a `RangeError`, not a refusal, because it is a caller bug rather
+ * than a physical incompatibility.
+ *
+ * @throws RangeError when `contexts` is empty.
+ * @internal
+ */
+export function contextUnion(contexts) {
+    if (contexts.length === 0) {
+        throw new RangeError('contextUnion: no contexts; a union over nothing states nothing');
+    }
+    // ── Gate 1: no DECLARED convention pair may disagree ──────────────────────
+    for (let i = 0; i < contexts.length; i++) {
+        for (let j = i + 1; j < contexts.length; j++) {
+            const clash = checkConventions(contexts[i].conventions, contexts[j].conventions);
+            if (clash.length > 0) {
+                return {
+                    kind: 'no-union',
+                    reason: 'convention-conflict',
+                    detail: `contexts ${i} and ${j} declare different values for ` +
+                        `${clash.map((k) => `'${k}'`).join(', ')}; they do not pool`,
+                };
+            }
+        }
+    }
+    // ── Gate 2: incompatible assumptions are NEVER pooled ─────────────────────
+    const stated = new Map();
+    for (let i = 0; i < contexts.length; i++) {
+        for (const a of contexts[i].assumptions) {
+            if (!stated.has(a))
+                stated.set(a, i);
+        }
+    }
+    for (let i = 0; i < contexts.length; i++) {
+        for (const x of contexts[i].excludes) {
+            const at = stated.get(x);
+            if (at !== undefined) {
+                return {
+                    kind: 'no-union',
+                    reason: 'contradictory-assumptions',
+                    detail: `context ${i} excludes '${x}', which context ${at} assumes; ` +
+                        'incompatible assumptions are never pooled',
+                };
+            }
+        }
+    }
+    // ── Gate 3: a declared gauge or frame may not be contradicted ─────────────
+    for (const key of ['gauge', 'frame']) {
+        const values = declaredChoices(contexts, key);
+        if (values.length > 1) {
+            return {
+                kind: 'no-union',
+                reason: 'choice-conflict',
+                detail: `the contexts declare ${values.length} different ${key}s ` +
+                    `(${values.map((v) => `'${v}'`).join(', ')}); they do not pool`,
+            };
+        }
+    }
+    // ── The pool ──────────────────────────────────────────────────────────────
+    // Conventions merge by KEY rather than by object, so a context silent on a
+    // key inherits another's declaration instead of erasing it. Gate 1 has
+    // already proved no two declarations disagree, so the order of assignment
+    // cannot change the result.
+    const conventions = {};
+    for (const c of contexts) {
+        for (const [k, v] of Object.entries(c.conventions ?? {})) {
+            if (v !== undefined)
+                conventions[k] = v;
+        }
+    }
+    const quantityTypes = [...new Set(contexts.flatMap((c) => c.quantityTypes ?? []))];
+    const gauge = declaredChoices(contexts, 'gauge')[0];
+    const frame = declaredChoices(contexts, 'frame')[0];
+    return {
+        kind: 'union',
+        context: {
+            ...(quantityTypes.length > 0 ? { quantityTypes } : {}),
+            ...(gauge !== undefined ? { gauge } : {}),
+            ...(frame !== undefined ? { frame } : {}),
+            ...(Object.keys(conventions).length > 0
+                ? { conventions: conventions }
+                : {}),
+            assumptions: [...stated.keys()],
+            excludes: [...new Set(contexts.flatMap((c) => c.excludes))],
+        },
+    };
+}
+/**
+ * The context union of a set of STATEMENTS, by id, resolved through `registry`.
+ *
+ * @throws RangeError if an id does not resolve. An unresolved id silently
+ *   dropped would narrow the union and could turn a refusal into a pool —
+ *   precisely the direction that manufactures a false claim.
+ * @internal
+ */
+export function statementContextUnion(ids, registry) {
+    const contexts = [];
+    for (const id of ids) {
+        const s = registry.get(id);
+        if (s === undefined) {
+            throw new RangeError(`statementContextUnion: unknown statement '${id}'`);
+        }
+        contexts.push(s.context);
+    }
+    return contextUnion(contexts);
+}
+//# sourceMappingURL=statement.js.map

package/dist/atlas/statement.js.map

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