Record that low_weight_words matches the reflected P112 transported supports

research/p112-reflected-frame-lane/README.md

@@ -0,0 +1,206 @@
+# The reflected P112 bit-lane iterator returns the transported supports
+
+**Set comparison of one published iterator on one reflected basis. No new κ.**
+The selected conditional exponent stays `781451/250000000`. On the reflected
+36-generator basis recorded by open PR #7017, `low_weight_words` at its
+default batch size 16 returns zero and the seven transported weight-16
+supports. The SHA256 of `json.dumps` of those seven sorted integers is
+`9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb`.
+
+## Result
+
+The line list is the coordinate model in
+`research/p112-rank6-frame-coverage/engine.py`. An independent E8 builder
+reproduces that ordered list. The simple system is the eight roots in
+`research/p112-a3-six-flat/geometry.py`. Its Gram matrix divided by 4 is the
+E8 Cartan matrix, and every one of the 240 roots is an integer combination of
+these simple roots with coefficients all nonnegative or all nonpositive.
+
+In simple-root order, then punctured-line order, the first pair that moves a
+line is simple root 0,
+
+```text
+α = (1, -1, -1, -1, -1, -1, -1, 1)
+```
+
+acting on punctured line 1,
+
+```text
+β = (2, -2, 0, 0, 0, 0, 0, 0).
+```
+
+The image is `(1, -1, 1, 1, 1, 1, 1, -1)`, line 88 of the pinned list. The
+reflection fixes four punctured lines and moves four. The rebuilt 112-line
+complement, in increasing position, has SHA256
+`a2ac7049d9eef1cff8af1eec35b084e6d261efad5311625e5356cceafe260da7`.
+
+Transport of the seven supports recorded for the unreflected frame is a
+bijection of the 112 bit positions. The transported integers are
+
+```text
+12726038110963558112484457976320
+61084916320812443394843581087904
+2433889152476423258413102440464394
+6363012028601310481939177671680
+954453281446482856702353473856
+580303949270928947429810196
+2677278706012631304342476888735745
+```
+
+They are seven disjoint weight-16 words, they cover every rebuilt line, and
+their sorted-list SHA256 is the hash above. Each meets every orthogonal
+8-frame of the rebuilt list evenly. Each of the seven untransported integers
+fails a frame parity.
+
+On that list there are 1260 orthogonal 8-frames, and every line lies in 90
+of them. The incidence matrix has rank 76. The kernel basis with an identity
+on the free coordinates
+
+```text
+(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 17, 19, 21,
+ 25, 26, 27, 28, 30, 34, 36, 38, 42, 43, 52, 53, 54, 55, 56, 60, 68, 84)
+```
+
+has the weights recorded by PR #7017. The SHA256 of `json.dumps` of these 36
+generator integers is
+`f71157e487ad45377cb6a92651d3a8d8b1055b6978f14a44dea511049ca7da8c`.
+A local comparison during this session, against the functions in PR #7017 at
+`11af08b8ff57dc26492501b4efaffdb34d298a00`, found the same ordered basis and
+the same transported integers. That comparison is not a registered input.
+The replay rebuilds the basis from the three pinned files on this base and
+checks the hashes above.
+
+`low_weight_words` is the function in
+`research/e7-bitsliced-exhaustion/binary.py`. Its signature is
+`(generators, width, maximum, batch_bits)` and the default of `batch_bits`
+is 16. The call here is that function on this ordered basis, width 112,
+weight bound 16, batch size 16. The yield has no duplicates. It is exactly
+
+```text
+{0} ∪ {the seven transported supports}
+```
+
+Every positive yielded word has weight 16. Deleting one support makes the
+sets unequal. Clearing the top bit of the first transported support produces
+a weight-15 word outside the yield and outside the code, and the weight
+predicate rejects a set that contains it. The seven untransported integers
+are not the yielded set. The function rejects a repeated copy of the first
+generator with `binary generators must be independent`. On generators
+`(1, 2, 4)`, weight bound 1 returns `{0, 1, 2, 4}` and weight bound 0
+returns `{0}`.
+
+### Completeness of this call
+
+The domain is the span of these 36 independent generators, a set of `2^36`
+words. Batch size `k = 16` splits each coefficient vector into a low part of
+16 bits and a high part of 20 bits. The implementation walks the high part
+by the Gray recurrence of length `2^20` and, at each step, stores all `2^16`
+low parts as bit lanes. The coefficient-partition argument in
+`research/e7-bitsliced-exhaustion/PROOF.md` says every coefficient vector
+appears in exactly one batch and one lane, and the lane comparator keeps the
+words of weight at most 16. Independence, which the basis identity and the
+function's pivot check both give, makes those images distinct. This package
+checks those hypotheses on this input and compares the yielded set with the
+transported supports. It uses that published argument for the lane arithmetic
+and does not reprove it.
+
+This is an exhaustive finite census of the weight-at-most-16 words of this
+one ordered basis, through this one call at batch size 16. It is a set
+comparison with the transported hash. It is not a second half-split, not a
+census of another batch size, and not a statement about every generator
+matrix.
+
+## Scope
+
+Task card `replay-runtime`, priority revision 8, base
+`17469fff78c22941280f04d39dc5a1faee09c840`. Scope status is **refined**.
+
+The card asks for a measured speedup that keeps coverage. The revision-8
+verification row says faster output is the same coverage only after the sets
+are compared. Open PR #7017 recorded the reflected half-split and asked
+whether `low_weight_words` on this basis returns the transported supports.
+This package is that comparison at the function's default batch size.
+Width 112, weight bound 16, thirty-six generators, one call. On this
+machine the direct call took 486.22 seconds and the registered package
+runner took 278.75 seconds. Both finished inside the 600-second command
+bound. Those figures are wall-clock observations of this environment, not
+a coverage or speedup claim. The selected conditional exponent stays
+unchanged.
+
+The priority note on this base still quotes the older displayed value
+`0.00310045` from PR #5599. This package reads the selected record and
+keeps `781451/250000000`.
+
+Ordered overlap check on 2026-11-10, after fetching upstream `main` at
+`17469fff78c22941280f04d39dc5a1faee09c840`. `scripts/find_overlap.py
+--refresh` read 339 open pull requests, including drafts (fetched
+`2026-11-10T10:27:07Z`, pagination complete) and 7013 discussion records
+(fetched `2026-11-10T10:28:11Z`, pagination complete), with 10178 local notes
+and a complete local inventory at that head. The transported hash and the
+reflected iterator question match open PR #7017 and discussion reply
+[#1166 comment 19514152](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19514152).
+Both state the question and record that the bit-lane iterator was not run.
+Open PR #7007 is the unreflected half-split and the unreflected call at
+batch size 20. Open PR #7034 is the intersection-counter refusal on the
+unreflected 36-generator basis. No fork `cursor/*` branch had named this
+reflected iterator comparison.
+
+## Reproduce
+
+Python 3.12 and the standard library, from the repository root. Assertions
+must remain enabled. The registered command is one call at batch size 16.
+
+```sh
+python3 -B scripts/research_package.py --package research/p112-reflected-frame-lane --check-only
+python3 -I -B research/p112-reflected-frame-lane/verify.py
+python3 -B scripts/research_package.py --package research/p112-reflected-frame-lane
+```
+
+The direct verifier prints
+
+```text
+PASS_P112_REFLECTED_FRAME_LANE width=112 dimension=36 batch=16 supports=7 hash=9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb half_split_rerun=false intersection_engine=false no_new_kappa=true
+```
+
+`verify.py basis` rebuilds the basis and does not call the iterator. That
+mode is not the registered comparison.
+
+Outside this run: the half-split in #7017, batch size 20 and every batch
+size other than 16, a reversed generator order, the unreflected call from
+#7007, `research/e7-intersection-counters/engine.py`, any other simple
+root, Lean, Docker, and `scripts/research_selected_baseline.py` as a
+scientific replay. The selected record is read only to require that its
+kappa string is unchanged.
+
+## Open next questions
+
+1. Does `low_weight_words` at batch size 20 on this same ordered reflected
+   basis return the same seven transported supports? Batch size 20 is the
+   size used for the unreflected basis in #7007. The published iterator says
+   the batch size changes storage and runtime only. This package executes
+   the default batch size 16, so that statement is unchecked for batch 20
+   on this basis. First call the same function at batch size 20 on the
+   generator tuple pinned by
+   `f71157e487ad45377cb6a92651d3a8d8b1055b6978f14a44dea511049ca7da8c`
+   and compare the positive words with
+   `9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb`.
+2. Does the reversed 36-tuple, at batch size 16, return the same set? The
+   iterator's result is claimed independent of generator order once the
+   rows stay independent. This package uses the free-coordinate order only.
+   First reverse that pinned tuple and repeat the batch-16 call.
+
+## Credit
+
+The 120-line coordinate order is the model in
+`research/p112-rank6-frame-coverage`, from the PR1226/PR1323 E8 listing
+used by Cinna Davis. The simple system is the one fixed in
+`research/p112-a3-six-flat/geometry.py`, from Nick Petalas's PR3161/PR3162
+lineage. `low_weight_words` and its coefficient-partition argument are Ali
+Romman's `research/e7-bitsliced-exhaustion`. The seven unreflected supports
+are the recorded result of open PR #7007. The reflection, the transported
+integers, the free coordinates, and the basis weights are the recorded
+result of open PR #7017. This package runs the iterator that #7017 left
+unrun.
+
+Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0.
+No independent human review and no formal-kernel acceptance are claimed.

research/p112-reflected-frame-lane/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "17469fff78c22941280f04d39dc5a1faee09c840",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/e7-bitsliced-exhaustion/binary.py",
+      "usage": "input",
+      "git_blob": "cad9fc43ec0244bce415a76bc61b6445ffbd7519",
+      "sha256": "e79ad4d1d4be1748cf09aacc4274a316000d4b5922f13495778892b9309dc56e"
+    },
+    {
+      "path": "research/p112-a3-six-flat/geometry.py",
+      "usage": "input",
+      "git_blob": "222ea556faf2b275f73815c4e7d0d5f1e3294f2f",
+      "sha256": "b8ac379e41f5ad83bdb6c7f7c55129fc3d9c07801ea61591478f25d72ff0b021"
+    },
+    {
+      "path": "research/p112-rank6-frame-coverage/engine.py",
+      "usage": "input",
+      "git_blob": "6afabd3777975310683e4cdc8a4e4b95f0a330ac",
+      "sha256": "b59101564855a89de04f39fd28b0a853aa3c46ce0ce99951d93d7dd018543536"
+    }
+  ]
+}

research/p112-reflected-frame-lane/TASK.json

@@ -0,0 +1,67 @@
+{
+  "schema_version": 1,
+  "task_id": "replay-runtime",
+  "priority_revision": 8,
+  "base_commit": "17469fff78c22941280f04d39dc5a1faee09c840",
+  "original_card": {
+    "id": "replay-runtime",
+    "question": "Can one measured replay bottleneck be sped up without dropping coverage?",
+    "starting_points": [
+      "scripts/run_isolated_tests.py",
+      "scripts/verify_replay_coverage.py",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Profile one isolated replay and optimize the measured bottleneck.",
+      "Design source-bound reuse with explicit dependency invalidation and negative controls."
+    ],
+    "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
+      "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
+    },
+    "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.",
+    "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.",
+    "allowed_variations": [
+      "Profile one stage or design one source-bound cache boundary."
+    ],
+    "scope_change_triggers": [
+      "Skipping coverage or comparing different fixtures to claim speedup."
+    ],
+    "overlap_terms": [
+      "replay runtime",
+      "cache invalidation",
+      "isolated tests"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Does low_weight_words at its default batch size 16, on the reflected 36-generator basis of PR #7017, return the seven transported supports with hash 9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb?",
+  "scope_change_reason": "The replay-runtime card asks for a measured speedup. The revision-8 verification row says a published faster replay is equivalent coverage only after the sets are compared. Open PR #7017 recorded the reflected P112 half-split and asked whether low_weight_words on that 36-generator basis returns the transported supports. This package answers that set comparison at the function's default batch size. It does not time an engine or rerun the half-split.",
+  "bottleneck_link": "Frame-code coverage checks remain usable only when the published bit-lane iterator returns the same low-weight set as the recorded supports. This comparison binds that iterator to the reflected P112 basis. It does not change a supplier bill or the selected kappa.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop after one call of low_weight_words at batch size 16 on this ordered reflected basis, compared with the transported support hash. Do not run another batch size, reverse the basis, rerun the half-split, or call the intersection-counter engine.",
+  "outcome": "completed",
+  "evidence": "The reflected basis rebuilt from the pinned E8 line list and simple system matches the #7017 free coordinates, basis weights, line-list hash a2ac7049d9eef1cff8af1eec35b084e6d261efad5311625e5356cceafe260da7, and transported-support hash 9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb. The 36 generators have hash f71157e487ad45377cb6a92651d3a8d8b1055b6978f14a44dea511049ca7da8c. low_weight_words at batch size 16 returns exactly zero and those seven weight-16 supports, with no repeated yield. A dropped support, a weight-15 injection, the untransported integers, a repeated generator, and a toy bound change all fail. Selected kappa stays 781451/250000000.",
+  "author": "unpaidmoon",
+  "ai_assistance": "Substantial Cursor Grok assistance.",
+  "open_questions": [
+    {
+      "question": "Does low_weight_words at batch size 20 on this same ordered reflected basis return the same seven transported supports?",
+      "why_it_matters": "Batch size 20 is the size used for the unreflected basis in #7007. The iterator says batch size changes storage and runtime only. This package executes the default batch size 16, so that claim is unchecked at batch 20 on this basis.",
+      "first_step": "Call low_weight_words at batch size 20 on the generator tuple with hash f71157e487ad45377cb6a92651d3a8d8b1055b6978f14a44dea511049ca7da8c and compare the positive words with hash 9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb.",
+      "blocked_by": "This package stops after the batch-16 call. A second scan is a separate execution."
+    },
+    {
+      "question": "Does the reversed 36-tuple, at batch size 16, return the same set?",
+      "why_it_matters": "The iterator's result is claimed independent of generator order once the rows stay independent. This package uses the free-coordinate order only.",
+      "first_step": "Reverse the pinned generator tuple and repeat the batch-16 call against the same transported hash.",
+      "blocked_by": "This package does not reverse the basis."
+    }
+  ]
+}

research/p112-reflected-frame-lane/VERIFY.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/e7-bitsliced-exhaustion/binary.py",
+    "research/p112-a3-six-flat/geometry.py",
+    "research/p112-rank6-frame-coverage/engine.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 600,
+      "checks": "Rebuild the reflected P112 36-generator basis, require generator hash f71157e487ad45377cb6a92651d3a8d8b1055b6978f14a44dea511049ca7da8c, and compare low_weight_words at the default batch size 16 and weight 16 with the seven transported supports of hash 9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb. Reject a dropped support, a weight-15 injection, the untransported integers, a repeated generator, and a toy bound change."
+    }
+  ]
+}