@mark1russell7/rigor-bench 0.2.15 → 0.2.16

package/README.md

@@ -42,6 +42,9 @@ v.comparison;                                     // the cases that gain and dro
 | `pooledBand(pool, level)` | The pooled band: the larger of the floor and the A/A spread of the records of earlier runs. |
 | `caseIntervals(records, level)` | The ratio of each case with a distribution-free interval of its median over the rounds. The level 0.95 needs 6 rounds or more. |
 | `limitVerdict(candidate, aa, options)` | The verdict of the claim "the ratio of each case is at most `limit`": `within`, `beyond` or `cannot decide`. |
+| `tailLimitVerdict(candidate, aa, options)` | The verdict of the claim "the median and a high value of each case are at most their limits", for a bench with few rounds. |
+| `caseTails(records, rank)` | The value at one rank of the ratios of each case, from the largest. |
+| `tailFalseFails(aa, options)` | The cases of an A/A arm that the rule of `tailLimitVerdict` fails, and apart from these the cases with a limit under 1. |
 | `gateOf(cases)` | The gate of a list of case outcomes: `pass`, `block` or `no read`. |
 | `notSlowerVerdict(jobs, options)` | The gate of the claim "not slower by more than the margin", with looks and a family level. |
 | `budgetVerdict(rounds, aa, options)` | The verdict of the claim "the median of each case is at most `limit`", for one build: `within`, `beyond` or `cannot decide`. |
@@ -80,6 +83,35 @@ v.cases;                                          // the interval, the bound and
 
 The verdict has no correction for many cases. Each case has its own interval at the level `caseLevel`. Thus with many cases, a verdict `beyond` can come from noise only. Set `caseLevel` higher when a bench has many cases. A correction of Holm is an option for a later version.
 
+## A claim with a limit on a tail
+
+`limitVerdict` needs an interval of the median, and a few rounds give a wide interval. `tailLimitVerdict` reads each value as it is. An example is a gate with 7 rounds and one limit for each module:
+
+```ts
+const v = tailLimitVerdict(records, aaRecords, {
+  limit: (name) => limits[name],
+  aaCap: 1.3,
+});
+v.outcome;                                        // "within", "beyond" or "cannot decide"
+v.aaTail;                                         // the largest tail of the A/A arm
+```
+
+The rule of the verdict:
+
+- The tail of a case is the value at `rank` of its ratios, from the largest. The default rank is 2, so one slow process cannot move it.
+- A case is `beyond` when its median is over `limit.median`.
+- A case is also `beyond` when its tail is over `limit.tail` and over the largest tail of the A/A arm of the run.
+- Each case is `cannot decide` when the largest tail of the A/A arm is over `aaCap`. A loud run has no power, and this is not a pass. The caller takes another read.
+- The option `aaCap` has no default, because a run with no cap passes each row when it is loud.
+- The option `expected` names the cases that the run must have. A case of that list with no record reads `cannot decide`. Without this option, a run that loses a case reads the other cases only.
+- `gateOf(v.cases)` gives the gate of the verdict: `pass`, `block` or `no read`.
+
+With the default rank, a real cost in 1 round cannot fail the tail limit. This is by design: of 7 rounds, 1 round passes the tail, 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. `tailFalseFails` applies the rule to each case of an A/A arm. Each case reads the tail of the other cases. Print the count of `fails` on the gate, to state what the rule costs on noise.
+
+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 false fails of a gain limit come from repeat reads of an unchanged tree against its fixed base.
+
 ## A gate that can fail
 
 A check that blocks a merge needs a result that can fail. `gateOf` reads the case outcomes of a verdict, and `notSlowerVerdict` gives the claim of a speed gate.
@@ -433,7 +465,7 @@ v.pool;                                           // { cases, runs, spread, floo
 - The rule `difference` uses the larger of `margin` and the noise of the pooled band as its margin.
 - The run still needs its own A/A arm of 5 cases or more. The noise cap uses that arm.
 
-For a fixed limit, for example 1.10 against a fixed base, use `limitVerdict`.
+For a fixed limit, for example 1.10 against a fixed base, use `limitVerdict`. With few rounds and a limit on a high value of each case, use `tailLimitVerdict`.
 
 ## The outcomes
 

package/build/index.d.ts

@@ -790,6 +790,107 @@ export declare function rungVerdict(rung: Rung, record: RungRecord | undefined,
  * a `RangeError` for a ladder with problems, because a verdict on a bad ladder has no meaning. See `checkLadder`.
  */
 export declare function ladderVerdict(ladder: Ladder, records: readonly RungRecord[], options: LadderOptions): LadderVerdict;
+/** The value at one rank of the ratios of one case, from the largest. */
+interface CaseTail {
+  readonly case: string;
+  /** The value at the rank, or undefined when the rounds do not put the rank above the median. */
+  readonly tail: number | undefined;
+  readonly rounds: number;
+}
+/** The two limits of one case. */
+interface TailLimit {
+  /** The largest median of the ratio `b / a` that the claim permits. */
+  readonly median: number;
+  /** The largest tail of the ratio `b / a` that the claim permits. */
+  readonly tail: number;
+}
+/** The options of `tailFalseFails`. */
+interface TailRuleOptions {
+  /** The limits of all the cases, or a function that gives the limits of one case. */
+  readonly limit: TailLimit | ((caseName: string) => TailLimit);
+  /** The rank of the tail, from the largest. The default 2 reads the second largest ratio, so one slow process cannot move it. */
+  readonly rank?: number;
+}
+/** The options of a tail limit verdict. */
+interface TailLimitOptions extends TailRuleOptions {
+  /**
+   * The largest tail of the A/A arm that lets a run decide. Each row under the tail of the A/A arm passes the tail limit, so
+   * a loud run has no power. This option has no default, because a run with no cap passes each row when it is loud.
+   */
+  readonly aaCap: number;
+  /** The smallest number of A/A cases with a tail. The default is 5. */
+  readonly minimum?: number;
+  /**
+   * The names of the cases that the run must have. A case of this list with no record reads `cannot decide`. Without this
+   * option, the verdict reads only the cases of the candidate, so a run that loses a case can read `within`.
+   */
+  readonly expected?: readonly string[];
+}
+/** The verdict of one case. */
+interface CaseTailLimit extends CaseTail {
+  /** The median ratio of the case: the value `ratio` of `caseRatios`. The value is undefined when the case has no record. */
+  readonly ratio: number | undefined;
+  readonly limit: TailLimit;
+  /** The median is over its limit. */
+  readonly overMedian: boolean;
+  /** The tail is over its limit and over the tail of the A/A arm of the run. */
+  readonly overTail: boolean;
+  readonly outcome: LimitOutcome;
+}
+/** A case that an A/A arm cannot read, with the reason. */
+interface TailGainCase {
+  readonly case: string;
+  /** The reason in one sentence. It names the limit under 1. */
+  readonly reason: string;
+}
+/** The result of `tailFalseFails`. */
+interface TailFalseFails {
+  /** The cases that the rule fails on the A/A arm. Print the count of this list on the gate. */
+  readonly fails: readonly string[];
+  /** The cases with a limit under 1. These cases are not in `fails`, because an A/A pair shows no gain. */
+  readonly gains: readonly TailGainCase[];
+}
+/** A tail limit verdict, with the facts that it uses. */
+interface TailLimitVerdict {
+  readonly outcome: LimitOutcome;
+  /** The reason of the outcome, in one sentence. */
+  readonly reason: string;
+  readonly cases: readonly CaseTailLimit[];
+  /** The largest tail over the cases of the A/A arm, or undefined when that arm has too few cases. */
+  readonly aaTail: number | undefined;
+  readonly aaCap: number;
+  readonly rank: number;
+}
+/**
+ * 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.
+ */
+export declare function caseTails(records: readonly PairedTime[], rank?: number): CaseTail[];
+/**
+ * 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.
+ */
+export declare function tailLimitVerdict(candidate: readonly PairedTime[], aa: readonly PairedTime[], options: TailLimitOptions): TailLimitVerdict;
+/**
+ * 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.
+ */
+export declare function tailFalseFails(aa: readonly PairedTime[], options: TailRuleOptions): TailFalseFails;
 /** One value of one measure, for one entry and one input. */
 interface MeasureRow {
   /** The name of the measure. */
@@ -1072,5 +1173,5 @@ interface Rounds {
  * keeps the work.
  */
 export declare function timeRounds(arms: Readonly<Record<Arm, () => number>>, options: RoundsOptions): Rounds;
-export { type Arm, type Balanced, type Band, type BandKind, type BandOptions, type BudgetLook, type BudgetLooksOptions, type BudgetLooksVerdict, type BudgetMore, type BudgetOptions, type BudgetOutcome, type BudgetResult, type BudgetRound, type BudgetVerdict, type CaseBudget, type CaseGate, type CaseInterval, type CaseLimit, type CaseRatio, type Comparison, type ControlFactors, type ControlOptions, type ControlRead, type ControlRow, type EntryCount, type Gate, type GateCaseOutcome, type GateJobRead, type GateOutcome, type GroupCounts, type GroupFactor, type GuardRead, type JobLimitVerdict, type JobRecords, type JobVerdict, type Ladder, type LadderDimension, type LadderOptions, type LadderVerdict, type LimitOptions, type LimitOutcome, type LimitVerdict, type MeasureCheck, type MeasureCheckOptions, type MeasureChecks, type MeasureFinding, type MeasureFindingKind, type MeasureRow, type MeasureRule, type MeasuredFactor, type MedianBudget, type NoControl, type NoFactor, type NoiseCheck, type NotSlowerOptions, type NotSlowerRead, type NotSlowerVerdict, type PairedTime, type PartnerRead, type PoolFacts, type PoolOptions, type PooledJob, type PooledLimitVerdict, type PooledRecords, type PooledVerdict, type Power, type PowerOptions, type QuantileBudget, type RateBudget, type Rounds, type RoundsOptions, type RunPairs, type Rung, type RungBudget, type RungEvidence, type RungRecord, type RungVerdict, type SpreadRead, type TimeOutcome, type TimeVerdict, type VerdictOptions, type VerdictRule, type WinClaim, type WorstBudget, caseRatios, checkPairedTime, firstArm };
+export { type Arm, type Balanced, type Band, type BandKind, type BandOptions, type BudgetLook, type BudgetLooksOptions, type BudgetLooksVerdict, type BudgetMore, type BudgetOptions, type BudgetOutcome, type BudgetResult, type BudgetRound, type BudgetVerdict, type CaseBudget, type CaseGate, type CaseInterval, type CaseLimit, type CaseRatio, type CaseTail, type CaseTailLimit, type Comparison, type ControlFactors, type ControlOptions, type ControlRead, type ControlRow, type EntryCount, type Gate, type GateCaseOutcome, type GateJobRead, type GateOutcome, type GroupCounts, type GroupFactor, type GuardRead, type JobLimitVerdict, type JobRecords, type JobVerdict, type Ladder, type LadderDimension, type LadderOptions, type LadderVerdict, type LimitOptions, type LimitOutcome, type LimitVerdict, type MeasureCheck, type MeasureCheckOptions, type MeasureChecks, type MeasureFinding, type MeasureFindingKind, type MeasureRow, type MeasureRule, type MeasuredFactor, type MedianBudget, type NoControl, type NoFactor, type NoiseCheck, type NotSlowerOptions, type NotSlowerRead, type NotSlowerVerdict, type PairedTime, type PartnerRead, type PoolFacts, type PoolOptions, type PooledJob, type PooledLimitVerdict, type PooledRecords, type PooledVerdict, type Power, type PowerOptions, type QuantileBudget, type RateBudget, type Rounds, type RoundsOptions, type RunPairs, type Rung, type RungBudget, type RungEvidence, type RungRecord, type RungVerdict, type SpreadRead, type TailFalseFails, type TailGainCase, type TailLimit, type TailLimitOptions, type TailLimitVerdict, type TailRuleOptions, type TimeOutcome, type TimeVerdict, type VerdictOptions, type VerdictRule, type WinClaim, type WorstBudget, caseRatios, checkPairedTime, firstArm };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"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/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

@@ -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,7 +209,7 @@ 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
@@ -871,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",
@@ -946,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);
@@ -956,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,
@@ -983,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,
@@ -1009,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
@@ -1114,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;
 }
@@ -1870,6 +2061,6 @@ function timeRounds(arms, options) {
 		sink
 	};
 }
-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 };
+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