Function unifyInertTrig

src/compute-engine/rubi/rubi-utils.ts:3005–3036

(
  ce: ComputeEngine,
  u: Expression,
  x: string
)

  if (!ops || ops.length === 0) return e;
  const newOps = ops.map((o) => reciprocalToPowerRec(ce, o, frozen, keepRaw));
  if (newOps.every((o, i) => o === ops[i])) return e;
  return ce.function(e.operator, newOps);
}

/** True if a `csc`/`sec` reciprocal head appears anywhere in the tree. */
function hasReciprocalTrig(e: Expression): boolean {
  if (RECIP_BASE[e.operator] !== undefined) return true;
  return e.ops?.some(hasReciprocalTrig) ?? false;
}

/** True if a `csc`/`sec` head appears raised to a NON-integer power (including
 * under `Sqrt`, or as `(coef·sec)^(1/2)`). Converting such a reciprocal to a
 * cosine/sine power is branch-unsafe — `√(b·sec) ≠ √(b/cos)` off the principal
 * branch — and even a branch-safe INTEGER `csc`/`sec` factor sharing the
 * integrand with such a half-integer reciprocal exposes it to elliptic rules
 * that return branch-wrong forms. So skip the whole rewrite for those
 * (R3 half-integer-power territory). A fractional power of a *plain* sin/cos
 * (with only integer csc/sec present) is unaffected — that conversion is safe
 * and closes real cases (e.g. `csc/(d·cos)^(7/2)`). */
function hasFractionalReciprocalTrig(e: Expression): boolean {
  if (e.operator === 'Sqrt')
    return e.ops?.[0] ? hasReciprocalTrig(e.ops[0]) : false;
  if (e.operator === 'Power' && e.ops?.length === 2) {
    const [base, exp] = e.ops;
    if (!isLiteralInteger(exp) && hasReciprocalTrig(base)) return true;
  }
  return e.ops?.some(hasFractionalReciprocalTrig) ?? false;
}

/** Rewrite inert reciprocal trig heads to negative powers: `csc[θ]→sin[θ]^-1`,
 * `sec[θ]→cos[θ]^-1` (identity when neither appears). See the block comment.
 * Only branch-safe (integer-exponent) occurrences are converted, and the whole
 * rewrite is skipped for integrands carrying a half-integer csc/sec power. */
export function reciprocalToPower(
  ce: ComputeEngine,