@johnhenry/math 0.0.2 → 0.1.0

package/dist/Symbolic.js

@@ -323,13 +323,16 @@ export class InfiniteSolutionsError extends Error {
     }
 }
 export class Symbolic {
-    /** Parse an expression string such as `"sin(x^2) + 3*x"` into an AST. */
-    static parse(input) {
-        return new Parser(input).parse();
+    /**
+     * Parse an expression string such as `"sin(x^2) + 3*x"` into an AST.
+     * Pass `{ implicitMultiplication: true }` to also read `2x`, `x y` and `2(x+1)`; see {@link ParseOptions}.
+     */
+    static parse(input, options = {}) {
+        return new Parser(input, options ?? {}).parse();
     }
     static differentiate(expr, variable = "x") {
         const e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
-        return Symbolic.simplify(diff(e, variable));
+        return simplifyCore(diff(e, variable));
     }
     /**
      * Like {@link differentiate}, but also returns a bottom-up trace of every
@@ -342,17 +345,20 @@ export class Symbolic {
         const e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
         const steps = [];
         const raw = diffTraced(e, variable, steps);
-        return { steps, result: Symbolic.simplify(raw) };
+        return { steps, result: simplifyCore(raw) };
     }
+    /**
+     * Algebraic simplification: constant folding, like-term collection, and, as a last
+     * step, expanding the expression as a rational function and cancelling common
+     * factors -- `(x+1)^2 - x^2 - 2*x` gives `1` and `(x^2-1)/(x-1)` gives `x+1`.
+     * The expanded/cancelled form is used only when it is strictly smaller than the
+     * collected form, so a product such as `(x+1)*2` keeps its shape. Non-polynomial
+     * subexpressions (`sin(x)`, `x^y`) are treated as opaque symbols. Like any CAS
+     * cancellation, `(x^2-1)/(x-1)` is `x+1` as an expression, ignoring that the
+     * original is undefined at `x = 1`.
+     */
     static simplify(expr) {
-        let e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
-        for (let i = 0; i < 30; i++) {
-            const next = collectLikeTerms(simplifyOnce(e));
-            if (equal(next, e))
-                return next;
-            e = next;
-        }
-        return e;
+        return normalizeRational(simplifyCore(expr));
     }
     /**
      * Simplifies `expr` with additional domain knowledge about specific
@@ -371,14 +377,14 @@ export class Symbolic {
      * assumptions (e.g. "x+y is positive" isn't expressible).
      */
     static simplifyAssuming(expr, assumptions) {
-        const simplified = Symbolic.simplify(expr);
+        const simplified = simplifyCore(expr);
         const rewritten = applyAssumptions(simplified, assumptions);
-        return Symbolic.simplify(rewritten);
+        return simplifyCore(rewritten);
     }
     /** Symbolic anti-derivative (elementary rules; throws {@link NotIntegrableError} otherwise). */
     static integrate(expr, variable = "x") {
         const e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
-        return Symbolic.simplify(integ(e, variable));
+        return simplifyCore(integ(e, variable));
     }
     /**
      * Definite integral of `expr` over `[lower, upper]` with respect to
@@ -410,13 +416,13 @@ export class Symbolic {
      * @throws {IntegrationSingularityError} if an interior singularity is detected.
      */
     static integrateDefinite(expr, lower, upper, variable = "x", env = {}) {
-        const e = Symbolic.simplify(typeof expr === "string" ? Symbolic.parse(expr) : expr);
+        const e = simplifyCore(typeof expr === "string" ? Symbolic.parse(expr) : expr);
         const probe = compileExpr(e);
         if (hasInteriorSingularity((val) => probe({ ...env, [variable]: val }), lower, upper)) {
             throw new IntegrationSingularityError();
         }
         try {
-            const F = Symbolic.simplify(integ(e, variable));
+            const F = simplifyCore(integ(e, variable));
             const at = (val) => evalExpr(F, { ...env, [variable]: val });
             return at(upper) - at(lower);
         }
@@ -471,7 +477,7 @@ export class Symbolic {
      * @throws {NoClosedFormError} if a method matches but its required integral(s) aren't elementary.
      */
     static solveOdeClosedForm(dyDxExpr, x0, y0, xVar = "x", yVar = "y") {
-        const e = Symbolic.simplify(typeof dyDxExpr === "string" ? Symbolic.parse(dyDxExpr) : dyDxExpr);
+        const e = simplifyCore(typeof dyDxExpr === "string" ? Symbolic.parse(dyDxExpr) : dyDxExpr);
         const sep = matchSeparable(e, xVar, yVar);
         if (sep)
             return solveSeparableOde(sep, xVar, yVar, x0, y0);
@@ -580,20 +586,20 @@ export class Symbolic {
             }
             term = diff(term, variable);
         }
-        return Symbolic.simplify(result);
+        return simplifyCore(result);
     }
     /** Replace every occurrence of a variable with a sub-expression (e.g. for changing variables or plugging in a solved value). */
     static substitute(expr, variable, replacement) {
         const e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
         const r = typeof replacement === "string" ? Symbolic.parse(replacement) : replacement;
-        return Symbolic.simplify(subst(e, variable, r));
+        return simplifyCore(subst(e, variable, r));
     }
     /** Distribute multiplication over addition/subtraction and expand small integer powers of sums, e.g. `(x+1)^2 -> x^2+2*x+1`. */
     static expand(expr) {
         const e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
         let cur = e;
         for (let i = 0; i < 30; i++) {
-            const next = Symbolic.simplify(expandOnce(cur));
+            const next = simplifyCore(expandOnce(cur));
             if (equal(next, cur))
                 return next;
             cur = next;
@@ -694,12 +700,16 @@ export class Symbolic {
      * commands (`\sin`, `\arcsin`, `\sinh`, `\operatorname{sech}`, ...), and the
      * two-argument `BinaryFuncName` commands (`\min`, `\max`, `\gcd`,
      * `\operatorname{atan2}`, `\operatorname{hypot}`, `\operatorname{lcm}`).
-     * Spacing commands (`\,`, `\;`, `\!`, `\quad`) are ignored.
+     * Spacing commands (`\,`, `\;`, `\!`, `\quad`) are ignored. Single-token arguments as TeX
+     * reads them (`\frac12`, `\frac1x`, `\sqrt2`) and a power on a function command
+     * (`\sin^{2}(x)` is `sin(x)^2`) are accepted. An exponent of `-1` on a function command (`\sin^{-1}`) is
+     * refused as ambiguous (inverse function or reciprocal): write `\arcsin(x)` or `(\sin x)^{-1}`. For what people type into a math field
+     * (`2x`, `\sin 2x`, `(x+1)(x-1)`, `x^23`) pass `{ implicitMultiplication: true }`; see {@link ParseOptions}.
      *
      * @throws on LaTeX constructs with no `Expr` equivalent, e.g. `\int` or `\sum`.
      */
-    static fromLatex(latex) {
-        return Symbolic.parse(latexToInfix(latex));
+    static fromLatex(latex, options = {}) {
+        return Symbolic.parse(latexToInfix(latex, options), options);
     }
     /**
      * Solve `expr = 0` for `variable`, returning every *real* root @johnhenry/math
@@ -719,11 +729,11 @@ export class Symbolic {
      */
     static solve(expr, variable = "x") {
         const e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
-        const coeffs = polynomialCoeffs(Symbolic.simplify(e), variable, 6);
+        const coeffs = polynomialCoeffs(simplifyCore(e), variable, 6);
         if (!coeffs) {
             throw new Error(`solve: expression is not a polynomial in "${variable}" of degree ≤ 6.`);
         }
-        return solvePolynomial(coeffs).map((r) => Symbolic.simplify(r));
+        return solvePolynomial(coeffs).map((r) => simplifyCore(r));
     }
     /**
      * Solve a system of linear equations, each written in the same "expr
@@ -740,7 +750,7 @@ export class Symbolic {
      * @throws {SingularSystemError} if the coefficient matrix is singular/rank-deficient.
      */
     static solveSystem(equations, variables) {
-        const exprs = equations.map((eq) => Symbolic.simplify(typeof eq === "string" ? Symbolic.parse(eq) : eq));
+        const exprs = equations.map((eq) => simplifyCore(typeof eq === "string" ? Symbolic.parse(eq) : eq));
         if (exprs.length !== variables.length) {
             throw new Error(`solveSystem: expected ${variables.length} equations for ${variables.length} variables, got ${exprs.length}.`);
         }
@@ -948,7 +958,7 @@ export class Symbolic {
      */
     static factor(expr, variable = "x") {
         const e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
-        const simplified = Symbolic.simplify(e);
+        const simplified = simplifyCore(e);
         const coeffs = polynomialCoeffs(simplified, variable, 6);
         if (!coeffs)
             return simplified;
@@ -1132,6 +1142,17 @@ function diff(e, x) {
     }
 }
 // -- simplification ---------------------------------------------------------
+/** Constant folding and like-term collection to a fixed point -- no expansion or cancellation. */
+function simplifyCore(expr) {
+    let e = typeof expr === "string" ? Symbolic.parse(expr) : expr;
+    for (let i = 0; i < 30; i++) {
+        const next = collectLikeTerms(simplifyOnce(e));
+        if (equal(next, e))
+            return next;
+        e = next;
+    }
+    return e;
+}
 function simplifyOnce(e) {
     if (e.type === "const" || e.type === "var")
         return e;
@@ -1876,7 +1897,7 @@ function freshVariableName(e, x) {
  * legitimately hit a domain error/NaN on either side).
  */
 function verifyByDifferentiation(candidate, e, x) {
-    const check = Symbolic.simplify(diff(candidate, x));
+    const check = simplifyCore(diff(candidate, x));
     let agreements = 0;
     for (const p of [0.7, 1.3, -0.9]) {
         const expected = evalExpr(e, { [x]: p });
@@ -1902,10 +1923,10 @@ function verifyByDifferentiation(candidate, e, x) {
  */
 function tryUSubstitution(e, x) {
     for (const g of collectSubstitutionCandidates(e, x)) {
-        const gPrime = Symbolic.simplify(diff(g, x));
+        const gPrime = simplifyCore(diff(g, x));
         if (isConst(gPrime, 0))
             continue;
-        const quotient = Symbolic.simplify(divideOutFactors(e, gPrime) ?? div(e, gPrime));
+        const quotient = simplifyCore(divideOutFactors(e, gPrime) ?? div(e, gPrime));
         if (!containsExpr(quotient, g))
             continue;
         const uName = freshVariableName(quotient, x);
@@ -1914,7 +1935,7 @@ function tryUSubstitution(e, x) {
             continue;
         try {
             const antiderivativeInU = integRules(substituted, uName);
-            const candidate = Symbolic.simplify(substExpr(antiderivativeInU, v(uName), g));
+            const candidate = simplifyCore(substExpr(antiderivativeInU, v(uName), g));
             if (verifyByDifferentiation(candidate, e, x))
                 return candidate;
         }
@@ -2044,13 +2065,13 @@ function matchSeparable(e, xVar, yVar) {
 function matchLinearOde(e, xVar, yVar) {
     if (!containsVar(e, yVar))
         return null; // handled by matchSeparable's h(y)=1 case instead
-    const negP = Symbolic.simplify(diff(e, yVar));
+    const negP = simplifyCore(diff(e, yVar));
     if (containsVar(negP, yVar))
         return null; // not affine in y
-    const q = Symbolic.simplify(sub(e, mul(negP, v(yVar))));
+    const q = simplifyCore(sub(e, mul(negP, v(yVar))));
     if (containsVar(q, yVar))
         return null; // sanity check
-    const p = Symbolic.simplify(neg(negP));
+    const p = simplifyCore(neg(negP));
     // Conservative, matching matchSeparable's philosophy: p/q must depend on
     // no free variable other than xVar (an extra symbolic parameter, or a
     // stray reference to yVar that survived simplification, both bail out).
@@ -2105,12 +2126,12 @@ function tryInvertForY(H, yVar, rhs, y0) {
     return null;
 }
 function solveSeparableOde(sep, xVar, yVar, x0, y0) {
-    const invH = Symbolic.simplify(div(num(1), sep.h));
+    const invH = simplifyCore(div(num(1), sep.h));
     let H;
     let G;
     try {
-        H = Symbolic.simplify(integ(invH, yVar));
-        G = Symbolic.simplify(integ(sep.g, xVar));
+        H = simplifyCore(integ(invH, yVar));
+        G = simplifyCore(integ(sep.g, xVar));
     }
     catch (err) {
         if (err instanceof NotIntegrableError)
@@ -2118,20 +2139,20 @@ function solveSeparableOde(sep, xVar, yVar, x0, y0) {
         throw err;
     }
     const C = evalExpr(H, { [yVar]: y0 }) - evalExpr(G, { [xVar]: x0 });
-    const rhs = Symbolic.simplify(add(G, num(C)));
+    const rhs = simplifyCore(add(G, num(C)));
     const explicitY = tryInvertForY(H, yVar, rhs, y0);
     if (explicitY)
-        return { explicit: true, y: Symbolic.simplify(explicitY) };
-    return { explicit: false, implicitRelation: Symbolic.simplify(sub(H, rhs)) };
+        return { explicit: true, y: simplifyCore(explicitY) };
+    return { explicit: false, implicitRelation: simplifyCore(sub(H, rhs)) };
 }
 function solveLinearOde(lin, xVar, _yVar, x0, y0) {
     let integralP;
     let mu;
     let muQIntegral;
     try {
-        integralP = Symbolic.simplify(integ(lin.p, xVar));
-        mu = Symbolic.simplify(fn("exp", integralP));
-        muQIntegral = Symbolic.simplify(integ(Symbolic.simplify(mul(mu, lin.q)), xVar));
+        integralP = simplifyCore(integ(lin.p, xVar));
+        mu = simplifyCore(fn("exp", integralP));
+        muQIntegral = simplifyCore(integ(simplifyCore(mul(mu, lin.q)), xVar));
     }
     catch (err) {
         if (err instanceof NotIntegrableError)
@@ -2142,7 +2163,7 @@ function solveLinearOde(lin, xVar, _yVar, x0, y0) {
     const muAtX0 = evalExpr(mu, { [xVar]: x0 });
     const muQIntegralAtX0 = evalExpr(muQIntegral, { [xVar]: x0 });
     const C = y0 * muAtX0 - muQIntegralAtX0;
-    const y = Symbolic.simplify(div(add(muQIntegral, num(C)), mu));
+    const y = simplifyCore(div(add(muQIntegral, num(C)), mu));
     return { explicit: true, y };
 }
 /** A variable name distinct from every name in `avoid` and not free in `e`, for a temporary substitution variable (like {@link freshVariableName}, but avoiding a whole list of names rather than just one). */
@@ -2198,7 +2219,7 @@ function matchHomogeneous(e, xVar, yVar) {
     }
     if (attempts === 0 || agreements < 4)
         return null; // not enough usable probes to trust the match
-    const F = Symbolic.simplify(subst(substituted, xVar, num(1)));
+    const F = simplifyCore(subst(substituted, xVar, num(1)));
     return { vName, F };
 }
 /**
@@ -2223,15 +2244,15 @@ function matchHomogeneous(e, xVar, yVar) {
 function solveHomogeneousOde(hom, xVar, yVar, x0, y0) {
     const { vName, F } = hom;
     const v0 = y0 / x0;
-    const FMinusV = Symbolic.simplify(sub(F, v(vName)));
+    const FMinusV = simplifyCore(sub(F, v(vName)));
     if (FMinusV.type === "const" && FMinusV.value === 0) {
-        return { explicit: true, y: Symbolic.simplify(mul(num(v0), v(xVar))) };
+        return { explicit: true, y: simplifyCore(mul(num(v0), v(xVar))) };
     }
     const sepResult = solveSeparableOde({ g: div(num(1), v(xVar)), h: FMinusV }, xVar, vName, x0, v0);
     if (sepResult.explicit && sepResult.y) {
-        return { explicit: true, y: Symbolic.simplify(mul(sepResult.y, v(xVar))) };
+        return { explicit: true, y: simplifyCore(mul(sepResult.y, v(xVar))) };
     }
-    const implicitRelation = Symbolic.simplify(subst(sepResult.implicitRelation, vName, div(v(yVar), v(xVar))));
+    const implicitRelation = simplifyCore(subst(sepResult.implicitRelation, vName, div(v(yVar), v(xVar))));
     return { explicit: false, implicitRelation };
 }
 /**
@@ -2324,8 +2345,8 @@ function matchBernoulli(e, xVar, yVar) {
     }
     if (powMatch.n === 0)
         return null; // y^0=1: really just linear, matchLinearOde's job
-    const q = powSign === 1 ? powMatch.coef : Symbolic.simplify(neg(powMatch.coef));
-    const p = linSign === 1 ? Symbolic.simplify(neg(linMatch.coef)) : linMatch.coef;
+    const q = powSign === 1 ? powMatch.coef : simplifyCore(neg(powMatch.coef));
+    const p = linSign === 1 ? simplifyCore(neg(linMatch.coef)) : linMatch.coef;
     return { p, q, n: powMatch.n };
 }
 /**
@@ -2345,10 +2366,10 @@ function matchBernoulli(e, xVar, yVar) {
 function solveBernoulliOde(bern, xVar, yVar, x0, y0) {
     const oneMinusN = 1 - bern.n;
     const w0 = y0 ** oneMinusN;
-    const transformedP = Symbolic.simplify(mul(num(oneMinusN), bern.p));
-    const transformedQ = Symbolic.simplify(mul(num(oneMinusN), bern.q));
+    const transformedP = simplifyCore(mul(num(oneMinusN), bern.p));
+    const transformedQ = simplifyCore(mul(num(oneMinusN), bern.q));
     const wResult = solveLinearOde({ p: transformedP, q: transformedQ }, xVar, yVar, x0, w0);
-    const y = Symbolic.simplify(pow(wResult.y, num(1 / oneMinusN)));
+    const y = simplifyCore(pow(wResult.y, num(1 / oneMinusN)));
     return { explicit: true, y };
 }
 /**
@@ -2371,7 +2392,7 @@ function matchExact(e, xVar, yVar) {
     if (![...vars].every((n) => n === xVar || n === yVar))
         return null;
     const M = e.left;
-    const N = Symbolic.simplify(neg(e.right));
+    const N = simplifyCore(neg(e.right));
     const dMdy = diff(M, yVar);
     const dNdx = diff(N, xVar);
     let agreements = 0;
@@ -2421,8 +2442,8 @@ function solveExactOde(exact, xVar, yVar, x0, y0) {
     let g;
     let gPrime;
     try {
-        F0 = Symbolic.simplify(integ(M, xVar));
-        gPrime = Symbolic.simplify(sub(N, diff(F0, yVar)));
+        F0 = simplifyCore(integ(M, xVar));
+        gPrime = simplifyCore(sub(N, diff(F0, yVar)));
         if (containsVar(gPrime, xVar)) {
             // Symbolic cancellation fell short -- verify x-independence
             // numerically, then pin x to a probe value that evaluates finitely.
@@ -2435,21 +2456,21 @@ function solveExactOde(exact, xVar, yVar, x0, y0) {
                 if (Math.abs(atProbe - atOther) > 1e-6 * Math.max(1, Math.abs(atProbe))) {
                     throw new NoClosedFormError();
                 }
-                pinned = Symbolic.simplify(subst(gPrime, xVar, num(xp)));
+                pinned = simplifyCore(subst(gPrime, xVar, num(xp)));
                 break;
             }
             if (!pinned)
                 throw new NoClosedFormError();
             gPrime = pinned;
         }
-        g = Symbolic.simplify(integ(gPrime, yVar));
+        g = simplifyCore(integ(gPrime, yVar));
     }
     catch (err) {
         if (err instanceof NotIntegrableError)
             throw new NoClosedFormError();
         throw err;
     }
-    const F = Symbolic.simplify(add(F0, g));
+    const F = simplifyCore(add(F0, g));
     const C = evalExpr(F, { [xVar]: x0, [yVar]: y0 });
     if (!Number.isFinite(C))
         throw new NoClosedFormError();
@@ -2467,13 +2488,13 @@ function solveExactOde(exact, xVar, yVar, x0, y0) {
                 continue;
             if (F.type === "sub" && yPart === b)
                 continue; // F = G(x) - H(y): inverting -H is out of tryInvertForY's shapes
-            const rhs = Symbolic.simplify(sub(num(C), xPartSigned));
+            const rhs = simplifyCore(sub(num(C), xPartSigned));
             const explicitY = tryInvertForY(yPart, yVar, rhs, y0);
             if (explicitY)
-                return { explicit: true, y: Symbolic.simplify(explicitY) };
+                return { explicit: true, y: simplifyCore(explicitY) };
         }
     }
-    return { explicit: false, implicitRelation: Symbolic.simplify(sub(F, num(C))) };
+    return { explicit: false, implicitRelation: simplifyCore(sub(F, num(C))) };
 }
 /** If `e` is `a·x + b` (a, b constant), return `{ a, b }`, else `null`. */
 function linearCoeffs(e, x) {
@@ -3345,11 +3366,54 @@ const CMP_LATEX_CMDS = {
     "\\ne": "!=",
 };
 /** Convert a LaTeX math string into the plain-infix syntax `Symbolic.parse`'s `Parser` understands. */
-function latexToInfix(latex) {
-    const cleaned = latex.replace(/\\left|\\right/g, "").replace(/\\(?:,|;|!|quad|qquad| )/g, "");
-    return transformLatex(cleaned);
+function latexToInfix(latex, opts = {}) {
+    const cleaned = latex.replace(/\\left|\\right/g, "").replace(/(?<!\\)\\(?:,|;|!|quad|qquad| )/g, "");
+    return transformLatex(cleaned, opts);
+}
+/**
+ * Where the unbracketed argument of a function command ends under implicit multiplication: the longest
+ * product of numbers, letters, `\\pi`, powers, subscripts and bracket groups starting at `start`
+ * (`\\sin 2x` takes `2x`; `\\sin x\\cos x` takes just `x`). Returns `start` when there is none.
+ */
+function bareArgumentEnd(s, start) {
+    let j = start;
+    const group = (at) => {
+        const open = s[at];
+        return findGroupEnd(s, at, open, open === "{" ? "}" : ")") + 1;
+    };
+    while (j < s.length) {
+        const c = s[j];
+        if (/[A-Za-z0-9.]/.test(c)) {
+            j++;
+        }
+        else if (c === "(" || c === "{") {
+            j = group(j);
+        }
+        else if (c === "_" && s[j + 1] === "{") {
+            j = group(j + 1);
+        }
+        else if (c === "^") {
+            if (s[j + 1] === "{")
+                j = group(j + 1);
+            else if (s[j + 1] === "\\")
+                j += 1 + (/^\\[a-zA-Z]+/.exec(s.slice(j + 1))?.[0].length ?? 1);
+            else
+                j += 2;
+        }
+        else if (/^\\pi(?![a-zA-Z])/.test(s.slice(j))) {
+            j += 3;
+        }
+        else if (c === " " && /^ +(?:[A-Za-z0-9.({]|\\pi(?![a-zA-Z]))/.test(s.slice(j))) {
+            j += s.slice(j).length - s.slice(j).trimStart().length;
+        }
+        else {
+            break;
+        }
+    }
+    return j;
 }
-function transformLatex(s) {
+function transformLatex(s, opts = {}) {
+    const implicit = opts.implicitMultiplication === true;
     let out = "";
     let i = 0;
     const readGroup = () => {
@@ -3360,11 +3424,21 @@ function transformLatex(s) {
         return content;
     };
     const readGroupOrParenOrToken = () => {
+        while (s[i] === " ")
+            i++;
         if (s[i] === "{" || s[i] === "(") {
             const { content, next } = extractGroup(s, i);
             i = next;
             return content;
         }
+        if (implicit) {
+            const end = bareArgumentEnd(s, i);
+            if (end > i) {
+                const run = s.slice(i, end).trim();
+                i = end;
+                return run;
+            }
+        }
         const m = /^[a-zA-Z_]\w*|^\d+\.?\d*(?:[eE][+-]?\d+)?/.exec(s.slice(i));
         if (m) {
             i += m[0].length;
@@ -3372,6 +3446,32 @@ function transformLatex(s) {
         }
         throw new Error(`Expected an argument at position ${i} in LaTeX source: ${s}`);
     };
+    /** A `{...}` group, or the one token TeX takes without braces: a digit, a letter or a `\\command`. */
+    const readGroupOrToken = () => {
+        while (s[i] === " ")
+            i++;
+        if (s[i] === "{")
+            return readGroup();
+        const m = /^(?:\\[a-zA-Z]+|[a-zA-Z0-9])/.exec(s.slice(i));
+        if (!m)
+            throw new Error(`Expected an argument at position ${i} in LaTeX source: ${s}`);
+        i += m[0].length;
+        return m[0];
+    };
+    /** A power written on a function command (`\\sin^{2}`, `\\sin^2`), or null. */
+    const readFunctionPower = () => {
+        if (s[i] !== "^")
+            return null;
+        i++;
+        const power = readGroupOrToken();
+        // `\sin^{-1}` is arcsin in most textbooks and calculators but 1/sin in strict TeX/notation; guessing
+        // wrong would silently change the maths, so it is refused rather than interpreted.
+        if (/^\s*-\s*1\s*$/.test(power)) {
+            throw new Error("Ambiguous LaTeX: a function with exponent -1 (e.g. \\sin^{-1}) may mean the inverse function or the reciprocal; " +
+                "write \\arcsin(x) for the inverse, or (\\sin x)^{-1} / 1/\\sin x for the reciprocal");
+        }
+        return power;
+    };
     /** Read a `(...)`/`{...}` group holding exactly 2 comma-separated arguments, for `call2` functions. */
     const readArgPair = () => {
         if (s[i] !== "(" && s[i] !== "{")
@@ -3427,10 +3527,11 @@ function transformLatex(s) {
                     if (condPart.trim() === "\\text{otherwise}") {
                         if (otherwise !== null)
                             throw new Error("\\begin{cases} may have only one \\text{otherwise} row");
-                        otherwise = transformLatex(exprPart);
+                        otherwise = transformLatex(exprPart, opts);
                     }
                     else {
-                        parts.push(`${transformLatex(condPart)}, ${transformLatex(exprPart)}`);
+                        const condition = condPart.replace(/^\s*\\text\{\s*(?:if|when)\s*\}/, ""); // "x & \text{if } x<0" as MathLive writes it
+                        parts.push(`${transformLatex(condition, opts)}, ${transformLatex(exprPart, opts)}`);
                     }
                 }
                 if (otherwise === null) {
@@ -3439,29 +3540,29 @@ function transformLatex(s) {
                 out += `piecewise(${parts.concat(otherwise).join(", ")})`;
                 continue;
             }
-            if (cmd === "\\frac") {
-                const numerator = readGroup();
-                const denominator = readGroup();
-                out += `((${transformLatex(numerator)})/(${transformLatex(denominator)}))`;
+            if (cmd === "\\frac" || cmd === "\\dfrac" || cmd === "\\tfrac") {
+                const numerator = readGroupOrToken();
+                const denominator = readGroupOrToken();
+                out += `((${transformLatex(numerator, opts)})/(${transformLatex(denominator, opts)}))`;
                 continue;
             }
             if (cmd === "\\sqrt") {
                 if (s[i] === "[") {
                     const { content: root, next } = extractGroup(s, i);
                     i = next;
-                    const arg = readGroup();
-                    const transformedRoot = transformLatex(root).trim();
+                    const arg = readGroupOrToken();
+                    const transformedRoot = transformLatex(root, opts).trim();
                     // \sqrt[3]{...} maps to cbrt(...) rather than a fractional power so
                     // negative arguments evaluate correctly (Math.cbrt(-8) = -2, but
                     // (-8)^(1/3) is NaN under JS's `**`).
                     out +=
                         transformedRoot === "3"
-                            ? `cbrt(${transformLatex(arg)})`
-                            : `((${transformLatex(arg)})^(1/(${transformedRoot})))`;
+                            ? `cbrt(${transformLatex(arg, opts)})`
+                            : `((${transformLatex(arg, opts)})^(1/(${transformedRoot})))`;
                 }
                 else {
-                    const arg = readGroup();
-                    out += `sqrt(${transformLatex(arg)})`;
+                    const arg = readGroupOrToken();
+                    out += `sqrt(${transformLatex(arg, opts)})`;
                 }
                 continue;
             }
@@ -3475,8 +3576,10 @@ function transformLatex(s) {
                 if (base !== "10" && base !== "2") {
                     throw new Error(`Unsupported LaTeX construct: \\log base ${base} (only base 10 and base 2 are supported)`);
                 }
+                const power = readFunctionPower();
                 const arg = readGroupOrParenOrToken();
-                out += `${base === "2" ? "log2" : "log10"}(${transformLatex(arg)})`;
+                const call = `${base === "2" ? "log2" : "log10"}(${transformLatex(arg, opts)})`;
+                out += power === null ? call : `${call}^(${transformLatex(power, opts)})`;
                 continue;
             }
             if (cmd === "\\lfloor" || cmd === "\\lceil") {
@@ -3486,7 +3589,7 @@ function transformLatex(s) {
                     throw new Error(`Unmatched '${cmd}' in LaTeX source`);
                 const inner = s.slice(i, closeIdx);
                 i = closeIdx + closeCmd.length;
-                out += `${cmd === "\\lfloor" ? "floor" : "ceil"}(${transformLatex(inner)})`;
+                out += `${cmd === "\\lfloor" ? "floor" : "ceil"}(${transformLatex(inner, opts)})`;
                 continue;
             }
             if (cmd === "\\operatorname") {
@@ -3494,26 +3597,30 @@ function transformLatex(s) {
                 const binaryName = OPERATORNAME_BINARY_FUNC_NAMES[opName];
                 if (binaryName) {
                     const [left, right] = readArgPair();
-                    out += `${binaryName}(${transformLatex(left)}, ${transformLatex(right)})`;
+                    out += `${binaryName}(${transformLatex(left, opts)}, ${transformLatex(right, opts)})`;
                     continue;
                 }
                 const funcName = OPERATORNAME_FUNC_NAMES[opName];
                 if (!funcName)
                     throw new Error(`Unsupported LaTeX construct: \\operatorname{${opName}}`);
+                const power = readFunctionPower();
                 const arg = readGroupOrParenOrToken();
-                out += `${funcName}(${transformLatex(arg)})`;
+                const call = `${funcName}(${transformLatex(arg, opts)})`;
+                out += power === null ? call : `${call}^(${transformLatex(power, opts)})`;
                 continue;
             }
             const binaryFuncName = LATEX_BINARY_FUNC_NAMES[cmd];
             if (binaryFuncName) {
                 const [left, right] = readArgPair();
-                out += `${binaryFuncName}(${transformLatex(left)}, ${transformLatex(right)})`;
+                out += `${binaryFuncName}(${transformLatex(left, opts)}, ${transformLatex(right, opts)})`;
                 continue;
             }
             const funcName = LATEX_FUNC_NAMES[cmd];
             if (funcName) {
+                const power = readFunctionPower();
                 const arg = readGroupOrParenOrToken();
-                out += `${funcName}(${transformLatex(arg)})`;
+                const call = `${funcName}(${transformLatex(arg, opts)})`;
+                out += power === null ? call : `${call}^(${transformLatex(power, opts)})`;
                 continue;
             }
             throw new Error(`Unsupported LaTeX construct: ${cmd}`);
@@ -3524,13 +3631,20 @@ function transformLatex(s) {
                 throw new Error("Unmatched '|' in LaTeX source");
             const inner = s.slice(i + 1, closeIdx);
             i = closeIdx + 1;
-            out += `abs(${transformLatex(inner)})`;
+            out += `abs(${transformLatex(inner, opts)})`;
+            continue;
+        }
+        if (implicit && ch === "^" && /^[a-zA-Z0-9]|^\\[a-zA-Z]/.test(s.slice(i + 1))) {
+            // TeX reads `x^23` as `x^2` times `3`: the exponent is one token
+            const m = /^(?:\\[a-zA-Z]+|[a-zA-Z0-9])/.exec(s.slice(i + 1));
+            i += 1 + m[0].length;
+            out += `^(${transformLatex(m[0], opts)})`;
             continue;
         }
         if (ch === "^" && s[i + 1] === "{") {
             const { content, next } = extractGroup(s, i + 1);
             i = next;
-            out += `^(${transformLatex(content)})`;
+            out += `^(${transformLatex(content, opts)})`;
             continue;
         }
         if (ch === "_" && s[i + 1] === "{") {
@@ -3542,7 +3656,7 @@ function transformLatex(s) {
         if (ch === "{") {
             const { content, next } = extractGroup(s, i);
             i = next;
-            out += `(${transformLatex(content)})`;
+            out += `(${transformLatex(content, opts)})`;
             continue;
         }
         if (ch === "=") {
@@ -3558,6 +3672,378 @@ function transformLatex(s) {
     }
     return out;
 }
+const MAX_POLY_TERMS = 400;
+const MAX_RATIONAL_POWER = 8;
+class RatBail extends Error {
+}
+function atomIndex(ctx, e) {
+    const key = render(e, 0);
+    let i = ctx.keys.indexOf(key);
+    if (i < 0) {
+        i = ctx.keys.length;
+        ctx.keys.push(key);
+        ctx.atoms.push(e);
+    }
+    return i;
+}
+function expsCmp(a, b) {
+    const n = Math.max(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        const d = (a[i] ?? 0) - (b[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+function expsKey(a) {
+    let end = a.length;
+    while (end > 0 && !a[end - 1])
+        end--;
+    return a.slice(0, end).join(",");
+}
+function polyNormalize(terms) {
+    const byKey = new Map();
+    for (const t of terms) {
+        const k = expsKey(t.exps);
+        const prev = byKey.get(k);
+        if (prev)
+            byKey.set(k, { exps: prev.exps, c: prev.c.add(t.c) });
+        else
+            byKey.set(k, { exps: t.exps, c: t.c });
+    }
+    const out = [...byKey.values()].filter((t) => !t.c.isZero());
+    out.sort((a, b) => expsCmp(b.exps, a.exps));
+    if (out.length > MAX_POLY_TERMS)
+        throw new RatBail();
+    return out;
+}
+const polyConst = (c) => (c.isZero() ? [] : [{ exps: [], c }]);
+const polyAdd = (a, b) => polyNormalize([...a, ...b]);
+const polyNeg = (a) => a.map((t) => ({ exps: t.exps, c: t.c.negate() }));
+const polySub = (a, b) => polyAdd(a, polyNeg(b));
+function polyMul(a, b) {
+    if (a.length * b.length > MAX_POLY_TERMS * 20)
+        throw new RatBail();
+    const out = [];
+    for (const x of a) {
+        for (const y of b) {
+            const n = Math.max(x.exps.length, y.exps.length);
+            const exps = [];
+            for (let i = 0; i < n; i++)
+                exps.push((x.exps[i] ?? 0) + (y.exps[i] ?? 0));
+            out.push({ exps, c: x.c.multiply(y.c) });
+        }
+    }
+    return polyNormalize(out);
+}
+function polyEqual(a, b) {
+    return a.length === b.length && a.every((t, i) => expsKey(t.exps) === expsKey(b[i].exps) && t.c.equals(b[i].c));
+}
+const polyIsConst = (a) => a.length === 0 || (a.length === 1 && expsKey(a[0].exps) === "");
+/** Division in lex order: `a = q*b + r` (`b` must be nonzero). */
+function polyDivMod(a, b) {
+    const lead = b[0];
+    let rem = a;
+    const q = [];
+    const r = [];
+    let guard = 0;
+    while (rem.length > 0) {
+        if (++guard > 20_000)
+            throw new RatBail();
+        const t = rem[0];
+        const n = Math.max(t.exps.length, lead.exps.length);
+        const exps = [];
+        let divisible = true;
+        for (let i = 0; i < n; i++) {
+            const d = (t.exps[i] ?? 0) - (lead.exps[i] ?? 0);
+            if (d < 0)
+                divisible = false;
+            exps.push(d);
+        }
+        if (!divisible) {
+            r.push(t);
+            rem = rem.slice(1);
+            continue;
+        }
+        const qt = { exps, c: t.c.divide(lead.c) };
+        q.push(qt);
+        rem = polySub(rem, polyMul([qt], b));
+    }
+    return { q: polyNormalize(q), r: polyNormalize(r) };
+}
+function polyAtoms(...ps) {
+    const s = new Set();
+    for (const p of ps) {
+        for (const t of p) {
+            for (let i = 0; i < t.exps.length; i++)
+                if (t.exps[i] > 0)
+                    s.add(i);
+        }
+    }
+    return s;
+}
+/** Monic GCD of two polynomials in one atom (Euclid); 1 when several atoms are involved. */
+function polyGcd(a, b) {
+    if (polyAtoms(a, b).size > 1)
+        return polyConst(Rational.One);
+    let x = a;
+    let y = b;
+    while (y.length > 0) {
+        const { r } = polyDivMod(x, y);
+        x = y;
+        y = r;
+    }
+    if (x.length === 0)
+        return polyConst(Rational.One);
+    const lc = x[0].c;
+    return x.map((t) => ({ exps: t.exps, c: t.c.divide(lc) }));
+}
+/** The largest monomial dividing every term (exponent-wise minimum). */
+function monomialContent(p) {
+    if (p.length === 0)
+        return [];
+    const n = Math.max(...p.map((t) => t.exps.length));
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push(Math.min(...p.map((t) => t.exps[i] ?? 0)));
+    return out;
+}
+function polyDivMonomial(p, m) {
+    return p.map((t) => ({ exps: t.exps.map((e, i) => e - (m[i] ?? 0)), c: t.c }));
+}
+const ratioFromPoly = (n) => ({ n, d: polyConst(Rational.One) });
+function ratioAdd(a, b, subtract) {
+    const bn = subtract ? polyNeg(b.n) : b.n;
+    if (polyEqual(a.d, b.d))
+        return { n: polyAdd(a.n, bn), d: a.d };
+    return { n: polyAdd(polyMul(a.n, b.d), polyMul(bn, a.d)), d: polyMul(a.d, b.d) };
+}
+const ratioMul = (a, b) => ({ n: polyMul(a.n, b.n), d: polyMul(a.d, b.d) });
+function ratioDiv(a, b) {
+    if (b.n.length === 0)
+        throw new RatBail(); // division by zero: leave it to evaluation
+    return { n: polyMul(a.n, b.d), d: polyMul(a.d, b.n) };
+}
+function ratioPow(a, n) {
+    const k = Math.abs(n);
+    if (k > 1000)
+        throw new RatBail();
+    const singleTerm = a.n.length === 1 && a.d.length === 1;
+    if (!singleTerm && k > MAX_RATIONAL_POWER)
+        throw new RatBail();
+    let result;
+    if (singleTerm) {
+        const mono = (t) => ({ exps: t.exps.map((e) => e * k), c: t.c.pow(k) });
+        result = { n: [mono(a.n[0])], d: [mono(a.d[0])] };
+    }
+    else {
+        result = ratioFromPoly(polyConst(Rational.One));
+        for (let i = 0; i < k; i++)
+            result = ratioMul(result, a);
+    }
+    return n < 0 ? ratioDiv(ratioFromPoly(polyConst(Rational.One)), result) : result;
+}
+function exactRational(value) {
+    if (!Number.isFinite(value))
+        return null;
+    if (Number.isInteger(value))
+        return new Rational(BigInt(value));
+    const r = Rational.fromNumber(value, 10_000);
+    return r.toNumber() === value ? r : null;
+}
+function toRatio(e, ctx) {
+    const atom = (x) => {
+        const i = atomIndex(ctx, x);
+        const exps = new Array(i + 1).fill(0);
+        exps[i] = 1;
+        return ratioFromPoly([{ exps, c: Rational.One }]);
+    };
+    switch (e.type) {
+        case "const": {
+            const r = exactRational(e.value);
+            return r ? ratioFromPoly(polyConst(r)) : atom(e);
+        }
+        case "var":
+            return atom(e);
+        case "neg": {
+            const a = toRatio(e.arg, ctx);
+            return { n: polyNeg(a.n), d: a.d };
+        }
+        case "add":
+            return ratioAdd(toRatio(e.left, ctx), toRatio(e.right, ctx), false);
+        case "sub":
+            return ratioAdd(toRatio(e.left, ctx), toRatio(e.right, ctx), true);
+        case "mul":
+            return ratioMul(toRatio(e.left, ctx), toRatio(e.right, ctx));
+        case "div":
+            return ratioDiv(toRatio(e.left, ctx), toRatio(e.right, ctx));
+        case "pow": {
+            if (e.exp.type === "const" && Number.isInteger(e.exp.value)) {
+                return ratioPow(toRatio(e.base, ctx), e.exp.value);
+            }
+            return atom(pow(normalizeRational(e.base), normalizeRational(e.exp)));
+        }
+        case "func":
+            return atom(fn(e.name, normalizeRational(e.arg)));
+        case "call2":
+            return atom(call2(e.name, normalizeRational(e.left), normalizeRational(e.right)));
+        case "cmp":
+            return atom(cmp(e.op, normalizeRational(e.left), normalizeRational(e.right)));
+        case "piecewise":
+            return atom(piecewise(e.branches.map((br) => ({ cond: normalizeRational(br.cond), expr: normalizeRational(br.expr) })), normalizeRational(e.otherwise)));
+        case "sum":
+            return atom(sumExpr(e.variable, normalizeRational(e.from), normalizeRational(e.to), normalizeRational(e.body)));
+        case "product":
+            return atom(productExpr(e.variable, normalizeRational(e.from), normalizeRational(e.to), normalizeRational(e.body)));
+    }
+}
+function bigGcd(a, b) {
+    let x = a < 0n ? -a : a;
+    let y = b < 0n ? -b : b;
+    while (y)
+        [x, y] = [y, x % y];
+    return x;
+}
+/** Cancel common factors, then scale to coprime integer coefficients with a positive denominator lead. */
+function ratioReduce(r) {
+    if (r.n.length === 0)
+        return ratioFromPoly([]);
+    let { n, d } = r;
+    const m = monomialContent([...n, ...d]);
+    if (m.some((e) => e > 0)) {
+        n = polyDivMonomial(n, m);
+        d = polyDivMonomial(d, m);
+    }
+    if (!polyIsConst(d)) {
+        const g = polyGcd(n, d);
+        if (!polyIsConst(g)) {
+            n = polyDivMod(n, g).q;
+            d = polyDivMod(d, g).q;
+        }
+        else {
+            // Several atoms: still cancel when one side divides the other exactly.
+            const dn = polyDivMod(n, d);
+            if (dn.r.length === 0) {
+                n = dn.q;
+                d = polyConst(Rational.One);
+            }
+            else {
+                const nd = polyDivMod(d, n);
+                if (nd.r.length === 0) {
+                    d = nd.q;
+                    n = polyConst(Rational.One);
+                }
+            }
+        }
+    }
+    if (polyIsConst(d)) {
+        const c = d[0].c;
+        return { n: n.map((t) => ({ exps: t.exps, c: t.c.divide(c) })), d: polyConst(Rational.One) };
+    }
+    // integer coefficients: multiply through by the lcm of the denominators, divide by the content
+    let lcm = 1n;
+    for (const t of [...n, ...d]) {
+        const den = t.c.denominator;
+        lcm = (lcm / bigGcd(lcm, den)) * den;
+    }
+    const scale = new Rational(lcm);
+    n = n.map((t) => ({ exps: t.exps, c: t.c.multiply(scale) }));
+    d = d.map((t) => ({ exps: t.exps, c: t.c.multiply(scale) }));
+    let content = 0n;
+    for (const t of [...n, ...d])
+        content = bigGcd(content, t.c.numerator);
+    if (content > 1n) {
+        const inv = new Rational(1n, content);
+        n = n.map((t) => ({ exps: t.exps, c: t.c.multiply(inv) }));
+        d = d.map((t) => ({ exps: t.exps, c: t.c.multiply(inv) }));
+    }
+    if (d[0].c.sign < 0) {
+        n = polyNeg(n);
+        d = polyNeg(d);
+    }
+    return { n, d };
+}
+function monomialExpr(exps, ctx) {
+    let out = null;
+    for (let i = 0; i < exps.length; i++) {
+        const e = exps[i] ?? 0;
+        if (e === 0)
+            continue;
+        const factor = e === 1 ? ctx.atoms[i] : pow(ctx.atoms[i], num(e));
+        out = out ? mul(out, factor) : factor;
+    }
+    return out;
+}
+/** A polynomial as a descending-degree sum; fractional coefficients print as `p*m/q`. */
+function polyToTree(p, ctx) {
+    if (p.length === 0)
+        return num(0);
+    const ordered = [...p].sort((a, b) => {
+        const da = a.exps.reduce((s, x) => s + x, 0);
+        const db = b.exps.reduce((s, x) => s + x, 0);
+        return db - da || expsCmp(b.exps, a.exps);
+    });
+    let out = null;
+    for (const t of ordered) {
+        const negative = t.c.sign < 0;
+        const abs = t.c.abs();
+        const mono = monomialExpr(t.exps, ctx);
+        const numer = abs.numerator;
+        let body;
+        if (!mono)
+            body = num(abs.toNumber());
+        else if (numer === 1n && abs.denominator === 1n)
+            body = mono;
+        else if (abs.denominator === 1n)
+            body = mul(num(Number(numer)), mono);
+        else
+            body = div(numer === 1n ? mono : mul(num(Number(numer)), mono), num(Number(abs.denominator)));
+        if (!out)
+            out = negative ? neg(body) : body;
+        else
+            out = negative ? sub(out, body) : add(out, body);
+    }
+    return out;
+}
+function nodeCount(e) {
+    switch (e.type) {
+        case "const":
+        case "var":
+            return 1;
+        case "neg":
+        case "func":
+            return 1 + nodeCount(e.arg);
+        case "pow":
+            return 1 + nodeCount(e.base) + nodeCount(e.exp);
+        case "piecewise":
+            return 1 + nodeCount(e.otherwise) + e.branches.reduce((s, br) => s + nodeCount(br.cond) + nodeCount(br.expr), 0);
+        case "sum":
+        case "product":
+            return 1 + nodeCount(e.from) + nodeCount(e.to) + nodeCount(e.body);
+        default:
+            return 1 + nodeCount(e.left) + nodeCount(e.right);
+    }
+}
+/**
+ * Expand `e` as a rational function and cancel common factors, returning the result only
+ * when it has strictly fewer nodes than `e`; otherwise returns `e` itself.
+ */
+function normalizeRational(e) {
+    if (e.type === "const" || e.type === "var")
+        return e;
+    try {
+        const ctx = { atoms: [], keys: [] };
+        const reduced = ratioReduce(toRatio(e, ctx));
+        const numer = polyToTree(reduced.n, ctx);
+        const candidate = polyIsConst(reduced.d) ? numer : div(numer, polyToTree(reduced.d, ctx));
+        return nodeCount(candidate) < nodeCount(e) ? candidate : e;
+    }
+    catch (err) {
+        if (err instanceof RatBail)
+            return e;
+        throw err;
+    }
+}
 // -- equation solving & factoring ----------------------------------------------
 /** Best-effort exact `Expr` for a numeric value: an integer, a reduced fraction, or (as a last resort) the raw float. */
 function toExactExpr(value) {
@@ -3591,7 +4077,7 @@ function linearCoeffsForSystem(eq, variables) {
         return null;
     const coeffs = [];
     for (const name of variables) {
-        const derivative = Symbolic.simplify(diff(eq, name));
+        const derivative = simplifyCore(diff(eq, name));
         if (variables.some((other) => containsVar(derivative, other)))
             return null;
         const coeff = evalExpr(derivative, zeroEnv);
@@ -3623,7 +4109,7 @@ function polynomialCoeffs(expr, variable, maxDegree) {
         // derivative of x^0 (`0·x^-1`) evaluates to `0·Infinity = NaN` at x=0
         // even though it is symbolically zero — simplifying collapses `0·anything`
         // to `0` before that indeterminate form can arise.
-        term = Symbolic.simplify(diff(term, variable));
+        term = simplifyCore(diff(term, variable));
     }
     while (coeffs.length > 1 && Math.abs(coeffs[coeffs.length - 1]) < 1e-9)
         coeffs.pop();
@@ -3818,7 +4304,7 @@ function factorPolynomial(coeffsIn, variable) {
     else if (Math.abs(remaining[0] - 1) > 1e-9) {
         result = mul(result, toExactExpr(remaining[0]));
     }
-    return Symbolic.simplify(result);
+    return simplifyCore(result);
 }
 // -- limits ---------------------------------------------------------------------
 function evalNear(e, x, point, direction) {
@@ -3842,19 +4328,25 @@ function limitAt(e, x, point, direction, depth) {
             // operand verbatim into the result) and a limit needing more than a
             // couple of rounds (e.g. most limits at infinity) blows up memory
             // long before the depth<12 cap is reached.
-            const df = Symbolic.simplify(diff(e.left, x));
-            const dg = Symbolic.simplify(diff(e.right, x));
+            const df = simplifyCore(diff(e.left, x));
+            const dg = simplifyCore(diff(e.right, x));
             return limitAt(div(df, dg), x, point, direction, depth + 1);
         }
     }
     return direct;
 }
 // -- recursive-descent parser ----------------------------------------------
+/** Every name the parser treats as a function, longest first, so `asinh(` is not read as `a*sinh(`. */
+const FUNCTION_NAMES_LONGEST_FIRST = [...FUNCTION_NAMES].sort((a, b) => b.length - a.length);
 class Parser {
     s;
+    implicit;
     pos = 0;
-    constructor(input) {
-        this.s = input.replace(/\s+/g, "");
+    constructor(input, options = {}) {
+        this.implicit = options.implicitMultiplication === true;
+        // With implicit multiplication, white space between two numbers is a product (`2 3`), not one number.
+        const spaced = this.implicit ? input.replace(/(\d)\s+(?=[\d.])/g, "$1*") : input;
+        this.s = spaced.replace(/\s+/g, "");
     }
     parse() {
         const e = this.comparison();
@@ -3973,12 +4465,38 @@ class Parser {
     }
     term() {
         let left = this.factor();
-        while (this.peek() === "*" || this.peek() === "/") {
-            const op = this.s[this.pos++];
-            const right = this.factor();
-            left = op === "*" ? mul(left, right) : div(left, right);
+        for (;;) {
+            const ch = this.peek();
+            if (ch === "*" || ch === "/") {
+                this.pos++;
+                const right = this.factor();
+                left = ch === "*" ? mul(left, right) : div(left, right);
+            }
+            else if (this.implicit && /[a-zA-Z0-9.(]/.test(ch)) {
+                left = mul(left, this.factor()); // juxtaposition: `2x`, `x y`, `2(x+1)`
+            }
+            else {
+                return left;
+            }
         }
-        return left;
+    }
+    /**
+     * The identifier at `this.pos` under implicit multiplication: a function name followed by `(`, `pi`, or a
+     * single letter with an optional `_subscript`. A letter run like `xy` is therefore read one letter at a time.
+     */
+    implicitIdentifier() {
+        const rest = this.s.slice(this.pos);
+        const run = /^[a-zA-Z]+/.exec(rest)?.[0] ?? "";
+        const call = FUNCTION_NAMES_LONGEST_FIRST.find((f) => rest.startsWith(f) && rest[f.length] === "(");
+        if (call)
+            return call;
+        const bare = FUNCTION_NAMES_LONGEST_FIRST.find((f) => f.length > 1 && run.startsWith(f));
+        if (bare)
+            throw new Error(`Function ${bare} needs parentheses: ${bare}(...)`);
+        if (rest.startsWith("pi"))
+            return "pi";
+        const sub = /^[a-zA-Z]_(?:\d+|[a-zA-Z])/.exec(rest);
+        return sub ? sub[0] : rest[0];
     }
     factor() {
         if (this.peek() === "-") {
@@ -4016,9 +4534,11 @@ class Parser {
             return num(Number(numMatch[0]));
         }
         // identifier (function or variable or constant)
-        const idMatch = /^[a-zA-Z_]\w*/.exec(this.s.slice(this.pos));
+        const idMatch = this.implicit
+            ? /^[a-zA-Z_]/.exec(this.s.slice(this.pos))
+            : /^[a-zA-Z_]\w*/.exec(this.s.slice(this.pos));
         if (idMatch) {
-            const name = idMatch[0];
+            const name = this.implicit ? this.implicitIdentifier() : idMatch[0];
             this.pos += name.length;
             if ((name === "log" || name === "clamp") && this.peek() === "(") {
                 this.pos++;