Function validateRoots

src/compute-engine/boxed-expression/solve.ts:2571–2626

(
  expr: Expression,
  x: string,
  roots: ReadonlyArray<Expression>,
  trace?: RuleSteps
)

        // decidable guard for the narrative (a numeric ratio collapses to the
        // bare root, matching the pre-Phase-2 trace; a False guard drops the
        // step). An undecidable guard is displayed as the `When`.
        let value: Expression | null = m.value;
        if (isFunction(value, 'When'))
          value = conditionalRoot(ce, value.op1, value.op2);
        if (value === null) continue;
        traceStep(
          trace,
          m.because !== '' ? m.because : 'solve.template',
          rootsAsEquations(ce, x, [value])
        );
      }
    };

    // FAST PATH: a univariate polynomial of degree ≥ 2 is solved directly from
    // its coefficients (quadratic formula / rational-root + numeric), skipping
    // the commutative pattern-matcher whose operand-permutation search dominates
    // polynomial solving (P1-2). Non-polynomial shapes — and linear equations,
    // whose rule is already cheap — fall through to the rule templates below.
    // `originalExpr` is preferred (clean); when radical-clearing turned a
    // non-polynomial original into a sqrt-free polynomial (`√(1−x²) = x²` →
    // `1 − x² − x⁴`), the transformed `expr` is used and `validateRoots` drops
    // any roots the squaring introduced.
    const polyExpr =
      polynomialDegree(originalExpr, x) >= 0
        ? originalExpr
        : polynomialDegree(expr, x) >= 0
          ? expr
          : null;
    if (polyExpr !== null && polynomialDegree(polyExpr, x) >= 2)
      result = solvePolynomialByCoefficients(polyExpr, x, trace);

    if (result.length === 0) {
      for (const e of exprs) {
        const matches = matchRootsSteps(e);
        traceMatches(matches);
        result.push(...matches.map((s) => s.value));
      }
    }

    // If we didn't find a solution yet, try modifying the expression
    //expr.
    // Note: @todo we can try different heuristics here:
    // Collection: reduce the numbers of occurrences of the unknown
    // Attraction: bring the occurrences of the unknown closer together
    // Function Swapping: replacing function with ones easier to solve
    //    - square roots: square both sides
    //    - logs: exponentiate both sides
    //    - trig functions: use inverse trig functions
    // Homogenization: replace a function of the unknown by a new variable,
    // e.g. exp(x) -> y, then solve for y

    let harmonized: Expression[] = [];
    if (result.length === 0) {
      harmonized = exprs.flatMap((expr) => harmonize(expr));
      for (const h of harmonized) {
        const matches = matchRootsSteps(h);
        traceMatches(matches, { because: 'solve.harmonize', form: h });
        result.push(...matches.map((s) => s.value));