From f0d6a48245e44fc29cfe077d21ca2521c2a8d941 Mon Sep 17 00:00:00 2001 From: Aaron Wang Date: Fri, 16 Oct 2026 16:09:23 -0400 Subject: [PATCH] Add block-climb complete-profile package: charged realization obstruction for rank-one reblocking Drawn card complex-rank-shape-decoder (unchanged scope), smallest falsifying instance plus one bounded pivot. - Exact k=2 decoding-identity classification (matching patterns admit only coordinate-aligned block-child outputs; shared-row/column mixing decodes with exact additions but never reduces charged transports) with k=3 fixture. - Dirty gather-slot writes are non-injective, so restoration forces a paid rank-1 save per overwritten slot: PR 1605's per-block tax becomes a proved lower bound for every non-owned-slot realization. - Per-group transport obstruction in closed form: a k-block climb group with alpha charged transports pays only when a > ln(1+alpha)/ln k, and ln2/ln51 = 0.17629143, so every charged group is strictly dearer than its rank-1 payload children for all a <= 1/99 and every k in 2..51 (100 grid points, two independent exact enclosures). - Complete per-call screens at a* = 21/20 * 1690054109089/1e15: every per-group charged realization fails (one shared rank-16 transport already fails), the +5% ceiling gate is missed by all charged threshold realizations (best case +4.5% with idle credit) and stays open only for call-level invoices inside PR 1605's reproduced budget of 10 added rank-1 units per call. - Controls reproduce PR 1605's k=363 threshold and budget receipts and the PR 1240 baseline ceiling bracket. No kappa claim; selected record unchanged; frozen pins untouched. Aaron Wang, with help from opencode (substantial AI assistance; no model named). --- .../README.md | 162 ++ .../RESULT.json | 1500 +++++++++++++++++ .../SOURCES.json | 36 + .../TASK.json | 122 ++ .../VERIFY.json | 23 + .../make_meta.py | 207 +++ .../verify.py | 464 +++++ 7 files changed, 2514 insertions(+) create mode 100644 research/block-climb-complete-profile-seed1ed712/README.md create mode 100644 research/block-climb-complete-profile-seed1ed712/RESULT.json create mode 100644 research/block-climb-complete-profile-seed1ed712/SOURCES.json create mode 100644 research/block-climb-complete-profile-seed1ed712/TASK.json create mode 100644 research/block-climb-complete-profile-seed1ed712/VERIFY.json create mode 100644 research/block-climb-complete-profile-seed1ed712/make_meta.py create mode 100644 research/block-climb-complete-profile-seed1ed712/verify.py diff --git a/research/block-climb-complete-profile-seed1ed712/README.md b/research/block-climb-complete-profile-seed1ed712/README.md new file mode 100644 index 0000000000..dcf0345d1b --- /dev/null +++ b/research/block-climb-complete-profile-seed1ed712/README.md @@ -0,0 +1,162 @@ +# Block-climb complete profile: the charged realization of rank-one reblocking (no new κ) + +**Scoped exact obstruction for one declared realization family of the drawn +`complex-rank-shape-decoder` card. No κ claim; the selected record is unchanged.** +Agent: Aaron Wang, with help from opencode (substantial AI assistance; no model +named; no independent human review). Base commit +`d8e0f83f00191df62174b641e9fff055c357f641`, priority revision 6. + +The card asks for one exact small decoding identity whose frame path climbs in +blocks, priced with its complete per-call profile. This package builds the +smallest such identity (`k = 2`), prices its complete invoice, and records where +the construction dies and what remains open. + +## What this establishes + +1. **Exact identity classification at the smallest block (`k = 2`).** + A rank-`k` block child delivers `k` products of linear forms, so its outputs + are rank-1 tensors. For two payload products `x_p1 y_q1`, `x_p2 y_q2`: + + - If the pair pattern is a *matching* (`p1 != p2`, `q1 != q2`), the rank-1 + tensors inside the required span `span(x_p1 y_q1, x_p2 y_q2)` are exactly + the two coordinate ones (the determinant conic of `aA + bB` is `ab`). + Only coordinate-aligned child outputs can deliver the two products. + - If the pattern shares a row or a column, mixed rank-1 outputs exist + (e.g. `x_1(y_1 + y_2)`) and decode back with exact integer additions + (`x_1 y_2 = f_1 - f_2`), but mixing never reduces the number of charged + transports: the block operands are length-`k` vectors at the block frame + in every exact realization. + + The `k = 3` fixture (all 0/1 diagonal matrices) witnesses coordinate + alignment in a finite alphabet; the general argument is the two-line + rank-1-support observation recorded in `RESULT.json` and is not + machine-checked. + +2. **Dirty gather-slot restoration forces paid work.** Writing a gathered + operand over a dirty slot is non-injective in the slot's prior content + (exact witness: states 0 and 1 collide), so restoring arbitrary dirty state + needs a paid save per overwritten slot — a rank-1 child in the retained + cost alphabet. This turns [PR 1605](https://github.com/CrocSwap/integer-mult-bounds/pull/1605)'s + "one added rank-one call per output block" tax from an assumption into a + lower bound for every realization that cannot use owned temporaries. + +3. **The transport obstruction, in closed form.** A climb group of `k` payload + units delivered by one rank-`k` child with `alpha` charged transports (each + rank-`r` transport charged as a rank-`r` recursive child, + [PR 1429](https://github.com/CrocSwap/integer-mult-bounds/pull/1429)'s contract) has net + saving `k c(1) - (1 + alpha) c(k)` over the `k` rank-1 children it replaces. + The group pays only when `k^a > alpha + 1`, that is `a > ln(1+alpha)/ln k`. + With exact enclosures, `ln 2 / ln 51 = 0.17629143...`, so **every group with + at least one charged transport is strictly dearer than its payload children + for every `a <= 1/99` (indeed every `a < 0.17629`), every `k = 2..51`**. + Both the retained `ceiling.py` enclosure and an independent binomial-tail + enclosure agree on all 150 grid points per `a`. + +4. **Complete per-call screens at the acceptance target** + `a* = 21/20 * 1690054109089/10^15 = 0.001774556814543` (the card's +5% + ceiling margin). All signs exact: + + | Realization (rank-1 payload reblocked at cap 16) | Moment at `a*` | Ceiling vs baseline | + |---|---|---| + | Selected word (no reblock) | fails (control) | 1.00x | + | `k = 362`, zero charge | fails | — | + | `k = 363`, zero charge | passes (PR 1605 threshold) | — | + | `k = 363`, one transport per group | fails | +2.8% (with idle credit) | + | `k = 363`, two transports per group | fails | +0.8% (with idle credit) | + | `k = 363`, one rank-1 save per block | fails | +4.5% (with idle credit) | + | Full reblock (`k = 2412`), zero charge | passes | 1.47x | + | Full reblock + one shared rank-16 transport | fails | — | + | Full reblock + 10 rank-1 units (the call budget) | passes | 1.47x | + + The +5% gate is missed by every per-group charged realization screened; it + stays open for call-level invoices inside PR 1605's reproduced budget of + **10 added rank-1 units per call** at full reblock (zero at `k = 363`), + which is under 0.07 units per group for 151 groups. Since the cheapest + charged item in the frame contract is one rank-1 call, **any surviving + realization must be per-group zero-charge** (both operand vectors already at + the block frame, owned gather slots) with all its charged work shared across + the call. + +So the answer to the card's question for this family: a decoder cannot deliver +the local paid mass in fewer, larger-rank children through *charged* block +frame climbs at any saving below `a = ln 2 / ln 51`; the entire lever now rests +on whether zero-charge co-frame groups exist inside the selected word. + +## Reproduce + +Python 3.12, standard library only, exact rational arithmetic throughout +(about 2 minutes): + +```sh +python3.12 -I -B research/block-climb-complete-profile-seed1ed712/verify.py +python3.12 -I -B research/block-climb-complete-profile-seed1ed712/verify.py --write # regenerates RESULT.json +``` + +Expected final line: + +```text +PASS_BLOCK_CLIMB_COMPLETE_PROFILE controls=26 charged_groups_excluded=100 free_groups_open=50 budget_rank1=10 +``` + +`make_meta.py` regenerates `TASK.json` (its `draw_card` reads the full catalogue +card object) and `SOURCES.json` pins. `verify.py` is read-only without +`--write`; it recomputes every number from the pinned inputs. + +## Scope and inherited obligations + +- **Covered.** The cost-alphabet model of [PR 1240](https://github.com/CrocSwap/integer-mult-bounds/pull/1240) + (width 73, 896 families per nine stages, centre charge 64, idle mass 1,646, + halving guard `R = 51`) with PR 1429's transport charge and PR 1605's + added-work contract (no old idle credit). The `k = 2` and `k = 3` identity + fixtures are exact; the per-group grid is exhaustive over `k = 2..51`, + `alpha in {0, 1, 2}` and three `a` values. +- **Not covered.** Word-level realizability: which of the selected word's + actual 2,412 rank-one children share frames (the zero-charge question); + joint replacement of the rank-2/rank-3 frame-step children (PR 1605 open + question 2); any changed coverage law, template, port count or centre path; + masked or overcomplete support families, which would change an assumption of + the eight-term all-pairs bound instead of this one. +- **Claims.** A scoped exclusion of the charged block-climb family and exact + per-group budgets. Not a supplier, not a lower bound on all decoders, not a + formal proof of the multiplication theorem. The ceiling comparisons grant + overhead old idle credit where that is legal, which is favorable to the + construction; the moment screens use PR 1605's stricter contract. + +## Provenance and credit + +- [PR 1605](https://github.com/CrocSwap/integer-mult-bounds/pull/1605) by Arham Tahir + (`research/complex-rank-one-block-budget`) is the direct predecessor: the + integer block budgets, the `a*` target and the `k = 363` threshold are its + results, reproduced here as controls. Its open question 1 asks for a concrete + rank-16 block decoder with fewer than one added paid call per output block; + this package prices the frame transports and restoration such a decoder must + pay and excludes every charged variant. +- [PR 1240](https://github.com/CrocSwap/integer-mult-bounds/pull/1240) by Doug Colkitt + (`research/complex-local-word-ceiling`) supplies the retained ceiling engine, + the packing ceiling `1690054109089/10^15` and the ideal lever budgets. +- [PR 1429](https://github.com/CrocSwap/integer-mult-bounds/pull/1429) by Ali Romman + (`research/complex-block-rank-optimum`) supplies the transport-charge + contract and the fixed-block moment results; nothing here reopens its scope. +- The binomial-tail enclosure method is reimplemented from PR 1605's + `verify.py` as an independent cross-check of `ceiling.py`. + +Apache-2.0. + +## Open next questions + +- **Do zero-charge co-frame climb groups exist among the selected word's actual + 2,412 rank-one payload children?** This is now the whole lever: only groups + whose operand vectors already sit at one common rank-`k` frame, with owned + gather slots, clear the complete-profile gate. A first step is to read the + pinned t16 canonical word's per-child operand frames and partition payload + pairs into co-frame groups, pricing only those. The blocker is that the + per-child frame data lives in the pinned word archives + (`t16/global/base/providers/gauge44`); extracting and classifying it is a + separate data pass not attempted here. +- **What complete profile results if a block climb also replaces the word's + rank-2/rank-3 frame-step children?** Rank-one-only reblocking cannot reach + `a = 1/99`, and the step children are the "rank-1 to rank-3 steps" the card + names. A first step is to declare the joint replacement contract and its + coverage identity before any synthesis. The blocker: the coverage identity + fixes paid mass at `72w + 64` per call, so moving step mass requires a proved + replacement identity. diff --git a/research/block-climb-complete-profile-seed1ed712/RESULT.json b/research/block-climb-complete-profile-seed1ed712/RESULT.json new file mode 100644 index 0000000000..d241d4b8fb --- /dev/null +++ b/research/block-climb-complete-profile-seed1ed712/RESULT.json @@ -0,0 +1,1500 @@ +{ + "ceilings": { + "all_mass_rank16_ideal": [ + "3909456001/1000000000000", + "1954728001/500000000000" + ], + "baseline": [ + "1690054109/1000000000000", + "169005411/100000000000" + ], + "full_alpha0": [ + "620031071/250000000000", + "496024857/200000000000" + ], + "full_plus10_budget": [ + "1236662077/500000000000", + "494664831/200000000000" + ], + "k363_alpha1_idle_credit": [ + "1737963143/1000000000000", + "217245393/125000000000" + ], + "k363_alpha2_idle_credit": [ + "26603863/15625000000", + "1702647233/1000000000000" + ], + "k363_dirty_saves_idle_credit": [ + "353357983/200000000000", + "441697479/250000000000" + ] + }, + "controls": [ + "A1_matching_conic_is_ab", + "A2_matching_mixed_output_not_rank1", + "A3_shared_row_mixed_decode_exact", + "A4_mutated_decode_fails", + "A5_shared_col_mixed_decode_exact", + "A6_coincident_span_degenerate", + "A7_k3_diagonal_rank1_are_singles", + "A8_dirty_write_noninjective", + "A9_block_child_outputs_exact", + "B1_all_charged_groups_worse_everywhere", + "B2_all_free_groups_pay_everywhere", + "B3_boundary_ln2_over_ln51", + "C1_baseline_fails_target", + "C2_threshold_363_reproduced", + "C3_charged_realizations_fail_at_threshold", + "C4_one_save_per_block_fails", + "C5_full_reblock_passes_at_zero_overhead", + "C6_one_shared_rank16_transport_fails", + "C7_full_reblock_natural_realization_fails", + "C8_overhead_budget_10_reproduced", + "C9_baseline_ceiling_bracket_contains_pinned_value", + "C10_gate_fails_for_charged_threshold_realizations", + "C14_gate_stays_open_within_call_budget", + "C11_all_mass_rank16_ideal_control", + "C12_mass_conservation", + "C13_target_matches_pinned_receipts" + ], + "full_reblock_max_extra_rank1_calls": 10, + "gate_five_percent": { + "call_budget_ten_rank1_units_meets_gate": true, + "charged_realization_even_with_idle_credit": true, + "dirty_save_realization_even_with_idle_credit": true, + "note": "The gate is missed by every per-group charged realization at the threshold partitions; it stays open for realizations whose complete charged invoice fits PR 1605's call-level budget (<= 10 added rank-1 units per call at full reblock, i.e. under 0.07 units per group).", + "one_transport_realization_even_with_idle_credit": true, + "zero_charge_full_reblock_meets_gate": true + }, + "identities": { + "coincident": { + "conic": [ + 0, + 0, + 0 + ], + "mixed_rank1_exists": true + }, + "matching": { + "conic": [ + 0, + 1, + 0 + ], + "mixed_rank1_exists": false + }, + "shared_col": { + "conic": [ + 0, + 0, + 0 + ], + "mixed_rank1_exists": true + }, + "shared_row": { + "conic": [ + 0, + 0, + 0 + ], + "mixed_rank1_exists": true + } + }, + "model": { + "centre_per_call": 64, + "families": 896, + "idle_mass": 1646, + "idle_rank_cap": 51, + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "overhead_contract": "additional work charged on top, no old idle credit (PR 1605)", + "stages": 9, + "transport_contract": "each rank-r transport charged as a rank-r recursive child (PR 1429)", + "width_m": 73 + }, + "per_group_boundary": { + "alpha1_min_boundary": [ + "ln2/ln51", + "40130480092995654431116952103155035266995333805794973303061433752709978488085/227637152264991171221148878767266763557937936282895634789427526473757754776413", + "40130480092995654431116952103155035266995333805794973303061433752709978488086/227637152264991171221148878767266763557937936282895634789427526473757754776363", + "0.17629143" + ], + "consequence": "every group with >= 1 charged transport is strictly worse than its k rank-1 payload children for all a <= 1/99 and indeed all a < ln2/ln51", + "pay_condition": "k^a > alpha + 1, i.e. a > ln(1+alpha)/ln k", + "sign_convention": "+1 = net saving positive (block group cheaper); -1 = net negative (block group dearer)" + }, + "per_group_signs": [ + { + "alpha": 0, + "k": 2, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 3, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 4, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 5, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 6, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 7, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 8, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 9, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 10, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 11, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 12, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 13, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 14, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 15, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 16, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 17, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 18, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 19, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 20, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 21, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 22, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 23, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 24, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 25, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 26, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 27, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 28, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 29, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 30, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 31, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 32, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 33, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 34, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 35, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 36, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 37, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 38, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 39, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 40, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 41, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 42, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 43, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 44, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 45, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 46, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 47, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 48, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 49, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 50, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 0, + "k": 51, + "signs": { + "base_hi": 1, + "one_99": 1, + "target": 1 + } + }, + { + "alpha": 1, + "k": 2, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 3, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 4, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 5, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 6, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 7, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 8, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 9, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 10, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 11, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 12, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 13, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 14, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 15, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 16, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 17, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 18, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 19, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 20, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 21, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 22, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 23, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 24, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 25, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 26, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 27, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 28, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 29, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 30, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 31, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 32, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 33, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 34, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 35, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 36, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 37, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 38, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 39, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 40, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 41, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 42, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 43, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 44, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 45, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 46, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 47, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 48, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 49, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 50, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 1, + "k": 51, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 2, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 3, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 4, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 5, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 6, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 7, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 8, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 9, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 10, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 11, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 12, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 13, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 14, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 15, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 16, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 17, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 18, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 19, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 20, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 21, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 22, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 23, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 24, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 25, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 26, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 27, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 28, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 29, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 30, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 31, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 32, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 33, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 34, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 35, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 36, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 37, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 38, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 39, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 40, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 41, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 42, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 43, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 44, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 45, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 46, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 47, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 48, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 49, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 50, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + }, + { + "alpha": 2, + "k": 51, + "signs": { + "base_hi": -1, + "one_99": -1, + "target": -1 + } + } + ], + "profile_screens": { + "baseline": 1, + "full_alpha0": -1, + "full_alpha2": 1, + "full_shared_rank16_one": 1, + "full_shared_rank16_two": 1, + "k362_alpha0": 1, + "k363_alpha0": -1, + "k363_alpha1": 1, + "k363_alpha2": 1, + "k363_dirty_saves": 1 + }, + "scope": "Smallest falsifying instance (k=2 exact identity) and one bounded pivot (PR 1605 threshold partitions and full reblock) of block-climb delivery of the selected word's rank-one payload; charged-climb family excluded, zero-charge co-frame groups remain open.", + "status": "PASS_BLOCK_CLIMB_COMPLETE_PROFILE", + "target": "35491136290869/20000000000000000", + "target_definition": "21/20 times the certified baseline primitive ceiling upper bound" +} diff --git a/research/block-climb-complete-profile-seed1ed712/SOURCES.json b/research/block-climb-complete-profile-seed1ed712/SOURCES.json new file mode 100644 index 0000000000..2cb30b7c90 --- /dev/null +++ b/research/block-climb-complete-profile-seed1ed712/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "files": [ + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-rank-one-block-budget/RESULT.json", + "usage": "input", + "git_blob": "7bff1e841d729679d4ce44df8103fab9430e2539", + "sha256": "fb7d1baaccc236a8e4eb1417dea76aefb1a423cf9c7677fbfa774b0673e333b6" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + } + ] +} diff --git a/research/block-climb-complete-profile-seed1ed712/TASK.json b/research/block-climb-complete-profile-seed1ed712/TASK.json new file mode 100644 index 0000000000..667272b47e --- /dev/null +++ b/research/block-climb-complete-profile-seed1ed712/TASK.json @@ -0,0 +1,122 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "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": [ + "docs/research/research-family-status.md", + "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. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "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.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "unchanged", + "actual_scope": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641", + "priority_revision": 6, + "catalogue_sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "assignment_seed": "1ed71298f6f32dd18e15e5ed217adb95", + "assignment_scope_key": "02b31ebd160542c86299", + "bottleneck_link": "Rank-1 children are about half of the selected word's recursive cost (2,412 of 5,586 local mass; effective child rank about 3.9). Block-climb delivery in fewer, larger-rank children is the card's lever (ideal rank-16 budget 2.31x in levers.py). The complete per-call profile, with charged frame transports and restoration, decides whether any charged realization of that lever survives.", + "stop_rule": "Stop at the smallest falsifying instance (the k=2 exact identity and its complete invoice), one bounded pivot to the PR 1605 threshold partitions and full reblock, and the recorded exact obstruction. Do not reprice the word's non-payload children, change the coverage law, or build a supplier.", + "evidence": "RESULT.json: k=2 exact identity classification (matching payload pairs admit only coordinate-aligned child outputs; mixing with free decode additions exists only for shared-row/shared-column pairs and never reduces charged transports); dirty gather-slot restoration forces at least one paid rank-1 save per block; per-group charged-climb nets are strictly negative for every k in 2..51, every alpha >= 1 transports per group, and every a <= 1/99 (closed form: a block group pays only when k^a > alpha + 1, i.e. a > ln(1+alpha)/ln k >= ln2/ln51 > 0.1757); complete per-call screens at a* = 21/20 * 1690054109089/1e15 fail for every per-group charged realization (one shared rank-16 transport already fails, matching PR 1605), and the card's +5% ceiling gate is missed by every charged realization screened at the threshold partitions (best case with full idle credit reaches +4.5% over the baseline ceiling) while it stays open for call-level invoices within PR 1605's 10 added rank units; controls include an independent cost enclosure cross-check and PR 1605 threshold sign reproduction.", + "outcome": "negative-result", + "author": "Aaron Wang", + "ai_assistance": "Substantial opencode assistance in choosing the scope, deriving the identity classification and transport obstruction, implementing the exact arithmetic and verification, and writing the documentation; no model named; no independent human review.", + "open_questions": [ + { + "question": "Do zero-charge co-frame climb groups exist among the selected word's actual 2,412 rank-one payload children?", + "why_it_matters": "Only alpha = 0 groups (both operand vectors already at the block frame, no restoration) clear the complete-profile gate; PR 1605's budget admits zero added work at its k = 363 threshold and up to 10 added rank units after full reblock, so co-frame coverage decides the whole lever.", + "first_step": "Read the pinned t16 canonical word's per-child operand frames, partition payload pairs whose two operand vectors already sit at one common rank-k frame, and price exactly those groups with zero charged transports.", + "blocked_by": "The per-child frame data lives in the pinned word archives (t16/global/base/providers/gauge44); extracting and classifying it is a separate data pass not attempted here." + }, + { + "question": "What complete profile results if a block climb also replaces the word's rank-2/rank-3 frame-step children (PR 1605 open question 2)?", + "why_it_matters": "Rank-one-only reblocking cannot reach a = 1/99; the frame-step children are the 'rank-1 to rank-3 steps' the card names, and subsuming them in one block climb is the only other mass-moving route.", + "first_step": "Declare the joint replacement contract (which step children each block group subsumes) and its coverage identity, then recompute the complete per-call profile before any synthesis.", + "blocked_by": "The coverage identity fixes paid mass at 72w + 64 per call; moving step mass requires a proved replacement identity, which this package does not supply." + } + ], + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18981731", + "overlap": { + "entry": { + "searched_at": "2026-10-16T19:22:14Z", + "coverage": { + "open_prs": { + "fetched_at": "2026-10-16T19:21:43Z", + "complete_pagination": true, + "records": 275 + }, + "discussions": { + "fetched_at": "2026-10-16T19:22:14Z", + "complete_pagination": true, + "records": 1756 + } + }, + "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched." + }, + "nearest_work": [ + { + "pr": 1605, + "author": "Arham Tahir (Arham-Tahir64)", + "title": "Research: sharp rank-one block budgets and per-block overhead obstruction", + "retained_package": "research/complex-rank-one-block-budget", + "difference": "Cost-alphabet screening with generic added-work budgets; this package constructs the smallest exact block-climb identity and prices its charged frame transports and dirty restoration, closing its open question 1 for every charged realization." + }, + { + "pr": 1240, + "author": "Doug Colkitt (Mister-Meeseeks)", + "retained_package": "research/complex-local-word-ceiling", + "difference": "Packing ceiling and ideal lever budgets; retained as the screening engine." + }, + { + "pr": 1429, + "author": "Ali Romman (aliromman)", + "retained_package": "research/complex-block-rank-optimum", + "difference": "Moment optimality of fixed eight-array blocks and the transport-charge contract (each rank-r transport charged as a rank-r recursive child) that this package's invoices use." + } + ], + "pair_collision": "disc-comments --grep scans of discussions 1317 and 1166 (nested replies, timestamps) found no live CLAIM on this object at entry; the Oct 14-15 complex-rank-shape-decoder claims there are all DONE/released.", + "final_conclusion": "No competing claim on the charged-climb realization question was located in the searched coverage; this is not proof of novelty." + } +} diff --git a/research/block-climb-complete-profile-seed1ed712/VERIFY.json b/research/block-climb-complete-profile-seed1ed712/VERIFY.json new file mode 100644 index 0000000000..afaed92043 --- /dev/null +++ b/research/block-climb-complete-profile-seed1ed712/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-rank-one-block-budget/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Exact k=2/k=3 decoding-identity classification and decode witnesses, dirty-slot restoration witness, the exhaustive (k, alpha, a) per-group sign grid with two independent cost enclosures, complete per-call moment screens at a*, ceiling gate screens with idle credit, and reproduction of PR 1605's threshold and overhead-budget receipts. Read-only; recomputes every number from the pinned inputs." + } + ] +} diff --git a/research/block-climb-complete-profile-seed1ed712/make_meta.py b/research/block-climb-complete-profile-seed1ed712/make_meta.py new file mode 100644 index 0000000000..68c5f9b5a2 --- /dev/null +++ b/research/block-climb-complete-profile-seed1ed712/make_meta.py @@ -0,0 +1,207 @@ +#!/usr/bin/env python3 +"""Generate TASK.json and SOURCES.json for this package. + +draw_card() reads the full catalogue card object from +docs/research/agent-task-catalog.json at the pinned base commit, so TASK.json's +original_card is byte-equal to the catalogue object (the generic generator's +trimmed card fails scripts/research_package.py's exact comparison). + +Aaron Wang, with help from opencode. Apache-2.0. +""" +import hashlib +import json +import subprocess +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +TASK_ID = "complex-rank-shape-decoder" +BASE_COMMIT = "d8e0f83f00191df62174b641e9fff055c357f641" +CATALOGUE_SHA256 = "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" +SELECTED_RECORD_SHA256 = "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" +SEED = "1ed71298f6f32dd18e15e5ed217adb95" +SCOPE_KEY = "02b31ebd160542c86299" + + +def draw_card(task_id): + """Return the full catalogue card object for task_id at the pinned base commit.""" + raw = subprocess.run( + ["git", "show", BASE_COMMIT + ":docs/research/agent-task-catalog.json"], + cwd=ROOT, capture_output=True, check=True).stdout + catalog = json.loads(raw.decode("utf-8")) + cards = [t for tr in catalog["tracks"] for t in tr["tasks"] if t["id"] == task_id] + if len(cards) != 1: + raise ValueError("expected exactly one catalogue card for " + task_id) + return cards[0] + + +def git_blob(path): + out = subprocess.run(["git", "ls-tree", BASE_COMMIT, "--", path], + cwd=ROOT, capture_output=True, check=True).stdout.decode("ascii") + fields = out.split() + if len(fields) < 3 or fields[1] != "blob": + raise ValueError("missing blob at base commit: " + path) + return fields[2] + + +def main(): + sys.stdout.reconfigure(encoding="utf-8") + card = draw_card(TASK_ID) + task = { + "schema_version": 1, + "task_id": TASK_ID, + "original_card": card, + "scope_status": "unchanged", + "actual_scope": card["question"], + "base_commit": BASE_COMMIT, + "priority_revision": 6, + "catalogue_sha256": CATALOGUE_SHA256, + "selected_record_sha256": SELECTED_RECORD_SHA256, + "assignment_seed": SEED, + "assignment_scope_key": SCOPE_KEY, + "bottleneck_link": ( + "Rank-1 children are about half of the selected word's recursive cost " + "(2,412 of 5,586 local mass; effective child rank about 3.9). Block-climb " + "delivery in fewer, larger-rank children is the card's lever (ideal rank-16 " + "budget 2.31x in levers.py). The complete per-call profile, with charged " + "frame transports and restoration, decides whether any charged realization " + "of that lever survives."), + "stop_rule": ( + "Stop at the smallest falsifying instance (the k=2 exact identity and its " + "complete invoice), one bounded pivot to the PR 1605 threshold partitions " + "and full reblock, and the recorded exact obstruction. Do not reprice the " + "word's non-payload children, change the coverage law, or build a supplier."), + "evidence": ( + "RESULT.json: k=2 exact identity classification (matching payload pairs admit " + "only coordinate-aligned child outputs; mixing with free decode additions exists " + "only for shared-row/shared-column pairs and never reduces charged transports); " + "dirty gather-slot restoration forces at least one paid rank-1 save per block; " + "per-group charged-climb nets are strictly negative for every k in 2..51, every " + "alpha >= 1 transports per group, and every a <= 1/99 (closed form: a block group " + "pays only when k^a > alpha + 1, i.e. a > ln(1+alpha)/ln k >= ln2/ln51 > 0.1757); " + "complete per-call screens at a* = 21/20 * 1690054109089/1e15 fail for every " + "per-group charged realization (one shared rank-16 transport already fails, " + "matching PR 1605), and the card's +5% ceiling gate is missed by every charged " + "realization screened at the threshold partitions (best case with full idle " + "credit reaches +4.5% over the baseline ceiling) while it stays open for " + "call-level invoices within PR 1605's 10 added rank units; controls include " + "an independent cost enclosure cross-check and PR 1605 threshold " + "sign reproduction."), + "outcome": "negative-result", + "author": "Aaron Wang", + "ai_assistance": ( + "Substantial opencode assistance in choosing the scope, deriving the identity " + "classification and transport obstruction, implementing the exact arithmetic and " + "verification, and writing the documentation; no model named; no independent " + "human review."), + "open_questions": [ + { + "question": ( + "Do zero-charge co-frame climb groups exist among the selected word's " + "actual 2,412 rank-one payload children?"), + "why_it_matters": ( + "Only alpha = 0 groups (both operand vectors already at the block frame, " + "no restoration) clear the complete-profile gate; PR 1605's budget admits " + "zero added work at its k = 363 threshold and up to 10 added rank units " + "after full reblock, so co-frame coverage decides the whole lever."), + "first_step": ( + "Read the pinned t16 canonical word's per-child operand frames, partition " + "payload pairs whose two operand vectors already sit at one common rank-k " + "frame, and price exactly those groups with zero charged transports."), + "blocked_by": ( + "The per-child frame data lives in the pinned word archives " + "(t16/global/base/providers/gauge44); extracting and classifying it is a " + "separate data pass not attempted here."), + }, + { + "question": ( + "What complete profile results if a block climb also replaces the word's " + "rank-2/rank-3 frame-step children (PR 1605 open question 2)?"), + "why_it_matters": ( + "Rank-one-only reblocking cannot reach a = 1/99; the frame-step children " + "are the 'rank-1 to rank-3 steps' the card names, and subsuming them in " + "one block climb is the only other mass-moving route."), + "first_step": ( + "Declare the joint replacement contract (which step children each block " + "group subsumes) and its coverage identity, then recompute the complete " + "per-call profile before any synthesis."), + "blocked_by": ( + "The coverage identity fixes paid mass at 72w + 64 per call; moving step " + "mass requires a proved replacement identity, which this package does not " + "supply."), + }, + ], + "claim_url": ( + "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166" + "#discussioncomment-18981731"), + "overlap": { + "entry": { + "searched_at": "2026-10-16T19:22:14Z", + "coverage": { + "open_prs": {"fetched_at": "2026-10-16T19:21:43Z", + "complete_pagination": True, "records": 275}, + "discussions": {"fetched_at": "2026-10-16T19:22:14Z", + "complete_pagination": True, "records": 1756}, + }, + "limits": ( + "Remote PR scope is open PRs including drafts. Closed work is searched " + "through local READMEs, TASK metadata and ledger only. No code diffs or " + "arbitrary package files are searched."), + }, + "nearest_work": [ + {"pr": 1605, + "author": "Arham Tahir (Arham-Tahir64)", + "title": "Research: sharp rank-one block budgets and per-block overhead obstruction", + "retained_package": "research/complex-rank-one-block-budget", + "difference": ( + "Cost-alphabet screening with generic added-work budgets; this package " + "constructs the smallest exact block-climb identity and prices its " + "charged frame transports and dirty restoration, closing its open " + "question 1 for every charged realization.")}, + {"pr": 1240, + "author": "Doug Colkitt (Mister-Meeseeks)", + "retained_package": "research/complex-local-word-ceiling", + "difference": "Packing ceiling and ideal lever budgets; retained as the screening engine."}, + {"pr": 1429, + "author": "Ali Romman (aliromman)", + "retained_package": "research/complex-block-rank-optimum", + "difference": ( + "Moment optimality of fixed eight-array blocks and the transport-charge " + "contract (each rank-r transport charged as a rank-r recursive child) " + "that this package's invoices use.")}, + ], + "pair_collision": ( + "disc-comments --grep scans of discussions 1317 and 1166 (nested replies, " + "timestamps) found no live CLAIM on this object at entry; the Oct 14-15 " + "complex-rank-shape-decoder claims there are all DONE/released."), + "final_conclusion": ( + "No competing claim on the charged-climb realization question was located in " + "the searched coverage; this is not proof of novelty."), + }, + } + (HERE / "TASK.json").write_text(json.dumps(task, indent=2) + "\n", encoding="utf-8", newline="\n") + + inputs = [ + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-rank-one-block-budget/RESULT.json", + ] + provenance = [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + ] + rows = [] + for usage, paths in (("input", inputs), ("provenance", provenance)): + for path in paths: + blob = git_blob(path) + digest = hashlib.sha256((ROOT / path).read_bytes()).hexdigest() + rows.append({"path": path, "usage": usage, "git_blob": blob, "sha256": digest}) + sources = {"schema_version": 1, "base_commit": BASE_COMMIT, "files": rows} + (HERE / "SOURCES.json").write_text(json.dumps(sources, indent=2) + "\n", + encoding="utf-8", newline="\n") + print("WROTE_TASK_AND_SOURCES card_keys=" + ",".join(sorted(card))) + + +if __name__ == "__main__": + main() diff --git a/research/block-climb-complete-profile-seed1ed712/verify.py b/research/block-climb-complete-profile-seed1ed712/verify.py new file mode 100644 index 0000000000..f525177bf0 --- /dev/null +++ b/research/block-climb-complete-profile-seed1ed712/verify.py @@ -0,0 +1,464 @@ +#!/usr/bin/env python3 +"""Complete-profile screen for block-climb decoding identities of the rank-one payload. + +Scope: the drawn catalogue card complex-rank-shape-decoder (unchanged), executed at +its smallest falsifying instance (k = 2) and one bounded pivot (the PR 1605 +threshold partitions and full reblock). All arithmetic is exact rational +enclosure arithmetic (integers and fractions only). + +Sections: + A. Exact k = 2 decoding identities: which operand-mixing patterns can deliver + the two payload products at all, the exact decode matrices, and the + dirty gather-slot restoration witness. + B. Per-group hard search: net saving of one k-block climb group with alpha + charged transports against k rank-1 payload children, exact intervals, + k = 2..51, alpha in {0, 1, 2}, a in {target, 1/99, baseline ceiling}, + plus the closed-form boundary ln(1+alpha)/ln k. + C. Complete per-call profiles at the target a*: threshold signs, charged + realizations, full reblock, overhead budgets, and the +5% ceiling gate. + D. Controls: independent cost enclosure cross-check, threshold reproduction + against pinned predecessor receipts, mutated-decode failure, mass checks. + +Aaron Wang, with help from opencode. Apache-2.0. +""" +import argparse +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +import hashlib +import importlib.util +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +M, W, IDLE, RMAX = 73, Q(896, 9), 1646, 51 +BASE_HI = Q(1690054109089, 10 ** 15) +TARGET = Q(21, 20) * BASE_HI +WORD = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} +INPUTS = [ + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-rank-one-block-budget/RESULT.json", +] +CHECKS = [] + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def check(ok, name, detail=""): + require(ok, "control failed: " + name + ("; " + detail if detail else "")) + CHECKS.append(name) + print("PASS " + name + (" " + detail if detail else "")) + + +def fstr(x): + return str(x.numerator) + "/" + str(x.denominator) + + +def fdec(x, places=12): + return format(float(x), "." + str(places) + "f") + + +# ---------------------------------------------------------------- sources + + +def load_sources(): + pins = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + declared = [row["path"] for row in pins["files"] if row["usage"] == "input"] + require(sorted(declared) == sorted(INPUTS), "source inventory must match INPUTS") + for row in pins["files"]: + if row["usage"] == "input": + digest = hashlib.sha256((ROOT / row["path"]).read_bytes()).hexdigest() + require(digest == row["sha256"], "source drift: " + row["path"]) + path = ROOT / "research/complex-local-word-ceiling/ceiling.py" + spec = importlib.util.spec_from_file_location("retained_ceiling", path) + engine = importlib.util.module_from_spec(spec) + spec.loader.exec_module(engine) + return engine + + +# ------------------------------------------- independent cost enclosure (B) + + +@lru_cache(None) +def binomial_cost(r, a): + """Independent enclosure of (r/73)^(1-a) via the negative binomial tail. + + Method reimplemented from PR 1605 (Arham Tahir) verify.py: for q = 1-a and + z = 1-r/73, (1-z)^q = 1 - sum(t_n), all t_n > 0, t_1 = q z, + t_(n+1) = t_n z (n-q)/(n+1). Outward integer rounding encloses roundoff. + """ + require(type(r) is int and 1 <= r < M and 0 < a < 1, "binomial domain") + scale = 1 << 160 + q, z = 1 - a, Q(M - r, M) + + def floor(x): + return x.numerator // x.denominator + + def ceil(x): + return -((-x.numerator) // x.denominator) + + lo, hi = floor(q * z * scale), ceil(q * z * scale) + sum_lo, sum_hi, n = lo, hi, 1 + while True: + ratio = z * (n - q) / (n + 1) + lo, hi = floor(lo * ratio), ceil(hi * ratio) + tail = ceil(hi / (1 - z)) + if tail <= 1 << 70: + return Q(scale - sum_hi - tail, scale), Q(scale - sum_lo, scale) + sum_lo, sum_hi, n = sum_lo + lo, sum_hi + hi, n + 1 + + +def sign_of(bounds): + if bounds[1] < 1: + return -1 + if bounds[0] > 1: + return 1 + raise ValueError("unresolved strict moment sign") + + +def moment(profile, a, cost, overhead=None): + """Per-call moment bounds: profile + ideal idle packing + charged overhead on top.""" + terms = dict(profile) + terms[RMAX] = terms.get(RMAX, 0) + Q(IDLE, RMAX) + for r, n in (overhead or {}).items(): + require(type(r) is int and 1 <= r <= RMAX and Q(n) >= 0, "overhead alphabet") + terms[r] = terms.get(r, 0) + Q(n) + lo = hi = Q(0) + for r, n in terms.items(): + c = cost(r, a) + lo, hi = lo + Q(n) * c[0], hi + Q(n) * c[1] + return lo / W, hi / W + + +def partition(k, cap): + count, remainder = divmod(k, cap) + out = Counter({cap: count}) if count else Counter() + if remainder: + out[remainder] += 1 + return dict(sorted(out.items())) + + +def profile(k, cap): + out = Counter(WORD) + out[1] -= k + out.update(partition(k, cap)) + return {r: n for r, n in sorted(out.items()) if n} + + +def mass(p): + return sum(r * Q(n) for r, n in p.items()) + + +# ------------------------------------------------------ A: exact identities + +# A bilinear form on (x1, x2) x (y1, y2) is the 2x2 integer tuple +# (m00, m01, m10, m11) with m_ij the coefficient of x_i y_j. + + +def det2(m): + return m[0] * m[3] - m[1] * m[2] + + +def addm(p, q, ap=1, bq=1): + return tuple(ap * p[i] + bq * q[i] for i in range(4)) + + +def is_rank1(m): + return m != (0, 0, 0, 0) and det2(m) == 0 + + +def conic(A, B): + """det(aA + bB) = alpha a^2 + beta ab + gamma b^2 with exact integers.""" + alpha = det2(A) + gamma = det2(B) + beta = det2(addm(A, B)) - alpha - gamma + return alpha, beta, gamma + + +def identity_section(): + out = {} + matching = ((1, 0, 0, 0), (0, 0, 0, 1)) + shared_row = ((1, 0, 0, 0), (0, 1, 0, 0)) + shared_col = ((1, 0, 0, 0), (0, 0, 1, 0)) + coincident = ((1, 0, 0, 0), (1, 0, 0, 0)) + patterns = {"matching": matching, "shared_row": shared_row, + "shared_col": shared_col, "coincident": coincident} + for name, (A, B) in patterns.items(): + alpha, beta, gamma = conic(A, B) + mixed_rank1 = is_rank1(addm(A, B)) + out[name] = {"conic": [alpha, beta, gamma], "mixed_rank1_exists": mixed_rank1} + # Matching: det(aA + bB) = ab, so every rank-1 tensor in the span is a + # multiple of A or B: only coordinate-aligned child outputs can deliver the + # two products individually. + alpha, beta, gamma = out["matching"]["conic"] + check((alpha, beta, gamma) == (0, 1, 0), "A1_matching_conic_is_ab", + "conic=(0,1,0)") + check(not out["matching"]["mixed_rank1_exists"], "A2_matching_mixed_output_not_rank1") + # Shared-row and shared-column spans contain non-coordinate rank-1 tensors; + # the mixed outputs decode back with exact integer additions. + f1 = addm(*shared_row) # x1(y1 + y2) + f2 = shared_row[0] # x1 y1 + decoded_b = addm(f1, f2, 1, -1) # f1 - f2 = x1 y2 + check(is_rank1(f1) and decoded_b == shared_row[1], + "A3_shared_row_mixed_decode_exact", "f1-f2=x1y2") + mutated = addm(f1, f2, 1, 1) # wrong decode: f1 + f2 + check(mutated != shared_row[1], "A4_mutated_decode_fails") + g1 = addm(*shared_col) # (x1 + x2) y1 + g2 = shared_col[0] # x1 y1 + check(is_rank1(g1) and addm(g1, g2, 1, -1) == shared_col[1], + "A5_shared_col_mixed_decode_exact") + check(all(addm(*coincident, a, b) == tuple((a + b) * coincident[0][i] for i in range(4)) + for a, b in ((1, 1), (2, -1))), + "A6_coincident_span_degenerate") + # k = 3 finite fixture for coordinate alignment: among 0/1 3x3 matrices + # supported on the diagonal, the rank-1 ones are exactly the three singles. + singles = 0 + multi = 0 + for bits in range(1 << 9): + off = [(bits >> (i * 3 + j)) & 1 for i in range(3) for j in range(3) if i != j] + if any(off): + continue + diag = [(bits >> (i * 3 + i)) & 1 for i in range(3)] + nonzero = sum(diag) # rank of a diagonal 0/1 matrix + if nonzero == 1: + singles += 1 + elif nonzero >= 2: + multi += 1 + check(singles == 3 and multi == 4, "A7_k3_diagonal_rank1_are_singles", + "singles=3 multi=4") + # Dirty gather-slot restoration witness: writing the gathered operand over a + # dirty slot is non-injective in the prior content, so restoring arbitrary + # dirty state needs a paid save of the overwritten content first. + def write_gather(prior): + return 5 # the gathered value, independent of prior + + check(write_gather(0) == write_gather(1), "A8_dirty_write_noninjective", + "states 0 and 1 collide") + + # The k = 2 coordinate-aligned block child: outputs u1v1, u2v2 are exactly + # the two payload products (exact integer fixtures, flat (m00,m01,m10,m11)). + out1 = (1, 0, 0, 0) # u1 v1 = x1 y1 + out2 = (0, 0, 0, 1) # u2 v2 = x2 y2 + check(out1 == matching[0] and out2 == matching[1], "A9_block_child_outputs_exact") + return out + + +# ------------------------------------------------- B: per-group hard search + + +def per_group(engines): + """Net saving of one k-block climb group (alpha charged transports) against + k rank-1 payload children: net = k c(1) - (1+alpha) c(k). Sign convention: + +1 = net positive (block group strictly cheaper), -1 = net negative.""" + rows = [] + for alpha in (0, 1, 2): + for k in range(2, 52): + row = {"k": k, "alpha": alpha, "signs": {}} + for label, a in (("target", TARGET), ("one_99", Q(1, 99)), ("base_hi", BASE_HI)): + signs = [] + for name, cost in engines: + c1 = cost(1, a) + ck = cost(k, a) + lo = k * c1[0] - (1 + alpha) * ck[1] + hi = k * c1[1] - (1 + alpha) * ck[0] + signs.append(1 if lo > 0 else (-1 if hi < 0 else 0)) + require(signs[0] == signs[1] != 0, "engine sign disagreement at k=%d" % k) + row["signs"][label] = signs[0] + rows.append(row) + return rows + + +def boundary_alpha1(engine): + ln = engine.ln + l2 = ln(2) + l51 = ln(51) + lo = l2[0] / l51[1] + hi = l2[1] / l51[0] + return lo, hi + + +# --------------------------------------------- C: complete per-call profiles + + +def profile_section(engine): + def cost(r, a): + return engine.child_cost(r, M, a) + + def sign_at(p, overhead=None): + return sign_of(moment(p, TARGET, cost, overhead)) + + screens = {} + screens["baseline"] = sign_at(WORD) + p363 = profile(363, 16) + p362 = profile(362, 16) + pfull = profile(2412, 16) + screens["k363_alpha0"] = sign_at(p363) + screens["k362_alpha0"] = sign_at(p362) + screens["k363_alpha2"] = sign_at(p363, {16: 44, 11: 2}) + screens["k363_alpha1"] = sign_at(p363, {16: 22, 11: 1}) + screens["k363_dirty_saves"] = sign_at(p363, {1: 23}) + screens["full_alpha0"] = sign_at(pfull) + screens["full_shared_rank16_one"] = sign_at(pfull, {16: 1}) + screens["full_shared_rank16_two"] = sign_at(pfull, {16: 2}) + screens["full_alpha2"] = sign_at(pfull, {16: 300, 12: 2}) + + budget = None + for n in range(0, 21): + if sign_at(pfull, {1: n}) == -1: + budget = n + else: + break + ceilings = {} + + def cap(local): + return engine.ceiling(local, M, 896, 9, 64, grid=Q(1, 10 ** 12), unpaid=1) + + ceilings["baseline"] = cap(WORD) + ceilings["all_mass_rank16_ideal"] = cap({16: Q(5586, 16)}) + ceilings["full_alpha0"] = cap(pfull) + charged = dict(p363) + for r, n in {16: 44, 11: 2}.items(): + charged[r] = charged.get(r, 0) + n + ceilings["k363_alpha2_idle_credit"] = cap(charged) + charged1 = dict(p363) + for r, n in {16: 22, 11: 1}.items(): + charged1[r] = charged1.get(r, 0) + n + ceilings["k363_alpha1_idle_credit"] = cap(charged1) + ceilings["k363_dirty_saves_idle_credit"] = cap({**p363, 1: p363[1] + 23}) + ceilings["full_plus10_budget"] = cap({**pfull, 1: pfull.get(1, 0) + 10}) + return screens, budget, ceilings, {"k363": p363, "k362": p362, "full": pfull} + + +# ------------------------------------------------------------------- main + + +def main(): + sys.stdout.reconfigure(encoding="utf-8") + parser = argparse.ArgumentParser() + parser.add_argument("--write", action="store_true") + args = parser.parse_args() + engine = load_sources() + ceiling_result = json.loads( + (ROOT / "research/complex-local-word-ceiling/RESULT.json").read_text(encoding="utf-8")) + budget_result = json.loads( + (ROOT / "research/complex-rank-one-block-budget/RESULT.json").read_text(encoding="utf-8")) + + ids = identity_section() + + engines = [("retained_ceiling", lambda r, a: engine.child_cost(r, M, a)), + ("independent_binomial", lambda r, a: binomial_cost(r, a))] + rows = per_group(engines) + # Sign convention: +1 means net saving positive (block group strictly + # cheaper), -1 means net saving negative (block group strictly dearer). + charged_worse = [r for r in rows if r["alpha"] >= 1 and all(v == -1 for v in r["signs"].values())] + free_pays = [r for r in rows if r["alpha"] == 0 and all(v == 1 for v in r["signs"].values())] + check(len(charged_worse) == 100, "B1_all_charged_groups_worse_everywhere", "100 rows") + check(len(free_pays) == 50, "B2_all_free_groups_pay_everywhere", "50 rows") + + lo, hi = boundary_alpha1(engine) + check(Q(1, 99) < lo and TARGET < lo, "B3_boundary_ln2_over_ln51", + "ln2/ln51 in [" + fdec(lo, 8) + ", " + fdec(hi, 8) + "]") + + screens, budget, ceilings, profs = profile_section(engine) + check(screens["baseline"] == 1, "C1_baseline_fails_target") + check(screens["k363_alpha0"] == -1 and screens["k362_alpha0"] == 1, + "C2_threshold_363_reproduced", "k=362 fails, k=363 passes at zero overhead") + check(screens["k363_alpha1"] == 1 and screens["k363_alpha2"] == 1, + "C3_charged_realizations_fail_at_threshold") + check(screens["k363_dirty_saves"] == 1, "C4_one_save_per_block_fails") + check(screens["full_alpha0"] == -1, "C5_full_reblock_passes_at_zero_overhead") + check(screens["full_shared_rank16_one"] == 1 and screens["full_shared_rank16_two"] == 1, + "C6_one_shared_rank16_transport_fails") + check(screens["full_alpha2"] == 1, "C7_full_reblock_natural_realization_fails") + check(budget == budget_result["rank16_complete_max_extra_integer_rank_mass"] == 10, + "C8_overhead_budget_10_reproduced", "max extra rank-1 calls = 10") + + base_cap = ceilings["baseline"] + check(base_cap[0] <= BASE_HI <= base_cap[1], + "C9_baseline_ceiling_bracket_contains_pinned_value", + "[" + fdec(base_cap[0], 15) + ", " + fdec(base_cap[1], 15) + "]") + gate_free = ceilings["full_alpha0"][0] >= TARGET + gate_charged = ceilings["k363_alpha2_idle_credit"][1] < TARGET + gate_charged1 = ceilings["k363_alpha1_idle_credit"][1] < TARGET + gate_dirty = ceilings["k363_dirty_saves_idle_credit"][1] < TARGET + check(gate_free and gate_charged and gate_charged1 and gate_dirty, + "C10_gate_fails_for_charged_threshold_realizations") + budget_sign = sign_of(moment(profs["full"], TARGET, + lambda r, a: engine.child_cost(r, M, a), {1: 10})) + gate_budget = ceilings["full_plus10_budget"][0] >= TARGET + check(gate_budget and budget_sign == -1, "C14_gate_stays_open_within_call_budget", + "full reblock + 10 rank-1 units") + ideal = ceilings["all_mass_rank16_ideal"] + check(ideal[0] > 2 * BASE_HI, "C11_all_mass_rank16_ideal_control", + "x" + fdec(ideal[0] / BASE_HI, 3)) + + require(mass(profs["k363"]) == mass(profs["k362"]) == mass(profs["full"]) == 2412 + 418 * 2 + + 432 * 3 + 142 * 4 + 82 * 5 + 8 * 8, "mass conservation") + check(True, "C12_mass_conservation", "local mass 5586 preserved") + + target_check = Q(21, 20) * Q(1690054109089, 10 ** 15) + num, den = budget_result["target"].split("/") + require(target_check == Q(int(num), int(den)) == TARGET, + "target definition drift") + check(True, "C13_target_matches_pinned_receipts", + "a* = " + fdec(TARGET, 15)) + + result = { + "status": "PASS_BLOCK_CLIMB_COMPLETE_PROFILE", + "scope": ( + "Smallest falsifying instance (k=2 exact identity) and one bounded pivot " + "(PR 1605 threshold partitions and full reblock) of block-climb delivery of " + "the selected word's rank-one payload; charged-climb family excluded, " + "zero-charge co-frame groups remain open."), + "model": { + "width_m": 73, "families": 896, "stages": 9, "centre_per_call": 64, + "local_profile": {str(k): v for k, v in WORD.items()}, + "idle_mass": IDLE, "idle_rank_cap": RMAX, + "transport_contract": "each rank-r transport charged as a rank-r recursive child (PR 1429)", + "overhead_contract": "additional work charged on top, no old idle credit (PR 1605)", + }, + "target": fstr(TARGET), + "target_definition": "21/20 times the certified baseline primitive ceiling upper bound", + "identities": ids, + "per_group_boundary": { + "sign_convention": "+1 = net saving positive (block group cheaper); -1 = net negative (block group dearer)", + "pay_condition": "k^a > alpha + 1, i.e. a > ln(1+alpha)/ln k", + "alpha1_min_boundary": ["ln2/ln51", fstr(lo), fstr(hi), fdec(lo, 8)], + "consequence": ( + "every group with >= 1 charged transport is strictly worse than its k " + "rank-1 payload children for all a <= 1/99 and indeed all a < ln2/ln51"), + }, + "per_group_signs": rows, + "profile_screens": {k: v for k, v in screens.items()}, + "full_reblock_max_extra_rank1_calls": budget, + "ceilings": {k: [fstr(v[0]), fstr(v[1])] for k, v in ceilings.items()}, + "gate_five_percent": { + "zero_charge_full_reblock_meets_gate": gate_free, + "charged_realization_even_with_idle_credit": gate_charged, + "one_transport_realization_even_with_idle_credit": gate_charged1, + "dirty_save_realization_even_with_idle_credit": gate_dirty, + "call_budget_ten_rank1_units_meets_gate": gate_budget, + "note": ( + "The gate is missed by every per-group charged realization at the " + "threshold partitions; it stays open for realizations whose complete " + "charged invoice fits PR 1605's call-level budget (<= 10 added rank-1 " + "units per call at full reblock, i.e. under 0.07 units per group)."), + }, + "controls": CHECKS, + } + text = json.dumps(result, indent=1, sort_keys=True) + if args.write: + (HERE / "RESULT.json").write_text(text + "\n", encoding="utf-8", newline="\n") + print("WROTE_RESULT_JSON") + print("PASS_BLOCK_CLIMB_COMPLETE_PROFILE controls=" + str(len(CHECKS)) + + " charged_groups_excluded=100 free_groups_open=50 budget_rank1=" + str(budget)) + + +if __name__ == "__main__": + main()