universal-physics-tensor 10.0.0 → 11.0.0

package/dist/numerical/tensor-engine.js.map

@@ -1 +1 @@
-{"version":3,"file":"tensor-engine.js","sourceRoot":"","sources":["../../src/numerical/tensor-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH;;;;GAIG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AA0GpD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAoB;IACrD,OAAO,OAAO,MAAM,CAAC,WAAW,KAAK,UAAU;WACxC,OAAO,MAAM,CAAC,WAAW,KAAK,UAAU,CAAC;AAClD,CAAC;AAED;;;;gBAIgB;AAChB,MAAM,UAAU,YAAY,CAAC,CAAU;IACrC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACtD,MAAM,CAAC,GAAG,CAA+C,CAAC;IAC1D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IAC3E,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACtD,MAAM,IAAI,GAAI,CAAwB,CAAC,IAAI,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAC5D,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC9D,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAC;QACjF,CAAC;IACH,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACtD,MAAM,EAAE,GAAG,CAA0C,CAAC;QACtD,IAAI,OAAO,EAAE,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,EAAE,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;IAClF,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["/**\n * The TensorEngine contract. `MathTSEngine` implements it. See docs/planning/\n * v0.3.5-Design.md §3, §5.\n *\n * `EngineTensor` is an opaque handle; consumers operate on it only through\n * a TensorEngine. The lowering pass (lowering.ts) builds an `EinsumSpec`\n * from `computeContraction()`'s `contractionPairs` and hands it to\n * `engine.einsum()`.\n *\n * @module numerical/tensor-engine\n */\n\nimport type { NestedArray } from './types.js';\n/**\n * Thrown when an engine does not implement a requested capability.\n *\n * @public\n */\nexport { EngineCapabilityError } from './errors.js';\n\n/** Opaque rank-N tensor handle. Each engine backs it with its own storage\n *  (Float64Array, a MathTS Tensor, a future WASM offset); consumers see\n *  only the shape.\n *  @public */\nexport interface EngineTensor {\n  readonly shape: ReadonlyArray<number>;\n}\n\n/** One contracted index: the two (operand, axis) coordinates that the\n *  Einstein summation pairs and sums over. Named by the public\n *  {@link EinsumSpec}, so it is public too.\n *  @public */\nexport interface EinsumContraction {\n  readonly pair: readonly [readonly [number, number], readonly [number, number]];\n}\n\n/** One surviving (free) index in the einsum output, in output-axis order:\n *  the operand and the axis of that operand it comes from. Exported because\n *  the public {@link EinsumSpec} names it (the surface is closed under type\n *  references).\n *  @public */\nexport interface EinsumFreeAxis {\n  readonly operand: number;\n  readonly axis: number;\n}\n\n/** The engine-agnostic einsum plan produced by lowering.ts.\n *  @public */\nexport interface EinsumSpec {\n  readonly contractions: ReadonlyArray<EinsumContraction>;\n  readonly free: ReadonlyArray<EinsumFreeAxis>;\n}\n\n/**\n * Result of a forward-mode automatic differentiation pass.\n * `value` is f(x); `jacobian` is the Jacobian of f at x (Jvp with tangent 1).\n * @public\n */\nexport interface ForwardGradResult {\n  readonly value: EngineTensor;\n  readonly jacobian: EngineTensor;\n}\n\n/**\n * Result of a reverse-mode automatic differentiation pass.\n * `value` is f(x); `gradient` is ∂L/∂x for cotangent dL/df (ones-like by default).\n * @public\n */\nexport interface ReverseGradResult {\n  readonly value: EngineTensor;\n  readonly gradient: EngineTensor;\n}\n\n/** The compute contract. MathTSEngine implements it.\n *  @public */\nexport interface TensorEngine {\n  readonly name: string;\n\n  fromNested(data: NestedArray, shape: ReadonlyArray<number>): EngineTensor;\n  toNested(t: EngineTensor): NestedArray;\n\n  einsum(spec: EinsumSpec, ...operands: EngineTensor[]): EngineTensor;\n  matMul(a: EngineTensor, b: EngineTensor): EngineTensor;\n  transpose(t: EngineTensor, perm?: ReadonlyArray<number>): EngineTensor;\n  reshape(t: EngineTensor, shape: ReadonlyArray<number>): EngineTensor;\n\n  add(a: EngineTensor, b: EngineTensor): EngineTensor;\n  sub(a: EngineTensor, b: EngineTensor): EngineTensor;\n  mul(a: EngineTensor, b: EngineTensor): EngineTensor;\n  scale(t: EngineTensor, k: number): EngineTensor;\n\n  identity(n: number): EngineTensor;\n  normInf(t: EngineTensor): number;\n\n  /** Optional — no-op for pure-JS engines; a future native engine implements\n   *  real disposal. evaluateNumerical() never relies on it. */\n  dispose?(t: EngineTensor): void;\n\n  /**\n   * Forward-mode AD (Jacobian-vector product). Always Promise-returning for\n   * uniform consumer semantics (S6 reconciliation fix — no T | Promise<T> union).\n   * Engines without AD support omit this method; call `hasAutogradSupport(engine)`\n   * before invoking.\n   * @public\n   */\n  forwardGrad?(\n    fn: (x: EngineTensor) => EngineTensor,\n    x: EngineTensor,\n  ): Promise<ForwardGradResult>;\n\n  /**\n   * Reverse-mode AD (vector-Jacobian product). `cotangent` defaults to\n   * ones-like(value) when omitted. Always Promise-returning (S6).\n   * Engines without AD support omit this method; call `hasAutogradSupport(engine)`\n   * before invoking.\n   * @public\n   */\n  reverseGrad?(\n    fn: (x: EngineTensor) => EngineTensor,\n    x: EngineTensor,\n    cotangent?: EngineTensor,\n  ): Promise<ReverseGradResult>;\n}\n\n/**\n * Returns `true` iff the engine implements both `forwardGrad` and `reverseGrad`.\n * Use this before invoking AD methods so callers get a clear capability signal\n * rather than a runtime TypeError.\n *\n * @example\n * ```typescript\n * if (!hasAutogradSupport(engine)) {\n *   throw new EngineCapabilityError(engine.name, 'forwardGrad');\n * }\n * const { value, jacobian } = await engine.forwardGrad!(fn, x);\n * ```\n * @public\n */\nexport function hasAutogradSupport(engine: TensorEngine): boolean {\n  return typeof engine.forwardGrad === 'function'\n      && typeof engine.reverseGrad === 'function';\n}\n\n/** Runtime guard for EinsumSpec — validates structure before passing to\n *  engine.einsum(). Not called internally by the lowering pass (which builds\n *  specs via buildEinsumSpec and trusts the upstream AST validation). Available\n *  for consumers who construct EinsumSpec objects directly.\n *  @internal */\nexport function isEinsumSpec(x: unknown): x is EinsumSpec {\n  if (typeof x !== 'object' || x === null) return false;\n  const s = x as { contractions?: unknown; free?: unknown };\n  if (!Array.isArray(s.contractions) || !Array.isArray(s.free)) return false;\n  for (const c of s.contractions) {\n    if (typeof c !== 'object' || c === null) return false;\n    const pair = (c as { pair?: unknown }).pair;\n    if (!Array.isArray(pair) || pair.length !== 2) return false;\n    for (const coord of pair) {\n      if (!Array.isArray(coord) || coord.length !== 2) return false;\n      if (typeof coord[0] !== 'number' || typeof coord[1] !== 'number') return false;\n    }\n  }\n  for (const f of s.free) {\n    if (typeof f !== 'object' || f === null) return false;\n    const fa = f as { operand?: unknown; axis?: unknown };\n    if (typeof fa.operand !== 'number' || typeof fa.axis !== 'number') return false;\n  }\n  return true;\n}\n"]}
+{"version":3,"file":"tensor-engine.js","sourceRoot":"","sources":["../../src/numerical/tensor-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH;;;;GAIG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AA4BpD,iIAAiI;AACjI,MAAM,UAAU,UAAU,CAAC,CAAe;IACxC,IAAI,SAAS,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IACrC,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IAClC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,gGAAgG;AAChG,MAAM,UAAU,cAAc,CAAC,CAAe;IAC5C,OAAO,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAChC,CAAC;AAkGD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAoB;IACrD,OAAO,OAAO,MAAM,CAAC,WAAW,KAAK,UAAU;WACxC,OAAO,MAAM,CAAC,WAAW,KAAK,UAAU,CAAC;AAClD,CAAC;AAED;;;;gBAIgB;AAChB,MAAM,UAAU,YAAY,CAAC,CAAU;IACrC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACtD,MAAM,CAAC,GAAG,CAA+C,CAAC;IAC1D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IAC3E,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACtD,MAAM,IAAI,GAAI,CAAwB,CAAC,IAAI,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAC5D,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC9D,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAC;QACjF,CAAC;IACH,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QACtD,MAAM,EAAE,GAAG,CAA0C,CAAC;QACtD,IAAI,OAAO,EAAE,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,EAAE,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;IAClF,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["/**\n * The TensorEngine contract. `MathTSEngine` implements it. See docs/planning/\n * v0.3.5-Design.md §3, §5.\n *\n * `EngineTensor` is an opaque handle; consumers operate on it only through\n * a TensorEngine. The lowering pass (lowering.ts) builds an `EinsumSpec`\n * from `computeContraction()`'s `contractionPairs` and hands it to\n * `engine.einsum()`.\n *\n * @module numerical/tensor-engine\n */\n\nimport type { NestedArray } from './types.js';\n/**\n * Thrown when an engine does not implement a requested capability.\n *\n * @public\n */\nexport { EngineCapabilityError } from './errors.js';\n\n/** Opaque rank-N tensor handle. Each engine backs it with its own storage\n *  (Float64Array, a MathTS Tensor, a future WASM offset); consumers see\n *  only the shape.\n *  @public */\nexport interface EngineTensor {\n  readonly shape: ReadonlyArray<number>;\n}\n\n/**\n * An `EngineTensor` that `@danielsimonjr/mathts-autograd` has wrapped for\n * tracing: a `DualTensor` (forward mode, carries `tangent`) or a\n * `TapedTensor` (reverse mode, carries `tape`). Both implement the traced\n * arithmetic over another wrapped tensor, which is what the engine dispatches\n * to inside an AD call. The autograd package is loaded at that call, so its\n * classes are not named here; this is the shape the package keeps.\n * @internal\n */\nexport interface TracedEngineTensor extends EngineTensor {\n  readonly tangent?: unknown;\n  readonly tape?: unknown;\n  add(other: EngineTensor): EngineTensor;\n  sub(other: EngineTensor): EngineTensor;\n  mul(other: EngineTensor): EngineTensor;\n  scale(k: number): EngineTensor;\n}\n\n/** The AD mode a wrapped tensor carries: `forward` (a `tangent`), `reverse` (a `tape`), or null for a plain tensor. @internal */\nexport function tracedMode(t: EngineTensor): 'forward' | 'reverse' | null {\n  if ('tangent' in t) return 'forward';\n  if ('tape' in t) return 'reverse';\n  return null;\n}\n\n/** Whether `t` is an autograd-wrapped tensor (it carries a `tangent` or a `tape`). @internal */\nexport function isTracedTensor(t: EngineTensor): t is TracedEngineTensor {\n  return tracedMode(t) !== null;\n}\n\n/** One contracted index: the two (operand, axis) coordinates that the\n *  Einstein summation pairs and sums over. Named by the public\n *  {@link EinsumSpec}, so it is public too.\n *  @public */\nexport interface EinsumContraction {\n  readonly pair: readonly [readonly [number, number], readonly [number, number]];\n}\n\n/** One surviving (free) index in the einsum output, in output-axis order:\n *  the operand and the axis of that operand it comes from. Exported because\n *  the public {@link EinsumSpec} names it (the surface is closed under type\n *  references).\n *  @public */\nexport interface EinsumFreeAxis {\n  readonly operand: number;\n  readonly axis: number;\n}\n\n/** The engine-agnostic einsum plan produced by lowering.ts.\n *  @public */\nexport interface EinsumSpec {\n  readonly contractions: ReadonlyArray<EinsumContraction>;\n  readonly free: ReadonlyArray<EinsumFreeAxis>;\n}\n\n/**\n * Result of a forward-mode automatic differentiation pass.\n * `value` is f(x); `jacobian` is the Jacobian of f at x (Jvp with tangent 1).\n * @public\n */\nexport interface ForwardGradResult {\n  readonly value: EngineTensor;\n  readonly jacobian: EngineTensor;\n}\n\n/**\n * Result of a reverse-mode automatic differentiation pass.\n * `value` is f(x); `gradient` is ∂L/∂x for cotangent dL/df (ones-like by default).\n * @public\n */\nexport interface ReverseGradResult {\n  readonly value: EngineTensor;\n  readonly gradient: EngineTensor;\n}\n\n/** The compute contract. MathTSEngine implements it.\n *  @public */\nexport interface TensorEngine {\n  readonly name: string;\n\n  fromNested(data: NestedArray, shape: ReadonlyArray<number>): EngineTensor;\n  toNested(t: EngineTensor): NestedArray;\n\n  einsum(spec: EinsumSpec, ...operands: EngineTensor[]): EngineTensor;\n  matMul(a: EngineTensor, b: EngineTensor): EngineTensor;\n  transpose(t: EngineTensor, perm?: ReadonlyArray<number>): EngineTensor;\n  reshape(t: EngineTensor, shape: ReadonlyArray<number>): EngineTensor;\n\n  add(a: EngineTensor, b: EngineTensor): EngineTensor;\n  sub(a: EngineTensor, b: EngineTensor): EngineTensor;\n  mul(a: EngineTensor, b: EngineTensor): EngineTensor;\n  scale(t: EngineTensor, k: number): EngineTensor;\n\n  identity(n: number): EngineTensor;\n  normInf(t: EngineTensor): number;\n\n  /** Optional — no-op for pure-JS engines; a future native engine implements\n   *  real disposal. evaluateNumerical() never relies on it. */\n  dispose?(t: EngineTensor): void;\n\n  /**\n   * Forward-mode AD (Jacobian-vector product). Always Promise-returning for\n   * uniform consumer semantics (S6 reconciliation fix — no T | Promise<T> union).\n   * Engines without AD support omit this method; call `hasAutogradSupport(engine)`\n   * before invoking.\n   * @public\n   */\n  forwardGrad?(\n    fn: (x: EngineTensor) => EngineTensor,\n    x: EngineTensor,\n  ): Promise<ForwardGradResult>;\n\n  /**\n   * Reverse-mode AD (vector-Jacobian product). `cotangent` defaults to\n   * ones-like(value) when omitted. Always Promise-returning (S6).\n   * Engines without AD support omit this method; call `hasAutogradSupport(engine)`\n   * before invoking.\n   * @public\n   */\n  reverseGrad?(\n    fn: (x: EngineTensor) => EngineTensor,\n    x: EngineTensor,\n    cotangent?: EngineTensor,\n  ): Promise<ReverseGradResult>;\n}\n\n/**\n * Returns `true` iff the engine implements both `forwardGrad` and `reverseGrad`.\n * Use this before invoking AD methods so callers get a clear capability signal\n * rather than a runtime TypeError.\n *\n * @example\n * ```typescript\n * if (!hasAutogradSupport(engine)) {\n *   throw new EngineCapabilityError(engine.name, 'forwardGrad');\n * }\n * const { value, jacobian } = await engine.forwardGrad!(fn, x);\n * ```\n * @public\n */\nexport function hasAutogradSupport(engine: TensorEngine): boolean {\n  return typeof engine.forwardGrad === 'function'\n      && typeof engine.reverseGrad === 'function';\n}\n\n/** Runtime guard for EinsumSpec — validates structure before passing to\n *  engine.einsum(). Not called internally by the lowering pass (which builds\n *  specs via buildEinsumSpec and trusts the upstream AST validation). Available\n *  for consumers who construct EinsumSpec objects directly.\n *  @internal */\nexport function isEinsumSpec(x: unknown): x is EinsumSpec {\n  if (typeof x !== 'object' || x === null) return false;\n  const s = x as { contractions?: unknown; free?: unknown };\n  if (!Array.isArray(s.contractions) || !Array.isArray(s.free)) return false;\n  for (const c of s.contractions) {\n    if (typeof c !== 'object' || c === null) return false;\n    const pair = (c as { pair?: unknown }).pair;\n    if (!Array.isArray(pair) || pair.length !== 2) return false;\n    for (const coord of pair) {\n      if (!Array.isArray(coord) || coord.length !== 2) return false;\n      if (typeof coord[0] !== 'number' || typeof coord[1] !== 'number') return false;\n    }\n  }\n  for (const f of s.free) {\n    if (typeof f !== 'object' || f === null) return false;\n    const fa = f as { operand?: unknown; axis?: unknown };\n    if (typeof fa.operand !== 'number' || typeof fa.axis !== 'number') return false;\n  }\n  return true;\n}\n"]}

package/dist/relations/regime.d.ts

@@ -166,4 +166,14 @@ export interface RegimeBearing {
  * @internal
  */
 export declare function uncoveredRegions(family: string, models: readonly RegimeBearing[], samples: Readonly<Record<string, readonly number[]>>): readonly RegionSample[];
+/**
+ * Build a regime from its family, its dimensioned parameters, its dimensionless
+ * inputs and its inequalities: the one owner of the literal
+ * `{ family, inequalities, groupDefinitions: deriveRegimeGroups(…) }` every
+ * atlas model and bridge used to spell out. The groups are derived here, so an
+ * inequality names a `PiGroup.formula` of the same dimension matrix.
+ *
+ * @internal
+ */
+export declare function makeRegime(family: string, parameters: readonly DimensionalVariable[], dimensionlessInputs: readonly string[], inequalities: readonly RegimeInequality[]): Regime;
 //# sourceMappingURL=regime.d.ts.map

package/dist/relations/regime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regime.d.ts","sourceRoot":"","sources":["../../src/relations/regime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAEjF,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,mBAAmB,EAAE,SAAS,MAAM,EAAE,GACrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBzB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,CAAC;IACjC,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAeD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC5C,WAAW,CAeb;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAsB7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,CAqB7E;AA8FD,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,CAWjE;AAED,qFAAqF;AACrF,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAClD;AAED,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,GACnD,SAAS,YAAY,EAAE,CAgBzB"}
+{"version":3,"file":"regime.d.ts","sourceRoot":"","sources":["../../src/relations/regime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAEjF,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,mBAAmB,EAAE,SAAS,MAAM,EAAE,GACrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBzB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,CAAC;IACjC,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAeD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC5C,WAAW,CAeb;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAsB7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,CAqB7E;AA8FD,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa,CAWjE;AAED,qFAAqF;AACrF,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAClD;AAED,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,GACnD,SAAS,YAAY,EAAE,CAgBzB;AAiBD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,mBAAmB,EAAE,SAAS,MAAM,EAAE,EACtC,YAAY,EAAE,SAAS,gBAAgB,EAAE,GACxC,MAAM,CAMR"}

package/dist/relations/regime.js

@@ -12,6 +12,7 @@
  *
  * @module relations/regime
  */
+import { compareCodepoint } from '../core/compare.js';
 import { buckinghamPi } from '../dimensional/buckingham.js';
 import { DIMENSIONLESS } from '../dimensional/types.js';
 /**
@@ -160,7 +161,7 @@ export function collidingRegimeGroups(regimes) {
 function exponentSignature(group) {
     return Object.entries(group.exponents)
         .filter(([, exp]) => exp !== 0)
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .sort(([a], [b]) => compareCodepoint(a, b))
         .map(([name, exp]) => `${name}:${exp}`)
         .join(',');
 }
@@ -313,4 +314,20 @@ function gridPoints(samples) {
     }
     return points;
 }
+/**
+ * Build a regime from its family, its dimensioned parameters, its dimensionless
+ * inputs and its inequalities: the one owner of the literal
+ * `{ family, inequalities, groupDefinitions: deriveRegimeGroups(…) }` every
+ * atlas model and bridge used to spell out. The groups are derived here, so an
+ * inequality names a `PiGroup.formula` of the same dimension matrix.
+ *
+ * @internal
+ */
+export function makeRegime(family, parameters, dimensionlessInputs, inequalities) {
+    return {
+        family,
+        inequalities,
+        groupDefinitions: deriveRegimeGroups(family, parameters, dimensionlessInputs),
+    };
+}
 //# sourceMappingURL=regime.js.map

package/dist/relations/regime.js.map

@@ -1 +1 @@
-{"version":3,"file":"regime.js","sourceRoot":"","sources":["../../src/relations/regime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Regime derivation — π-groups as the coordinates a regime is written in.\n *\n * Dimensionless inputs are passed INTO `buckinghamPi` as zero-dimension\n * variables and come back as their own trivial groups, keyed by their own\n * names in `PiGroup.formula`. Nothing is synthesized here. (Measured in\n * design note §10 Q1 by executing `buckinghamPi`; the implementation plan's\n * \"plus one trivial group per dimensionless input\" would double-add.)\n *\n * `admitApproximation` stays in `src/atlas/regime.ts`: it is generic over\n * `AtlasBridge`, and moving it would drag that record into this vocabulary.\n *\n * @module relations/regime\n */\n\nimport { buckinghamPi } from '../dimensional/buckingham.js';\nimport type { DimensionalVariable, PiGroup } from '../dimensional/buckingham.js';\nimport { DIMENSIONLESS } from '../dimensional/types.js';\nimport type { Regime, RegimeInequality } from './types.js';\n\n/**\n * Derive the regime coordinates of a family, keyed by `PiGroup.formula`.\n *\n * A dimensionally-independent set has no groups and yields an empty record.\n *\n * @internal\n */\nexport function deriveRegimeGroups(\n  family: string,\n  parameters: readonly DimensionalVariable[],\n  dimensionlessInputs: readonly string[],\n): Record<string, PiGroup> {\n  const variables: DimensionalVariable[] = [\n    ...parameters,\n    ...dimensionlessInputs.map((name) => ({ name, dim: DIMENSIONLESS })),\n  ];\n  if (variables.length === 0) {\n    throw new Error(`deriveRegimeGroups(${family}) requires at least one variable`);\n  }\n  // buckinghamPi rejects duplicate names itself; the message is clearer here.\n  const names = variables.map((v) => v.name);\n  if (new Set(names).size !== names.length) {\n    throw new Error(\n      `deriveRegimeGroups(${family}) requires unique names across parameters and ` +\n        `dimensionless inputs; got [${names.join(', ')}]`,\n    );\n  }\n  const groups: Record<string, PiGroup> = {};\n  for (const group of buckinghamPi(variables).piGroups) groups[group.formula] = group;\n  return groups;\n}\n\n/**\n * Result of {@link regimeHolds} — TRI-STATE, not a boolean.\n *\n * Design note §1, Adam A2 RED #2. The first draft of this rule returned a\n * boolean and folded \"could not check\" into one of the two answers. Both\n * foldings are wrong in a way that is invisible at the call site:\n *\n *   - Folding absence into `true` is a SILENT PASS. A caller who supplies\n *     `{ Ma: 0.1 }` and never computes `Re` gets a confident \"the regime\n *     holds\" while `Re = 50` grossly violates it. The omission of the very\n *     data that would reveal the violation is what produces the pass.\n *   - Folding absence into `false` reports a VIOLATION that was never\n *     observed, which is a different false claim and destroys the caller's\n *     ability to tell \"I measured this and it failed\" from \"I never measured\n *     this\". Only the first licenses saying the regime is violated.\n *\n * So `ok` carries three answers and the two failure sets are kept apart.\n *\n * @public\n */\nexport interface RegimeCheck {\n  /**\n   * `true` — every inequality was CHECKED and satisfied.\n   * `false` — at least one was checked and VIOLATED.\n   * `'unknown'` — nothing was violated, but at least one could NOT be checked.\n   *\n   * `'unknown'` is a failure to confirm validity, NEVER validity. A caller\n   * asking \"may I use this model here?\" must test `=== true`; `!== false` is\n   * the silent pass this type exists to prevent.\n   */\n  readonly ok: boolean | 'unknown';\n  /** CHECKED and violated — carried whole so the caller can name them. */\n  readonly violated: readonly RegimeInequality[];\n  /** NOT checked: the π-group value was absent or non-finite. */\n  readonly unchecked: readonly RegimeInequality[];\n  /**\n   * How many inequalities a finite value reached. `ok: true` with\n   * `checked: 0` is a VACUOUS pass: the regime states no inequality (the\n   * plasma, piezoelectricity and Tolman registrations), so nothing was\n   * checked and nothing held. That is a different fact from a pass over a\n   * non-empty list, and a coverage count must not add it (AGENTS law 4).\n   */\n  readonly checked: number;\n}\n\nfunction satisfies(value: number, ineq: RegimeInequality): boolean {\n  switch (ineq.op) {\n    case '<':\n      return value < ineq.bound;\n    case '<=':\n      return value <= ineq.bound;\n    case '>':\n      return value > ineq.bound;\n    case '>=':\n      return value >= ineq.bound;\n  }\n}\n\n/**\n * Check a regime against measured group values.\n *\n * A group with no supplied value, or a non-finite one, is UNCHECKED — not\n * violated and not satisfied. See {@link RegimeCheck} for why the distinction\n * is load-bearing. A regime with no inequalities returns `true` with\n * `checked: 0`: there was nothing to check and nothing went unchecked, so the\n * claim \"every inequality was checked and satisfied\" is vacuously true rather\n * than unknown, and `checked` says that nothing was checked. A caller that\n * counts coverage reads `checked`, never `ok` alone.\n *\n * A violation outranks an absence: once one inequality is CHECKED and fails,\n * the regime does not hold, whatever the unmeasured coordinates would say.\n *\n * @public\n */\nexport function regimeHolds(\n  regime: Regime,\n  groupValues: Readonly<Record<string, number>>,\n): RegimeCheck {\n  const violated: RegimeInequality[] = [];\n  const unchecked: RegimeInequality[] = [];\n  let checked = 0;\n  for (const ineq of regime.inequalities) {\n    const value = groupValues[ineq.group];\n    if (typeof value !== 'number' || !Number.isFinite(value)) {\n      unchecked.push(ineq);\n      continue;\n    }\n    checked += 1;\n    if (!satisfies(value, ineq)) violated.push(ineq);\n  }\n  const ok = violated.length > 0 ? false : unchecked.length > 0 ? 'unknown' : true;\n  return { ok, violated, unchecked, checked };\n}\n\n// ── Sprint 2: regime algebra and admission ──────────────────────────────────\n\n/**\n * Merge two regimes into the regime that holds where BOTH hold.\n *\n * The conjunction is the whole operation: an inequality from either side is an\n * inequality of the intersection, so the list is concatenated rather than\n * reduced. No attempt is made to simplify `x < 1` and `x < 2` into one\n * inequality — the redundant one is still true, and a simplifier that dropped\n * the wrong one would be a silent change of claim.\n *\n * `groupDefinitions` are merged and CHECKED, not overwritten. Two regimes that\n * key the same `PiGroup.formula` to different exponent vectors are not\n * traceable to one dimension matrix, and quietly keeping one would hand the\n * caller a regime whose group definitions no longer describe its inequalities.\n *\n * @throws Error if the families differ, or if a shared group name carries\n *   conflicting definitions.\n * @internal\n */\nexport function intersectRegimes(a: Regime, b: Regime): Regime {\n  if (a.family !== b.family) {\n    throw new Error(\n      `intersectRegimes: families differ ('${a.family}' vs '${b.family}'); ` +\n        'a regime is stated in the groups of its own family',\n    );\n  }\n  const groupDefinitions: Record<string, PiGroup> = { ...a.groupDefinitions };\n  for (const [name, group] of Object.entries(b.groupDefinitions)) {\n    const existing = groupDefinitions[name];\n    if (existing !== undefined && !samePiGroup(existing, group)) {\n      throw new Error(\n        `intersectRegimes: group '${name}' is defined differently in the two regimes`,\n      );\n    }\n    groupDefinitions[name] = group;\n  }\n  return {\n    family: a.family,\n    inequalities: [...a.inequalities, ...b.inequalities],\n    groupDefinitions,\n  };\n}\n\n/**\n * Group names whose π-groups differ across `regimes`. The path command leaves\n * those names unchecked on every step that defines them. It does not call\n * {@link intersectRegimes}: that function still throws when the families differ.\n *\n * The same key with the same exponent vector is not a collision. A zero\n * exponent is ignored, matching `--at` derivation.\n *\n * @internal\n */\nexport function collidingRegimeGroups(\n  regimes: readonly Regime[],\n): readonly { readonly group: string; readonly families: readonly string[] }[] {\n  const seen = new Map<string, { sig: string; families: string[] }>();\n  const collisions = new Map<string, string[]>();\n  for (const regime of regimes) {\n    for (const [name, group] of Object.entries(regime.groupDefinitions)) {\n      const sig = exponentSignature(group);\n      const prev = seen.get(name);\n      if (prev === undefined) {\n        seen.set(name, { sig, families: [regime.family] });\n        continue;\n      }\n      if (prev.sig === sig) {\n        if (!prev.families.includes(regime.family)) prev.families.push(regime.family);\n        continue;\n      }\n      const families = collisions.get(name) ?? [...prev.families];\n      if (!families.includes(regime.family)) families.push(regime.family);\n      collisions.set(name, families);\n    }\n  }\n  return [...collisions.entries()].map(([group, families]) => ({ group, families }));\n}\n\nfunction exponentSignature(group: PiGroup): string {\n  return Object.entries(group.exponents)\n    .filter(([, exp]) => exp !== 0)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n    .map(([name, exp]) => `${name}:${exp}`)\n    .join(',');\n}\n\nfunction samePiGroup(x: PiGroup, y: PiGroup): boolean {\n  const names = new Set([...Object.keys(x.exponents), ...Object.keys(y.exponents)]);\n  for (const name of names) {\n    if ((x.exponents[name] ?? 0) !== (y.exponents[name] ?? 0)) return false;\n  }\n  return true;\n}\n\n/** A closed-or-open interval on one π-group. Unbounded ends are ±Infinity. */\ninterface GroupInterval {\n  lo: number;\n  loOpen: boolean;\n  hi: number;\n  hiOpen: boolean;\n}\n\nfunction fullInterval(): GroupInterval {\n  return { lo: -Infinity, loOpen: true, hi: Infinity, hiOpen: true };\n}\n\n/** Narrow `iv` in place by one inequality. */\nfunction narrow(iv: GroupInterval, ineq: RegimeInequality): void {\n  switch (ineq.op) {\n    case '<':\n    case '<=': {\n      const open = ineq.op === '<';\n      if (ineq.bound < iv.hi || (ineq.bound === iv.hi && open)) {\n        iv.hi = ineq.bound;\n        iv.hiOpen = open;\n      }\n      return;\n    }\n    case '>':\n    case '>=': {\n      const open = ineq.op === '>';\n      if (ineq.bound > iv.lo || (ineq.bound === iv.lo && open)) {\n        iv.lo = ineq.bound;\n        iv.loOpen = open;\n      }\n      return;\n    }\n  }\n}\n\n/** The per-group intervals the inequalities of a regime carve out. */\nfunction intervalsOf(regime: Regime): Map<string, GroupInterval> {\n  const out = new Map<string, GroupInterval>();\n  for (const ineq of regime.inequalities) {\n    let iv = out.get(ineq.group);\n    if (iv === undefined) {\n      iv = fullInterval();\n      out.set(ineq.group, iv);\n    }\n    narrow(iv, ineq);\n  }\n  return out;\n}\n\nfunction isEmpty(iv: GroupInterval): boolean {\n  if (iv.lo > iv.hi) return true;\n  return iv.lo === iv.hi && (iv.loOpen || iv.hiOpen);\n}\n\nfunction intersectIntervals(x: GroupInterval, y: GroupInterval): GroupInterval {\n  const lo = Math.max(x.lo, y.lo);\n  const hi = Math.min(x.hi, y.hi);\n  return {\n    lo,\n    loOpen: (x.lo === lo && x.loOpen) || (y.lo === lo && y.loOpen),\n    hi,\n    hiOpen: (x.hi === hi && x.hiOpen) || (y.hi === hi && y.hiOpen),\n  };\n}\n\n/** Is every point of `inner` a point of `outer`? */\nfunction contains(outer: GroupInterval, inner: GroupInterval): boolean {\n  if (isEmpty(inner)) return true;\n  const loOk =\n    outer.lo < inner.lo || (outer.lo === inner.lo && (!outer.loOpen || inner.loOpen));\n  const hiOk =\n    outer.hi > inner.hi || (outer.hi === inner.hi && (!outer.hiOpen || inner.hiOpen));\n  return loOk && hiOk;\n}\n\n/** How two regimes sit relative to each other. @internal */\nexport type RegimeOverlap = 'disjoint' | 'overlap' | 'nested';\n\n/**\n * Classify two regimes on the group names they SHARE.\n *\n * Shared names only, and that restriction is the whole subtlety. A group one\n * regime constrains and the other says nothing about cannot separate them:\n * silence is not a constraint, so treating the unconstrained side as empty\n * would report `'disjoint'` for two regimes that genuinely overlap. The answer\n * is therefore about the shared coordinates, and says nothing about the\n * private ones.\n *\n * - `'disjoint'` — some shared group has intervals that cannot both hold.\n * - `'nested'` — the shared box of one regime contains the other (equal boxes,\n *   and the no-shared-group case, are nested: each contains the other).\n * - `'overlap'` — they meet, and neither contains the other.\n *\n * @internal\n */\nexport function regimeOverlap(a: Regime, b: Regime): RegimeOverlap {\n  const ia = intervalsOf(a);\n  const ib = intervalsOf(b);\n  const shared = [...ia.keys()].filter((name) => ib.has(name));\n\n  for (const name of shared) {\n    if (isEmpty(intersectIntervals(ia.get(name)!, ib.get(name)!))) return 'disjoint';\n  }\n  const aInB = shared.every((name) => contains(ib.get(name)!, ia.get(name)!));\n  const bInA = shared.every((name) => contains(ia.get(name)!, ib.get(name)!));\n  return aInB || bInA ? 'nested' : 'overlap';\n}\n\n/** One grid cell of a sampled group box, and the regimes that cover it. @internal */\nexport interface RegionSample {\n  /** The π-group value at this cell, keyed by `PiGroup.formula`. */\n  readonly point: Readonly<Record<string, number>>;\n}\n\n/** A record carrying a regime — `AtlasModel` and `AtlasBridge` both fit. @internal */\nexport interface RegimeBearing {\n  readonly id: string;\n  readonly regime: Regime;\n}\n\n/**\n * Grid-sample a group box and list the cells no regime covers.\n *\n * `samples` IS the box: one explicit axis of values per π-group name. The box\n * is not derived from the bounds the regimes themselves carry, and that is\n * deliberate — a synthesized box would report coverage against an extent this\n * library invented, so \"uncovered\" would measure the guess rather than the\n * atlas. The caller states where it wants to know about.\n *\n * COVERED means some regime returned `true` with at least one inequality\n * checked. An `'unknown'` is NOT coverage, by the same rule that makes\n * {@link regimeHolds} tri-state: a regime whose groups the sample axes never\n * mention has not been shown to apply anywhere. Neither is a vacuous pass: a\n * regime that states no inequality has checked nothing at the point.\n *\n * Records of another family are skipped, so a mixed list is safe to pass.\n *\n * @internal\n */\nexport function uncoveredRegions(\n  family: string,\n  models: readonly RegimeBearing[],\n  samples: Readonly<Record<string, readonly number[]>>,\n): readonly RegionSample[] {\n  const inFamily = models.filter((m) => m.regime.family === family);\n  const uncovered: RegionSample[] = [];\n  for (const point of gridPoints(samples)) {\n    // `checked > 0`: a regime with no inequality passes vacuously and has shown\n    // nothing about this point, so it covers nothing (the rule in `regimeHolds`'s\n    // doc comment: coverage reads `checked`, never `ok` alone).\n    const covered = inFamily.some((m) => {\n      const check = regimeHolds(m.regime, point);\n      return check.ok === true && check.checked > 0;\n    });\n    // An uncovered cell is covered by nothing, by definition; the sample\n    // carries the point and no list that could only ever be empty.\n    if (!covered) uncovered.push({ point });\n  }\n  return uncovered;\n}\n\n/** Cartesian product of the named axes. An axis with no values yields nothing. */\nfunction gridPoints(\n  samples: Readonly<Record<string, readonly number[]>>,\n): readonly Record<string, number>[] {\n  let points: Record<string, number>[] = [{}];\n  for (const [group, axis] of Object.entries(samples)) {\n    const next: Record<string, number>[] = [];\n    for (const base of points) {\n      for (const value of axis) next.push({ ...base, [group]: value });\n    }\n    points = next;\n  }\n  return points;\n}\n"]}
+{"version":3,"file":"regime.js","sourceRoot":"","sources":["../../src/relations/regime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Regime derivation — π-groups as the coordinates a regime is written in.\n *\n * Dimensionless inputs are passed INTO `buckinghamPi` as zero-dimension\n * variables and come back as their own trivial groups, keyed by their own\n * names in `PiGroup.formula`. Nothing is synthesized here. (Measured in\n * design note §10 Q1 by executing `buckinghamPi`; the implementation plan's\n * \"plus one trivial group per dimensionless input\" would double-add.)\n *\n * `admitApproximation` stays in `src/atlas/regime.ts`: it is generic over\n * `AtlasBridge`, and moving it would drag that record into this vocabulary.\n *\n * @module relations/regime\n */\n\nimport { compareCodepoint } from '../core/compare.js';\nimport { buckinghamPi } from '../dimensional/buckingham.js';\nimport type { DimensionalVariable, PiGroup } from '../dimensional/buckingham.js';\nimport { DIMENSIONLESS } from '../dimensional/types.js';\nimport type { Regime, RegimeInequality } from './types.js';\n\n/**\n * Derive the regime coordinates of a family, keyed by `PiGroup.formula`.\n *\n * A dimensionally-independent set has no groups and yields an empty record.\n *\n * @internal\n */\nexport function deriveRegimeGroups(\n  family: string,\n  parameters: readonly DimensionalVariable[],\n  dimensionlessInputs: readonly string[],\n): Record<string, PiGroup> {\n  const variables: DimensionalVariable[] = [\n    ...parameters,\n    ...dimensionlessInputs.map((name) => ({ name, dim: DIMENSIONLESS })),\n  ];\n  if (variables.length === 0) {\n    throw new Error(`deriveRegimeGroups(${family}) requires at least one variable`);\n  }\n  // buckinghamPi rejects duplicate names itself; the message is clearer here.\n  const names = variables.map((v) => v.name);\n  if (new Set(names).size !== names.length) {\n    throw new Error(\n      `deriveRegimeGroups(${family}) requires unique names across parameters and ` +\n        `dimensionless inputs; got [${names.join(', ')}]`,\n    );\n  }\n  const groups: Record<string, PiGroup> = {};\n  for (const group of buckinghamPi(variables).piGroups) groups[group.formula] = group;\n  return groups;\n}\n\n/**\n * Result of {@link regimeHolds} — TRI-STATE, not a boolean.\n *\n * Design note §1, Adam A2 RED #2. The first draft of this rule returned a\n * boolean and folded \"could not check\" into one of the two answers. Both\n * foldings are wrong in a way that is invisible at the call site:\n *\n *   - Folding absence into `true` is a SILENT PASS. A caller who supplies\n *     `{ Ma: 0.1 }` and never computes `Re` gets a confident \"the regime\n *     holds\" while `Re = 50` grossly violates it. The omission of the very\n *     data that would reveal the violation is what produces the pass.\n *   - Folding absence into `false` reports a VIOLATION that was never\n *     observed, which is a different false claim and destroys the caller's\n *     ability to tell \"I measured this and it failed\" from \"I never measured\n *     this\". Only the first licenses saying the regime is violated.\n *\n * So `ok` carries three answers and the two failure sets are kept apart.\n *\n * @public\n */\nexport interface RegimeCheck {\n  /**\n   * `true` — every inequality was CHECKED and satisfied.\n   * `false` — at least one was checked and VIOLATED.\n   * `'unknown'` — nothing was violated, but at least one could NOT be checked.\n   *\n   * `'unknown'` is a failure to confirm validity, NEVER validity. A caller\n   * asking \"may I use this model here?\" must test `=== true`; `!== false` is\n   * the silent pass this type exists to prevent.\n   */\n  readonly ok: boolean | 'unknown';\n  /** CHECKED and violated — carried whole so the caller can name them. */\n  readonly violated: readonly RegimeInequality[];\n  /** NOT checked: the π-group value was absent or non-finite. */\n  readonly unchecked: readonly RegimeInequality[];\n  /**\n   * How many inequalities a finite value reached. `ok: true` with\n   * `checked: 0` is a VACUOUS pass: the regime states no inequality (the\n   * plasma, piezoelectricity and Tolman registrations), so nothing was\n   * checked and nothing held. That is a different fact from a pass over a\n   * non-empty list, and a coverage count must not add it (AGENTS law 4).\n   */\n  readonly checked: number;\n}\n\nfunction satisfies(value: number, ineq: RegimeInequality): boolean {\n  switch (ineq.op) {\n    case '<':\n      return value < ineq.bound;\n    case '<=':\n      return value <= ineq.bound;\n    case '>':\n      return value > ineq.bound;\n    case '>=':\n      return value >= ineq.bound;\n  }\n}\n\n/**\n * Check a regime against measured group values.\n *\n * A group with no supplied value, or a non-finite one, is UNCHECKED — not\n * violated and not satisfied. See {@link RegimeCheck} for why the distinction\n * is load-bearing. A regime with no inequalities returns `true` with\n * `checked: 0`: there was nothing to check and nothing went unchecked, so the\n * claim \"every inequality was checked and satisfied\" is vacuously true rather\n * than unknown, and `checked` says that nothing was checked. A caller that\n * counts coverage reads `checked`, never `ok` alone.\n *\n * A violation outranks an absence: once one inequality is CHECKED and fails,\n * the regime does not hold, whatever the unmeasured coordinates would say.\n *\n * @public\n */\nexport function regimeHolds(\n  regime: Regime,\n  groupValues: Readonly<Record<string, number>>,\n): RegimeCheck {\n  const violated: RegimeInequality[] = [];\n  const unchecked: RegimeInequality[] = [];\n  let checked = 0;\n  for (const ineq of regime.inequalities) {\n    const value = groupValues[ineq.group];\n    if (typeof value !== 'number' || !Number.isFinite(value)) {\n      unchecked.push(ineq);\n      continue;\n    }\n    checked += 1;\n    if (!satisfies(value, ineq)) violated.push(ineq);\n  }\n  const ok = violated.length > 0 ? false : unchecked.length > 0 ? 'unknown' : true;\n  return { ok, violated, unchecked, checked };\n}\n\n// ── Sprint 2: regime algebra and admission ──────────────────────────────────\n\n/**\n * Merge two regimes into the regime that holds where BOTH hold.\n *\n * The conjunction is the whole operation: an inequality from either side is an\n * inequality of the intersection, so the list is concatenated rather than\n * reduced. No attempt is made to simplify `x < 1` and `x < 2` into one\n * inequality — the redundant one is still true, and a simplifier that dropped\n * the wrong one would be a silent change of claim.\n *\n * `groupDefinitions` are merged and CHECKED, not overwritten. Two regimes that\n * key the same `PiGroup.formula` to different exponent vectors are not\n * traceable to one dimension matrix, and quietly keeping one would hand the\n * caller a regime whose group definitions no longer describe its inequalities.\n *\n * @throws Error if the families differ, or if a shared group name carries\n *   conflicting definitions.\n * @internal\n */\nexport function intersectRegimes(a: Regime, b: Regime): Regime {\n  if (a.family !== b.family) {\n    throw new Error(\n      `intersectRegimes: families differ ('${a.family}' vs '${b.family}'); ` +\n        'a regime is stated in the groups of its own family',\n    );\n  }\n  const groupDefinitions: Record<string, PiGroup> = { ...a.groupDefinitions };\n  for (const [name, group] of Object.entries(b.groupDefinitions)) {\n    const existing = groupDefinitions[name];\n    if (existing !== undefined && !samePiGroup(existing, group)) {\n      throw new Error(\n        `intersectRegimes: group '${name}' is defined differently in the two regimes`,\n      );\n    }\n    groupDefinitions[name] = group;\n  }\n  return {\n    family: a.family,\n    inequalities: [...a.inequalities, ...b.inequalities],\n    groupDefinitions,\n  };\n}\n\n/**\n * Group names whose π-groups differ across `regimes`. The path command leaves\n * those names unchecked on every step that defines them. It does not call\n * {@link intersectRegimes}: that function still throws when the families differ.\n *\n * The same key with the same exponent vector is not a collision. A zero\n * exponent is ignored, matching `--at` derivation.\n *\n * @internal\n */\nexport function collidingRegimeGroups(\n  regimes: readonly Regime[],\n): readonly { readonly group: string; readonly families: readonly string[] }[] {\n  const seen = new Map<string, { sig: string; families: string[] }>();\n  const collisions = new Map<string, string[]>();\n  for (const regime of regimes) {\n    for (const [name, group] of Object.entries(regime.groupDefinitions)) {\n      const sig = exponentSignature(group);\n      const prev = seen.get(name);\n      if (prev === undefined) {\n        seen.set(name, { sig, families: [regime.family] });\n        continue;\n      }\n      if (prev.sig === sig) {\n        if (!prev.families.includes(regime.family)) prev.families.push(regime.family);\n        continue;\n      }\n      const families = collisions.get(name) ?? [...prev.families];\n      if (!families.includes(regime.family)) families.push(regime.family);\n      collisions.set(name, families);\n    }\n  }\n  return [...collisions.entries()].map(([group, families]) => ({ group, families }));\n}\n\nfunction exponentSignature(group: PiGroup): string {\n  return Object.entries(group.exponents)\n    .filter(([, exp]) => exp !== 0)\n    .sort(([a], [b]) => compareCodepoint(a, b))\n    .map(([name, exp]) => `${name}:${exp}`)\n    .join(',');\n}\n\nfunction samePiGroup(x: PiGroup, y: PiGroup): boolean {\n  const names = new Set([...Object.keys(x.exponents), ...Object.keys(y.exponents)]);\n  for (const name of names) {\n    if ((x.exponents[name] ?? 0) !== (y.exponents[name] ?? 0)) return false;\n  }\n  return true;\n}\n\n/** A closed-or-open interval on one π-group. Unbounded ends are ±Infinity. */\ninterface GroupInterval {\n  lo: number;\n  loOpen: boolean;\n  hi: number;\n  hiOpen: boolean;\n}\n\nfunction fullInterval(): GroupInterval {\n  return { lo: -Infinity, loOpen: true, hi: Infinity, hiOpen: true };\n}\n\n/** Narrow `iv` in place by one inequality. */\nfunction narrow(iv: GroupInterval, ineq: RegimeInequality): void {\n  switch (ineq.op) {\n    case '<':\n    case '<=': {\n      const open = ineq.op === '<';\n      if (ineq.bound < iv.hi || (ineq.bound === iv.hi && open)) {\n        iv.hi = ineq.bound;\n        iv.hiOpen = open;\n      }\n      return;\n    }\n    case '>':\n    case '>=': {\n      const open = ineq.op === '>';\n      if (ineq.bound > iv.lo || (ineq.bound === iv.lo && open)) {\n        iv.lo = ineq.bound;\n        iv.loOpen = open;\n      }\n      return;\n    }\n  }\n}\n\n/** The per-group intervals the inequalities of a regime carve out. */\nfunction intervalsOf(regime: Regime): Map<string, GroupInterval> {\n  const out = new Map<string, GroupInterval>();\n  for (const ineq of regime.inequalities) {\n    let iv = out.get(ineq.group);\n    if (iv === undefined) {\n      iv = fullInterval();\n      out.set(ineq.group, iv);\n    }\n    narrow(iv, ineq);\n  }\n  return out;\n}\n\nfunction isEmpty(iv: GroupInterval): boolean {\n  if (iv.lo > iv.hi) return true;\n  return iv.lo === iv.hi && (iv.loOpen || iv.hiOpen);\n}\n\nfunction intersectIntervals(x: GroupInterval, y: GroupInterval): GroupInterval {\n  const lo = Math.max(x.lo, y.lo);\n  const hi = Math.min(x.hi, y.hi);\n  return {\n    lo,\n    loOpen: (x.lo === lo && x.loOpen) || (y.lo === lo && y.loOpen),\n    hi,\n    hiOpen: (x.hi === hi && x.hiOpen) || (y.hi === hi && y.hiOpen),\n  };\n}\n\n/** Is every point of `inner` a point of `outer`? */\nfunction contains(outer: GroupInterval, inner: GroupInterval): boolean {\n  if (isEmpty(inner)) return true;\n  const loOk =\n    outer.lo < inner.lo || (outer.lo === inner.lo && (!outer.loOpen || inner.loOpen));\n  const hiOk =\n    outer.hi > inner.hi || (outer.hi === inner.hi && (!outer.hiOpen || inner.hiOpen));\n  return loOk && hiOk;\n}\n\n/** How two regimes sit relative to each other. @internal */\nexport type RegimeOverlap = 'disjoint' | 'overlap' | 'nested';\n\n/**\n * Classify two regimes on the group names they SHARE.\n *\n * Shared names only, and that restriction is the whole subtlety. A group one\n * regime constrains and the other says nothing about cannot separate them:\n * silence is not a constraint, so treating the unconstrained side as empty\n * would report `'disjoint'` for two regimes that genuinely overlap. The answer\n * is therefore about the shared coordinates, and says nothing about the\n * private ones.\n *\n * - `'disjoint'` — some shared group has intervals that cannot both hold.\n * - `'nested'` — the shared box of one regime contains the other (equal boxes,\n *   and the no-shared-group case, are nested: each contains the other).\n * - `'overlap'` — they meet, and neither contains the other.\n *\n * @internal\n */\nexport function regimeOverlap(a: Regime, b: Regime): RegimeOverlap {\n  const ia = intervalsOf(a);\n  const ib = intervalsOf(b);\n  const shared = [...ia.keys()].filter((name) => ib.has(name));\n\n  for (const name of shared) {\n    if (isEmpty(intersectIntervals(ia.get(name)!, ib.get(name)!))) return 'disjoint';\n  }\n  const aInB = shared.every((name) => contains(ib.get(name)!, ia.get(name)!));\n  const bInA = shared.every((name) => contains(ia.get(name)!, ib.get(name)!));\n  return aInB || bInA ? 'nested' : 'overlap';\n}\n\n/** One grid cell of a sampled group box, and the regimes that cover it. @internal */\nexport interface RegionSample {\n  /** The π-group value at this cell, keyed by `PiGroup.formula`. */\n  readonly point: Readonly<Record<string, number>>;\n}\n\n/** A record carrying a regime — `AtlasModel` and `AtlasBridge` both fit. @internal */\nexport interface RegimeBearing {\n  readonly id: string;\n  readonly regime: Regime;\n}\n\n/**\n * Grid-sample a group box and list the cells no regime covers.\n *\n * `samples` IS the box: one explicit axis of values per π-group name. The box\n * is not derived from the bounds the regimes themselves carry, and that is\n * deliberate — a synthesized box would report coverage against an extent this\n * library invented, so \"uncovered\" would measure the guess rather than the\n * atlas. The caller states where it wants to know about.\n *\n * COVERED means some regime returned `true` with at least one inequality\n * checked. An `'unknown'` is NOT coverage, by the same rule that makes\n * {@link regimeHolds} tri-state: a regime whose groups the sample axes never\n * mention has not been shown to apply anywhere. Neither is a vacuous pass: a\n * regime that states no inequality has checked nothing at the point.\n *\n * Records of another family are skipped, so a mixed list is safe to pass.\n *\n * @internal\n */\nexport function uncoveredRegions(\n  family: string,\n  models: readonly RegimeBearing[],\n  samples: Readonly<Record<string, readonly number[]>>,\n): readonly RegionSample[] {\n  const inFamily = models.filter((m) => m.regime.family === family);\n  const uncovered: RegionSample[] = [];\n  for (const point of gridPoints(samples)) {\n    // `checked > 0`: a regime with no inequality passes vacuously and has shown\n    // nothing about this point, so it covers nothing (the rule in `regimeHolds`'s\n    // doc comment: coverage reads `checked`, never `ok` alone).\n    const covered = inFamily.some((m) => {\n      const check = regimeHolds(m.regime, point);\n      return check.ok === true && check.checked > 0;\n    });\n    // An uncovered cell is covered by nothing, by definition; the sample\n    // carries the point and no list that could only ever be empty.\n    if (!covered) uncovered.push({ point });\n  }\n  return uncovered;\n}\n\n/** Cartesian product of the named axes. An axis with no values yields nothing. */\nfunction gridPoints(\n  samples: Readonly<Record<string, readonly number[]>>,\n): readonly Record<string, number>[] {\n  let points: Record<string, number>[] = [{}];\n  for (const [group, axis] of Object.entries(samples)) {\n    const next: Record<string, number>[] = [];\n    for (const base of points) {\n      for (const value of axis) next.push({ ...base, [group]: value });\n    }\n    points = next;\n  }\n  return points;\n}\n\n/**\n * Build a regime from its family, its dimensioned parameters, its dimensionless\n * inputs and its inequalities: the one owner of the literal\n * `{ family, inequalities, groupDefinitions: deriveRegimeGroups(…) }` every\n * atlas model and bridge used to spell out. The groups are derived here, so an\n * inequality names a `PiGroup.formula` of the same dimension matrix.\n *\n * @internal\n */\nexport function makeRegime(\n  family: string,\n  parameters: readonly DimensionalVariable[],\n  dimensionlessInputs: readonly string[],\n  inequalities: readonly RegimeInequality[],\n): Regime {\n  return {\n    family,\n    inequalities,\n    groupDefinitions: deriveRegimeGroups(family, parameters, dimensionlessInputs),\n  };\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-physics-tensor",
-  "version": "10.0.0",
+  "version": "11.0.0",
   "description": "Computational framework for exploring unified physics through tensor formalism",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -98,13 +98,13 @@
   },
   "homepage": "https://github.com/danielsimonjr/Universal-Physics-Tensor#readme",
   "dependencies": {
-    "@danielsimonjr/mathts-autograd": "^0.3.16",
-    "@danielsimonjr/mathts-core": "^0.16.0",
-    "@danielsimonjr/mathts-expression": "^0.10.0",
-    "@danielsimonjr/mathts-functions": "^0.68.0",
-    "@danielsimonjr/mathts-matrix": "^0.7.6",
+    "@danielsimonjr/mathts-autograd": "^0.3.18",
+    "@danielsimonjr/mathts-core": "^0.18.1",
+    "@danielsimonjr/mathts-expression": "^0.10.2",
+    "@danielsimonjr/mathts-functions": "^0.68.5",
+    "@danielsimonjr/mathts-matrix": "^0.7.8",
     "@danielsimonjr/mathts-parallel": "^0.6.8",
-    "@danielsimonjr/mathts-tensor": "^0.2.22",
+    "@danielsimonjr/mathts-tensor": "^0.2.24",
     "@danielsimonjr/mathts-wasm": "^0.3.0",
     "@danielsimonjr/mathts-workerpool": "^0.2.6"
   },