@classytic/stage 0.1.0

package/dist/logic/latex.mjs

@@ -0,0 +1,33 @@
+//#region src/logic/latex.ts
+const OP_TEX = {
+	and: "\\land",
+	or: "\\lor",
+	xor: "\\oplus",
+	implies: "\\rightarrow",
+	iff: "\\leftrightarrow"
+};
+const PREC = {
+	and: 50,
+	xor: 40,
+	or: 30,
+	implies: 20,
+	iff: 10
+};
+function toLatex(n) {
+	const walk = (x, parentPrec) => {
+		switch (x.kind) {
+			case "var": return x.name;
+			case "const": return x.value ? "\\top" : "\\bot";
+			case "not": return `\\neg ${walk(x.a, 100)}`;
+			case "bin": {
+				const p = PREC[x.op];
+				const s = `${walk(x.a, p)} ${OP_TEX[x.op]} ${walk(x.b, p + 1)}`;
+				return p < parentPrec ? `\\left(${s}\\right)` : s;
+			}
+		}
+	};
+	return walk(n, 0);
+}
+
+//#endregion
+export { toLatex };

package/dist/logic/minimize.d.mts

@@ -0,0 +1,37 @@
+import { LNode } from "./ast.mjs";
+
+//#region src/logic/minimize.d.ts
+interface Cube {
+  value: number;
+  mask: number;
+}
+interface Minimization {
+  vars: string[];
+  minterms: number[];
+  dontCares: number[];
+  primeImplicants: Cube[];
+  /** A minimal SOP cover (subset of the prime implicants). */
+  cover: Cube[];
+  /** The simplified sum-of-products expression ('0' / '1' for the constants). */
+  expression: string;
+}
+/** All minterms a cube covers, within an n-variable space. */
+declare function cubeCovers(c: Cube, n: number): number[];
+/** The product term for a cube — a literal per FIXED bit (MSB = first var). */
+declare function cubeTerm(c: Cube, vars: string[], neg?: string, join?: string): string;
+/** Quine–McCluskey prime implicants of a set of minterms (+ optional don't-cares). */
+declare function primeImplicants(minterms: number[], n: number, dontCares?: number[]): Cube[];
+/** A minimal SOP cover: essential prime implicants + a greedy fill of the rest. */
+declare function minimalCover(minterms: number[], n: number, dontCares?: number[]): Cube[];
+/** Full minimisation of a formula (or explicit minterms) → cover + SOP string. */
+declare function minimize(input: LNode | {
+  minterms: number[];
+  vars: string[];
+  dontCares?: number[];
+}): Minimization;
+/** Is `selected` a legal implicant (a sub-cube) of an n-var map? If so return
+ *  the tightest cube containing exactly it; else null. (Used by the K-map lab to
+ *  validate a learner's hand-drawn group.) */
+declare function cubeOfSelection(selected: number[], n: number): Cube | null;
+//#endregion
+export { Cube, Minimization, cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImplicants };

package/dist/logic/minimize.mjs

@@ -0,0 +1,175 @@
+import { freeVars } from "./ast.mjs";
+import { truthTable } from "./table.mjs";
+
+//#region src/logic/minimize.ts
+/**
+* Boolean minimisation — Quine–McCluskey: the algorithm a Karnaugh map performs
+* by eye. Given a function's minterms (the rows where it is 1) over n variables,
+* it finds the PRIME IMPLICANTS (maximal "don't-care cubes" — groups on the
+* K-map) and a minimal SUM-OF-PRODUCTS cover (essential PIs + a greedy fill).
+* Pure + dependency-free, the boolean sibling of `simplify` in the expr engine;
+* the K-map lab renders these cubes as the coloured groups, and the same routine
+* powers ICT boolean-algebra simplification.
+*
+* A cube is {value, mask}: a minterm m is covered iff (m & mask) === value, so
+* `mask` marks the FIXED bits (a 0 bit is "don't care" = a dimension the group
+* spans). popcount(~mask) free bits ⇒ the cube covers 2^free cells.
+*/
+const popcount = (x) => {
+	let c = 0;
+	while (x) {
+		x &= x - 1;
+		c++;
+	}
+	return c;
+};
+const cubeKey = (c) => `${c.value}|${c.mask}`;
+/** All minterms a cube covers, within an n-variable space. */
+function cubeCovers(c, n) {
+	const out = [];
+	const total = 1 << n;
+	for (let m = 0; m < total; m++) if ((m & c.mask) === c.value) out.push(m);
+	return out;
+}
+/** The product term for a cube — a literal per FIXED bit (MSB = first var). */
+function cubeTerm(c, vars, neg = "¬", join = " ∧ ") {
+	const n = vars.length;
+	const lits = [];
+	for (let i = 0; i < n; i++) {
+		const bit = 1 << n - 1 - i;
+		if (c.mask & bit) lits.push(c.value & bit ? vars[i] : `${neg}${vars[i]}`);
+	}
+	return lits.length ? lits.join(join) : "T";
+}
+/** Quine–McCluskey prime implicants of a set of minterms (+ optional don't-cares). */
+function primeImplicants(minterms, n, dontCares = []) {
+	const fullMask = (1 << n) - 1;
+	const seed = [...new Set([...minterms, ...dontCares])].sort((a, b) => a - b);
+	if (seed.length === 0) return [];
+	if (seed.length === 1 << n) return [{
+		value: 0,
+		mask: 0
+	}];
+	let current = seed.map((m) => ({
+		value: m,
+		mask: fullMask
+	}));
+	const primes = /* @__PURE__ */ new Map();
+	while (current.length) {
+		const used = /* @__PURE__ */ new Set();
+		const nextMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < current.length; i++) for (let j = i + 1; j < current.length; j++) {
+			const a = current[i], b = current[j];
+			if (a.mask !== b.mask) continue;
+			const diff = a.value ^ b.value;
+			if (popcount(diff) !== 1) continue;
+			const merged = {
+				value: a.value & ~diff,
+				mask: a.mask & ~diff
+			};
+			nextMap.set(cubeKey(merged), merged);
+			used.add(cubeKey(a));
+			used.add(cubeKey(b));
+		}
+		for (const c of current) if (!used.has(cubeKey(c))) primes.set(cubeKey(c), c);
+		current = [...nextMap.values()];
+	}
+	return [...primes.values()];
+}
+/** Minterms (required, NOT don't-cares) each prime implicant covers. */
+function coverageOf(pis, required) {
+	const map = /* @__PURE__ */ new Map();
+	pis.forEach((pi, idx) => {
+		const got = [];
+		for (const m of required) if ((m & pi.mask) === pi.value) got.push(m);
+		map.set(idx, got);
+	});
+	return map;
+}
+/** A minimal SOP cover: essential prime implicants + a greedy fill of the rest. */
+function minimalCover(minterms, n, dontCares = []) {
+	const required = new Set(minterms);
+	if (required.size === 0) return [];
+	const pis = primeImplicants(minterms, n, dontCares);
+	if (pis.length === 1 && pis[0].mask === 0) return pis;
+	const cov = coverageOf(pis, required);
+	const chosen = /* @__PURE__ */ new Set();
+	const uncovered = new Set(required);
+	for (const m of required) {
+		const owners = pis.map((_, i) => i).filter((i) => cov.get(i).includes(m));
+		if (owners.length === 1) chosen.add(owners[0]);
+	}
+	for (const i of chosen) for (const m of cov.get(i)) uncovered.delete(m);
+	while (uncovered.size) {
+		let best = -1, bestCount = -1;
+		pis.forEach((_, i) => {
+			if (chosen.has(i)) return;
+			const c = cov.get(i).filter((m) => uncovered.has(m)).length;
+			if (c > bestCount) {
+				bestCount = c;
+				best = i;
+			}
+		});
+		if (best < 0 || bestCount <= 0) break;
+		chosen.add(best);
+		for (const m of cov.get(best)) uncovered.delete(m);
+	}
+	return [...chosen].map((i) => pis[i]);
+}
+/** Full minimisation of a formula (or explicit minterms) → cover + SOP string. */
+function minimize(input) {
+	let vars;
+	let minterms;
+	let dontCares;
+	if ("minterms" in input) {
+		vars = input.vars;
+		minterms = [...input.minterms].sort((a, b) => a - b);
+		dontCares = (input.dontCares ?? []).slice();
+	} else {
+		vars = freeVars(input);
+		minterms = truthTable(input, vars).rows.map((r, i) => r.value ? i : -1).filter((i) => i >= 0);
+		dontCares = [];
+	}
+	const n = vars.length;
+	const cover = minimalCover(minterms, n, dontCares);
+	const pis = primeImplicants(minterms, n, dontCares);
+	let expression;
+	if (minterms.length === 0) expression = "0";
+	else if (cover.length === 1 && cover[0].mask === 0) expression = "1";
+	else expression = cover.map((c) => cover.length > 1 ? `(${cubeTerm(c, vars)})` : cubeTerm(c, vars)).join(" ∨ ");
+	return {
+		vars,
+		minterms,
+		dontCares,
+		primeImplicants: pis,
+		cover,
+		expression
+	};
+}
+/** Is `selected` a legal implicant (a sub-cube) of an n-var map? If so return
+*  the tightest cube containing exactly it; else null. (Used by the K-map lab to
+*  validate a learner's hand-drawn group.) */
+function cubeOfSelection(selected, n) {
+	if (selected.length === 0) return null;
+	if ((selected.length & selected.length - 1) !== 0) return null;
+	const fullMask = (1 << n) - 1;
+	const first = selected[0];
+	let mask = fullMask;
+	for (let i = 0; i < n; i++) {
+		const bit = 1 << i;
+		const v0 = first & bit;
+		if (selected.some((m) => (m & bit) !== v0)) mask &= ~bit;
+	}
+	const cube = {
+		value: first & mask,
+		mask
+	};
+	const covers = cubeCovers(cube, n);
+	if (covers.length !== selected.length) return null;
+	const set = new Set(selected);
+	if (!covers.every((m) => set.has(m))) return null;
+	return cube;
+}
+
+//#endregion
+export { cubeCovers, cubeOfSelection, cubeTerm, minimalCover, minimize, primeImplicants };

package/dist/logic/parse.d.mts

@@ -0,0 +1,6 @@
+import { LNode } from "./ast.mjs";
+
+//#region src/logic/parse.d.ts
+declare function parseLogic(src: string): LNode;
+//#endregion
+export { parseLogic };

package/dist/logic/parse.mjs

@@ -0,0 +1,68 @@
+import { tokenizeLogic } from "./tokenize.mjs";
+
+//#region src/logic/parse.ts
+const PREC = {
+	and: 50,
+	xor: 40,
+	or: 30,
+	implies: 20,
+	iff: 10
+};
+const RIGHT_ASSOC = { implies: true };
+function parseLogic(src) {
+	const toks = tokenizeLogic(src);
+	let pos = 0;
+	const peek = () => toks[pos];
+	const next = () => {
+		const t = toks[pos];
+		if (!t) throw new Error("Unexpected end of formula");
+		pos++;
+		return t;
+	};
+	const parsePrefix = () => {
+		const t = next();
+		if (t.type === "not") return {
+			kind: "not",
+			a: parsePrefix()
+		};
+		if (t.type === "lparen") {
+			const inner = parseExpr(0);
+			if (next().type !== "rparen") throw new Error("Expected \")\"");
+			return inner;
+		}
+		if (t.type === "var") return {
+			kind: "var",
+			name: t.value
+		};
+		if (t.type === "const") return {
+			kind: "const",
+			value: t.value === "true"
+		};
+		throw new Error(`Expected a variable, "(", or ¬ but found "${t.value}"`);
+	};
+	const parseExpr = (minPrec) => {
+		let left = parsePrefix();
+		for (;;) {
+			const t = peek();
+			if (!t || t.type !== "bin") break;
+			const op = t.value;
+			const prec = PREC[op];
+			if (prec < minPrec) break;
+			pos++;
+			const right = parseExpr(RIGHT_ASSOC[op] ? prec : prec + 1);
+			left = {
+				kind: "bin",
+				op,
+				a: left,
+				b: right
+			};
+		}
+		return left;
+	};
+	const node = parseExpr(0);
+	if (pos < toks.length) throw new Error(`Unexpected "${toks[pos].value}" after a complete formula`);
+	return node;
+}
+
+//#endregion
+export { parseLogic };

package/dist/logic/table.d.mts

@@ -0,0 +1,24 @@
+import { LNode } from "./ast.mjs";
+
+//#region src/logic/table.d.ts
+interface TruthRow {
+  env: Record<string, boolean>;
+  value: boolean;
+}
+interface TruthTable {
+  vars: string[];
+  rows: TruthRow[];
+}
+/** Enumerate all 2^vars assignments (MSB = first var), evaluating `n` on each. */
+declare function truthTable(n: LNode, varsIn?: string[]): TruthTable;
+type Classification = 'tautology' | 'contradiction' | 'contingency';
+declare function classify(n: LNode): Classification;
+/** Two formulas are equivalent iff they agree on every assignment of the
+ *  COMBINED variable set. */
+declare function equivalent(a: LNode, b: LNode): boolean;
+/** Disjunctive normal form (sum of minterms) read straight off the true rows. */
+declare function toDNF(n: LNode): string;
+/** Conjunctive normal form (product of maxterms) read off the false rows. */
+declare function toCNF(n: LNode): string;
+//#endregion
+export { Classification, TruthRow, TruthTable, classify, equivalent, toCNF, toDNF, truthTable };

package/dist/logic/table.mjs

@@ -0,0 +1,65 @@
+import { evalBool, freeVars } from "./ast.mjs";
+
+//#region src/logic/table.ts
+/**
+* Truth tables + the things derived from them: classification (tautology /
+* contradiction / contingency), logical equivalence, and DNF/CNF. Everything is
+* a fold over the 2ⁿ assignments — the truth table is the source of truth, so
+* equivalence is just "same output column" (no algebraic law engine needed).
+*/
+/** Enumerate all 2^vars assignments (MSB = first var), evaluating `n` on each. */
+function truthTable(n, varsIn) {
+	const vars = varsIn ?? freeVars(n);
+	const rows = [];
+	const total = 1 << vars.length;
+	for (let mask = 0; mask < total; mask++) {
+		const env = {};
+		vars.forEach((v, i) => {
+			env[v] = (mask & 1 << vars.length - 1 - i) !== 0;
+		});
+		rows.push({
+			env,
+			value: evalBool(n, env)
+		});
+	}
+	return {
+		vars,
+		rows
+	};
+}
+function classify(n) {
+	const { rows } = truthTable(n);
+	const t = rows.some((r) => r.value);
+	const f = rows.some((r) => !r.value);
+	if (t && !f) return "tautology";
+	if (f && !t) return "contradiction";
+	return "contingency";
+}
+/** Two formulas are equivalent iff they agree on every assignment of the
+*  COMBINED variable set. */
+function equivalent(a, b) {
+	const vars = [...new Set([...freeVars(a), ...freeVars(b)])].sort();
+	const ta = truthTable(a, vars);
+	const tb = truthTable(b, vars);
+	return ta.rows.every((r, i) => r.value === tb.rows[i].value);
+}
+const term = (vars, env, positiveWhenTrue, join, neg) => vars.map((v) => env[v] === positiveWhenTrue ? v : `${neg}${v}`).join(join);
+/** Disjunctive normal form (sum of minterms) read straight off the true rows. */
+function toDNF(n) {
+	const { vars, rows } = truthTable(n);
+	const minterms = rows.filter((r) => r.value);
+	if (minterms.length === 0) return "F";
+	if (minterms.length === rows.length) return "T";
+	return minterms.map((r) => `(${term(vars, r.env, true, " ∧ ", "¬")})`).join(" ∨ ");
+}
+/** Conjunctive normal form (product of maxterms) read off the false rows. */
+function toCNF(n) {
+	const { vars, rows } = truthTable(n);
+	const maxterms = rows.filter((r) => !r.value);
+	if (maxterms.length === 0) return "T";
+	if (maxterms.length === rows.length) return "F";
+	return maxterms.map((r) => `(${term(vars, r.env, false, " ∨ ", "¬")})`).join(" ∧ ");
+}
+
+//#endregion
+export { classify, equivalent, toCNF, toDNF, truthTable };

package/dist/logic/tokenize.mjs

@@ -0,0 +1,258 @@
+//#region src/logic/tokenize.ts
+const TRUE = new Set([
+	"true",
+	"t",
+	"1",
+	"⊤"
+]);
+const FALSE = new Set([
+	"false",
+	"f",
+	"0",
+	"⊥"
+]);
+const WORD_OPS = {
+	not: { type: "not" },
+	and: {
+		type: "bin",
+		op: "and"
+	},
+	or: {
+		type: "bin",
+		op: "or"
+	},
+	xor: {
+		type: "bin",
+		op: "xor"
+	},
+	implies: {
+		type: "bin",
+		op: "implies"
+	},
+	iff: {
+		type: "bin",
+		op: "iff"
+	}
+};
+/** Multi-char symbol operators, longest-match first. */
+const SYMBOLS = [
+	{
+		re: "<->",
+		tok: {
+			type: "bin",
+			value: "iff"
+		}
+	},
+	{
+		re: "<=>",
+		tok: {
+			type: "bin",
+			value: "iff"
+		}
+	},
+	{
+		re: "->",
+		tok: {
+			type: "bin",
+			value: "implies"
+		}
+	},
+	{
+		re: "=>",
+		tok: {
+			type: "bin",
+			value: "implies"
+		}
+	},
+	{
+		re: "&&",
+		tok: {
+			type: "bin",
+			value: "and"
+		}
+	},
+	{
+		re: "||",
+		tok: {
+			type: "bin",
+			value: "or"
+		}
+	},
+	{
+		re: "∧",
+		tok: {
+			type: "bin",
+			value: "and"
+		}
+	},
+	{
+		re: "·",
+		tok: {
+			type: "bin",
+			value: "and"
+		}
+	},
+	{
+		re: "&",
+		tok: {
+			type: "bin",
+			value: "and"
+		}
+	},
+	{
+		re: "∨",
+		tok: {
+			type: "bin",
+			value: "or"
+		}
+	},
+	{
+		re: "+",
+		tok: {
+			type: "bin",
+			value: "or"
+		}
+	},
+	{
+		re: "|",
+		tok: {
+			type: "bin",
+			value: "or"
+		}
+	},
+	{
+		re: "⊕",
+		tok: {
+			type: "bin",
+			value: "xor"
+		}
+	},
+	{
+		re: "^",
+		tok: {
+			type: "bin",
+			value: "xor"
+		}
+	},
+	{
+		re: "↔",
+		tok: {
+			type: "bin",
+			value: "iff"
+		}
+	},
+	{
+		re: "≡",
+		tok: {
+			type: "bin",
+			value: "iff"
+		}
+	},
+	{
+		re: "→",
+		tok: {
+			type: "bin",
+			value: "implies"
+		}
+	},
+	{
+		re: "⊃",
+		tok: {
+			type: "bin",
+			value: "implies"
+		}
+	},
+	{
+		re: "¬",
+		tok: {
+			type: "not",
+			value: "not"
+		}
+	},
+	{
+		re: "~",
+		tok: {
+			type: "not",
+			value: "not"
+		}
+	},
+	{
+		re: "!",
+		tok: {
+			type: "not",
+			value: "not"
+		}
+	},
+	{
+		re: "(",
+		tok: {
+			type: "lparen",
+			value: "("
+		}
+	},
+	{
+		re: ")",
+		tok: {
+			type: "rparen",
+			value: ")"
+		}
+	}
+];
+const isIdentStart = (c) => /[A-Za-z]/.test(c);
+const isIdent = (c) => /[A-Za-z0-9_]/.test(c);
+function tokenizeLogic(src) {
+	const out = [];
+	let i = 0;
+	const s = src;
+	outer: while (i < s.length) {
+		const c = s[i];
+		if (c === " " || c === "	" || c === "\n" || c === "\r") {
+			i++;
+			continue;
+		}
+		for (const { re, tok } of SYMBOLS) if (s.startsWith(re, i)) {
+			out.push({ ...tok });
+			i += re.length;
+			continue outer;
+		}
+		if (isIdentStart(c)) {
+			let j = i + 1;
+			while (j < s.length && isIdent(s[j])) j++;
+			const word = s.slice(i, j);
+			const lower = word.toLowerCase();
+			i = j;
+			if (TRUE.has(lower)) out.push({
+				type: "const",
+				value: "true"
+			});
+			else if (FALSE.has(lower)) out.push({
+				type: "const",
+				value: "false"
+			});
+			else if (WORD_OPS[lower]) {
+				const w = WORD_OPS[lower];
+				out.push({
+					type: w.type,
+					value: w.op ?? "not"
+				});
+			} else out.push({
+				type: "var",
+				value: word
+			});
+			continue;
+		}
+		if (c === "1" || c === "0") {
+			out.push({
+				type: "const",
+				value: c === "1" ? "true" : "false"
+			});
+			i++;
+			continue;
+		}
+		throw new Error(`Unexpected character "${c}" at ${i}`);
+	}
+	return out;
+}
+
+//#endregion
+export { tokenizeLogic };

package/dist/math/ast.d.mts

@@ -0,0 +1,35 @@
+//#region src/math/ast.d.ts
+/**
+ * expr/ast — the Abstract Syntax Tree: node types, evaluation, free-variable
+ * collection, and small builder helpers. The AST is the shared representation
+ * that evaluation, differentiation, simplification, and LaTeX printing all
+ * operate on.
+ */
+type BinOp = '+' | '-' | '*' | '/' | '%' | '^';
+type Node = {
+  type: 'num';
+  value: number;
+} | {
+  type: 'var';
+  name: string;
+} | {
+  type: 'neg';
+  arg: Node;
+} | {
+  type: 'binary';
+  op: BinOp;
+  left: Node;
+  right: Node;
+} | {
+  type: 'call';
+  fn: string;
+  args: Node[];
+};
+/** Evaluate the AST against a scope of variable values. Returns NaN for unknowns. */
+declare function evaluate(node: Node, scope: Record<string, number>): number;
+/** Free variables referenced (excludes constants & function names). */
+declare function freeVars(node: Node, into?: Set<string>): Set<string>;
+/** Compile to a fast closure (a thin wrapper over `evaluate`). */
+declare const compileNode: (node: Node) => (scope: Record<string, number>) => number;
+//#endregion
+export { BinOp, Node, compileNode, evaluate, freeVars };