Function simplify

src/compute-engine/boxed-expression/simplify.ts:99–232

(
  expr: Expression,
  options?: Partial<InternalSimplifyOptions>,
  steps?: RuleSteps
)

  // subexpression with no free unknowns must NOT be folded when its
  // constant-ness comes from an assigned value — `9 - w²` with `w := 5` stays
  // symbolic, not `-72`, and a binder body `Add(x,1)` with a global `x := 5`
  // stays `x + 1`. `simplify()` never substitutes assigned values; that is
  // `.evaluate()`'s job. The `hasAssignedVariable` check is ordered LAST (after
  // the cheap `unknowns`/operator gates) so it runs only on fold candidates.

  // If purely numeric (no unknowns), evaluate the whole expression.
  if (
    expr.unknowns.length === 0 &&
    BASIC_ARITHMETIC.includes(expr.operator) &&
    !hasAssignedVariable(expr)
  ) {
    const evaluated = expr.evaluate();
    if (isNumber(evaluated)) return evaluated;
  }

  // Constant logarithms are folded to their exact value even when they are
  // not BASIC_ARITHMETIC and are buried inside another operand. This closes
  // the Divide-context gap where `(ln(e)·y)/x` kept its `ln(e)` factor: the
  // lazy-Multiply branch simplifies bare `Ln` operands, but the Divide
  // branch only runs this numeric fold on its operands, so a constant `Ln`
  // in a Divide numerator/denominator was never reduced. The exactness
  // contract keeps genuinely-symbolic logs (Ln(2)) as non-literal, so only
  // closed-form constants (Ln(e) -> 1, Log(1000,10) -> 3) fold here.
  if (
    (expr.operator === 'Ln' || expr.operator === 'Log') &&
    expr.unknowns.length === 0 &&
    !hasAssignedVariable(expr)
  ) {
    const evaluated = expr.evaluate();
    if (isNumber(evaluated) && !evaluated.isSame(expr)) return evaluated;
  }

  // Otherwise, recursively process operands
  const newOps = expr.ops.map((op) => evaluateNumericSubexpressions(op));

  // Check if anything changed
  const changed = newOps.some((op, i) => op !== expr.ops[i]);
  if (!changed) return expr;

  // Reconstruct with _fn to avoid re-canonicalization
  return expr.engine._fn(expr.operator, newOps);
}

/**
 * Cheap structural pre-check: is there a product or power that expansion could
 * act on at all? Keeps the trial expansion below from calling `expand()` on
 * every expression that reaches the fixpoint.
 */
function mightExpand(expr: Expression): boolean {
  if (!isFunction(expr)) return false;
  if (
    expr.operator === 'Multiply' &&
    expr.ops.some((x) => isFunction(x, 'Add'))
  )
    return true;
  if (expr.operator === 'Power' && isFunction(expr.op1, 'Add')) return true;
  return expr.ops.some(mightExpand);
}