@classytic/stage 0.3.0 → 0.4.0

package/dist/math/calculus.mjs

@@ -106,14 +106,25 @@ function freeVarsHas(node, x) {
 * `differentiate` rather than matching `a*x+b` by shape means `(3-2x)^5` and `(-2x+3)^5` and
 * `3-2*x` all work without three separate matchers.
 */
+/**
+* The `a` in `u = ax + b`, as a NODE, or null when `u` is not linear in `x`.
+*
+* It used to demand a numeric `a`, which made `sin(2x)` integrable and `sin(ωt)` not. That is the
+* wrong line to draw for physics: a coefficient that is a symbol is still a constant with respect
+* to the integration variable, and `exp(-λt)`, `sin(ωt)` and `cos(kx)` are the shape of half the
+* integrals in waves, decay and alternating current. The test is "does d/dx vanish under further
+* differentiation", not "is it a literal number".
+*/
 function linearFactor(u, x) {
 	const d = differentiate(u, x);
 	if (!d) return null;
 	const s = simplify(d);
-	return s.type === "num" && s.value !== 0 ? s.value : null;
+	if (freeVarsHas(s, x)) return null;
+	if (s.type === "num" && s.value === 0) return null;
+	return s;
 }
-/** Divide by a constant, without emitting the noise of `expr / 1`. */
-const overConst = (node, a) => a === 1 ? node : div(node, num(a));
+/** Divide by the linear coefficient, without emitting the noise of `expr / 1`. */
+const overConst = (node, a) => a.type === "num" && a.value === 1 ? node : div(node, a);
 /**
 * Exact symbolic antiderivative with respect to `x`, or `null` when this engine cannot do it.
 *
@@ -121,12 +132,208 @@ const overConst = (node, a) => a === 1 ? node : div(node, num(a));
 * commonly dropped mark in the topic, so it belongs in the lesson's own working where a learner
 * has to write it, not silently bolted on by the engine.
 *
-* Covers the Cambridge P1/P3 toolkit: linearity, the power rule including the `1/x → ln|x|`
-* exception, and any of the above composed with a LINEAR inner function. Returns null for
-* integration by parts, by non-linear substitution, and partial fractions, so a caller can fall
-* back to the numerical `integrate` in `core/numeric` and show area rather than a wrong formula.
+* Covers: linearity, the power rule including the `1/x → ln|x|` exception, any of those composed
+* with a linear inner function whose coefficient may be a SYMBOL (`sin(ωt)`, `e^{-λt}`), and any
+* polynomial that becomes one of the above after being multiplied out.
+*
+* Returns null for integration by parts (`x·eˣ`), non-linear substitution (`√(1−x²)`, `x/(1+x²)`)
+* and trigonometric powers (`sin²x`). A caller that must produce a number regardless should fall
+* back to `quadrature` in `analysis.ts` and say that it did, rather than show a wrong formula.
+* `physics/integral-sweep` is the worked example of that pattern.
+*/
+/**
+* Squares and cubes of the trigonometric functions.
+*
+* These are not power-rule cases and they are not substitutions either. Each is a standard identity
+* that turns the power into something already integrable:
+*
+*     ∫sin²u du = u/2 − sin 2u / 4          the double-angle identity, cos 2u = 1 − 2sin²u
+*     ∫cos²u du = u/2 + sin 2u / 4
+*     ∫sin³u du = −cos u + cos³u / 3        writing sin³ as sin·(1 − cos²) and substituting
+*     ∫cos³u du =  sin u − sin³u / 3
+*     ∫tan²u du =  tan u − u                from sec² = 1 + tan²
+*
+* WHY THESE FIVE AND NOT A GENERAL REDUCTION FORMULA. Squares are the ones that actually turn up:
+* mean power in an alternating circuit is `∫sin²`, a spherical shell parameterised by angle is
+* `∫sin³`, and between them they cover the syllabus. A general `sin^n` reduction is a much larger
+* commitment for cases nobody sets, and returning null for `sin⁴` is honest.
+*
+* The inner function may be linear with a symbolic coefficient, so `sin²(ωt)` works, which is the
+* form every alternating-current question is actually written in.
+*/
+function integrateTrigPower(base, n, x) {
+	if (base.type !== "call" || base.args.length !== 1) return null;
+	const u = base.args[0];
+	if (!u) return null;
+	const a = linearFactor(u, x);
+	if (a === null) return null;
+	const sin = (arg) => call("sin", arg);
+	const cos = (arg) => call("cos", arg);
+	if (n === 2) {
+		if (base.fn === "sin") return overConst(sub(div(u, num(2)), div(sin(mul(num(2), u)), num(4))), a);
+		if (base.fn === "cos") return overConst(add(div(u, num(2)), div(sin(mul(num(2), u)), num(4))), a);
+		if (base.fn === "tan") return overConst(sub(call("tan", u), u), a);
+		return null;
+	}
+	if (n === 3) {
+		if (base.fn === "sin") return overConst(add(neg(cos(u)), div(pow(cos(u), num(3)), num(3))), a);
+		if (base.fn === "cos") return overConst(sub(sin(u), div(pow(sin(u), num(3)), num(3))), a);
+		return null;
+	}
+	return null;
+}
+/** How far `expand` will raise a sum before giving up. 8 covers anything at this level. */
+const MAX_EXPAND_POWER = 8;
+/**
+* Multiply out products and integer powers of sums: `(R² − x²)²` becomes `R⁴ − 2R²x² + x⁴`.
+*
+* This exists because of a sharp edge in the integrator. It handles a sum term by term and a power
+* of a LINEAR inner function, so `R⁴ − 2R²x² + x⁴` integrates and the identical `(R² − x²)²` does
+* not. A student writing the moment of inertia of a sphere writes the second form, and being told
+* it is not integrable while its expansion is would be indefensible.
+*
+* Not a general simplifier and not a normal form: it distributes and it raises, and it leaves
+* everything else alone. `simplify` is still what tidies the result.
+*/
+function expand(node) {
+	switch (node.type) {
+		case "neg": return neg(expand(node.arg));
+		case "call": return call(node.fn, ...node.args.map(expand));
+		case "binary": {
+			const left = expand(node.left);
+			const right = expand(node.right);
+			switch (node.op) {
+				case "+": return add(left, right);
+				case "-": return sub(left, right);
+				case "*": return distribute(left, right);
+				case "/": return isSum(left) ? expand(distributeOverSum(left, (t) => div(t, right))) : div(left, right);
+				case "^": {
+					const exponent = simplify(right);
+					if (!isSum(left) || exponent.type !== "num") return pow(left, right);
+					const n = exponent.value;
+					if (!Number.isInteger(n) || n < 2 || n > MAX_EXPAND_POWER) return pow(left, right);
+					let out = left;
+					for (let i = 1; i < n; i++) out = distribute(out, left);
+					return out;
+				}
+				default: return {
+					...node,
+					left,
+					right
+				};
+			}
+		}
+		default: return node;
+	}
+}
+const isSum = (node) => node.type === "binary" && (node.op === "+" || node.op === "-");
+/** Apply `f` to each term of a sum, preserving the signs. */
+function distributeOverSum(sum, f) {
+	if (sum.type === "binary" && sum.op === "+") return add(distributeOverSum(sum.left, f), distributeOverSum(sum.right, f));
+	if (sum.type === "binary" && sum.op === "-") return sub(distributeOverSum(sum.left, f), distributeOverSum(sum.right, f));
+	return f(sum);
+}
+/** `(a + b)(c + d)` term by term, in whichever direction has a sum. */
+function distribute(left, right) {
+	if (isSum(left)) return distributeOverSum(left, (term) => distribute(term, right));
+	if (isSum(right)) return distributeOverSum(right, (term) => distribute(left, term));
+	return mul(left, right);
+}
+/**
+* A structural key for a node, so two occurrences of the same factor can be recognised.
+*
+* Deliberately crude and deliberately not a canonical form: `x*y` and `y*x` get different keys, so
+* they are not merged. Merging them would need an ordering over expressions, which is a much larger
+* commitment than this needs. Failing to merge costs nothing except a missed simplification.
+*/
+function key(node) {
+	switch (node.type) {
+		case "num": return `#${node.value}`;
+		case "var": return `$${node.name}`;
+		case "neg": return `-(${key(node.arg)})`;
+		case "binary": return `(${key(node.left)}${node.op}${key(node.right)})`;
+		case "call": return `${node.fn}(${node.args.map(key).join(",")})`;
+		default: return "?";
+	}
+}
+/**
+* Gather repeated factors into powers: `x·x` becomes `x²`, and `(x+1)/x` becomes `1 + x⁻¹`.
+*
+* Without this, `expand` is almost useless to the integrator. `∫x(x+1)dx` expands to `∫(x·x + x)dx`
+* and the power rule reads `^`, not repeated multiplication, so it would still refuse. Division is
+* folded in as a negative exponent, which is also what lets the `1/x → ln|x|` rule be reached
+* through a quotient that was written as a fraction of sums.
+*/
+function collect(node) {
+	const factors = [];
+	let numeric = 1;
+	let ok = true;
+	const gather = (n, sign) => {
+		if (!ok) return;
+		if (n.type === "binary" && n.op === "*") {
+			gather(n.left, sign);
+			gather(n.right, sign);
+			return;
+		}
+		if (n.type === "binary" && n.op === "/") {
+			gather(n.left, sign);
+			gather(n.right, sign === 1 ? -1 : 1);
+			return;
+		}
+		let base = n;
+		let exponent = 1;
+		if (n.type === "binary" && n.op === "^") {
+			const e = simplify(n.right);
+			if (e.type === "num" && Number.isFinite(e.value)) {
+				base = n.left;
+				exponent = e.value;
+			}
+		}
+		if (base.type === "num") {
+			if (exponent !== 1 && !Number.isInteger(exponent)) ok = false;
+			numeric *= Math.pow(base.value, sign * exponent);
+			return;
+		}
+		const k = key(base);
+		const found = factors.find((f) => key(f.base) === k);
+		if (found) found.exponent += sign * exponent;
+		else factors.push({
+			base,
+			exponent: sign * exponent
+		});
+	};
+	gather(node, 1);
+	if (!ok) return node;
+	const parts = [];
+	for (const { base, exponent } of factors) {
+		if (exponent === 0) continue;
+		parts.push(exponent === 1 ? base : pow(base, num(exponent)));
+	}
+	if (numeric !== 1 || parts.length === 0) parts.unshift(num(numeric));
+	return parts.reduce((a, b) => mul(a, b));
+}
+/** Run `collect` over every product in a sum, leaving the sum's shape alone. */
+function collectAll(node) {
+	if (node.type === "binary" && (node.op === "+" || node.op === "-")) {
+		const left = collectAll(node.left);
+		const right = collectAll(node.right);
+		return node.op === "+" ? add(left, right) : sub(left, right);
+	}
+	if (node.type === "neg") return neg(collectAll(node.arg));
+	if (node.type === "binary" && (node.op === "*" || node.op === "/")) return collect(node);
+	return node;
+}
+/**
+* Exact symbolic antiderivative, trying the expression as written and then multiplied out.
+*
+* The second attempt is what makes `∫x(x+1)dx` and `∫(R²−x²)²dx` work: expand distributes, collect
+* turns the resulting repeated factors back into powers, and then the ordinary power rule applies
+* term by term. A single retry, because both passes are idempotent on their own output.
 */
 function integrate(node, x) {
+	return integrateDirect(node, x) ?? integrateDirect(collectAll(expand(node)), x);
+}
+function integrateDirect(node, x) {
 	if (isConstantIn(node, x)) return mul(node, variable(x));
 	switch (node.type) {
 		case "var": return div(pow(variable(x), num(2)), num(2));
@@ -167,6 +374,8 @@ function integrate(node, x) {
 				const exponent = simplify(right);
 				if (exponent.type !== "num") return null;
 				const n = exponent.value;
+				const trig = integrateTrigPower(left, n, x);
+				if (trig) return trig;
 				const a = linearFactor(left, x);
 				if (a === null) return null;
 				if (n === -1) return overConst(call("ln", call("abs", left)), a);

package/dist/math/complex.d.mts

@@ -0,0 +1,93 @@
+declare namespace complex_d_exports {
+  export { Complex, DEG2RAD, I, MAX_POW, MAX_ROOTS, ONE, RAD2DEG, TWO_PI, ZERO, abs, add, arg, argDeg, conj, cx, div, eq, fromPolar, iPow, isFiniteC, mul, neg, nthRoots, omega, powInt, rootsOfUnity, scale, sub, toPolar, toStr, toTex };
+}
+/**
+ * Complex-number kernel, the pure engine every complex/Argand/polar lab computes
+ * against (so a lab — or an agent — never hand-rolls a²+b² or atan2). A complex
+ * number is rectangular `{ re, im }`; the polar view (modulus r, argument θ) is
+ * derived, exactly the (x, y) ↔ (r, θ) bridge the vector labs already teach.
+ *
+ * Engineered for CORRECTNESS + SAFETY (no NaN spirals, no overflow, no runaway
+ * loops):
+ *   • modulus uses Math.hypot (no re²+im² overflow);
+ *   • division uses Smith's algorithm (scale by the larger term, avoids overflow
+ *     / underflow), with a near-zero-denominator guard;
+ *   • integer powers use exponentiation-by-squaring, |n| capped (MAX_POW), with a
+ *     finiteness guard so r^n that overflows returns an explicit ∞, not garbage;
+ *   • iⁿ is computed EXACTLY from n mod 4 (no float drift in the i, −1, −i, 1 cycle);
+ *   • rootsOfUnity / nthRoots cap n (MAX_ROOTS) so an author can't request a
+ *     billion-element array.
+ */
+interface Complex {
+  re: number;
+  im: number;
+}
+declare const TWO_PI: number;
+declare const RAD2DEG: number;
+declare const DEG2RAD: number;
+/** Hard caps so an authored value can never blow memory or hang a loop. */
+declare const MAX_POW = 1024;
+declare const MAX_ROOTS = 360;
+declare const cx: (re: number, im?: number) => Complex;
+declare const ZERO: Complex;
+declare const ONE: Complex;
+declare const I: Complex;
+declare const isFiniteC: (z: Complex) => boolean;
+declare const add: (a: Complex, b: Complex) => Complex;
+declare const sub: (a: Complex, b: Complex) => Complex;
+declare const neg: (a: Complex) => Complex;
+declare const conj: (a: Complex) => Complex;
+declare const scale: (a: Complex, k: number) => Complex;
+/** (a+bi)(c+di) = (ac − bd) + (ad + bc)i. */
+declare const mul: (a: Complex, b: Complex) => Complex;
+/**
+ * Complex division via Smith's algorithm: divide through by the LARGER of the
+ * denominator's components so the intermediate ratio stays in [−1, 1] (no
+ * overflow when |b| is huge, no underflow when tiny). Returns an ∞/NaN complex
+ * for a (near-)zero denominator rather than throwing.
+ */
+declare function div(a: Complex, b: Complex): Complex;
+/** Modulus |z| = √(re² + im²), via hypot so large components don't overflow. */
+declare const abs: (z: Complex) => number;
+/** Argument arg(z) in RADIANS, in (−π, π]. arg(0) = 0 by convention. */
+declare const arg: (z: Complex) => number;
+/** Argument in DEGREES, in (−180, 180]. */
+declare const argDeg: (z: Complex) => number;
+/** Polar → rectangular: r·e^{iθ} = r(cosθ + i sinθ), θ in radians. */
+declare const fromPolar: (r: number, theta: number) => Complex;
+/** Rectangular → polar { r, theta(rad) }. */
+declare const toPolar: (z: Complex) => {
+  r: number;
+  theta: number;
+};
+/**
+ * iⁿ for any integer n, EXACTLY (no De Moivre float drift): the 4-cycle
+ * 1, i, −1, −i. Negative n handled by the (n mod 4 + 4) mod 4 normalisation.
+ */
+declare function iPow(n: number): Complex;
+/**
+ * zⁿ for an INTEGER n via exponentiation-by-squaring (negative n inverts).
+ * |n| is capped at MAX_POW; an overflowing magnitude returns an explicit ∞
+ * complex (finite check) instead of looping into garbage.
+ */
+declare function powInt(z: Complex, n: number): Complex;
+/**
+ * The n nth-roots of UNITY: e^{2πik/n}, k = 0…n−1 (so ω = roots[1] is the
+ * primitive root). For n = 2 → {1, −1}; n = 3 → {1, ω, ω²}; n = 4 → {1, i, −1, −i}.
+ * n is clamped to [1, MAX_ROOTS]. The k = n/2 (real −1) and k = 0 (real 1) entries
+ * are snapped to exact values so labels read cleanly.
+ */
+declare function rootsOfUnity(n: number): Complex[];
+/** The n nth-roots of any z: |z|^{1/n} · e^{i(arg z + 2πk)/n}, k = 0…n−1. */
+declare function nthRoots(z: Complex, n: number): Complex[];
+/** The primitive nth root of unity ω (default the CUBE root, n = 3): e^{2πi/n}.
+ *  For n = 3: ω = −½ + (√3/2)i, with ω³ = 1 and 1 + ω + ω² = 0. */
+declare const omega: (n?: number) => Complex;
+/** Equal within a tolerance (default 1e-9), on both components. */
+declare const eq: (a: Complex, b: Complex, eps?: number) => boolean;
+/** Plain string, e.g. "3 − 2i", "i", "−1", "0", "2i". */
+declare function toStr(z: Complex, dp?: number): string;
+/** LaTeX form for <Tex> (uses real minus signs, "i"). */
+declare function toTex(z: Complex, dp?: number): string;
+//#endregion
+export { Complex, complex_d_exports };

package/dist/math/complex.mjs

@@ -0,0 +1,239 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+
+//#region src/math/complex.ts
+var complex_exports = /* @__PURE__ */ __exportAll({
+	DEG2RAD: () => DEG2RAD,
+	I: () => I,
+	MAX_POW: () => MAX_POW,
+	MAX_ROOTS: () => 360,
+	ONE: () => ONE,
+	RAD2DEG: () => RAD2DEG,
+	TWO_PI: () => TWO_PI,
+	ZERO: () => ZERO,
+	abs: () => abs,
+	add: () => add,
+	arg: () => arg,
+	argDeg: () => argDeg,
+	conj: () => conj,
+	cx: () => cx,
+	div: () => div,
+	eq: () => eq,
+	fromPolar: () => fromPolar,
+	iPow: () => iPow,
+	isFiniteC: () => isFiniteC,
+	mul: () => mul,
+	neg: () => neg,
+	nthRoots: () => nthRoots,
+	omega: () => omega,
+	powInt: () => powInt,
+	rootsOfUnity: () => rootsOfUnity,
+	scale: () => scale,
+	sub: () => sub,
+	toPolar: () => toPolar,
+	toStr: () => toStr,
+	toTex: () => toTex
+});
+const TWO_PI = Math.PI * 2;
+const RAD2DEG = 180 / Math.PI;
+const DEG2RAD = Math.PI / 180;
+/** Hard caps so an authored value can never blow memory or hang a loop. */
+const MAX_POW = 1024;
+const MAX_ROOTS = 360;
+const cx = (re, im = 0) => ({
+	re,
+	im
+});
+const ZERO = {
+	re: 0,
+	im: 0
+};
+const ONE = {
+	re: 1,
+	im: 0
+};
+const I = {
+	re: 0,
+	im: 1
+};
+const isFiniteC = (z) => Number.isFinite(z.re) && Number.isFinite(z.im);
+const add = (a, b) => ({
+	re: a.re + b.re,
+	im: a.im + b.im
+});
+const sub = (a, b) => ({
+	re: a.re - b.re,
+	im: a.im - b.im
+});
+const neg = (a) => ({
+	re: -a.re,
+	im: -a.im
+});
+const conj = (a) => ({
+	re: a.re,
+	im: -a.im
+});
+const scale = (a, k) => ({
+	re: a.re * k,
+	im: a.im * k
+});
+/** (a+bi)(c+di) = (ac − bd) + (ad + bc)i. */
+const mul = (a, b) => ({
+	re: a.re * b.re - a.im * b.im,
+	im: a.re * b.im + a.im * b.re
+});
+/**
+* Complex division via Smith's algorithm: divide through by the LARGER of the
+* denominator's components so the intermediate ratio stays in [−1, 1] (no
+* overflow when |b| is huge, no underflow when tiny). Returns an ∞/NaN complex
+* for a (near-)zero denominator rather than throwing.
+*/
+function div(a, b) {
+	const { re: c, im: d } = b;
+	if (c === 0 && d === 0) return {
+		re: a.re / 0,
+		im: a.im / 0
+	};
+	if (Math.abs(c) >= Math.abs(d)) {
+		const r = d / c, den = c + d * r;
+		return {
+			re: (a.re + a.im * r) / den,
+			im: (a.im - a.re * r) / den
+		};
+	}
+	const r = c / d, den = c * r + d;
+	return {
+		re: (a.re * r + a.im) / den,
+		im: (a.im * r - a.re) / den
+	};
+}
+/** Modulus |z| = √(re² + im²), via hypot so large components don't overflow. */
+const abs = (z) => Math.hypot(z.re, z.im);
+/** Argument arg(z) in RADIANS, in (−π, π]. arg(0) = 0 by convention. */
+const arg = (z) => z.re === 0 && z.im === 0 ? 0 : Math.atan2(z.im, z.re);
+/** Argument in DEGREES, in (−180, 180]. */
+const argDeg = (z) => arg(z) * RAD2DEG;
+/** Polar → rectangular: r·e^{iθ} = r(cosθ + i sinθ), θ in radians. */
+const fromPolar = (r, theta) => ({
+	re: r * Math.cos(theta),
+	im: r * Math.sin(theta)
+});
+/** Rectangular → polar { r, theta(rad) }. */
+const toPolar = (z) => ({
+	r: abs(z),
+	theta: arg(z)
+});
+/**
+* iⁿ for any integer n, EXACTLY (no De Moivre float drift): the 4-cycle
+* 1, i, −1, −i. Negative n handled by the (n mod 4 + 4) mod 4 normalisation.
+*/
+function iPow(n) {
+	if (!Number.isInteger(n)) return {
+		re: NaN,
+		im: NaN
+	};
+	switch ((n % 4 + 4) % 4) {
+		case 0: return {
+			re: 1,
+			im: 0
+		};
+		case 1: return {
+			re: 0,
+			im: 1
+		};
+		case 2: return {
+			re: -1,
+			im: 0
+		};
+		default: return {
+			re: 0,
+			im: -1
+		};
+	}
+}
+/**
+* zⁿ for an INTEGER n via exponentiation-by-squaring (negative n inverts).
+* |n| is capped at MAX_POW; an overflowing magnitude returns an explicit ∞
+* complex (finite check) instead of looping into garbage.
+*/
+function powInt(z, n) {
+	if (!Number.isInteger(n)) return {
+		re: NaN,
+		im: NaN
+	};
+	if (Math.abs(n) > 1024) return {
+		re: Infinity,
+		im: Infinity
+	};
+	if (n === 0) return { ...ONE };
+	let base = n < 0 ? div(ONE, z) : z;
+	let e = Math.abs(n);
+	let acc = { ...ONE };
+	while (e > 0) {
+		if (e & 1) acc = mul(acc, base);
+		e >>= 1;
+		if (e > 0) base = mul(base, base);
+		if (!isFiniteC(acc)) return {
+			re: Infinity,
+			im: Infinity
+		};
+	}
+	return acc;
+}
+/** Clamp an nth-root count to a safe, sane range [1, MAX_ROOTS]. */
+const safeN = (n) => Number.isInteger(n) && n >= 1 ? Math.min(n, 360) : 1;
+/**
+* The n nth-roots of UNITY: e^{2πik/n}, k = 0…n−1 (so ω = roots[1] is the
+* primitive root). For n = 2 → {1, −1}; n = 3 → {1, ω, ω²}; n = 4 → {1, i, −1, −i}.
+* n is clamped to [1, MAX_ROOTS]. The k = n/2 (real −1) and k = 0 (real 1) entries
+* are snapped to exact values so labels read cleanly.
+*/
+function rootsOfUnity(n) {
+	const m = safeN(n);
+	return Array.from({ length: m }, (_, k) => {
+		if (k === 0) return {
+			re: 1,
+			im: 0
+		};
+		if (m % 2 === 0 && k === m / 2) return {
+			re: -1,
+			im: 0
+		};
+		return fromPolar(1, TWO_PI * k / m);
+	});
+}
+/** The n nth-roots of any z: |z|^{1/n} · e^{i(arg z + 2πk)/n}, k = 0…n−1. */
+function nthRoots(z, n) {
+	const m = safeN(n);
+	const { r, theta } = toPolar(z);
+	const root = Math.pow(r, 1 / m);
+	return Array.from({ length: m }, (_, k) => fromPolar(root, (theta + TWO_PI * k) / m));
+}
+/** The primitive nth root of unity ω (default the CUBE root, n = 3): e^{2πi/n}.
+*  For n = 3: ω = −½ + (√3/2)i, with ω³ = 1 and 1 + ω + ω² = 0. */
+const omega = (n = 3) => fromPolar(1, TWO_PI / safeN(n));
+/** Equal within a tolerance (default 1e-9), on both components. */
+const eq = (a, b, eps = 1e-9) => Math.abs(a.re - b.re) <= eps && Math.abs(a.im - b.im) <= eps;
+const numStr = (n, dp) => {
+	if (!Number.isFinite(n)) return n > 0 ? "∞" : "−∞";
+	const r = Math.round(n * 10 ** dp) / 10 ** dp;
+	return Object.is(r, -0) ? "0" : String(r).replace(/^-/, "−");
+};
+/** Plain string, e.g. "3 − 2i", "i", "−1", "0", "2i". */
+function toStr(z, dp = 2) {
+	if (!isFiniteC(z)) return "∞";
+	const re = Math.round(z.re * 10 ** dp) / 10 ** dp;
+	const im = Math.round(z.im * 10 ** dp) / 10 ** dp;
+	if (im === 0) return numStr(re, dp);
+	const imPart = im === 1 ? "i" : im === -1 ? "−i" : `${numStr(Math.abs(im), dp)}i`;
+	if (re === 0) return im < 0 && im !== -1 ? `−${imPart}` : im === -1 ? "−i" : imPart;
+	const sign = im < 0 ? "−" : "+";
+	const mag = Math.abs(im) === 1 ? "i" : `${numStr(Math.abs(im), dp)}i`;
+	return `${numStr(re, dp)} ${sign} ${mag}`;
+}
+/** LaTeX form for <Tex> (uses real minus signs, "i"). */
+function toTex(z, dp = 2) {
+	return toStr(z, dp).replace(/−/g, "-");
+}
+
+//#endregion
+export { ONE, ZERO, abs, add, complex_exports, cx, div, fromPolar, isFiniteC, mul, sub, toStr };

package/dist/math/expr.d.mts

@@ -0,0 +1,23 @@
+import { Node } from "./ast.mjs";
+
+//#region src/math/expr.d.ts
+interface CompiledExpr {
+  /** Evaluate against a scope of variable values (unknown vars → NaN). */
+  readonly fn: (scope: Record<string, number>) => number;
+  /** Free variables referenced (excludes constants & functions), e.g. `['x','a']`. */
+  readonly vars: string[];
+  /** The parsed syntax tree, for differentiation, LaTeX, or analysis. */
+  readonly ast: Node;
+  readonly error?: undefined;
+}
+interface ExprError {
+  readonly error: string;
+  readonly fn?: undefined;
+  readonly vars?: undefined;
+  readonly ast?: undefined;
+}
+type ExprResult = CompiledExpr | ExprError;
+/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
+declare function compileExpr(src: string): ExprResult;
+//#endregion
+export { CompiledExpr, ExprError, ExprResult, compileExpr };

package/dist/math/expr.mjs

@@ -0,0 +1,36 @@
+import { evaluate, freeVars } from "./ast.mjs";
+import { parse } from "./parse.mjs";
+
+//#region src/math/expr.ts
+/**
+* compileExpr, the stable entry point to the engine: a formula string in, a fast evaluator plus
+* the free variables and the parsed AST out.
+*
+* It NEVER THROWS. `parse` throws on bad input, which is correct for a parser and wrong for the
+* call site that matters here: an author or a student typing into a field, where a thrown error
+* would take the lab down mid-keystroke. So the result is a union, `{ fn, vars, ast }` or
+* `{ error }`, discriminated by an optional `error` on both arms so `if (c.error)` narrows without
+* a type guard.
+*
+* This lived in `index.ts` until the answer checker needed it, which would have made the barrel
+* import a file that imports the barrel. Implementation in a barrel is a circular import waiting
+* for its second consumer.
+*/
+/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
+function compileExpr(src) {
+	if (!src || !src.trim()) return { error: "Empty expression" };
+	let ast;
+	try {
+		ast = parse(src);
+	} catch (e) {
+		return { error: e instanceof Error ? e.message : "Parse error" };
+	}
+	return {
+		fn: (scope) => evaluate(ast, scope),
+		vars: [...freeVars(ast)],
+		ast
+	};
+}
+
+//#endregion
+export { compileExpr };

package/dist/math/index.d.mts

@@ -1,27 +1,13 @@
 import { BinOp, Node, compileNode, evaluate, freeVars } from "./ast.mjs";
 import { parse } from "./parse.mjs";
+import { isolate, occurrences } from "./rearrange.mjs";
 import { definiteIntegral, differentiate, integrate, simplify } from "./calculus.mjs";
 import { CompiledFn, compile } from "./compile.mjs";
 import { toLatex } from "./latex.mjs";
-
-//#region src/math/index.d.ts
-interface CompiledExpr {
-  /** Evaluate against a scope of variable values (unknown vars → NaN). */
-  readonly fn: (scope: Record<string, number>) => number;
-  /** Free variables referenced (excludes constants & functions), e.g. `['x','a']`. */
-  readonly vars: string[];
-  /** The parsed syntax tree, for differentiation, LaTeX, or analysis. */
-  readonly ast: Node;
-  readonly error?: undefined;
-}
-interface ExprError {
-  readonly error: string;
-  readonly fn?: undefined;
-  readonly vars?: undefined;
-  readonly ast?: undefined;
-}
-type ExprResult = CompiledExpr | ExprError;
-/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
-declare function compileExpr(src: string): ExprResult;
-//#endregion
-export { type BinOp, CompiledExpr, type CompiledFn, ExprError, ExprResult, type Node, compile, compileExpr, compileNode, definiteIntegral, differentiate, evaluate, freeVars, integrate, parse, simplify, toLatex };
+import { CompiledExpr, ExprError, ExprResult, compileExpr } from "./expr.mjs";
+import { Complex, complex_d_exports } from "./complex.mjs";
+import { Poly, PolyRoots, allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, polyRoots, polyTex, poly_d_exports, solveEquation, trim } from "./poly.mjs";
+import { PolySolution, polyCoeffs, solutionTex, solvePoly } from "./solve.mjs";
+import { Fn1, Line, areaBetween, intersections, normalAt, quadrature, roots, tangentAt } from "./analysis.mjs";
+import { AnswerSpec, ExprCheckOpts, checkAnswer, checkExpression, checkNumber, normalizeMathInput, parseValue } from "./answer-check.mjs";
+export { type AnswerSpec, type BinOp, type CompiledExpr, type CompiledFn, type Complex, type ExprCheckOpts, type ExprError, type ExprResult, type Fn1, type Line, type Node, type Poly, type PolyRoots, type PolySolution, allRoots, areaBetween, checkAnswer, checkExpression, checkNumber, compile, compileExpr, compileNode, complex_d_exports as complex, definiteIntegral, deflate, degree, deriv, differentiate, evalC, evalPoly, evaluate, factorTex, freeVars, fromAst, integrate, intersections, isolate, normalAt, normalizeMathInput, occurrences, parse, parseValue, poly_d_exports as poly, polyCoeffs, polyRoots, polyTex, quadrature, roots, simplify, solutionTex, solveEquation, solvePoly, tangentAt, toLatex, trim };