diff --git a/research/complex-rank6-hetero21-seedfb19/CERTIFICATE.json b/research/complex-rank6-hetero21-seedfb19/CERTIFICATE.json new file mode 100644 index 0000000000..53f5d63df3 --- /dev/null +++ b/research/complex-rank6-hetero21-seedfb19/CERTIFICATE.json @@ -0,0 +1,1435 @@ +{ + "schema_version": 1, + "source": { + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "archive_sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "member": "candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz", + "member_sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + }, + "fusion": { + "rank_multiset": [ + 1, + 1, + 2, + 2 + ], + "child_rank": 6, + "rank_mass_before": 6, + "rank_mass_after": 6, + "identity": "diag(A2,B2,a,b) diag(C2,D2,c,d) = diag(A2*C2,B2*D2,a*c,b*d)" + }, + "orientations": { + "backward": { + "event_count": 24767, + "profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "admissible_windows": [ + { + "start": 16718, + "end": 16721, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 14, + 15, + 16, + 17 + ] + }, + { + "start": 16728, + "end": 16731, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 24, + 25, + 26, + 27 + ] + }, + { + "start": 16729, + "end": 16732, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 25, + 26, + 27, + 28 + ] + }, + { + "start": 16780, + "end": 16783, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 76, + 77, + 78, + 79 + ] + }, + { + "start": 16794, + "end": 16797, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 90, + 91, + 92, + 93 + ] + }, + { + "start": 16827, + "end": 16830, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 235, + 236, + 237, + 238 + ] + }, + { + "start": 16828, + "end": 16831, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 236, + 237, + 238, + 239 + ] + }, + { + "start": 16829, + "end": 16832, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 237, + 238, + 239, + 240 + ] + }, + { + "start": 16843, + "end": 16846, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 251, + 252, + 253, + 254 + ] + }, + { + "start": 16844, + "end": 16847, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 252, + 253, + 254, + 255 + ] + }, + { + "start": 16845, + "end": 16848, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 253, + 254, + 255, + 256 + ] + }, + { + "start": 16859, + "end": 16862, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 267, + 268, + 269, + 270 + ] + }, + { + "start": 16860, + "end": 16863, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 268, + 269, + 270, + 271 + ] + }, + { + "start": 16861, + "end": 16864, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 269, + 270, + 271, + 272 + ] + }, + { + "start": 16969, + "end": 16972, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 411, + 412, + 413, + 414 + ] + }, + { + "start": 16970, + "end": 16973, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 412, + 413, + 414, + 415 + ] + }, + { + "start": 16971, + "end": 16974, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 413, + 414, + 415, + 416 + ] + }, + { + "start": 16985, + "end": 16988, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 427, + 428, + 429, + 430 + ] + }, + { + "start": 16986, + "end": 16989, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 428, + 429, + 430, + 431 + ] + }, + { + "start": 16987, + "end": 16990, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 429, + 430, + 431, + 432 + ] + }, + { + "start": 17001, + "end": 17004, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 443, + 444, + 445, + 446 + ] + }, + { + "start": 17002, + "end": 17005, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 444, + 445, + 446, + 447 + ] + }, + { + "start": 17003, + "end": 17006, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 445, + 446, + 447, + 456 + ] + }, + { + "start": 17020, + "end": 17023, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 470, + 471, + 472, + 473 + ] + }, + { + "start": 17042, + "end": 17045, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 494, + 495, + 496, + 497 + ] + }, + { + "start": 17043, + "end": 17046, + "ranks_in_order": [ + 1, + 2, + 2, + 1 + ], + "destinations": [ + 495, + 496, + 497, + 499 + ] + }, + { + "start": 17044, + "end": 17047, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 496, + 497, + 499, + 502 + ] + }, + { + "start": 17058, + "end": 17061, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 518, + 519, + 520, + 521 + ] + } + ], + "admissible_window_count": 28, + "maximum_disjoint_count": 13, + "one_maximum_schedule": [ + { + "start": 16718, + "end": 16721, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 14, + 15, + 16, + 17 + ] + }, + { + "start": 16728, + "end": 16731, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 24, + 25, + 26, + 27 + ] + }, + { + "start": 16780, + "end": 16783, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 76, + 77, + 78, + 79 + ] + }, + { + "start": 16794, + "end": 16797, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 90, + 91, + 92, + 93 + ] + }, + { + "start": 16827, + "end": 16830, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 235, + 236, + 237, + 238 + ] + }, + { + "start": 16843, + "end": 16846, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 251, + 252, + 253, + 254 + ] + }, + { + "start": 16859, + "end": 16862, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 267, + 268, + 269, + 270 + ] + }, + { + "start": 16969, + "end": 16972, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 411, + 412, + 413, + 414 + ] + }, + { + "start": 16985, + "end": 16988, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 427, + 428, + 429, + 430 + ] + }, + { + "start": 17001, + "end": 17004, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 443, + 444, + 445, + 446 + ] + }, + { + "start": 17020, + "end": 17023, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 470, + 471, + 472, + 473 + ] + }, + { + "start": 17042, + "end": 17045, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 494, + 495, + 496, + 497 + ] + }, + { + "start": 17058, + "end": 17061, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 518, + 519, + 520, + 521 + ] + } + ] + }, + "forward": { + "event_count": 24767, + "profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "admissible_windows": [ + { + "start": 16718, + "end": 16721, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 14, + 15, + 16, + 17 + ] + }, + { + "start": 16728, + "end": 16731, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 24, + 25, + 26, + 27 + ] + }, + { + "start": 16729, + "end": 16732, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 25, + 26, + 27, + 28 + ] + }, + { + "start": 16780, + "end": 16783, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 76, + 77, + 78, + 79 + ] + }, + { + "start": 16794, + "end": 16797, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 90, + 91, + 92, + 93 + ] + }, + { + "start": 16827, + "end": 16830, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 235, + 236, + 237, + 238 + ] + }, + { + "start": 16828, + "end": 16831, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 236, + 237, + 238, + 239 + ] + }, + { + "start": 16829, + "end": 16832, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 237, + 238, + 239, + 240 + ] + }, + { + "start": 16843, + "end": 16846, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 251, + 252, + 253, + 254 + ] + }, + { + "start": 16844, + "end": 16847, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 252, + 253, + 254, + 255 + ] + }, + { + "start": 16845, + "end": 16848, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 253, + 254, + 255, + 256 + ] + }, + { + "start": 16859, + "end": 16862, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 267, + 268, + 269, + 270 + ] + }, + { + "start": 16860, + "end": 16863, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 268, + 269, + 270, + 271 + ] + }, + { + "start": 16861, + "end": 16864, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 269, + 270, + 271, + 272 + ] + }, + { + "start": 16969, + "end": 16972, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 411, + 412, + 413, + 414 + ] + }, + { + "start": 16970, + "end": 16973, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 412, + 413, + 414, + 415 + ] + }, + { + "start": 16971, + "end": 16974, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 413, + 414, + 415, + 416 + ] + }, + { + "start": 16985, + "end": 16988, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 427, + 428, + 429, + 430 + ] + }, + { + "start": 16986, + "end": 16989, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 428, + 429, + 430, + 431 + ] + }, + { + "start": 16987, + "end": 16990, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 429, + 430, + 431, + 432 + ] + }, + { + "start": 17001, + "end": 17004, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 443, + 444, + 445, + 446 + ] + }, + { + "start": 17002, + "end": 17005, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 444, + 445, + 446, + 447 + ] + }, + { + "start": 17003, + "end": 17006, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 445, + 446, + 447, + 456 + ] + }, + { + "start": 17020, + "end": 17023, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 470, + 471, + 472, + 473 + ] + }, + { + "start": 17042, + "end": 17045, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 494, + 495, + 496, + 497 + ] + }, + { + "start": 17043, + "end": 17046, + "ranks_in_order": [ + 1, + 2, + 2, + 1 + ], + "destinations": [ + 495, + 496, + 497, + 499 + ] + }, + { + "start": 17044, + "end": 17047, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 496, + 497, + 499, + 502 + ] + }, + { + "start": 17058, + "end": 17061, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 518, + 519, + 520, + 521 + ] + } + ], + "admissible_window_count": 28, + "maximum_disjoint_count": 13, + "one_maximum_schedule": [ + { + "start": 16718, + "end": 16721, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 14, + 15, + 16, + 17 + ] + }, + { + "start": 16728, + "end": 16731, + "ranks_in_order": [ + 1, + 2, + 1, + 2 + ], + "destinations": [ + 24, + 25, + 26, + 27 + ] + }, + { + "start": 16780, + "end": 16783, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 76, + 77, + 78, + 79 + ] + }, + { + "start": 16794, + "end": 16797, + "ranks_in_order": [ + 2, + 2, + 1, + 1 + ], + "destinations": [ + 90, + 91, + 92, + 93 + ] + }, + { + "start": 16827, + "end": 16830, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 235, + 236, + 237, + 238 + ] + }, + { + "start": 16843, + "end": 16846, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 251, + 252, + 253, + 254 + ] + }, + { + "start": 16859, + "end": 16862, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 267, + 268, + 269, + 270 + ] + }, + { + "start": 16969, + "end": 16972, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 411, + 412, + 413, + 414 + ] + }, + { + "start": 16985, + "end": 16988, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 427, + 428, + 429, + 430 + ] + }, + { + "start": 17001, + "end": 17004, + "ranks_in_order": [ + 2, + 1, + 2, + 1 + ], + "destinations": [ + 443, + 444, + 445, + 446 + ] + }, + { + "start": 17020, + "end": 17023, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 470, + 471, + 472, + 473 + ] + }, + { + "start": 17042, + "end": 17045, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 494, + 495, + 496, + 497 + ] + }, + { + "start": 17058, + "end": 17061, + "ranks_in_order": [ + 1, + 1, + 2, + 2 + ], + "destinations": [ + 518, + 519, + 520, + 521 + ] + } + ] + } + }, + "profiles_and_ceilings": { + "baseline_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "baseline_ceiling_bracket": [ + "1690054109/1000000000000", + "169005411/100000000000" + ], + "maximum_source_schedule_groups": 13, + "maximum_source_profile": { + "1": 2386, + "2": 392, + "3": 432, + "4": 142, + "5": 82, + "6": 13, + "8": 8 + }, + "maximum_source_ceiling_bracket": [ + "212305837/125000000000", + "1698446697/1000000000000" + ], + "five_percent_threshold_from_baseline_upper": "3549113631/2000000000000", + "maximum_source_passes_five_percent": false, + "zero_charge_groups_125_profile": { + "1": 2162, + "2": 168, + "3": 432, + "4": 142, + "5": 82, + "6": 125, + "8": 8 + }, + "zero_charge_groups_125_ceiling_bracket": [ + "443592027/250000000000", + "1774368109/1000000000000" + ], + "zero_charge_groups_126_profile": { + "1": 2160, + "2": 166, + "3": 432, + "4": 142, + "5": 82, + "6": 126, + "8": 8 + }, + "zero_charge_groups_126_ceiling_bracket": [ + "11094229/6250000000", + "1775076641/1000000000000" + ], + "minimum_zero_charge_groups_for_five_percent": 126, + "maximum_source_relative_gain_upper_vs_baseline_lower": "8392588/1690054109" + }, + "controls": [ + "exact block-diagonal identity on integer matrices", + "off-diagonal support produces a cross-block output", + "wrong-rank window rejected", + "duplicate-destination window rejected", + "overlapping windows not double-counted" + ], + "scope": "Only contiguous four-event windows in the two pinned selected traces; all non-child charges are waived for the optimistic ceiling screen." +} diff --git a/research/complex-rank6-hetero21-seedfb19/README.md b/research/complex-rank6-hetero21-seedfb19/README.md new file mode 100644 index 0000000000..3219cc17ad --- /dev/null +++ b/research/complex-rank6-hetero21-seedfb19/README.md @@ -0,0 +1,86 @@ +# Mixed rank-six blocks with two scalar children + +**Scoped negative result.** The exact direct-sum construction is available at 28 strict source windows in each orientation of the selected gauge44 provider. A maximum disjoint schedule uses 13 blocks. Even with every added interface charge set to zero, that profile raises the local ceiling by less than 0.5%, below the task's 5% gate. No supplier or new \(\kappa\) is claimed. + +## Construction + +For 2-by-2 matrices \(A,B,C,D\) and scalars \(a,b,c,d\), the block-diagonal product gives + +\[ +\operatorname{diag}(A,B,a,b)\operatorname{diag}(C,D,c,d) + =\operatorname{diag}(AC,BD,ac,bd). +\] + +This fuses the child-rank multiset \((2,2,1,1)\) into one rank-six matrix-multiplication child. The paid rank mass stays six. The operation is exact over any associative coefficient ring. A nonzero off-diagonal input entry can create a cross-block output, so a realization must supply diagonal inputs and route the four outputs to the original destinations. The screen below grants those steps zero cost. + +## Exact source schedule + +The input is the member `candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz` in the selected replay archive. The archive SHA-256 is `f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6`; the decompressed member SHA-256 is `241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a`. The selected-record SHA-256 is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. + +The verifier scans every raw, consecutive four-event window in both 24,767-event orientations. A window qualifies only when all four events are climbs, their ranks are exactly \(\{1,1,2,2\}\), and the four destination columns are distinct. Any scalar, adapter, centre, phase marker, or other climb between children breaks the window. It then computes a maximum disjoint interval schedule and independently checks its cardinality by dynamic programming. + +| Orientation | Events | Qualifying windows | Maximum disjoint blocks | +|---|---:|---:|---:| +| Forward | 24,767 | 28 | 13 | +| Backward | 24,767 | 28 | 13 | + +The complete qualifying windows and one maximum schedule per orientation are recorded in [CERTIFICATE.json](CERTIFICATE.json). Their event indices and rank order agree across orientations; the certificate retains each orientation's destination columns. + +## Cost screen + +The pinned baseline paid profile is `{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}` with rank mass 5,586. Thirteen fusions produce + +```text +{1:2386, 2:392, 3:432, 4:142, 5:82, 6:13, 8:8} +``` + +The exact rational ceiling brackets from `ceiling.ceiling(profile, 73, 896, 9, 64)` on a \(10^{-12}\) grid are: + +| Profile | Lower endpoint | Upper endpoint | +|---|---:|---:| +| Baseline | `1690054109/1000000000000` | `169005411/100000000000` | +| 13 ideal fusions | `212305837/125000000000` | `1698446697/1000000000000` | + +The card's 5% screen is the baseline upper endpoint multiplied by \(21/20\), exactly `3549113631/2000000000000`. The 13-block candidate upper endpoint lies strictly below it. Relative to the baseline lower endpoint, its best-case upper-endpoint gain is exactly `8392588/1690054109`, less than one half percent. + +The minimum number of zero-charge fusions needed to cross that 5% threshold is 126. With 125 blocks, the ceiling upper endpoint is `1774368109/1000000000000`, still below the target. With 126, the lower endpoint is `11094229/6250000000`, strictly above it. Each additional fusion lowers the local moment for \(0 (\sum r_i)^{1-a}\) for positive ranks; therefore the ceiling is monotone in the fusion count, and the adjacent exact brackets identify the minimum. + +This is the most favorable cost model: source access, operand copies, diagonal gather, output scatter, frame changes, interface transitions, hosting, precision, and arbitrary-dirty restoration are all free. The source-limited count of 13 misses the gate before any of these costs are charged. The result closes only this pinned, strict-contiguous schedule; it does not exclude a different word or a fully specified buffered interface. + +## Relation to prior work + +- [PR #1779](https://github.com/CrocSwap/integer-mult-bounds/pull/1779) batches sixteen rank-one children into rank sixteen. This package uses two rank-two and two rank-one children in one rank-six block. +- [PR #1866](https://github.com/CrocSwap/integer-mult-bounds/pull/1866) constructs the different tensor \((3,1,1,1)\to6\) and checks phase A, where its pinned stream has no rank-three climb. This package studies \((2,2,1,1)\to6\) and enumerates both complete selected orientations. +- Open [PR #1960](https://github.com/CrocSwap/integer-mult-bounds/pull/1960) optimizes consecutive blocks whose child ranks are two and three. This package includes rank-one children and the exact rank-six multiset above. +- The adjacent [claim on Discussion #1167](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926727) also restricts blocks to ranks two and three. This search includes rank-one children and the exact rank-six multiset above. +- The current claim and scope update for this complementary result are [Discussion #1167, comments 18929907 and 18930030](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18929907). + +These results share the broad direct-sum idea. This package's added evidence is the distinct mixed-rank tensor shape and the full, source-pinned occurrence census for that shape in both selected traces. + +## Reproduce + +From the repository root, using the standard library and Python 3.12 or later: + +```sh +python3 -B scripts/research_package.py --package research/complex-rank6-hetero21-seedfb19 --check-only +python3 -B research/complex-rank6-hetero21-seedfb19/verify.py +``` + +Expected output: + +```text +PASS_PACKAGE_METADATA_AND_PINS +PASS_MIXED_RANK21_BLOCK_SCREEN windows=28 disjoint=13 target_minimum=126 profile_gain_below_0.5_percent +``` + +The replay checks the source pins, exact event profiles, every qualifying interval, maximum disjoint schedules, direct-sum identity, profile mass, rational ceiling thresholds, and negative controls for off-diagonal support, wrong ranks, duplicate destinations, and overlapping intervals. It reads frozen inputs and does not modify them. + +## Open next questions + +Can another selected word or a charged buffered schedule realize at least 126 useful \((2,2,1,1)\to6\) blocks? The current trace reaches only 13 groups under strict chronology. A first step is to derive operand-ready/use intervals and the dirty-output contract for one explicitly selected alternative, then price source access, copying, frames, hosting, precision, and restoration. The current event trace does not contain that multi-block lifetime map. + +## Provenance and credit + +The assignment was drawn from task `complex-rank-shape-decoder`, seed `fb19d5d7333247ee6fd2818087dc4509`, priority revision 3, exact base `f0c1cd4495674afcc81d618774949690b504217d`, and selected-record hash above. Current upstream main later advanced to `1d201395e037bd3fcb0175007fdcd0154878e613`; the package retains the assigned base and live source hashes. + +Predecessor credit includes the selected provider lineage in PR #1094, rank-one batching in PR #1779, heterogeneous rank-six tensor construction in PR #1866, and the mixed rank-two/rank-three family in open PR #1960 and comment #18926727. Prepared by Cinna with substantial OpenAI Codex assistance in scope selection, source analysis, mathematical formulation, verifier and certificate construction, exact cost calculation, and writing. No independent human review is claimed. New material is Apache-2.0; frozen source archives and certificates are unchanged. diff --git a/research/complex-rank6-hetero21-seedfb19/SOURCES.json b/research/complex-rank6-hetero21-seedfb19/SOURCES.json new file mode 100644 index 0000000000..4a4e1bbca7 --- /dev/null +++ b/research/complex-rank6-hetero21-seedfb19/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "f0c1cd4495674afcc81d618774949690b504217d", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/complex-rank6-hetero21-seedfb19/TASK.json b/research/complex-rank6-hetero21-seedfb19/TASK.json new file mode 100644 index 0000000000..7b46d33289 --- /dev/null +++ b/research/complex-rank6-hetero21-seedfb19/TASK.json @@ -0,0 +1,97 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "track": "complex-mechanisms", + "research_seed": "fb19d5d7333247ee6fd2818087dc4509", + "priority_revision": 3, + "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "base_commit": "f0c1cd4495674afcc81d618774949690b504217d", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "predecessors": [ + { + "reference": "CrocSwap/integer-mult-bounds#1094", + "head": "0fc329d0bec93ca7cd288eaea1295172e8789810", + "relationship": "Selected gauge44 provider and both pinned local-program orientations." + }, + { + "reference": "CrocSwap/integer-mult-bounds#1779", + "head": "5577f27d54355bc916efe0a23128dd0e0c169434", + "relationship": "Homogeneous rank-one diagonal batches; this package tests the heterogeneous (2,2,1,1)->6 child shape." + }, + { + "reference": "CrocSwap/integer-mult-bounds#1866", + "head": "7d22d1d51eb6c0bc040f8181b6c5f83e051fb234", + "relationship": "Exact rank-six tensor for (3,1,1,1); this package changes the direct-sum tensor to (2,2,1,1) and checks both complete source traces." + }, + { + "reference": "CrocSwap/integer-mult-bounds#1960", + "head": "df468539cb55e3c90e0dc492394450b162beeb56", + "relationship": "Open source-bound census of contiguous rank-2/rank-3 direct-sum blocks; this package includes rank-one children in the fixed four-event rank-six tensor." + }, + { + "reference": "CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926727", + "relationship": "Adjacent active claim restricts chronological fusion blocks to ranks 2 and 3; this package includes two rank-one children in every fused block." + } + ], + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18929907", + "scope_status": "changed", + "actual_scope": "On the selected PR1094 gauge44 provider, fuse only four consecutive events with child ranks (2,2,1,1) in any order into one rank-6 block-diagonal child. Enumerate every eligible window and maximum disjoint schedule in both complete orientations, then apply the exact zero-additional-cost local ceiling screen.", + "scope_change_reason": "The broad rank-shape card is refined to a distinct mixed-level direct-sum tensor M2⊕M2⊕M1⊕M1. PR1779 covers homogeneous rank-one batches, PR1866 constructs a different (3,1,1,1) rank-six tensor without a phase-A placement, and the adjacent active rank-2/rank-3 claim excludes rank-one children. This scope tests the missing (2,2,1,1) shape at actual chronological occurrences in both full selected traces.", + "bottleneck_link": "The selected complex-side cost is a concave moment of child rank. Replacing rank mass 6 from two rank-2 and two rank-1 children by one rank-6 child can reduce that moment while preserving paid rank mass; the task card requires at least a 5% ceiling gain.", + "budget_minutes": 60, + "stop_rule": "Enumerate all contiguous four-event windows in both exact pinned traces. Admit only rank multiset {1,1,2,2} with four distinct destination columns; select a maximum disjoint schedule. Waive every added source, gather, output, frame, hosting, precision and restoration expense. Stop if the resulting exact ceiling misses 1.05 times the selected baseline ceiling; do not extend this cycle to moved events or a new source word.", + "outcome": "negative-result", + "evidence": "Both orientations contain 24,767 events, 28 eligible windows and a maximum of 13 disjoint (2,2,1,1)->6 fusions. The ideal profile is {1:2386,2:392,3:432,4:142,5:82,6:13,8:8}; its exact ceiling bracket is [212305837/125000000000,1698446697/1000000000000], below the five-percent target 3549113631/2000000000000. Even with all new interface charges zero, at least 126 such blocks are needed: 125 is strictly below and 126 strictly above the target. Rank mass remains 5586. No physical supplier or kappa is claimed.", + "author": "Cinna", + "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, source analysis, mathematical formulation, exact verifier and certificate, cost calculation, and writing. No subagents or independent human review claimed.", + "open_questions": [ + { + "question": "Can a different source word or a charged buffered schedule realize at least 126 useful (2,2,1,1)->6 blocks?", + "why_it_matters": "The selected strict contiguous schedule reaches only 13 groups, and the favorable profile needs 126 before any added interface expense to cross the card's five-percent screen.", + "first_step": "For one explicitly selected alternative word, derive operand-ready/use intervals and the dirty-output contract, then compute a disjoint mixed-rank schedule and a complete source, copy, frame, hosting, precision and restoration invoice.", + "blocked_by": "The pinned selected trace contains event and destination records but no multi-block operand-lifetime or arbitrary-dirty output map; nonconsecutive buffering would add those missing interface costs." + } + ] +} diff --git a/research/complex-rank6-hetero21-seedfb19/VERIFY.json b/research/complex-rank6-hetero21-seedfb19/VERIFY.json new file mode 100644 index 0000000000..489626f7e0 --- /dev/null +++ b/research/complex-rank6-hetero21-seedfb19/VERIFY.json @@ -0,0 +1,22 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/community-frontier1094-audit/selected-replay.tar.gz", + "research/complex-local-word-ceiling/ceiling.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Archive/member/selected-record pins; complete source event profiles in both orientations; exact census of every consecutive {1,1,2,2} four-event window with distinct destinations; maximum disjoint schedule by greedy and dynamic programming; integer block-diagonal identity and off-diagonal negative control; mass-preserving profiles; exact 5% ceiling brackets at 13, 125 and 126 fusions; wrong-rank, duplicate-destination and overlapping-interval controls." + } + ] +} diff --git a/research/complex-rank6-hetero21-seedfb19/verify.py b/research/complex-rank6-hetero21-seedfb19/verify.py new file mode 100644 index 0000000000..6b0a0009d3 --- /dev/null +++ b/research/complex-rank6-hetero21-seedfb19/verify.py @@ -0,0 +1,282 @@ +#!/usr/bin/env python3 +"""Replay the exact (2,2,1,1)->6 selected-word screen.""" +from __future__ import annotations + +import argparse +import collections +import gzip +import hashlib +import json +import sys +import tarfile +from bisect import bisect_left +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(ROOT / "research/complex-local-word-ceiling")) +import ceiling as C # noqa: E402 + +ARCHIVE = ROOT / "research/community-frontier1094-audit/selected-replay.tar.gz" +ARCHIVE_SHA256 = "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6" +MEMBER = "candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz" +MEMBER_SHA256 = "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" +SELECTED_SHA256 = "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" +BASE_PROFILE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} +EXPECTED_STARTS = (16718, 16728, 16780, 16794, 16827, 16843, 16859, + 16969, 16985, 17001, 17020, 17042, 17058) +GRID = Q(1, 10**12) + + +def require(condition: bool, message: str) -> None: + if not condition: + raise RuntimeError(message) + + +def selected_programs() -> dict[str, list]: + archive = ARCHIVE.read_bytes() + require(hashlib.sha256(archive).hexdigest() == ARCHIVE_SHA256, + "selected replay archive pin") + with tarfile.open(ARCHIVE, "r:gz") as tar: + members = [item for item in tar.getmembers() if item.name == MEMBER] + require(len(members) == 1, "exactly one selected gauge44 LOCAL-PROGRAMS member") + stream = tar.extractfile(members[0]) + require(stream is not None, "selected provider member is readable") + payload = stream.read() + require(hashlib.sha256(payload).hexdigest() == MEMBER_SHA256, + "selected provider member pin") + result = json.loads(gzip.decompress(payload)) + require(set(result) == {"forward", "backward"}, "both selected orientations present") + return result + + +def profile_of(events: list) -> dict[int, int]: + counts: collections.Counter[int] = collections.Counter() + for event in events: + if event[0] == "climb": + counts[int(event[5])] += 1 + elif event[0] == "center": + counts[int(event[4])] += 1 + return dict(sorted(counts.items())) + + +def admissible_window(block: list) -> bool: + if len(block) != 4 or not all(event[0] == "climb" for event in block): + return False + ranks = [int(event[5]) for event in block] + destinations = [int(event[2]) for event in block] + return sorted(ranks) == [1, 1, 2, 2] and len(set(destinations)) == 4 + + +def enumerate_windows(events: list) -> list[dict]: + windows = [] + for start in range(len(events) - 3): + block = events[start:start + 4] + if admissible_window(block): + windows.append({ + "start": start, + "end": start + 3, + "ranks_in_order": [int(event[5]) for event in block], + "destinations": [int(event[2]) for event in block], + }) + return windows + + +def disjoint_schedule(windows: list[dict]) -> tuple[list[dict], int]: + """Return earliest-finish packing and independently compute the optimum.""" + ordered = sorted(windows, key=lambda w: (w["end"], w["start"])) + chosen = [] + last_end = -1 + for window in ordered: + if window["start"] > last_end: + chosen.append(window) + last_end = window["end"] + + ends = [window["end"] for window in ordered] + best = [0] + for index, window in enumerate(ordered): + predecessor_count = bisect_left(ends, window["start"], 0, index) + best.append(max(best[-1], 1 + best[predecessor_count])) + return chosen, best[-1] + + +def transformed_profile(groups: int) -> dict[int, int]: + require(0 <= groups <= min(BASE_PROFILE[1] // 2, BASE_PROFILE[2] // 2), + "fusion count within rank-one/rank-two inventory") + result = dict(BASE_PROFILE) + result[1] -= 2 * groups + result[2] -= 2 * groups + result[6] = groups + return dict(sorted(result.items())) + + +def mass(profile: dict[int, int]) -> int: + return sum(rank * count for rank, count in profile.items()) + + +def matmul(left: list[list[int]], right: list[list[int]]) -> list[list[int]]: + return [[sum(left[i][k] * right[k][j] for k in range(len(right))) + for j in range(len(right[0]))] for i in range(len(left))] + + +def block_diagonal(blocks: list[list[list[int]]]) -> list[list[int]]: + size = sum(len(block) for block in blocks) + result = [[0] * size for _ in range(size)] + offset = 0 + for block in blocks: + for i, row in enumerate(block): + for j, value in enumerate(row): + result[offset + i][offset + j] = value + offset += len(block) + return result + + +def check_identity_and_controls(sample: list) -> list[str]: + a = [[1, 2], [3, 4]] + b = [[0, 5], [6, 7]] + c = [[2, 1], [0, 3]] + d = [[3, 0], [1, 2]] + left_blocks = [a, b, [[5]], [[7]]] + right_blocks = [c, d, [[11]], [[13]]] + product = matmul(block_diagonal(left_blocks), block_diagonal(right_blocks)) + expected = block_diagonal([ + matmul(a, c), matmul(b, d), [[55]], [[91]], + ]) + require(product == expected, "positive exact block-diagonal multiplication identity") + + # The diagonal-input premise is real: a cross-block entry creates an + # off-diagonal output that the direct-sum map does not promise to handle. + bad_left = block_diagonal(left_blocks) + bad_left[0][2] = 1 + bad_product = matmul(bad_left, block_diagonal(right_blocks)) + require(bad_product[0][2] != 0, "off-diagonal-support negative control") + + require(admissible_window(sample), "positive source-window control") + wrong_rank = [event[:] for event in sample] + wrong_rank[0][5] = 3 + require(not admissible_window(wrong_rank), "wrong-rank negative control") + duplicate_column = [event[:] for event in sample] + duplicate_column[-1][2] = duplicate_column[0][2] + require(not admissible_window(duplicate_column), "duplicate-destination negative control") + _, overlap_optimum = disjoint_schedule([ + {"start": 0, "end": 3}, {"start": 2, "end": 5}, + ]) + require(overlap_optimum == 1, "overlapping-window negative control") + return [ + "exact block-diagonal identity on integer matrices", + "off-diagonal support produces a cross-block output", + "wrong-rank window rejected", + "duplicate-destination window rejected", + "overlapping windows not double-counted", + ] + + +def ceiling_strings(profile: dict[int, int]) -> list[str]: + return [str(endpoint) for endpoint in C.ceiling( + profile, 73, 896, 9, 64, grid=GRID, + )] + + +def build_certificate() -> dict: + selected = ROOT / "certificates/selected-result.json" + require(hashlib.sha256(selected.read_bytes()).hexdigest() == SELECTED_SHA256, + "selected-record SHA-256 pin") + programs = selected_programs() + orientations = {} + sample = None + for orientation in ("backward", "forward"): + events = programs[orientation] + require(len(events) == 24767, f"{orientation} complete event count") + require(profile_of(events) == BASE_PROFILE, f"{orientation} paid profile") + windows = enumerate_windows(events) + chosen, optimum = disjoint_schedule(windows) + starts = tuple(window["start"] for window in chosen) + require(len(windows) == 28, f"{orientation} admissible-window census") + require(optimum == 13 == len(chosen), f"{orientation} maximum disjoint packing") + require(starts == EXPECTED_STARTS, f"{orientation} exact optimal schedule") + orientations[orientation] = { + "event_count": len(events), + "profile": {str(k): v for k, v in sorted(profile_of(events).items())}, + "admissible_windows": windows, + "admissible_window_count": len(windows), + "maximum_disjoint_count": optimum, + "one_maximum_schedule": chosen, + } + if sample is None: + sample = events[windows[0]["start"]:windows[0]["end"] + 1] + + require(sample is not None, "at least one source window exists") + controls = check_identity_and_controls(sample) + groups = 13 + profile13 = transformed_profile(groups) + base_ceiling = ceiling_strings(BASE_PROFILE) + ceiling13 = ceiling_strings(profile13) + profile125 = transformed_profile(125) + profile126 = transformed_profile(126) + ceiling125 = ceiling_strings(profile125) + ceiling126 = ceiling_strings(profile126) + target = Q(base_ceiling[1]) * Q(21, 20) + require(mass(BASE_PROFILE) == mass(profile13) == 5586, + "rank mass preserved by each (2,2,1,1)->6 fusion") + require(Q(ceiling13[1]) < target, + "13-block zero-charge ceiling misses the five-percent target") + require(Q(ceiling125[1]) < target < Q(ceiling126[0]), + "126 zero-charge blocks are the first to cross the five-percent target") + require(Q(ceiling13[1]) / Q(base_ceiling[0]) - 1 < Q(1, 200), + "13-block ideal gain is below one half percent") + return { + "schema_version": 1, + "source": { + "selected_record_sha256": SELECTED_SHA256, + "archive_sha256": ARCHIVE_SHA256, + "member": MEMBER, + "member_sha256": MEMBER_SHA256, + }, + "fusion": { + "rank_multiset": [1, 1, 2, 2], + "child_rank": 6, + "rank_mass_before": 6, + "rank_mass_after": 6, + "identity": "diag(A2,B2,a,b) diag(C2,D2,c,d) = diag(A2*C2,B2*D2,a*c,b*d)", + }, + "orientations": orientations, + "profiles_and_ceilings": { + "baseline_profile": {str(k): v for k, v in BASE_PROFILE.items()}, + "baseline_ceiling_bracket": base_ceiling, + "maximum_source_schedule_groups": groups, + "maximum_source_profile": {str(k): v for k, v in profile13.items()}, + "maximum_source_ceiling_bracket": ceiling13, + "five_percent_threshold_from_baseline_upper": str(target), + "maximum_source_passes_five_percent": False, + "zero_charge_groups_125_profile": {str(k): v for k, v in profile125.items()}, + "zero_charge_groups_125_ceiling_bracket": ceiling125, + "zero_charge_groups_126_profile": {str(k): v for k, v in profile126.items()}, + "zero_charge_groups_126_ceiling_bracket": ceiling126, + "minimum_zero_charge_groups_for_five_percent": 126, + "maximum_source_relative_gain_upper_vs_baseline_lower": str( + Q(ceiling13[1]) / Q(base_ceiling[0]) - 1 + ), + }, + "controls": controls, + "scope": "Only contiguous four-event windows in the two pinned selected traces; all non-child charges are waived for the optimistic ceiling screen.", + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--write", action="store_true", help="write the deterministic certificate") + args = parser.parse_args() + certificate = build_certificate() + destination = HERE / "CERTIFICATE.json" + encoded = json.dumps(certificate, indent=2) + "\n" + if args.write: + destination.write_text(encoded, encoding="utf-8") + else: + require(destination.read_text(encoding="utf-8") == encoded, + "committed certificate differs from exact replay") + print("PASS_MIXED_RANK21_BLOCK_SCREEN windows=28 disjoint=13 target_minimum=126 profile_gain_below_0.5_percent") + + +if __name__ == "__main__": + main()