Function factorQuadratic

src/compute-engine/boxed-expression/factor.ts:298–371

(
  expr: Expression,
  variable: string
)

}

/**
 * Detect if an expression is a difference of squares.
 * Returns the factored form (a-b)(a+b) if successful, null otherwise.
 *
 * Pattern: a² - b² → (a-b)(a+b)
 *
 * IMPORTANT: Does not call .simplify() on the result to avoid infinite recursion.
 */
export function factorDifferenceOfSquares(expr: Expression): Expression | null {
  const ce = expr.engine;

  // Must be an Add expression with exactly 2 terms (one positive, one negative)
  if (!isFunction(expr, 'Add')) return null;

  const terms = expr.ops;
  if (terms.length !== 2) return null;

  // Try to extract square roots of both terms
  // One should be positive, one negative
  const results: Array<{
    sqrt: Expression;
    isNegative: boolean;
  }> = [];

  for (const term of terms) {
    // Check if term is negative
    let isNeg = isFunction(term, 'Negate');
    let absTerm = isNeg && isFunction(term) ? term.op1 : term;

    // Also handle negative numeric literals
    if (!isNeg && isNumber(term) && term.isNegative === true) {
      isNeg = true;
      absTerm = term.neg(); // Get the absolute value
    }

    // Also handle negative terms from Multiply with negative coefficient
    if (!isNeg && isFunction(term, 'Multiply')) {
      const ops = term.ops;
      // Check if first operand is negative number
      if (isNumber(ops[0]) && ops[0].isNegative === true) {
        isNeg = true;
        // Create positive version by negating the coefficient
        const newOps = [ops[0].neg(), ...ops.slice(1)];
        absTerm = ce.expr(['Multiply', ...newOps.map((op) => op.json)]);
      }
    }

    const sqrt = extractSquareRoot(absTerm);
    if (sqrt === null) return null;

    results.push({ sqrt, isNegative: isNeg });
  }

  // We need exactly one positive and one negative square
  const posSquares = results.filter((r) => !r.isNegative);
  const negSquares = results.filter((r) => r.isNegative);

  if (posSquares.length !== 1 || negSquares.length !== 1) return null;