@mark1russell7/rigor-bench 0.2.14 → 0.2.16

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Comparison"],"sources":["../src/budget.ts","../src/control.ts","../src/ladder.ts","../src/verdict.ts","../src/limit.ts","../src/merge.ts","../src/measures.ts","../src/power.ts","../src/rounds.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["Comparison"],"sources":["../src/budget.ts","../src/verdict.ts","../src/limit.ts","../src/merge.ts","../src/gate.ts","../src/control.ts","../src/ladder.ts","../src/tail.ts","../src/measures.ts","../src/power.ts","../src/rounds.ts"],"mappings":"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"}

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, holm, median, medianInterval, quantile, quantileInterval, quantileSamples, signTest, signTestPower, 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
 /**
@@ -28,7 +28,7 @@ function caseBudget(name, values, aaValues, options, level) {
 	const aaMedian = aaValues.length > 0 ? median(aaValues) : void 0;
 	const difference = aaMedian === void 0 ? void 0 : Math.abs(middle - aaMedian);
 	const aaCoverage = aaValues.length > 0 ? medianInterval(aaValues, level).coverage : 0;
-	const facts = `median ${round$2(middle)} of ${values.length} rounds, interval ${round$2(interval.low)} to ${round$2(interval.high)}, limit ${limit}, A/A median ${aaMedian === void 0 ? "none" : round$2(aaMedian)} of ${aaValues.length} rounds, difference ${difference === void 0 ? "none" : round$2(difference)}`;
+	const facts = `median ${round$3(middle)} of ${values.length} rounds, interval ${round$3(interval.low)} to ${round$3(interval.high)}, limit ${limit}, A/A median ${aaMedian === void 0 ? "none" : round$3(aaMedian)} of ${aaValues.length} rounds, difference ${difference === void 0 ? "none" : round$3(difference)}`;
 	const decide = (outcome, why) => ({
 		case: name,
 		rounds: values.length,
@@ -180,7 +180,7 @@ function budgetLooksVerdict(rounds, aa, options) {
 	const looks = options.looks ?? BUDGET_LOOKS;
 	const level = options.level ?? .95;
 	const spent = budgetLookSpend(looks);
-	if (spent > 1 - level) throw new RangeError(`budgetLooksVerdict: the looks spend ${round$2(spent)}, over the ${round$2(1 - level)} of the level ${level}.`);
+	if (spent > 1 - level) throw new RangeError(`budgetLooksVerdict: the looks spend ${round$3(spent)}, over the ${round$3(1 - level)} of the level ${level}.`);
 	if (!(limit >= 0 && Number.isFinite(limit))) throw new RangeError(`budgetLooksVerdict: the limit is finite and 0 or more, not ${limit}.`);
 	if (!(maxDifference >= 0 && Number.isFinite(maxDifference))) throw new RangeError(`budgetLooksVerdict: the largest difference is finite and 0 or more, not ${maxDifference}.`);
 	const byRound = (list) => [...list].sort((a, b) => a.round - b.round);
@@ -209,9 +209,219 @@ function budgetLooksVerdict(rounds, aa, options) {
 		fails: verdict.cases.some((c) => c.outcome === "beyond")
 	};
 }
-function round$2(x) {
+function round$3(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.
@@ -661,14 +871,14 @@ function timeVerdict(candidate, aa, options = {}) {
 			noise
 		};
 		if (noise.noisy && verdict.band !== void 0) {
-			const reason = `${spread === void 0 ? "The A/A arm of the run has no cases, so the noise cap has no spread." : `The A/A spread of the run is ${round$1(spread)}, above the noise cap ${cap}.`} Without the cap, the outcome is "${verdict.outcome}".`;
+			const reason = `${spread === void 0 ? "The A/A arm of the run has no cases, so the noise cap has no spread." : `The A/A spread of the run is ${round$2(spread)}, above the noise cap ${cap}.`} Without the cap, the outcome is "${verdict.outcome}".`;
 			verdict = {
 				...verdict,
 				outcome: "cannot decide",
 				reason
 			};
 		} else if (noise.biased && verdict.band !== void 0) {
-			const reason = `The A/A median ratio of the run is ${round$1(aaMedian)}, out of [${round$1(Math.exp(-cap))}, ${round$1(Math.exp(cap))}] of the noise cap ${cap}. Without the cap, the outcome is "${verdict.outcome}".`;
+			const reason = `The A/A median ratio of the run is ${round$2(aaMedian)}, out of [${round$2(Math.exp(-cap))}, ${round$2(Math.exp(cap))}] of the noise cap ${cap}. Without the cap, the outcome is "${verdict.outcome}".`;
 			verdict = {
 				...verdict,
 				outcome: "cannot decide",
@@ -736,7 +946,7 @@ function ruleVerdict(candidate, aa, options, pooled) {
 	};
 	if (rule === "difference") {
 		const margin = marginOf(options, pooled);
-		const shown = pooled === void 0 ? margin : round$1(margin);
+		const shown = pooled === void 0 ? margin : round$2(margin);
 		const logs = cases.map((c) => Math.log(c.ratio));
 		const aaLogs = aaRatios.map((c) => Math.log(c.ratio));
 		const d = bootstrapTwo(logs, aaLogs, (x, y) => median(x) - median(y), options.bootstrap);
@@ -746,7 +956,7 @@ function ruleVerdict(candidate, aa, options, pooled) {
 			low: Math.exp(d.low),
 			high: Math.exp(d.high)
 		};
-		const span = `The interval of the candidate median over the A/A median is [${round$1(interval.low)}, ${round$1(interval.high)}].`;
+		const span = `The interval of the candidate median over the A/A median is [${round$2(interval.low)}, ${round$2(interval.high)}].`;
 		if (d.low >= -margin && d.high <= margin) return {
 			...facts,
 			interval,
@@ -773,7 +983,7 @@ function ruleVerdict(candidate, aa, options, pooled) {
 		};
 	}
 	const interval = bootstrapMedian(cases.map((c) => c.ratio), options.bootstrap);
-	const span = `The interval of the median ratio is [${round$1(interval.low)}, ${round$1(interval.high)}], and the A/A band is [${round$1(band.low)}, ${round$1(band.high)}].`;
+	const span = `The interval of the median ratio is [${round$2(interval.low)}, ${round$2(interval.high)}], and the A/A band is [${round$2(band.low)}, ${round$2(band.high)}].`;
 	if (interval.high < band.low) return {
 		...facts,
 		interval,
@@ -799,7 +1009,7 @@ function ruleVerdict(candidate, aa, options, pooled) {
 		reason: `${span} The interval crosses an end of the band.`
 	};
 }
-function round$1(x) {
+function round$2(x) {
 	return Math.round(x * 1e4) / 1e4;
 }
 // src/limit.ts
@@ -904,17 +1114,208 @@ function limitVerdict(candidate, aa, options) {
 		const rest = others.length === 0 ? "" : ` ${others.length} of ${cases.length} cases are not within${permit}.`;
 		return {
 			outcome: "within",
-			reason: `The largest bound of a case within is ${round(top.bound)} in the case ${JSON.stringify(top.case)}, and it is at most the limit ${limit}.${rest}`,
+			reason: `The largest bound of a case within is ${round$1(top.bound)} in the case ${JSON.stringify(top.case)}, and it is at most the limit ${limit}.${rest}`,
 			...facts
 		};
 	}
 	const top = cases.reduce((a, b) => b.bound > a.bound ? b : a);
 	return {
 		outcome: "cannot decide",
-		reason: `${others.length} of ${cases.length} cases are not within${permit}. The bound of the case ${JSON.stringify(top.case)} is ${round(top.bound)}, above the limit ${limit}, and too few floors are above it.`,
+		reason: `${others.length} of ${cases.length} cases are not within${permit}. The bound of the case ${JSON.stringify(top.case)} is ${round$1(top.bound)}, above the limit ${limit}, and too few floors are above it.`,
 		...facts
 	};
 }
+function round$1(x) {
+	return Math.round(x * 1e4) / 1e4;
+}
+// src/tail.ts
+/**
+* The tail limit verdict of a bench with few rounds. The median of each case has one limit, and a high value of its rounds
+* has another limit. The verdict `limitVerdict` needs an interval of the median, and a few rounds give a wide interval.
+* This verdict reads each value as it is, and the A/A arm of the same run tells which tail is noise.
+*/
+function ratiosOf(records) {
+	const ratios = /* @__PURE__ */ new Map();
+	for (const r of records) {
+		const list = ratios.get(r.case) ?? [];
+		list.push(r.b / r.a);
+		ratios.set(r.case, list);
+	}
+	return ratios;
+}
+function checkRank(rank) {
+	if (!Number.isSafeInteger(rank) || rank < 1) throw new RangeError(`tail: the rank is a whole number of 1 or more, not ${rank}.`);
+}
+/**
+* This function gives the value at one rank of the ratios of each case, from the largest, in the order of `caseRatios`. It
+* examines the records as `caseRatios` does. A case needs `2 * rank + 1` rounds, so that the value is above the median.
+*/
+function caseTails(records, rank = 2) {
+	checkRank(rank);
+	const ratios = ratiosOf(records);
+	return caseRatios(records).map((c) => {
+		const sorted = (ratios.get(c.case) ?? []).toSorted((x, y) => y - x);
+		return {
+			case: c.case,
+			rounds: c.rounds,
+			tail: c.rounds >= 2 * rank + 1 ? sorted[rank - 1] : void 0
+		};
+	});
+}
+function limitOf(options, name) {
+	const limit = typeof options.limit === "function" ? options.limit(name) : options.limit;
+	for (const value of [limit.median, limit.tail]) if (!(value > 0 && Number.isFinite(value))) throw new RangeError(`tail: each limit is a finite number above 0, not ${value} for the case ${JSON.stringify(name)}.`);
+	return limit;
+}
+function largestTail(tails) {
+	const values = tails.flatMap((c) => c.tail === void 0 ? [] : [c.tail]);
+	return values.length === 0 ? void 0 : Math.max(...values);
+}
+/**
+* This function gives the verdict of the claim "the median and the tail of each case are at most their limits".
+* - A case is `beyond` when its median is over its limit. It is also `beyond` when its tail is over its limit and over the
+*   largest tail of the A/A arm of the run.
+* - A case with too few rounds for the rank is `cannot decide`, unless its median is over its limit.
+* - A case of `expected` with no record is `cannot decide`.
+* - The verdict is `beyond` when a case is `beyond`, and `within` when each case is `within`.
+* - Each case and the verdict are `cannot decide` when the largest tail of the A/A arm is over `aaCap`. The same applies
+*   when the A/A arm has fewer than `minimum` cases with a tail. This is not a pass, so the caller takes another read.
+*
+* With the default rank, a real cost in 1 round cannot fail the tail limit, because 1 round cannot be told from noise. A
+* cost in 2 rounds or more can fail it. The verdict has no interval, so a limit needs a margin from the spread of earlier
+* runs.
+*/
+function tailLimitVerdict(candidate, aa, options) {
+	const { aaCap } = options;
+	const rank = options.rank ?? 2;
+	const minimum = options.minimum ?? 5;
+	checkRank(rank);
+	if (!(aaCap > 0 && Number.isFinite(aaCap))) throw new RangeError(`tailLimitVerdict: the cap is a finite number above 0, not ${aaCap}.`);
+	if (!Number.isSafeInteger(minimum) || minimum < 1) throw new RangeError(`tailLimitVerdict: the minimum is a whole number of 1 or more, not ${minimum}.`);
+	const aaTails = caseTails(aa, rank).filter((c) => c.tail !== void 0);
+	const aaTail = aaTails.length < minimum ? void 0 : largestTail(aaTails);
+	const tails = new Map(caseTails(candidate, rank).map((c) => [c.case, c]));
+	const facts = {
+		aaTail,
+		aaCap,
+		rank
+	};
+	const present = caseRatios(candidate).map((c) => {
+		const { tail } = tails.get(c.case) ?? { tail: void 0 };
+		const limit = limitOf(options, c.case);
+		if (aaTail === void 0 || aaTail > aaCap) return {
+			case: c.case,
+			tail,
+			rounds: c.rounds,
+			ratio: c.ratio,
+			limit,
+			overMedian: false,
+			overTail: false,
+			outcome: "cannot decide"
+		};
+		const overMedian = c.ratio > limit.median;
+		const overTail = tail !== void 0 && tail > limit.tail && tail > aaTail;
+		const outcome = overMedian || overTail ? "beyond" : tail === void 0 ? "cannot decide" : "within";
+		return {
+			case: c.case,
+			tail,
+			rounds: c.rounds,
+			ratio: c.ratio,
+			limit,
+			overMedian,
+			overTail,
+			outcome
+		};
+	});
+	const found = new Set(present.map((c) => c.case));
+	const missing = [...new Set(options.expected ?? [])].filter((name) => !found.has(name)).map((name) => ({
+		case: name,
+		tail: void 0,
+		rounds: 0,
+		ratio: void 0,
+		limit: limitOf(options, name),
+		overMedian: false,
+		overTail: false,
+		outcome: "cannot decide"
+	}));
+	const cases = [...present, ...missing];
+	if (aaTail === void 0) return {
+		...facts,
+		outcome: "cannot decide",
+		cases,
+		reason: `The A/A arm has ${aaTails.length} cases with a tail, and the verdict needs ${minimum} or more.`
+	};
+	if (aaTail > aaCap) return {
+		...facts,
+		outcome: "cannot decide",
+		cases,
+		reason: `The largest tail ${round(aaTail)} of the A/A arm is over the cap ${aaCap}, so this run has no power.`
+	};
+	if (cases.length === 0) return {
+		...facts,
+		outcome: "cannot decide",
+		cases,
+		reason: "The candidate has no cases."
+	};
+	const beyond = cases.filter((c) => c.outcome === "beyond");
+	if (beyond.length > 0) return {
+		...facts,
+		outcome: "beyond",
+		cases,
+		reason: `${beyond.length} of ${cases.length} cases are over a limit. The first is ${JSON.stringify(beyond[0].case)}.`
+	};
+	if (missing.length > 0) return {
+		...facts,
+		outcome: "cannot decide",
+		cases,
+		reason: `${missing.length} of ${cases.length} cases have no record. The first is ${JSON.stringify(missing[0].case)}.`
+	};
+	const open = cases.filter((c) => c.outcome === "cannot decide");
+	if (open.length > 0) return {
+		...facts,
+		outcome: "cannot decide",
+		cases,
+		reason: `${open.length} of ${cases.length} cases have too few rounds for the rank ${rank}. The first is ${JSON.stringify(open[0].case)}.`
+	};
+	return {
+		...facts,
+		outcome: "within",
+		cases,
+		reason: `Each of the ${cases.length} cases is at most its limits, or its tail is at most the tail ${round(aaTail)} of the A/A arm.`
+	};
+}
+/**
+* This function applies the rule of `tailLimitVerdict` to each case of the A/A arm, and gives the cases that fail. Each
+* case reads the tail of the other cases, because a case cannot be the noise of itself. An arm with one case gives no
+* failed case.
+*
+* A limit under 1 states a gain, and an A/A pair shows no gain. So the A/A arm has no read of that case, and the case goes
+* in `gains` with that reason. The tail of that case stays in the noise of the other cases. The false fails of a gain limit
+* come from repeat reads of an unchanged tree against its fixed base.
+*/
+function tailFalseFails(aa, options) {
+	const tails = caseTails(aa, options.rank ?? 2);
+	const ratios = new Map(caseRatios(aa).map((c) => [c.case, c.ratio]));
+	const gains = tails.flatMap((c) => {
+		const limit = limitOf(options, c.case);
+		const under = Math.min(limit.median, limit.tail);
+		return under < 1 ? [{
+			case: c.case,
+			reason: `The limit ${under} is under 1, and an A/A pair shows no gain, so the A/A arm has no read of this case.`
+		}] : [];
+	});
+	const noRead = new Set(gains.map((c) => c.case));
+	return {
+		fails: tails.filter((c) => {
+			if (noRead.has(c.case)) return false;
+			const others = largestTail(tails.filter((other) => other !== c));
+			if (others === void 0) return false;
+			const limit = limitOf(options, c.case);
+			return (ratios.get(c.case) ?? 0) > limit.median || c.tail !== void 0 && c.tail > limit.tail && c.tail > others;
+		}).map((c) => c.case),
+		gains
+	};
+}
 function round(x) {
 	return Math.round(x * 1e4) / 1e4;
 }
@@ -1660,6 +2061,6 @@ function timeRounds(arms, options) {
 		sink
 	};
 }
-export { BUDGET_LOOKS, LADDER_FORMAT, aaBand, aaSpread, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, checkLadder, checkMeasures, checkPairedTime, controlFactor, firstArm, ladderVerdict, limitVerdict, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, rungVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower, winClaim };
+export { BUDGET_LOOKS, GATE_LOOKS, LADDER_FORMAT, aaBand, aaSpread, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, caseTails, checkLadder, checkMeasures, checkPairedTime, controlFactor, firstArm, gateOf, ladderVerdict, limitVerdict, notSlowerVerdict, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, rungVerdict, tailFalseFails, tailLimitVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower, winClaim };
 
 //# sourceMappingURL=index.js.map