Function selfTestSolveTemplate

scripts/fungrim/apply-solve-templates.ts:152–196

(
  match: MathJSON,
  replace: MathJSON,
  innerA: MathJSON
)

  // two products into one commutative `Multiply(__a, _x, …)`, and the matcher
  // cannot synthesize an EMPTY `__a` among the flattened factors (it fires only
  // when `__a` is explicitly present, i.e. the already-scaled case). That
  // regresses the unscaled integer-RHS case (`x·eˣ = 3`). For product inners we
  // therefore keep the unscaled shape `Add(A(_x), __b)` (no leading scale
  // wildcard).
  //
  // This no longer costs the rational-RHS case: `clearDenominators` (solve.ts)
  // now skips exact numeric-literal denominators, so a rational RHS like
  // `x·eˣ = −1/10` is NOT rescaled to `10·x·eˣ + 1` and reaches the templates
  // as `Add(Multiply(_x, Exp(_x)), 1/10)`, matching this unscaled product-inner
  // shape (the `__b` wildcard + `useVariations` absorbs the rational offset).
  const isProduct = Array.isArray(innerA) && innerA[0] === 'Multiply';
  const negOffset: MathJSON = isProduct
    ? ['Negate', '__b']
    : ['Negate', ['Divide', '__b', '__a']];
  const outer = (m as MathJSON[]).map((part, i) =>
    i === slot ? negOffset : part
  );
  return {
    match: isProduct
      ? ['Add', innerA, '__b']
      : ['Add', ['Multiply', '__a', innerA], '__b'],
    replace: substituteSymbol(outer, unknown, '_x'),
    innerA,
  };
}

// ---------------------------------------------------------------------------
// End-to-end self-test
// ---------------------------------------------------------------------------

/** Probe values for the solve self-test (positive bias: many inner functions
 *  — `Ln`, `Sqrt` — are real only for positive arguments). The negative
 *  probes exercise templates that only validate for x0 < −1, e.g. the W₋₁
 *  branch seed ed7dac (`A(x0) = x0·e^{x0} ∈ (−1/e, 0)` where W₋₁ inverts);
 *  probes whose image is non-real for a given seed are skipped structurally. */
const SOLVE_SELFTEST_PROBES = [0.5, 1.5, 2.5, 0.7, 3.25, -2, -1.5, -3.25];

/** The no-capture filter (mirrors `solve.ts`'s `filter` and the loader copy):
 *  no wildcard other than `_x` may capture `_x`. */
function noCaptureFilter(sub: Record<string, { has(s: string): boolean }>): boolean {
  for (const [k, v] of Object.entries(sub))
    if (k !== '_x' && k !== 'x' && v.has('_x')) return false;
  return true;
}

/** Push the template (in isolation) to a stock engine's `solveRules` and
 *  solve a concrete instance `A(x) = A(x0)`; succeeds when a returned,
 *  `validateRoots`-approved root equals the chosen probe `x0`. */