universal-physics-tensor 10.0.0 → 12.0.0

package/dist/composition/quantity-clusters.js

@@ -0,0 +1,98 @@
+/**
+ * The one component owner: items that share a (canonical) quantity are one cluster.
+ *
+ * `linkageMap` (equations sharing a quantity), `buildVizModel` (junctions sharing a quantity,
+ * with a proposed or user overlay) and the discovery funnel (quantities sharing an equation or
+ * an identification) each once ran their own union-find with the same ordering. This module is
+ * that partition, computed through MathTS `connectedComponents` over an adjacency of item
+ * indices, with the ordering every caller used: a cluster keeps its items in input order, and
+ * clusters come largest first, then by the id of their first item. The anchoring rules differ
+ * between callers on purpose (`graph-viz.ts` anchors on `law` or `established` status,
+ * `bridge-analysis.ts` on `established` confidence) and stay with each caller.
+ *
+ * @module composition/quantity-clusters
+ */
+import { connectedComponents } from '@danielsimonjr/mathts-functions';
+import { QUANTITY_IDENTIFICATIONS } from './compose.js';
+/**
+ * Quantity-name canonicalizer honouring `QUANTITY_IDENTIFICATIONS`: maps each name to its
+ * identified representative (`hawking-temperature` → `temperature`) and leaves every other
+ * name alone. The linkage substrate of `linkageMap`, `proposeLinkCandidates` and the visual
+ * map. `anchoringDistance` deliberately does NOT use it (it links on raw names; its 0/∞
+ * distance contract is pinned).
+ *
+ * @internal
+ */
+export function quantityCanonicalizer() {
+    const alias = new Map(QUANTITY_IDENTIFICATIONS.map((id) => [id.from, id.to]));
+    return (n) => alias.get(n) ?? n;
+}
+/**
+ * Group items by one key, keys in first-seen order, members in input order. The group-by
+ * every cluster consumer once re-inlined as `if (!m.has(k)) m.set(k, []); m.get(k)!.push(v)`.
+ *
+ * @internal
+ */
+export function groupInto(items, keyOf) {
+    const out = new Map();
+    for (const item of items) {
+        const k = keyOf(item);
+        const group = out.get(k);
+        if (group === undefined)
+            out.set(k, [item]);
+        else
+            group.push(item);
+    }
+    return out;
+}
+/**
+ * Partition `items` into clusters of items that share at least one key (transitively): the
+ * connected components, through MathTS `connectedComponents`, of the graph whose nodes are item
+ * indices and whose links join items with a key in common. Each cluster lists its items in
+ * input order; clusters come largest first, then by `idOf` of their first item (by that item's
+ * input position when no `idOf` is given). An item with no key is a cluster of its own; an
+ * empty input is no cluster.
+ *
+ * Cost: `connectedComponents` takes a dense n×n adjacency matrix, so memory is O(n²) in the
+ * number of items (8·n² bytes as numbers: about 4 MB at n = 700, the order of the quantity
+ * names one discovery context clusters, once per context; 800 MB at n = 10 000). A caller with
+ * thousands of items should expect that, or cluster with a union-find over the key lists.
+ *
+ * @internal
+ */
+export function clusterBySharedKeys(items, keysOf, idOf) {
+    const n = items.length;
+    if (n === 0)
+        return [];
+    // Items sharing a key: the first holder of the key is linked to every later holder, which is
+    // enough for connectivity (a star joins the whole set).
+    const holders = new Map();
+    items.forEach((item, i) => {
+        for (const key of keysOf(item)) {
+            const list = holders.get(key);
+            if (list === undefined)
+                holders.set(key, [i]);
+            else
+                list.push(i);
+        }
+    });
+    const adjacency = Array.from({ length: n }, () => new Array(n).fill(0));
+    for (const idxs of holders.values()) {
+        for (let k = 1; k < idxs.length; k++) {
+            adjacency[idxs[0]][idxs[k]] = 1;
+            adjacency[idxs[k]][idxs[0]] = 1;
+        }
+    }
+    const components = connectedComponents(adjacency);
+    const clusters = components.map((idxs) => [...idxs].sort((a, b) => a - b));
+    const first = (c) => idOf === undefined ? String(c[0]).padStart(12, '0') : idOf(items[c[0]]);
+    clusters.sort((a, b) => b.length - a.length || first(a).localeCompare(first(b)));
+    // Every item is placed exactly once: a component listing that dropped or repeated an index
+    // would be the instrument reporting its own breakage, so say so rather than render it.
+    const placed = clusters.reduce((acc, c) => acc + c.length, 0);
+    if (placed !== n || new Set(clusters.flat()).size !== n) {
+        throw new Error(`clusterBySharedKeys: ${placed} placements over ${n} items`);
+    }
+    return clusters.map((c) => c.map((i) => items[i]));
+}
+//# sourceMappingURL=quantity-clusters.js.map

package/dist/composition/quantity-clusters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantity-clusters.js","sourceRoot":"","sources":["../../src/composition/quantity-clusters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAExD;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB;IACnC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAiB,wBAAwB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9F,OAAO,CAAC,CAAS,EAAU,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAClD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAO,KAAmB,EAAE,KAAqB;IACxE,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QACtB,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,KAAK,KAAK,SAAS;YAAE,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;;YACvC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAmB,EACnB,MAAsC,EACtC,IAA0B;IAE1B,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;IACvB,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACvB,6FAA6F;IAC7F,wDAAwD;IACxD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC5C,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;QACxB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;;gBACzC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;IACH,CAAC,CAAC,CAAC;IACH,MAAM,SAAS,GAAe,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,IAAI,KAAK,CAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5F,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;QACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YAChC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IACD,MAAM,UAAU,GAAG,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAClD,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,KAAK,GAAG,CAAC,CAAoB,EAAU,EAAE,CAC7C,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1E,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjF,2FAA2F;IAC3F,uFAAuF;IACvF,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAC9D,IAAI,MAAM,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,wBAAwB,MAAM,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC/E,CAAC;IACD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC","sourcesContent":["/**\n * The one component owner: items that share a (canonical) quantity are one cluster.\n *\n * `linkageMap` (equations sharing a quantity), `buildVizModel` (junctions sharing a quantity,\n * with a proposed or user overlay) and the discovery funnel (quantities sharing an equation or\n * an identification) each once ran their own union-find with the same ordering. This module is\n * that partition, computed through MathTS `connectedComponents` over an adjacency of item\n * indices, with the ordering every caller used: a cluster keeps its items in input order, and\n * clusters come largest first, then by the id of their first item. The anchoring rules differ\n * between callers on purpose (`graph-viz.ts` anchors on `law` or `established` status,\n * `bridge-analysis.ts` on `established` confidence) and stay with each caller.\n *\n * @module composition/quantity-clusters\n */\n\nimport { connectedComponents } from '@danielsimonjr/mathts-functions';\nimport { QUANTITY_IDENTIFICATIONS } from './compose.js';\n\n/**\n * Quantity-name canonicalizer honouring `QUANTITY_IDENTIFICATIONS`: maps each name to its\n * identified representative (`hawking-temperature` → `temperature`) and leaves every other\n * name alone. The linkage substrate of `linkageMap`, `proposeLinkCandidates` and the visual\n * map. `anchoringDistance` deliberately does NOT use it (it links on raw names; its 0/∞\n * distance contract is pinned).\n *\n * @internal\n */\nexport function quantityCanonicalizer(): (name: string) => string {\n  const alias = new Map<string, string>(QUANTITY_IDENTIFICATIONS.map((id) => [id.from, id.to]));\n  return (n: string): string => alias.get(n) ?? n;\n}\n\n/**\n * Group items by one key, keys in first-seen order, members in input order. The group-by\n * every cluster consumer once re-inlined as `if (!m.has(k)) m.set(k, []); m.get(k)!.push(v)`.\n *\n * @internal\n */\nexport function groupInto<K, V>(items: readonly V[], keyOf: (item: V) => K): Map<K, V[]> {\n  const out = new Map<K, V[]>();\n  for (const item of items) {\n    const k = keyOf(item);\n    const group = out.get(k);\n    if (group === undefined) out.set(k, [item]);\n    else group.push(item);\n  }\n  return out;\n}\n\n/**\n * Partition `items` into clusters of items that share at least one key (transitively): the\n * connected components, through MathTS `connectedComponents`, of the graph whose nodes are item\n * indices and whose links join items with a key in common. Each cluster lists its items in\n * input order; clusters come largest first, then by `idOf` of their first item (by that item's\n * input position when no `idOf` is given). An item with no key is a cluster of its own; an\n * empty input is no cluster.\n *\n * Cost: `connectedComponents` takes a dense n×n adjacency matrix, so memory is O(n²) in the\n * number of items (8·n² bytes as numbers: about 4 MB at n = 700, the order of the quantity\n * names one discovery context clusters, once per context; 800 MB at n = 10 000). A caller with\n * thousands of items should expect that, or cluster with a union-find over the key lists.\n *\n * @internal\n */\nexport function clusterBySharedKeys<T>(\n  items: readonly T[],\n  keysOf: (item: T) => readonly string[],\n  idOf?: (item: T) => string,\n): T[][] {\n  const n = items.length;\n  if (n === 0) return [];\n  // Items sharing a key: the first holder of the key is linked to every later holder, which is\n  // enough for connectivity (a star joins the whole set).\n  const holders = new Map<string, number[]>();\n  items.forEach((item, i) => {\n    for (const key of keysOf(item)) {\n      const list = holders.get(key);\n      if (list === undefined) holders.set(key, [i]);\n      else list.push(i);\n    }\n  });\n  const adjacency: number[][] = Array.from({ length: n }, () => new Array<number>(n).fill(0));\n  for (const idxs of holders.values()) {\n    for (let k = 1; k < idxs.length; k++) {\n      adjacency[idxs[0]][idxs[k]] = 1;\n      adjacency[idxs[k]][idxs[0]] = 1;\n    }\n  }\n  const components = connectedComponents(adjacency);\n  const clusters = components.map((idxs) => [...idxs].sort((a, b) => a - b));\n  const first = (c: readonly number[]): string =>\n    idOf === undefined ? String(c[0]).padStart(12, '0') : idOf(items[c[0]]);\n  clusters.sort((a, b) => b.length - a.length || first(a).localeCompare(first(b)));\n  // Every item is placed exactly once: a component listing that dropped or repeated an index\n  // would be the instrument reporting its own breakage, so say so rather than render it.\n  const placed = clusters.reduce((acc, c) => acc + c.length, 0);\n  if (placed !== n || new Set(clusters.flat()).size !== n) {\n    throw new Error(`clusterBySharedKeys: ${placed} placements over ${n} items`);\n  }\n  return clusters.map((c) => c.map((i) => items[i]));\n}\n"]}

package/dist/composition/rational-exponent.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Exact rationals from doubles, for exponents and prefactors.
+ *
+ * A monomial exponent read from an AST literal (`0.5`, `0.3333333333333333`)
+ * and a prefactor recovered by a fit are doubles that stand for small
+ * rationals. This module turns one into a core `Fraction` when a rational
+ * with a bounded denominator reproduces it to a stated relative tolerance,
+ * and refuses otherwise, so an irrational is never approximated into a
+ * rational and a rounding error never becomes a denominator of 10¹⁶.
+ *
+ * `Fraction.fromNumber(x, cap)` is asked first. Before `@danielsimonjr/mathts-core`
+ * 0.18.1 it could return a denominator above its cap; the cap and the tolerance
+ * are still checked here, which costs nothing and catches a regression. When that answer is refused, a bounded-denominator scan (the one
+ * `dimensional/buckingham.ts` uses for dimension exponents) is the second
+ * method, so a rational the continued fraction stepped past is still found.
+ *
+ * @module composition/rational-exponent
+ */
+import { Fraction } from '@danielsimonjr/mathts-core';
+/** The denominator cap the Buckingham enumerator uses for exponents. @internal */
+export declare const DEFAULT_MAX_DENOMINATOR = 720;
+/** Options of {@link rationalize}. @internal */
+export interface RationalizeOptions {
+    /** Largest denominator accepted (default {@link DEFAULT_MAX_DENOMINATOR}). */
+    readonly maxDenominator?: number;
+    /** Relative tolerance `|n/d − x| ≤ tolerance·|x|` (default 1e-9); for `x = 0` the match is exact. */
+    readonly tolerance?: number;
+}
+/**
+ * The rational with denominator ≤ `maxDenominator` that reproduces `x` to
+ * the tolerance, or `undefined` when there is none.
+ *
+ * @internal
+ */
+export declare function rationalize(x: number, options?: RationalizeOptions): Fraction | undefined;
+/** The double a fraction stands for, MathTS `Fraction#toNumber`. @internal */
+export declare function fractionToNumber(f: Fraction): number;
+/** `9/8`, `2`, `-1/3`: the fraction in lowest terms, no sign on the denominator; MathTS `Fraction#toString`. @internal */
+export declare function formatRational(f: Fraction): string;
+//# sourceMappingURL=rational-exponent.d.ts.map

package/dist/composition/rational-exponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rational-exponent.d.ts","sourceRoot":"","sources":["../../src/composition/rational-exponent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtD,kFAAkF;AAClF,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C,gDAAgD;AAChD,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,qGAAqG;IACrG,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAQD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,QAAQ,GAAG,SAAS,CAiB7F;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,0HAA0H;AAC1H,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAElD"}

package/dist/composition/rational-exponent.js

@@ -0,0 +1,65 @@
+/**
+ * Exact rationals from doubles, for exponents and prefactors.
+ *
+ * A monomial exponent read from an AST literal (`0.5`, `0.3333333333333333`)
+ * and a prefactor recovered by a fit are doubles that stand for small
+ * rationals. This module turns one into a core `Fraction` when a rational
+ * with a bounded denominator reproduces it to a stated relative tolerance,
+ * and refuses otherwise, so an irrational is never approximated into a
+ * rational and a rounding error never becomes a denominator of 10¹⁶.
+ *
+ * `Fraction.fromNumber(x, cap)` is asked first. Before `@danielsimonjr/mathts-core`
+ * 0.18.1 it could return a denominator above its cap; the cap and the tolerance
+ * are still checked here, which costs nothing and catches a regression. When that answer is refused, a bounded-denominator scan (the one
+ * `dimensional/buckingham.ts` uses for dimension exponents) is the second
+ * method, so a rational the continued fraction stepped past is still found.
+ *
+ * @module composition/rational-exponent
+ */
+import { Fraction } from '@danielsimonjr/mathts-core';
+/** The denominator cap the Buckingham enumerator uses for exponents. @internal */
+export const DEFAULT_MAX_DENOMINATOR = 720;
+function within(candidate, x, tolerance) {
+    const value = fractionToNumber(candidate);
+    if (x === 0)
+        return value === 0;
+    return Math.abs(value - x) <= tolerance * Math.abs(x);
+}
+/**
+ * The rational with denominator ≤ `maxDenominator` that reproduces `x` to
+ * the tolerance, or `undefined` when there is none.
+ *
+ * @internal
+ */
+export function rationalize(x, options = {}) {
+    if (!Number.isFinite(x))
+        return undefined;
+    const maxDenominator = options.maxDenominator ?? DEFAULT_MAX_DENOMINATOR;
+    const tolerance = options.tolerance ?? 1e-9;
+    if (Number.isInteger(x))
+        return new Fraction(x, 1);
+    const guess = Fraction.fromNumber(x, BigInt(maxDenominator));
+    if (guess.denominator <= BigInt(maxDenominator) && within(guess, x, tolerance))
+        return guess;
+    for (let d = 1; d <= maxDenominator; d++) {
+        const n = Math.round(x * d);
+        // A safe-integer n/d is the same correctly rounded quotient as the reduced
+        // fraction's, so a miss is decided on doubles and no Fraction is built for it
+        // (the clean-prefactor rule asks this 43,200 times for one miss).
+        if (Number.isSafeInteger(n) && !(Math.abs(n / d - x) <= tolerance * Math.abs(x)))
+            continue;
+        const candidate = new Fraction(n, d);
+        if (within(candidate, x, tolerance))
+            return candidate;
+    }
+    return undefined;
+}
+/** The double a fraction stands for, MathTS `Fraction#toNumber`. @internal */
+export function fractionToNumber(f) {
+    return f.toNumber();
+}
+/** `9/8`, `2`, `-1/3`: the fraction in lowest terms, no sign on the denominator; MathTS `Fraction#toString`. @internal */
+export function formatRational(f) {
+    return f.toString();
+}
+//# sourceMappingURL=rational-exponent.js.map

package/dist/composition/rational-exponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rational-exponent.js","sourceRoot":"","sources":["../../src/composition/rational-exponent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtD,kFAAkF;AAClF,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAU3C,SAAS,MAAM,CAAC,SAAmB,EAAE,CAAS,EAAE,SAAiB;IAC/D,MAAM,KAAK,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;IAC1C,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,KAAK,CAAC,CAAC;IAChC,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,CAAS,EAAE,OAAO,GAAuB,EAAE;IACrE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1C,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,uBAAuB,CAAC;IACzE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC;IAC5C,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD,MAAM,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC;IAC7D,IAAI,KAAK,CAAC,WAAW,IAAI,MAAM,CAAC,cAAc,CAAC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,SAAS,CAAC;QAAE,OAAO,KAAK,CAAC;IAC7F,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,cAAc,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5B,2EAA2E;QAC3E,8EAA8E;QAC9E,kEAAkE;QAClE,IAAI,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAAE,SAAS;QAC3F,MAAM,SAAS,GAAG,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACrC,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC;YAAE,OAAO,SAAS,CAAC;IACxD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,gBAAgB,CAAC,CAAW;IAC1C,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;AACtB,CAAC;AAED,0HAA0H;AAC1H,MAAM,UAAU,cAAc,CAAC,CAAW;IACxC,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;AACtB,CAAC","sourcesContent":["/**\n * Exact rationals from doubles, for exponents and prefactors.\n *\n * A monomial exponent read from an AST literal (`0.5`, `0.3333333333333333`)\n * and a prefactor recovered by a fit are doubles that stand for small\n * rationals. This module turns one into a core `Fraction` when a rational\n * with a bounded denominator reproduces it to a stated relative tolerance,\n * and refuses otherwise, so an irrational is never approximated into a\n * rational and a rounding error never becomes a denominator of 10¹⁶.\n *\n * `Fraction.fromNumber(x, cap)` is asked first. Before `@danielsimonjr/mathts-core`\n * 0.18.1 it could return a denominator above its cap; the cap and the tolerance\n * are still checked here, which costs nothing and catches a regression. When that answer is refused, a bounded-denominator scan (the one\n * `dimensional/buckingham.ts` uses for dimension exponents) is the second\n * method, so a rational the continued fraction stepped past is still found.\n *\n * @module composition/rational-exponent\n */\n\nimport { Fraction } from '@danielsimonjr/mathts-core';\n\n/** The denominator cap the Buckingham enumerator uses for exponents. @internal */\nexport const DEFAULT_MAX_DENOMINATOR = 720;\n\n/** Options of {@link rationalize}. @internal */\nexport interface RationalizeOptions {\n  /** Largest denominator accepted (default {@link DEFAULT_MAX_DENOMINATOR}). */\n  readonly maxDenominator?: number;\n  /** Relative tolerance `|n/d − x| ≤ tolerance·|x|` (default 1e-9); for `x = 0` the match is exact. */\n  readonly tolerance?: number;\n}\n\nfunction within(candidate: Fraction, x: number, tolerance: number): boolean {\n  const value = fractionToNumber(candidate);\n  if (x === 0) return value === 0;\n  return Math.abs(value - x) <= tolerance * Math.abs(x);\n}\n\n/**\n * The rational with denominator ≤ `maxDenominator` that reproduces `x` to\n * the tolerance, or `undefined` when there is none.\n *\n * @internal\n */\nexport function rationalize(x: number, options: RationalizeOptions = {}): Fraction | undefined {\n  if (!Number.isFinite(x)) return undefined;\n  const maxDenominator = options.maxDenominator ?? DEFAULT_MAX_DENOMINATOR;\n  const tolerance = options.tolerance ?? 1e-9;\n  if (Number.isInteger(x)) return new Fraction(x, 1);\n  const guess = Fraction.fromNumber(x, BigInt(maxDenominator));\n  if (guess.denominator <= BigInt(maxDenominator) && within(guess, x, tolerance)) return guess;\n  for (let d = 1; d <= maxDenominator; d++) {\n    const n = Math.round(x * d);\n    // A safe-integer n/d is the same correctly rounded quotient as the reduced\n    // fraction's, so a miss is decided on doubles and no Fraction is built for it\n    // (the clean-prefactor rule asks this 43,200 times for one miss).\n    if (Number.isSafeInteger(n) && !(Math.abs(n / d - x) <= tolerance * Math.abs(x))) continue;\n    const candidate = new Fraction(n, d);\n    if (within(candidate, x, tolerance)) return candidate;\n  }\n  return undefined;\n}\n\n/** The double a fraction stands for, MathTS `Fraction#toNumber`. @internal */\nexport function fractionToNumber(f: Fraction): number {\n  return f.toNumber();\n}\n\n/** `9/8`, `2`, `-1/3`: the fraction in lowest terms, no sign on the denominator; MathTS `Fraction#toString`. @internal */\nexport function formatRational(f: Fraction): string {\n  return f.toString();\n}\n"]}

package/dist/composition/representative-values.d.ts

@@ -34,7 +34,29 @@ export interface RepresentativeValue {
     readonly value: number;
     /** Provenance — how the estimate is obtained (a citation or a one-liner). */
     readonly source: string;
+    /**
+     * The value's stated uncertainty, as a standard deviation in decades of `log10|value|`.
+     * Absent means {@link DEFAULT_SIGMA_DECADES}, the table's "good to about one order"; a row
+     * states another only with a source for it. The graded magnitude gate
+     * (`discovery.ts`, `magnitudeP`) reads it; the verdict threshold does not.
+     */
+    readonly sigmaDecades?: number;
 }
+/**
+ * The σ in decades a representative value carries when its row states none: one decade, the
+ * precision this table has always claimed ("good to ~1 order"). Not a per-row measurement.
+ *
+ * @internal
+ */
+export declare const DEFAULT_SIGMA_DECADES = 1;
+/**
+ * The σ in decades of a representative value: its own `sigmaDecades`, else the default. A stated
+ * σ that is not a finite number > 0 is refused with a `RangeError` naming the row's source: σ = 0
+ * would make the falsifier's strength 0 (certain) and a negative or NaN σ would make it NaN.
+ *
+ * @internal
+ */
+export declare function sigmaDecadesOf(rv: RepresentativeValue): number;
 /**
  * Scale-specific quantities only. Keyed by the canonical quantity name used in
  * the composition graph. Generic quantities are intentionally omitted.

package/dist/composition/representative-values.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"representative-values.d.ts","sourceRoot":"","sources":["../../src/composition/representative-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAC1C,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CA0DpC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,GACX,mBAAmB,GAAG,SAAS,CAEjC"}
+{"version":3,"file":"representative-values.d.ts","sourceRoot":"","sources":["../../src/composition/representative-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,mBAAmB,GAAG,MAAM,CAS9D;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAC1C,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAiEpC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,GACX,mBAAmB,GAAG,SAAS,CAEjC"}

package/dist/composition/representative-values.js

@@ -28,6 +28,29 @@
  *
  * @module composition/representative-values
  */
+/**
+ * The σ in decades a representative value carries when its row states none: one decade, the
+ * precision this table has always claimed ("good to ~1 order"). Not a per-row measurement.
+ *
+ * @internal
+ */
+export const DEFAULT_SIGMA_DECADES = 1;
+/**
+ * The σ in decades of a representative value: its own `sigmaDecades`, else the default. A stated
+ * σ that is not a finite number > 0 is refused with a `RangeError` naming the row's source: σ = 0
+ * would make the falsifier's strength 0 (certain) and a negative or NaN σ would make it NaN.
+ *
+ * @internal
+ */
+export function sigmaDecadesOf(rv) {
+    const sigma = rv.sigmaDecades;
+    if (sigma === undefined)
+        return DEFAULT_SIGMA_DECADES;
+    if (!(Number.isFinite(sigma) && sigma > 0)) {
+        throw new RangeError(`representative value sigmaDecades ${String(sigma)} (source: ${rv.source}) must be a finite number > 0 decades`);
+    }
+    return sigma;
+}
 /**
  * Scale-specific quantities only. Keyed by the canonical quantity name used in
  * the composition graph. Generic quantities are intentionally omitted.
@@ -76,6 +99,12 @@ export const REPRESENTATIVE_VALUES = {
         source: 'BE-26 DNA H-bond proton-tunneling distance ~1 Å (Löwdin 1963)',
     },
     'planck-length': { value: 1.616e-35, source: 'ℓ_P = √(ℏG/c³)' },
+    // The Hubble distance is a definite cosmological scale, not a generic length: c over the
+    // hubble-rate row above (a test pins the two rows together, so one cannot move alone).
+    'hubble-distance': {
+        value: 1.363e26,
+        source: 'D_H = c/H0 = 2.998e8 m/s / 2.2e-18 s^-1 ≈ 1.363e26 m, with H0 ≈ 67 km/s/Mpc (Planck 2018), the hubble-rate row',
+    },
     // Canonical-graph atomic length scales — sourced so the gate compares real
     // magnitudes instead of falling back to the {mass: M_sun} anchor, which makes
     // a 1/mass quantity like the Compton wavelength absurdly small (~10⁻⁷³ m) and

package/dist/composition/representative-values.js.map

@@ -1 +1 @@
-{"version":3,"file":"representative-values.js","sourceRoot":"","sources":["../../src/composition/representative-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAUH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAE9B;IACF,2EAA2E;IAC3E,aAAa,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,gCAAgC,EAAE;IAC3E,uBAAuB,EAAE;QACvB,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,gEAAgE;KACzE;IACD,mBAAmB,EAAE;QACnB,KAAK,EAAE,IAAI;QACX,MAAM,EAAE,0CAA0C;KACnD;IAED,2EAA2E;IAC3E,yBAAyB,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,qBAAqB,EAAE;IAC5E,oBAAoB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,EAAE;IACzE,0BAA0B,EAAE;QAC1B,KAAK,EAAE,OAAO;QACd,MAAM,EAAE,uBAAuB;KAChC;IACD,gBAAgB,EAAE;QAChB,KAAK,EAAE,OAAO;QACd,MAAM,EAAE,sDAAsD;KAC/D;IAED,2EAA2E;IAC3E,aAAa,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE;IAC3D,gBAAgB,EAAE;QAChB,KAAK,EAAE,SAAS;QAChB,MAAM,EAAE,4DAA4D;KACrE;IAED,2EAA2E;IAC3E,iBAAiB,EAAE;QACjB,KAAK,EAAE,IAAI;QACX,MAAM,EAAE,mCAAmC;KAC5C;IACD,yBAAyB,EAAE;QACzB,KAAK,EAAE,IAAI;QACX,MAAM,EAAE,iEAAiE;KAC1E;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,+DAA+D;KACxE;IACD,eAAe,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE;IAC/D,2EAA2E;IAC3E,8EAA8E;IAC9E,8EAA8E;IAC9E,6DAA6D;IAC7D,oBAAoB,EAAE;QACpB,KAAK,EAAE,SAAS;QAChB,MAAM,EAAE,mEAAmE;KAC5E;IACD,aAAa,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,uCAAuC,EAAE;IAEpF,2EAA2E;IAC3E,aAAa,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE;CAC7D,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAY;IAEZ,OAAO,qBAAqB,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC","sourcesContent":["/**\n * Order-of-magnitude representative values for the discovery falsifier.\n *\n * The discovery loop (`discovery.ts`) vets a hypothesised identification a≡b,\n * but its numeric check (`retrodict`) runs from a single anchor and cannot\n * evaluate the quantities a dimensional coincidence \"unlocks\" — so it never\n * contradicts them, and they surface as `promising` (e.g.\n * `landauer-erasure-energy ≟ planck-mass-energy`, ~30 orders apart). The graph\n * structurally CANNOT supply the magnitudes that would falsify these.\n *\n * This table injects that missing ground truth: a sourced, order-of-magnitude\n * value for quantities that have a WELL-DEFINED physical scale. Two classes are\n * deliberately ABSENT:\n *   - generic quantities (`mass`, `energy`, `length`, …) — no single scale (the\n *     discovery gate now reads these from the graph at the anchor instead, see\n *     `discovery.ts`); and\n *   - speculative-physics quantities with no agreed scale (`dark-fermion-mass`,\n *     `scalar-field-value`, `inflation-hubble-energy`, `boundary-length`, the\n *     time-dependent `coarsening-length`) — a value would be fabrication, so the\n *     gate correctly abstains on them.\n * When a value is absent the gate abstains; it never false-rejects on unknowns.\n *\n * Values are order-of-magnitude estimates (good to ~1 order), each carrying its\n * provenance. Nothing here is fabricated; coarse by design. When the canonical-\n * equation registry lands it can supply these centrally and this table folds in.\n *\n * INTERNAL — surfaced via `upt discover`.\n *\n * @module composition/representative-values\n */\n\n/** A sourced order-of-magnitude value for one quantity. @internal */\nexport interface RepresentativeValue {\n  /** Order-of-magnitude value in the quantity's SI unit (good to ~1 order). */\n  readonly value: number;\n  /** Provenance — how the estimate is obtained (a citation or a one-liner). */\n  readonly source: string;\n}\n\n/**\n * Scale-specific quantities only. Keyed by the canonical quantity name used in\n * the composition graph. Generic quantities are intentionally omitted.\n *\n * @internal\n */\nexport const REPRESENTATIVE_VALUES: Readonly<\n  Record<string, RepresentativeValue>\n> = {\n  // ── frequencies / rates [s^-1] ──────────────────────────────────────────\n  'hubble-rate': { value: 2.2e-18, source: 'H0 ≈ 67 km/s/Mpc (Planck 2018)' },\n  'grw-localization-rate': {\n    value: 1e-16,\n    source: 'GRW collapse rate λ ≈ 10^-16 s^-1 (Ghirardi–Rimini–Weber 1986)',\n  },\n  'attempt-frequency': {\n    value: 1e13,\n    source: 'Debye/phonon attempt frequency ~10^13 Hz',\n  },\n\n  // ── energies [J] ────────────────────────────────────────────────────────\n  'landauer-erasure-energy': { value: 2.9e-21, source: 'kT·ln2 at T = 300 K' },\n  'planck-mass-energy': { value: 1.96e9, source: 'm_P·c² (m_P = √(ℏc/G))' },\n  'vacuum-expectation-value': {\n    value: 3.94e-8,\n    source: 'Higgs VEV v ≈ 246 GeV',\n  },\n  'barrier-height': {\n    value: 3.2e-20,\n    source: 'BE-26 Löwdin DNA proton-transfer barrier V−E ~0.2 eV',\n  },\n\n  // ── masses [kg] ─────────────────────────────────────────────────────────\n  'planck-mass': { value: 2.176e-8, source: 'm_P = √(ℏc/G)' },\n  'tunneling-mass': {\n    value: 1.673e-27,\n    source: 'BE-26 tunneling particle is the proton, m_p = 1.673e-27 kg',\n  },\n\n  // ── lengths [m] ─────────────────────────────────────────────────────────\n  'foerster-radius': {\n    value: 5e-9,\n    source: 'typical FRET Förster radius ~5 nm',\n  },\n  'donor-acceptor-distance': {\n    value: 5e-9,\n    source: 'BE-24 FRET donor–acceptor separation ~5 nm (same regime as R_0)',\n  },\n  'barrier-width': {\n    value: 1e-10,\n    source: 'BE-26 DNA H-bond proton-tunneling distance ~1 Å (Löwdin 1963)',\n  },\n  'planck-length': { value: 1.616e-35, source: 'ℓ_P = √(ℏG/c³)' },\n  // Canonical-graph atomic length scales — sourced so the gate compares real\n  // magnitudes instead of falling back to the {mass: M_sun} anchor, which makes\n  // a 1/mass quantity like the Compton wavelength absurdly small (~10⁻⁷³ m) and\n  // produces a spurious clash against the (fixed) Bohr radius.\n  'compton-wavelength': {\n    value: 2.426e-12,\n    source: 'electron Compton wavelength λ_C = h/(m_e c) = 2.43e-12 m (CODATA)',\n  },\n  'bohr-radius': { value: 5.292e-11, source: 'Bohr radius a_0 = 5.29e-11 m (CODATA)' },\n\n  // ── times [s] ───────────────────────────────────────────────────────────\n  'planck-time': { value: 5.39e-44, source: 't_P = √(ℏG/c⁵)' },\n};\n\n/**\n * The sourced order-of-magnitude value for `name`, or `undefined` when the\n * quantity has no well-defined representative scale (the gate then abstains).\n *\n * @internal\n */\nexport function representativeValue(\n  name: string,\n): RepresentativeValue | undefined {\n  return REPRESENTATIVE_VALUES[name];\n}\n"]}
+{"version":3,"file":"representative-values.js","sourceRoot":"","sources":["../../src/composition/representative-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAiBH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,EAAuB;IACpD,MAAM,KAAK,GAAG,EAAE,CAAC,YAAY,CAAC;IAC9B,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,qBAAqB,CAAC;IACtD,IAAI,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAClB,qCAAqC,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC,MAAM,uCAAuC,CAChH,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAE9B;IACF,2EAA2E;IAC3E,aAAa,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,gCAAgC,EAAE;IAC3E,uBAAuB,EAAE;QACvB,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,gEAAgE;KACzE;IACD,mBAAmB,EAAE;QACnB,KAAK,EAAE,IAAI;QACX,MAAM,EAAE,0CAA0C;KACnD;IAED,2EAA2E;IAC3E,yBAAyB,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,qBAAqB,EAAE;IAC5E,oBAAoB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,EAAE;IACzE,0BAA0B,EAAE;QAC1B,KAAK,EAAE,OAAO;QACd,MAAM,EAAE,uBAAuB;KAChC;IACD,gBAAgB,EAAE;QAChB,KAAK,EAAE,OAAO;QACd,MAAM,EAAE,sDAAsD;KAC/D;IAED,2EAA2E;IAC3E,aAAa,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE;IAC3D,gBAAgB,EAAE;QAChB,KAAK,EAAE,SAAS;QAChB,MAAM,EAAE,4DAA4D;KACrE;IAED,2EAA2E;IAC3E,iBAAiB,EAAE;QACjB,KAAK,EAAE,IAAI;QACX,MAAM,EAAE,mCAAmC;KAC5C;IACD,yBAAyB,EAAE;QACzB,KAAK,EAAE,IAAI;QACX,MAAM,EAAE,iEAAiE;KAC1E;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,+DAA+D;KACxE;IACD,eAAe,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE;IAC/D,yFAAyF;IACzF,uFAAuF;IACvF,iBAAiB,EAAE;QACjB,KAAK,EAAE,QAAQ;QACf,MAAM,EACJ,gHAAgH;KACnH;IACD,2EAA2E;IAC3E,8EAA8E;IAC9E,8EAA8E;IAC9E,6DAA6D;IAC7D,oBAAoB,EAAE;QACpB,KAAK,EAAE,SAAS;QAChB,MAAM,EAAE,mEAAmE;KAC5E;IACD,aAAa,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,uCAAuC,EAAE;IAEpF,2EAA2E;IAC3E,aAAa,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE;CAC7D,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAY;IAEZ,OAAO,qBAAqB,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC","sourcesContent":["/**\n * Order-of-magnitude representative values for the discovery falsifier.\n *\n * The discovery loop (`discovery.ts`) vets a hypothesised identification a≡b,\n * but its numeric check (`retrodict`) runs from a single anchor and cannot\n * evaluate the quantities a dimensional coincidence \"unlocks\" — so it never\n * contradicts them, and they surface as `promising` (e.g.\n * `landauer-erasure-energy ≟ planck-mass-energy`, ~30 orders apart). The graph\n * structurally CANNOT supply the magnitudes that would falsify these.\n *\n * This table injects that missing ground truth: a sourced, order-of-magnitude\n * value for quantities that have a WELL-DEFINED physical scale. Two classes are\n * deliberately ABSENT:\n *   - generic quantities (`mass`, `energy`, `length`, …) — no single scale (the\n *     discovery gate now reads these from the graph at the anchor instead, see\n *     `discovery.ts`); and\n *   - speculative-physics quantities with no agreed scale (`dark-fermion-mass`,\n *     `scalar-field-value`, `inflation-hubble-energy`, `boundary-length`, the\n *     time-dependent `coarsening-length`) — a value would be fabrication, so the\n *     gate correctly abstains on them.\n * When a value is absent the gate abstains; it never false-rejects on unknowns.\n *\n * Values are order-of-magnitude estimates (good to ~1 order), each carrying its\n * provenance. Nothing here is fabricated; coarse by design. When the canonical-\n * equation registry lands it can supply these centrally and this table folds in.\n *\n * INTERNAL — surfaced via `upt discover`.\n *\n * @module composition/representative-values\n */\n\n/** A sourced order-of-magnitude value for one quantity. @internal */\nexport interface RepresentativeValue {\n  /** Order-of-magnitude value in the quantity's SI unit (good to ~1 order). */\n  readonly value: number;\n  /** Provenance — how the estimate is obtained (a citation or a one-liner). */\n  readonly source: string;\n  /**\n   * The value's stated uncertainty, as a standard deviation in decades of `log10|value|`.\n   * Absent means {@link DEFAULT_SIGMA_DECADES}, the table's \"good to about one order\"; a row\n   * states another only with a source for it. The graded magnitude gate\n   * (`discovery.ts`, `magnitudeP`) reads it; the verdict threshold does not.\n   */\n  readonly sigmaDecades?: number;\n}\n\n/**\n * The σ in decades a representative value carries when its row states none: one decade, the\n * precision this table has always claimed (\"good to ~1 order\"). Not a per-row measurement.\n *\n * @internal\n */\nexport const DEFAULT_SIGMA_DECADES = 1;\n\n/**\n * The σ in decades of a representative value: its own `sigmaDecades`, else the default. A stated\n * σ that is not a finite number > 0 is refused with a `RangeError` naming the row's source: σ = 0\n * would make the falsifier's strength 0 (certain) and a negative or NaN σ would make it NaN.\n *\n * @internal\n */\nexport function sigmaDecadesOf(rv: RepresentativeValue): number {\n  const sigma = rv.sigmaDecades;\n  if (sigma === undefined) return DEFAULT_SIGMA_DECADES;\n  if (!(Number.isFinite(sigma) && sigma > 0)) {\n    throw new RangeError(\n      `representative value sigmaDecades ${String(sigma)} (source: ${rv.source}) must be a finite number > 0 decades`,\n    );\n  }\n  return sigma;\n}\n\n/**\n * Scale-specific quantities only. Keyed by the canonical quantity name used in\n * the composition graph. Generic quantities are intentionally omitted.\n *\n * @internal\n */\nexport const REPRESENTATIVE_VALUES: Readonly<\n  Record<string, RepresentativeValue>\n> = {\n  // ── frequencies / rates [s^-1] ──────────────────────────────────────────\n  'hubble-rate': { value: 2.2e-18, source: 'H0 ≈ 67 km/s/Mpc (Planck 2018)' },\n  'grw-localization-rate': {\n    value: 1e-16,\n    source: 'GRW collapse rate λ ≈ 10^-16 s^-1 (Ghirardi–Rimini–Weber 1986)',\n  },\n  'attempt-frequency': {\n    value: 1e13,\n    source: 'Debye/phonon attempt frequency ~10^13 Hz',\n  },\n\n  // ── energies [J] ────────────────────────────────────────────────────────\n  'landauer-erasure-energy': { value: 2.9e-21, source: 'kT·ln2 at T = 300 K' },\n  'planck-mass-energy': { value: 1.96e9, source: 'm_P·c² (m_P = √(ℏc/G))' },\n  'vacuum-expectation-value': {\n    value: 3.94e-8,\n    source: 'Higgs VEV v ≈ 246 GeV',\n  },\n  'barrier-height': {\n    value: 3.2e-20,\n    source: 'BE-26 Löwdin DNA proton-transfer barrier V−E ~0.2 eV',\n  },\n\n  // ── masses [kg] ─────────────────────────────────────────────────────────\n  'planck-mass': { value: 2.176e-8, source: 'm_P = √(ℏc/G)' },\n  'tunneling-mass': {\n    value: 1.673e-27,\n    source: 'BE-26 tunneling particle is the proton, m_p = 1.673e-27 kg',\n  },\n\n  // ── lengths [m] ─────────────────────────────────────────────────────────\n  'foerster-radius': {\n    value: 5e-9,\n    source: 'typical FRET Förster radius ~5 nm',\n  },\n  'donor-acceptor-distance': {\n    value: 5e-9,\n    source: 'BE-24 FRET donor–acceptor separation ~5 nm (same regime as R_0)',\n  },\n  'barrier-width': {\n    value: 1e-10,\n    source: 'BE-26 DNA H-bond proton-tunneling distance ~1 Å (Löwdin 1963)',\n  },\n  'planck-length': { value: 1.616e-35, source: 'ℓ_P = √(ℏG/c³)' },\n  // The Hubble distance is a definite cosmological scale, not a generic length: c over the\n  // hubble-rate row above (a test pins the two rows together, so one cannot move alone).\n  'hubble-distance': {\n    value: 1.363e26,\n    source:\n      'D_H = c/H0 = 2.998e8 m/s / 2.2e-18 s^-1 ≈ 1.363e26 m, with H0 ≈ 67 km/s/Mpc (Planck 2018), the hubble-rate row',\n  },\n  // Canonical-graph atomic length scales — sourced so the gate compares real\n  // magnitudes instead of falling back to the {mass: M_sun} anchor, which makes\n  // a 1/mass quantity like the Compton wavelength absurdly small (~10⁻⁷³ m) and\n  // produces a spurious clash against the (fixed) Bohr radius.\n  'compton-wavelength': {\n    value: 2.426e-12,\n    source: 'electron Compton wavelength λ_C = h/(m_e c) = 2.43e-12 m (CODATA)',\n  },\n  'bohr-radius': { value: 5.292e-11, source: 'Bohr radius a_0 = 5.29e-11 m (CODATA)' },\n\n  // ── times [s] ───────────────────────────────────────────────────────────\n  'planck-time': { value: 5.39e-44, source: 't_P = √(ℏG/c⁵)' },\n};\n\n/**\n * The sourced order-of-magnitude value for `name`, or `undefined` when the\n * quantity has no well-defined representative scale (the gate then abstains).\n *\n * @internal\n */\nexport function representativeValue(\n  name: string,\n): RepresentativeValue | undefined {\n  return REPRESENTATIVE_VALUES[name];\n}\n"]}

package/dist/composition/retrodiction.d.ts

@@ -30,6 +30,15 @@
  */
 import type { BridgeEdge } from './edge.js';
 import type { QuantityIdentification } from './compose.js';
+/**
+ * Source values, plus a dimensionless group the edge multiplies when the
+ * ground truth names it. The group is not a source: Buckingham cannot see
+ * it, and a missing group is the unset coefficient, not a missing input.
+ * Exported for the own-equation magnitudes (`own-equation-magnitude.ts`),
+ * which evaluate an edge the same way.
+ * @internal
+ */
+export declare function evaluationInputs(edge: BridgeEdge, values: ReadonlyMap<string, number>): Record<string, number>;
 /** Outcome of retrodicting one node. @public */
 export type RetrodictionOutcome = 'consistent' | 'inconsistent' | 'single' | 'unrecoverable';
 /** One derivation's recovered value for a masked node. @public */
@@ -94,6 +103,12 @@ export interface RetrodictionReport {
     /** The headline gate: no inconsistent node was found. */
     readonly allConsistent: boolean;
 }
+/**
+ * True when the error says the edge does not fire here (or at all, for an unset coefficient).
+ * Exported so the own-equation magnitudes read an edge's refusal by this one rule.
+ * @internal
+ */
+export declare function refusesThePoint(err: unknown): boolean;
 /**
  * Monotone forward EVALUATION: propagate values from `groundTruth` through
  * the graph (domain-checked; identifications supply identified names;

package/dist/composition/retrodiction.d.ts.map

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

package/dist/composition/retrodiction.js

@@ -33,6 +33,7 @@ import { CoefficientUnsetError, evaluateEdge } from './edge.js';
 import { DomainViolationError } from '../bridges/evaluation-errors.js';
 import { CarrierSignError } from '../bridges/carrier-sign.js';
 import { FormulaError } from '../numerical/formula-contract.js';
+import { meanOf } from '../numerical/statistics.js';
 import { QUANTITY_IDENTIFICATIONS } from './compose.js';
 import { conventionFactor } from '../dimensional/unit-convention.js';
 import { classifyAll } from './identifiability.js';
@@ -40,8 +41,11 @@ import { classifyAll } from './identifiability.js';
  * Source values, plus a dimensionless group the edge multiplies when the
  * ground truth names it. The group is not a source: Buckingham cannot see
  * it, and a missing group is the unset coefficient, not a missing input.
+ * Exported for the own-equation magnitudes (`own-equation-magnitude.ts`),
+ * which evaluate an edge the same way.
+ * @internal
  */
-function evaluationInputs(edge, values) {
+export function evaluationInputs(edge, values) {
     const inputs = {};
     for (const s of edge.sources)
         inputs[s.name] = values.get(s.name);
@@ -65,8 +69,12 @@ function refusalKind(err) {
         return 'formula';
     return undefined;
 }
-/** True when the error says the edge does not fire here (or at all, for an unset coefficient). */
-function refusesThePoint(err) {
+/**
+ * True when the error says the edge does not fire here (or at all, for an unset coefficient).
+ * Exported so the own-equation magnitudes read an edge's refusal by this one rule.
+ * @internal
+ */
+export function refusesThePoint(err) {
     return refusalKind(err) !== undefined;
 }
 /**
@@ -201,7 +209,7 @@ export function retrodictNode(edges, groundTruth, target, opts = {}) {
     };
     const ref = opts.references?.[target];
     if (ref !== undefined && predictions.length >= 1) {
-        const mean = predictions.reduce((a, p) => a + p.value, 0) / predictions.length;
+        const mean = meanOf(predictions.map((p) => p.value));
         const referenceRelError = Math.abs(mean - ref) / (Math.abs(ref) || 1);
         return {
             ...result,

package/dist/composition/retrodiction.js.map

@@ -1 +1 @@
-{"version":3,"file":"retrodiction.js","sourceRoot":"","sources":["../../src/composition/retrodiction.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Retrodiction harness (Consequence 2 of\n * docs/planning/Bridge-Inference-Epistemics-Note.md, designed in\n * docs/planning/Retrodiction-Harness-Design-Note.md).\n *\n * The framework's own falsification benchmark. Mask a quantity the graph\n * can compute, recompute it from ground-truth inputs via EACH independent\n * derivation, and check the predictions agree. This operationalizes the\n * identifiability classifier's OVER-DETERMINED verdict: the surplus\n * derivations of an over-determined node are PREDICTED to be consistency\n * constraints; the harness evaluates them and checks that numerically.\n *\n *   - consistent    — ≥2 derivations agree within tolerance.\n *   - inconsistent  — ≥2 derivations DISAGREE (a falsification: two\n *                     encodings of one quantity-name are not the same\n *                     physics).\n *   - single        — exactly one derivation fired (recovered, no check).\n *   - unrecoverable — no derivation fired from the ground truth.\n *\n * \"Mask\" = compute source values over the graph with every edge INTO the\n * target removed (the classifier's target-removed closure — so the node\n * is genuinely hidden, never read back through its own derivation).\n * Forward evaluation honors `QUANTITY_IDENTIFICATIONS` and is\n * domain-checked (an edge that refuses its domain contributes no\n * prediction). The consistency check needs no external truth and is the\n * re-runnable core; an optional `references` map adds external-value\n * scoring. Pass bar pre-registered in the design note (spread ≤ 1e-6).\n *\n * @module composition/retrodiction\n */\n\nimport type { BridgeEdge } from './edge.js';\nimport { CANONICAL_GROUP_PREFACTORS } from './canonical-prefactors.js';\nimport { CoefficientUnsetError, evaluateEdge } from './edge.js';\nimport { DomainViolationError } from '../bridges/evaluation-errors.js';\nimport { CarrierSignError } from '../bridges/carrier-sign.js';\nimport { FormulaError } from '../numerical/formula-contract.js';\nimport type { QuantityIdentification } from './compose.js';\nimport { QUANTITY_IDENTIFICATIONS } from './compose.js';\nimport { conventionFactor } from '../dimensional/unit-convention.js';\nimport { classifyAll } from './identifiability.js';\n\n/**\n * Source values, plus a dimensionless group the edge multiplies when the\n * ground truth names it. The group is not a source: Buckingham cannot see\n * it, and a missing group is the unset coefficient, not a missing input.\n */\nfunction evaluationInputs(edge: BridgeEdge, values: ReadonlyMap<string, number>): Record<string, number> {\n  const inputs: Record<string, number> = {};\n  for (const s of edge.sources) inputs[s.name] = values.get(s.name)!;\n  const group = CANONICAL_GROUP_PREFACTORS.find((g) => g.id === edge.id);\n  if (group !== undefined) {\n    const g = values.get(group.group);\n    if (g !== undefined) inputs[group.group] = g;\n  }\n  return inputs;\n}\n\n/** Outcome of retrodicting one node. @public */\nexport type RetrodictionOutcome =\n  | 'consistent'\n  | 'inconsistent'\n  | 'single'\n  | 'unrecoverable';\n\n/** One derivation's recovered value for a masked node. @public */\nexport interface RetrodictionPrediction {\n  /** The edge id that produced this value. */\n  readonly edge: string;\n  readonly value: number;\n}\n\n/** Options for the harness. @public */\nexport interface RetrodictionOptions {\n  /** Identifications honored in forward evaluation (default registered). */\n  readonly identifications?: readonly QuantityIdentification[];\n  /** Relative-spread tolerance for `consistent` (default 1e-6). */\n  readonly tolerance?: number;\n  /** External (textbook) values to score recovered nodes against. */\n  readonly references?: Readonly<Record<string, number>>;\n  /** Relative-error tolerance for reference scoring (default 1e-3). */\n  readonly referenceTolerance?: number;\n}\n\n/** One refused edge in a retrodiction, with the kind of refusal. @public */\nexport interface RetrodictionRefusal {\n  readonly edge: string;\n  /**\n   * `domain`: the validity domain rejected the point. `coefficient-unset`: the edge has no\n   * sourced prefactor, whatever the values. `carrier-sign`: the carrier charge and the\n   * mobility had opposite signs. `formula`: the relation's formula did not evaluate at the\n   * point (a 0/0, say). Four facts, kept apart (AGENTS law 4).\n   */\n  readonly kind: 'domain' | 'coefficient-unset' | 'carrier-sign' | 'formula';\n  readonly reason: string;\n}\n\n/** The result of retrodicting one node. @public */\nexport interface RetrodictionResult {\n  readonly target: string;\n  readonly outcome: RetrodictionOutcome;\n  /** Recovered values, one per derivation that fired. */\n  readonly predictions: readonly RetrodictionPrediction[];\n  /** (max − min)/|mean| across predictions; 0 when fewer than two. */\n  readonly relativeSpread: number;\n  readonly tolerance: number;\n  /**\n   * Edges that refused the supplied values. `kind` keeps the refusals apart (AGENTS law 4):\n   * `domain`, `carrier-sign` and `formula` are the point (the edge does not fire there);\n   * `coefficient-unset` is the edge's own state (no sourced prefactor), whatever the values.\n   */\n  readonly refusals?: readonly RetrodictionRefusal[];\n  /** `outcome !== 'inconsistent'` — the falsification gate. */\n  readonly pass: boolean;\n  /** Supplied external value, when scored. */\n  readonly referenceValue?: number;\n  /** |mean(predictions) − reference| / |reference|, when scored. */\n  readonly referenceRelError?: number;\n  readonly referencePass?: boolean;\n}\n\n/** Aggregate report across the swept nodes. @public */\nexport interface RetrodictionReport {\n  readonly results: readonly RetrodictionResult[];\n  /** Nodes with ≥2 derivations (consistent + inconsistent). */\n  readonly checked: number;\n  readonly consistent: number;\n  readonly inconsistent: number;\n  /** The headline gate: no inconsistent node was found. */\n  readonly allConsistent: boolean;\n}\n\n/** The refusal an evaluator error is, or `undefined` when it is not a refusal at all. */\nfunction refusalKind(err: unknown): RetrodictionRefusal['kind'] | undefined {\n  if (err instanceof DomainViolationError) return 'domain';\n  if (err instanceof CoefficientUnsetError) return 'coefficient-unset';\n  if (err instanceof CarrierSignError) return 'carrier-sign';\n  if (err instanceof FormulaError) return 'formula';\n  return undefined;\n}\n\n/** True when the error says the edge does not fire here (or at all, for an unset coefficient). */\nfunction refusesThePoint(err: unknown): boolean {\n  return refusalKind(err) !== undefined;\n}\n\n/**\n * Monotone forward EVALUATION: propagate values from `groundTruth` through\n * the graph (domain-checked; identifications supply identified names;\n * non-finite or domain-refused edges do not fire). Each node is assigned\n * the value of the first edge that fires for it.\n *\n * Exported `@internal` so the discovery magnitude-gate can read a quantity's\n * value AT THE REGISTERED ANCHOR when the static representative-value table\n * has no entry for it (graph-derived quantities like `schwarzschild-radius`).\n *\n * @internal\n */\nexport function forwardEvaluate(\n  edges: readonly BridgeEdge[],\n  groundTruth: Readonly<Record<string, number>>,\n  idents: readonly QuantityIdentification[],\n): Map<string, number> {\n  // Finite-seed guard (matches the computed-value guard below and the\n  // library-wide finiteness discipline): a NaN/∞ seed would propagate silently\n  // through the graph and spoof downstream magnitude/consistency checks.\n  for (const [name, v] of Object.entries(groundTruth)) {\n    if (!Number.isFinite(v)) {\n      throw new TypeError(\n        `forwardEvaluate: ground-truth seed '${name}' must be a finite number, got ${v}.`,\n      );\n    }\n  }\n  const values = new Map<string, number>(Object.entries(groundTruth));\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const id of idents) {\n      const fromVal = values.get(id.from);\n      if (fromVal !== undefined && !values.has(id.to)) {\n        const converted = fromVal * conventionFactor(id.from, id.to);\n        if (Number.isFinite(converted)) {\n          values.set(id.to, converted);\n          changed = true;\n        }\n      }\n    }\n    for (const e of edges) {\n      if (values.has(e.target.name)) continue;\n      if (!e.sources.every((s) => values.has(s.name))) continue;\n      const inputs = evaluationInputs(e, values);\n      let v: number;\n      try {\n        v = evaluateEdge(e, inputs);\n      } catch (err) {\n        // The edge refusing this point (a domain miss, opposite carrier signs, a formula\n        // that has no finite value there) or an unset coefficient is \"the edge does not\n        // fire\". Anything else (an alias conflict, a TypeError in an evaluator) is a\n        // different fact and is not hidden as a non-derivation (9.0.0 audit §4 C6).\n        if (!refusesThePoint(err)) throw err;\n        continue;\n      }\n      if (Number.isFinite(v)) {\n        values.set(e.target.name, v);\n        changed = true;\n      }\n    }\n  }\n  return values;\n}\n\n/**\n * Retrodict one node: mask it (source values from the target-removed\n * graph), recover it via each incoming edge, and score the spread.\n *\n * @public\n */\nexport function retrodictNode(\n  edges: readonly BridgeEdge[],\n  groundTruth: Readonly<Record<string, number>>,\n  target: string,\n  opts: RetrodictionOptions = {},\n): RetrodictionResult {\n  const idents = opts.identifications ?? QUANTITY_IDENTIFICATIONS;\n  const tolerance = opts.tolerance ?? 1e-6;\n\n  // Masked source values: never let the target be assigned (so no\n  // derivation reads it back — circular self-support excluded).\n  const edgesMinusIntoTarget = edges.filter((e) => e.target.name !== target);\n  const values = forwardEvaluate(edgesMinusIntoTarget, groundTruth, idents);\n\n  const predictions: RetrodictionPrediction[] = [];\n  const refusals: RetrodictionRefusal[] = [];\n  for (const e of edges) {\n    if (e.target.name !== target) continue;\n    if (!e.sources.every((s) => values.has(s.name))) continue;\n    const inputs = evaluationInputs(e, values);\n    let v: number;\n    try {\n      v = evaluateEdge(e, inputs);\n    } catch (err) {\n      // A refusal of the point or an unset coefficient is a recorded refusal of\n      // this edge, under its own kind. Any other error (an alias conflict, a\n      // TypeError in an evaluator) is a different fact and propagates instead of\n      // reading as \"unrecoverable\" (§4 C6).\n      const kind = refusalKind(err);\n      if (kind === undefined) throw err;\n      refusals.push({ edge: e.id, kind, reason: (err as Error).message });\n      continue;\n    }\n    if (Number.isFinite(v)) predictions.push({ edge: e.id, value: v });\n  }\n\n  let relativeSpread = 0;\n  if (predictions.length >= 2) {\n    const vals = predictions.map((p) => p.value);\n    const max = Math.max(...vals);\n    const min = Math.min(...vals);\n    // Normalize the (max − min) span by the largest MAGNITUDE, not the mean:\n    // opposite-sign predictions (e.g. +6 and −6) cancel in the mean → a ~0\n    // denominator → spurious Infinity, even though the true relative spread is\n    // finite (12/6 = 2). `maxAbs === 0` only when every value is 0 (max = min),\n    // so the span is 0 too.\n    const maxAbs = Math.max(...vals.map(Math.abs));\n    relativeSpread = maxAbs > 0 ? (max - min) / maxAbs : 0;\n  }\n\n  let outcome: RetrodictionOutcome;\n  if (predictions.length === 0) outcome = 'unrecoverable';\n  else if (predictions.length === 1) outcome = 'single';\n  else outcome = relativeSpread <= tolerance ? 'consistent' : 'inconsistent';\n\n  const result: RetrodictionResult = {\n    target,\n    outcome,\n    predictions,\n    relativeSpread,\n    tolerance,\n    ...(refusals.length > 0 ? { refusals } : {}),\n    pass: outcome !== 'inconsistent',\n  };\n\n  const ref = opts.references?.[target];\n  if (ref !== undefined && predictions.length >= 1) {\n    const mean =\n      predictions.reduce((a, p) => a + p.value, 0) / predictions.length;\n    const referenceRelError = Math.abs(mean - ref) / (Math.abs(ref) || 1);\n    return {\n      ...result,\n      referenceValue: ref,\n      referenceRelError,\n      referencePass: referenceRelError <= (opts.referenceTolerance ?? 1e-3),\n    };\n  }\n\n  return result;\n}\n\n/**\n * Sweep the graph: retrodict every over-determined node (the classifier\n * is the feeder), plus any node with a supplied reference value. Returns\n * the per-node results and the headline `allConsistent` gate.\n *\n * @public\n */\nexport function retrodict(\n  edges: readonly BridgeEdge[],\n  groundTruth: Readonly<Record<string, number>>,\n  opts: RetrodictionOptions = {},\n): RetrodictionReport {\n  const idents = opts.identifications ?? QUANTITY_IDENTIFICATIONS;\n  const known = Object.keys(groundTruth);\n  const classified = classifyAll(edges, known, { identifications: idents });\n\n  const overDetermined = classified\n    .filter((r) => r.verdict === 'over-determined')\n    .map((r) => r.target);\n  const refTargets = opts.references ? Object.keys(opts.references) : [];\n  const targets = [...new Set([...overDetermined, ...refTargets])].sort();\n\n  const results = targets.map((t) =>\n    retrodictNode(edges, groundTruth, t, opts),\n  );\n\n  const consistent = results.filter((r) => r.outcome === 'consistent').length;\n  const inconsistent = results.filter(\n    (r) => r.outcome === 'inconsistent',\n  ).length;\n\n  return {\n    results,\n    checked: consistent + inconsistent,\n    consistent,\n    inconsistent,\n    allConsistent: inconsistent === 0,\n  };\n}\n"]}
+{"version":3,"file":"retrodiction.js","sourceRoot":"","sources":["../../src/composition/retrodiction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAgB,EAAE,MAAmC;IACpF,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO;QAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAE,CAAC;IACnE,MAAM,KAAK,GAAG,0BAA0B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC;IACvE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,KAAK,SAAS;YAAE,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AA4ED,yFAAyF;AACzF,SAAS,WAAW,CAAC,GAAY;IAC/B,IAAI,GAAG,YAAY,oBAAoB;QAAE,OAAO,QAAQ,CAAC;IACzD,IAAI,GAAG,YAAY,qBAAqB;QAAE,OAAO,mBAAmB,CAAC;IACrE,IAAI,GAAG,YAAY,gBAAgB;QAAE,OAAO,cAAc,CAAC;IAC3D,IAAI,GAAG,YAAY,YAAY;QAAE,OAAO,SAAS,CAAC;IAClD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,GAAY;IAC1C,OAAO,WAAW,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAC7B,KAA4B,EAC5B,WAA6C,EAC7C,MAAyC;IAEzC,oEAAoE;IACpE,6EAA6E;IAC7E,uEAAuE;IACvE,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,SAAS,CACjB,uCAAuC,IAAI,kCAAkC,CAAC,GAAG,CAClF,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,GAAG,CAAiB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;IACpE,IAAI,OAAO,GAAG,IAAI,CAAC;IACnB,OAAO,OAAO,EAAE,CAAC;QACf,OAAO,GAAG,KAAK,CAAC;QAChB,KAAK,MAAM,EAAE,IAAI,MAAM,EAAE,CAAC;YACxB,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;gBAChD,MAAM,SAAS,GAAG,OAAO,GAAG,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC7D,IAAI,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;oBAC/B,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;oBAC7B,OAAO,GAAG,IAAI,CAAC;gBACjB,CAAC;YACH,CAAC;QACH,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,SAAS;YACxC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBAAE,SAAS;YAC1D,MAAM,MAAM,GAAG,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;YAC3C,IAAI,CAAS,CAAC;YACd,IAAI,CAAC;gBACH,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;YAC9B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,iFAAiF;gBACjF,gFAAgF;gBAChF,6EAA6E;gBAC7E,4EAA4E;gBAC5E,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC;oBAAE,MAAM,GAAG,CAAC;gBACrC,SAAS;YACX,CAAC;YACD,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;gBACvB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBAC7B,OAAO,GAAG,IAAI,CAAC;YACjB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAC3B,KAA4B,EAC5B,WAA6C,EAC7C,MAAc,EACd,IAAI,GAAwB,EAAE;IAE9B,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,IAAI,wBAAwB,CAAC;IAChE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;IAEzC,gEAAgE;IAChE,8DAA8D;IAC9D,MAAM,oBAAoB,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IAC3E,MAAM,MAAM,GAAG,eAAe,CAAC,oBAAoB,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAE1E,MAAM,WAAW,GAA6B,EAAE,CAAC;IACjD,MAAM,QAAQ,GAA0B,EAAE,CAAC;IAC3C,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,MAAM;YAAE,SAAS;QACvC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAAE,SAAS;QAC1D,MAAM,MAAM,GAAG,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAC3C,IAAI,CAAS,CAAC;QACd,IAAI,CAAC;YACH,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,0EAA0E;YAC1E,uEAAuE;YACvE,2EAA2E;YAC3E,sCAAsC;YACtC,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,IAAI,KAAK,SAAS;gBAAE,MAAM,GAAG,CAAC;YAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAG,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;YACpE,SAAS;QACX,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IACrE,CAAC;IAED,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,IAAI,WAAW,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;QAC9B,yEAAyE;QACzE,uEAAuE;QACvE,2EAA2E;QAC3E,4EAA4E;QAC5E,wBAAwB;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/C,cAAc,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IAED,IAAI,OAA4B,CAAC;IACjC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,eAAe,CAAC;SACnD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,QAAQ,CAAC;;QACjD,OAAO,GAAG,cAAc,IAAI,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC;IAE3E,MAAM,MAAM,GAAuB;QACjC,MAAM;QACN,OAAO;QACP,WAAW;QACX,cAAc;QACd,SAAS;QACT,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5C,IAAI,EAAE,OAAO,KAAK,cAAc;KACjC,CAAC;IAEF,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,GAAG,KAAK,SAAS,IAAI,WAAW,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACjD,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACrD,MAAM,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;QACtE,OAAO;YACL,GAAG,MAAM;YACT,cAAc,EAAE,GAAG;YACnB,iBAAiB;YACjB,aAAa,EAAE,iBAAiB,IAAI,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC;SACtE,CAAC;IACJ,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CACvB,KAA4B,EAC5B,WAA6C,EAC7C,IAAI,GAAwB,EAAE;IAE9B,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,IAAI,wBAAwB,CAAC;IAChE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACvC,MAAM,UAAU,GAAG,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,CAAC,CAAC;IAE1E,MAAM,cAAc,GAAG,UAAU;SAC9B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,iBAAiB,CAAC;SAC9C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACvE,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,cAAc,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAExE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAChC,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,IAAI,CAAC,CAC3C,CAAC;IAEF,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,YAAY,CAAC,CAAC,MAAM,CAAC;IAC5E,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,CACjC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,cAAc,CACpC,CAAC,MAAM,CAAC;IAET,OAAO;QACL,OAAO;QACP,OAAO,EAAE,UAAU,GAAG,YAAY;QAClC,UAAU;QACV,YAAY;QACZ,aAAa,EAAE,YAAY,KAAK,CAAC;KAClC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Retrodiction harness (Consequence 2 of\n * docs/planning/Bridge-Inference-Epistemics-Note.md, designed in\n * docs/planning/Retrodiction-Harness-Design-Note.md).\n *\n * The framework's own falsification benchmark. Mask a quantity the graph\n * can compute, recompute it from ground-truth inputs via EACH independent\n * derivation, and check the predictions agree. This operationalizes the\n * identifiability classifier's OVER-DETERMINED verdict: the surplus\n * derivations of an over-determined node are PREDICTED to be consistency\n * constraints; the harness evaluates them and checks that numerically.\n *\n *   - consistent    — ≥2 derivations agree within tolerance.\n *   - inconsistent  — ≥2 derivations DISAGREE (a falsification: two\n *                     encodings of one quantity-name are not the same\n *                     physics).\n *   - single        — exactly one derivation fired (recovered, no check).\n *   - unrecoverable — no derivation fired from the ground truth.\n *\n * \"Mask\" = compute source values over the graph with every edge INTO the\n * target removed (the classifier's target-removed closure — so the node\n * is genuinely hidden, never read back through its own derivation).\n * Forward evaluation honors `QUANTITY_IDENTIFICATIONS` and is\n * domain-checked (an edge that refuses its domain contributes no\n * prediction). The consistency check needs no external truth and is the\n * re-runnable core; an optional `references` map adds external-value\n * scoring. Pass bar pre-registered in the design note (spread ≤ 1e-6).\n *\n * @module composition/retrodiction\n */\n\nimport type { BridgeEdge } from './edge.js';\nimport { CANONICAL_GROUP_PREFACTORS } from './canonical-prefactors.js';\nimport { CoefficientUnsetError, evaluateEdge } from './edge.js';\nimport { DomainViolationError } from '../bridges/evaluation-errors.js';\nimport { CarrierSignError } from '../bridges/carrier-sign.js';\nimport { FormulaError } from '../numerical/formula-contract.js';\nimport { meanOf } from '../numerical/statistics.js';\nimport type { QuantityIdentification } from './compose.js';\nimport { QUANTITY_IDENTIFICATIONS } from './compose.js';\nimport { conventionFactor } from '../dimensional/unit-convention.js';\nimport { classifyAll } from './identifiability.js';\n\n/**\n * Source values, plus a dimensionless group the edge multiplies when the\n * ground truth names it. The group is not a source: Buckingham cannot see\n * it, and a missing group is the unset coefficient, not a missing input.\n * Exported for the own-equation magnitudes (`own-equation-magnitude.ts`),\n * which evaluate an edge the same way.\n * @internal\n */\nexport function evaluationInputs(edge: BridgeEdge, values: ReadonlyMap<string, number>): Record<string, number> {\n  const inputs: Record<string, number> = {};\n  for (const s of edge.sources) inputs[s.name] = values.get(s.name)!;\n  const group = CANONICAL_GROUP_PREFACTORS.find((g) => g.id === edge.id);\n  if (group !== undefined) {\n    const g = values.get(group.group);\n    if (g !== undefined) inputs[group.group] = g;\n  }\n  return inputs;\n}\n\n/** Outcome of retrodicting one node. @public */\nexport type RetrodictionOutcome =\n  | 'consistent'\n  | 'inconsistent'\n  | 'single'\n  | 'unrecoverable';\n\n/** One derivation's recovered value for a masked node. @public */\nexport interface RetrodictionPrediction {\n  /** The edge id that produced this value. */\n  readonly edge: string;\n  readonly value: number;\n}\n\n/** Options for the harness. @public */\nexport interface RetrodictionOptions {\n  /** Identifications honored in forward evaluation (default registered). */\n  readonly identifications?: readonly QuantityIdentification[];\n  /** Relative-spread tolerance for `consistent` (default 1e-6). */\n  readonly tolerance?: number;\n  /** External (textbook) values to score recovered nodes against. */\n  readonly references?: Readonly<Record<string, number>>;\n  /** Relative-error tolerance for reference scoring (default 1e-3). */\n  readonly referenceTolerance?: number;\n}\n\n/** One refused edge in a retrodiction, with the kind of refusal. @public */\nexport interface RetrodictionRefusal {\n  readonly edge: string;\n  /**\n   * `domain`: the validity domain rejected the point. `coefficient-unset`: the edge has no\n   * sourced prefactor, whatever the values. `carrier-sign`: the carrier charge and the\n   * mobility had opposite signs. `formula`: the relation's formula did not evaluate at the\n   * point (a 0/0, say). Four facts, kept apart (AGENTS law 4).\n   */\n  readonly kind: 'domain' | 'coefficient-unset' | 'carrier-sign' | 'formula';\n  readonly reason: string;\n}\n\n/** The result of retrodicting one node. @public */\nexport interface RetrodictionResult {\n  readonly target: string;\n  readonly outcome: RetrodictionOutcome;\n  /** Recovered values, one per derivation that fired. */\n  readonly predictions: readonly RetrodictionPrediction[];\n  /** (max − min)/|mean| across predictions; 0 when fewer than two. */\n  readonly relativeSpread: number;\n  readonly tolerance: number;\n  /**\n   * Edges that refused the supplied values. `kind` keeps the refusals apart (AGENTS law 4):\n   * `domain`, `carrier-sign` and `formula` are the point (the edge does not fire there);\n   * `coefficient-unset` is the edge's own state (no sourced prefactor), whatever the values.\n   */\n  readonly refusals?: readonly RetrodictionRefusal[];\n  /** `outcome !== 'inconsistent'` — the falsification gate. */\n  readonly pass: boolean;\n  /** Supplied external value, when scored. */\n  readonly referenceValue?: number;\n  /** |mean(predictions) − reference| / |reference|, when scored. */\n  readonly referenceRelError?: number;\n  readonly referencePass?: boolean;\n}\n\n/** Aggregate report across the swept nodes. @public */\nexport interface RetrodictionReport {\n  readonly results: readonly RetrodictionResult[];\n  /** Nodes with ≥2 derivations (consistent + inconsistent). */\n  readonly checked: number;\n  readonly consistent: number;\n  readonly inconsistent: number;\n  /** The headline gate: no inconsistent node was found. */\n  readonly allConsistent: boolean;\n}\n\n/** The refusal an evaluator error is, or `undefined` when it is not a refusal at all. */\nfunction refusalKind(err: unknown): RetrodictionRefusal['kind'] | undefined {\n  if (err instanceof DomainViolationError) return 'domain';\n  if (err instanceof CoefficientUnsetError) return 'coefficient-unset';\n  if (err instanceof CarrierSignError) return 'carrier-sign';\n  if (err instanceof FormulaError) return 'formula';\n  return undefined;\n}\n\n/**\n * True when the error says the edge does not fire here (or at all, for an unset coefficient).\n * Exported so the own-equation magnitudes read an edge's refusal by this one rule.\n * @internal\n */\nexport function refusesThePoint(err: unknown): boolean {\n  return refusalKind(err) !== undefined;\n}\n\n/**\n * Monotone forward EVALUATION: propagate values from `groundTruth` through\n * the graph (domain-checked; identifications supply identified names;\n * non-finite or domain-refused edges do not fire). Each node is assigned\n * the value of the first edge that fires for it.\n *\n * Exported `@internal` so the discovery magnitude-gate can read a quantity's\n * value AT THE REGISTERED ANCHOR when the static representative-value table\n * has no entry for it (graph-derived quantities like `schwarzschild-radius`).\n *\n * @internal\n */\nexport function forwardEvaluate(\n  edges: readonly BridgeEdge[],\n  groundTruth: Readonly<Record<string, number>>,\n  idents: readonly QuantityIdentification[],\n): Map<string, number> {\n  // Finite-seed guard (matches the computed-value guard below and the\n  // library-wide finiteness discipline): a NaN/∞ seed would propagate silently\n  // through the graph and spoof downstream magnitude/consistency checks.\n  for (const [name, v] of Object.entries(groundTruth)) {\n    if (!Number.isFinite(v)) {\n      throw new TypeError(\n        `forwardEvaluate: ground-truth seed '${name}' must be a finite number, got ${v}.`,\n      );\n    }\n  }\n  const values = new Map<string, number>(Object.entries(groundTruth));\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const id of idents) {\n      const fromVal = values.get(id.from);\n      if (fromVal !== undefined && !values.has(id.to)) {\n        const converted = fromVal * conventionFactor(id.from, id.to);\n        if (Number.isFinite(converted)) {\n          values.set(id.to, converted);\n          changed = true;\n        }\n      }\n    }\n    for (const e of edges) {\n      if (values.has(e.target.name)) continue;\n      if (!e.sources.every((s) => values.has(s.name))) continue;\n      const inputs = evaluationInputs(e, values);\n      let v: number;\n      try {\n        v = evaluateEdge(e, inputs);\n      } catch (err) {\n        // The edge refusing this point (a domain miss, opposite carrier signs, a formula\n        // that has no finite value there) or an unset coefficient is \"the edge does not\n        // fire\". Anything else (an alias conflict, a TypeError in an evaluator) is a\n        // different fact and is not hidden as a non-derivation (9.0.0 audit §4 C6).\n        if (!refusesThePoint(err)) throw err;\n        continue;\n      }\n      if (Number.isFinite(v)) {\n        values.set(e.target.name, v);\n        changed = true;\n      }\n    }\n  }\n  return values;\n}\n\n/**\n * Retrodict one node: mask it (source values from the target-removed\n * graph), recover it via each incoming edge, and score the spread.\n *\n * @public\n */\nexport function retrodictNode(\n  edges: readonly BridgeEdge[],\n  groundTruth: Readonly<Record<string, number>>,\n  target: string,\n  opts: RetrodictionOptions = {},\n): RetrodictionResult {\n  const idents = opts.identifications ?? QUANTITY_IDENTIFICATIONS;\n  const tolerance = opts.tolerance ?? 1e-6;\n\n  // Masked source values: never let the target be assigned (so no\n  // derivation reads it back — circular self-support excluded).\n  const edgesMinusIntoTarget = edges.filter((e) => e.target.name !== target);\n  const values = forwardEvaluate(edgesMinusIntoTarget, groundTruth, idents);\n\n  const predictions: RetrodictionPrediction[] = [];\n  const refusals: RetrodictionRefusal[] = [];\n  for (const e of edges) {\n    if (e.target.name !== target) continue;\n    if (!e.sources.every((s) => values.has(s.name))) continue;\n    const inputs = evaluationInputs(e, values);\n    let v: number;\n    try {\n      v = evaluateEdge(e, inputs);\n    } catch (err) {\n      // A refusal of the point or an unset coefficient is a recorded refusal of\n      // this edge, under its own kind. Any other error (an alias conflict, a\n      // TypeError in an evaluator) is a different fact and propagates instead of\n      // reading as \"unrecoverable\" (§4 C6).\n      const kind = refusalKind(err);\n      if (kind === undefined) throw err;\n      refusals.push({ edge: e.id, kind, reason: (err as Error).message });\n      continue;\n    }\n    if (Number.isFinite(v)) predictions.push({ edge: e.id, value: v });\n  }\n\n  let relativeSpread = 0;\n  if (predictions.length >= 2) {\n    const vals = predictions.map((p) => p.value);\n    const max = Math.max(...vals);\n    const min = Math.min(...vals);\n    // Normalize the (max − min) span by the largest MAGNITUDE, not the mean:\n    // opposite-sign predictions (e.g. +6 and −6) cancel in the mean → a ~0\n    // denominator → spurious Infinity, even though the true relative spread is\n    // finite (12/6 = 2). `maxAbs === 0` only when every value is 0 (max = min),\n    // so the span is 0 too.\n    const maxAbs = Math.max(...vals.map(Math.abs));\n    relativeSpread = maxAbs > 0 ? (max - min) / maxAbs : 0;\n  }\n\n  let outcome: RetrodictionOutcome;\n  if (predictions.length === 0) outcome = 'unrecoverable';\n  else if (predictions.length === 1) outcome = 'single';\n  else outcome = relativeSpread <= tolerance ? 'consistent' : 'inconsistent';\n\n  const result: RetrodictionResult = {\n    target,\n    outcome,\n    predictions,\n    relativeSpread,\n    tolerance,\n    ...(refusals.length > 0 ? { refusals } : {}),\n    pass: outcome !== 'inconsistent',\n  };\n\n  const ref = opts.references?.[target];\n  if (ref !== undefined && predictions.length >= 1) {\n    const mean = meanOf(predictions.map((p) => p.value));\n    const referenceRelError = Math.abs(mean - ref) / (Math.abs(ref) || 1);\n    return {\n      ...result,\n      referenceValue: ref,\n      referenceRelError,\n      referencePass: referenceRelError <= (opts.referenceTolerance ?? 1e-3),\n    };\n  }\n\n  return result;\n}\n\n/**\n * Sweep the graph: retrodict every over-determined node (the classifier\n * is the feeder), plus any node with a supplied reference value. Returns\n * the per-node results and the headline `allConsistent` gate.\n *\n * @public\n */\nexport function retrodict(\n  edges: readonly BridgeEdge[],\n  groundTruth: Readonly<Record<string, number>>,\n  opts: RetrodictionOptions = {},\n): RetrodictionReport {\n  const idents = opts.identifications ?? QUANTITY_IDENTIFICATIONS;\n  const known = Object.keys(groundTruth);\n  const classified = classifyAll(edges, known, { identifications: idents });\n\n  const overDetermined = classified\n    .filter((r) => r.verdict === 'over-determined')\n    .map((r) => r.target);\n  const refTargets = opts.references ? Object.keys(opts.references) : [];\n  const targets = [...new Set([...overDetermined, ...refTargets])].sort();\n\n  const results = targets.map((t) =>\n    retrodictNode(edges, groundTruth, t, opts),\n  );\n\n  const consistent = results.filter((r) => r.outcome === 'consistent').length;\n  const inconsistent = results.filter(\n    (r) => r.outcome === 'inconsistent',\n  ).length;\n\n  return {\n    results,\n    checked: consistent + inconsistent,\n    consistent,\n    inconsistent,\n    allConsistent: inconsistent === 0,\n  };\n}\n"]}

package/dist/composition/user-equation.d.ts

@@ -64,6 +64,7 @@ export interface AnalyzeUserEquationOptions {
     /** Reconcile a dimension difference by powers of c, ħ, and (geometrized) G. */
     readonly units?: Exclude<UnitMode, 'si'>;
 }
+/** Parse a `TARGET = EXPR` equation into its target and source quantities. A malformed equation throws. */
 export declare function parseUserEquation(equation: string, catalogNames?: ReadonlySet<string> | Iterable<string>): Promise<UserEquation>;
 /**
  * Up to `k` catalog names most similar to `name` — the "did you mean?" set for an

package/dist/composition/user-equation.d.ts.map

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

package/dist/composition/user-equation.js

@@ -21,7 +21,7 @@
 import { getFormulaParser, parsePhysics } from '../numerical/formula-registry.js';
 import { formulaSymbolDimension } from '../numerical/formula-dimension.js';
 import { CONSTANT_SPELLINGS } from '../dimensional/dimension-spec.js';
-import { CONSTANTS } from '../dimensional/symbolic-constants.js';
+import { CONSTANTS, isRegisteredConstant } from '../dimensional/symbolic-constants.js';
 import { formulaNameDimensions } from '../dimensional/formula-names.js';
 import { naturalNote, naturalPowers } from '../dimensional/natural-units.js';
 import { aliasesForTarget, editDistance } from './aliases.js';
@@ -104,6 +104,7 @@ function withFormulaNames(catalog) {
     }
     return out;
 }
+/** Parse a `TARGET = EXPR` equation into its target and source quantities. A malformed equation throws. */
 export async function parseUserEquation(equation, catalogNames) {
     if (equation.length > MAX_USER_EQUATION_LEN) {
         throw new UserEquationError(`equation exceeds ${MAX_USER_EQUATION_LEN} characters (${equation.length})`);
@@ -131,7 +132,7 @@ export async function parseUserEquation(equation, catalogNames) {
         // No parse tree, so no subtraction was read: the hyphen hint needs the parsed variables.
         throw new UserEquationError(`could not parse the right-hand side '${rhs}': ${e.message}`);
     }
-    const sources = variables.filter((v) => !Object.prototype.hasOwnProperty.call(CONSTANTS, v));
+    const sources = variables.filter((v) => !isRegisteredConstant(v));
     // An all-constant right-hand side (the Planck length) is an equation about a catalog quantity
     // only when its target is one; otherwise it names nothing to check (persona finding W5).
     const targetIsCatalog = names !== undefined && resolveQuantityName(target, names) !== null;