Function reciprocalToPowerRec

src/compute-engine/rubi/rubi-utils.ts:2591–2621

Rewrite one node. `frozen` is set inside the base of a NON-integer power: * there the reciprocal must NOT be converted, because `(b·sec[θ])^(1/2)` and * `(b·cos[θ]^-1)^(1/2)` disagree on the principal branch (the √ of a reciprocal * ≠ the reciprocal of the √ where the base is negative) — converti

(
  ce: ComputeEngine,
  e: Expression,
  frozen: boolean
)

  const ops = e.ops;
  if (!ops || ops.length === 0) return e;
  const newOps = ops.map((o) => mapTrigHeads(ce, o, map));
  const newHead = map[e.operator] ?? e.operator;
  if (newHead === e.operator && newOps.every((o, i) => o === ops[i])) return e;
  return ce.function(newHead, newOps);
}

/** True if `u` contains a `Power(base, p)` whose base is LINEAR in `x` and
 * whose exponent `p` is a POSITIVE non-integer literal (`√(c+d·x)`,
 * `(c+d·x)^(3/2)`) — the linear-inner shape whose substitution reduction
 * (4.1.12 #81-86) lands an elementary sin/cos·poly antiderivative. Distinguishes
 * `√(c+d·x)` (kept active) from a reciprocal `b/x` / `(c+d·x)^(-1)` (negative
 * exponent ⇒ NOT matched ⇒ deactivated, so the reciprocal declines cleanly). */
function fractionalLinearInnerQ(u: Expression, x: string): boolean {
  // `√(c+d·x)` canonicalizes to a `Sqrt` head, not `Power`.
  if (u.operator === 'Sqrt' && u.ops && polyDegreeX(u.ops[0], x) === 1)
    return true;
  if (u.operator === 'Power' && u.ops) {
    const [base, exp] = u.ops;
    if (polyDegreeX(base, x) === 1 && exp.isNumberLiteral) {
      const e = exp.re;
      if (typeof e === 'number' && e > 0 && !Number.isInteger(e)) return true;
    }
  }
  return (u.ops ?? []).some((o) => fractionalLinearInnerQ(o, x));
}

/** Active → inert: `Cos[x]` → `cos[x]`. Applied to integrands on driver entry.
 *
 * Rubi-faithful `DeactivateTrigAux` (with one deliberate CE refinement): a trig
 * head is deactivated when its argument is LINEAR in `x`, x-free, or a BARE
 * MONOMIAL `c+d·xᵏ`. A trig of a COMPOSITE nonlinear argument — a linear base
 * raised to a power (`Sin[a+b·(c+d·x)ⁿ]`, `Sin[a+b·√(c+d·x)]`) or a genuine
 * quadratic/polynomial (`Sin[a+b·x+c·x²]`) — is left ACTIVE, because the
 * substitution / completing-the-square rules that reduce such arguments to