Function genBinomialPartsX

src/compute-engine/rubi/rubi-utils.ts:1930–1972

Rubi GeneralizedBinomialParts → {a,b,n,q}: u ≡ a·x^q + b·x^n, PosQ[n−q]

(u: Expression, x: string)

      ? ce.function('Multiply', [
          ce.function('Power', [ce.symbol(x), ce.number(m)]),
          R,
        ])
      : R;
  return n.div(denExpr);
}

function functionOfLog(
  u: Expression,
  x: string
): { f: Expression; v: Expression; n: Expression } | null {
  const ce = u.engine;
  u = cancelCommonXPower(u, x);
  // (vAcc,nAcc) accumulate the shared log argument and exponent; vAcc===null
  // is Rubi's `False` sentinel meaning "not yet bound".
  let vAcc: Expression | null = null;
  let nAcc: Expression | null = null;
  const rec = (e: Expression): Expression | null => {
    // AtomQ[u]: a constant passes through; the bare integration variable
    // (u===x) cannot be expressed as a function of a log → False.
    if (e.ops == null || e.ops.length === 0) return e.symbol === x ? null : e;
    const head = e.operator;
    if (CALCULUS_FNS.has(head)) return null; // CalculusQ[u] → False
    // Log[a·x^n] leaf (zero constant term): substitute → x, record (v,n).
    if (head === 'Ln' || (head === 'Log' && e.ops.length === 1)) {
      const bp = binomialPartsX(e.ops[0], x);
      if (bp !== null && (bp.a.isSame(0) || zeroQ(bp.a))) {
        if (vAcc === null || e.ops[0].isSame(vAcc)) {
          vAcc = e.ops[0];
          nAcc = bp.n;
          return ce.symbol(x);
        }
        return null; // a second, distinct log argument → False
      }
      // otherwise fall through: recurse structurally into the log's argument
    }
    // Map FunctionOfLog over the operands, threading (v,n), reconstruct head.
    const parts: Expression[] = [];
    for (const op of e.ops) {
      const r = rec(op);
      if (r === null) return null; // Throw[False]
      parts.push(r);
    }
    return ce.function(head, parts);
  };
  const f = rec(u);
  if (f === null || vAcc === null) return null;