diff --git a/research/complex-shared-line-rank2-seedceaca8/LICENSE b/research/complex-shared-line-rank2-seedceaca8/LICENSE new file mode 100644 index 0000000000..458f5a2dee --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/LICENSE @@ -0,0 +1,15 @@ +SPDX-License-Identifier: Apache-2.0 + +Copyright 2026 Cinna Davis + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/research/complex-shared-line-rank2-seedceaca8/NOTICE.md b/research/complex-shared-line-rank2-seedceaca8/NOTICE.md new file mode 100644 index 0000000000..c95a055e83 --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/NOTICE.md @@ -0,0 +1,12 @@ +# Notice + +This package contains an exact profile-level cost screen written for this +research cycle. It imports the pinned repository ceiling calculator but does +not alter or replace the selected source, certificate, or frontier. + +Adjacent work is acknowledged in `TASK.json`: PR #2130's rank-one-to-rank-two +retiming, PR #2124's Phase-B mixed-rank block, Discussion #1987's Karatsuba +block, and PR #1872's shared-product helper. This package studies only the +favorable profile effect of pairing two rank-two children into one rank-three +block when the target frames share a line. It does not claim a source-realized +block or a new supplier. diff --git a/research/complex-shared-line-rank2-seedceaca8/README.md b/research/complex-shared-line-rank2-seedceaca8/README.md new file mode 100644 index 0000000000..3e5cb7c236 --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/README.md @@ -0,0 +1,97 @@ +# Shared-line rank-two block: exact favorable ceiling screen + +**Scoped negative result. No source-realized block, supplier, or new κ.** + +The selected #1094 complex local profile is +`{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}` per call. I tested a new rank-shape +mechanism: if two rank-two child frames have target planes that share exactly +one line, replace the two rank-two children by one rank-three block child that +materializes the shared direction once. This changes `2+2` paid rank units to +`3`, frees one unit of coverage mass per pair, and would need a legal block +interface to copy the shared output to both targets. + +## Exact upper-bound calculation + +Keep the selected model fixed: child size `m=73`, 896 families over 9 stages, +centre charge 64, one unpaid coordinate, and idle cap `R=51`. Allow every one +of the 418 rank-two events to pair, so `g` ranges from 0 to 209. For each `g`, +the relaxed local profile is + +```text +n2 = 418 - 2g +n3 = 432 + g +n1 = 2412, n4 = 142, n5 = 82, n8 = 8 +``` + +All matching, source access, input/output adapters, copies, fanout, frame +transitions, hosting, precision, and dirty-state restoration are charged zero. +The freed rank mass is assigned to fractional rank-51 idle children by the +pinned ceiling model. This is a favorable completed budget for the proposed +profile substitution. + +More fusions cannot worsen this relaxation. For a fusion, four units of rank-2 +mass become three units of rank-3 mass plus one unit of idle mass. The idle +unit is carried at rank 51. For `a >= 0`, the per-mass cost factor `r^(-a)` is +non-increasing in `r`; the three rank-3 units and one rank-51 unit therefore +cost no more than four rank-2 units. So `g=209` gives the best ceiling in this +profile family. + +| Profile | Rank mass | Idle mass | Certified `a` ceiling | +|---|---:|---:|---:| +| `g=0` (selected) | 5,586 | 1,646 | `[0.001690054109088, 0.001690054109089]` | +| `g=209` (every rank-2 event paired) | 5,377 | 1,855 | `[0.001768394682583, 0.001768394682584]` | + +Using the baseline upper endpoint, a 5% target is +`0.00177455681454345`. Even the all-pairs upper endpoint is below it: the +endpoint ratio is exactly `43131577624/41220831929` (about `1.0463`), less than +`21/20`. The profile-only gain therefore tops out at about `4.6354%`, before charging +any physical interface. Per the task gate, I stopped before searching or +synthesizing selected-source pairs. + +## Scope and limits + +This rules out a 5% ceiling improvement from this profile substitution alone, +under the unchanged coverage law, centre charge, and outer rank cap. It does +not show that a shared-line block is impossible. Nor does it rule out a smaller +profile gain, combinations with a changed coverage law, or other rank-shape +mechanisms. The source event stream supplies frame IDs and ranks, but this +screen does not prove that any particular two transitions admit the proposed +joint interface. Physical compatibility and all adapter/copy/restoration +costs remain unproved. + +## Open next questions + +- **Can a selected-source pair of rank-two frame transitions with a shared + target line be realized by one rank-three block with fully charged source + access, fanout, adapters, and dirty restoration?** A source-realized block + could still offer a sub-5% local gain or combine with a changed coverage law. + The first step is to identify one exact pair in the pinned local program and + compare its full Clifford transitions with a proposed joint rank-three block + interface. This was not needed after the ideal 5% gate failed. + +## Reproduce + +```sh +python3 -I -B research/complex-shared-line-rank2-seedceaca8/verify.py +python3 scripts/research_package.py --package research/complex-shared-line-rank2-seedceaca8 +``` + +The verifier checks the selected replay archive and member hashes, independently +recounts both directions of the local rank profile, recomputes both rational +ceiling brackets using the pinned `complex-local-word-ceiling/ceiling.py`, and +checks the maximal-fusion and 5% boundary controls. + +## Provenance + +Cycle X, seed `ceaca886bcd52d7e2a036a2b4d561117`, on exact base +`0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; task `complex-rank-shape-decoder`, +catalogue priority revision 4. Claim: [Discussion #1163 comment 18933950](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18933950). +Focused review package: [PR #2151](https://github.com/CrocSwap/integer-mult-bounds/pull/2151). + +The initial claim comment contains transcription errors in its archive and +canonical-word member SHA-256 strings. `SOURCES.json` and `verify.py` contain +the correct hashes; the Discussion comment still needs a correction reply. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in selecting +the profile-level mechanism, deriving the favorable bound, implementing exact +checks, and writing the package. diff --git a/research/complex-shared-line-rank2-seedceaca8/RESULT.json b/research/complex-shared-line-rank2-seedceaca8/RESULT.json new file mode 100644 index 0000000000..c4082a0261 --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/RESULT.json @@ -0,0 +1,56 @@ +{ + "schema_version": 1, + "status": "SCOPED_NEGATIVE_RESULT", + "objective": "5% increase in the fixed-word a ceiling from 2xrank-2 to rank-3 shared-line block substitutions", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "source_profile_per_call": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "model": { + "m": 73, + "families": 896, + "stages": 9, + "centre": 64, + "unpaid_coordinates": 1, + "idle_rank_cap": 51, + "interface_expenses_charged": "zero" + }, + "selected_profile": { + "rank_mass": 5586, + "idle_mass": 1646, + "a_ceiling_interval": [ + "52814190909/31250000000000", + "1690054109089/1000000000000000" + ] + }, + "all_pairs_profile": { + "groups": 209, + "profile": { + "1": 2412, + "2": 0, + "3": 641, + "4": 142, + "5": 82, + "8": 8 + }, + "rank_mass": 5377, + "idle_mass": 1855, + "a_ceiling_interval": [ + "1768394682583/1000000000000000", + "221049335323/125000000000000" + ] + }, + "five_percent_target": "35491136290869/20000000000000000", + "all_pairs_upper_endpoint_ratio": "43131577624/41220831929", + "all_pairs_improvement_percent": "4.6353884809776", + "margin_below_target": "123242639189/20000000000000000", + "source_realized": false, + "new_supplier_or_kappa": false, + "remaining_obligation": "Find an exact selected-source pair and certify its rank-three shared-line block interface and complete costs if pursuing a smaller gain." +} diff --git a/research/complex-shared-line-rank2-seedceaca8/SOURCES.json b/research/complex-shared-line-rank2-seedceaca8/SOURCES.json new file mode 100644 index 0000000000..71af3a5c2e --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/SOURCES.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "input", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/complex-shared-line-rank2-seedceaca8/TASK.json b/research/complex-shared-line-rank2-seedceaca8/TASK.json new file mode 100644 index 0000000000..df0043c4bb --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/TASK.json @@ -0,0 +1,88 @@ +{ + "schema_version": 1, + "track": "complex-mechanisms", + "seed": "ceaca886bcd52d7e2a036a2b4d561117", + "scope_key": "cad3ba853d7f324f16fa", + "task_id": "complex-rank-shape-decoder", + "priority_revision": 4, + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1163#discussioncomment-18933950", + "pull_request_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2151", + "claim_update_status": "Pending correction reply because GitHub GraphQL returned an API rate-limit error; correct hashes are recorded in SOURCES.json and verify.py.", + "overlap_snapshot": { + "searched_at": "2026-10-14T20:59:11Z", + "open_prs": 401, + "discussions": 821, + "complete_pagination": true, + "warnings": [ + "Exact terms were queried offline against the complete live snapshot fetched at 20:57:09Z and 20:59:04Z; refresh again if submitting after cache expiry." + ], + "exact_grid_matches": 0 + }, + "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", + "research/selected-k8-unrestricted-ends/README.md", + "research/eisenstein-reduction-copy-floor/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.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "changed", + "actual_scope": "Upper-bound the best possible fixed-word ceiling from replacing pairs of rank-two children by rank-three blocks under a shared target-frame line, with all physical interface expenses set to zero.", + "bottleneck_link": "The selected complex side binds; reducing rank-2 paid mass could improve the fixed-word ceiling, but this ideal block family alone does not reach the 5% screen.", + "scope_change_reason": "This is a distinct geometric block hypothesis within rank-shape decoder research. The profile gate gives a strict stopping result before source synthesis.", + "budget_minutes": 60, + "stop_rule": "Allow all 209 pairings of the selected 418 rank-two events at zero interface cost. Stop before source matching if the resulting exact ceiling is below 1.05 times the pinned baseline ceiling.", + "outcome": "negative-result", + "evidence": "verify.py recomputes the selected profile and exact ceiling intervals. Even all 209 rank-two pair fusions give a ceiling ratio 43131577624/41220831929 < 21/20.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in mechanism selection, exact cost derivation, verifier implementation, and package writing.", + "open_questions": [ + { + "question": "Can a selected-source pair of rank-two frame transitions with a shared target line be realized by one rank-three block with fully charged source access, fanout, adapters, and dirty restoration?", + "why_it_matters": "A source-realized block could still offer a sub-5% local gain or combine with a changed coverage law, although this package's profile gate rejects a 5% gain from this substitution alone.", + "first_step": "Identify one exact pair in the pinned local program and compare its full Clifford transitions with a proposed joint rank-three block interface.", + "blocked_by": "No physical paired transition was needed after the ideal 5% cost gate failed." + } + ] +} diff --git a/research/complex-shared-line-rank2-seedceaca8/VERIFY.json b/research/complex-shared-line-rank2-seedceaca8/VERIFY.json new file mode 100644 index 0000000000..53714c5945 --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/complex-local-word-ceiling/ceiling.py", + "research/community-frontier1094-audit/ASSEMBLY.json", + "docs/research/community-batch1099-review.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Replay archive and member hashes; independent forward/backward profile counts; exact baseline/all-pairs ceiling brackets; maximal pair count; exact 5% ratio; impossible-pair, overfull-mass, and rank-cap negative controls" + } + ] +} diff --git a/research/complex-shared-line-rank2-seedceaca8/verify.py b/research/complex-shared-line-rank2-seedceaca8/verify.py new file mode 100644 index 0000000000..6dc9705ade --- /dev/null +++ b/research/complex-shared-line-rank2-seedceaca8/verify.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact favorable ceiling screen for rank-two shared-line block fusion.""" +from __future__ import annotations + +import gzip +import hashlib +import importlib.util +import json +import tarfile +from fractions import Fraction +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +ARCHIVE = ROOT / "research/community-frontier1094-audit/selected-replay.tar.gz" +ARCHIVE_SHA256 = "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" +MEMBERS = { + "candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz": + "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz": + "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", +} +BASE_PROFILE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} +BASE_CEILING = ( + Fraction(52814190909, 31250000000000), + Fraction(1690054109089, 10**15), +) +FULL_CEILING = ( + Fraction(1768394682583, 10**15), + Fraction(221049335323, 125000000000000), +) + + +def need(ok: bool, message: str) -> None: + if not ok: + raise AssertionError(message) + + +def sha256(data: bytes) -> str: + return hashlib.sha256(data).hexdigest() + + +def load_member(archive: tarfile.TarFile, name: str) -> bytes: + raw = archive.extractfile(name).read() + need(sha256(raw) == MEMBERS[name], f"archive member digest: {name}") + return gzip.decompress(raw) + + +def fused(profile: dict[int, int], groups: int) -> dict[int, int]: + need(isinstance(groups, int) and 0 <= groups <= profile[2] // 2, + "fusion count must be in 0..floor(n2/2)") + out = dict(profile) + out[2] -= 2 * groups + out[3] += groups + return out + + +def main() -> None: + need(sha256(ARCHIVE.read_bytes()) == ARCHIVE_SHA256, "selected replay archive digest") + with tarfile.open(ARCHIVE, "r:gz") as archive: + word = json.loads(load_member( + archive, + "candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz", + )) + programs = json.loads(load_member( + archive, + "candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz", + )) + + profile = {int(rank): int(count) for rank, count in word["local_profile"].items()} + need(profile == BASE_PROFILE, "pinned canonical local profile") + for direction in ("forward", "backward"): + recounted: dict[int, int] = {} + for event in programs[direction]: + if event[0] == "climb": + rank = int(event[5]) + elif event[0] == "center": + rank = 8 + else: + continue + recounted[rank] = recounted.get(rank, 0) + 1 + need(recounted == BASE_PROFILE, f"{direction} source-event rank census") + + model_path = ROOT / "research/complex-local-word-ceiling/ceiling.py" + spec = importlib.util.spec_from_file_location("pinned_ceiling", model_path) + need(spec is not None and spec.loader is not None, "ceiling module load") + ceiling = importlib.util.module_from_spec(spec) + spec.loader.exec_module(ceiling) + + kwargs = dict(m=73, families=896, stages=9, centre=64) + base_model = ceiling.model(profile, **kwargs) + need(base_model["R"] == 51, "selected outer rank cap") + need(base_model["total_mass"] == 7232, "coverage mass") + need(base_model["local_mass"] == 5586 and base_model["idle_mass"] == 1646, + "selected mass split") + + baseline = ceiling.ceiling(profile, **kwargs) + need(baseline == BASE_CEILING, "exact selected ceiling bracket") + no_fusion = fused(profile, 0) + need(no_fusion == profile, "zero-fusion control") + maximum_groups = profile[2] // 2 + need(maximum_groups == 209, "maximum pair count") + best = fused(profile, maximum_groups) + need(best == {1: 2412, 2: 0, 3: 641, 4: 142, 5: 82, 8: 8}, + "all-pairs profile") + best_model = ceiling.model(best, **kwargs) + need(best_model["local_mass"] == 5377 and best_model["idle_mass"] == 1855, + "all-pairs mass split") + best_bracket = ceiling.ceiling(best, **kwargs) + need(best_bracket == FULL_CEILING, "exact all-pairs ceiling bracket") + + target = baseline[1] * Fraction(105, 100) + ratio = best_bracket[1] / baseline[1] + need(best_bracket[1] < target, "5% target must remain out of reach") + need(ratio == Fraction(43131577624, 41220831929), "exact endpoint ratio") + need(ratio < Fraction(21, 20), "strict 5% ratio control") + + # Negative controls: no 210th pair exists, an overfull source profile is rejected, + # and rank 52 violates the pinned outer halving guard. + try: + fused(profile, 210) + except AssertionError: + pass + else: + raise AssertionError("impossible 210th fusion accepted") + try: + ceiling.model({**profile, 1: profile[1] + 10000}, **kwargs) + except ValueError: + pass + else: + raise AssertionError("overfull local mass accepted") + try: + ceiling.model(profile, **kwargs, R=52) + except ValueError: + pass + else: + raise AssertionError("rank-52 cap accepted") + + print( + "PASS_SHARED_LINE_RANK2_SCREEN", + f"profile={profile}", + f"groups={maximum_groups}", + f"baseline_hi={float(baseline[1]):.15f}", + f"best_hi={float(best_bracket[1]):.15f}", + f"ratio={float(ratio):.10f}", + "target=1.05", + "physical_interface=not_established", + ) + + +if __name__ == "__main__": + main()