Function foeFunctionAux

src/compute-engine/rubi/rubi-utils.ts:3311–3365

FunctionOfExponentialFunctionAux: u with F^v → x (the new integration * variable), using the registered $base$/$expon$.

(u: Expression, x: string, st: FoeState)

      // (g Cot)^p (a+b Cos)^m == (-g Tan[θ−π/2])^p (a−b Sin[θ−π/2])^m
      if (g.head === 'cot')
        return ce.function('Multiply', [
          buildMono(ce, g.coef.neg(), 'tan', argM, g.exp),
          binomM,
        ]);
      // (g Tan)^p (a+b Cos)^m == (-g Cot[θ+π/2])^p (a+b Sin[θ+π/2])^m
      if (g.head === 'tan')
        return ce.function('Multiply', [
          buildMono(ce, g.coef.neg(), 'cot', argP, g.exp),
          binomP,
        ]);
    }
  }
  return null;
}

// Standalone-cosine leaf shift (the poly·cos generalization of cosBaseToSin).
// Rubi's DeactivateTrig reflects a lone linear-argument cosine onto the sine
// chapter (`cos[e+f·x] → sin[e+π/2+f·x]`, source line 6576) as a LEAF identity —
// it applies regardless of what x-dependent factors (a polynomial (c+d·x)^m, a
// reciprocal (c+d·x)^-k, …) multiply the cosine. `cosBaseToSin`/`unifyInertTrig`
// only cover the base of a `(a+b·cos)^n` power (x-free coefficient), so a
// poly·cos product (`∫(c+d·x)^m·cos`, `∫cos/(c+d·x)^k`) was NOT reflected and
// stranded — the sine-chapter reduction `∫(c+d·x)^m·sin → …+∫(c+d·x)^(m-1)·cos`
// (4.1.10 #1) bottoms out in exactly such a `poly·cos` sub-integral whose
// closing rule lives in the unbundled Cosine chapter. This full-tree leaf
// rewrite closes it. Gated to fire ONLY when cosine is the SOLE trig head: any
// other inert trig (sin/tan/cot/sec/csc) means a mixed cross-pair form where a
// blind reflection desyncs arguments or steals a mixed-rule match — left to the
// two-factor clauses in `unifyInertTrig` and the bundled mixed rules.
const NON_COS_INERT_TRIG = new Set(['sin', 'tan', 'cot', 'sec', 'csc']);
function hasNonCosInertTrig(e: Expression): boolean {
  if (NON_COS_INERT_TRIG.has(e.operator)) return true;
  return e.ops?.some(hasNonCosInertTrig) ?? false;
}
function hasLinearArgCos(e: Expression, x: string): boolean {
  if (
    e.operator === 'cos' &&
    e.ops?.length === 1 &&
    polyDegreeX(e.ops[0], x) === 1
  )
    return true;
  return e.ops?.some((o) => hasLinearArgCos(o, x)) ?? false;
}
function cosLeafShiftRec(
  ce: ComputeEngine,
  e: Expression,
  x: string
): Expression {
  if (
    e.operator === 'cos' &&
    e.ops?.length === 1 &&
    polyDegreeX(e.ops[0], x) === 1
  )
    return ce.function('sin', [e.ops[0].add(ce.Pi.div(2))]);
  const ops = e.ops;
  if (!ops || ops.length === 0) return e;
  const newOps = ops.map((o) => cosLeafShiftRec(ce, o, x));
  if (newOps.every((o, i) => o === ops[i])) return e;