Function deepExpand

src/compute-engine/rubi/rubi-utils.ts:3678–3707

Recursively expand products and positive-integer powers of sums into a flat * sum, treating every leaf (E^…, symbols, x-powers) as opaque. Used after * `hyperbolicToExp` because CE's `Expand` is shallow — it will not expand a * Power(Add, n) that sits as a factor inside a Multiply. Non-integer

(ce: ComputeEngine, e: Expression)

  if (u.symbol === x || CALCULUS_FNS.has(u.operator)) return false;

  if (u.operator === 'Power' && u.ops && !u.ops[0].has(x)) {
    const exp = u.ops[1];
    if (linX(exp, x)) {
      st.flag = true;
      return foeTestAux(u.ops[0], exp, x, st);
    }
    // F^(a+b+…) → F^a · F^b · … : test each summand
    if (exp.operator === 'Add' && exp.ops) {
      st.flag = true;
      return exp.ops.every((t) =>
        foeTest(ce.function('Power', [u.ops![0], t]), x, st)
      );
    }
  }
  if (HYPERBOLIC_HEADS.has(u.operator) && u.ops && linX(u.ops[0], x))
    return foeTestAux(ce.E, u.ops[0], x, st);

  for (const op of u.ops ?? []) if (!foeTest(op, x, st)) return false;
  return true;
}

/** FunctionOfExponentialFunctionAux: u with F^v → x (the new integration
 *  variable), using the registered $base$/$expon$. */
function foeFunctionAux(u: Expression, x: string, st: FoeState): Expression {
  const ce = u.engine;
  if (!u.ops || u.ops.length === 0) return u; // atom

  if (u.operator === 'Power' && !u.ops[0].has(x)) {
    const G = u.ops[0];
    const w = u.ops[1];
    if (linX(w, x)) {
      const p = safeSimplify(
        G.ln()