Skip to content

Record the next moving P112 simple root's transported weight-16 equality. #7072

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
unpaidmoon wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Record the next moving P112 simple root's transported weight-16 equality. #7072

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
243 changes: 243 additions & 0 deletions research/p112-next-moving-simple-root/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,243 @@
# The next moving P112 simple root keeps the transported weight-16 equality

**Exhaustive finite census of one later reflected frame code. No new κ.**
The selected conditional exponent stays `781451/250000000`. Continue the
pinned simple-root order past the first moving pair, reflect by the next
simple root that moves a punctured line, rebuild that 112-line complement,
and transport the seven supports recorded for the unreflected frame. One
half-split of the rebuilt incidence kernel returns exactly those seven
transported words.

## Result

The order is the one fixed by #7017: simple-root index in
`research/p112-a3-six-flat/geometry.py`, then punctured-line index in the
120-line model of `research/p112-rank6-frame-coverage/engine.py`. All 64
pairs were evaluated. Sixteen pairs move a line, and they lie on simple
roots 0, 3, 5 and 7, four lines each. Simple roots 1, 2, 4 and 6 fix every
punctured line, so they do not rebuild a frame.

Simple root 0 is the reflection already compared in #7017. Its three later
moving punctured lines use that same reflection and the same rebuilt list.
The next simple root that moves a punctured line is index 3,

```text
α = (0, -2, 2, 0, 0, 0, 0, 0),
```

and the first punctured line it moves is index 0,

```text
β = (2, 2, 0, 0, 0, 0, 0, 0).
```

The reflection coefficient is `β·α / 4 = -1`, so

```text
s_α(β) = β + α = (2, 0, 2, 0, 0, 0, 0, 0).
```

That vector is line 2 of the pinned list. The same reflection applied to
the whole puncture fixes four lines and moves four:

| Old line | Old vector | New line | Image vector |
|---:|---|---:|---|
| 0 | `(2, 2, 0, 0, 0, 0, 0, 0)` | 2 | `(2, 0, 2, 0, 0, 0, 0, 0)` |
| 1 | `(2, -2, 0, 0, 0, 0, 0, 0)` | 3 | `(2, 0, -2, 0, 0, 0, 0, 0)` |
| 26 | `(0, 0, 2, 2, 0, 0, 0, 0)` | 16 | `(0, 2, 0, 2, 0, 0, 0, 0)` |
| 27 | `(0, 0, 2, -2, 0, 0, 0, 0)` | 17 | `(0, 2, 0, -2, 0, 0, 0, 0)` |
| 44 | `(0, 0, 0, 0, 2, 2, 0, 0)` | 44 | same line |
| 45 | `(0, 0, 0, 0, 2, -2, 0, 0)` | 45 | same line |
| 54 | `(0, 0, 0, 0, 0, 0, 2, 2)` | 54 | same line |
| 55 | `(0, 0, 0, 0, 0, 0, 2, -2)` | 55 | same line |

The image is a different orthogonal 8-frame. The rebuilt 112-line list is
the complement of that frame, in increasing position in the same 120-line
order. Its SHA256, of `json.dumps` of the 112 coordinate lists, is
`36e3ad43dbfd53d71b20cfac522fbf9c0c1c065054994b9c81767a228d7e6f3c`.
It is not the #7017 list
`a2ac7049d9eef1cff8af1eec35b084e6d261efad5311625e5356cceafe260da7`.

The seven recorded supports, in the order published with their hash, are

```text
64691900160
1034819666160
280375465144335
4772259772306660006937399132160
15509841550538713979819718082560
1216944648758260568639796318044160
3955070108453721685622467917250560
```

Their SHA256, of `json.dumps` of that sorted list, is
`ff8861dab18040c03d403a860773218df7c120d03770d701afb61b78c941e3d3`.
This package uses those integers as the set to transport. It does not rerun
the unreflected half-split or the #7017 half-split.

Transport sends each old live line to its reflected line and records the
new position. The resulting permutation of the 112 bit positions is a
bijection and fixes 62 positions. The transported supports are

```text
68451290880
1031047741680
280375477678095
4814039611113066403813140725760
15468061711732307582943976488960
1216944811960755906164784113909760
3955069945251226348097480121384960
```

Their SHA256, of `json.dumps` of that sorted list, is
`0ab33f7ea89182ea1cbc5ca06d5f3bdcaeb72a08aef3eaceb33e6a43bbb96636`.
They are seven disjoint weight-16 words and cover every rebuilt line.
They are not the untransported integers, and they are not the #7017
transported integers
`9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb`.

On that line list there are 1260 orthogonal 8-frames, and every line lies
in 90 of them. The F2 incidence matrix has rank 76. A kernel basis with an
identity on the free coordinates

```text
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 18, 20, 22, 24,
26, 28, 32, 34, 36, 40, 42, 48, 49, 50, 51, 52, 56, 58, 64, 80)
```

is orthogonal to every frame row. These free coordinates differ from the
#7017 basis. The seven transported supports meet every frame evenly. Each
of the seven untransported integers fails a frame parity.

`scan.c` lists the span of the first 18 generators and the span of the
other 18 by doubling. The basis identity makes the 36 generators
independent, so each of the `2^36` kernel words is the XOR of exactly one
pair. The scan's seen-count and the histogram both equal `68719476736`.
The words of weight 1 through 16 are exactly the seven transported
supports, and the least positive weight is 16. The weight distribution is
the same tuple recorded for the unreflected frame:

```text
0:1 16:7 20:336 22:3584 24:3752 26:10752 28:6864 30:50176
32:872613 34:2243584 36:5633600 38:21482496 40:123827424
42:275960832 44:878407488 46:1531507712 48:3797117779
50:4774038528 52:8574631520 54:8427087872 56:11893702896
58:8427087872 60:8574631520 62:4774038528 64:3797117779
66:1531507712 68:878407488 70:275960832 72:123827424
74:21482496 76:5633600 78:2243584 80:872613 82:50176
84:6864 86:10752 88:3752 90:3584 92:336 96:7 112:1
```

That agreement is a comparison of this split's histogram with the recorded
unreflected enumerator. It is a separate run, on this simple-root-3 basis.
The seven words themselves differ from both earlier support lists.

A copy of the low-weight set with one support removed compares unequal.
Clearing the top bit of a transported support produces a weight-15 word
that fails a frame parity, and the weight predicate rejects a set that
contains it. The seven untransported integers are not the low-weight set.

The same coordinate vector α is the simple root used by the D6
reflected-anchor census in discussion comment 19515229. That census
transports the #6959 anchors on a 30-line rank-10 code. It does not rebuild
this 112-line list and it does not compare these seven supports.

## Scope

Task card `replay-runtime`, priority revision 8, base
`17469fff78c22941280f04d39dc5a1faee09c840`. Scope status is **refined**.

The card asks for a new measured speedup that keeps coverage. The
revision-8 verification row instead says that faster output is not the same
coverage until checked. Open PR #7017 recorded the first moving pair and
asked whether the next simple root, in the same order, induces the same set
equality on its own rebuilt list. This package is that comparison for
simple root 3 and punctured line 0. Width 112, weight bound 16, one split
after 18 generators.

The selected record's κ is `781451/250000000`. The priority note on this
base still quotes the older displayed value `0.00310045` from PR #5599.
This package uses the selected record and leaves it unchanged.

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:25:29Z`, pagination complete) and 7013 discussion records
(fetched `2026-11-10T10:26:30Z`, pagination complete), plus 10178 local
notes at that head, with a complete local inventory. The matches were open
PR #7017, which poses this question and answers only the first pair, and
discussion comment 19514152, which records that first pair. A cache search
for “simple root 3” also hits discussion comment 19515229, the D6
reflected-anchor census named above. No open pull request and no fork
`cursor/*` branch had named this next P112 simple root. That search is not
a proof that no comment uses other wording.

This is an exhaustive finite census of two finite domains. The movement
predicate is all 64 pairs of the 8 simple roots with the 8 punctured lines;
the recorded 16 moving pairs are the completeness statement for which root
is next. The code census is all `2^36` kernel words of this one reflected
frame, through one half-split. The basis identity and the seen-count are
the completeness argument for that kernel. It is not a census of simple
roots 5 or 7, not a proof that every simple reflection preserves the
equality, not a proof that the iterator is correct for every generator
matrix, and not an unrestricted nonexistence result. A failed search was
not used. The unreflected equality of #7007, the first reflected equality
of #7017, the D6 equality of #6959, and the E6 equality of #6948 are not
claimed as this result.

## Reproduce

Python 3.12, `gcc`, and the standard library, from the repository root.
One half-split of this kernel measured about 67 seconds on 4 cores.

```sh
python3 -B scripts/research_package.py --package research/p112-next-moving-simple-root --check-only
python3 -I -B research/p112-next-moving-simple-root/verify.py
python3 -B scripts/research_package.py --package research/p112-next-moving-simple-root
```

The direct verifier prints

```text
PASS_P112_NEXT_MOVING_SIMPLE_ROOT width=112 frames=1260 dimension=36 minimum=16 supports=7 codewords=68719476736 split=18 simple=3 punctured=0 moved_lines=4 fixed_roots=4 later_roots=5,7 same_frame=false first_pair=false unreflected_census=false engine=false no_new_kappa=true
```

Outside this run: the unreflected half-split, the #7017 half-split, a
second split of this kernel, `low_weight_words`,
`research/e7-intersection-counters/engine.py`, the E6 and D6 censuses, the
frames of simple roots 5 and 7, Lean, Docker, and
`scripts/research_selected_baseline.py` as a scientific replay. The
selected record is provenance only.

## Open next questions

1. Does simple root 5, the next root after this one in the same pinned
order that moves a punctured line, induce the same set equality on its
own rebuilt list? The 64-pair scan records that root, and simple root 7
after it, but neither half-split was run. The transported integers above
belong to simple root 3. First rebuild the simple-root-5 complement and
compare one half-split with that root's transported supports.
2. Does `low_weight_words` on this simple-root-3 36-generator basis return
the same seven transported supports? This is the bit-lane iterator on
the basis pinned here, compared with
`0ab33f7ea89182ea1cbc5ca06d5f3bdcaeb72a08aef3eaceb33e6a43bbb96636`.
It is not the #7017 reflected basis and not the hash
`9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb`.
First run that iterator at one batch size on the free coordinates
pinned above.

## Credit

The 120-line coordinate order and the unreflected puncture are 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. The seven supports, their hash, and the unreflected weight
distribution are the recorded result of open PR #7007. The first moving
pair, the question answered here, and the doubling half-split are from
open PR #7017. This scanner reads a different basis. The D6 use of the
same simple-root vector is discussion comment 19515229 and is a different
code.

Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0.
No independent human review and no formal-kernel acceptance are claimed.
30 changes: 30 additions & 0 deletions research/p112-next-moving-simple-root/SOURCES.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,30 @@
{
"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/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"
}
]
}
67 changes: 67 additions & 0 deletions research/p112-next-moving-simple-root/TASK.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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 the next simple root, in the #7017 pinned order, that moves a punctured line induce the same weight-16 set equality on its own rebuilt 112-line list?",
"scope_change_reason": "The replay-runtime card asks for a measured speedup. The revision-8 verification row says a published faster replay is not equivalent coverage until checked. Open PR #7017 recorded the first moving pair and asked whether the next simple root preserves the transported weight-16 equality. This package answers that question for the next root only. It does not time an engine or rerun the first reflection.",
"bottleneck_link": "Frame-code coverage checks remain usable only when the low-weight set still matches after the root list changes. This comparison binds the seven recorded supports to the next reflected P112 frame. It does not change a supplier bill or the selected kappa.",
"budget_minutes": 60,
"stop_rule": "Stop after the next simple root that moves a punctured line, one rebuilt 112-line list, and one half-split compared with the transported supports. Do not half-split a later simple root, rerun the first reflection, or call the bit-lane or intersection-counter engines.",
"outcome": "completed",
"evidence": "The 8 by 8 scan moves 16 pairs, on simple roots 0, 3, 5 and 7. Roots 1, 2, 4 and 6 fix every punctured line. The next simple root after the #7017 root is alpha=(0,-2,2,0,0,0,0,0), and its first moved punctured line is (2,2,0,0,0,0,0,0), sent to (2,0,2,0,0,0,0,0). The image frame moves four lines and is a different orthogonal 8-frame. The rebuilt 112-line complement has SHA256 36e3ad43dbfd53d71b20cfac522fbf9c0c1c065054994b9c81767a228d7e6f3c. Transporting the seven recorded supports gives SHA256 0ab33f7ea89182ea1cbc5ca06d5f3bdcaeb72a08aef3eaceb33e6a43bbb96636. The incidence matrix has 1260 rows, rank 76 and kernel dimension 36, with free coordinates distinct from the #7017 basis. One half-split after 18 generators visits all 68719476736 kernel words and returns exactly those seven weight-16 supports. The weight distribution equals the distribution recorded for the unreflected frame. The seven untransported integers fail frame parity. Selected kappa stays 781451/250000000.",
"author": "unpaidmoon",
"ai_assistance": "Substantial Cursor Grok assistance.",
"open_questions": [
{
"question": "Does simple root 5, the next root after this one in the same pinned order that moves a punctured line, induce the same set equality on its own rebuilt list?",
"why_it_matters": "This census is simple root 3 only. The 64-pair scan records simple roots 5 and 7 as later moving roots, and a different root produces a different frame, so these transported integers do not answer them.",
"first_step": "Rebuild the simple-root-5 112-line complement and compare one half-split with that root's transported supports.",
"blocked_by": "This package stops once simple root 3 has been compared."
},
{
"question": "Does low_weight_words on this simple-root-3 36-generator basis return the same seven transported supports?",
"why_it_matters": "The half-split is one enumeration of this kernel. The bit-lane iterator is a different procedure. This basis and hash 0ab33f7ea89182ea1cbc5ca06d5f3bdcaeb72a08aef3eaceb33e6a43bbb96636 are not the #7017 basis or hash 9ce7e5edc72ee3104d62cb068146b73840e9a3c42c4132403dece70c8146cccb.",
"first_step": "Run low_weight_words at one batch size on the free coordinates pinned here and compare it with support hash 0ab33f7ea89182ea1cbc5ca06d5f3bdcaeb72a08aef3eaceb33e6a43bbb96636.",
"blocked_by": "This package does not call low_weight_words."
}
]
}
22 changes: 22 additions & 0 deletions research/p112-next-moving-simple-root/VERIFY.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,22 @@
{
"schema_version": 1,
"status": "ready",
"python": "3.12",
"requirements": [],
"inputs": [
"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": "Authenticate the live E8 line list and the pinned simple system. Continue the simple-root then punctured-line scan past the first moving pair, select the next simple root that moves a punctured line, rebuild its 112-line complement, and transport the seven recorded supports. Compare one half-split after 18 generators, visiting all 2^36 kernel words, with those transported supports. Reject a dropped support, a weight-15 injection, the untransported integers, and the first reflection's transported integers."
}
]
}
Loading