@classytic/labs 0.1.0

package/dist/discrete/binomial/preset.mjs

@@ -0,0 +1,333 @@
+'use client';
+
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { CheckButton, Chip, Slider, StatusPill, Stepper } from "../../kit/controls.mjs";
+import { Callout, ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
+import { HintLadder, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
+import { nCr } from "../core/combinatorics.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { useControlSurface } from "@classytic/stage";
+
+//#region src/discrete/binomial/preset.tsx
+/**
+* BinomialDistributionLab — the bridge from counting to the bell. P(X=k successes
+* in n trials) = C(n,k)·pᵏ·(1−p)ⁿ⁻ᵏ, drawn as bars you can interrogate: click a bar
+* and the formula DERIVES itself — k successes happen C(n,k) ways (the Pascal /
+* counting number), each way has probability pᵏ for the successes times (1−p)ⁿ⁻ᵏ for
+* the failures. Slide p to watch it skew and (at ½) turn symmetric; slide n and flip
+* on the normal overlay to watch the binomial become the Galton-board bell. Mean np
+* and σ = √(np(1−p)) are marked.
+*
+* One lab ties together Pascal (the coefficients), the counting labs (the C(n,k)),
+* and the normal distribution (the limit). Values from the nCr kernel.
+*/
+const W = 540, H = 300, ML = 30, MR = 14, MT = 16, MB = 34;
+const PW = W - ML - MR, PH = H - MT - MB;
+const ACC = "var(--stage-accent)", GOOD = "var(--stage-good)";
+const f3 = (x) => x < 5e-4 ? x.toExponential(1) : x.toFixed(3);
+function BinomialDistributionLab({ n: n0 = 10, p: p0 = .5, showNormal: sn0 = false, title = "Binomial distribution", prompt, objectives, hints: hintList, controlId }) {
+	const [n, setN] = useState(n0);
+	const [p, setP] = useState(p0);
+	const [normal, setNormal] = useState(sn0);
+	const [sel, setSel] = useState(null);
+	const [guess, setGuess] = useState(0);
+	const [checked, setChecked] = useState(false);
+	const hints = useHints(hintList);
+	const probs = useMemo(() => Array.from({ length: n + 1 }, (_, k) => nCr(n, k) * p ** k * (1 - p) ** (n - k)), [n, p]);
+	const mean = n * p, variance = n * p * (1 - p), sd = Math.sqrt(variance);
+	const mode = probs.indexOf(Math.max(...probs));
+	const npdf = (x) => variance > 0 ? Math.exp(-((x - mean) ** 2) / (2 * variance)) / Math.sqrt(2 * Math.PI * variance) : 0;
+	const yMax = Math.max(...probs, normal ? npdf(mean) : 0) * 1.1 || 1;
+	const colW = PW / (n + 1);
+	const xOf = (k) => ML + (k + .5) * colW;
+	const yOf = (v) => 266 - v / yMax * PH;
+	const barW = Math.min(40, colW * .74);
+	useCheckpoint({
+		solved: checked && guess === mode,
+		activity: `binomial:${title}`,
+		hintsUsed: hints.count
+	});
+	useControlSurface(controlId, {
+		n: {
+			type: "number",
+			label: "trials n",
+			min: 1,
+			max: 24,
+			step: 1,
+			get: () => n,
+			set: (v) => {
+				setN(Math.round(v));
+				setChecked(false);
+			}
+		},
+		p: {
+			type: "number",
+			label: "success prob p",
+			min: 0,
+			max: 1,
+			step: .01,
+			get: () => p,
+			set: setP
+		},
+		normal: {
+			type: "boolean",
+			label: "normal overlay",
+			get: () => normal,
+			set: setNormal
+		},
+		inspect: {
+			type: "number",
+			label: "inspect k (−1 clears)",
+			min: -1,
+			max: n,
+			step: 1,
+			get: () => sel ?? -1,
+			set: (v) => setSel(v < 0 ? null : Math.round(v))
+		}
+	});
+	const ticks = n <= 16 ? Array.from({ length: n + 1 }, (_, k) => k) : Array.from({ length: n + 1 }, (_, k) => k).filter((k) => k % 2 === 0);
+	const figure = /* @__PURE__ */ jsx("div", {
+		style: {
+			borderRadius: 14,
+			background: "var(--stage-bg)",
+			border: "1px solid var(--stage-grid)",
+			padding: 8
+		},
+		children: /* @__PURE__ */ jsxs("svg", {
+			viewBox: `0 0 ${W} ${H}`,
+			style: {
+				width: "100%",
+				maxWidth: W,
+				height: "auto",
+				display: "block"
+			},
+			role: "img",
+			"aria-label": `binomial n ${n} p ${p}, most likely ${mode}`,
+			children: [
+				probs.map((pr, k) => {
+					const on = sel === k;
+					return /* @__PURE__ */ jsxs("g", {
+						onClick: () => setSel(on ? null : k),
+						style: { cursor: "pointer" },
+						children: [
+							/* @__PURE__ */ jsx("rect", {
+								x: xOf(k) - colW / 2,
+								y: MT,
+								width: colW,
+								height: PH,
+								fill: "transparent"
+							}),
+							/* @__PURE__ */ jsx("rect", {
+								x: xOf(k) - barW / 2,
+								y: yOf(pr),
+								width: barW,
+								height: Math.max(0, 266 - yOf(pr)),
+								rx: 3,
+								fill: on ? GOOD : `color-mix(in oklab, ${ACC} 78%, transparent)`
+							}),
+							(n <= 16 || on) && /* @__PURE__ */ jsx("text", {
+								x: xOf(k),
+								y: yOf(pr) - 3,
+								textAnchor: "middle",
+								fontSize: 9,
+								fill: "var(--stage-muted)",
+								children: (pr * 100).toFixed(pr < .1 ? 1 : 0)
+							})
+						]
+					}, k);
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: ML,
+					y1: 266,
+					x2: W - MR,
+					y2: 266,
+					stroke: "var(--stage-fg)",
+					strokeWidth: 1.5
+				}),
+				ticks.map((k) => /* @__PURE__ */ jsx("text", {
+					x: xOf(k),
+					y: 280,
+					textAnchor: "middle",
+					fontSize: 10,
+					fill: "var(--stage-muted)",
+					children: k
+				}, k)),
+				/* @__PURE__ */ jsx("line", {
+					x1: xOf(mean),
+					y1: MT,
+					x2: xOf(mean),
+					y2: 266,
+					stroke: GOOD,
+					strokeWidth: 1.5,
+					strokeDasharray: "4 3"
+				}),
+				/* @__PURE__ */ jsxs("text", {
+					x: xOf(mean),
+					y: 25,
+					textAnchor: "middle",
+					fontSize: 10,
+					fontWeight: 700,
+					fill: GOOD,
+					children: ["μ=", mean.toFixed(1)]
+				}),
+				normal && variance > 0 && /* @__PURE__ */ jsx("polyline", {
+					points: Array.from({ length: 121 }, (_, i) => {
+						const x = -.5 + i / 120 * (n + 1);
+						return `${(ML + (x + .5) * colW).toFixed(1)},${yOf(npdf(x)).toFixed(1)}`;
+					}).join(" "),
+					fill: "none",
+					stroke: "var(--stage-warn)",
+					strokeWidth: 2.5,
+					strokeDasharray: "6 4"
+				})
+			]
+		})
+	});
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		aside: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsxs(Callout, {
+				tone: "result",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						style: {
+							fontSize: 12,
+							color: "var(--stage-muted)",
+							fontWeight: 600
+						},
+						children: "most likely"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "lab-callout-big",
+						children: mode
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						style: {
+							fontSize: 12,
+							color: "var(--stage-muted)"
+						},
+						children: [
+							/* @__PURE__ */ jsx(Tex$1, { tex: `\\mu = np = ${mean.toFixed(2)}` }),
+							" · ",
+							/* @__PURE__ */ jsx(Tex$1, { tex: `\\sigma = ${sd.toFixed(2)}` })
+						]
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				style: { fontSize: 13.5 },
+				children: /* @__PURE__ */ jsx(Tex$1, { tex: "P(X=k)=\\binom{n}{k}p^{k}(1-p)^{n-k}" })
+			}),
+			sel != null ? /* @__PURE__ */ jsxs("div", {
+				style: {
+					fontSize: 13.5,
+					padding: "8px 10px",
+					borderRadius: 9,
+					background: "color-mix(in oklab, var(--stage-good) 10%, transparent)",
+					display: "grid",
+					gap: 3
+				},
+				children: [
+					/* @__PURE__ */ jsxs("b", { children: [
+						"P(X=",
+						sel,
+						") = ",
+						f3(probs[sel])
+					] }),
+					/* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(Tex$1, { tex: `= \\binom{${n}}{${sel}} \\cdot ${p}^{${sel}} \\cdot ${(1 - p).toFixed(2)}^{${n - sel}}` }) }),
+					/* @__PURE__ */ jsxs("span", {
+						style: { color: "var(--stage-muted)" },
+						children: [
+							"= ",
+							nCr(n, sel),
+							" ways × (each ",
+							f3(p ** sel * (1 - p) ** (n - sel)),
+							")"
+						]
+					})
+				]
+			}) : /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("p", {
+				className: "lab-prompt",
+				children: "🎯 Which number of successes is most likely? Guess, then check."
+			}), /* @__PURE__ */ jsxs(ControlBar, { children: [
+				/* @__PURE__ */ jsx(Field, {
+					label: "most likely k",
+					children: /* @__PURE__ */ jsx(Stepper, {
+						value: guess,
+						onChange: (v) => {
+							setGuess(v);
+							setChecked(false);
+						},
+						min: 0,
+						max: n
+					})
+				}),
+				/* @__PURE__ */ jsx(CheckButton, {
+					onClick: () => setChecked(true),
+					children: "Check"
+				}),
+				checked && /* @__PURE__ */ jsx(StatusPill, {
+					ok: guess === mode,
+					children: guess === mode ? `✓ ${mode}` : `it's ${mode}`
+				})
+			] })] })
+		] }),
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [
+			/* @__PURE__ */ jsx(Field, {
+				label: "trials n",
+				value: n,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: n,
+					min: 1,
+					max: 24,
+					step: 1,
+					onChange: (v) => {
+						setN(v);
+						setChecked(false);
+					},
+					ariaLabel: "trials"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "success p",
+				value: p.toFixed(2),
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: p,
+					min: 0,
+					max: 1,
+					step: .01,
+					onChange: setP,
+					ariaLabel: "success probability"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "normal",
+				children: /* @__PURE__ */ jsx(Chip, {
+					selected: normal,
+					onClick: () => setNormal((v) => !v),
+					children: "bell overlay"
+				})
+			}),
+			sel != null && /* @__PURE__ */ jsx(Chip, {
+				selected: false,
+				onClick: () => setSel(null),
+				children: "clear inspect"
+			})
+		] }),
+		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("p", {
+			className: "lab-prompt",
+			style: {
+				fontSize: 12.5,
+				color: "var(--stage-muted)"
+			},
+			children: "Coefficients are Pascal's row n; at p = ½ it's that row ÷ 2ⁿ. Crank n with the bell overlay → the binomial becomes the normal (the Galton board)."
+		}), /* @__PURE__ */ jsx(HintLadder, { hints })] }),
+		children: figure
+	});
+}
+
+//#endregion
+export { BinomialDistributionLab };

package/dist/discrete/core/combinatorics.d.mts

@@ -0,0 +1,23 @@
+//#region src/discrete/core/combinatorics.d.ts
+/**
+ * Combinatorics kernel — the counting source-of-truth every discrete-math lab
+ * trusts (so an agent narrates these, never computes its own). Pure, integer,
+ * dependency-free. The headline identity the Counting lab is built on:
+ *   nCr(n,k) = nPr(n,k) / k!   ("overcount by order, then divide it out").
+ */
+declare function factorial(n: number): number;
+/** Ordered selections: n·(n−1)···(n−r+1). */
+declare function nPr(n: number, r: number): number;
+/** Unordered selections: nPr/k!, via the exact step-wise multiplicative form. */
+declare function nCr(n: number, r: number): number;
+/** Binomial coefficient — alias of nCr (the "n choose k"). */
+declare const binomial: typeof nCr;
+/** Arrangements of a multiset: n! / (k1! k2! …), where Σki = n. */
+declare function multinomial(...counts: number[]): number;
+/** Stars and bars: ways to place n identical items into k distinct bins =
+ *  C(n+k−1, k−1). */
+declare function starsAndBars(n: number, k: number): number;
+declare function gcd(a: number, b: number): number;
+declare function lcm(a: number, b: number): number;
+//#endregion
+export { binomial, factorial, gcd, lcm, multinomial, nCr, nPr, starsAndBars };

package/dist/discrete/core/combinatorics.mjs

@@ -0,0 +1,57 @@
+//#region src/discrete/core/combinatorics.ts
+/**
+* Combinatorics kernel — the counting source-of-truth every discrete-math lab
+* trusts (so an agent narrates these, never computes its own). Pure, integer,
+* dependency-free. The headline identity the Counting lab is built on:
+*   nCr(n,k) = nPr(n,k) / k!   ("overcount by order, then divide it out").
+*/
+const isCount = (n) => Number.isInteger(n) && n >= 0;
+function factorial(n) {
+	if (!isCount(n)) return NaN;
+	let r = 1;
+	for (let i = 2; i <= n; i++) r *= i;
+	return r;
+}
+/** Ordered selections: n·(n−1)···(n−r+1). */
+function nPr(n, r) {
+	if (!isCount(n) || !isCount(r) || r > n) return r > n ? 0 : NaN;
+	let r0 = 1;
+	for (let i = 0; i < r; i++) r0 *= n - i;
+	return r0;
+}
+/** Unordered selections: nPr/k!, via the exact step-wise multiplicative form. */
+function nCr(n, r) {
+	if (!isCount(n) || !isCount(r)) return NaN;
+	if (r > n) return 0;
+	const k = Math.min(r, n - r);
+	let res = 1;
+	for (let i = 1; i <= k; i++) res = res * (n - k + i) / i;
+	return Math.round(res);
+}
+/** Binomial coefficient — alias of nCr (the "n choose k"). */
+const binomial = nCr;
+/** Arrangements of a multiset: n! / (k1! k2! …), where Σki = n. */
+function multinomial(...counts) {
+	let res = factorial(counts.reduce((s, c) => s + c, 0));
+	for (const c of counts) res /= factorial(c);
+	return Math.round(res);
+}
+/** Stars and bars: ways to place n identical items into k distinct bins =
+*  C(n+k−1, k−1). */
+function starsAndBars(n, k) {
+	if (!isCount(n) || !isCount(k) || k < 1) return NaN;
+	return nCr(n + k - 1, k - 1);
+}
+function gcd(a, b) {
+	a = Math.abs(a);
+	b = Math.abs(b);
+	while (b) [a, b] = [b, a % b];
+	return a;
+}
+function lcm(a, b) {
+	if (a === 0 || b === 0) return 0;
+	return Math.abs(a / gcd(a, b) * b);
+}
+
+//#endregion
+export { binomial, factorial, gcd, lcm, multinomial, nCr, nPr, starsAndBars };

package/dist/discrete/core/inclusionExclusion.d.mts

@@ -0,0 +1,19 @@
+import { Elem } from "./sets.mjs";
+
+//#region src/discrete/core/inclusionExclusion.d.ts
+interface IETerm {
+  /** Which input sets this term intersects (indices into `sets`). */
+  indices: number[];
+  size: number;
+  /** +1 for odd-sized subsets, −1 for even (the alternating sign). */
+  sign: 1 | -1;
+}
+interface IEResult {
+  /** |A ∪ B ∪ …| via inclusion–exclusion. */
+  unionSize: number;
+  /** The signed terms, in increasing subset size. */
+  terms: IETerm[];
+}
+declare function inclusionExclusion<T extends Elem>(sets: readonly (readonly T[])[]): IEResult;
+//#endregion
+export { IEResult, IETerm, inclusionExclusion };

package/dist/discrete/core/inclusionExclusion.mjs

@@ -0,0 +1,30 @@
+import { intersection } from "./sets.mjs";
+
+//#region src/discrete/core/inclusionExclusion.ts
+function inclusionExclusion(sets) {
+	const n = sets.length;
+	if (n > 16) throw new Error("inclusionExclusion: too many sets (max 16)");
+	const terms = [];
+	let unionSize = 0;
+	for (let mask = 1; mask < 1 << n; mask++) {
+		const indices = [];
+		for (let i = 0; i < n; i++) if (mask & 1 << i) indices.push(i);
+		let acc = sets[indices[0]];
+		for (let j = 1; j < indices.length; j++) acc = intersection(acc, sets[indices[j]]);
+		const sign = indices.length % 2 === 1 ? 1 : -1;
+		terms.push({
+			indices,
+			size: acc.length,
+			sign
+		});
+		unionSize += sign * acc.length;
+	}
+	terms.sort((a, b) => a.indices.length - b.indices.length);
+	return {
+		unionSize,
+		terms
+	};
+}
+
+//#endregion
+export { inclusionExclusion };

package/dist/discrete/core/pigeonhole.d.mts

@@ -0,0 +1,15 @@
+//#region src/discrete/core/pigeonhole.d.ts
+/**
+ * Pigeonhole kernel — the certainty math behind "guarantee ≠ likely". With more
+ * pigeons than holes some hole holds ≥ ⌈n/k⌉. The lab's adversary deals the
+ * worst case; these functions say exactly when a collision is FORCED.
+ */
+/** The guaranteed max occupancy: ⌈pigeons / holes⌉. */
+declare function guaranteedOccupancy(pigeons: number, holes: number): number;
+/** Fewest draws that FORCE a repeat across `holes` categories (k+1). */
+declare function minToGuaranteePair(holes: number): number;
+/** Fewest pigeons that force some hole to reach `occupancy`:
+ *  holes·(occupancy−1) + 1 (the adversary fills every hole to occupancy−1 first). */
+declare function minForOccupancy(holes: number, occupancy: number): number;
+//#endregion
+export { guaranteedOccupancy, minForOccupancy, minToGuaranteePair };

package/dist/discrete/core/pigeonhole.mjs

@@ -0,0 +1,24 @@
+//#region src/discrete/core/pigeonhole.ts
+/**
+* Pigeonhole kernel — the certainty math behind "guarantee ≠ likely". With more
+* pigeons than holes some hole holds ≥ ⌈n/k⌉. The lab's adversary deals the
+* worst case; these functions say exactly when a collision is FORCED.
+*/
+/** The guaranteed max occupancy: ⌈pigeons / holes⌉. */
+function guaranteedOccupancy(pigeons, holes) {
+	if (holes <= 0) return Infinity;
+	return Math.ceil(pigeons / holes);
+}
+/** Fewest draws that FORCE a repeat across `holes` categories (k+1). */
+function minToGuaranteePair(holes) {
+	return holes + 1;
+}
+/** Fewest pigeons that force some hole to reach `occupancy`:
+*  holes·(occupancy−1) + 1 (the adversary fills every hole to occupancy−1 first). */
+function minForOccupancy(holes, occupancy) {
+	if (holes <= 0 || occupancy <= 0) return NaN;
+	return holes * (occupancy - 1) + 1;
+}
+
+//#endregion
+export { guaranteedOccupancy, minForOccupancy, minToGuaranteePair };

package/dist/discrete/core/probability.d.mts

@@ -0,0 +1,29 @@
+//#region src/discrete/core/probability.d.ts
+/**
+ * Probability kernel — equally-likely sample spaces, conditioning, Bayes,
+ * independence, expectation. This is the "truth" the base-rate / Monty labs read
+ * (the agent narrates these numbers; it never invents them). Conditioning =
+ * shrink the sample space: P(A|B) = |A∩B| / |B|.
+ */
+/** Favourable / total over an equally-likely space. */
+declare function probability(favorable: number, total: number): number;
+declare function complement(p: number): number;
+/** P(A|B) = P(A∩B) / P(B) — restrict the world to B, then re-count. */
+declare function conditional(pAandB: number, pB: number): number;
+/**
+ * P(A|B) from the natural inputs: the true-positive rate P(B|A), the prior P(A),
+ * and the false-positive rate P(B|¬A). The base-rate-neglect engine.
+ */
+declare function bayes(pBgivenA: number, pA: number, pBgivenNotA: number): number;
+/** A and B are independent iff P(A∩B) = P(A)·P(B) (within eps). NOT the same as
+ *  disjoint — disjoint events are maximally DEPENDENT. */
+declare function independent(pA: number, pB: number, pAandB: number, eps?: number): boolean;
+/** Expected value Σ p·value (probabilities should sum to 1). */
+declare function expectedValue(outcomes: ReadonlyArray<{
+  p: number;
+  value: number;
+}>): number;
+/** "At least one" via the complement: 1 − (1−p)^n. */
+declare function atLeastOne(pEach: number, n: number): number;
+//#endregion
+export { atLeastOne, bayes, complement, conditional, expectedValue, independent, probability };

package/dist/discrete/core/probability.mjs

@@ -0,0 +1,43 @@
+//#region src/discrete/core/probability.ts
+/**
+* Probability kernel — equally-likely sample spaces, conditioning, Bayes,
+* independence, expectation. This is the "truth" the base-rate / Monty labs read
+* (the agent narrates these numbers; it never invents them). Conditioning =
+* shrink the sample space: P(A|B) = |A∩B| / |B|.
+*/
+/** Favourable / total over an equally-likely space. */
+function probability(favorable, total) {
+	return total > 0 ? favorable / total : NaN;
+}
+function complement(p) {
+	return 1 - p;
+}
+/** P(A|B) = P(A∩B) / P(B) — restrict the world to B, then re-count. */
+function conditional(pAandB, pB) {
+	return pB > 0 ? pAandB / pB : NaN;
+}
+/**
+* P(A|B) from the natural inputs: the true-positive rate P(B|A), the prior P(A),
+* and the false-positive rate P(B|¬A). The base-rate-neglect engine.
+*/
+function bayes(pBgivenA, pA, pBgivenNotA) {
+	const num = pBgivenA * pA;
+	const den = num + pBgivenNotA * (1 - pA);
+	return den > 0 ? num / den : NaN;
+}
+/** A and B are independent iff P(A∩B) = P(A)·P(B) (within eps). NOT the same as
+*  disjoint — disjoint events are maximally DEPENDENT. */
+function independent(pA, pB, pAandB, eps = 1e-9) {
+	return Math.abs(pAandB - pA * pB) <= eps;
+}
+/** Expected value Σ p·value (probabilities should sum to 1). */
+function expectedValue(outcomes) {
+	return outcomes.reduce((s, o) => s + o.p * o.value, 0);
+}
+/** "At least one" via the complement: 1 − (1−p)^n. */
+function atLeastOne(pEach, n) {
+	return 1 - Math.pow(1 - pEach, n);
+}
+
+//#endregion
+export { atLeastOne, bayes, complement, conditional, expectedValue, independent, probability };

package/dist/discrete/core/sets.d.mts

@@ -0,0 +1,21 @@
+//#region src/discrete/core/sets.d.ts
+/**
+ * Finite-set kernel — set algebra over arrays of primitives (the Venn /
+ * inclusion–exclusion labs run on these). De Morgan here mirrors the logic
+ * kernel's De Morgan: ∩↔∧, ∪↔∨, complement↔¬ (the "trinity" spine). Order is
+ * first-seen (insertion) and duplicates are collapsed, so results are clean sets.
+ */
+type Elem = string | number;
+declare function union<T extends Elem>(a: readonly T[], b: readonly T[]): T[];
+declare function intersection<T extends Elem>(a: readonly T[], b: readonly T[]): T[];
+declare function difference<T extends Elem>(a: readonly T[], b: readonly T[]): T[];
+declare function symmetricDifference<T extends Elem>(a: readonly T[], b: readonly T[]): T[];
+/** Aᶜ within a universe. */
+declare function complement<T extends Elem>(a: readonly T[], universe: readonly T[]): T[];
+declare function isSubset<T extends Elem>(a: readonly T[], b: readonly T[]): boolean;
+declare function setEqual<T extends Elem>(a: readonly T[], b: readonly T[]): boolean;
+/** All 2^|a| subsets. */
+declare function powerset<T extends Elem>(a: readonly T[]): T[][];
+declare function cartesian<A extends Elem, B extends Elem>(a: readonly A[], b: readonly B[]): [A, B][];
+//#endregion
+export { Elem, cartesian, complement, difference, intersection, isSubset, powerset, setEqual, symmetricDifference, union };

package/dist/discrete/core/sets.mjs

@@ -0,0 +1,45 @@
+//#region src/discrete/core/sets.ts
+const dedupe = (xs) => [...new Set(xs)];
+function union(a, b) {
+	return dedupe([...a, ...b]);
+}
+function intersection(a, b) {
+	const bs = new Set(b);
+	return dedupe(a.filter((x) => bs.has(x)));
+}
+function difference(a, b) {
+	const bs = new Set(b);
+	return dedupe(a.filter((x) => !bs.has(x)));
+}
+function symmetricDifference(a, b) {
+	return union(difference(a, b), difference(b, a));
+}
+/** Aᶜ within a universe. */
+function complement(a, universe) {
+	return difference(universe, a);
+}
+function isSubset(a, b) {
+	const bs = new Set(b);
+	return dedupe(a).every((x) => bs.has(x));
+}
+function setEqual(a, b) {
+	return isSubset(a, b) && isSubset(b, a);
+}
+/** All 2^|a| subsets. */
+function powerset(a) {
+	const s = dedupe(a);
+	const out = [[]];
+	for (const x of s) {
+		const len = out.length;
+		for (let i = 0; i < len; i++) out.push([...out[i], x]);
+	}
+	return out;
+}
+function cartesian(a, b) {
+	const out = [];
+	for (const x of a) for (const y of b) out.push([x, y]);
+	return out;
+}
+
+//#endregion
+export { cartesian, complement, difference, intersection, isSubset, powerset, setEqual, symmetricDifference, union };

package/dist/discrete/counting-slots/preset.d.mts

@@ -0,0 +1,30 @@
+import { ReactNode } from "react";
+
+//#region src/discrete/counting-slots/preset.d.ts
+type SlotMode = 'arrange' | 'choose';
+interface CountingSlotsProps {
+  items?: string[];
+  slots?: number;
+  positions?: string[];
+  mode?: SlotMode;
+  replacement?: boolean;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  hints?: string[];
+  controlId?: string;
+}
+declare function CountingSlotsLab({
+  items,
+  slots,
+  positions,
+  mode: mode0,
+  replacement: repl0,
+  title,
+  prompt,
+  objectives,
+  hints: hintList,
+  controlId
+}: CountingSlotsProps): ReactNode;
+//#endregion
+export { CountingSlotsLab, CountingSlotsProps, SlotMode };