Function onBranchCut

src/compute-engine/function-properties/index.ts:197–233

(
  ce: IComputeEngine,
  operator: string,
  arg: Expression
)

}

/**
 * Eligibility gate for **real-only** simplification rewrites (policy D4).
 *
 * Rewrites that are valid only on the reals — `√(x²) → |x|`, `|x²| → x²`,
 * `|x|² → x²`, `ln(x^{2k}) → 2k·ln|x|` — must not fire when the operand was
 * *declared* (or provably inferred) a complex or imaginary type. Although
 * `complex ⊇ real`, an explicit `complex`/`imaginary` declaration signals a
 * *general* complex value, so these rewrites bail on it (e.g.
 * `z: complex ⇒ √(z²)` stays `√(z²)`, not `|z|`, since `√(i²) = i ≠ 1`).
 *
 * *Unconstrained* symbols (type `unknown`) — and composite expressions of them
 * (`x·y`, `x+1`, which the engine types `number`) — keep the
 * documented generic-real convention and remain eligible.
 *
 * Detection is by **type**, not by `isExtendedReal`. That predicate is
 * three-valued for functions as well as symbols, so a composite expression of
 * unconstrained symbols answers `undefined` rather than `true`: `x·y` and
 * `ln(x)` both type `number`, which is not below the extended real line.
 * Gating on it would therefore need a decision about the
 * `undefined` case, and treating `undefined` as "bail" would drop the
 * generic-real convention on `ln(x)+ln(y) → ln(xy)` and friends. A type that
 * matches `complex` but not `real` is a two-valued test that reliably
 * identifies declared/inferred complex operands, which is what D4 targets.
 *
 * @returns `false` (bail) when `x`'s type admits genuinely non-real complex
 *   values — that is, `complex` or `imaginary`; `true` otherwise.
 */
export function isEligibleRealRewrite(x: Expression): boolean {
  return !isNonRealNumber(x.type.type);
}

// Operators that carry at least one Poles record — a cheap gate so the numeric
// evaluator only does membership work for functions that can have poles.
const POLE_OPERATORS: ReadonlySet<string> = new Set(
  Object.keys(DATA.operators).filter((op) =>
    DATA.operators[op].some((r) => r.property === 'Poles')
  )
);

function isOnPoleSet(