From 1e3128bf642bbaf250b7d6b9639b2bb24b98ce5e Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 04:41:49 -0500 Subject: [PATCH 1/2] research: screen diagonal rank-16 child batches --- .../CLAIM.md | 14 ++ .../README.md | 94 +++++++++ .../SOURCES.json | 42 ++++ .../TASK.json | 83 ++++++++ .../VERIFY.json | 24 +++ .../verify.py | 181 ++++++++++++++++++ 6 files changed, 438 insertions(+) create mode 100644 research/complex-diagonal-child-batches-seed95da/CLAIM.md create mode 100644 research/complex-diagonal-child-batches-seed95da/README.md create mode 100644 research/complex-diagonal-child-batches-seed95da/SOURCES.json create mode 100644 research/complex-diagonal-child-batches-seed95da/TASK.json create mode 100644 research/complex-diagonal-child-batches-seed95da/VERIFY.json create mode 100644 research/complex-diagonal-child-batches-seed95da/verify.py diff --git a/research/complex-diagonal-child-batches-seed95da/CLAIM.md b/research/complex-diagonal-child-batches-seed95da/CLAIM.md new file mode 100644 index 0000000000..9b6c0572c2 --- /dev/null +++ b/research/complex-diagonal-child-batches-seed95da/CLAIM.md @@ -0,0 +1,14 @@ +# Coordination claim + +Claim posted in the authorized mechanism-coordination thread: +[Discussion #1167, comment 18920760](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18920760). + +- Track: `complex-mechanisms`; accepted seed: `95da2249593d8218c4c1e30f471d675f`. +- Card: `complex-rank-shape-decoder`, priority revision 3; refined scope `selected-gauge44-diagonal-batch/contiguous-rank1-runs`. +- Exact base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. +- Object: size-16 diagonal block children from uninterrupted rank-one climbs on distinct output columns in the selected gauge44 provider. +- Method: source-pinned census in both orientations, exact diagonal multiplication identity, and favorable ceiling screen with all additional interface costs set to zero. +- Bounded domain: non-overlapping size-16 groups wholly contained in rank-one-only event runs; no reordering, buffering, changed word, or other rank. +- Nearest predecessor: open PR #1605 / Discussion #1596 on rank-one reblocking thresholds; this package tests cross-column diagonal batching on the exact selected chronology. +- Expiry: 2026-10-14 10:05 UTC. +- Outcome: eight groups, 128 rank-one calls; best-case ceiling gain 1.7191%, below 5%. No physical admission or κ claim. diff --git a/research/complex-diagonal-child-batches-seed95da/README.md b/research/complex-diagonal-child-batches-seed95da/README.md new file mode 100644 index 0000000000..f9e55c2812 --- /dev/null +++ b/research/complex-diagonal-child-batches-seed95da/README.md @@ -0,0 +1,94 @@ +# Cross-column diagonal batching has limited chronological coverage + +**Scoped construction screen and bounded obstruction. No physical supplier or new κ is claimed.** + +## Result + +The selected #1094 gauge44 provider has 2,412 rank-one children per orientation. I tested a new +cross-column mechanism: replace sixteen adjacent rank-one child calls on distinct destination +columns by one rank-16 child. For input blocks (X_i,Y_i), place them on the diagonals of two +16-by-16 block matrices. Their product is + +\[ +\operatorname{diag}(X_1,\ldots,X_{16}) +\operatorname{diag}(Y_1,\ldots,Y_{16}) +=\operatorname{diag}(X_1Y_1,\ldots,X_{16}Y_{16}). +\] + +The diagonal outputs are exactly the sixteen original rank-one child results; every off-diagonal +output is zero. This is an exact identity over any associative coefficient ring. + +The hash-pinned forward and backward traces each contain exactly eight non-overlapping, uninterrupted +rank-one batches of size 16: one run of 16 calls and one run of 112 calls, partitioned into seven +batches. The batches serve 128 of 2,412 rank-one children. No other uninterrupted rank-one run has +length 16. No event is moved across a scalar, adapter, centre, or other-rank climb. + +Replacing those batches preserves the paid rank mass: + +| Per-call profile | Rank mass | Exact relaxed ceiling upper endpoint | +|---|---:|---:| +| Selected `{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}` | 5,586 | 0.001690054109089 | +| Eight ideal rank-16 batches `{1:2284, 2:418, 3:432, 4:142, 5:82, 8:8, 16:8}` | 5,586 | 0.001719107428154 | + +The upper endpoint rises by **1.7191%**, below the task's required 5% gate (target 0.001774556814543). +This is already the most favorable screen: every new operand-copy, source-access, frame, interface, +hosting, output-storage, precision, and dirty-restoration charge is set to zero. The physical child +would expose 256 input slots per side and 256 output slots per batch, although only sixteen diagonal +inputs and outputs are useful. Its actual gathering and restoration contract has not been realized +or priced. Since the free-interface profile misses the declared gate, this chronology-constrained +family is stopped before physical rewriting. + +This result does not rule out batching nonconsecutive children with stored operands, changing the +word or template, or using another block size. It supplies no supplier admission, κ, or selected-record +change. + +## Source and overlap + +The provider member is +`candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz` in +[`selected-replay.tar.gz`](../community-frontier1094-audit/selected-replay.tar.gz), archive SHA-256 +`f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6` and member SHA-256 +`241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a`. The selected-record SHA-256 +is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`; all live pins are listed +in [SOURCES.json](SOURCES.json). + +Nearest predecessor work is Arham Tahir's [PR #1605](https://github.com/CrocSwap/integer-mult-bounds/pull/1605) +(head `488f2ecf1835c6d813e96543656dddf0062fdc9a`) +and Josie Elliston's [Discussion #1596](https://github.com/CrocSwap/integer-mult-bounds/discussions/1596), +which derive rank-one reblocking budgets and leave chronological physical batching open. Navinor's +[Discussion #1659](https://github.com/CrocSwap/integer-mult-bounds/discussions/1659) and [PR #1686](https://github.com/CrocSwap/integer-mult-bounds/pull/1686) +settle same-word per-column frame assignments. The present test changes the interface by batching +across sixteen distinct destination columns through a diagonal rank-16 child; it does not improve a +per-column frame assignment. The exact diagonal identity is elementary, while its physical input, +output, and restoration realization remains open. + +## Reproduce + +From the repository root, Python 3.12 and the standard library are sufficient: + +```sh +python3 scripts/research_package.py --package research/complex-diagonal-child-batches-seed95da --check-only +python3.12 scripts/research_package.py --package research/complex-diagonal-child-batches-seed95da +``` + +The verifier checks both event orientations, every admissible contiguous batch, the unchanged rank +mass, the exact diagonal product identity, the rational ceiling bracket, and failure controls for +off-diagonal support, duplicate destinations, and wrong-rank events. + +## Open next questions + +Can nonconsecutive rank-one children be buffered into diagonal rank-16 batches with a fully charged +source, copy, frame, hosting, output, and arbitrary-dirty restoration schedule? This matters because +the available contiguous batches cover too little rank-one payload to pass the 5% screen. A feasible +first step is to pin operand-ready/use windows for the selected word and solve the resulting disjoint +16-way interval packing problem. The blocker is that the current local event trace records child +columns and frame changes, not a realized multi-column dirty-state memory contract. + +## Credit + +Credit Sagar Thakrar / PR1012 for the retained coverage identity, Douglas Colkitt / PR1240 for the +local-word ceiling model, Arham Tahir / PR1605 and Josie Elliston / Discussion #1596 for rank-one +reblocking budgets, Navinor / Discussion #1659 and PR1686 for same-word frame screens, and the +selected Rohan Arun / Jeremy Kothe / Hao Yan construction lineage. Prepared by Jose Manuel +(@jmbarrancoml) with substantial OpenAI Codex assistance in source analysis, proof, code, and prose. +New material is Apache-2.0; frozen source archives and licenses are unchanged. diff --git a/research/complex-diagonal-child-batches-seed95da/SOURCES.json b/research/complex-diagonal-child-batches-seed95da/SOURCES.json new file mode 100644 index 0000000000..b6deb812a0 --- /dev/null +++ b/research/complex-diagonal-child-batches-seed95da/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/complex-diagonal-child-batches-seed95da/TASK.json b/research/complex-diagonal-child-batches-seed95da/TASK.json new file mode 100644 index 0000000000..71a7a93c86 --- /dev/null +++ b/research/complex-diagonal-child-batches-seed95da/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "track": "complex-mechanisms", + "research_seed": "95da2249593d8218c4c1e30f471d675f", + "priority_revision": 3, + "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "predecessors": [ + { + "reference": "CrocSwap/integer-mult-bounds#1605", + "head": "488f2ecf1835c6d813e96543656dddf0062fdc9a", + "relationship": "Rank-one reblocking cost thresholds; this package adds an exact chronological cross-column diagonal-batch census." + }, + { + "reference": "CrocSwap/integer-mult-bounds#1094", + "head": "0fc329d0bec93ca7cd288eaea1295172e8789810", + "relationship": "Selected provider construction and source lineage, retained through the pinned main-branch source archive." + } + ], + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18920760", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "changed", + "actual_scope": "On the selected #1094 gauge44 provider, census size-16 diagonal rank-16 batches drawn only from uninterrupted rank-one child runs on distinct destination columns, in both orientations; price the exact transformed local profile with all additional interface costs optimistically set to zero.", + "scope_change_reason": "The broad rank-shape card is refined away from the heavily covered same-column frame-retiming and eight-term masked-decoder families. This changes the child interface: one rank-16 diagonal block child serves sixteen rank-one children across distinct output columns. The bounded experiment stops if even the zero-additional-cost profile misses the 5% ceiling gate.", + "bottleneck_link": "Rank-one children are a large share of the selected local recursive mass. A rank-16 child can lower the moment per unit of preserved rank mass, so a valid cross-column batch could improve the binding complex-side ceiling.", + "budget_minutes": 60, + "stop_rule": "Restrict to non-overlapping size-16 batches wholly contained in uninterrupted rank-one climb runs in the hash-pinned selected provider, ignoring only explicit phase markers. Grant all new copying, source, frame, interface, hosting, output-storage, precision and restoration costs zero for the ceiling screen. Stop without physical rewriting if the resulting exact ceiling is below 1.05 times the selected local-word ceiling; do not expand into nonconsecutive buffering or a different word in this cycle.", + "outcome": "negative-result", + "evidence": "Both source orientations have 2,412 rank-one climbs and exactly eight admissible size-16 batches, serving 128 climbs. The mass-preserving ideal profile {1:2284, 2:418, 3:432, 4:142, 5:82, 8:8, 16:8} has exact rational ceiling upper endpoint 1719107428154/10^15, 1.7191% above the baseline 1690054109089/10^15 and below the 5% target. The 16-way diagonal block identity is exact. Every additional physical interface charge is waived in this favorable screen; no physical admission, new supplier, or kappa is claimed.", + "author": "Jose Manuel (@jmbarrancoml)", + "ai_assistance": "Substantial OpenAI Codex assistance in source analysis, mathematical formulation, exact verifier, package construction, and writing; no subagents.", + "open_questions": [ + { + "question": "Can nonconsecutive rank-one children be buffered into diagonal rank-16 batches with a fully charged source, copy, frame, hosting, output, and arbitrary-dirty restoration schedule?", + "why_it_matters": "The eight contiguous batches cover too little rank-one payload to pass the 5% ceiling screen; a larger packing would be needed before the new interface could affect the binding supplier materially.", + "first_step": "Pin operand-ready/use windows from the selected local word, then solve a disjoint 16-way interval packing problem and price one emitted batch end to end.", + "blocked_by": "The pinned local event trace records columns and frame changes but does not specify a multi-column dirty-state memory layout, operand lifetimes, or the restoration contract for an M16 child." + } + ] +} diff --git a/research/complex-diagonal-child-batches-seed95da/VERIFY.json b/research/complex-diagonal-child-batches-seed95da/VERIFY.json new file mode 100644 index 0000000000..ce2c513e95 --- /dev/null +++ b/research/complex-diagonal-child-batches-seed95da/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Archive/member pins; exact rank-one event profiles in both orientations; all maximum disjoint size-16 uninterrupted batch windows; direct-sum diagonal product identity; mass-preserving candidate profile; certified baseline and candidate ceiling brackets; five-percent rejection and three mathematical/source negative controls." + } + ] +} diff --git a/research/complex-diagonal-child-batches-seed95da/verify.py b/research/complex-diagonal-child-batches-seed95da/verify.py new file mode 100644 index 0000000000..f40f184b6f --- /dev/null +++ b/research/complex-diagonal-child-batches-seed95da/verify.py @@ -0,0 +1,181 @@ +#!/usr/bin/env python3 +"""Replay the selected-word contiguous diagonal-batch screen with exact pins.""" +from __future__ import annotations + +import collections +import gzip +import hashlib +import json +import tarfile +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(ROOT / "research/complex-local-word-ceiling")) +import ceiling as C # noqa: E402 + +ARCHIVE = ROOT / "research/community-frontier1094-audit/selected-replay.tar.gz" +ARCHIVE_SHA256 = "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" +MEMBER = "candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz" +MEMBER_SHA256 = "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" +EXPECTED_BATCHES = ( + (17006, 17021, 456, 471), + (17106, 17121, 592, 607), + (17122, 17137, 608, 623), + (17138, 17153, 624, 639), + (17154, 17169, 640, 655), + (17170, 17185, 656, 671), + (17186, 17201, 672, 687), + (17202, 17217, 688, 703), +) +BASE_PROFILE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} +BASE_CEILING_HI = Q(1690054109089, 10**15) +CANDIDATE_PROFILE = {1: 2284, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8, 16: 8} +CANDIDATE_CEILING = ( + Q(1719107428153, 10**15), + Q(1719107428154, 10**15), +) + + +def require(ok: bool, why: str) -> None: + if not ok: + raise RuntimeError(why) + + +def selected_programs() -> dict[str, list]: + archive = ARCHIVE.read_bytes() + require(hashlib.sha256(archive).hexdigest() == ARCHIVE_SHA256, "selected replay archive pin") + with tarfile.open(ARCHIVE, "r:gz") as tar: + members = [m for m in tar.getmembers() if m.name == MEMBER] + require(len(members) == 1, "exactly one selected gauge44 program member") + raw = tar.extractfile(members[0]).read() + require(hashlib.sha256(raw).hexdigest() == MEMBER_SHA256, "selected provider member pin") + return json.loads(gzip.decompress(raw)) + + +def rank_one_runs(events: list) -> list[list[tuple[int, list]]]: + """Runs ignore phase markers only; every computational event breaks a run.""" + runs: list[list[tuple[int, list]]] = [] + current: list[tuple[int, list]] = [] + for index, event in enumerate(events): + if event[0] == "phase": + continue + if event[0] == "climb" and event[5] == 1: + current.append((index, event)) + else: + if current: + runs.append(current) + current = [] + if current: + runs.append(current) + return runs + + +def admissible_batches(events: list) -> list[tuple[int, int, int, int]]: + batches = [] + for run in rank_one_runs(events): + for group in range(len(run) // 16): + block = run[group * 16:(group + 1) * 16] + indices = [i for i, _ in block] + climbs = [e for _, e in block] + columns = [e[2] for e in climbs] + if len(set(columns)) != 16: + continue + batches.append((indices[0], indices[-1], columns[0], columns[-1])) + return batches + + +def diagonal_product(a: list[list[int | None]], b: list[list[int | None]]) -> list[list[set[tuple[int, int]]]]: + n = len(a) + out = [[set() for _ in range(n)] for _ in range(n)] + for i in range(n): + for j in range(n): + for k in range(n): + if a[i][k] is not None and b[k][j] is not None: + out[i][j].add((a[i][k], b[k][j])) + return out + + +def check_diagonal_identity() -> None: + n = 16 + a = [[i if i == j else None for j in range(n)] for i in range(n)] + b = [[i if i == j else None for j in range(n)] for i in range(n)] + out = diagonal_product(a, b) + for i in range(n): + for j in range(n): + expected = {(i, i)} if i == j else set() + require(out[i][j] == expected, f"diagonal block product at ({i},{j})") + + # A nonzero off-diagonal entry invalidates the direct-sum premise. + bad_a = [row[:] for row in a] + bad_a[0][1] = 16 + bad = diagonal_product(bad_a, b) + require(bool(bad[0][1]), "off-diagonal-support negative control") + + +def check_batch_controls(events: list, spec: tuple[int, int, int, int]) -> None: + start, end, first_column, last_column = spec + block = events[start:end + 1] + require(len(block) == 16, "source block length") + require(all(e[0] == "climb" and e[5] == 1 for e in block), "source block rank-one tags") + require([e[2] for e in block] == list(range(first_column, last_column + 1)), "source destinations") + + wrong_rank = [e[:] for e in block] + wrong_rank[0][5] = 2 + duplicate_column = [e[:] for e in block] + duplicate_column[0][2] = duplicate_column[1][2] + require(not all(e[0] == "climb" and e[5] == 1 for e in wrong_rank), "wrong-rank negative control") + require(len({e[2] for e in duplicate_column}) != 16, "duplicate-destination negative control") + + +def main() -> None: + programs = selected_programs() + require(set(programs) == {"forward", "backward"}, "both selected orientations present") + orientation_batches = {} + for orientation, events in programs.items(): + profile = collections.Counter() + for event in events: + if event[0] == "climb": + profile[event[5]] += 1 + elif event[0] == "center": + profile[event[4]] += 1 + require(dict(sorted(profile.items())) == BASE_PROFILE, f"{orientation} paid profile") + require(profile[1] == 2412, f"{orientation} rank-one count") + runs = rank_one_runs(events) + require(sum(len(run) // 16 for run in runs) == 8, f"{orientation} maximum run packing") + found = admissible_batches(events) + require(tuple(found) == EXPECTED_BATCHES, f"{orientation} exact batch windows") + for spec in EXPECTED_BATCHES: + check_batch_controls(events, spec) + orientation_batches[orientation] = found + require(orientation_batches["forward"] == orientation_batches["backward"], "orientation batch agreement") + + mass_before = sum(r * n for r, n in BASE_PROFILE.items()) + mass_after = sum(r * n for r, n in CANDIDATE_PROFILE.items()) + require(mass_before == mass_after == 5586, "rank mass preserved by eight batches") + require(BASE_PROFILE[1] - CANDIDATE_PROFILE[1] == 128, "sixteen rank-one calls per batch") + require(CANDIDATE_PROFILE[16] == 8, "one rank-sixteen child per batch") + + base_bracket = C.ceiling(BASE_PROFILE, 73, 896, 9, 64, grid=Q(1, 10**15)) + candidate_bracket = C.ceiling(CANDIDATE_PROFILE, 73, 896, 9, 64, grid=Q(1, 10**15)) + require(base_bracket[1] == BASE_CEILING_HI, "baseline ceiling pin") + require(candidate_bracket == CANDIDATE_CEILING, "candidate exact ceiling bracket") + target = BASE_CEILING_HI * Q(105, 100) + require(candidate_bracket[1] < target, "zero-charge profile misses the five-percent gate") + require(candidate_bracket[1] > BASE_CEILING_HI, "diagonal batching improves the ideal ceiling") + + check_diagonal_identity() + gain = 100 * (candidate_bracket[1] / BASE_CEILING_HI - 1) + print( + "PASS_COMPLEX_DIAGONAL_CHILD_BATCH_SCREEN " + f"groups=8 rank1_repacked=128 profile_mass={mass_after} " + f"baseline_a_hi={float(BASE_CEILING_HI):.15f} " + f"candidate_a_hi={float(candidate_bracket[1]):.15f} " + f"gain_percent={float(gain):.6f} target_percent=5 controls=3" + ) + + +if __name__ == "__main__": + main() From 5577f27d54355bc916efe0a23128dd0e0c169434 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 09:49:32 -0500 Subject: [PATCH 2/2] docs: record diagonal batch research handoff --- research/complex-diagonal-child-batches-seed95da/CLAIM.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/research/complex-diagonal-child-batches-seed95da/CLAIM.md b/research/complex-diagonal-child-batches-seed95da/CLAIM.md index 9b6c0572c2..f01b7b6c44 100644 --- a/research/complex-diagonal-child-batches-seed95da/CLAIM.md +++ b/research/complex-diagonal-child-batches-seed95da/CLAIM.md @@ -12,3 +12,11 @@ Claim posted in the authorized mechanism-coordination thread: - Nearest predecessor: open PR #1605 / Discussion #1596 on rank-one reblocking thresholds; this package tests cross-column diagonal batching on the exact selected chronology. - Expiry: 2026-10-14 10:05 UTC. - Outcome: eight groups, 128 rank-one calls; best-case ceiling gain 1.7191%, below 5%. No physical admission or κ claim. + +## Result and handoff + +The claim was updated with the finding and released at the same Discussion link. The source-pinned +package was submitted as [PR #1779](https://github.com/CrocSwap/integer-mult-bounds/pull/1779), +head `1e3128bf642bbaf250b7d6b9639b2bb24b98ce5e`. At the last hosted-status check (2026-10-14 +14:48 UTC), the PR was open and its 61 checks were queued; local registered replay and metadata +checks passed. Physical input staging and dirty-state restoration remain unimplemented.