@classytic/labs 0.1.0 → 0.2.0

package/dist/discrete/counting-slots/preset.mjs

@@ -11,9 +11,9 @@ import { useControlSurface } from "@classytic/stage";
 
 //#region src/discrete/counting-slots/preset.tsx
 /**
-* CountingSlotsLab — counting made concrete, the FUN way (the tree drowns past ~8
+* CountingSlotsLab, counting made concrete, the FUN way (the tree drowns past ~8
 * leaves; this scales and reads friendly). The multiplication principle as filling
-* a row of POSITIONS: fill slot 1 from the whole pool, slot 2 from what's left, … —
+* a row of POSITIONS: fill slot 1 from the whole pool, slot 2 from what's left, … , 
 * the pool shrinks, the product builds (4 × 3 × 2). It covers the whole family from
 * one model:
 *   • arrange (order matters)      → permutations nPr  (k = n ⇒ factorial n!)
@@ -139,7 +139,7 @@ function CountingSlotsLab({ items = [
 			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs("p", {
 				className: "lab-field-label",
 				children: [
-					"the pool — ",
+					"the pool, ",
 					n,
 					" to pick from",
 					!repl && ", each used once"
@@ -176,7 +176,7 @@ function CountingSlotsLab({ items = [
 					" position",
 					k === 1 ? "" : "s",
 					" to fill ",
-					mode === "choose" ? "(a group — order won't matter)" : "(in order)"
+					mode === "choose" ? "(a group, order won't matter)" : "(in order)"
 				]
 			}), /* @__PURE__ */ jsx("div", {
 				style: {
@@ -244,7 +244,7 @@ function CountingSlotsLab({ items = [
 						fontWeight: 500,
 						fontSize: 14
 					},
-					children: "Fill the first slot — how many choices?"
+					children: "Fill the first slot, how many choices?"
 				}) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
 					/* @__PURE__ */ jsx(Tex$1, { tex: Array.from({ length: step }, (_, i) => choices(i)).join(" \\times ") }),
 					step < k && /* @__PURE__ */ jsxs("span", {
@@ -277,7 +277,7 @@ function CountingSlotsLab({ items = [
 				children: [
 					/* @__PURE__ */ jsx("p", {
 						className: "lab-field-label",
-						children: "order doesn't matter — these are all the SAME group"
+						children: "order doesn't matter, these are all the SAME group"
 					}),
 					factorial(k) <= 8 ? /* @__PURE__ */ jsxs("div", {
 						style: {
@@ -324,7 +324,7 @@ function CountingSlotsLab({ items = [
 							k,
 							"! = ",
 							factorial(k),
-							" ways — all the same selection."
+							" ways, all the same selection."
 						]
 					}),
 					/* @__PURE__ */ jsxs("p", {
@@ -460,7 +460,7 @@ function CountingSlotsLab({ items = [
 			}),
 			checked && /* @__PURE__ */ jsx(StatusPill, {
 				ok: guess === total,
-				children: guess === total ? "✓ right!" : "not yet — fill the slots"
+				children: guess === total ? "✓ right!" : "not yet, fill the slots"
 			})
 		] })] })] }),
 		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [

package/dist/discrete/counting-tree/preset.mjs

@@ -3,7 +3,7 @@
 import { Tex as Tex$1 } from "../../core/tex.mjs";
 import { CheckButton, Chip, StatusPill, Stepper } from "../../kit/controls.mjs";
 import { ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
-import { HintLadder, RevealSolution, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
+import { ChallengeCard, HintLadder, RevealSolution, useChallenge, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
 import { factorial } from "../core/combinatorics.mjs";
 import { Fragment, useMemo, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
@@ -11,7 +11,7 @@ import { Dot, Label, Segment, Stage, useControlSurface, useLearner } from "@clas
 
 //#region src/discrete/counting-tree/preset.tsx
 /**
-* CountingTree — the GENERAL sequential-counting + probability-tree tool. One
+* CountingTree, the GENERAL sequential-counting + probability-tree tool. One
 * model covers the multiplication principle, permutations (draw without
 * replacement → n·(n−1)·…), with-replacement counts (nᵏ), the
 * permutation→combination collapse (÷k!), AND probability trees (multiply the
@@ -20,9 +20,9 @@ import { Dot, Label, Segment, Stage, useControlSurface, useLearner } from "@clas
 * an agent narrates and never invents.
 *
 * Two authoring forms:
-*   • `stages`  — explicit uniform-per-stage branches (general multiplication /
+*   • `stages` , explicit uniform-per-stage branches (general multiplication /
 *                 independent probability, e.g. flip a coin 3×).
-*   • `pool`+`draws`+`replacement` — draw k items from a pool; replacement off
+*   • `pool`+`draws`+`replacement`, draw k items from a pool; replacement off
 *                 ⇒ a permutation tree (5·4·3), on ⇒ nᵏ.
 */
 const MAX_LEAVES = 28;
@@ -141,9 +141,61 @@ function CountingTreeLab({ stages, pool, draws = 2, replacement = false, mode =
 		stages
 	]);
 	const target = ask === "unordered" ? unorderedTotal : orderedTotal;
+	const predictQ = useMemo(() => {
+		if (mode !== "count") return [];
+		const n = pool ? pool.length : 0;
+		const withRepl = pool ? Math.pow(n, draws) : 0;
+		const kFact = factorial(k);
+		const addTrap = pool ? n * draws : 0;
+		const prompt = pool ? `Filling ${draws} ranked ${draws === 1 ? "spot" : "spots"} from ${n} ${n === 1 ? "option" : "options"}, ${replacement ? "reuse allowed" : "with no repeats"} — how many ${ask === "unordered" ? "unordered selections" : "ordered outcomes"} are there?` : `Working down ${k} ${k === 1 ? "stage" : "stages"} of choices, how many ${ask === "unordered" ? "unordered selections" : "ordered paths"} does the tree end with?`;
+		const distractors = [
+			withRepl,
+			kFact,
+			addTrap,
+			target + 1,
+			target * 2
+		].filter((v) => Number.isFinite(v) && v > 0 && v !== target);
+		const seen = new Set([target]);
+		const choiceVals = [target];
+		for (const v of distractors) {
+			if (!seen.has(v)) {
+				seen.add(v);
+				choiceVals.push(v);
+			}
+			if (choiceVals.length >= 3) break;
+		}
+		choiceVals.sort((a, b) => a - b);
+		return [{
+			id: "predict-count",
+			prompt,
+			choices: choiceVals.map((v) => ({
+				value: String(v),
+				label: String(v)
+			})),
+			answer: String(target),
+			explain: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				"Multiply a ",
+				/* @__PURE__ */ jsx("b", { children: "shrinking pool" }),
+				": ",
+				/* @__PURE__ */ jsx(Tex$1, { tex: `${factorStr}${ask === "unordered" ? ` \\div ${k}!` : ""} = ${target}` }),
+				"."
+			] })
+		}];
+	}, [
+		mode,
+		pool,
+		draws,
+		replacement,
+		ask,
+		k,
+		target,
+		orderedTotal,
+		factorStr
+	]);
+	const ch = useChallenge(predictQ);
 	const solved = mode === "count" ? checked && guess === target && !peeked : false;
 	useCheckpoint({
-		solved,
+		solved: solved || ch.allCorrect,
 		activity: `counting-tree:${title}`,
 		hintsUsed: hints.count
 	});
@@ -260,7 +312,7 @@ function CountingTreeLab({ stages, pool, draws = 2, replacement = false, mode =
 		children: [
 			"Tree truncated at ",
 			MAX_LEAVES,
-			" paths — shrink the pool/draws to see it all."
+			" paths, shrink the pool/draws to see it all."
 		]
 	})] });
 	return /* @__PURE__ */ jsx(LabFrame, {
@@ -286,7 +338,7 @@ function CountingTreeLab({ stages, pool, draws = 2, replacement = false, mode =
 			}),
 			checked && /* @__PURE__ */ jsx(StatusPill, {
 				ok: guess === target,
-				children: guess === target ? `✓ ${target}` : `Not yet — count the branches`
+				children: guess === target ? `✓ ${target}` : `Not yet, count the branches`
 			}),
 			built.leafPaths.length <= 16 && /* @__PURE__ */ jsxs(Field, {
 				label: "Trace each path",
@@ -326,6 +378,11 @@ function CountingTreeLab({ stages, pool, draws = 2, replacement = false, mode =
 			]
 		})] }),
 		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			predictQ.length > 0 && /* @__PURE__ */ jsx(ChallengeCard, {
+				questions: predictQ,
+				state: ch,
+				title: "Predict first"
+			}),
 			mode === "count" && checked && /* @__PURE__ */ jsxs("p", {
 				className: "lab-prompt",
 				children: [
@@ -348,7 +405,7 @@ function CountingTreeLab({ stages, pool, draws = 2, replacement = false, mode =
 				solution: /* @__PURE__ */ jsxs(Fragment$1, { children: [
 					"The count is ",
 					/* @__PURE__ */ jsx("b", { children: target }),
-					" — ",
+					", ",
 					/* @__PURE__ */ jsx(Tex$1, { tex: `${factorStr}${ask === "unordered" ? ` \\div ${k}!` : ""}` }),
 					"."
 				] }),

package/dist/discrete/expected-value/preset.mjs

@@ -4,33 +4,27 @@ import { mulberry32 } from "../../core/rng.mjs";
 import { Tex as Tex$1 } from "../../core/tex.mjs";
 import { Chip, Slider, Stepper } from "../../kit/controls.mjs";
 import { Callout, ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
-import { HintLadder, useHints } from "../../kit/pedagogy.mjs";
+import { HintLadder, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
 import { expectedValue } from "../core/probability.mjs";
+import { CATEGORICAL } from "../../kit/palette.mjs";
 import { useMemo, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { useControlSurface } from "@classytic/stage";
 
 //#region src/discrete/expected-value/preset.tsx
 /**
-* ExpectedValueLab — E[X] = Σ value·prob, made physical: each outcome is a WEIGHT
+* ExpectedValueLab, E[X] = Σ value·prob, made physical: each outcome is a WEIGHT
 * (heavier = more likely) sitting at its value on a number line, and the expected
 * value is exactly where they BALANCE (the long-run average payout). Framed as "is
 * this game worth it?": a cost marker shows the house edge when E[X] < cost. Then
 * SPIN it many times and watch the running average settle onto E[X] (the law of
-* large numbers — the average is the expectation, earned).
+* large numbers, the average is the expectation, earned).
 *
 * Drag the probabilities/values; the fulcrum slides. Kernel = expectedValue; seeded
 * rng for replayable spins.
 */
 const W = 520, H = 210, ML = 30, MR = 20, AXIS = 138;
-const PAL = [
-	"#1c7ed6",
-	"#2f9e44",
-	"#e8590c",
-	"#9c36b5",
-	"#0ca678",
-	"#e03131"
-];
+const PAL = CATEGORICAL;
 function ExpectedValueLab({ outcomes = [
 	{
 		label: "lose",
@@ -47,7 +41,7 @@ function ExpectedValueLab({ outcomes = [
 		value: 50,
 		prob: .05
 	}
-], cost = 5, title = "Expected value — is the game fair?", prompt, objectives, hints: hintList, controlId }) {
+], cost = 5, title = "Expected value: is the game fair?", prompt, objectives, hints: hintList, controlId }) {
 	const [probs, setProbs] = useState(outcomes.map((o) => o.prob));
 	const [vals, setVals] = useState(outcomes.map((o) => o.value));
 	const [plays, setPlays] = useState(0);
@@ -63,6 +57,12 @@ function ExpectedValueLab({ outcomes = [
 	const lo = Math.min(0, ...vals), hi = Math.max(...vals, cost) * 1.12 || 1;
 	const xOf = (v) => ML + (v - lo) / (hi - lo) * (W - ML - MR);
 	const avg = plays ? total / plays : null;
+	const tol = Math.max(.5, Math.abs(ev) * .05);
+	useCheckpoint({
+		solved: plays >= 30 && avg != null && Math.abs(avg - ev) <= tol,
+		activity: `expected-value:${title}`,
+		hintsUsed: hints?.count ?? 0
+	});
 	const spin = (times) => {
 		let t = total, c = plays;
 		for (let s = 0; s < times; s++) {
@@ -281,7 +281,7 @@ function ExpectedValueLab({ outcomes = [
 			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("p", {
 				className: "lab-prompt",
 				style: { fontSize: 13 },
-				children: "Play it for real — the average payout homes in on E[X]."
+				children: "Play it for real, the average payout homes in on E[X]."
 			}), /* @__PURE__ */ jsxs(ControlBar, { children: [
 				/* @__PURE__ */ jsx(Chip, {
 					selected: false,

package/dist/discrete/hypergeometric/preset.mjs

@@ -3,7 +3,7 @@
 import { Tex as Tex$1 } from "../../core/tex.mjs";
 import { Slider } from "../../kit/controls.mjs";
 import { Callout, ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
-import { HintLadder, useHints } from "../../kit/pedagogy.mjs";
+import { ChallengeCard, HintLadder, useChallenge, 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";
@@ -11,12 +11,12 @@ import { useControlSurface } from "@classytic/stage";
 
 //#region src/discrete/hypergeometric/preset.tsx
 /**
-* HypergeometricLab — does it matter whether you put the ball back? Same urn (K
+* HypergeometricLab, does it matter whether you put the ball back? Same urn (K
 * winners in N), draw n, and compare the two distributions of "how many winners":
 *   • WITH replacement  → binomial   C(n,k) pᵏ(1−p)ⁿ⁻ᵏ,  p = K/N  (draws independent)
 *   • WITHOUT            → hypergeometric  C(K,k)·C(N−K,n−k) / C(N,n)
 * Drawn as paired bars. The lesson lives in the difference: without replacement is
-* NARROWER (each draw shifts the odds — a finite-population correction (N−n)/(N−1)),
+* NARROWER (each draw shifts the odds, a finite-population correction (N−n)/(N−1)),
 * but as the population N grows huge the two distributions merge (taking one ball
 * barely changes the mix). Both share the same mean n·K/N.
 *
@@ -26,12 +26,37 @@ const W = 540, H = 300, ML = 30, MR = 14, MT = 16, MB = 34;
 const PW = W - ML - MR, PH = H - MT - MB;
 const BIN = "var(--stage-accent)", HYP = "var(--stage-warn)";
 const f3 = (x) => x < 5e-4 && x > 0 ? x.toExponential(1) : x.toFixed(3);
+const Q = [{
+	id: "narrower",
+	prompt: "Same urn, draw n. One version puts each ball BACK (independent draws), the other does NOT. Which distribution of 'number of winners' is NARROWER (less spread)?",
+	choices: [
+		{
+			value: "without",
+			label: "WITHOUT replacement (hypergeometric)"
+		},
+		{
+			value: "with",
+			label: "WITH replacement (binomial)"
+		},
+		{
+			value: "same",
+			label: "identical spread"
+		}
+	],
+	answer: "without",
+	explain: "Without replacement is narrower. Each draw removes a ball and shifts the odds for the next, so draws are negatively correlated. That shrinks the variance by the finite-population correction (N−n)/(N−1) < 1: varHyp = varBin · (N−n)/(N−1). The means stay identical at n·K/N; only the spread differs, and the two converge as N grows huge."
+}];
 function HypergeometricLab({ N: N0 = 10, K: K0 = 4, n: n0 = 3, title = "With vs without replacement", prompt, objectives, hints: hintList, controlId }) {
 	const [N, setN] = useState(N0);
 	const [K, setK] = useState(K0);
 	const [n, setN_] = useState(n0);
 	const [sel, setSel] = useState(null);
 	const hints = useHints(hintList);
+	const ch = useChallenge(Q);
+	useCheckpoint({
+		solved: ch.allCorrect,
+		activity: "hypergeometric:predict"
+	});
 	const Kc = Math.min(K, N), nc = Math.min(n, N);
 	const p = Kc / N;
 	const bin = useMemo(() => Array.from({ length: nc + 1 }, (_, k) => nCr(nc, k) * p ** k * (1 - p) ** (nc - k)), [nc, p]);
@@ -310,18 +335,26 @@ function HypergeometricLab({ N: N0 = 10, K: K0 = 4, n: n0 = 3, title = "With vs
 				})
 			})
 		] }),
-		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("p", {
-			className: "lab-prompt",
-			style: {
-				fontSize: 12.5,
-				color: "var(--stage-muted)"
-			},
-			children: [
-				"Without replacement is narrower by the factor (N−n)/(N−1) = ",
-				((N - nc) / (N - 1 || 1)).toFixed(2),
-				". Push N up (with K/N fixed) and the bars converge — for a huge population, taking one out barely changes the odds."
-			]
-		}), /* @__PURE__ */ jsx(HintLadder, { hints })] }),
+		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(ChallengeCard, {
+				questions: Q,
+				state: ch,
+				title: "Predict first"
+			}),
+			/* @__PURE__ */ jsxs("p", {
+				className: "lab-prompt",
+				style: {
+					fontSize: 12.5,
+					color: "var(--stage-muted)"
+				},
+				children: [
+					"Without replacement is narrower by the factor (N−n)/(N−1) = ",
+					((N - nc) / (N - 1 || 1)).toFixed(2),
+					". Push N up (with K/N fixed) and the bars converge, for a huge population, taking one out barely changes the odds."
+				]
+			}),
+			/* @__PURE__ */ jsx(HintLadder, { hints })
+		] }),
 		children: figure
 	});
 }

package/dist/discrete/index.d.mts

@@ -1,9 +1,10 @@
-import { binomial, factorial, gcd, lcm, multinomial, nCr, nPr, starsAndBars } from "./core/combinatorics.mjs";
+import { binomial, circularPermutations, combinationsWithRepetition, factorial, gcd, lcm, multichoose, multinomial, nCr, nPr, permutationsWithRepetition, ruleOfProduct, ruleOfSum, starsAndBars } from "./core/combinatorics.mjs";
 import { Elem, cartesian, complement, difference, intersection, isSubset, powerset, setEqual, symmetricDifference, union } from "./core/sets.mjs";
 import { IEResult, IETerm, inclusionExclusion } from "./core/inclusionExclusion.mjs";
 import { atLeastOne, bayes, complement as complement$1, conditional, expectedValue, independent, probability } from "./core/probability.mjs";
 import { guaranteedOccupancy, minForOccupancy, minToGuaranteePair } from "./core/pigeonhole.mjs";
 import { Rng, mulberry32, randInt, sample, shuffle } from "../core/rng.mjs";
+import { COMBINATION_RULE, COUNTING_RULES, FACTORIAL_RULE, PERMUTATION_RULE, PERM_REP_RULE, PRODUCT_RULE, SUM_RULE, explainFactorial, explainNCr, explainNPr, explainPermWithRep, explainProduct, explainSum } from "./rules.mjs";
 import { TruthTableLab, TruthTableMode, TruthTableProps } from "./truth-table/preset.mjs";
 import { CountAsk, CountingTreeLab, CountingTreeProps, TreeBranch, TreeStage } from "./counting-tree/preset.mjs";
 import { VennMode, VennSet, VennSetBoardLab, VennSetBoardProps } from "./venn/preset.mjs";
@@ -13,6 +14,7 @@ import { KMapMode, KMapProps, KarnaughMapLab } from "./karnaugh/preset.mjs";
 import { ExperimentSpec, MCSeries, MonteCarloLab, MonteCarloProps } from "./monte-carlo/preset.mjs";
 import { MontyHallLab, MontyHallProps } from "./monty-hall/preset.mjs";
 import { OutcomeBuilderLab, OutcomeBuilderProps } from "./outcome-builder/preset.mjs";
+import { CombinationStudioLab, CombinationStudioProps, ComboCategory, ComboOption } from "./combination-studio/preset.mjs";
 import { BayesLab, BayesProps } from "./bayes/preset.mjs";
 import { LawOfLargeNumbersLab, LlnProps } from "./lln/preset.mjs";
 import { CountingSlotsLab, CountingSlotsProps, SlotMode } from "./counting-slots/preset.mjs";
@@ -23,4 +25,4 @@ import { BinomialDistributionLab, BinomialProps } from "./binomial/preset.mjs";
 import { HypergeometricLab, HypergeometricProps } from "./hypergeometric/preset.mjs";
 import { EVOutcome, ExpectedValueLab, ExpectedValueProps } from "./expected-value/preset.mjs";
 import { Classification, CompiledLogic, Cube, LNode, LogicResult, Minimization, TruthRow, TruthTable, classify, compileLogic, cubeCovers, cubeOfSelection, cubeTerm, equivalent, evalBool, logicToLatex, minimalCover, minimize, parseLogic, primeImplicants, toCNF, toDNF, truthTable } from "@classytic/stage";
-export { type ArrangeItem, ArrangementsLab, type ArrangementsProps, BayesLab, type BayesProps, BinomialDistributionLab, type BinomialProps, BooleanCircuitLab, type BooleanCircuitProps, type CircuitGate, type CircuitInput, type CircuitOutput, type Classification, type Cmp, type CompiledLogic, type CountAsk, CountingSlotsLab, type CountingSlotsProps, CountingTreeLab, type CountingTreeProps, type Cube, type EVOutcome, type Elem, ExpectedValueLab, type ExpectedValueProps, type ExperimentSpec, HypergeometricLab, type HypergeometricProps, type IEResult, type IETerm, type KMapMode, type KMapProps, KarnaughMapLab, type LNode, LawOfLargeNumbersLab, type LlnProps, type LogicResult, type MCSeries, type Minimization, MonteCarloLab, type MonteCarloProps, MontyHallLab, type MontyHallProps, OutcomeBuilderLab, type OutcomeBuilderProps, type PascalProps, PascalTriangleLab, type PascalView, type Reduce, type Rng, type SampleEvent, SampleSpaceBoardLab, type SampleSpaceProps, type SelectionGroup, SelectionLab, type SelectionMode, type SelectionProps, type SlotMode, type TreeBranch, type TreeStage, type TruthRow, type TruthTable, TruthTableLab, type TruthTableMode, type TruthTableProps, type VennMode, type VennSet, VennSetBoardLab, type VennSetBoardProps, atLeastOne, bayes, binomial, cartesian, classify, compileLogic, complement, conditional, cubeCovers, cubeOfSelection, cubeTerm, difference, equivalent, evalBool, expectedValue, factorial, gcd, guaranteedOccupancy, inclusionExclusion, independent, intersection, isSubset, lcm, logicToLatex, minForOccupancy, minToGuaranteePair, minimalCover, minimize, mulberry32, multinomial, nCr, nPr, parseLogic, powerset, primeImplicants, complement$1 as probComplement, probability, randInt, sample, setEqual, shuffle, starsAndBars, symmetricDifference, toCNF, toDNF, truthTable, union };
+export { type ArrangeItem, ArrangementsLab, type ArrangementsProps, BayesLab, type BayesProps, BinomialDistributionLab, type BinomialProps, BooleanCircuitLab, type BooleanCircuitProps, COMBINATION_RULE, COUNTING_RULES, type CircuitGate, type CircuitInput, type CircuitOutput, type Classification, type Cmp, CombinationStudioLab, type CombinationStudioProps, type ComboCategory, type ComboOption, type CompiledLogic, type CountAsk, CountingSlotsLab, type CountingSlotsProps, CountingTreeLab, type CountingTreeProps, type Cube, type EVOutcome, type Elem, ExpectedValueLab, type ExpectedValueProps, type ExperimentSpec, FACTORIAL_RULE, HypergeometricLab, type HypergeometricProps, type IEResult, type IETerm, type KMapMode, type KMapProps, KarnaughMapLab, type LNode, LawOfLargeNumbersLab, type LlnProps, type LogicResult, type MCSeries, type Minimization, MonteCarloLab, type MonteCarloProps, MontyHallLab, type MontyHallProps, OutcomeBuilderLab, type OutcomeBuilderProps, PERMUTATION_RULE, PERM_REP_RULE, PRODUCT_RULE, type PascalProps, PascalTriangleLab, type PascalView, type Reduce, type Rng, SUM_RULE, type SampleEvent, SampleSpaceBoardLab, type SampleSpaceProps, type SelectionGroup, SelectionLab, type SelectionMode, type SelectionProps, type SlotMode, type TreeBranch, type TreeStage, type TruthRow, type TruthTable, TruthTableLab, type TruthTableMode, type TruthTableProps, type VennMode, type VennSet, VennSetBoardLab, type VennSetBoardProps, atLeastOne, bayes, binomial, cartesian, circularPermutations, classify, combinationsWithRepetition, compileLogic, complement, conditional, cubeCovers, cubeOfSelection, cubeTerm, difference, equivalent, evalBool, expectedValue, explainFactorial, explainNCr, explainNPr, explainPermWithRep, explainProduct, explainSum, factorial, gcd, guaranteedOccupancy, inclusionExclusion, independent, intersection, isSubset, lcm, logicToLatex, minForOccupancy, minToGuaranteePair, minimalCover, minimize, mulberry32, multichoose, multinomial, nCr, nPr, parseLogic, permutationsWithRepetition, powerset, primeImplicants, complement$1 as probComplement, probability, randInt, ruleOfProduct, ruleOfSum, sample, setEqual, shuffle, starsAndBars, symmetricDifference, toCNF, toDNF, truthTable, union };

package/dist/discrete/index.mjs

@@ -1,9 +1,10 @@
 import { mulberry32, randInt, sample, shuffle } from "../core/rng.mjs";
-import { binomial, factorial, gcd, lcm, multinomial, nCr, nPr, starsAndBars } from "./core/combinatorics.mjs";
+import { binomial, circularPermutations, combinationsWithRepetition, factorial, gcd, lcm, multichoose, multinomial, nCr, nPr, permutationsWithRepetition, ruleOfProduct, ruleOfSum, starsAndBars } from "./core/combinatorics.mjs";
 import { cartesian, complement, difference, intersection, isSubset, powerset, setEqual, symmetricDifference, union } from "./core/sets.mjs";
 import { inclusionExclusion } from "./core/inclusionExclusion.mjs";
 import { atLeastOne, bayes, complement as complement$1, conditional, expectedValue, independent, probability } from "./core/probability.mjs";
 import { guaranteedOccupancy, minForOccupancy, minToGuaranteePair } from "./core/pigeonhole.mjs";
+import { COMBINATION_RULE, COUNTING_RULES, FACTORIAL_RULE, PERMUTATION_RULE, PERM_REP_RULE, PRODUCT_RULE, SUM_RULE, explainFactorial, explainNCr, explainNPr, explainPermWithRep, explainProduct, explainSum } from "./rules.mjs";
 import { TruthTableLab } from "./truth-table/preset.mjs";
 import { CountingTreeLab } from "./counting-tree/preset.mjs";
 import { VennSetBoardLab } from "./venn/preset.mjs";
@@ -13,6 +14,7 @@ import { KarnaughMapLab } from "./karnaugh/preset.mjs";
 import { MonteCarloLab } from "./monte-carlo/preset.mjs";
 import { MontyHallLab } from "./monty-hall/preset.mjs";
 import { OutcomeBuilderLab } from "./outcome-builder/preset.mjs";
+import { CombinationStudioLab } from "./combination-studio/preset.mjs";
 import { BayesLab } from "./bayes/preset.mjs";
 import { LawOfLargeNumbersLab } from "./lln/preset.mjs";
 import { CountingSlotsLab } from "./counting-slots/preset.mjs";
@@ -24,4 +26,4 @@ import { HypergeometricLab } from "./hypergeometric/preset.mjs";
 import { ExpectedValueLab } from "./expected-value/preset.mjs";
 import { classify, compileLogic, cubeCovers, cubeOfSelection, cubeTerm, equivalent, evalBool, logicToLatex, minimalCover, minimize, parseLogic, primeImplicants, toCNF, toDNF, truthTable } from "@classytic/stage";
 
-export { ArrangementsLab, BayesLab, BinomialDistributionLab, BooleanCircuitLab, CountingSlotsLab, CountingTreeLab, ExpectedValueLab, HypergeometricLab, KarnaughMapLab, LawOfLargeNumbersLab, MonteCarloLab, MontyHallLab, OutcomeBuilderLab, PascalTriangleLab, SampleSpaceBoardLab, SelectionLab, TruthTableLab, VennSetBoardLab, atLeastOne, bayes, binomial, cartesian, classify, compileLogic, complement, conditional, cubeCovers, cubeOfSelection, cubeTerm, difference, equivalent, evalBool, expectedValue, factorial, gcd, guaranteedOccupancy, inclusionExclusion, independent, intersection, isSubset, lcm, logicToLatex, minForOccupancy, minToGuaranteePair, minimalCover, minimize, mulberry32, multinomial, nCr, nPr, parseLogic, powerset, primeImplicants, complement$1 as probComplement, probability, randInt, sample, setEqual, shuffle, starsAndBars, symmetricDifference, toCNF, toDNF, truthTable, union };
+export { ArrangementsLab, BayesLab, BinomialDistributionLab, BooleanCircuitLab, COMBINATION_RULE, COUNTING_RULES, CombinationStudioLab, CountingSlotsLab, CountingTreeLab, ExpectedValueLab, FACTORIAL_RULE, HypergeometricLab, KarnaughMapLab, LawOfLargeNumbersLab, MonteCarloLab, MontyHallLab, OutcomeBuilderLab, PERMUTATION_RULE, PERM_REP_RULE, PRODUCT_RULE, PascalTriangleLab, SUM_RULE, SampleSpaceBoardLab, SelectionLab, TruthTableLab, VennSetBoardLab, atLeastOne, bayes, binomial, cartesian, circularPermutations, classify, combinationsWithRepetition, compileLogic, complement, conditional, cubeCovers, cubeOfSelection, cubeTerm, difference, equivalent, evalBool, expectedValue, explainFactorial, explainNCr, explainNPr, explainPermWithRep, explainProduct, explainSum, factorial, gcd, guaranteedOccupancy, inclusionExclusion, independent, intersection, isSubset, lcm, logicToLatex, minForOccupancy, minToGuaranteePair, minimalCover, minimize, mulberry32, multichoose, multinomial, nCr, nPr, parseLogic, permutationsWithRepetition, powerset, primeImplicants, complement$1 as probComplement, probability, randInt, ruleOfProduct, ruleOfSum, sample, setEqual, shuffle, starsAndBars, symmetricDifference, toCNF, toDNF, truthTable, union };

package/dist/discrete/karnaugh/preset.mjs

@@ -4,42 +4,36 @@ import { Tex as Tex$1 } from "../../core/tex.mjs";
 import { Chip } from "../../kit/controls.mjs";
 import { LabFrame } from "../../kit/frame.mjs";
 import { HintLadder, RevealSolution, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
+import { CATEGORICAL } from "../../kit/palette.mjs";
 import { useMemo, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { compileLogic, cubeCovers, cubeOfSelection, cubeTerm, logicToLatex, minimize, useControlSurface } from "@classytic/stage";
 
 //#region src/discrete/karnaugh/preset.tsx
 /**
-* KarnaughMapLab — the GENERAL "simplify boolean by eye" tool. A K-map is just a
+* KarnaughMapLab, the GENERAL "simplify boolean by eye" tool. A K-map is just a
 * truth table re-laid in GRAY-CODE order so that adjacent cells differ in ONE
 * variable; circling a power-of-two block of 1s drops the variable that changes
 * across it. That is the same "overcount, then correct" move as the rest of the
-* pack — a group merges redundant minterms the way ÷k! merges redundant orderings.
+* pack, a group merges redundant minterms the way ÷k! merges redundant orderings.
 *
 * Creator declares a `formula` (any 2–4 variable expression) OR explicit
 * `minterms` (+ optional `dontCares`). Two modes:
-*   • show     — the kernel's minimal cover is drawn as coloured loops + the SOP.
-*   • simplify — the learner taps 1-cells to draw their own groups; each is
+*   • show    , the kernel's minimal cover is drawn as coloured loops + the SOP.
+*   • simplify, the learner taps 1-cells to draw their own groups; each is
 *                live-validated (legal sub-cube? all ones?) and its product term
 *                shown; solved when every 1 is covered, with a "minimal!" bonus.
 *
 * Minimisation is Quine–McCluskey in the stage logic kernel (`minimize` /
-* `cubeOfSelection`) — the map only RENDERS what the kernel computes. Groups that
+* `cubeOfSelection`), the map only RENDERS what the kernel computes. Groups that
 * wrap the map edges render as two (or four) loops, exactly as on paper.
 */
 const CS = 50;
 const LH = 50, TH = 46;
-const PALETTE = [
-	"#2f9e44",
-	"#1c7ed6",
-	"#e8590c",
-	"#9c36b5",
-	"#1098ad",
-	"#e03131"
-];
+const PALETTE = CATEGORICAL;
 const gray = (i) => i ^ i >> 1;
 const bits = (v, n) => v.toString(2).padStart(n, "0");
-/** Maximal consecutive runs of sorted indices (wrap shows as two runs — desired). */
+/** Maximal consecutive runs of sorted indices (wrap shows as two runs, desired). */
 function runs(idx) {
 	const s = [...idx].sort((a, b) => a - b);
 	const out = [];
@@ -205,11 +199,11 @@ function KarnaughMapLab({ formula, minterms: mtIn, dontCares: dcIn = [], vars: v
 		viewBox: `0 0 ${W} ${H}`,
 		style: {
 			width: "100%",
-			maxWidth: W,
+			maxWidth: "100%",
 			height: "auto"
 		},
-		role: "img",
-		"aria-label": `Karnaugh map of ${vars.join(",")}, ${minterms.length} ones`,
+		role: "grid",
+		"aria-label": `Karnaugh map, ${n} variables (${vars.join(", ")}), ${nRows * nCols} cells, ${minterms.length} one${minterms.length === 1 ? "" : "s"}`,
 		children: [
 			/* @__PURE__ */ jsx("text", {
 				x: LH + gridW / 2,
@@ -256,9 +250,21 @@ function KarnaughMapLab({ formula, minterms: mtIn, dontCares: dcIn = [], vars: v
 				const isOne = oneSet.has(m), isDC = dcSet.has(m);
 				const sel = mode === "simplify" && selected.includes(m);
 				const val = isOne ? "1" : isDC ? "X" : "0";
+				const tappable = mode === "simplify" && (isOne || isDC) && !revealed;
+				const cellLabel = `minterm ${m}, value ${val}${sel ? ", selected" : ""}`;
 				return /* @__PURE__ */ jsxs("g", {
 					onClick: () => tapCell(m),
-					style: { cursor: mode === "simplify" && (isOne || isDC) && !revealed ? "pointer" : "default" },
+					onKeyDown: tappable ? (e) => {
+						if (e.key === "Enter" || e.key === " ") {
+							e.preventDefault();
+							tapCell(m);
+						}
+					} : void 0,
+					role: tappable ? "button" : "img",
+					tabIndex: tappable ? 0 : void 0,
+					"aria-label": cellLabel,
+					"aria-pressed": tappable ? sel : void 0,
+					style: { cursor: tappable ? "pointer" : "default" },
 					children: [
 						/* @__PURE__ */ jsx("rect", {
 							x: cellX(gc),
@@ -427,7 +433,7 @@ function KarnaughMapLab({ formula, minterms: mtIn, dontCares: dcIn = [], vars: v
 				className: "lab-pill",
 				"data-state": "ok",
 				style: { marginTop: 8 },
-				children: minimal ? "✓ all ones covered — minimal!" : `✓ covered, but minimal is ${result.cover.length} group${result.cover.length === 1 ? "" : "s"}`
+				children: minimal ? "✓ all ones covered, minimal!" : `✓ covered, but minimal is ${result.cover.length} group${result.cover.length === 1 ? "" : "s"}`
 			})
 		] }) }),
 		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [mode === "simplify" && /* @__PURE__ */ jsx(RevealSolution, {
@@ -436,7 +442,7 @@ function KarnaughMapLab({ formula, minterms: mtIn, dontCares: dcIn = [], vars: v
 			solution: /* @__PURE__ */ jsxs(Fragment$1, { children: [
 				"The minimal SOP is ",
 				/* @__PURE__ */ jsx(TexExpr, { expr: result.expression }),
-				" — ",
+				", ",
 				result.cover.length,
 				" group",
 				result.cover.length === 1 ? "" : "s",

package/dist/discrete/lln/preset.mjs

@@ -2,6 +2,7 @@
 
 import { Chip } from "../../kit/controls.mjs";
 import { ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
+import { useCheckpoint } from "../../kit/pedagogy.mjs";
 import { LLN_ASSET } from "./asset.mjs";
 import { useMemo, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -9,17 +10,17 @@ import { Scene, registerAsset } from "@classytic/stage";
 
 //#region src/discrete/lln/preset.tsx
 /**
-* LawOfLargeNumbersLab — the `sampler` core made tangible, the STANDARD data-driven
+* LawOfLargeNumbersLab, the `sampler` core made tangible, the STANDARD data-driven
 * way: a SceneDoc with one `sampler` sim (meta.sims) + the `lln` asset reading it
 * live via simBind. Flip a coin / roll a die thousands of times and watch the
-* frequencies settle onto the true probability. Coin vs die is just `weights` —
+* frequencies settle onto the true probability. Coin vs die is just `weights` , 
 * the general tool, not a one-off widget.
 *
 * Changing the experiment or hitting "new run" re-keys <Scene> so the sampler
 * re-seeds (fresh counts); "speed" (draws/frame) merges live without a restart.
 */
 registerAsset("lln", LLN_ASSET);
-function LawOfLargeNumbersLab({ experiment: exp0 = "coin", title = "The law of large numbers", prompt = "Flip a coin (or roll a die) over and over — the running frequencies settle onto the true probability.", objectives } = {}) {
+function LawOfLargeNumbersLab({ experiment: exp0 = "coin", title = "The law of large numbers", prompt = "Flip a coin (or roll a die) over and over, the running frequencies settle onto the true probability.", objectives } = {}) {
 	const [experiment, setExperiment] = useState(exp0);
 	const [perStep, setPerStep] = useState(1);
 	const [resetN, setResetN] = useState(0);
@@ -94,6 +95,46 @@ function LawOfLargeNumbersLab({ experiment: exp0 = "coin", title = "The law of l
 		perStep,
 		resetN
 	]);
+	const { totalSamples, estimates, trueProbs } = useMemo(() => {
+		const weights = experiment === "coin" ? [1, 1] : [
+			1,
+			1,
+			1,
+			1,
+			1,
+			1
+		];
+		const maxDraws = experiment === "coin" ? 4e3 : 12e3;
+		const total = weights.reduce((a, b) => a + b, 0) || 1;
+		const trueP = weights.map((w) => w / total);
+		const counts = new Array(weights.length).fill(0);
+		let a = 1 + resetN | 0;
+		for (let n = 0; n < maxDraws; n++) {
+			a = a + 1831565813 | 0;
+			let t = Math.imul(a ^ a >>> 15, 1 | a);
+			t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+			let x = ((t ^ t >>> 14) >>> 0) / 4294967296 * total;
+			let idx = weights.length - 1;
+			for (let i = 0; i < weights.length - 1; i++) {
+				const w = weights[i] ?? 0;
+				if (x < w) {
+					idx = i;
+					break;
+				}
+				x -= w;
+			}
+			counts[idx] = (counts[idx] ?? 0) + 1;
+		}
+		return {
+			totalSamples: maxDraws,
+			estimates: counts.map((c) => c / maxDraws),
+			trueProbs: trueP
+		};
+	}, [experiment, resetN]);
+	useCheckpoint({
+		solved: totalSamples >= 300 && estimates.every((est, i) => Math.abs(est - (trueProbs[i] ?? 0)) <= .02),
+		activity: `lln:${title}`
+	});
 	return /* @__PURE__ */ jsx(LabFrame, {
 		title,
 		prompt,

package/dist/discrete/logic-circuit/preset.mjs

@@ -10,7 +10,7 @@ import { useControlSurface } from "@classytic/stage";
 
 //#region src/discrete/logic-circuit/preset.tsx
 /**
-* BooleanCircuitLab — the GENERAL "build something real with logic gates" tool.
+* BooleanCircuitLab, the GENERAL "build something real with logic gates" tool.
 * A creator declares a NETLIST (input switches, typed gates wired by id, output
 * devices = LEDs/lamps); the learner flips switches and watches power flow
 * through the gates and LIGHT the outputs. One tool → any combinational circuit:
@@ -297,7 +297,7 @@ function BooleanCircuitLab({ inputs: inputs0, gates, outputs, initial, title = "
 				"."
 			] }),
 			onReveal: () => {},
-			note: "Try each switch combination — the wires glow when they carry a 1."
+			note: "Try each switch combination, the wires glow when they carry a 1."
 		}), /* @__PURE__ */ jsx(HintLadder, { hints })] }),
 		children: figure
 	});

package/dist/discrete/monte-carlo/preset.d.mts

@@ -15,7 +15,7 @@ interface MCSeries {
   };
   /** Map the hit-fraction to the reported quantity (default: the fraction itself). */
   estimate?: (frac: number) => number;
-  /** The value the estimate should converge to — drawn as a dashed guide. */
+  /** The value the estimate should converge to, drawn as a dashed guide. */
   theoretical?: number;
 }
 type ExperimentSpec = {