From db75add2d7393a73ee2ed66dac0eea575fda857b Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Fri, 25 Sep 2026 17:06:07 +0000 Subject: [PATCH] docs(inventable): RN crosswalk, mesoscopic challenge, and Math- #8 handoff Copy the three 2026-09-25 notes and the Math- #8 eligibility patch from PR #92 onto 077464ef. Declare the pages in the hardening-branch navigation list. Soften bypass, proof-chain, and main-landing wording so OBL-H5-JETMOD and D3-LEMMA-RN-UNIF stay OPEN and SIDE24 stays ABSENT. Co-authored-by: Dylan Roy --- docs/DOWNSTREAM_RN_CROSSWALK_20260925.md | 120 ++++++++++++ docs/MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md | 71 ++++++++ docs/NAVIGATION.json | 5 +- ...MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md | 106 +++++++++++ .../math_pr8_eligibility_fix_REPORT.json | 54 ++++++ .../math_pr8_own_node_eligibility.patch | 171 ++++++++++++++++++ tests/test_navigation.py | 13 ++ 7 files changed, 539 insertions(+), 1 deletion(-) create mode 100644 docs/DOWNSTREAM_RN_CROSSWALK_20260925.md create mode 100644 docs/MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md create mode 100644 docs/RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md create mode 100644 docs/patches/math_pr8_eligibility_fix_REPORT.json create mode 100644 docs/patches/math_pr8_own_node_eligibility.patch diff --git a/docs/DOWNSTREAM_RN_CROSSWALK_20260925.md b/docs/DOWNSTREAM_RN_CROSSWALK_20260925.md new file mode 100644 index 000000000..25846fc06 --- /dev/null +++ b/docs/DOWNSTREAM_RN_CROSSWALK_20260925.md @@ -0,0 +1,120 @@ +# Downstream closure crosswalk — historical RN route versus 2026-09-24 successors + +**Date:** 2026-09-25 +**Disposition:** dependency classification only. This document changes no scientific +Boolean, frozen object, register row, or historical theorem statement. + +**Placement:** `docs/DOWNSTREAM_RN_CROSSWALK_20260925.md`. It does **not** live under +`docs/math_status/`. That packet directory is closed (`EXPECTED_NAMES`); an extra file +there fails `tools/math_status_check.py` without discharging or promoting anything. +This note is navigation and classification only. It also does **not** edit +`docs/OPEN_PROBLEMS.md`, which is byte-pinned by `tools/twelve_project_check.py`. + +## Purpose + +The hardening branch still correctly records the historical D3-LEMMA-RN-UNIF route as +OPEN: ENV-RESCOV → ALLCELL-FDZ-Q4 → LOGQ-TAIL → SYM-Fw-jet → CH-LIFT, with Piece-2, +OBL-H5-JETMOD and FREEZE downstream. Historical objects `rnu_env.py`, +`CL_ANTHROPIC_BUNDLE_2026-09-17_v5.zip`, and `allcell_fdz_enclosures.json` are recorded +ABSENT. This crosswalk prevents newer author-side proofs from being mistaken for those +absent carriers or, conversely, old route-specific walls from being silently treated as +dependencies of every newer draft. The SIDE24 prep triad on this branch stays +ABSENT as a source of truth. This crosswalk does not invent a carrier for it. + +This page is the human D0 classification companion to the in-development Math- +[downstream hard gate](https://github.com/d6g8k5htny-coder/Math-/pull/8) +(`DOWNSTREAM-HARD-GATE-20260925-v1`, main [#86](https://github.com/d6g8k5htny-coder/main/issues/86) / +[#90](https://github.com/d6g8k5htny-coder/main/issues/90)). Linking that draft has +scientific effect NONE. As of Math- head `5887a2f8`, the gate still has a load-bearing +own-node eligibility hole: dependency terminality alone can allow +`AUTHOR_SIDE_CANDIDATE` → `controlling`. Do **not** read this crosswalk as evidence +that Math- #8 already enforces every [#90](https://github.com/d6g8k5htny-coder/main/issues/90) +semantic. + +## Classification rule + +A newer draft can avoid importing a historical-route requirement only when its own +statement does not use that predicate. Avoiding the import does not set the old +predicate TRUE and does not discharge it. +Distinguish historical-route requirements, mathematical interfaces rederived by a +successor, and carrier/replay identities required only for the historical certificate. + +Terminal integrity labels used by the Math- gate (not theorem acceptance): +`PROVED_REVIEWED`, `SUPERSEDED_NONBLOCKING`, `REFUTED`, `BLOCKED_ABSENT`. Green CI, +hashes, same-author review, and navigation success are never mathematical discharge. + +## Crosswalk + +| Historical object / predicate | Math- gate node | Gate classification | Active reading | +|---|---|---|---| +| `rnu_env.py` | `hist.rnu_env.py` | `BLOCKED_ABSENT` | ABSENT; historical-route blocker only | +| `CL_ANTHROPIC_BUNDLE_2026-09-17_v5.zip` | `hist.CL_ANTHROPIC_BUNDLE_2026-09-17_v5.zip` | `BLOCKED_ABSENT` | ABSENT; historical-route blocker only | +| `allcell_fdz_enclosures.json` | `hist.allcell_fdz_enclosures.json` | `BLOCKED_ABSENT` | ABSENT; historical-route blocker only | +| ENV-RESCOV | `hist.ENV-RESCOV` | `OPEN_HISTORICAL` | OPEN for historical D3. A newer author-side draft may restate a qualitative interface; that restatement does not set this predicate TRUE and does not discharge D3-LEMMA-RN-UNIF | +| ALLCELL-FDZ-Q4 | `hist.ALLCELL-FDZ-Q4` | `OPEN_HISTORICAL` | OPEN for historical D3. The fixed-remote author-side candidate is a different statement and does not discharge this predicate | +| LOGQ-TAIL | `hist.LOGQ-TAIL` | `OPEN_HISTORICAL` | OPEN historically. A named successor draft may use a different tail statement; that does not replace or discharge this predicate | +| SYM-Fw-jet | `hist.SYM-Fw-jet` | `OPEN_HISTORICAL` | OPEN historically. An analogous interface written in a successor draft is not a discharge of this predicate | +| CH-LIFT | `hist.CH-LIFT` | `OPEN_ACTIVE` | OPEN and still mathematically relevant for shrinking charts | +| Piece-2 annulus | `hist.Piece-2-annulus` | `OPEN_ACTIVE` | OPEN; active mathematical blocker for shrinking/pin-collision regions | +| OBL-H5-JETMOD | `hist.OBL-H5-JETMOD` | `OPEN_HISTORICAL` | OPEN for historical/certificate route | +| H5-ZBAND | _(not a separate gate node)_ | — | do not conflate with newer normalizer scopes; historical predicate unchanged | +| H5-REMOTE-THRESHOLD | see D4/D5 region nodes | region inventory | Stays OPEN. A fixed-remote height/spatial candidate is a different statement and does not discharge this predicate. The shrinking/global complement stays OPEN | +| `lemma_closed` | `hist.lemma_closed` | `FALSE` | no successor is an operator fold of D3 | +| `certified_C_H` | _(register companion)_ | false | newer qualitative constants are not this certificate | + +## D4/D5 region complement (from the Math- gate) + +`COVERED_BY_CANDIDATE` below is the Math- draft gate's own label. It is not +acceptance, not a discharge of `OBL-H5-JETMOD` or `D3-LEMMA-RN-UNIF`, and not a +SIDE24 source-of-truth carrier. SIDE24 stays ABSENT. Engineering classification +is not discharge. + +| Region | Gate node | Classification | +|---|---|---| +| Fixed-remote covered set | `math.rn-region.fixed-remote` | `COVERED_BY_CANDIDATE` (draft-gate label only; not discharge) | +| Mesoscopic scaled annulus | `math.rn-region.mesoscopic-scaled-annulus` | `OPEN_ACTIVE` | +| Pin-collision | `math.rn-region.pin-collision` | `OPEN_ACTIVE` | +| Intermediate r≪\|x\|≪ρ | `math.rn-region.intermediate-r-to-rho` | `OPEN_ACTIVE` | +| Witness collision | `math.rn-region.witness-collision` | `OPEN_ACTIVE` | + +## Author-side candidates (classification only) + +These rows name drafts. They are not accepted theorems. No flag is flipped. +`OBL-H5-JETMOD` and `D3-LEMMA-RN-UNIF` stay OPEN. Engineering records are not +discharge. SIDE24 stays ABSENT; this page invents no source-of-truth carrier. + +1. UNIFORM-MATRIX-CAP-LIFETIME-20260924-v1 / main [#63](https://github.com/d6g8k5htny-coder/main/issues/63) / gate `math.uniform-matrix-cap-lifetime` (author-side candidate, not accepted here): claims a compact-mark global elder defect O(r³), unrestricted leading finite-bar density, full normalizer and marked Kac–Rice interfaces. +2. LIFETIME-BOUNDED-REMAINDER-20260924-v1 / main [#67](https://github.com/d6g8k5htny-coder/main/issues/67) / gate `math.lifetime-remainder` (author-side candidate, not accepted here): claims an unrestricted cell^(-1/3)+O(1) bound and bounded nonselected density, importing named #63 interfaces. +3. RN-FIXED-REMOTE-WINDOW-20260924-v1 / main [#76](https://github.com/d6g8k5htny-coder/main/issues/76) / gate `math.rn-fixed-remote-window` (author-side candidate, not accepted here): claims a three-determinant O(r⁵) numerator and O(r³) expected count for the between-pin height window at fixed positive spatial distance. +4. RN-MESOSCOPIC-ANNULUS-REDUCTION-20260925-v1 / [Math- PR #7](https://github.com/d6g8k5htny-coder/Math-/pull/7) (open draft) / gate `math.rn-mesoscopic-reduction`: candidate reduction for x = r y on fixed scaled annuli; exact divided-difference determinant ledger still open. + +None is a replacement carrier for the historical ABSENT files. None flips +`lemma_closed` away from false. Reading this page does not discharge +`OBL-H5-JETMOD` or `D3-LEMMA-RN-UNIF`. The Math- hard-gate draft is intended to +refuse CONTROLLING promotion while required dependencies stay non-terminal, but +until its own-node eligibility repair lands it must not be cited as a complete +[#90](https://github.com/d6g8k5htny-coder/main/issues/90) enforcer. + +## Downstream consequence + +If the goal is to reproduce/promote the historical D1/D3 certificate exactly, the +ABSENT carriers and ordered walls remain blockers. If the goal is a new author-side +statement by the 2026-09-24 analytic route, those carrier identities are not +dependencies unless explicitly imported; the named analytic-review interfaces plus +the shrinking-annulus/collision complement stay open. This page does not promote +either route. A future operator may formally retire the +historical route as superseded only through the applicable register/fold mechanism. +This crosswalk does not perform that governance action. + +## Related reading + +- [RN status (historical route walls)](math_status/STATUS_RN_UNIF.md) +- [Math status packet](math_status/README.md) — OPEN/HOLD; closed directory +- [Open problems §A5](OPEN_PROBLEMS.md) (pinned; do not rewrite for navigation) +- [Research index — RN counting](RESEARCH_INDEX.md) +- Fixed-remote candidate (external file named PROOF.md; not accepted here): [Math- remote_window PROOF](https://github.com/d6g8k5htny-coder/Math-/blob/main/frontiers/remote_window_20260924/PROOF.md) +- Mesoscopic draft: [Math- PR #7](https://github.com/d6g8k5htny-coder/Math-/pull/7) +- In-development D0–D7 hard gate (eligibility repair still open): [Math- PR #8](https://github.com/d6g8k5htny-coder/Math-/pull/8) +- Math- #8 eligibility repair handoff (main cannot push Math-): [MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md](MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md) +- Mesoscopic reduction challenge (not R17): [RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md](RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md) +- Owner surfaces: [#86](https://github.com/d6g8k5htny-coder/main/issues/86), [#90](https://github.com/d6g8k5htny-coder/main/issues/90) diff --git a/docs/MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md b/docs/MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md new file mode 100644 index 000000000..5ab2c22d4 --- /dev/null +++ b/docs/MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md @@ -0,0 +1,71 @@ +# Math- PR #8 own-node eligibility handoff + +**Object:** MATH-PR8-OWN-NODE-ELIGIBILITY-20260925-v1 +**Against:** Math- head `5887a2f8aaf121760362e6e90f9974f1e0078bc5` +**Author of the patch recipe:** Cursor, from a session that could write `main` and could not push Math-. **This copy** is on `chatgpt/drive-github-hardening-20260919`. It is not a `main` landing. **Scientific effect: NONE.** `OBL-H5-JETMOD` and `D3-LEMMA-RN-UNIF` stay OPEN. No flags are flipped. SIDE24 stays ABSENT. Engineering repair is not discharge. + +## Diagnosis + +[Math- PR #8](https://github.com/d6g8k5htny-coder/Math-/pull/8) implements the +[#90](https://github.com/d6g8k5htny-coder/main/issues/90) / [#86](https://github.com/d6g8k5htny-coder/main/issues/86) +downstream hard gate, but at head `5887a2f8` dependency terminality alone can +still allow an `AUTHOR_SIDE_CANDIDATE` node to become `controlling`. That fails +the own-node eligibility reading of #90: only a positive reviewed disposition +(`PROVED_REVIEWED`) may become controlling, and terminal dependencies remain +separately necessary. + +## Exact fix (ready to apply on Math-) + +Portable patch: [`patches/math_pr8_own_node_eligibility.patch`](patches/math_pr8_own_node_eligibility.patch) + +SHA-256 `1648237df8525276b17704d12a934cc97c12b1f1184af671ee894b65d60816f1` (8156 bytes). + +Applies on top of Math- `5887a2f8`: + +1. Add `CONTROLLING_ELIGIBLE = {PROVED_REVIEWED}` and enforce it in + `promotion_allowed()`. +2. Replace fail-open `test_promote_after_all_terminal_deps` with: + - `test_author_side_with_terminal_deps_cannot_become_controlling` (negative) + - `test_proved_reviewed_with_terminal_deps_may_become_controlling` (positive) +3. Add mutant `bypass_own_node_eligibility`; raise `EXPECTED_TESTS` to 28. +4. Refresh `RESULTS.json` / `SOURCE_FILES.json` hashes after the gate change. + +Local verification (recorded in +[`patches/math_pr8_eligibility_fix_REPORT.json`](patches/math_pr8_eligibility_fix_REPORT.json)): + +```text +28 tests, 8 distinct semantic mutations, modes normal+optimized → passed +``` + +## Why this is not a Math- push + +The session that prepared the patch could write `main` and received **403 +pushing to `d6g8k5htny-coder/Math-`** (`Permission denied to cursor[bot]`). The +repair was prepared and locally verified in a Math- worktree; it was not +published on that forge tip. This note and patch are the source-bound +eligibility recipe for an agent or owner with Math- write access. This copy +lives on the hardening branch. It does not land on `main`, does not push to +Math-, and does not merge Math- #8. + +## Apply recipe + +```sh +git clone --filter=blob:none https://github.com/d6g8k5htny-coder/Math-.git +cd Math- +git checkout 5887a2f8 +git apply /path/to/hardening-checkout/docs/patches/math_pr8_own_node_eligibility.patch +python -B -S frontiers/downstream_gate_20260925/hard_gate.py +python -B -S -m unittest discover -s frontiers/downstream_gate_20260925 -p 'test_*.py' -v +python -B -S frontiers/downstream_gate_20260925/run_validation.py --output /tmp/downstream-gate-eligibility +``` + +Then push to the Math- #8 branch (or open a successor PR) from a credential that +can write Math-. + +## Non-claims + +- Does not merge Math- #8 or main [#92](https://github.com/d6g8k5htny-coder/main/pull/92). +- Does not flip any scientific Boolean; `lemma_closed` stays false. +- Does not edit Math- PR #7 or award R17 independence credit. +- Does not touch the #91 Drive vault. +- Applying the patch would be an integrity-gate repair on Math- only. It does not discharge `OBL-H5-JETMOD` or `D3-LEMMA-RN-UNIF`, does not flip `lemma_closed`, `prizes_solved`, `discharges_OBL_H5_JETMOD`, `certified_C_H`, or `inventable_attempt_accepted`, and does not invent a source-of-truth carrier. SIDE24 stays ABSENT. Engineering repair is not discharge. The hole on the published Math- tip stays open until a Math- writer applies a repair there. diff --git a/docs/NAVIGATION.json b/docs/NAVIGATION.json index 324e71f8e..a3d21db99 100644 --- a/docs/NAVIGATION.json +++ b/docs/NAVIGATION.json @@ -12,7 +12,10 @@ "docs/RESEARCH_EXECUTION.md", "docs/RN_SIDE24.md", "docs/RN_SIDE24_DENSITY.md", - "docs/RN_SIDE24_CELL.md" + "docs/RN_SIDE24_CELL.md", + "docs/DOWNSTREAM_RN_CROSSWALK_20260925.md", + "docs/RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md", + "docs/MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md" ], "public_targets": [ { diff --git a/docs/RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md b/docs/RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md new file mode 100644 index 000000000..68b219c97 --- /dev/null +++ b/docs/RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md @@ -0,0 +1,106 @@ +# Challenge note — RN mesoscopic annulus reduction (Math- PR #7) + +**Date:** 2026-09-25 +**Disposition:** same-author technical challenge of an author-side reduction. +**Not** an R17 review record. **Not** a gate movement. Organizational independence credit is **0**. `lemma_closed` stays false. Scientific effect: NONE. `OBL-H5-JETMOD` and `D3-LEMMA-RN-UNIF` stay OPEN. No flags are flipped. SIDE24 stays ABSENT; this note invents no source-of-truth carrier. Engineering notes are not discharge. + +## Exact object + +| Field | Value | +|---|---| +| Object | `frontiers/rn_mesoscopic_20260925/PROOF.md` | +| Claim name in object | `RN-MESOSCOPIC-ANNULUS-REDUCTION-20260925-v1` | +| Math- surface | [PR #7](https://github.com/d6g8k5htny-coder/Math-/pull/7) (draft) | +| Bytes / sha256 | **7316** / `b7ef84cd1e5946c766e125e1ccff6bf611214254d35dc2e0778f019b8d48dcb9` | +| Companion recon | `RECONNAISSANCE.md` **1708** / `13b60b25326dc2bd857e54339e9ca2c75b34185d619ea24f32a60ae39fd90ec9` | +| Gate node | `math.rn-mesoscopic-reduction` (`AUTHOR_SIDE_REDUCTION`, layer D5) | + +Hash taken from the PR head branch `chatgpt/rn-mesoscopic-annulus-20260925` in this +session. A changed legitimate source needs a new declared identity. + +## What the object itself claims to establish + +1. Fixed-remote control with `dist ≥ ρ` does not cover `x = r y` with fixed + `1 < A ≤ |y| ≤ B < ∞`. +2. Raw remote gradients are the wrong witness variables as `r → 0` because residual + covariance collapses under the pin constraints. +3. After a centered divided-difference / Hermite residual map `J_r(y)`, Lemma A + asserts uniform positive-definiteness of the contact covariance on the compact + annulus away from scaled pin sites `±e₁/2`, plus uniform finite-`r` covariance / + Schur convergence. +4. After `x = r R y`, the expected count on the scaled annulus is an explicit + `r^d` spatial factor times a height window of length `k r³` times an integrand + `γ_AB`; an `O(r³)` annulus budget needs `γ_AB ≤ C r^{-d}` (or better). +5. The remaining load-bearing work is finite-dimensional: enumerate independent + `J_0(y)` rows, compute `det S_r(y)` powers, combine with the conditioned witness + Hessian determinant, and prove chart-boundary integrability. + +The object explicitly does **not** claim the exact `J_0` ledger, pin-neighborhood +limits, the `r ≪ |x| ≪ ρ` transition, witness-collision charts, or any 24-jet / +`lemma_closed` discharge. + +## Reconstruction (condensed) + +The reduction direction is coherent with the fixed-remote refusal to shrink `ρ` by +compactness alone: the parent/fixed-remote contact transform `U_r` already absorbs +the leading jet; the residual remote gradient must be re-expressed by divided +differences that remain finite at contact. Positive Fourier spectrum ⇒ vanishing +variance of a linear differential functional forces the symbol to vanish, which is +the right mechanism for Lemma A's contact positive-definiteness **once** a fixed +rank chart of independent rows is chosen. The spatial power identity +`dx = r^d dy` and height length `k r³` are elementary and correctly isolate +`γ_AB` as the remaining analytic object. + +## Challenges (do not treat as PASS_TECHNICAL) + +1. **Row list is an open hypothesis, not a lemma hypothesis.** Lemma A quantifies + over “the independent rows of `(U_0, J_0(y))`” after removing algebraic + dependence, but the object never exhibits those rows. A compactness argument + over an unspecified basis cannot be replayed. Next exact action remains §5 + item 1: enumerate gradient-plus-height contact rows after the six/eight pins. +2. **Rank-chart cover is deferred.** The “Important qualification” after Lemma A + admits that a single chart need not reach algebraic rank-change loci and that + overlap Jacobians must be controlled. Until that finite cover exists, Lemma A + is a mechanism sketch, not an annulus theorem. +3. **Pin excision must be quantitative.** Excluding `±e₁/2` from `K_AB` is + necessary, but the note gives no modulus for how close `|y ± e₁/2|` may + approach before the least eigenvalue collapses. That modulus is exactly the + pin-collision complement recorded as `math.rn-region.pin-collision` + (`OPEN_ACTIVE`) in the Math- hard gate / [D0 crosswalk](DOWNSTREAM_RN_CROSSWALK_20260925.md). +4. **`γ_AB ≤ C r^{-d}` is not evidenced.** Section 4 correctly states the target + inequality and that naive fixed-remote covariance cannot prove it. No lower or + upper contact determinant power is computed. An `O(r³)` claim for this annulus + would be an illegal promotion under [#90](https://github.com/d6g8k5htny-coder/main/issues/90) + while `math.rn-mesoscopic-reduction` stays non-terminal. +5. **Same-author / navigation non-discharge.** Green CI on Math- #7, this note, + or the hard-gate wiring cannot promote the reduction to CONTROLLING. + +## Negative controls attempted here + +| Control | Result | +|---|---| +| Re-hash PR7 `PROOF.md` / `RECONNAISSANCE.md` | Digests above; mismatch would refuse citation | +| Check object’s own “still open” list against gate D5 regions | Aligns with mesoscopic / pin-collision / intermediate / witness-collision `OPEN_ACTIVE` nodes | +| Search object text for `lemma_closed` flip or 24-jet discharge | Absent; object refuses legacy Boolean promotion | + +No symbolic `J_0` enumeration was executed in this session. That omission is why +this note is a challenge, not a technical pass. + +## Relation to downstream-first work + +| Surface | Role | +|---|---| +| [Math- #7](https://github.com/d6g8k5htny-coder/Math-/pull/7) | Object under challenge | +| [Math- #8](https://github.com/d6g8k5htny-coder/Math-/pull/8) | In-development integrity-gate draft; maps this object as `AUTHOR_SIDE_REDUCTION`; own-node eligibility repair still open | +| [main #92](https://github.com/d6g8k5htny-coder/main/pull/92) (superseded main-based PR; not this landing) / [crosswalk](DOWNSTREAM_RN_CROSSWALK_20260925.md) | Human D0/D4/D5 classification companion on this hardening branch | +| [#86](https://github.com/d6g8k5htny-coder/main/issues/86) D5 | Owns shrinking RN geometry; this note does not close D5 | + +## Verdict (informal; not an R17 `technical_verdict`) + +**AMEND-shaped challenge:** accept the reduction *framing* (wrong variables named, +compactness mechanism identified, remaining ledger isolated). Refuse any reading +that treats Lemma A or the `γ_AB` bound as established. Required amendment is the +explicit `J_0` / `det S_r` ledger on finitely many rank charts with a quantitative +pin-separation modulus. + +Gate status after this note: UNCHANGED. Independence credit: 0. `OBL-H5-JETMOD` and `D3-LEMMA-RN-UNIF` stay OPEN. No flags flip. SIDE24 stays ABSENT. Accepting the reduction framing is not a technical pass and not a discharge. diff --git a/docs/patches/math_pr8_eligibility_fix_REPORT.json b/docs/patches/math_pr8_eligibility_fix_REPORT.json new file mode 100644 index 000000000..9a444052b --- /dev/null +++ b/docs/patches/math_pr8_eligibility_fix_REPORT.json @@ -0,0 +1,54 @@ +{ + "distinct_semantic_mutations": 8, + "distinct_tests": 28, + "meaning": "same-author integrity-gate checks for main #90/#86; not analytic review or theorem acceptance", + "modes": [ + "normal", + "optimized" + ], + "passed": true, + "python": "3.12.3 (main, Mar 23 2026, 19:04:32) [GCC 13.3.0]", + "source_files": { + "D0_CI_UNBLOCK.md": { + "bytes": 2068, + "sha256": "2423fa7d3519a5ba06739cb43cc72e26db70020350338a1fa508e5adfb109643" + }, + "GRAPH.json": { + "bytes": 12191, + "sha256": "34100e8541f7b1893bbc7207d2183762b60070c443da28f670953437515ef496" + }, + "README.md": { + "bytes": 2231, + "sha256": "57776258bc5ab409fa6f784e2a9a99c6a2d37d40a537ebc0e348b405e026bae9" + }, + "RESULTS.json": { + "bytes": 5928, + "sha256": "53e6a73c47e3662b1b4613c6603a3017dbc0ce57ec3bfd5ad0f084205f164069" + }, + "SCOPE.md": { + "bytes": 2218, + "sha256": "c7b5bb0ec34f53395b96ae24edceb3b5b0a3451caf7df6205b924d40e9e9fd84" + }, + "SELECTOR_REGION.json": { + "bytes": 2753, + "sha256": "53fa0ec88e417882eff2a40e4b575c639d43b7e8787e7fb8917aa22ace79390d" + }, + "SOURCE_FILES.json": { + "bytes": 1312, + "sha256": "6ac23297cef7c0526e1b4a4b081b7b48bf6a156ed6bcb9250d71df50bd0f619e" + }, + "hard_gate.py": { + "bytes": 18185, + "sha256": "2f153ccc94245ef26394714fac79992324a649822c8171c7d67c7b2456f02b79" + }, + "run_validation.py": { + "bytes": 5680, + "sha256": "581d29958ff47a0c2b686e27a5f1fbc0d6727aa420c05b5b0e6f6222d7ea0988" + }, + "test_hard_gate.py": { + "bytes": 13250, + "sha256": "0374457a5e698a81d86c49339a02c61a2dd48092d34461a6d9ac80641981a324" + } + }, + "sources_unchanged": true +} diff --git a/docs/patches/math_pr8_own_node_eligibility.patch b/docs/patches/math_pr8_own_node_eligibility.patch new file mode 100644 index 000000000..39ad5776a --- /dev/null +++ b/docs/patches/math_pr8_own_node_eligibility.patch @@ -0,0 +1,171 @@ +diff --git a/frontiers/downstream_gate_20260925/RESULTS.json b/frontiers/downstream_gate_20260925/RESULTS.json +index 78a671c..d27c87f 100644 +--- a/frontiers/downstream_gate_20260925/RESULTS.json ++++ b/frontiers/downstream_gate_20260925/RESULTS.json +@@ -66,6 +66,7 @@ + "node": "math.rn-fixed-remote-window", + "reasons": [ + "required transitive dependency is not terminally classified", ++ "own-node classification is not CONTROLLING-eligible (need PROVED_REVIEWED; dependency terminality is not enough)", + "evidence consists only of non-discharge tokens" + ], + "refused": true +@@ -79,7 +80,8 @@ + "missing_terminal": [], + "node": "hist.ENV-RESCOV", + "reasons": [ +- "required BLOCKED_ABSENT dependency forces HOLD" ++ "required BLOCKED_ABSENT dependency forces HOLD", ++ "own-node classification is not CONTROLLING-eligible (need PROVED_REVIEWED; dependency terminality is not enough)" + ], + "required_dependencies": [ + "hist.rnu_env.py" +@@ -98,7 +100,8 @@ + ], + "node": "math.lifetime-remainder", + "reasons": [ +- "required transitive dependency is not terminally classified" ++ "required transitive dependency is not terminally classified", ++ "own-node classification is not CONTROLLING-eligible (need PROVED_REVIEWED; dependency terminality is not enough)" + ], + "required_dependencies": [ + "math.uniform-matrix-cap-lifetime" +@@ -117,7 +120,8 @@ + ], + "node": "eng.main-pr87-crosswalk", + "reasons": [ +- "required transitive dependency is not terminally classified" ++ "required transitive dependency is not terminally classified", ++ "own-node classification is not CONTROLLING-eligible (need PROVED_REVIEWED; dependency terminality is not enough)" + ], + "required_dependencies": [ + "eng.d0-packet-allowlist-fix" +@@ -136,7 +140,8 @@ + ], + "node": "math.side24-coefficient", + "reasons": [ +- "required transitive dependency is not terminally classified" ++ "required transitive dependency is not terminally classified", ++ "own-node classification is not CONTROLLING-eligible (need PROVED_REVIEWED; dependency terminality is not enough)" + ], + "required_dependencies": [ + "math.uniform-matrix-cap-lifetime" +diff --git a/frontiers/downstream_gate_20260925/SOURCE_FILES.json b/frontiers/downstream_gate_20260925/SOURCE_FILES.json +index a0c005b..785cc36 100644 +--- a/frontiers/downstream_gate_20260925/SOURCE_FILES.json ++++ b/frontiers/downstream_gate_20260925/SOURCE_FILES.json +@@ -13,8 +13,8 @@ + "sha256": "57776258bc5ab409fa6f784e2a9a99c6a2d37d40a537ebc0e348b405e026bae9" + }, + "RESULTS.json": { +- "bytes": 5308, +- "sha256": "814948372dd6fc6690d097b24a363d6075330f4645dadcae282d1a2cdce85742" ++ "bytes": 5928, ++ "sha256": "53e6a73c47e3662b1b4613c6603a3017dbc0ce57ec3bfd5ad0f084205f164069" + }, + "SCOPE.md": { + "bytes": 2218, +@@ -25,16 +25,16 @@ + "sha256": "53fa0ec88e417882eff2a40e4b575c639d43b7e8787e7fb8917aa22ace79390d" + }, + "hard_gate.py": { +- "bytes": 17698, +- "sha256": "a5a662badb7d051cff1313810f5660534a13df9573dd87ff61279739d9bcbf94" ++ "bytes": 18185, ++ "sha256": "2f153ccc94245ef26394714fac79992324a649822c8171c7d67c7b2456f02b79" + }, + "run_validation.py": { +- "bytes": 5512, +- "sha256": "1d35469d156d0e94947e853ffe60c0ef3193a45729d07b3bebf9973cdbc82627" ++ "bytes": 5680, ++ "sha256": "581d29958ff47a0c2b686e27a5f1fbc0d6727aa420c05b5b0e6f6222d7ea0988" + }, + "test_hard_gate.py": { +- "bytes": 12466, +- "sha256": "2786a4f9ea9c00eaf1cf7ca970989d623512c3d32054c4cee979b6b065dbccb6" ++ "bytes": 13250, ++ "sha256": "0374457a5e698a81d86c49339a02c61a2dd48092d34461a6d9ac80641981a324" + } + }, + "meaning": "Exact identity, not theorem correctness", +diff --git a/frontiers/downstream_gate_20260925/hard_gate.py b/frontiers/downstream_gate_20260925/hard_gate.py +index d5705e3..673a324 100644 +--- a/frontiers/downstream_gate_20260925/hard_gate.py ++++ b/frontiers/downstream_gate_20260925/hard_gate.py +@@ -22,6 +22,13 @@ TERMINAL = frozenset({ + 'BLOCKED_ABSENT', + }) + ++# Own-node eligibility for CONTROLLING (main #90). Dependency terminality is ++# separately necessary; it is not sufficient. Only a positive reviewed ++# disposition may become controlling. ++CONTROLLING_ELIGIBLE = frozenset({ ++ 'PROVED_REVIEWED', ++}) ++ + # Classifications that may appear on live nodes but are never terminal discharge. + NONTERMINAL = frozenset({ + 'OPEN_HISTORICAL', +@@ -151,6 +158,11 @@ def promotion_allowed(graph: dict[str, Any], node_id: str) -> dict[str, Any]: + reasons.append('required transitive dependency is not terminally classified') + if node.get('classification') == 'FALSE' and node_id == 'hist.lemma_closed': + reasons.append('lemma_closed register must remain FALSE; gate never promotes it') ++ if node.get('classification') not in CONTROLLING_ELIGIBLE: ++ reasons.append( ++ 'own-node classification is not CONTROLLING-eligible ' ++ '(need PROVED_REVIEWED; dependency terminality is not enough)' ++ ) + + allowed = not reasons + return { +diff --git a/frontiers/downstream_gate_20260925/run_validation.py b/frontiers/downstream_gate_20260925/run_validation.py +index ebec8bc..b260ab5 100644 +--- a/frontiers/downstream_gate_20260925/run_validation.py ++++ b/frontiers/downstream_gate_20260925/run_validation.py +@@ -8,8 +8,12 @@ import subprocess + import sys + + ROOT = Path(__file__).resolve().parent +-EXPECTED_TESTS = 27 ++EXPECTED_TESTS = 28 + MUTANTS = { ++ 'bypass_own_node_eligibility': ( ++ "if node.get('classification') not in CONTROLLING_ELIGIBLE:", ++ "if False: # bypassed own-node eligibility", ++ ), + 'allow_green_ci': ( + "only_non_discharge = bool(tokens) and all(t in non_discharge for t in tokens)", + "only_non_discharge = False", +diff --git a/frontiers/downstream_gate_20260925/test_hard_gate.py b/frontiers/downstream_gate_20260925/test_hard_gate.py +index fd16513..0c95590 100644 +--- a/frontiers/downstream_gate_20260925/test_hard_gate.py ++++ b/frontiers/downstream_gate_20260925/test_hard_gate.py +@@ -233,13 +233,25 @@ class HardGateControls(unittest.TestCase): + self.assertTrue(payload['d0_ci_unblock']['ready']) + self.assertGreaterEqual(payload['selector_region']['open_or_partial_cell_count'], 15) + +- def test_promote_after_all_terminal_deps(self): ++ def test_author_side_with_terminal_deps_cannot_become_controlling(self): + g = copy.deepcopy(self.graph) +- # Synthesize a tiny legal subgraph: make parent terminal reviewed. ++ # Dependency terminality alone must not promote an author-side candidate. + g['nodes']['math.p15-price-boundary']['classification'] = 'REFUTED' + g['nodes']['math.p15-full-price']['classification'] = 'AUTHOR_SIDE_CANDIDATE' + decision = m.promotion_allowed(g, 'math.p15-full-price') +- self.assertTrue(decision['allowed']) ++ self.assertFalse(decision['allowed']) ++ self.assertTrue(any('own-node' in r for r in decision['reasons'])) ++ applied = m.apply_promotion(g, 'math.p15-full-price') ++ self.assertFalse(applied['decision']['ok']) ++ self.assertFalse(applied['graph']['nodes']['math.p15-full-price']['controlling']) ++ ++ def test_proved_reviewed_with_terminal_deps_may_become_controlling(self): ++ g = copy.deepcopy(self.graph) ++ # Positive control: own-node PROVED_REVIEWED + terminal required deps. ++ g['nodes']['math.p15-price-boundary']['classification'] = 'REFUTED' ++ g['nodes']['math.p15-full-price']['classification'] = 'PROVED_REVIEWED' ++ decision = m.promotion_allowed(g, 'math.p15-full-price') ++ self.assertTrue(decision['allowed'], decision) + applied = m.apply_promotion(g, 'math.p15-full-price') + self.assertTrue(applied['decision']['ok']) + self.assertTrue(applied['graph']['nodes']['math.p15-full-price']['controlling']) diff --git a/tests/test_navigation.py b/tests/test_navigation.py index 0ebb2ded5..733b3d34a 100644 --- a/tests/test_navigation.py +++ b/tests/test_navigation.py @@ -117,6 +117,19 @@ def test_rn_side24_prep_triad_pages_are_declared_and_resolve(self): result=n.check(root) self.assertEqual(result['problems'],[],result) + def test_rn_crosswalk_docs_pages_are_declared_and_resolve(self): + root=Path(__file__).resolve().parents[1] + data=n.load(root) + for page in ( + 'docs/DOWNSTREAM_RN_CROSSWALK_20260925.md', + 'docs/RN_MESOSCOPIC_REDUCTION_CHALLENGE_20260925.md', + 'docs/MATH_PR8_ELIGIBILITY_HANDOFF_20260925.md', + ): + self.assertIn(page,data['pages']) + self.assertTrue((root/page).is_file(),page) + result=n.check(root) + self.assertEqual(result['problems'],[],result) + def test_navigation_pages_do_not_flip_claim_flags(self): root=Path(__file__).resolve().parents[1] data=n.load(root)