universal-physics-tensor 0.45.2 → 0.47.0

package/dist/atlas/types.d.ts

@@ -0,0 +1,325 @@
+/**
+ * Atlas Phase 0 pilot types (oscillator pilot).
+ *
+ * Fixed by `docs/planning/Atlas-Phase-0-Design.md` §2 and the implementation
+ * plan's §"S0 types" block, implemented here verbatim.
+ *
+ * **These are throwaway pilot types** (design note §4). If Phase 1's
+ * relation-contract work disagrees with any of them, the Phase 0 type is
+ * replaced, not adapted: nothing atlas-side is public before Phase 6 and the
+ * only consumers are Phase 0's own tests.
+ *
+ * Name note: the probe's `RelationKind` and `AuditState` are NOT shadowed —
+ * this sprint uses `RelationType` and defines no `AuditState`.
+ * `src/composition/bridge-prediction.ts` has a module-local, unexported
+ * `interface Regime` for tensor-cell placement; different concept, no
+ * import collision.
+ *
+ * @module atlas/types
+ */
+import type { PiGroup } from '../dimensional/buckingham.js';
+/** The relation a bridge asserts between its premises and its conclusion. @public */
+export type RelationType = 'derivation' | 'exact-equivalence' | 'restriction' | 'approximation' | 'coarse-graining' | 'analytic-continuation' | 'structural-analogy' | 'deformation-quantization';
+/** What kind of support a record carries. Carried only if its witness passes. @public */
+export type EvidenceTag = 'proposed' | 'reviewed' | 'dimension-checked' | 'convention-checked' | 'symbolically-checked' | 'numerically-supported' | 'formally-proved' | 'empirically-supported' | 'contradicted' | 'unresolved';
+/**
+ * Every `EvidenceTag`, in declaration order, so a report can name all of them.
+ *
+ * Lives HERE, not in `coverage.ts` (which re-exports it), because
+ * `tests/atlas/derived-tag-literals.test.ts` allows the literals
+ * `'formally-proved'` and `'symbolically-checked'` under `src/atlas/` in
+ * exactly two files: this one and `derive-evidence.ts`. A tag that can only be
+ * DERIVED must not be spellable anywhere a record could hand-set it.
+ *
+ * @internal
+ */
+export declare const ALL_EVIDENCE_TAGS: readonly ["proposed", "reviewed", "dimension-checked", "convention-checked", "symbolically-checked", "numerically-supported", "formally-proved", "empirically-supported", "contradicted", "unresolved"];
+/**
+ * How a formal reference's statement was checked against the physics it claims
+ * to state (Phase 4 design note §3).
+ *
+ * - `'two-formalizers'` — two people formalized it independently and agreed.
+ * - `'back-translation'` — a reviewer who had not seen the source translated
+ *   the formal statement back to prose and it matched.
+ * - `'sanity-lemmas'` — the statement was instantiated on known cases in
+ *   `tests/atlas/formal-sanity.test.ts`.
+ * - `'unreviewed'` — recorded, not checked. **Earns no tag, by construction.**
+ *
+ * @internal
+ */
+export type FormalFidelity = 'two-formalizers' | 'back-translation' | 'sanity-lemmas' | 'unreviewed';
+/**
+ * A machine-checked counterpart of a record's claim in a proof assistant.
+ *
+ * A proof of the WRONG statement proves nothing about the physics, so the
+ * reference carries its `fidelity` — how anyone knows the formal statement says
+ * what the bridge says. `formally-proved` is derived from it and never set.
+ *
+ * @internal
+ */
+export interface FormalRef {
+    readonly system: 'lean4-physlib' | 'other';
+    /** The formal statement's name or text, as it appears in `system`. */
+    readonly statement: string;
+    /** The library version or commit the statement was checked against. */
+    readonly version: string;
+    /** Axioms the proof depends on beyond the system's core. */
+    readonly axioms: readonly string[];
+    readonly fidelity: FormalFidelity;
+}
+/** Whether the limit a bridge takes is regular or singular. @public */
+export type LimitCharacter = 'regular' | 'singular' | 'unknown';
+/**
+ * One inequality on a regime coordinate. The coordinate is either a π-group
+ * `buckinghamPi` produced from the family's dimensioned parameters (keyed by
+ * `PiGroup.formula`), or a dimensionless INPUT of the model (an initial datum
+ * such as θ0, a wavenumber-lattice product qa) declared as a
+ * `DimensionalVariable` with the zero dimension, which is its own trivial
+ * group. Derived quantities such as ζ = ½ (m k / b²)^(−½) are NOT groups:
+ * write the inequality on the group (`m k / b² > 1/4`) and record the display
+ * alias in `alias`.
+ *
+ * @public
+ */
+export interface RegimeInequality {
+    /** `PiGroup.formula`, or the dimensionless input's name. */
+    readonly group: string;
+    readonly op: '<' | '<=' | '>' | '>=';
+    readonly bound: number;
+    /** `'ζ < 1'` — for display only, never evaluated. */
+    readonly alias?: string;
+}
+/** Where in parameter space a model or bridge is claimed to apply. @public */
+export interface Regime {
+    /** `'oscillators'`. */
+    readonly family: string;
+    readonly inequalities: readonly RegimeInequality[];
+    /** Traceability back to the dimension matrix, keyed by `PiGroup.formula`. */
+    readonly groupDefinitions: Readonly<Record<string, PiGroup>>;
+}
+/** A Lipschitz-plus-offset error bound with a mandatory horizon. @public */
+export interface ApproximationBound {
+    /** Lipschitz constant of the map, in the stated norm. */
+    readonly K: number;
+    /**
+     * Uniform error, same norm: the SUPREMUM OF THE BOUND OVER THE WHOLE
+     * DECLARED DOMAIN (`domain` / `parameterRange`), never a sample of it at
+     * one convenient fixture point.
+     *
+     * A parameter-dependent bound evaluated at a fixture is not a bound on the
+     * domain it claims: the record would read as covering every admissible
+     * parameter while holding only at the one point it was measured. When the
+     * supremum is approached but not attained at an open edge of the domain,
+     * `delta` is that supremum, and `deltaAt` is what a caller uses to get the
+     * tighter value at its own point.
+     */
+    readonly delta: number;
+    /**
+     * `'relative period error, normalized by the value of the reduced model'`,
+     * `'sup |x − x_reduced| for t ≥ 5 m/b'`, …
+     *
+     * A RELATIVE norm divides |exact − reduced| by the REDUCED model's value, and
+     * says so in this string. The other reading, by the exact value, gives a
+     * different number: at x = ck/ω₀ = 1 the non-relativistic kinetic frequency
+     * exceeds the exact Klein–Gordon one by 20.7% of the exact value, and by
+     * 17.2% of its own value. `tests/atlas/relative-norm-convention.test.ts` recomputes
+     * every relative `delta` from closed-form physics and pins the convention.
+     */
+    readonly norm: string;
+    /** Where the bound holds. */
+    readonly domain: string;
+    /** MANDATORY prose horizon: `'t ≪ 16 T0/θ0²'`. */
+    readonly horizon: string;
+    /** MANDATORY machine form of `horizon`: true while the bound is claimed to hold. */
+    readonly horizonHolds: (t: number, params: Readonly<Record<string, number>>) => boolean;
+    /**
+     * MACHINE FORM OF `delta`, mirroring what `horizonHolds` is to `horizon`:
+     * the bound AT A POINT of the declared domain, in the same norm.
+     *
+     * `horizon` had a machine counterpart and `delta` had none, so an
+     * implementer holding a correct parameter-dependent bound could only freeze
+     * it at a single point and hope the reader noticed. `deltaAt` is where that
+     * dependence goes; `delta` stays the supremum over the domain, and
+     * `deltaAt(p) <= delta` for every admissible `p`.
+     *
+     * Optional on the interface so a genuinely constant bound need not restate
+     * itself, and so `coarse-graining` bounds are unaffected; MANDATORY for an
+     * `approximation`, enforced at admission by `admitApproximation`.
+     */
+    readonly deltaAt?: (params: Readonly<Record<string, number>>) => number;
+    /**
+     * What `deltaAt` rests on. `'closed-form'`: it returns the EXACT error in
+     * closed form, so it is a proven bound, holding with equality. `'numerically-
+     * supported'`: a formula that witnesses support numerically but no proof
+     * covers. `upt path` prints a point bound only when every step is closed-form.
+     */
+    readonly deltaAtBasis?: 'closed-form' | 'numerically-supported';
+    /** `'θ0 ≤ 0.5 rad'`. */
+    readonly parameterRange?: string;
+    readonly limitCharacter: LimitCharacter;
+    /**
+     * What the error is uniform in.
+     *
+     * `null` means NOT YET ANALYSED. That is a legitimate recorded state:
+     * `makeApproximation` accepts it, and the check lives at use (`boundPath`),
+     * not at construction. An empty array means the same thing — a universal
+     * over nothing must not count as analysed. A non-empty array names the
+     * scopes the error is uniform in. A variable a side condition says the
+     * error is NOT uniform in is not listed.
+     */
+    readonly uniformity: readonly string[] | null;
+}
+/** A named check that supports a record, and the test file that runs it. @public */
+export interface Witness {
+    /** `'W7b'`. */
+    readonly id: string;
+    readonly kind: 'symbolic' | 'numeric' | 'formal';
+    /** Test file path. */
+    readonly test: string;
+    /** As stated in the brief. */
+    readonly tolerance?: string;
+}
+/**
+ * `AtlasModel` MOVED to `./model.ts` in Phase 3, where it gained
+ * `boundaryData?`, `initialData?` and `symmetryGroup?`. It is NOT re-exported
+ * from here: `model.ts` imports `Regime` from this module, so a re-export
+ * would close a cycle `bun run docs:deps` reports. Import it from
+ * `./model.js`.
+ */
+/** A case a bridge does NOT cover, and the witness that shows it. @public */
+export interface Counterexample {
+    readonly description: string;
+    /** `'W2b'`. */
+    readonly witness: string;
+}
+/** Field set = Blueprint v2 §3.1 Bridge record + citations. @internal */
+export interface AtlasBridge {
+    /** `'ab-spring-lc'`. */
+    readonly id: string;
+    readonly relation: RelationType;
+    /** Model ids (many). */
+    readonly premises: readonly string[];
+    /** Model id (one). */
+    readonly conclusion: string;
+    /** `'u = x/x0 (or q/q0), τ = ω0 t'`. */
+    readonly transformation: string;
+    /** `'x = x0 u, t = τ/ω0'` — required for `exact-equivalence`. */
+    readonly inverse?: string;
+    readonly preserves: readonly string[];
+    readonly doesNotPreserve: readonly string[];
+    readonly sideConditions: readonly string[];
+    /** Required iff `relation === 'approximation'`. */
+    readonly bound?: ApproximationBound;
+    readonly regime: Regime;
+    readonly counterexamples: readonly Counterexample[];
+    readonly evidence: ReadonlySet<EvidenceTag>;
+    readonly witnesses: readonly Witness[];
+    readonly citations: readonly string[];
+    readonly reviewStatus: 'proposed' | 'reviewed';
+    /**
+     * A machine-checked counterpart, when one genuinely exists (Phase 4, S4.6).
+     * Absent is the honest default: a statement with no checked counterpart gets
+     * no reference rather than an `'unreviewed'` placeholder.
+     */
+    readonly formalRef?: FormalRef;
+}
+/** A claimed bridge the atlas records as REJECTED, with the reason. @public */
+export interface AtlasRejection {
+    /** `'ax-cubic-spring-lc'`. */
+    readonly id: string;
+    readonly claimed: RelationType;
+    readonly premises: readonly string[];
+    readonly conclusion: string;
+    readonly reason: string;
+    /** `'beta·x0²·k⁻¹'`. */
+    readonly survivingGroup: string;
+    readonly witnesses: readonly Witness[];
+}
+/**
+ * The relation a record asserts, as a DISCRIMINATED UNION over `RelationType`.
+ *
+ * This is the Phase 1 overlay (design note §1.2, "One overlay, not two"). Its
+ * purpose is to move `AtlasBridge`'s two CONDITIONAL requirements — written
+ * there only as doc comments — into the type system:
+ *
+ *   - `approximation` REQUIRES `bound`, and `ApproximationBound` itself
+ *     mandates `horizon` + `horizonHolds`. So an approximation without a
+ *     machine horizon is a COMPILE error, not a runtime one.
+ *   - `exact-equivalence` REQUIRES `inverse`.
+ *
+ * Deliberately conservative elsewhere. The design note §2.2 names the fields
+ * the other members WOULD need (an analyticity domain, a checkable
+ * `preserves` set, an ħ-order) and records that none of them exists before
+ * Phase 2. Inventing them here would encode claims the data cannot support,
+ * so every other member carries only `transformation`.
+ *
+ * @internal
+ */
+export type RelationContract = {
+    readonly type: 'derivation';
+    readonly transformation: string;
+} | {
+    readonly type: 'exact-equivalence';
+    readonly transformation: string;
+    /** REQUIRED: `'x = x0 u, t = τ/ω0'`. An equivalence without an inverse is not one. */
+    readonly inverse: string;
+} | {
+    readonly type: 'restriction';
+    readonly transformation: string;
+} | {
+    readonly type: 'approximation';
+    readonly transformation: string;
+    /** REQUIRED, and mandates its own machine horizon. */
+    readonly bound: ApproximationBound;
+} | {
+    readonly type: 'coarse-graining';
+    readonly transformation: string;
+    /** Optional: errors accumulate through `composeBounds` when present. */
+    readonly bound?: ApproximationBound;
+} | {
+    readonly type: 'analytic-continuation';
+    readonly transformation: string;
+} | {
+    readonly type: 'structural-analogy';
+    readonly transformation: string;
+} | {
+    readonly type: 'deformation-quantization';
+    readonly transformation: string;
+};
+/**
+ * Sign and unit choices a record depends on. Every field is optional, and a
+ * field is only meaningful when the record actually depends on that choice.
+ *
+ * Non-emptiness matters downstream: design note §3 requires `conventions` to
+ * declare AT LEAST ONE field before `convention-checked` can be derived,
+ * because `[].every(…)` is vacuously true and would hand out a free tag.
+ *
+ * @internal
+ */
+export interface Conventions {
+    /** First law as `dU = Q − W` or `dU = Q + W`. */
+    readonly heatWorkSign?: 'Q-W' | 'Q+W';
+    readonly metricSignature?: '-+++' | '+---';
+    readonly fourierNormalization?: 'unitary' | 'physics' | 'none';
+    readonly unitSystem?: 'SI' | 'gaussian' | 'natural';
+    readonly capacitorChargeSign?: '+' | '-';
+}
+/** Thrown when an `ApproximationBound` is built without its machine horizon. @public */
+export declare class MissingHorizonError extends Error {
+}
+/**
+ * Thrown when an `approximation` bound is built without the machine form of
+ * its `delta`.
+ *
+ * A distinct type rather than a reuse of `MissingHorizonError`: the horizon of
+ * such a record is present and correct, and reporting a missing horizon for it
+ * would send the next reader to the one field that is not the defect.
+ *
+ * @internal
+ */
+export declare class MissingDeltaAtError extends Error {
+}
+/** Thrown when a bound path has no Lipschitz constant anywhere but at its end. @public */
+export declare class MissingLipschitzError extends Error {
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/atlas/types.js

@@ -0,0 +1,61 @@
+/**
+ * Atlas Phase 0 pilot types (oscillator pilot).
+ *
+ * Fixed by `docs/planning/Atlas-Phase-0-Design.md` §2 and the implementation
+ * plan's §"S0 types" block, implemented here verbatim.
+ *
+ * **These are throwaway pilot types** (design note §4). If Phase 1's
+ * relation-contract work disagrees with any of them, the Phase 0 type is
+ * replaced, not adapted: nothing atlas-side is public before Phase 6 and the
+ * only consumers are Phase 0's own tests.
+ *
+ * Name note: the probe's `RelationKind` and `AuditState` are NOT shadowed —
+ * this sprint uses `RelationType` and defines no `AuditState`.
+ * `src/composition/bridge-prediction.ts` has a module-local, unexported
+ * `interface Regime` for tensor-cell placement; different concept, no
+ * import collision.
+ *
+ * @module atlas/types
+ */
+/**
+ * Every `EvidenceTag`, in declaration order, so a report can name all of them.
+ *
+ * Lives HERE, not in `coverage.ts` (which re-exports it), because
+ * `tests/atlas/derived-tag-literals.test.ts` allows the literals
+ * `'formally-proved'` and `'symbolically-checked'` under `src/atlas/` in
+ * exactly two files: this one and `derive-evidence.ts`. A tag that can only be
+ * DERIVED must not be spellable anywhere a record could hand-set it.
+ *
+ * @internal
+ */
+export const ALL_EVIDENCE_TAGS = [
+    'proposed',
+    'reviewed',
+    'dimension-checked',
+    'convention-checked',
+    'symbolically-checked',
+    'numerically-supported',
+    'formally-proved',
+    'empirically-supported',
+    'contradicted',
+    'unresolved',
+];
+/** Thrown when an `ApproximationBound` is built without its machine horizon. @public */
+export class MissingHorizonError extends Error {
+}
+/**
+ * Thrown when an `approximation` bound is built without the machine form of
+ * its `delta`.
+ *
+ * A distinct type rather than a reuse of `MissingHorizonError`: the horizon of
+ * such a record is present and correct, and reporting a missing horizon for it
+ * would send the next reader to the one field that is not the defect.
+ *
+ * @internal
+ */
+export class MissingDeltaAtError extends Error {
+}
+/** Thrown when a bound path has no Lipschitz constant anywhere but at its end. @public */
+export class MissingLipschitzError extends Error {
+}
+//# sourceMappingURL=types.js.map

package/dist/atlas/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/atlas/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AA4BH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,UAAU;IACV,UAAU;IACV,mBAAmB;IACnB,oBAAoB;IACpB,sBAAsB;IACtB,uBAAuB;IACvB,iBAAiB;IACjB,uBAAuB;IACvB,cAAc;IACd,YAAY;CAC6B,CAAC;AA0R5C,wFAAwF;AACxF,MAAM,OAAO,mBAAoB,SAAQ,KAAK;CAAG;AAEjD;;;;;;;;;GASG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;CAAG;AAEjD,0FAA0F;AAC1F,MAAM,OAAO,qBAAsB,SAAQ,KAAK;CAAG"}

package/dist/atlas/waves/bridges-closure.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Atlas Phase 4 — the three wave-family bridges added to close Sprint 4's
+ * "≥ 20 bridges" exit criterion.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §4 (Sprint 4 closure).
+ *
+ * | Bridge | Relation | Witnesses |
+ * |---|---|---|
+ * | Klein–Gordon → free Schrödinger | `approximation` (ck/ω₀ → 0) | WS5 (convergence), WS5b |
+ * | Klein–Gordon → spring | `restriction` (uniform mode) | WS6 (convergence) |
+ * | stiff string → string | `approximation` (EIk²/F → 0) | WS7 (convergence), WS7b |
+ *
+ * Two of these END in other families (`model-schrodinger-free` in diffusion,
+ * `model-spring` in oscillators): the atlas is one graph, and
+ * `tests/atlas/families.test.ts` resolves endpoints across all of it.
+ *
+ * @module atlas/waves/bridges-closure
+ */
+import type { AtlasBridge } from '../types.js';
+/** Domain edge of the non-relativistic limit: ck/ω₀ ≤ 0.1. @internal */
+export declare const KG_NR_MAX_X = 0.1;
+/** Domain edge of the flexible-string limit: β = EIk²/F ≤ 0.01. @internal */
+export declare const STIFF_MAX_BETA = 0.01;
+/**
+ * Bridge: Klein–Gordon → free Schrödinger, the non-relativistic limit.
+ *
+ * Factor out the rest-frequency phase e^{−iω₀t}; the remaining envelope obeys
+ * the free Schrödinger equation with ħ/m ↦ c²/ω₀ (that is, mc² = ħω₀).
+ *
+ * @internal
+ */
+export declare const BRIDGE_KG_SCHRODINGER: AtlasBridge;
+/** Bridge: Klein–Gordon → spring, restricted to the spatially uniform mode. @internal */
+export declare const BRIDGE_KG_OSCILLATOR: AtlasBridge;
+/** Bridge: stiff string → flexible string, as bending stiffness → 0. @internal */
+export declare const BRIDGE_STIFF_STRING: AtlasBridge;
+/** The wave-family closure bridges. @internal */
+export declare const WAVE_CLOSURE_BRIDGES: readonly AtlasBridge[];
+//# sourceMappingURL=bridges-closure.d.ts.map

package/dist/atlas/waves/bridges-closure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridges-closure.d.ts","sourceRoot":"","sources":["../../../src/atlas/waves/bridges-closure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C,wEAAwE;AACxE,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,6EAA6E;AAC7E,eAAO,MAAM,cAAc,OAAO,CAAC;AAWnC;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,WA+EnC,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,oBAAoB,EAAE,WA+BlC,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,EAAE,WAqEjC,CAAC;AAEF,iDAAiD;AACjD,eAAO,MAAM,oBAAoB,EAAE,SAAS,WAAW,EAItD,CAAC"}

package/dist/atlas/waves/bridges-closure.js

@@ -0,0 +1,226 @@
+/**
+ * Atlas Phase 4 — the three wave-family bridges added to close Sprint 4's
+ * "≥ 20 bridges" exit criterion.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §4 (Sprint 4 closure).
+ *
+ * | Bridge | Relation | Witnesses |
+ * |---|---|---|
+ * | Klein–Gordon → free Schrödinger | `approximation` (ck/ω₀ → 0) | WS5 (convergence), WS5b |
+ * | Klein–Gordon → spring | `restriction` (uniform mode) | WS6 (convergence) |
+ * | stiff string → string | `approximation` (EIk²/F → 0) | WS7 (convergence), WS7b |
+ *
+ * Two of these END in other families (`model-schrodinger-free` in diffusion,
+ * `model-spring` in oscillators): the atlas is one graph, and
+ * `tests/atlas/families.test.ts` resolves endpoints across all of it.
+ *
+ * @module atlas/waves/bridges-closure
+ */
+import { ACTION, FORCE, FREQUENCY, MASS, VELOCITY } from '../../dimensional/types.js';
+import { makeApproximation } from '../oscillators/bridges-limits.js';
+import { SPRING_CONSTANT } from '../oscillators/dimensions.js';
+import { deriveRegimeGroups } from '../regime.js';
+import { FLEXURAL_RIGIDITY, LINEAR_DENSITY, WAVENUMBER, WAVES_FAMILY_NAME } from './models.js';
+import { kgNonrelativisticError, stiffStringPhaseError } from './numerics.js';
+const TEST = 'tests/atlas/closure.test.ts';
+/** Domain edge of the non-relativistic limit: ck/ω₀ ≤ 0.1. @internal */
+export const KG_NR_MAX_X = 0.1;
+/** Domain edge of the flexible-string limit: β = EIk²/F ≤ 0.01. @internal */
+export const STIFF_MAX_BETA = 0.01;
+const regime = (parameters, inequalities) => ({
+    family: WAVES_FAMILY_NAME,
+    inequalities,
+    groupDefinitions: deriveRegimeGroups(WAVES_FAMILY_NAME, parameters, []),
+});
+/**
+ * Bridge: Klein–Gordon → free Schrödinger, the non-relativistic limit.
+ *
+ * Factor out the rest-frequency phase e^{−iω₀t}; the remaining envelope obeys
+ * the free Schrödinger equation with ħ/m ↦ c²/ω₀ (that is, mc² = ħω₀).
+ *
+ * @internal
+ */
+export const BRIDGE_KG_SCHRODINGER = {
+    id: 'ab-kg-schrodinger',
+    relation: 'approximation',
+    premises: ['model-klein-gordon'],
+    conclusion: 'model-schrodinger-free',
+    transformation: 'u = Re(ψ e^{−iω₀t}) with ψ slowly varying; ħ/m ↦ c²/ω₀: ω − ω₀ = ω₀(√(1 + x²) − 1) → ω₀x²/2, x = ck/ω₀',
+    preserves: ['the kinetic frequency ħk²/(2m) to O(x²)', 'linearity'],
+    doesNotPreserve: [
+        'the rest-frequency phase e^{−iω₀t}',
+        'the negative-frequency branch',
+        'relativistic dispersion at x ≳ 1',
+    ],
+    sideConditions: ['non-relativistic modes: x = ck/ω₀ ≤ 0.1', 'the bound is a FREQUENCY error, not uniform in time'],
+    bound: makeApproximation({
+        K: 1,
+        delta: kgNonrelativisticError(KG_NR_MAX_X),
+        deltaAt: (p) => {
+            const { c, k, omega0 } = p;
+            if (c === undefined || k === undefined || omega0 === undefined)
+                return Number.NaN;
+            return kgNonrelativisticError((c * k) / omega0);
+        },
+        deltaAtBasis: 'closed-form',
+        norm: 'relative error of the kinetic frequency ω − ω₀, normalized by the value of the reduced model',
+        domain: 'x = ck/ω₀ ≤ 0.1',
+        horizon: 't ≪ π/(δ ω₀ x²): the kinetic-phase drift reaches π/2; machine form t < π/(δ ω₀ x²)',
+        horizonHolds: (t, p) => {
+            const { c, k, omega0 } = p;
+            if (c === undefined || k === undefined || omega0 === undefined)
+                return false;
+            const x = (c * k) / omega0;
+            const delta = kgNonrelativisticError(x);
+            if (!Number.isFinite(delta))
+                return false;
+            if (delta === 0)
+                return true;
+            return t < Math.PI / (delta * omega0 * x * x);
+        },
+        parameterRange: 'x = ck/ω₀ ≤ 0.1',
+        limitCharacter: 'regular',
+        // A frequency error. The record says it is not uniform in time.
+        uniformity: ['kinetic frequency of one mode, for x = ck/ω₀ ≤ 0.1'],
+    }),
+    regime: regime([
+        { name: 'c', dim: VELOCITY },
+        { name: 'omega0', dim: FREQUENCY },
+        { name: 'k', dim: WAVENUMBER },
+        { name: 'hbar', dim: ACTION },
+        { name: 'm', dim: MASS },
+    ], [{ group: 'c · omega0^-1 · k', op: '<=', bound: KG_NR_MAX_X, alias: 'ck/ω₀ ≤ 0.1' }]),
+    counterexamples: [
+        {
+            description: 'At x = ck/ω₀ = 1 the non-relativistic kinetic frequency ω₀/2 is 20.7% above the exact ' +
+                'ω₀(√2 − 1), which is 17.2% of its own value (the normalization of delta): the limit is a ' +
+                'long-wavelength statement.',
+            witness: 'WS5b',
+        },
+    ],
+    evidence: new Set(['proposed', 'numerically-supported']),
+    witnesses: [
+        {
+            id: 'WS5',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: 'kinetic-frequency error below 1e-3 at x = 0.05; falls ≈4× per halving of x',
+        },
+        {
+            id: 'WS5b',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: 'relative error 3 − 2√2 = 0.1716 at x = 1, normalized by the reduced value',
+        },
+    ],
+    citations: [
+        'Greiner, Relativistic Quantum Mechanics: Wave Equations - Ch. 1, the Klein-Gordon equation and its non-relativistic limit',
+    ],
+    reviewStatus: 'proposed',
+};
+/** Bridge: Klein–Gordon → spring, restricted to the spatially uniform mode. @internal */
+export const BRIDGE_KG_OSCILLATOR = {
+    id: 'ab-kg-oscillator',
+    relation: 'restriction',
+    premises: ['model-klein-gordon'],
+    conclusion: 'model-spring',
+    transformation: 'u(x, t) = u(t): u_tt = −ω₀² u; u ↦ x, ω₀² ↦ k/m',
+    preserves: ['the k = 0 mode exactly', 'the frequency ω₀'],
+    doesNotPreserve: ['every mode with k ≠ 0', 'spatial structure'],
+    sideConditions: ['spatially uniform initial data', 'periodic or infinite domain (no boundary forcing)'],
+    regime: regime([
+        { name: 'omega0', dim: FREQUENCY },
+        { name: 'm', dim: MASS },
+        { name: 'k', dim: SPRING_CONSTANT },
+    ], []),
+    counterexamples: [],
+    evidence: new Set(['proposed', 'numerically-supported']),
+    witnesses: [
+        {
+            id: 'WS6',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: 'uniform leapfrog field within 3e-4 of cos(ω₀t) at 100 steps (ω₀ = 2, t = 3); ≈4× per halving',
+        },
+    ],
+    citations: [
+        'Whitham, Linear and Nonlinear Waves - §11.1, dispersive waves and the Klein-Gordon equation',
+    ],
+    reviewStatus: 'proposed',
+};
+/** Bridge: stiff string → flexible string, as bending stiffness → 0. @internal */
+export const BRIDGE_STIFF_STRING = {
+    id: 'ab-stiff-string',
+    relation: 'approximation',
+    premises: ['model-stiff-string'],
+    conclusion: 'model-string',
+    transformation: 'drop EI y_xxxx: ω² = (F/μ)k² + (EI/μ)k⁴ → (F/μ)k²',
+    preserves: ['the wave speed √(F/μ) for long wavelengths', 'harmonic partials to O(β)'],
+    doesNotPreserve: ['inharmonicity: high partials of a stiff string are sharp', 'the fourth-order boundary conditions'],
+    sideConditions: ['β = EIk²/F ≤ 0.01', 'the bound is a PHASE-VELOCITY error, not uniform in time'],
+    bound: makeApproximation({
+        K: 1,
+        delta: stiffStringPhaseError(1, STIFF_MAX_BETA, 1),
+        deltaAt: (p) => stiffStringPhaseError(p['F'] ?? Number.NaN, p['EI'] ?? Number.NaN, p['k'] ?? Number.NaN),
+        deltaAtBasis: 'closed-form',
+        norm: 'relative phase-velocity error of a Fourier mode, normalized by the value of the reduced model',
+        domain: 'β = EIk²/F ≤ 0.01',
+        horizon: 't ≪ π/(2 c k δ): the phase drift reaches π/2; machine form t < π/(2 √(F/μ) k δ)',
+        horizonHolds: (t, p) => {
+            const { F, EI, k, mu } = p;
+            if (F === undefined || EI === undefined || k === undefined || mu === undefined)
+                return false;
+            const delta = stiffStringPhaseError(F, EI, k);
+            if (!Number.isFinite(delta))
+                return false;
+            if (delta === 0)
+                return true;
+            return t < Math.PI / (2 * Math.sqrt(F / mu) * k * delta);
+        },
+        parameterRange: 'β = EIk²/F ≤ 0.01',
+        limitCharacter: 'regular',
+        // A phase-velocity error. The record says it is not uniform in time.
+        uniformity: ['phase velocity of one Fourier mode, for β = EIk²/F ≤ 0.01'],
+    }),
+    regime: regime([
+        { name: 'F', dim: FORCE },
+        { name: 'mu', dim: LINEAR_DENSITY },
+        { name: 'EI', dim: FLEXURAL_RIGIDITY },
+        { name: 'k', dim: WAVENUMBER },
+    ], 
+    // The derived group is F/(EIk²) = 1/β, so β ≤ 0.01 is F/(EIk²) ≥ 100.
+    [{ group: 'F · EI^-1 · k^-2', op: '>=', bound: 1 / STIFF_MAX_BETA, alias: 'β = EIk²/F ≤ 0.01' }]),
+    counterexamples: [
+        {
+            description: 'The partials of a stiff string are sharp: at β = 1 the phase velocity is √2 times the ' +
+                'flexible-string value, the inharmonicity piano tuners stretch octaves to accommodate.',
+            witness: 'WS7b',
+        },
+    ],
+    evidence: new Set(['proposed', 'numerically-supported']),
+    witnesses: [
+        {
+            id: 'WS7',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: 'phase velocity within 0.15 of √(F/μ) = 100 at k = 5 (EI/F = 1e-4); ≈4× per halving of k',
+        },
+        {
+            id: 'WS7b',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: 'relative phase error √2 − 1 at β = 1',
+        },
+    ],
+    citations: [
+        'Fletcher, J. Acoust. Soc. Am. 36 (1964) 203 - Normal vibration frequencies of a stiff piano string',
+    ],
+    reviewStatus: 'proposed',
+};
+/** The wave-family closure bridges. @internal */
+export const WAVE_CLOSURE_BRIDGES = [
+    BRIDGE_KG_SCHRODINGER,
+    BRIDGE_KG_OSCILLATOR,
+    BRIDGE_STIFF_STRING,
+];
+//# sourceMappingURL=bridges-closure.js.map