From af85f05fdfcb810e0973e829d838ecb35946390a Mon Sep 17 00:00:00 2001
From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com>
Date: Mon, 5 Oct 2026 19:10:11 -0700
Subject: [PATCH] IBA2-012: conditional count-weighted multi-soft transfer and
 sharpness obstructions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Dylan Roy — delegated AI work. Author OpenAI / GPT-6 Astra Pro, iba2-count-weight-transfer-r6-20261006. Four additive files only; exact FR/CP/erratum bindings. No scientific status or formal source changes. Test source is not claimed executed; local execution tools fail before command startup. Nonauthor mathematical review and actual replay required.
---
 .../iba2_012_count_transfer_20261006/PROOF.md | 276 ++++++++++++++++++
 .../README.md                                 |  60 ++++
 .../SOURCES.json                              |  51 ++++
 .../test_count_transfer.py                    | 198 +++++++++++++
 4 files changed, 585 insertions(+)
 create mode 100644 reviews/iba2_012_count_transfer_20261006/PROOF.md
 create mode 100644 reviews/iba2_012_count_transfer_20261006/README.md
 create mode 100644 reviews/iba2_012_count_transfer_20261006/SOURCES.json
 create mode 100644 reviews/iba2_012_count_transfer_20261006/test_count_transfer.py

diff --git a/reviews/iba2_012_count_transfer_20261006/PROOF.md b/reviews/iba2_012_count_transfer_20261006/PROOF.md
new file mode 100644
index 000000000..3630e4794
--- /dev/null
+++ b/reviews/iba2_012_count_transfer_20261006/PROOF.md
@@ -0,0 +1,276 @@
+# IBA2-012: count-weighted transfer on shrinking multi-soft sectors
+
+Object: IBA2-012-COUNT-TRANSFER-20261006-v1.
+Dylan Roy — delegated AI mathematical work. Actual author OpenAI / GPT-6 Astra Pro,
+continuation `iba2-count-weight-transfer-r6-20261006`, under main#259/6007422896
+and resumption6007796915. The author also authored the finite-radius precursor.
+Source-exposed; organizational-independence credit0; scientific effect NONE.
+**Author-side conditional proof candidate. Nonauthor analytic review required.**
+No existing proof, scientific register, acceptance record or formal manifest changes.
+
+## 1. Exact source cut and the gap being addressed
+
+Repository `d6g8k5htny-coder/Math-`, source cut
+`99ba2dfe33ef0052694510355b0c4d811fd66441`.
+
+| Tag | Path | Full Git blob | Consumed slice |
+|---|---|---|---|
+| FR | `reviews/iba2_012_finite_radius_20261005/PROOF.md` | `5ed684c9bb446efc9bef5f3980717c6dc039abfd` | Sections3–5 and8: same-law finite-radius derivative-weighted nonempty-sector bounds, especially FR-mixed |
+| CP | `frontiers/c6_palm_route_20260929/PROOF.md` | `89eb8adf08fe7afc2cab9662d3a9875c05ae5cc5` | Sections1.1–1.3: law/count, Theorem Q(1.1), all inherited scope/dependency qualifications |
+| ERR | `reviews/d5_dimension_lift_erratum_20261005/ERRATUM.md` | `23df87bbe4ffd3b2d786cd695fb9f5448cfa1d05` | Entire additive correction, including CP section6.2 R3a's repeated citation |
+
+FR section5 explicitly says that inserting N_R^j needs a separate count-moment
+argument. This note supplies that argument. It neither re-proves P section7 nor
+reclaims the existing limiting multi-soft measure. FR was integrated by #306 with
+scoped nonauthor review6005379068; its original author-side source header remains
+historical. CP is imported at Theorem Q's stated scope, not promoted by its merge,
+and ERR is read with the unchanged original. No mistaken intermediate Lipschitz
+display or doubled normalizer is imported. A defect in an imported interface
+invalidates the corresponding application here. No fresh full audit of CP's
+ancestors is claimed.
+
+The argument needs only one fixed factorial moment order for each chosen bound.
+It does not infer a global first moment from higher factorial moments, assume
+count/curvature independence, or assert conditional derivative moments under an
+additional witness law. The localization below handles the missing first moment.
+
+## 2. Setting, notation and claimed result
+
+Keep FR's fixed dimension d>=3, torus side L>0, observation radius R>=1, compact
+birth interval and compact gap marks 0<k_-<=k<=k_+. Frames range over the compact
+orthogonal group. Reduce the common positive radius cutoff so FR and the chosen
+instance of CP hold and r<=1. Constants may depend on these fixed data and the
+chosen moment orders, but not on r, frames, marks within their sets or thresholds.
+
+Write P_r=Q_r^W, using the exact same Gaussian pin law, typed maximum/saddle weight
+and full normalizer as FR and CP. P_r is a probability measure, not source P.
+Let N be CP's torus-wide count of all-index critical points between the pin heights,
+excluding pins. Let N_R be FR's count in the Rr-ball. Then 0<=N_R<=N pathwise.
+Let K>=1 be FR's C4 derivative control; CP's unrelated use of K for a C6 norm
+introduces no new assumption about this K.
+
+Fix 1<=q<=d-2 and ordered deterministic thresholds
+0<=eta_2<=...<=eta_(q+1)<=1. With FR's ordered midpoint eigenvalues h_j, define
+
+    S = {h_j<=eta_j for 2<=j<=q+1},
+    E = {N_R>0} intersect S,
+    Xi = product_{j=2}^{q+1}(eta_j+r)^(j+2),
+    beta_q = sum_{j=2}^{q+1}(j+2) = q(q+7)/2.
+
+The h_j need not be positive at finite r. Remaining eigenvalues have no hard
+lower bound; the all-soft transverse case is allowed. FR gives, for every fixed t>=0,
+
+    E_{P_r}[K^t 1_E] <= A_t r^3 Xi.                     (F)
+
+CP gives, for every fixed integer m>=2,
+
+    E_{P_r}[(N)_m] <= B_m r^3.                         (C)
+
+Here (n)_m=n(n-1)...(n-m+1), with value0 for integers 0<=n<m.
+These are the only quantitative inputs.
+
+**Theorem CT.** Fix real a>=0, p>0 and an integer m>=2 with m>p. Then
+
+    E_{P_r}[K^a N^p 1_E] <= C_{a,p,m} r^3 Xi^(1-p/m).  (CT)
+
+Consequently
+
+    E_{P_r}[K^a N_R^p 1_S] <= C_{a,p,m} r^3 Xi^(1-p/m). (CT-local)
+
+For p=0 use (F) directly, with E retained. There is no convention turning
+N_R^0 1_S into a nonempty-sector event. The theorem does not bound N^p 1_S
+when all witnesses are remote and N_R=0.
+
+## 3. Proof
+
+### 3.1 A localized ordinary moment, without a global first-moment premise
+
+For every nonnegative integer n and integer m>=2,
+
+    n^m <= m^m [1+(n)_m].                              (3.1)
+
+If n<m the constant suffices. If n>=m, each factor n-i, 0<=i<m, is at least n/m,
+since n-m+1>=n/m. Therefore (n)_m>=(n/m)^m. Multiplying by 1_E and using (C)
+and (F) at t=0 gives
+
+    E[N^m 1_E] <= m^m[P_r(E)+E[(N)_m]]
+               <= m^m(A_0 Xi+B_m)r^3 <= D_m r^3,       (3.2)
+
+because Xi<=2^beta_q. Finiteness is licensed by the count interface; alternatively
+(C) excludes an infinite count, and truncation proves the same displayed bounds.
+The +1 in (3.1) and the event localization are essential: N=1 has all factorial
+moments of order>=2 equal to0. We do not replace (3.2) by an unproved global
+E N^m=O(r^3).
+
+### 3.2 Holder on the same probability measure
+
+Put u=m/(m-p) and v=m/p. These are conjugate exponents greater than1. Holder gives
+
+    E[K^a N^p 1_E]
+      <= (E[N^m 1_E])^(p/m)
+         (E[K^(a m/(m-p)) 1_E])^(1-p/m).              (3.3)
+
+Use (3.2) and (F) at the fixed larger derivative moment a m/(m-p):
+
+    <= (D_m r^3)^(p/m)
+       (A_(a m/(m-p)) r^3 Xi)^(1-p/m)
+     = C_{a,p,m} r^3 Xi^(1-p/m).
+
+The radial exponent is 3, not 3(1-p/m): both factors contain r^3. No independence
+is used and no additional division by Z occurs. FR already charged the derivative
+tails. There is no joint count/derivative-moment premise or exchange of a limiting
+law with shrinking thresholds. For p>0, N_R^p 1_S=N_R^p 1_E<=N^p 1_E. This proves
+CT-local and completes the proof.
+
+## 4. Consequences at the r^3 cluster scale
+
+### 4.1 Shrinking thresholds and the quantified loss
+
+For eta_j=r^alpha_j with fixed alpha_2>=...>=alpha_(q+1)>0, let
+
+    B = sum_{j=2}^{q+1}(j+2) min(alpha_j,1)>0.
+
+Each eta_j+r<=2 r^min(alpha_j,1), so
+
+    E[K^a N_R^p 1_S] = O(r^[3+B(1-p/m)]) = o(r^3).     (4.1)
+
+Saturation below the perturbation scale r is unchanged. For equal thresholds r,
+B=beta_q. Taking m=2p for a fixed positive integer p gives:
+
+| Additional soft directions q | FR event bound | Count-weighted bound with m=2p |
+|---:|---:|---:|
+| 1 | O(r^7) | O(r^5) |
+| 2 | O(r^12) | O(r^(15/2)) |
+| 3 | O(r^18) | O(r^(21/2)) |
+
+Rows require d>=q+2. For q=2, thresholds (r^(1/2),r^(1/4)) give B=13/4;
+p=1,m=2 gives O(r^(37/8)), still o(r^3).
+
+For every fixed epsilon in (0,1), choose a fixed integer m>=2 with m>p and
+p/m<=epsilon. Then CT implies O(r^3 Xi^(1-epsilon)); for Xi>1 absorb the bounded
+range Xi<=2^beta_q into the constant. Neither B_m nor A_t is controlled uniformly
+as m grows. Setting epsilon=0 by taking a limit of these inequalities is invalid.
+Section5 supplies countermodels. No r-dependent moment order is allowed here.
+
+More generally, ordered thresholds all tending to0 give Xi->0 and o(r^3), without
+a prescribed power-law rate. Fixed nonshrinking thresholds give a bound, not an
+assertion of negligible contribution as r tends to0.
+
+### 4.2 Factorial intensity measures and polynomial observables
+
+For each fixed integer s>=1, (N_R)_s<=N_R^s. CT-local with p=s bounds the mass of
+ordered s-tuples of distinct local window points on S. Let nu_(r,s) be r^-3 times
+the expected positive measure of these tuples, with measurable positional or
+rescaled-coordinate marks; let nu_(r,s)^keep delete configurations in S. Then
+
+    ||nu_(r,s)-nu_(r,s)^keep||_variation
+      = r^-3 E[(N_R)_s 1_S] <= C Xi^(1-s/m),           (4.2)
+
+where m>=2 and m>s. This uses total mass as the norm of a positive measure, not
+the half-L1 convention for probability distributions. These are finite measures
+at each fixed r: (3.1) and (C) also give finite unlocalized ordinary moments,
+though not the r^3 order used in (3.2). There is no assertion that the entire
+intensity measures converge; only the deleted mass is controlled.
+
+For a signed tuple observable bounded pointwise by K^a, its deleted expectation
+is bounded in absolute value by r^-3 E[K^a(N_R)_s 1_S]. Nonnegative sums of fixed
+powers, or polynomials whose constant term is multiplied by 1_{N_R>0}, follow
+term by term. Factorial degrees and polynomial degrees stay fixed.
+
+An additional local lower bound P_r(N_R>0)>=c r^3 would allow division to obtain
+conditional-on-local-occurrence bounds of order Xi^(1-p/m). That lower bound is
+not assumed or proved here. Size-biased normalization needs its own lower bound.
+A torus-wide lower obstruction is not silently substituted for a local one.
+
+## 5. What the listed interfaces cannot prove
+
+### 5.1 Optimal exponent with one fixed factorial order
+
+Fix m>=2 and 0<p<m; use d=3, beta_1=4. On an abstract finite probability space,
+set r_n=2^(-mn), K=1. An ordinary atom has mass r_n^3, N_R=N=2 and h_2=2.
+A rare atom has mass r_n^7, N_R=N=2^(4n) and h_2=r_n. The remainder has count0;
+put h_1=r_n/2 throughout. Probabilities sum to less than1 for n>=1.
+
+For every eta in [0,1], E is empty if eta<r_n and consists of the rare atom
+otherwise. Thus (F) holds for every derivative power. Also (N)_m<=N^m and
+r_n^7 2^(4nm)=r_n^3, proving the mth instance of (C). Yet
+
+    E[N^p;E_(eta=r_n)] = r_n^3 r_n^[4(1-p/m)].          (5.1)
+
+Consequently a uniformly larger Xi exponent is not deducible from (F) and that
+one factorial-moment bound. Higher factorial orders need not be O(r^3) for this
+family; this is not the all-orders countermodel below.
+
+### 5.2 All fixed factorial orders still do not give loss-free transfer
+
+Use d=3 again, but now r_n=2^(-n), K=1. The ordinary atom has mass r_n^3,
+N_R=N=2,h_2=2; the rare atom has mass r_n^7,N_R=N=n+2,h_2=r_n; the remainder has
+count0. Set h_1=r_n/2. This is one family for all moment orders simultaneously.
+The same all-threshold calculation proves (F), and for every fixed integer s>=2,
+
+    E[(N)_s] <= E[N^s]
+      = r_n^3[2^s+2^(-4n)(n+2)^s] <= C_s r_n^3.       (5.2)
+
+For example n+2<=3n and
+n^s<=s! binomial(n+s-1,s)<=s!2^(n+s-1) for n>=1 give an explicit finite C_s.
+The family also satisfies P(N_R>0)>=r_n^3 and E[(N)_2]>=2r_n^3. Nevertheless,
+for every p>0 at eta=r_n,
+
+    E[N_R^p;S]/[r_n^3(eta+r_n)^4] = (n+2)^p/16 -> infinity. (5.3)
+
+Loss-free O(r^3 Xi) count transfer therefore does not follow even from the entire
+collection (C),(F) and those occurrence/second-factorial lower bounds. In fact
+r_n^-3 E[exp(tN);N>0] is bounded for each fixed 0<t<4 log2: its rare term is
+exp(2t) exp[-n(4log2-t)]. Even that additional property does not give a constant
+loss-free bound on this sector. The inequality fails already on a sequence r_n;
+no continuous interpolation of the family is needed to refute a uniform deduction.
+
+These are abstract count/mark models, not Gaussian fields, Hessian realizations,
+or fixed Gaussian residual counterexamples. They limit an inference from the
+stated interfaces, not a stronger independently proved field theorem.
+
+### 5.3 A sufficient additional interface for a loss-free bound
+
+One natural sufficient strengthening is a uniform conditional count moment under
+the derivative-weighted sector measure:
+
+    E[K^a N_R^p 1_E] <= C E[K^a 1_E].                 (5.4)
+
+Where the right-hand denominator is positive, this states a bounded pth count
+moment after normalizing K^a 1_E dP_r; otherwise both integrals vanish. Combining
+(5.4) with (F) gives O(r^3 Xi) without exponent loss. This is not claimed to be
+logically necessary or already proved by CP. It is a precise missing interface
+for that natural route; it needs a sector-conditioned count estimate, not just
+unconditional fixed-order moments. The present CT already proves the required
+o(r^3) negligibility on shrinking sectors without (5.4).
+
+## 6. Verification and limits
+
+The standard-library test_count_transfer.py contains thirteen finite test methods.
+They check the factorial envelope including counts below m, event-localized moments,
+finite Holder inequalities with correlated derivative/count marks, common radial
+power, unequal exponents, saturation, the all-order spike model and ordered-tuple
+mass. M1 drops a radial factor, M2 discards Holder's exponent loss, M3 reverses
+unequal threshold weights, and M4 removes the indispensable +1 in (3.1).
+Intended failures must be assertions with no unexpected errors; an invalid label
+must exit2. These tests do not prove the continuum or imported field interfaces.
+
+At initial publication the author's container/Python execution tools returned
+InvalidArgumentError before execution. The test source was written but no new
+local execution or SHA-256 calculation is claimed. Native Git blobs bind the
+published text; actual runs, review and their exact source identities belong in
+subsequent PR receipts. No standalone test is secretly covered by the existing
+repository CI, which does not discover tests in this packet automatically.
+
+The smallest nonauthor read is (3.1)–(3.3), with the exact (F)/(C) law alignment,
+and the all-threshold countermodel (5.2)–(5.3). Check real p, zero thresholds,
+p=0 exclusion, derivative moment order, all-soft dimensions and intensity marking.
+Review may reuse the unchanged imported interfaces without repeating their whole
+proof chains, while retaining every inherited qualification.
+
+IBA2-012 remains open globally: no all-mark limit, growing observation radius,
+general higher-jet classification, remote-only sector bound, lifetime pushforward,
+elder-selection theorem, loss-free conditional moment, or full cluster-law rate
+is established. IBA2-009 matching is untouched. No numerical field constant,
+new Lean theorem, scientific acceptance or claim of independent organization is
+created by this note.
diff --git a/reviews/iba2_012_count_transfer_20261006/README.md b/reviews/iba2_012_count_transfer_20261006/README.md
new file mode 100644
index 000000000..e9b84ea84
--- /dev/null
+++ b/reviews/iba2_012_count_transfer_20261006/README.md
@@ -0,0 +1,60 @@
+# Count-weighted IBA2-012 transfer
+
+**Author:** OpenAI / GPT-6 Astra Pro, `iba2-count-weight-transfer-r6-20261006`, for Dylan Roy.
+**Initial disposition:** conditional proof candidate; nonauthor mathematical review and actual test execution required.
+Scientific effect NONE. This packet adds no scientific status register or formal target.
+
+Read [PROOF.md](PROOF.md) and its [exact bindings](SOURCES.json). From the landed
+finite-radius multi-soft event estimate and the C6 fixed-order factorial moments,
+Holder gives
+
+    E[K^a N_R^p; S] <= C r^3 Xi^(1-p/m),
+    Xi = product_(j=2..q+1)(eta_j+r)^(j+2), m>=2, m>p>0.
+
+All field, dimension, observation radius and positive-compact-mark hypotheses stay
+fixed. The proof localizes the ordinary count moment before applying Holder; it
+does not silently insert a first-moment premise or assume independence. Shrinking
+thresholds give o(r^3) for every fixed polynomial or factorial local-count weight.
+A precise abstract rare-spike family rules out loss-free O(r^3 Xi) as a consequence
+of these inputs alone, even with every fixed factorial order available.
+
+## Replay
+
+From this directory, with Python 3.11 or newer and no third-party packages:
+
+```sh
+python3 -B -S test_count_transfer.py
+python3 -B -O -S test_count_transfer.py
+python3 -B -S test_count_transfer.py --mutant M1
+python3 -B -S test_count_transfer.py --mutant M2
+python3 -B -S test_count_transfer.py --mutant M3
+python3 -B -S test_count_transfer.py --mutant M4
+```
+
+Baseline contract: 13 methods, exit0, JSON ok=true, empty failures/errors; stdout
+must agree between normal and optimized modes. Each named mutant must exit1 with
+one or more intended assertion failures and an empty errors array. M1 drops the
+common radial factor; M2 removes Holder's exponent loss; M3 reverses the unequal
+weights; M4 omits the constant in the factorial envelope. Repeat in optimized mode.
+An unknown label must exit2. A crash, missing dependency, syntax error, or unrelated
+failure is not evidence that a mathematical mutant was correctly rejected.
+
+At publication, the author's execution tools fail before starting a command, so
+these are **instructions and unexecuted author test source**, not a claim of local
+passes. Read later PR receipts for actual execution and reviewer provenance.
+The existing general CI does not automatically discover this standalone suite.
+
+## Offline preservation and handoff
+
+Save the four packet files plus the three source files at the full source-cut
+commit in SOURCES.json. Preserve relative paths in a new directory, record Git
+blobs and SHA-256 locally, and retain test stdout, stderr, exit codes and the actual
+Python version outside the frozen packet. A source checkout is not a claim of
+installed Lean, model weights, full Git history or laptop readiness. Do not modify
+the already sealed R5 offline kit or overwrite any laptop worktree.
+
+For a bounded review, read PROOF sections2–5 against the consumed source interfaces,
+try the N=1 and remote-only countercases, and inspect the all-threshold rare-spike
+models. Report exact source identity, actual executions, PASS_SCOPED or actionable
+AMEND and residual scope. Required integration checks and separate eligible merge
+execution remain necessary after review. General IBA2-012 and IBA2-009 remain open.
diff --git a/reviews/iba2_012_count_transfer_20261006/SOURCES.json b/reviews/iba2_012_count_transfer_20261006/SOURCES.json
new file mode 100644
index 000000000..983a08350
--- /dev/null
+++ b/reviews/iba2_012_count_transfer_20261006/SOURCES.json
@@ -0,0 +1,51 @@
+{
+  "object": "IBA2-012-COUNT-TRANSFER-20261006-v1",
+  "repository": "d6g8k5htny-coder/Math-",
+  "source_cut": "99ba2dfe33ef0052694510355b0c4d811fd66441",
+  "author": "OpenAI / GPT-6 Astra Pro / iba2-count-weight-transfer-r6-20261006",
+  "principal": "Dylan Roy — delegated AI work",
+  "scientific_effect": "NONE",
+  "organizational_independence_credit": 0,
+  "status_at_publication": "AUTHOR_SIDE_CONDITIONAL_PROOF_CANDIDATE",
+  "inputs": [
+    {
+      "tag": "FR",
+      "path": "reviews/iba2_012_finite_radius_20261005/PROOF.md",
+      "git_blob": "5ed684c9bb446efc9bef5f3980717c6dc039abfd",
+      "consumed_sections": "3–5 and 8; finite-r same-law derivative-weighted event estimates",
+      "scope": "fixed d>=3,L,R; compact birth and strictly positive compact gap marks; original full normalizer"
+    },
+    {
+      "tag": "CP",
+      "path": "frontiers/c6_palm_route_20260929/PROOF.md",
+      "git_blob": "89eb8adf08fe7afc2cab9662d3a9875c05ae5cc5",
+      "consumed_sections": "1.1–1.3; Theorem Q(1.1) and all inherited dependency qualifications",
+      "scope": "same tilted law and torus-wide between-pin count; each fixed factorial order m>=2; no new ancestor review"
+    },
+    {
+      "tag": "ERR",
+      "path": "reviews/d5_dimension_lift_erratum_20261005/ERRATUM.md",
+      "git_blob": "23df87bbe4ffd3b2d786cd695fb9f5448cfa1d05",
+      "consumed_sections": "entire additive correction; original DL/CP bodies stay unchanged",
+      "scope": "retains the missing Lipschitz factor and both corrected citation locations; no exponent change"
+    }
+  ],
+  "payloads": [
+    {"path": "PROOF.md", "git_blob": "3630e479461b7edf0c698484c58469aab04b34ac"},
+    {"path": "test_count_transfer.py", "git_blob": "629ba742ee777e7da992cf0a975cb7384ad1763f"}
+  ],
+  "identity_note": "Payload identities were returned by native Git create_blob; no local SHA-256 or execution is asserted. README and this source inventory are contextual files, not self-hashed payloads. The exact branch commit/tree binds all four files.",
+  "local_execution_at_publication": {
+    "ran": false,
+    "reason": "Container and Python tools returned InvalidArgumentError before any command executed."
+  },
+  "reviews_and_execution": "Read later exact-head PR receipts; original author-side labels are historical, not a second status register.",
+  "nonclaims": [
+    "No full IBA2-012 or IBA2-009 closure",
+    "No exponent-loss-free count transfer from unconditional moment bounds",
+    "No local nonempty or size-biased lower normalizer is assumed",
+    "No remote-only sector estimate, growing radius or all-mark extension",
+    "No field realization of the abstract countermodels",
+    "No new formal target or scientific acceptance"
+  ]
+}
diff --git a/reviews/iba2_012_count_transfer_20261006/test_count_transfer.py b/reviews/iba2_012_count_transfer_20261006/test_count_transfer.py
new file mode 100644
index 000000000..629ba742e
--- /dev/null
+++ b/reviews/iba2_012_count_transfer_20261006/test_count_transfer.py
@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Exact finite controls for the conditional IBA2 count-transfer note.
+
+No network, third-party packages, field simulation or Lean execution.
+Exit 0: every finite control passes. Exit 1: assertion rejection only.
+Exit 2: invalid arguments or an unexpected test error, not a math rejection.
+"""
+from __future__ import annotations
+
+import argparse
+from fractions import Fraction as F
+from itertools import permutations
+import json
+from math import factorial
+import sys
+import unittest
+
+MUTANT = None
+
+
+def falling(n: int, m: int) -> int:
+    if n < m:
+        return 0
+    value = 1
+    for i in range(m):
+        value *= n - i
+    return value
+
+
+def beta(q: int) -> int:
+    return sum(j + 2 for j in range(2, q + 2))
+
+
+def theta(p: F, order: int) -> F:
+    p = F(p)
+    if p < 0 or order < 2 or order <= p:
+        raise ValueError("need p >= 0 and integer order >= 2, order > p")
+    return F(1) if MUTANT == "M2" else 1 - p / order
+
+
+def common_radial_power(p: F, order: int) -> F:
+    return F(3) * theta(p, order) if MUTANT == "M1" else F(3)
+
+
+def mixed_power(alphas: tuple[F, ...]) -> F:
+    weights = list(range(4, 4 + len(alphas)))
+    if MUTANT == "M3":
+        weights.reverse()
+    return sum((w * min(F(a), F(1)) for w, a in zip(weights, alphas)), F(0))
+
+
+def envelope(n: int, order: int) -> int:
+    return order ** order * (falling(n, order) + (0 if MUTANT == "M4" else 1))
+
+
+def spike(n: int, q: int = 1) -> tuple[F, F, F, int]:
+    r = F(1, 2 ** n)
+    ordinary = r ** 3
+    rare = r ** (3 + beta(q))
+    return r, ordinary, rare, n + 2
+
+
+class CountTransferTests(unittest.TestCase):
+    def test_beta(self):
+        self.assertEqual([beta(q) for q in range(1, 5)], [4, 9, 15, 22])
+        for q in range(1, 12):
+            self.assertEqual(beta(q), q * (q + 7) // 2)
+
+    def test_factorial_envelope(self):
+        for order in range(2, 9):
+            for n in range(0, 41):
+                with self.subTest(order=order, n=n):
+                    self.assertLessEqual(n ** order, envelope(n, order))
+
+    def test_holder_exponents(self):
+        for order in range(2, 9):
+            for p in range(1, order):
+                self.assertEqual(theta(F(p), order), F(order - p, order))
+                self.assertEqual(F(p, order) + theta(F(p), order), 1)
+        self.assertEqual(theta(F(3, 2), 4), F(5, 8))
+        for p, order in [(2, 2), (3, 2), (-1, 2), (0, 1)]:
+            with self.assertRaises(ValueError):
+                theta(F(p), order)
+
+    def test_radial_power(self):
+        for order in range(2, 9):
+            for p in range(1, order):
+                self.assertEqual(common_radial_power(F(p), order), 3)
+                self.assertEqual(3 * F(p, order) + 3 * F(order - p, order), 3)
+
+    def test_weighted_holder_finite_laws(self):
+        laws = [
+            [(F(1, 2), 0, 1), (F(1, 8), 1, 2), (F(1, 8), 2, 3),
+             (F(1, 8), 3, 5), (F(1, 8), 7, 7)],
+            [(F(1, 3), 1, 9), (F(1, 3), 4, 2), (F(1, 3), 9, 1)],
+        ]
+        for law in laws:
+            for cutoff in [1, 2, 5]:
+                selected = [(w, n, k) for w, n, k in law if n >= cutoff]
+                for order in range(2, 7):
+                    for p in range(1, order):
+                        lhs = sum((w * k ** (order-p) * n ** p for w,n,k in selected), F(0))
+                        moment = sum((w * n ** order for w,n,k in selected), F(0))
+                        weighted = sum((w * k ** order for w,n,k in selected), F(0))
+                        self.assertLessEqual(lhs ** order, moment ** p * weighted ** (order-p))
+
+    def test_event_restricted_moment(self):
+        # A large count outside E does not justify removing the event from K.
+        law = [(F(1, 2), 0, False), (F(1, 4), 1, True),
+               (F(1, 8), 5, True), (F(1, 8), 19, False)]
+        pe = sum((w for w,n,e in law if e), F(0))
+        for order in range(2, 8):
+            lhs = sum((w * n ** order for w,n,e in law if e), F(0))
+            fm = sum((w * falling(n, order) for w,n,e in law), F(0))
+            self.assertLessEqual(lhs, order ** order * (pe + fm))
+
+    def test_mixed_diagonal(self):
+        b = mixed_power((F(1, 2), F(1, 4)))
+        self.assertEqual(b, F(13, 4))
+        self.assertEqual(common_radial_power(F(1), 2) + b * theta(F(1), 2), F(37, 8))
+        self.assertEqual(common_radial_power(F(2), 4) + 4 * theta(F(2), 4), 5)
+
+    def test_saturation(self):
+        self.assertEqual(mixed_power((F(2), F(1))), 9)
+        self.assertEqual(mixed_power((F(1),)), 4)
+        self.assertEqual(mixed_power((F(1, 2),)), 2)
+        for n in range(1, 15):
+            r = F(1, 2 ** n)
+            self.assertLessEqual(r ** 2 + r, 2*r)
+            self.assertGreaterEqual(r ** 2 + r, r)
+
+    def test_spike_event_thresholds(self):
+        for q in range(1, 5):
+            for n in range(1, 13):
+                r, ordinary, rare, count = spike(n, q)
+                self.assertLess(ordinary + rare, 1)
+                for eta in [F(0), r/2, r, min(2*r, F(1)), F(1)]:
+                    mass = rare if eta >= r else F(0)
+                    self.assertLessEqual(mass, r ** 3 * (eta+r) ** beta(q))
+
+    def test_spike_fixed_moments(self):
+        for order in range(2, 9):
+            bound = 2 ** order + 6 ** order * factorial(order)
+            for n in range(1, 65):
+                r, ordinary, rare, count = spike(n)
+                moment = ordinary * 2 ** order + rare * count ** order
+                fm = ordinary * falling(2, order) + rare * falling(count, order)
+                self.assertLessEqual(fm, moment)
+                self.assertLessEqual(moment, bound * r ** 3)
+                self.assertGreaterEqual(ordinary + rare, r ** 3)
+
+    def test_lossfree_obstruction(self):
+        for p in [1, 2, 3]:
+            ratios = []
+            for n in [2, 8, 32, 128]:
+                r, ordinary, rare, count = spike(n)
+                value = rare * count ** p / (r ** 3 * (2*r) ** 4)
+                self.assertEqual(value, F((n+2) ** p, 16))
+                ratios.append(value)
+            self.assertEqual(ratios, sorted(ratios))
+            self.assertGreater(ratios[-1], 1)
+        # Finite checks only; divergence follows from (n+2)^p/16 -> infinity.
+
+    def test_remote_only_exclusion(self):
+        global_count, local_count, soft = 7, 0, True
+        event = local_count > 0 and soft
+        self.assertFalse(event)
+        self.assertEqual(local_count ** 2 * int(soft), 0)
+        self.assertGreater(global_count ** 2 * int(soft), 0)
+        self.assertEqual(global_count ** 2 * int(event), 0)
+
+    def test_factorial_intensity_mass(self):
+        for n in range(0, 7):
+            for degree in range(1, 5):
+                ordered_tuples = sum(1 for _ in permutations(range(n), degree))
+                self.assertEqual(ordered_tuples, falling(n, degree))
+                self.assertLessEqual(falling(n, degree), n ** degree)
+
+
+def main() -> int:
+    global MUTANT
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mutant", choices=["M1", "M2", "M3", "M4"])
+    args = parser.parse_args()
+    MUTANT = args.mutant
+    suite = unittest.defaultTestLoader.loadTestsFromTestCase(CountTransferTests)
+    result = unittest.TextTestRunner(stream=sys.stderr, verbosity=2).run(suite)
+    report = {"ok": result.wasSuccessful(), "tests": result.testsRun,
+              "mutant": MUTANT,
+              "failures": [str(t) for t, _ in result.failures],
+              "errors": [str(t) for t, _ in result.errors],
+              "scope": "finite arithmetic only; no continuum or kernel verdict"}
+    print(json.dumps(report, sort_keys=True, separators=(",", ":")))
+    return 2 if result.errors else (0 if result.wasSuccessful() else 1)
+
+
+if __name__ == "__main__":
+    sys.exit(main())