Function limitPowerAtPosInf

src/compute-engine/symbolic/limit.ts:352–397

(
  base: Expression,
  expo: Expression,
  x: string,
  ce: ComputeEngine,
  depth: number
)

 * cannot be decided does the same.
 */
function substituteAtFinitePoint(
  e: Expression,
  x: string,
  a: Expression,
  dir: number,
  ce: ComputeEngine
): Expression | undefined {
  // A substitution can land an operand outside a Contract B carrier — at
  // `x = 0`, `Ln(1/x²)` substitutes to `Ln(~oo)` (division by zero folds
  // to the unsigned pole), which is an incompatible-type Error since the
  // complex-extension carrier flips. An invalid substitute is NOT the
  // limit's answer: the LIMIT can still exist through the directed
  // strategies (the inner limit of `1/x²` is `+∞`, and `Ln(+∞) = +∞`),
  // so decline and let the caller fall through to them.
  const substituteAndCheck = (expr: Expression): Expression | undefined => {
    const at = expr.subs({ [x]: a }).evaluate();
    return at.isValid ? at : undefined;
  };
  let current = e;
  // Each pass resolves ONE on-jump subterm (innermost first); the rewrite
  // can nest, so iterate, capped well above any practical nesting.
  for (let pass = 0; pass < 8; pass++) {
    if (!current.has(JUMP_FNS)) return substituteAndCheck(current);
    let jump: Expression | undefined = undefined;
    let offset: Expression | undefined = undefined;
    let jumpSize = Infinity;
    for (const head of JUMP_FNS) {
      for (const sub of current.getSubexpressions(head)) {
        const off = jumpOffsetAt(sub, x, a, ce);
        if (off === 'unknown') return undefined;
        if (off === 'off') continue;
        const size = sub.getSubexpressions('').length;
        if (size < jumpSize) {
          jump = sub;
          offset = off;
          jumpSize = size;
        }
      }
    }
    if (jump === undefined) return substituteAndCheck(current);
    if (dir === 0) return undefined;
    // The expansion anchor must be EXACT when representable: a machine-float
    // point (`0.5` parsed from the limit) mixed with the exact subtrahend of
    // the offset leaves an unfoldable `−1/2 + 0.5` constant term in the
    // series (machine floats are excluded from canonical `Add` folding), a
    // broken datum whose sign read declines. Integers and half-integers —
    // the anchors this code's offsets create — exactify losslessly.
    let anchor = a;
    const ar = a.re;