Function deriveSolveTemplate

scripts/fungrim/apply-solve-templates.ts:96–131

(
  rule: CompiledFungrimRule
)

  if (Array.isArray(x)) return x.map((y) => substituteSymbol(y, from, to));
  return x;
}

// ---------------------------------------------------------------------------
// Derivation
// ---------------------------------------------------------------------------

export type SolveTemplate = {
  /** Raw `['Add', ['Multiply', '__a', A(_x)], '__b']`. */
  match: MathJSON;
  /** Raw `f(Negate(Divide(__b, __a)))`. */
  replace: MathJSON;
  /** The inner `A(_x)` (in the solve `_x` convention) — used by the self-test. */
  innerA: MathJSON;
};

/** Derive a root template from a compiled inverse-composition simplify rule
 *  (`f(A(_w)) → _w`). Returns `{error}` when the rule is not of that shape. */
export function deriveSolveTemplate(
  rule: CompiledFungrimRule
): SolveTemplate | { error: string } {
  const m = rule.match;
  const rep = rule.replace;
  if (typeof rep !== 'string' || !rep.startsWith('_'))
    return { error: 'replace is not a bare wildcard' };
  if (!Array.isArray(m) || m.length < 2)
    return { error: 'match is not a function expression' };
  const unknown = rep;
  // The topmost node `[head, arg1, …]` must contain the unknown in exactly
  // one argument slot (the inner expression `A`).
  const slots: number[] = [];
  for (let i = 1; i < m.length; i++)
    if (collectWildcards(m[i]).has(unknown)) slots.push(i);
  if (slots.length !== 1)
    return { error: `unknown appears in ${slots.length} argument slots` };
  const slot = slots[0];
  const A = m[slot];
  if (A === unknown)
    return { error: 'inner argument is the bare unknown (degenerate f(x)=x)' };
  // `A` must reference no wildcard other than the unknown (no free parameter).