universal-physics-tensor 10.0.0 → 11.0.0

package/dist/dimensional/algebra.js.map

@@ -1 +1 @@
-{"version":3,"file":"algebra.js","sourceRoot":"","sources":["../../src/dimensional/algebra.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Dimensional algebra: per-base-exponent arithmetic.\n *\n * Operations follow standard dimensional analysis (Bridgman, \"Dimensional Analysis\", 1922):\n *   - multiply: add exponents per base\n *   - divide:   subtract exponents per base\n *   - power:    scale exponents by the scalar `n`\n *   - add/sub:  permitted only when both operands have the same dimension\n *\n * @module dimensional/algebra\n */\n\nimport { Dimension, NAMED_DIMENSIONS } from './types.js';\nimport { DimensionMismatchError } from './errors.js';\n\n/**\n * Re-exported for callers that import the error from the algebra module.\n * The definition lives in `errors.ts`.\n *\n * @public\n */\nexport { DimensionMismatchError } from './errors.js';\n\nconst BASES = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'] as const;\ntype Base = typeof BASES[number];\n\n/** Product of two dimensions: exponents add per base. */\nexport function multiply(a: Dimension, b: Dimension): Dimension {\n  const out = {} as Dimension;\n  for (const base of BASES) {\n    out[base as Base] = a[base as Base] + b[base as Base];\n  }\n  return out;\n}\n\n/** Quotient of two dimensions: exponents subtract per base. */\nexport function divide(a: Dimension, b: Dimension): Dimension {\n  const out = {} as Dimension;\n  for (const base of BASES) {\n    out[base as Base] = a[base as Base] - b[base as Base];\n  }\n  return out;\n}\n\n/** Raise a dimension to a (possibly fractional) power: exponents scale by `n`. */\nexport function power(a: Dimension, n: number): Dimension {\n  const out = {} as Dimension;\n  for (const base of BASES) {\n    out[base as Base] = a[base as Base] * n;\n  }\n  return out;\n}\n\n/**\n * Largest exponent difference still treated as equal. Physical dimension\n * exponents are integers or simple rationals (halves, thirds), so any genuine\n * distinction is ≥ ~1/3 — far above this tolerance, which only absorbs\n * floating-point round-off in fractional powers (v0.20 dimensionful `M^0.5`\n * reached by different op chains, e.g. 0.30000000000000004 vs 0.3).\n */\nexport const EXPONENT_TOL = 1e-9;\n\n/**\n * True iff two dimensions have equal exponents on every base, within\n * `EXPONENT_TOL` so floating-point round-off in fractional exponents does not\n * read as unequal.\n *\n * Unrolled over the 7 bases (no iterator / dynamic-key access) and\n * short-circuiting — `equals` is on the hot path (every `add`/`subtract`, and\n * `format`'s named-dimension scan calls it per entry). Stays distinct from\n * `linkage.ts`'s exact `dimEqual`: this one is tolerant by design (the v0.20\n * fractional-power round-off fix), so they are NOT the same predicate.\n */\nexport function equals(a: Dimension, b: Dimension): boolean {\n  return (\n    Math.abs(a.L - b.L) <= EXPONENT_TOL &&\n    Math.abs(a.M - b.M) <= EXPONENT_TOL &&\n    Math.abs(a.T - b.T) <= EXPONENT_TOL &&\n    Math.abs(a.I - b.I) <= EXPONENT_TOL &&\n    Math.abs(a.Theta - b.Theta) <= EXPONENT_TOL &&\n    Math.abs(a.N - b.N) <= EXPONENT_TOL &&\n    Math.abs(a.J - b.J) <= EXPONENT_TOL\n  );\n}\n\n/** Dimensional sum: requires equal dimensions, else throws `DimensionMismatchError`. */\nexport function add(a: Dimension, b: Dimension): Dimension {\n  if (!equals(a, b)) {\n    throw new DimensionMismatchError(\n      `Cannot add unlike dimensions: ${format(a)} + ${format(b)}`,\n      a,\n      b,\n    );\n  }\n  return { ...a };\n}\n\n/** Dimensional difference: requires equal dimensions, else throws `DimensionMismatchError`. */\nexport function subtract(a: Dimension, b: Dimension): Dimension {\n  if (!equals(a, b)) {\n    throw new DimensionMismatchError(\n      `Cannot subtract unlike dimensions: ${format(a)} - ${format(b)}`,\n      a,\n      b,\n    );\n  }\n  return { ...a };\n}\n\n/**\n * Format a `Dimension` for human display.\n *\n * Strategy:\n *   1. If `d` matches a named SI dimension exactly, return e.g. \"[energy]\".\n *      \"dimensionless\" is rendered as \"[1]\" for compactness.\n *   2. Otherwise emit the bracketed product form, e.g. \"[M L^2 T^-2]\".\n *      Bases with exponent 0 are omitted; exponent 1 is written without \"^1\".\n */\nexport function format(d: Dimension): string {\n  for (const [name, ref] of NAMED_DIMENSIONS) {\n    if (equals(d, ref)) {\n      if (name === 'dimensionless') return '[1]';\n      return `[${name}]`;\n    }\n  }\n  const parts: string[] = [];\n  for (const base of BASES) {\n    const exp = d[base as Base];\n    if (exp === 0) continue;\n    if (exp === 1) parts.push(base);\n    else parts.push(`${base}^${exp}`);\n  }\n  if (parts.length === 0) return '[1]';\n  return `[${parts.join(' ')}]`;\n}\n"]}
+{"version":3,"file":"algebra.js","sourceRoot":"","sources":["../../src/dimensional/algebra.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Dimensional algebra: per-base-exponent arithmetic.\n *\n * Operations follow standard dimensional analysis (Bridgman, \"Dimensional Analysis\", 1922):\n *   - multiply: add exponents per base\n *   - divide:   subtract exponents per base\n *   - power:    scale exponents by the scalar `n`\n *   - add/sub:  permitted only when both operands have the same dimension\n *\n * @module dimensional/algebra\n */\n\nimport { Dimension, NAMED_DIMENSIONS } from './types.js';\nimport { DimensionMismatchError } from './errors.js';\n\n/**\n * Re-exported for callers that import the error from the algebra module.\n * The definition lives in `errors.ts`.\n *\n * @public\n */\nexport { DimensionMismatchError } from './errors.js';\n\n/** The seven SI bases, in the order every exponent list is written. @internal */\nexport const BASES = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'] as const;\ntype Base = typeof BASES[number];\n\n/** Exact zero on every base; a base missing from a partial object reads as 0. @internal */\nexport function isDimensionless(d: Dimension): boolean {\n  return BASES.every((base) => (d[base] ?? 0) === 0);\n}\n\n/**\n * Exact equality on every base, no tolerance: the predicate for exponents that\n * were never computed. {@link equals} is the tolerant one for exponents that\n * were (a fractional power reached by different op chains).\n * @internal\n */\nexport function exactlyEquals(a: Dimension, b: Dimension): boolean {\n  return BASES.every((base) => (a[base] ?? 0) === (b[base] ?? 0));\n}\n\n/** Product of two dimensions: exponents add per base. */\nexport function multiply(a: Dimension, b: Dimension): Dimension {\n  const out = {} as Dimension;\n  for (const base of BASES) {\n    out[base as Base] = a[base as Base] + b[base as Base];\n  }\n  return out;\n}\n\n/** Quotient of two dimensions: exponents subtract per base. */\nexport function divide(a: Dimension, b: Dimension): Dimension {\n  const out = {} as Dimension;\n  for (const base of BASES) {\n    out[base as Base] = a[base as Base] - b[base as Base];\n  }\n  return out;\n}\n\n/** Raise a dimension to a (possibly fractional) power: exponents scale by `n`. */\nexport function power(a: Dimension, n: number): Dimension {\n  const out = {} as Dimension;\n  for (const base of BASES) {\n    out[base as Base] = a[base as Base] * n;\n  }\n  return out;\n}\n\n/**\n * Largest exponent difference still treated as equal. Physical dimension\n * exponents are integers or simple rationals (halves, thirds), so any genuine\n * distinction is ≥ ~1/3 — far above this tolerance, which only absorbs\n * floating-point round-off in fractional powers (v0.20 dimensionful `M^0.5`\n * reached by different op chains, e.g. 0.30000000000000004 vs 0.3).\n */\nexport const EXPONENT_TOL = 1e-9;\n\n/**\n * True iff two dimensions have equal exponents on every base, within\n * `EXPONENT_TOL` so floating-point round-off in fractional exponents does not\n * read as unequal.\n *\n * Unrolled over the 7 bases (no iterator / dynamic-key access) and\n * short-circuiting — `equals` is on the hot path (every `add`/`subtract`, and\n * `format`'s named-dimension scan calls it per entry). Stays distinct from\n * `linkage.ts`'s exact `dimEqual`: this one is tolerant by design (the v0.20\n * fractional-power round-off fix), so they are NOT the same predicate.\n */\nexport function equals(a: Dimension, b: Dimension): boolean {\n  return (\n    Math.abs(a.L - b.L) <= EXPONENT_TOL &&\n    Math.abs(a.M - b.M) <= EXPONENT_TOL &&\n    Math.abs(a.T - b.T) <= EXPONENT_TOL &&\n    Math.abs(a.I - b.I) <= EXPONENT_TOL &&\n    Math.abs(a.Theta - b.Theta) <= EXPONENT_TOL &&\n    Math.abs(a.N - b.N) <= EXPONENT_TOL &&\n    Math.abs(a.J - b.J) <= EXPONENT_TOL\n  );\n}\n\n/** Dimensional sum: requires equal dimensions, else throws `DimensionMismatchError`. */\nexport function add(a: Dimension, b: Dimension): Dimension {\n  if (!equals(a, b)) {\n    throw new DimensionMismatchError(\n      `Cannot add unlike dimensions: ${format(a)} + ${format(b)}`,\n      a,\n      b,\n    );\n  }\n  return { ...a };\n}\n\n/** Dimensional difference: requires equal dimensions, else throws `DimensionMismatchError`. */\nexport function subtract(a: Dimension, b: Dimension): Dimension {\n  if (!equals(a, b)) {\n    throw new DimensionMismatchError(\n      `Cannot subtract unlike dimensions: ${format(a)} - ${format(b)}`,\n      a,\n      b,\n    );\n  }\n  return { ...a };\n}\n\n/**\n * Format a `Dimension` for human display.\n *\n * Strategy:\n *   1. If `d` matches a named SI dimension exactly, return e.g. \"[energy]\".\n *      \"dimensionless\" is rendered as \"[1]\" for compactness.\n *   2. Otherwise emit the bracketed product form, e.g. \"[M L^2 T^-2]\".\n *      Bases with exponent 0 are omitted; exponent 1 is written without \"^1\".\n */\nexport function format(d: Dimension): string {\n  for (const [name, ref] of NAMED_DIMENSIONS) {\n    if (equals(d, ref)) {\n      if (name === 'dimensionless') return '[1]';\n      return `[${name}]`;\n    }\n  }\n  const parts: string[] = [];\n  for (const base of BASES) {\n    const exp = d[base as Base];\n    if (exp === 0) continue;\n    if (exp === 1) parts.push(base);\n    else parts.push(`${base}^${exp}`);\n  }\n  if (parts.length === 0) return '[1]';\n  return `[${parts.join(' ')}]`;\n}\n\n/** Each base with its coherent SI unit, kilogram first (the order `siUnitOf` prints). @internal */\nexport const SI_BASE: readonly (readonly [keyof Dimension, string])[] = [\n  ['M', 'kg'],\n  ['L', 'm'],\n  ['T', 's'],\n  ['I', 'A'],\n  ['Theta', 'K'],\n  ['N', 'mol'],\n  ['J', 'cd'],\n];\n\n/**\n * A dimension as SI base units, numerator before one `/` (`m^3/(kg*s^2)`), a bare denominator as\n * negative powers (`s^-1`), and `1` when dimensionless: the forms `parseUnit` reads back.\n */\nexport function siUnitOf(dim: Dimension): string {\n  const factor = (u: string, e: number): string => (e === 1 ? u : `${u}^${e}`);\n  const num = SI_BASE.filter(([k]) => dim[k] > 0).map(([k, u]) => factor(u, dim[k]));\n  const den = SI_BASE.filter(([k]) => dim[k] < 0).map(([k, u]) => factor(u, -dim[k]));\n  if (num.length === 0 && den.length === 0) return '1';\n  if (num.length === 0) return SI_BASE.filter(([k]) => dim[k] < 0).map(([k, u]) => factor(u, dim[k])).join('*');\n  if (den.length === 0) return num.join('*');\n  return `${num.join('*')}/${den.length === 1 ? den[0] : `(${den.join('*')})`}`;\n}\n"]}

package/dist/dimensional/ast-builders.d.ts

@@ -23,4 +23,11 @@ export declare function sym(name: string, dim: Dimension): ExprNode;
  * are reachable from the one builder.
  */
 export declare function dim(L?: number, M?: number, T?: number, I?: number, Theta?: number, N?: number, J?: number): Dimension;
+/**
+ * `base ^ exponent`, with the exponent a dimensionless literal written `String(exponent)`;
+ * exponent 1 returns `base` itself. The factor both monomial builders share
+ * (`monomialToExpr` in composition/probe/generator.ts, `fromMonomial` in
+ * composition/proposed-bridges.ts), which arrange their factors differently.
+ */
+export declare function symbolPower(base: ExprNode, exponent: number): ExprNode;
 //# sourceMappingURL=ast-builders.d.ts.map

package/dist/dimensional/ast-builders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast-builders.d.ts","sourceRoot":"","sources":["../../src/dimensional/ast-builders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,mEAAmE;AACnE,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,QAAQ,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,KAAK,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,GAAG,SAAS,CAElF"}
+{"version":3,"file":"ast-builders.d.ts","sourceRoot":"","sources":["../../src/dimensional/ast-builders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,mEAAmE;AACnE,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,QAAQ,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,KAAK,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,GAAG,SAAS,CAElF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAGtE"}

package/dist/dimensional/ast-builders.js

@@ -25,4 +25,15 @@ export function sym(name, dim) {
 export function dim(L = 0, M = 0, T = 0, I = 0, Theta = 0, N = 0, J = 0) {
     return { L, M, T, I, Theta, N, J };
 }
+/**
+ * `base ^ exponent`, with the exponent a dimensionless literal written `String(exponent)`;
+ * exponent 1 returns `base` itself. The factor both monomial builders share
+ * (`monomialToExpr` in composition/probe/generator.ts, `fromMonomial` in
+ * composition/proposed-bridges.ts), which arrange their factors differently.
+ */
+export function symbolPower(base, exponent) {
+    if (exponent === 1)
+        return base;
+    return { kind: 'op', op: '^', args: [base, sym(String(exponent), dim())] };
+}
 //# sourceMappingURL=ast-builders.js.map

package/dist/dimensional/ast-builders.js.map

@@ -1 +1 @@
-{"version":3,"file":"ast-builders.js","sourceRoot":"","sources":["../../src/dimensional/ast-builders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,mEAAmE;AACnE,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,GAAc;IAC9C,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC;IACrE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACrC,CAAC","sourcesContent":["/**\n * Tiny pure builders for dimensional ASTs — `sym` (a symbol leaf) and `dim`\n * (a `Dimension` from its first five base exponents). These were copy-pasted\n * across the bridge-equation helpers, the canonical L1 builder, the\n * composition layer, and the formula transpiler; this module is their single\n * source of truth.\n *\n * Deliberately depends only on TYPES (`ExprNode`, `Dimension`), so it has no\n * runtime imports and can be imported from any layer without risking a cycle.\n * `_be-helpers` and `_l1-build` re-export `sym`/`dim` for their existing\n * importers, so most call sites are unchanged.\n *\n * @module dimensional/ast-builders\n */\n\nimport type { ExprNode } from './validator.js';\nimport type { Dimension } from './types.js';\n\n/** A symbol-leaf `ExprNode` carrying its name and SI dimension. */\nexport function sym(name: string, dim: Dimension): ExprNode {\n  return { kind: 'symbol', name, dim };\n}\n\n/**\n * Build a `Dimension` from its base exponents. Arg order is\n * (L, M, T, **I**, **Θ**, N, J) — note I precedes Θ; every omitted exponent\n * is 0, so the amount-of-substance (N) and luminous-intensity (J) exponents\n * are reachable from the one builder.\n */\nexport function dim(L = 0, M = 0, T = 0, I = 0, Theta = 0, N = 0, J = 0): Dimension {\n  return { L, M, T, I, Theta, N, J };\n}\n"]}
+{"version":3,"file":"ast-builders.js","sourceRoot":"","sources":["../../src/dimensional/ast-builders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,mEAAmE;AACnE,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,GAAc;IAC9C,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC;IACrE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACrC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAc,EAAE,QAAgB;IAC1D,IAAI,QAAQ,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAChC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;AAC7E,CAAC","sourcesContent":["/**\n * Tiny pure builders for dimensional ASTs — `sym` (a symbol leaf) and `dim`\n * (a `Dimension` from its first five base exponents). These were copy-pasted\n * across the bridge-equation helpers, the canonical L1 builder, the\n * composition layer, and the formula transpiler; this module is their single\n * source of truth.\n *\n * Deliberately depends only on TYPES (`ExprNode`, `Dimension`), so it has no\n * runtime imports and can be imported from any layer without risking a cycle.\n * `_be-helpers` and `_l1-build` re-export `sym`/`dim` for their existing\n * importers, so most call sites are unchanged.\n *\n * @module dimensional/ast-builders\n */\n\nimport type { ExprNode } from './validator.js';\nimport type { Dimension } from './types.js';\n\n/** A symbol-leaf `ExprNode` carrying its name and SI dimension. */\nexport function sym(name: string, dim: Dimension): ExprNode {\n  return { kind: 'symbol', name, dim };\n}\n\n/**\n * Build a `Dimension` from its base exponents. Arg order is\n * (L, M, T, **I**, **Θ**, N, J) — note I precedes Θ; every omitted exponent\n * is 0, so the amount-of-substance (N) and luminous-intensity (J) exponents\n * are reachable from the one builder.\n */\nexport function dim(L = 0, M = 0, T = 0, I = 0, Theta = 0, N = 0, J = 0): Dimension {\n  return { L, M, T, I, Theta, N, J };\n}\n\n/**\n * `base ^ exponent`, with the exponent a dimensionless literal written `String(exponent)`;\n * exponent 1 returns `base` itself. The factor both monomial builders share\n * (`monomialToExpr` in composition/probe/generator.ts, `fromMonomial` in\n * composition/proposed-bridges.ts), which arrange their factors differently.\n */\nexport function symbolPower(base: ExprNode, exponent: number): ExprNode {\n  if (exponent === 1) return base;\n  return { kind: 'op', op: '^', args: [base, sym(String(exponent), dim())] };\n}\n"]}

package/dist/dimensional/ast-leaves.d.ts

@@ -0,0 +1,81 @@
+/**
+ * One owner for the scalar-leaf walk of an `ExprNode` and the literal rule.
+ *
+ * Thirteen walks over the leaves and six spellings of "is this name a number"
+ * once lived in the funnel, the probe and the canonical layer, and they
+ * disagreed on the edges: one accepted `0x2`, one rejected `1e3`, and several
+ * accepted the empty string (`Number('')` is `0`). The rule here is the
+ * validator's decimal-literal grammar, so a formula is read the same way
+ * everywhere it is read.
+ *
+ * The walker descends into `op` arguments always. Every other arm is opted
+ * into by the caller through {@link LeafWalkArms}, because the callers it
+ * replaced did not agree on which arms they walked (the evaluator reads
+ * `transcendental` and `abs`; the simplifier reads an integral's measure and
+ * integrand but not its bounds), and the behaviour of each is kept by passing
+ * its own set.
+ *
+ * @module dimensional/ast-leaves
+ */
+import type { ExprNode } from './ast-types.js';
+/** A scalar leaf: a symbol with its dimension. @internal */
+export type ScalarLeaf = Extract<ExprNode, {
+    kind: 'symbol';
+}>;
+/**
+ * The decimal-literal grammar: an optional sign, digits with an optional
+ * fraction (or a bare fraction), and an optional exponent. `1e3` and `2.` are
+ * literals; `0x2`, `Infinity` and the empty string are not. This is the
+ * validator's rule for a literal exponent.
+ *
+ * @internal
+ */
+export declare const DECIMAL_LITERAL: RegExp;
+/** True when `name` is a decimal literal under {@link DECIMAL_LITERAL}. @internal */
+export declare function isDecimalLiteral(name: string): boolean;
+/**
+ * The number a decimal-literal symbol names, or `undefined` for any other
+ * node. The dimension stored on the symbol is not read: a caller that needs
+ * the literal to be dimensionless checks that itself.
+ *
+ * @internal
+ */
+export declare function literalValue(node: ExprNode): number | undefined;
+/**
+ * Which non-`op` arms a walk descends into. `op` arguments are always walked.
+ * An arm left out is not entered, and its leaves are not visited.
+ *
+ * @internal
+ */
+export interface LeafWalkArms {
+    /** `exp`, `ln`, the trigonometric functions: their argument. */
+    readonly transcendental?: boolean;
+    /** `abs`: its argument. */
+    readonly abs?: boolean;
+    /** `dirac-delta`: its argument. */
+    readonly diracDelta?: boolean;
+    /** `integral`: the measure and the integrand, or those and both bounds. */
+    readonly integral?: 'over+integrand' | 'all';
+    /** `derivative`: `of` and `wrt`. */
+    readonly derivative?: boolean;
+    /** `variational-derivative`: the functional, the field and the measure. */
+    readonly variationalDerivative?: boolean;
+    /** `tensor-product`: its arguments. */
+    readonly tensorProduct?: boolean;
+}
+/**
+ * Visit every scalar leaf of `node` reachable through `op` arguments and the
+ * arms in `arms`, in source order. A leaf is visited once per occurrence.
+ *
+ * @internal
+ */
+export declare function forEachScalarLeaf(node: ExprNode, visit: (leaf: ScalarLeaf) => void, arms: LeafWalkArms): void;
+/**
+ * Replace each scalar leaf reachable under `arms` by `f(leaf)`. A subtree in
+ * which no leaf changed is returned by reference, so an arm the walk did not
+ * enter, and an unchanged tree, are the same objects the caller passed.
+ *
+ * @internal
+ */
+export declare function mapScalarLeaves(node: ExprNode, f: (leaf: ScalarLeaf) => ExprNode, arms: LeafWalkArms): ExprNode;
+//# sourceMappingURL=ast-leaves.d.ts.map

package/dist/dimensional/ast-leaves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-leaves.d.ts","sourceRoot":"","sources":["../../src/dimensional/ast-leaves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,4DAA4D;AAC5D,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAgD,CAAC;AAE7E,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAG/D;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,2BAA2B;IAC3B,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,mCAAmC;IACnC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,GAAG,KAAK,CAAC;IAC7C,oCAAoC;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IACzC,uCAAuC;IACvC,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAiCD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,EACjC,IAAI,EAAE,YAAY,GACjB,IAAI,CAMN;AAmCD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,QAAQ,EACjC,IAAI,EAAE,YAAY,GACjB,QAAQ,CAWV"}

package/dist/dimensional/ast-leaves.js

@@ -0,0 +1,146 @@
+/**
+ * One owner for the scalar-leaf walk of an `ExprNode` and the literal rule.
+ *
+ * Thirteen walks over the leaves and six spellings of "is this name a number"
+ * once lived in the funnel, the probe and the canonical layer, and they
+ * disagreed on the edges: one accepted `0x2`, one rejected `1e3`, and several
+ * accepted the empty string (`Number('')` is `0`). The rule here is the
+ * validator's decimal-literal grammar, so a formula is read the same way
+ * everywhere it is read.
+ *
+ * The walker descends into `op` arguments always. Every other arm is opted
+ * into by the caller through {@link LeafWalkArms}, because the callers it
+ * replaced did not agree on which arms they walked (the evaluator reads
+ * `transcendental` and `abs`; the simplifier reads an integral's measure and
+ * integrand but not its bounds), and the behaviour of each is kept by passing
+ * its own set.
+ *
+ * @module dimensional/ast-leaves
+ */
+/**
+ * The decimal-literal grammar: an optional sign, digits with an optional
+ * fraction (or a bare fraction), and an optional exponent. `1e3` and `2.` are
+ * literals; `0x2`, `Infinity` and the empty string are not. This is the
+ * validator's rule for a literal exponent.
+ *
+ * @internal
+ */
+export const DECIMAL_LITERAL = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+/** True when `name` is a decimal literal under {@link DECIMAL_LITERAL}. @internal */
+export function isDecimalLiteral(name) {
+    return DECIMAL_LITERAL.test(name);
+}
+/**
+ * The number a decimal-literal symbol names, or `undefined` for any other
+ * node. The dimension stored on the symbol is not read: a caller that needs
+ * the literal to be dimensionless checks that itself.
+ *
+ * @internal
+ */
+export function literalValue(node) {
+    if (node.kind !== 'symbol' || !isDecimalLiteral(node.name))
+        return undefined;
+    return Number(node.name);
+}
+/** The children a walk enters under `arms`, in source order. */
+function walkedChildren(node, arms) {
+    switch (node.kind) {
+        case 'op':
+            return node.args;
+        case 'transcendental':
+            return arms.transcendental ? [node.arg] : [];
+        case 'abs':
+            return arms.abs ? [node.arg] : [];
+        case 'dirac-delta':
+            return arms.diracDelta ? [node.arg] : [];
+        case 'integral':
+            if (arms.integral === undefined)
+                return [];
+            if (arms.integral === 'over+integrand')
+                return [node.over, node.integrand];
+            return [
+                node.over,
+                node.integrand,
+                ...(node.lower === undefined ? [] : [node.lower]),
+                ...(node.upper === undefined ? [] : [node.upper]),
+            ];
+        case 'derivative':
+            return arms.derivative ? [node.of, node.wrt] : [];
+        case 'variational-derivative':
+            return arms.variationalDerivative ? [node.functional, node.field, node.over] : [];
+        case 'tensor-product':
+            return arms.tensorProduct ? node.args : [];
+        default:
+            return [];
+    }
+}
+/**
+ * Visit every scalar leaf of `node` reachable through `op` arguments and the
+ * arms in `arms`, in source order. A leaf is visited once per occurrence.
+ *
+ * @internal
+ */
+export function forEachScalarLeaf(node, visit, arms) {
+    if (node.kind === 'symbol') {
+        visit(node);
+        return;
+    }
+    for (const child of walkedChildren(node, arms))
+        forEachScalarLeaf(child, visit, arms);
+}
+/** Rebuild `node` with the walked children replaced, keeping the node when none changed. */
+function rebuild(node, arms, children) {
+    switch (node.kind) {
+        case 'op':
+            return { ...node, args: [...children] };
+        case 'transcendental':
+        case 'abs':
+        case 'dirac-delta':
+            return { ...node, arg: children[0] };
+        case 'integral': {
+            if (arms.integral === 'over+integrand')
+                return { ...node, over: children[0], integrand: children[1] };
+            let i = 2;
+            const lower = node.lower === undefined ? undefined : children[i++];
+            const upper = node.upper === undefined ? undefined : children[i++];
+            return {
+                ...node,
+                over: children[0],
+                integrand: children[1],
+                ...(lower === undefined ? {} : { lower }),
+                ...(upper === undefined ? {} : { upper }),
+            };
+        }
+        case 'derivative':
+            return { ...node, of: children[0], wrt: children[1] };
+        case 'variational-derivative':
+            return { ...node, functional: children[0], field: children[1], over: children[2] };
+        case 'tensor-product':
+            return { ...node, args: [...children] };
+        default:
+            return node;
+    }
+}
+/**
+ * Replace each scalar leaf reachable under `arms` by `f(leaf)`. A subtree in
+ * which no leaf changed is returned by reference, so an arm the walk did not
+ * enter, and an unchanged tree, are the same objects the caller passed.
+ *
+ * @internal
+ */
+export function mapScalarLeaves(node, f, arms) {
+    if (node.kind === 'symbol')
+        return f(node);
+    const children = walkedChildren(node, arms);
+    if (children.length === 0)
+        return node;
+    let changed = false;
+    const mapped = children.map((child) => {
+        const next = mapScalarLeaves(child, f, arms);
+        if (next !== child)
+            changed = true;
+        return next;
+    });
+    return changed ? rebuild(node, arms, mapped) : node;
+}
+//# sourceMappingURL=ast-leaves.js.map

package/dist/dimensional/ast-leaves.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-leaves.js","sourceRoot":"","sources":["../../src/dimensional/ast-leaves.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * One owner for the scalar-leaf walk of an `ExprNode` and the literal rule.\n *\n * Thirteen walks over the leaves and six spellings of \"is this name a number\"\n * once lived in the funnel, the probe and the canonical layer, and they\n * disagreed on the edges: one accepted `0x2`, one rejected `1e3`, and several\n * accepted the empty string (`Number('')` is `0`). The rule here is the\n * validator's decimal-literal grammar, so a formula is read the same way\n * everywhere it is read.\n *\n * The walker descends into `op` arguments always. Every other arm is opted\n * into by the caller through {@link LeafWalkArms}, because the callers it\n * replaced did not agree on which arms they walked (the evaluator reads\n * `transcendental` and `abs`; the simplifier reads an integral's measure and\n * integrand but not its bounds), and the behaviour of each is kept by passing\n * its own set.\n *\n * @module dimensional/ast-leaves\n */\n\nimport type { ExprNode } from './ast-types.js';\n\n/** A scalar leaf: a symbol with its dimension. @internal */\nexport type ScalarLeaf = Extract<ExprNode, { kind: 'symbol' }>;\n\n/**\n * The decimal-literal grammar: an optional sign, digits with an optional\n * fraction (or a bare fraction), and an optional exponent. `1e3` and `2.` are\n * literals; `0x2`, `Infinity` and the empty string are not. This is the\n * validator's rule for a literal exponent.\n *\n * @internal\n */\nexport const DECIMAL_LITERAL = /^[+-]?(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?$/;\n\n/** True when `name` is a decimal literal under {@link DECIMAL_LITERAL}. @internal */\nexport function isDecimalLiteral(name: string): boolean {\n  return DECIMAL_LITERAL.test(name);\n}\n\n/**\n * The number a decimal-literal symbol names, or `undefined` for any other\n * node. The dimension stored on the symbol is not read: a caller that needs\n * the literal to be dimensionless checks that itself.\n *\n * @internal\n */\nexport function literalValue(node: ExprNode): number | undefined {\n  if (node.kind !== 'symbol' || !isDecimalLiteral(node.name)) return undefined;\n  return Number(node.name);\n}\n\n/**\n * Which non-`op` arms a walk descends into. `op` arguments are always walked.\n * An arm left out is not entered, and its leaves are not visited.\n *\n * @internal\n */\nexport interface LeafWalkArms {\n  /** `exp`, `ln`, the trigonometric functions: their argument. */\n  readonly transcendental?: boolean;\n  /** `abs`: its argument. */\n  readonly abs?: boolean;\n  /** `dirac-delta`: its argument. */\n  readonly diracDelta?: boolean;\n  /** `integral`: the measure and the integrand, or those and both bounds. */\n  readonly integral?: 'over+integrand' | 'all';\n  /** `derivative`: `of` and `wrt`. */\n  readonly derivative?: boolean;\n  /** `variational-derivative`: the functional, the field and the measure. */\n  readonly variationalDerivative?: boolean;\n  /** `tensor-product`: its arguments. */\n  readonly tensorProduct?: boolean;\n}\n\n/** The children a walk enters under `arms`, in source order. */\nfunction walkedChildren(node: ExprNode, arms: LeafWalkArms): readonly ExprNode[] {\n  switch (node.kind) {\n    case 'op':\n      return node.args;\n    case 'transcendental':\n      return arms.transcendental ? [node.arg] : [];\n    case 'abs':\n      return arms.abs ? [node.arg] : [];\n    case 'dirac-delta':\n      return arms.diracDelta ? [node.arg] : [];\n    case 'integral':\n      if (arms.integral === undefined) return [];\n      if (arms.integral === 'over+integrand') return [node.over, node.integrand];\n      return [\n        node.over,\n        node.integrand,\n        ...(node.lower === undefined ? [] : [node.lower]),\n        ...(node.upper === undefined ? [] : [node.upper]),\n      ];\n    case 'derivative':\n      return arms.derivative ? [node.of, node.wrt] : [];\n    case 'variational-derivative':\n      return arms.variationalDerivative ? [node.functional, node.field, node.over] : [];\n    case 'tensor-product':\n      return arms.tensorProduct ? node.args : [];\n    default:\n      return [];\n  }\n}\n\n/**\n * Visit every scalar leaf of `node` reachable through `op` arguments and the\n * arms in `arms`, in source order. A leaf is visited once per occurrence.\n *\n * @internal\n */\nexport function forEachScalarLeaf(\n  node: ExprNode,\n  visit: (leaf: ScalarLeaf) => void,\n  arms: LeafWalkArms,\n): void {\n  if (node.kind === 'symbol') {\n    visit(node);\n    return;\n  }\n  for (const child of walkedChildren(node, arms)) forEachScalarLeaf(child, visit, arms);\n}\n\n/** Rebuild `node` with the walked children replaced, keeping the node when none changed. */\nfunction rebuild(node: ExprNode, arms: LeafWalkArms, children: readonly ExprNode[]): ExprNode {\n  switch (node.kind) {\n    case 'op':\n      return { ...node, args: [...children] };\n    case 'transcendental':\n    case 'abs':\n    case 'dirac-delta':\n      return { ...node, arg: children[0]! };\n    case 'integral': {\n      if (arms.integral === 'over+integrand') return { ...node, over: children[0]!, integrand: children[1]! };\n      let i = 2;\n      const lower = node.lower === undefined ? undefined : children[i++];\n      const upper = node.upper === undefined ? undefined : children[i++];\n      return {\n        ...node,\n        over: children[0]!,\n        integrand: children[1]!,\n        ...(lower === undefined ? {} : { lower }),\n        ...(upper === undefined ? {} : { upper }),\n      };\n    }\n    case 'derivative':\n      return { ...node, of: children[0]!, wrt: children[1]! };\n    case 'variational-derivative':\n      return { ...node, functional: children[0]!, field: children[1]!, over: children[2]! };\n    case 'tensor-product':\n      return { ...node, args: [...children] };\n    default:\n      return node;\n  }\n}\n\n/**\n * Replace each scalar leaf reachable under `arms` by `f(leaf)`. A subtree in\n * which no leaf changed is returned by reference, so an arm the walk did not\n * enter, and an unchanged tree, are the same objects the caller passed.\n *\n * @internal\n */\nexport function mapScalarLeaves(\n  node: ExprNode,\n  f: (leaf: ScalarLeaf) => ExprNode,\n  arms: LeafWalkArms,\n): ExprNode {\n  if (node.kind === 'symbol') return f(node);\n  const children = walkedChildren(node, arms);\n  if (children.length === 0) return node;\n  let changed = false;\n  const mapped = children.map((child) => {\n    const next = mapScalarLeaves(child, f, arms);\n    if (next !== child) changed = true;\n    return next;\n  });\n  return changed ? rebuild(node, arms, mapped) : node;\n}\n"]}

package/dist/dimensional/buckingham.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buckingham.d.ts","sourceRoot":"","sources":["../../src/dimensional/buckingham.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C;kEACkE;AAClE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED;;6BAE6B;AAC7B,MAAM,WAAW,OAAO;IACtB,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,yDAAyD;AACzD,MAAM,MAAM,iBAAiB,GACzB,2BAA2B,GAC3B,kBAAkB,GAClB,qBAAqB,CAAC;AAE1B,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,yDAAyD;IACzD,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,mCAAmC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACrC;AAED,yDAAyD;AACzD,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;oDACgD;IAChD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD,oEAAoE;IACpE,QAAQ,CAAC,yBAAyB,CAAC,EAAE,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;cACc;AACd,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAsGD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,SAAS,mBAAmB,EAAE,GACxC,gBAAgB,CAsClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,SAAS,mBAAmB,EAAE,GACxC,8BAA8B,CAmEhC"}
+{"version":3,"file":"buckingham.d.ts","sourceRoot":"","sources":["../../src/dimensional/buckingham.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C;kEACkE;AAClE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED;;6BAE6B;AAC7B,MAAM,WAAW,OAAO;IACtB,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,yDAAyD;AACzD,MAAM,MAAM,iBAAiB,GACzB,2BAA2B,GAC3B,kBAAkB,GAClB,qBAAqB,CAAC;AAE1B,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,yDAAyD;IACzD,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,mCAAmC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACrC;AAED,yDAAyD;AACzD,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;oDACgD;IAChD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD,oEAAoE;IACpE,QAAQ,CAAC,yBAAyB,CAAC,EAAE,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;cACc;AACd,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AA+ED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,SAAS,mBAAmB,EAAE,GACxC,gBAAgB,CAsClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,SAAS,mBAAmB,EAAE,GACxC,8BAA8B,CAmEhC"}

package/dist/dimensional/buckingham.js

@@ -26,7 +26,7 @@
  */
 import { Fraction } from '@danielsimonjr/mathts-core';
 import { rationalNullspace } from '@danielsimonjr/mathts-functions';
-const BASES = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'];
+import { BASES } from './algebra.js';
 /** Rationalization failed: a dimension exponent is not a small rational.
  *  @public */
 export class RationalizationError extends Error {
@@ -35,39 +35,28 @@ export class RationalizationError extends Error {
         this.name = 'RationalizationError';
     }
 }
-function gcd(a, b) {
-    a = Math.abs(a);
-    b = Math.abs(b);
-    while (b) {
-        [a, b] = [b, a % b];
-    }
-    return a || 1;
-}
-function frac(n, d) {
-    if (d === 0)
-        throw new RationalizationError('zero denominator');
-    if (d < 0) {
-        n = -n;
-        d = -d;
-    }
-    const g = gcd(n, d);
-    return { n: n / g, d: d / g };
-}
+// ---------------------------------------------------------------------------
+// Exact rational arithmetic: MathTS core `Fraction` (bigint-backed, reduced by
+// its constructor). Dimension exponents are small rationals.
+// ---------------------------------------------------------------------------
 const MAX_DEN = 720;
-/** Convert a (possibly rational) exponent to an exact fraction by scanning
- *  small denominators; throws if none matches within tolerance. */
+/**
+ * Convert a (possibly rational) exponent to an exact {@link Fraction} by
+ * scanning small denominators; throws if none matches within tolerance. The
+ * scan, not `Fraction.fromNumber`'s continued fraction, is what refuses an
+ * irrational exponent instead of approximating it.
+ */
 function toFrac(x) {
     if (Number.isInteger(x))
-        return { n: x, d: 1 };
+        return new Fraction(x, 1);
     for (let d = 2; d <= MAX_DEN; d++) {
         const n = x * d;
         if (Math.abs(n - Math.round(n)) < 1e-9 * Math.max(1, Math.abs(n))) {
-            return frac(Math.round(n), d);
+            return new Fraction(Math.round(n), d);
         }
     }
     throw new RationalizationError(`dimension exponent ${x} is not a rational with denominator ≤ ${MAX_DEN}`);
 }
-const fZero = (a) => a.n === 0;
 /**
  * Exact null space of the dimension matrix. Exponents pass through as
  * {@link Fraction} values after {@link toFrac}, so an irrational is still
@@ -76,8 +65,7 @@ const fZero = (a) => a.n === 0;
  * MathTS integerizes each vector (content 1, first nonzero entry positive).
  */
 function nullSpace(matrix, cols) {
-    const entries = matrix.map((row) => row.map((f) => new Fraction(f.n, f.d)));
-    const solved = rationalNullspace(entries, { columns: cols });
+    const solved = rationalNullspace(matrix, { columns: cols });
     const basis = solved.basis.map((vec) => vec.map((entry) => {
         if (entry.denominator !== 1n) {
             throw new RationalizationError(`null-space entry ${entry.toString()} is not an integer`);
@@ -91,7 +79,7 @@ function buildMatrix(variables) {
     const matrix = [];
     for (const base of BASES) {
         const row = variables.map((v) => toFrac(v.dim[base]));
-        if (row.some((f) => !fZero(f))) {
+        if (row.some((f) => !f.isZero())) {
             spannedBases.push(base);
             matrix.push(row);
         }

package/dist/dimensional/buckingham.js.map

@@ -1 +1 @@
-{"version":3,"file":"buckingham.js","sourceRoot":"","sources":["../../src/dimensional/buckingham.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Buckingham-π enumerator (build target 1 of\n * docs/planning/Bridge-Inference-Epistemics-Note.md — the principled\n * primitive for the classifier's EXACTLY-DETERMINED case).\n *\n * Given a set of dimensional variables presumed to obey one\n * dimensionally-homogeneous relation, the Buckingham-π theorem says that\n * relation re-expresses as F(π₁,…,π_{n−r}) = 0, where each πᵢ is a\n * dimensionless power-product of the variables and there are exactly\n * n − r of them (n = variables, r = rank of the dimension matrix). The\n * π-groups are a basis of the NULL SPACE of the dimension matrix.\n *\n * THE HONEST BOUNDARY (enforced by the result types — there is no value\n * or constant field anywhere): this returns the FORM only. It yields the\n * π-groups and, for a target, the monomial that determines it UP TO A\n * DIMENSIONLESS CONSTANT (the 2π, the ½, α). It does NOT and cannot\n * supply that constant, nor the function F. That boundary is exactly what\n * separates dimensional analysis from numerology — see the epistemics\n * note.\n *\n * Computation is EXACT (rational arithmetic), not floating Gaussian\n * elimination: physics dimension exponents are small rationals, and the\n * null-space basis must be exact to be trustworthy.\n *\n * @module dimensional/buckingham\n */\n\nimport { Fraction } from '@danielsimonjr/mathts-core';\nimport { rationalNullspace } from '@danielsimonjr/mathts-functions';\nimport type { Dimension } from './types.js';\n\nconst BASES = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'] as const;\n\n/** A named physical quantity with a dimension — the enumerator's input.\n *  Structurally satisfied by a composition `Quantity`. @public */\nexport interface DimensionalVariable {\n  readonly name: string;\n  readonly dim: Dimension;\n}\n\n/** A dimensionless power-product of the input variables (integer\n *  exponents; the conventional form). No value — π-groups carry FORM,\n *  not magnitude. @public */\nexport interface PiGroup {\n  /** Integer exponent of each variable in this dimensionless product. */\n  readonly exponents: Readonly<Record<string, number>>;\n  /** Display form, e.g. `period^2 · gravity · length^-1`. */\n  readonly formula: string;\n}\n\n/** The dimensional closure of a variable set. @public */\nexport type BuckinghamVerdict =\n  | 'dimensionally-independent' // 0 π-groups: no dimensionless product exists\n  | 'single-invariant' // 1 π-group: one dimensionless invariant\n  | 'multiple-invariants'; // ≥2 π-groups: a family F(π₁,…)\n\n/** Result of {@link buckinghamPi}. @public */\nexport interface BuckinghamResult {\n  readonly variables: readonly string[];\n  /** Base SI dimensions actually spanned by the inputs. */\n  readonly baseDimensions: readonly string[];\n  /** n — the number of variables. */\n  readonly variableCount: number;\n  /** r — the rank of the dimension matrix. */\n  readonly rank: number;\n  /** n − r — the number of independent dimensionless groups. */\n  readonly piGroupCount: number;\n  readonly piGroups: readonly PiGroup[];\n  readonly verdict: BuckinghamVerdict;\n}\n\n/** Result of {@link dimensionallyDetermines}. @public */\nexport interface DimensionalDeterminationResult {\n  readonly target: string;\n  readonly governing: readonly string[];\n  /** True iff the target is fixed by the governing variables UP TO A\n   *  DIMENSIONLESS CONSTANT (unique monomial). */\n  readonly determined: boolean;\n  /**\n   * When determined: target = const · Π(governingⱼ ^ monomial[j]). The\n   * exponents may be rational (e.g. 0.5 for a √ law). Always read with\n   * `upToDimensionlessConstant` — the leading constant is NOT supplied.\n   */\n  readonly monomial?: Readonly<Record<string, number>>;\n  /** Always true when `monomial` is present — a standing reminder. */\n  readonly upToDimensionlessConstant?: true;\n  /**\n   * True only when the target's dimension is not in the span of the governing\n   * variables, so a monomial needs dimensionful constants the inputs do not\n   * name. False when the governing variables are dimensionally dependent or\n   * leave more than one π-group: that failure is not a missing constant.\n   */\n  readonly outsideGoverningSpan: boolean;\n  /** Plain-language reason for the verdict. */\n  readonly reason: string;\n}\n\n/** Rationalization failed: a dimension exponent is not a small rational.\n *  @public */\nexport class RationalizationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'RationalizationError';\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Exact rational arithmetic (number-backed; dimension exponents are small\n// rationals, so reduced fractions never overflow in practice).\n// ---------------------------------------------------------------------------\n\ninterface Frac {\n  readonly n: number;\n  readonly d: number;\n}\n\nfunction gcd(a: number, b: number): number {\n  a = Math.abs(a);\n  b = Math.abs(b);\n  while (b) {\n    [a, b] = [b, a % b];\n  }\n  return a || 1;\n}\n\nfunction frac(n: number, d: number): Frac {\n  if (d === 0) throw new RationalizationError('zero denominator');\n  if (d < 0) {\n    n = -n;\n    d = -d;\n  }\n  const g = gcd(n, d);\n  return { n: n / g, d: d / g };\n}\n\nconst MAX_DEN = 720;\n\n/** Convert a (possibly rational) exponent to an exact fraction by scanning\n *  small denominators; throws if none matches within tolerance. */\nfunction toFrac(x: number): Frac {\n  if (Number.isInteger(x)) return { n: x, d: 1 };\n  for (let d = 2; d <= MAX_DEN; d++) {\n    const n = x * d;\n    if (Math.abs(n - Math.round(n)) < 1e-9 * Math.max(1, Math.abs(n))) {\n      return frac(Math.round(n), d);\n    }\n  }\n  throw new RationalizationError(\n    `dimension exponent ${x} is not a rational with denominator ≤ ${MAX_DEN}`,\n  );\n}\n\nconst fZero = (a: Frac): boolean => a.n === 0;\n\n/**\n * Exact null space of the dimension matrix. Exponents pass through as\n * {@link Fraction} values after {@link toFrac}, so an irrational is still\n * {@link RationalizationError} and is not accepted by a continued fraction.\n * A matrix with no rows is `0×n`: `{ columns: n }` is the standard basis.\n * MathTS integerizes each vector (content 1, first nonzero entry positive).\n */\nfunction nullSpace(matrix: Frac[][], cols: number): { basis: number[][]; rank: number } {\n  const entries = matrix.map((row) => row.map((f) => new Fraction(f.n, f.d)));\n  const solved = rationalNullspace(entries, { columns: cols });\n  const basis = solved.basis.map((vec) =>\n    vec.map((entry) => {\n      if (entry.denominator !== 1n) {\n        throw new RationalizationError(\n          `null-space entry ${entry.toString()} is not an integer`,\n        );\n      }\n      return Number(entry.numerator);\n    }),\n  );\n  return { basis, rank: solved.rank };\n}\n\nfunction buildMatrix(variables: readonly DimensionalVariable[]): {\n  matrix: Frac[][];\n  spannedBases: string[];\n} {\n  const spannedBases: string[] = [];\n  const matrix: Frac[][] = [];\n  for (const base of BASES) {\n    const row = variables.map((v) => toFrac(v.dim[base]));\n    if (row.some((f) => !fZero(f))) {\n      spannedBases.push(base);\n      matrix.push(row);\n    }\n  }\n  return { matrix, spannedBases };\n}\n\nfunction formatPiGroup(\n  exponents: Record<string, number>,\n  order: readonly string[],\n): string {\n  const parts: string[] = [];\n  for (const name of order) {\n    const e = exponents[name];\n    if (e === 0) continue;\n    parts.push(e === 1 ? name : `${name}^${e}`);\n  }\n  return parts.join(' · ') || '1';\n}\n\n/**\n * Enumerate the Buckingham-π groups of a dimensional variable set. Returns\n * the rank, the count n − r, and a null-space basis of dimensionless\n * groups. FORM only — no constants (see module docs).\n *\n * @public\n */\nexport function buckinghamPi(\n  variables: readonly DimensionalVariable[],\n): BuckinghamResult {\n  if (variables.length === 0) {\n    throw new RationalizationError('buckinghamPi requires at least one variable');\n  }\n  const names = variables.map((v) => v.name);\n  if (new Set(names).size !== names.length) {\n    throw new RationalizationError(\n      `buckinghamPi requires unique variable names; got [${names.join(', ')}]`,\n    );\n  }\n\n  const n = variables.length;\n  const { matrix, spannedBases } = buildMatrix(variables);\n\n  const { basis, rank } = nullSpace(matrix, n);\n  const piGroups: PiGroup[] = basis.map((vec) => {\n    const exponents: Record<string, number> = {};\n    for (let j = 0; j < n; j++) exponents[names[j]] = vec[j];\n    return { exponents, formula: formatPiGroup(exponents, names) };\n  });\n\n  const piGroupCount = n - rank;\n  const verdict: BuckinghamVerdict =\n    piGroupCount === 0\n      ? 'dimensionally-independent'\n      : piGroupCount === 1\n        ? 'single-invariant'\n        : 'multiple-invariants';\n\n  return {\n    variables: names,\n    baseDimensions: spannedBases,\n    variableCount: n,\n    rank,\n    piGroupCount,\n    piGroups,\n    verdict,\n  };\n}\n\n/**\n * Does the governing set fix the target UP TO A DIMENSIONLESS CONSTANT?\n *\n * True iff the governing variables are dimensionally independent and the\n * target's dimension lies in their span — equivalently, the full set has\n * exactly one π-group and the governing set has none. When determined,\n * returns the (possibly rational) monomial exponents such that\n * target = const · Π(governingⱼ ^ monomial[j]). The constant is NOT\n * supplied — dimensional analysis cannot.\n *\n * @public\n */\nexport function dimensionallyDetermines(\n  target: DimensionalVariable,\n  governing: readonly DimensionalVariable[],\n): DimensionalDeterminationResult {\n  const governingNames = governing.map((v) => v.name);\n\n  const governingPi = buckinghamPi(\n    governing.length > 0 ? governing : [target],\n  );\n  // A redundancy among the governing variables means the monomial is not\n  // unique (any dimensionless governing combo can be folded into the\n  // constant) → not determined.\n  if (governing.length > 0 && governingPi.piGroupCount > 0) {\n    return {\n      target: target.name,\n      governing: governingNames,\n      determined: false,\n      outsideGoverningSpan: false,\n      reason:\n        'governing variables are dimensionally dependent ' +\n        `(${governingPi.piGroupCount} dimensionless combination(s) among them); ` +\n        'the determining monomial is not unique',\n    };\n  }\n\n  const full = buckinghamPi([target, ...governing]);\n  if (full.piGroupCount !== 1) {\n    return {\n      target: target.name,\n      governing: governingNames,\n      determined: false,\n      outsideGoverningSpan: full.piGroupCount === 0,\n      reason:\n        full.piGroupCount === 0\n          ? \"the target's dimension is not in the span of the governing \" +\n            'variables — no dimensionless group exists, so no monomial determines it'\n          : `${full.piGroupCount} independent π-groups — the target is fixed ` +\n            'only as a function of several dimensionless ratios (under-constrained)',\n    };\n  }\n\n  // The single π-group involves the target; solve it for the target.\n  const group = full.piGroups[0].exponents;\n  const targetExp = group[target.name];\n  if (!targetExp) {\n    return {\n      target: target.name,\n      governing: governingNames,\n      determined: false,\n      outsideGoverningSpan: false,\n      reason:\n        'the sole dimensionless group does not involve the target ' +\n        '(the target is dimensionally redundant with the governing set)',\n    };\n  }\n  const monomial: Record<string, number> = {};\n  for (const name of governingNames) {\n    monomial[name] = -(group[name] ?? 0) / targetExp;\n  }\n\n  return {\n    target: target.name,\n    governing: governingNames,\n    determined: true,\n    monomial,\n    upToDimensionlessConstant: true,\n    outsideGoverningSpan: false,\n    reason:\n      'unique dimensionless group fixes the target up to a dimensionless constant',\n  };\n}\n"]}
+{"version":3,"file":"buckingham.js","sourceRoot":"","sources":["../../src/dimensional/buckingham.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Buckingham-π enumerator (build target 1 of\n * docs/planning/Bridge-Inference-Epistemics-Note.md — the principled\n * primitive for the classifier's EXACTLY-DETERMINED case).\n *\n * Given a set of dimensional variables presumed to obey one\n * dimensionally-homogeneous relation, the Buckingham-π theorem says that\n * relation re-expresses as F(π₁,…,π_{n−r}) = 0, where each πᵢ is a\n * dimensionless power-product of the variables and there are exactly\n * n − r of them (n = variables, r = rank of the dimension matrix). The\n * π-groups are a basis of the NULL SPACE of the dimension matrix.\n *\n * THE HONEST BOUNDARY (enforced by the result types — there is no value\n * or constant field anywhere): this returns the FORM only. It yields the\n * π-groups and, for a target, the monomial that determines it UP TO A\n * DIMENSIONLESS CONSTANT (the 2π, the ½, α). It does NOT and cannot\n * supply that constant, nor the function F. That boundary is exactly what\n * separates dimensional analysis from numerology — see the epistemics\n * note.\n *\n * Computation is EXACT (rational arithmetic), not floating Gaussian\n * elimination: physics dimension exponents are small rationals, and the\n * null-space basis must be exact to be trustworthy.\n *\n * @module dimensional/buckingham\n */\n\nimport { Fraction } from '@danielsimonjr/mathts-core';\nimport { rationalNullspace } from '@danielsimonjr/mathts-functions';\nimport type { Dimension } from './types.js';\nimport { BASES } from './algebra.js';\n\n/** A named physical quantity with a dimension — the enumerator's input.\n *  Structurally satisfied by a composition `Quantity`. @public */\nexport interface DimensionalVariable {\n  readonly name: string;\n  readonly dim: Dimension;\n}\n\n/** A dimensionless power-product of the input variables (integer\n *  exponents; the conventional form). No value — π-groups carry FORM,\n *  not magnitude. @public */\nexport interface PiGroup {\n  /** Integer exponent of each variable in this dimensionless product. */\n  readonly exponents: Readonly<Record<string, number>>;\n  /** Display form, e.g. `period^2 · gravity · length^-1`. */\n  readonly formula: string;\n}\n\n/** The dimensional closure of a variable set. @public */\nexport type BuckinghamVerdict =\n  | 'dimensionally-independent' // 0 π-groups: no dimensionless product exists\n  | 'single-invariant' // 1 π-group: one dimensionless invariant\n  | 'multiple-invariants'; // ≥2 π-groups: a family F(π₁,…)\n\n/** Result of {@link buckinghamPi}. @public */\nexport interface BuckinghamResult {\n  readonly variables: readonly string[];\n  /** Base SI dimensions actually spanned by the inputs. */\n  readonly baseDimensions: readonly string[];\n  /** n — the number of variables. */\n  readonly variableCount: number;\n  /** r — the rank of the dimension matrix. */\n  readonly rank: number;\n  /** n − r — the number of independent dimensionless groups. */\n  readonly piGroupCount: number;\n  readonly piGroups: readonly PiGroup[];\n  readonly verdict: BuckinghamVerdict;\n}\n\n/** Result of {@link dimensionallyDetermines}. @public */\nexport interface DimensionalDeterminationResult {\n  readonly target: string;\n  readonly governing: readonly string[];\n  /** True iff the target is fixed by the governing variables UP TO A\n   *  DIMENSIONLESS CONSTANT (unique monomial). */\n  readonly determined: boolean;\n  /**\n   * When determined: target = const · Π(governingⱼ ^ monomial[j]). The\n   * exponents may be rational (e.g. 0.5 for a √ law). Always read with\n   * `upToDimensionlessConstant` — the leading constant is NOT supplied.\n   */\n  readonly monomial?: Readonly<Record<string, number>>;\n  /** Always true when `monomial` is present — a standing reminder. */\n  readonly upToDimensionlessConstant?: true;\n  /**\n   * True only when the target's dimension is not in the span of the governing\n   * variables, so a monomial needs dimensionful constants the inputs do not\n   * name. False when the governing variables are dimensionally dependent or\n   * leave more than one π-group: that failure is not a missing constant.\n   */\n  readonly outsideGoverningSpan: boolean;\n  /** Plain-language reason for the verdict. */\n  readonly reason: string;\n}\n\n/** Rationalization failed: a dimension exponent is not a small rational.\n *  @public */\nexport class RationalizationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'RationalizationError';\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Exact rational arithmetic: MathTS core `Fraction` (bigint-backed, reduced by\n// its constructor). Dimension exponents are small rationals.\n// ---------------------------------------------------------------------------\n\nconst MAX_DEN = 720;\n\n/**\n * Convert a (possibly rational) exponent to an exact {@link Fraction} by\n * scanning small denominators; throws if none matches within tolerance. The\n * scan, not `Fraction.fromNumber`'s continued fraction, is what refuses an\n * irrational exponent instead of approximating it.\n */\nfunction toFrac(x: number): Fraction {\n  if (Number.isInteger(x)) return new Fraction(x, 1);\n  for (let d = 2; d <= MAX_DEN; d++) {\n    const n = x * d;\n    if (Math.abs(n - Math.round(n)) < 1e-9 * Math.max(1, Math.abs(n))) {\n      return new Fraction(Math.round(n), d);\n    }\n  }\n  throw new RationalizationError(\n    `dimension exponent ${x} is not a rational with denominator ≤ ${MAX_DEN}`,\n  );\n}\n\n/**\n * Exact null space of the dimension matrix. Exponents pass through as\n * {@link Fraction} values after {@link toFrac}, so an irrational is still\n * {@link RationalizationError} and is not accepted by a continued fraction.\n * A matrix with no rows is `0×n`: `{ columns: n }` is the standard basis.\n * MathTS integerizes each vector (content 1, first nonzero entry positive).\n */\nfunction nullSpace(matrix: Fraction[][], cols: number): { basis: number[][]; rank: number } {\n  const solved = rationalNullspace(matrix, { columns: cols });\n  const basis = solved.basis.map((vec) =>\n    vec.map((entry) => {\n      if (entry.denominator !== 1n) {\n        throw new RationalizationError(\n          `null-space entry ${entry.toString()} is not an integer`,\n        );\n      }\n      return Number(entry.numerator);\n    }),\n  );\n  return { basis, rank: solved.rank };\n}\n\nfunction buildMatrix(variables: readonly DimensionalVariable[]): {\n  matrix: Fraction[][];\n  spannedBases: string[];\n} {\n  const spannedBases: string[] = [];\n  const matrix: Fraction[][] = [];\n  for (const base of BASES) {\n    const row = variables.map((v) => toFrac(v.dim[base]));\n    if (row.some((f) => !f.isZero())) {\n      spannedBases.push(base);\n      matrix.push(row);\n    }\n  }\n  return { matrix, spannedBases };\n}\n\nfunction formatPiGroup(\n  exponents: Record<string, number>,\n  order: readonly string[],\n): string {\n  const parts: string[] = [];\n  for (const name of order) {\n    const e = exponents[name];\n    if (e === 0) continue;\n    parts.push(e === 1 ? name : `${name}^${e}`);\n  }\n  return parts.join(' · ') || '1';\n}\n\n/**\n * Enumerate the Buckingham-π groups of a dimensional variable set. Returns\n * the rank, the count n − r, and a null-space basis of dimensionless\n * groups. FORM only — no constants (see module docs).\n *\n * @public\n */\nexport function buckinghamPi(\n  variables: readonly DimensionalVariable[],\n): BuckinghamResult {\n  if (variables.length === 0) {\n    throw new RationalizationError('buckinghamPi requires at least one variable');\n  }\n  const names = variables.map((v) => v.name);\n  if (new Set(names).size !== names.length) {\n    throw new RationalizationError(\n      `buckinghamPi requires unique variable names; got [${names.join(', ')}]`,\n    );\n  }\n\n  const n = variables.length;\n  const { matrix, spannedBases } = buildMatrix(variables);\n\n  const { basis, rank } = nullSpace(matrix, n);\n  const piGroups: PiGroup[] = basis.map((vec) => {\n    const exponents: Record<string, number> = {};\n    for (let j = 0; j < n; j++) exponents[names[j]] = vec[j];\n    return { exponents, formula: formatPiGroup(exponents, names) };\n  });\n\n  const piGroupCount = n - rank;\n  const verdict: BuckinghamVerdict =\n    piGroupCount === 0\n      ? 'dimensionally-independent'\n      : piGroupCount === 1\n        ? 'single-invariant'\n        : 'multiple-invariants';\n\n  return {\n    variables: names,\n    baseDimensions: spannedBases,\n    variableCount: n,\n    rank,\n    piGroupCount,\n    piGroups,\n    verdict,\n  };\n}\n\n/**\n * Does the governing set fix the target UP TO A DIMENSIONLESS CONSTANT?\n *\n * True iff the governing variables are dimensionally independent and the\n * target's dimension lies in their span — equivalently, the full set has\n * exactly one π-group and the governing set has none. When determined,\n * returns the (possibly rational) monomial exponents such that\n * target = const · Π(governingⱼ ^ monomial[j]). The constant is NOT\n * supplied — dimensional analysis cannot.\n *\n * @public\n */\nexport function dimensionallyDetermines(\n  target: DimensionalVariable,\n  governing: readonly DimensionalVariable[],\n): DimensionalDeterminationResult {\n  const governingNames = governing.map((v) => v.name);\n\n  const governingPi = buckinghamPi(\n    governing.length > 0 ? governing : [target],\n  );\n  // A redundancy among the governing variables means the monomial is not\n  // unique (any dimensionless governing combo can be folded into the\n  // constant) → not determined.\n  if (governing.length > 0 && governingPi.piGroupCount > 0) {\n    return {\n      target: target.name,\n      governing: governingNames,\n      determined: false,\n      outsideGoverningSpan: false,\n      reason:\n        'governing variables are dimensionally dependent ' +\n        `(${governingPi.piGroupCount} dimensionless combination(s) among them); ` +\n        'the determining monomial is not unique',\n    };\n  }\n\n  const full = buckinghamPi([target, ...governing]);\n  if (full.piGroupCount !== 1) {\n    return {\n      target: target.name,\n      governing: governingNames,\n      determined: false,\n      outsideGoverningSpan: full.piGroupCount === 0,\n      reason:\n        full.piGroupCount === 0\n          ? \"the target's dimension is not in the span of the governing \" +\n            'variables — no dimensionless group exists, so no monomial determines it'\n          : `${full.piGroupCount} independent π-groups — the target is fixed ` +\n            'only as a function of several dimensionless ratios (under-constrained)',\n    };\n  }\n\n  // The single π-group involves the target; solve it for the target.\n  const group = full.piGroups[0].exponents;\n  const targetExp = group[target.name];\n  if (!targetExp) {\n    return {\n      target: target.name,\n      governing: governingNames,\n      determined: false,\n      outsideGoverningSpan: false,\n      reason:\n        'the sole dimensionless group does not involve the target ' +\n        '(the target is dimensionally redundant with the governing set)',\n    };\n  }\n  const monomial: Record<string, number> = {};\n  for (const name of governingNames) {\n    monomial[name] = -(group[name] ?? 0) / targetExp;\n  }\n\n  return {\n    target: target.name,\n    governing: governingNames,\n    determined: true,\n    monomial,\n    upToDimensionlessConstant: true,\n    outsideGoverningSpan: false,\n    reason:\n      'unique dimensionless group fixes the target up to a dimensionless constant',\n  };\n}\n"]}

package/dist/dimensional/constant-rows.js

@@ -34,9 +34,9 @@ export const CONSTANT_ROWS = [
     row({ name: 'c', spellings: ['speed-of-light', 'speed_of_light'], value: C_SI, unit: 'm/s', canonical: true, mathts: 'speedOfLight', exact: true,
         meaning: 'speed of light in vacuum', source: `exact SI (${OWNER} C_SI)` }),
     row({ name: 'R_inf', spellings: ['Rinf', 'R_infinity', 'rydberg'], quantity: 'rydberg-constant', value: R_INF_SI, unit: '1/m', canonical: true, mathts: 'rydberg',
-        meaning: 'Rydberg constant R∞, infinite nuclear mass (the reduced-mass correction R_M = R∞/(1 + m_e/M) is not applied)', source: `CODATA 2018 (${OWNER} R_INF_SI)` }),
+        meaning: 'Rydberg constant R∞, infinite nuclear mass (the reduced-mass correction R_M = R∞/(1 + m_e/M) is not applied)', source: `CODATA 2022, MathTS (${OWNER} R_INF_SI)` }),
     row({ name: 'G', value: G_SI, unit: 'm^3/(kg*s^2)', canonical: true, mathts: 'gravitationConstant',
-        meaning: 'Newtonian gravitational constant', source: `CODATA 2018 (${OWNER} G_SI)` }),
+        meaning: 'Newtonian gravitational constant', source: `CODATA 2022, MathTS (${OWNER} G_SI)` }),
     row({ name: 'k_B', spellings: ['kB', 'boltzmann'], quantity: 'boltzmann-constant', value: K_B_SI, unit: 'J/K', canonical: true, mathts: 'boltzmann', exact: true,
         meaning: 'Boltzmann constant', source: `exact SI, 2019 redefinition (${OWNER} K_B_SI)` }),
     row({ name: 'ln2', value: Math.LN2, unit: '1', canonical: true, irrational: true,
@@ -53,25 +53,25 @@ export const CONSTANT_ROWS = [
     row({ name: 'e', spellings: ['e_charge'], value: E_SI, unit: 'C', canonical: true, mathts: 'elementaryCharge', exact: true,
         meaning: 'elementary charge', source: `exact SI, 2019 redefinition (${OWNER} E_SI)` }),
     row({ name: 'epsilon_0', spellings: ['epsilon0', 'eps0', 'vacuum-permittivity'], value: EPS0_SI, unit: 'F/m', canonical: true,
-        meaning: 'vacuum permittivity', source: `CODATA 2018 (${OWNER} EPS0_SI)` }),
+        meaning: 'vacuum permittivity', source: `CODATA 2022, MathTS (${OWNER} EPS0_SI)` }),
     row({ name: 'sigma_sb', spellings: ['stefan-boltzmann-constant'], value: SIGMA_SB_SI, unit: 'W/(m^2*K^4)', canonical: true, mathts: 'stefanBoltzmann',
-        meaning: 'Stefan–Boltzmann constant', source: `CODATA 2018 (${OWNER} SIGMA_SB_SI)` }),
+        meaning: 'Stefan–Boltzmann constant', source: `CODATA 2022, MathTS (${OWNER} SIGMA_SB_SI)` }),
     row({ name: 'b', spellings: ['wien-constant'], value: B_WIEN_SI, unit: 'm*K', canonical: true, mathts: 'wienDisplacement',
-        meaning: 'Wien displacement constant', source: `CODATA 2018 (${OWNER} B_WIEN_SI)` }),
+        meaning: 'Wien displacement constant', source: `CODATA 2022, MathTS (${OWNER} B_WIEN_SI)` }),
     // IAU 2015 nominal solar parameter. M_sun in eval stays the rounded kilogram M_SUN_SI.
     row({ name: 'GM_sun', value: GM_SUN_SI, unit: 'm^3/s^2', canonical: true,
         meaning: 'IAU nominal solar gravitational parameter (GM)☉', source: `IAU 2015 Resolution B3 (${OWNER} GM_SUN_SI)` }),
     row({ name: 'Msun_iau', value: M_SUN_IAU_SI, unit: 'kg', canonical: true,
         meaning: 'IAU solar mass (GM)☉/G, the mass that reproduces GM_sun with G_SI', source: `GM_SUN_SI/G_SI (${OWNER} M_SUN_IAU_SI)` }),
     row({ name: 'm_u', value: M_U_SI, unit: 'kg', canonical: true, mathts: 'atomicMass',
-        meaning: 'unified atomic mass unit (atomic mass constant)', source: `CODATA 2018 (${OWNER} M_U_SI)` }),
+        meaning: 'unified atomic mass unit (atomic mass constant)', source: `CODATA 2022, MathTS (${OWNER} M_U_SI)` }),
     row({ name: 'm_e', spellings: ['electron_mass', 'electron-mass'], value: M_E_SI, unit: 'kg', canonical: true, mathts: 'electronMass',
-        meaning: 'electron mass', source: `CODATA 2018 (${OWNER} M_E_SI)` }),
+        meaning: 'electron mass', source: `CODATA 2022, MathTS (${OWNER} M_E_SI)` }),
     // ── overlay names for `upt eval` and the dimensional assignment only ────
     row({ name: 'mu_0', spellings: ['mu0'], value: MU0_SI, unit: 'H/m', mathts: 'magneticConstant',
         meaning: 'vacuum permeability 1/(ε₀ c²)', source: `1/(EPS0_SI·C_SI²) (${OWNER} MU0_SI)` }),
     row({ name: 'm_p', spellings: ['m_proton'], value: M_PROTON_SI, unit: 'kg', mathts: 'protonMass',
-        meaning: 'proton mass', source: `CODATA 2018 (${OWNER} M_PROTON_SI)` }),
+        meaning: 'proton mass', source: `CODATA 2022, MathTS (${OWNER} M_PROTON_SI)` }),
     row({ name: 'N_A', value: N_A_SI, unit: 'mol^-1', mathts: 'avogadro', exact: true,
         meaning: 'Avogadro constant', source: `exact SI, 2019 redefinition (${OWNER} N_A_SI)` }),
     row({ name: 'F', value: FARADAY_SI, unit: 'C/mol', mathts: 'faraday', exact: true,
@@ -88,7 +88,7 @@ export const CONSTANT_ROWS = [
     row({ name: 'scale_factor', value: 1, unit: 'm',
         meaning: 'Friedmann scale factor, unit by default', source: 'this registry (default 1)' }),
     row({ name: 'sigma_T', value: THOMSON_CROSS_SECTION_SI, unit: 'm^2', mathts: 'thomsonCrossSection',
-        meaning: 'Thomson cross section', source: `CODATA 2018 (${OWNER} THOMSON_CROSS_SECTION_SI)` }),
+        meaning: 'Thomson cross section', source: `CODATA 2022, MathTS (${OWNER} THOMSON_CROSS_SECTION_SI)` }),
     row({ name: 'lane_emden_omega_3', quantity: 'lane-emden-omega-3', value: LANE_EMDEN_OMEGA3, unit: '1',
         meaning: 'Lane–Emden n = 3 dimensionless radius', source: `${OWNER} LANE_EMDEN_OMEGA3` }),
     row({ name: 'euler_gamma', value: EULER_GAMMA, unit: '1',