From 9b8689e0153e038b2c1179b06026adfaa7f7593b Mon Sep 17 00:00:00 2001 From: Tairitsu-Aya Date: Thu, 15 Oct 2026 04:31:56 +0800 Subject: [PATCH] Rule out identity from nested P104 transport refinements --- research/p104-nested-refinement-cut/README.md | 243 +++ .../p104-nested-refinement-cut/RESULT.json | 1739 +++++++++++++++++ .../p104-nested-refinement-cut/SELECTION.json | 61 + .../p104-nested-refinement-cut/SOURCES.json | 24 + research/p104-nested-refinement-cut/TASK.json | 194 ++ .../p104-nested-refinement-cut/VERIFY.json | 33 + research/p104-nested-refinement-cut/audit.py | 301 +++ research/p104-nested-refinement-cut/verify.py | 322 +++ 8 files changed, 2917 insertions(+) create mode 100644 research/p104-nested-refinement-cut/README.md create mode 100644 research/p104-nested-refinement-cut/RESULT.json create mode 100644 research/p104-nested-refinement-cut/SELECTION.json create mode 100644 research/p104-nested-refinement-cut/SOURCES.json create mode 100644 research/p104-nested-refinement-cut/TASK.json create mode 100644 research/p104-nested-refinement-cut/VERIFY.json create mode 100644 research/p104-nested-refinement-cut/audit.py create mode 100644 research/p104-nested-refinement-cut/verify.py diff --git a/research/p104-nested-refinement-cut/README.md b/research/p104-nested-refinement-cut/README.md new file mode 100644 index 0000000000..6240a461b8 --- /dev/null +++ b/research/p104-nested-refinement-cut/README.md @@ -0,0 +1,243 @@ +# P104: a cut surviving arbitrary nested transport refinements + +The frozen native P104 channel cannot become an identity supplier solely by +subdividing its original nested transports into more nested steps, even with +arbitrary interleaving and common-chart linear resynthesis. Its source-to-target +rank is at most **56 arrays** in the model below. More specifically, the 56 +sources outside the survivor span can contribute at most **eight arrays**. +Identity on those sources alone needs rank 56 arrays. + +This is a **scoped obstruction**, not a new kappa, an attaining correction, +a sharp capacity claim, or a lower bound for arbitrary replacement transports. +It changes the operation alphabet addressed by the fixed-path rank-eight +result in [Jeremy Diviney's PR2113](https://github.com/CrocSwap/integer-mult-bounds/pull/2113). +The weaker numerical upper bound covers every intermediate binary subspace +inside each original nested interval, including charts absent from the old word. +It does not meet the original task card's constructive supplier gate. + +## Exact model + +Work over a characteristic-zero field containing the native scalar constants, +with each register carrying one `d`-dimensional array. Binary charts are +subspaces of `F_2^9`; the binary geometry is separate from the scalar field. +The pinned input is the PR1972 scalar/frame word distributed by PR1991: + +``` +research/p104-native-channel/inputs/LOWRANK-WITNESS.json +SHA256 0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e +``` + +Each of its 1,410 original transport occurrences is retained as an obligation. +An upward occurrence `L -> U` may be replaced by any finite chain +`L = W0 <= W1 <= ... <= Wm = U`. A downward occurrence has the analogous +descending chain. Repeated equal charts can be removed; they add no transport. +Each obligation follows **one array** through its chain and is consumed once. +It cannot fork into two independently descending arrays halfway through. + +Grant arbitrary interleaving, arbitrary linear operations among arrays in an +identical chart, and source-independent fresh owned storage with free +common-chart copy/discard. The original scalar instructions need not be kept. +Storage may receive an original transport obligation, but it cannot duplicate +that obligation. There are still only eight descending private lifetimes. +All initial data and final target charts are fixed. The usual fixed external +endpoint adapters are inherited from the native channel. + +No other cross-chart interface is granted, including a supposedly free +cross-chart map. A different route outside an original interval, an additional +transport, replacement/fusion of endpoint obligations, or a branched transport +chain is outside this model. Native implementation of every intermediate chart +is generously granted; the obstruction therefore does not require building +those recipes. The argument even grants dirty helpers without requiring their +restoration, so imposing arbitrary-input restoration cannot remove it. + +This is distinct from [Ross Richardson's PR2127](https://github.com/CrocSwap/integer-mult-bounds/pull/2127), +which retains the old unsplit occurrences and counts additional transports +with added storage. Here the original occurrences themselves are replaced by +nested chains. Neither result automatically converts new steps into excess +recursive cost or idle progress. + +## The interval separator + +Write `a_0,...,a_7` for the singleton survivors of the eight private descents, +and `A = span(a_0,...,a_7)`. The exact input gives, in descent order: + +``` +243, 95, 447, 502, 486, 127, 500, 383 +``` + +These eight compressed labels are independent. Their span has dimension eight. +No ordinary physical dot product on these compressed labels is used: membership +and inclusion are preserved by the native package's fixed binary isometry. + +Color a chart `W` **T** exactly when it is proper (`dim W < 9`) and + +``` +W is contained in A, OR W contains at least two distinct a_i. +``` + +Every other chart is **R**, including the full nine-dimensional chart. +The source-bound checks establish: + +| Exact fact | Count | +|---|---:| +| Initial singleton sources in T / R | 48 / 56 | +| Final target hyperplanes in T | 104 | +| Survivors in each private descent's initial hyperplane | exactly 1 | +| Descending private obligations | 8 | + +Each descending initial hyperplane is outside `A`; its endpoint is its unique +survivor line inside `A`. Final target hyperplanes contain 2, 3, 4, 5 or 6 +survivors, with respective multiplicities 12, 24, 32, 24 and 12. + +Every upward interval falls into one of the following sufficient cases, +applied in this order. The counts and every event index are in +[RESULT.json](RESULT.json). + +| Interval condition | Occurrences | Why an ascending refinement cannot cross R -> T | +|---|---:|---| +| Its upper chart contains at most one survivor | 701 | T then means containment in A; ascent cannot enter A from outside it. | +| Its upper chart is contained in A | 421 | Every intermediate chart is T. | +| Its lower chart contains at least two survivors | 136 | Every proper intermediate chart is T; the full endpoint can only produce T -> R. | +| It goes from dimension eight to the full chart | 144 | There is no strict intermediate chart; its endpoint is R. | + +For a downward private interval, every chart lies inside its original +hyperplane, which contains only one survivor. Thus T again means containment +in `A`. Once a descending chain enters `A`, all its subsequent charts remain +inside `A`. Its start is R and its end is T. **Each such obligation crosses +R -> T exactly once**, however many steps replace the original rank-seven +child. That crossing carries one array, not seven arrays. + +The four upward cases cover all 1,402 upward occurrences. They are sufficient, +not claimed necessary for arbitrary new intervals. Together with the eight +private intervals they prove the separator for all permitted refinements, +without sampling the intermediate charts or assuming a frozen chronology. + +## Transcript proof of the rank bound + +First vary only the 56 initial R-side source arrays. Fix the other 48 source +arrays, every target input and all source-independent workspace inputs to zero. +The T side initially has no dependence on the varying sources. + +Same-chart linear operations stay on one side. No permitted upward refinement +has an R -> T transition. The only possible arrivals of R-source information +are the eight single-array crossings just proved. Record their array values +in execution order as a transcript `z` in a space of dimension `8d`. +Inductively, every T-side value is a linear function of the transcript entries +already seen. T -> R feedback may influence later transcript entries; it does +not create an additional R -> T arrival or invalidate the induction. Copies +after an arrival also remain functions of the same transcript. + +Every final target lies on the T side. Its dependence on the 56 varying source +arrays therefore factors through `z`, and has rank at most `8d`. Identity +transfer on these 56 arrays would have rank `56d`, which is impossible. +Restoring the other 48 independent source arrays adds at most `48d` to the +rank, giving the stated total upper bound `56d`. No program attaining that +upper bound is supplied or claimed; the inherited `G/2` word has rank `8d`. + +The theorem concerns information capacity. It does **not** say that 48 more +native children would suffice, that an arbitrary new crossing costs a fixed +rank, or that splitting preserves the recursive moment. A changed supplier +still needs actual native operators, dirty restoration and the complete bill. + +## Independent decision procedure + +The second checker uses literal XOR-span sets and independently decides whether +an upward interval contains any R -> T pair. It does not rely on the preceding +four-case classification to establish absence of a bypass. + +For `L <= U`, an ascending R -> T pair cannot enter `A`. Its T endpoint must +contain two distinct survivor lines. If `L` already contains two, no proper +R chart above it exists. If `U` is inside `A`, all charts in the interval are T. +Otherwise enumerate the at most 28 pairs of survivors contained in `U`: + +1. If `L` is outside `A`, use `V = L` as the candidate R chart. +2. If `L` is inside `A`, append any one vector of `U` outside `A` to obtain V. + Then `V intersect A = L`, so V contains the same survivor lines as L. +3. Adjoin the chosen two survivors to V. If the result is proper, it is an + actual T chart in the interval and exhibits a bypass. If it is full, no + smaller chart with those requirements exists. + +This is exhaustive: any crossing endpoint contains `L`, the selected pair, +and an outside-A vector. When `L` lies in `A`, the required dimension is +`dim(span(L, pair)) + 1`, independent of the selected outside vector. +Otherwise the minimum is simply `span(L, pair)`. +The checker finds no bypass in any of the 1,402 original upward intervals. +It also compares this decision against literal exhaustive comparisons in two +complete 67-chart subspace lattices, one ending at the full chart. + +## Direct-read gate and controls + +The initial construction attempt considered direct `Y_t += c X_s` reads. +All existing X/Y phases and all strict intermediate positions in their +transports give 728 slots on each side. A common chart B exists for two slots +precisely when their lower-bound join fits inside the intersection of their +upper bounds, with the slots' dimension restrictions. Both checkers evaluate +all **529,984 slot pairs**, covering all 104-by-104 source/target pairs, and +find none. No timing constraint is used, so arbitrary retiming cannot help this +particular direct-read attempt. The helper-mediated obstruction is the separate +transcript proof above. + +Meaningful controls include an actual excluded new route +`span(x) -> span(x,a_0,a_1)` for `x` outside A, and a new `0 -> full` lift. +Both admit R -> T crossings and are rejected by the original-interval premise. +Dependent survivors, a ninth descent, a full-to-line replacement and nonnested +replacement also reject. Equivalent basis presentations preserve the entire +receipt. Equal dimension alone fails the common-chart test, while identical +charts and compatible strict refinements pass positive controls. The full +chart's exceptional color and the 48 initially T-side sources are checked +explicitly; they cannot be silently counted as R sources to claim rank eight. + +## Reproduce + +Standard-library Python, read-only by default, no network or Git needed for the +two mathematical checks: + +```sh +python3 -I -O -B research/p104-nested-refinement-cut/verify.py +python3 -I -O -B research/p104-nested-refinement-cut/audit.py +python3.12 scripts/research_package.py --package research/p104-nested-refinement-cut +``` + +`verify.py --out NEW_PATH` writes a computed receipt exclusively; it never +overwrites an existing path. Default replay compares the entire saved receipt. +Exact source and historical task pins are in [SOURCES.json](SOURCES.json). +Both implementations were written by the same author/assistant and are +code-disjoint, not independently human-reviewed. The generic linear transcript +proof is written mathematics, not a proof-assistant certificate. This package +does not replay the original scalar coefficients, native compiler, global +hosting, precision, selected construction or all-size assumptions. + +## Open next questions + +A changed route must leave at least one original nested interval, add a genuine +cross-chart information transfer, or change another explicit model premise. +Start with an actual bypass such as the small excluded interval above, then +check simultaneous availability and arbitrary dirty-state restoration. The +remaining problem is a legal complete word with a favorable native invoice; +a graph bypass by itself is insufficient. + +The sharp capacity of the larger refinement model is also uncomputed. It could +remain eight despite this 56-array upper bound. Only pursue a sharper cut if it +changes a concrete construction decision; identity is already excluded here. +Structured handoffs and stopping criteria are in [TASK.json](TASK.json). + +## Credit and provenance + +Rohan Arun / PR1972 supplies the channel; Chafik Boukhalfa / PR1991 its native +realization and the source distribution; Adam Gall / PR1940 the schedule. +Geometry and decoder credit continues through Josie Elliston / PR1071, +Ali Romman / PR1125 and the predecessor lineage documented by PR1991. +David Arias / PR2082 and Adam Gall / PR2090 supply frozen-itinerary cuts; +Jeremy Diviney / PR2113 supplies the arbitrary-interleaving fixed-path cut; +Ross Richardson / PR2127 treats arbitrary added storage with retained old +occurrences. Their results are not claimed new here. + +The prior fixed-alphabet corroboration is preserved on +[Tairitsu-Aya's public branch](https://github.com/Tairitsu-Aya/integer-mult-bounds/tree/bb473eb4838c271112a95861833847faed55c579/research/p104-chart-alphabet-cut), +without a competing PR. The present contribution is the interval-wide separator, +restricted-source transcript argument and its exact checks. Source files are +read in place and are not copied or modified. + +Prepared for Tairitsu-Aya with substantial OpenAI Codex assistance in +mathematics, implementation, source reading and prose. Apache-2.0. No independent +human review, literature-priority guarantee or formal-kernel verification. diff --git a/research/p104-nested-refinement-cut/RESULT.json b/research/p104-nested-refinement-cut/RESULT.json new file mode 100644 index 0000000000..df13aaeeca --- /dev/null +++ b/research/p104-nested-refinement-cut/RESULT.json @@ -0,0 +1,1739 @@ +{ + "schema_version": 1, + "status": "PASS_P104_NESTED_REFINEMENT_CUT", + "source": { + "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" + }, + "ambient_binary_dimension": 9, + "original_events": 4058, + "original_operations": { + "add": 2624, + "copy": 8, + "erase": 8, + "transport": 1410, + "zero": 8 + }, + "transport_occurrences": 1410, + "transport_signature_sha256": "245796c0f8c399ad5677ebacec524085a269bab9c3e65c55dfebe79add32b3d9", + "survivor_lines_in_drop_order": [ + 243, + 95, + 447, + 502, + 486, + 127, + 500, + 383 + ], + "survivor_span_reduced_basis": [ + 256, + 136, + 72, + 32, + 16, + 4, + 2, + 1 + ], + "drop_hyperplanes": [ + [ + 256, + 128, + 64, + 32, + 16, + 8, + 2, + 1 + ], + [ + 256, + 128, + 64, + 16, + 8, + 4, + 2, + 1 + ], + [ + 256, + 128, + 32, + 16, + 8, + 4, + 2, + 1 + ], + [ + 256, + 128, + 64, + 32, + 17, + 8, + 4, + 3 + ], + [ + 256, + 128, + 64, + 32, + 8, + 4, + 2, + 1 + ], + [ + 260, + 128, + 64, + 36, + 16, + 8, + 2, + 1 + ], + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 1 + ], + [ + 260, + 132, + 64, + 32, + 16, + 8, + 2, + 1 + ] + ], + "survivors_per_drop_hyperplane": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "private_lifetimes": [ + [ + 2461, + 2462, + 2463, + 2469 + ], + [ + 2470, + 2471, + 2472, + 2476 + ], + [ + 2477, + 2478, + 2479, + 2484 + ], + [ + 2485, + 2486, + 2487, + 2492 + ], + [ + 2493, + 2494, + 2495, + 2500 + ], + [ + 2501, + 2502, + 2503, + 2507 + ], + [ + 2508, + 2509, + 2510, + 2515 + ], + [ + 2516, + 2517, + 2518, + 2524 + ] + ], + "interval_classes": { + "last_step_to_full": [ + 1326, + 1328, + 1330, + 1332, + 1334, + 1336, + 1338, + 1340, + 1342, + 1344, + 1346, + 1348, + 1350, + 1352, + 1354, + 1356, + 1358, + 1360, + 1362, + 1364, + 1366, + 1368, + 1370, + 1372, + 1374, + 1376, + 1378, + 1380, + 1382, + 1384, + 1386, + 1388, + 1390, + 1392, + 1394, + 1396, + 1398, + 1400, + 1402, + 1404, + 1406, + 1408, + 1410, + 1412, + 1414, + 1416, + 1418, + 1420, + 1422, + 1424, + 1426, + 1428, + 1430, + 1432, + 1434, + 1436, + 1438, + 1440, + 1442, + 1444, + 1446, + 1448, + 1450, + 1452, + 1454, + 1456, + 1458, + 1460, + 1462, + 1464, + 1466, + 1468, + 1470, + 1472, + 1474, + 1476, + 1478, + 1480, + 1482, + 1484, + 1486, + 1488, + 1490, + 1492, + 1494, + 1496, + 1498, + 1500, + 1502, + 1504, + 1506, + 1508, + 1510, + 1512, + 1514, + 1516, + 1518, + 1520, + 1522, + 1524, + 1526, + 1528, + 1530, + 1532, + 1565, + 1566, + 1567, + 1568, + 1569, + 1570, + 1571, + 1572, + 1573, + 1574, + 1575, + 1576, + 1577, + 1578, + 1579, + 1580, + 1581, + 1582, + 1583, + 1584, + 1585, + 1586, + 1587, + 1588, + 1589, + 1590, + 1591, + 1592, + 1593, + 1594, + 1595, + 1596, + 3570, + 3571, + 3572, + 3573, + 3574, + 3575, + 3576, + 3577 + ], + "lower_at_least_two_survivors": [ + 3466, + 3467, + 3468, + 3469, + 3470, + 3471, + 3472, + 3473, + 3474, + 3475, + 3476, + 3477, + 3478, + 3479, + 3480, + 3481, + 3482, + 3483, + 3484, + 3485, + 3486, + 3487, + 3488, + 3489, + 3490, + 3491, + 3492, + 3493, + 3494, + 3495, + 3496, + 3497, + 3498, + 3499, + 3500, + 3501, + 3502, + 3503, + 3504, + 3505, + 3506, + 3507, + 3508, + 3509, + 3510, + 3511, + 3512, + 3513, + 3514, + 3515, + 3516, + 3517, + 3518, + 3519, + 3520, + 3521, + 3522, + 3523, + 3524, + 3525, + 3526, + 3527, + 3528, + 3529, + 3530, + 3531, + 3532, + 3533, + 3534, + 3535, + 3536, + 3537, + 3538, + 3539, + 3540, + 3541, + 3542, + 3543, + 3544, + 3545, + 3546, + 3547, + 3548, + 3549, + 3550, + 3551, + 3552, + 3553, + 3554, + 3555, + 3556, + 3557, + 3558, + 3559, + 3560, + 3561, + 3562, + 3563, + 3564, + 3565, + 3566, + 3567, + 3568, + 3569, + 3578, + 3580, + 3582, + 3584, + 3586, + 3588, + 3590, + 3592, + 3594, + 3596, + 3598, + 3600, + 3602, + 3604, + 3606, + 3608, + 3610, + 3612, + 3614, + 3616, + 3618, + 3620, + 3622, + 3624, + 3626, + 3628, + 3630, + 3632, + 3634, + 3636, + 3638, + 3640 + ], + "private_downward_interval": [ + 2463, + 2472, + 2479, + 2487, + 2495, + 2503, + 2510, + 2518 + ], + "upper_at_most_one_survivor": [ + 417, + 419, + 421, + 423, + 425, + 426, + 428, + 430, + 432, + 434, + 435, + 437, + 439, + 441, + 442, + 444, + 446, + 448, + 450, + 451, + 453, + 455, + 457, + 459, + 460, + 462, + 464, + 466, + 468, + 469, + 471, + 473, + 475, + 476, + 478, + 480, + 482, + 484, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508, + 509, + 510, + 511, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 548, + 549, + 550, + 551, + 552, + 553, + 554, + 555, + 556, + 557, + 558, + 559, + 560, + 561, + 562, + 563, + 564, + 565, + 566, + 567, + 568, + 569, + 570, + 571, + 572, + 573, + 574, + 575, + 576, + 577, + 578, + 579, + 580, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591, + 593, + 594, + 596, + 597, + 599, + 600, + 602, + 603, + 605, + 606, + 608, + 609, + 611, + 612, + 614, + 615, + 617, + 618, + 620, + 621, + 623, + 624, + 626, + 627, + 629, + 630, + 632, + 633, + 635, + 636, + 638, + 639, + 641, + 643, + 644, + 646, + 647, + 649, + 650, + 652, + 653, + 655, + 657, + 658, + 660, + 661, + 663, + 664, + 666, + 668, + 669, + 671, + 672, + 674, + 675, + 677, + 678, + 680, + 681, + 683, + 684, + 686, + 687, + 689, + 690, + 692, + 694, + 695, + 697, + 699, + 700, + 702, + 703, + 705, + 706, + 708, + 710, + 711, + 713, + 714, + 716, + 717, + 719, + 720, + 722, + 724, + 725, + 727, + 728, + 730, + 732, + 733, + 735, + 737, + 738, + 740, + 741, + 743, + 744, + 746, + 748, + 750, + 751, + 753, + 755, + 756, + 758, + 760, + 762, + 763, + 765, + 767, + 768, + 770, + 772, + 773, + 775, + 777, + 778, + 780, + 781, + 783, + 785, + 787, + 788, + 790, + 792, + 793, + 795, + 797, + 798, + 800, + 801, + 803, + 805, + 806, + 808, + 810, + 812, + 813, + 815, + 816, + 818, + 820, + 821, + 823, + 825, + 827, + 829, + 830, + 832, + 834, + 836, + 838, + 839, + 841, + 842, + 844, + 846, + 847, + 849, + 851, + 852, + 854, + 856, + 858, + 860, + 861, + 863, + 865, + 867, + 868, + 870, + 872, + 874, + 875, + 877, + 879, + 880, + 882, + 883, + 885, + 886, + 888, + 890, + 891, + 893, + 895, + 896, + 898, + 900, + 902, + 903, + 905, + 907, + 909, + 911, + 912, + 914, + 916, + 918, + 920, + 921, + 923, + 925, + 927, + 928, + 930, + 932, + 934, + 935, + 937, + 939, + 941, + 942, + 944, + 946, + 948, + 950, + 952, + 953, + 955, + 957, + 959, + 960, + 962, + 964, + 966, + 968, + 969, + 971, + 973, + 975, + 976, + 978, + 980, + 982, + 984, + 986, + 988, + 989, + 991, + 993, + 995, + 997, + 999, + 1001, + 1002, + 1004, + 1006, + 1008, + 1010, + 1011, + 1013, + 1015, + 1017, + 1018, + 1020, + 1022, + 1024, + 1025, + 1027, + 1029, + 1031, + 1033, + 1034, + 1036, + 1038, + 1040, + 1042, + 1043, + 1045, + 1047, + 1049, + 1051, + 1053, + 1054, + 1056, + 1058, + 1060, + 1062, + 1064, + 1066, + 1067, + 1069, + 1071, + 1073, + 1075, + 1076, + 1078, + 1080, + 1082, + 1083, + 1085, + 1087, + 1089, + 1090, + 1092, + 1094, + 1096, + 1097, + 1099, + 1101, + 1103, + 1104, + 1106, + 1108, + 1110, + 1112, + 1114, + 1116, + 1118, + 1120, + 1121, + 1123, + 1125, + 1127, + 1129, + 1131, + 1133, + 1135, + 1137, + 1139, + 1140, + 1142, + 1144, + 1146, + 1148, + 1150, + 1151, + 1153, + 1155, + 1157, + 1159, + 1161, + 1163, + 1165, + 1167, + 1169, + 1171, + 1173, + 1175, + 1177, + 1178, + 1180, + 1182, + 1184, + 1186, + 1188, + 1190, + 1192, + 1194, + 1196, + 1198, + 1199, + 1201, + 1203, + 1205, + 1207, + 1209, + 1210, + 1212, + 1214, + 1216, + 1218, + 1220, + 1222, + 1224, + 1226, + 1228, + 1230, + 1232, + 1234, + 1235, + 1237, + 1239, + 1241, + 1243, + 1245, + 1247, + 1249, + 1251, + 1253, + 1255, + 1257, + 1259, + 1261, + 1262, + 1264, + 1266, + 1268, + 1270, + 1272, + 1274, + 1276, + 1278, + 1279, + 1281, + 1283, + 1285, + 1287, + 1289, + 1291, + 1293, + 1295, + 1296, + 1298, + 1300, + 1302, + 1304, + 1306, + 1308, + 1310, + 1312, + 1313, + 1315, + 1317, + 1319, + 1321, + 1323, + 1324, + 2429, + 2430, + 2431, + 2432, + 2433, + 2434, + 2435, + 2436, + 2437, + 2438, + 2439, + 2440, + 2441, + 2442, + 2443, + 2444, + 2445, + 2446, + 2447, + 2448, + 2449, + 2450, + 2451, + 2452, + 2453, + 2454, + 2455, + 2456, + 2457, + 2458, + 2459, + 2460, + 2525, + 2527, + 2529, + 2531, + 2533, + 2535, + 2537, + 2539, + 2541, + 2543, + 2545, + 2547, + 2549, + 2551, + 2553, + 2555, + 2557, + 2559, + 2561, + 2563, + 2565, + 2567, + 2569, + 2571, + 2573, + 2575, + 2577, + 2579, + 2581, + 2583, + 2585, + 2587, + 2589, + 2591, + 2593, + 2595, + 2597, + 2599, + 2601, + 2603, + 2605, + 2607, + 2609, + 2611, + 2613, + 2615, + 2617, + 2619, + 2621, + 2623, + 2625, + 2627, + 2629, + 2631, + 2633, + 2635, + 2637, + 2639, + 2641, + 2643, + 2645, + 2647, + 2649, + 2651, + 2653, + 2655, + 2657, + 2659, + 2661, + 2663, + 2665, + 2667, + 2669, + 2671, + 2673, + 2675, + 2677, + 2679, + 2681, + 2683, + 2685, + 2687, + 2689, + 2691, + 2693, + 2695, + 2697, + 2699, + 2701, + 2703, + 2705, + 2707, + 2709, + 2711, + 2713, + 2715, + 2717, + 2719, + 2721, + 2723, + 2725, + 2727, + 2729, + 2731 + ], + "upper_in_survivor_span": [ + 2733, + 2734, + 2736, + 2738, + 2740, + 2742, + 2744, + 2745, + 2747, + 2749, + 2751, + 2753, + 2755, + 2757, + 2759, + 2761, + 2762, + 2764, + 2766, + 2768, + 2770, + 2772, + 2774, + 2776, + 2778, + 2779, + 2781, + 2783, + 2785, + 2787, + 2789, + 2791, + 2793, + 2795, + 2796, + 2798, + 2800, + 2802, + 2804, + 2806, + 2808, + 2810, + 2812, + 2814, + 2816, + 2818, + 2820, + 2822, + 2823, + 2825, + 2827, + 2829, + 2831, + 2833, + 2835, + 2837, + 2839, + 2841, + 2843, + 2845, + 2847, + 2848, + 2850, + 2852, + 2854, + 2856, + 2858, + 2859, + 2861, + 2863, + 2865, + 2867, + 2869, + 2871, + 2873, + 2875, + 2877, + 2879, + 2880, + 2882, + 2884, + 2886, + 2888, + 2890, + 2892, + 2894, + 2896, + 2898, + 2900, + 2902, + 2904, + 2906, + 2907, + 2909, + 2911, + 2913, + 2915, + 2917, + 2918, + 2920, + 2922, + 2924, + 2926, + 2928, + 2930, + 2932, + 2934, + 2936, + 2937, + 2939, + 2941, + 2943, + 2945, + 2947, + 2949, + 2951, + 2953, + 2954, + 2956, + 2958, + 2960, + 2961, + 2963, + 2965, + 2967, + 2968, + 2970, + 2972, + 2974, + 2975, + 2977, + 2979, + 2981, + 2982, + 2984, + 2986, + 2988, + 2990, + 2991, + 2993, + 2995, + 2997, + 2999, + 3001, + 3003, + 3004, + 3006, + 3008, + 3010, + 3012, + 3014, + 3015, + 3017, + 3019, + 3021, + 3023, + 3024, + 3026, + 3028, + 3030, + 3032, + 3033, + 3035, + 3037, + 3039, + 3040, + 3042, + 3044, + 3046, + 3047, + 3049, + 3051, + 3053, + 3055, + 3056, + 3058, + 3060, + 3062, + 3064, + 3066, + 3068, + 3069, + 3071, + 3073, + 3075, + 3077, + 3079, + 3081, + 3082, + 3084, + 3086, + 3088, + 3089, + 3091, + 3093, + 3095, + 3097, + 3098, + 3100, + 3102, + 3104, + 3105, + 3107, + 3109, + 3111, + 3113, + 3115, + 3116, + 3118, + 3120, + 3122, + 3123, + 3125, + 3127, + 3129, + 3130, + 3132, + 3134, + 3136, + 3137, + 3139, + 3141, + 3143, + 3145, + 3146, + 3148, + 3150, + 3152, + 3154, + 3155, + 3157, + 3159, + 3161, + 3162, + 3164, + 3166, + 3167, + 3169, + 3171, + 3172, + 3174, + 3175, + 3177, + 3178, + 3180, + 3182, + 3183, + 3185, + 3187, + 3189, + 3190, + 3192, + 3194, + 3196, + 3197, + 3199, + 3201, + 3203, + 3205, + 3206, + 3208, + 3210, + 3211, + 3213, + 3215, + 3216, + 3218, + 3219, + 3221, + 3223, + 3225, + 3227, + 3228, + 3230, + 3232, + 3234, + 3236, + 3237, + 3239, + 3241, + 3242, + 3244, + 3245, + 3247, + 3249, + 3251, + 3252, + 3254, + 3256, + 3257, + 3259, + 3260, + 3262, + 3264, + 3265, + 3267, + 3269, + 3270, + 3272, + 3274, + 3276, + 3277, + 3279, + 3280, + 3282, + 3284, + 3285, + 3287, + 3289, + 3290, + 3292, + 3294, + 3295, + 3297, + 3299, + 3301, + 3302, + 3304, + 3306, + 3307, + 3309, + 3311, + 3313, + 3314, + 3316, + 3317, + 3319, + 3320, + 3322, + 3324, + 3325, + 3327, + 3329, + 3330, + 3332, + 3333, + 3335, + 3337, + 3338, + 3340, + 3341, + 3343, + 3344, + 3346, + 3347, + 3349, + 3351, + 3352, + 3354, + 3355, + 3357, + 3358, + 3360, + 3362, + 3363, + 3365, + 3367, + 3368, + 3370, + 3371, + 3373, + 3374, + 3376, + 3377, + 3379, + 3380, + 3382, + 3383, + 3385, + 3386, + 3388, + 3389, + 3391, + 3393, + 3394, + 3396, + 3397, + 3399, + 3400, + 3402, + 3404, + 3405, + 3407, + 3408, + 3410, + 3411, + 3413, + 3414, + 3416, + 3418, + 3419, + 3421, + 3422, + 3424, + 3425, + 3427, + 3428, + 3430, + 3431, + 3433, + 3434, + 3436, + 3437, + 3439, + 3440, + 3442, + 3443, + 3445, + 3446, + 3448, + 3449, + 3451, + 3452, + 3454, + 3455, + 3457, + 3458, + 3460, + 3461, + 3463, + 3464 + ] + }, + "interval_class_counts": { + "last_step_to_full": 144, + "lower_at_least_two_survivors": 136, + "private_downward_interval": 8, + "upper_at_most_one_survivor": 701, + "upper_in_survivor_span": 421 + }, + "initial_sources_on_target_side": [ + "X2", + "X4", + "X5", + "X8", + "X11", + "X13", + "X15", + "X17", + "X18", + "X20", + "X23", + "X25", + "X28", + "X30", + "X32", + "X34", + "X37", + "X39", + "X40", + "X42", + "X45", + "X48", + "X50", + "X51", + "X53", + "X56", + "X58", + "X59", + "X61", + "X63", + "X65", + "X68", + "X70", + "X71", + "X73", + "X76", + "X78", + "X80", + "X82", + "X84", + "X87", + "X89", + "X91", + "X94", + "X96", + "X98", + "X100", + "X102" + ], + "initial_sources_on_other_side": [ + "X0", + "X1", + "X3", + "X6", + "X7", + "X9", + "X10", + "X12", + "X14", + "X16", + "X19", + "X21", + "X22", + "X24", + "X26", + "X27", + "X29", + "X31", + "X33", + "X35", + "X36", + "X38", + "X41", + "X43", + "X44", + "X46", + "X47", + "X49", + "X52", + "X54", + "X55", + "X57", + "X60", + "X62", + "X64", + "X66", + "X67", + "X69", + "X72", + "X74", + "X75", + "X77", + "X79", + "X81", + "X83", + "X85", + "X86", + "X88", + "X90", + "X92", + "X93", + "X95", + "X97", + "X99", + "X101", + "X103" + ], + "target_survivor_count_histogram": { + "2": 12, + "3": 24, + "4": 32, + "5": 24, + "6": 12 + }, + "rank_bounds_in_array_units": { + "other_side_source_count": 56, + "other_side_source_transfer_upper_bound": 8, + "all_source_transfer_upper_bound": 56, + "identity_required": 104, + "sharpness_claimed": false + }, + "direct_read_gate": { + "source_slots": 728, + "target_slots": 728, + "slot_pairs": 529984, + "common_chart_pairs": 0, + "timing_constraints_used": false + } +} diff --git a/research/p104-nested-refinement-cut/SELECTION.json b/research/p104-nested-refinement-cut/SELECTION.json new file mode 100644 index 0000000000..12efe62342 --- /dev/null +++ b/research/p104-nested-refinement-cut/SELECTION.json @@ -0,0 +1,61 @@ +{ + "seed": "42cfe0fa1a2cc7beaef5efc7e55377bd", + "track": "complex-mechanisms", + "suggestions": [ + { + "task_id": "p104-side-correction", + "scope_key": "72dfbf0708467ad34793", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "method": "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget.", + "starting_points": [ + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991" + ], + "scope_rule": "If you change the card's premise, record scope_status=changed and explain why. A package metadata check cannot establish mathematical relevance." + } + ], + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "catalog_assessed_on": "2026-10-14", + "priority_revision": 4, + "priority_log": "docs/research/research-priority-log.md", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected": { + "kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "reproduce": "make frontier1094-verify" + }, + "status": "SUGGESTIONS_ONLY_NOT_RESERVED", + "next_step": "Check live overlap, refine one question's object and domain, and record a bounded task card. A different seed or scope key is not evidence of novelty." +} diff --git a/research/p104-nested-refinement-cut/SOURCES.json b/research/p104-nested-refinement-cut/SOURCES.json new file mode 100644 index 0000000000..a9ff7abd34 --- /dev/null +++ b/research/p104-nested-refinement-cut/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "usage": "input", + "git_blob": "86beaf424e9f0f800ae3a62797d94ec9386b7706", + "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" + } + ] +} diff --git a/research/p104-nested-refinement-cut/TASK.json b/research/p104-nested-refinement-cut/TASK.json new file mode 100644 index 0000000000..0708eab2ef --- /dev/null +++ b/research/p104-nested-refinement-cut/TASK.json @@ -0,0 +1,194 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "p104-side-correction", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "starting_points": [ + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991" + ] + }, + "scope_status": "changed", + "actual_scope": "Prove a source-bound communication cut under arbitrary nested refinements of every original P104 transport interval, arbitrary interleaving and common-chart linear resynthesis; also exhaust the direct source-to-target common-chart gate.", + "scope_change_reason": "The initial direct-correction construction gate found no compatible chart even before chronology. A bounded pivot identified a geometric interval separator. This supplies a scoped negative result and does not meet the card's constructive complete-supplier gate.", + "bottleneck_link": "The changed-intermediate-frame handoff in PR2113 is a concrete attempted escape from the fixed-path cut. This proof excludes every nested refinement of the old occurrences, so a successful successor must change an interval, add a true cross-chart transfer, or change another explicit premise.", + "budget_minutes": 105, + "stop_rule": "Stop the nested-refinement route after the interval separator and its scope are independently checked, or if a counterexample/overlap invalidates the result. Do not launch scheduling or coefficient optimization after identity has been excluded in this model.", + "outcome": "negative-result", + "evidence": "RESULT.json pins 1410 transport intervals, their four upward cases and eight descending lifetimes; 48/56 initial source colors and 104 target colors; at most eight array messages from the 56 outside sources, and total rank at most 56 arrays. Two code-disjoint implementations agree on the full receipt and 529984 impossible direct-read slot pairs.", + "author": "Tairitsu-Aya", + "ai_assistance": "Substantial OpenAI Codex assistance for proof, source reading, code and prose. Both code-disjoint implementations were prepared by this same author/assistant. No independent human review or proof-assistant verification.", + "open_questions": [ + { + "question": "Can a route outside an original nested interval yield a fully restored correction with a favorable complete native bill?", + "why_it_matters": "Nested subdivision and scalar retiming alone cannot produce identity; an actual premise-changing transfer is required.", + "first_step": "Construct a legal simultaneous read using one explicit new R-to-T interval, then check all arbitrary input columns, dirty restoration, native operators and every additional child.", + "blocked_by": "No executable changed word, native lowering, owner map or favorable complete moment is provided here." + }, + { + "question": "Is the larger refinement model's sharp capacity still eight arrays or greater?", + "why_it_matters": "This can distinguish partial information routes but is secondary because identity is already excluded.", + "first_step": "Only if needed by a concrete construction, find an executable ninth independent message or a sharper separator; a union-graph path is insufficient.", + "blocked_by": "The present 56-array total upper bound is not accompanied by an attaining program." + } + ], + "selection_mode": "Explicit revision-4 changed-intermediate-frame handoff from PR2113, following the completed fixed-alphabet corroboration; --task selection is not a fresh random draw.", + "selection_file": "SELECTION.json", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2113#issuecomment-6177169033", + "claim_expires_utc": "2026-10-14T21:45:00Z", + "compute_limit": { + "maximum_local_workers": 3, + "registered_replay_cpus": 1 + }, + "predecessors": [ + { + "pr": 1972, + "head": "fd82d172f46933fd253c2c6de4bd5eaff5429cfd", + "author": "Rohan Arun", + "credit": "Complete scalar/frame low-rank channel and dirty restoration." + }, + { + "pr": 1991, + "head": "6e222517e182e98499239bc9a4009f540e1c5520", + "author": "Chafik Boukhalfa", + "credit": "Finite native realization and frozen source distribution." + }, + { + "pr": 1940, + "author": "Adam Gall", + "credit": "Exact 32-chain delivery schedule." + }, + { + "pr": 1071, + "author": "Josie Elliston", + "credit": "P104 fixture and decoder geometry." + }, + { + "pr": 1125, + "author": "Ali Romman", + "credit": "Monotone delivery lower bound." + }, + { + "pr": 2082, + "head": "60f4e337ffba470e09727dd435b1f1be3b67d03d", + "author": "David Arias", + "credit": "Frozen-itinerary temporal cut and retained excursion cost obstruction." + }, + { + "pr": 2090, + "head": "dff116efc2c4ddd7236020ad8316db5c98aa693e", + "author": "Adam Gall", + "credit": "Sharp eight-query frozen temporal cut." + }, + { + "pr": 2113, + "head": "fa1a45f91c14bb4b372d19dd7d66e11fea480ef5", + "author": "Jeremy Diviney", + "credit": "Arbitrary-interleaving fixed-path cut; explicit changed-intermediate-frame handoff." + }, + { + "pr": 2127, + "head": "befebf0f4ae7a3f69fe9c5e136262559dcac125f", + "author": "Ross Richardson", + "credit": "Added-storage cut retaining the original unsplit occurrences; distinct from replacing them by nested chains." + } + ], + "overlap_at_entry": { + "searched_at_utc": "2026-10-14T20:17:20Z", + "open_prs": 386, + "pr_snapshot_utc": "2026-10-14T20:14:12Z", + "discussion_records": 754, + "discussion_snapshot_utc": "2026-10-14T19:23:36Z", + "discussion_refresh": "GitHub GraphQL EOF; retained older complete cache.", + "live_supplement": "Read current PR2113 and PR2127 bodies/heads, all PR2113 comments, and Discussion2121. Its joint-side producer replaces the source/producer paths and is outside this nested-refinement claim.", + "limits": "Non-atomic snapshots; stale broad Discussion cache; no arbitrary-diff, unpublished-work or literature novelty guarantee. Refresh before publication." + }, + "validation": { + "windows": { + "python": "3.12.9", + "registered_replay": "passed", + "source_export_cases": 12, + "normal_and_optimized": true, + "default_export_writes": false + }, + "linux": { + "distribution": "Ubuntu 24.04 under WSL", + "python": "3.12.3", + "command": "python3 -B scripts/research_package.py --package research/p104-nested-refinement-cut", + "elapsed_seconds": 1.52, + "max_rss_kib": 53752, + "cpu_affinity": [ + 1 + ], + "outcome": "PASS_REGISTERED_RESEARCH_PACKAGE outcome=negative-result" + }, + "not_run": [ + "Original scalar coefficient/280-column replay for this package", + "native recipe compilation or regeneration for new intermediate charts", + "global hosting/precision/all-size/outer admission", + "selected cold replay for this package", + "hosted CI", + "proof assistant" + ], + "limits": "The interval premises have two code-disjoint exact checks; the generic linear transcript implication is a written proof, not a formal-kernel certificate. Other earlier session replays are not claimed as this package's checks." + }, + "overlap_at_submission": { + "searched_at_utc": "2026-10-14T20:30:12.128656+00:00", + "cached_coverage": { + "open_prs": { + "fetched_at": "2026-10-14T20:14:12.897822+00:00", + "complete_pagination": true, + "records": 386 + }, + "discussions": { + "fetched_at": "2026-10-14T19:23:36.452347+00:00", + "complete_pagination": true, + "records": 754 + } + }, + "refresh_warnings": [ + "open_prs: refresh failed; using old data if available: Command '['gh', 'api', '--paginate', 'repos/CrocSwap/integer-mult-bounds/pulls?state=open&per_page=100&sort=updated&direction=desc', '--jq', '@json']' timed out after 90 seconds", + "discussions: refresh failed; using old data if available: Post \"https://api.github.com/graphql\": EOF\n" + ], + "live_supplement": "Current PR2113/2127 heads and bodies rechecked unchanged; PR2133 scope map at a79f0f91a8a8f6b8c3bd1e0b885349f73436146e read. Retrieved 20 most recently updated Discussions with up to 10 comments each at 20:28 UTC, including current 2121 and 2131 claims, 2123 release and the three hubs. No matching nested-refinement result found in this coverage.", + "distinct_live_work": "Discussion2121 changes the joint side producer; Discussion2131 permits replacement transport paths and new dirty carriers. Both change premises outside this result. PR2133 consolidates existing scopes without new mathematics.", + "limits": "Broad PR and Discussion refresh failed, so old complete cache coverage is not called current. Recent-discussion supplement has truncated older history. Text searches and exact neighboring heads are not a novelty guarantee." + } +} diff --git a/research/p104-nested-refinement-cut/VERIFY.json b/research/p104-nested-refinement-cut/VERIFY.json new file mode 100644 index 0000000000..b27d3fe487 --- /dev/null +++ b/research/p104-nested-refinement-cut/VERIFY.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Source digest, complete frame trace, exact binary interval separator, full receipt, all 529984 direct-read pairs, six rejecting premise controls and basis-presentation invariance." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/audit.py" + ], + "timeout_seconds": 120, + "checks": "Code-disjoint literal spans, independent exhaustive upward-bypass criterion, complete receipt, excluded-route counterexamples and 892 literal intervals in two complete 67-chart lattices." + } + ] +} diff --git a/research/p104-nested-refinement-cut/audit.py b/research/p104-nested-refinement-cut/audit.py new file mode 100644 index 0000000000..76b52a0691 --- /dev/null +++ b/research/p104-nested-refinement-cut/audit.py @@ -0,0 +1,301 @@ +#!/usr/bin/env python3 +"""Code-disjoint literal-subspace audit and constructive interval-bypass test. + +Tairitsu-Aya, with substantial OpenAI Codex assistance. Apache-2.0. +Does not import verify.py, the old channel producer or its native compiler. +""" +from collections import Counter, defaultdict +from itertools import combinations +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +INPUT = "research/p104-native-channel/inputs/LOWRANK-WITNESS.json" +PIN = "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" + + +def check(condition, message): + if not condition: + raise RuntimeError(message) + + +def generate(vectors): + values = {0} + for v in vectors: + check(type(v) is int and 0 < v < 512, "binary label") + values.update({x ^ v for x in tuple(values)}) + return frozenset(values) + + +def from_basis(vectors): + result = generate(vectors) + check(len(result) == 2 ** len(vectors), "independent source basis") + return result + + +def reduced_presentation(values): + # Enumerate each pivot's numerically least representative, without elimination. + return [min(x for x in values if x.bit_length() == bit) + for bit in range(9, 0, -1) if any(x.bit_length() == bit for x in values)] + + +def extend(values, vectors): + result = set(values) + for v in vectors: + result.update({x ^ v for x in tuple(result)}) + return frozenset(result) + + +def target(values, survivors, hull): + return len(values) < 512 and (values <= hull or len(values & survivors) >= 2) + + +def upward_bypass(lo, hi, survivors, hull): + """Return an actual R->T pair within [lo,hi], or certify none exists. + + This does not use the producer's four sufficient interval categories. + For an R->T crossing, the target must contain two survivor lines: entry + into hull is impossible by ascent. A minimum candidate is lo plus those + two lines and, if lo is in hull, any one vector of hi outside hull. + Its dimension is independent of the outside vector selected. The README + proves that this exhausts the possibilities. + """ + check(lo < hi, "proper nested upward interval") + if len(lo & survivors) >= 2 or hi <= hull: + return None + candidates = sorted(hi & survivors) + if len(candidates) < 2: + return None + other = lo + if lo <= hull: + other = extend(lo, [min(hi - hull)]) + check(not target(other, survivors, hull), "candidate R chart") + for first, second in combinations(candidates, 2): + goal = extend(other, [first, second]) + if len(goal) == 512: + continue + check(lo <= other < goal <= hi and target(goal, survivors, hull), "actual interval bypass") + return other, goal + return None + + +def inspect(word): + entry = {r: from_basis(v) for r, v in word["initial_frames"].items()} + exit_frames = {r: from_basis(v) for r, v in word["final_frames"].items()} + live = dict(entry) + paths = {r: [v] for r, v in entry.items()} + moves = [] + lives = [] + owned = None + counts = Counter() + for n, event in enumerate(word["program"]): + kind, reg = event[:2] + counts[kind] += 1 + if kind == "transport": + before, after = from_basis(event[2]), from_basis(event[3]) + check(live[reg] == before, "frame continuity") + check(before < after or after < before, "strict nested source move") + check(abs(len(before).bit_length() - len(after).bit_length()) == event[4], "paid rank") + moves.append((n, reg, before, after, event[4])) + live[reg] = after + if reg != "C": + paths[reg].append(after) + elif kind == "zero": + check(reg == "C" and reg not in live and owned is None, "owned creation") + live[reg] = from_basis(event[-1]) + owned = [] + elif kind in ("copy", "add"): + check(live[reg] == live[event[2]] == from_basis(event[-1]), "common chart") + elif kind == "erase": + check(reg == "C" and live[reg] == from_basis(event[-1]), "owned discard") + del live[reg] + else: + raise RuntimeError("unrecognized source operation") + if reg == "C": + check(owned is not None, "owned lifetime exists") + owned.append(n) + if kind == "erase": + lives.append(owned) + owned = None + check(owned is None and live == exit_frames, "complete final frames") + check(len(lives) == 8 and all(len(life) == 4 for life in lives), "eight four-event lifetimes") + check(set(entry) == set(exit_frames) and len(entry) == 280, "persistent roles") + down = [row for row in moves if row[3] < row[2]] + check(len(down) == 8, "eight descending occurrences") + labels = [next(iter(row[3] - {0})) for row in down] + survivors = frozenset(labels) + hull = generate(labels) + check(len(hull) == 256 and len(survivors) == 8, "eight-dimensional survivor hull") + for _, role, old, new, rank in down: + check(role == "C" and len(old) == 256 and len(new) == 2 and rank == 7, "drop shape") + check(old & survivors == new - {0}, "exactly its own survivor in drop hyperplane") + check(not old <= hull and new <= hull, "descending entry into hull") + groups = defaultdict(list) + for n, _, old, new, _ in moves: + if new < old: + group = "private_downward_interval" + else: + check(upward_bypass(old, new, survivors, hull) is None, "a refined upward bypass exists") + # Compare the full receipt's convenient four-case classification too. + if len(new & survivors) <= 1: + group = "upper_at_most_one_survivor" + elif new <= hull: + group = "upper_in_survivor_span" + elif len(old & survivors) >= 2: + group = "lower_at_least_two_survivors" + else: + check(len(old) == 256 and len(new) == 512, "last cover before full chart") + group = "last_step_to_full" + groups[group].append(n) + inside, outside = [], [] + for k in range(104): + name = f"X{k}" + check(len(entry[name]) == 2, "singleton source") + (inside if target(entry[name], survivors, hull) else outside).append(name) + target_counts = Counter() + for k in range(104): + chart = exit_frames[f"Y{k}"] + check(len(chart) == 256 and target(chart, survivors, hull), "target endpoint color") + target_counts[str(len(chart & survivors))] += 1 + + def all_slots(prefix): + out = [] + for k in range(104): + for values in paths[f"{prefix}{k}"]: + dimension = len(values).bit_length() - 1 + out.append((values, values, dimension, dimension)) + for _, reg, first, last, rank in moves: + if reg.startswith(prefix) and rank > 1: + check(first < last, "data moves ascend") + out.append((first, last, len(first).bit_length(), len(last).bit_length() - 2)) + return out + + left, right = all_slots("X"), all_slots("Y") + feasible = 0 + for a, b, amin, amax in left: + for c, d, cmin, cmax in right: + available = b & d + if not a <= available or not c <= available: + continue + join_size = len(a) * len(c) // len(a & c) + least = max(join_size.bit_length() - 1, amin, cmin) + most = min(len(available).bit_length() - 1, amax, cmax) + feasible += least <= most + check(feasible == 0, "direct-read gate") + signature = [[n, reg, sorted(a), sorted(b), rank] for n, reg, a, b, rank in moves] + computed = { + "schema_version": 1, + "status": "PASS_P104_NESTED_REFINEMENT_CUT", + "source": {"path": INPUT, "sha256": PIN}, + "ambient_binary_dimension": 9, + "original_events": sum(counts.values()), + "original_operations": dict(sorted(counts.items())), + "transport_occurrences": len(moves), + "transport_signature_sha256": hashlib.sha256(json.dumps(signature, separators=(",", ":")).encode()).hexdigest(), + "survivor_lines_in_drop_order": labels, + "survivor_span_reduced_basis": reduced_presentation(hull), + "drop_hyperplanes": [reduced_presentation(row[2]) for row in down], + "survivors_per_drop_hyperplane": [len(row[2] & survivors) for row in down], + "private_lifetimes": lives, + "interval_classes": dict(sorted(groups.items())), + "interval_class_counts": {key: len(value) for key, value in sorted(groups.items())}, + "initial_sources_on_target_side": inside, + "initial_sources_on_other_side": outside, + "target_survivor_count_histogram": dict(sorted(target_counts.items())), + "rank_bounds_in_array_units": { + "other_side_source_count": len(outside), + "other_side_source_transfer_upper_bound": len(down), + "all_source_transfer_upper_bound": len(inside) + len(down), + "identity_required": len(inside) + len(outside), + "sharpness_claimed": False, + }, + "direct_read_gate": { + "source_slots": len(left), "target_slots": len(right), + "slot_pairs": len(left) * len(right), "common_chart_pairs": feasible, + "timing_constraints_used": False, + }, + } + # Construct excluded routes instead of merely provoking a producer guard. + outsider = min(set(range(512)) - hull) + u = from_basis([outsider]) + v = from_basis([outsider, labels[0], labels[1]]) + bypass = upward_bypass(u, v, survivors, hull) + check(bypass is not None and bypass == (u, v), "new interval really bypasses") + full = frozenset(range(512)) + check(upward_bypass(frozenset([0]), full, survivors, hull) is not None, + "new long initial lift really permits a crossing") + check(not target(full, survivors, hull), "full frame is not target-side") + check(all(not target(row[2], survivors, hull) for row in down), "old gather hyperplanes are other-side") + return computed + + +def exhaustive_small_interval_controls(labels): + """Compare the bypass decision with literal all-pairs subspace lattices. + + One lattice has dimension four; another is a four-dimensional quotient + ending at the full nine-dimensional chart. The latter exercises the + exceptional color of the full chart, not just small proper charts. + """ + survivors = frozenset(labels) + hull = generate(labels) + outside = min(set(range(512)) - hull) + + def lattice(base, extra): + quotient = generate(extra) + found = {frozenset([0])} + pending = [frozenset([0])] + while pending: + current = pending.pop() + for vector in quotient - current: + successor = extend(current, [vector]) + if successor not in found: + found.add(successor) + pending.append(successor) + return [extend(base, part - {0}) for part in found] + + low = generate([labels[k] ^ labels[7] for k in range(5)]) + growing = low + extra = [] + for unit in (1 << k for k in range(9)): + if unit not in growing: + extra.append(unit) + growing = extend(growing, [unit]) + check(len(extra) == 4 and len(growing) == 512, "four-dimensional full-chart quotient") + lattices = [lattice(frozenset([0]), [outside, *labels[:3]]), lattice(low, extra)] + tested = 0 + for charts in lattices: + check(len(charts) == 67, "all 67 binary subspaces of dimension-four quotient") + crossings = [(a, b) for a in charts for b in charts + if a < b and not target(a, survivors, hull) and target(b, survivors, hull)] + for a in charts: + for b in charts: + if not a < b: + continue + literal = any(a <= x and y <= b for x, y in crossings) + constructed = upward_bypass(a, b, survivors, hull) is not None + check(literal == constructed, "exhaustive interval-bypass comparison") + tested += 1 + # This safe rank-two interval is outside the four sufficient source cases: + # its lower chart is the seven-dimensional even survivor subspace. + even = generate([labels[k] ^ labels[7] for k in range(7)]) + check(len(even) == 128 and not even & survivors, "even survivor hyperplane") + check(upward_bypass(even, frozenset(range(512)), survivors, hull) is None, + "four-case classification is sufficient, not necessary") + return tested + + +def main(): + data = (ROOT / INPUT).read_bytes() + check(hashlib.sha256(data).hexdigest() == PIN, "input digest") + result = inspect(json.loads(data)) + expected = json.loads((HERE / "RESULT.json").read_text(encoding="utf-8")) + check(result == expected, "independent complete receipt comparison") + tested = exhaustive_small_interval_controls(result["survivor_lines_in_drop_order"]) + print("PASS_INDEPENDENT_P104_REFINEMENT_AUDIT: literal spans, exact upward-bypass test, full receipt") + print(f"Exhaustive controls: {tested} strict intervals in two complete 67-chart lattices") + + +if __name__ == "__main__": + main() diff --git a/research/p104-nested-refinement-cut/verify.py b/research/p104-nested-refinement-cut/verify.py new file mode 100644 index 0000000000..392fbfedf9 --- /dev/null +++ b/research/p104-nested-refinement-cut/verify.py @@ -0,0 +1,322 @@ +#!/usr/bin/env python3 +"""Exact interval premises for the P104 nested-refinement cut. + +Tairitsu-Aya, with substantial OpenAI Codex assistance. Apache-2.0. +No producer imports; no floating point; explicit guards also run under -O. +The transcript/rank implication is the written proof in README.md. +""" +from __future__ import annotations + +import argparse +from collections import Counter, defaultdict +from functools import lru_cache +import hashlib +import json +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +SOURCE = "research/p104-native-channel/inputs/LOWRANK-WITNESS.json" +SHA256 = "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" +PASS = "PASS_P104_NESTED_REFINEMENT_CUT" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +@lru_cache(maxsize=None) +def reduced(vectors): + """Unique high-pivot reduced basis; dependencies are permitted here.""" + rows = {} + for value in vectors: + require(type(value) is int and 0 < value < 512, "nine-bit nonzero vector") + x = value + for bit in sorted(rows, reverse=True): + if x & (1 << bit): + x ^= rows[bit] + if not x: + continue + bit = x.bit_length() - 1 + for other in rows: + if rows[other] & (1 << bit): + rows[other] ^= x + rows[bit] = x + return tuple(rows[bit] for bit in sorted(rows, reverse=True)) + + +def basis(values): + result = reduced(tuple(values)) + require(len(result) == len(values), "independent input frame") + return result + + +@lru_cache(maxsize=None) +def contains(space, vector): + for row in space: + if vector & (1 << (row.bit_length() - 1)): + vector ^= row + return vector == 0 + + +@lru_cache(maxsize=None) +def included(smaller, larger): + return all(contains(larger, x) for x in smaller) + + +def elements(space): + out = [0] + for x in space: + out += [y ^ x for y in out] + return sorted(out) + + +def numeric_names(names, prefix): + return sorted((r for r in names if r.startswith(prefix)), key=lambda r: int(r[1:])) + + +def frame_trace(witness): + initial = {r: basis(v) for r, v in witness["initial_frames"].items()} + final = {r: basis(v) for r, v in witness["final_frames"].items()} + require(set(initial) == set(final) and len(initial) == 280, "280 persistent roles") + require(numeric_names(initial, "X") == [f"X{i}" for i in range(104)], "source roles") + require(numeric_names(final, "Y") == [f"Y{i}" for i in range(104)], "target roles") + current = dict(initial) + phases = defaultdict(list) + for name, space in initial.items(): + phases[name].append(space) + transports = [] + lifetimes = [] + active = None + operations = Counter() + for index, event in enumerate(witness["program"]): + op, reg = event[:2] + operations[op] += 1 + if op == "transport": + old, new, rank = basis(event[2]), basis(event[3]), event[4] + require(current[reg] == old, "transport continuity") + require(included(old, new) or included(new, old), "nested transport") + require(type(rank) is int and rank == abs(len(old) - len(new)) > 0, + "positive dimension-difference rank") + transports.append((index, reg, old, new, rank)) + current[reg] = new + phases[reg].append(new) + if reg == "C": + require(active is not None, "private transport owns a lifetime") + active.append(index) + elif op == "zero": + require(reg == "C" and reg not in current and active is None, "fresh private lifetime") + current[reg] = basis(event[2]) + active = [index] + elif op == "erase": + require(reg == "C" and active is not None and current[reg] == basis(event[2]), + "private discard frame") + active.append(index) + require(len(active) == 4, "one initialization, copy, transport, discard per lifetime") + lifetimes.append(active) + active = None + del current[reg] + elif op in ("add", "copy"): + src = event[2] + require(reg != src and current[reg] == current[src] == basis(event[-1]), + "literal common-chart operation") + if op == "copy": + require(reg == "C" and active is not None and len(active) == 1, + "private copy follows initialization") + active.append(index) + else: + raise ValueError("unknown source event") + require(active is None and current == final, "complete frame endpoints") + require(len(lifetimes) == 8, "eight owned private lifetimes") + return initial, final, phases, transports, lifetimes, operations + + +def geometry(transports): + drops = [row for row in transports if len(row[2]) > len(row[3])] + require(len(drops) == 8, "eight descending occurrences") + require(all(reg == "C" and len(old) == 8 and len(new) == 1 and rank == 7 + for _, reg, old, new, rank in drops), "eight private hyperplane-to-line drops") + lines = tuple(row[3][0] for row in drops) + span = basis(lines) + require(len(span) == 8, "independent survivor lines") + for _, _, old, new, _ in drops: + require(sum(contains(old, a) for a in lines) == 1, "one survivor in each drop hyperplane") + require(not included(old, span) and included(new, span), "drop enters survivor span") + return drops, lines, span + + +def target_side(space, lines, survivor_span): + return len(space) < 9 and (included(space, survivor_span) + or sum(contains(space, a) for a in lines) >= 2) + + +def upward_case(lower, upper, lines, survivor_span): + require(len(lower) < len(upper) and included(lower, upper), "strict upward interval") + if sum(contains(upper, a) for a in lines) <= 1: + return "upper_at_most_one_survivor" + if included(upper, survivor_span): + return "upper_in_survivor_span" + if sum(contains(lower, a) for a in lines) >= 2: + return "lower_at_least_two_survivors" + if len(lower) == 8 and len(upper) == 9: + return "last_step_to_full" + raise ValueError("uncovered upward interval: the claimed cut is not established") + + +def slots(phases, transports, prefix): + result = [] + for reg in numeric_names(phases, prefix): + for space in phases[reg]: + result.append((space, space, len(space), len(space))) + for _, reg, lower, upper, _ in transports: + if not reg.startswith(prefix): + continue + require(included(lower, upper), "upward data itinerary") + if len(upper) - len(lower) > 1: + result.append((lower, upper, len(lower) + 1, len(upper) - 1)) + return result + + +def common_chart(first, second): + a, b, amin, amax = first + c, d, cmin, cmax = second + if not included(a, d) or not included(c, b): + return False + join_dimension = len(reduced(a + c)) + intersection_dimension = len(b) + len(d) - len(reduced(b + d)) + return max(join_dimension, amin, cmin) <= min(intersection_dimension, amax, cmax) + + +def analyze(witness): + initial, final, phases, transports, lifetimes, operations = frame_trace(witness) + drops, lines, span = geometry(transports) + classes = defaultdict(list) + for index, _, lower, upper, _ in transports: + key = ("private_downward_interval" if len(lower) > len(upper) + else upward_case(lower, upper, lines, span)) + classes[key].append(index) + inside, outside = [], [] + for reg in numeric_names(initial, "X"): + require(len(initial[reg]) == 1, "singleton source entry") + (inside if target_side(initial[reg], lines, span) else outside).append(reg) + targets = numeric_names(final, "Y") + require(all(len(final[r]) == 8 and target_side(final[r], lines, span) for r in targets), + "all target endpoints lie on target side") + xs, ys = slots(phases, transports, "X"), slots(phases, transports, "Y") + direct_count = sum(common_chart(x, y) for x in xs for y in ys) + require(direct_count == 0, "no direct source/target common chart under refinements") + signature = [[i, reg, elements(a), elements(b), rank] for i, reg, a, b, rank in transports] + return { + "schema_version": 1, + "status": PASS, + "source": {"path": SOURCE, "sha256": SHA256}, + "ambient_binary_dimension": 9, + "original_events": sum(operations.values()), + "original_operations": dict(sorted(operations.items())), + "transport_occurrences": len(transports), + "transport_signature_sha256": hashlib.sha256(json.dumps(signature, separators=(",", ":")).encode()).hexdigest(), + "survivor_lines_in_drop_order": list(lines), + "survivor_span_reduced_basis": list(span), + "drop_hyperplanes": [list(row[2]) for row in drops], + "survivors_per_drop_hyperplane": [sum(contains(row[2], a) for a in lines) for row in drops], + "private_lifetimes": lifetimes, + "interval_classes": {key: value for key, value in sorted(classes.items())}, + "interval_class_counts": {key: len(value) for key, value in sorted(classes.items())}, + "initial_sources_on_target_side": inside, + "initial_sources_on_other_side": outside, + "target_survivor_count_histogram": dict(sorted(Counter(str(sum(contains(final[r], a) for a in lines)) for r in targets).items())), + "rank_bounds_in_array_units": { + "other_side_source_count": len(outside), + "other_side_source_transfer_upper_bound": len(drops), + "all_source_transfer_upper_bound": len(inside) + len(drops), + "identity_required": len(inside) + len(outside), + "sharpness_claimed": False, + }, + "direct_read_gate": { + "source_slots": len(xs), "target_slots": len(ys), + "slot_pairs": len(xs) * len(ys), "common_chart_pairs": direct_count, + "timing_constraints_used": False, + }, + } + + +def controls(witness): + _, _, _, transports, _, _ = frame_trace(witness) + drops, lines, span = geometry(transports) + rejected = [] + + def reject(name, call): + try: + call() + except ValueError: + rejected.append(name) + else: + raise ValueError("negative control did not reject: " + name) + + full = basis([1 << i for i in range(9)]) + outsider = next(x for x in range(1, 512) if not contains(span, x)) + lower = basis([outsider]) + upper = basis([outsider, lines[0], lines[1]]) + require(not target_side(lower, lines, span) and target_side(upper, lines, span), + "actual new-interval crossing counterexample") + reject("new_upward_route_crosses_cut", lambda: upward_case(lower, upper, lines, span)) + reject("zero_to_full_can_cross_back_and_forth", lambda: upward_case((), full, lines, span)) + reject("nonnested_replacement", lambda: upward_case(lower, basis(lines[:2]), lines, span)) + reject("dependent_survivors", lambda: basis(lines[:-1] + lines[:1])) + reject("ninth_descending_occurrence", lambda: geometry(transports + [drops[0]])) + changed = list(transports) + where = next(i for i, row in enumerate(changed) if row == drops[0]) + i, reg, _, line, _ = changed[where] + changed[where] = (i, reg, full, line, 8) + reject("unretained_full_to_line_drop", lambda: geometry(changed)) + require(not target_side(full, lines, span), "full chart is on other side") + require(all(not target_side(row[2], lines, span) for row in drops), "gather hyperplanes on other side") + require(all(target_side(basis([a]), lines, span) for a in lines), "survivor lines on target side") + inside_non_survivor = next(x for x in elements(span) if x and x not in lines) + require(target_side(basis([inside_non_survivor]), lines, span), "inside-span sources cannot be counted as outside") + same = (lower, lower, 1, 1) + require(common_chart(same, same), "direct-read positive control") + require(common_chart(((), upper, 1, 2), (lower, upper, 1, 2)), "strict-refinement positive control") + require(not common_chart((lower, lower, 1, 1), (basis([lines[0]]), basis([lines[0]]), 1, 1)), + "equal dimensions do not mean equal subspaces") + # An equivalent presentation must not change the certificate. + alternate = json.loads(json.dumps(witness)) + + def rebase(v): + values = list(reversed(v)) + if len(values) > 1: + values[0] ^= values[1] + return values + + for group in ("initial_frames", "final_frames"): + alternate[group] = {r: rebase(v) for r, v in alternate[group].items()} + for event in alternate["program"]: + if event[0] == "transport": + event[2], event[3] = rebase(event[2]), rebase(event[3]) + else: + event[-1] = rebase(event[-1]) + require(analyze(alternate) == analyze(witness), "basis-presentation invariance") + return rejected + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path, help="write computed receipt exclusively; otherwise compare RESULT.json") + args = parser.parse_args() + raw = (ROOT / SOURCE).read_bytes() + require(hashlib.sha256(raw).hexdigest() == SHA256, "source SHA256") + witness = json.loads(raw) + result = analyze(witness) + checks = controls(witness) + if args.out: + with args.out.open("x", encoding="utf-8", newline="\n") as handle: + handle.write(json.dumps(result, indent=2) + "\n") + else: + require(result == json.loads((PACKAGE / "RESULT.json").read_text(encoding="utf-8")), "exact receipt") + print(PASS + ": 56-array total upper bound; 8 from 56 outside sources; 529984 direct-read pairs reject") + print("Controls: " + ", ".join(checks) + "; basis presentation and positive/counter-controls pass") + + +if __name__ == "__main__": + main()