Function factor

src/compute-engine/boxed-expression/factor.ts:696–766

(expr: Expression)

  return factor(expr);
}

/**
 * Recursively factor each operand of a product. Used to fully factor the
 * result of a single difference-of-squares split, whose halves may themselves
 * be factorable (e.g. (x³−1)(x³+1)). Non-product inputs are returned
 * unchanged. Recursion is bounded: each call factors strictly lower-degree
 * factors.
 */
function refactorProductFactors(
  product: Expression,
  variable: string | undefined
): Expression {
  const ce = product.engine;

  // Power: factor the base, then distribute a positive-integer exponent over
  // the factored base so each prime factor carries the multiplicity —
  // (x²+x)² → x²·(x+1)², while an irreducible base such as (x²+1)² is left
  // intact. collectFactors/partial fractions need irreducible factors, not
  // (f·g)^n.
  if (isFunction(product, 'Power')) {
    const exp = asSmallInteger(product.op2);
    if (exp === null || exp <= 0) return product;
    const factoredBase = factorPolynomial(product.op1, variable);
    if (factoredBase.isSame(product.op1)) return product; // base irreducible
    const baseFactors = isFunction(factoredBase, 'Multiply')
      ? factoredBase.ops
      : [factoredBase];
    return ce.function(
      'Multiply',
      baseFactors.map(
        (f) => ce.function('Power', [f.json, product.op2.json]).json
      )
    );
  }

  if (!isFunction(product, 'Multiply')) return product;
  const factors = product.ops.map((f) => factorPolynomial(f, variable));
  return ce.function(
    'Multiply',
    factors.map((f) => f.json)
  );
}

/**
 * Pull a common monomial factor xᵏ out of a polynomial: x³+x² → x²·(x+1),
 * 3x⁴+2x³ → x³·(3x+2). The cofactor is recursively factored. Returns null
 * when the constant term is nonzero (no monomial content) or the input is not
 * a polynomial in `variable`.
 */
function extractMonomialContent(
  expr: Expression,
  variable: string
): Expression | null {
  const coeffs = getPolynomialCoefficients(expr, variable);
  if (!coeffs || coeffs.length === 0) return null;

  // Lowest index with a nonzero coefficient = the shared power of x.
  let k = 0;