Function expandPolyOverLinear

src/compute-engine/rubi/rubi-utils.ts:4264–4330

(u: Expression, ctx: Ctx)

 *  integer powers of sums, then each additive term is reduced. A term that
 *  cannot be reduced (unexpected shape) is kept verbatim — a safe no-op.
 *  Exported for the rubi-utils unit test (the reduction is an exact identity). */
export function circularTrigReduce(
  ce: ComputeEngine,
  u: Expression
): Expression {
  const expanded = deepExpand(ce, u);
  const terms =
    expanded.operator === 'Add' && expanded.ops ? expanded.ops : [expanded];
  const out: Expression[] = [];
  for (const t of terms) {
    const atoms = reduceTrigTerm(ce, t);
    out.push(atoms === null ? t : atomsToExpr(ce, atoms));
  }
  if (out.length === 0) return ce.Zero;
  if (out.length === 1) return out[0];
  return ce.function('Add', out);
}

/** ExpandTrigReduce[u,x] (2-arg) — product/power reduction of u. Circular
 *  Sin/Cos reduce to a real multiple-angle sum (`circularTrigReduce`);
 *  Sinh/Cosh route through the exponential expansion (see the section
 *  comment). Returns a sum the linearity prelude integrates termwise. */
function expandTrigReduce(ce: ComputeEngine, u: Expression): Expression {
  if (containsCircularSinCos(u)) return circularTrigReduce(ce, u);
  return deepExpand(ce, hyperbolicToExp(ce, u));
}

/** Driver Chapter-6 fallback: rewrite a hyperbolic integrand to exponential
 *  form and expand it into a sum, so the bundled Chapter-2 exponential rules
 *  close each term. Used only when no Rubi rule closed the integrand — Rubi's
 *  bare `(a+b·Sinh[linear])^n` / `(c+d·x)^m·Sinh^n` recurrences live in shared
 *  machinery that is not a standalone corpus rule, so this self-contained
 *  reducer keeps those linear-argument families integrable. The antiderivative
 *  is exponential-form but numerically identical to Rubi's hyperbolic form. */
export function expandHyperbolicToExp(
  ce: ComputeEngine,
  u: Expression
): Expression {
  return deepExpand(ce, hyperbolicToExp(ce, u));
}

// ---------------------------------------------------------------------------
// Trig → exponential fallback for NONLINEAR-argument sin/cos (4.1.11 / 4.1.12).
//
// The direct analog of the Chapter-6 hyperbolic→exp fallback. Rubi's
// nonlinear-argument sine rules (4.1.12 #5/#15 `∫Sin[c+d·xⁿ] → I/2·∫E^… − …`,
// #29 the t=xⁿ substitution) route `∫xᵐ·sin(a+b·xⁿ)` to `∫xᵐ·E^(k·xⁿ)`, closed
// by the bundled Chapter-2 incomplete-Γ kernel — exactly like the hyperbolic
// `Sinh[a+b·xⁿ]` cases. CE's structural matcher does not bind those Subst /
// linear-inner-match rules (the `(e+f·x)ⁿ` base defaulting to `xⁿ` and the
// `Simplify[(m+1)/n]` exponent are Mathematica-simplifier dependent), so this
// self-contained reducer supplies the same capability: rewrite sin/cos → E^(±i·w)
// and expand, so every term is `coef·xᵏ·E^(k·xⁿ)`.
//
// Gated (`sinCosArgNonlinearExpandableQ`) to fire ONLY when a sin/cos of a
// NONLINEAR monomial argument (`c + d·xᵏ`, k≠1 — incl. k<0 for sin(a+b/x)) is
// present and EVERY x-dependent sin/cos argument is such a monomial. Linear-
// argument sin/cos is left to the sine chapter (it never reaches this fallback —