Function tendsToInfinity

src/compute-engine/symbolic/limit.ts:618–685

Does |e| → ∞ as x → +∞? true / false / undefined (unknown).

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

    if (isDefiniteValue(l)) return l.neg().evaluate();
    return undefined;
  }

  if (op === 'Add') {
    // After the leading-order rewrite the surviving terms are co-dominant
    // (e.g. 1/x + 1/x², both → 0); sum their individual limits.
    let acc: Expression = ce.Zero;
    let posInf = 0;
    let negInf = 0;
    for (const t of oo(e)) {
      const l = limitAtPosInf(t, x, ce, depth + 1);
      if (!l) return undefined;
      if (l.isInfinity === true) {
        if (l.isNegative === true) negInf++;
        else posInf++;
      } else if (isDefiniteValue(l)) acc = acc.add(l);
      else return undefined;
    }
    if (posInf > 0 && negInf > 0) return undefined; // ∞ − ∞ (needs cancellation)
    if (posInf > 0) return ce.PositiveInfinity;
    if (negInf > 0) return ce.NegativeInfinity;
    return acc.evaluate();
  }

  if (op === 'Divide') return limitRatioAtPosInf(o1(e), o2(e), x, ce, depth);

  if (op === 'Power') return limitPowerAtPosInf(o1(e), o2(e), x, ce, depth);

  // √u and ⁿ√u (canonical forms of u^{1/2}, u^{1/n}): monotone for a real
  // radicand, so they carry the argument's limit. A radicand → −∞ heads to an
  // imaginary infinity — deferred (undefined) rather than resolved.
  if (op === 'Sqrt' || op === 'Root') {
    const inner = limitAtPosInf(o1(e), x, ce, depth + 1);
    if (!inner) return undefined;
    if (inner.isInfinity === true)
      return inner.isPositive === true ? ce.PositiveInfinity : undefined;
    if (isDefiniteValue(inner)) {
      const rest = op === 'Root' ? [inner, o2(e)] : [inner];
      return ce.function(op, rest).evaluate();
    }
    return undefined;
  }

  if (op === 'Exp') {
    const inner = limitAtPosInf(o1(e), x, ce, depth + 1);
    return expOfLimit(inner, ce);
  }

  if (op === 'Ln' || op === 'Log') {
    const inner = limitAtPosInf(o1(e), x, ce, depth + 1);
    return lnOfLimit(inner, ce);
  }

  if (op === 'Multiply') return limitProductAtPosInf(oo(e), x, ce, depth);

  if (op === 'Arctan') {
    const inner = limitAtPosInf(o1(e), x, ce, depth + 1);
    if (inner?.isInfinity === true)
      return inner.isNegative === true ? ce.Pi.div(-2) : ce.Pi.div(2);