Function isValidValueDef

src/compute-engine/boxed-expression/utils.ts:361–403

(def: unknown)

 * `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
 * coefficient symbol was already resolved further down the pipeline; only a
 * binding that conceals the unknown was mishandled.
 *
 * Reads the *stored* value (`.value`), never `.evaluate()`: evaluating would
 * resolve the unknown inside that value too (with `w := 7`, `s.evaluate()`
 * would fold `w` away). `protect` holds the unknowns, so the variable being
 * solved for is never substituted, and `seen` stops a self-referential or
 * mutually-referential binding from looping.
 */
export function resolveBoundSymbols(
  expr: Expression,
  protect: ReadonlySet<string>,
  seen: Set<string> = new Set()
): Expression {
  if (isSymbol(expr)) {
    const name = expr.symbol;
    if (protect.has(name) || seen.has(name)) return expr;
    const def = expr.engine.lookupDefinition(name);
    if (!isValueDef(def)) return expr;
    const value = def.value.value;
    if (value === undefined || value === null) return expr;
    seen.add(name);
    const resolved = resolveBoundSymbols(value, protect, seen);
    seen.delete(name);
    return resolved;
  }

  if (!isFunction(expr)) return expr;

  // Binder-awareness: a `Function` literal, `Block`, `Sum`, etc. binds its own
  // variables. Those must NOT be resolved to a same-named GLOBAL value —
  // `Simplify(x ↦ x + 1)` with `x := 5` must stay `x ↦ x + 1`, not corrupt the
  // body's bound `x` into `5`. Extend the protected set with the locally-bound
  // names before descending. (`localScope` covers `Block`/`Sum`/`Product`/…;
  // a `Function`'s parameters live in its operand slots, not its scope.)
  const bound = boundVariableNames(expr);
  const childProtect = bound.length ? new Set([...protect, ...bound]) : protect;

  const ops = expr.ops;
  const resolved = ops.map((op) => resolveBoundSymbols(op, childProtect, seen));
  if (resolved.every((op, i) => op === ops[i])) return expr;
  return expr.engine.function(expr.operator, resolved);
}

/**
 * Replace `At(List(e₁, …, eₙ), k)` by `e_k` — a purely *structural*