Function forget

src/compute-engine/engine-assumptions.ts:422–492

(
  ce: IComputeEngine,
  symbol: undefined | MathJsonSymbol | MathJsonSymbol[]
)

    console.error(e instanceof Error ? e.message : String(e));
    throw e;
  }
}

export function forget(
  ce: IComputeEngine,
  symbol: undefined | MathJsonSymbol | MathJsonSymbol[]
): void {
  //
  // ## THEORY OF OPERATIONS
  //
  // When forgeting we need to preserve existing definitions for symbols,
  // as some expressions may be pointing to them. Instead, we
  // reset the value of those definitions, but don't change the domain.
  //

  if (symbol === undefined) {
    ce.context.assumptions?.clear();

    // Also undo value bindings installed by `assume(x = …)` (SYM P2-10): the
    // docstring promises no-arg forget() removes *all* assumptions, but a
    // value assigned via `assume` used to survive (so `x` still evaluated to
    // its assumed value). Only assumption-installed values are cleared — user
    // `declare()`/`assign()` values (never recorded in `assumptionBindings`)
    // are left intact.
    const installed = ce.context.assumptionBindings;
    if (installed) {
      for (const s of installed) {
        const binding = ce.context.lexicalScope.bindings.get(s);
        if (binding && isValueDef(binding) && !binding.value.isConstant)
          binding.value.value = undefined;
      }
      installed.clear();
    }

    // The removed assumptions could affect existing expressions
    ce._noteStateEvent({ kind: 'assumption' });
    if (ce.context) ce.context._assumptionsDirty = true;

    return;
  }

  if (Array.isArray(symbol)) {
    for (const x of symbol) forget(ce, x);
    return;
  }

  if (typeof symbol === 'string') {
    // Remove any assumptions that make a reference to this symbol
    // (note that when a scope is created, any assumptions from the
    // parent scope are copied over, so this effectively removes any
    // reference to this symbol, even if there are assumptions about
    // it in a parent scope. However, when the current scope exits,
    // any previous assumptions about the symbol will be restored).
    for (const [assumption, _val] of ce.context.assumptions) {
      if (assumption.has(symbol)) ce.context.assumptions.delete(assumption);
    }

    // Also reset the symbol's value in the current scope's bindings.