Function findNumericSeed

scripts/fungrim/compile-rules.ts:1282–1339

(
  ce: ComputeEngine,
  e: Entry,
  guards: ReadonlyArray<GuardSpec>,
  closures: ReadonlyArray<(sub: Sub) => boolean>,
  seedTypes: Record<string, string>
)

            replace: ce.expr(replaceW as never) as never,
            id: 'fungrim:' + e.id,
          },
        ],
        { canonical: true }
      );
      const inst = ce.expr(substituteWildcards(matchW, dewild) as never);
      const expected = ce.expr(substituteWildcards(replaceW, dewild) as never);
      if (inst.isValid && expected.isValid) {
        const r = inst.replace(unconditioned);
        // Same comparison ladder as `fireTest` above: `isSame` compares
        // binder identity (a rule that transplants a lambda-bound occurrence
        // yields a name-identical but differently-bound result), and
        // `isEqual` is the cheap arithmetic tier — it answers `undefined`,
        // not `true`, for an identity in free variables. Without
        // `sameSyntactic` this branch rejects rewrites whose result is
        // structurally identical to the expectation (e.g. 50f72f, the Sinc
        // derivative).
        if (
          r !== null &&
          (r.isSame(expected) ||
            sameSyntactic(r, expected) ||
            r.isEqual(expected) === true)
        )
          return { ok: true, sampleKind: 'symbolic' };
      }
    } finally {
      ce.popScope();
    }
  }

  return { ok: false, reason: 'no-fire', detail: symbolicDetail };
}

function findNumericSeed(
  ce: ComputeEngine,
  e: Entry,
  guards: ReadonlyArray<GuardSpec>,
  closures: ReadonlyArray<(sub: Sub) => boolean>,
  seedTypes: Record<string, string>
): Record<string, MathJSON> | null {
  const vars = e.variables;
  const sub: Sub = {};

  // Guards are checked at the depth where their last referenced variable is
  // assigned (massive pruning for multi-variable entries).
  const wcIndex = new Map<string, number>(vars.map((v, i) => ['_' + v, i]));
  const guardDepth = guards.map((g) => {
    let depth = -1;
    for (const w of guardWildcards(g)) depth = Math.max(depth, wcIndex.get(w) ?? vars.length - 1);
    return depth;
  });

  // Variable-free guards must hold outright
  for (let i = 0; i < guards.length; i++)
    if (guardDepth[i] === -1 && !closures[i](sub)) return null;
  if (vars.length === 0) return {};

  // A variable the entry APPLIES (`chi` in `chi(m)`) is typed `function` by
  // `variableTypes` in `load.ts`. Every candidate below is a number literal,