Function isValidOperatorDef

src/compute-engine/boxed-expression/utils.ts:323–359

(
  def: unknown
)

 * `budget` bounds the TOTAL number of beta-reductions so a self-recursive
 * definition (`fact(n) = … fact(n - 1) …`) cannot loop forever, while a finite
 * self-composition (`g(g(x))` for a non-recursive `g`) still fully expands — an
 * on-path name guard would wrongly stop the inner `g(x)`, leaving `Solve` an
 * opaque `g(x)` it reads as "no solutions". `budget` is a single object shared
 * by reference across every branch of the traversal, so it is one global cap on
 * the TOTAL number of beta-reductions in the whole tree — sibling calls
 * (`g(a) + g(b)`) draw down the same counter rather than each getting a fresh
 * budget. That shared cap is what bounds a self-recursive definition.
 */
// Generous enough that no realistic expression (a wide system of many function
// calls) is capped, low enough that a self-recursive definition terminates
// quickly. Only genuine runaway recursion reaches it.
const MAX_LAMBDA_INLINE = 1000;

function inlineLambdaApplications(
  expr: Expression,
  budget: { n: number } = { n: MAX_LAMBDA_INLINE }
): Expression {
  if (!isFunction(expr)) return expr;

  if (budget.n > 0) {
    const reduced = betaReduceLambda(expr);
    if (reduced !== undefined) {
      budget.n -= 1;
      return inlineLambdaApplications(reduced, budget);
    }
  }

  const ops = expr.ops;
  const inlined = ops.map((op) => inlineLambdaApplications(op, budget));
  if (inlined.every((op, i) => op === ops[i])) return expr;
  return expr.engine.function(expr.operator, inlined);
}

/**
 * Replace symbols bound to a value by that value, except for the names in
 * `protect`.
 *
 * A symbol whose value *contains* the unknown hides it from the solver:
 * `Solve(s = 2, w)` with `s := (9 - w²)/4` saw an equation with no `w` in it
 * and returned `[]` — which by contract means "proven no solutions". A