universal-physics-tensor 0.45.2 → 0.47.0

package/dist/atlas/oscillators/bridges-coarse.js

@@ -0,0 +1,146 @@
+/**
+ * Bridge 5 of the oscillator pilot: the COARSE-GRAINING bridge from the
+ * discrete mass–spring chain to the 1-D wave equation.
+ *
+ * This is the only Phase 0 bridge whose relation is `coarse-graining`: the
+ * reduction map `u_n(t) ↦ u(x = na, t)` is not invertible, and the
+ * short-wavelength half of the lattice Brillouin zone (`q > π/a`) has no image
+ * in the continuum model. The information loss is therefore recorded in
+ * `doesNotPreserve` and witnessed numerically by `W9`.
+ *
+ * @module atlas/oscillators/bridges-coarse
+ */
+import { LENGTH, MASS, VELOCITY } from '../../dimensional/types.js';
+import { deriveRegimeGroups } from '../regime.js';
+import { relationContractOf } from './bridges-exact.js';
+import { SPRING_CONSTANT } from './dimensions.js';
+const FAMILY = 'oscillators';
+/**
+ * The lattice dispersion relation of `m u_n″ = κ(u_{n+1} − 2u_n + u_{n−1})`:
+ * `ω(q) = 2 √(κ/m) |sin(qa/2)|`.
+ *
+ * @internal
+ */
+export function latticeDispersion(q, a, kappa, m) {
+    return 2 * Math.sqrt(kappa / m) * Math.abs(Math.sin((q * a) / 2));
+}
+/**
+ * The continuum dispersion relation of `u_tt = c² u_xx` with `c² = κ a² / m`:
+ * `ω = c q`.
+ *
+ * @internal
+ */
+export function continuumDispersion(q, a, kappa, m) {
+    return Math.sqrt((kappa * a * a) / m) * Math.abs(q);
+}
+/** The long-wavelength wave speed `c = a √(κ/m)`. @internal */
+export function chainWaveSpeed(a, kappa, m) {
+    return a * Math.sqrt(kappa / m);
+}
+/**
+ * The band edge of the lattice, at `qa = π`: `ω_max = 2 √(κ/m)`.
+ * The continuum relation `ω = c q` is unbounded and has no counterpart —
+ * that absence IS the information the coarse-graining discards.
+ *
+ * @internal
+ */
+export function latticeBandEdge(kappa, m) {
+    return 2 * Math.sqrt(kappa / m);
+}
+/**
+ * Leading-order relative dispersion error `1 − ω_lattice/ω_continuum`,
+ * approximated as `(qa)²/24`.
+ *
+ * Convention note (fixed for the whole sprint): with `x = qa/2`,
+ * `1 − sin x / x = x²/6 − x⁴/120 + …`, so the true relative error is
+ * `(qa)²/24 − (qa)⁴/1920`. The quartic term makes `(qa)²/24` an
+ * OVERESTIMATE; the signed deviation `(true − approx)/approx` is therefore
+ * NEGATIVE and equals `−(qa)²/80` to leading order. The W9 assertion is on
+ * the MAGNITUDE, so the sign convention does not change the test — it is
+ * stated here so the next reader does not rederive it.
+ *
+ * @internal
+ */
+export function dispersionErrorApproximation(qa) {
+    return (qa * qa) / 24;
+}
+/** Bridge 5: chain → wave equation by coarse-graining. @internal */
+export const BRIDGE_CHAIN_WAVE = {
+    id: 'ab-chain-wave',
+    relation: 'coarse-graining',
+    premises: ['model-chain'],
+    conclusion: 'model-wave-1d',
+    transformation: 'u_n(t) ↦ u(x = n a, t), with c² = κ a² / m',
+    preserves: [
+        'long-wavelength dispersion ω ≈ c q',
+        'wave speed c = a √(κ/m)',
+        'linearity',
+    ],
+    doesNotPreserve: [
+        'modes with q > π/a',
+        'the band edge ω_max = 2 √(κ/m) at qa = π',
+        'the discrete lattice spacing a as an independent scale',
+    ],
+    sideConditions: ['long-wavelength, qa ≪ 1'],
+    regime: {
+        family: FAMILY,
+        inequalities: [{ group: 'qa', op: '<', bound: 1, alias: 'qa ≪ 1' }],
+        groupDefinitions: deriveRegimeGroups(FAMILY, [
+            { name: 'm', dim: MASS },
+            { name: 'kappa', dim: SPRING_CONSTANT },
+            { name: 'a', dim: LENGTH },
+            { name: 'c', dim: VELOCITY },
+        ], ['qa']),
+    },
+    counterexamples: [
+        {
+            description: 'A mode at the band edge qa = π has ω = 2√(κ/m) on the lattice, while the ' +
+                'continuum relation ω = c q is unbounded: the coarse-grained model has no ' +
+                'band edge at all.',
+            witness: 'W9',
+        },
+    ],
+    evidence: new Set(['proposed', 'dimension-checked', 'numerically-supported']),
+    witnesses: [
+        {
+            id: 'W9',
+            kind: 'numeric',
+            test: 'tests/atlas/oscillators-coarse.test.ts',
+            tolerance: 'relative dispersion error matches (qa)²/24 within 0.5% of itself',
+        },
+        {
+            id: 'W9b',
+            kind: 'numeric',
+            test: 'tests/atlas/oscillators-coarse.test.ts',
+            tolerance: 'ring of 64 masses integrated: ω matches the lattice dispersion within 1e-9 and the coarse error ' +
+                '(qa)²/24 within 1%; superposition within 1e-10 (linearity); a 10% wrong κ and a cubic on-site force each fail',
+        },
+    ],
+    // The monatomic-chain dispersion omega(q) = 2 sqrt(kappa/m) |sin(qa/2)| and its
+    // long-wavelength continuum limit are standard solid-state results. Work and topic are
+    // cited rather than a precise section number, which would be fabrication in a more
+    // confident costume. This array was EMPTY, which is honest but leaves a textbook result
+    // looking unsourced.
+    citations: [
+        'Kittel, Introduction to Solid State Physics - Phonons I: the monatomic linear chain, its dispersion relation and the qa << 1 continuum limit',
+        'Ashcroft & Mermin, Solid State Physics - the one-dimensional monatomic Bravais lattice and the first Brillouin zone band edge at qa = pi',
+    ],
+    reviewStatus: 'proposed',
+};
+/**
+ * Bridge 5 re-registered through `RelationContract`.
+ *
+ * `coarse-graining` leaves `bound` OPTIONAL, and this record carries none: the
+ * `qa²/24` dispersion residual is a per-mode series term, not a Lipschitz
+ * constant with a uniform offset in a stated norm. The union permits the
+ * absence rather than forcing an invented `K` and `delta`.
+ *
+ * No `deltaAt` either, for the same reason and by the same rule: `deltaAt` is
+ * the machine form OF a `delta`, so a record with no `delta` has nothing for
+ * it to be the machine form of. `admitApproximation` requires `deltaAt` only
+ * of an `approximation`, so this record passes admission unchanged.
+ *
+ * @internal
+ */
+export const CONTRACT_CHAIN_WAVE = relationContractOf(BRIDGE_CHAIN_WAVE);
+//# sourceMappingURL=bridges-coarse.js.map

package/dist/atlas/oscillators/bridges-coarse.js.map

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

package/dist/atlas/oscillators/bridges-exact.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The two Phase 0 `exact-equivalence` bridges of design note §3.
+ *
+ * - `ab-spring-lc` — the lossless mechanical/electrical dictionary, exact with
+ *   no side condition beyond positivity and losslessness.
+ * - `ab-damped-rlc` — exact only ON a side condition: the two damping ratios
+ *   must agree, `b/(2√(mk)) = (R/2)√(C/L)`.
+ *
+ * **Regimes carry no inequalities.** `RegimeInequality` expresses `<`, `<=`,
+ * `>`, `>=` only, so the bridge-2 side condition — an EQUALITY between two
+ * derived ratios — cannot be written as one. It is carried in
+ * `sideConditions` as prose instead, and the equality is what witness W2
+ * executes. Writing an inequality that merely resembles it would be a
+ * fabricated constraint, so none is written. `groupDefinitions` is derived
+ * from the premise and conclusion parameters by `deriveRegimeGroups`, exactly
+ * as the models do; nothing there is hand-authored.
+ *
+ * **Evidence tags are witness-gated.** A tag appears only because a witness in
+ * `tests/atlas/oscillators-exact.test.ts` passes and shows it.
+ *
+ * @module atlas/oscillators/bridges-exact
+ */
+import type { AtlasBridge, RelationContract } from '../types.js';
+/**
+ * Bridge 1 — the lossless spring ↔ LC dictionary.
+ *
+ * `m ↔ L`, `k ↔ 1/C`, `x ↔ q`. Under `u = x/x0` (or `q/q0`) and `τ = ω0 t`
+ * both systems become `u'' + u = 0`, so the equivalence is exact and
+ * invertible.
+ *
+ * Its counterexample is W2b, which lives on THIS bridge: it shows that adding
+ * a resistor to the LC side breaks the equivalence, so bridge 1 is a statement
+ * about the LOSSLESS pair only.
+ *
+ * @internal
+ */
+export declare const BRIDGE_SPRING_LC: AtlasBridge;
+/**
+ * Bridge 2 — damped spring ↔ RLC, exact ON a side condition.
+ *
+ * The undamped dictionary of bridge 1 does not extend for free: `b` and `R`
+ * are independent parameters, and the nondimensional systems coincide only
+ * when the damping ratios match. The side condition is that equality, and W2
+ * DERIVES `R` from it rather than assuming a value.
+ *
+ * @internal
+ */
+export declare const BRIDGE_DAMPED_RLC: AtlasBridge;
+/**
+ * Re-register an `AtlasBridge` through the Phase 1 `RelationContract` union.
+ *
+ * `AtlasBridge` states its two conditional requirements — `exact-equivalence`
+ * needs `inverse`, `approximation` needs `bound` — only in doc comments, so a
+ * record that breaks them type-checks. `RelationContract` states them in the
+ * type system. This function is the one place the Sprint 0 records cross from
+ * the weaker shape to the stronger one, and it THROWS on the two cases the
+ * doc comments could only describe.
+ *
+ * It copies rather than restates: every field comes off the bridge, so a
+ * contract cannot drift from the record it re-registers.
+ *
+ * @throws TypeError when the bridge omits the field its relation requires.
+ * @internal
+ */
+export declare function relationContractOf(bridge: AtlasBridge): RelationContract;
+/** Bridge 1 re-registered through the Phase 1 contract. @internal */
+export declare const CONTRACT_SPRING_LC: RelationContract;
+/** Bridge 2 re-registered through the Phase 1 contract. @internal */
+export declare const CONTRACT_DAMPED_RLC: RelationContract;
+//# sourceMappingURL=bridges-exact.d.ts.map

package/dist/atlas/oscillators/bridges-exact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridges-exact.d.ts","sourceRoot":"","sources":["../../../src/atlas/oscillators/bridges-exact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAuB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA+CtF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,EAAE,WA2D9B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAoC/B,CAAC;AAMF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,gBAAgB,CAwBxE;AAED,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,gBAAuD,CAAC;AAEzF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB,EAAE,gBAAwD,CAAC"}

package/dist/atlas/oscillators/bridges-exact.js

@@ -0,0 +1,230 @@
+/**
+ * The two Phase 0 `exact-equivalence` bridges of design note §3.
+ *
+ * - `ab-spring-lc` — the lossless mechanical/electrical dictionary, exact with
+ *   no side condition beyond positivity and losslessness.
+ * - `ab-damped-rlc` — exact only ON a side condition: the two damping ratios
+ *   must agree, `b/(2√(mk)) = (R/2)√(C/L)`.
+ *
+ * **Regimes carry no inequalities.** `RegimeInequality` expresses `<`, `<=`,
+ * `>`, `>=` only, so the bridge-2 side condition — an EQUALITY between two
+ * derived ratios — cannot be written as one. It is carried in
+ * `sideConditions` as prose instead, and the equality is what witness W2
+ * executes. Writing an inequality that merely resembles it would be a
+ * fabricated constraint, so none is written. `groupDefinitions` is derived
+ * from the premise and conclusion parameters by `deriveRegimeGroups`, exactly
+ * as the models do; nothing there is hand-authored.
+ *
+ * **Evidence tags are witness-gated.** A tag appears only because a witness in
+ * `tests/atlas/oscillators-exact.test.ts` passes and shows it.
+ *
+ * @module atlas/oscillators/bridges-exact
+ */
+import { deriveRegimeGroups } from '../regime.js';
+import { getAtlasModel } from './models.js';
+const FAMILY = 'oscillators';
+/** The witness test file every witness below runs in. */
+const TEST = 'tests/atlas/oscillators-exact.test.ts';
+/** Where the CAS witnesses W1s and W2s are named; the artifact pin runs them. */
+const WITNESS_RESULTS_TEST = 'tests/atlas/witness-results.test.ts';
+/**
+ * Literature for the electromechanical analogy, NOT a pointer at our own plan.
+ *
+ * The previous value here was `docs/planning/Atlas-Phase-0-Design.md §3, §6` - a citation
+ * naming the document that ASSERTED the claim. That is circular, and it is worse than an
+ * empty array because it LOOKS sourced and would satisfy any check that only asks whether
+ * `citations[]` is non-empty. Same failure class as the evidence-tag theatre that
+ * `tests/atlas/evidence-rule.test.ts` exists to catch.
+ *
+ * Work and topic are cited rather than precise section numbers, because a section number
+ * stated without checking the edition in hand is the same fabrication in a more confident
+ * costume. `reviewStatus` stays 'proposed' until the independent physicist review lands.
+ */
+const CITATIONS = [
+    'Olson, Dynamical Analogies - the force-voltage (impedance) analogy between a mass-spring–damper and a series RLC circuit',
+    'Feynman, Lectures on Physics Vol. II, chapter on resonance - the LC oscillator and its mechanical counterpart',
+];
+/**
+ * Regime coordinates spanning a bridge's premise and conclusion parameters.
+ *
+ * The two models' parameter names are disjoint in both bridges, so the union
+ * is a legal `deriveRegimeGroups` input.
+ */
+function bridgeRegime(premiseId, conclusionId) {
+    const parameters = [
+        ...getAtlasModel(premiseId).parameters,
+        ...getAtlasModel(conclusionId).parameters,
+    ];
+    return {
+        family: FAMILY,
+        inequalities: [],
+        groupDefinitions: deriveRegimeGroups(FAMILY, parameters, []),
+    };
+}
+const evidence = (...tags) => new Set(tags);
+/**
+ * Bridge 1 — the lossless spring ↔ LC dictionary.
+ *
+ * `m ↔ L`, `k ↔ 1/C`, `x ↔ q`. Under `u = x/x0` (or `q/q0`) and `τ = ω0 t`
+ * both systems become `u'' + u = 0`, so the equivalence is exact and
+ * invertible.
+ *
+ * Its counterexample is W2b, which lives on THIS bridge: it shows that adding
+ * a resistor to the LC side breaks the equivalence, so bridge 1 is a statement
+ * about the LOSSLESS pair only.
+ *
+ * @internal
+ */
+export const BRIDGE_SPRING_LC = {
+    id: 'ab-spring-lc',
+    relation: 'exact-equivalence',
+    premises: ['model-spring'],
+    conclusion: 'model-lc',
+    // Two nondimensionalizations, each with its own ω0; composed, the spring→LC map is
+    // q(t) = (q0/x0)·x(ω_LC t / ω_s). The dimensioned frequencies differ (W1a: ω_s = 2,
+    // ω_LC = 2√2); what is preserved is the frequency in units of ω0.
+    transformation: 'force–voltage analogy m ↔ L, k ↔ 1/C, x ↔ q (so ω0² = k/m ↔ 1/(LC)); ' +
+        'u = x/x0 or q/q0, τ = ω0 t; composed, q(t) = (q0/x0)·x(ω_LC t / ω_s)',
+    inverse: 'x = x0 u, t = τ/ω0',
+    preserves: ['the natural frequency in units of ω0 (ω = 1 in τ = ω0 t)', 'energy up to scale', 'phase portrait'],
+    doesNotPreserve: ['physical interpretation', 'units'],
+    sideConditions: ['m, k, L, C > 0', 'lossless', 'unforced', 'x0, q0 nonzero'],
+    regime: bridgeRegime('model-spring', 'model-lc'),
+    counterexamples: [
+        {
+            description: 'adding R to bridge 1 breaks it: the circuit L = 2, C = 0.125 of witness W2b with R = 4 has ' +
+                'ζ_RLC = (R/2)√(C/L) = 0.5, ' +
+                'which no lossless spring matches — the trajectories separate by more than 1e-2 at τ = π',
+            witness: 'W2b',
+        },
+    ],
+    // `symbolically-checked` is NOT stored here any more (Phase 4 S4.3): it is
+    // DERIVED from `data/atlas/witness-results.json`, where W1s records the CAS
+    // check of this bridge's dictionary. A stored copy would be a second source
+    // of truth that no run could falsify.
+    evidence: evidence('proposed', 'numerically-supported'),
+    witnesses: [
+        {
+            id: 'W1',
+            kind: 'symbolic',
+            test: TEST,
+            tolerance: 'exact — rational exponent arithmetic, no floating point',
+        },
+        {
+            id: 'W1a',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: '|u_spring − u_lc| < 1e-8; each within 1e-8 of cos τ',
+        },
+        {
+            id: 'W1b',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: 'inverse-mapped trajectory solves m x″ + k x = 0 within 1e-8; a 1% wrong ω0 fails',
+        },
+        { id: 'W2b', kind: 'numeric', test: TEST, tolerance: 'separation > 1e-2 at τ = π' },
+        {
+            id: 'W1s',
+            kind: 'symbolic',
+            test: WITNESS_RESULTS_TEST,
+            tolerance: 'CAS: k/m under m ↔ L, k ↔ 1/C minus 1/(LC) simplifies to literal 0',
+        },
+    ],
+    citations: CITATIONS,
+    reviewStatus: 'proposed',
+};
+/**
+ * Bridge 2 — damped spring ↔ RLC, exact ON a side condition.
+ *
+ * The undamped dictionary of bridge 1 does not extend for free: `b` and `R`
+ * are independent parameters, and the nondimensional systems coincide only
+ * when the damping ratios match. The side condition is that equality, and W2
+ * DERIVES `R` from it rather than assuming a value.
+ *
+ * @internal
+ */
+export const BRIDGE_DAMPED_RLC = {
+    id: 'ab-damped-rlc',
+    relation: 'exact-equivalence',
+    premises: ['model-damped-spring'],
+    conclusion: 'model-rlc',
+    transformation: 'force–voltage analogy m ↔ L, k ↔ 1/C, b ↔ R, x ↔ q; ' +
+        'u = x/x0 or q/q0, τ = ω0 t; composed, q(t) = (q0/x0)·x(ω_RLC t / ω_mech)',
+    inverse: 'x = x0 u, t = τ/ω0',
+    preserves: ['the natural frequency in units of ω0 (ω = 1 in τ = ω0 t)', 'damping ratio', 'phase portrait'],
+    doesNotPreserve: ['physical interpretation', 'units'],
+    sideConditions: [
+        'b/√(mk) = R√(C/L), equivalently ζ_mech = b/(2√(mk)) equals ζ_RLC = (R/2)√(C/L)',
+        'm, b, k, L, R, C > 0',
+        'unforced',
+        'x0, q0 nonzero',
+    ],
+    regime: bridgeRegime('model-damped-spring', 'model-rlc'),
+    counterexamples: [],
+    evidence: evidence('proposed', 'numerically-supported'),
+    witnesses: [
+        {
+            id: 'W2',
+            kind: 'numeric',
+            test: TEST,
+            tolerance: 'R derived exactly; |u_mech − u_rlc| < 1e-8 at four τ',
+        },
+        {
+            id: 'W2s',
+            kind: 'symbolic',
+            test: WITNESS_RESULTS_TEST,
+            tolerance: 'CAS: b²/(4mk) under m ↔ L, k ↔ 1/C, b ↔ R minus R²C/(4L) simplifies to literal 0',
+        },
+    ],
+    citations: CITATIONS,
+    reviewStatus: 'proposed',
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase 1 re-registration: the Sprint 0 bridges through `RelationContract`
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Re-register an `AtlasBridge` through the Phase 1 `RelationContract` union.
+ *
+ * `AtlasBridge` states its two conditional requirements — `exact-equivalence`
+ * needs `inverse`, `approximation` needs `bound` — only in doc comments, so a
+ * record that breaks them type-checks. `RelationContract` states them in the
+ * type system. This function is the one place the Sprint 0 records cross from
+ * the weaker shape to the stronger one, and it THROWS on the two cases the
+ * doc comments could only describe.
+ *
+ * It copies rather than restates: every field comes off the bridge, so a
+ * contract cannot drift from the record it re-registers.
+ *
+ * @throws TypeError when the bridge omits the field its relation requires.
+ * @internal
+ */
+export function relationContractOf(bridge) {
+    const { relation, transformation } = bridge;
+    switch (relation) {
+        case 'exact-equivalence': {
+            if (bridge.inverse === undefined) {
+                throw new TypeError(`${bridge.id}: exact-equivalence without an inverse`);
+            }
+            return { type: relation, transformation, inverse: bridge.inverse };
+        }
+        case 'approximation': {
+            if (bridge.bound === undefined) {
+                throw new TypeError(`${bridge.id}: approximation without a bound`);
+            }
+            return { type: relation, transformation, bound: bridge.bound };
+        }
+        case 'coarse-graining':
+            // `bound` is OPTIONAL here: the chain/wave bridge carries none, and the
+            // union allows that rather than forcing an invented one.
+            return bridge.bound === undefined
+                ? { type: relation, transformation }
+                : { type: relation, transformation, bound: bridge.bound };
+        default:
+            return { type: relation, transformation };
+    }
+}
+/** Bridge 1 re-registered through the Phase 1 contract. @internal */
+export const CONTRACT_SPRING_LC = relationContractOf(BRIDGE_SPRING_LC);
+/** Bridge 2 re-registered through the Phase 1 contract. @internal */
+export const CONTRACT_DAMPED_RLC = relationContractOf(BRIDGE_DAMPED_RLC);
+//# sourceMappingURL=bridges-exact.js.map

package/dist/atlas/oscillators/bridges-exact.js.map

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

package/dist/atlas/oscillators/bridges-limits.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The two Phase 0 APPROXIMATION bridges — design note §3, bridges 3 and 4.
+ *
+ * - `ab-pendulum-linear` — a REGULAR limit. `θ'' + ω0² sin θ = 0` reduces to
+ *   `θ'' + ω0² θ = 0` as `θ0 → 0`. The order of the system does not drop, the
+ *   error is `O(θ0²)` in the relative period, and the approximation is
+ *   NON-UNIFORM in time: a fixed relative period error accumulates phase
+ *   without bound, so the bound carries the horizon `t ≪ 16 T0/θ0²`.
+ * - `ab-damped-massless` — a SINGULAR limit. `m x'' + b x' + k x = 0` reduces
+ *   to `b x' + k x = 0` as `m → 0`. The order DROPS from two to one, one
+ *   initial condition is lost, and the reduced model cannot satisfy `x'(0)`.
+ *   The bound therefore holds only OUTSIDE the boundary layer, `t ≥ 5 m/b`.
+ *
+ * On the position offset of the singular bridge: `x_full − x_red` is an
+ * `O((1 + |v0|) m)` deviation that PERSISTS THROUGHOUT THE OUTER REGION and
+ * decays only on the slow time scale `b/k`. It is the matched-asymptotics
+ * correction, not a boundary-layer transient, and waiting out the fast mode
+ * does not remove it. (Design note §9 YELLOW (5) — "non-vanishing" was the
+ * imprecise wording this replaces: the offset does go to zero as `t → ∞`.)
+ *
+ * @module atlas/oscillators/bridges-limits
+ */
+import type { ApproximationBound, AtlasBridge, RelationContract } from '../types.js';
+/**
+ * Build an `ApproximationBound`, rejecting one with no prose horizon.
+ *
+ * Every `approximation` bridge in this module is constructed through here, so
+ * the mandatory-horizon rule of `ApproximationBound` has something that FAILS
+ * rather than a comment asking for compliance. `horizonHolds` is mandatory by
+ * the type; the prose `horizon` is the field a caller can satisfy with `''`,
+ * so it is the one checked at run time. `uniformity: null` is accepted: not
+ * yet analysed is a real state, and the refusal lives in `boundPath`.
+ *
+ * @throws MissingHorizonError if `horizon` is empty or whitespace.
+ * @internal
+ */
+export declare function makeApproximation(bound: ApproximationBound): ApproximationBound;
+/**
+ * The EXACT relative period error of the pendulum at amplitude `theta0`:
+ * `(2/π) K(sin(θ0/2)) − 1 = 1/AGM(1, cos(θ0/2)) − 1`.
+ *
+ * This is the machine form of `ab-pendulum-linear`'s `delta`. It is SHARP —
+ * the bound equals the error it bounds — and it is strictly increasing in
+ * `|θ0|`, so its value at the edge of a declared amplitude range is the
+ * supremum over that range. That last property is what lets the record state
+ * one scalar for the whole domain honestly.
+ *
+ * The series `θ0²/16` is the LEADING TERM of this quantity, not an upper bound
+ * on it: at the domain edge `θ0 = 0.5` the series gives `0.0156250` while the
+ * exact error is `0.0158525311`, so the series UNDERSTATES by 1.456%. A record
+ * that declares the series value is violated at its own boundary.
+ *
+ * @returns `Infinity` outside `|θ0| < π`, where no finite period error exists.
+ * @internal
+ */
+export declare function pendulumPeriodErrorAt(params: Readonly<Record<string, number>>): number;
+/**
+ * The position-offset bound of `ab-damped-massless` at a point:
+ * `2 (1 + |v0|) m / b`, the formula this record's docstring has always
+ * carried. It is a bound ONLY at the witness normalisation `b = k = x0 = 1`:
+ * the leading offset is `(m/b)(v0 + k x0/b)`, and the formula has no `k` or
+ * `x0` in it. At `m = 1e-3, b = 1, k = 100` (inside `m k/b² < 1/4`) the true
+ * error is more than 20 times the formula.
+ *
+ * @returns `Infinity` unless `m`, `b`, `k`, `x0` and `v0` are all finite and
+ *   `b = k = x0 = 1` — a missing parameter would otherwise silently return a
+ *   bound for a normalisation the caller did not ask about.
+ * @internal
+ */
+export declare function dampedOffsetBoundAt(params: Readonly<Record<string, number>>): number;
+/**
+ * `ab-pendulum-linear` — small-angle pendulum → harmonic spring.
+ *
+ * `θ0²/16` is the leading term of the exact relative period error
+ * `(2/π) K(sin(θ0/2)) − 1`. At `θ0 = 0.2` the residual is `5.744e-6`, which
+ * the next series term `11 θ0⁴/3072 = 5.729e-6` accounts for to `1.5e-8`.
+ *
+ * `delta` is the EXACT error at the edge of the declared range, not that
+ * series term. The record previously declared `0.5²/16 = 0.0156250`, which is
+ * the series evaluated at `θ0 = 0.5` — and the exact error there is
+ * `0.0158525311`, so the declared bound was VIOLATED AT ITS OWN BOUNDARY by
+ * 1.456%. A truncated series is an approximation of the error, not a bound on
+ * it, and the sign of its omitted tail decides which. Here the tail is
+ * positive, so the series sits below what it was asked to cover.
+ *
+ * @internal
+ */
+export declare const AB_PENDULUM_LINEAR: AtlasBridge;
+/**
+ * `ab-damped-massless` — the SINGULAR `m → 0` limit of the damped spring.
+ *
+ * `deltaAt = 2(1 + |v0|) m/b` bounds the position offset outside the boundary
+ * layer, and `delta` is its supremum over the declared range rather than its
+ * value at one fixture. The lost initial condition is visible in the VELOCITY: inside the
+ * layer the reduced model's `x'` is wrong by O(1/m·…), and it is only after
+ * `t ≈ 5 m/b` that the fast mode has decayed.
+ *
+ * @internal
+ */
+export declare const AB_DAMPED_MASSLESS: AtlasBridge;
+/** The two approximation bridges of this module, in design-note order. @internal */
+export declare const LIMIT_BRIDGES: readonly AtlasBridge[];
+/**
+ * The two approximation bridges re-registered through `RelationContract`.
+ *
+ * The union REQUIRES `bound` on an `approximation`, and `ApproximationBound`
+ * requires its own machine `horizonHolds`, so these two lines are what turn
+ * Sprint 0's doc-comment requirement into a compile-and-throw one. Both bounds
+ * are the records' own, measured ones — nothing is restated here.
+ *
+ * @internal
+ */
+export declare const CONTRACT_PENDULUM_LINEAR: RelationContract;
+/** @internal */
+export declare const CONTRACT_DAMPED_MASSLESS: RelationContract;
+/** The two limit contracts, in design-note order. @internal */
+export declare const LIMIT_CONTRACTS: readonly RelationContract[];
+//# sourceMappingURL=bridges-limits.d.ts.map

package/dist/atlas/oscillators/bridges-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridges-limits.d.ts","sourceRoot":"","sources":["../../../src/atlas/oscillators/bridges-limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,gBAAgB,EAAU,MAAM,aAAa,CAAC;AAQ7F;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,kBAAkB,GAAG,kBAAkB,CAO/E;AAYD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAItF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAKpF;AAuCD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,EAAE,WA4FhC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,EAAE,WA2EhC,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,aAAa,EAAE,SAAS,WAAW,EAA6C,CAAC;AAE9F;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,gBACC,CAAC;AAEzC,gBAAgB;AAChB,eAAO,MAAM,wBAAwB,EAAE,gBACC,CAAC;AAEzC,+DAA+D;AAC/D,eAAO,MAAM,eAAe,EAAE,SAAS,gBAAgB,EAGtD,CAAC"}