@mark1russell7/rigor-bench 0.2.13 → 0.2.15

package/build/index.js

@@ -1,5 +1,5 @@
 import { n as checkPairedTime, r as firstArm, t as caseRatios } from "./paired.js";
-import { bootstrapMedian, bootstrapTwo, compareRatios, median, medianInterval, quantile, quantileInterval, quantileSamples, wilson } from "@mark1russell7/rigor-statistics";
+import { bootstrapMedian, bootstrapTwo, compareRatios, holm, median, medianInterval, partialConjunction, quantile, quantileInterval, quantileSamples, signTest, signTestPower, wilson } from "@mark1russell7/rigor-statistics";
 import { random } from "@mark1russell7/rigor-generators";
 // src/budget.ts
 /**
@@ -212,6 +212,216 @@ function budgetLooksVerdict(rounds, aa, options) {
 function round$2(x) {
 	return Math.round(x * 1e4) / 1e4;
 }
+// src/gate.ts
+/**
+* The gate of a bench: the result that a check of a merge reads. A verdict gives one of the words of `LimitOutcome` for each
+* case, and the gate gives "pass", "block" or "no read". A case with no outcome does not pass.
+*/
+/**
+* This function gives the gate of a list of case outcomes.
+* - The result is "block" when a case is `beyond`.
+* - The result is "pass" when each case is `within`.
+* - Each other result is "no read", and so is a list with no cases. A caller does not count "no read" as a pass.
+*/
+function gateOf(cases) {
+	const names = (outcome) => cases.filter((c) => c.outcome === outcome).map((c) => c.case);
+	const blocks = names("beyond");
+	const noRead = names("cannot decide");
+	if (cases.length === 0) return {
+		outcome: "no read",
+		reason: "The gate has no cases.",
+		blocks,
+		noRead
+	};
+	if (blocks.length > 0) return {
+		outcome: "block",
+		reason: `${blocks.length} of ${cases.length} cases are beyond the claim. The first is ${JSON.stringify(blocks[0])}.`,
+		blocks,
+		noRead
+	};
+	if (noRead.length > 0) return {
+		outcome: "no read",
+		reason: `${noRead.length} of ${cases.length} cases have no outcome. The first is ${JSON.stringify(noRead[0])}.`,
+		blocks,
+		noRead
+	};
+	return {
+		outcome: "pass",
+		reason: `Each of the ${cases.length} cases is within the claim.`,
+		blocks,
+		noRead
+	};
+}
+const READ_OF = {
+	within: "not slower",
+	beyond: "slower",
+	"cannot decide": "no read"
+};
+/** The looks of `notSlowerVerdict`: the rounds in each job. The level of the family has an equal share at each look. */
+const GATE_LOOKS = [
+	12,
+	24,
+	48
+];
+/** This function examines the options. */
+function checkOptions(level, looks, need) {
+	if (!(level > 0 && level < 1)) throw new RangeError(`notSlowerVerdict: the level is above 0 and below 1, not ${level}.`);
+	if (looks.length === 0) throw new RangeError("notSlowerVerdict: the list of looks is empty.");
+	let last = 0;
+	for (const rounds of looks) {
+		if (!(Number.isInteger(rounds) && rounds > last && rounds % 2 === 0)) throw new RangeError(`notSlowerVerdict: the looks are even whole numbers in rising order, not ${rounds} after ${last}.`);
+		last = rounds;
+	}
+	if (!(Number.isInteger(need) && need >= 1)) throw new RangeError(`notSlowerVerdict: the count of jobs is a whole number of 1 or more, not ${need}.`);
+}
+/** This function gives the records of one case of one job in the order of the rounds. It refuses a round that comes twice. */
+function casesOf(records) {
+	const out = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		checkPairedTime(record);
+		const list = out.get(record.case) ?? [];
+		if (list.some((r) => r.round === record.round)) throw new RangeError(`notSlowerVerdict: the round ${record.round} of ${JSON.stringify(record.case)} comes twice.`);
+		list.push(record);
+		out.set(record.case, list);
+	}
+	for (const list of out.values()) list.sort((a, b) => a.round - b.round);
+	return out;
+}
+/**
+* This function gives the differences of the first `rounds` rounds: log(b / a) of the candidate minus log(b / a) of the A/A arm.
+* A pair has two records with the same first arm, because a difference of two orders holds the effect of the order.
+*/
+function differences(candidate, aa, rounds) {
+	const out = [];
+	const ofOrder = (list, first) => list.slice(0, rounds).filter((r) => r.first === first);
+	for (const first of ["a", "b"]) {
+		const left = ofOrder(candidate, first);
+		const right = ofOrder(aa, first);
+		for (let i = 0; i < Math.min(left.length, right.length); i++) {
+			const c = left[i];
+			const a = right[i];
+			out.push(Math.log(c.b / c.a) - Math.log(a.b / a.a));
+		}
+	}
+	return out;
+}
+/** This function gives the read of one job. A job that has not reached the look gives a p of 1 in both directions. */
+function jobRead(job, diffs, margin, rounds) {
+	if (diffs.length < rounds) return {
+		job,
+		rounds: diffs.length,
+		below: 0,
+		above: 0,
+		notSlower: 1,
+		slower: 1,
+		centre: void 0
+	};
+	const below = diffs.filter((d) => d < margin).length;
+	const above = diffs.filter((d) => d > margin).length;
+	return {
+		job,
+		rounds: diffs.length,
+		below,
+		above,
+		notSlower: signTest(below, diffs.length - below),
+		slower: signTest(above, diffs.length - above),
+		centre: median(diffs)
+	};
+}
+/** This function gives the words of the facts of one job, for a reason. */
+function jobFacts(read) {
+	if (read.centre === void 0) return `job ${read.job} has ${read.rounds} pairs`;
+	return `job ${read.job} has ${read.below} of ${read.rounds} pairs below the margin, centre ${Math.round(read.centre * 1e5) / 1e3} %`;
+}
+/**
+* This function gives the gate of the claim "the candidate is not slower than the A/A arm by more than the margin" for each
+* case. A one-sided bound answers the claim. Thus a case with its whole interval under the margin reads "not slower", also
+* when its interval holds 1.
+*
+* - In each job, the sign test compares the median of the differences with the margin. It uses no random numbers.
+* - A case reads in `jobs` jobs or more: `partialConjunction` joins the p of each job, with no condition on how they depend.
+* - The level is for the family. Each look has `level / looks` of it, and `holm` corrects each look over all cases.
+* - The first look with an outcome decides a case. Later rounds do not change it. Each look uses the first rounds of a job.
+* - The result is "block" when a case reads "slower", and "pass" when each case reads "not slower".
+* - Each other result is "no read". The field `more` gives the next look of each case. After the last look, the caller adds jobs.
+*
+* The level needs independent rounds. Rounds with a shared cause, for example a slow computer for one job, do not have it.
+* A job that a caller adds after the last look is one more look, and the level does not count it.
+*/
+function notSlowerVerdict(jobs, options) {
+	const level = options.level ?? .05;
+	const looks = options.looks ?? GATE_LOOKS;
+	const need = options.jobs ?? 2;
+	checkOptions(level, looks, need);
+	const marginOf = (name) => {
+		const margin = typeof options.margin === "number" ? options.margin : options.margin(name);
+		if (!(margin >= 0 && Number.isFinite(margin))) throw new RangeError(`notSlowerVerdict: the margin of ${JSON.stringify(name)} is finite and 0 or more, not ${margin}.`);
+		return margin;
+	};
+	const records = jobs.map((job) => ({
+		job: job.job,
+		candidate: casesOf(job.candidate),
+		aa: casesOf(job.aa)
+	}));
+	const names = [...new Set(records.flatMap((job) => [...job.candidate.keys()]))].sort();
+	const margins = names.map(marginOf);
+	const decided = /* @__PURE__ */ new Map();
+	const reached = /* @__PURE__ */ new Map();
+	const each = level / looks.length;
+	for (const rounds of looks) {
+		const reads = names.map((name, i) => records.map((job) => jobRead(job.job, differences(job.candidate.get(name) ?? [], job.aa.get(name) ?? [], rounds), margins[i], rounds)));
+		const joined = (pick) => reads.map((list) => list.length < need ? 1 : partialConjunction(list.map(pick), need));
+		const within = holm(joined((read) => read.notSlower), each);
+		const beyond = holm(joined((read) => read.slower), each);
+		names.forEach((name, i) => {
+			const list = reads[i];
+			if (!reached.has(name) || list.some((read) => read.rounds >= rounds)) reached.set(name, list);
+			if (decided.has(name)) return;
+			if (within[i]?.reject === true) decided.set(name, {
+				outcome: "within",
+				look: rounds,
+				reads: list
+			});
+			else if (beyond[i]?.reject === true) decided.set(name, {
+				outcome: "beyond",
+				look: rounds,
+				reads: list
+			});
+		});
+	}
+	const cases = names.map((name, i) => {
+		const decision = decided.get(name);
+		const outcome = decision?.outcome ?? "cannot decide";
+		const reads = decision?.reads ?? reached.get(name) ?? [];
+		const facts = reads.map(jobFacts).join(", ");
+		const where = decision === void 0 ? `no look of ${looks.join(", ")} rounds decides it` : `the look of ${decision.look} rounds decides it`;
+		return {
+			case: name,
+			outcome,
+			read: READ_OF[outcome],
+			margin: margins[i],
+			look: decision?.look,
+			jobs: reads,
+			reason: `The case ${JSON.stringify(name)} reads "${READ_OF[outcome]}": ${where} (${facts}).`
+		};
+	});
+	const more = cases.flatMap((c) => {
+		if (c.outcome !== "cannot decide") return [];
+		const next = looks.find((rounds) => records.some((job) => differences(job.candidate.get(c.case) ?? [], job.aa.get(c.case) ?? [], rounds).length < rounds));
+		return next === void 0 ? [] : [{
+			case: c.case,
+			rounds: next
+		}];
+	});
+	return {
+		...gateOf(cases),
+		level,
+		looks,
+		need,
+		cases,
+		more
+	};
+}
 // src/control.ts
 /**
 * The load factor of a run, read from a control. Runs on shared machines differ by load. A change does not touch a control.
@@ -1089,6 +1299,463 @@ function armVerdicts(run, aaPair, options = {}) {
 	for (const [pair, records] of Object.entries(run.pairs)) if (pair !== aaPair) out[pair] = timeVerdict(balanceOrders(records).records, aa, options);
 	return out;
 }
+// src/measures.ts
+/**
+* The check that a trick does not buy a measure. A control is a strategy made to win one measure and nothing else.
+* A real entry that wins that measure can do the same trick, so the win alone tells little. This check reads the controls of a
+* bench, and it tells which wins need a partner measure beside them. It also tells which measures separate nothing.
+*
+* A test compares paired values with the sign test of `rigor-statistics` and with the Holm correction. The keys of one stratum come
+* from one family of inputs, so they are not independent draws. The p of a test holds only under the sign test's own null: each
+* untied key is a fair coin. A result is about these keys, and this check claims nothing about other inputs.
+*/
+const DEFAULT_ALPHA = .05;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+function checkedDate(name, date) {
+	const time = Date.parse(`${date}T00:00:00Z`);
+	if (!DATE.test(date) || !Number.isFinite(time) || new Date(time).toISOString().slice(0, 10) !== date) throw new RangeError(`checkMeasures: ${name} is a date as YYYY-MM-DD, not ${JSON.stringify(date)}.`);
+	return date;
+}
+/** This function refuses the rules that contradict each other, because a wrong rule reads as a passed check. */
+function checkedRules(options) {
+	const controls = new Set(options.controls);
+	const rules = /* @__PURE__ */ new Map();
+	for (const rule of options.rules) {
+		if (rules.has(rule.measure)) throw new RangeError(`checkMeasures: the measure ${JSON.stringify(rule.measure)} has two rules.`);
+		rules.set(rule.measure, rule);
+	}
+	for (const rule of options.rules) {
+		const name = JSON.stringify(rule.measure);
+		for (const control of rule.controls) if (!controls.has(control)) throw new RangeError(`checkMeasures: the control ${JSON.stringify(control)} of ${name} is not in the controls of the options.`);
+		for (const partner of rule.partners) {
+			if (partner === rule.measure) throw new RangeError(`checkMeasures: ${name} names itself as a partner.`);
+			if (!rules.has(partner)) throw new RangeError(`checkMeasures: the partner ${JSON.stringify(partner)} of ${name} has no rule.`);
+		}
+		if (rule.resolution !== void 0 && !(Number.isFinite(rule.resolution) && rule.resolution >= 0)) throw new RangeError(`checkMeasures: the resolution of ${name} is finite and 0 or more, not ${rule.resolution}.`);
+		if (rule.noControl !== void 0) {
+			if (rule.controls.length > 0) throw new RangeError(`checkMeasures: ${name} has controls and also noControl.`);
+			checkedDate(`the date of ${name}`, rule.noControl.until);
+		}
+	}
+	return rules;
+}
+/** This function groups the rows. It refuses a value that is not finite, a repeat, and a key in two strata. */
+function groupedRows(rows) {
+	const strata = /* @__PURE__ */ new Map();
+	const measures = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const where = `${JSON.stringify(row.key)} of ${JSON.stringify(row.group)} on ${JSON.stringify(row.measure)}`;
+		if (!Number.isFinite(row.value)) throw new RangeError(`checkMeasures: the value of ${where} is not finite: ${row.value}.`);
+		if (strata.has(row.key) && strata.get(row.key) !== row.stratum) throw new RangeError(`checkMeasures: the key ${JSON.stringify(row.key)} has two strata.`);
+		strata.set(row.key, row.stratum);
+		const measure = measures.get(row.measure) ?? /* @__PURE__ */ new Map();
+		measures.set(row.measure, measure);
+		const groups = measure.get(row.stratum) ?? /* @__PURE__ */ new Map();
+		measure.set(row.stratum, groups);
+		const keys = groups.get(row.group) ?? /* @__PURE__ */ new Map();
+		groups.set(row.group, keys);
+		if (keys.has(row.key)) throw new RangeError(`checkMeasures: the row ${where} comes twice. State how the repeats reduce to one row.`);
+		keys.set(row.key, row);
+	}
+	return measures;
+}
+/** This function gives the least count of untied keys with the power to pass at `level`. */
+function pairsNeeded(level, sides) {
+	let n = 1;
+	while (signTestPower(n, level, sides) === void 0) n += 1;
+	return n;
+}
+/** This function compares two groups on the keys that both finished. A positive difference favours `better`. */
+function rawTest(better, other, stratum, groups, sense) {
+	const a = groups.get(better);
+	const b = groups.get(other);
+	if (a === void 0 || b === void 0) return void 0;
+	const differences = [];
+	for (const [key, row] of a) {
+		const pair = b.get(key);
+		if (pair === void 0 || row.censored === true || pair.censored === true) continue;
+		differences.push(sense === "higher" ? row.value - pair.value : pair.value - row.value);
+	}
+	if (differences.length === 0) return void 0;
+	const wins = differences.filter((d) => d > 0).length;
+	const losses = differences.filter((d) => d < 0).length;
+	return {
+		better,
+		other,
+		stratum,
+		shared: differences.length,
+		wins,
+		losses,
+		medianDifference: median(differences)
+	};
+}
+/** This function corrects one family of tests, over all strata. A test with too few keys beats nothing, even when a step of Holm passes it. */
+function corrected(tests, sides, alpha, resolution) {
+	if (tests.length === 0) return [];
+	const family = tests.length;
+	const needs = pairsNeeded(alpha / family, sides);
+	const ps = tests.map((t) => signTest(t.wins, t.losses, sides));
+	const steps = holm(ps, alpha);
+	return tests.map((t, i) => {
+		const n = t.wins + t.losses;
+		const tooFew = n < needs;
+		const size = sides === 1 ? t.medianDifference : Math.abs(t.medianDifference);
+		const clears = resolution === void 0 || size > resolution;
+		return {
+			...t,
+			n,
+			ties: t.shared - n,
+			p: ps[i],
+			adjusted: steps[i]?.adjusted,
+			family,
+			needs,
+			tooFew,
+			tied: tooFew && t.shared >= needs,
+			beats: !tooFew && steps[i]?.reject === true && clears
+		};
+	});
+}
+const stratumText = (stratum) => stratum === void 0 ? "" : ` in the stratum ${JSON.stringify(stratum)}`;
+/** This function tells that a test has too few keys to read, so a tie on enough keys is a read. */
+const unread = (c) => c.tooFew && !c.tied;
+/** The reads of one control on one measure: one for each stratum of the measure. */
+function controlReads(measure, control, data, rule, real, alpha) {
+	if (data === void 0) return [];
+	const comparisons = corrected([...data].flatMap(([stratum, groups]) => real.flatMap((entry) => rawTest(entry, control, stratum, groups, rule.sense) ?? [])), 1, alpha, rule.resolution);
+	const attacks = corrected([...data].flatMap(([stratum, groups]) => real.flatMap((entry) => rawTest(control, entry, stratum, groups, rule.sense) ?? [])), 1, alpha, rule.resolution);
+	return [...data.keys()].map((stratum) => {
+		const here = comparisons.filter((c) => c.stratum === stratum);
+		const against = attacks.filter((c) => c.stratum === stratum);
+		return {
+			measure,
+			control,
+			stratum,
+			status: here.length === 0 ? "no-rows" : here.some((c) => c.beats) ? "beaten" : here.every(unread) ? "too-few" : "wins",
+			aheadOf: here.filter((c) => c.losses > c.wins).length,
+			comparisons: here,
+			beatsEntries: against.filter((c) => c.beats).length,
+			of: against.filter((c) => !unread(c)).length,
+			against
+		};
+	});
+}
+/** The read of the spread of one measure: one family over all pairs of real entries and all strata. */
+function spreadReads(data, rule, real, alpha) {
+	const comparisons = corrected([...data].flatMap(([stratum, groups]) => real.flatMap((entry, i) => real.slice(i + 1).flatMap((other) => rawTest(entry, other, stratum, groups, rule.sense) ?? []))), 2, alpha, rule.resolution);
+	return {
+		reads: [...data.keys()].map((stratum) => {
+			const here = comparisons.filter((c) => c.stratum === stratum);
+			const widest = here.length === 0 ? void 0 : Math.max(...here.map((c) => Math.abs(c.medianDifference)));
+			return {
+				stratum,
+				pairs: here.length,
+				separated: here.filter((c) => c.beats).length,
+				tooFew: here.filter(unread).length,
+				widest
+			};
+		}),
+		comparisons
+	};
+}
+function countsOf(data) {
+	const counts = [];
+	for (const [stratum, groups] of data ?? []) for (const [group, keys] of groups) {
+		const censored = [...keys.values()].filter((row) => row.censored === true).length;
+		counts.push({
+			group,
+			stratum,
+			finished: keys.size - censored,
+			censored
+		});
+	}
+	return counts;
+}
+/** This function gives the methods of a measure. A row with no method counts as one more method beside a named one. */
+function methodsOf(data) {
+	const methods = /* @__PURE__ */ new Set();
+	for (const groups of data?.values() ?? []) for (const keys of groups.values()) for (const row of keys.values()) methods.add(row.method);
+	return [...methods];
+}
+/** This function tells that a test clears a control on one of `partners` partners. One passed partner is enough, so the level divides by their count. */
+const clearsPartner = (c, partners, alpha) => c.beats && c.adjusted * partners <= alpha;
+/** This function reads a control on one of `partners` partners. A test with too few shared keys for the divided level has no power, so a miss there is not a read. */
+const partnerStatus = (read, partners, alpha) => {
+	if (read === void 0 || read.status === "no-rows") return "no-rows";
+	if (read.comparisons.some((c) => clearsPartner(c, partners, alpha))) return "lost";
+	const needs = pairsNeeded(alpha / ((read.comparisons[0]?.family ?? 1) * partners), 1);
+	return read.comparisons.every((c) => c.shared < needs) ? "too-few" : "not-lost";
+};
+function readsOf(reading, measure, control) {
+	const memoKey = JSON.stringify([measure, control]);
+	const known = reading.memo.get(memoKey);
+	if (known !== void 0) return known;
+	const rule = reading.rules.get(measure);
+	const reads = reading.mixed.has(measure) ? [] : controlReads(measure, control, reading.data.get(measure), rule, reading.real, reading.alpha);
+	reading.memo.set(memoKey, reads);
+	return reads;
+}
+/** The findings of the rows and the controls of one rule that have nothing to read. */
+function missingFindings(rule, reading) {
+	const findings = [];
+	const hasRows = (measure, group) => [...reading.data.get(measure)?.values() ?? []].some((groups) => groups.has(group));
+	const missing = (text, control) => {
+		findings.push({
+			kind: "no-rows",
+			measure: rule.measure,
+			...control === void 0 ? {} : { control },
+			text,
+			comparisons: []
+		});
+	};
+	if (!reading.data.has(rule.measure)) missing(`The measure ${rule.measure} has a rule and no rows.`);
+	for (const control of rule.controls) {
+		if (reading.data.has(rule.measure) && !hasRows(rule.measure, control)) missing(`The control ${control} has no rows on ${rule.measure}, so it reads as nothing and not as "not beaten".`, control);
+		for (const partner of rule.partners) if (!hasRows(partner, control)) missing(`The control ${control} has no rows on the partner ${partner} of ${rule.measure}, so it reads as nothing and not as "not beaten".`, control);
+	}
+	return findings;
+}
+/** The findings of the win of a control on one stratum: the partners and the censored keys. */
+function winFindings(rule, read, guard, counts, partnerReads) {
+	const findings = [];
+	const where = stratumText(read.stratum);
+	const count = guard.partners.length;
+	const thin = guard.partners.filter((p) => p.status === "too-few").map((p) => p.partner);
+	const noRows = guard.partners.some((p) => p.status === "no-rows");
+	const behind = partnerReads.flatMap((r) => r.comparisons);
+	if (!guard.partners.some((p) => p.status === "lost")) {
+		if (thin.length > 0) findings.push({
+			kind: "too-few",
+			measure: rule.measure,
+			stratum: read.stratum,
+			control: read.control,
+			partners: count,
+			text: `The control ${read.control} wins ${rule.measure}${where} and loses no partner. Of its ${count} partners, ${thin.join(", ")} have too few keys for a read.`,
+			comparisons: behind
+		});
+		else if (!noRows) {
+			const list = count === 0 ? "It has no partner." : `It loses none of its ${count} partners, ${guard.partners.map((p) => p.partner).join(", ")}.`;
+			findings.push({
+				kind: "uncaught",
+				measure: rule.measure,
+				stratum: read.stratum,
+				control: read.control,
+				partners: count,
+				text: `The control ${read.control} wins ${rule.measure}${where}. ${list}`,
+				comparisons: [...read.comparisons, ...behind]
+			});
+		}
+	}
+	const own = counts.find((c) => c.group === read.control && c.stratum === read.stratum)?.censored ?? 0;
+	const fewer = counts.filter((c) => c.group !== read.control && c.stratum === read.stratum && read.comparisons.some((t) => t.better === c.group) && c.censored < own);
+	if (fewer.length > 0) {
+		const list = fewer.map((c) => `${c.group} ${c.censored}`).join(", ");
+		findings.push({
+			kind: "censored-win",
+			measure: rule.measure,
+			stratum: read.stratum,
+			control: read.control,
+			text: `The control ${read.control} wins ${rule.measure}${where} with ${own} censored keys, more than ${list}. Its win can come from the easy keys.`,
+			comparisons: read.comparisons.filter((t) => fewer.some((c) => c.group === t.better))
+		});
+	}
+	return findings;
+}
+/** The read of one rule, with its findings. */
+function checkRule(rule, reading, asOf) {
+	const data = reading.data.get(rule.measure);
+	const methods = methodsOf(data);
+	const mixed = reading.mixed.has(rule.measure);
+	const counts = countsOf(data);
+	const findings = missingFindings(rule, reading);
+	const reads = [];
+	const guards = [];
+	if (mixed) findings.push({
+		kind: "mixed-method",
+		measure: rule.measure,
+		text: `The measure ${rule.measure} mixes the methods ${methods.map((m) => m ?? "(none)").join(", ")}. The check has no read of it until the rows are split or marked.`,
+		comparisons: []
+	});
+	if (rule.controls.length === 0) {
+		if (rule.noControl === void 0) findings.push({
+			kind: "no-control",
+			measure: rule.measure,
+			text: `The measure ${rule.measure} has no control and no noControl with a date.`,
+			comparisons: []
+		});
+		else if (rule.noControl.until < asOf) findings.push({
+			kind: "control-late",
+			measure: rule.measure,
+			text: `The control of ${rule.measure} was due on ${rule.noControl.until}, and the date of the check is ${asOf}.`,
+			comparisons: []
+		});
+	}
+	for (const control of rule.controls) for (const read of readsOf(reading, rule.measure, control)) {
+		const partnerReads = rule.partners.map((partner) => readsOf(reading, partner, control).find((r) => r.stratum === read.stratum));
+		const partners = rule.partners.map((partner, i) => ({
+			partner,
+			status: partnerStatus(partnerReads[i], rule.partners.length, reading.alpha)
+		}));
+		const guard = {
+			control,
+			stratum: read.stratum,
+			status: read.status,
+			partners
+		};
+		guards.push(guard);
+		reads.push(read, ...partnerReads.filter((r) => r !== void 0));
+		if (read.status === "wins") findings.push(...winFindings(rule, read, guard, counts, partnerReads.filter((r) => r !== void 0)));
+	}
+	const controlComparisons = guards.length === 0 ? [] : reads.filter((r) => r.measure === rule.measure).flatMap((r) => r.comparisons);
+	if (rule.controls.length > 0 && guards.length > 0 && !mixed) {
+		if (guards.every((g) => g.status === "too-few" || g.status === "no-rows")) {
+			const needs = Math.max(0, ...controlComparisons.map((c) => c.needs));
+			findings.push({
+				kind: "too-few",
+				measure: rule.measure,
+				text: `No control of ${rule.measure} has enough pairs for a read. A test needs ${needs} untied pairs.`,
+				comparisons: controlComparisons
+			});
+		} else for (const control of rule.controls) {
+			const own = reads.filter((r) => r.measure === rule.measure && r.control === control);
+			const of = own.reduce((sum, r) => sum + r.of, 0);
+			if (of > 0 && own.every((r) => r.beatsEntries === 0)) findings.push({
+				kind: "weak-control",
+				measure: rule.measure,
+				control,
+				text: `The control ${control} beats 0 of ${of} real entries on ${rule.measure} by test, in all strata. The trick buys nothing.`,
+				comparisons: own.flatMap((r) => r.against)
+			});
+		}
+	}
+	let spread = [];
+	if (data !== void 0 && !mixed) {
+		const { reads: spreadRows, comparisons } = spreadReads(data, rule, reading.real, reading.alpha);
+		spread = spreadRows;
+		const testable = comparisons.filter((c) => !unread(c));
+		if (comparisons.length > 0 && testable.length === 0) findings.push({
+			kind: "too-few",
+			measure: rule.measure,
+			text: `No pair of real entries has enough keys for a read of the spread of ${rule.measure}. A test needs ${comparisons[0]?.needs} untied pairs.`,
+			comparisons: []
+		});
+		else if (testable.length > 0 && !comparisons.some((c) => c.beats)) {
+			const widest = Math.max(...comparisons.map((c) => Math.abs(c.medianDifference)));
+			const basis = rule.resolution === void 0 ? "by the test only" : `by the test and the resolution ${rule.resolution}`;
+			findings.push({
+				kind: "no-spread",
+				measure: rule.measure,
+				text: `No pair of the ${comparisons.length} pairs of real entries separates on ${rule.measure}, ${basis}. The widest median difference is ${widest}.`,
+				comparisons: [...comparisons].sort((a, b) => a.adjusted - b.adjusted).slice(0, 1)
+			});
+		}
+	}
+	return {
+		check: {
+			measure: rule.measure,
+			sense: rule.sense,
+			basis: rule.resolution === void 0 ? "test only" : "test and resolution",
+			method: mixed ? void 0 : methods[0],
+			mixed,
+			guards,
+			spread,
+			entries: counts,
+			partners: rule.partners,
+			open: rule.noControl
+		},
+		findings,
+		reads
+	};
+}
+/**
+* This function reads the controls and the spread of each measure of a bench.
+*
+* - A control wins a measure when no real entry beats it on the keys that both finished. A tie counts for the control.
+* - A real entry beats a control when the Holm-corrected sign test passes and the median paired difference is over the resolution.
+* - One Holm family holds the tests of one control on one measure over all real entries and all strata.
+* - One more Holm family holds the tests of one control against the real entries, with the same need and resolution. A control that beats none of them is weak.
+* - One Holm family holds the tests of the spread of one measure over all pairs of real entries and all strata.
+* - A test with fewer untied keys than `signTestPower` needs for that family reads `tooFew` and beats nothing.
+* - A test with enough shared keys and too few untied keys is `tied`. The two entries read as equal, so a constant measure is `no-spread` and not `too-few`.
+* - A control loses a partner only at the level divided by the count of its partners. One passed partner clears `uncaught`, so each partner is one more chance.
+*
+* The function throws a `RangeError` for a value that is not finite, a repeat of measure, group and key, or a key in two strata.
+* It also throws one for rules that contradict each other.
+* The rules, the controls and the date are stated, so the result depends only on the arguments.
+*/
+function checkMeasures(rows, options) {
+	const alpha = options.alpha ?? DEFAULT_ALPHA;
+	if (!(alpha > 0 && alpha < 1)) throw new RangeError(`checkMeasures: alpha is over 0 and under 1, not ${alpha}.`);
+	const asOf = checkedDate("asOf", options.asOf);
+	const rules = checkedRules(options);
+	const data = groupedRows(rows);
+	const controls = new Set(options.controls);
+	const reading = {
+		rules,
+		data,
+		real: [...new Set(rows.map((row) => row.group))].filter((group) => !controls.has(group)),
+		alpha,
+		mixed: new Set([...data.keys()].filter((measure) => methodsOf(data.get(measure)).length > 1)),
+		memo: /* @__PURE__ */ new Map()
+	};
+	const findings = [];
+	for (const measure of data.keys()) if (!rules.has(measure)) findings.push({
+		kind: "no-rule",
+		measure,
+		text: `The measure ${measure} has rows and no rule.`,
+		comparisons: []
+	});
+	const measures = [];
+	const reads = /* @__PURE__ */ new Map();
+	for (const rule of options.rules) {
+		const result = checkRule(rule, reading, asOf);
+		measures.push(result.check);
+		findings.push(...result.findings);
+		for (const read of result.reads) reads.set(JSON.stringify([
+			read.measure,
+			read.control,
+			read.stratum ?? null
+		]), read);
+	}
+	return {
+		alpha,
+		measures,
+		reads: [...reads.values()],
+		findings
+	};
+}
+/**
+* This function tells what a page says about the win of one real entry on one measure.
+* The claim is about this entry: only this entry beating the control, on this measure or on a partner, clears the entry. A win by another entry clears nothing.
+* With a stratum, the function reads that stratum. Without one, it reads the rows with no stratum.
+* The function throws a `RangeError` for a measure with no read and for an entry that the rows do not hold.
+*/
+function winClaim(check, measure, entry, stratum) {
+	const read = check.measures.find((m) => m.measure === measure);
+	if (read === void 0) throw new RangeError(`winClaim: the measure ${JSON.stringify(measure)} has no rule.`);
+	const count = read.entries.find((c) => c.group === entry && c.stratum === stratum);
+	if (count === void 0) throw new RangeError(`winClaim: the entry ${JSON.stringify(entry)} has no rows on ${JSON.stringify(measure)}${stratumText(stratum)}.`);
+	const guards = read.guards.filter((g) => g.stratum === stratum);
+	const winning = guards.filter((g) => g.status === "wins");
+	const lostByControl = (guard) => guard.partners.filter((p) => p.status === "lost").map((p) => p.partner);
+	const testsOf = (of, control) => check.reads.find((r) => r.measure === of && r.control === control && r.stratum === stratum)?.comparisons ?? [];
+	const notBeaten = guards.filter((g) => !testsOf(measure, g.control).some((c) => c.better === entry && c.beats));
+	const clearsOnPartner = (guard) => guard.partners.some((p) => testsOf(p.partner, guard.control).some((c) => c.better === entry && clearsPartner(c, guard.partners.length, check.alpha)));
+	const countOf = (control) => read.entries.find((c) => c.group === control && c.stratum === stratum)?.censored ?? 0;
+	const alone = guards.length > 0 && notBeaten.length === 0;
+	return {
+		alone,
+		show: notBeaten.length > 0 && notBeaten.every((g) => g.status === "wins") ? [...new Set(winning.flatMap(lostByControl))] : alone ? [] : read.partners,
+		likeControl: notBeaten.some((guard) => !clearsOnPartner(guard)),
+		censored: {
+			entry: count.censored,
+			controls: notBeaten.map((g) => ({
+				control: g.control,
+				censored: countOf(g.control)
+			}))
+		},
+		open: read.open
+	};
+}
 // src/power.ts
 /**
 * The power test of a time verdict. It draws seeded benches with a known speedup and counts the verdicts that find it.
@@ -1203,6 +1870,6 @@ function timeRounds(arms, options) {
 		sink
 	};
 }
-export { BUDGET_LOOKS, LADDER_FORMAT, aaBand, aaSpread, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, checkLadder, checkPairedTime, controlFactor, firstArm, ladderVerdict, limitVerdict, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, rungVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower };
+export { BUDGET_LOOKS, GATE_LOOKS, LADDER_FORMAT, aaBand, aaSpread, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, checkLadder, checkMeasures, checkPairedTime, controlFactor, firstArm, gateOf, ladderVerdict, limitVerdict, notSlowerVerdict, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, rungVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower, winClaim };
 
 //# sourceMappingURL=index.js.map