diff --git a/.github/workflows/elder-lower-review.yml b/.github/workflows/elder-lower-review.yml new file mode 100644 index 000000000..dbbddd04c --- /dev/null +++ b/.github/workflows/elder-lower-review.yml @@ -0,0 +1,60 @@ +name: D1 elder lower-bound nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/d1_elder_lower_claude_20260928/**' + - '.github/workflows/elder-lower-review.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-probe: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify sources, replay both modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('reviews/d1_elder_lower_claude_20260928').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['files'] + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']) + if present != expected_names: + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + script = str(root / 'elder_lower_exact_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['drop-aZ-over-8', 'hessian-sign', 'path-endpoint', + 'weight-power', 'tv-half'] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], + check=True, capture_output=True, timeout=300).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + for m in mutants: + rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], + capture_output=True, timeout=300).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False})) + PY + git diff --exit-code diff --git a/.github/workflows/p15-bipartite-overlap.yml b/.github/workflows/p15-bipartite-overlap.yml new file mode 100644 index 000000000..57266f07a --- /dev/null +++ b/.github/workflows/p15-bipartite-overlap.yml @@ -0,0 +1,30 @@ +name: P15 overlapping-block exact controls + +'on': + pull_request: + paths: + - 'frontiers/p15_bipartite_overlap_20260928/**' + - '.github/workflows/p15-bipartite-overlap.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-overlap: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify exact sources and both-mode semantic controls + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S frontiers/p15_bipartite_overlap_20260928/run_validation.py + git diff --exit-code diff --git a/.github/workflows/p15-overlap-tail-review.yml b/.github/workflows/p15-overlap-tail-review.yml new file mode 100644 index 000000000..c7d35ac14 --- /dev/null +++ b/.github/workflows/p15-overlap-tail-review.yml @@ -0,0 +1,60 @@ +name: P15 overlap and tail nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/p15_overlap_tail_claude_20260928/**' + - '.github/workflows/p15-overlap-tail-review.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-probe: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify sources, replay both modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('reviews/p15_overlap_tail_claude_20260928').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['files'] + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']) + if present != expected_names: + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + script = str(root / 'p15_exact_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['odd-nonbipartite', 'charge-inactive', 'q-one', 'max-load', + 'interval-swap', 'tail-a3', 'drop-superset-cover'] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], + check=True, capture_output=True, timeout=300).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + for m in mutants: + rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], + capture_output=True, timeout=300).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False})) + PY + git diff --exit-code diff --git a/.github/workflows/p15-tail-load.yml b/.github/workflows/p15-tail-load.yml new file mode 100644 index 000000000..e55e456da --- /dev/null +++ b/.github/workflows/p15-tail-load.yml @@ -0,0 +1,33 @@ +name: P15 tail and weighted-load exact controls + +'on': + pull_request: + paths: + - 'frontiers/p15_tail_load_20260928/**' + - '.github/workflows/p15-tail-load.yml' + push: + branches: [main] + paths: + - 'frontiers/p15_tail_load_20260928/**' + - '.github/workflows/p15-tail-load.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + finite-tail-load: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Exact sources, both Python modes and seven semantic mutants + run: | + set -euo pipefail + python -B -S frontiers/p15_tail_load_20260928/verify.py --output "${RUNNER_TEMP}/tail-load-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" + git diff --exit-code diff --git a/.github/workflows/remote-height-decoupling.yml b/.github/workflows/remote-height-decoupling.yml new file mode 100644 index 000000000..52ab5b906 --- /dev/null +++ b/.github/workflows/remote-height-decoupling.yml @@ -0,0 +1,30 @@ +name: Remote within-window height-decoupling controls + +'on': + pull_request: + paths: + - 'frontiers/remote_height_decoupling_20260928/**' + - '.github/workflows/remote-height-decoupling.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-height: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify exact sources and both-mode semantic controls + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S frontiers/remote_height_decoupling_20260928/verify.py + git diff --exit-code diff --git a/.github/workflows/remote-height-review.yml b/.github/workflows/remote-height-review.yml new file mode 100644 index 000000000..d527d5efa --- /dev/null +++ b/.github/workflows/remote-height-review.yml @@ -0,0 +1,60 @@ +name: Remote height-decoupling nonauthor review checks + +'on': + pull_request: + paths: + - 'reviews/remote_height_claude_20260928/**' + - '.github/workflows/remote-height-review.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-probe: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify sources, replay both modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('reviews/remote_height_claude_20260928').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['files'] + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']) + if present != expected_names: + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + script = str(root / 'height_exact_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['no-endpoint-pins', 'gradient-target', 'unscaled-beta', 'indicator-only', + 'lip-constant', 'eps-over-2m', 'a-as-probability', 'p2-r6', 'var-l'] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], + check=True, capture_output=True, timeout=300).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + for m in mutants: + rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], + capture_output=True, timeout=300).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False})) + PY + git diff --exit-code diff --git a/docs/integration/2026-09-28-reviewed-mathematics.md b/docs/integration/2026-09-28-reviewed-mathematics.md new file mode 100644 index 000000000..0c7f4a7e6 --- /dev/null +++ b/docs/integration/2026-09-28-reviewed-mathematics.md @@ -0,0 +1,80 @@ +# Reviewed mathematics integration — 28 September 2026 + +Scientific effect: NONE. This is a one-time source/review integration record, +not a replacement for STATUS, PROOF_INDEX, the candidate catalog, or a theorem +promotion register. Existing proof bodies and historical verdicts are unchanged. + +## Complete source imports and their reviews + +The following existing source heads are included unchanged, with their exact +commits retained as integration ancestors: + +| PR | Source head | Scope | +|---|---|---| +| Math-#118 | `23b7558943f69a7f479251566b19ba58e75cfc26` | Bipartite overlapping capacity blocks; alternative even/read-two class; original-coordinate coloring and full-price budgets. | +| Math-#120 | `f3e16585338e4c4dc878df43f9117b1b3ed5a479` | Fixed-remote, same-r height decoupling from the actual finite-r location/index marginal. | +| Math-#122 | `245f3d77c9d38f49d13affb9563a266eba92a47b` | Sharp even reference-tail bound and genuine-cover, original-coordinate weighted-load budget. | +| Math-#123 | `3460de746b9dfb15551ca7674aac28811ee957a5` | Three Anthropic review packets, including the amended P15 and height wording. | + +Read the reviews under `reviews/p15_overlap_tail_claude_20260928/`, +`reviews/remote_height_claude_20260928/`, and +`reviews/d1_elder_lower_claude_20260928/`. They record source-bound, scoped +ACCEPT judgments, not a fabricated native GitHub approval. All models share the +owner's GitHub account. Provider distinction, source exposure and organizational +independence are different things. In particular Claude authored the imported +remote-collision premise and previously reviewed the parent upper theorem. + +Four documentary overclaims were corrected by the review author before this +integration: minimal obstructions are the inclusion-minimal distinct active +blocks; a reference-tail limitation is not a cover-factor impossibility; an +O(r) upper bound is not an optimality result; and three observed ratios do not +prove an asymptotic rate. Original proof bodies, check scripts and verdicts were +not altered by these review-wording corrections. + +## Partial import from Math-#116 — C1/C2 only + +Exactly three pre-existing blobs from source head +`0507e3a1dbd3dede84cbeb805947c70aa16ebc36` are copied verbatim at their original +paths under `frontiers/window_multiplicity_laws_20260928/`: + +| File | Git blob | +|---|---| +| ELDER_LOWER_AND_DENSITY_GAP.md | `aaefc8da9668e819591dd9db0b34442394f2362e` | +| LOCAL_MULTIPLICITY.md | `b5c18aac5529c5f975ee5bb056b304debafc6697` | +| SOURCE_MAP.json | `01f090360e7fd4e836e1a9b6d0433a6a46d8c466` | + +These are the two proof modules covered by the elder/local review in #123 and +the original dependency map. Their exact-source hashes are also recorded in that +review. The whole #116 head is deliberately NOT an integration ancestor. +The remainder of #116 is NOT merged by this operation. + +The selected modules prove a direct planar ordinary-elder failure lower event, +and local multiple-window occurrence, with the stated compact marks and fixed +torus. Their two-sided and lifetime-density consequences retain their separately +named parent upper/weighted-density inputs. Neither a legacy q/p identification, +a numerical lower constant/cutoff, unrestricted-mark statement, nor governing +status transition is inferred here. + +The source directory is intentionally PARTIAL. This integration does not copy +its full-packet README, SOURCE_FILES.json, RESULTS or publication claims. Its +remote pair law, distance-moment law and separate HEIGHT_MARKS module remain +pending outside this import. No acceptance of C3-C6 is inherited from C1/C2. + +The original #116 algebra.py publication was blocked and is not retried or +reconstructed. The public elder reviewer program is a separately authored +finite check, not recovery or execution of that unavailable author program. +The original SOURCE_MAP's historical replay wording must not be read as a claim +that the absent original suite executed from this partial directory. + +## Execution and integration boundaries + +The existing public author and reviewer workflows are retained unchanged. +They check their own exact file memberships and finite outputs; a combined-head +run is required before merge. The existing downstream and pinned Lean aggregate +must also actually pass for the current tested integration. A workflow definition +or an older passing head is not that execution evidence. + +Actual run IDs, source comparisons and merge readback belong in the integration +PR discussion and main#95. Local versus hosted execution must be distinguished. +The existing Lean scalar package does not formalize these entire new Gaussian +or combinatorial proofs. Nothing here changes required checks or bypasses them. diff --git a/frontiers/p15_bipartite_overlap_20260928/EVEN_CAPACITY_EXTENSION.md b/frontiers/p15_bipartite_overlap_20260928/EVEN_CAPACITY_EXTENSION.md new file mode 100644 index 000000000..ce21e4244 --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/EVEN_CAPACITY_EXTENSION.md @@ -0,0 +1,150 @@ +# Even capacities: read-two overlap without bipartiteness + +Object: OA-P15-EVEN-READ-TWO-20260928-v1. +Author: OpenAI / ChatGPT, 28 September 2026. +Disposition: AUTHOR-SIDE CANDIDATE; independent analytic review required. +Scientific effect NONE. This is an explicit alternative to the bipartite +hypothesis of PROOF.md, not permission to omit that hypothesis for odd capacities. + +## E1. Exact coloring under the alternative structural hypothesis + +Keep the finite original ground set X, covering blocks X_i and capacity downset +D of (O1), but replace bipartiteness by: + + every original coordinate belongs to at most two blocks; + every capacity a_i is a POSITIVE EVEN integer. (E1) + +**Theorem E1.** For all U subset X, + + chi_D(U)=max_i ceil(|U intersect X_i|/a_i). (E2) + +*Proof.* Necessity is unchanged. Write k for the right side and assume U is +nonempty. Represent coordinates by edges of the possibly NONBIPARTITE block +incidence multigraph: a shared coordinate joins its two distinct block vertices; +a private coordinate joins its block to a private auxiliary vertex. + +At each real vertex i, split incident edges as evenly as possible among a_i/2 +auxiliary vertices. Each new vertex has degree at most +ceil(2|U intersect X_i|/a_i)<=2k. Private auxiliary vertices have degree one. +Each original edge keeps its one original-coordinate label. + +The number of odd-degree vertices is even. Pair them arbitrarily and add one +auxiliary edge per pair. Every odd degree was at most 2k-1, so every augmented +degree is even and at most 2k. Each component has an Euler orientation, with +indegree=outdegree=degree/2<=k at every vertex. Form the bipartite directed +incidence graph with one outgoing and one incoming copy of each vertex; an +oriented edge becomes one edge from its tail's outgoing copy to its head's +incoming copy. Maximum degree is at most k. The matching decomposition in the +proof of (O2) colors this bipartite graph with at most k colors. + +In the undirected split graph, a color has at most one outgoing and one incoming +edge at each split vertex, thus at most two incident edges. Remove the auxiliary +edges and combine the a_i/2 split vertices back into block i: at most a_i +original coordinates of each color lie in X_i. This is a coloring of ORIGINAL +coordinates, not independent copies of them. It proves (E2). QED. + +For |X_i|=a_i d_i+1, K=max_i d_i, the exact active-full-block obstruction (O4) +and chi_D(X)=K+1 follow from (E2) by the same elementary argument. This holds +even on an odd cycle of blocks. It does not extend to the odd-capacity triangle +counterexample of PROOF.md, where capacities are one. + +## E2. A self-contained read-q hazard inequality + +The two-sided Cauchy-Schwarz proof of (O9) used a bipartition. It cannot be +reused unchanged for an odd cycle. We prove the necessary replacement rather +than assuming independence of the overlapping events. + +**Lemma E2.** Let mu be a finite product probability measure. Let A_i be events +depending on coordinate sets S_i, each coordinate lying in at most q of those +sets. If D is contained in every A_i, then + + sum_i [-log mu(A_i)] <= q[-log mu(D)]. (E3) + +The inequality uses extended hazards; mu(D)=0 is immediate. + +*Proof for mu(D)>0.* Set nu=mu(.|D). Denote relative entropy by +D_KL(nu||mu), with the usual zero-mass conventions. Then +D_KL(nu||mu)=-log mu(D). Each marginal nu_{S_i} is supported on A_i, whence + + D_KL(nu_{S_i}||mu_{S_i}) + = D_KL(nu_{S_i}||mu_{S_i}(.|A_i)) - log mu(A_i) + >= -log mu(A_i). (E4) + +Order all coordinates. The chain rule and product form of mu give + + D_KL(nu_S||mu_S) + = sum_{v in S} E_nu D_KL(nu(v | earlier coordinates in S)||mu_v). + +Conditioning on only the earlier coordinates in S gives a mixture of the laws +conditioned on all earlier coordinates. Convexity of relative entropy in its +first argument (the finite log-sum inequality) therefore bounds each summand by + + c_v := E_nu D_KL(nu(v | all earlier coordinates)||mu_v) >= 0. + +Thus D_KL(nu_S||mu_S)<=sum_{v in S} c_v. Summing over S_i and using read-q +incidence gives + + sum_i D_KL(nu_{S_i}||mu_{S_i}) <= q sum_v c_v + = q D_KL(nu||mu). + +Combine with (E4). Deterministic coordinates (probability zero or one) have zero +conditional divergence and can also be removed from the finite product support. +No absolute-continuity problem arises because nu is a conditioning of mu. QED. + +This is the entropy form of a classical read-q/Finner-type inequality. Its proof +is included; no result about arbitrary dependent measures is asserted. It +applies to just the active blocks in (O4), as required for charging generators. + +## E3. Full transformed prices and a sub-2/3 factor + +Assume additionally |X_i|=a_i d_i+1, with d_i positive integers and K=max_i d_i>=4. +For an active block a_i is even, hence a_i>=2. The Chernoff calculation in Lemma +O3 gives its reference probability at p_*=1-exp(-1) at most 25/512, uniformly +in ALL such capacities. Hence its reference hazard is at least + + h_even=log(512/25)>3. (E5) + +The last inequality has a short rational certificate: + + e < 87/32, + 512/25 - (87/32)^3 = 314641/819200 > 0. + +The separate-concavity transfer (O5) yields price(X_i)<=h_i/h_even. Lemma E2 with +q=2 yields sum_active h_i<=2[-log mu_p(D)]. Since the active full-block cover is +proved by Theorem E1, summing and applying the price-one empty-generator cap gives + + covercost_c(O_K(D)) + <= min(1, [2/log(512/25)] [-log mu_p(D)]) + <= min(1, (2/3)[-log mu_p(D)]). (E6) + +Here 2/log(512/25)<2/3; neither factor is claimed optimal. Probabilities are the +original independent Bernoulli probabilities in [0,1], and all prices +0<=c_v<=min(1,-log(1-p_v)) are admitted. The zero/infinite-hazard cases are handled +as in PROOF.md. The global palette remains K, not 2K. + +This supplies a second justified structural class: arbitrary read-two block +incidence with EVEN capacities. The first class permits arbitrary positive +capacities but requires bipartiteness. Their hypotheses should not be mixed or +silently dropped. Inactive smaller demands, including demand one, are harmless +to the generator budget in both classes, but (E1) still requires their capacities +to be even for the displayed coloring proof. + +## E4. Verification and literature boundary + +The standard-library implementation follows the displayed construction: +capacity-two splitting, pairing odd vertices, Euler orientation, a bipartite +matching coloring, and one final color per original coordinate. It is checked +against an independent partition oracle on small nonbipartite examples with +heterogeneous even capacities. A triangle with four shared edges per side and +one private coordinate per block has K=4: the twelve shared coordinates are +4-colorable, while the full fifteen-coordinate set needs five colors. + +The read-two hazard inequality is tested on exact heterogeneous Bernoulli grids +on triangle incidence. Finite grids do not prove (E3); its entropy argument does. + +Aboulker-Aubian-Huang, arXiv:2201.11548, studies defective edge coloring and states +the uniform even-capacity phenomenon. This note does not claim invention of that +classical structural mechanism. The variable-capacity construction and the +original-coordinate price/cover assembly are written out here; no unpublished +original checker from another packet is used. Independent mathematical review +and any formalization are still separate obligations. diff --git a/frontiers/p15_bipartite_overlap_20260928/PROOF.md b/frontiers/p15_bipartite_overlap_20260928/PROOF.md new file mode 100644 index 000000000..8ad826ecb --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/PROOF.md @@ -0,0 +1,291 @@ +# P15: overlapping original-coordinate blocks with an exact palette and a sub-3/4 budget + +Object: OA-P15-BIPARTITE-OVERLAP-20260928-v1. +Author: OpenAI / ChatGPT, foreground continuation, 28 September 2026. +Disposition: AUTHOR-SIDE MATHEMATICAL CANDIDATE; NONAUTHOR REVIEW REQUIRED. +Scientific effect: NONE. No existing theorem body, verdict, graph or prize is modified. + +## 1. What changes, and what does not + +The existing `frontiers/full_price_20260924/PROOF.md` treats disjoint capacity +blocks, with an additional macro-clutter. Its full transformed-price theorem +uses independence of local restrictions on disjoint coordinate sets. That +independence is generally false once original coordinates are shared. + +This note proves a different structural extension: capacity blocks MAY OVERLAP, +provided their intersection graph is bipartite. We drop the additional +macro-clutter restriction. The new conclusion is therefore not a blanket +extension of every earlier realized family, nor an arbitrary-downset result. +Both its coloring assertion and its probability budget are proved below on the +actual original coordinates; it does not simply invoke P15-B with unverified +local covers. Auxiliary graph vertices do not duplicate random coordinates. + +Let X be a finite ground set, covered by nonempty blocks X_i (i in I). Fix positive +integer capacities a_i. Assume a partition I=L disjoint-union R such that +blocks on the SAME side are pairwise disjoint. Equivalently the graph joining +intersecting blocks is bipartite. A coordinate belongs to at most one block on +each side and thus to at most two blocks overall. Repeated equal blocks on +opposite sides cause no difficulty. + +Define the decreasing family + + D = {U subset X : |U intersect X_i| <= a_i for every i}. (O1) + +Let chi_D(U) be the least number of sets in D whose disjoint union is U, with +chi_D(empty)=0. Let O_k(D)={U:chi_D(U)>k}. A generator cover G means that every +U in O_k(D) contains some g in G; generators need not themselves be minimal. +Its price is sum_{g in G} product_{v in g} c_v. The empty generator costs one; +the empty FAMILY costs zero. Repeated generators are counted only once. + +## 2. Exact original-coordinate coloring + +**Theorem O1.** For every U subset X, + + chi_D(U) = max_i ceil(|U intersect X_i|/a_i). (O2) + +In particular the lower bounds from individual capacities are simultaneously +attainable despite overlaps. + +*Proof.* Write k for the right side. The lower bound follows because a union of +k members of D contains at most k a_i coordinates in each block. The empty U +case is immediate. Otherwise k>=1. + +Construct a bipartite multigraph whose original edges correspond ONE-TO-ONE to +coordinates of U. A coordinate in both X_l and X_r is an edge between l and r. +A coordinate in only one block is joined to its own auxiliary degree-one +vertex on the other side. Because X covers the ground set, no coordinate lacks +an endpoint. Parallel edges are retained with their distinct coordinate labels. + +At each real vertex i, split its incident edges among a_i auxiliary vertices, +with loads differing by at most one. Every such vertex has degree at most +ceil(|U intersect X_i|/a_i)<=k. An original edge retains both its assigned +endpoints and its SINGLE original label. Private auxiliary vertices have +degree one. + +For completeness, a bipartite multigraph of maximum degree at most k has a +proper edge coloring with at most k colors. Add isolated vertices to make its +two sides have the same size N. Their total degree deficits from k are equal, +namely kN minus the current edge count. Add auxiliary edges between vertices +with positive deficits until every vertex has degree k. Parallel auxiliary +edges are allowed. For S on the left, its k|S| incident edges end in N(S), whose +total degree is k|N(S)|, so |N(S)|>=|S|. Hall's condition gives a perfect +matching. Remove one perfect matching and repeat in the remaining regular +bipartite multigraph, using one new color each time. Discard all auxiliary +edges. This proves the asserted edge-coloring fact. + +Return each original coordinate to the color of its edge. At most one edge of +a given color uses any split vertex, so at most a_i coordinates of that color +lie in X_i. Each color class belongs to D. This proves (O2). The construction +uses independent Bernoulli variables only later: graph splitting has not +altered the ground set or introduced probabilistic independence. QED. + +## 3. The same palette and the exact obstruction + +Now assume + + |X_i| = a_i d_i+1, d_i positive integers, + K = max_i d_i >= 4. (O3) + +Only the maximal demand K must be at least four. Lower-demand blocks, including +demand one, are allowed. Set I_*={i:d_i=K} and let G_* be the distinct full +blocks X_i for i in I_*. + +**Corollary O2.** At the SAME palette K, + + O_K(D) = union_{i in I_*} {U subset X : X_i subset U}. (O4) + +Thus G_* is a genuine cover; its inclusion-minimal distinct members are exactly +the minimal K-obstructions. The whole ground set has chi_D(X)=K+1, so the +obstruction is nonempty. If k>K then O_k(D) is empty. + +*Proof.* By (O2), a K-obstruction must have |U intersect X_i|>Ka_i for some i. +If d_i0. + +The probability stays positive on this cube. With other coordinates fixed, +mu(A)=A_0+B_0 exp(-t_j), where A_0>=0 and B_0>=0 by decreasingness. Consequently + + partial_j^2 F = -A_0 B_0 exp(-t_j)/(A_0+B_0 exp(-t_j))^2 <= 0. + +Only separate, not joint, concavity is needed. Since F>=0, its chord bound +implies F(t)>=t_j F(t with t_j=1). Iterate over all coordinates: + + F(t) >= H_A product_j t_j. + +For arbitrary p_j, take t_j=phi(p_j) and p'_j=1-exp(-t_j)<=p_j. Monotonicity of +a decreasing event gives mu_p(A)<=mu_{p'}(A). Thus, as an extended inequality, + + product_j c_j <= [-log mu_p(A)]/H_A. (O5) + +No division by a zero coordinate probability is made. If mu_p(A)=0, its +hazard is infinite; if some c_j=0, the generator remains in the setwise cover. + +For A_i={|U intersect X_i|<=a_i}, let h_i=-log mu_p(A_i) and + + H_i=-log P(Bin(|X_i|,p_*)<=a_i), p_*=1-exp(-1). + +Equation (O5) gives price(X_i)<=h_i/H_i. We need this only for i in I_*. + +## 5. A uniform reference hazard for the active blocks + +Define + + q_5=P(Bin(5,p_*)<=1)=(5e-4)e^(-5), + h_5=-log q_5=5-log(5e-4), rho_bip=2/h_5. (O6) + +**Lemma O3.** If a>=1 and n>=4a+1, then + + P(Bin(n,p_*)<=a) <= q_5, hence H_(n,a)>=h_5. (O7) + +*Proof.* For a=1 this is monotonicity in n and the exact n=5 formula. For a>=2, +put s=E[5^(-Bernoulli(p_*))]=(e+4)/(5e). Since e>8/3, s<1/2. Markov's +inequality, applied in its valid direction to 5^(-Bin(n,p_*)), gives + + P(Bin(n,p_*)<=a) <= 5^a s^n + <= 5^a s^(4a+1) < (1/2)(5/16)^a <= 25/512. + +This is a bound uniform over ALL a>=2, not a finite-grid inference. The +inequalities 8/3 (28/3)(4/11)^5 > 25/512, + +where the difference in the final comparison is the positive rational +2601239/247374336. This proves (O7). QED. + +Every active block has n=a_i K+1>=4a_i+1, so H_i>=h_5. No estimate on the +reference hazard of inactive blocks is required. + +## 6. Replace false independence by two-sided Cauchy-Schwarz + +Let A_L=intersection_{i in I_* intersect L} A_i, and define A_R analogously. +Blocks within either side are disjoint original coordinate sets. Therefore + + mu_p(A_L)=product_{i in I_* intersect L} mu_p(A_i), + mu_p(A_R)=product_{i in I_* intersect R} mu_p(A_i). + +There is in general NO independence between A_L and A_R. Instead, + + mu_p(D) <= mu_p(A_L intersect A_R) + <= [mu_p(A_L) mu_p(A_R)]^(1/2), (O8) + +by Cauchy-Schwarz for the two indicators. Taking logarithms when probabilities +are positive, and treating zero cases by extended hazards, gives + + sum_{i in I_*} h_i <= 2[-log mu_p(D)]. (O9) + +Empty side intersections have probability one. Combining (O5), (O7), (O9), +and the possible removal of duplicate full-block generators proves + + price_c(G_*) <= sum_{i in I_*} h_i/h_5 + <= rho_bip[-log mu_p(D)]. (O10) + +**Theorem O4 (full-price overlapping-block budget).** Under (O1)-(O3), for every +independent probability vector and every transformed price vector, + + covercost_c(O_K(D)) <= min(1, rho_bip[-log mu_p(D)]), + rho_bip = 2/[5-log(5e-4)] < 3/4. (O11) + +If the uncapped bound is at least one, use the empty generator; otherwise use +G_*. If mu_p(D)=0 the empty generator deals with the infinite hazard. All-zero +prices or probability-one good events create no undefined operation. The +palette is K=max_i d_i, not a sum of palettes or a twofold inflation. + +This is an upper bound, NOT a claim that rho_bip is optimal. Setwise coloring +(O2) is exact; budget-factor sharpness is a different question. + +## 7. Short exact certificate and numerical enclosure + +The positive exponential series through degree six, with a geometric tail, +gives + + 8/3 < 1957/720 < e < 31967/11760 < 87/32 < 11/4. + +Thus 5e-4<307/32. The positive Taylor polynomial for exp(7/3) through degree six +satisfies + + sum_{j=0}^6 (7/3)^j/j! - 307/32 = 129055/209952 > 0. + +It follows that log(5e-4)<7/3, h_5>8/3, and rho_bip<3/4. This exact rational +certificate is sufficient for (O11); no decimal estimate is needed. + +A separate rational-series calculation gives the outward enclosure + + 0.73015826409534942932 < rho_bip < 0.73015826409534942934. (O12) + +The code encloses e by a positive series and its geometric tail. It encloses +logarithms by binary reduction and the positive atanh series with remainder +2t^(2m+1)/((2m+1)(1-t^2)), t=(x-1)/(x+1). Monotonic interval operations yield +(O12). Floating-point arithmetic is not used to choose its endpoints. + +The number is not directly comparable as an improvement on the old sharp +0.84548 factor: the old result allowed maximal demand two and disjoint blocks, +whereas this one uses maximal demand at least four and a different overlap +structure. The substantive advance is handling shared ORIGINAL coordinates. + +## 8. Two false extensions excluded by exact counterexamples + +**Read-two alone does not give the same coloring theorem.** Take nine original +coordinates and blocks + + X_0={0,1,4,5,6}, X_1={0,1,2,3,7}, X_2={2,3,4,5,8}, + a_i=1, d_i=4, K=4. + +Every coordinate belongs to at most two blocks. For U={0,1,2,3,4,5}, no full X_i +is contained in U, but every two distinct coordinates of U share a block. +Equivalently U is the six edges of a triangle with two parallel edges per +side; every matching has size at most one. Thus chi_D(U)=6>4, although the +individual capacity lower bound is four. The full-block family fails to +cover this K-obstruction. The intersection graph is the excluded odd triangle. +This example rules out omitting bipartiteness, not all possible covers on +non-bipartite systems. + +**Overlap invalidates multiplying all local good probabilities.** Take blocks +{0,1} and {1,2}, capacities one, and independent probabilities 1/2. Their good +probabilities are 3/4 each, while the joint good probability is 5/8>9/16. +The invalid disjoint-block inequality fails. The squared Cauchy-Schwarz +inequality (5/8)^2<= (3/4)^2 remains true. + +These are exact finite counterexamples, not asymptotic heuristics. Demand-one +counterexamples to older standalone budgets are also unchanged: allowing an +inactive demand-one block here is not accepting its standalone K=1 budget. + +## 9. Scope, attribution, and verification + +The new proof is self-contained apart from Hall's elementary matching theorem; +the regular bipartite edge-coloring reduction is displayed, not claimed as an +invention. Separate concavity and Cauchy-Schwarz are classical. This note makes +no novelty-priority claim. It closes an author-side overlapping-family route, +not a governing P15 prize, an arbitrary macro-clutter, arbitrary read-two +systems, or an unrestricted downset statement. + +`test_overlap.py` checks exact coloring against independent partition dynamic +programming, shared-edge consistency, parallel edges, heterogeneous capacities, +maximal-demand generator selection, all subsets of a nine-coordinate overlap +instance, rational probability grids, exact counterexamples, and rational +series bounds. The runner rejects semantic changes in both ordinary and +optimized Python. Such tests do not prove an analytic inequality for a +continuum of probabilities; Sections 4-7 supply that argument. No independent +review, Lean formalization, or theorem-status promotion is implied. + +Source identities and limited primary-source reconnaissance are in +SOURCE_MAP.json and RECONNAISSANCE.md. The prior interrupted 31/11 collision +test claim is NOT evidence for this distinct suite. All execution counts +reported here are recomputed for this packet. diff --git a/frontiers/p15_bipartite_overlap_20260928/README.md b/frontiers/p15_bipartite_overlap_20260928/README.md new file mode 100644 index 000000000..c832a76ff --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/README.md @@ -0,0 +1,29 @@ +# P15 bipartite-overlap capacity candidate + +Scientific effect NONE. Author-side theorem; nonauthor review required. + +[Full proof](PROOF.md): shared original coordinates, exact capacity coloring, +same global palette K=max d_i>=4, and transformed-price hazard factor +2/[5-log(5e-4)]<3/4. Inactive smaller demands are permitted. No arbitrary +macro-clutter, arbitrary read-two, sharp-factor, or unrestricted P15 claim. + +The triangle counterexample shows why read-two incidence alone is insufficient; +the overlap probability example shows why the old independence step is invalid. + +Run from this directory: + + python -B -S run_validation.py + python -B -O -S run_validation.py + +The self-contained standard-library runner verifies exact source membership, +checks the stored deterministic summary, runs the finite tests in both modes, +and rejects the semantic mutants. It is not a continuum or Lean proof checker. + +[Source map](SOURCE_MAP.json) and [reconnaissance](RECONNAISSANCE.md) distinguish +project inputs, classical facts, and neighboring literature. No blocked source +from the other mathematical packet has been republished or reconstructed here. + +[Even-capacity extension](EVEN_CAPACITY_EXTENSION.md): for arbitrary read-two +block incidence with all capacities even, the same exact palette and cover +formula holds without bipartiteness. A proved entropy hazard inequality gives +the stronger factor 2/log(512/25)<2/3. Neither factor is claimed optimal. diff --git a/frontiers/p15_bipartite_overlap_20260928/RECONNAISSANCE.md b/frontiers/p15_bipartite_overlap_20260928/RECONNAISSANCE.md new file mode 100644 index 000000000..f94388556 --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/RECONNAISSANCE.md @@ -0,0 +1,35 @@ +# Limited primary-source reconnaissance — 28 September 2026 + +Scientific effect NONE; this memo does not establish historical priority. + +The requested Consensus search for bipartite multigraph/capacity/downset work +returned its monthly-limit error (30 searches used, reset October 1). No +Consensus search result is represented as a read paper in this continuation. +The earlier interrupted search records are not treated as fresh verification. + +Primary-source records read through web search: + +1. Benjamin Gunby, Xiaoyu He, Bhargav Narayanan, *Down-set thresholds*, + arXiv:2112.08525; Random Structures & Algorithms 63 (2023), 442-456, + DOI 10.1002/rsa.21148. https://arxiv.org/abs/2112.08525 +2. Lutz Warnke, *Note on down-set thresholds*, arXiv:2310.11662; + Random Structures & Algorithms 64 (2024), 807-813, + DOI 10.1002/rsa.21194. https://arxiv.org/abs/2310.11662 +3. Pierre Aboulker, Guillaume Aubian, Chien-Chung Huang, *Vizing's and Shannon's + Theorems for defective edge colouring*, arXiv:2201.11548. + https://arxiv.org/abs/2201.11548 + +Read scope: abstracts and publisher metadata, not full-text theorem verification. +The first two establish why up-set threshold predictions cannot be transferred +uncritically to arbitrary downsets; neither supplies this generator-price +statement. The third treats defective edge coloring and confirms that bounded +capacity edge partitions are an established graph-theoretic subject. Its +non-bipartite bounds are NOT imported here. The exact bipartite result used by +this packet is proved from vertex splitting, regularization and Hall's theorem +in PROOF.md. No external abstract is used to justify an unproved continuum or +combinatorial step, and no novelty claim is made for this reduction. + +The present contribution is a scoped assembly on overlapping original +coordinates, with exact cover eligibility and a hazard comparison that does not +assume overlapping events are independent. Existing mathematical source and +review records remain unchanged. diff --git a/frontiers/p15_bipartite_overlap_20260928/RESULTS.json b/frontiers/p15_bipartite_overlap_20260928/RESULTS.json new file mode 100644 index 000000000..ef2558d7a --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/RESULTS.json @@ -0,0 +1,15 @@ +{ + "baseline": { + "errors": [], + "failures": [], + "passed": true, + "tests": 29 + }, + "scientific_effect": "NONE", + "scope": "Finite exact controls only; continuum probability inequality is the written proof.", + "rho_bip_outward_lower": "0.73015826409534942932", + "rho_bip_outward_upper": "0.73015826409534942934", + "rational_strict_upper": "3/4", + "nonauthor_acceptance": false, + "even_capacity_rational_upper": "2/3" +} diff --git a/frontiers/p15_bipartite_overlap_20260928/SOURCE_FILES.json b/frontiers/p15_bipartite_overlap_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..2930e7e9b --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/SOURCE_FILES.json @@ -0,0 +1,51 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "files": [ + { + "path": "EVEN_CAPACITY_EXTENSION.md", + "bytes": 7620, + "sha256": "d28aa700ba83ca139b7b29b6ff06cc39c725470b710af10728867ec10c8ca985" + }, + { + "path": "PROOF.md", + "bytes": 13835, + "sha256": "21ce7a29ac0971919c0602f556f1aeba48bb14fffd4193864b3f482185bc1698" + }, + { + "path": "README.md", + "bytes": 1458, + "sha256": "5614ed403d5af1d21b36d78299db2a4cd3f01cc865e4a6a89d91a6cf9bce792f" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 2005, + "sha256": "311cc89850600da11d8391b168cb7d5a29dd98c9cd5fe9a1906701aaa4f47222" + }, + { + "path": "RESULTS.json", + "bytes": 440, + "sha256": "c8db2affadd641db7c64e04b6dc68ff5447230a8d9bd2805c9e300a66a459bee" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 1141, + "sha256": "0c1a2c71c90ec6909acd5023a7977961172fbeb98a9063ada8d7331c69a57b89" + }, + { + "path": "overlap.py", + "bytes": 10684, + "sha256": "7fcc877b683f284d3489b25bdbfa8dfb75ba9deaf94c4ba63e0f8aee4cc7b355" + }, + { + "path": "run_validation.py", + "bytes": 6123, + "sha256": "96f3ae68052a8ea0e8a66a0803084aa264902e514c2ade5fd45ad89f48f5d0c6" + }, + { + "path": "test_overlap.py", + "bytes": 10555, + "sha256": "5f07ea9d1bd25bfe11382a0fe07f8e1e82c4e290dfb8171cb4658c8b77defe0c" + } + ] +} diff --git a/frontiers/p15_bipartite_overlap_20260928/SOURCE_MAP.json b/frontiers/p15_bipartite_overlap_20260928/SOURCE_MAP.json new file mode 100644 index 000000000..3da4b2e01 --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/SOURCE_MAP.json @@ -0,0 +1,28 @@ +{ + "scientific_effect": "NONE", + "source_repository": "d6g8k5htny-coder/Math-", + "source_commit": "5a5b97d2c518dd5c04c89d17029ec96e721d3b78", + "inputs": [ + { + "path": "frontiers/full_price_20260924/PROOF.md", + "git_blob": "582180e41dca0ad815ad0f18574df42040912149", + "use": "Separate-concavity hazard lemma rederived; disjoint-block global step explicitly NOT extended by independence." + }, + { + "path": "frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md", + "git_blob": "173881916ccd0e738bdb41279e835e78e520fcbc", + "use": "Generator-cover terminology and realized capacity family; the new overlap coloring proof is direct, with no imported macro-clutter or assumed local P15-B premise." + } + ], + "external_facts": [ + "Hall matching theorem", + "classical bipartite multigraph edge coloring", + "separate coordinatewise concavity", + "Cauchy-Schwarz", + "Euler orientation of even-degree multigraphs", + "relative entropy chain rule and log-sum inequality" + ], + "governing_status_changed": false, + "nonauthor_acceptance": false, + "blocked_other_packet_republished": false +} diff --git a/frontiers/p15_bipartite_overlap_20260928/overlap.py b/frontiers/p15_bipartite_overlap_20260928/overlap.py new file mode 100644 index 000000000..f2d18543c --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/overlap.py @@ -0,0 +1,263 @@ +"""Finite exact helpers for the bipartite-overlap capacity theorem. + +Standard library only. Original coordinates are graph EDGES, never independent +clones. The analytic probability/hazard theorem is proved in PROOF.md. +""" +from fractions import Fraction +from itertools import product +from math import factorial + +F = Fraction + + +def _validate(blocks, capacities): + if not blocks or len(blocks) != len(capacities): + raise ValueError('nonempty blocks and one capacity per block required') + if any(not b for b in blocks): + raise ValueError('blocks must be nonempty') + if any(type(a) is not int or a < 1 for a in capacities): + raise ValueError('capacities must be positive integers') + + +def capacity_bound(vertices, blocks, capacities): + """Lower bound, exact when the block intersection graph is bipartite.""" + _validate(blocks, capacities) + vertices = set(vertices) + if not vertices <= set().union(*blocks): + raise ValueError('all coordinates must belong to a block') + return max((len(vertices & b) + a - 1) // a for b, a in zip(blocks, capacities)) + + +def color_capacity(vertices, blocks, capacities, sides): + """Construct an optimal coloring of ORIGINAL coordinates under bipartite overlap. + +sides[i] is 0 or 1. Blocks on the same side must be disjoint. Vertex +splitting is an auxiliary incidence-graph construction, not a change to the +probability space. Returns one integer color per original coordinate. + """ + _validate(blocks, capacities) + if len(sides) != len(blocks) or any(s not in (0, 1) for s in sides): + raise ValueError('one bipartition side per block required') + for i, b in enumerate(blocks): + for j in range(i): + if sides[i] == sides[j] and b & blocks[j]: + raise ValueError('same-side blocks intersect') + vertices = set(vertices) + k = capacity_bound(vertices, blocks, capacities) + if not vertices: + return {} + # Incidence slots: each block has a_i auxiliary vertices of degree <= k. + slots = {} + for i, (b, a) in enumerate(zip(blocks, capacities)): + for j, v in enumerate(sorted(b & vertices)): + slots[i, v] = (0, i, j % a) + edges = [] + for v in sorted(vertices): + incidence = [i for i, b in enumerate(blocks) if v in b] + left = next((slots[i, v] for i in incidence if sides[i] == 0), (1, v, 0)) + right = next((slots[i, v] for i in incidence if sides[i] == 1), (1, v, 0)) + edges.append((left, right, v)) + left_nodes = sorted({e[0] for e in edges}) + right_nodes = sorted({e[1] for e in edges}) + n = max(len(left_nodes), len(right_nodes)) + left_nodes += [(2, i, 0) for i in range(n-len(left_nodes))] + right_nodes += [(2, i, 0) for i in range(n-len(right_nodes))] + # Regularize by adding auxiliary edges between deficits; keep original tags. + dl = {v: k for v in left_nodes}; dr = {v: k for v in right_nodes} + for l, r, _ in edges: + dl[l] -= 1; dr[r] -= 1 + if min((*dl.values(), *dr.values())) < 0: + raise RuntimeError('capacity splitting exceeded palette') + for l in left_nodes: + for r in right_nodes: + count = min(dl[l], dr[r]) + edges.extend((l, r, None) for _ in range(count)) + dl[l] -= count; dr[r] -= count + if any(dl.values()) or any(dr.values()): + raise RuntimeError('regularization deficits did not balance') + colors = {} + # A k-regular bipartite multigraph has a perfect matching by Hall; repeat. + for color in range(k): + adjacency = {l: [] for l in left_nodes} + for index, (l, r, _) in enumerate(edges): + adjacency[l].append((r, index)) + match = {} + + def augment(l, seen): + for r, index in adjacency[l]: + if r in seen: + continue + seen.add(r) + if r not in match or augment(match[r][0], seen): + match[r] = (l, index) + return True + return False + + for l in left_nodes: + if not augment(l, set()): + raise RuntimeError('Hall matching failed') + chosen = {index for _, index in match.values()} + for index in chosen: + original = edges[index][2] + if original is not None: + if original in colors: + raise RuntimeError('original coordinate colored twice') + colors[original] = color + edges = [e for index, e in enumerate(edges) if index not in chosen] + if edges or set(colors) != vertices: + raise RuntimeError('incomplete original-coordinate coloring') + return colors + + +def active_generators(blocks, capacities, demands): + """Full blocks at maximal demand; remove duplicates, not zero prices.""" + _validate(blocks, capacities) + if len(demands) != len(blocks) or any(type(d) is not int or d < 1 for d in demands): + raise ValueError('one positive integer demand per block required') + if any(len(b) != a*d+1 for b, a, d in zip(blocks, capacities, demands)): + raise ValueError('block size must be a_i d_i + 1') + k = max(demands) + answer = [] + for b, d in zip(blocks, demands): + if d == k and b not in answer: + answer.append(b) + return answer + + +def good_probability(blocks, capacities, probabilities): + """Exact small-instance Bernoulli enumeration, NOT a large-instance algorithm.""" + _validate(blocks, capacities) + vertices = sorted(set().union(*blocks)) + if len(vertices) > 20: + raise ValueError('finite enumeration is limited to 20 coordinates') + if any(v not in probabilities or not F(0) <= probabilities[v] <= F(1) for v in vertices): + raise ValueError('probabilities in [0,1] required') + total = F(0) + for bits in product((0, 1), repeat=len(vertices)): + selected = {v for v, bit in zip(vertices, bits) if bit} + if not all(len(selected & b) <= a for b, a in zip(blocks, capacities)): + continue + weight = F(1) + for v, bit in zip(vertices, bits): + weight *= probabilities[v] if bit else 1-probabilities[v] + total += weight + return total + + +def cs_probability_bound(joint, left, right): + return joint**2 <= left*right + + +def exp_one_interval(n=40): + if type(n) is not int or n < 1: + raise ValueError('positive series length required') + lo = sum((F(1, factorial(j)) for j in range(n+1)), F(0)) + tail = F(1, factorial(n+1))/(1-F(1, n+2)) + return lo, lo+tail + + +def _log_unit_interval(x, terms): + t = (x-1)/(x+1) + lo = 2*sum((t**(2*j+1)/(2*j+1) for j in range(terms)), F(0)) + error = 2*t**(2*terms+1)/((2*terms+1)*(1-t*t)) + return lo, lo+error + + +def log_interval(x, terms=55): + x = F(x) + if x <= 0 or type(terms) is not int or terms < 1: + raise ValueError('positive logarithm argument and series length required') + if x < 1: + lo, hi = log_interval(1/x, terms) + return -hi, -lo + exponent = 0 + while x >= 2: + x /= 2; exponent += 1 + lo, hi = _log_unit_interval(x, terms) + l2, u2 = _log_unit_interval(F(2), terms) + return lo+exponent*l2, hi+exponent*u2 + + +def overlap_constant_interval(): + elo, ehi = exp_one_interval() + llo, _ = log_interval(5*elo-4) + _, lhi = log_interval(5*ehi-4) + hlo, hhi = 5-lhi, 5-llo + return 2/hhi, 2/hlo + + +def small_certificates(): + return { + 'exp_seven_thirds_margin': sum((F(7, 3)**j/factorial(j) for j in range(7)), F(0))-F(307, 32), + 'a_ge_two_tail_margin': F(28, 3)*F(4, 11)**5-F(25, 512), + 'e_upper_margin': F(87, 32)-exp_one_interval(6)[1], + 'chernoff_geometric_margin': 1-F(5, 16), + } + + +def color_even_capacity(vertices, blocks, capacities): + """Optimal original-coordinate coloring for read-two blocks with EVEN capacities. + +The incidence graph need not be bipartite. Split into capacity-two vertices, +Euler-orient after pairing odd vertices, then edge-color the bipartite +outgoing/incoming incidence graph. Auxiliary edges are discarded at the end. + """ + _validate(blocks, capacities) + if any(a % 2 for a in capacities): + raise ValueError('all capacities must be even') + ground = set().union(*blocks) + if any(sum(v in b for b in blocks) > 2 for v in ground): + raise ValueError('a coordinate may belong to at most two blocks') + vertices = set(vertices) + capacity_bound(vertices, blocks, capacities) + if not vertices: + return {} + slots = {} + for i, (block, capacity) in enumerate(zip(blocks, capacities)): + half_capacity = capacity // 2 + for j, v in enumerate(sorted(block & vertices)): + slots[i, v] = (0, i, j % half_capacity) + edges = [] + for v in sorted(vertices): + incident = [i for i, b in enumerate(blocks) if v in b] + left = slots[incident[0], v] + right = slots[incident[1], v] if len(incident) == 2 else (1, v, 0) + edges.append((left, right, v)) + adjacency = {} + for index, (left, right, _) in enumerate(edges): + adjacency.setdefault(left, []).append(index) + adjacency.setdefault(right, []).append(index) + odd = sorted(v for v, incident in adjacency.items() if len(incident) % 2) + for left, right in zip(odd[::2], odd[1::2]): + index = len(edges) + edges.append((left, right, None)) + adjacency[left].append(index) + adjacency[right].append(index) + unused = set(range(len(edges))) + oriented = {} + while unused: + start = edges[min(unused)][0] + current = start + while True: + while adjacency[current] and adjacency[current][-1] not in unused: + adjacency[current].pop() + if not adjacency[current]: + if current != start: + raise RuntimeError('Euler trail did not close') + break + index = adjacency[current].pop() + unused.remove(index) + left, right, _ = edges[index] + nxt = right if current == left else left + oriented[index] = (current, nxt) + current = nxt + out_blocks = {}; in_blocks = {} + for index, (tail, head) in oriented.items(): + out_blocks.setdefault(tail, set()).add(index) + in_blocks.setdefault(head, set()).add(index) + auxiliary_blocks = list(out_blocks.values()) + list(in_blocks.values()) + colors = color_capacity(set(range(len(edges))), auxiliary_blocks, + [1]*len(auxiliary_blocks), + [0]*len(out_blocks) + [1]*len(in_blocks)) + return {original: colors[index] for index, (_, _, original) in enumerate(edges) + if original is not None} diff --git a/frontiers/p15_bipartite_overlap_20260928/run_validation.py b/frontiers/p15_bipartite_overlap_20260928/run_validation.py new file mode 100644 index 000000000..314ae7a08 --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/run_validation.py @@ -0,0 +1,140 @@ +"""Source-bound finite replay. Standard library only; no network or repository writes.""" +import argparse +import hashlib +import importlib +import io +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +MUTANTS = { + 'allow-odd-capacity': ( + 'if any(a % 2 for a in capacities):', 'if False:', + 'test_even_capacity_requires_even'), + 'wrong-even-splitting': ( + 'half_capacity = capacity // 2', 'half_capacity = capacity', + 'test_even_triangle_same_palette'), + 'floor-instead-of-ceiling': ( + '(len(vertices & b) + a - 1) // a', 'len(vertices & b) // a', + 'test_exact_coloring_against_partition_oracle'), + 'ignore-bipartition': ( + 'if sides[i] == sides[j] and b & blocks[j]:', 'if False:', + 'test_bipartition_validation'), + 'false-overlap-independence': ( + 'return joint**2 <= left*right', 'return joint <= left*right', + 'test_overlap_destroys_local_independence'), + 'lose-cauchy-schwarz-factor': ( + 'return 2/hhi, 2/hlo', 'return 1/hhi, 1/hlo', + 'test_overlap_constant'), + 'charge-inactive-blocks': ( + 'if d == k and b not in answer:', 'if d <= k and b not in answer:', + 'test_inactive_demand_one_is_not_a_generator'), + 'drop-active-generators': ( + 'if d == k and b not in answer:', 'if d < k and b not in answer:', + 'test_complete_active_block_needs_extra_color'), + 'omit-exponential-tail': ( + 'return lo, lo+tail', 'return lo, lo', + 'test_exp_rational_enclosure'), + 'strict-capacity-event': ( + 'if not all(len(selected & b) <= a for b, a in zip(blocks, capacities)):', + 'if not all(len(selected & b) < a for b, a in zip(blocks, capacities)):', + 'test_binomial_five_tail_identity'), +} + + +def decode_unique(text): + def pairs(items): + result = {} + for key, value in items: + if key in result: + raise ValueError('duplicate JSON key: '+key) + result[key] = value + return result + return json.loads(text, object_pairs_hook=pairs) + + +def child(root): + sys.path.insert(0, str(root)) + tests = importlib.import_module('test_overlap') + result = unittest.TextTestRunner(stream=io.StringIO(), verbosity=0).run( + unittest.defaultTestLoader.loadTestsFromModule(tests)) + output = { + 'tests': result.testsRun, + 'failures': sorted(t.id().rsplit('.', 1)[-1] for t, _ in result.failures), + 'errors': sorted(t.id().rsplit('.', 1)[-1] for t, _ in result.errors), + 'passed': result.wasSuccessful(), + } + print(json.dumps(output, sort_keys=True)) + return 0 if result.wasSuccessful() else 1 + + +def source_check(root): + manifest = decode_unique((root/'SOURCE_FILES.json').read_text()) + entries = manifest['files'] + names = [entry['path'] for entry in entries] + if len(names) != len(set(names)) or any(Path(p).name != p for p in names): + raise ValueError('unique flat manifest paths required') + present = sorted(p.name for p in root.iterdir()) + if present != sorted(names+['SOURCE_FILES.json']): + raise ValueError('source membership mismatch') + for entry in entries: + p = root/entry['path'] + if p.is_symlink() or not p.is_file(): + raise ValueError('regular source required') + data = p.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: '+p.name) + + +def replay(root): + source_check(root) + original = (root/'overlap.py').read_text() + expected = decode_unique((root/'RESULTS.json').read_text()) + records = [] + for name in ['baseline', *MUTANTS]: + with tempfile.TemporaryDirectory(prefix='p15-overlap-replay-') as tmp: + copy = Path(tmp) + shutil.copyfile(root/'overlap.py', copy/'overlap.py') + shutil.copyfile(root/'test_overlap.py', copy/'test_overlap.py') + if name != 'baseline': + old, new, _ = MUTANTS[name] + if original.count(old) != 1: + raise ValueError('mutation anchor is not unique: '+name) + (copy/'overlap.py').write_text(original.replace(old, new)) + outputs = [] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + process = subprocess.run([sys.executable, *flags, str(root/'run_validation.py'), + '--child', str(copy)], capture_output=True, timeout=45) + result = decode_unique(process.stdout.decode()) + if process.stderr or result['errors']: + raise ValueError('execution error, not a valid predicate test: '+name) + if name == 'baseline': + if process.returncode != 0 or result != expected['baseline']: + raise ValueError('baseline differs from frozen summary') + else: + if process.returncode != 1 or result['passed'] or MUTANTS[name][2] not in result['failures']: + raise ValueError('expected semantic assertion did not reject: '+name) + outputs.append(process.stdout) + if outputs[0] != outputs[1]: + raise ValueError('normal and optimized outputs differ: '+name) + records.append({'case': name, **decode_unique(outputs[0].decode())}) + source_check(root) + summary = {'scientific_effect':'NONE', 'nonauthor_acceptance':False, + 'tests_per_mode': expected['baseline']['tests'], + 'mutants_per_mode': len(MUTANTS), 'all_output_pairs_identical':True, + 'source_membership_and_hashes':'PASS', 'cases':records} + print(json.dumps(summary, indent=2, sort_keys=True)) + return 0 + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--child', type=Path) + options = parser.parse_args() + if options.child is not None: + sys.exit(child(options.child.resolve())) + sys.exit(replay(Path(__file__).resolve().parent)) diff --git a/frontiers/p15_bipartite_overlap_20260928/test_overlap.py b/frontiers/p15_bipartite_overlap_20260928/test_overlap.py new file mode 100644 index 000000000..5db599b42 --- /dev/null +++ b/frontiers/p15_bipartite_overlap_20260928/test_overlap.py @@ -0,0 +1,227 @@ +"""Independent finite controls. These do not certify the continuum hazard proof.""" +import itertools +import unittest +from fractions import Fraction as F +from math import factorial +import overlap as m + + +def exact_chromatic_table(blocks, capacities): + vertices = sorted(set().union(*blocks)) + n = len(vertices) + sets = [{vertices[j] for j in range(n) if mask >> j & 1} for mask in range(1 << n)] + good = [all(len(s & b) <= a for b, a in zip(blocks, capacities)) for s in sets] + dp = [0] + [n + 1] * ((1 << n) - 1) + for mask in range(1, 1 << n): + first = mask & -mask + sub = mask + while sub: + if sub & first and good[sub]: + dp[mask] = min(dp[mask], 1 + dp[mask ^ sub]) + sub = (sub - 1) & mask + return sets, dp + + +def check_coloring(test, vertices, blocks, capacities, colors): + test.assertEqual(set(colors), set(vertices)) + for color in set(colors.values()): + test.assertTrue(all(sum(colors.get(v, -1) == color for v in block & set(vertices)) <= a + for block, a in zip(blocks, capacities))) + + +class OverlapTests(unittest.TestCase): + def test_minimum_palette(self): + self.assertEqual(m.capacity_bound(set(range(4)), [{0, 1, 2, 3, 4}], [1]), 4) + + def test_empty_configuration(self): + self.assertEqual(m.capacity_bound(set(), [{0, 1}], [1]), 0) + self.assertEqual(m.color_capacity(set(), [{0, 1}], [1], [0]), {}) + + def test_exact_coloring_against_partition_oracle(self): + instances = [([{0, 1, 2}, {2, 3, 4}], [1, 1], [0, 1]), + ([{0, 1, 2, 3}, {2, 3, 4}], [2, 1], [0, 1]), + ([{0, 1}, {2, 3}, {0, 2}, {1, 3}], [1]*4, [0, 0, 1, 1])] + for blocks, capacities, sides in instances: + sets, oracle = exact_chromatic_table(blocks, capacities) + for vertices, expected in zip(sets, oracle): + self.assertEqual(m.capacity_bound(vertices, blocks, capacities), expected) + colors = m.color_capacity(vertices, blocks, capacities, sides) + check_coloring(self, vertices, blocks, capacities, colors) + self.assertEqual(len(set(colors.values())), expected) + + def test_parallel_edges(self): + vertices = set(range(5)); blocks = [vertices, vertices] + colors = m.color_capacity(vertices, blocks, [1, 1], [0, 1]) + self.assertEqual(len(set(colors.values())), 5) + check_coloring(self, vertices, blocks, [1, 1], colors) + + def test_nonunit_capacities(self): + vertices = set(range(8)); blocks = [set(range(6)), set(range(3, 8))] + colors = m.color_capacity(vertices, blocks, [2, 3], [0, 1]) + check_coloring(self, vertices, blocks, [2, 3], colors) + self.assertEqual(len(set(colors.values())), 3) + + def test_one_original_coordinate_one_color(self): + blocks = [{0, 1, 2, 3}, {2, 3, 4, 5}] + colors = m.color_capacity(set(range(6)), blocks, [2, 2], [0, 1]) + self.assertEqual(len(colors), 6) + check_coloring(self, set(range(6)), blocks, [2, 2], colors) + + def test_bipartition_validation(self): + with self.assertRaises(ValueError): + m.color_capacity({0, 1, 2}, [{0, 1}, {1, 2}], [1, 1], [0, 0]) + + def test_read_two_is_not_enough(self): + # Triangle with two parallel edges per side; one private coordinate per block. + blocks = [{0, 1, 4, 5, 6}, {0, 1, 2, 3, 7}, {2, 3, 4, 5, 8}] + vertices = set(range(6)) + _, oracle = exact_chromatic_table([b & vertices for b in blocks], [1]*3) + self.assertEqual(oracle[-1], 6) + self.assertEqual(m.capacity_bound(vertices, blocks, [1]*3), 4) + self.assertTrue(all(not b <= vertices for b in blocks)) + with self.assertRaises(ValueError): + m.color_capacity(vertices, blocks, [1]*3, [0, 1, 0]) + + def test_complete_active_block_needs_extra_color(self): + blocks = [set(range(5)), set(range(4, 9))] + self.assertEqual(m.capacity_bound(blocks[0], blocks, [1, 1]), 5) + self.assertEqual(m.active_generators(blocks, [1, 1], [4, 4]), blocks) + + def test_inactive_demand_one_is_not_a_generator(self): + blocks = [set(range(5)), {4, 5}] + self.assertEqual(m.active_generators(blocks, [1, 1], [4, 1]), [blocks[0]]) + self.assertEqual(m.capacity_bound({4, 5}, blocks, [1, 1]), 2) + + def test_exact_obstruction_all_subsets(self): + blocks = [set(range(5)), set(range(4, 9))] + generators = m.active_generators(blocks, [1, 1], [4, 4]) + for bits in itertools.product((False, True), repeat=9): + vertices = {i for i, bit in enumerate(bits) if bit} + self.assertEqual(m.capacity_bound(vertices, blocks, [1, 1]) > 4, + any(g <= vertices for g in generators)) + + def test_shape_validation(self): + with self.assertRaises(ValueError): + m.active_generators([{0, 1, 2}], [1], [4]) + with self.assertRaises(ValueError): + m.color_capacity({9}, [{0, 1}], [1], [0]) + with self.assertRaises(ValueError): + m.color_capacity({0}, [{0}], [0], [0]) + + def test_overlap_destroys_local_independence(self): + blocks = [{0, 1}, {1, 2}]; p = {i: F(1, 2) for i in range(3)} + joint = m.good_probability(blocks, [1, 1], p) + marg = [m.good_probability([b], [1], p) for b in blocks] + self.assertEqual(joint, F(5, 8)) + self.assertGreater(joint, marg[0]*marg[1]) + self.assertTrue(m.cs_probability_bound(joint, marg[0], marg[1])) + + def test_cauchy_schwarz_on_heterogeneous_grid(self): + blocks = [{0, 1}, {1, 2}] + for values in itertools.product((F(0), F(1, 4), F(1, 2), F(3, 4), F(1)), repeat=3): + p = dict(enumerate(values)) + q = m.good_probability(blocks, [1, 1], p) + q0 = m.good_probability([blocks[0]], [1], p) + q1 = m.good_probability([blocks[1]], [1], p) + self.assertTrue(m.cs_probability_bound(q, q0, q1)) + + def test_probability_boundaries(self): + blocks = [{0, 1}, {1, 2}] + self.assertEqual(m.good_probability(blocks, [1, 1], {i: F(0) for i in range(3)}), 1) + self.assertEqual(m.good_probability(blocks, [1, 1], {i: F(1) for i in range(3)}), 0) + + def test_same_side_independence_exact(self): + p = {i: F(i+1, 7) for i in range(5)} + self.assertEqual(m.good_probability([{0, 1}, {2, 3, 4}], [1, 2], p), + m.good_probability([{0, 1}], [1], p)*m.good_probability([{2, 3, 4}], [2], p)) + + def test_binomial_five_tail_identity(self): + for q in (F(1, 4), F(1, 3), F(1, 2), F(3, 4)): + p = {i: 1-q for i in range(5)} + self.assertEqual(m.good_probability([set(range(5))], [1], p), 5*q**4-4*q**5) + + def test_exp_rational_enclosure(self): + lo, hi = m.exp_one_interval(6) + self.assertEqual(lo, F(1957, 720)) + self.assertEqual(hi, F(31967, 11760)) + self.assertGreater(lo, F(8, 3)) + self.assertLess(hi, F(87, 32)) + + def test_tail_and_constant_certificates(self): + cert = m.small_certificates() + self.assertTrue(all(v > 0 for v in cert.values())) + self.assertEqual(cert['exp_seven_thirds_margin'], F(129055, 209952)) + self.assertEqual(cert['a_ge_two_tail_margin'], F(2601239, 247374336)) + + def test_overlap_constant(self): + lo, hi = m.overlap_constant_interval() + self.assertGreater(lo, F(73015826409534942932, 10**20)) + self.assertLess(hi, F(73015826409534942934, 10**20)) + self.assertLess(hi, F(3, 4)) + + def test_demand_one_obstruction_preserved(self): + # At reference p*=1-1/e the two-point capacity-one good probability exceeds e^-1. + lo, hi = m.exp_one_interval(6) + # e>2 implies 2/e-1/e^2>1/e, i.e. e-1>0. + self.assertGreater(lo-1, 0) + self.assertEqual(m.capacity_bound({0, 1}, [{0, 1}], [1]), 2) + + def test_log_interval_contains_known_identity(self): + lo, hi = m.log_interval(F(1)) + self.assertEqual((lo, hi), (0, 0)) + l2, u2 = m.log_interval(F(2)) + l4, u4 = m.log_interval(F(4)) + self.assertEqual((l4, u4), (2*l2, 2*u2)) + + def test_even_triangle_same_palette(self): + blocks = [set(range(4)) | set(range(8, 12)) | {12}, + set(range(8)) | {13}, + set(range(4, 12)) | {14}] + vertices = set(range(12)) + colors = m.color_even_capacity(vertices, blocks, [2, 2, 2]) + check_coloring(self, vertices, blocks, [2, 2, 2], colors) + self.assertEqual(len(set(colors.values())), 4) + whole = set(range(15)) + colors = m.color_even_capacity(whole, blocks, [2, 2, 2]) + check_coloring(self, whole, blocks, [2, 2, 2], colors) + self.assertEqual(len(set(colors.values())), 5) + + def test_even_capacity_partition_oracle(self): + blocks = [{0, 1, 4, 5}, {0, 1, 2, 3}, {2, 3, 4, 5}] + for caps in ([2, 2, 2], [2, 4, 2]): + sets, oracle = exact_chromatic_table(blocks, caps) + for vertices, expected in zip(sets, oracle): + colors = m.color_even_capacity(vertices, blocks, caps) + check_coloring(self, vertices, blocks, caps, colors) + self.assertEqual(len(set(colors.values())), expected) + + def test_even_capacity_requires_even(self): + with self.assertRaises(ValueError): + m.color_even_capacity(set(range(4)), [set(range(4))], [3]) + + def test_even_capacity_rejects_read_three(self): + with self.assertRaises(ValueError): + m.color_even_capacity({0, 1, 2}, [{0, 1}, {0, 2}, {0}], [2, 2, 2]) + + def test_even_empty(self): + self.assertEqual(m.color_even_capacity(set(), [{0, 1}], [2]), {}) + + def test_nonbipartite_read_two_probability(self): + blocks = [{0, 1}, {1, 2}, {2, 0}] + for values in itertools.product((F(1, 4), F(1, 2), F(3, 4)), repeat=3): + p = dict(enumerate(values)) + q = m.good_probability(blocks, [1, 1, 1], p) + product_marginals = F(1) + for block in blocks: + product_marginals *= m.good_probability([block], [1], p) + self.assertLessEqual(q*q, product_marginals) + + def test_even_hazard_rational_certificate(self): + self.assertEqual(F(512, 25)-F(87, 32)**3, F(314641, 819200)) + self.assertGreater(F(512, 25)-F(87, 32)**3, 0) + lo, hi = m.log_interval(F(512, 25)) + self.assertGreater(lo, 3) + self.assertLess(2/lo, F(2, 3)) + +if __name__ == '__main__': + unittest.main() diff --git a/frontiers/p15_tail_load_20260928/PROOF.md b/frontiers/p15_tail_load_20260928/PROOF.md new file mode 100644 index 000000000..8187908df --- /dev/null +++ b/frontiers/p15_tail_load_20260928/PROOF.md @@ -0,0 +1,262 @@ +# Even-capacity reference tails and instance-adaptive overlap budgets + +Object: OA-P15-TAIL-LOAD-20260928-v1. +Author: OpenAI / ChatGPT, foreground continuation, 28 September 2026. +Disposition: AUTHOR-SIDE MATHEMATICAL CANDIDATE; source-bound nonauthor review required. +Scientific effect: NONE. No existing proof, governing status, graph or prize changes. + +## 1. Results and exact scope + +This additive note sharpens two steps in the P15 overlap packet at Math- commit +`23b7558943f69a7f479251566b19ba58e75cfc26`. Its original proof documents are not +modified. The independent-provider review of that packet is not presumed complete. +The arguments used here are displayed below rather than imported as accepted +premises. SOURCE_MAP.json identifies the related source objects and their roles. + +Let X be a finite nonempty set covered by nonempty blocks X_i. Every coordinate +belongs to at most two blocks. Each capacity a_i is a positive EVEN integer, +including the capacities of inactive blocks. Define + + D = {U subset X: |U intersect X_i| <= a_i for every i}. + +Let chi_D(U) be the minimum number of members of D partitioning U, with +chi_D(empty)=0. Assume |X_i|=a_i d_i+1, with positive integer d_i, and put +K=max_i d_i >=4. Let O_K(D)={U:chi_D(U)>K}. For independent original Bernoulli +probabilities p_v in [0,1], put H_D=-log mu_p(D), possibly infinite. Admissible +prices satisfy 0<=c_v<=min(1,-log(1-p_v)), taking the upper bound to be one at +p_v=1. A generator family covers O_K(D) when every obstruction contains a member; +a generator g costs product_{v in g}c_v. The empty generator costs one. + +**Theorem 1 (same palette, tighter even-capacity factor).** In this class, + + covercost_c(O_K(D)) <= min(1, rho_9 H_D), (T1) + rho_9 = 2/[9-log(36e^2-63e+28)] < 1/2. + +A rational outward enclosure, not a floating-point fit, is + + 0.47734798895766998533 < rho_9 < 0.47734798895766998534. (T2) + +The former packet supplied 2/log(512/25)<2/3. The new bound has the SAME +structural hypotheses and K, with no restriction on the Bernoulli vector or +transformed prices. It is not a claim that rho_9 is the optimal COVER factor. +The reference-tail optimization used to obtain it is exact, as stated below. + +**Theorem 2 (actual-coordinate load).** More generally, suppose a nonempty family of +nonempty blocks indexed by J really covers an obstruction family, and D is +contained in each local event A_i={|U intersect X_i|<=a_i}. Put p_*=1-e^(-1) and + + H_i=-log P(Bin(|X_i|,p_*)<=a_i)>0, + beta_J=max_{v in X} sum_{i in J: v in X_i} 1/H_i. (T3) + +For independent original coordinates and the same prices, + + covercost_c(O) <= min(1, beta_J H_D). (T4) + +The statement presupposes a genuine setwise cover and positive reference +hazards; it does not assert the palette formula for an arbitrary downset. +It needs neither an even-capacity nor a bipartite hypothesis ONCE a cover has +been established. Section 2 establishes such a cover for Theorem 1. The earlier +bipartite class also has a displayed palette proof in the referenced packet. + +Choose J to contain one representative of each inclusion-minimal active block +(d_i=K). Repeated blocks and redundant strict supersets can be removed because +their containment events are covered by smaller retained generators. In the +even/read-two class beta_J<=2/(-log q_9)=rho_9. If the retained blocks are +disjoint, beta_J<=1/(-log q_9). Unequal reference hazards are retained separately; +a shared coordinate is charged the SUM of its incident weights, never their max. + +## 2. Why the even/read-two full-block family is a cover + +For every U subset X, + + chi_D(U)=max_i ceil(|U intersect X_i|/a_i). (T5) + +The lower bound is immediate. For the upper bound write k for the right side; +the empty set is trivial. Represent each ORIGINAL coordinate of U as one edge +of the block-incidence multigraph: a shared coordinate joins its two block +vertices, and a private coordinate joins its block to a private degree-one +vertex. Coordinates are never duplicated as independent random variables. + +Split the edges incident to block i among a_i/2 vertices as evenly as possible. +Every split degree is at most ceil(2|U intersect X_i|/a_i)<=2k. Pair odd-degree +vertices and add auxiliary edges. Each odd degree was at most 2k-1, so the +augmented degrees are even and at most 2k. Orient an Euler tour in each component. +Each vertex now has at most k incoming and k outgoing edges. Replace each vertex +by its outgoing and incoming copies. An oriented edge joins its tail's outgoing +copy to its head's incoming copy, producing a bipartite multigraph of maximum +degree at most k. + +A bipartite multigraph of maximum degree k can be regularized to a k-regular +one by adding isolated vertices to balance its two parts, then adding edges +between degree deficits. For a left vertex set S, its k|S| edges end in a set +of total degree at most k|N(S)|, proving Hall's condition. Remove a perfect +matching repeatedly to obtain k edge colors. Remove all added edges. In the +original split graph a color has at most one incoming and one outgoing edge +at each vertex, hence at most two. Combining the a_i/2 vertices permits at most +a_i original coordinates per color in X_i. This proves (T5). + +For an inactive i, d_ia_i K holds exactly when X_i subset U. Consequently + + O_K(D)=union_{i:d_i=K}{U:X_i subset U}. (T6) + +Thus J described above is a valid cover at the SAME K. This proves the needed +cover premise independently of a status label on the older packet. It does not +reintroduce that packet's excluded arbitrary macro-clutter or odd capacities. + +## 3. Local price-to-hazard transfer + +For a proper decreasing event A containing the empty configuration, on its +finite coordinate set S define p_v(t)=1-e^(-t_v), 0<=t_v<=1, and +F(t)=-log mu_{p(t)}(A). Since p_v(t)<1 and A contains the empty set, its probability +is positive. Holding other coordinates fixed gives mu(A)=A_0+B_0 e^(-t_v) with +A_0,B_0>=0, by decreasingness. Direct differentiation yields + + partial_v^2 F=-A_0 B_0 e^(-t_v)/(A_0+B_0 e^(-t_v))^2 <=0. + +F is nonnegative. Its one-coordinate chord inequality implies +F(t)>=t_v F(t with t_v=1). Iterating gives + + F(t)>=F(1,...,1) product_{v in S}t_v. (T7) + +For arbitrary probabilities set t_v=min(1,-log(1-p_v)); then p_v(t)<=p_v. +Decreasingness implies -log mu_p(A)>=F(t). Therefore + + product_{v in S}c_v <= [-log mu_p(A)]/F(1,...,1). (T8) + +This holds as an extended inequality at zero event probability. A zero price is +not a reason to delete a generator from the setwise cover. Applying (T8) to A_i +uses reference hazard H_i, not the hazard of the full-block containment event. + +## 4. Weighted entropy with actual coordinate loads + +We prove the needed finite product inequality rather than presume independence +of overlapping events. If H_D is finite, set nu=mu_p(.|D). Let KL denote relative +entropy. Then KL(nu||mu_p)=H_D. Since the S_i=X_i marginal of nu is supported on +A_i, + + KL(nu_{S_i}||mu_{S_i}) + =KL(nu_{S_i}||mu_{S_i}(.|A_i)) - log mu_p(A_i) + >= h_i, h_i=-log mu_p(A_i). (T9) + +All A_i have positive probability because D does. Order the original coordinates +and write + + b_v=E_nu KL(nu(v | all earlier coordinates)||mu_v)>=0. + +Product form of mu and the chain rule give sum_v b_v=H_D. For a subset S, the +law conditioned on earlier coordinates IN S is a mixture of laws conditioned +on all earlier coordinates. Convexity of KL in its first entry gives + + KL(nu_S||mu_S)<=sum_{v in S} b_v. (T10) + +For arbitrary nonnegative weights w_i, multiply (T9)-(T10), sum, and exchange +finite sums: + + sum_i w_i h_i + <=sum_v b_v sum_{i:v in S_i}w_i + <=[max_v sum_{i:v in S_i}w_i] H_D. (T11) + +This is a weighted read-incidence / Finner-type inequality, not a new claim about +arbitrary dependent measures. Deterministic original coordinates have zero +conditional divergence and can be removed from the product support. + +Take w_i=1/H_i on the genuine cover J. Equation (T8) followed by (T11) proves +price_c(J)<=beta_J H_D. Comparing with the unit-price empty-generator cover proves +(T4). If H_D=infinity use that empty generator directly; if H_D=0 the finite +argument gives a zero-price covering family. No infinity divided by infinity +or logarithm of a zero REFERENCE probability is involved. + +A sum, not a maximum, at each shared coordinate is necessary for (T11). Two +identical events depending on one Bernoulli(1/2) coordinate, both of probability +1/2 and both of weight one, have local hazard sum2log2 but global hazardlog2. +Their load is two. This is a counterexample to a max-instead-of-sum entropy step, +not a claim that keeping duplicate generators is optimal. + +## 5. Exact worst reference tail among positive even capacities + +Let + + q_9=P(Bin(9,1-e^(-1))<=2) + =e^(-9)[1+9(e-1)+36(e-1)^2] + =e^(-9)(36e^2-63e+28). (T12) + +**Lemma (sharp reference-tail maximum).** For every even a>=2 and integer K>=4, + + P(Bin(aK+1,1-e^(-1))<=a) <= q_9, (T13) + +and equality is attained at a=2,K=4. + +For a=2, monotonicity in the number of trials gives (T13). If a>=4 is even, put +s=E[5^(-Bernoulli(1-e^(-1)))]=(e+4)/(5e). The elementary inequality e>8/3 gives +s<1/2. Markov's inequality applied to 5^(-Bin(n,p_*)), with n=aK+1>=4a+1, yields + + P(Bin(n,p_*)<=a) <=5^a s^n + <(1/2)(5/16)^a <=625/131072. (T14) + +There is no omitted a=3 case: the theorem's capacity is EVEN. No assertion for +an odd-capacity nonbipartite graph is licensed by this estimate. + +We certify 625/1310720 on [l,u]. Thus + + P(l)/u^9 < q_9 < P(u)/l^9. (T15) + +The two strict margins are the exact positive rationals + + P(l)/u^9 - 625/131072 + =87187623163627321174969/8421039761612032386662400, + 1/64 - P(u)/l^9 + =12311490319341451572976881157/26946192308072632700222520394048. + +This proves the reference maximum and -log q_9>log64. Also e<11/4 implies +e^2<121/16<8, hence log2>2/3. Therefore + + rho_9=2/(-log q_9)<2/log64=1/(3log2)<1/2. (T16) + +Every active even block has H_i>=-log q_9. Every original coordinate belongs +to at most two retained blocks. Equations (T3)-(T4) now prove (T1). + +This is exact sharpness of the uniform REFERENCE tail over the displayed integer +parameter family. The entropy bound, local transfer and empty-generator choice +may lose slack, so optimality of the COVER factor does not follow. + +## 6. Certified numerical interval and operational use + +The executable certificate brackets e by its positive series and geometric tail. +It brackets log x using x=2^j y with 1<=y<2, and + + log y=2 sum_{n=0}^{m-1}t^(2n+1)/(2n+1)+R, + t=(y-1)/(y+1), + 0<=R<=2t^(2m+1)/[(2m+1)(1-t^2)]. + +The same formula gives log2. Monotonic interval operations on +2/[9-log P(e)] give (T2) without using floats to choose or certify endpoints. + +For an instance, first establish an exact palette theorem and identify its +active full-block cover. Remove duplicates and strict supersets. Evaluate each +positive reference H_i, using outward enclosures when numerical certification is +needed. Use a certified UPPER bound on 1/H_i in the load at every original +coordinate. The maximum load is a safe instance-specific factor. One may then +use the full-block cover or the empty-generator cap. An uncertified numerical +hazard is not substituted for a proved lower bound. + +## 7. Verification and acceptance limits + +The small standard-library suite checks the nine-trial polynomial identity, +strict rational margins, interval directions and tails, weight addition at shared +coordinates, inactive-block exclusion, duplicate/superset removal, and the integer- +weighted probability form of (T11) on a heterogeneous finite Bernoulli grid. +It includes the max-instead-of-sum counterexample. Finite tests do not prove +(T7)-(T11) for every probability vector; their analytic proofs are above. + +This is an additive author-side candidate, not a governing acceptance. It does +not modify either #118 source proof, revive #116's unrelated blocked executable, +claim an optimal cover factor, retain arbitrary macro-clutter constraints, or +permit odd capacities in the nonbipartite case. Read-only targeted CI checks +finite certificates and existing repository gates, not the truth of a new full +analytic theorem or organizational reviewer independence. diff --git a/frontiers/p15_tail_load_20260928/README.md b/frontiers/p15_tail_load_20260928/README.md new file mode 100644 index 000000000..2a8d963f9 --- /dev/null +++ b/frontiers/p15_tail_load_20260928/README.md @@ -0,0 +1,21 @@ +# P15: tighter even-capacity and weighted-incidence bounds + +Scientific effect NONE. Author-side candidate; nonauthor mathematical review required. + +Read PROOF.md. Under the SAME even-capacity/read-two assumptions as Math-#118, +the uniform factor is improved from 2/log(512/25)<2/3 to + + 2/[9-log(36e^2-63e+28)] < 1/2. + +The rational enclosure is (0.47734798895766998533,0.47734798895766998534). +The exact sharp reference-tail maximum is the Bin(9,1-e^-1) lower tail at2; +this is NOT a claim that the resulting cover factor is optimal. + +The additional weighted entropy bound uses each coordinate's actual sum of +inverse reference hazards. It applies only after a genuine cover is established. +No source proof or governing status is changed. + +Run `python3 -B -S verify.py --output /tmp/new-tail-load-replay` from this folder. +The output directory must be new and outside the packet. The runner verifies +source membership and hashes, executes both Python modes, and tests semantic +mutants. It is a finite certificate runner, not a continuum theorem checker. diff --git a/frontiers/p15_tail_load_20260928/RECONNAISSANCE.md b/frontiers/p15_tail_load_20260928/RECONNAISSANCE.md new file mode 100644 index 000000000..8bc61b156 --- /dev/null +++ b/frontiers/p15_tail_load_20260928/RECONNAISSANCE.md @@ -0,0 +1,30 @@ +# Primary-source reconnaissance and attribution + +OpenAI / ChatGPT, 28 September 2026. Scientific effect NONE. + +Primary abstract records opened in this session: + +1. Pierre Aboulker, Guillaume Aubian and Chien-Chung Huang, *Vizing's and Shannon's + Theorems for defective edge colouring*, arXiv:2201.11548v2 (3 February 2022), + https://arxiv.org/abs/2201.11548 . Its abstract explicitly describes the even- + defect ceil(Delta/d) multigraph phenomenon. We do not claim invention of that + mechanism. The variable-capacity original-coordinate construction needed here + is written in PROOF.md Section2, using the existing #118 construction. +2. Dmytro Gavinsky, Shachar Lovett, Michael Saks and Srikanth Srinivasan, + *A Tail Bound for Read-k Families of Functions*, arXiv:1205.1478 (25 April 2012), + https://arxiv.org/abs/1205.1478 . The abstract concerns Boolean functions of + independent coordinates, with each coordinate influencing at most k functions. + This confirms a classical related dependence framework, not the exact theorem + or weighted constant of this note. The required weighted entropy chain argument + is provided in full in PROOF.md Section4. + +These were abstract/metadata reads, not full-paper verifications or a comprehensive +novelty audit. No claim of priority, optimal cover constant, or literature absence +is made. The improvement is to this workspace's displayed bound for the same +structural class: the exact even-capacity reference-tail maximum q9 replaces a +coarse Chernoff constant, and actual weighted incidences replace a uniform load. + +The preceding #118 source and tests were read and exposed to this author. The +new rational-series code follows elementary interval estimates also used there. +Source exposure and shared provider/account remain disclosed; no independent +review is created by this note or its citations. diff --git a/frontiers/p15_tail_load_20260928/RESULTS.json b/frontiers/p15_tail_load_20260928/RESULTS.json new file mode 100644 index 000000000..28e13439f --- /dev/null +++ b/frontiers/p15_tail_load_20260928/RESULTS.json @@ -0,0 +1,9 @@ +{ + "all_mutants_assertion_rejected": true, + "baseline_passed": true, + "continuum_verified": false, + "output_pairs_identical": 8, + "scientific_effect": "NONE", + "semantic_mutants_per_mode": 7, + "tests_per_mode": 15 +} diff --git a/frontiers/p15_tail_load_20260928/SOURCE_FILES.json b/frontiers/p15_tail_load_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..263e99df6 --- /dev/null +++ b/frontiers/p15_tail_load_20260928/SOURCE_FILES.json @@ -0,0 +1,54 @@ +{ + "files": [ + { + "bytes": 12828, + "git_blob": "8187908dfd220cb833b94f82c451ef4c0e45e367", + "path": "PROOF.md", + "sha256": "fbca462d4988a06754ded9415ceea6bb1385be5535656d643bdd48edbbee8a20" + }, + { + "bytes": 1056, + "git_blob": "2a8d963f925a769d629e45112983867870691bcf", + "path": "README.md", + "sha256": "830637948365dae801c4ec8382310c7bd69c0ac5735996d7854642e4d698a99d" + }, + { + "bytes": 1864, + "git_blob": "8bc61b1567dcd9b104fa6a361ae0e3efca8c3e4d", + "path": "RECONNAISSANCE.md", + "sha256": "a2741cd9751638916de3983e99ddc70c6363aeab26ef5f1f293d5a95fcfcc9b7" + }, + { + "bytes": 223, + "git_blob": "28e13439f86f0414a051460f36a48f53836f6771", + "path": "RESULTS.json", + "sha256": "e059e301bd6d4d106dfdfd957c538a11d658b149bdc4dcba068ef2f80ff10752" + }, + { + "bytes": 1133, + "git_blob": "294bebc1633f4bcae202569e832f99f5ca4447c8", + "path": "SOURCE_MAP.json", + "sha256": "9b0547968e91ddfbbd42c2d879df4e6d88cf4c1de20c12548b553d3687c15981" + }, + { + "bytes": 5482, + "git_blob": "c2a5b175e6444da578a6d8e1bbd97c36347f9fa0", + "path": "certificate.py", + "sha256": "ed786acea3839ede09a38d46f7425acd7dcfdbaa5f715834142a183aec4128f3" + }, + { + "bytes": 5189, + "git_blob": "9321541e8d5852cca24855244852f73e46db9448", + "path": "test_certificate.py", + "sha256": "6f64322ae77ff9c6fa905ab2e790d244836aa62597ee20b3ea6800f8836c7ebe" + }, + { + "bytes": 5900, + "git_blob": "e0b94703ee235beb115d9d736a0b8254048b08f4", + "path": "verify.py", + "sha256": "52bbaa19975c9be61abc0d6533c181c58cfdedaa2938dbd7efc928b076900a8a" + } + ], + "schema": 1, + "scientific_effect": "NONE" +} diff --git a/frontiers/p15_tail_load_20260928/SOURCE_MAP.json b/frontiers/p15_tail_load_20260928/SOURCE_MAP.json new file mode 100644 index 000000000..294bebc16 --- /dev/null +++ b/frontiers/p15_tail_load_20260928/SOURCE_MAP.json @@ -0,0 +1,24 @@ +{ + "scientific_effect": "NONE", + "repository": "d6g8k5htny-coder/Math-", + "related_sources": [ + { + "commit": "23b7558943f69a7f479251566b19ba58e75cfc26", + "path": "frontiers/p15_bipartite_overlap_20260928/PROOF.md", + "git_blob": "8ad826ecb374cc733e3a547bdba0ba63cad10c08", + "sha256": "21ce7a29ac0971919c0602f556f1aeba48bb14fffd4193864b3f482185bc1698", + "role": "exposed predecessor: exact palette, active generators, local transfer and coarse reference tail; required arguments displayed again here" + }, + { + "commit": "23b7558943f69a7f479251566b19ba58e75cfc26", + "path": "frontiers/p15_bipartite_overlap_20260928/EVEN_CAPACITY_EXTENSION.md", + "git_blob": "ce21e424433100d0307c49bc15cccc748f9438fc", + "sha256": "d28aa700ba83ca139b7b29b6ff06cc39c725470b710af10728867ec10c8ca985", + "role": "exposed predecessor: even-capacity construction and entropy proof; same class, no inherited acceptance" + } + ], + "runtime_dependency_on_predecessor": false, + "original_proofs_changed": false, + "nonauthor_acceptance": false, + "blocked_math116_code_consumed_or_retried": false +} diff --git a/frontiers/p15_tail_load_20260928/certificate.py b/frontiers/p15_tail_load_20260928/certificate.py new file mode 100644 index 000000000..c2a5b175e --- /dev/null +++ b/frontiers/p15_tail_load_20260928/certificate.py @@ -0,0 +1,152 @@ +"""Rational controls for a tighter reference tail and weighted coordinate loads. + +Standard library only; no network or repository writes. Finite calculations are +not a continuum theorem checker. See PROOF.md for the analytic argument. +""" +from fractions import Fraction as F +from itertools import product +from math import factorial + + +def exact(value): + if isinstance(value, bool) or not isinstance(value, (int, F)): + raise TypeError('integer or Fraction required; floats are not certificates') + return F(value) + + +def positive_integer(value): + if type(value) is not int or value < 1: + raise ValueError('positive integer required') + return value + + +def tail_polynomial(z): + z = exact(z) + if z < 1: + raise ValueError('z >= 1 required') + return 36*z*z - 63*z + 28 + + +def tail_nine(z): + """P(Bin(9,1-1/z)<=2) for rational z>=1; not an approximation to e.""" + z = exact(z) + return tail_polynomial(z)/z**9 + + +def exp_one_interval(n=40): + positive_integer(n) + lower = sum((F(1, factorial(j)) for j in range(n+1)), F(0)) + remainder = F(1, factorial(n+1))/(1-F(1, n+2)) + return lower, lower + remainder + + +def _unit_log(x, terms): + t = (x-1)/(x+1) + lower = 2*sum((t**(2*j+1)/(2*j+1) for j in range(terms)), F(0)) + remainder = 2*t**(2*terms+1)/((2*terms+1)*(1-t*t)) + return lower, lower+remainder + + +def log_interval(x, terms=50): + x = exact(x) + positive_integer(terms) + if x <= 0: + raise ValueError('positive logarithm argument required') + if x < 1: + lower, upper = log_interval(1/x, terms) + return -upper, -lower + exponent = 0 + while x >= 2: + x /= 2 + exponent += 1 + lower, upper = _unit_log(x, terms) + l2, u2 = _unit_log(F(2), terms) + return lower + exponent*l2, upper + exponent*u2 + + +def coarse_tail_interval(): + """Outward bounds from 1957/720=4 required') + return F(1, 2)*F(5, 16)**a + + +def factor_interval(): + """Outward bounds for 2/[9-log(36e^2-63e+28)], using rational series.""" + lower_e, upper_e = exp_one_interval() + lower_log, _ = log_interval(tail_polynomial(lower_e)) + _, upper_log = log_interval(tail_polynomial(upper_e)) + lower_h, upper_h = 9-upper_log, 9-lower_log + if lower_h <= 0: + raise ValueError('nonpositive certified hazard floor') + return 2/upper_h, 2/lower_h + + +def _blocks(blocks): + if any(not isinstance(b, (set, frozenset)) or not b or + any(type(v) is not int or v < 0 for v in b) for b in blocks): + raise ValueError('nonempty sets of nonnegative integer coordinates required') + + +def coordinate_load(blocks, weights): + """Maximum SUM of nonnegative weights over blocks sharing a coordinate.""" + _blocks(blocks) + if len(blocks) != len(weights): + raise ValueError('one weight per block required') + weights = [exact(w) for w in weights] + if any(w < 0 for w in weights): + raise ValueError('nonnegative weights required') + ground = set().union(*blocks) + return max((sum((w for b, w in zip(blocks, weights) if v in b), F(0)) + for v in ground), default=F(0)) + + +def minimal_active_indices(blocks, capacities, demands): + """Deduplicate and remove redundant supersets from maximal-demand blocks. + +This only constructs a proposed full-block cover. Its eligibility still requires +an exact palette theorem; it does not certify coloring of an arbitrary downset. + """ + _blocks(blocks) + if not blocks or len(blocks) != len(capacities) or len(blocks) != len(demands): + raise ValueError('one capacity and demand for each nonempty block required') + for a, d in zip(capacities, demands): + positive_integer(a) + positive_integer(d) + if any(len(b) != a*d+1 for b, a, d in zip(blocks, capacities, demands)): + raise ValueError('block size must equal a*d+1') + active = [i for i, d in enumerate(demands) if d == max(demands)] + return [i for i in active if not any( + blocks[j] < blocks[i] or (j < i and blocks[j] == blocks[i]) + for j in active if j != i)] + + +def good_probability(blocks, capacities, probabilities): + """Exact finite product enumeration, limited to 12 coordinates.""" + _blocks(blocks) + if len(blocks) != len(capacities) or any(type(a) is not int or a < 0 for a in capacities): + raise ValueError('nonnegative integer capacity per block required') + ground = sorted(set().union(*blocks)) + if len(ground) > 12: + raise ValueError('enumeration limit is 12 coordinates') + if any(v not in probabilities for v in ground): + raise ValueError('missing original-coordinate probability') + p = {v: exact(probabilities[v]) for v in ground} + if any(value < 0 or value > 1 for value in p.values()): + raise ValueError('probabilities must be in [0,1]') + total = F(0) + for bits in product((0, 1), repeat=len(ground)): + chosen = {v for v, bit in zip(ground, bits) if bit} + if not all(len(chosen & block) <= a for block, a in zip(blocks, capacities)): + continue + mass = F(1) + for v, bit in zip(ground, bits): + mass *= p[v] if bit else 1-p[v] + total += mass + return total diff --git a/frontiers/p15_tail_load_20260928/test_certificate.py b/frontiers/p15_tail_load_20260928/test_certificate.py new file mode 100644 index 000000000..9321541e8 --- /dev/null +++ b/frontiers/p15_tail_load_20260928/test_certificate.py @@ -0,0 +1,119 @@ +"""Exact finite controls, not a proof of a continuum probability theorem.""" +from fractions import Fraction as F +from itertools import product +from math import comb +import unittest +import certificate as c + + +class CertificateTests(unittest.TestCase): + def test_exact_nine_tail_identity(self): + for z in (F(2), F(5, 2), F(87, 32), F(3)): + q = 1/z + direct = sum(F(comb(9, j))*(1-q)**j*q**(9-j) for j in range(3)) + self.assertEqual(c.tail_nine(z), direct) + + def test_tail_domain(self): + for z in (F(0), F(1, 2), True, 2.7): + with self.assertRaises((ValueError, TypeError)): + c.tail_nine(z) + + def test_exponential_bracket(self): + lo, hi = c.exp_one_interval(6) + self.assertEqual(lo, F(1957, 720)) + self.assertEqual(hi, F(31967, 11760)) + self.assertLess(hi, F(87, 32)) + self.assertGreater(lo, F(8, 3)) + + def test_log_brackets_and_reciprocals(self): + self.assertEqual(c.log_interval(F(1)), (0, 0)) + lo, hi = c.log_interval(F(2)) + self.assertGreater(lo, F(2, 3)) + self.assertLess(hi, F(7, 10)) + self.assertEqual(c.log_interval(F(4)), (2*lo, 2*hi)) + self.assertEqual(c.log_interval(F(1, 2)), (-hi, -lo)) + + def test_logarithm_remainder_is_retained(self): + self.assertEqual(c.log_interval(F(2), 1), (F(2, 3), F(25, 36))) + + def test_exact_rational_tail_separation(self): + lo, hi = c.coarse_tail_interval() + self.assertEqual(lo, c.tail_polynomial(F(1957, 720))/F(87, 32)**9) + self.assertEqual(hi, c.tail_polynomial(F(87, 32))/F(1957, 720)**9) + self.assertGreater(lo, F(625, 131072)) + self.assertLess(hi, F(1, 64)) + self.assertGreater(F(8)-F(11, 4)**2, 0) + + def test_even_chernoff_envelope(self): + self.assertEqual(c.even_large_tail_bound(4), F(625, 131072)) + for a in range(4, 34, 2): + self.assertLessEqual(c.even_large_tail_bound(a), c.even_large_tail_bound(4)) + for a in (2, 3, 5, 0, True): + with self.assertRaises((ValueError, TypeError)): + c.even_large_tail_bound(a) + + def test_tight_factor_enclosure(self): + lo, hi = c.factor_interval() + self.assertGreater(lo, F(47734798895766998533, 10**20)) + self.assertLess(hi, F(47734798895766998534, 10**20)) + self.assertLess(hi, F(1, 2)) + self.assertGreater(hi, lo) + + def test_invalid_interval_arguments(self): + for n in (0, True, 1.5): + with self.assertRaises((ValueError, TypeError)): + c.exp_one_interval(n) + for x in (0, -1, True, 0.5): + with self.assertRaises((ValueError, TypeError)): + c.log_interval(x) + + def test_weighted_overlap_load_is_sum(self): + blocks = [{0, 1}, {1, 2}] + self.assertEqual(c.coordinate_load(blocks, [F(1, 3), F(1, 5)]), F(8, 15)) + self.assertEqual(c.coordinate_load([{0}, {1}], [F(1, 3), F(1, 5)]), F(1, 3)) + self.assertEqual(c.coordinate_load([{0}, {0}], [F(1, 3), F(1, 5)]), F(8, 15)) + + def test_active_minimal_cover_unchanged_scope(self): + blocks = [{0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}, set(range(9)), {9, 10}] + self.assertEqual(c.minimal_active_indices(blocks, [1, 1, 2, 1], [4, 4, 4, 1]), [0]) + # Inactive demand-one is not charged, although it remains a constraint of D. + self.assertEqual(c.minimal_active_indices([set(range(5)), {4, 5}], [1, 1], [4, 1]), [0]) + + def test_cover_input_validation(self): + with self.assertRaises(ValueError): + c.minimal_active_indices([{0, 1}], [1], [4]) + with self.assertRaises(ValueError): + c.coordinate_load([{0}], [F(-1)]) + with self.assertRaises(ValueError): + c.coordinate_load([{0}], []) + + def test_integer_weighted_entropy_probability_form(self): + blocks = [{0, 1}, {1, 2}, {2, 0}] + weights = [1, 2, 3] + exponent = int(c.coordinate_load(blocks, list(map(F, weights)))) + self.assertEqual(exponent, 5) + for vals in product((F(0), F(1, 3), F(2, 3), F(1)), repeat=3): + p = dict(enumerate(vals)) + joint = c.good_probability(blocks, [1, 1, 1], p) + rhs = F(1) + for block, weight in zip(blocks, weights): + rhs *= c.good_probability([block], [1], p)**weight + self.assertLessEqual(joint**exponent, rhs) + + def test_shared_coordinate_max_instead_of_sum_is_false(self): + p = {0: F(1, 2)} + joint = c.good_probability([{0}], [0], p) + self.assertEqual(joint, F(1, 2)) + # Two identical local events, each with weight one, need load TWO. + self.assertGreater(joint, joint*joint) + self.assertEqual(joint**2, joint*joint) + + def test_exact_enumeration_endpoints(self): + blocks = [{0, 1}, {1, 2}] + self.assertEqual(c.good_probability(blocks, [1, 1], {v: F(0) for v in range(3)}), 1) + self.assertEqual(c.good_probability(blocks, [1, 1], {v: F(1) for v in range(3)}), 0) + self.assertEqual(c.good_probability(blocks, [1, 1], {v: F(1, 2) for v in range(3)}), F(5, 8)) + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/frontiers/p15_tail_load_20260928/verify.py b/frontiers/p15_tail_load_20260928/verify.py new file mode 100644 index 000000000..e0b94703e --- /dev/null +++ b/frontiers/p15_tail_load_20260928/verify.py @@ -0,0 +1,119 @@ +"""Exact source and finite-control replay; no network or repository mutation.""" +import argparse +import hashlib +import importlib +import io +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +ROOT=Path(__file__).resolve().parent +MUTANTS={ + 'wrong-nine-tail':('36*z*z - 63*z + 28','36*z*z - 62*z + 28','test_exact_nine_tail_identity'), + 'omit-exp-tail':('return lower, lower + remainder','return lower, lower','test_exponential_bracket'), + 'omit-log-tail':('return lower, lower+remainder','return lower, lower','test_logarithm_remainder_is_retained'), + 'lose-read-two':('return 2/upper_h, 2/lower_h','return 1/upper_h, 1/lower_h','test_tight_factor_enclosure'), + 'lose-chernoff-half':('return F(1, 2)*F(5, 16)**a','return F(5, 16)**a','test_even_chernoff_envelope'), + 'max-not-load-sum':('sum((w for b, w in zip(blocks, weights) if v in b), F(0))','max((w for b, w in zip(blocks, weights) if v in b), default=F(0))','test_weighted_overlap_load_is_sum'), + 'charge-inactive':('if d == max(demands)','if d <= max(demands)','test_active_minimal_cover_unchanged_scope'), +} + + +def require(condition,message): + if not condition: + raise ValueError(message) + + +def unique_json(text): + def pairs(rows): + result={} + for key,value in rows: + require(key not in result,'duplicate JSON key: '+key) + result[key]=value + return result + return json.loads(text,object_pairs_hook=pairs) + + +def identity(path): + require(path.is_file() and not path.is_symlink(),'regular source required: '+path.name) + data=path.read_bytes() + return {'bytes':len(data),'sha256':hashlib.sha256(data).hexdigest(), + 'git_blob':hashlib.sha1(f'blob {len(data)}\0'.encode()+data).hexdigest()} + + +def sources(): + identity(ROOT/'SOURCE_FILES.json') + rows=unique_json((ROOT/'SOURCE_FILES.json').read_text())['files'] + names=[row['path'] for row in rows] + require(len(names)==len(set(names)) and all(Path(n).name==n and n!='SOURCE_FILES.json' for n in names),'unique flat source paths required') + require(sorted(p.name for p in ROOT.iterdir())==sorted(names+['SOURCE_FILES.json']),'source membership mismatch') + for row in rows: + require(identity(ROOT/row['path'])=={k:row[k] for k in ['bytes','sha256','git_blob']},'source identity mismatch: '+row['path']) + return {p.name:identity(p) for p in sorted(ROOT.iterdir())} + + +def child(directory): + sys.path.insert(0,str(directory)) + module=importlib.import_module('test_certificate') + result=unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromModule(module)) + record={'tests':result.testsRun,'passed':result.wasSuccessful(), + 'failures':sorted(test.id().rsplit('.',1)[-1] for test,_ in result.failures), + 'errors':sorted(test.id().rsplit('.',1)[-1] for test,_ in result.errors)} + print(json.dumps(record,sort_keys=True)) + return 0 if result.wasSuccessful() else 1 + + +def replay(output): + output=output.resolve() + require(not output.exists() and not output.is_relative_to(ROOT),'new output outside source required') + before=sources() + output.mkdir(parents=True) + code=(ROOT/'certificate.py').read_text() + records={} + for name in ['baseline',*MUTANTS]: + with tempfile.TemporaryDirectory(prefix='p15-tail-load-') as temporary: + directory=Path(temporary) + shutil.copyfile(ROOT/'test_certificate.py',directory/'test_certificate.py') + text=code + if name!='baseline': + old,new,_=MUTANTS[name] + require(code.count(old)==1,'mutation anchor not unique: '+name) + text=code.replace(old,new) + (directory/'certificate.py').write_text(text) + pair=[] + for mode,flags in [('normal',[]),('optimized',['-O'])]: + process=subprocess.run([sys.executable,'-B',*flags,'-S',str(ROOT/'verify.py'),'--child',str(directory)],capture_output=True,timeout=30) + (output/(name+'_'+mode+'.stdout')).write_bytes(process.stdout) + (output/(name+'_'+mode+'.stderr')).write_bytes(process.stderr) + result=unique_json(process.stdout.decode()) + require(not process.stderr and not result['errors'],'execution error: '+name) + require(result['tests']==15,'wrong test count: '+name) + if name=='baseline': + require(process.returncode==0 and result['passed'] and not result['failures'],'baseline failed') + else: + require(process.returncode==1 and not result['passed'] and MUTANTS[name][2] in result['failures'],'intended assertion did not reject: '+name) + pair.append(process.stdout) + require(pair[0]==pair[1],'Python mode output mismatch: '+name) + records[name]=unique_json(pair[0].decode()) + summary={'tests_per_mode':15,'semantic_mutants_per_mode':7,'output_pairs_identical':8, + 'baseline_passed':True,'all_mutants_assertion_rejected':True, + 'scientific_effect':'NONE','continuum_verified':False} + require(summary==unique_json((ROOT/'RESULTS.json').read_text()),'stored summary differs') + require(sources()==before,'source mutation') + report={**summary,'source_identities':before,'sources_unchanged':True,'cases':records} + (output/'REPORT.json').write_text(json.dumps(report,sort_keys=True,indent=2)+'\n') + print(json.dumps(summary,sort_keys=True,indent=2)) + return 0 + + +if __name__=='__main__': + parser=argparse.ArgumentParser(description=__doc__) + group=parser.add_mutually_exclusive_group(required=True) + group.add_argument('--output',type=Path) + group.add_argument('--child',type=Path) + args=parser.parse_args() + raise SystemExit(child(args.child.resolve()) if args.child else replay(args.output)) diff --git a/frontiers/remote_height_decoupling_20260928/PROOF.md b/frontiers/remote_height_decoupling_20260928/PROOF.md new file mode 100644 index 000000000..4d7af587d --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/PROOF.md @@ -0,0 +1,284 @@ +# Faster within-window height decoupling at fixed remote separation + +Object: OA-REMOTE-HEIGHT-DECOUPLING-20260928-v1. +Author: OpenAI / ChatGPT, foreground continuation, 28 September 2026. +Disposition: AUTHOR-SIDE PROOF CANDIDATE; source-bound nonauthor review required. +Scientific effect NONE. No parent source, verdict, graph or scientific status changes. + +## 1. Precise improvement and inputs + +Use the exact fixed-remote setting of RM and RC in SOURCE_MAP.json: the normalized +periodic Gaussian field on the fixed d-dimensional torus, d>=2, fixed rho>0, +compact birth marks b and gap marks 0=1, is within O(r^2) of a +single point with location/index law pi_{r,1} and independent uniform theta. +A measurable point-selection rule on nonempty configurations which returns the +unique point when N_r=1 has the same O(r^2) height-uniformity and own-marginal +independence conclusions. This is not an assertion that a finite-r location and +index are mutually independent. + +The full joint law compared to the LIMITING contact profile pi_E tensor lambda +remains O(r), as before. The stronger height/decoupling estimates do not supply +a faster location-profile convergence rate or a height law for persistence +partners. No numerical C or cutoff, global/no-rho statement, or optimal Gaussian +rate is claimed. + +### Exact imported premises + +RM Sections 2-5 supply the uniform positive covariance sandwich for the transformed +pins U_r plus Y_x=(grad f(x),f(x)), all fixed C^q Gaussian regression moments, +the filtered-determinant estimate (8), Z_r/r^2 bounded above and away from zero, +and the full pre-height-integrated density + + R_{r,j}(x,h)=p_{Y_x|U_r=v_r}(0,h) + E[W_r F_j(H_x)|U_r=v_r,Y_x=(0,h)]/Z_r. (H5) + +Its pointwise contact comparison and positive contact kernels give + + c r^3 |E| <= m_r <= C r^3 |E|. (H6) + +RC Corollary D supplies q_r<=C r^5 |E|. These premises concern the same fixed +remote law and all indices. They are not imported from a global cap event or +from a probability bound in the wrong direction. The new work below is a +same-r comparison in the actual height h, retaining the homogeneous endpoint +constraints so that division by Z_r does not lose r^2. + +## 2. Height regression changes along a smooth homogeneous-pin direction + +Fix r,x and all endpoint marks/frames. Order V_r=(U_r,grad f(x),f(x)), and let e_h +be the target coordinate vector for its last entry. With one unconditioned field +F, use RM's Gaussian regression realization for each height target h: + + F_h(z)=F(z)+Cov(F(z),V_r) Sigma_r^{-1}(a_h-V_r), + a_h=(v_r,0,h), Sigma_r=Cov(V_r). + +For h,h' in the closed between-pin interval this gives the exact pathwise identity + + F_h-F_{h'}=(h-h') g_{r,x}, + g_{r,x}(z)=Cov(F(z),V_r) Sigma_r^{-1} e_h. (H7) + +All fixed derivatives of the cross-covariance in z are uniformly bounded, by +Cauchy-Schwarz and the smooth field's uniform derivative variances. The inverse +covariance is uniformly bounded by RM Section 2. Thus for each fixed q, + + ||g_{r,x}||_{C^q} <= C_q. (H8) + +Applying the observation vector V_r to g_{r,x} gives Sigma_r Sigma_r^{-1}e_h=e_h. +Therefore U_r g=0, grad g(x)=0 and g(x)=1. Since the transformed U_r is invertible +as a re-expression of the ORIGINAL endpoint observations for r>0, + + g(M)=g(S)=0, grad g(M)=grad g(S)=0. (H9) + +This step uses the same exact pin law, not contact pins substituted at finite r. +The direction is deterministic; the conditioned Gaussian residual is shared. +All field supremum moments are uniform over h,h' by RM's extra-height regression +argument. No independence of endpoint and witness Hessians is asserted. + +## 3. The vanishing endpoint columns survive the height comparison + +For any smooth g with both gradient pins zero, the average of D^2g u over the +endpoint segment vanishes. At either endpoint i, + + ||D^2g(i)u|| + <= (1/r) integral_0^r t dt * ||D^3g||_infinity + = (r/2)||D^3g||_infinity. (H10) + +For M, subtract D^2g(M+tu)u from D^2g(M)u inside its zero-average integral; +for S reverse the segment. This is a vector integral identity, not an unjustified +simultaneous vector Rolle point. + +For each conditioned F_h define its endpoint blocks as in RM Section 4: + + H_i(h)=[[r alpha_i(h), r beta_i(h)^T], + [r beta_i(h), A_i(h)]], + K_i(h)=[[alpha_i(h), sqrt(r) beta_i(h)^T], + [sqrt(r) beta_i(h), A_i(h)]]. + +Equations (H7)-(H10) give, uniformly in small r, + + |alpha_i(h)-alpha_i(h')|+||beta_i(h)-beta_i(h')|| + <= C|h-h'|, + ||A_i(h)-A_i(h')|| <= C|h-h'|, + ||K_i(h)-K_i(h')||+||H_x(h)-H_x(h')|| <= C|h-h'|. (H11) + +The normalizations alpha=f_uu/r and beta=grad_perp f_u/r therefore do NOT cause +an r^-1 loss. Every matrix in (H11) has moments of all fixed orders uniformly in +h, by the gradient-pin bounds and the extra-conditioned Gaussian moments. + +Positive congruence gives exactly, including at singular Hessians, + + W_r(F_h)/r^2 = F_d(K_M(h)) F_(d-1)(K_S(h)). (H12) + +## 4. Uniform Lipschitz continuity of the full height density + +The deterministic estimate in RM (8) is + + |F_j(A)-F_j(B)| + <= d max(||A||,||B||)^(d-1)||A-B||. (H13) + +It concerns the determinant TIMES the index indicator, not the indicator alone. +Across index changes the matrix segment reaches determinant zero, so this bound +does not require eigenvalues bounded away from zero. + +Apply (H13), (H11), and the product difference identity to the three factors in + + T_h=F_d(K_M(h))F_(d-1)(K_S(h))F_j(H_x(h)). + +Hölder and the uniform moments give + + |E T_h-E T_{h'}| <= E|T_h-T_{h'}| <= C|h-h'|, + sup_h E|T_h| <= C. (H14) + +The conditional Gaussian density p_{Y_x|U_r=v_r}(0,h) and its first h derivative +are uniformly bounded on this compact target/covariance domain. Its difference +is at most C|h-h'|. Multiply (H14) by this density and by r^2/Z_r, which is bounded +and does NOT depend on the additional witness height h. Equation (H5) yields + + |R_{r,j}(x,h)-R_{r,j}(x,h')| <= L |h-h'| (H15) + +with L uniform over remote x, compact endpoint marks/frames and small r. +This is stronger for within-window variation than comparing each height to the +contact kernel with an O(r) error. No derivative of a discontinuous index +indicator or differentiation under an unbounded expectation is being used. + +## 5. Exact finite-r mean decoupling and its third-order rate + +The finite measure form of weighted Kac-Rice in RM gives, after h=b-l theta, + + mu_r(dx,{j},dtheta)=l R_{r,j}(x,b-l theta) dx dtheta. (H16) + +Write Rbar_{r,j}(x)=integral_0^1 R_{r,j}(x,b-l t)dt. The location/index marginal +of mu_r has density l Rbar. By (H15), + + integral_0^1 |R(x,b-l theta)-Rbar(x)| dtheta + <= L l integral_0^1 integral_0^1 |theta-t| dt dtheta + = L l/3. + +Sum over the d+1 indices and integrate over E. The FULL variation estimate is + + ||mu_r - mu_r^Y tensor lambda||_var + <= (d+1)L l^2 |E|/3 <= C r^6 |E|. (H17) + +Both measures have the SAME mass m_r. Divide by 2m_r and use (H6), obtaining (H1). +Unlike a comparison with the limiting contact profile, there is no normalization +error between two different total masses. The volume factor cancels even when +E_r varies and tends to zero in volume. A zero-volume E has no conditional law +and is explicitly excluded. + +## 6. Conditional singleton law and physical-height moments + +Let sigma be the expected marked measure restricted to N_r=1, of mass p_1. +Let eta be the mean marked measure on N_r>=2, of mass a=E[N_r;N_r>=2]. Then + + mu_r=sigma+eta, m_r=p_1+a, a<=q_r. (H18) + +For small r, p_1>=m_r-q_r>0. The mixture identity implies + + dTV(S_r, mu_r/m_r) <= a/m_r, S_r=sigma/p_1. (H19) + +Marginal contraction gives dTV(pi_{r,1},pi_r)<=a/m_r. Tensoring with a fixed +probability measure preserves TV. The triangle inequality and (H1) therefore give + + dTV(S_r,pi_{r,1} tensor lambda) <= 2a/m_r+C r^3 <= C r^2. + +For the height marginal alone, compare first with mu_r/m_r and then with pi_r +tensor lambda. Its bound is a/m_r+C r^3, again O(r^2). This proves (H2)-(H3). +The factor two in the joint own-marginal comparison is kept, not silently removed. + +Since 0<=theta<=1, TV controls its first two moments: +E theta=1/2+O(r^2), E theta^2=1/3+O(r^2), Var theta=1/12+O(r^2). +Using H=b-l theta and l=k r^3 proves (H4), with uniform compact-k constants. + +Bonferroni and the factorial bound give + + P(N_r>=1)>=m_r-q_r/2, + epsilon_r:=P(N_r>=2 | N_r>=1)<=q_r/(2m_r-q_r)=O(r^2). (H20) + +The nonempty configuration law is a mixture of its singleton part and a +multiple-configuration part with mass epsilon_r. Its TV distance from the +singleton law S_r, embedded into configurations, is exactly epsilon_r. Combining +with (H2) proves the complete-configuration assertion. + +Any measurable rule selecting one actual point from a nonempty configuration +agrees with S_r on N_r=1, hence its selected-mark law differs from S_r by at most +epsilon_r. Applying marginal contraction once more proves O(r^2) decoupling from +its OWN selected location/index marginal, and O(r^2) height uniformity. A rule +may be randomized via a probability kernel; the same mixture argument applies. + +## 7. Why this does not improve the contact-profile rate + +If pi_E is the limiting contact spatial/index profile, RM gives only +TV(pi_r,pi_E)=O(r). Therefore + + TV(S_r,pi_E tensor lambda) <= O(r^2)+TV(pi_{r,1},pi_E)=O(r). + +There is no contradiction with the sharper own-marginal factorization. The old +O(r) comparison can be dominated by spatial/index drift which is common to +all heights and vanishes when that finite-r marginal is retained. + +Nor do the moment premises alone permit O(r^3) conditional height error. For a +simple abstract marked process at two distinct locations A,B, choose m=r^3 and +p_2=r^5/2. A two-point configuration occurs with probability p_2 and contains one +point at each location with a common height uniform on (0,1/2). Choose the +singleton submeasure to make the TOTAL mean mark measure exactly m times the +uniform law on {A,B} times Uniform(0,1): its height density summed over locations +is m-4p_2 on (0,1/2) and m on (1/2,1). These are nonnegative for r<=1/2 and have +mass p_1=m-2p_2. Put the remaining probability 1-m+p_2 on the empty configuration. + +This process has an exactly height-flat mean and q=2p_2=r^5, but its singleton +height TV from uniform is + + p_2/(m-2p_2)=r^2/[2(1-r^2)]. (H21) + +It shows the O(r^2) multiplicity correction cannot be eliminated from just these +mean/factorial premises. It is NOT an example of the conditioned Gaussian field +and does not prove that the rate is optimal for that specific field. + +## 8. Review and verification boundaries + +The new load-bearing analytic step is (H15): the shared regression direction, +homogeneous endpoint constraints, normalized Hessian columns, filtered +polynomial determinant bound, and extra-conditioned moments. The finite tests +check the TV convention, actual finite-r marginal, pair multiplicity weights, +normalizations, the explicit homogeneous-pin polynomial, and the rate-barrier +example. They do not establish a covariance floor, a Gaussian supremum bound, +or Kac-Rice applicability. + +This note does not permit rho->0, changing d/L, unbounded birth marks or k->0, +or field-selected random E. It does not imply global uniqueness, change a +persistence-partner definition, or recover/retry the unrelated blocked code in +Math-#116. Authorship/exposure is OpenAI, including the prior remote source; +independent acceptance requires an actual source-bound nonauthor review. diff --git a/frontiers/remote_height_decoupling_20260928/README.md b/frontiers/remote_height_decoupling_20260928/README.md new file mode 100644 index 000000000..12ab1168b --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/README.md @@ -0,0 +1,14 @@ +# Within-window height decoupling — author-side candidate + +[PROOF.md](PROOF.md) proves the proposed improvement using the existing fixed-remote +mean and factorial inputs: O(r^3) factorization of the normalized mean against its +own finite-r location/index marginal, and O(r^2) height uniformity/independence for +the actual unique witness. Joint convergence to the limiting contact profile stays +O(r). Physical height mean and variance errors become O(r^5) and O(r^8). + +Scientific effect NONE. No parent source or scientific status is changed. +This is a new derivation, not a replay of the absent Math-#116 algebra suite. + +Run `python -B -S verify.py` or `python -B -O -S verify.py` from this directory. +The finite standard-library tests and semantic mutants do not certify the Gaussian +argument. Source identities and comparison scope are in SOURCE_MAP.json. diff --git a/frontiers/remote_height_decoupling_20260928/RECONNAISSANCE.md b/frontiers/remote_height_decoupling_20260928/RECONNAISSANCE.md new file mode 100644 index 000000000..5fb3e4816 --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/RECONNAISSANCE.md @@ -0,0 +1,22 @@ +# Reconnaissance and attribution — 28 September 2026 + +This is a source-consumer derivation, not an independent Gaussian-field theory +or a novelty/priority claim. The existing remote mean proof is read at its exact +Git blob in SOURCE_MAP.json. Its same-r conditional Gaussian field construction, +filtered determinant estimate and full normalizer are the load-bearing inputs. +The same-r height-Lipschitz consequence and finite-r marginal target are derived +explicitly in PROOF.md rather than inferred from an integrated mean. + +The neighboring primary-source Kac-Rice framework is Armentano, Azais and Leon, +On a general Kac-Rice formula for the measure of a level set, +arXiv:2304.07424v3. It is the underlying reference of the consumed remote source, +not a new direct theorem import here. Gaussian regression, vector integral +Taylor bounds, TV contraction and the singleton/mean mixture are classical. +The earlier HEIGHT_MARKS and remote-singleton records are credited in the proof; +neither is silently rewritten or treated as new independent review. + +The current Consensus request returned its monthly quota error. The continuation +used direct primary-source records instead; no Consensus search hit or full-text +read is fabricated. A future novelty audit would need substantially broader +search than this dependency-focused pass. The finite tests do not prove the +Gaussian covariance or expected-integral premises. diff --git a/frontiers/remote_height_decoupling_20260928/RESULTS.json b/frontiers/remote_height_decoupling_20260928/RESULTS.json new file mode 100644 index 000000000..82f2f3aef --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/RESULTS.json @@ -0,0 +1,11 @@ +{ + "scientific_effect": "NONE", + "baseline": { + "errors": [], + "failures": [], + "passed": true, + "tests": 12 + }, + "scope": "Finite identities, normalization and counterexamples only; no Gaussian continuum verification.", + "nonauthor_acceptance": false +} diff --git a/frontiers/remote_height_decoupling_20260928/SOURCE_FILES.json b/frontiers/remote_height_decoupling_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..606647ba8 --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/SOURCE_FILES.json @@ -0,0 +1,40 @@ +{ + "schema": 1, + "files": [ + { + "path": "PROOF.md", + "bytes": 13747, + "sha256": "67249f0311342beab7833cb60c3239d9888df96befda4fbae3ec29a66f8cd78e" + }, + { + "path": "README.md", + "bytes": 860, + "sha256": "172f89489a5dbcae5723a4ef25a2bf311d40f2063355a8e58915667dffa4f76d" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 1417, + "sha256": "c1c847aeca81d809dc15a578a960f3c0873db991d1a75303a8dc0db68d08a3ae" + }, + { + "path": "RESULTS.json", + "bytes": 271, + "sha256": "ed08787edd576df6a3ddc78904c78e7f90fcdd2c837f8aead4af632f04e589e7" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 1327, + "sha256": "21c033a48551ebdc084e44845a0172e36ebeba4ef8879c81cad7943fe81d5e0d" + }, + { + "path": "check.py", + "bytes": 5189, + "sha256": "3edbfc286c1660b5beb3a3b10df85d0d2dc51d256320a58f360682ab5db2adfc" + }, + { + "path": "verify.py", + "bytes": 3024, + "sha256": "7f057116ee8a0fa2c81dde06a821b5f717795a6bb06bf763af1ee3e9f81460f2" + } + ] +} diff --git a/frontiers/remote_height_decoupling_20260928/SOURCE_MAP.json b/frontiers/remote_height_decoupling_20260928/SOURCE_MAP.json new file mode 100644 index 000000000..fe7f8e5c7 --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/SOURCE_MAP.json @@ -0,0 +1,27 @@ +{ + "scientific_effect": "NONE", + "source_repository": "d6g8k5htny-coder/Math-", + "inputs": [ + { + "commit": "4b2aa45b2f995fc27c16ec37cccb081821eda74c", + "path": "frontiers/remote_window_20260924/PROOF.md", + "git_blob": "b383bfcc88ec4ad497dff01fb6640e429ba24a84", + "use": "Sections 2-5: same-r height regression, extra-conditioned moments, filtered determinant Lipschitz inequality, full normalizer, pre-height mean kernel and its positive contact limit." + }, + { + "commit": "4b2aa45b2f995fc27c16ec37cccb081821eda74c", + "path": "frontiers/remote_collision_20260928/PROOF.md", + "git_blob": "7b48a88e2af54e759e89a8c8219573bb450a65ea", + "use": "Corollary D: fixed-remote all-index factorial moment O(r^5)|E|." + }, + { + "commit": "0507e3a1dbd3dede84cbeb805947c70aa16ebc36", + "path": "frontiers/window_multiplicity_laws_20260928/HEIGHT_MARKS.md", + "git_blob": "015d769675d9a2cf191286979d3b8c877cd91bdc", + "use": "Comparison and attribution only: prior O(r) target is the limiting contact profile, not the new finite-r marginal. Its blocked code is not consumed." + } + ], + "new_analytic_obligation": "Uniform Lipschitz height density via homogeneous endpoint regression directions.", + "nonauthor_acceptance": false, + "global_extension_claimed": false +} diff --git a/frontiers/remote_height_decoupling_20260928/check.py b/frontiers/remote_height_decoupling_20260928/check.py new file mode 100644 index 000000000..5e52cf0f5 --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/check.py @@ -0,0 +1,132 @@ +"""Exact finite controls for the new same-r height-decoupling argument. + +This is not a Gaussian-field simulator or a continuum theorem verifier. +""" +import argparse +from fractions import Fraction as F +import io +import json +import unittest + +MUTANT = None + +def tv(p, q): + if len(p) != len(q): + raise ValueError('matching finite mark spaces required') + scale = 1 if MUTANT == 'tv-factor' else F(1, 2) + return scale*sum(abs(a-b) for a,b in zip(p,q)) + + +def own_spatial_product(mu): + if len(mu) != 4 or any(v < 0 for v in mu): + raise ValueError('four nonnegative mark masses required') + mass=sum(mu) + if mass == 0: + if MUTANT == 'allow-zero': + return [F(0)]*4 + raise ValueError('positive mean mass required') + if MUTANT == 'wrong-marginal': + return [F(1, 4)]*4 + divisor=F(2) if MUTANT == 'ignore-mass' else 2*mass + return [(mu[0]+mu[1])/divisor]*2+[(mu[2]+mu[3])/divisor]*2 + + +def normalized_mean(singletons, pair_mass): + if len(singletons) != 4 or pair_mass < 0 or any(v < 0 for v in singletons): + raise ValueError('nonnegative configuration weights required') + mu=list(singletons) + mu[0] += pair_mass + if MUTANT != 'drop-pair-weight': + mu[2] += pair_mass + mass=sum(mu) + if mass <= 0: + raise ValueError('positive mean mass required') + return [v/mass for v in mu] + + +class HeightTests(unittest.TestCase): + def test_probability_tv_half_convention(self): + self.assertEqual(tv([F(1), F(0)], [F(0), F(1)]), 1) + + def test_equal_probability(self): + self.assertEqual(tv([F(1, 3), F(2, 3)], [F(1, 3), F(2, 3)]), 0) + + def test_own_not_contact_marginal(self): + self.assertEqual(own_spatial_product([F(3, 10), F(3, 10), F(1, 5), F(1, 5)]), + [F(3, 10), F(3, 10), F(1, 5), F(1, 5)]) + + def test_normalization_handles_small_mass(self): + self.assertEqual(own_spatial_product([F(3, 100), F(3, 100), F(1, 50), F(1, 50)]), + [F(3, 10), F(3, 10), F(1, 5), F(1, 5)]) + + def test_zero_mass_excluded(self): + with self.assertRaises(ValueError): + own_spatial_product([F(0)]*4) + + def test_mean_needs_two_pair_points(self): + # Four mark bins: A0,A1,B0,B1. A multiple configuration has A0 and B0. + p = F(1, 100) + self.assertEqual(normalized_mean([p, 2*p, p, 2*p], p), [F(1, 4)]*4) + + def test_pair_mixture_bound(self): + for r in (F(1, 2), F(1, 3), F(1, 10)): + mass = r**3; p2 = r**5/2 + sig = [mass/4-p2, mass/4, mass/4-p2, mass/4] + p1 = sum(sig) + mean = normalized_mean(sig, p2) + single = [v/p1 for v in sig] + self.assertEqual(mean, [F(1, 4)]*4) + self.assertEqual(tv(single, mean), r*r/(2*(1-r*r))) + self.assertLessEqual(tv(single, mean), r*r) + + def test_mean_uniform_does_not_force_singleton_uniform(self): + r = F(1, 10); mass = r**3; p2 = r**5/2 + sig = [mass/4-p2, mass/4, mass/4-p2, mass/4] + single = [v/sum(sig) for v in sig] + self.assertGreater(tv(single, [F(1, 4)]*4), r**3) + + def test_exact_height_change_of_variables(self): + for r in (F(1, 2), F(1, 7)): + k = F(6, 5); length = k*r**3 + # An affine within-window density gives TV = slope*length/(8*mean). + base = F(2); slope = F(3) + average = base-slope*length/2 + self.assertEqual((slope*length*length/4)/(2*length*average), + slope*length/(8*average)) + + def test_average_distance_integral(self): + # Integral_0^1 [theta^2/2+(1-theta)^2/2] dtheta = 1/3. + self.assertEqual(F(1, 6)+F(1, 6), F(1, 3)) + + def test_homogeneous_gradient_pin_cancellation(self): + # g=x^2*z-r^2*z/4+(x^2-r^2/4)^2. Both values/gradients vanish at M,S. + for r in (F(1, 2), F(1, 11), F(1, 101)): + for x in (-r/2, r/2): + self.assertEqual(x*x-r*r/4, 0) + self.assertEqual(4*x*(x*x-r*r/4), 0) + beta = (2*x)/r + alpha = (12*x*x-r*r)/r + self.assertEqual(abs(beta), 1) + self.assertEqual(alpha, 2*r) + self.assertLessEqual(abs(alpha), 1) + + def test_tv_marginal_contraction(self): + p=[F(1, 10),F(2, 10),F(3, 10),F(4, 10)]; q=[F(1, 4)]*4 + self.assertLessEqual(tv([p[0]+p[2], p[1]+p[3]], [F(1, 2)]*2), tv(p,q)) + + +def main(): + parser=argparse.ArgumentParser() + parser.add_argument('--mutant', choices=['tv-factor', 'wrong-marginal', 'drop-pair-weight', 'ignore-mass', 'allow-zero']) + args=parser.parse_args() + global MUTANT + MUTANT=args.mutant + suite=unittest.defaultTestLoader.loadTestsFromTestCase(HeightTests) + result=unittest.TextTestRunner(stream=io.StringIO()).run(suite) + print(json.dumps({'tests':result.testsRun, 'passed':result.wasSuccessful(), + 'failures':sorted(t.id().rsplit('.',1)[-1] for t,_ in result.failures), + 'errors':sorted(t.id().rsplit('.',1)[-1] for t,_ in result.errors)}, sort_keys=True)) + return 0 if result.wasSuccessful() else 1 + +if __name__=='__main__': + raise SystemExit(main()) diff --git a/frontiers/remote_height_decoupling_20260928/verify.py b/frontiers/remote_height_decoupling_20260928/verify.py new file mode 100644 index 000000000..3d12c5453 --- /dev/null +++ b/frontiers/remote_height_decoupling_20260928/verify.py @@ -0,0 +1,73 @@ +"""Verify the exact flat packet, execute both modes, reject semantic mutants.""" +import hashlib +import json +from pathlib import Path +import subprocess +import sys + +EXPECTED_FAILURE = { + 'tv-factor':'test_probability_tv_half_convention', + 'wrong-marginal':'test_own_not_contact_marginal', + 'drop-pair-weight':'test_mean_needs_two_pair_points', + 'ignore-mass':'test_normalization_handles_small_mass', + 'allow-zero':'test_zero_mass_excluded', +} + +def unique(items): + result={} + for key,value in items: + if key in result: + raise ValueError('duplicate JSON key: '+key) + result[key]=value + return result + +def load(text): + return json.loads(text,object_pairs_hook=unique) + +def check_sources(root): + entries=load((root/'SOURCE_FILES.json').read_text())['files'] + names=[e['path'] for e in entries] + if len(names)!=len(set(names)) or any(Path(n).name!=n for n in names): + raise ValueError('invalid flat source paths') + if sorted(p.name for p in root.iterdir())!=sorted(names+['SOURCE_FILES.json']): + raise ValueError('packet membership differs') + for e in entries: + p=root/e['path'] + if p.is_symlink() or not p.is_file(): + raise ValueError('nonregular source') + data=p.read_bytes() + if len(data)!=e['bytes'] or hashlib.sha256(data).hexdigest()!=e['sha256']: + raise ValueError('source identity differs: '+p.name) + +def main(): + root=Path(__file__).resolve().parent + check_sources(root) + baseline=load((root/'RESULTS.json').read_text())['baseline'] + records=[] + for case in ['baseline',*EXPECTED_FAILURE]: + outs=[] + for flags in (['-B','-S'],['-B','-O','-S']): + command=[sys.executable,*flags,str(root/'check.py')] + if case!='baseline': + command+=['--mutant',case] + process=subprocess.run(command,capture_output=True,timeout=30) + result=load(process.stdout.decode()) + if process.stderr or result['errors']: + raise ValueError('execution error rather than semantic failure') + if case=='baseline': + if process.returncode!=0 or result!=baseline: + raise ValueError('baseline mismatch') + elif process.returncode!=1 or result['passed'] or EXPECTED_FAILURE[case] not in result['failures']: + raise ValueError('semantic mutant not rejected: '+case) + outs.append(process.stdout) + if outs[0]!=outs[1]: + raise ValueError('normal and optimized outputs differ') + records.append({'case':case,**load(outs[0].decode())}) + check_sources(root) + print(json.dumps({'scientific_effect':'NONE','nonauthor_acceptance':False, + 'tests_per_mode':baseline['tests'],'mutants_per_mode':len(EXPECTED_FAILURE), + 'exact_sources':'PASS','all_output_pairs_identical':True,'cases':records}, + indent=2,sort_keys=True)) + +if __name__=='__main__': + main() diff --git a/frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md b/frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md new file mode 100644 index 000000000..aaefc8da9 --- /dev/null +++ b/frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md @@ -0,0 +1,205 @@ +# A direct planar elder-failure lower bound and the sharp compact-window density loss + +Object: OA-ELDER-LOWER-DENSITY-GAP-20260928-v1. +Author: OpenAI / ChatGPT, foreground research session, 28 September 2026. +Disposition: AUTHOR-SIDE PROOF CANDIDATE; NONAUTHOR ANALYTIC REVIEW REQUIRED. +Scientific effect: NONE. This does not change any historical certificate or governing status. + +## 1. Exact elder probability and conclusions + +Use the exact planar periodized Gaussian field and the original typed pair law +Q_r^W defined in LOCAL_MULTIPLICITY.md. The torus L is fixed, birth b is in a fixed +compact interval, k is in [k_-,k_+] with k_->0, and frames range over O(2). The six +pins are M=-(r/2)u, S=(r/2)u, f(M)=b, f(S)=b-k r^3, and both gradients zero. +W_r=F_2(H_M)F_1(H_S) and the FULL normalizer is Z_r=E_Qr W_r. This is not a law +conditioned on adjacency. + +Let p_r(b,k,R) be the probability that the global ordinary superlevel elder death +partner of M is S. This is **exactly** the p_r definition in [LP, Section 1], not +a new selector. On the generic locus its death height is the maximin + + d_f(M)=sup_{gamma(0)=M, f(gamma(1))>f(M)} min_t f(gamma(t)), (E1) + +with the empty supremum convention of [LP, Section 8]. A path to a point strictly +above the birth height, entirely above f(S), therefore prevents S from being M's +elder death partner. No gradient-trajectory or saddle-saddle transversality theorem +is required for this sufficient obstruction. + +**Theorem E1 (direct lower bound).** Uniformly on the stated compact planar model, +there are c,r_*>0 such that + + 1-p_r(b,k,R) >= c r^3, 0= b-k r^3/4 > f(S), + d_f(M)-f(S) >= 3k r^3/4. (E3) + +It does not use a subtraction of competing witness-intensity bounds, numerical +rungs, an asymptotically fitted exponent, or an assumed independence of witnesses. +In particular a window-count lower bound alone would not prove (E2); the explicit +path below is essential. + +**Corollary E2 (two-sided selection rate, with a separate upper input).** If the +precise Theorem A upper bound in [LP] is consumed, then in d=2 + + c r^3 <= 1-p_r(b,k,R) <= C r^3. (E4) + +The lower proof below is independent of that upper theorem. A defect in the upper +input would affect (E4)'s upper half, not the direct lower mechanism (E2). + +## 2. A rational polygonal path with strict quantitative margins + +Use the local scaled cubic + + G_k(X,Z)=k(2X^3-3X/2-1/2-3Z^2/4-XZ^2). + +Consider the three-segment path + + (-1/2,0) -> (-3/4,0) -> (-3/4,9/4) -> (-1,9/4). (E5) + +Every segment lies in B(0,3): the largest endpoint squared norm is 97/16<9, +and the ball is convex. On the three segments, parameterized consecutively by +v in [0,1], the exact restricted polynomials divided by k are + + g_1(v)=-3v^2/16-v^3/32, + g_2(v)=-7/32, + g_3(v)=-7/32+51v/64-9v^2/32-v^3/32. (E6) + +The first is nonincreasing, the second constant, and + + g_3'(v)=(51-36v-6v^2)/64 >= 9/64>0. + +It follows that the minimum on the entire path is -7k/32, while its final value +is +17k/64. The path passes through a level region, but its proof does not rely on +that level remaining exactly constant under perturbation. + +If a field F on B(0,3) obeys + + ||F-G_k||_infinity < k/64, F(-1/2,0)=0, + +then the entire path has F-values above -15k/64>-k/4 and the endpoint has value +above 16k/64=k/4>0. Consequently, for the physical field with +F(X,Z)=(f(rX,rZ)-b)/r^3, the same path scaled by r connects M to a point with +value above b, entirely above b-k r^3/4. Definition (E1) proves (E3). + +This is stable C^0 connectivity, not a statement that a prescribed path is a +separatrix. It remains a sufficient elder obstruction even without identifying +the exact saddle where the merger occurs. The existence of the two extra saddles +proved in the local multiplicity module is useful additional information, but is +not needed for the path argument. + +## 3. Positive probability of the path under the actual tilted Gaussian law + +For completeness, the ingredients from the local module can be isolated without +using its global upper bound or its extra-saddle implicit-function argument. +With s=f_zz(0)/r, a=f_xxz(0), beta=f_xzz(0), c=f_zzz(0), the exact six pins give + + (f(rX,rZ)-b)/r^3 + =2kX^3-3kX/2-k/2+(s/2)Z^2 + +(a/2)(X^2-1/4)Z+(beta/2)XZ^2+(c/6)Z^3 + +O_{C^2(B3)}(r||f||C4). (E7) + +The term -aZ/8 retains both transverse gradient pins. The target values +s=-3k/2, a=0, beta=-2k, c=0 recover G_k. Choose a fixed small epsilon and the +physical jet box + + |f_zz+(3k/2)r|= c_2 r^4 + +on this event. The full normalizer obeys 0 A_0>0 (E9) + +uniformly on the compact parameters, where sigma is the ordinary surface measure +and pi_r is the density of the endpoint observation frame. Selected intensity has +the same factors times p_r. There is no factor 1/2 for the differently typed, +ordered maximum/saddle pair. + +Changing variables ell=k r^3 at fixed k gives the exact density-gap version + + nu_cand(ell)-nu_eld(ell) + =(ell^(-1/3)/3) integral_B integral_K integral_S + k^(-2/3) A_{(ell/k)^(1/3)}(b,k,u) + [1-p_{(ell/k)^(1/3)}(b,k,u)] d sigma dk db. (E10) + +For sufficiently small ell all these radii are below the common cutoff. The +uniform positive lower and finite upper bounds for A_r, and (E2)/(E4), imply + + c_{B,K} ell^(2/3) + <= nu_cand(ell)-nu_eld(ell) + <= C_{B,K} ell^(2/3). (E11) + +The lower follows directly from (E2); the upper consumes the already identified +parent upper theorem. The k factor in its bounding integral is k^(-5/3), since +r^3=ell/k. It is finite and has positive integral on the fixed gap window. + +Thus the parent's compact-window O(ell^(2/3)) **selection-density loss** is optimal +in order in the planar model; it cannot be replaced by o(ell^(2/3)) under these +assumptions. This does not prove sharpness of the different O(1) remainder in a +leading density expansion, and does not remove the compact-mark restriction. +Combining with nu_cand(ell)~c ell^(-1/3) gives a rejected-pair fraction of order ell. +Integrating (E11) from zero to epsilon gives a cumulative rejected-pair intensity +of order epsilon^(5/3), versus total compact-window intensity of order + epsilon^(2/3). No leading numerical constant is determined by these inequalities. + +## 5. Relation to the lower-rate campaign and review boundaries + +The new direct event proves a uniform, all-small-r positive lower constant for +the exact typed pair law and ordinary elder selector defined in [LP]. Fixing any +birth and any positive gap mark in these ranges gives the corresponding one-mark +specialization. This is an existential analytic lower theorem, not a collection +of finite-r numerical checks. It does not rely on any disputed window-saddle +Cauchy-Schwarz estimate or on its numerical budget subtraction. + +A historical artifact using the symbol q(r,b) is not automatically identified +with this p_r: its covariance, scaling convention, pin meanings, tilt and selector +must match. No historical numerical c,r_0, finite-band certificate, lower-campaign +registry bit, or prize is advanced here. In particular an adjacency-conditioned +law is a different law and is excluded from the statement. + +The ordinary elder obstruction itself uses only the maximin definition and the +strict polygonal path, not the SARD-G no-saddle-connection theorem. The local +Gaussian jet-density and extra-conditioned C^4 control are the core new analytic +obligations. The parent upper theorem and weighted density identity are separately +named dependencies for (E4) and (E11). This separation permits a reviewer to accept +or reject the direct lower mechanism without inheriting a broader parent verdict. diff --git a/frontiers/window_multiplicity_laws_20260928/LOCAL_MULTIPLICITY.md b/frontiers/window_multiplicity_laws_20260928/LOCAL_MULTIPLICITY.md new file mode 100644 index 000000000..b5c18aac5 --- /dev/null +++ b/frontiers/window_multiplicity_laws_20260928/LOCAL_MULTIPLICITY.md @@ -0,0 +1,270 @@ +# A local two-saddle mechanism: global window multiplicity has order r^3 + +Object: OA-WINDOW-MULTIPLICITY-LOCAL-20260928-v1. +Author: OpenAI / ChatGPT, foreground research session, 28 September 2026. +Disposition: AUTHOR-SIDE PROOF CANDIDATE; NONAUTHOR ANALYTIC REVIEW REQUIRED. +Scientific effect: NONE. This note does not change a governing status or a prior proof. + +## 1. Setting and statements + +Use the exact **planar**, variance-one periodized Gaussian field, endpoint observations, +and determinant tilt of [RM] and [IW] in SOURCE_MAP.json. The torus side L is fixed. +Birth marks b range over a fixed compact interval and k over [k_-,k_+], with k_->0. +Frames range over O(2); stationarity permits the midpoint to be zero. In a local frame, + + M=(-r/2,0), S=(r/2,0), + f(M)=b, f(S)=b-k r^3, grad f(M)=grad f(S)=0. + +Q_r is continuous Gaussian regression on these six actual observations. It has no +adjacency or elder-pairing condition. F_j(H) is |det H| on nonsingular Hessians of +negative index j, and zero otherwise. Set + + W_r=F_2(H_M) F_1(H_S), Z_r=E_Qr W_r, + dQ_r^W=(W_r/Z_r)dQ_r, I_r=(b-k r^3,b). + +Let N_r count additional critical points on the torus, excluding M,S, whose heights +belong to I_r. Let A_r be the event that **two distinct additional saddles** in the +physical ball B(0,2r) have heights in I_r. No restriction on other critical points +is made. Balls are embedded by reducing r_*. + +**Theorem L.** There are positive c,C,r_*, depending only on the fixed parameter +ranges and L, such that, uniformly in b,k,frame and 0=2} <= C r^3. (L1) + +Consequently, + + E_Qr^W[N_r(N_r-1)] >= c r^3, (L2) + Q_r^W{N_r>=2 | N_r>=1} >= c_0>0. (L3) + +The expectation in (L2) is allowed to be an extended nonnegative number; no finite +upper estimate for it is being supplied. The conditioning in (L3) is well-defined +by (L1). The upper bound in (L1) consumes the already integrated planar global +HEIGHT-WINDOW first moment [IW, (I5)]. The lower bound has a direct Gaussian +jet-box proof below and does not consume any global elder-selection assertion. + +In particular, a torus-wide extension of [RC]'s remote O(r^5) factorial bound is +false under these assumptions. A torus-wide conditional-uniqueness assertion +1-O(r^2) is also false. These statements do **not** contradict [RC] or the remote +singleton-law candidate [SL]: their spatial exclusion radius is fixed and positive, +whereas the event A_r occurs a distance of order r from the pins. + +## 2. An exact cubic with strict, stable window witnesses + +For k>0 define + + G_k(X,Z)=k(2X^3-3X/2-1/2-3Z^2/4-XZ^2). (L4) + +Its gradient is k(6X^2-3/2-Z^2, -(3/2+2X)Z). Its four critical points and +Hessian data are as follows; all entries are exact. + +| Point | Height | Hessian or determinant | Type | +|---|---|---|---| +| M_*=(-1/2,0) | 0 | diag(-6k,-k/2), det=3k^2 | maximum | +| S_*=(1/2,0) | -k | diag(6k,-5k/2), det=-15k^2 | saddle | +| P_+=(-3/4,sqrt(15/8)) | -7k/32 | det=-15k^2/2 | saddle | +| P_-=(-3/4,-sqrt(15/8)) | -7k/32 | det=-15k^2/2 | saddle | + +At P_+ and P_- the Hessian is [[-9k,-2kZ],[-2kZ,0]]. The extra points +satisfy |P_+|^2=|P_-|^2=39/16<4. Their height -7k/32 lies strictly in (-k,0). +The endpoint determinant weight of this scaled cubic is 45k^4. + +The equal heights of P_+ and P_- cause no stability problem: we require each +critical point to be nondegenerate and its height to be strictly inside the window, +not an equality between their heights. A perturbation can and generally will split +them while preserving both witnesses. + +Choose disjoint small closed disks about P_+,P_- inside B(0,2), avoiding M_*,S_*. +The implicit-function theorem applied to the gradient at these nondegenerate zeros +gives a C^2 neighborhood of G_1 with a saddle in each disk. Shrink the neighborhood +so the two saddle heights lie, for example, strictly between -1 and 0. For fields +with the two pins exactly retained, shrink it again so their Hessians have the +specified indices and their determinant magnitudes exceed 3/2 and 15/2. +Multiplying by k and using k_->0 makes these neighborhoods uniform for the compact +k range. Thus there is a fixed epsilon_0>0 such that a scaled field within +k epsilon_0 of G_k in C^2(B(0,2)) has the two witnesses and + + F_2(H_scaled(M_*)) F_1(H_scaled(S_*)) >= (45/4) k^4. (L5) + +This is an ordinary open stability assertion about finitely many nondegenerate +zeros. It neither counts all critical points in the ball nor assumes a globally +Morse contact field. + +## 3. Pinned Taylor normal form, including the transverse linear term + +All derivatives below are at the physical midpoint. Write + + s=f_zz(0)/r, a=f_xxz(0), beta=f_xzz(0), c=f_zzz(0), + P_{k,s,a,beta,c}(X,Z) + =2kX^3-3kX/2-1/2*k + (s/2)Z^2 + +(a/2)(X^2-1/4)Z +(beta/2)XZ^2 +(c/6)Z^3. (L6) + +If ||f||_{C^4}<=K and the actual endpoint observations hold, multivariate Taylor +expansion gives, uniformly on B(0,3), + + || (f(rX,rZ)-b)/r^3 - P_{k,s,a,beta,c} ||_{C^2(B(0,3))} <= C r K. (L7) + +Here and below harmless norm-equivalence constants depend on the fixed dimension. +To check all potentially dangerous divided powers of r, put h=r/2. The positive +Hermite/Peano identity for the endpoint heights and gradients gives + + f_xxx(0)=12k+O(r K). + +Adding and subtracting the two endpoint expansions of f_x and f_z gives + + f_x(0)=-(r^2/8)f_xxx(0)+O(r^3K), + f_z(0)=-(r^2/8)f_xxz(0)+O(r^3K), + f_xx(0)=O(r^2K), f_xz(0)=O(r^2K). + +Expanding f at M and using its height b then yields + + f(0)-b=-(r^3/24)f_xxx(0)+O(r^4K) + =-k r^3/2+O(r^4K). + +Taylor remainders for derivatives of order 0,1,2 have sizes respectively r^4K, +r^3K,r^2K. After the coordinate and value rescaling each becomes O(rK). +This proves (L7). The term -a Z/8 is essential: omitting it violates the two +transverse gradient pins. The polynomial in (L6) itself satisfies both height and +both gradient pins exactly for arbitrary s,a,beta,c. + +The cubic (L4) is (L6) at + + s=-3k/2, a=0, beta=-2k, c=0. (L8) + +No exact degree-three assumption is imposed on the random field; (L7) controls +its higher-order terms on the event used below. + +## 4. A rare jet box with probability bounded below by a constant times r + +Use the nonsingular endpoint frame U_r of [RM, Section 2]. Its target v_r is bounded +and it converges to + + U_0=(f,f_x,f_xx,f_xxx,f_z,f_xz), v_0=(b,0,0,12k,0,0). + +Append the **physical**, not rescaled, vector + + J=(f_zz,f_xxz,f_xzz,f_zzz) at 0. (L9) + +At r=0, (U_0,J) consists of the ten independent planar jet entries of orders at +most three. The positive Fourier spectrum of the exact periodized Gaussian field +makes its covariance positive definite: a zero-variance combination annihilates +every Fourier mode, hence is a zero distribution; arbitrary smooth prescribed +jets at the site force all its coefficients to vanish. Frame rotation preserves +linear independence. Continuity and compactness in O(2) give a uniform positive +covariance floor through sufficiently small r>=0. The corresponding upper bound +is finite as well. + +It follows by a Schur complement that J under Q_r has a covariance sandwich and +bounded mean, uniformly in the compact marks and frame. Its Gaussian density is +therefore bounded **below** on any fixed compact target box. + +For a small fixed epsilon>0 let B_r be the target box + + |f_zz + (3k/2)r| < epsilon k r, + |f_xxz| < epsilon k, + |f_xzz + 2k| < epsilon k, + |f_zzz| < epsilon k. (L10) + +All these physical targets lie in a fixed compact box. Its Lebesgue volume is +16 epsilon^4 k^4 r, so + + Q_r{J in B_r} >= c_J r. (L11) + +The small factor r is attached to exactly one coordinate, f_zz. Treating the +rescaled coordinate f_zz/r as having a uniformly nondegenerate density would lose +this factor and would be wrong. + +## 5. Remainder control AFTER the rare jet restriction + +A bounded unconditioned moment is not enough to subtract a fixed tail error from +an event of probability order r. Instead regress the entire smooth field on the +joint observation vector (U_r,J), at each target (v_r,j) with j in B_r. + +For an unconditioned field copy F the usual regression representation is + + F(z)+Cov(F(z),V)Cov(V)^{-1}((v_r,j)-V), V=(U_r,J). + +The coefficient functions have uniformly bounded C^4 norms: derivatives of the +covariance kernel are bounded, the integral observation frames have uniformly +bounded derivative-covariance norms, and Cov(V)^{-1} is uniformly bounded. The +Gaussian Fourier series has finite moments of its C^4 norm. Targets are bounded. +The triangle and moment inequalities therefore give, for every fixed finite p, + + sup_{r,marks,frame,j in B_r} + E[||f||_{C^4}^p | U_r=v_r,J=j] < infinity. (L12) + +Choose a finite K large enough that Markov's inequality gives conditional +probability at least 1/2 to ||f||_{C^4}<=K at **every** such target. Integrating +this conditional probability against the jet density over B_r gives + + Q_r{J in B_r, ||f||_{C^4}<=K} >= (c_J/2)r. (L13) + +This uses a continuous Gaussian regular conditional kernel; it is not a claim of +independence between J and the field remainder. The rare event is retained before +any tail estimate is applied. + +## 6. Tilt and normalization: r times r^4 divided by r^2 + +Choose epsilon in (L10) so (L6) is within k epsilon_0/2 of (L4) on B(0,3), hence on B(0,2). +Then choose r_* small enough that the C r K error in (L7) is below the remaining +k_- epsilon_0/2 margin. On the event in (L13), the stability argument gives A_r. +Since H_f(rX)=r H_scaled(X) in dimension two, each physical endpoint determinant +is r^2 times its scaled determinant. Equation (L5) implies + + W_r >= c_W r^4 (L14) + +on that event, with c_W>0 uniform in the marks. + +The full normalizer satisfies 0= E_Qr[W_r 1{J in B_r, ||f||C4<=K}]/Z_r + >= (c_W c_J/(2C_Z)) r^3. (L15) + +For the upper bound sum [IW, (I5)] over indices and use +1{N_r>=2}<=N_r/2. This proves (L1). The inequalities +N_r(N_r-1)>=2*1{N_r>=2} and +Q_r^W{N_r>=1}<=E_Qr^W N_r<=C r^3 prove (L2) and (L3). + +## 7. Sharp obstruction to a global Bernoulli-configuration approximation + +Let Xi_r be the finite global window point process, retaining any of location, +index and normalized height as marks. Its mean measure mu_r has mass m_r<=C r^3, +so m_r<=1 for small r. Define Ber(mu_r) to be empty with probability 1-m_r and +otherwise a singleton with distribution mu_r/m_r. + +The elementary identity in the parallel singleton-law candidate [SL] is useful, +but we rederive it here so this corollary does not consume an unreviewed premise. +Write sigma for the singleton submeasure, eta for the mean measure on N>=2, +h=eta(S)=E[N;N>=2], alpha=P(N>=2), and s=P(N=1). The difference between Law Xi +and Ber(mu) has masses h-alpha on the empty stratum, minus the nonnegative +measure eta on the singleton stratum, and mass alpha on the multiple stratum. +Its full variation is 2h; therefore probability TV is exactly h. Applying (L1), + + c r^3 <= dTV(Law Xi_r,Ber(mu_r)) <= C r^3. (L16) + +Indeed h>=2P(N_r>=2) and h<=m_r. Thus the global exact-mean Bernoulli error is +of the **same order** as the global occurrence probability, unlike the remote +r^5 error. More generally, any probability law supported only on empty and +singleton configurations differs from Law Xi_r by at least c r^3, by testing +the event N>=2. Conditional on nonemptiness, its distance from every singleton +law is at least c_0 from (L3). No global factorial-moment upper bound was needed. + +## 8. What this closes and what it does not + +This supplies an existential, all-small-r lower mechanism for **local multiple +window saddles** under the original maximum/saddle determinant tilt. Together +with the existing first moment it fixes the global multiple-occurrence probability +order at r^3. It therefore rules out a proposed uniform extension of remote +single-point asymptotics to the whole torus. + +It does not give a global upper bound on the second factorial moment, a numerical +constant or cutoff, a global limit measure, or a distribution of persistence +partners. The weaker event A_r by itself does not determine elder pairing. The separate +ELDER_LOWER_AND_DENSITY_GAP.md uses the stronger specific jet-box event and an +explicit path to a point above the birth height to prove an elder-failure lower bound. No result for d>2, shrinking gap mark k, growing torus, random +selected spatial domain, or all-height count is asserted. The Gaussian jet-box and +stability arguments above are analytic proof obligations for a nonauthor reviewer; +the exact polynomial tests are not their substitute. diff --git a/frontiers/window_multiplicity_laws_20260928/SOURCE_MAP.json b/frontiers/window_multiplicity_laws_20260928/SOURCE_MAP.json new file mode 100644 index 000000000..01f090360 --- /dev/null +++ b/frontiers/window_multiplicity_laws_20260928/SOURCE_MAP.json @@ -0,0 +1,62 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "meaning": "Exact source identification is not theorem acceptance. Hosted default replay verifies consumed bytes; local packet-only replay does not.", + "sources": [ + { + "id": "RM", + "role": "consumed", + "repository": "d6g8k5htny-coder/Math-", + "commit": "5a5b97d2c518dd5c04c89d17029ec96e721d3b78", + "path": "frontiers/remote_window_20260924/PROOF.md", + "bytes": 18355, + "sha256": "a332bae9bdc0106ce17047f7e0409cc3d94eb610a0c7b74ba5ba2d01a1620cb7", + "git_blob": "b383bfcc88ec4ad497dff01fb6640e429ba24a84", + "consumed_scope": "Exact pins; positive Fourier spectrum; conditional moments; full normalizer; pointwise pre-height kernel; fixed-distance multi-witness density." + }, + { + "id": "RC", + "role": "consumed", + "repository": "d6g8k5htny-coder/Math-", + "commit": "5a5b97d2c518dd5c04c89d17029ec96e721d3b78", + "path": "frontiers/remote_collision_20260928/PROOF.md", + "bytes": 26002, + "sha256": "b9b8b58fd8266db7ffe6537078003888ef138b445d3289ec5588f116af9050c2", + "git_blob": "7b48a88e2af54e759e89a8c8219573bb450a65ea", + "consumed_scope": "Pair Kac-Rice; collision covariance floor; conditional moments; fixed-remote O(r^5) factorial bound." + }, + { + "id": "IW", + "role": "consumed", + "repository": "d6g8k5htny-coder/Math-", + "commit": "5a5b97d2c518dd5c04c89d17029ec96e721d3b78", + "path": "frontiers/intermediate_window_20260928/PROOF.md", + "bytes": 27775, + "sha256": "b3eb9456d7058b5b78149cfca4e072679beda85cd1a0293d209664a542db66cf", + "git_blob": "f53a527ce0204fda271f24730b62b4223a5e43ec", + "consumed_scope": "Planar global HEIGHT-WINDOW first moment (I5), only for the upper bound in the local multiplicity theorem." + }, + { + "id": "LP", + "role": "consumed", + "repository": "d6g8k5htny-coder/Math-", + "commit": "5a5b97d2c518dd5c04c89d17029ec96e721d3b78", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "bytes": 40261, + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "consumed_scope": "Exact ordinary elder-selector definition; upper half only of E4/E11 and the weighted radial density identity E9-E10. The direct lower E2 does not consume the parent upper theorem." + }, + { + "id": "SL", + "role": "context_only_not_consumed", + "repository": "d6g8k5htny-coder/Math-", + "commit": "8ab9498c3162db5f673607607582958e1468fae6", + "path": "frontiers/remote_singleton_law_20260928/PROOF.md", + "bytes": 13112, + "sha256": "f5bbdb0923f5dcdeeb21de7c624a08afe71ebd8c0b8c09e67152359ff544615a", + "git_blob": "2b01956978d7f1d917e929a955f2588263a87426", + "consumed_scope": "Parallel OpenAI candidate #115; generic mixture identities are independently displayed here. No independent acceptance is inherited." + } + ] +} diff --git a/reviews/d1_elder_lower_claude_20260928/RESULTS.json b/reviews/d1_elder_lower_claude_20260928/RESULTS.json new file mode 100644 index 000000000..931611ed1 --- /dev/null +++ b/reviews/d1_elder_lower_claude_20260928/RESULTS.json @@ -0,0 +1,44 @@ +{ + "checks": { + "G_cubic_critical_data": { + "M_hessian_diag_-6k_-k_over_2_max": true, + "S_hessian_diag_6k_-5k_over_2_saddle": true, + "extra_det_-15_over_2_saddle": true, + "extra_height_-7_over_32": true, + "extra_norm_sq_39_over_16_lt_4": true, + "extra_points_are_critical": true, + "floor_45_over_4_from_3_over_2_and_15_over_2": true, + "pin_gradients_zero": true, + "pins_heights_0_and_minus_k": true, + "weight_product_45k4": true + }, + "LED_ledgers": { + "box_volume_16_eps4_k4_r": true, + "loss_exponent_l_2_3_k_minus_5_3": true, + "radial_jacobian_r_dr": true, + "tilt_ledger_r_times_r4_over_r2_is_r3": true + }, + "NF_pinned_normal_form": { + "F_minus_P_is_O_r_generic_degree6": true, + "P_satisfies_all_six_pins_for_arbitrary_jets": true, + "target_jets_give_G_k": true + }, + "PATH_elder_obstruction": { + "g1_nonincreasing": true, + "g3_prime_ge_9_over_64": true, + "margin_end_above_quarter": true, + "margin_path_above_minus_quarter": true, + "path_end_17_over_64": true, + "path_in_B3": true, + "path_min_-7_over_32": true, + "segment_polynomials_E6": true + }, + "TV_multiplicity": { + "bernoulli_tv_equals_h_random_exact": true, + "counting_inequalities": true + } + }, + "passed": true, + "scientific_effect": "NONE", + "scope": "exact identities only; Gaussian jet-box, conditional C^4 and normalizer steps are argued in REVIEW.md" +} diff --git a/reviews/d1_elder_lower_claude_20260928/REVIEW.md b/reviews/d1_elder_lower_claude_20260928/REVIEW.md new file mode 100644 index 000000000..179c1e6d3 --- /dev/null +++ b/reviews/d1_elder_lower_claude_20260928/REVIEW.md @@ -0,0 +1,222 @@ +# Nonauthor analytic review: direct planar elder lower bound and local window multiplicity (Math-#116) + +Scientific effect: **NONE**. This file does not change `lemma_closed`, prizes, premises, `STATUS`, +`PROOF_INDEX`, `GRAPH`, the candidate registry or any author source. It records verdicts on candidates +C1 and C2 of `reviews/candidates_pending_20260928/CANDIDATES.md`. Integration is a separate act. + +## Object + +| Field | Value | +|---|---| +| Objects | OA-ELDER-LOWER-DENSITY-GAP-20260928-v1 and OA-WINDOW-MULTIPLICITY-LOCAL-20260928-v1 (OpenAI / ChatGPT) | +| Branch / head | `chatgpt/window-multiplicity-laws-20260928` / `0507e3a1dbd3dede84cbeb805947c70aa16ebc36` ([Math-#116](https://github.com/d6g8k5htny-coder/Math-/pull/116)) | +| `ELDER_LOWER_AND_DENSITY_GAP.md` | Git blob `aaefc8da9668e819591dd9db0b34442394f2362e`, 10229 B, SHA256 `8ce05a43bde8e0d718f09e2da1ffe75d3ec5893489254afdbf5b58b602cdba0c` | +| `LOCAL_MULTIPLICITY.md` | Git blob `b5c18aac5529c5f975ee5bb056b304debafc6697`, 13100 B, SHA256 `e6272e8709835ca6290fecb7034fa84832dde08c3c4cc990a48b8019e89e7c8d` | +| Consumed, already on main | [LP] `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md` (blob `dfed3b8d…`): §1 selector, §8 maximin, §§9–11 ledger, Theorem A. [IW] `frontiers/intermediate_window_20260928/PROOF.md` (blob `f53a527c…`): (I5). [RM] `frontiers/remote_window_20260924/PROOF.md` (blob `b383bfcc…`): frame and (11). | +| Request | [Owner comment 5877622700](https://github.com/d6g8k5htny-coder/Math-/pull/116#issuecomment-5877622700) | + +## Provenance + +| Field | Value | +|---|---| +| Reviewer | Anthropic Claude, Claude Code session `session_017Mi3hxjaxV45x6zo6o1ee3` | +| Relation | Different provider from the OpenAI author. Same GitHub account as every lane, so no organizational independence is claimed. | +| Exposure | I read both modules in full, the #116 README, SOURCE_MAP and PUBLICATION records, and LP §§1, 8–11. I wrote the #106 nonauthor review of LP Theorem A and the §9 repair, the #109 review of [IW], and the #110 remote-collision proof [RC]. The upper halves of (E4), (E11) and (L1) consume objects I reviewed or wrote, so for those halves this review is **not** independent of its inputs. The direct lower halves (E2) and (L1)-lower consume none of them. | +| Author code | The author's `algebra.py` is absent from the PR tree, as `PUBLICATION.json` discloses. **I did not run it and do not claim any execution of it.** | +| Independent checks | `elder_lower_exact_check.py` is my own exact-rational suite, written from the markdown. It checks only finite identities. Every Gaussian step below was argued by hand and is not replaced by those checks. | + +## Verdicts + +The lower result (E2) is judged separately from the parent-dependent (E4) and (E11), as requested. + +| Interface | Verdict | +|---|---| +| (E1) ordinary maximin elder definition and the path obstruction | **ACCEPT**. It is LP §8's definition verbatim; see §1. | +| (E5)–(E6) three-segment path, min `-7k/32`, end `+17k/64`, `k/64` margins | **ACCEPT**. Hand-derived; exact check `PATH_*`. | +| (E7) = (L6)–(L8) pinned normal form, including `-aZ/8` | **ACCEPT**. Hand-derived; exact check on a generic degree-6 field with the pins solved. | +| (L9)–(L11) ten-jet Schur floor through `r = 0`; box mass `>= c r` | **ACCEPT**; see §3. | +| (L12)–(L13) `C^4` control **after** conditioning on the physical jets | **ACCEPT**; see §4. | +| (L5), (L14) `W_r >= c r^4`; full `Z_r <= C r^2`; (E8)/(L15) ledger `r·r^4/r^2` | **ACCEPT**; see §5. | +| **Theorem E1, (E2)–(E3)**: `1 - p_r >= c r^3`, d = 2 | **ACCEPT** at its stated existential scope. | +| **Corollary E2, (E4)**: `c r^3 <= 1 - p_r <= C r^3` | **ACCEPT** as a composition with LP Theorem A, accepted at existential scope in [Math-#106](https://github.com/d6g8k5htny-coder/Math-/pull/106). | +| (E9)–(E11) compact-window loss `Θ(ℓ^{2/3})` | **ACCEPT** as a composition with LP §§9–11 and (E4); see §6. | +| **Theorem L, (L1)**: `c r^3 <= Q^W(A_r) <= Q^W{N_r >= 2} <= C r^3` | **ACCEPT**. The lower bound is direct. The upper bound uses the merged (I5). | +| (L2), (L3) | **ACCEPT** | +| §7, (L16) Bernoulli comparison `TV = h` | **ACCEPT**. Hand-derived; checked exactly on random finite laws. | + +No defect was found. Notes N1–N5 below record observations that strengthen or delimit the text without changing it. + +--- + +## §1 — the obstruction (E1) and why it suffices + +LP §8 defines the ordinary superlevel death height of a local maximum `M` as the maximin `(E1)`, with the empty +supremum for a global maximum. On the generic locus the elder partner of `M` is the unique critical point at height +`d_f(M)`. `S` has height `f(S)`, and critical values are almost surely distinct. So `d_f(M) > f(S)` forces the partner +to differ from `S`. A single admissible path supplies that lower bound: it must end strictly above `f(M) = b` and stay +strictly above `f(S)`. No gradient-flow, separatrix or saddle-connection statement is used, and none is needed. The +event has positive probability, and the generic locus has full measure, so the intersection costs nothing. + +## §2 — the cubic, the path and the normal form + +**Cubic.** For `G_k = k(2X^3 - 3X/2 - 1/2 - 3Z^2/4 - XZ^2)`, `∇G_k = k(6X^2 - 3/2 - Z^2, -(3/2 + 2X)Z)`, and +`G_xx = 12kX`, `G_xz = -2kZ`, `G_zz = -k(3/2 + 2X)`. At `M_* = (-1/2,0)` the Hessian is `diag(-6k,-k/2)` (maximum, +det `3k^2`). At `S_* = (1/2,0)` it is `diag(6k,-5k/2)` (saddle, det `-15k^2`). The heights are `0` and `-k`. The +extra points solve `X = -3/4`, `Z^2 = 15/8`. There `G = k(-27/32 + 9/8 - 1/2) = -7k/32`, `G_zz = 0`, and +det `= -4k^2 Z^2 = -15k^2/2`. Also `|P_±|^2 = 9/16 + 15/8 = 39/16 < 4`. + +**Path.** On `X = -3/4` the `Z`-terms cancel: `-3Z^2/4 - XZ^2 = 0`. So segment 2 is the level line `-7k/32`, and it +passes **through** the extra saddle `P_+` (`√(15/8) ≈ 1.369 < 9/4`). Segment 1 is +`g_1(v) = -3v^2/16 - v^3/32`, which is nonincreasing. Segment 3 has `g_3'(v) = (51 - 36v - 6v^2)/64 >= 9/64`. The +path minimum is `-7k/32` and the end value is `+17k/64`. With `‖F - G_k‖_∞ < k/64` on `B(0,3)` and the exact pin +`F(-1/2,0) = 0`, the path stays above `-15k/64 > -k/4` and ends above `k/4`. Physically, the path stays above +`b - kr^3/4`, ends above `b + kr^3/4 > b`, and `b - kr^3/4 - f(S) = 3kr^3/4`. This is (E3). + +**N1 (level region).** Segment 2 runs along a level line through a saddle of `G_k`. Under perturbation, that line +tilts and the saddle moves. The argument never uses the level or the saddle: it only uses the strict `C^0` margin +`k/64`, which survives every sub-`k/64` perturbation. The author's remark that the proof "does not rely on that level +remaining exactly constant" is therefore correct, and it is the reason the argument works. + +**Normal form (E7)/(L7).** Put `h = r/2`. Cubic Hermite interpolation of the axial data +`f(∓h) = b, b - kr^3` and `f_x(∓h) = 0` gives the leading coefficient `2k`, so `f_xxx(0) = 12k + O(rK)`. It also gives +`f(0) - b = -kr^3/2 + O(r^4 K)`. The half-sums and half-differences of the endpoint expansions of `f_x` and `f_z` +give `f_x(0) = -(r^2/8)f_xxx(0) + O(r^3K)` and `f_z(0) = -(r^2/8)f_xxz(0) + O(r^3K)`, with +`f_xx(0), f_xz(0) = O(r^2 K)`. After the rescaling `(f(rX,rZ) - b)/r^3`: + +- `f_x(0) X/r^2` becomes `-3kX/2`. +- `f_z(0) Z/r^2` becomes `-aZ/8`. +- The cubic terms become `2kX^3`, `(a/2)X^2Z`, `(β/2)XZ^2` and `(c/6)Z^3`. +- `f_zz(0) Z^2/(2r)` becomes `(s/2)Z^2`. +- Every other term is `O(rK)` in `C^2(B(0,3))`. + +This is (L6)–(L7). The `-aZ/8` term is exactly the `f_z(0)` contribution, so dropping it breaks both transverse +gradient pins at order one. The exact check solves the six pins on a generic degree-6 field and confirms +`F - P = O(r)` identically in the free coefficients. The `drop-aZ-over-8` mutant is rejected. + +## §3 — the ten-jet floor through `r = 0` and the box mass (L9)–(L11) + +At `r = 0` the endpoint frame is `U_0 = (f, f_x, f_xx, f_xxx, f_z, f_xz)` at the midpoint. Appending +`J = (f_zz, f_xxz, f_xzz, f_zzz)` gives all `1 + 2 + 3 + 4 = 10` planar jets of order `<= 3`, each exactly once. +A null combination `Σ c_α ∂^α f(0)` would make the polynomial `Σ c_α (iξ)^α` vanish on the whole dual lattice +`(2π/L)Z^2`, because every periodized Gaussian Fourier weight is positive. A nonzero polynomial of degree `<= 3` +cannot vanish on a two-dimensional lattice, so the covariance is positive definite. The divided-difference frame `U_r` is continuous in `r` up to `0` ([RM] §2, LP §3), and frames range +over compact `O(2)`. Hence the joint covariance of `(U_r, J)` has a uniform floor `λ_* > 0` and a uniform ceiling for +`0 <= r <= r_1`. + +By the Schur complement, `J | U_r = v_r` has covariance at least `λ_*` and mean `Cov(J,U)Σ_U^{-1} v_r`. That mean is +bounded because `v_r` is bounded. Its Gaussian density is therefore bounded below by some `ρ_* > 0` on any fixed +compact set. The target box (L10) lies in such a set. Its volume is `(2εkr)(2εk)^3 = 16ε^4k^4r` (exact check), so +`Q_r{J ∈ B_r} >= 16ρ_* ε^4 k_-^4 r`. + +The `r` comes only from the **physical** `f_zz` width `εkr`. Normalizing `f_zz/r` would cancel that factor +illegitimately. The author's warning about this is correct. + +## §4 — `C^4` control after the rare restriction (L12)–(L13) + +Condition on the joint vector `V = (U_r, J)` at a target `(v_r, j)` with `j ∈ B_r`. The regular conditional field is +`F + Cov(F,V)Σ_V^{-1}((v_r,j) - V)`, where `F` is an unconditioned copy. The kernel is real-analytic, and the +observations are divided differences of order `<= 3` (averages of derivatives). So each coefficient function +`Cov(F(·),V_i)` has a uniformly bounded `C^4` norm, and `Σ_V^{-1}` is uniformly bounded by §3. The targets are bounded. +Therefore +`E[‖f‖_{C^4}^p | V = (v_r,j)] <= C_p(1 + E‖F‖_{C^4}^p + E|V|^p)`, uniformly. Choose `K` by Markov so the conditional +probability of `{‖f‖_{C^4} <= K}` is at least `1/2` at **every** target. Integrating over the box gives +`Q_r{J ∈ B_r, ‖f‖_{C^4} <= K} >= (c_J/2) r`. + +This is the correct order of operations. Subtracting a fixed unconditioned tail from an event of mass `O(r)` would +fail. + +**N2 (constants).** The dependency chain is acyclic. `ε` fixes the box and `c_J(ε)`. `K` is uniform over all targets +with `ε <= 1`. `r_*` is then chosen from `ε` and `K`. The `C^0` gap between `P` and `G_k` on `B(0,3)` on the box is at +most `εk(9/2 + 111/8 + 27/2 + 9/2) < 37εk`, so `ε < 1/4800` suffices for a `k/128` share of the `k/64` budget. + +## §5 — tilt and normalizer (L5), (L14), (E8) + +`F(X,Z) = (f(rX,rZ) - b)/r^3` gives `∇²f = r ∇²F`. In `d = 2`, each physical determinant is `r^2` times the scaled one. +On the event, the scaled pinned Hessians are `C^2`-close to `diag(-6k,-k/2)` and `diag(6k,-5k/2)`, so both indices +persist. With the author's floors `3/2 k^2` and `15/2 k^2`, `W_r >= (45/4)k_-^4 r^4` (exact check: weight `45k^4` and +floor `45/4`). + +For the full normalizer, `f_x(M) = f_x(S) = 0` gives `∫_0^1 f_xx(M + t r e_1) dt = 0`, so `|f_xx(M)| <= r‖f‖_{C^3}`. +Likewise `f_z(M) = f_z(S) = 0` gives `|f_xz(M)| <= r‖f‖_{C^3}`. Hence +`|det H_M| <= 2r‖f‖_{C^2}‖f‖_{C^3}` and the same holds at `S`, so `W_r <= C r^2 (1 + ‖f‖_{C^3})^4`. The uniform `Q_r` +moments then give `Z_r <= C_Z r^2`. `Z_r > 0` because the event above has positive probability. The normalizer is +the **full** `E_{Q_r} W_r`, not a restricted one. The ledger is `r · r^4 / r^2 = r^3` (exact check, `weight-power` +mutant rejected). + +## §6 — composition (E4), (E9)–(E11) + +(E4)'s upper half is LP Theorem A, `1 - p_r <= C r^3` uniformly over `B × K × O(d)`. It is accepted at existential +scope in [Math-#106](https://github.com/d6g8k5htny-coder/Math-/pull/106), merged at `5eba8f7`. + +(E9) is LP (10.2) verbatim: `A_r = 12 π_r(v_r) Z_r/r^2`, with no factor `1/2`. LP (11.1) gives +`r dr/dℓ = (1/3)k^{-2/3}ℓ^{-1/3}` (exact check `radial_jacobian_r_dr`). Multiplying by `1 - p ≍ r^3 = ℓ/k` gives the +integrand order `ℓ^{2/3}k^{-5/3}` (exact check `loss_exponent_*`). The lower half uses (E2) and `inf A_r > 0`. The +upper half is LP §11's display. + +LP §§8–15 interfaces are accepted by the +[D1-A–E review](https://github.com/d6g8k5htny-coder/main/issues/63#issuecomment-5841570965). The §9 Borel repair is +accepted in #106 Part II. + +**N3 (sharpness of Theorem A in d = 2).** (E4) makes Theorem A's `r^3` rate sharp in order for `d = 2`, uniformly on +the compact marks. This **supersedes** the remark in my #106 review, where sharpness was restricted to the (6.1)/(6.2) +matrix relaxation. That restriction remains correct for the relaxation statement. The Gaussian rate itself is now +shown sharp by the direct event, not by the relaxation. Consequently LP's `O(ℓ^{2/3})` selection-density loss cannot +be improved to `o(ℓ^{2/3})` in `d = 2`. Nothing is said about `d > 2` or about the leading constant. + +## §7 — local multiplicity (L1)–(L3), (L16) + +Choose disjoint closed disks about `P_±` inside `B(0,2)`, away from `M_*` and `S_*`. By the implicit function theorem +applied to `∇G_1` at nondegenerate zeros, there is a `C^2` neighborhood with one saddle per disk and heights in +`(-1, 0)`. Positive scaling by `k` preserves critical points and indices, scales heights by `k` and determinants by +`k^2`. So the neighborhood is uniform over `[k_-, k_+]`, and on the §3–§5 event (with the smaller `ε` for `C^2`) both +witnesses exist with physical heights in `I_r`. This gives the lower half of (L1) with the same `r · r^4/r^2` +ledger. + +The upper half is `1{N >= 2} <= N/2` together with (I5) summed over indices. (I5) is merged +([Math-#107](https://github.com/d6g8k5htny-coder/Math-/pull/107) and my review in [Math-#109](https://github.com/d6g8k5htny-coder/Math-/pull/109)). (L2) follows from +`N(N-1) >= 2·1{N >= 2}`, and (L3) from dividing (L1) by `Q^W{N >= 1} <= C r^3` (exact check `counting_inequalities`). + +For (L16), write `σ` for the singleton submeasure, `η` for the mean measure on `{N >= 2}`, `h = η(S)` and +`α = P(N >= 2)`. Then `Law Ξ - Ber(μ)` has signed masses `h - α >= 0` on the empty stratum, `-η` on singletons and +`α` on multiples. The total variation is `2h`, so the probability TV is exactly `h`, and `2α <= h <= m_r`. Because `-η` has one +sign, its variation is its mass, so the check may aggregate the singleton stratum. It verifies `TV = h` on 1000+ +random exact count laws with a nontrivial multiple stratum. The `tv-half` mutant is +rejected. + +**N4 (the #110 scope).** (L1)–(L2) show that a torus-wide `O(r^5)` factorial bound is false. This confirms that the +fixed-radius `D_ρ` restriction in the merged remote-collision proof ([Math-#110](https://github.com/d6g8k5htny-coder/Math-/pull/110)) +was necessary, not a proof convenience. There is no conflict: `A_r` occurs within distance `O(r)` of the pins. + +**N5 (one box, two conclusions).** The same jet box, intersected with the smaller `C^2` neighborhood, carries both +(E3) and `A_r`. This does not mean every two-saddle configuration defeats the elder pairing, and the source does not +claim that (LOCAL §8: "`A_r` by itself does not determine elder pairing"). + +## Checks run + +``` +python3 -B -S elder_lower_exact_check.py # rc 0, stdout == RESULTS.json +python3 -B -O -S elder_lower_exact_check.py # rc 0, byte-identical +python3 -B -S elder_lower_exact_check.py --mutant drop-aZ-over-8 # rc 1 +python3 -B -S elder_lower_exact_check.py --mutant hessian-sign # rc 1 +python3 -B -S elder_lower_exact_check.py --mutant path-endpoint # rc 1 +python3 -B -S elder_lower_exact_check.py --mutant weight-power # rc 1 +python3 -B -S elder_lower_exact_check.py --mutant tv-half # rc 1 +``` + +Python standard library only. The workflow `.github/workflows/elder-lower-review.yml` verifies the packet tree against +`SOURCE_FILES.json`, replays both modes and requires every mutant to be rejected. + +## Not established here + +- `REMOTE_PAIR_LAW.md`, `REMOTE_DISTANCE_MOMENTS.md`, `HEIGHT_MARKS.md` (C3–C5). The owner routed these to Grok/Harper. +- Numerical `c`, `r_*`, or any leading constant. The results are existential. +- `d > 2`, a shrinking gap mark, a growing torus, all-height counts, or a global second factorial moment upper bound + (C6). +- A runnable reproduction of the author's suite. It is absent from the tree and was not run. +- Organizational independence: all lanes share one GitHub account. + +A non-Claude review of §§3–5 (the Gaussian steps) remains welcome before any status integration. + +## Revision history + +- **v1**, reviewing head `0507e3a`: initial packet. diff --git a/reviews/d1_elder_lower_claude_20260928/SOURCE_FILES.json b/reviews/d1_elder_lower_claude_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..33a83598f --- /dev/null +++ b/reviews/d1_elder_lower_claude_20260928/SOURCE_FILES.json @@ -0,0 +1,43 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW", + "reviewed_object": { + "pr": "d6g8k5htny-coder/Math-#116", + "head": "0507e3a1dbd3dede84cbeb805947c70aa16ebc36", + "paths": [ + { + "path": "frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md", + "git_blob": "aaefc8da9668e819591dd9db0b34442394f2362e", + "bytes": 10229, + "sha256": "8ce05a43bde8e0d718f09e2da1ffe75d3ec5893489254afdbf5b58b602cdba0c" + }, + { + "path": "frontiers/window_multiplicity_laws_20260928/LOCAL_MULTIPLICITY.md", + "git_blob": "b5c18aac5529c5f975ee5bb056b304debafc6697", + "bytes": 13100, + "sha256": "e6272e8709835ca6290fecb7034fa84832dde08c3c4cc990a48b8019e89e7c8d" + } + ] + }, + "files": [ + { + "path": "REVIEW.md", + "bytes": 16640, + "sha256": "53bd5289a2060ce6c906023ed09a5aec457313e782135e1df86e743941839495", + "git_blob": "179c1e6d3d4005b2e406b1bd4d9584caf5465793" + }, + { + "path": "elder_lower_exact_check.py", + "bytes": 14334, + "sha256": "f46409953e138147211d2fdf9fd9cddcd757c7cf6d4867b01b04691d0559a654", + "git_blob": "b35cf96a977f3048efafb5bbc74e397037a91ace" + }, + { + "path": "RESULTS.json", + "bytes": 1487, + "sha256": "4a431a8a3fa1527339aa25bac3f1ff22168529aadbb45e437add2257d58e35aa", + "git_blob": "931611ed14c4d210aa8e579c9e5c8b732fcaea61" + } + ] +} diff --git a/reviews/d1_elder_lower_claude_20260928/elder_lower_exact_check.py b/reviews/d1_elder_lower_claude_20260928/elder_lower_exact_check.py new file mode 100644 index 000000000..b35cf96a9 --- /dev/null +++ b/reviews/d1_elder_lower_claude_20260928/elder_lower_exact_check.py @@ -0,0 +1,383 @@ +"""Independent exact checks for the nonauthor review of Math-#116's direct elder lower bound +(ELDER_LOWER_AND_DENSITY_GAP.md) and local multiplicity module (LOCAL_MULTIPLICITY.md). + +Python standard library only; exact rational / Laurent-polynomial arithmetic. Written without the +author's (unpublished) algebra.py. Groups: + + NF (E7)/(L6)-(L7): a GENERIC degree-six planar field with the six actual pins solved exactly + satisfies (f(rX,rZ)-b)/r^3 = P_{k,s,a,beta,c} + O(r) with s=f_zz(0)/r, including -aZ/8; + P itself satisfies all six pins for arbitrary (s,a,beta,c); dropping -aZ/8 breaks them. + G G_k: pins, the four critical points, heights, Hessians, determinants, |P_pm|^2 = 39/16. + PATH the three segment polynomials (E6), their monotonicity, min -7k/32, end +17k/64, the k/64 + margins, and containment in B(0,3). + LED weight 45k^4 and floor 45/4, box volume 16 eps^4 k^4 r, tilt ledger r*r^4/r^2 = r^3, + radial Jacobian r dr = (1/3) l^(-1/3) k^(-2/3) dl and the loss exponent l^(2/3) k^(-5/3). + TV the exact Bernoulli-comparison total variation h on random exact laws, and the counting + inequalities 1{N>=2} <= N/2, N(N-1) >= 2*1{N>=2}. + +Not a continuum or Gaussian proof: the jet-box density floor, conditional C^4 control and the +normalizer bound are argued in REVIEW.md. +""" +import argparse +import itertools +import json +import random +import sys +from fractions import Fraction as F + + +def _mono_mul(a, b): + d = dict(a) + for v, e in b: + n = d.get(v, 0) + e + if n: + d[v] = n + else: + d.pop(v, None) + return tuple(sorted(d.items())) + + +class P: + __slots__ = ("t",) + + def __init__(self, t=None): + self.t = {m: c for m, c in (t or {}).items() if c != 0} + + @staticmethod + def c(x): + return P({(): F(x)}) + + @staticmethod + def v(name, e=1): + return P({((name, e),): F(1)}) + + @staticmethod + def lift(o): + return o if isinstance(o, P) else P.c(o) + + def __add__(self, o): + o = P.lift(o) + t = dict(self.t) + for m, c in o.t.items(): + t[m] = t.get(m, 0) + c + return P(t) + + __radd__ = __add__ + + def __neg__(self): + return P({m: -c for m, c in self.t.items()}) + + def __sub__(self, o): + return self + (-P.lift(o)) + + def __rsub__(self, o): + return P.lift(o) - self + + def __mul__(self, o): + o = P.lift(o) + t = {} + for m1, c1 in self.t.items(): + for m2, c2 in o.t.items(): + m = _mono_mul(m1, m2) + t[m] = t.get(m, 0) + c1 * c2 + return P(t) + + __rmul__ = __mul__ + + def __pow__(self, n): + out = P.c(1) + for _ in range(n): + out = out * self + return out + + def is_zero(self): + return not self.t + + def d(self, name): + t = {} + for m, c in self.t.items(): + dm = dict(m) + e = dm.get(name, 0) + if e == 0: + continue + if e == 1: + dm.pop(name) + else: + dm[name] = e - 1 + key = tuple(sorted(dm.items())) + t[key] = t.get(key, 0) + c * e + return P(t) + + def antider(self, name): + t = {} + for m, c in self.t.items(): + dm = dict(m) + e = dm.get(name, 0) + if e == -1: + raise ValueError("log term") + dm[name] = e + 1 + key = tuple(sorted(dm.items())) + t[key] = t.get(key, 0) + c / (e + 1) + return P(t) + + def subs(self, name, q): + q = P.lift(q) + out = P() + for m, c in self.t.items(): + dm = dict(m) + e = dm.pop(name, 0) + if e < 0: + raise ValueError("negative power substitution") + rest = P({tuple(sorted(dm.items())): c}) + out = out + rest * (q ** e) + return out + + def integrate(self, name, lo, hi): + a = self.antider(name) + return a.subs(name, hi) - a.subs(name, lo) + + def coeff(self, name, e): + """Coefficient of name^e (as a polynomial in the other variables).""" + t = {} + for m, c in self.t.items(): + dm = dict(m) + if dm.get(name, 0) != e: + continue + dm.pop(name, None) + key = tuple(sorted(dm.items())) + t[key] = t.get(key, 0) + c + return P(t) + + def exponents(self, name): + return sorted({dict(m).get(name, 0) for m in self.t}) + + +def det(M): + n = len(M) + total = P() + for perm in itertools.permutations(range(n)): + inv = sum(1 for i in range(n) for j in range(i + 1, n) if perm[i] > perm[j]) + term = P.c(-1 if inv % 2 else 1) + for i in range(n): + term = term * M[i][perm[i]] + total = total + term + return total + + +def adj(M): + n = len(M) + out = [[P() for _ in range(n)] for _ in range(n)] + for i in range(n): + for j in range(n): + minor = [[M[a][b] for b in range(n) if b != j] for a in range(n) if a != i] + cof = det(minor) if minor else P.c(1) + out[j][i] = cof if (i + j) % 2 == 0 else -cof + return out + + +def at(p, X1, X2): + return p.subs("x", X1).subs("z", X2) + + +def hermite(gm, gp, dgm, dgp, a, ainv): + s0 = (gm + gp) * F(1, 2) + d0 = (gp - gm) * ainv * F(1, 2) + s1 = (dgm + dgp) * F(1, 2) + d1 = (dgp - dgm) * ainv * F(1, 2) + return s0 - a * a * d1 * F(1, 2), (3 * d0 - s1) * F(1, 2), d1, 3 * (s1 - d0) * ainv * ainv + + +def pinned_generic(deg=6): + x, z = P.v("x"), P.v("z") + f = P() + for i in range(deg + 1): + for j in range(deg + 1 - i): + f = f + P.v("c%d%d" % (i, j)) * x ** i * z ** j + R, RI = P.v("r"), P.v("r", -1) + a, ai = R * F(1, 2), 2 * RI + b, k = P.v("b"), P.v("k") + h = sum((P.v("c%d0" % i) * x ** i for i in range(4, deg + 1)), P()) + q = sum((P.v("c%d1" % i) * x ** i for i in range(2, deg)), P()) + Ht = hermite(b, b - k * R ** 3, P.c(0), P.c(0), a, ai) + hh = hermite(h.subs("x", -a), h.subs("x", a), h.d("x").subs("x", -a), h.d("x").subs("x", a), a, ai) + sol = { + "c00": Ht[0] - hh[0], "c10": Ht[1] - hh[1], + "c20": (Ht[2] - hh[2]) * F(1, 2), "c30": (Ht[3] - hh[3]) * F(1, 6), + "c01": -(q.subs("x", a) + q.subs("x", -a)) * F(1, 2), + "c11": -(q.subs("x", a) - q.subs("x", -a)) * ai * F(1, 2), + } + for nm, val in sol.items(): + f = f.subs(nm, val) + return f + + +def Ppoly(X, Z, k, s, a, beta, c, mut): + lin = F(0) if mut == "drop-aZ-over-8" else F(1) + return (2 * k * X ** 3 - F(3, 2) * k * X - k * F(1, 2) + s * F(1, 2) * Z * Z + + a * F(1, 2) * (X * X - lin * F(1, 4)) * Z + beta * F(1, 2) * X * Z * Z + c * F(1, 6) * Z ** 3) + + +def check_nf(mut): + out = {} + R = P.v("r") + f = pinned_generic() + X, Z = P.v("X"), P.v("Z") + b, k = P.v("b"), P.v("k") + Fsc = (at(f, R * X, R * Z) - b) * P.v("r", -3) + s = 2 * P.v("c02") * P.v("r", -1) + a, beta, c = 2 * P.v("c21"), 2 * P.v("c12"), 6 * P.v("c03") + Pp = Ppoly(X, Z, k, s, a, beta, c, mut) + diff = Fsc - Pp + ex = diff.exponents("r") + out["F_minus_P_is_O_r_generic_degree6"] = (not ex) or min(ex) >= 1 + # P satisfies all six pins for arbitrary (s,a,beta,c) (scaled pins: F(-1/2,0)=0, F(1/2,0)=-k, grad=0). + ss, aa, bb, cc = P.v("s"), P.v("a"), P.v("bt"), P.v("cc") + Pg = Ppoly(X, Z, k, ss, aa, bb, cc, mut) + ev = lambda p, u, w: p.subs("X", P.c(u)).subs("Z", P.c(w)) + pins = [ev(Pg, F(-1, 2), 0), ev(Pg, F(1, 2), 0) + k, + ev(Pg.d("X"), F(-1, 2), 0), ev(Pg.d("X"), F(1, 2), 0), + ev(Pg.d("Z"), F(-1, 2), 0), ev(Pg.d("Z"), F(1, 2), 0)] + out["P_satisfies_all_six_pins_for_arbitrary_jets"] = all(p.is_zero() for p in pins) + # Target jets give G_k. + Gk = k * (2 * X ** 3 - F(3, 2) * X - F(1, 2) - F(3, 4) * Z * Z - X * Z * Z) + Pt = Ppoly(X, Z, k, -F(3, 2) * k, P.c(0), -2 * k, P.c(0), mut) + out["target_jets_give_G_k"] = (Pt - Gk).is_zero() + return out + + +def check_g(mut): + out = {} + k = F(1) + G = lambda X, Z: k * (2 * X ** 3 - F(3, 2) * X - F(1, 2) - F(3, 4) * Z * Z - X * Z * Z) + GX = lambda X, Z: k * (6 * X * X - F(3, 2) - Z * Z) + GZ = lambda X, Z: -k * (F(3, 2) + 2 * X) * Z + hess = lambda X, Z: (12 * k * X, -2 * k * Z, k * (-F(3, 2) - 2 * X)) + out["pins_heights_0_and_minus_k"] = G(F(-1, 2), 0) == 0 and G(F(1, 2), 0) == -k + out["pin_gradients_zero"] = all(GX(u, 0) == 0 and GZ(u, 0) == 0 for u in (F(-1, 2), F(1, 2))) + hm, hs = hess(F(-1, 2), 0), hess(F(1, 2), 0) + sgn = -1 if mut == "hessian-sign" else 1 + out["M_hessian_diag_-6k_-k_over_2_max"] = hm == (sgn * -6 * k, 0, -k / 2) and hm[0] < 0 and hm[2] < 0 + out["S_hessian_diag_6k_-5k_over_2_saddle"] = hs == (6 * k, 0, -F(5, 2) * k) + # Extra critical points: X=-3/4, Z^2 = 15/8 (use z2 in place of Z^2; Z only enters via Z^2 or Z*Z). + z2 = F(15, 8) + Xp = F(-3, 4) + out["extra_points_are_critical"] = (6 * Xp * Xp - F(3, 2) - z2 == 0) and (F(3, 2) + 2 * Xp == 0) + height = 2 * Xp ** 3 - F(3, 2) * Xp - F(1, 2) - (F(3, 4) + Xp) * z2 + out["extra_height_-7_over_32"] = height == F(-7, 32) and -1 < height < 0 + det_extra = (12 * Xp) * (-F(3, 2) - 2 * Xp) - 4 * z2 + out["extra_det_-15_over_2_saddle"] = det_extra == F(-15, 2) + out["extra_norm_sq_39_over_16_lt_4"] = Xp * Xp + z2 == F(39, 16) and Xp * Xp + z2 < 4 + out["weight_product_45k4"] = abs(hm[0] * hm[2]) * abs(hs[0] * hs[2]) == 45 + out["floor_45_over_4_from_3_over_2_and_15_over_2"] = F(3, 2) * F(15, 2) == F(45, 4) + return out + + +def check_path(mut): + out = {} + v = P.v("v") + k = F(1) + Gp = lambda X, Z: (2 * X ** 3 - F(3, 2) * X - F(1, 2) - F(3, 4) * Z * Z - X * Z * Z) * k + last = (F(-1), F(2)) if mut == "path-endpoint" else (F(-1), F(9, 4)) + V = [(F(-1, 2), F(0)), (F(-3, 4), F(0)), (F(-3, 4), F(9, 4)), last] + segs = [] + for (x0, z0), (x1, z1) in zip(V, V[1:]): + X = x0 + (x1 - x0) * v + Z = z0 + (z1 - z0) * v + segs.append(Gp(X, Z)) + want = [-F(3, 16) * v ** 2 - F(1, 32) * v ** 3, P.c(F(-7, 32)), + F(-7, 32) + F(51, 64) * v - F(9, 32) * v ** 2 - F(1, 32) * v ** 3] + out["segment_polynomials_E6"] = all((s - w).is_zero() for s, w in zip(segs, want)) + ev = lambda p, t: p.subs("v", P.c(t)).t.get((), F(0)) + g1p, g3p = segs[0].d("v"), segs[2].d("v") + grid = [F(i, 400) for i in range(401)] + out["g1_nonincreasing"] = all(ev(g1p, t) <= 0 for t in grid) and ev(segs[0].d("v").d("v"), F(0)) <= 0 + # g3' is a decreasing quadratic on [0,1] (g3'' = -9/16 - 3v/16 < 0), so its minimum is g3'(1). + out["g3_prime_ge_9_over_64"] = ev(g3p, F(1)) == F(9, 64) and all(ev(g3p.d("v"), t) < 0 for t in grid) + vals = [ev(s, t) for s in segs for t in grid] + out["path_min_-7_over_32"] = min(vals) == F(-7, 32) + out["path_end_17_over_64"] = ev(segs[2], F(1)) == F(17, 64) + out["margin_path_above_minus_quarter"] = F(-7, 32) - F(1, 64) == F(-15, 64) and F(-15, 64) > F(-1, 4) + out["margin_end_above_quarter"] = F(17, 64) - F(1, 64) == F(1, 4) + out["path_in_B3"] = max(x * x + z * z for x, z in V) == F(97, 16) and F(97, 16) < 9 + return out + + +def check_led(mut): + out = {} + eps, k, r = P.v("eps"), P.v("k"), P.v("r") + vol = (2 * eps * k * r) * (2 * eps * k) ** 3 + out["box_volume_16_eps4_k4_r"] = (vol - 16 * eps ** 4 * k ** 4 * r).is_zero() + wpow = 3 if mut == "weight-power" else 4 + out["tilt_ledger_r_times_r4_over_r2_is_r3"] = 1 + wpow - 2 == 3 + # Radial Jacobian with k = t^3 and r = q (so l = k r^3 = t^3 q^3, l^(1/3) = t q): + # r dr = q dq, dl = 3 t^3 q^2 dq => r dr / dl = 1/(3 t^3 q); (1/3) l^(-1/3) k^(-2/3) = 1/(3 t q t^2). + t, q = P.v("t"), P.v("q") + lhs = q * P.v("t", -3) * P.v("q", -2) * F(1, 3) # r dr / dl = q / (3 t^3 q^2) + rhs = F(1, 3) * P.v("t", -1) * P.v("q", -1) * P.v("t", -2) + out["radial_jacobian_r_dr"] = (lhs - rhs).is_zero() + # Loss: l^(-1/3) k^(-2/3) * (1-p ~ r^3 = l/k): exponents of (l, k) = (-1/3 + 1, -2/3 - 1). + le, ke = F(-1, 3) + 1, F(-2, 3) - 1 + out["loss_exponent_l_2_3_k_minus_5_3"] = (le, ke) == (F(2, 3), F(-5, 3)) + return out + + +def check_tv(mut): + rng = random.Random(116) + ok_tv, ok_cnt = True, True + nontrivial = 0 + for _ in range(2000): + # A random law of the count N in {0..6} with mean m <= 1 (heavy mass at N = 0). + pN = [F(rng.randrange(300, 1000))] + [F(rng.randrange(0, 30)) for _ in range(6)] + tot = sum(pN) + pN = [x / tot for x in pN] + m = sum(n * pN[n] for n in range(7)) + if m > 1: + continue + s1 = pN[1] + h = sum(n * pN[n] for n in range(2, 7)) + alpha = sum(pN[n] for n in range(2, 7)) + # Law minus Bernoulli(mean): empty (1-m) vs P(N=0); singleton mean mass s1+h vs s1; multiples alpha. + diff_empty = pN[0] - (1 - m) + diff_single = s1 - (s1 + h) + diff_mult = alpha + tv = (abs(diff_empty) + abs(diff_single) + abs(diff_mult)) / 2 + target = h if mut != "tv-half" else h / 2 + ok_tv &= tv == target and h >= 2 * alpha + nontrivial += h > 0 + for N in range(40): + ok_cnt &= F(int(N >= 2)) <= F(N, 2) and N * (N - 1) >= 2 * int(N >= 2) + return {"bernoulli_tv_equals_h_random_exact": ok_tv and nontrivial >= 1000, + "counting_inequalities": ok_cnt} + + +MUTANTS = ("drop-aZ-over-8", "hessian-sign", "path-endpoint", "weight-power", "tv-half") + + +def flatten(d): + for v in d.values(): + if isinstance(v, dict): + yield from flatten(v) + else: + yield v + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + mut = ap.parse_args().mutant + groups = { + "NF_pinned_normal_form": check_nf(mut), + "G_cubic_critical_data": check_g(mut), + "PATH_elder_obstruction": check_path(mut), + "LED_ledgers": check_led(mut), + "TV_multiplicity": check_tv(mut), + } + passed = all(flatten(groups)) + res = {"checks": groups, "passed": passed, "scientific_effect": "NONE", + "scope": "exact identities only; Gaussian jet-box, conditional C^4 and normalizer steps are argued in REVIEW.md"} + sys.stdout.write(json.dumps(res, indent=2, sort_keys=True) + "\n") + return 0 if passed else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/reviews/p15_overlap_tail_claude_20260928/RESULTS.json b/reviews/p15_overlap_tail_claude_20260928/RESULTS.json new file mode 100644 index 000000000..60cec87c3 --- /dev/null +++ b/reviews/p15_overlap_tail_claude_20260928/RESULTS.json @@ -0,0 +1,51 @@ +{ + "checks": { + "COL_colouring": { + "E4_triangle_shared_4_full_5": true, + "bipartite_arbitrary_capacity_formula_equals_oracle": true, + "doubled_triangle_capacity_one_chi_6_formula_4": true, + "read_two_nonbipartite_even_capacity_formula_equals_oracle": true + }, + "HAZ_product_hazards": { + "overlap_5_8_exceeds_9_16_and_CS": true, + "read_q_product_inequality_arbitrary_events": true, + "two_sided_cauchy_schwarz_bipartite": true, + "weighted_load_sum_not_max": true + }, + "OBS_obstruction_cover": { + "O4_exact_obstruction_equals_active_full_blocks": true, + "chi_whole_ground_K_plus_1": true, + "duplicate_and_superset_removal_keeps_cover": true, + "inactive_full_block_not_obstruction": true + }, + "TAIL_reference_tails": { + "512_25_exceeds_87_32_cubed": true, + "R1_a3_markov_insufficient_direct_tail_below_q9": true, + "R1_a3_monotone_in_trials": true, + "R1_odd_a_ge_5_markov_below_q9": true, + "T15_interval_directions": true, + "T15_margins_exact": true, + "a1_monotone_in_trials": true, + "capacity_one_tail_q5_exceeds_q9": true, + "e_bounds_consistent_with_tight": true, + "e_bounds_series": true, + "exp_7_3_certificate": true, + "log2_above_2_3": true, + "markov_chain_a_ge_2_and_a_ge_4": true, + "q5_above_25_512_margin": true, + "q5_polynomial_identity": true, + "q9_polynomial_identity": true, + "rho_9_inside_T2": true, + "rho_bip_inside_O12": true, + "s_below_half_from_e_above_8_3": true, + "uniform_even_tail_max_only_at_a2_K4": true + }, + "TRANS_local_transfer": { + "decreasing_event_affine_nonneg_coefficients": true, + "separate_concavity_chord_decimal60": true + } + }, + "passed": true, + "scientific_effect": "NONE", + "scope": "exact identities, brute-force colouring oracle and exact product-measure inequalities on finite instances; one 60-digit decimal check; the continuum arguments are in REVIEW.md" +} diff --git a/reviews/p15_overlap_tail_claude_20260928/REVIEW.md b/reviews/p15_overlap_tail_claude_20260928/REVIEW.md new file mode 100644 index 000000000..29ec33677 --- /dev/null +++ b/reviews/p15_overlap_tail_claude_20260928/REVIEW.md @@ -0,0 +1,240 @@ +# Nonauthor analytic review: P15 overlapping blocks (Math-#118) and sharp even tail with weighted loads (Math-#122) + +Scientific effect: **NONE**. This file does not change `lemma_closed`, prizes, premises, `STATUS`, +`PROOF_INDEX`, `GRAPH` or any author source. It records verdicts on two author-side P15 candidates and one +reviewer remark (R1). Integration is a separate act. + +## Objects + +| Field | Value | +|---|---| +| #118 object | OA-P15-BIPARTITE-OVERLAP-20260928-v1 and OA-P15-EVEN-READ-TWO-20260928-v1 (OpenAI / ChatGPT) | +| #118 head | `chatgpt/p15-overlap-20260928` / `23b7558943f69a7f479251566b19ba58e75cfc26` ([Math-#118](https://github.com/d6g8k5htny-coder/Math-/pull/118)) | +| #118 `PROOF.md` | Git blob `8ad826ecb374cc733e3a547bdba0ba63cad10c08`, 13835 B, SHA256 `21ce7a29ac0971919c0602f556f1aeba48bb14fffd4193864b3f482185bc1698` | +| #118 `EVEN_CAPACITY_EXTENSION.md` | Git blob `ce21e424433100d0307c49bc15cccc748f9438fc`, 7620 B, SHA256 `d28aa700ba83ca139b7b29b6ff06cc39c725470b710af10728867ec10c8ca985` | +| #122 object | OA-P15-TAIL-LOAD-20260928-v1 (OpenAI / ChatGPT) | +| #122 head | `chatgpt/p15-tail-load-20260928` / `245f3d77c9d38f49d13affb9563a266eba92a47b` ([Math-#122](https://github.com/d6g8k5htny-coder/Math-/pull/122)) | +| #122 `PROOF.md` | Git blob `8187908dfd220cb833b94f82c451ef4c0e45e367`, 12828 B, SHA256 `fbca462d4988a06754ded9415ceea6bb1385be5535656d643bdd48edbbee8a20` | +| Requests | [#118 comment 5878164407](https://github.com/d6g8k5htny-coder/Math-/pull/118#issuecomment-5878164407), [#122 comment 5879215663](https://github.com/d6g8k5htny-coder/Math-/pull/122#issuecomment-5879215663) | +| Prior review | OpenAI same-provider review of #118, [5344833684](https://github.com/d6g8k5htny-coder/Math-/pull/118#pullrequestreview-5344833684): no blocker. #122 is its additive follow-up. | + +## Provenance + +| Field | Value | +|---|---| +| Reviewer | Anthropic Claude, Claude Code session `session_017Mi3hxjaxV45x6zo6o1ee3` | +| Relation | Different provider from the OpenAI author. Same GitHub account as every lane, so no organizational independence is claimed. | +| Exposure | I read all three proof files in full, both READMEs, RECONNAISSANCE and SOURCE_MAP files, and the OpenAI review above. I did not write or earlier review `frontiers/full_price_20260924/PROOF.md` or any P15 source. | +| Author code | Replayed from `git archive` of each head: #118 `run_validation.py` passes 29 tests and rejects 10 mutants per mode, with identical output pairs. #122 `verify.py --output ` passes 15 tests and rejects 7 mutants per mode, with 8 identical pairs. | +| Independent checks | `p15_exact_check.py` is my own suite. Its colouring oracle is a plain backtracking search over colour assignments of the original coordinates, not the authors' constructions. It covers 34 checks and 7 mutants. Finite checks do not prove the continuum steps argued below. | + +## Verdicts + +### Math-#118 + +| Interface | Verdict | +|---|---| +| (O1)–(O2) Theorem O1: exact colouring on bipartite overlap with arbitrary capacities | **ACCEPT** | +| (O3)–(O4) Corollary O2: active full blocks form a cover, and their inclusion-minimal distinct members are exactly the minimal `K`-obstructions (an active block containing another is not minimal; see §2); `χ_D(X) = K+1` | **ACCEPT** | +| (O5) separate-concavity price-to-hazard transfer | **ACCEPT** | +| (O6)–(O7) Lemma O3: uniform tail `<= q_5` for all `a >= 1` | **ACCEPT** | +| (O8)–(O10) two-sided Cauchy–Schwarz and sum | **ACCEPT** | +| **Theorem O4 (O11)**: `ρ_bip < 3/4` | **ACCEPT** | +| (O12) enclosure and §7 rational certificate | **ACCEPT**. My rigorous enclosure has width about `3·10^-47` and lies inside (O12). | +| §8 doubled triangle and overlap counterexamples | **ACCEPT**. Both were reproduced by the oracle and by exact measure. | +| Even extension (E1)–(E2) Theorem E1: read-two, even capacities, nonbipartite | **ACCEPT** | +| (E3) Lemma E2: read-`q` entropy inequality, direction | **ACCEPT** | +| (E5)–(E6) `2/log(512/25) < 2/3` | **ACCEPT** | + +### Math-#122 + +| Interface | Verdict | +|---|---| +| (T5)–(T6) cover eligibility in the even/read-two class | **ACCEPT** (same argument as E1) | +| (T7)–(T8) local transfer | **ACCEPT** | +| (T9)–(T11) weighted entropy with actual coordinate loads (sum, not max) | **ACCEPT** | +| **Theorem 2 (T3)–(T4)** instance-adaptive load, once a genuine cover is proved | **ACCEPT** | +| (T12)–(T13) sharp reference maximum `q_9`, attained only at `a=2, K=4` | **ACCEPT** | +| (T14)–(T16) interval directions and margins; `ρ_9 < 1/2` | **ACCEPT** | +| **Theorem 1 (T1)** and (T2) enclosure | **ACCEPT**. My rigorous enclosure (width about `10^-48`) lies inside (T2). | +| Zero or infinite `H_D`; duplicate and superset removal; the active/inactive distinction | **ACCEPT** | + +No defect was found in either PR. Remark R1 below slightly extends #122's factor to the bipartite class of #118. + +--- + +## §1 — Colouring: (O2), (E2), (T5) + +**Bipartite, arbitrary capacities.** Each original coordinate of `U` becomes exactly one edge: shared coordinates +join the left and right blocks, and private ones join a private degree-one vertex. So the degree of block `i` is +exactly `|U ∩ X_i|`. Splitting `i` into `a_i` vertices gives degree `<= ⌈|U ∩ X_i|/a_i⌉ <= k`. König's theorem, +proved in the source by regularization and Hall, gives `k` colours. Each split vertex sees at most one edge of a +colour, so each colour meets `X_i` in at most `a_i` coordinates. The source's regularization is sound: the total +deficits of the two sides are equal, so a positive deficit on one side always has a partner on the other. + +**Read-two, even capacities.** Split `i` into `a_i/2` vertices, so each split degree is `<= 2k`. Pair the odd +vertices; their degrees were `<= 2k-1`. Then take an Euler orientation, so in- and out-degree are both `<= k`, and +apply König to the out/in double. Each colour has at most one out-edge and one in-edge per split vertex. That means +at most `2 · (a_i/2) = a_i` per block, because no edge is a loop. + +**Oracle checks.** The formula matches the backtracking oracle on: + +- 720 random subsets of 120 random bipartite systems with capacities 1–3; +- 320 random subsets of 80 random read-two systems whose incidence graph is an odd cycle (3 or 5) with capacities + 2 or 4; +- the E4 triangle: capacity 2, blocks of 9, the 12 shared coordinates need 4 colours and all 15 need 5. + +**Adversarial cases requested by the owner.** + +- *Doubled triangle, capacity one.* The oracle gives `χ = 6` while the formula gives 4, and no block lies inside `U`. + This confirms that §8 excludes it correctly, and that neither class covers it: it is not bipartite, and its + capacities are odd. +- *Odd capacities on odd cycles in general.* The `odd-nonbipartite` mutant sets capacity one on the random + odd-cycle systems, and the formula then fails. The evenness in (E1) and (T5) is genuinely needed, not a proof + convenience. + +## §2 — Obstruction and cover: (O4), (T6), inactive blocks, duplicates + +For an inactive block (`d_i < K`), `|X_i| = a_i d_i + 1 <= a_i K`, so it can never exceed the palette. For an active +block, exceeding `a_i K` means containing all of `X_i`. + +Brute force over all `2^10` subsets of a bipartite system confirms `O_4(D) = {U ⊇ X_0} ∪ {U ⊇ X_2}` and +`χ_D(X) = 5`. The system has two active capacity-one blocks and an **inactive demand-one block** `{4,5}` that meets +both. The inactive block's full set has `χ = 2 <= K`, so it is not an obstruction. The `charge-inactive` mutant, +which adds it to the obstruction family, fails. + +Brute force also confirms two removal rules: + +- dropping a duplicate block (`X_0 = X_1`) keeps the cover; +- keeping only the smaller of `X_0 ⊊ X_1` (capacities 1 and 2, both active) keeps the cover. + +The `drop-superset-cover` mutant keeps the superset instead, and fails on `U = X_0`. + +## §3 — Local transfer: (O5), (T7)–(T8) + +With the other coordinates fixed, a decreasing event has `μ(A) = P_1 + (P_0 - P_1)(1 - p_v)` with `P_0 >= P_1 >= 0`. +This was checked exactly on 120 random decreasing events. So `F(t) = -log(A_0 + B_0 e^{-t_v})` has +`∂²F = -A_0B_0e^{-t}/(·)^2 <= 0`. `F >= 0` gives the chord bound `F(t) >= t_v F(t_v = 1)`, and iterating gives +`F(t) >= H_A Π t_v`. + +Replacing `p_v` by `1 - e^{-φ(p_v)} <= p_v` only increases the probability of a decreasing event, so the direction +is right. The chord bound was also checked on 60 random capacity events in 60-digit decimal arithmetic. That check +is labelled numerical; it is not exact. + +The transfer is applied to the capacity event `A_i = {|U ∩ X_i| <= a_i}`, with reference hazard `H_i`. It is **not** +applied to the containment event. Both sources say this explicitly. + +## §4 — Hazard aggregation: (O8)–(O9), (E3), (T9)–(T11) + +- **Two-sided Cauchy–Schwarz.** `D ⊆ A_L ∩ A_R`, and `P(A ∩ B)^2 <= P(A)P(B)`. Same-side independence holds only + because same-side blocks are disjoint. Exact checks on 150 random rational product measures confirm the + factorization and `μ(D)^2 <= Π μ(A_i)`. The source's overlap example, `5/8 > 9/16` with `(5/8)^2 <= (3/4)^2`, is + reproduced exactly. +- **Entropy (E3)/(T11).** `KL(ν||μ) = H_D` for `ν = μ(·|D)`. Support gives `KL(ν_S||μ_S) >= h_i`. The chain rule + with a product `μ`, plus Jensen for KL's first argument, bounds each marginal contribution by the full conditional + one `b_v`. Summing with weights gives `Σ w_i h_i <= (max_v Σ_{i∋v} w_i) H_D`. The inequality directions are + correct. +- **Exact exponentiated checks.** `Π μ(A_i) >= μ(D)^q` held on 150 random product measures with **arbitrary** + (non-monotone) events on read-2 and read-3 incidences. So did `Π μ(A_i)^{n_i} >= μ(D)^{max_v Σ n_i}`. The `q-one` + mutant (independence-style `q = 1`) fails. The `max-load` mutant fails on the source's counterexample: two copies + of one fair-coin event, where equality `1/4 = 1/4` holds only with the summed load 2. + +## §5 — Reference tails: (O6)–(O7), (E5), (T12)–(T16) + +All rational certificates were recomputed exactly: + +- `1957/720 < e < 31967/11760 < 87/32 < 11/4`; +- `s = (e+4)/(5e) < 1/2` from `e > 8/3`, with equality exactly at `8/3`; +- `5^a 2^{-(4a+1)} = (1/2)(5/16)^a`, and the chains `<= 25/512` for `a >= 2` and `<= 625/131072` for `a >= 4`; +- `q_5 > (28/3)(4/11)^5`, with the margin `2601239/247374336`; +- `Σ_{j<=6}(7/3)^j/j! - 307/32 = 129055/209952`; +- `512/25 - (87/32)^3 = 314641/819200`; +- the `q_5` and `q_9` identities as polynomial identities in `e`; +- both (T15) margins, digit for digit. + +**Interval directions (T15).** `P(z) = 36z^2 - 63z + 28` increases on `[l,u]`, so `P(l)/u^9 < q_9 < P(u)/l^9`. Both +published bounds bracket a rigorous 40-term enclosure of `q_9`. The `interval-swap` mutant fails. + +**Enclosures.** I built independent rigorous enclosures of `ρ_bip` and `ρ_9`. `e` comes from the series with the +`1/(N!N)` tail. The log uses binary reduction and the atanh series with its remainder, after outward rounding. The +enclosures have widths of about `3·10^-47` and `10^-48` and lie strictly inside (O12) and (T2). + +**Sharpness of the even tail (T13).** Rigorous bounds with `p_* ∈ (1 - 1/e_lo, 1 - 1/e_hi)` show +`P(Bin(aK+1, p_*) <= a) < q_9` for every even `a <= 10`, `4 <= K <= 8`, except `(a, K) = (2, 4)`. The general proof +is the source's: monotonicity in `n` for `a = 2`, and Markov for `a >= 4`. + +Capacity one gives `q_5 > q_9`, so the uniform `q_9` reference bound does not reach active capacity-one blocks. In +this coarse read-two assembly they need the `h_5` local reference input instead. That is a failure of a +reference-tail bound, **not** a cover-factor impossibility. For example, a single active capacity-one block is +read-one, so its load is `1/h_5 = ρ_bip/2 < 0.36508 < ρ_9` by the enclosures (O12) and (T2). + +### R1 (reviewer remark, not a source claim): the `q_9` reference tail covers every capacity `>= 2`, odd included + +In the **bipartite** class of #118, which allows arbitrary capacities, suppose every **active** block has +`a_i >= 2`. Then: + + covercost_c(O_K(D)) <= min(1, ρ_9 H_D), ρ_9 < 1/2. + +Inactive capacity-one blocks are allowed. + +*Proof.* (O4), (O5) and (O9) are unchanged. It remains to show `H_i >= -log q_9` for every `a_i >= 2` and `K >= 4`: + +- `a = 2`: monotonicity in `n`. +- `a >= 4` of either parity: Markov gives `(1/2)(5/16)^a <= 625/131072`. +- `a = 3`: this case needs a separate step. **Markov's bound `125/8192` exceeds `q_9`**. But `n = 3K+1 >= 13`, and + monotonicity in `n` gives `P(Bin(3K+1, p_*) <= 3) <= P(Bin(13, p_*) <= 3) ≈ 0.00385 < q_9 ≈ 0.01515`. That last + inequality is certified exactly by `P(Bin(13, 1 - 1/e_lo) <= 3) < P(Bin(9, 1 - 1/e_hi) <= 2)` with 40-term + bounds `e_lo < e < e_hi`. + +The `tail-a3` mutant, which replaces the direct tail by Markov, fails. ∎ + +So in this coarse read-two assembly, only **active capacity-one** blocks need the `h_5` reference input, which +yields the uniform factor `ρ_bip`. No necessity or optimality of `ρ_bip` as a cover factor is claimed. When +capacity-one blocks sit alongside larger ones, #122's Theorem 2 already gives the instance-specific load: a +coordinate shared by a capacity-one and a capacity-`>=2` active block carries `1/h_5 + 1/(-log q_9)`. R1 is offered +to the author and changes no source. + +## §6 — #122 Theorem 2 edge cases + +- **Cover eligibility.** Theorem 2 presupposes a genuine cover and `H_i > 0`. `H_i > 0` holds exactly when + `|X_i| > a_i`, which is automatic for active blocks. +- **`H_D = ∞`.** The unit-price empty generator applies. +- **`H_D = 0`.** Then `μ(A_i) = 1`. That forces at least `|X_i| - a_i >= 1` coordinates with `p_v = 0`, hence + `c_v = 0`, so the full-block price is zero, consistent with (T8). +- **Loads.** Loads are per original coordinate, summed. Duplicate removal halves a doubled load, and the cover is + unchanged (§2). + +## Checks run + +``` +python3 -B -S run_validation.py # #118 author runner at 23b7558 (git archive): 29 tests, 10 mutants +python3 -B -S verify.py --output # #122 author runner at 245f3d7 (git archive): 15 tests, 7 mutants +python3 -B -S p15_exact_check.py # rc 0, stdout == RESULTS.json +python3 -B -O -S p15_exact_check.py # rc 0, byte-identical +python3 -B -S p15_exact_check.py --mutant M # rc 1 for each of: + odd-nonbipartite charge-inactive q-one max-load interval-swap tail-a3 drop-superset-cover +``` + +Python standard library only. The workflow `.github/workflows/p15-overlap-tail-review.yml` verifies the packet tree +against `SOURCE_FILES.json`, replays both modes and requires every mutant to be rejected. + +## Not established here + +- Optimality of any cover factor. Both sources disclaim it; the tail in (T13) is sharp as a reference tail only. +- Arbitrary macro-clutters, arbitrary read-two with odd capacities, unrestricted downsets, or any governing P15 + status. +- The old `0.84548` sharp factor of `full_price_20260924` is a different class (maximal demand two, disjoint + blocks). No comparison is asserted. +- Organizational independence: all lanes share one GitHub account. + +## Revision history + +- **v1**, reviewing #118 at `23b7558` and #122 at `245f3d7`: initial packet. +- **v2**, responding to the OpenAI review + [5345318332](https://github.com/d6g8k5htny-coder/Math-/pull/123#pullrequestreview-5345318332). Wording only; + no verdict, check or source changes. + - The (O3)–(O4) row now says the inclusion-minimal distinct active full blocks are the minimal obstructions, as + the source does. The reviewer's `X_0 ⊂ X_1` example is the §2 superset case. + - §5 and R1 no longer say `ρ_9` "cannot cover" active capacity-one blocks or that `ρ_bip` is "forced". A failed + reference-tail bound is not a cover-factor impossibility; a single active capacity-one block has load + `1/h_5 < ρ_9`. diff --git a/reviews/p15_overlap_tail_claude_20260928/SOURCE_FILES.json b/reviews/p15_overlap_tail_claude_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..eab24e711 --- /dev/null +++ b/reviews/p15_overlap_tail_claude_20260928/SOURCE_FILES.json @@ -0,0 +1,57 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW", + "reviewed_objects": [ + { + "pr": "d6g8k5htny-coder/Math-#118", + "head": "23b7558943f69a7f479251566b19ba58e75cfc26", + "paths": [ + { + "path": "frontiers/p15_bipartite_overlap_20260928/PROOF.md", + "git_blob": "8ad826ecb374cc733e3a547bdba0ba63cad10c08", + "bytes": 13835, + "sha256": "21ce7a29ac0971919c0602f556f1aeba48bb14fffd4193864b3f482185bc1698" + }, + { + "path": "frontiers/p15_bipartite_overlap_20260928/EVEN_CAPACITY_EXTENSION.md", + "git_blob": "ce21e424433100d0307c49bc15cccc748f9438fc", + "bytes": 7620, + "sha256": "d28aa700ba83ca139b7b29b6ff06cc39c725470b710af10728867ec10c8ca985" + } + ] + }, + { + "pr": "d6g8k5htny-coder/Math-#122", + "head": "245f3d77c9d38f49d13affb9563a266eba92a47b", + "paths": [ + { + "path": "frontiers/p15_tail_load_20260928/PROOF.md", + "git_blob": "8187908dfd220cb833b94f82c451ef4c0e45e367", + "bytes": 12828, + "sha256": "fbca462d4988a06754ded9415ceea6bb1385be5535656d643bdd48edbbee8a20" + } + ] + } + ], + "files": [ + { + "path": "REVIEW.md", + "bytes": 15923, + "sha256": "7a425f7119dd8a0701fb241769a3e82d80fbd6b148d074f11e1015e826813268", + "git_blob": "29ec33677854661964f2e659e7c9116a5749e95c" + }, + { + "path": "p15_exact_check.py", + "bytes": 20898, + "sha256": "1c865eaca5b7e4fc815f1f050695dc5ed1acb0edbebb73824e93124916779540", + "git_blob": "378aa17fb47738d047fd6e4913670f9c8f07e583" + }, + { + "path": "RESULTS.json", + "bytes": 2001, + "sha256": "87b52587cbed09cb893086c2db2d73992da8e0c940ffa156a56cd053361491d5", + "git_blob": "60cec87c3cd25cd9400a8cc1df3427bbf2b7b0df" + } + ] +} diff --git a/reviews/p15_overlap_tail_claude_20260928/p15_exact_check.py b/reviews/p15_overlap_tail_claude_20260928/p15_exact_check.py new file mode 100644 index 000000000..378aa17fb --- /dev/null +++ b/reviews/p15_overlap_tail_claude_20260928/p15_exact_check.py @@ -0,0 +1,461 @@ +"""Independent exact checks for the nonauthor review of Math-#118 (P15 bipartite overlap and even-capacity +extension) and Math-#122 (P15 sharp even reference tail and weighted loads). + +Python standard library only; exact rational arithmetic (one group uses 60-digit decimal arithmetic and says so). +Written after reading the authors' suites, but it shares no code with them. Its colouring oracle is a plain +backtracking search over colour assignments of ORIGINAL coordinates, not the authors' constructions. Groups: + + COL (O2)/(E2)/(T5) chi_D = max ceil(|U^X_i|/a_i) against the oracle: random bipartite systems with arbitrary + capacities, random read-two NONbipartite systems with even capacities, the E4 triangle (12 shared + coordinates 4-colourable, all 15 need 5), and the excluded doubled triangle with capacity one (chi = 6 > 4). + OBS (O4)/(T6) O_K(D) = union of active full-block containments, by brute force over all subsets, with an inactive + demand-one block; chi_D(X) = K+1; duplicate and strict-superset generator removal keeps a cover. + HAZ (O8)-(O9), (E3), (T11) in exponentiated exact form on random rational product measures: two-sided + Cauchy-Schwarz, read-q product inequality for arbitrary events, integer-weighted loads; the overlap + example 5/8 > 9/16; the max-instead-of-sum counterexample. + TRANS (O5)/(T8) decreasing events are affine in each p_v with nonnegative coefficients; separate concavity + chord bound checked in 60-digit decimal arithmetic (not exact). + TAIL (O6)-(O7), (E5), (T12)-(T16): rational e bounds, s < 1/2, Markov chains, q_5 > 25/512, the exp(7/3) + certificate, 512/25 > (87/32)^3, the q_9 polynomial identity, both (T15) margins, rigorous enclosures of + rho_bip and rho_9 inside (O12)/(T2), the uniform even tail with equality only at a=2, K=4, capacity one + giving q_5 > q_9, and reviewer remark R1: every capacity a >= 2 (odd included) has tail < q_9, where + a = 3 needs a direct tail because Markov's bound 125/8192 exceeds q_9. + +Not a proof of the continuum inequalities: separate concavity, the relative-entropy chain rule and König's +theorem are argued in REVIEW.md. +""" +import argparse +import decimal +import itertools +import json +import random +import sys +from fractions import Fraction as F +from math import comb, factorial + +MUTANTS = ("odd-nonbipartite", "charge-inactive", "q-one", "max-load", "interval-swap", "tail-a3", + "drop-superset-cover") + +# ---------------------------------------------------------------------------------------------------------- +# Colouring +# ---------------------------------------------------------------------------------------------------------- + + +def formula(U, blocks, caps): + return max([0] + [-(-len(U & B) // a) for B, a in zip(blocks, caps)]) + + +def chi_oracle(U, blocks, caps): + """Least k such that U splits into k sets each meeting every block X_i in <= a_i coordinates.""" + U = sorted(U) + if not U: + return 0 + memb = {v: [i for i, B in enumerate(blocks) if v in B] for v in U} + U.sort(key=lambda v: -len(memb[v])) + lower = max(-(-sum(1 for v in U if i in memb[v]) // a) for i, a in enumerate(caps)) # counting bound + for k in range(max(1, lower), len(U) + 1): + load = [[0] * len(blocks) for _ in range(k)] + + def bt(idx, used): + if idx == len(U): + return True + v = U[idx] + for c in range(min(used + 1, k)): + if all(load[c][i] < caps[i] for i in memb[v]): + for i in memb[v]: + load[c][i] += 1 + if bt(idx + 1, max(used, c + 1)): + return True + for i in memb[v]: + load[c][i] -= 1 + return False + + if bt(0, 0): + return k + raise AssertionError("unreachable") + + +def random_bipartite(rng): + n = rng.randrange(5, 10) + nl, nr = rng.randrange(1, 4), rng.randrange(1, 4) + L = [set() for _ in range(nl)] + R = [set() for _ in range(nr)] + for v in range(n): + side = rng.randrange(3) + if side in (0, 2): + L[rng.randrange(nl)].add(v) + if side in (1, 2): + R[rng.randrange(nr)].add(v) + blocks = [B for B in L + R if B] + caps = [rng.randrange(1, 4) for _ in blocks] + return n, blocks, caps + + +def random_read_two(rng, cyc): + """Blocks are the vertices of an odd cycle; coordinates are cycle edges (shared) or private.""" + blocks = [set() for _ in range(cyc)] + v = 0 + for i in range(cyc): + for _ in range(rng.randrange(1, 3)): + blocks[i].add(v) + blocks[(i + 1) % cyc].add(v) + v += 1 + for _ in range(rng.randrange(0, 2)): + blocks[i].add(v) + v += 1 + return v, blocks + + +def check_col(mut): + rng = random.Random(118) + out = {} + ok_bip, ok_even = True, True + for _ in range(120): + n, blocks, caps = random_bipartite(rng) + for _ in range(6): + U = {x for x in range(n) if rng.random() < 0.7} + ok_bip &= chi_oracle(U, blocks, caps) == formula(U, blocks, caps) + for _ in range(80): + n, blocks = random_read_two(rng, rng.choice((3, 5))) + caps = [1 if mut == "odd-nonbipartite" else rng.choice((2, 4)) for _ in blocks] + for _ in range(4): + U = {x for x in range(n) if rng.random() < 0.8} + ok_even &= chi_oracle(U, blocks, caps) == formula(U, blocks, caps) + out["bipartite_arbitrary_capacity_formula_equals_oracle"] = ok_bip + out["read_two_nonbipartite_even_capacity_formula_equals_oracle"] = ok_even + # E4 triangle: capacity 2, four shared coordinates per side, one private per block. + blocks = [set(), set(), set()] + v = 0 + for i in range(3): + for _ in range(4): + blocks[i].add(v) + blocks[(i + 1) % 3].add(v) + v += 1 + shared = set(range(v)) + for i in range(3): + blocks[i].add(v) + v += 1 + full = set(range(v)) + caps = [2, 2, 2] + out["E4_triangle_shared_4_full_5"] = (all(len(B) == 9 for B in blocks) and chi_oracle(shared, blocks, caps) == 4 + and chi_oracle(full, blocks, caps) == 5) + # Excluded doubled triangle, capacity one (PROOF.md section 8). + blocks = [{0, 1, 4, 5, 6}, {0, 1, 2, 3, 7}, {2, 3, 4, 5, 8}] + U = {0, 1, 2, 3, 4, 5} + out["doubled_triangle_capacity_one_chi_6_formula_4"] = (chi_oracle(U, blocks, [1, 1, 1]) == 6 + and formula(U, blocks, [1, 1, 1]) == 4 + and not any(B <= U for B in blocks)) + return out + + +def check_obs(mut): + out = {} + # Bipartite: X0 (a=1, d=4, active), X1={4,5} (a=1, d=1, inactive, overlaps both), X2 (a=1, d=4, active). + blocks = [set(range(0, 5)), {4, 5}, set(range(5, 10))] + caps, d = [1, 1, 1], [4, 1, 4] + K = max(d) + X = set(range(10)) + active = [B for B, di in zip(blocks, d) if di == K] + charged = blocks if mut == "charge-inactive" else active + ok = all(len(B) == a * di + 1 for B, a, di in zip(blocks, caps, d)) + for bits in range(1 << 10): + U = {v for v in range(10) if bits >> v & 1} + obstruct = chi_oracle(U, blocks, caps) > K + ok &= obstruct == any(B <= U for B in active) + if mut == "charge-inactive": + ok &= obstruct == any(B <= U for B in charged) + out["O4_exact_obstruction_equals_active_full_blocks"] = ok + out["chi_whole_ground_K_plus_1"] = chi_oracle(X, blocks, caps) == K + 1 + out["inactive_full_block_not_obstruction"] = chi_oracle(blocks[1], blocks, caps) == 2 <= K + # Duplicate removal (X0 = X1, read-two, bipartite) and strict-superset removal (X0 inside X1, a = 1 and 2). + ok = True + for blocks, caps, keep, drop in (([set(range(5)), set(range(5)), set(range(5, 10))], [1, 1, 1], [0, 2], [1, 2]), + ([set(range(5)), set(range(9))], [1, 2], [0], [1])): + ok &= all(len(B) == a * 4 + 1 for B, a in zip(blocks, caps)) + n = len(set().union(*blocks)) + retained = [blocks[i] for i in (drop if mut == "drop-superset-cover" and len(blocks) == 2 else keep)] + for bits in range(1 << n): + U = {v for v in range(n) if bits >> v & 1} + ok &= (chi_oracle(U, blocks, caps) > 4) == any(B <= U for B in retained) + out["duplicate_and_superset_removal_keeps_cover"] = ok + return out + + +# ---------------------------------------------------------------------------------------------------------- +# Product-measure hazards +# ---------------------------------------------------------------------------------------------------------- + + +def configs(n): + return [tuple(bits >> v & 1 for v in range(n)) for bits in range(1 << n)] + + +def measure(p, event, n): + tot = F(0) + for x in configs(n): + if event(x): + w = F(1) + for v in range(n): + w *= p[v] if x[v] else 1 - p[v] + tot += w + return tot + + +def check_haz(mut): + rng = random.Random(1181) + out = {} + # Overlap destroys independence; Cauchy-Schwarz survives. + p = [F(1, 2)] * 3 + a1 = measure(p, lambda x: x[0] + x[1] <= 1, 3) + a2 = measure(p, lambda x: x[1] + x[2] <= 1, 3) + dd = measure(p, lambda x: x[0] + x[1] <= 1 and x[1] + x[2] <= 1, 3) + out["overlap_5_8_exceeds_9_16_and_CS"] = a1 == a2 == F(3, 4) and dd == F(5, 8) > a1 * a2 and dd ** 2 <= a1 * a2 + ok_cs, ok_rq, ok_w = True, True, True + for trial in range(150): + n = rng.randrange(4, 7) + p = [F(rng.randrange(0, 11), 10) for _ in range(n)] + # Bipartite capacity system: two disjoint left blocks, two disjoint right blocks. + perm = list(range(n)) + rng.shuffle(perm) + cut = rng.randrange(1, n) + L = [set(perm[:cut]), set(perm[cut:])] + rng.shuffle(perm) + cut = rng.randrange(1, n) + R = [set(perm[:cut]), set(perm[cut:])] + blocks = L + R + caps = [rng.randrange(0, 3) for _ in blocks] + ev = [lambda x, B=B, a=a: sum(x[v] for v in B) <= a for B, a in zip(blocks, caps)] + mus = [measure(p, e, n) for e in ev] + muL = measure(p, lambda x: ev[0](x) and ev[1](x), n) + muR = measure(p, lambda x: ev[2](x) and ev[3](x), n) + muD = measure(p, lambda x: all(e(x) for e in ev), n) + ok_cs &= muL == mus[0] * mus[1] and muR == mus[2] * mus[3] and muD ** 2 <= muL * muR + ok_cs &= muD ** 2 <= mus[0] * mus[1] * mus[2] * mus[3] + # Read-q with ARBITRARY events on triangle incidence (q = 2): Prod mu(A_i) >= mu(D)^q. + S = [(0, 1), (1, 2), (2, 0)] + ([(3, 0)] if n > 3 else []) + q = max(sum(1 for s in S if v in s) for v in range(n)) + tables = [{xy: rng.random() < 0.75 for xy in itertools.product((0, 1), repeat=2)} for _ in S] + evs = [lambda x, s=s, t=t: t[(x[s[0]], x[s[1]])] for s, t in zip(S, tables)] + muA = [measure(p, e, n) for e in evs] + muD = measure(p, lambda x: all(e(x) for e in evs), n) + qq = 1 if mut == "q-one" else q + prod = F(1) + for m in muA: + prod *= m + ok_rq &= prod >= muD ** qq + # Integer-weighted loads (T11): Prod mu(A_i)^{n_i} >= mu(D)^{max_v sum_{i ni v} n_i}. + wts = [rng.randrange(0, 4) for _ in S] + if mut == "max-load": + load = max(max([w for s, w in zip(S, wts) if v in s], default=0) for v in range(n)) + else: + load = max(sum(w for s, w in zip(S, wts) if v in s) for v in range(n)) + prod = F(1) + for m, w in zip(muA, wts): + prod *= m ** w + ok_w &= prod >= muD ** load + # Max-instead-of-sum counterexample: two identical events on one fair coordinate. + mA = measure([F(1, 2)], lambda x: x[0] == 0, 1) + load = 1 if mut == "max-load" else 2 + ok_w &= mA * mA >= mA ** load + out["two_sided_cauchy_schwarz_bipartite"] = ok_cs + out["read_q_product_inequality_arbitrary_events"] = ok_rq + out["weighted_load_sum_not_max"] = ok_w + return out + + +def check_trans(mut): + rng = random.Random(1182) + out = {} + ok_aff = True + for _ in range(120): + n = rng.randrange(2, 6) + gens = [frozenset(v for v in range(n) if rng.random() < 0.5) for _ in range(3)] + # decreasing event: the configuration contains no nonempty generator + down = lambda x, gens=gens: not any(g and all(x[v] for v in g) for g in gens) + p = [F(rng.randrange(0, 11), 10) for _ in range(n)] + j = rng.randrange(n) + vals = [] + for pj in (F(0), F(1, 3), F(1)): + pp = list(p) + pp[j] = pj + vals.append(measure(pp, down, n)) + P0, P1 = vals[0], vals[2] # coordinate j forced absent / present + ok_aff &= P0 >= P1 >= 0 and vals[1] == P1 + (P0 - P1) * (1 - F(1, 3)) + out["decreasing_event_affine_nonneg_coefficients"] = ok_aff + # Separate-concavity chord bound F(t) >= H prod t, 60-digit decimal (numerical, not exact). + ctx = decimal.Context(prec=60) + D = decimal.Decimal + ok = True + for _ in range(60): + n = rng.randrange(2, 5) + a = rng.randrange(0, n) + t = [D(rng.randrange(1, 101)) / D(100) for _ in range(n)] + pt = [1 - ctx.exp(-x) for x in t] + p1 = 1 - ctx.exp(D(-1)) + + def mu(pv): + tot = D(0) + for x in configs(n): + if sum(x) <= a: + w = D(1) + for v in range(n): + w *= pv[v] if x[v] else 1 - pv[v] + tot += w + return tot + + Ft = -ctx.ln(mu(pt)) + H = -ctx.ln(mu([p1] * n)) + prod = D(1) + for x in t: + prod *= x + ok &= Ft >= H * prod - D(10) ** -50 + out["separate_concavity_chord_decimal60"] = ok + return out + + +# ---------------------------------------------------------------------------------------------------------- +# Reference tails and certificates +# ---------------------------------------------------------------------------------------------------------- + + +def e_bounds(N): + s = sum(F(1, factorial(j)) for j in range(N + 1)) + return s, s + F(1, factorial(N) * N) + + +def round_out(x, down): + den = 10 ** 45 + num = (x.numerator * den) // x.denominator + return F(num if down else num + 1, den) + + +def log_enclosure(x, m=60): + """Rigorous [lo, hi] for log x, rational x >= 1, via x = 2^j y and the atanh series with remainder.""" + assert x >= 1 + j = 0 + while x >= 2: + x /= 2 + j += 1 + + def atanh2(y): + t = (y - 1) / (y + 1) + s = 2 * sum(t ** (2 * k + 1) / (2 * k + 1) for k in range(m)) + return s, s + 2 * t ** (2 * m + 1) / ((2 * m + 1) * (1 - t * t)) + + l2lo, l2hi = atanh2(F(2)) + ylo, yhi = atanh2(x) + return j * l2lo + ylo, j * l2hi + yhi + + +def binom_le(n, p, a): + return sum(comb(n, i) * p ** i * (1 - p) ** (n - i) for i in range(a + 1)) + + +def check_tail(mut): + out = {} + l, u = F(1957, 720), F(87, 32) + eu6 = l + F(1, factorial(7)) * F(8, 7) + out["e_bounds_series"] = (l == sum(F(1, factorial(j)) for j in range(7)) and eu6 == F(31967, 11760) + and F(8, 3) < l < eu6 < u < F(11, 4)) + el, eh = e_bounds(40) + out["e_bounds_consistent_with_tight"] = l < el < eh < F(31967, 11760) + s_at = lambda e: (e + 4) / (5 * e) + out["s_below_half_from_e_above_8_3"] = s_at(F(8, 3)) == F(1, 2) and s_at(eh) < F(1, 2) + out["markov_chain_a_ge_2_and_a_ge_4"] = (all(F(1, 2) * F(5, 16) ** a <= F(25, 512) for a in range(2, 60)) + and all(F(1, 2) * F(5, 16) ** a <= F(625, 131072) + for a in range(4, 60, 2)) + and all(5 ** a * F(1, 2) ** (4 * a + 1) == F(1, 2) * F(5, 16) ** a + for a in range(1, 30))) + q5lo = F(28, 3) * F(4, 11) ** 5 + out["q5_above_25_512_margin"] = q5lo - F(25, 512) == F(2601239, 247374336) > 0 + out["exp_7_3_certificate"] = (sum(F(7, 3) ** j / factorial(j) for j in range(7)) - F(307, 32) + == F(129055, 209952) and 5 * u - 4 == F(307, 32)) + out["512_25_exceeds_87_32_cubed"] = F(512, 25) - u ** 3 == F(314641, 819200) + # q_9 identity as a polynomial identity in e (y = 1/e): Bin(9, 1-y) <= 2. + ok = True + for e in (F(5, 2), F(11, 4), F(271, 100), F(3)): + y = 1 / e + lhs = binom_le(9, 1 - y, 2) + ok &= lhs == (36 * e * e - 63 * e + 28) / e ** 9 == y ** 9 * (1 + 9 * (e - 1) + 36 * (e - 1) ** 2) + out["q9_polynomial_identity"] = ok + Pz = lambda z: 36 * z * z - 63 * z + 28 + lo9, hi9 = Pz(l) / u ** 9, Pz(u) / l ** 9 + if mut == "interval-swap": + hi9 = Pz(l) / u ** 9 + tlo, thi = Pz(el) / eh ** 9, Pz(eh) / el ** 9 + out["T15_margins_exact"] = (lo9 - F(625, 131072) == F(87187623163627321174969, 8421039761612032386662400) + and F(1, 64) - Pz(u) / l ** 9 + == F(12311490319341451572976881157, 26946192308072632700222520394048)) + out["T15_interval_directions"] = (72 * l - 63 > 0 and lo9 <= tlo and thi <= hi9 and lo9 < hi9 + and F(625, 131072) < lo9 and hi9 < F(1, 64)) + out["log2_above_2_3"] = F(11, 4) ** 2 < 8 + # Rigorous enclosures of rho_bip and rho_9 lie inside the published ones. + x_lo, x_hi = round_out(5 * el - 4, True), round_out(5 * eh - 4, False) + lg_lo, _ = log_enclosure(x_lo) + _, lg_hi = log_enclosure(x_hi) + rb = (2 / (5 - lg_lo), 2 / (5 - lg_hi)) + P_lo, P_hi = round_out(Pz(el), True), round_out(Pz(eh), False) + lq_lo, _ = log_enclosure(P_lo) + _, lq_hi = log_enclosure(P_hi) + r9 = (2 / (9 - lq_lo), 2 / (9 - lq_hi)) + out["rho_bip_inside_O12"] = (F("0.73015826409534942932") < rb[0] <= rb[1] < F("0.73015826409534942934") + and rb[1] < F(3, 4)) + out["rho_9_inside_T2"] = (F("0.47734798895766998533") < r9[0] <= r9[1] < F("0.47734798895766998534") + and r9[1] < F(1, 2)) + # Uniform even tail (T13): rigorous upper bound on P(Bin(aK+1, p*) <= a) via p* > 1 - 1/el. + p_lo, p_hi = 1 - 1 / el, 1 - 1 / eh + q9_lo = binom_le(9, p_hi, 2) + ok_even = True + for a in range(2, 11, 2): + for K in range(4, 9): + if (a, K) == (2, 4): + continue + ok_even &= binom_le(a * K + 1, p_lo, a) < q9_lo + # Capacity one is NOT covered by q_9 (it gives q_5), which is why rho_9 excludes it. + q5_lo = binom_le(5, p_hi, 1) + q9_hi = binom_le(9, p_lo, 2) + out["uniform_even_tail_max_only_at_a2_K4"] = ok_even + out["capacity_one_tail_q5_exceeds_q9"] = q5_lo > q9_hi + # Reviewer remark R1: every capacity a >= 2, odd included, has reference tail < q_9 for K >= 4. For a = 3 + # Markov's bound (1/2)(5/16)^3 = 125/8192 EXCEEDS q_9, so a direct tail (monotone in n, n >= 13) is needed. + markov_a3 = F(1, 2) * F(5, 16) ** 3 + direct_a3 = markov_a3 if mut == "tail-a3" else binom_le(13, p_lo, 3) + out["R1_a3_markov_insufficient_direct_tail_below_q9"] = markov_a3 > q9_hi and direct_a3 < q9_lo + out["R1_a3_monotone_in_trials"] = all(binom_le(n + 1, p_lo, 3) <= binom_le(n, p_lo, 3) for n in range(13, 40)) + out["R1_odd_a_ge_5_markov_below_q9"] = all(F(1, 2) * F(5, 16) ** a < q9_lo for a in range(5, 61, 2)) + # Five-trial reference: q_5 = e^-5 (5e-4) as a polynomial identity. + ok = True + for e in (F(5, 2), F(11, 4), F(3)): + ok &= binom_le(5, 1 - 1 / e, 1) == (5 * e - 4) / e ** 5 + out["q5_polynomial_identity"] = ok + # a = 1 branch: monotone in n. + out["a1_monotone_in_trials"] = all(binom_le(n + 1, p_lo, 1) <= binom_le(n, p_lo, 1) for n in range(5, 30)) + return out + + +def flatten(d): + for v in d.values(): + if isinstance(v, dict): + yield from flatten(v) + else: + yield v + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + mut = ap.parse_args().mutant + checks = {"COL_colouring": check_col(mut), "OBS_obstruction_cover": check_obs(mut), + "HAZ_product_hazards": check_haz(mut), "TRANS_local_transfer": check_trans(mut), + "TAIL_reference_tails": check_tail(mut)} + passed = all(flatten(checks)) + print(json.dumps({"checks": checks, "passed": passed, "scientific_effect": "NONE", + "scope": "exact identities, brute-force colouring oracle and exact product-measure " + "inequalities on finite instances; one 60-digit decimal check; the continuum " + "arguments are in REVIEW.md"}, + indent=2, sort_keys=True)) + return 0 if passed else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/reviews/remote_height_claude_20260928/RESULTS.json b/reviews/remote_height_claude_20260928/RESULTS.json new file mode 100644 index 000000000..914ccba4c --- /dev/null +++ b/reviews/remote_height_claude_20260928/RESULTS.json @@ -0,0 +1,53 @@ +{ + "checks": { + "BAR_r2_barrier": { + "exceeds_r3": true, + "mean_exactly_flat": true, + "q_equals_r5": true, + "singleton_tv_r2_over_2_1_minus_r2": true, + "valid_law_r_le_half": true + }, + "CONG_congruence": { + "F_j_H_equals_r_F_j_K": true, + "det_H_equals_r_det_K": true, + "inertia_preserved": true + }, + "FDET_filtered_determinant": { + "filtered_det_lipschitz_all_pairs": true + }, + "LIP_window_variation": { + "double_integral_abs_diff_one_third": true, + "mean_deviation_le_L_over_3": true + }, + "MIX_singleton_mixture": { + "a_le_q": true, + "bonferroni_and_multiple": true, + "configuration_tv_equals_epsilon": true, + "epsilon_le_q_over_2m_minus_q": true, + "height_marginal_bound": true, + "mixture_tv_le_a_over_m": true, + "own_marginal_factor_two": true, + "p1_ge_m_minus_q": true, + "selectors_within_epsilon": true + }, + "MOM_moments": { + "mean_error_power_r5": true, + "tv_controls_bounded_moments": true, + "variance_error_power_r8": true, + "variance_perturbation_3_delta": true + }, + "REG_regression_direction": { + "U_r_reexpression_gives_same_g": true, + "V_g_equals_e_h_exact": true, + "column_bound_r_over_2_sup_D3": true, + "contact_limit_second_order": true, + "g_x_one_and_grad_g_x_zero": true, + "original_endpoint_values_and_gradients_vanish": true, + "pathwise_F_h_minus_F_h2_is_dh_times_g_and_targets_realized": true, + "zero_average_identity_both_endpoints": true + } + }, + "passed": true, + "scientific_effect": "NONE", + "scope": "exact identities and a finite-rank Gaussian regression model only; uniform covariance floors, conditional moments and Kac-Rice are argued in REVIEW.md" +} diff --git a/reviews/remote_height_claude_20260928/REVIEW.md b/reviews/remote_height_claude_20260928/REVIEW.md new file mode 100644 index 000000000..1cc9afe98 --- /dev/null +++ b/reviews/remote_height_claude_20260928/REVIEW.md @@ -0,0 +1,228 @@ +# Nonauthor analytic review: remote within-window height decoupling (Math-#120) + +Scientific effect: **NONE**. This file does not change `lemma_closed`, prizes, premises, `STATUS`, +`PROOF_INDEX`, `GRAPH`, the candidate registry or any author source. It records verdicts. Integration is a +separate act. + +## Object + +| Field | Value | +|---|---| +| Object | OA-REMOTE-HEIGHT-DECOUPLING-20260928-v1 (OpenAI / ChatGPT) | +| Branch / head | `chatgpt/remote-height-decoupling-20260928` / `f3e16585338e4c4dc878df43f9117b1b3ed5a479` ([Math-#120](https://github.com/d6g8k5htny-coder/Math-/pull/120)) | +| `PROOF.md` | Git blob `4d7af587db20515955585732d8150d912c89c0e4`, 13747 B, SHA256 `67249f0311342beab7833cb60c3239d9888df96befda4fbae3ec29a66f8cd78e` | +| Consumed, already on main | [RM] `frontiers/remote_window_20260924/PROOF.md` (blob `b383bfcc…`): §§2–5, (2), (5), (8), (11), (12). [RC] `frontiers/remote_collision_20260928/PROOF.md` (blob `7b48a88e…`): Corollary D. Both blobs match main at `63857fe`. | +| Request | [Owner comment 5878357612](https://github.com/d6g8k5htny-coder/Math-/pull/120#issuecomment-5878357612), "especially (H7)–(H15)" | +| Prior review | OpenAI same-provider, source-exposed review [5344808206](https://github.com/d6g8k5htny-coder/Math-/pull/120#pullrequestreview-5344808206): no blocker. This record is the requested different-provider review. | + +## Provenance + +| Field | Value | +|---|---| +| Reviewer | Anthropic Claude, Claude Code session `session_017Mi3hxjaxV45x6zo6o1ee3` | +| Relation | Different provider from the OpenAI author. Same GitHub account as every lane, so no organizational independence is claimed. | +| Exposure | I read `PROOF.md` in full, its README, RECONNAISSANCE, SOURCE_MAP and `check.py`, RM §§1–6, and the OpenAI review above before writing this record. **I am the author of [RC]** ([Math-#110](https://github.com/d6g8k5htny-coder/Math-/pull/110)), whose Corollary D supplies `q_r <= C r^5 |E|`. I consumed RM there. So the probability slice (H18)–(H20) is not independent of my own earlier work. The analytic slice (H7)–(H15) consumes only RM. | +| Author code | Replayed from a `git archive` of `f3e1658`: `verify.py` passes all sources, 12 tests per mode, 5 mutants rejected per mode, and identical output pairs. | +| Independent checks | `height_exact_check.py` is my own exact-rational suite. It shares no code with the author's `check.py` and tests different objects, notably an exact finite-rank Gaussian regression model for (H7)–(H10). It does not replace the Gaussian arguments below. | + +## Verdicts + +| Interface | Verdict | +|---|---| +| (H7) exact pathwise identity `F_h - F_h' = (h - h') g` | **ACCEPT** | +| (H8) uniform `C^q` bound on `g` | **ACCEPT**, with note N2 | +| (H9) `V_r g = e_h`, so the ORIGINAL endpoint values and gradients of `g` vanish | **ACCEPT** | +| (H10) vector zero-average column bound `(r/2)‖D^3 g‖` | **ACCEPT** | +| (H11) Lipschitz endpoint and witness blocks, with no `1/r` loss | **ACCEPT**, and it is deterministic (N1) | +| (H12) `W_r/r^2 = F_d(K_M) F_(d-1)(K_S)` by positive congruence | **ACCEPT** | +| (H13) = RM (8) filtered-determinant Lipschitz bound | **ACCEPT** | +| (H14) product difference and moments; (H15) uniform `L` | **ACCEPT**. `Z_r` is independent of the witness height (§3). | +| (H16)–(H17) marked mean measure, variation `<= (d+1) L l^2 |E|/3` | **ACCEPT** | +| **(H1)** `O(r^3)` own-marginal factorization of the normalized mean | **ACCEPT** | +| (H18)–(H19) mixture, `a <= q`; **(H2)** with the factor two; **(H3)** | **ACCEPT** | +| **(H4)** physical mean `O(r^5)`, variance `O(r^8)` | **ACCEPT** | +| (H20), configuration-level `TV = ε`, measurable and randomized selectors | **ACCEPT** | +| §7 contact-profile compatibility; (H21) abstract `r^2` barrier | **ACCEPT**. It is correctly not claimed as Gaussian sharpness. | + +No defect was found. Notes N1–N6 strengthen or delimit the text without changing it. + +--- + +## §1 — (H7)–(H9): the regression direction and the original pins + +The regression realization is affine in the target. So `F_h - F_h' = Cov(F(·),V_r) Σ_r^{-1}(a_h - a_h')`, and +`a_h - a_h' = (h - h') e_h`. That is (H7), pathwise and exact. It is one coupling, not an independence statement. + +Applying the observation functionals to the deterministic function `g(z) = Cov(F(z),V_r) Σ_r^{-1} e_h` gives +`V_r[g] = Cov(V_r,V_r) Σ_r^{-1} e_h = e_h`. Differentiation commutes with covariance for this smooth field. So +`U_r[g] = 0`, `∇g(x) = 0` and `g(x) = 1`. For `r > 0`, `U_r` is an invertible linear re-expression of +`(f(M), ∇f(M), f(S), ∇f(S))`, with determinant `12 r^{-(d+3)}` in RM §2. Hence all `2(d+1)` original observations +of `g` vanish. That is (H9). + +The owner's first falsification target therefore holds. The zero is a statement about the original values and +gradients, not a contact substitute. + +**Exact check (finite-rank Gaussian model).** Take `F = Σ ξ_m φ_m` over all monomials of degree `<= 5` in the plane, +with independent `ξ_m ~ N(0, 1/(a!b!))`. At `x = (3/5, 2/7)` and `r ∈ {1/3, 1/7, 1/19}`, the direction `g` is computed +exactly. The suite confirms: + +- `V_raw[g] = e_h`, including all six original pins. +- `g` is identical whether the pins are written raw or through RM's `U_r` rows (including the `12/r^3` row). +- For a rational `ξ`, `F_h1 - F_h2 = (h1 - h2) g` coefficientwise, and each `F_h` realizes every original target. + +The `no-endpoint-pins` and `gradient-target` mutants fail these checks. + +**N2 (what (H8) needs).** Cauchy–Schwarz bounds `|∂_z^α Cov(F(z),V_i)|` by `(Var ∂^α F(z) · Var V_i)^{1/2}`. So the +input is uniformly bounded **variances** of the divided-difference rows, not bounded raw coefficients: the fourth +row carries `12/r^3`. RM §2 supplies this through `U_r -> U_0` at second order in `L^2`. `Σ_r^{-1}` is uniformly +bounded on `O(d) × D_ρ` by compactness. The model is consistent with this: the coefficient sup-norm of `g_r - g_0` +is 1.50, 0.091 and 0.0057 at `r = 1/4, 1/16, 1/64`, a ratio of about 16 per factor 4 despite the `r^{-3}` +coefficient. Three observed ratios are consistent with `O(r^2)` but do not by themselves prove that asymptotic. The +proof is RM's analytic argument, which this observation does not replace. + +## §2 — (H10)–(H12): no `1/r` loss in the endpoint columns + +The gradient pins on `g` give `∫_0^r D^2 g(M + t u) u dt = ∇g(S) - ∇g(M) = 0`. Integrating by parts: + +- `D^2 g(M) u = -(1/r) ∫_0^r (r - t) D^3 g(M + t u)[u,u] dt` +- `D^2 g(S) u = (1/r) ∫_0^r t D^3 g(M + t u)[u,u] dt` + +Both are vector identities, so no common Rolle point is needed, and each gives the bound `(r/2) ‖D^3 g‖_∞`. That is +(H10). + +The exact check verifies both identities, for the `xx` and `xz` entries, and the bound at both endpoints. The +`no-endpoint-pins` mutant breaks the identities **and** the bound. This shows the homogeneous gradient pins are what +remove the `1/r`. + +With `α_i = f_uu(i)/r` and `β_i = ∇_⊥ f_u(i)/r`, the `h`-differences are `(h - h') g_uu(i)/r` and +`(h - h') ∇_⊥ g_u(i)/r`, each at most `(1/2)‖D^3 g‖ |h - h'|`. `A_i` and `H_x` change by `(h - h')` times bounded +second derivatives of `g`. That is (H11). The owner's second target holds: the column changes are +`O(r |h - h'|)` before the division by `r`. + +**N1 (deterministic Lipschitz).** `g` is deterministic, so every difference in (H11) is a deterministic number +bounded by a deterministic `C|h - h'|`, for every `ω`. That is stronger than the text needs. Moments enter only +through the `max(‖·‖)^{d-1}` factors in (H14). + +(H12): `H_i = D_r K_i D_r` with `D_r = diag(√r, I_{d-1})`. Sylvester's law preserves inertia, and +`det H_i = r det K_i`. So `F_j(H_i) = r F_j(K_i)` for every `j`, including the singular cases. The exact check covers +150 random rational instances in each of `d = 2, 3`, with the index computed exactly by Descartes' rule on the real-rooted +characteristic polynomial. The `unscaled-beta` mutant (no `√r` on `β`) fails. + +## §3 — (H13)–(H15): filtered determinants, moments, and the normalizer + +(H13) is RM (8), and the proof there is correct. If `X` has index `j` and `Y` does not, the segment from `X` to `Y` +contains a singular matrix `Z`. Then `|F_j(X) - F_j(Y)| = |det X - det Z|`, and `‖X - Z‖ <= ‖X - Y‖`, +`‖Z‖ <= max(‖X‖,‖Y‖)`. The determinant bound `|det X - det Z| <= n max^{n-1} ‖X - Z‖` uses `‖adj‖ <= ‖·‖^{n-1}`. + +The exact check tests the implied Frobenius form on 300 random pairs and six forced index flips across a singular +matrix, with `ε` down to `10^-6`. The `indicator-only` mutant (the bare index indicator) fails on the flips. This +confirms that the Lipschitz quantity is the filtered determinant, as the text says. + +(H14): write `T_h = F_d(K_M(h)) F_{d-1}(K_S(h)) F_j(H_x(h))` and apply +`|abc - a'b'c'| <= |a - a'||bc| + |a'||b - b'||c| + |a'b'||c - c'|`. Each difference is at most +`d max(‖·‖)^{d-1} C|h - h'|`. RM (5) gives uniform moments of all the matrices over the extra height pin, and Hölder +then gives `E|T_h - T_h'| <= C|h - h'|`. `E T_h` is the conditional expectation in (H5), because `F_h` has exactly the +conditional law given `Y_x = (0,h)`. + +**Normalizer (owner's third target).** `Z_r = E_{Q_r} W_r` is an endpoint-only functional. It does not involve +`Y_x`, so it is independent of `h`, and RM (11) makes `r^2/Z_r` uniformly bounded. The density +`p_{Y_x|U_r=v_r}(0,h)` is Gaussian with uniformly positive covariance and bounded mean, so it and its `h`-derivative +are bounded. The product rule gives (H15) with `L` uniform over `x ∈ D_ρ`, marks, frames and small `r`. No +derivative of an indicator, and no differentiation under an unbounded expectation, is used. + +**N3 (why the rate improves).** `R_{r,j}(x,·)` is `Θ(1)`, and it varies by `O(|h - h'|) = O(r^3)` across the window. +So the within-window density is flat to **relative** `O(r^3)`. The contact comparison in RM gives only `O(r)`, because +the finite-`r` spatial and index drift is common to all heights. The new proof avoids that drift by comparing at the +same `r`. + +## §4 — (H16)–(H17) and (H1) + +RM's height disintegration gives the density in `t` on Borel subwindows, so (H16) holds as an equality of finite +marked measures. By Jensen, + +`∫_0^1 |R(b - lθ) - R̄| dθ <= L l ∫∫ |θ - t| = L l/3`. + +The exact check confirms `∫∫ |θ - t| = 1/3`. It also checks the mean deviation `<= L/3` on 300 random piecewise-linear +Lipschitz profiles; the affine extremal case gives `L/4`, and the `lip-constant` mutant (`L/6`) fails. + +The comparison measure `μ^Y ⊗ λ` has the same mass `m_r`. So + +`TV <= (d+1) L l^2 |E| / (6 m_r)`, + +and the RM lower bound `m_r >= c r^3 |E|` gives `O(r^3)`, with `|E|` cancelling. That is (H1). + +## §5 — (H18)–(H20), (H2)–(H4), selectors + +`a = E[N; N >= 2] <= E[N(N-1)] = q`, because `N <= N(N-1)` for `N >= 2`. The mixture identity gives +`TV(S, μ/m) = (a/m) TV(S, η/a) <= a/m`. The factor two in (H2) comes from two separate costs: the mixture, and the +change of marginal from `π_r` to `π_{r,1}`. (H3) needs only one of them. (H4) follows because `0 <= θ <= 1`, so TV +controls `E θ` and `E θ^2` and `|Var θ - 1/12| <= 3δ`. With `l = k r^3`, the errors are `l · r^2 = O(r^5)` and +`l^2 · r^2 = O(r^8)`. + +(H20): `1{N >= 1} >= N - N(N-1)/2` and `1{N >= 2} <= N(N-1)/2`, so `ε <= q/(2m - q)`. The nonempty configuration law +is `(1 - ε)`·singletons + `ε`·multiples, and the two parts have disjoint supports, so its TV to the embedded `S_r` is +exactly `ε`. A deterministic or randomized selector agrees with `S_r` on `{N = 1}`, so its law is within `ε`. + +All of these were checked on 300 random exact configuration laws with 8 marks and up to 3 points, plus one extremal +law with an equality case: the singleton at one mark and the pair on two others. That law gives equality in both +`TV(S, μ/m) = a/m` and `ε = q/(2m - q)`, so neither bound can be tightened in general. The mutants +`a-as-probability` (using `P(N >= 2)` in place of `a`) and `eps-over-2m` fail on it. Both a min-mark selector and the +uniform randomized selector satisfy the selector bounds. + +## §6 — §7 compatibility and the (H21) barrier + +`TV(S_r, π_E ⊗ λ) <= O(r^2) + TV(π_{r,1}, π_E) = O(r)`. The given premises only establish `O(r)` here. No lower +bound or optimal Gaussian profile rate is claimed. There is no conflict with (H1)–(H3). + +The (H21) example was rebuilt exactly at `r = 1/2, 1/3, 1/10, 1/50`: + +- The mean is exactly `m × Unif{A,B} × Unif(0,1)`. +- `q = a = r^5`. +- The singleton height TV is `r^2/(2(1 - r^2))`, which is at most `a/m`. +- The law is valid for `r <= 1/2`, and the TV exceeds `r^3` for `r <= 1/10`. + +Within each height half the densities are constant, so bin-level TV equals the continuous TV. The example is +abstract. It shows that the two moment premises cannot give `O(r^3)`, and the text correctly does not claim a +Gaussian lower bound. + +**N4 (consistency with #116).** On the whole torus, #116's LOCAL (L3) gives `P(N >= 2 | N >= 1) >= c_0`; see my +review in [Math-#123](https://github.com/d6g8k5htny-coder/Math-/pull/123). Here `ε = O(r^2)` only on `D_ρ`. The +two statements are consistent: the fixed-`ρ` restriction is exactly what separates them, and #120 claims nothing +global. + +**N5 (dimension).** RM and RC Corollary D both hold for every fixed `d >= 2`, so #120's `d >= 2` scope is +supported. Constants depend on `d, L, ρ, B, K`. + +**N6 (candidate C5).** #120 does not consume #116's `HEIGHT_MARKS.md`. It proves a different, own-marginal target. +Nothing here reviews C5. + +## Checks run + +``` +python3 -B -S verify.py # author packet at f3e1658 (git archive): PASS, 12 tests, 5 mutants per mode +python3 -B -S height_exact_check.py # rc 0, stdout == RESULTS.json +python3 -B -O -S height_exact_check.py # rc 0, byte-identical +python3 -B -S height_exact_check.py --mutant M # rc 1 for each of the nine mutants: + no-endpoint-pins gradient-target unscaled-beta indicator-only lip-constant + eps-over-2m a-as-probability p2-r6 var-l +``` + +Python standard library only. The workflow `.github/workflows/remote-height-review.yml` verifies the packet tree +against `SOURCE_FILES.json`, replays both modes and requires every mutant to be rejected. + +## Not established here + +- RM's own premises: the covariance floor, the moments (5) and the Kac–Rice formula (12). They are consumed as + written, with RM's existing review status. +- Any `ρ -> 0`, global, `k -> 0`, unbounded-mark or random-domain statement. The text excludes all of these. +- Numerical `C`, `r_*`, or an optimal Gaussian rate. +- Organizational independence: all lanes share one GitHub account, and I wrote RC. + +## Revision history + +- **v1**, reviewing head `f3e1658`: initial packet. +- **v2**, responding to [owner comment 5879827321](https://github.com/d6g8k5htny-coder/Math-/pull/123#issuecomment-5879827321). + Wording only; no verdict, check or source changes. + - §6 no longer infers from an `O(r)` upper bound that the contact-profile rate "cannot be better". The given + premises establish only `O(r)`, and no lower bound is claimed. + - N2 now presents the three finite-rank ratios as consistent with `O(r^2)`, not as a proof of it. diff --git a/reviews/remote_height_claude_20260928/SOURCE_FILES.json b/reviews/remote_height_claude_20260928/SOURCE_FILES.json new file mode 100644 index 000000000..1443b3dab --- /dev/null +++ b/reviews/remote_height_claude_20260928/SOURCE_FILES.json @@ -0,0 +1,33 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "NONAUTHOR_REVIEW", + "reviewed_object": { + "pr": "d6g8k5htny-coder/Math-#120", + "head": "f3e16585338e4c4dc878df43f9117b1b3ed5a479", + "path": "frontiers/remote_height_decoupling_20260928/PROOF.md", + "git_blob": "4d7af587db20515955585732d8150d912c89c0e4", + "bytes": 13747, + "sha256": "67249f0311342beab7833cb60c3239d9888df96befda4fbae3ec29a66f8cd78e" + }, + "files": [ + { + "path": "REVIEW.md", + "bytes": 15257, + "sha256": "ebd045805855817821815d70acc811fe4c4b65a9db4a9f605fc2fdf611445489", + "git_blob": "1cc9afe98ba48bac5699f76021d339476b061e5e" + }, + { + "path": "height_exact_check.py", + "bytes": 21277, + "sha256": "52e24dd08961589baee06f4777b3fafdb53f7d1f61865201ba5dcd97c897e0c4", + "git_blob": "01ac919b2bbf7fcd6c9f276a6294478c5f5ce698" + }, + { + "path": "RESULTS.json", + "bytes": 1786, + "sha256": "a758f43296ce43c727667201846cc7458834d8686da05b4fed4a6e70774d6608", + "git_blob": "914ccba4c12b304457449f5786878bd962345f69" + } + ] +} diff --git a/reviews/remote_height_claude_20260928/height_exact_check.py b/reviews/remote_height_claude_20260928/height_exact_check.py new file mode 100644 index 000000000..01ac919b2 --- /dev/null +++ b/reviews/remote_height_claude_20260928/height_exact_check.py @@ -0,0 +1,495 @@ +"""Independent exact checks for the nonauthor review of Math-#120 +(frontiers/remote_height_decoupling_20260928/PROOF.md, remote within-window height decoupling). + +Python standard library only; exact rational arithmetic. Written after reading the author's check.py, but it +shares no code with it and tests different objects. Groups: + + REG (H7)-(H10) in an exact finite-rank Gaussian model on the plane (monomial basis of degree <= 5 with + positive coefficient variances). The regression direction g = Cov(F, V) Sigma^-1 e_h is computed + exactly. Checks: V[g] = e_h, hence the ORIGINAL endpoint values and gradients of g vanish; g is the same + whether the pins are written raw or through RM's U_r transform; the pathwise identity + F_h - F_h' = (h - h') g; the vector zero-average identity behind (H10) at both endpoints; the bound + |D^2 g(i) u| <= (r/2) sup |D^3 g|; and second-order convergence of g to its contact limit. + CONG (H12) positive congruence: det H = r det K and equal inertia, so F_j(H) = r F_j(K), for d = 2, 3. + FDET (H13) = RM (8) for the filtered determinant on random and index-changing pairs (Frobenius form, which + the operator-norm statement implies). + LIP (H17) integral of |theta - t| is 1/3; mean deviation of Lipschitz densities is at most L/3. + MIX (H18)-(H20) singleton/mean mixture, a <= q, Bonferroni, epsilon, own-marginal factor two, + configuration-level TV = epsilon, and deterministic and randomized selectors, on random exact laws. + BAR (H21) the abstract r^2 barrier: exactly flat mean, q = r^5, singleton TV = r^2/(2(1-r^2)). + MOM (H4) TV controls bounded moments; physical mean/variance power ledger. + +Not a continuum or Gaussian proof: uniform covariance floors, conditional moments and Kac-Rice are argued in +REVIEW.md. +""" +import argparse +import json +import random +import sys +from fractions import Fraction as F +from math import comb, factorial + +MUTANTS = ("no-endpoint-pins", "gradient-target", "unscaled-beta", "indicator-only", "lip-constant", + "eps-over-2m", "a-as-probability", "p2-r6", "var-l") + +# ---------------------------------------------------------------------------------------------------------- +# Exact linear algebra and polynomials +# ---------------------------------------------------------------------------------------------------------- + + +def solve(A, b): + n = len(A) + M = [list(row) + [b[i]] for i, row in enumerate(A)] + for col in range(n): + piv = next(i for i in range(col, n) if M[i][col] != 0) + M[col], M[piv] = M[piv], M[col] + pv = M[col][col] + M[col] = [x / pv for x in M[col]] + for i in range(n): + if i != col and M[i][col] != 0: + fac = M[i][col] + M[i] = [x - fac * y for x, y in zip(M[i], M[col])] + return [M[i][n] for i in range(n)] + + +def det(A): + n = len(A) + if n == 1: + return A[0][0] + return sum((-1) ** j * A[0][j] * det([row[:j] + row[j + 1:] for row in A[1:]]) for j in range(n)) + + +def charpoly(A): + """Faddeev-LeVerrier: coefficients c[0..n] of det(t I - A), c[n] = 1.""" + n = len(A) + c = [F(0)] * (n + 1) + c[n] = F(1) + Mk = [[F(0)] * n for _ in range(n)] + for k in range(1, n + 1): + AM = [[sum(A[i][l] * Mk[l][j] for l in range(n)) for j in range(n)] for i in range(n)] + Mk = [[AM[i][j] + (c[n - k + 1] if i == j else 0) for j in range(n)] for i in range(n)] + AMk = [[sum(A[i][l] * Mk[l][j] for l in range(n)) for j in range(n)] for i in range(n)] + c[n - k] = -sum(AMk[i][i] for i in range(n)) / k + return c + + +def inertia(A): + """(negatives, zeros) for a symmetric rational matrix: Descartes' rule is exact for real-rooted polynomials.""" + c = charpoly(A) + z = 0 + while c[z] == 0: + z += 1 + q = [c[i] * (-1) ** i for i in range(z, len(c))] # coefficients of p(-t)/t^z + signs = [x > 0 for x in q if x != 0] + return sum(1 for u, v in zip(signs, signs[1:]) if u != v), z + + +def Fj(A, j, mut=None): + neg, z = inertia(A) + if z or neg != j: + return F(0) + return F(1) if mut == "indicator-only" else abs(det(A)) + + +def frob2(A): + return sum(x * x for row in A for x in row) + + +DEG = 5 +BASIS = [(a, b) for a in range(DEG + 1) for b in range(DEG + 1 - a)] +WEIGHT = [F(1, factorial(a) * factorial(b)) for a, b in BASIS] # positive coefficient variances + + +def dmono(m, i, j, pt): + a, b = m + if i > a or j > b: + return F(0) + c = (factorial(a) // factorial(a - i)) * (factorial(b) // factorial(b - j)) + return c * pt[0] ** (a - i) * pt[1] ** (b - j) + + +def apply(func, coeffs): + return sum(w * dmono(m, i, j, pt) * coeffs[k] for k, m in enumerate(BASIS) for (w, i, j, pt) in func) + + +def row(func): + return [sum(w * dmono(m, i, j, pt) for (w, i, j, pt) in func) for m in BASIS] + + +def observations(r, x, kind): + O = (F(0), F(0)) + Y = [[(1, 1, 0, x)], [(1, 0, 1, x)], [(1, 0, 0, x)]] + if kind == "Y": + return Y + if kind == "U0": + U0 = [[(1, 0, 0, O)], [(1, 1, 0, O)], [(1, 2, 0, O)], [(1, 3, 0, O)], [(1, 0, 1, O)], [(1, 1, 1, O)]] + return U0 + Y + M, S = (-r / 2, F(0)), (r / 2, F(0)) + raw = [[(1, 0, 0, M)], [(1, 1, 0, M)], [(1, 0, 1, M)], [(1, 0, 0, S)], [(1, 1, 0, S)], [(1, 0, 1, S)]] + U = [[(F(1, 2), 0, 0, M), (F(1, 2), 0, 0, S)], + [(-1 / r, 0, 0, M), (1 / r, 0, 0, S)], + [(-1 / r, 1, 0, M), (1 / r, 1, 0, S)], + [(6 / r ** 2, 1, 0, M), (6 / r ** 2, 1, 0, S), (12 / r ** 3, 0, 0, M), (-12 / r ** 3, 0, 0, S)], + [(F(1, 2), 0, 1, M), (F(1, 2), 0, 1, S)], + [(-1 / r, 0, 1, M), (1 / r, 0, 1, S)]] + return {"raw": raw + Y, "U": U + Y}[kind] + + +def direction(V, e_index): + """Coefficients of g = Cov(F(.), V) Sigma^-1 e and the observation matrix A.""" + A = [row(f) for f in V] + n = len(V) + Sig = [[sum(A[k][i] * WEIGHT[i] * A[l][i] for i in range(len(BASIS))) for l in range(n)] for k in range(n)] + e = [F(0)] * n + e[e_index] = F(1) + y = solve(Sig, e) + return [WEIGHT[i] * sum(A[k][i] * y[k] for k in range(n)) for i in range(len(BASIS))], A, Sig + + +def restrict_axis(coeffs, i, j, r): + """Univariate coefficients in t of (d_x^i d_z^j g)(-r/2 + t, 0).""" + out = [F(0)] * (DEG + 1) + for k, (a, b) in enumerate(BASIS): + if coeffs[k] == 0 or i > a or j != b: + continue + c = coeffs[k] * (factorial(a) // factorial(a - i)) * factorial(b) + p = a - i # (-r/2 + t)^p + for s in range(p + 1): + out[s] += c * comb(p, s) * (-r / 2) ** (p - s) + while len(out) > 1 and out[-1] == 0: + out.pop() + return out + + +def uni_int(p, weight, r): + """integral_0^r weight(t) p(t) dt for weight 'r-t' or 't'.""" + tot = F(0) + for s, c in enumerate(p): + if weight == "t": + tot += c * r ** (s + 2) / (s + 2) + else: + tot += c * (r * r ** (s + 1) / (s + 1) - r ** (s + 2) / (s + 2)) + return tot + + +def uni_eval(p, t): + return sum(c * t ** s for s, c in enumerate(p)) + + +def uni_maxabs(p, r): + assert len(p) <= 3 + pts = [F(0), r] + if len(p) == 3 and p[2] != 0: + v = -p[1] / (2 * p[2]) + if 0 < v < r: + pts.append(v) + return max(abs(uni_eval(p, t)) for t in pts) + + +# ---------------------------------------------------------------------------------------------------------- +# Groups +# ---------------------------------------------------------------------------------------------------------- + + +def check_reg(mut): + out = {} + x = (F(3, 5), F(2, 7)) + nopin = mut == "no-endpoint-pins" + # V ends with (f_x(x), f_z(x), f(x)); the mutant conditions on the witness observations alone. + e_idx = (7 if mut == "gradient-target" else 8) - (6 if nopin else 0) + kind_r, kind_0 = ("Y", "Y") if nopin else ("U", "U0") + ok_ev, ok_pins, ok_one, ok_inv, ok_path, ok_avg, ok_bound = True, True, True, True, True, True, True + rng = random.Random(120) + for r in (F(1, 3), F(1, 7), F(1, 19)): + used = observations(r, x, "Y" if nopin else "raw") + c, A, Sig = direction(used, e_idx) + cU, _, _ = direction(observations(r, x, "U"), 8) + ok_inv &= c == cU + raw = observations(r, x, "raw") + vals = [apply(f, c) for f in raw] + target = [F(0)] * 9 + target[8] = F(1) + ok_ev &= vals == target + ok_pins &= all(v == 0 for v in vals[:6]) + ok_one &= vals[8] == 1 and vals[6] == 0 and vals[7] == 0 + # (H7): pathwise identity with one unconditioned coefficient vector xi; the conditioned copies must + # also realize every ORIGINAL target. + xi = [F(rng.randrange(-40, 41), rng.randrange(1, 9)) for _ in BASIS] + Vxi = [sum(a * z for a, z in zip(Ar, xi)) for Ar in A] + vt = [F(1, 3), F(0), F(0), F(1, 3) - F(2, 5) * r ** 3, F(0), F(0), F(0), F(0)] + + def cond(h): + a_h = (vt[6:] if nopin else vt) + [h] + y = solve(Sig, [ai - vi for ai, vi in zip(a_h, Vxi)]) + return [xi[i] + WEIGHT[i] * sum(A[k][i] * y[k] for k in range(len(A))) for i in range(len(BASIS))] + + h1, h2 = F(1, 3) - F(1, 10) * r ** 3, F(1, 3) - F(3, 10) * r ** 3 + f1, f2 = cond(h1), cond(h2) + ok_path &= all(u - v == (h1 - h2) * gi for u, v, gi in zip(f1, f2, c)) + ok_path &= [apply(f, f1) for f in raw] == vt[:6] + [F(0), F(0), h1] + # (H10): vector zero-average identity at both endpoints, for the u-column (xx and xz entries). + for (i, j) in ((2, 0), (1, 1)): + col = restrict_axis(c, i, j, r) + third = restrict_axis(c, i + 1, j, r) + at_M, at_S = uni_eval(col, F(0)), uni_eval(col, r) + ok_avg &= at_M == -uni_int(third, "r-t", r) / r and at_S == uni_int(third, "t", r) / r + bnd = r / 2 * uni_maxabs(third, r) + ok_bound &= abs(at_M) <= bnd and abs(at_S) <= bnd + out["V_g_equals_e_h_exact"] = ok_ev + out["original_endpoint_values_and_gradients_vanish"] = ok_pins + out["g_x_one_and_grad_g_x_zero"] = ok_one + out["U_r_reexpression_gives_same_g"] = ok_inv + out["pathwise_F_h_minus_F_h2_is_dh_times_g_and_targets_realized"] = ok_path + out["zero_average_identity_both_endpoints"] = ok_avg + out["column_bound_r_over_2_sup_D3"] = ok_bound + # Second-order contact convergence of the direction: ||g_r - g_0|| shrinks by >= 8 per factor 4 in r. + c0, _, _ = direction(observations(None, x, kind_0), e_idx) + ds = [] + for r in (F(1, 4), F(1, 16), F(1, 64)): + cr, _, _ = direction(observations(r, x, kind_r), e_idx) + ds.append(max(abs(u - v) for u, v in zip(cr, c0))) + out["contact_limit_second_order"] = ds[1] * 8 <= ds[0] and ds[2] * 8 <= ds[1] and ds[2] > 0 + return out + + +def check_cong(mut): + rng = random.Random(1201) + ok_det, ok_idx, ok_F = True, True, True + for n in (2, 3): + for _ in range(150): + s = F(rng.randrange(1, 20), 20) + r = s * s + alpha = F(rng.randrange(-9, 10), rng.randrange(1, 4)) + beta = [F(rng.randrange(-9, 10), rng.randrange(1, 4)) for _ in range(n - 1)] + Ab = [[F(0)] * (n - 1) for _ in range(n - 1)] + for i in range(n - 1): + for j in range(i, n - 1): + Ab[i][j] = Ab[j][i] = F(rng.randrange(-9, 10), rng.randrange(1, 4)) + sb = 1 if mut == "unscaled-beta" else s + K = [[alpha] + [sb * b for b in beta]] + [[sb * beta[i]] + Ab[i] for i in range(n - 1)] + H = [[r * alpha] + [r * b for b in beta]] + [[r * beta[i]] + Ab[i] for i in range(n - 1)] + ok_det &= det(H) == r * det(K) + ok_idx &= inertia(H) == inertia(K) + ok_F &= all(Fj(H, j) == r * Fj(K, j) for j in range(n + 1)) + return {"det_H_equals_r_det_K": ok_det, "inertia_preserved": ok_idx, "F_j_H_equals_r_F_j_K": ok_F} + + +def check_fdet(mut): + rng = random.Random(1202) + ok, flips = True, 0 + pairs = [] + for n in (2, 3): + for _ in range(150): + X = [[F(0)] * n for _ in range(n)] + E = [[F(0)] * n for _ in range(n)] + for i in range(n): + for j in range(i, n): + X[i][j] = X[j][i] = F(rng.randrange(-9, 10), rng.randrange(1, 5)) + E[i][j] = E[j][i] = F(rng.randrange(-9, 10), rng.randrange(1, 5)) + t = F(1, rng.choice((1, 10, 1000))) + pairs.append((X, [[X[i][j] + t * E[i][j] for j in range(n)] for i in range(n)])) + for eps in (F(1, 10), F(1, 1000), F(1, 10 ** 6)): # forced index change across a singular matrix + D1 = [[F(1) if i == j else F(0) for j in range(n)] for i in range(n)] + D2 = [list(rw) for rw in D1] + D1[n - 1][n - 1], D2[n - 1][n - 1] = eps, -eps + pairs.append((D1, D2)) + for X, Y in pairs: + n = len(X) + m2 = max(frob2(X), frob2(Y)) + d2 = frob2([[X[i][j] - Y[i][j] for j in range(n)] for i in range(n)]) + flips += inertia(X) != inertia(Y) + for j in range(n + 1): + diff = Fj(X, j, mut) - Fj(Y, j, mut) + ok &= diff * diff <= n * n * m2 ** (n - 1) * d2 + return {"filtered_det_lipschitz_all_pairs": ok and flips >= 6} + + +def check_lip(mut): + out = {} + # integral_0^1 integral_0^1 |theta - t| dt dtheta = integral_0^1 (theta^2/2 + (1-theta)^2/2) dtheta + out["double_integral_abs_diff_one_third"] = F(1, 6) + F(1, 6) == F(1, 3) + const = F(1, 6) if mut == "lip-constant" else F(1, 3) + rng = random.Random(1203) + Lc = F(3) + ok = True + cases = [[Lc] * 8, [-Lc] * 8] + [[F(rng.randrange(-30, 31), 10) for _ in range(8)] for _ in range(300)] + for slopes in cases: + knots = [F(5)] + for sl in slopes: + knots.append(knots[-1] + sl / 8) + mean = sum((knots[i] + knots[i + 1]) / 2 for i in range(8)) / 8 + dev = F(0) + for i in range(8): + u, v = knots[i] - mean, knots[i + 1] - mean # linear on a piece of width 1/8 + if u * v >= 0: + dev += abs(u + v) / 2 / 8 + else: + dev += (u * u + v * v) / (2 * abs(v - u)) / 8 + ok &= dev <= Lc * const + out["mean_deviation_le_L_over_3"] = ok + return out + + +def tv(p, q): + keys = set(p) | set(q) + return sum(abs(p.get(k, F(0)) - q.get(k, F(0))) for k in keys) / 2 + + +def law_stats(law): + m = sum(P * len(c) for c, P in law.items()) + mu, sig = {}, {} + for c, P in law.items(): + for pt in c: + mu[pt] = mu.get(pt, F(0)) + P + if len(c) == 1: + sig[c[0]] = sig.get(c[0], F(0)) + P + a = sum(mu.values()) - sum(sig.values()) + q = sum(P * len(c) * (len(c) - 1) for c, P in law.items()) + alpha = sum(P for c, P in law.items() if len(c) >= 2) + P1 = sum(P for c, P in law.items() if len(c) >= 1) + return m, mu, sig, a, q, alpha, P1 + + +def ymarg(d): + out = {} + for (y, th), v in d.items(): + out[y] = out.get(y, F(0)) + v + return out + + +def times_lambda(d): + return {(y, th): v / 2 for y, v in d.items() for th in (0, 1)} + + +def check_mix(mut): + rng = random.Random(1204) + marks = [(y, th) for y in range(4) for th in (0, 1)] + laws = [] + s, p = F(1, 10), F(1, 20) + laws.append({(): 1 - s - p, ((0, 0),): s, ((1, 0), (2, 1)): p}) # extremal: equality in (H19), (H20) + for _ in range(300): + w = {(): F(rng.randrange(1000, 3000))} + for mk in marks: + w[(mk,)] = F(rng.randrange(0, 60)) + for _ in range(6): + c = tuple(sorted(rng.sample(marks, 2))) + w[c] = w.get(c, F(0)) + rng.randrange(0, 6) + for _ in range(3): + c = tuple(sorted(rng.sample(marks, 3))) + w[c] = w.get(c, F(0)) + rng.randrange(0, 3) + tot = sum(w.values()) + laws.append({c: v / tot for c, v in w.items() if v}) + res = dict.fromkeys(("mixture_tv_le_a_over_m", "a_le_q", "p1_ge_m_minus_q", "bonferroni_and_multiple", + "epsilon_le_q_over_2m_minus_q", "own_marginal_factor_two", "height_marginal_bound", + "configuration_tv_equals_epsilon", "selectors_within_epsilon"), True) + for law in laws: + m, mu, sig, a, q, alpha, P1 = law_stats(law) + p1 = sum(sig.values()) + S = {k: v / p1 for k, v in sig.items()} + mun = {k: v / m for k, v in mu.items()} + abound = alpha if mut == "a-as-probability" else a + res["mixture_tv_le_a_over_m"] &= tv(S, mun) <= abound / m + res["a_le_q"] &= a <= q + res["p1_ge_m_minus_q"] &= p1 == m - a and p1 >= m - q + res["bonferroni_and_multiple"] &= P1 >= m - q / 2 and alpha <= q / 2 + eps = alpha / P1 + ebound = q / (2 * m) if mut == "eps-over-2m" else q / (2 * m - q) + res["epsilon_le_q_over_2m_minus_q"] &= 2 * m > q and eps <= ebound + base = tv(mun, times_lambda(ymarg(mun))) + pi1 = ymarg(S) + res["own_marginal_factor_two"] &= (tv(pi1, ymarg(mun)) <= tv(S, mun) + and tv(S, times_lambda(pi1)) <= 2 * a / m + base) + thS = {th: sum(v for (y, t), v in S.items() if t == th) for th in (0, 1)} + res["height_marginal_bound"] &= tv(thS, {0: F(1, 2), 1: F(1, 2)}) <= a / m + base + cond = {c: P / P1 for c, P in law.items() if c} + emb = {(k,): v for k, v in S.items()} + res["configuration_tv_equals_epsilon"] &= tv(cond, emb) == eps + det_sel, rnd_sel = {}, {} + for c, P in cond.items(): + k = min(c) + det_sel[k] = det_sel.get(k, F(0)) + P + for pt in c: + rnd_sel[pt] = rnd_sel.get(pt, F(0)) + P / len(c) + for sel in (det_sel, rnd_sel): + res["selectors_within_epsilon"] &= (tv(sel, S) <= eps and + tv(sel, times_lambda(ymarg(sel))) <= 2 * eps + tv(S, times_lambda(pi1))) + return res + + +def check_bar(mut): + ok_flat, ok_q, ok_tv, ok_nonneg, ok_beats = True, True, True, True, True + for r in (F(1, 2), F(1, 3), F(1, 10), F(1, 50)): + m = r ** 3 + p2 = r ** 6 / 2 if mut == "p2-r6" else r ** 5 / 2 + sig = {("A", 0): m / 4 - p2, ("A", 1): m / 4, ("B", 0): m / 4 - p2, ("B", 1): m / 4} + law = {c: v for c, v in (((k,), v) for k, v in sig.items())} + law[(("A", 0), ("B", 0))] = p2 + law[()] = 1 - sum(sig.values()) - p2 + mm, mu, sg, a, q, alpha, P1 = law_stats(law) + ok_flat &= mm == m and all(v == m / 4 for v in mu.values()) + ok_q &= q == r ** 5 and a == q + p1 = sum(sg.values()) + th = {t: sum(v for (y, tt), v in sg.items() if tt == t) / p1 for t in (0, 1)} + val = tv(th, {0: F(1, 2), 1: F(1, 2)}) + ok_tv &= val == r * r / (2 * (1 - r * r)) and val <= a / m + ok_nonneg &= all(v >= 0 for v in law.values()) + if r <= F(1, 10): + ok_beats &= val > r ** 3 + return {"mean_exactly_flat": ok_flat, "q_equals_r5": ok_q, "singleton_tv_r2_over_2_1_minus_r2": ok_tv, + "valid_law_r_le_half": ok_nonneg, "exceeds_r3": ok_beats} + + +def check_mom(mut): + rng = random.Random(1205) + grid = [F(i, 12) for i in range(13)] + ok = True + for _ in range(300): + P = [F(rng.randrange(0, 20)) for _ in grid] + Q = [F(rng.randrange(0, 20)) for _ in grid] + if not sum(P) or not sum(Q): + continue + P = [v / sum(P) for v in P] + Q = [v / sum(Q) for v in Q] + d = sum(abs(u - v) for u, v in zip(P, Q)) / 2 + for phi in (lambda t: t, lambda t: t * t): + ok &= abs(sum(u * phi(t) for u, t in zip(P, grid)) - sum(v * phi(t) for v, t in zip(Q, grid))) <= d + # Var(theta) perturbation: E theta = 1/2 + d1, E theta^2 = 1/3 + d2, |d_i| <= delta <= 1 => |Var - 1/12| <= 3 delta + ok_var = True + for _ in range(300): + delta = F(rng.randrange(1, 100), 100) + d1 = delta * F(rng.randrange(-100, 101), 100) + d2 = delta * F(rng.randrange(-100, 101), 100) + var = F(1, 3) + d2 - (F(1, 2) + d1) ** 2 + ok_var &= abs(var - F(1, 12)) <= 3 * delta + lpow = 3 + varpow = 1 if mut == "var-l" else 2 + return {"tv_controls_bounded_moments": ok, "variance_perturbation_3_delta": ok_var, + "mean_error_power_r5": lpow + 2 == 5, "variance_error_power_r8": varpow * lpow + 2 == 8} + + +def flatten(d): + for v in d.values(): + if isinstance(v, dict): + yield from flatten(v) + else: + yield v + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + mut = ap.parse_args().mutant + checks = {"REG_regression_direction": check_reg(mut), "CONG_congruence": check_cong(mut), + "FDET_filtered_determinant": check_fdet(mut), "LIP_window_variation": check_lip(mut), + "MIX_singleton_mixture": check_mix(mut), "BAR_r2_barrier": check_bar(mut), + "MOM_moments": check_mom(mut)} + passed = all(flatten(checks)) + print(json.dumps({"checks": checks, "passed": passed, "scientific_effect": "NONE", + "scope": "exact identities and a finite-rank Gaussian regression model only; uniform " + "covariance floors, conditional moments and Kac-Rice are argued in REVIEW.md"}, + indent=2, sort_keys=True)) + return 0 if passed else 1 + + +if __name__ == "__main__": + sys.exit(main())