Scoped negative result: all-support R439 common-frame kernel entrances

research/r439-kernel-entrance-closure/CLAIM.json

@@ -0,0 +1,42 @@
+{
+  "worker": "astra_003",
+  "seed": 5,
+  "track": "bit supplier",
+  "base": "dd6403f774a0891093a006ae9716c02e371b1fdb",
+  "candidates": [
+    "semantic D with nonzero entrances",
+    "larger-register abelian model",
+    "all-support response-kernel entrance classification"
+  ],
+  "scope": "R439 response-kernel entrance gauges over arbitrary support, exact eligible-helper kernel spaces for first-contact frame intersections",
+  "expected_deliverable": "source-bound all-support finite classification, exact controls, no new kappa",
+  "expected_finish": "2026-10-13T21:33:50Z",
+  "scope_status": "changed",
+  "os_draw": "secrets.randbelow(100), 2026-10-13T20:53:50.688826Z",
+  "no_pinned_coordination_issue": true,
+  "overlap": {
+    "open_pr_count": 843,
+    "read_full_bodies": true,
+    "discussions": [
+      1163,
+      1166,
+      1167,
+      1233,
+      1237,
+      1210,
+      1202
+    ],
+    "closest_pr": 1179,
+    "closest_head": "a09f799fdb312e049a81f59b44f1339b5a053bbe",
+    "distinctness": "Complete linear-algebra classification for all binary supports, rather than sparse support<=4 enumeration. No imported construction."
+  },
+  "result": "366 distinct nonzero rational subspaces; 365 zero kernels; unique remaining binary direction {444,470}",
+  "final_overlap": {
+    "checked_at_utc": "2026-10-13T21:06:56.906525+00:00",
+    "open_pr_count": 844,
+    "highest_open_pr": 1247,
+    "refreshed_default_head": "dadfea6e8a78ff6ba901705f87532a71c6f5bbb8",
+    "nearest_pr_1179_unchanged": true,
+    "new_overlap_found": false
+  }
+}

research/r439-kernel-entrance-closure/PROOF.md

@@ -0,0 +1,109 @@
+# Proof of the fixed first-contact classification
+
+## 1. Precisely delimited finite problem
+
+Let `K : F₂^439 → F₂^111` be the dirty-helper response of the frozen PR589
+A/scatter/B/C word. Physical helper labels run from 222 through 660. Its D
+section has one target-only compensation matrix. The verifier independently
+replays the raw word on 661 formal dirty columns and requires that its helper
+response is exactly this D matrix; sources and helpers are restored and the
+remaining target map is `y_i ↦ y_i+x_i`.
+
+For each helper `h`, let `F_h ≤ Q^8` be the span of the frame at its first A/B
+contact. Every helper occurs, and every retained copied helper has an A contact
+before the copy. Thus omission of scatter in the first-contact extraction does
+not skip any earlier helper contact. Each `F_h` has dimension one or two.
+
+A **candidate direction** in this note is a nonzero binary vector `c` and a
+nonzero rational subspace `U` such that
+
+1. `Kc=0`;
+2. `U ⊆ F_h` for every `h ∈ supp(c)`.
+
+These are necessary conditions for the particular common-frame entrance
+mechanism: an initial helper coordinate mapped into the raw helper bank as
+column `c` is absent from D exactly when `Kc=0`; every helper carrying that
+coordinate must admit the same entrance subspace before its first frozen raw
+contact. We do not assert that these two conditions suffice for a physical
+compiler, address realization or hosted execution. We do not assert their
+necessity for differently timed or differently framed mechanisms.
+
+**Finite classification.** In this precise problem, every candidate has
+`c=e_444+e_470` and
+`U=span_Q(0,1,0,-1,1,0,1,0)`. Consequently there is only one independent binary
+candidate direction, even without a support-size bound.
+
+## 2. A finite closure covers all rational entrances
+
+Let `L` be the nonzero intersection closure of the distinct `F_h`. Because all
+generators have dimension at most two, its elements are exactly:
+
+- the distinct original lines and planes;
+- every nonzero intersection of two distinct original planes.
+
+Indeed, an intersection involving a line is either that line or zero. An
+intersection involving only planes is one plane if all are equal; otherwise
+choose two unequal ones. Their intersection has dimension at most one, and
+further intersections can only preserve that line or make it zero. This proves
+closure and completeness without sampling vectors or bounding their rational
+numerators or denominators.
+
+For any candidate with support `S`, let `V=∩_{h∈S} F_h`. Then `U⊆V`, so `V≠0`
+and `V∈L`. Define the eligible set
+
+`I(V)={h : V⊆F_h}`.
+
+All of S lies in I(V). Thus c belongs to the kernel of the column restriction
+`K|_{I(V)}`. It suffices to compute these finitely many kernels. Testing the
+maximal intersection V is enough even when U is an arbitrary subline of a
+plane: V contains the whole support's common subspace and still has every
+support helper in its eligible set. No possible candidate is discarded by
+using V rather than listing infinitely many sublines U.
+
+## 3. Exact finite certificate
+
+The certificate has 264 original rowspaces (111 lines and 153 planes). All
+`153 choose 2 = 11628` distinct plane pairs are checked. Of those, 549 have a
+one-dimensional intersection. After identifying equal rational subspaces the
+closure consists of 213 lines and 153 planes, or 366 elements.
+
+For each V, `CERTIFICATE.json` lists a rational RREF basis of V, the entire
+I(V), rank of its response matrix and a complete binary nullbasis. Column
+Gaussian elimination retains each input column's binary combination mask.
+A newly dependent column produces one null vector with a distinct highest
+input position. Those dependency vectors are independent and their count is
+`|I(V)|−rank(K|I(V))`; hence they form the full kernel, not a sparse sample.
+
+The separately implemented checker converts source spaces and certificate
+spaces to exact orthogonal Gram projectors, so equality is equality of rational
+subspaces rather than coordinate representatives. For two different planes
+A and B, it forms the residuals of A's two basis vectors after projection onto
+B. A nonzero linear combination in the joint kernel exists exactly when those
+two residual columns are dependent. It obtains that line from one nonzero
+residual coordinate and checks every residual coordinate. This yields exactly
+the same closure. Eligibility is checked by exact projection. Binary row
+elimination of all target equations independently recovers every rank and
+nullbasis.
+
+There are 365 zero kernels. The remaining space is the line U₀ stated above,
+with `I(U₀)={390,391,444,470,578,580,582}`. Its response rank is six and its
+kernel is spanned by `e_444+e_470`. Over F₂ that one-dimensional kernel has only
+one nonzero vector. The intersection `F_444 ∩ F_470` is exactly U₀ (checked
+by both engines' source geometry). Therefore every nonzero U admitted by the
+candidate pair is U₀ itself. This proves the finite classification.
+
+## 4. What the result does and does not bound
+
+For any invertible binary helper-basis matrix in this same common-first-contact
+model, independent dormant coordinates would have independent response-null
+columns. There is only one allowable nonzero column direction, so the model
+cannot provide two independent dormant coordinates. A single direction also
+has only a one-dimensional common entrance. This is an algebraic limitation
+on the stated boundary, not a global bound on gate counts or recursive moments.
+
+PR1179 constructs this direction by a restored pair shear; its finite word and
+physical costs are not re-executed here. New helpers, changed first contacts,
+nonuniform timing, later cuts, raw-word changes, changed target interfaces and
+broader address maps are outside this proof. Finite exact checking of this
+source word does not establish any inherited all-size, realization, hosting,
+precision/tape or analytic implication, or the integer-multiplication theorem.

research/r439-kernel-entrance-closure/README.md

@@ -0,0 +1,148 @@
+# R439: all-support common-frame kernel entrance classification
+
+**Scoped negative result in the bit-supplier track; no new κ.** For the fixed
+PR589 R439 word, the only nonzero binary response-null direction whose entire
+support shares a nonzero rational first-contact frame is
+
+```
+e_444 + e_470,
+U = span_Q(0, 1, 0, -1, 1, 0, 1, 0).
+```
+
+This is the same pair already constructed by Adam Gall in [PR1179](https://github.com/CrocSwap/integer-mult-bounds/pull/1179).
+The new result removes that package's support-at-most-four restriction:
+**arbitrary binary support sizes among all 439 helpers are covered**. There is
+no second independent null direction in this fixed common-entrance model.
+This does not exclude changed raw words, later chronological cuts, changed
+first-contact frames, differently timed basis changes or different physical
+interfaces.
+
+## Concrete evidence
+
+The selected record at base `dd6403f774a0891093a006ae9716c02e371b1fdb`
+selects #1094, conditional κ `0.001672660197076918`, with the unchanged #589
+bit supplier. Its actual source manifest binds the word used here. The complex
+supplier binds. The selected record, `upstream/` and predecessors are unchanged.
+
+| Object | Exact result |
+|---|---:|
+| Original dirty helper columns | 439 |
+| Distinct first-contact rowspaces | 264: 111 lines and 153 planes |
+| Helper counts by first-contact dimension | 286 at rank one; 153 at rank two |
+| Distinct plane pairs checked | 11,628 |
+| Pairs meeting in a line | 549 |
+| Complete nonzero intersection closure | 366: 213 lines and 153 planes |
+| Restricted response spaces with zero nullity | 365 |
+| Restricted response spaces with nullity one | 1 |
+| Helpers eligible at the unique surviving line | 390, 391, 444, 470, 578, 580, 582 |
+| Complete nullbasis there | `{444,470}` |
+
+The full [certificate](CERTIFICATE.json) records every subspace, every eligible
+helper set, its exact binary rank and a complete nullbasis. `verify.py` also
+rederives the raw A/scatter/B/C operator and checks equality with compensation D
+on all 661 dirty columns. COPY values are snapshots of the retained helpers;
+this finite scalar endpoint check is not a native COPY/ERASE or physical audit.
+
+The [proof](PROOF.md) explains why the finite closure covers every rational
+common entrance and every support size. The main engine uses rational RREF,
+orthogonal complements and binary column elimination. A separately written
+engine uses exact Gram projectors, two-column residual equations, and binary
+row elimination. They compare all 366 spaces and all 366 restricted response
+matrices, rather than just agreeing on final counts. Neither engine imports the
+other or PR1179's implementation.
+
+## Reproduce
+
+Python 3.10 or newer, standard library only, from the repository root:
+
+```sh
+python3 -I -B research/r439-kernel-entrance-closure/verify.py
+python3 -I -B research/r439-kernel-entrance-closure/independent.py
+python3 -I -O -B research/r439-kernel-entrance-closure/test_package.py -v
+```
+
+The first two commands print `PASS_R439_KERNEL_ENTRANCE_CLOSURE` and
+`PASS_R439_KERNEL_ENTRANCE_INDEPENDENT`, with 366 classes and the unique
+`444+470` direction. The test command checks all 4,096 binary 3×4 response
+matrices against all 16 support masks, a minimal six-helper dependency beyond
+the old cutoff, rational geometry controls, source/receipt corruptions and a
+relocated optimized replay. See [VALIDATION.json](VALIDATION.json) for the
+executed environment and results.
+
+The package also opts into the bounded registered replay:
+
+```sh
+python3.12 scripts/research_package.py --package research/r439-kernel-entrance-closure
+```
+
+The registered wrapper specifically requires Python 3.12. The standalone commands
+also pass on Python 3.14. Exact source bytes and the base commit are pinned in [SOURCES.json](SOURCES.json).
+The selected record and catalogue are historical Git provenance, not moving
+runtime inputs. This package does not rerun the selected hosted construction,
+PR1179's complete candidate, native compilation, all-size interfaces or the
+multiplication theorem.
+
+## Scope and paid-cost implication
+
+The question is whether a new binary helper direction `c` can satisfy `Kc=0`
+while every helper in its support can receive the **same nonzero rational
+entrance subspace before its original first raw contact**. The raw word and
+its first-contact frames are frozen; no helper/source/target replacements,
+free frame descent, reassigned frame paths or later-cut borrowing are allowed.
+Geometry is over Q; response coefficients are over F₂. An algebraic direction
+is necessary, not sufficient, for a compiled and hosted entrance gauge.
+
+PR1179 already supplies the known direction's finite entry/exit shear witness.
+Its inherited complete local bill is 24,252 ADDs versus 24,305, with rank mass
+5,128 versus 5,129; those construction claims are credited, **not re-executed
+here**. Its old width-eight host needs an additional rank-one idle child when
+hosting the width-seven residual, cancelling the local one-rank gain before
+adapters. Even granting free entry/exit synthesis cannot create another algebraic direction.
+This package supplies no new gate saving, physical invoice, hosted
+supplier, precision improvement or exponent saving. It closes only the hope
+that larger supports alone produce another direction under the same boundary.
+
+## Task, overlap and stopping rule
+
+OS assignment seed **5**, drawn with `secrets.randbelow(100)`, selects the bit
+supplier track in the user's assignment. The alternatives and local claim are
+in [CLAIM.json](CLAIM.json). The catalogue card is declared **changed** in
+[TASK.json](TASK.json): this investigates a nonzero-entrance necessary condition,
+not a replacement H2/K proof for frame-zero helper mixing. PR1194 already covers
+that narrower semantic-D task.
+
+Live open-PR and discussion checks preceded the experiment and submission;
+there was no pinned coordination issue, so the authorized local-claim fallback
+was used. The experiment stops after the complete intersection closure and all
+restricted kernels, with independent verification. It is not an enlarged
+random sparse-support search. All support sizes are handled by exact nullspace
+algebra. Scope exclusions remain material.
+
+## Open next questions
+
+The full fixed-first-contact common-frame question is closed by this result.
+A useful distinct next step is to choose one later chronological cut and
+recompute both the remaining response and actual current frames, then price
+all transport and restoration. Such a cut may change this necessary condition;
+the blocker is a complete, legal entry/exit and hosting contract. No wider
+search under the same frozen first-contact rule is warranted.
+
+## Credit and AI disclosure
+
+Prepared for **mightyOil** with substantial **OpenAI Codex, GPT-6 Astra**
+assistance in research, proof, implementation, verification and writing.
+The two algorithms were written by the same AI-assisted contributor; no
+independent human review or proof-assistant verification is implied.
+
+Adam Gall's #1179, pinned at `a09f799fdb312e049a81f59b44f1339b5a053bbe`,
+provides the sparse-support first-contact formulation and the known pair's
+construction. This package independently corroborates that pair and completes
+its support domain; it makes no priority claim for the gauge mechanism.
+Dugongue's #254 (`9ce32efb421132420242cfdb91ddd9eabe2c3795`) and
+Chafik Boukhalfa's #382 (`536329e6cddd37d70a6b52cbe2c2604ea18c5e83`)
+are earlier kernel-entrance precedents. DreamingOfClouds' #589
+(`a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46`) supplies the tuned word on
+eumemic's #555/#543 construction. Their original notices and license remain
+unchanged. Ali Romman's #1128 and #1043, Hanson Sun's #1079, and the broader
+kernel/retiming lineage are related work, not imported dependencies. New work
+is under the repository's Apache-2.0 license.

research/r439-kernel-entrance-closure/SOURCES.json

@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "base_commit": "dd6403f774a0891093a006ae9716c02e371b1fdb",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb",
+      "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce"
+    },
+    {
+      "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz",
+      "usage": "input",
+      "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a",
+      "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f"
+    }
+  ]
+}

research/r439-kernel-entrance-closure/TASK.json

@@ -0,0 +1,60 @@
+{
+  "schema_version": 1,
+  "task_id": "bit-helper-contract",
+  "priority_revision": 2,
+  "base_commit": "dd6403f774a0891093a006ae9716c02e371b1fdb",
+  "original_card": {
+    "id": "bit-helper-contract",
+    "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?",
+    "starting_points": [
+      "research/r439-bsection-stars-seed01/README.md",
+      "research/r439-copy-path-sharing-barrier/README.md"
+    ],
+    "methods": [
+      "Derive a replacement interface lemma and price its implementation.",
+      "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement."
+    ],
+    "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/r439-bsection-stars-seed01/verify.py"
+      ],
+      "expected": "PASS_R439_BSECTION_STARS",
+      "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.",
+    "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.",
+    "allowed_variations": [
+      "Choose one helper-star or quartet instance; narrow to one boundary implication."
+    ],
+    "scope_change_triggers": [
+      "Changing only source count or scalar addition count without an interface argument."
+    ],
+    "overlap_terms": [
+      "H2_D_frame0_targets_from_helpers",
+      "K_equals_D",
+      "helper-star"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "All-support binary response-kernel classification under fixed PR589 common first-contact rational entrance frames",
+  "scope_change_reason": "The user assigned the bit-supplier track. PR1194 already treats the catalogue card's frame-zero semantic D contract; this contribution instead closes the arbitrary-support nonzero-entrance necessary condition beyond PR1179's support<=4 census.",
+  "bottleneck_link": "No new direction means larger supports alone do not provide another dormant helper coordinate in this frozen boundary; no kappa or hosted gain follows.",
+  "budget_minutes": 40,
+  "stop_rule": "Complete all distinct first-frame intersections and all restricted binary kernels, then independently compare the full finite certificate.",
+  "outcome": "negative-result",
+  "evidence": "CERTIFICATE.json, PROOF.md, verify.py, independent.py and test_package.py",
+  "author": "mightyOil, with substantial OpenAI Codex (GPT-6 Astra) assistance",
+  "ai_assistance": "Substantial OpenAI Codex GPT-6 Astra assistance in all research, mathematics, code, verification and writing; same AI-assisted contributor wrote both algorithms; no independent human review.",
+  "open_questions": [
+    {
+      "question": "Can one named later chronological cut yield a new kernel entrance?",
+      "why_it_matters": "A later cut changes both the remaining response matrix and actual current frames, outside this closed class.",
+      "first_step": "Choose one cut, derive its remaining helper response and live frame state, then price a complete entry/exit construction.",
+      "blocked_by": "A valid physical compiler, transport/restoration and owner/window contract; no candidate has been established here."
+    }
+  ]
+}