universal-physics-tensor 0.47.1 → 1.0.1

package/dist/atlas/path-bound.d.ts

@@ -35,6 +35,13 @@
  * makes the error invisible without this gate: the danger is not a wrong
  * magnitude, it is a right magnitude attached to the wrong norm.
  *
+ * The one way through is a DECLARATION on the exact bridge
+ * (`AtlasBridge.normTransports`, `docs/planning/ADR-transported-norm-composition.md`):
+ * a norm, a direction, a factor `K` and a time map, each with a witness. A route
+ * that crosses the bridge in that direction, carrying a bound in that norm,
+ * composes with `(K, 0)`; every other norm and direction is still refused, and
+ * the refusal names the declaration that is missing.
+ *
  * ⚠ **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
@@ -55,7 +62,7 @@
  */
 import { IDENTITY_BOUND } from './error-algebra.js';
 import type { BoundPair } from './error-algebra.js';
-import type { AtlasBridge, RelationType } from './types.js';
+import type { AtlasBridge, NormTransport, RelationType } from './types.js';
 /**
  * Shortest chain of bridges from `from` to `to`, or `null` if none exists.
  *
@@ -72,6 +79,59 @@ import type { AtlasBridge, RelationType } from './types.js';
  * @internal
  */
 export declare function findPath(family: string, from: string, to: string): readonly AtlasBridge[] | null;
+/**
+ * Shortest chain of bridges from `from` to `to` across EVERY registered
+ * family, or `null` if none exists.
+ *
+ * A family is a filing label, not a physical boundary: `ab-kg-schrodinger` is
+ * filed under waves and ends in the diffusion family's free Schrödinger model.
+ * The search runs over the union of all families' bridges under the same
+ * rules as {@link findPath} — an exact equivalence both ways, every lossy
+ * relation forward only — and the route it returns is composed by
+ * {@link boundPath} exactly as a single-family route is. Crossing a family
+ * adds no composition rule.
+ *
+ * Ties are broken by {@link ATLAS_FAMILIES} order, then each family's bridge
+ * order, so the result is stable across runs.
+ *
+ * @throws RangeError if an endpoint is not a model of any family.
+ * @internal
+ */
+export declare function findAtlasPath(from: string, to: string): readonly AtlasBridge[] | null;
+/**
+ * The simple routes from `from` to `to` across every registered family, as
+ * far as a bounded search reaches. Each route is a list of bridges, and no route
+ * visits a model twice. Traversal follows the same rules as
+ * {@link findAtlasPath}: an exact equivalence both ways, every lossy relation
+ * forward only, multi-premise bridges skipped.
+ *
+ * The search runs by bridge count (every route of k bridges before any of
+ * k + 1), with ties in {@link ATLAS_FAMILIES} order and then bridge order. It stops
+ * once it has found `limit + 1` routes, or after expanding `budget` partial
+ * routes. Stopping early is REPORTED, not hidden: `exhausted` is false,
+ * `stoppedBy` says which bound stopped it, and `completeThrough` is the largest
+ * bridge count up to which every route has been found. When `exhausted` is
+ * true, `routes` holds all of them.
+ *
+ * @throws RangeError if an endpoint is not a model of any family, or `limit`
+ *   is not a positive integer (via {@link enumerateRoutes}).
+ * @internal
+ */
+export declare function enumerateAtlasRoutes(from: string, to: string, limit: number, budget?: number): RouteEnumeration;
+/** What {@link enumerateAtlasRoutes} found, and whether the search was cut short. @internal */
+export interface RouteEnumeration {
+    readonly routes: (readonly AtlasBridge[])[];
+    readonly exhausted: boolean;
+    readonly completeThrough: number | null;
+    readonly stoppedBy: 'limit' | 'budget' | null;
+}
+/**
+ * {@link enumerateAtlasRoutes} over an explicit bridge list; endpoints are not
+ * validated against any family.
+ * @throws RangeError if `limit` is not a positive integer.
+ * @internal
+ */
+export declare function enumerateRoutes(bridges: readonly AtlasBridge[], from: string, to: string, limit: number, budget?: number): RouteEnumeration;
 /** Why a path supports no bound. @internal */
 export type NoClaimReason = 
 /** The relations along the path do not compose to a relation at all. */
@@ -80,6 +140,12 @@ export type NoClaimReason =
  | 'norm-not-stated'
 /** Two edges state DIFFERENT norms; composing across norms is unsound. */
  | 'norm-mismatch'
+/**
+ * A norm stated in one model family was carried into another with no
+ * witnessed transport across that boundary. String equality is not a match
+ * there. A one-step route does not reach this gate.
+ */
+ | 'cross-family-unmapped'
 /**
  * A bound on the path has `uniformity === null` or an empty list: what the
  * error is uniform in has not been analysed, so no number is stated.
@@ -94,11 +160,21 @@ export interface PathBoundClaim {
     /** The relation the chain asserts, from {@link composeRelation}. */
     readonly relation: RelationType;
     /**
-     * The single norm every bound on the path states, or `null` when the path
-     * carries no bound at all and the claim is the vacuous `terminal` identity
-     * over an empty prefix.
+     * The norm the composite holds in: the single norm every bound on the path
+     * states, or the `to` norm of the last transport applied after them. `null`
+     * when the path carries no bound at all and the claim is the vacuous
+     * `terminal` identity over an empty prefix.
      */
     readonly norm: string | null;
+    /** The declared norm transports that carried the bound across exact maps; absent when none did. */
+    readonly transports?: readonly AppliedTransport[];
+}
+/** A declared norm transport {@link boundPath} applied, and where on the path. @internal */
+export interface AppliedTransport {
+    /** Index of the exact bridge in the path. */
+    readonly index: number;
+    readonly bridgeId: string;
+    readonly transport: NormTransport;
 }
 /** A path that carries NO bound, and the reason. @internal */
 export interface PathNoClaim {
@@ -112,7 +188,7 @@ export type PathBoundResult = PathBoundClaim | PathNoClaim;
 /**
  * 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
+ * Five 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
@@ -127,10 +203,21 @@ export type PathBoundResult = PathBoundClaim | PathNoClaim;
  *    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.
+ * 4. **Norm.** Every stated norm on the path must be the SAME norm as the bound
+ *    reaching it, 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 —
+ *    UNLESS the exact bridge declares a `NormTransport` from the running norm,
+ *    for the direction the route crosses it, with a uniform time map. Then it
+ *    contributes `(K, 0)` and the running norm becomes the transport's `to`.
+ *    A mismatch is reported before a missing norm.
+ * 5. **Vocabulary.** When the models a norm is carried between sit in different
+ *    families, string equality is not a match. The carry needs a
+ *    `NormTransport` whose `fromModel` / `toModel` are the models the route
+ *    crosses, whose `from` is the running norm, whose time map is uniform, and
+ *    whose witness is present. Otherwise the refusal is
+ *    `'cross-family-unmapped'`. A one-step route has nothing to carry, so this
+ *    gate does not fire. A missing Lipschitz constant is reported first.
  *
  * @throws RangeError on an empty path. Returning `IDENTITY_BOUND` for "no
  *   edges" would be a bound asserted about nothing.
@@ -138,6 +225,36 @@ export type PathBoundResult = PathBoundClaim | PathNoClaim;
  * @internal
  */
 export declare function boundPath(bridges: readonly AtlasBridge[]): PathBoundResult;
+/**
+ * The model each step of a route is entered from, or `null` where the list is
+ * not a chain. An exact equivalence may be crossed either way; the first one is
+ * read as reversed when the next step leaves from its premise and not from its
+ * conclusion. Every other relation is crossed forward.
+ *
+ * @internal
+ */
+export declare function routeEntryModels(bridges: readonly AtlasBridge[]): (string | null)[];
+/**
+ * True when step `index` sits in a different model family from the previous
+ * step and no applied transport restates a clock onto it. The step's own
+ * horizon is then unevaluated: a family change does not copy one.
+ *
+ * @internal
+ */
+export declare function familyChangeBlocksHorizon(bridges: readonly AtlasBridge[], transports: readonly AppliedTransport[], index: number): boolean;
+/**
+ * The horizon of the bound on `bridges[index]` as it reads at the END of the
+ * route: restated through every transport applied after it (a
+ * {@link PathBoundClaim}'s `transports`; none for a no-claim). `null` when that
+ * step carries no bound.
+ *
+ * @internal
+ */
+export declare function horizonOnRoute(bridges: readonly AtlasBridge[], transports: readonly AppliedTransport[], index: number): {
+    readonly horizon: string;
+    readonly restatedBy: readonly AppliedTransport[];
+    readonly holds: (t: number, params: Readonly<Record<string, number>>) => boolean;
+} | null;
 /** Re-exported so a caller need not reach into the algebra module. @internal */
 export { IDENTITY_BOUND };
 //# sourceMappingURL=path-bound.d.ts.map

package/dist/atlas/path-bound.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-bound.d.ts","sourceRoot":"","sources":["../../src/atlas/path-bound.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EAAoB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA+C5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,SAAS,WAAW,EAAE,GAAG,IAAI,CA2C/B;AAED,8CAA8C;AAC9C,MAAM,MAAM,aAAa;AACvB,wEAAwE;AACtE,oBAAoB;AACtB,0EAA0E;GACxE,iBAAiB;AACnB,0EAA0E;GACxE,eAAe;AACjB;;;GAGG;GACD,uBAAuB,CAAC;AAE5B,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,8DAA8D;AAC9D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,kFAAkF;AAClF,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,WAAW,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,eAAe,CAkG1E;AAED,gFAAgF;AAChF,OAAO,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"path-bound.d.ts","sourceRoot":"","sources":["../../src/atlas/path-bound.ts"],"names":[],"mappings":"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"}