From 1a5151e84019799d7ffa59441f2b6ee865a556e1 Mon Sep 17 00:00:00 2001 From: Mihir Srivastava Date: Thu, 22 Oct 2026 01:10:27 -0700 Subject: [PATCH 1/2] Prove all-length concave-cost floors for PR4470 receiver windows --- research/receiver-all-length-floor/README.md | 184 ++++++++++++ .../receiver-all-length-floor/RESULT.json | 141 +++++++++ .../receiver-all-length-floor/SOURCES.json | 60 ++++ research/receiver-all-length-floor/TASK.json | 125 ++++++++ .../receiver-all-length-floor/VERIFY.json | 38 +++ .../receiver-all-length-floor/test_verify.py | 135 +++++++++ research/receiver-all-length-floor/verify.py | 277 ++++++++++++++++++ 7 files changed, 960 insertions(+) create mode 100644 research/receiver-all-length-floor/README.md create mode 100644 research/receiver-all-length-floor/RESULT.json create mode 100644 research/receiver-all-length-floor/SOURCES.json create mode 100644 research/receiver-all-length-floor/TASK.json create mode 100644 research/receiver-all-length-floor/VERIFY.json create mode 100644 research/receiver-all-length-floor/test_verify.py create mode 100644 research/receiver-all-length-floor/verify.py diff --git a/research/receiver-all-length-floor/README.md b/research/receiver-all-length-floor/README.md new file mode 100644 index 0000000000..d49de70859 --- /dev/null +++ b/research/receiver-all-length-floor/README.md @@ -0,0 +1,184 @@ +# All-length floor for the 128 PR4470 receiver windows + +**Every eligible window has zero paid-cost headroom for any finite shear word +on the same three fields, with the same monotone frame boundaries.** There is +no word-length or coefficient cap. The incumbent minimizes every increasing +concave rank cost `f`, with `f(0)=0`; in particular `f(r)=r^(1-C)` for +`0 <= C < 1`. No new kappa or selected-frontier change is claimed. + +This closes the length/coefficient direction left by [#4546](https://github.com/CrocSwap/integer-mult-bounds/pull/4546) +and [#4567](https://github.com/CrocSwap/integer-mult-bounds/pull/4567), within their +fixed three-field monotone contract. Those packages enumerate bounded scalar +words. This package discards scalar coefficients and the exact endpoint after +retaining necessary temporal ancestry, then exhausts a finite acyclic frame +relaxation. It is a scoped exclusion, not a general barrier to better suppliers. + +## Contract and theorem + +The three persistent fields are `(a,b,x)`, with arbitrary initial values. Their +entrance and exit frames `S_i <= E_i` are binary subspaces of `F_2^9`. Each +constant-coefficient shear `y_i += c*y_j` requires a common frame for its two +operands. Each field's frame only grows by inclusion. Every positive movement +of dimension `r` is charged `f(r)`, including the final movement to `E_i`. +The required endpoint is `a += ca*x; b += cb*x`, with `ca,cb` in `{+1,-1}` and +`x` restored. Replacement coefficients can be arbitrary constants; the proof +does not bound their magnitudes or charge their scalar cost. + +For each of the 128 eligible adjacent pairs freshly extracted from main's +PR4470 constructor (123 phase-B and 5 cleanup-tail), every such replacement +has cost at least the incumbent's. The incumbent itself satisfies the boundary +contract, so the minimum is attained. The proof has four parts. + +### 1. Temporal ancestry is necessary + +Initially give field `i` the marker set `{i}`. At a contact of `i,j`, replace +both marker sets by their union. This is deliberately generous: a shear moves +information in only one direction and cancellations may remove information. +Induction on gates shows that every actual nonzero input dependency remains in +the marker set. Since both receiver outputs depend nontrivially on the original +`x`, their final marker sets must contain marker 2 (bit 4 in the checker). +Restoring `x` and cancelling unwanted dependencies are additional constraints +that the relaxation omits. + +Each current frame also contains the sum of the entrance subspaces associated +with its markers. Initially this is equality. A common contact frame contains +both previous frames, so their union of markers preserves this property. +This geometric induction is valid even when a scalar coefficient cancels. + +### 2. A finite graph contains every legal path + +A state consists of three marker bitmasks `M_i` and three current contact +dimensions `d_i`. For contact `i,j`, put `M=M_i union M_j`. Its frame must contain +`L=sum(S_k : k in M)` and be contained in `U=E_i intersection E_j`. Reject the +transition if `L` is not contained in `U`. Otherwise permit every integer + +`max(d_i,d_j,dim L) <= d <= dim U`. + +Set both operand dimensions to `d`, both marker sets to `M`, and charge each +positive gap `d-d_i`, `d-d_j`. We forget incidence constraints on the unknown +current frames, so this can admit extra paths, never exclude an actual one. +Once both receivers contain the source marker, termination charges every +positive gap `dim(E_i)-d_i`. + +A state-changing transition strictly increases +`sum(d_i) + sum(|M_i|)`, bounded by 36. A transition leaving the state unchanged +has zero frame cost and can be deleted: the relaxed endpoint depends only on +the markers. Thus all finite words, however long, map into this finite DAG. +The checker retains every attainable rank partition, not just a heuristic +minimum. The sum of its ranks must equal `sum(dim E_i - dim S_i)`. + +Extra monotone movements between contacts are compressed into one jump. This +cannot raise cost: for an increasing concave `f` with `f(0)=0`, +`f(u+v) <= f(u)+f(v)`. To see this for integer ranks, the first `v` discrete +slopes dominate the `v` slopes starting at `u`. This also covers split terminal +movements. Consequently the relaxed cost is a lower bound on actual cost. + +### 3. Integer capped-rank sums certify all concave tariffs + +For each relaxed partition `p` and incumbent partition `o`, the checker proves +equal rank mass and, for every `k=1,...,9`, + +`sum(min(r,k) for r in o) <= sum(min(r,k) for r in p)`. + +Let `s_k=f(k)-f(k-1)`. Concavity and monotonicity give +`s_1 >= ... >= s_9 >= 0`. The exact identity + +`f(r) = s_9*r + sum((s_k-s_(k+1))*min(r,k), k=1,...,8)` + +proves the cost order by nonnegative linear combination. Thus the certificate +uses integers only, with no root rounding or sampled exponents. It includes +the predecessors' `C=0.00302015` and every `0 <= C < 1`. + +### 4. Source-bound application and attainment + +[SOURCES.json](SOURCES.json) authenticates all seven constructor inputs before +execution. The constructor supplies candidate frames and the forward program; +its acceptance engine is not invoked. The new extractor uses chronological +entrances and per-role next-use lists for exits (including warp pre-frames). +It independently checks the incumbent's actual subspace containment and ranks. + +[RESULT.json](RESULT.json) records all 128 window indices, roles, signs, +canonical entrance/contact/exit bases, incumbent partitions and relaxed +partitions. In total there are **1,603 states and 239 window/partition pairs**; +the largest individual graph has 45 states. Every incumbent is admitted and +every integer comparison passes. Partition-count frequencies are +`{1:93, 2:9, 3:6, 4:2, 5:13, 7:4, 9:1}`. Different windows may overlap; +their gains or costs must not be summed as disjoint modifications. + +## Verification + +Python 3.12, standard library only, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/receiver-all-length-floor +``` + +The registered replay freshly extracts the windows and compares every receipt +field without rewriting it. Both registered Python commands use isolated mode; +the constructor child also gets a fresh bytecode cache namespace. The second +command runs semantic controls under `-O` with explicit checks/unittest: + +- A separate forward traversal over actual `F_2^2` subspaces covers all 1,728 + triples of comparable entrance/exit pairs (664 have a terminal path). + Every actual geometric partition is admitted by the dimension relaxation. +- The shape of window 10557 rejects the tempting cheaper partition `(1,2)` + when the old bill is `(1,1,1)`. Forgetting temporal source ancestry admits + it. Connectedness alone can contact `a,b` before `x` arrives, leaving `a` + without the required source contribution. +- Omitting an exit payment fails rank mass; incompatible equal-dimensional + frames and shrinking boundaries fail; zero-dimensional source propagation + and a next-use/warp extraction fixture pass. +- All 220 decreasing nine-step slope sequences over `{0,1/3,2/3,1}` satisfy + the exact cost expansion. A corrupted constructor input is rejected before + execution. + +The finite controls support the implementation; the all-length statement +rests on the inductions and finite-state reduction above. No formal-kernel or +independent human verification is claimed. `--write` is an authoring option, +not part of the registered replay. + +Local validation on Windows with CPython 3.12.0 passed the metadata/source-pin +check, full registered replay and all six optimized controls. A one-time +development cross-check matched all 128 indices, roles, signs, complete +subspaces and incumbent bills against #4567's separately loaded extractor at +the pinned head. That comparison is corroboration, not a replay dependency. + +## Scope, overlap, and credit + +Canonical base: `f626db5c3a3d781d8f7695038776c621651f75e1`, priority revision 7. +Coordination: [Discussion #4573](https://github.com/CrocSwap/integer-mult-bounds/discussions/4573). +The handoff-first selection and exact predecessor heads are in [TASK.json](TASK.json). +The initial overlap refresh covered 355 open PR bodies and 3,470 Discussion +records; all 5,860 tracked top-level package README/TASK notes were then +materialized and searched. Coverage is a dated search, not proof of novelty. +The older R420 all-length cleanup floor and P111 receiver census concern +different targets and tariffs; neither covers these PR4470 frame contracts. + +The historical baseline helper was attempted but stopped at absent source +packages in the sparse checkout. It is not reported as a pass. The selected +record, review, source manifest, claim and reproduction entry point were read; +the selected full cold replay is outside this local result. The selected record +remains `23/10000`. Native all-column correctness, physical lowering, stock, +precision, fixed tape, compiler and outer transfer are not reverified here. +There is no conclusion about extra fields, nonmonotone frames, changed +boundaries, nonadjacent windows, or simultaneous overlapping rewrites. + +Credit Chris R / Clear1nsight's #4546 fixed-window relaxation; Ryanson +Jonathan's #4567 broader finite census and explanation motivating this +all-length question; Cinna Davis's #4470 construction and retiming lineage; +zxv's receiver-sharing/productive-helper work; Jacob Alan Sussman and the +retained native, Clifford, geometry and outer contributors. Predecessor code +was read during development; a local probe reused #4567's extraction for +comparison. The committed extractor, state graph and cost checker are new, +and import no #4546/#4567 acceptance code. This is a separate implementation, +not a separately launched audit team. Prepared for mihir-s-05 with substantial +OpenAI Codex assistance. Apache-2.0; retained source notices are unchanged. + +## Open next questions + +Further word-length or coefficient sweeps in these fixed contracts have no +headroom under the stated tariff. A useful follow-up must explicitly change +the contract: for example, one additional field with fully charged entry, +exit, restoration and consumer work. Derive that optimistic complete budget +before implementing a search. This certificate does not decide that changed +model. [TASK.json](TASK.json) records the first step and blockers. diff --git a/research/receiver-all-length-floor/RESULT.json b/research/receiver-all-length-floor/RESULT.json new file mode 100644 index 0000000000..be079e0bcf --- /dev/null +++ b/research/receiver-all-length-floor/RESULT.json @@ -0,0 +1,141 @@ +{ + "status": "PASS_RECEIVER_ALL_LENGTH_CONCAVE_FLOOR", + "window_count": 128, + "state_count": 1603, + "partition_count": 239, + "boundary_sha256": "8cdc8a25f3d880fc398fe21aaf3c2c4668d9d453102ba7b6e5cae00cbdb578ae", + "word_length_cap": null, + "coefficient_cap": null, + "cost_scope": "Every increasing concave rank weight f with f(0)=0; in particular r^q for 0 0 and size & (size - 1) == 0, "power-of-two frame size") + return size.bit_length() - 1 + + +def constructor_data(): + # -B alone does not prevent cached imports. This child has a fresh cache + # namespace as well as isolated Python and authenticated source inputs. + code = ( + "import json,sys;sys.path.insert(0,sys.argv[1]);" + "import native_joint;candidate,programs,*_=native_joint.construct();" + "print(json.dumps([candidate,programs['forward']]))" + ) + with tempfile.TemporaryDirectory(prefix="receiver-floor-pyc-") as cache: + completed = subprocess.run( + [sys.executable, "-I", "-B", "-X", "pycache_prefix=" + cache, "-c", code, + str(ROOT / "research/joint-helper-lattice")], + check=True, capture_output=True, text=True, encoding="utf-8", timeout=120, + ) + return json.loads(completed.stdout) + + +def contacts(event): + """Persistent uses: (role, frame required before operation, frame after).""" + if event[0] == "scalar": + gate = event[1] + require(gate[0] in ("add", "copy", "scale", "clear"), "known scalar kind") + require(gate[0] != "clear" or gate[1][0] != "L", "no persistent clear") + roles = gate[1:3] if gate[0] in ("add", "copy") else gate[1:2] + return [(r[1], event[2], event[2]) for r in roles if r[0] == "L"] + if event[0] == "warp": + require(event[1][0] == "L", "persistent warp") + return [(event[1][1], event[3], event[4])] + return [] + + +def extract_windows(candidate, program): + """Next-use lists bind exits; chronology supplies entrances. + + Indices follow the inherited convention: the program with climbs removed. + Climb costs are reconstructed from the actual contact frames. + """ + events = [e for e in program if e[0] != "climb"] + uses = [[] for _ in candidate["start"]] + use_positions = [[] for _ in candidate["start"]] + for position, event in enumerate(events): + for role, before, _ in contacts(event): + uses[role].append(before) + use_positions[role].append(position) + frame_spaces = [span(basis) for basis in candidate["frames"]] + current = list(candidate["start"]) + phase = None + windows = [] + for position, event in enumerate(events): + if event[0] == "phase": + phase = event[1] + pair = events[position:position + 2] + if phase in ("B", "cleanup_tail") and len(pair) == 2 and all( + e[0] == "scalar" and e[1][0] == "add" for e in pair): + first, second = (e[1] for e in pair) + if all(r[0] == "L" for g in (first, second) for r in g[1:3]): + a, x, b, y = first[1][1], first[2][1], second[1][1], second[2][1] + coefficients = [] + for gate in (first, second): + numerator, denominator = gate[3:5] + require(denominator != 0, "nonzero coefficient denominator") + if abs(numerator) != abs(denominator): + break + coefficients.append(1 if numerator * denominator > 0 else -1) + if x == y and len({a, b, x}) == 3 and len(coefficients) == 2: + owners = (a, b, x) + exits = [] + for role in owners: + next_use = bisect_right(use_positions[role], position + 1) + exits.append(uses[role][next_use] if next_use < len(uses[role]) + else candidate["final"][role]) + windows.append({ + "index": position, "phase": phase, "roles": list(owners), + "coefficients": coefficients, + "starts": tuple(frame_spaces[current[r]] for r in owners), + "ends": tuple(frame_spaces[f] for f in exits), + "frames": tuple(frame_spaces[e[2]] for e in pair), + }) + for role, _, after in contacts(event): + current[role] = after + return windows + + +def incumbent_profile(window): + current = list(window["starts"]) + ranks = [] + for (i, j), frame in zip(((0, 2), (1, 2)), window["frames"]): + for role in (i, j): + require(current[role] <= frame, "incumbent contact containment") + gap = dimension(frame) - dimension(current[role]) + if gap: + ranks.append(gap) + current[role] = frame + for frame, end in zip(current, window["ends"]): + require(frame <= end, "incumbent exit containment") + gap = dimension(end) - dimension(frame) + if gap: + ranks.append(gap) + return tuple(sorted(ranks)) + + +def relaxed_profiles(starts, ends, required=(4, 4, 0)): + """All finite contact words, quotiented by a strictly increasing state. + + masks[i] records initial roles that can have met role i along a temporal + undirected contact path. This overapproximates scalar information flow. + dims[i] is the current contact dimension. No coefficients or word cap. + """ + if not all(s <= e for s, e in zip(starts, ends)): + return frozenset(), 0 + end_dims = tuple(map(dimension, ends)) + joins = {mask: span(v for i in range(3) if mask & (1 << i) for v in starts[i]) + for mask in range(1, 8)} + + @lru_cache(None) + def visit(masks, dims): + profiles = set() + if all(mask & needed == needed for mask, needed in zip(masks, required)): + profiles.add(tuple(sorted(e - d for d, e in zip(dims, end_dims) if e > d))) + for i, j in PAIRS: + merged = masks[i] | masks[j] + lower = joins[merged] + upper = ends[i] & ends[j] + if not lower <= upper: + continue + for contact_dim in range(max(dims[i], dims[j], dimension(lower)), dimension(upper) + 1): + next_masks, next_dims = list(masks), list(dims) + next_masks[i] = next_masks[j] = merged + next_dims[i] = next_dims[j] = contact_dim + next_state = (tuple(next_masks), tuple(next_dims)) + if next_state == (masks, dims): + continue # zero-cost self-loop; no remaining endpoint constraint + rank_before = sum(dims) + sum(mask.bit_count() for mask in masks) + rank_after = sum(next_dims) + sum(mask.bit_count() for mask in next_masks) + require(rank_after > rank_before, "strictly increasing state rank") + gaps = tuple(contact_dim - dims[k] for k in (i, j) if contact_dim > dims[k]) + for tail in visit(*next_state): + profiles.add(tuple(sorted(gaps + tail))) + return frozenset(profiles) + + profiles = visit((1, 2, 4), tuple(map(dimension, starts))) + mass = sum(end_dims) - sum(map(dimension, starts)) + require(all(sum(p) == mass for p in profiles), "all terminal gaps charged") + return profiles, visit.cache_info().currsize + + +def concave_floor(old, other): + """Integer certificate for every increasing concave f with f(0)=0. + + Equal mass and ordered capped-rank sums imply the cost ordering. + README proves the discrete-slope expansion; no floating point is used. + """ + return (sum(old) == sum(other) and all( + sum(min(r, cap) for r in old) <= sum(min(r, cap) for r in other) + for cap in range(1, 10))) + + +def boundary_record(window): + def basis(space): + out, generated = [], {0} + for vector in sorted(space): + if vector not in generated: + out.append(vector) + generated.update(x ^ vector for x in tuple(generated)) + require(generated == space, "canonical basis spans frame") + return out + names = {"starts": "start_bases", "ends": "exit_bases", "frames": "contact_bases"} + return {names.get(key, key): ([basis(s) for s in value] if key in names else value) + for key, value in window.items()} + + +def compute(): + authenticate() + windows = extract_windows(*constructor_data()) + require(len(windows) == 128, "128 eligible source windows") + require(len({w["index"] for w in windows}) == 128, "unique window indices") + require(Counter(w["phase"] for w in windows) == {"B": 123, "cleanup_tail": 5}, "phase census") + rows = [] + for window in windows: + old = incumbent_profile(window) + profiles, states = relaxed_profiles(window["starts"], window["ends"]) + require(old in profiles, "incumbent admitted at " + str(window["index"])) + require(all(concave_floor(old, p) for p in profiles), "concave floor at " + str(window["index"])) + rows.append({**boundary_record(window), "incumbent_ranks": list(old), + "relaxed_rank_partitions": [list(p) for p in sorted(profiles)], + "states": states, "concave_floor": True}) + return {"status": "PASS_RECEIVER_ALL_LENGTH_CONCAVE_FLOOR", "windows": rows, + "window_count": len(rows), "state_count": sum(r["states"] for r in rows), + "partition_count": sum(len(r["relaxed_rank_partitions"]) for r in rows), + "boundary_sha256": hashlib.sha256(canonical([boundary_record(w) for w in windows])).hexdigest(), + "word_length_cap": None, "coefficient_cap": None, + "cost_scope": "Every increasing concave rank weight f with f(0)=0; in particular r^q for 0 Date: Thu, 22 Oct 2026 01:16:32 -0700 Subject: [PATCH 2/2] Corroborate concurrent receiver certificates with exact receipt comparisons --- research/receiver-all-length-floor/PEERS.json | 26 +++++++ research/receiver-all-length-floor/README.md | 49 ++++++++++++- research/receiver-all-length-floor/TASK.json | 31 ++++++-- .../receiver-all-length-floor/VERIFY.json | 11 +++ .../compare_peers.py | 69 ++++++++++++++++++ .../peers/pr4581-RESULT.json.gz | Bin 0 -> 5588 bytes .../peers/pr4582-RESULT.json.gz | Bin 0 -> 6174 bytes research/receiver-all-length-floor/verify.py | 2 +- 8 files changed, 180 insertions(+), 8 deletions(-) create mode 100644 research/receiver-all-length-floor/PEERS.json create mode 100644 research/receiver-all-length-floor/compare_peers.py create mode 100644 research/receiver-all-length-floor/peers/pr4581-RESULT.json.gz create mode 100644 research/receiver-all-length-floor/peers/pr4582-RESULT.json.gz diff --git a/research/receiver-all-length-floor/PEERS.json b/research/receiver-all-length-floor/PEERS.json new file mode 100644 index 0000000000..3c1b9e75f6 --- /dev/null +++ b/research/receiver-all-length-floor/PEERS.json @@ -0,0 +1,26 @@ +{ + "scope": "Pinned receipt comparison only; peer code is not executed or certified.", + "attribution": "Concurrent mihir-s-05/OpenAI Codex investigations #4577 and #4572; Apache-2.0.", + "receipts": [ + { + "pr": 4581, + "head": "b154350fbf1e7d49118851ab899a733727483289", + "source_path": "research/receiver-window-all-length-floor/RESULT.json", + "url": "https://github.com/mihir-s-05/integer-mult-bounds/blob/b154350fbf1e7d49118851ab899a733727483289/research/receiver-window-all-length-floor/RESULT.json", + "git_blob": "3fec4b9b5177745b11d84214c438ff926e264694", + "payload_sha256": "da70c9292df9922377a0bf0fd1a208562a0c5861de7eca8ddac4a7fde29d568b", + "archive_sha256": "b810f7ee8bba3bdfb999f4d35b521e29172f54c65cd1527132c09dbc9bbe59e8", + "local": "peers/pr4581-RESULT.json.gz" + }, + { + "pr": 4582, + "head": "23c515a3c071a6bfdd1fe80bc67cea55f6d43643", + "source_path": "research/receiver-window-all-length-floor/RESULT.json", + "url": "https://github.com/mihir-s-05/integer-mult-bounds/blob/23c515a3c071a6bfdd1fe80bc67cea55f6d43643/research/receiver-window-all-length-floor/RESULT.json", + "git_blob": "3e13f2b641f605fc8c42359389042c2d131e3d5c", + "payload_sha256": "2d1e520641a6bfbcd2ba84654a1a34f34a4c32592dc731acd943cce658c705fc", + "archive_sha256": "b5618ca25c893614e47e4dce33465e31c1a677fe50ac0791eec749ab3a61b845", + "local": "peers/pr4582-RESULT.json.gz" + } + ] +} diff --git a/research/receiver-all-length-floor/README.md b/research/receiver-all-length-floor/README.md index d49de70859..0686c9747d 100644 --- a/research/receiver-all-length-floor/README.md +++ b/research/receiver-all-length-floor/README.md @@ -1,4 +1,12 @@ -# All-length floor for the 128 PR4470 receiver windows +# Independent receiver-window floor and peer-certificate comparison + +This package independently corroborates the concurrent all-length results in +[#4581](https://github.com/CrocSwap/integer-mult-bounds/pull/4581) and +[#4582](https://github.com/CrocSwap/integer-mult-bounds/pull/4582), and supplies +an executable comparison of their pinned receipts. All three implementations +agree on every window boundary, incumbent bill and terminal rank partition. +The contribution adds a separate three-ancestry model and exhaustive small +geometric inclusion controls, with no exclusive novelty or priority claim. **Every eligible window has zero paid-cost headroom for any finite shear word on the same three fields, with the same monotone frame boundaries.** There is @@ -143,6 +151,37 @@ development cross-check matched all 128 indices, roles, signs, complete subspaces and incumbent bills against #4567's separately loaded extractor at the pinned head. That comparison is corroboration, not a replay dependency. +## Executable comparison with concurrent certificates + +The submission refresh found [#4572](https://github.com/CrocSwap/integer-mult-bounds/discussions/4572), +[#4577](https://github.com/CrocSwap/integer-mult-bounds/discussions/4577) and the +static-contact proof in [#4574](https://github.com/CrocSwap/integer-mult-bounds/discussions/4574). +They are concurrent investigations of the same conclusion. This package was +already implemented when discovered and is offered as independent corroboration. +It does not claim to have independently audited their proof code. + +[PEERS.json](PEERS.json) pins the exact source Git blobs and SHA256 payloads for +two committed receipts, retained as unchanged gzip-compressed inputs under +`peers/`. [compare_peers.py](compare_peers.py) authenticates those bytes, expands +bases to complete binary subspaces (basis order may differ), and compares all +128 identities, phases, roles, signs, entrances, contacts, exits, incumbent +bills and 239 terminal partitions with this package's freshly verified receipt. +It executes no peer code. This is the third registered command, also runnable +directly with `python -I -O -B research/receiver-all-length-floor/compare_peers.py`. + +| Certificate | Exact head | Reported states | Matched window/partition pairs | +|---|---|---:|---:| +| #4581, directed source dependence | `b154350fbf1e7d49118851ab899a733727483289` | 1,303 | 239 | +| #4582, bidirectional source dependence | `23c515a3c071a6bfdd1fe80bc67cea55f6d43643` | 1,496 | 239 | +| This package, all three entrance-ancestry masks | See this PR head | 1,603 | 239 | + +State counts are representation-dependent, not an improvement measure. The +executable comparison certifies the common projected data, not equivalence of +all intermediate states or peer tests. The peer receipts are package-local +immutable inputs; the generic runner includes them in package invalidation and +export, while their external-origin Git blob checks are explicit in the +comparison code. They do not add pending source-history dependencies. + ## Scope, overlap, and credit Canonical base: `f626db5c3a3d781d8f7695038776c621651f75e1`, priority revision 7. @@ -150,7 +189,11 @@ Coordination: [Discussion #4573](https://github.com/CrocSwap/integer-mult-bounds The handoff-first selection and exact predecessor heads are in [TASK.json](TASK.json). The initial overlap refresh covered 355 open PR bodies and 3,470 Discussion records; all 5,860 tracked top-level package README/TASK notes were then -materialized and searched. Coverage is a dated search, not proof of novelty. +materialized and searched. The 08:08-08:09 UTC submission refresh covered 358 +open PRs and 3,493 Discussion records and revealed the concurrent work above. +Canonical main and the priority revision were unchanged. Coverage is a dated +search, not proof of novelty. #4567's head `58695721e3cf9d5101440dd53a3ea5bbcc0e9313` +adds nonadjacent and contact-retiming checks outside this fixed adjacent scope. The older R420 all-length cleanup floor and P111 receiver census concern different targets and tariffs; neither covers these PR4470 frame contracts. @@ -173,6 +216,8 @@ comparison. The committed extractor, state graph and cost checker are new, and import no #4546/#4567 acceptance code. This is a separate implementation, not a separately launched audit team. Prepared for mihir-s-05 with substantial OpenAI Codex assistance. Apache-2.0; retained source notices are unchanged. +Credit the concurrent #4572/#4582, #4577/#4581 and #4574 investigations as well; +the compressed peer receipts retain their exact authored payloads and origin. ## Open next questions diff --git a/research/receiver-all-length-floor/TASK.json b/research/receiver-all-length-floor/TASK.json index 20390f054e..97949e63ee 100644 --- a/research/receiver-all-length-floor/TASK.json +++ b/research/receiver-all-length-floor/TASK.json @@ -80,13 +80,13 @@ ] }, "scope_status": "refined", - "actual_scope": "Prove an all-length, coefficient-independent paid-profile floor for all 128 fixed three-field PR4470 receiver windows, using temporal ancestry and monotone frame dimensions.", - "scope_change_reason": "Take the live #4546/#4567 length-cap handoff instead of the catalogue historical examples. Replace finite scalar-word enumeration with a finite-state relaxation and exact concave-cost certificates.", + "actual_scope": "Independently corroborate the all-length concave-cost floor for all 128 PR4470 receiver windows, with a three-ancestry frame DAG and an executable comparison of the exact #4581/#4582 receipts.", + "scope_change_reason": "Take the live #4546/#4567 length-cap handoff instead of the catalogue historical examples. Replace finite scalar-word enumeration with a finite-state relaxation and exact concave-cost certificates. The final refresh revealed concurrent same-conclusion work; preserve independent derivation, explicitly credit it, and add exact receipt agreement rather than claiming exclusive novelty.", "bottleneck_link": "Decides whether increasing word length or coefficient range alone can remove paid work in these fixed receiver windows; a zero floor redirects further construction to a changed boundary, fields, or nonmonotone frame model.", "budget_minutes": 60, "stop_rule": "Stop after source-bound coverage of the 128 windows and geometric/semantic controls. If a relaxed cheaper profile survives, report it as inconclusive; do not expand a construction search.", "outcome": "negative-result", - "evidence": "RESULT.json: 128 windows, 1603 states, 239 rank partitions; incumbent attains every floor. Integer capped-rank sums certify every increasing concave cost. Registered replay and optimized semantic controls; see README.md.", + "evidence": "RESULT.json: 128 windows, 1603 states, 239 rank partitions; incumbent attains every floor. Integer capped-rank sums certify every increasing concave cost. Registered replay and optimized semantic controls; see README.md. PEERS.json and compare_peers.py authenticate and match every projected field of #4581/#4582 at their pinned heads; peer proof code is not executed or certified.", "author": "mihir-s-05", "ai_assistance": "Prepared for mihir-s-05 with substantial OpenAI Codex assistance; no separately launched agents, formal kernel, or independent human review.", "open_questions": [ @@ -120,6 +120,27 @@ "priority_revision": 7, "initial_open_prs_utc": "2026-10-22T07:47:49Z", "initial_discussions_utc": "2026-10-22T07:49:34Z", - "local_coverage": "All 5860 tracked top-level README/TASK notes materialized and searched after the initial sparse check." - } + "local_coverage": "All 5860 tracked top-level README/TASK notes materialized and searched after the initial sparse check.", + "final_fetch_utc": "2026-10-22T08:08:30Z", + "final_open_prs_utc": "2026-10-22T08:08:35Z", + "final_discussions_utc": "2026-10-22T08:09:49Z", + "final_open_pr_count": 358, + "final_discussion_record_count": 3493 + }, + "concurrent_investigations": [ + { + "discussion": 4572, + "pr": 4582, + "head": "23c515a3c071a6bfdd1fe80bc67cea55f6d43643" + }, + { + "discussion": 4577, + "pr": 4581, + "head": "b154350fbf1e7d49118851ab899a733727483289" + }, + { + "discussion": 4574, + "scope": "static mandatory-contact and graph-bridge proof" + } + ] } diff --git a/research/receiver-all-length-floor/VERIFY.json b/research/receiver-all-length-floor/VERIFY.json index 58c2e99487..6d45251ed2 100644 --- a/research/receiver-all-length-floor/VERIFY.json +++ b/research/receiver-all-length-floor/VERIFY.json @@ -33,6 +33,17 @@ ], "timeout_seconds": 120, "checks": "Exhaust all 1728 triples of comparable F2^2 subspaces with a separate actual-frame traversal; causal, terminal-charge, incompatible-frame, extraction, concavity, and source-corruption controls under optimized Python." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/compare_peers.py" + ], + "timeout_seconds": 30, + "checks": "Authenticate exact #4581/#4582 archived receipts and compare every window identity, complete frame subspace, incumbent bill and terminal rank partition; no peer proof code executes." } ] } diff --git a/research/receiver-all-length-floor/compare_peers.py b/research/receiver-all-length-floor/compare_peers.py new file mode 100644 index 0000000000..2381615ffa --- /dev/null +++ b/research/receiver-all-length-floor/compare_peers.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +"""Compare pinned concurrent receipts without executing their proof engines. + +Prepared for mihir-s-05 with OpenAI Codex assistance. Apache-2.0. +""" +import gzip +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def frame(basis): + vectors = {0} + for value in basis: + need(type(value) is int and 0 <= value < 512, "binary coordinate") + vectors |= {x ^ value for x in tuple(vectors)} + return tuple(sorted(vectors)) + + +def projection(row, start_key, old_key, profiles_key): + profiles = tuple(sorted(tuple(sorted(p)) for p in row[profiles_key])) + need(len(set(profiles)) == len(profiles), "no duplicate rank partitions") + return { + "index": row["index"], "phase": row["phase"], "roles": row["roles"], + "coefficients": row["coefficients"], + "starts": [frame(s) for s in row[start_key]], + "exits": [frame(s) for s in row["exit_bases"]], + "contacts": [frame(s) for s in row["contact_bases"]], + "incumbent": tuple(sorted(row[old_key])), "profiles": profiles, + } + + +def main(): + ours = json.loads((HERE / "RESULT.json").read_text(encoding="utf-8")) + expected = [projection(w, "start_bases", "incumbent_ranks", "relaxed_rank_partitions") + for w in ours["windows"]] + need(len(expected) == len({w["index"] for w in expected}) == 128, "our complete window census") + comparisons = [] + for pin in json.loads((HERE / "PEERS.json").read_text(encoding="utf-8"))["receipts"]: + archive = (HERE / pin["local"]).read_bytes() + need(hashlib.sha256(archive).hexdigest() == pin["archive_sha256"], "committed peer archive hash") + raw = gzip.decompress(archive) + need(hashlib.sha256(raw).hexdigest() == pin["payload_sha256"], "peer payload hash") + need(hashlib.sha1(b"blob " + str(len(raw)).encode() + b"\0" + raw).hexdigest() == pin["git_blob"], + "peer original Git blob") + peer = json.loads(raw) + keys = ("start_bases", "incumbent", "terminal_profiles") if pin["pr"] == 4581 else ( + "entrance_bases", "incumbent_profile", "relaxed_profiles") + actual = [projection(w, *keys) for w in peer["windows"]] + # JSON canonicalization distinguishes boolean impostors from integers. + need(json.dumps(actual, sort_keys=True) == json.dumps(expected, sort_keys=True), + "all peer identities, full subspaces, incumbent bills and terminal partitions") + comparisons.append({"pr": pin["pr"], "head": pin["head"], "windows": len(actual), + "partitions": sum(len(w["profiles"]) for w in actual), + "reported_states": peer["reachable_states"]}) + need(len(comparisons) == 2 and {x["pr"] for x in comparisons} == {4581, 4582}, "two pinned peers") + print(json.dumps({"status": "PASS_TWO_PINNED_PEER_RECEIPTS", "comparisons": comparisons, + "our_states": ours["state_count"], "peer_code_executed": False}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/receiver-all-length-floor/peers/pr4581-RESULT.json.gz b/research/receiver-all-length-floor/peers/pr4581-RESULT.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..c4818ba9eba957174d32320b0f6ed016093f5a80 GIT binary patch literal 5588 zcmV;_6)Wl=iwFP!000023hiA>ZzMT#zW1*XbXLR3H`BMZF@698uQ9vu#V~{#sd~Dw zYDtjPGrL&qe|MEyEk)!gnItp#$V{GEC3P{GWW*OABZ3is|8RD8{%Lo(`TDTGyt=!6 zdbqoJJpbpjzaM{p{LA&j-TmeD;bDLEw7dz+~54|a(DgZ z@O1od$G`pW%iqq<_{Hmw?B%Eb`~Iu*!|m1AFF)^ZpU_v>#k)Vg^X=>XUyt8pol@rc zm;bl`v)=#p@N{{&ecC@f9%p~JyN#JMpEqZ(>9fw*-%tNI?=Oej-Oc6I=iS3E`>DxK zO^`d6Pkwv;hnG2=|FXaPvVVFwTzwabH;Fj@;%fKn{_^MDOR#mbkzybXH4d-{C(6SvyFKJ#|}+vQ(&_xHQwAD-Xv`M38Ecb^V7 zC(-BGy<;`p=o)T=07-R(bpI$Rx& z;`WH-?W0rnPg1qJdU{?C{Jl3pKK=Z=FFq^v#J665I!Zm47vQ7lUO%`W6Qx71zrFwb zvdjN+{`$Lj#Odt|M+F-9<{<71F$Oz-N*|A-MI$@E3^10$wH$dW<@v3Cig?7(v+ zP%YK*`GV-XI{xCxE=E7h72IfRmsM~pkW{C5T3Yc063MJtn0S^lvS1F1O$mcy^8|AG z3BuY7x+#$%sqRQcRfCsg3c#w8mQ+-ot5XG%Qc!^Of;&qriwZ6y61c+)mft>9jnm+%? zo`oI$rRvca?8Us(l(_JXt-Ok<33fp7&LO9~Q_wdFD1cPFum|eG4>Lyq^kRBY9zTvC znvWQtPZhRc8IBAoktTAy2jPZ-hjSW3>yKmb6xmCtmZC<72d|OS%r+q&J`IBej|WPs z7|3lF3(}KX5XOPg;GKb@Dw_q_yaidtX+r8ApQZC#5KHUM=~2+Rhia*6JQc6gf(Xt6 z!_;s|ED}l-q?>)-aEPMrg2{|^MsMI5LqN}>70a*?VIW*X1TsDBnsLCicwGhZQ*te* zrj~GM(W3#hxtQlug4EnkyNtD@1Wa@AMjEEY1Uc?=y5|y8xV*HF7knHa!5t5j5=1-} zrD4frI2g@8Ylo@rKyRAm3V~%8|2BOv|CYudmVvs-junGtuBBt8t-8n>?kWi3)tHY; ztyKyGHOH5cf~ZruV5H}u@uswjq{e1RYq6wm6xTSV8DTn3cQ#qh{EkP+U_(bu;z$q2s385a1L>o z%PZqX9!;5xIbe*cYUHV(YBuhY16d}Hc*sl$Jd=Lph__)TV<~TKj|bc|*BfFo#m~Hr z)-+l(cF0EnDG?;vE-Uu*wAdp@xJ<*I#bQr`9x#BiczDN&WRRuV1@RuP&^t2T`#z`u zzoM;07*sB~eVmNWzum=o3yjHX%`+a}&q`)TjVb68E5 z!xt5CEZ#w+S7`04(|$hiQb`rI8}9E1r04m#5(~{W@tc$J`tZ=HQ`39kfaN_rz4vj> zzQKy+-Y|!}teDzkS9ov@)SUWVYOV{>Zx-&%ck*~xe*sobVUhQO3h&oIdbXk7!zHX) zy}2_WW;UqozIrcd{dMrn-UBi%mZ|s-TCoulKQx?GlX&f#YeRu?6dtCT0AA3S%Sgr2C*KwB2_+W8P{1P)w``TnApVO*2Y)m4$9=hv9q_hB*nRb1(UNz_*I}!O$V?l# zDI;H@n-0&Z7hx;NaiuyY9ElLK^}o#Me3V5+b@IKNfUv$G9eH>OC zjB_qwUHV;Wu8YxcS~nad?@%>loOTb^EBAJ>fKHC9)$W?Dcd5BXjaK^5u6oKtJ1hw& z1o|K-biMFiIv&5~Bs#Vn!)~qPS-shwnfHVN&1o4uBJl#^K%DQ6vrU=&>cendp!;J` zO1>MfLC6Gc7%tCD)4n#DwYMEDu?K)E;B68i<9u{wcdOsvv3;{ECzlC-T^ql_;%>8)m}%PACS&7* zv_PaV@X`w6<|gviTF(P(L6B~j|BkG+frB<#)}Nq(L#CN7MX^cms34=Qfs)%UO0A3T zl{999wIE$9Se06rnQ3XYcIvVwW#G^%!%7m7tyn7FuOzBn;a&2I*>{|DaS^t;qt7o*>#3FSz;VNcaK<2_ie+`Huvmdz-4)yBKjT#GBW zQ=>^!$u+XkFpeGDIi;>W8-M(oDS6c5*cW3T!sdf(XHp_z1HzhsFr?TODJ=SNB54FMLK=vWwjpGl zaG3-{7Vq`)C>L7mA~kT*g)f+rTzW0Cqb}ZcD)hCoM?eO`L)= zu(UsK>Z^c)dYD%;<#d|P4dzr5kuTG4#);%sZ=2B4+xfQ_o2AD`v*t_Qs`(!z5TdTJ z#F)_2VuBqp`3)25!-NJ2gJ&TU!S#qcJL)z3Isla644$V0%V?ou)T@2?Y@|gYvlz8YMkj4_|k&R-+@S4o{M}mL`fSfs^X|3J0$KF>kdxn3kr}E3>1f~^FUvZS%#6iZoQSh!@2IDNo4ee{^<31JCC zj*xWFd~p6|4M*E%LQ0zuuCYL2CX>mcc=Fd?6B`$3PavUd#$`p8CbQYeY=e>*B&vid zDpOTorHp2`)_(MP-vZHwZycwa$ObWOAM4KUYQRxm;Mn-UI1$XIp}Q`QtGbRfCk#_u zQ5(Wk$(I}5NR1k(D8<>C;p30RCDk|QcXeZhNXSOuaahX6Msgg~TUe)2l+%B}Lor?l z+DKZo;bY9Cq0REprh(1(k*)7zWxUIc8|*6-dht9bIGaUv!O;K}6%3G_+6W%i6PIX* zE_!In1scOzy=r`5W@eD2L5pGBA*V8^GI^-ecA%=-h-wX_is1}dT(?UiJu#C-yrRa6 z!Kd=G9wS?roDGJS<3sBS$%rb&!d*baC2c7dSSMQb;C&?PNHZje#LQoXdHtymyp{w9 zPLx+bRfvVxKo1+pR=5I_5q!lpEftd&@1vz;admlDzCjg-=9@z2V@-nwE^;*LZsxEi zH&rsUfp)}{Oa(wt3)5<*n?}32t|#qXG*qs}Oo|42P4PbVOD}Av{kDBDi#d zjq|H=){rB|Ww$UtX*;#VpIS1(#4sL=ljfY1!%%uQl%ue0M+a8ExD{TTzl)5fD6g}Lio7sFqwrLOk0 zPgW+eihB4BYN!Xp^%w>OP>wrG(Npy-5b|_rhWE^xz#{?iNNyF6_yUsNXJnz*;fi!e zDD*hX_bEM3F?Q4$xcaxsx?=NOkr5S6r4!vWL^s$0L`L=pnl6-IYUP_VvNVx2EBYH^&xVwr~*P2%scHO%wouz z3tIezIa!(k$>WOlhC9{rHJaOKZiB!w5Gbtm&Gp1X_Y+QZ@=73@xDp70M$Pz|aI%#G zIoob25E{=e#s!AcIdJ|4S7F)a6hlY36DohFoXa(jvPxo?0h17l;Y}hg%ef4aEPNxo zjqElEUK0dshX=Q(!(%^hu9lVmWFP7pKFoXhkw;6<4gQ z?dBp%{52q{M)a^>j|tys`I@>;;CCmJ4 zxbcp;?6o68)nH`AtLr4WJ#7rij&NMAwgWN7d*B3wySZu`VR;@{`VK68$T&qljwS6w zir__awoR-ldeUz$y#yR*kcES*AQQeGa}10xsM@6w9#8ILIW6}Y^Y8JXq$@D1 zrIG1~TN-iX>ggedlxrzRw9>7kQI?}y0~yM(x^BFJBp$2xNmEYN%*b@a&5R)UXwhvH ziCQnC^vAgdSe3J)_wk1Iy23c|5pmVdR=z8w9GZ1BEW|5*o^=K0(ZB^czO zIBr!7tB4VSlOh5H0ZaoLB2};Id zlADGbIf61_KF)Svi3OufAQ9<*z(shunYJPB<1f+EG!H76V+l?naVc6NGxtI@Umd z3U+-UTTMRLtN@j6U< zH8t%WUNCQ%4=7AzW5q3OQoX*-C2O~FWuxMFuA_;8ScBsGom8|*h6M1W66xS*NKm1# zvswQFqv3Q8nXWXN(WF<@5DKt{2*ij`M+d@{0>U8G#?b^_&U-0?J_+nXz@NI(WWv(} zYC2L6Xg9(uB5MRS6xoO$bhXe_2r+Pis+|dYa{NFhSPp-vVOh9NL#YioMWw<5jGLO^ z)tc^m6*pK^5=aH}PP+)x{?MKj2jE2ED~Q-jc&p!`iW5B-s@20(Pw9B@z-bzm>sh_R z`<+*Ml?nkM%i+Cg2(St#XtVazgZ-|JI`;;!w8)?-kpZFsWXTN~Dno|t5e5^dZ#Kvg zD)7;8;K!($J$SkldeZO-d?g4Sf{6wfr2d5FLYRXc$&`AS5{j?y&mFsST{DrH(8L#5 z`W!r@0n6$gm0aP}Y3}kAaL=|XUY*-6Dw|JST&AtwLUwablL{{1^9f(w?02_c?=PQr zhZ}d5c;mVY+<})<+Q2OO*ho=bLcm6Q)+ih&;*Rc0TzjNdxDq~bzdC{6hmQm@sc^r_ z_884(G@H@plh9_!WHtlFWt0XuCz)J@&7d#YK4P12H@$BBJ#l@MfkT?Be#J(k*^Fj0 z+I;fZ43o@ez{1wb05p^9Fd2htnT{&nV&*wxboT!CL)gBZG8*PJi_vy-p2bjIm(F59 z&y)d(Dn++G&lEwyY$ literal 0 HcmV?d00001 diff --git a/research/receiver-all-length-floor/peers/pr4582-RESULT.json.gz b/research/receiver-all-length-floor/peers/pr4582-RESULT.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..d7b2333a5e7370127e11fd2ffbcdfc834295ac90 GIT binary patch literal 6174 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