universal-physics-tensor 10.0.0 → 11.0.0

package/dist/composition/identifiability.js

@@ -21,13 +21,33 @@
  * resulting nonlinear system has a unique numeric solution (undecidable
  * in general for closed-form evaluators). "Independent derivation" means
  * a structurally distinct edge, NOT a provably-independent formula — two
- * edges encoding the same relation are counted as two (an honest
- * over-count). The classifier PROPOSES; humans filter (Part-VI §XXVII-B),
- * exactly as `enumerateCompositions` does.
+ * edges encoding the same relation are counted as two by the forward
+ * count (an honest over-count, kept as `surplusConstraints`). The
+ * classifier PROPOSES; humans filter (Part-VI §XXVII-B), exactly as
+ * `enumerateCompositions` does.
+ *
+ * TWO INSTRUMENTS, TWO FIELDS. The forward closure fires an edge only when
+ * every source is known, so it never reads a law in reverse. The MONOMIAL
+ * edges (a `symbolic` product of powers, or a canonical equation with a
+ * stated monomial) are also a linear system in log space: `y = C Π xᵢ^aᵢ`
+ * is the row `log y − Σ aᵢ log xᵢ = log C`. Stacked with a unit row per
+ * known quantity, the exact null space (MathTS `rationalNullspace`) says
+ * which quantities are DETERMINED (their column is zero in every basis
+ * vector) whichever way the laws are read, and `distinct rows − rank` is
+ * the number of independent consistency checks, where a restated monomial
+ * is one row, not two. {@link identifiabilityByRank} is that instrument;
+ * {@link classifyIdentifiability} reports both, `determinable` being their
+ * union, and names every law the rank read in reverse, because a validity
+ * domain is stated on the sources and a caller may refuse the inversion.
  *
  * @module composition/identifiability
  */
+import { Fraction } from '@danielsimonjr/mathts-core';
+import { rationalNullspace } from '@danielsimonjr/mathts-functions';
 import { QUANTITY_IDENTIFICATIONS } from './compose.js';
+import { monomialExponentsExact } from './formula-shape.js';
+import { rationalize } from './rational-exponent.js';
+import { canonicalById } from '../canonical/registry.js';
 /**
  * The monotone forward closure: the least set ⊇ `knownNames` closed under
  * "all of an edge's sources determinable ⟹ its target determinable",
@@ -60,6 +80,317 @@ export function forwardClosure(edges, knownNames, identifications = QUANTITY_IDE
     }
     return determinable;
 }
+/**
+ * The exact exponents of `edge`'s target over its source names, read from
+ * its `symbolic` form, or, for a canonical edge with no symbolic form, from
+ * the equation's stated monomial and `formulaFactors`. A leaf that is not a
+ * source (a constant, a literal, a held stub) is part of the prefactor and
+ * contributes no column. Undefined when the form is not a monomial, when an
+ * exponent is not a small rational, or when the target is among the sources.
+ *
+ * @internal
+ */
+export function edgeMonomial(edge) {
+    const sourceNames = new Set(edge.sources.map((s) => s.name));
+    if (sourceNames.has(edge.target.name))
+        return undefined;
+    const out = new Map();
+    if (edge.symbolic !== undefined) {
+        const exact = monomialExponentsExact(edge.symbolic);
+        if (exact === undefined)
+            return undefined;
+        for (const [name, exp] of exact)
+            if (sourceNames.has(name))
+                out.set(name, exp);
+        return out;
+    }
+    if (edge.beId !== null)
+        return undefined;
+    const equation = canonicalById(edge.id);
+    const monomial = equation?.dimensional.monomial;
+    if (monomial === undefined || monomial === null)
+        return undefined;
+    const stated = { ...monomial, ...(edge.formulaFactors ?? {}) };
+    for (const [name, exp] of Object.entries(stated)) {
+        if (!sourceNames.has(name))
+            continue;
+        const q = rationalize(exp);
+        if (q === undefined)
+            return undefined;
+        out.set(name, q);
+    }
+    return out;
+}
+/** A row scaled so its first nonzero entry is 1, as a string, so two rows of one relation compare equal. */
+function rowKey(row) {
+    const pivot = row.find((f) => !f.isZero());
+    if (pivot === undefined)
+        return '0';
+    return row.map((f) => f.divide(pivot).toString()).join(',');
+}
+const ZERO = new Fraction(0);
+const ONE = new Fraction(1);
+/** Directed identifications: `from` in the set puts `to` in it. */
+function expandByIdentifications(set, identifications) {
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const ident of identifications) {
+            if (set.has(ident.from) && !set.has(ident.to)) {
+                set.add(ident.to);
+                changed = true;
+            }
+        }
+    }
+}
+const rankIndexCache = new WeakMap();
+/**
+ * The monomial rows of `edges` under `reader`, grouped into the connected
+ * components of the graph whose vertices are quantity names and whose links
+ * are the rows (a row joins its target to each of its sources). The
+ * log-space matrix is block-diagonal over these components, so each is
+ * solved on its own, once per asserted set, and the answers are exact.
+ * Built once per edge array and reader.
+ */
+function rankIndex(edges, reader, readerKey) {
+    let perEdges = rankIndexCache.get(edges);
+    if (perEdges === undefined) {
+        perEdges = new Map();
+        rankIndexCache.set(edges, perEdges);
+    }
+    const hit = perEdges.get(readerKey);
+    if (hit !== undefined)
+        return hit;
+    const rows = [];
+    for (const edge of edges) {
+        const sources = reader(edge);
+        if (sources !== undefined)
+            rows.push({ id: edge.id, target: edge.target.name, sources });
+    }
+    const parent = new Map();
+    const find = (name) => {
+        let root = name;
+        while (parent.get(root) !== root)
+            root = parent.get(root);
+        let cur = name;
+        while (cur !== root) {
+            const next = parent.get(cur);
+            parent.set(cur, root);
+            cur = next;
+        }
+        return root;
+    };
+    for (const row of rows) {
+        if (!parent.has(row.target))
+            parent.set(row.target, row.target);
+        for (const name of row.sources.keys()) {
+            if (!parent.has(name))
+                parent.set(name, name);
+            const a = find(row.target);
+            const b = find(name);
+            if (a !== b)
+                parent.set(a, b);
+        }
+    }
+    const groups = new Map();
+    for (const row of rows) {
+        const root = find(row.target);
+        let group = groups.get(root);
+        if (group === undefined) {
+            group = { rows: [], names: new Set() };
+            groups.set(root, group);
+        }
+        group.rows.push(row);
+        group.names.add(row.target);
+        for (const name of row.sources.keys())
+            group.names.add(name);
+    }
+    const components = [...groups.values()].map((group, index) => ({
+        index,
+        rows: group.rows,
+        names: [...group.names],
+    }));
+    const componentOf = new Map();
+    for (const component of components)
+        for (const name of component.names)
+            componentOf.set(name, component.index);
+    const index = { rows, components, componentOf, solves: new Map() };
+    perEdges.set(readerKey, index);
+    return index;
+}
+/**
+ * Solve one component with the asserted names inside it as unit rows.
+ * Memoised per asserted set; a solve whose asserted set extends a cached
+ * one by names that solve already determined is that solve with one more
+ * dependent row per extra name (an already-determined quantity asserted
+ * again is a consistency check, and determines nothing new).
+ */
+function solveComponent(index, component, asserted) {
+    const inside = component.names.filter((name) => asserted.has(name)).sort();
+    let cached = index.solves.get(component.index);
+    if (cached === undefined) {
+        cached = [];
+        index.solves.set(component.index, cached);
+    }
+    const insideSet = new Set(inside);
+    for (const solve of cached) {
+        if (solve.inside.length === inside.length && solve.inside.every((name) => insideSet.has(name)))
+            return solve;
+    }
+    for (const solve of cached) {
+        if (!solve.inside.every((name) => insideSet.has(name)))
+            continue;
+        const extra = inside.filter((name) => !solve.inside.includes(name));
+        if (extra.every((name) => solve.determined.has(name))) {
+            const widened = { inside, determined: solve.determined, surplus: solve.surplus + extra.length };
+            cached.push(widened);
+            return widened;
+        }
+    }
+    const column = new Map(component.names.map((name, i) => [name, i]));
+    const matrix = [];
+    const seen = new Set();
+    const pushRow = (row) => {
+        const k = rowKey(row);
+        if (k === '0' || seen.has(k))
+            return;
+        seen.add(k);
+        matrix.push(row);
+    };
+    for (const row of component.rows) {
+        const vector = component.names.map(() => ZERO);
+        vector[column.get(row.target)] = ONE;
+        for (const [name, exp] of row.sources) {
+            const i = column.get(name);
+            vector[i] = vector[i].sub(exp);
+        }
+        pushRow(vector);
+    }
+    for (const name of inside) {
+        const vector = component.names.map(() => ZERO);
+        vector[column.get(name)] = ONE;
+        pushRow(vector);
+    }
+    const solved = rationalNullspace(matrix, { columns: component.names.length });
+    const determined = new Set(inside);
+    component.names.forEach((name, i) => {
+        if (solved.basis.every((vector) => vector[i].isZero()))
+            determined.add(name);
+    });
+    const result = { inside, determined, surplus: matrix.length - solved.rank };
+    cached.push(result);
+    return result;
+}
+/**
+ * The asserted set is the known names plus every name a directed
+ * identification reaches from a known or a determined one; only these get a
+ * unit row, and a name the rank determines is never fed back in as a row
+ * (that would count it as a check). Each pass solves the components the
+ * asserted set touches (every component when `every`, so the surplus counts
+ * the whole system), lets the identifications assert what the determined
+ * names reach, and repeats until nothing new is asserted.
+ */
+function solveRank(index, knownNames, identifications, every) {
+    const asserted = new Set(knownNames);
+    expandByIdentifications(asserted, identifications);
+    const determined = new Set();
+    let surplus = 0;
+    for (;;) {
+        determined.clear();
+        for (const name of asserted)
+            determined.add(name);
+        surplus = 0;
+        for (const component of index.components) {
+            if (!every && !component.names.some((name) => asserted.has(name)))
+                continue;
+            const solve = solveComponent(index, component, asserted);
+            for (const name of solve.determined)
+                determined.add(name);
+            surplus += solve.surplus;
+        }
+        const before = asserted.size;
+        const reach = new Set(determined);
+        expandByIdentifications(reach, identifications);
+        for (const name of reach)
+            if (!determined.has(name))
+                asserted.add(name);
+        if (asserted.size === before)
+            break;
+    }
+    return { determined, surplus };
+}
+/** The cache of full rank reports per edge array, keyed by the known set and the identifications. */
+const rankCache = new WeakMap();
+function rankCacheKey(known, identifications, custom) {
+    return `${[...known].sort().join('\u0001')}|${identifications.map((i) => `${i.from}>${i.to}`).join('\u0001')}|${custom ? 'custom' : 'default'}`;
+}
+/**
+ * {@link identifiabilityByRank} with the monomial reader chosen by the
+ * caller (the default is {@link edgeMonomial}). A custom reader's index and
+ * results are cached beside the default's, never in its place.
+ *
+ * @internal
+ */
+export function identifiabilityByRankWith(edges, knownNames, reader, opts = {}) {
+    return rankWithReader(edges, knownNames, reader, reader !== edgeMonomial, opts);
+}
+/**
+ * The log-space rank: which quantities the monomial edges determine from
+ * `knownNames`, whichever direction each law is read, how many independent
+ * consistency checks the system carries, and which laws were read in
+ * reverse. Identifications stay directed, as in {@link forwardClosure}: a
+ * name they reach joins the known rows, and the system is solved again
+ * until nothing new is determined. Non-monomial edges contribute nothing
+ * here; the forward closure is their instrument.
+ *
+ * @public
+ */
+export function identifiabilityByRank(edges, knownNames, opts = {}) {
+    return rankWithReader(edges, knownNames, edgeMonomial, false, opts);
+}
+function rankWithReader(edges, knownNames, reader, custom, opts) {
+    const identifications = opts.identifications ?? QUANTITY_IDENTIFICATIONS;
+    const key = rankCacheKey(knownNames, identifications, custom);
+    let perEdges = rankCache.get(edges);
+    if (perEdges === undefined) {
+        perEdges = new Map();
+        rankCache.set(edges, perEdges);
+    }
+    const hit = perEdges.get(key);
+    if (hit !== undefined)
+        return hit;
+    const index = rankIndex(edges, reader, custom ? 'custom' : 'default');
+    const { determined, surplus } = solveRank(index, knownNames, identifications, true);
+    // A law is read in reverse when one of its sources is determined, and not
+    // by the forward closure over the monomial edges alone.
+    const monomialIds = new Set(index.rows.map((r) => r.id));
+    const forward = forwardClosure(edges.filter((e) => monomialIds.has(e.id)), knownNames, identifications);
+    const usedInReverse = index.rows
+        .filter((row) => [...row.sources.keys()].some((name) => !forward.has(name) && determined.has(name)))
+        .map((row) => row.id);
+    const result = {
+        determined: [...determined].sort(),
+        determinedByRankOnly: [...determined].filter((name) => !forward.has(name)).sort(),
+        surplusChecks: surplus,
+        usedInReverse,
+        monomialEdges: index.rows.map((r) => r.id),
+    };
+    perEdges.set(key, result);
+    return result;
+}
+/**
+ * Whether the rank determines `target` from `knownNames`. Only the
+ * components the asserted set touches are solved, and each solve is
+ * memoised, so the funnel's thousands of calls per anchor cost one solve
+ * per touched component, plus one per hypothesis that actually asserts a
+ * new name.
+ */
+function rankDetermines(edges, knownNames, target, identifications) {
+    const index = rankIndex(edges, edgeMonomial, 'default');
+    if (!index.componentOf.has(target))
+        return false;
+    return solveRank(index, knownNames, identifications, false).determined.has(target);
+}
 /** The quantities from which `targetName` is forward-reachable (its
  *  backward cone, target included). */
 function backwardCone(edges, targetName) {
@@ -90,7 +421,24 @@ function backwardCone(edges, targetName) {
 export function classifyIdentifiability(edges, knownNames, targetName, opts = {}) {
     const identifications = opts.identifications ?? QUANTITY_IDENTIFICATIONS;
     const known = [...new Set(knownNames)];
-    const determinable = forwardClosure(edges, known, identifications);
+    const closure = forwardClosure(edges, known, identifications);
+    // The rank is computed once per result and only when something reads it:
+    // the verdict needs it only for a target the closure does not reach, and
+    // the funnel classifies thousands of targets whose verdict it does reach.
+    let rankMemo;
+    const rankOf = () => {
+        rankMemo ??= identifiabilityByRank(edges, known, { identifications });
+        return rankMemo;
+    };
+    // The union: the closure (every edge, forward) and the rank (the monomial
+    // edges, either way). `determinedByRankOnly` is reported against the whole
+    // closure here, so a name the closure reaches through an opaque edge is
+    // not counted as rank-only.
+    const determinableOf = () => new Set([...closure, ...rankOf().determined]);
+    const rankReport = () => {
+        const rank = rankOf();
+        return { ...rank, determinedByRankOnly: rank.determined.filter((name) => !closure.has(name)) };
+    };
     // Derivations must not depend on the target itself: close over the
     // graph with every edge INTO the target removed (excludes circular
     // self-support — see the design note's worked counterexample).
@@ -105,13 +453,16 @@ export function classifyIdentifiability(edges, knownNames, targetName, opts = {}
     if (isGiven) {
         verdict = 'given';
     }
-    else if (!determinable.has(targetName)) {
+    else if (!closure.has(targetName) && !rankDetermines(edges, known, targetName, identifications)) {
         verdict = 'under-determined';
     }
     else if (derivations.length >= 2) {
         verdict = 'over-determined';
     }
     else {
+        // One forward derivation, or determined by identity, or determined by
+        // the rank alone (then `derivations` is empty and `rank.usedInReverse`
+        // names the laws that were read backwards).
         verdict = 'exactly-determined';
     }
     const surplusConstraints = isGiven
@@ -120,6 +471,7 @@ export function classifyIdentifiability(edges, knownNames, targetName, opts = {}
     let blockingFrontier = [];
     if (verdict === 'under-determined') {
         const knownSet = new Set(known);
+        const determinable = determinableOf();
         blockingFrontier = [...backwardCone(edges, targetName)]
             .filter((q) => q !== targetName && !determinable.has(q) && !knownSet.has(q))
             .sort();
@@ -131,7 +483,12 @@ export function classifyIdentifiability(edges, knownNames, targetName, opts = {}
         derivations,
         surplusConstraints,
         blockingFrontier,
-        determinable: [...determinable].sort(),
+        get determinable() {
+            return [...determinableOf()].sort();
+        },
+        get rank() {
+            return rankReport();
+        },
     };
 }
 /**

package/dist/composition/identifiability.js.map

@@ -1 +1 @@
-{"version":3,"file":"identifiability.js","sourceRoot":"","sources":["../../src/composition/identifiability.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Identifiability classifier (Consequence 1 of\n * docs/planning/Bridge-Inference-Epistemics-Note.md, designed in\n * docs/planning/Identifiability-Classifier-Design-Note.md).\n *\n * Answers a STRUCTURAL question over the directed hypergraph of\n * `BridgeEdge`s: given a set of known quantities and a target quantity,\n * how many INDEPENDENT ways can the graph compute the target from the\n * knowns? The count drives the epistemics-note trichotomy:\n *\n *   - under-determined — unreachable; needs more inputs or more physics.\n *   - exactly-determined — one derivation; solvable (up to the\n *     dimensionless constant dimensional analysis cannot supply).\n *   - over-determined — ≥2 derivations; the surplus are FALSIFIABLE\n *     consistency constraints (each predicts the target; they must\n *     agree). The headline regime.\n *   - given — the target is itself a known (degenerate); derivations\n *     become cross-checks on the supplied value.\n *\n * This is STRUCTURAL, not parametric: it does not decide whether the\n * resulting nonlinear system has a unique numeric solution (undecidable\n * in general for closed-form evaluators). \"Independent derivation\" means\n * a structurally distinct edge, NOT a provably-independent formula — two\n * edges encoding the same relation are counted as two (an honest\n * over-count). The classifier PROPOSES; humans filter (Part-VI §XXVII-B),\n * exactly as `enumerateCompositions` does.\n *\n * @module composition/identifiability\n */\n\nimport type { BridgeEdge } from './edge.js';\nimport type { QuantityIdentification } from './compose.js';\nimport { QUANTITY_IDENTIFICATIONS } from './compose.js';\n\n/** The four-way structural-identifiability verdict. @public */\nexport type IdentifiabilityVerdict =\n  | 'given'\n  | 'under-determined'\n  | 'exactly-determined'\n  | 'over-determined';\n\n/** Options for the classifier. @public */\nexport interface IdentifiabilityOptions {\n  /**\n   * Quantity identifications honored when expanding determinability\n   * (directed name-equivalences: `from` determinable ⟹ `to` determinable).\n   * Defaults to the registered {@link QUANTITY_IDENTIFICATIONS}, mirroring\n   * how `composeEdges` connects the graph. Pass `[]` for the pure\n   * physical-edge graph.\n   */\n  readonly identifications?: readonly QuantityIdentification[];\n}\n\n/** The result of classifying one target against one known set. @public */\nexport interface IdentifiabilityResult {\n  /** The target quantity name that was classified. */\n  readonly target: string;\n  /** The known-quantity names (deduplicated). */\n  readonly known: readonly string[];\n  readonly verdict: IdentifiabilityVerdict;\n  /**\n   * Ids of the distinct edges that independently derive the target from\n   * the known set — sources determinable WITHOUT using any edge into the\n   * target (so circular self-support is excluded). Empty ⟺ no physical\n   * derivation (under-determined, or determined only by identity).\n   */\n  readonly derivations: readonly string[];\n  /**\n   * Redundant derivations = falsifiable consistency constraints. For a\n   * non-given target the first derivation pins the value and the rest are\n   * checks (`max(0, |derivations| − 1)`); for a given (measured) target\n   * every derivation is a check (`|derivations|`).\n   */\n  readonly surplusConstraints: number;\n  /**\n   * For under-determined targets: the upstream quantities that block\n   * determinability — on some path toward the target, not determinable\n   * from the known set, not themselves known. Knowing a sufficient subset\n   * moves the target toward determined. Empty when determinable.\n   */\n  readonly blockingFrontier: readonly string[];\n  /** Every quantity determinable from the known set (the forward closure). */\n  readonly determinable: readonly string[];\n}\n\n/**\n * The monotone forward closure: the least set ⊇ `knownNames` closed under\n * \"all of an edge's sources determinable ⟹ its target determinable\",\n * with identifications expanding it as directed name-equivalences.\n *\n * A parameter-free edge (empty `sources`) fires unconditionally — its\n * target is in every closure (a constant is always determinable).\n *\n * @public\n */\nexport function forwardClosure(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  identifications: readonly QuantityIdentification[] = QUANTITY_IDENTIFICATIONS,\n): Set<string> {\n  const determinable = new Set<string>(knownNames);\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const ident of identifications) {\n      if (determinable.has(ident.from) && !determinable.has(ident.to)) {\n        determinable.add(ident.to);\n        changed = true;\n      }\n    }\n    for (const e of edges) {\n      if (determinable.has(e.target.name)) continue;\n      if (e.sources.every((s) => determinable.has(s.name))) {\n        determinable.add(e.target.name);\n        changed = true;\n      }\n    }\n  }\n  return determinable;\n}\n\n/** The quantities from which `targetName` is forward-reachable (its\n *  backward cone, target included). */\nfunction backwardCone(\n  edges: readonly BridgeEdge[],\n  targetName: string,\n): Set<string> {\n  const cone = new Set<string>([targetName]);\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const e of edges) {\n      if (!cone.has(e.target.name)) continue;\n      for (const s of e.sources) {\n        if (!cone.has(s.name)) {\n          cone.add(s.name);\n          changed = true;\n        }\n      }\n    }\n  }\n  return cone;\n}\n\n/**\n * Classify the structural identifiability of `targetName` given\n * `knownNames` over `edges`. See the module docs and\n * docs/planning/Identifiability-Classifier-Design-Note.md.\n *\n * @public\n */\nexport function classifyIdentifiability(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  targetName: string,\n  opts: IdentifiabilityOptions = {},\n): IdentifiabilityResult {\n  const identifications = opts.identifications ?? QUANTITY_IDENTIFICATIONS;\n  const known = [...new Set(knownNames)];\n\n  const determinable = forwardClosure(edges, known, identifications);\n\n  // Derivations must not depend on the target itself: close over the\n  // graph with every edge INTO the target removed (excludes circular\n  // self-support — see the design note's worked counterexample).\n  const edgesMinusIntoTarget = edges.filter(\n    (e) => e.target.name !== targetName,\n  );\n  const dMinusT = forwardClosure(edgesMinusIntoTarget, known, identifications);\n\n  const derivations = edges\n    .filter(\n      (e) =>\n        e.target.name === targetName &&\n        e.sources.every((s) => dMinusT.has(s.name)),\n    )\n    .map((e) => e.id);\n\n  const isGiven = known.includes(targetName);\n  let verdict: IdentifiabilityVerdict;\n  if (isGiven) {\n    verdict = 'given';\n  } else if (!determinable.has(targetName)) {\n    verdict = 'under-determined';\n  } else if (derivations.length >= 2) {\n    verdict = 'over-determined';\n  } else {\n    verdict = 'exactly-determined';\n  }\n\n  const surplusConstraints = isGiven\n    ? derivations.length\n    : Math.max(0, derivations.length - 1);\n\n  let blockingFrontier: string[] = [];\n  if (verdict === 'under-determined') {\n    const knownSet = new Set(known);\n    blockingFrontier = [...backwardCone(edges, targetName)]\n      .filter(\n        (q) => q !== targetName && !determinable.has(q) && !knownSet.has(q),\n      )\n      .sort();\n  }\n\n  return {\n    target: targetName,\n    known,\n    verdict,\n    derivations,\n    surplusConstraints,\n    blockingFrontier,\n    determinable: [...determinable].sort(),\n  };\n}\n\n/**\n * Classify every quantity that is some edge's target, against one known\n * set. The natural feeder for a retrodiction harness (mask a node, ask\n * whether the graph recovers it). Sorted by target name.\n *\n * @public\n */\nexport function classifyAll(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  opts: IdentifiabilityOptions = {},\n): IdentifiabilityResult[] {\n  const targets = [...new Set(edges.map((e) => e.target.name))].sort();\n  return targets.map((t) =>\n    classifyIdentifiability(edges, knownNames, t, opts),\n  );\n}\n"]}
+{"version":3,"file":"identifiability.js","sourceRoot":"","sources":["../../src/composition/identifiability.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Identifiability classifier (Consequence 1 of\n * docs/planning/Bridge-Inference-Epistemics-Note.md, designed in\n * docs/planning/Identifiability-Classifier-Design-Note.md).\n *\n * Answers a STRUCTURAL question over the directed hypergraph of\n * `BridgeEdge`s: given a set of known quantities and a target quantity,\n * how many INDEPENDENT ways can the graph compute the target from the\n * knowns? The count drives the epistemics-note trichotomy:\n *\n *   - under-determined — unreachable; needs more inputs or more physics.\n *   - exactly-determined — one derivation; solvable (up to the\n *     dimensionless constant dimensional analysis cannot supply).\n *   - over-determined — ≥2 derivations; the surplus are FALSIFIABLE\n *     consistency constraints (each predicts the target; they must\n *     agree). The headline regime.\n *   - given — the target is itself a known (degenerate); derivations\n *     become cross-checks on the supplied value.\n *\n * This is STRUCTURAL, not parametric: it does not decide whether the\n * resulting nonlinear system has a unique numeric solution (undecidable\n * in general for closed-form evaluators). \"Independent derivation\" means\n * a structurally distinct edge, NOT a provably-independent formula — two\n * edges encoding the same relation are counted as two by the forward\n * count (an honest over-count, kept as `surplusConstraints`). The\n * classifier PROPOSES; humans filter (Part-VI §XXVII-B), exactly as\n * `enumerateCompositions` does.\n *\n * TWO INSTRUMENTS, TWO FIELDS. The forward closure fires an edge only when\n * every source is known, so it never reads a law in reverse. The MONOMIAL\n * edges (a `symbolic` product of powers, or a canonical equation with a\n * stated monomial) are also a linear system in log space: `y = C Π xᵢ^aᵢ`\n * is the row `log y − Σ aᵢ log xᵢ = log C`. Stacked with a unit row per\n * known quantity, the exact null space (MathTS `rationalNullspace`) says\n * which quantities are DETERMINED (their column is zero in every basis\n * vector) whichever way the laws are read, and `distinct rows − rank` is\n * the number of independent consistency checks, where a restated monomial\n * is one row, not two. {@link identifiabilityByRank} is that instrument;\n * {@link classifyIdentifiability} reports both, `determinable` being their\n * union, and names every law the rank read in reverse, because a validity\n * domain is stated on the sources and a caller may refuse the inversion.\n *\n * @module composition/identifiability\n */\n\nimport { Fraction } from '@danielsimonjr/mathts-core';\nimport { rationalNullspace } from '@danielsimonjr/mathts-functions';\nimport type { BridgeEdge } from './edge.js';\nimport type { QuantityIdentification } from './compose.js';\nimport { QUANTITY_IDENTIFICATIONS } from './compose.js';\nimport { monomialExponentsExact } from './formula-shape.js';\nimport { rationalize } from './rational-exponent.js';\nimport { canonicalById } from '../canonical/registry.js';\n\n/** The four-way structural-identifiability verdict. @public */\nexport type IdentifiabilityVerdict =\n  | 'given'\n  | 'under-determined'\n  | 'exactly-determined'\n  | 'over-determined';\n\n/** Options for the classifier. @public */\nexport interface IdentifiabilityOptions {\n  /**\n   * Quantity identifications honored when expanding determinability\n   * (directed name-equivalences: `from` determinable ⟹ `to` determinable).\n   * Defaults to the registered {@link QUANTITY_IDENTIFICATIONS}, mirroring\n   * how `composeEdges` connects the graph. Pass `[]` for the pure\n   * physical-edge graph.\n   */\n  readonly identifications?: readonly QuantityIdentification[];\n}\n\n/**\n * What the log-space rank says about one known set, over the monomial edges\n * of the graph. See the module docs: this is the second instrument beside\n * the forward closure, and its numbers are not the closure's.\n *\n * @public\n */\nexport interface RankIdentifiability {\n  /** Every quantity whose column is zero in every null-space basis vector, sorted. */\n  readonly determined: readonly string[];\n  /** The quantities the rank determines that the forward closure does not, sorted. */\n  readonly determinedByRankOnly: readonly string[];\n  /**\n   * Independent consistency checks the system carries: distinct rows\n   * (a restated monomial is one row) minus the rank. Zero when every row\n   * is needed to determine what it determines.\n   */\n  readonly surplusChecks: number;\n  /**\n   * Ids of the monomial edges the rank read against their direction: a\n   * source of the edge is determined, and not by the forward closure over\n   * the monomial edges. A caller whose validity domain is stated on the\n   * sources may refuse these.\n   */\n  readonly usedInReverse: readonly string[];\n  /** Ids of the edges that contributed a row (a readable monomial, target not among its sources). */\n  readonly monomialEdges: readonly string[];\n}\n\n/** The result of classifying one target against one known set. @public */\nexport interface IdentifiabilityResult {\n  /** The target quantity name that was classified. */\n  readonly target: string;\n  /** The known-quantity names (deduplicated). */\n  readonly known: readonly string[];\n  readonly verdict: IdentifiabilityVerdict;\n  /**\n   * Ids of the distinct edges that independently derive the target from\n   * the known set — sources determinable WITHOUT using any edge into the\n   * target (so circular self-support is excluded). Empty ⟺ no physical\n   * derivation (under-determined, or determined only by identity).\n   */\n  readonly derivations: readonly string[];\n  /**\n   * Redundant derivations = falsifiable consistency constraints. For a\n   * non-given target the first derivation pins the value and the rest are\n   * checks (`max(0, |derivations| − 1)`); for a given (measured) target\n   * every derivation is a check (`|derivations|`).\n   */\n  readonly surplusConstraints: number;\n  /**\n   * For under-determined targets: the upstream quantities that block\n   * determinability — on some path toward the target, not determinable\n   * from the known set, not themselves known. Knowing a sufficient subset\n   * moves the target toward determined. Empty when determinable.\n   */\n  readonly blockingFrontier: readonly string[];\n  /**\n   * Every quantity determinable from the known set: the forward closure\n   * united with what the log-space rank determines through the monomial\n   * edges (`rank.determined`), sorted.\n   */\n  readonly determinable: readonly string[];\n  /** The rank instrument's own report for this known set. */\n  readonly rank: RankIdentifiability;\n}\n\n/**\n * The monotone forward closure: the least set ⊇ `knownNames` closed under\n * \"all of an edge's sources determinable ⟹ its target determinable\",\n * with identifications expanding it as directed name-equivalences.\n *\n * A parameter-free edge (empty `sources`) fires unconditionally — its\n * target is in every closure (a constant is always determinable).\n *\n * @public\n */\nexport function forwardClosure(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  identifications: readonly QuantityIdentification[] = QUANTITY_IDENTIFICATIONS,\n): Set<string> {\n  const determinable = new Set<string>(knownNames);\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const ident of identifications) {\n      if (determinable.has(ident.from) && !determinable.has(ident.to)) {\n        determinable.add(ident.to);\n        changed = true;\n      }\n    }\n    for (const e of edges) {\n      if (determinable.has(e.target.name)) continue;\n      if (e.sources.every((s) => determinable.has(s.name))) {\n        determinable.add(e.target.name);\n        changed = true;\n      }\n    }\n  }\n  return determinable;\n}\n\n// ---------------------------------------------------------------------------\n// The log-space rank over the monomial edges.\n// ---------------------------------------------------------------------------\n\n/**\n * The exact exponents of an edge's monomial over its SOURCE names, or\n * undefined when it is not one. Internal: a `Fraction` is not a root type.\n * @internal\n */\nexport type EdgeMonomialReader = (edge: BridgeEdge) => ReadonlyMap<string, Fraction> | undefined;\n\n/**\n * The exact exponents of `edge`'s target over its source names, read from\n * its `symbolic` form, or, for a canonical edge with no symbolic form, from\n * the equation's stated monomial and `formulaFactors`. A leaf that is not a\n * source (a constant, a literal, a held stub) is part of the prefactor and\n * contributes no column. Undefined when the form is not a monomial, when an\n * exponent is not a small rational, or when the target is among the sources.\n *\n * @internal\n */\nexport function edgeMonomial(edge: BridgeEdge): ReadonlyMap<string, Fraction> | undefined {\n  const sourceNames = new Set(edge.sources.map((s) => s.name));\n  if (sourceNames.has(edge.target.name)) return undefined;\n  const out = new Map<string, Fraction>();\n  if (edge.symbolic !== undefined) {\n    const exact = monomialExponentsExact(edge.symbolic);\n    if (exact === undefined) return undefined;\n    for (const [name, exp] of exact) if (sourceNames.has(name)) out.set(name, exp);\n    return out;\n  }\n  if (edge.beId !== null) return undefined;\n  const equation = canonicalById(edge.id);\n  const monomial = equation?.dimensional.monomial;\n  if (monomial === undefined || monomial === null) return undefined;\n  const stated: Record<string, number> = { ...monomial, ...(edge.formulaFactors ?? {}) };\n  for (const [name, exp] of Object.entries(stated)) {\n    if (!sourceNames.has(name)) continue;\n    const q = rationalize(exp);\n    if (q === undefined) return undefined;\n    out.set(name, q);\n  }\n  return out;\n}\n\ninterface MonomialRow {\n  readonly id: string;\n  readonly target: string;\n  readonly sources: ReadonlyMap<string, Fraction>;\n}\n\n/** A row scaled so its first nonzero entry is 1, as a string, so two rows of one relation compare equal. */\nfunction rowKey(row: readonly Fraction[]): string {\n  const pivot = row.find((f) => !f.isZero());\n  if (pivot === undefined) return '0';\n  return row.map((f) => f.divide(pivot).toString()).join(',');\n}\n\nconst ZERO = new Fraction(0);\nconst ONE = new Fraction(1);\n\n/** Directed identifications: `from` in the set puts `to` in it. */\nfunction expandByIdentifications(set: Set<string>, identifications: readonly QuantityIdentification[]): void {\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const ident of identifications) {\n      if (set.has(ident.from) && !set.has(ident.to)) {\n        set.add(ident.to);\n        changed = true;\n      }\n    }\n  }\n}\n\n/** One connected component of the monomial graph: its rows and its column names. */\ninterface MonomialComponent {\n  readonly index: number;\n  readonly rows: readonly MonomialRow[];\n  readonly names: readonly string[];\n}\n\n/** The solve of one component under one asserted set. */\ninterface ComponentSolve {\n  /** The asserted names inside the component, sorted. */\n  readonly inside: readonly string[];\n  readonly determined: ReadonlySet<string>;\n  /** Distinct rows minus rank, for this component. */\n  readonly surplus: number;\n}\n\n/** The rows, the components and the memo of component solves, per edge array and reader. */\ninterface RankIndex {\n  readonly rows: readonly MonomialRow[];\n  readonly components: readonly MonomialComponent[];\n  readonly componentOf: ReadonlyMap<string, number>;\n  readonly solves: Map<number, ComponentSolve[]>;\n}\n\nconst rankIndexCache = new WeakMap<readonly BridgeEdge[], Map<string, RankIndex>>();\n\n/**\n * The monomial rows of `edges` under `reader`, grouped into the connected\n * components of the graph whose vertices are quantity names and whose links\n * are the rows (a row joins its target to each of its sources). The\n * log-space matrix is block-diagonal over these components, so each is\n * solved on its own, once per asserted set, and the answers are exact.\n * Built once per edge array and reader.\n */\nfunction rankIndex(edges: readonly BridgeEdge[], reader: EdgeMonomialReader, readerKey: string): RankIndex {\n  let perEdges = rankIndexCache.get(edges);\n  if (perEdges === undefined) {\n    perEdges = new Map();\n    rankIndexCache.set(edges, perEdges);\n  }\n  const hit = perEdges.get(readerKey);\n  if (hit !== undefined) return hit;\n\n  const rows: MonomialRow[] = [];\n  for (const edge of edges) {\n    const sources = reader(edge);\n    if (sources !== undefined) rows.push({ id: edge.id, target: edge.target.name, sources });\n  }\n  const parent = new Map<string, string>();\n  const find = (name: string): string => {\n    let root = name;\n    while (parent.get(root) !== root) root = parent.get(root)!;\n    let cur = name;\n    while (cur !== root) {\n      const next = parent.get(cur)!;\n      parent.set(cur, root);\n      cur = next;\n    }\n    return root;\n  };\n  for (const row of rows) {\n    if (!parent.has(row.target)) parent.set(row.target, row.target);\n    for (const name of row.sources.keys()) {\n      if (!parent.has(name)) parent.set(name, name);\n      const a = find(row.target);\n      const b = find(name);\n      if (a !== b) parent.set(a, b);\n    }\n  }\n  const groups = new Map<string, { rows: MonomialRow[]; names: Set<string> }>();\n  for (const row of rows) {\n    const root = find(row.target);\n    let group = groups.get(root);\n    if (group === undefined) {\n      group = { rows: [], names: new Set() };\n      groups.set(root, group);\n    }\n    group.rows.push(row);\n    group.names.add(row.target);\n    for (const name of row.sources.keys()) group.names.add(name);\n  }\n  const components: MonomialComponent[] = [...groups.values()].map((group, index) => ({\n    index,\n    rows: group.rows,\n    names: [...group.names],\n  }));\n  const componentOf = new Map<string, number>();\n  for (const component of components) for (const name of component.names) componentOf.set(name, component.index);\n  const index: RankIndex = { rows, components, componentOf, solves: new Map() };\n  perEdges.set(readerKey, index);\n  return index;\n}\n\n/**\n * Solve one component with the asserted names inside it as unit rows.\n * Memoised per asserted set; a solve whose asserted set extends a cached\n * one by names that solve already determined is that solve with one more\n * dependent row per extra name (an already-determined quantity asserted\n * again is a consistency check, and determines nothing new).\n */\nfunction solveComponent(index: RankIndex, component: MonomialComponent, asserted: ReadonlySet<string>): ComponentSolve {\n  const inside = component.names.filter((name) => asserted.has(name)).sort();\n  let cached = index.solves.get(component.index);\n  if (cached === undefined) {\n    cached = [];\n    index.solves.set(component.index, cached);\n  }\n  const insideSet = new Set(inside);\n  for (const solve of cached) {\n    if (solve.inside.length === inside.length && solve.inside.every((name) => insideSet.has(name))) return solve;\n  }\n  for (const solve of cached) {\n    if (!solve.inside.every((name) => insideSet.has(name))) continue;\n    const extra = inside.filter((name) => !solve.inside.includes(name));\n    if (extra.every((name) => solve.determined.has(name))) {\n      const widened: ComponentSolve = { inside, determined: solve.determined, surplus: solve.surplus + extra.length };\n      cached.push(widened);\n      return widened;\n    }\n  }\n\n  const column = new Map(component.names.map((name, i) => [name, i] as const));\n  const matrix: Fraction[][] = [];\n  const seen = new Set<string>();\n  const pushRow = (row: Fraction[]): void => {\n    const k = rowKey(row);\n    if (k === '0' || seen.has(k)) return;\n    seen.add(k);\n    matrix.push(row);\n  };\n  for (const row of component.rows) {\n    const vector = component.names.map(() => ZERO);\n    vector[column.get(row.target)!] = ONE;\n    for (const [name, exp] of row.sources) {\n      const i = column.get(name)!;\n      vector[i] = vector[i]!.sub(exp);\n    }\n    pushRow(vector);\n  }\n  for (const name of inside) {\n    const vector = component.names.map(() => ZERO);\n    vector[column.get(name)!] = ONE;\n    pushRow(vector);\n  }\n  const solved = rationalNullspace(matrix, { columns: component.names.length });\n  const determined = new Set<string>(inside);\n  component.names.forEach((name, i) => {\n    if (solved.basis.every((vector) => vector[i]!.isZero())) determined.add(name);\n  });\n  const result: ComponentSolve = { inside, determined, surplus: matrix.length - solved.rank };\n  cached.push(result);\n  return result;\n}\n\ninterface RankSolution {\n  readonly determined: Set<string>;\n  readonly surplus: number;\n}\n\n/**\n * The asserted set is the known names plus every name a directed\n * identification reaches from a known or a determined one; only these get a\n * unit row, and a name the rank determines is never fed back in as a row\n * (that would count it as a check). Each pass solves the components the\n * asserted set touches (every component when `every`, so the surplus counts\n * the whole system), lets the identifications assert what the determined\n * names reach, and repeats until nothing new is asserted.\n */\nfunction solveRank(\n  index: RankIndex,\n  knownNames: readonly string[],\n  identifications: readonly QuantityIdentification[],\n  every: boolean,\n): RankSolution {\n  const asserted = new Set<string>(knownNames);\n  expandByIdentifications(asserted, identifications);\n  const determined = new Set<string>();\n  let surplus = 0;\n  for (;;) {\n    determined.clear();\n    for (const name of asserted) determined.add(name);\n    surplus = 0;\n    for (const component of index.components) {\n      if (!every && !component.names.some((name) => asserted.has(name))) continue;\n      const solve = solveComponent(index, component, asserted);\n      for (const name of solve.determined) determined.add(name);\n      surplus += solve.surplus;\n    }\n    const before = asserted.size;\n    const reach = new Set(determined);\n    expandByIdentifications(reach, identifications);\n    for (const name of reach) if (!determined.has(name)) asserted.add(name);\n    if (asserted.size === before) break;\n  }\n  return { determined, surplus };\n}\n\n/** The cache of full rank reports per edge array, keyed by the known set and the identifications. */\nconst rankCache = new WeakMap<readonly BridgeEdge[], Map<string, RankIdentifiability>>();\n\nfunction rankCacheKey(known: readonly string[], identifications: readonly QuantityIdentification[], custom: boolean): string {\n  return `${[...known].sort().join('\\u0001')}|${identifications.map((i) => `${i.from}>${i.to}`).join('\\u0001')}|${custom ? 'custom' : 'default'}`;\n}\n\n/**\n * {@link identifiabilityByRank} with the monomial reader chosen by the\n * caller (the default is {@link edgeMonomial}). A custom reader's index and\n * results are cached beside the default's, never in its place.\n *\n * @internal\n */\nexport function identifiabilityByRankWith(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  reader: EdgeMonomialReader,\n  opts: IdentifiabilityOptions = {},\n): RankIdentifiability {\n  return rankWithReader(edges, knownNames, reader, reader !== edgeMonomial, opts);\n}\n\n/**\n * The log-space rank: which quantities the monomial edges determine from\n * `knownNames`, whichever direction each law is read, how many independent\n * consistency checks the system carries, and which laws were read in\n * reverse. Identifications stay directed, as in {@link forwardClosure}: a\n * name they reach joins the known rows, and the system is solved again\n * until nothing new is determined. Non-monomial edges contribute nothing\n * here; the forward closure is their instrument.\n *\n * @public\n */\nexport function identifiabilityByRank(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  opts: IdentifiabilityOptions = {},\n): RankIdentifiability {\n  return rankWithReader(edges, knownNames, edgeMonomial, false, opts);\n}\n\nfunction rankWithReader(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  reader: EdgeMonomialReader,\n  custom: boolean,\n  opts: IdentifiabilityOptions,\n): RankIdentifiability {\n  const identifications = opts.identifications ?? QUANTITY_IDENTIFICATIONS;\n  const key = rankCacheKey(knownNames, identifications, custom);\n  let perEdges = rankCache.get(edges);\n  if (perEdges === undefined) {\n    perEdges = new Map();\n    rankCache.set(edges, perEdges);\n  }\n  const hit = perEdges.get(key);\n  if (hit !== undefined) return hit;\n\n  const index = rankIndex(edges, reader, custom ? 'custom' : 'default');\n  const { determined, surplus } = solveRank(index, knownNames, identifications, true);\n\n  // A law is read in reverse when one of its sources is determined, and not\n  // by the forward closure over the monomial edges alone.\n  const monomialIds = new Set(index.rows.map((r) => r.id));\n  const forward = forwardClosure(\n    edges.filter((e) => monomialIds.has(e.id)),\n    knownNames,\n    identifications,\n  );\n  const usedInReverse = index.rows\n    .filter((row) => [...row.sources.keys()].some((name) => !forward.has(name) && determined.has(name)))\n    .map((row) => row.id);\n\n  const result: RankIdentifiability = {\n    determined: [...determined].sort(),\n    determinedByRankOnly: [...determined].filter((name) => !forward.has(name)).sort(),\n    surplusChecks: surplus,\n    usedInReverse,\n    monomialEdges: index.rows.map((r) => r.id),\n  };\n  perEdges.set(key, result);\n  return result;\n}\n\n/**\n * Whether the rank determines `target` from `knownNames`. Only the\n * components the asserted set touches are solved, and each solve is\n * memoised, so the funnel's thousands of calls per anchor cost one solve\n * per touched component, plus one per hypothesis that actually asserts a\n * new name.\n */\nfunction rankDetermines(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  target: string,\n  identifications: readonly QuantityIdentification[],\n): boolean {\n  const index = rankIndex(edges, edgeMonomial, 'default');\n  if (!index.componentOf.has(target)) return false;\n  return solveRank(index, knownNames, identifications, false).determined.has(target);\n}\n\n/** The quantities from which `targetName` is forward-reachable (its\n *  backward cone, target included). */\nfunction backwardCone(\n  edges: readonly BridgeEdge[],\n  targetName: string,\n): Set<string> {\n  const cone = new Set<string>([targetName]);\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const e of edges) {\n      if (!cone.has(e.target.name)) continue;\n      for (const s of e.sources) {\n        if (!cone.has(s.name)) {\n          cone.add(s.name);\n          changed = true;\n        }\n      }\n    }\n  }\n  return cone;\n}\n\n/**\n * Classify the structural identifiability of `targetName` given\n * `knownNames` over `edges`. See the module docs and\n * docs/planning/Identifiability-Classifier-Design-Note.md.\n *\n * @public\n */\nexport function classifyIdentifiability(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  targetName: string,\n  opts: IdentifiabilityOptions = {},\n): IdentifiabilityResult {\n  const identifications = opts.identifications ?? QUANTITY_IDENTIFICATIONS;\n  const known = [...new Set(knownNames)];\n\n  const closure = forwardClosure(edges, known, identifications);\n  // The rank is computed once per result and only when something reads it:\n  // the verdict needs it only for a target the closure does not reach, and\n  // the funnel classifies thousands of targets whose verdict it does reach.\n  let rankMemo: RankIdentifiability | undefined;\n  const rankOf = (): RankIdentifiability => {\n    rankMemo ??= identifiabilityByRank(edges, known, { identifications });\n    return rankMemo;\n  };\n  // The union: the closure (every edge, forward) and the rank (the monomial\n  // edges, either way). `determinedByRankOnly` is reported against the whole\n  // closure here, so a name the closure reaches through an opaque edge is\n  // not counted as rank-only.\n  const determinableOf = (): Set<string> => new Set<string>([...closure, ...rankOf().determined]);\n  const rankReport = (): RankIdentifiability => {\n    const rank = rankOf();\n    return { ...rank, determinedByRankOnly: rank.determined.filter((name) => !closure.has(name)) };\n  };\n\n  // Derivations must not depend on the target itself: close over the\n  // graph with every edge INTO the target removed (excludes circular\n  // self-support — see the design note's worked counterexample).\n  const edgesMinusIntoTarget = edges.filter(\n    (e) => e.target.name !== targetName,\n  );\n  const dMinusT = forwardClosure(edgesMinusIntoTarget, known, identifications);\n\n  const derivations = edges\n    .filter(\n      (e) =>\n        e.target.name === targetName &&\n        e.sources.every((s) => dMinusT.has(s.name)),\n    )\n    .map((e) => e.id);\n\n  const isGiven = known.includes(targetName);\n  let verdict: IdentifiabilityVerdict;\n  if (isGiven) {\n    verdict = 'given';\n  } else if (!closure.has(targetName) && !rankDetermines(edges, known, targetName, identifications)) {\n    verdict = 'under-determined';\n  } else if (derivations.length >= 2) {\n    verdict = 'over-determined';\n  } else {\n    // One forward derivation, or determined by identity, or determined by\n    // the rank alone (then `derivations` is empty and `rank.usedInReverse`\n    // names the laws that were read backwards).\n    verdict = 'exactly-determined';\n  }\n\n  const surplusConstraints = isGiven\n    ? derivations.length\n    : Math.max(0, derivations.length - 1);\n\n  let blockingFrontier: string[] = [];\n  if (verdict === 'under-determined') {\n    const knownSet = new Set(known);\n    const determinable = determinableOf();\n    blockingFrontier = [...backwardCone(edges, targetName)]\n      .filter(\n        (q) => q !== targetName && !determinable.has(q) && !knownSet.has(q),\n      )\n      .sort();\n  }\n\n  return {\n    target: targetName,\n    known,\n    verdict,\n    derivations,\n    surplusConstraints,\n    blockingFrontier,\n    get determinable(): readonly string[] {\n      return [...determinableOf()].sort();\n    },\n    get rank(): RankIdentifiability {\n      return rankReport();\n    },\n  };\n}\n\n/**\n * Classify every quantity that is some edge's target, against one known\n * set. The natural feeder for a retrodiction harness (mask a node, ask\n * whether the graph recovers it). Sorted by target name.\n *\n * @public\n */\nexport function classifyAll(\n  edges: readonly BridgeEdge[],\n  knownNames: readonly string[],\n  opts: IdentifiabilityOptions = {},\n): IdentifiabilityResult[] {\n  const targets = [...new Set(edges.map((e) => e.target.name))].sort();\n  return targets.map((t) =>\n    classifyIdentifiability(edges, knownNames, t, opts),\n  );\n}\n"]}

package/dist/composition/index.d.ts

@@ -14,9 +14,11 @@ export type { Quantity, RegimeAttributes } from './quantity.js';
 export { regimesDiffer } from './quantity.js';
 export type { BridgeEdge, EdgeConfidence, ValidityDomain } from './edge.js';
 /** Edge evaluation and the errors it throws. An unset coefficient is `CoefficientUnsetError`. */
-export { CoefficientUnsetError, CompositionAliasError, CompositionDimensionError, CompositionJunctionError, UndefinedCompositionError, evaluateEdge, } from './edge.js';
+export { CoefficientUnsetError, CompositionAliasError, CompositionDimensionError, CompositionJunctionError, UndefinedCompositionError, evaluateEdge, validityDomain, } from './edge.js';
 /** The errors one evaluation throws: the input checks, then the validity domain. */
 export { DomainViolationError, DuplicateInputError, InputTypeError, MissingInputError, NonFiniteInputError, UnknownInputError, } from '../bridges/evaluation-errors.js';
+/** A failed validity condition and the inputs it read, as `DomainViolationError.violations` lists them. */
+export type { DomainInput, DomainViolation } from '../bridges/evaluation-errors.js';
 export type { ComposeOptions, QuantityIdentification } from './compose.js';
 export { composeEdges, minConfidence, QUANTITY_IDENTIFICATIONS, SOURCE_ALIAS_DISPOSITIONS, } from './compose.js';
 export type { AliasDisposition } from './compose.js';
@@ -29,15 +31,17 @@ export type { CompositionCandidate, EnumerationReport, } from './enumerate.js';
 export { enumerateCompositions, REGISTERED_COMPOSITION_IDS, } from './enumerate.js';
 export type { UncertaintyResult } from './uncertainty.js';
 export { propagateUncertainty } from './uncertainty.js';
-export type { IdentifiabilityVerdict, IdentifiabilityResult, IdentifiabilityOptions, } from './identifiability.js';
-export { classifyIdentifiability, classifyAll, forwardClosure, } from './identifiability.js';
+/** The classifier's verdict, result and option types, and the rank instrument's report. */
+export type { IdentifiabilityVerdict, IdentifiabilityResult, IdentifiabilityOptions, RankIdentifiability, } from './identifiability.js';
+/** The forward closure, the per-target classifier, the sweep, and the log-space rank over the monomial edges. */
+export { classifyIdentifiability, classifyAll, forwardClosure, identifiabilityByRank, } from './identifiability.js';
 /** The retrodiction harness's result, prediction, refusal, report and option types. */
 export type { RetrodictionOutcome, RetrodictionPrediction, RetrodictionResult, RetrodictionRefusal, RetrodictionReport, RetrodictionOptions, } from './retrodiction.js';
 export { retrodict, retrodictNode } from './retrodiction.js';
 export type { DerivationExplanation, ExplainOptions, QuantityExplanation, } from './explain.js';
 export { explainQuantity } from './explain.js';
 /** The result of {@link evaluateRelation}. A value carries a dimension. An unset coefficient carries the formula. */
-export type { Evaluation } from './evaluate-relation.js';
+export type { Evaluation, ExtraOutput } from './evaluate-relation.js';
 /** Evaluate a catalog id or a canonical id. A sourced number is `kind: 'value'`. An unset coefficient is `kind: 'unset'`. */
 export { evaluateRelation } from './evaluate-relation.js';
 export type { Observable, ComposeSymbolicOptions } from './compose-symbolic.js';

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

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

package/dist/composition/index.js

@@ -12,7 +12,7 @@
  */
 export { regimesDiffer } from './quantity.js';
 /** Edge evaluation and the errors it throws. An unset coefficient is `CoefficientUnsetError`. */
-export { CoefficientUnsetError, CompositionAliasError, CompositionDimensionError, CompositionJunctionError, UndefinedCompositionError, evaluateEdge, } from './edge.js';
+export { CoefficientUnsetError, CompositionAliasError, CompositionDimensionError, CompositionJunctionError, UndefinedCompositionError, evaluateEdge, validityDomain, } from './edge.js';
 /** The errors one evaluation throws: the input checks, then the validity domain. */
 export { DomainViolationError, DuplicateInputError, InputTypeError, MissingInputError, NonFiniteInputError, UnknownInputError, } from '../bridges/evaluation-errors.js';
 export { composeEdges, minConfidence, QUANTITY_IDENTIFICATIONS, SOURCE_ALIAS_DISPOSITIONS, } from './compose.js';
@@ -23,7 +23,8 @@ export { catalogEdge, CATALOG_GRAPH } from './catalog-graph.js';
 export { CANONICAL_GRAPH, canonicalToEdges, CANONICAL_CONSTANTS, } from './canonical-graph.js';
 export { enumerateCompositions, REGISTERED_COMPOSITION_IDS, } from './enumerate.js';
 export { propagateUncertainty } from './uncertainty.js';
-export { classifyIdentifiability, classifyAll, forwardClosure, } from './identifiability.js';
+/** The forward closure, the per-target classifier, the sweep, and the log-space rank over the monomial edges. */
+export { classifyIdentifiability, classifyAll, forwardClosure, identifiabilityByRank, } from './identifiability.js';
 export { retrodict, retrodictNode } from './retrodiction.js';
 export { explainQuantity } from './explain.js';
 /** Evaluate a catalog id or a canonical id. A sourced number is `kind: 'value'`. An unset coefficient is `kind: 'unset'`. */