Function simplifyLogCore

src/compute-engine/symbolic/simplify-log.ts:40–905

(x: Expression)

 *
 * They are matched by exact label, NOT by an `e^(ln(` prefix: sibling rules in
 * this file label themselves `e^(ln(x) * y) -> x^y` and
 * `e^(ln(x) / y) -> x^(1/y)`, which such a prefix would silently exempt too.
 * Neither needs the exemption (both reduce cost on their own), and a
 * `transform` tag is an unconditional gate bypass, so it should never be
 * handed out by accident.
 *
 * The `combine ln/log terms`, `c^...` and `log base 0 or 1` steps remain
 * untagged.
 */
const EXP_OF_LOG_SUM_LABELS = new Set([
  'e^(ln(x) + y) -> x * e^y',
  'e^(log_c(x) + y) -> x^{1/ln(c)} * e^y',
]);

export function simplifyLog(x: Expression): RuleStep | undefined {
  const r = simplifyLogCore(x);
  if (r === undefined) return r;
  const b = r.because;
  if (
    b === 'ln' ||
    b?.startsWith('ln(') ||
    b?.startsWith('log_') ||
    (b !== undefined && EXP_OF_LOG_SUM_LABELS.has(b))
  )
    return { ...r, purpose: 'transform' };
  return r;
}

function simplifyLogCore(x: Expression): RuleStep | undefined {
  const op = x.operator;
  const ce = x.engine;

  if (!isFunction(x)) return undefined;

  // Handle Ln
  if (op === 'Ln') {
    const arg = x.op1;
    if (!arg) return undefined;

    // ln(0) -> -inf (matches `evaluate()`/`BoxedNumber.ln()`, and Mathematica's
    // `Log[0] == -Infinity`). This branch is currently shadowed by the
    // unconditional "Ln, Log (basic evaluation)" rule in simplify-rules.ts,
    // which calls `.ln()` and already reduces `Ln(0)` before this one runs —
    // but keep this in sync with `evaluate()` in case that ordering changes.
    if (arg.isSame(0)) {
      return { value: ce.NegativeInfinity, because: 'ln(0) -> -inf' };
    }

    // ln(+inf) -> +inf
    if (arg.isInfinity === true && arg.isPositive === true) {
      return { value: ce.PositiveInfinity, because: 'ln(+inf) -> +inf' };
    }

    // ln(p/q) -> ln(p) - ln(q) for positive rational p/q (not integer)
    if (
      arg.operator === 'Rational' &&
      arg.isRational === true &&
      arg.isInteger === false