diff --git a/research/f7-18point-avtail-seed010d26fa/ANCHOR-REPRO.json b/research/f7-18point-avtail-seed010d26fa/ANCHOR-REPRO.json new file mode 100644 index 0000000000..2e97e6abf4 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/ANCHOR-REPRO.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "recorded_utc": "2026-10-16", + "purpose": "Anchor reproduction BEFORE any new number (assignment mandate), with the receipt-validation trap handled: every walk started from EMPTY receipts and two shards were re-walked from deleted receipts to prove recomputation.", + "fresh_receipts_evidence": "The package directory was created empty for this run. run_avtail.py printed 'fresh receipts confirmed (class71: no receipt file existed)' at the first walk; class82/class60 shard receipt files AVTAIL-C82-*.json / AVTAIL-C60-*.json did not exist before their launches (no SKIP lines appeared in the first launch of either mode; every shard printed RECEIPT with complete=true).", + "anchors": [ + { + "anchor": "PR 2870 OBSTRUCTION", + "expected": "parseval=696 allowed=504 deficit=192", + "observed": "parseval=696 allowed=504 deficit=192", + "command": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py quick", + "status": "REPRODUCED", + "route": "vendored PR 2911 engine cover18.squeeze_numbers(7, 11, 6)" + }, + { + "anchor": "PR 2933 CLASSIFY lines", + "expected": "class table incl. 2 lines value=32 need=32 TIGHT; L7 m=3 cases=6720", + "observed": "two TIGHT lines printed: (10,8) A_vanish (7,1) 32=32 and (10,8) D_vanish (8,2) 32=32; cases=6720 ok=true", + "command": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py quick", + "status": "REPRODUCED", + "route": "vendored PR 2933 engine vanish.class_table / vanish.check_tight_equality" + }, + { + "anchor": "PR 2911 ROWS18", + "expected": "808/501/251/196", + "observed": "rows=808 (12,6); 501 (11,7); 251 (10,8); 196 (9,9); 17-point controls (5,1),(6,0) remainder and (10,7) empty", + "command": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py rows", + "status": "REPRODUCED", + "route": "vendored PR 2911 engine cover18.sharp_rows_fast / surviving_rows_fast" + }, + { + "anchor": "PR 2911 NOVANISH", + "expected": "(12,6),(10,8) infeasible: vanishing forced", + "observed": "feasible=False for both splits", + "command": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py novanish", + "status": "REPRODUCED", + "route": "vendored PR 2911 engine cover18.fourier_profile_feasibility" + }, + { + "anchor": "PR 2961 FOURIER (7,1)", + "expected": "need=175 lower=239 contradiction=True", + "observed": "need=175 lower=239 contradiction=True", + "command": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py quick", + "status": "REPRODUCED", + "route": "vendored PR 2961 engine tight.fourier_71_identity" + }, + { + "anchor": "PR 2961 CLASS71", + "expected": "normalized_pairs=0", + "observed": "normalized_pairs=0 covering_pairs=0 (fresh empty-receipt walk, wall=12.3s)", + "command": "python3 -I -B run_avtail.py class71 --shards 1", + "status": "RE-WALKED FROM EMPTY RECEIPTS", + "route": "vendored PR 2961 engine tight.class71_run" + }, + { + "anchor": "PR 2961 CLASS82", + "expected": "checked=28815360 covering=0", + "observed": "checked=28815360 covering=0 fail_hist {('I','II','III'): 28815360}; normalized_sidon_pairs_total=4287920 non_1_invariant_pairs=4175360 (fresh empty-receipt walk, 8/8 shards complete)", + "command": "python3 -I -B run_avtail.py class82 --shards 8 [--shard k] (8 parallel processes) then run_avtail.py merge class82 --shards 8", + "status": "RE-WALKED FROM EMPTY RECEIPTS", + "route": "vendored PR 2961 engine tight.class82_run" + }, + { + "anchor": "PR 2961 CLASS60", + "expected": "d_checked=169911 d_with_transversals=0", + "observed": "d_checked=169911 d_with_transversals=0 transversals_total=0 covering_triples=0 (fresh empty-receipt walk, 8/8 shards complete)", + "command": "python3 -I -B run_avtail.py class60 --shards 8 [--shard k] (8 parallel processes) then run_avtail.py merge class60 --shards 8", + "status": "RE-WALKED FROM EMPTY RECEIPTS", + "route": "vendored PR 2961 engine tight.class60_run" + } + ], + "receipt_validation_correction": { + "trap": "A resumed walk against a committed receipt silently passes; replaying validate-only receipts proves nothing (recorded by PR 2961 and by the shared agent-tools notes).", + "proof_of_recomputation": "Spot re-walks: AVTAIL-C60-0.json and AVTAIL-C82-2.json were moved aside (backup-AVTAIL-*-*.json in scratch), the shards were re-run from absent receipts (RECEIPT lines printed; all other shards SKIPped), and the fresh receipts were compared to the originals SEMANTICALLY with the timing fields seconds/wall_seconds excluded (receipt byte hashes are not run-stable).", + "result": "SPOT_REWALK AVTAIL-C60-0.json semantic_equal=True (new_wall=89.54 vs old_wall=163.08); SPOT_REWALK AVTAIL-C82-2.json semantic_equal=True (new_wall=55.8 vs old_wall=102.62); SPOT_REWALK_ALL_EQUAL=True", + "command": "python3 -I -B /cmp_receipts.py (scratch helper: strip timing fields, compare sorted JSON)" + }, + "environment": { + "python": "CPython 3.12 (C:/Users/warha/.local/bin/python3.12.exe), -I -B", + "arithmetic": "exact Python integers only; no floats anywhere in the engines", + "sharding": "deterministic index sharding; per-shard receipt files written only by their own shard process; merge is idempotent" + } +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-0.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-0.json new file mode 100644 index 0000000000..2e220cb6ee --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-0.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4645.42, + "shard": 0, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190356354, + "uv_pairs_by_sumset_size": { + "27": 89972352, + "28": 98012502, + "29": 1897200, + "30": 474300 + }, + "w_candidates": 0, + "wall_seconds": 4645.42, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-1.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-1.json new file mode 100644 index 0000000000..5b4ebe296f --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-1.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4508.18, + "shard": 1, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190478961, + "uv_pairs_by_sumset_size": { + "27": 90040896, + "28": 98084115, + "29": 1883160, + "30": 470790 + }, + "w_candidates": 0, + "wall_seconds": 4508.18, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-10.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-10.json new file mode 100644 index 0000000000..7e139f3b22 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-10.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4551.63, + "shard": 10, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190560123, + "uv_pairs_by_sumset_size": { + "27": 89876160, + "28": 98316513, + "29": 1893960, + "30": 473490 + }, + "w_candidates": 0, + "wall_seconds": 4551.63, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-11.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-11.json new file mode 100644 index 0000000000..ea0b3ba350 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-11.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4455.08, + "shard": 11, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190068822, + "uv_pairs_by_sumset_size": { + "27": 89951616, + "28": 97743906, + "29": 1898640, + "30": 474660 + }, + "w_candidates": 0, + "wall_seconds": 4455.08, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-12.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-12.json new file mode 100644 index 0000000000..56e70aafca --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-12.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4676.76, + "shard": 12, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190153215, + "uv_pairs_by_sumset_size": { + "27": 90157248, + "28": 97668117, + "29": 1862280, + "30": 465570 + }, + "w_candidates": 0, + "wall_seconds": 4676.76, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-13.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-13.json new file mode 100644 index 0000000000..04361ccf1a --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-13.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4629.69, + "shard": 13, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190436211, + "uv_pairs_by_sumset_size": { + "27": 89947584, + "28": 98140977, + "29": 1878120, + "30": 469530 + }, + "w_candidates": 0, + "wall_seconds": 4629.69, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-14.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-14.json new file mode 100644 index 0000000000..257c8477ae --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-14.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4587.41, + "shard": 14, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190954575, + "uv_pairs_by_sumset_size": { + "27": 90224064, + "28": 98418861, + "29": 1849320, + "30": 462330 + }, + "w_candidates": 0, + "wall_seconds": 4587.41, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-15.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-15.json new file mode 100644 index 0000000000..b21e30c16a --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-15.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4365.18, + "shard": 15, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190474929, + "uv_pairs_by_sumset_size": { + "27": 90089280, + "28": 98062299, + "29": 1858680, + "30": 464670 + }, + "w_candidates": 0, + "wall_seconds": 4365.18, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-2.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-2.json new file mode 100644 index 0000000000..58c378c513 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-2.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4598.77, + "shard": 2, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 191129193, + "uv_pairs_by_sumset_size": { + "27": 90043200, + "28": 98741043, + "29": 1875960, + "30": 468990 + }, + "w_candidates": 0, + "wall_seconds": 4598.77, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-3.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-3.json new file mode 100644 index 0000000000..e9c9cb6e67 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-3.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4601.16, + "shard": 3, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190254960, + "uv_pairs_by_sumset_size": { + "27": 90104832, + "28": 97795728, + "29": 1883520, + "30": 470880 + }, + "w_candidates": 0, + "wall_seconds": 4601.16, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-4.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-4.json new file mode 100644 index 0000000000..753ca395b6 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-4.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4593.83, + "shard": 4, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190650924, + "uv_pairs_by_sumset_size": { + "27": 89837568, + "28": 98444556, + "29": 1895040, + "30": 473760 + }, + "w_candidates": 0, + "wall_seconds": 4593.83, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-5.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-5.json new file mode 100644 index 0000000000..8f2ee9c9e4 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-5.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4690.63, + "shard": 5, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 191156004, + "uv_pairs_by_sumset_size": { + "27": 89943552, + "28": 98868852, + "29": 1874880, + "30": 468720 + }, + "w_candidates": 0, + "wall_seconds": 4690.63, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-6.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-6.json new file mode 100644 index 0000000000..2a7ca04631 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-6.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4394.13, + "shard": 6, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190230975, + "uv_pairs_by_sumset_size": { + "27": 89714880, + "28": 98188245, + "29": 1862280, + "30": 465570 + }, + "w_candidates": 0, + "wall_seconds": 4394.13, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-7.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-7.json new file mode 100644 index 0000000000..06100b8c4c --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-7.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4534.52, + "shard": 7, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 191198439, + "uv_pairs_by_sumset_size": { + "27": 89991360, + "28": 98879229, + "29": 1862280, + "30": 465570 + }, + "w_candidates": 0, + "wall_seconds": 4534.52, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-8.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-8.json new file mode 100644 index 0000000000..68872db382 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-8.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4470.35, + "shard": 8, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190742625, + "uv_pairs_by_sumset_size": { + "27": 90045504, + "28": 98361171, + "29": 1868760, + "30": 467190 + }, + "w_candidates": 0, + "wall_seconds": 4470.35, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-9.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-9.json new file mode 100644 index 0000000000..8a8ecd2c99 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-AV51-9.json @@ -0,0 +1,21 @@ +{ + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4619.45, + "shard": 9, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190646010, + "uv_pairs_by_sumset_size": { + "27": 89967744, + "28": 98360766, + "29": 1854000, + "30": 463500 + }, + "w_candidates": 0, + "wall_seconds": 4619.45, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-0.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-0.json new file mode 100644 index 0000000000..80e18b3f78 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-0.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 89.54, + "shard": 0, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 89.54, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-1.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-1.json new file mode 100644 index 0000000000..ace9f73864 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-1.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.32, + "shard": 1, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.32, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-2.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-2.json new file mode 100644 index 0000000000..6a13c85d97 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-2.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.3, + "shard": 2, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.3, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-3.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-3.json new file mode 100644 index 0000000000..fa29b0784c --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-3.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.03, + "shard": 3, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.03, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-4.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-4.json new file mode 100644 index 0000000000..8c153d2ba7 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-4.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 162.89, + "shard": 4, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 162.89, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-5.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-5.json new file mode 100644 index 0000000000..63626459da --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-5.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.08, + "shard": 5, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.08, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-6.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-6.json new file mode 100644 index 0000000000..4e5e40cc44 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-6.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.84, + "shard": 6, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.84, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-7.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-7.json new file mode 100644 index 0000000000..90afdeb7dc --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C60-7.json @@ -0,0 +1,15 @@ +{ + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21238, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 159.69, + "shard": 7, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 159.69, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C71-0.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C71-0.json new file mode 100644 index 0000000000..8f85903d4e --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C71-0.json @@ -0,0 +1,12 @@ +{ + "checked": 0, + "complete": true, + "covering_configs_normalized": 0, + "covering_pairs": 0, + "equality_configs_normalized": 0, + "fail_hist": {}, + "normalized_pairs": 0, + "seconds": 12.29, + "wall_seconds": 12.29, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-0.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-0.json new file mode 100644 index 0000000000..df3115107a --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-0.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 4355072, + "budget_hit": false, + "checked": 4355072, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 4355072 + }, + "non_1_invariant_pairs": 518978, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 116.29, + "shard": 0, + "shards": 8, + "wall_seconds": 116.37, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-1.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-1.json new file mode 100644 index 0000000000..a306eb0961 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-1.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 3901440, + "budget_hit": false, + "checked": 3901440, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3901440 + }, + "non_1_invariant_pairs": 520750, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 111.03, + "shard": 1, + "shards": 8, + "wall_seconds": 111.1, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-2.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-2.json new file mode 100644 index 0000000000..ab072ac588 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-2.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 2946048, + "budget_hit": false, + "checked": 2946048, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 2946048 + }, + "non_1_invariant_pairs": 524482, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 55.75, + "shard": 2, + "shards": 8, + "wall_seconds": 55.8, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-3.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-3.json new file mode 100644 index 0000000000..c0577dfcc6 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-3.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 3179520, + "budget_hit": false, + "checked": 3179520, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3179520 + }, + "non_1_invariant_pairs": 523570, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 103.67, + "shard": 3, + "shards": 8, + "wall_seconds": 103.74, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-4.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-4.json new file mode 100644 index 0000000000..fd936af816 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-4.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 4368384, + "budget_hit": false, + "checked": 4368384, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 4368384 + }, + "non_1_invariant_pairs": 518926, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 115.57, + "shard": 4, + "shards": 8, + "wall_seconds": 115.66, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-5.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-5.json new file mode 100644 index 0000000000..50c0813e87 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-5.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 3892224, + "budget_hit": false, + "checked": 3892224, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3892224 + }, + "non_1_invariant_pairs": 520786, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 110.71, + "shard": 5, + "shards": 8, + "wall_seconds": 110.78, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-6.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-6.json new file mode 100644 index 0000000000..3ab1803e62 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-6.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 2967552, + "budget_hit": false, + "checked": 2967552, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 2967552 + }, + "non_1_invariant_pairs": 524398, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 102.18, + "shard": 6, + "shards": 8, + "wall_seconds": 102.27, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-7.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-7.json new file mode 100644 index 0000000000..0dac952666 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-C82-7.json @@ -0,0 +1,18 @@ +{ + "admissible_choice_sets": 3205120, + "budget_hit": false, + "checked": 3205120, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3205120 + }, + "non_1_invariant_pairs": 523470, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 105.77, + "shard": 7, + "shards": 8, + "wall_seconds": 105.86, + "witnesses": [] +} diff --git a/research/f7-18point-avtail-seed010d26fa/AVTAIL-PROGRESS.json b/research/f7-18point-avtail-seed010d26fa/AVTAIL-PROGRESS.json new file mode 100644 index 0000000000..4147fb0cac --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/AVTAIL-PROGRESS.json @@ -0,0 +1,688 @@ +{ + "modes": { + "av51": { + "complete": true, + "shards": { + "0": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4645.42, + "shard": 0, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190356354, + "uv_pairs_by_sumset_size": { + "27": 89972352, + "28": 98012502, + "29": 1897200, + "30": 474300 + }, + "w_candidates": 0, + "wall_seconds": 4645.42, + "witnesses": [] + }, + "1": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4508.18, + "shard": 1, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190478961, + "uv_pairs_by_sumset_size": { + "27": 90040896, + "28": 98084115, + "29": 1883160, + "30": 470790 + }, + "w_candidates": 0, + "wall_seconds": 4508.18, + "witnesses": [] + }, + "10": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4551.63, + "shard": 10, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190560123, + "uv_pairs_by_sumset_size": { + "27": 89876160, + "28": 98316513, + "29": 1893960, + "30": 473490 + }, + "w_candidates": 0, + "wall_seconds": 4551.63, + "witnesses": [] + }, + "11": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4455.08, + "shard": 11, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190068822, + "uv_pairs_by_sumset_size": { + "27": 89951616, + "28": 97743906, + "29": 1898640, + "30": 474660 + }, + "w_candidates": 0, + "wall_seconds": 4455.08, + "witnesses": [] + }, + "12": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4676.76, + "shard": 12, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190153215, + "uv_pairs_by_sumset_size": { + "27": 90157248, + "28": 97668117, + "29": 1862280, + "30": 465570 + }, + "w_candidates": 0, + "wall_seconds": 4676.76, + "witnesses": [] + }, + "13": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4629.69, + "shard": 13, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190436211, + "uv_pairs_by_sumset_size": { + "27": 89947584, + "28": 98140977, + "29": 1878120, + "30": 469530 + }, + "w_candidates": 0, + "wall_seconds": 4629.69, + "witnesses": [] + }, + "14": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4587.41, + "shard": 14, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190954575, + "uv_pairs_by_sumset_size": { + "27": 90224064, + "28": 98418861, + "29": 1849320, + "30": 462330 + }, + "w_candidates": 0, + "wall_seconds": 4587.41, + "witnesses": [] + }, + "15": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4365.18, + "shard": 15, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190474929, + "uv_pairs_by_sumset_size": { + "27": 90089280, + "28": 98062299, + "29": 1858680, + "30": 464670 + }, + "w_candidates": 0, + "wall_seconds": 4365.18, + "witnesses": [] + }, + "2": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4598.77, + "shard": 2, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 191129193, + "uv_pairs_by_sumset_size": { + "27": 90043200, + "28": 98741043, + "29": 1875960, + "30": 468990 + }, + "w_candidates": 0, + "wall_seconds": 4598.77, + "witnesses": [] + }, + "3": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4601.16, + "shard": 3, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190254960, + "uv_pairs_by_sumset_size": { + "27": 90104832, + "28": 97795728, + "29": 1883520, + "30": 470880 + }, + "w_candidates": 0, + "wall_seconds": 4601.16, + "witnesses": [] + }, + "4": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4593.83, + "shard": 4, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190650924, + "uv_pairs_by_sumset_size": { + "27": 89837568, + "28": 98444556, + "29": 1895040, + "30": 473760 + }, + "w_candidates": 0, + "wall_seconds": 4593.83, + "witnesses": [] + }, + "5": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4690.63, + "shard": 5, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 191156004, + "uv_pairs_by_sumset_size": { + "27": 89943552, + "28": 98868852, + "29": 1874880, + "30": 468720 + }, + "w_candidates": 0, + "wall_seconds": 4690.63, + "witnesses": [] + }, + "6": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4394.13, + "shard": 6, + "shards": 16, + "u_checked": 10620, + "uv_pairs": 190230975, + "uv_pairs_by_sumset_size": { + "27": 89714880, + "28": 98188245, + "29": 1862280, + "30": 465570 + }, + "w_candidates": 0, + "wall_seconds": 4394.13, + "witnesses": [] + }, + "7": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4534.52, + "shard": 7, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 191198439, + "uv_pairs_by_sumset_size": { + "27": 89991360, + "28": 98879229, + "29": 1862280, + "30": 465570 + }, + "w_candidates": 0, + "wall_seconds": 4534.52, + "witnesses": [] + }, + "8": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4470.35, + "shard": 8, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190742625, + "uv_pairs_by_sumset_size": { + "27": 90045504, + "28": 98361171, + "29": 1868760, + "30": 467190 + }, + "w_candidates": 0, + "wall_seconds": 4470.35, + "witnesses": [] + }, + "9": { + "budget_hit": false, + "complete": true, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "seconds": 4619.45, + "shard": 9, + "shards": 16, + "u_checked": 10619, + "uv_pairs": 190646010, + "uv_pairs_by_sumset_size": { + "27": 89967744, + "28": 98360766, + "29": 1854000, + "30": 463500 + }, + "w_candidates": 0, + "wall_seconds": 4619.45, + "witnesses": [] + } + }, + "shards_count": 16, + "total": { + "budget_hit": 0, + "complete": 16, + "covering_configs": 0, + "fail_hist": {}, + "normalized_u_total": 169911, + "u_checked": 169911, + "uv_pairs": 3049492320, + "uv_pairs_by_sumset_size": { + "27": 1439907840, + "28": 1572086880, + "29": 29998080, + "30": 7499520 + }, + "w_candidates": 0 + } + }, + "class60": { + "complete": true, + "shards": { + "0": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 89.54, + "shard": 0, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 89.54, + "witnesses": [] + }, + "1": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.32, + "shard": 1, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.32, + "witnesses": [] + }, + "2": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.3, + "shard": 2, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.3, + "witnesses": [] + }, + "3": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.03, + "shard": 3, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.03, + "witnesses": [] + }, + "4": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 162.89, + "shard": 4, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 162.89, + "witnesses": [] + }, + "5": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.08, + "shard": 5, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.08, + "witnesses": [] + }, + "6": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21239, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 161.84, + "shard": 6, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 161.84, + "witnesses": [] + }, + "7": { + "budget_hit": false, + "complete": true, + "covering_triples": 0, + "d_checked": 21238, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "seconds": 159.69, + "shard": 7, + "shards": 8, + "tested_triples": 0, + "transversals_total": 0, + "wall_seconds": 159.69, + "witnesses": [] + } + }, + "shards_count": 8, + "total": { + "budget_hit": 0, + "complete": 8, + "covering_triples": 0, + "d_checked": 169911, + "d_with_transversals": 0, + "normalized_d_total": 169911, + "tested_triples": 0, + "transversals_total": 0 + } + }, + "class71": { + "complete": true, + "shards": { + "0": { + "checked": 0, + "complete": true, + "covering_configs_normalized": 0, + "covering_pairs": 0, + "equality_configs_normalized": 0, + "fail_hist": {}, + "normalized_pairs": 0, + "seconds": 12.29, + "wall_seconds": 12.29, + "witnesses": [] + } + }, + "shards_count": 1, + "total": { + "checked": 0, + "complete": 1, + "covering_configs_normalized": 0, + "covering_pairs": 0, + "equality_configs_normalized": 0, + "fail_hist": {}, + "normalized_pairs": 0 + } + }, + "class82": { + "complete": true, + "shards": { + "0": { + "admissible_choice_sets": 4355072, + "budget_hit": false, + "checked": 4355072, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 4355072 + }, + "non_1_invariant_pairs": 518978, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 116.29, + "shard": 0, + "shards": 8, + "wall_seconds": 116.37, + "witnesses": [] + }, + "1": { + "admissible_choice_sets": 3901440, + "budget_hit": false, + "checked": 3901440, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3901440 + }, + "non_1_invariant_pairs": 520750, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 111.03, + "shard": 1, + "shards": 8, + "wall_seconds": 111.1, + "witnesses": [] + }, + "2": { + "admissible_choice_sets": 2946048, + "budget_hit": false, + "checked": 2946048, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 2946048 + }, + "non_1_invariant_pairs": 524482, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 55.75, + "shard": 2, + "shards": 8, + "wall_seconds": 55.8, + "witnesses": [] + }, + "3": { + "admissible_choice_sets": 3179520, + "budget_hit": false, + "checked": 3179520, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3179520 + }, + "non_1_invariant_pairs": 523570, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 103.67, + "shard": 3, + "shards": 8, + "wall_seconds": 103.74, + "witnesses": [] + }, + "4": { + "admissible_choice_sets": 4368384, + "budget_hit": false, + "checked": 4368384, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 4368384 + }, + "non_1_invariant_pairs": 518926, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 115.57, + "shard": 4, + "shards": 8, + "wall_seconds": 115.66, + "witnesses": [] + }, + "5": { + "admissible_choice_sets": 3892224, + "budget_hit": false, + "checked": 3892224, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3892224 + }, + "non_1_invariant_pairs": 520786, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 110.71, + "shard": 5, + "shards": 8, + "wall_seconds": 110.78, + "witnesses": [] + }, + "6": { + "admissible_choice_sets": 2967552, + "budget_hit": false, + "checked": 2967552, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 2967552 + }, + "non_1_invariant_pairs": 524398, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 102.18, + "shard": 6, + "shards": 8, + "wall_seconds": 102.27, + "witnesses": [] + }, + "7": { + "admissible_choice_sets": 3205120, + "budget_hit": false, + "checked": 3205120, + "complete": true, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 3205120 + }, + "non_1_invariant_pairs": 523470, + "normalized_sidon_pairs": 535990, + "normalized_sidon_pairs_total": 4287920, + "seconds": 105.77, + "shard": 7, + "shards": 8, + "wall_seconds": 105.86, + "witnesses": [] + } + }, + "shards_count": 8, + "total": { + "admissible_choice_sets": 28815360, + "budget_hit": 0, + "checked": 28815360, + "complete": 8, + "covering_configs": 0, + "fail_hist": { + "('I', 'II', 'III')": 28815360 + }, + "non_1_invariant_pairs": 4175360, + "normalized_sidon_pairs": 4287920, + "normalized_sidon_pairs_total": 4287920 + } + } + } +} diff --git a/research/f7-18point-avtail-seed010d26fa/CERTIFICATE.json b/research/f7-18point-avtail-seed010d26fa/CERTIFICATE.json new file mode 100644 index 0000000000..80fd695ba2 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/CERTIFICATE.json @@ -0,0 +1,89 @@ +{ + "ai_assistance": "Substantial AI assistance from opencode in scoping, implementation, verification and writing (no model named); no independent human review claimed.", + "arithmetic": "exact Python integers only; no floats anywhere in the engines (masks are Python ints; all counts exact)", + "author": "Aaron Wang", + "base_commit": "1c1de259ec4313da3a3279fd84a748bcee2d2d25", + "demoted": [ + { + "label": "NOT DECIDED - scoped limitation", + "statement": "No claim is made about (4,2)/(3,3) realizability: their complete walks exceed this session's budget and were not run. The recorded reductions and budgets are necessary conditions and exact search domains, not exclusions." + } + ], + "expected_markers": [ + "Ran 10 tests ... OK", + "PASS_AVTAIL_QUICK", + "PASS_AVTAIL_NOVANISH", + "PASS_AVTAIL_ROWS", + "PASS_AVTAIL_ANCHORS", + "PASS_AVTAIL_M4", + "PASS_AVTAIL_AV51" + ], + "labels": [ + { + "evidence": "Exact reduction to triples (U, V 6-sets, W 5-set) of F2^5 (lines (a)-(d); machine-checked line equivalence with the four L3 lines on 400 random configurations and per-slice engine cross-checks) and a complete walk over all 169,911 normalized U and all 3,049,492,320 normalized (U, V) pairs (0 in U, 0 in V, |U+V| >= 27): w_candidates=0 - no 5-set W containing M = F2^5 \\ (U+V) satisfies lines (a) and (b) simultaneously - so covering_configs=0. Pair counts by |U+V|: 27 -> 1,439,907,840; 28 -> 1,572,086,880; 29 -> 29,998,080; 30 -> 7,499,520. 16/16 shards complete (AVTAIL receipts AVTAIL-AV51-*.json, explicit complete/budget_hit flags).", + "label": "PROVEN", + "reproduce": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py av51", + "statement": "Class (12,6) A-vanish (5,1) of the 18-point cover question for F2^7 is empty: no covering pair (A, D) exists in the class, so no 18-point cover of F2^7 has split (12,6) with a vanishing character and D-half split (5,1)." + }, + { + "evidence": "test_engine.py: reduction line-equivalence on 400 random (A0, A1, D0, D1) configurations with backward round trip; residual-symmetry invariance on 300 random triples; WLOG normalization round trips on 200 random triples.", + "label": "PROVEN", + "reproduce": "python3 -I -B research/f7-18point-avtail-seed010d26fa/test_engine.py", + "statement": "Reduction and normalization correctness for the (5,1) class: absorbing the singleton D1 = {d1} via the half-translations U = A0+d1, V = A1+d1, W = D0+d1 preserves the four L3 lines exactly, and every solution maps bijectively to one with 0 in U and 0 in V (residual symmetries U -> U+a, W -> W+a, V -> V+b)." + }, + { + "evidence": "solve_w equals brute force over all C(32,5) = 201,376 5-sets on 14 pairs including the largest-sumset pairs of a sampled scan; pair_backtrack equals brute force over all 169,911 normalized V at needs 24 and 27 on 4 sampled U; optimized-vs-reference equality on 3 full U slices in the suite and on 30 randomized slices in the recorded spot recheck (all_equal=True, 79 s).", + "label": "CHECKED", + "reproduce": "python3 -I -B research/f7-18point-avtail-seed010d26fa/test_engine.py", + "statement": "Search-engine completeness and soundness on the smallest instances: the per-pair W search and the pair enumeration equal complete brute force, and the optimized decision engine equals the independent reference engine per U slice." + }, + { + "evidence": "m=4 A=(1,1) D=(7,1): direct=512=machinery; m=4 A=(2,2) D=(6,1): 11,648; m=4 A=(2,2) D=(5,1): 0 (floor-surviving, empty); m=3 grid: 14 classes with agreement; mutant_drop_a/mutant_drop_d differ from the full counts where lines are load-bearing.", + "label": "CHECKED", + "reproduce": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py m4", + "statement": "Small-space analogue controls: on 22 m=3/m=4 classes with the singleton-D1 shape of class (5,1), the reduction machinery and the direct A,D coverage census agree exactly, cover-bearing classes are found by both routes, and semantic failure controls (line mutants) change census counts." + }, + { + "evidence": "PR 2870 OBSTRUCTION 696/504/192; PR 2911 ROWS18 808/501/251/196 and NOVANISH (12,6)/(10,8) infeasible; PR 2933 CLASSIFY lines incl. both 32=32 TIGHT cases and L7 m=3 cases=6720; PR 2961 FOURIER (7,1) need=175 lower=239, CLASS82 checked=28,815,360 covering=0, CLASS60 d_checked=169,911 d_with_transversals=0 (fresh empty-receipt walks, 8/8 shards each). Spot re-walks of AVTAIL receipts AVTAIL-C60-0 and AVTAIL-C82-2 from deleted receipts are semantically identical excluding timing fields (ANCHOR-REPRO.json).", + "label": "CHECKED", + "reproduce": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py quick; verify.py rows; verify.py novanish; verify.py anchors", + "statement": "Every recorded anchor of the predecessor chain is reproduced before any new number, and the two heavy anchors are re-walked from empty receipts with recomputation proved by spot re-walks." + }, + { + "evidence": "(4,2): D1 = {d1, d1+delta} normalizes to {0, 1} (delta = 1 under GL(5,2), d1 absorbed by half-translations); reduced lines (a')-(d') with |U+W| >= 20, |V+W| >= 20, |U+V| >= 24. (3,3): the four L3 lines apply directly to (A0, A1 6-sets, D0, D1 3-sets) with 0 in A0, 0 in A1 (or 0 in D0, 0 in D1) WLOG; all line budgets slack (IV: 36+9 >= 32; I/II: 36 >= 32); no forced Sidon structure (the (6,0) rigidity A0+A1 = F2^5 does not extend).", + "label": "PROVEN", + "reproduce": "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py quick (CLASSIFY lines)", + "statement": "Exact classification of the remaining (12,6) A-vanish classes (4,2) and (3,3) to walkable reduced forms with exact necessary budgets (not decided here)." + } + ], + "not_checked": [ + "anything word-level: the corrected L=20 word census (PR 2973, Nicholas Stone - its corrected budgets found a false-prune defect in the PR 2542/2634/2691 word engines and exclude L=20) and the L=22 versus L=24 question are word-level work, untouched here; PR 2973's scope note records bit 0 as valid in set-level searches and the set-level chain PR 2773-2961 as unaffected", + "the 19-point cover question, walk-realizability of any cover, and any kappa, supplier, tariff or selected-frontier implication", + "the (12,6) D-vanish classes (9,3)/(8,4)/(7,5)/(6,6) and the (10,8) surviving classes (6,2)/(5,3)/(4,4)/(7,3)/(6,4)/(5,5) (PR 2961's remaining open question 1 for (10,8) is out of scope here)", + "the (11,7)/(9,9) identity pivot (PR 2961's open question 2; not taken - one bounded pivot maximum, and (a) consumed the budget)" + ], + "outcome": "partial", + "package": "research/f7-18point-avtail-seed010d26fa", + "reproduce": [ + "python3 -I -B research/f7-18point-avtail-seed010d26fa/test_engine.py", + "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py quick", + "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py novanish", + "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py rows", + "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py anchors", + "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py m4", + "python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py av51" + ], + "schema_version": 1, + "search_state": { + "18_point_cover_constructed": false, + "gap": "At base commit: 20 <= f(7) <= 24 (pinned record). Concurrent post-base word-level correction PR 2973 (Nicholas Stone, merged; title 'Correct word-census parity budgets; 22 <= f(7) <= 24 in the PR943 model'), corroborated by PR 3005 (Nick Petalas), records 22 <= f(7) <= 24 and scopes the set-level chain PR 2773-2961 as unaffected; under that record this package's question is the deciding necessary condition for f(7) = 22.", + "recorded_search_best": "k=18 max 118/128 (40 restarts), k=19 max 124/128 (200 restarts), 20-point covers exist (research/universal-f7-singleton-l20-seed06704c39, PR 2634 record as quoted by PR 2961); unchanged here - no construction search was run in this session" + }, + "title": "KB3h: (12,6) A-vanish (5,1) of the 18-point cover question for F2^7 PROVEN impossible; (4,2)/(3,3) reduced to exact walkable forms", + "walk_receipts": { + "av51": "AVTAIL-AV51-0..15.json (16 shards, all complete=true, budget_hit=false; first launch at budget 3000 recorded complete=false/budget_hit=true on all 16 shards and was re-walked from scratch at budget 6000; totals u_checked=169911 uv_pairs=3049492320 w_candidates=0 covering_configs=0)", + "class60_anchor": "AVTAIL-C60-0..7.json (8 shards complete; d_checked=169911 d_with_transversals=0)", + "class71_anchor": "AVTAIL receipts: AVTAIL-C71-0.json (normalized_pairs=0)", + "class82_anchor": "AVTAIL-C82-0..7.json (8 shards complete; checked=28815360 covering=0)" + } +} diff --git a/research/f7-18point-avtail-seed010d26fa/NOTICE.md b/research/f7-18point-avtail-seed010d26fa/NOTICE.md new file mode 100644 index 0000000000..1a9365bf23 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/NOTICE.md @@ -0,0 +1,46 @@ +# NOTICE - vendored engines and attribution + +All vendored files under `vendor/` are byte-exact copies, extracted with the +shared toolkit (`agent_tools.py pr-tree-extract`) from PR 2961's package +`research/f7-18point-tight-classes-seed4c1e7b30` at head +`df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd` (the head verified stable at +extraction and again before submission). They are read and executed as +vendored copies only; nothing is imported from a predecessor's tree at +runtime. Byte pins are enforced by `verify.py check_pins`. + +| File | sha256 | Origin | Credit | +|---|---|---|---| +| vendor/tight.py | 14670ef2d3df9e4ecc9e1db962f4e8cb77545d1c889144352760c1fd14e2273b | PR 2961 (own engine) | Aaron Wang (navinor) | +| vendor/cover18.py | 24c6a2f4911dc2d5de76972eb5ae93dc4e66d8fa1e904443de6d0638e70c0a04 | PR 2911 | Aaron Wang (navinor) | +| vendor/vanish.py | 6c605c54074f725321c5d770d538a652bf7727598a128270831f92fe7b9746d9 | PR 2933 | Aaron Wang (navinor) | +| vendor/agent64_cover17.py | 082bc838134cba9754368cff894d53c729467a689b4cafee8374423688d93654 | PR 2773 | Aaron Wang (navinor) | +| vendor/agent64_search17.py | 9eb1bf79ffb99b0efcdaf57916c493bc781abd4a0096d584dc6bc6ca294bf674 | PR 2773 | Aaron Wang (navinor) | +| vendor/anchors.py | 73d73a9b94539403448d7ff8c914c03711907f75c019c4ccb6843b32c259e8e7 | PR 2870 | Aaron Wang (navinor) | + +Model and record credit (read and reproduced, never re-derived): + +- PR 943 (Ross Richardson, RossRichardson): the prefix-walk model and the + `P + P = F2^n` covering condition. +- PR 1185 (Doug Colkitt, Mister-Meeseeks): the pinned `f(5) = 12`, + `f(6) = 16` record and frozen tier `EXPECTED.json`. +- PR 2542 / 2634 / 2773 / 2870 / 2911 / 2933 / 2961 (Aaron Wang, navinor): the + complete 17-point exclusion chain, the KB3b search ceilings (118/128 at + k = 18, 124/128 at k = 19) and the existence of 20-point covers, the + pair-representation rows, the odd-coverage Fourier/Parseval identity, the + (A, D) reduction and vanishing-character restriction, the vanishing class + classification with floors 41/44/45 for the classes decided/classified here, + and the tight-class decisions whose open question 1 this package executes. +- PR 2691 (Nicholas Stone, NicholasStone, Kimi agent): the completed (10,10) + simple-20-cycle word census (recorded state only). +- PR 2973 (Nicholas Stone, NicholasStone): the corrected word-census parity + budgets (its corrected weight-parity census found a false-prune defect in the + PR 2542/2634/2691 word engines and excludes L=20, recording + `22 <= f(7) <= 24`) and its explicit scoping of the set-level chain + PR 2773-2961 as unaffected; corroborated by PR 3005 (Nick Petalas, + petalas, independent union-support implementation). All word-level work, + untouched here. + +This package is contributed by Aaron Wang with help from opencode (substantial +AI assistance; no model named; no independent human review claimed). Same +repository/source licenses apply; all retained lineage keeps its original +attribution. diff --git a/research/f7-18point-avtail-seed010d26fa/README.md b/research/f7-18point-avtail-seed010d26fa/README.md new file mode 100644 index 0000000000..cb4a992f05 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/README.md @@ -0,0 +1,243 @@ +# KB3h - the (12,6) A-vanish tail classes of the 18-point cover question for F2^7 + +**Set-level finite result, no words enumerated. Outcome=partial: class (5,1) is +PROVEN impossible by a complete exact walk; classes (4,2) and (3,3) are reduced +to exact walkable forms with exact necessary budgets but are NOT decided. No +18-point cover of `F2^7` is constructed and no split is excluded outright. No +new kappa.** The pinned record at this package's base commit carries the gap +`20 <= f(7) <= 24`; the concurrent word-level correction +([PR 2973](https://github.com/CrocSwap/integer-mult-bounds/pull/2973), +Nicholas Stone, corroborated by +[PR 3005](https://github.com/CrocSwap/integer-mult-bounds/pull/3005)) moved the +recorded gap to `22 <= f(7) <= 24` after this base commit and explicitly scopes +the set-level chain PR 2773-2961 (and hence this package) as unaffected. With +`f(7) >= 22` the 18-point question is now exactly the deciding necessary +condition for `f(7) = 22`: at `L = 22` every universal word needs at least 18 +distinct prefixes and their set must cover. + +## Object and chain of record + +In the PR943 prefix-walk model +([Ross Richardson, `research/universal-connector-boundary`](https://github.com/CrocSwap/integer-mult-bounds/pull/943)) +a restored seven-source singleton word is universal exactly when its prefix set +`P` covers: `P + P = F2^7`. The 17-point question is closed +([PR 2542](https://github.com/CrocSwap/integer-mult-bounds/pull/2542), +[PR 2634](https://github.com/CrocSwap/integer-mult-bounds/pull/2634), +[PR 2773](https://github.com/CrocSwap/integer-mult-bounds/pull/2773), +[PR 2870](https://github.com/CrocSwap/integer-mult-bounds/pull/2870), +all Aaron Wang). [PR 2911](https://github.com/CrocSwap/integer-mult-bounds/pull/2911) +(Aaron Wang) narrowed the 18-point question to the splits `(12,6)`, `(11,7)`, +`(10,8)`, `(9,9)` and proved that any `(12,6)` or `(10,8)` cover must have a +vanishing character off the all-ones hyperplane. With `D = p + B` inside +`E = F2^6` (PR 2911's reduction) the pair `(A, D)` covers iff `A + D = E` and +`(A+A) union (D+D) = E`; fixing the vanishing character `psi = bit 0` (WLOG +under `GL(6,2)`), both halves `H = ker(psi)` and `H'` identify with `F2^5` and +coverage is the four PR 2933 L3 lines + +```text +(I) (A0+D0) u (A1+D1) = F2^5 +(II) (A0+D1) u (A1+D0) = F2^5 +(III) (A0+A0) u (A1+A1) u (D0+D0) u (D1+D1) = F2^5 +(IV) (A0+A1) u (D0+D1) = F2^5 +``` + +([PR 2933](https://github.com/CrocSwap/integer-mult-bounds/pull/2933), Aaron +Wang: L2 halving, L3 half-decomposition, L4 class floors, L7 Sidon pinning). +[PR 2961](https://github.com/CrocSwap/integer-mult-bounds/pull/2961) (Aaron +Wang) decided the three tightest classes - (10,8) A-vanish (7,1), (10,8) +D-vanish (8,2), (12,6) A-vanish (6,0) - and recorded the remainder this package +takes (its open question 1): the surviving non-tight (12,6) A-vanish classes +`(5,1)`, `(4,2)`, `(3,3)` (D-half splits; PR 2933 recorded their floors +`a0*a1 + d0*d1 = 36 + x*y` as 41, 44, 45 against need 32). + +Every cited PR author was verified against current ground truth at writing with +`gh pr view NNN --json author,title`: PR 2542/2634/2773/2870/2911/2933/2961 are +Aaron Wang (navinor); PR 2691 and PR 2973 are Nicholas Stone (NicholasStone). +PR 2973 is the concurrent word-level correction: the L=20 census budgets were +derived for Hamming-weight parity but applied to bit-0 state groups (a +false-prune defect, with the `n=4, L=8` word `01021323` as counterexample to +the prune), and its corrected weight-parity census excludes `L = 20` entirely, +giving `22 <= f(7) <= 24` (corroborated by the independent union-support +implementation [PR 3005](https://github.com/CrocSwap/integer-mult-bounds/pull/3005), +Nick Petalas). PR 2973's own scope note records that bit 0 remains valid in +set-level searches using actual group sizes and that the set-level chain +PR 2773-2961 is scoped separately - this package is set-level only, enumerates +no words, and is unaffected by that correction. + +## Verdict per class (exact integers) + +| Split | Class | PR 2933 floor | Verdict here | Deciding evidence | +|---|---|---|---|---| +| (12,6) | A-vanish (5,1) | 41 >= 32 survives | PROVEN impossible | complete walk: 0 W candidates over 3,049,492,320 normalized pairs | +| (12,6) | A-vanish (4,2) | 44 >= 32 survives | classified, NOT decided | exact reduction to W 4-sets with D1 = 0,1, budgets 20/20/24 | +| (12,6) | A-vanish (3,3) | 45 >= 32 survives | classified, NOT decided | four L3 lines direct, all budgets slack, no forced structure | + +Mirrors are identical by odd translation. The D-vanish classes of (12,6) +`(9,3)`, `(8,4)`, `(7,5)`, `(6,6)` and every surviving (10,8) class are out of +scope here (PR 2961's remaining open question 1 for (10,8) untouched). + +## The (5,1) decision + +### Exact reduction + +`D1 = {d1}` is a singleton, so the two half-translations `U = A0+d1`, +`V = A1+d1`, `W = D0+d1` absorb it (each translation preserves all four L3 +lines being all of `F2^5`; machine-checked on random configurations). The class +is EXACTLY the triples `(U, V 6-sets, W 5-set)` of `F2^5` satisfying + +```text +(a) V u (U+W) = F2^5 +(b) U u (V+W) = F2^5 +(c) (U+V) u W = F2^5 +(d) (U+U) u (V+V) u (W+W) u {0} = F2^5 +``` + +with the inverse `(A0, A1, D0, D1) = (U, V, W, 0)`. The residual symmetries +`U -> U+a, W -> W+a, V -> V+b` (independent half-translations) give WLOG +`0 in U` and `0 in V` - every solution maps bijectively to a normalized one. + +### Complete walk and the exact obstruction + +Line (c) forces `M = F2^5 \ (U+V)` into `W`, so `|M| <= 5` and `|U+V| >= 27`. +The walk enumerates every normalized `U` (all `C(31,5) = 169,911`) and, per `U`, +every normalized `V` with `0 in V` and `|U+V| >= 27` by a monotone excess-budget +backtracking; per pair it derives `W` candidates (`W` must contain `M` and hit +the requirement translates of (a) and (b)) and tests the survivors exactly. + +| Quantity | Value | +|---|---| +| normalized U walked (0 in U) | 169,911 | +| normalized pairs (U, V) walked (0 in V, |U+V| >= 27) | 3,049,492,320 | +| pairs with |U+V| = 27 | 1,439,907,840 | +| pairs with |U+V| = 28 | 1,572,086,880 | +| pairs with |U+V| = 29 | 29,998,080 | +| pairs with |U+V| = 30 | 7,499,520 | +| W candidates passing (a) and (b) and (c) | 0 | +| covering configurations | 0 | + +The exact obstruction is recorded as it occurs: for EVERY normalized pair, no +5-set `W` containing `M` satisfies lines (a) and (b) simultaneously +(`w_candidates = 0` over the whole walk), so the class is unsatisfiable before +line (d) is ever relevant. By the reduction's bijectivity this proves: + +**PROVEN - no covering (A, D) exists in class (12,6) A-vanish (5,1); an +18-point cover of `F2^7` cannot have that class.** + +The walk is 16 shards with per-shard receipts (`AVTAIL-AV51-0..15.json`), all +`complete=true` / `budget_hit=false`; the first launch hit its 3,000 s +per-shard budget with explicit `complete=false` on all 16 shards +(partial-as-complete avoided) and was re-walked from scratch at budget 6,000 s +(4,365-4,691 s per shard). + +### Why a false empty cannot hide here + +The engines were validated on the smallest instances where the answer is known +by complete brute force before the `m = 5` walk: + +- `solve_w` (the per-pair W search) equals brute force over all + `C(32,5) = 201,376` 5-sets on 14 pairs including the largest-sumset pairs of + a sampled scan; `pair_backtrack` equals brute force over all 169,911 + normalized `V` at needs 24 and 27 on sampled `U`. +- The optimized decision engine equals the independent reference engine + (`pair_backtrack + solve_w + lines51`) on full `U` slices in the test suite + and on 30 randomized slices in the recorded spot recheck (all equal). +- The m=3/m=4 analogue control censuses (22 classes with the singleton-D1 + shape) agree exactly between the reduction machinery and direct `A + D = E` + coverage tests, including cover-bearing positive controls (m=4 A=(1,1) + D=(7,1): 512 covers by both routes; m=4 A=(2,2) D=(6,1): 11,648) next to + floor-surviving EMPTY controls (m=4 A=(2,2) D=(5,1): 0 covers), and semantic + failure controls: dropping line (a) or line (d) changes the census counts. + +## Anchors reproduced before any new number + +| Anchor | Expected | Status here | +|---|---|---| +| PR 2870 OBSTRUCTION | parseval=696 allowed=504 deficit=192 | recomputed fresh | +| PR 2911 ROWS18 | 808/501/251/196 | recomputed fresh | +| PR 2911 NOVANISH | (12,6),(10,8) infeasible | recomputed fresh | +| PR 2933 CLASSIFY | 2 lines value=32 need=32 TIGHT, cases=6720 | recomputed fresh | +| PR 2961 FOURIER (7,1) | need=175 lower=239 | recomputed fresh | +| PR 2961 CLASS82 | checked=28,815,360 covering=0 | re-walked from empty receipts | +| PR 2961 CLASS60 | d_checked=169,911 d_with_transversals=0 | re-walked from empty receipts | + +Receipt-validation trap handled: the anchor walks started from missing receipt +files (`fresh receipts confirmed` printed), and two shards (CLASS60 shard 0, +CLASS82 shard 2) were re-walked from deleted receipts and compared to their +originals semantically with timing fields excluded - identical +(`ANCHOR-REPRO.json`). + +## (4,2) and (3,3): exact classification, not decided + +- **(4,2).** `D1 = {d1, d1+delta}` normalizes to `{0, 1}` (`delta = 1` under + `GL(5,2)`, `d1` absorbed as in (5,1)). The class is EXACTLY the triples + `(U, V 6-sets, W 4-set)` with `(U+W) u (V+0,1) = F2^5`, + `(U+0,1) u (V+W) = F2^5`, `(U+V) u (W+0,1) = F2^5` and the selfsum line. + Exact necessary budgets: `|U+W| >= 20`, `|V+W| >= 20` (excess at most 4 over + 24 pairs each), `|U+V| >= 24`. The complete walk is strictly larger than + (5,1)'s - line (c) only forces `M` into `W union (W+1)` - and was not run in + budget. Not decided. +- **(3,3).** No singleton absorption exists. The four L3 lines apply directly + to `(A0, A1 6-sets, D0, D1 3-sets)` with `0 in A0, 0 in A1` (or + `0 in D0, 0 in D1`) WLOG; every line budget is slack (line (IV): 36+9 against + 32; lines (I)/(II): 36 against 32) and no forced Sidon structure exists - + the (6,0) rigidity `A0+A1 = F2^5` does not extend. Not decided. + +## Reproduce + +Standard library only, CPython 3.12, from the repository root: + +```sh +python3 -I -B research/f7-18point-avtail-seed010d26fa/test_engine.py +python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py quick +python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py novanish +python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py rows +python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py anchors +python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py m4 +python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py av51 +``` + +Expected markers: `Ran 10 tests ... OK`, `PASS_AVTAIL_QUICK`, +`PASS_AVTAIL_NOVANISH`, `PASS_AVTAIL_ROWS`, `PASS_AVTAIL_ANCHORS`, +`PASS_AVTAIL_M4`, `PASS_AVTAIL_AV51`. The walks themselves are resumable with +per-shard receipts (`run_avtail.py class71|class82|class60|av51`, then +`run_avtail.py merge `; explicit `complete`/`budget_hit` flags, one +progress section per mode). Registered replay: +`python3 scripts/research_package.py --package research/f7-18point-avtail-seed010d26fa --check-only` +passes `PASS_PACKAGE_METADATA_AND_PINS`. + +## Scope and limitations + +Set-level only inside PR943's abstract interface. Not checked: anything +word-level (the corrected L=20 word census and the `L = 22` versus `L = 24` +question are Nicholas Stone's and the community's word-level work, PR +2973/PR 3005; untouched here), the 19-point cover question, walk-realizability +of any cover, and any kappa, supplier, tariff or selected-frontier implication. +(4,2)/(3,3) are not decided and no claim is made about them; their recorded +reductions and budgets are necessary conditions and exact search domains, not +exclusions. The (12,6) D-vanish classes and every surviving (10,8) class are +out of scope. No construction search was run; the recorded set-level search +ceilings stay `118/128` at `k = 18` and `124/128` at `k = 19` (PR 2634's +record as quoted by PR 2961). The word-level gap recorded at this package's +base commit is `20 <= f(7) <= 24`; the concurrent correction PR 2973 +(corroborated by PR 3005) records `22 <= f(7) <= 24`, under which this +package's question is the deciding necessary condition for `f(7) = 22`. + +## Open next questions + +1. **Decide (12,6) A-vanish (4,2).** The exact reduced form (W 4-sets with + `D1 = 0,1`) with budgets `|U+W| >= 20`, `|V+W| >= 20`, `|U+V| >= 24` is a + complete finite walk; extend the (5,1) walk and shard over the normalized U + with receipts. Why it matters: clearing (4,2) forces any (12,6) A-vanish + cover into (3,3). Blocked by: nothing structural; a few hours of sharded + walk. +2. **Decide or identify (12,6) A-vanish (3,3).** Either the direct normalized + walk on `(A0, A1, D0, D1)` with the four L3 lines, or a cross-line + multiplicity identity coupling (I)/(II) with (III)/(IV). Why it matters: + (3,3) is the last A-vanish class after (4,2). Blocked by: all four line + budgets are slack and no forced structure exists. +3. **Find the (11,7)/(9,9) coupling identity** (PR 2961's open question 2, + untouched here): derive the even-half coverage identity + `(A+A) u (D+D) = E` multiplicities for the 501/196 surviving rows and check + it against every odd-odd-split cover of `F2^5` (a complete census exists in + PR 2933's engine) before lifting to `m = 6`. Why it matters: those splits + carry the other half of the 18-point question. diff --git a/research/f7-18point-avtail-seed010d26fa/SOURCES.json b/research/f7-18point-avtail-seed010d26fa/SOURCES.json new file mode 100644 index 0000000000..edeb38ed89 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/SOURCES.json @@ -0,0 +1,148 @@ +{ + "base_commit": "1c1de259ec4313da3a3279fd84a748bcee2d2d25", + "files": [ + { + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "path": "docs/research/agent-task-catalog.json", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6", + "usage": "provenance" + }, + { + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "path": "certificates/selected-result.json", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "usage": "provenance" + }, + { + "git_blob": "160a96c50f77ba411af957b554da05a8470e70ca", + "path": "research/universal-connector-six-source/EXPECTED.json", + "sha256": "f1b1bec330640c81ac0da25ee8b3a0a49fe9ea5bb2eadaaa787c64bd62c9e73a", + "usage": "provenance" + } + ], + "notes": { + "concurrent_scopes": "Nicholas Stone (NicholasStone) holds the repeated-state L=20 word census claim (discussion 1166 comment 18954844), splits (10,9)/(10,8)/(9,9)/(10,7) at the WORD level; this package is set-level only and enumerates no words. The pair-collision check at entry and the refined re-run (discussions 1317 and 1166 via agent_tools.py disc-comments --grep including nested replies, plus scripts/find_overlap.py with the object's proper names and synonyms) found no claim on the (12,6) A-vanish tail classes or the (U, V, W) reduction.", + "model_and_pinned_results": "PR943 query model (research/universal-connector-boundary, Ross Richardson); pinned f(5)=12, f(6)=16 and the open gap 20 <= f(7) <= 24 (research/universal-connector-six-source, Doug Colkitt). Read and reproduced byte-exactly, never imported.", + "predecessor_chain": "PR 2542 (Aaron Wang) claimed 'no 17-point set covers F2^7' and excluded length 18; PR 2634 (Aaron Wang) continued KB3b and records the k=18/k=19 search ceilings (118/128, 124/128) and the existence of 20-point covers; PR 2773 (Aaron Wang) audited the claim split-by-split and supplied the Sidon/pair-sum budget enumeration; PR 2870 (Aaron Wang) closed the (5,1),(6,0) rows with the odd-coverage Fourier/Parseval identity (OBSTRUCTION 696/504/192); PR 2911 (Aaron Wang) narrowed the 18-point question to four splits and PROVED the vanishing-character restriction on (12,6)/(10,8); PR 2933 (Aaron Wang) classified the vanishing configurations (L2/L3/L4/L5/L7) and pinned the class floors; PR 2961 (Aaron Wang) decided the tight classes (10,8) (7,1)/(8,2) and (12,6) (6,0) and pressed the (11,7)/(9,9) identity gap. This package executes PR 2961's open question 1 for the (12,6) A-vanish tail: (5,1) PROVEN impossible; (4,2)/(3,3) reduced to exact walkable forms, not decided.", + "question": "KB3h: kill or classify the surviving non-tight (12,6) A-vanish classes (5,1),(4,2),(3,3) of the 18-point cover question for F2^7. Outcome=partial: (5,1) PROVEN impossible (complete walk: 169,911 normalized U, 3,049,492,320 normalized (U,V) pairs, zero W candidates); (4,2)/(3,3) classified to exact reduced forms with budgets, not decided." + }, + "references": [ + { + "head": "df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd", + "local_path": "vendor/tight.py", + "note": "Vendored byte-exact (extracted with agent_tools.py pr-tree-extract from PR 2961's package research/f7-18point-tight-classes-seed4c1e7b30 at head df2eba6c (verified stable at extraction and again before submission), never imported from the predecessor's tree), credit Aaron Wang (navinor), PR 2961: the bitmask primitives, the (7,1) Fourier identity, the rho classification and the class71/class82/class60 decision walks whose anchors are re-walked here from empty receipts. Enforced by byte-pin checks in verify.py.", + "pr": 2961, + "sha256": "14670ef2d3df9e4ecc9e1db962f4e8cb77545d1c889144352760c1fd14e2273b", + "source_path": "research/f7-18point-tight-classes-seed4c1e7b30/tight.py" + }, + { + "head": "df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd", + "local_path": "vendor/cover18.py", + "note": "Vendored byte-exact (via PR 2961's vendor/), credit Aaron Wang (navinor), PR 2911: the exact-arithmetic KB3e engine reproducing the SQUEEZE/NOVANISH premise and the ROWS18 lines (808/501/251/196) in verify.py quick/rows/novanish. Enforced by byte-pin checks.", + "pr": 2911, + "sha256": "24c6a2f4911dc2d5de76972eb5ae93dc4e66d8fa1e904443de6d0638e70c0a04", + "source_path": "research/f7-18point-cover-question-seed6d34356c/cover18.py" + }, + { + "head": "df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd", + "local_path": "vendor/vanish.py", + "note": "Vendored byte-exact (via PR 2961's vendor/), credit Aaron Wang (navinor), PR 2933: the class tables (L2/L4 floors incl. the 32=32 TIGHT lines) and the L7 tight-equality census (m=3 cases=6720) reproduced by verify.py quick. Enforced by byte-pin checks.", + "pr": 2933, + "sha256": "6c605c54074f725321c5d770d538a652bf7727598a128270831f92fe7b9746d9", + "source_path": "research/f7-18point-vanishing-seedfc618722/vanish.py" + }, + { + "head": "df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd", + "local_path": "vendor/agent64_cover17.py", + "note": "Vendored byte-exact (via PR 2961's hash-pinned vendor/, never imported), credit Aaron Wang (navinor), PR 2773. Used by the vendored cover18.py. Enforced by byte-pin checks.", + "pr": 2773, + "sha256": "082bc838134cba9754368cff894d53c729467a689b4cafee8374423688d93654", + "source_path": "research/f7-17point-cover-audit-seedcfa215c2/cover17.py" + }, + { + "head": "df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd", + "local_path": "vendor/agent64_search17.py", + "note": "Vendored byte-exact, credit Aaron Wang (navinor), PR 2773: the Sidon/pair-sum budget enumeration engine (not executed in this package; kept for anchor-walk provenance). Enforced by byte-pin checks.", + "pr": 2773, + "sha256": "9eb1bf79ffb99b0efcdaf57916c493bc781abd4a0096d584dc6bc6ca294bf674", + "source_path": "research/f7-17point-cover-audit-seedcfa215c2/search17.py" + }, + { + "head": "df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd", + "local_path": "vendor/anchors.py", + "note": "Vendored byte-exact (identical bytes in PR 2870's/2911's/2933's/2961's packages), credit Aaron Wang (navinor), PR 2870: the resumable heavy-anchor walk driver (not executed in this package; the PR 2773 heavy anchors are outside this package's anchor list). Enforced by byte-pin checks.", + "pr": 2870, + "sha256": "73d73a9b94539403448d7ff8c914c03711907f75c019c4ccb6843b32c259e8e7", + "source_path": "research/f7-17point-fourier-obstruction-seedb5e318fe/anchors.py" + }, + { + "head": "df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd", + "local_path": null, + "note": "Aaron Wang (navinor): the immediate predecessor. Its open question 1 (decide the surviving non-tight classes) is executed here for the (12,6) A-vanish tail; its tight-class engines are vendored byte-exact and its anchors re-walked from empty receipts.", + "pr": 2961, + "source_path": "research/f7-18point-tight-classes-seed4c1e7b30/" + }, + { + "head": "25ea0e94250444db9ab05c3c8f1a66ba68e737b6", + "local_path": null, + "note": "Aaron Wang (navinor): the L2 halving, L3 half-decomposition, L4 class floors, L5 grid and L7 Sidon pinning; the class (5,1)/(4,2)/(3,3) floor values 41/44/45 recorded there are reproduced here and the (U, V, W) reduction is built on its four L3 lines (read and reproduced, never re-derived as new results).", + "pr": 2933, + "source_path": "research/f7-18point-vanishing-seedfc618722/" + }, + { + "head": "cfb813f883e61519deedcd84151dc0c68b9d19cc", + "local_path": null, + "note": "Aaron Wang (navinor): the (A, D) reduction lemma in E = F2^6, the forced-vanishing premise, and the row remainder 808/501/251/196 reproduced here.", + "pr": 2911, + "source_path": "research/f7-18point-cover-question-seed6d34356c/" + }, + { + "head": "9f55f291e9e79e628fd98f1e4f4debfc1c2106e5", + "local_path": null, + "note": "Aaron Wang (navinor): the odd-coverage Fourier/Parseval identity (OBSTRUCTION 696/504/192) reproduced here.", + "pr": 2870, + "source_path": "research/f7-17point-fourier-obstruction-seedb5e318fe/" + }, + { + "head": "6739c799799621878a9249c93e2b12cc799c1482", + "local_path": null, + "note": "Aaron Wang (navinor): pair-representation rows and the census floors whose engines are vendored here for provenance.", + "pr": 2773, + "source_path": "research/f7-17point-cover-audit-seedcfa215c2/" + }, + { + "head": "e2f30d93efbef5658334072aa855aa95e795e394", + "local_path": null, + "note": "Aaron Wang (navinor): the recorded KB3b search state (k=18 max 118/128, k=19 max 124/128, 20-point covers exist) quoted as the recorded state in this package's CERTIFICATE.", + "pr": 2634, + "source_path": "research/universal-f7-singleton-l20-seed06704c39/" + }, + { + "head": "3b6011d2400f50ab0ad9e105c7c55a18f3cef4cf", + "local_path": null, + "note": "Aaron Wang (navinor): the audited claim 'no 17-point set covers F2^7' and the length-18 exclusion that defines the 18-point question.", + "pr": 2542, + "source_path": "research/universal-f7-singleton-seedb859517b/" + }, + { + "head": "88dda3534071442773106e9c0b941b9d39a3cea8", + "local_path": null, + "note": "Nicholas Stone (NicholasStone, Kimi agent): the completed (10,10) simple-20-cycle word census; recorded state, not re-run here. His concurrent L=20 repeated-state word claim (discussion 1166 comment 18954844) is a different, word-level object.", + "pr": 2691, + "source_path": "research/universal-f7-singleton-l20-census-complete-seedfd938f30/" + }, + { + "local_path": null, + "note": "Ross Richardson (RossRichardson): the PR943 prefix-walk model and the P + P = F2^n covering condition.", + "pr": 943, + "source_path": "research/universal-connector-boundary/" + }, + { + "local_path": null, + "note": "Doug Colkitt (Mister-Meeseeks): the pinned f(5) = 12, f(6) = 16 record and frozen tier EXPECTED.json.", + "pr": 1185, + "source_path": "research/universal-connector-six-source/" + } + ], + "schema_version": 1 +} diff --git a/research/f7-18point-avtail-seed010d26fa/TASK-CARD.md b/research/f7-18point-avtail-seed010d26fa/TASK-CARD.md new file mode 100644 index 0000000000..7621b8b41c --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/TASK-CARD.md @@ -0,0 +1,111 @@ +# Local task card - KB3h (written before substantial computation) + +Task ID / proposed scope key: kappa-blocker KB3h; drawn scope key c191650c0fa8d2fa514e +(independent-moment), refined object key f7-18point-avtail. + +Base commit; exact predecessor and dependency heads: +- Base commit (frozen assignment pin): `1c1de259ec4313da3a3279fd84a748bcee2d2d25` + (= origin/main of CrocSwap/integer-mult-bounds at worktree creation). +- Predecessor heads (verified at writing with `gh pr view NNN --json author,title` + and `--json headRefOid`): PR 2961 head `df2eba6c6c3dcc88b49b3b9a9c9c2e710710d7fd` + (OPEN, not merged), PR 2933 head `25ea0e94250444db9ab05c3c8f1a66ba68e737b6`, + PR 2911 head `cfb813f883e61519deedcd84151dc0c68b9d19cc`, + PR 2870 head `9f55f291e9e79e628fd98f1e4f4debfc1c2106e5`, + PR 2773 head `6739c799799621878a9249c93e2b12cc799c1482`, + PR 2542 head `3b6011d2400f50ab0ad9e105c7c55a18f3cef4cf`, + PR 2634 head `e2f30d93efbef5658334072aa855aa95e795e394`, + PR 2691 head `88dda3534071442773106e9c0b941b9d39a3cea8` (Nicholas Stone). + +Concrete object and question: +The shrinking remainder of the 18-point cover question for F2^7 (PR943 prefix-walk +model: a restored seven-source singleton word is universal exactly when its prefix +set P covers, P + P = F2^7; PR 2911 reduction: with D = p + B inside E = F2^6 the +pair (A, D) covers iff A + D = E and (A+A) u (D+D) = E). PR 2961 PROVEN impossible: +(10,8) A-vanish (7,1), (10,8) D-vanish (8,2), (12,6) A-vanish (6,0); it recorded +the remainder this task takes. Questions, smallest first: +(a) kill or classify (12,6) A-vanish (5,1), (4,2), (3,3) - the classes PR 2933 + recorded at floors 41/44/45 >= 32, where (6,0)'s full-sumset rigidity + (A0+A1 = F2^5) does not extend; +(b) sharpen the (11,7)/(9,9) identity gap (row remainders 501/196; both sides odd, + no vanishing character; PR 2961's sum-rho^2 >= 17/19 conditions do not + contradict) - the bounded pivot, only after (a) is decided or stalls; +(c) opportunistically: any covering 18-set in any surviving split (keeps the + f(7) L = 22 route alive). Honest search limits; a failed search is not an + exclusion. + +Scope status: changed (authorized "explicit open request" scope change, recorded +in TASK.json with this reason). The chooser (OS seed +`010d26faeebc345503e833f0ed63d7bd`, track independent-verification) drew the cards +independent-moment / formal-interface-lemma; neither targets the F2^7 cover +question. The assignment explicitly authorizes taking discussion 1166's open +request instead - the recorded remainder of PR 2961 (KB3g). Pair-collision checks +(entry + refined, discussions 1317 and 1166 via agent_tools.py disc-comments +--grep incl. nested replies) found no claim on this object; Nicholas Stone's +active claim (discussion 1166 comment 18954844) is the f(7) L=20/repeated-state +WORD census and this task stays strictly on the SET level. + +Existing restriction being changed (or exact claim being audited): +Extends PR 2961's decision of the three tightest classes to the surviving +non-tight (12,6) A-vanish classes; audits no prior claim negatively - every +predecessor number is reproduced before new numbers (anchors: PR 2870 OBSTRUCTION +696/504/192, PR 2911 ROWS18 808/501/251/196, PR 2933 CLASSIFY lines incl. the +32=32 TIGHT cases=6720, PR 2961 FOURIER (7,1) need=175 lower=239, CLASS82 +checked=28,815,360 covering=0, CLASS60 d_checked=169,911 d_with_transversals=0). + +Method; explicit parameter ranges/candidate alphabet: +Exact integer arithmetic only (Python int bitmasks over F2^5 = {0..31}; no floats). +Class (5,1): exact reduction to three F2^5 sets (U, V 6-sets, W 5-set, lines +(a) V u (U+W) = F2^5, (b) U u (V+W) = F2^5, (c) (U+V) u W = F2^5, +(d) selfsum(U) u selfsum(V) u selfsum(W) u {0} = F2^5; WLOG 0 in V, 0 in W by +half-translations), then a complete D-side walk over all C(31,4) = 31,465 +normalized W, per W the complete near-transversal family +G(W) = {6-sets U : |U+W| >= 26} (branch-on-uncovered search, PR 2961's +transversals6 extended with slack), and exact pair tests over G(W) x G(W)_0. +Classes (4,2)/(3,3): the right per-class structure (same four L3 lines with +D1 = {0,1} resp. a 3-set), or an exact narrowed classification if the walk does +not close in budget. Positive controls before any m=5 number: the identical +reduction + walk machinery at m=4 against a direct complete census of the +analogue class (702,464 brute-force configurations), and branch-vs-brute +equality of G(W) on sampled m=5 W. Failure controls: line-checker mutants must +change census results (semantic failure control). + +Nearest overlapping PRs and why this adds something: +PR 2961 (Aaron Wang) decided the tight classes and recorded this exact remainder +(its open question 1: "Decide the surviving non-tight classes of (12,6) and +(10,8)"; this task takes the (12,6) half, smallest class first). PR 2933 +(Aaron Wang) classified the vanishing configurations and recorded the class +floors 41/44/45. PR 2911 (Aaron Wang) proved the forced-vanishing premise and +the row remainders. No other open PR works these classes (overlap survey +2026-10-16: 40 matches, all predecessor lineage or the distinct word-level +L=20 work). + +Declared milestone: local module (a scoped set-level decision/classification +inside the PR943 abstract interface; no supplier, tariff or kappa). + +Optimistic full cost budget; required observable improvement: see +TASK.json priced_budget_breakdown. Required observable: each named class +decided (PROVEN impossible / realized / exactly classified) or an exact +obstruction recorded per class. + +Unresolved consumer/restoration costs; family expansion decision if continuing: +None at this level - the set-level question feeds the word-level L=22 route but +walk-realizability of any cover remains separate (and is Nicholas Stone's +word-level object at L = 20). No family expansion; no kappa change. + +Success evidence; falsification test; time/compute cap: +Success = class-by-class verdict with PROVEN/CHECKED labels and exact numbers, +plus reproduced anchors. Falsification of "class (5,1) is empty" = one covering +(U, V, W) configuration (then record it as a witness - an 18-point cover in +class (5,1) would be outcome (c) and would decide the question the other way). +Cap: the priced budget in TASK.json; long walks are blocking foreground chunks +with per-shard receipts (one section per mode), complete/budget_hit flags, and +re-runs from EMPTY receipts to prove recomputation. + +Predecessor authors; intended artifact and reproduction command: +All cited PR authors verified against current ground truth at writing: +PR 2542/2634/2773/2870/2911/2933/2961 Aaron Wang (navinor); PR 2691 Nicholas +Stone (NicholasStone); PR 943 Ross Richardson (prefix-walk model); PR 1185 +Doug Colkitt (pinned f(5)=12, f(6)=16 record). PR 2961's engines (tight.py and +its vendor/) are vendored byte-exact with SHA-256 pins and credited. Intended +artifact: this package, replayed with +`python3 -I -B research/f7-18point-avtail-seed010d26fa/verify.py `. diff --git a/research/f7-18point-avtail-seed010d26fa/TASK.json b/research/f7-18point-avtail-seed010d26fa/TASK.json new file mode 100644 index 0000000000..b8479b483d --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/TASK.json @@ -0,0 +1,108 @@ +{ + "actual_scope": "Kappa-blocker KB3h (explicit open request; set level, no words): kill or classify the surviving non-tight (12,6) A-vanish classes (5,1),(4,2),(3,3) of the 18-point cover question for F2^7 (PR 943 model P + P = F2^7; PR 2911 reduction (A, D) in E = F2^6 with A + D = E and (A+A) u (D+D) = E) - the recorded remainder of PR 2961 (its open question 1), which decides the f(7) L=22 route. Delivered outcome=partial: class (5,1) is PROVEN impossible and (4,2)/(3,3) are reduced to exact walkable forms but not decided. (1) (12,6) A-vanish (5,1): PROVEN impossible. Exact reduction (the singleton D1 = {d1} is absorbed by the two half-translations U = A0+d1, V = A1+d1, W = D0+d1; each preserves all four PR 2933 L3 lines; residual symmetries give WLOG 0 in U, 0 in V) to triples (U, V 6-sets, W 5-set) of F2^5 with (a) V u (U+W) = F2^5, (b) U u (V+W) = F2^5, (c) (U+V) u W = F2^5, (d) (U+U) u (V+V) u (W+W) u {0} = F2^5. Complete walk: all 169,911 normalized U (0 in U) and all 3,049,492,320 normalized pairs (U, V) with 0 in V and |U+V| >= 27 (line (c) forces M = F2^5 \\ (U+V) into W, |M| <= 5; pair counts by |U+V| = 27/28/29/30: 1,439,907,840 / 1,572,086,880 / 29,998,080 / 7,499,520). Exact obstruction: ZERO W candidates satisfy (a)+(b)+(c) for ANY pair (w_candidates=0 over the whole walk), so lines (a) and (b) are jointly unsatisfiable once W must contain M and have size 5; covering_configs=0. The walk engines are validated against complete brute force (pair enumeration and W enumeration equal brute force on sampled slices; the optimized engine equals the independent reference engine on full U slices; m=3/m=4 analogue censuses agree with direct A,D coverage tests on 22 classes including cover-bearing positive controls and empty floor-surviving controls, with semantic failure controls). (2) (12,6) A-vanish (4,2): classified, not decided. D1 = {d1, d1+delta} normalizes to {0, 1} (delta = 1 under GL(5,2), d1 absorbed): triples (U, V 6-sets, W 4-set) with (a') (U+W) u (V+{0,1}) = F2^5, (b') (U+{0,1}) u (V+W) = F2^5, (c') (U+V) u (W+{0,1}) = F2^5, (d') (U+U) u (V+V) u (W+W) u {0,1} = F2^5; exact necessary budgets |U+W| >= 20, |V+W| >= 20 (excess <= 4 over 24 pairs each), |U+V| >= 24. The complete walk is strictly larger than (5,1)'s (line (c') only forces M into W u (W+1)) and was not run in budget. (3) (12,6) A-vanish (3,3): classified, not decided. No singleton absorption exists; the four L3 lines apply directly to (A0, A1 6-sets, D0, D1 3-sets) with 0 in A0, 0 in A1 (or 0 in D0, 0 in D1) WLOG; every line budget is slack (line (IV) 36+9 >= 32, line (I)/(II) 36 >= 32) and no forced Sidon structure exists. No 18-point cover was constructed anywhere and no kappa, supplier or selected-frontier claim is made. The word-level gap recorded at this package's base commit is 20 <= f(7) <= 24; the concurrent word-level correction PR 2973 (Nicholas Stone, merged; corroborated by PR 3005, Nick Petalas) records 22 <= f(7) <= 24 and explicitly scopes the set-level chain PR 2773-2961 (and hence this package) as unaffected; under 22 <= f(7) <= 24 this package's question is the deciding necessary condition for f(7) = 22 (at L = 22 every universal word needs at least 18 distinct prefixes and their set must cover).", + "ai_assistance": "Substantial AI assistance from opencode in scoping, implementation, verification and writing (no model named); no independent human review claimed.", + "author": "Aaron Wang", + "base_commit": "1c1de259ec4313da3a3279fd84a748bcee2d2d25", + "bottleneck_link": "The set-level restricted addition basis value r((C2)^7) decides how small a universal word's prefix set can be inside the unchanged PR943 query model: 17-point covers are excluded (PR 2542/2773/2870) and the 18-point question is narrowed to four splits (PR 2911) with the vanishing classes pressed (PR 2933) and the tight classes decided (PR 2961). This package removes the smallest surviving non-tight class (12,6) A-vanish (5,1) outright and reduces (4,2)/(3,3) to exact walkable forms, feeding the word-level L=22 route its per-split feasibility. It changes no supplier, tariff or kappa and instantiates no physical interface.", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18976193", + "de_diagnostic": "Not applicable: a finite set-level question in the PR943 query model, with no supplier width m, role count W, child ranks or recursive moment to price. The applicable diagnostic is exact reproduction against the pinned predecessor numbers plus complete exact-integer enumerations with brute-force-validated search engines.", + "evidence": "CERTIFICATE.json labels every statement PROVEN / CHECKED / DEMOTED with its exact numbers. avtail.py holds the exact-arithmetic engine (generic m-bit mask primitives, the (U, V, W) reduction with machine-checked line equivalence, the complete pair backtrack with monotone excess budget, the complete per-pair W search, the optimized decision walk with precomputed XOR tables and staged filters, and the m=3/m=4 analogue control censuses). test_engine.py holds 10 tests: primitives vs naive sets, reduced lines vs naive lines, reduction line-equivalence on 400 random configurations, residual-symmetry invariance, WLOG normalization round trips, solve_w vs complete brute force over all C(32,5) 5-sets, pair_backtrack vs complete brute force over all 169,911 normalized V at needs 24 and 27, optimized-vs-reference agreement on full U slices, and the analogue control agreement with semantic failure controls (line mutants change census counts; at least one cover-bearing class). The walk receipts (AVTAIL-AV51-*.json, 16/16 shards complete, explicit complete/budget_hit flags) record u_checked=169,911, uv_pairs=3,049,492,320, w_candidates=0, covering_configs=0; the first launch hit its 3000 s per-shard budget with complete=false on all 16 shards (partial-as-complete avoided) and was re-walked from scratch at budget 6000; a 30-slice spot recheck recomputed each slice with both the optimized and the reference engine (all_equal=True). Vendored byte pins (verify.py check_pins): vendor/tight.py 14670ef2..., vendor/cover18.py 24c6a2f4..., vendor/vanish.py 6c605c54..., vendor/agent64_cover17.py 082bc838..., vendor/agent64_search17.py 9eb1bf79..., vendor/anchors.py 73d73a9b.... All mandated anchors reproduced before any new number (ANCHOR-REPRO.json): PR 2870 OBSTRUCTION 696/504/192; PR 2911 ROWS18 808/501/251/196 and NOVANISH; PR 2933 CLASSIFY lines incl. the 32=32 TIGHT cases=6720; PR 2961 FOURIER (7,1) need=175 lower=239, CLASS82 checked=28,815,360 covering=0 and CLASS60 d_checked=169,911 d_with_transversals=0 (both re-walked from empty receipts, 8/8 shards each, with two spot re-walks proving recomputation). No kappa claim.", + "object_synonyms_used_in_overlap": [ + "18-point", + "18point", + "18-set", + "A-vanish", + "vanishing character", + "transversal", + "near-transversal", + "P+P cover", + "P + P", + "F2^7", + "cover of F2^7", + "cross-sum", + "rho", + "A0+A1", + "universal word", + "L=22", + "f(7)" + ], + "open_questions": [ + { + "blocked_by": "Nothing structural; the walk is strictly larger than (5,1)'s (2.8e9 pairs at need 27 become more at need 24, and W candidates are looser) - a bounded sharded walk of a few hours.", + "first_step": "Extend the (5,1) walk to W 4-sets and D1 = {0,1}: enumerate normalized pairs (U, V) with |U+V| >= 24 and per pair the W candidates with M = F2^5 \\ (U+V) contained in W u (W+1), testing the four reduced lines exactly; shard over the normalized U with receipts as in run_avtail.py av51.", + "question": "Does the (12,6) A-vanish class (4,2) admit a covering (U, V, W) triple in the exact reduced form ((U+W) u (V+{0,1}), (U+{0,1}) u (V+W), (U+V) u (W+{0,1}), selfsums)?", + "why_it_matters": "(4,2) is the next surviving (12,6) class after (5,1)'s exclusion; clearing it would halve the (12,6) remainder and force any (12,6) cover into (3,3)." + }, + { + "blocked_by": "No forced structure: all four line budgets are slack at (3,3); the direct configuration space (C(31,5)^2 x C(31,2)^2) needs a new reduction or a much larger walk.", + "first_step": "Set up the exact normalized enumeration for (A0, A1 6-sets, D0, D1 3-sets) with 0 in A0, 0 in A1 and complete the four-line test per configuration via a D-side walk analogous to (5,1)'s, or derive a cross-line multiplicity identity coupling (I)/(II) with (III)/(IV).", + "question": "Is the (12,6) A-vanish class (3,3) realizable, and does any coupling of the four slack L3 lines exclude it?", + "why_it_matters": "(3,3) is the most symmetric surviving (12,6) class and the last A-vanish class after (4,2); excluding all three A-vanish tail classes would leave (12,6) covers dependent on D-vanish (9,3)/(8,4)/(7,5)/(6,6) only." + }, + { + "blocked_by": "No known coupling identity between odd-line cross-sum multiplicities and even-line self-sums (PR 2961 recorded the same blocker).", + "first_step": "Derive the even-half coverage identity ((A+A) u (D+D) = E multiplicities) for the 501/196 surviving rows and check it against every odd-odd-split cover of F2^5 (a complete census exists in PR 2933's engine) before lifting to m=6.", + "question": "What identity couples odd-line cross-sum multiplicities to even-line selfsums at (11,7)/(9,9), where no character can vanish and sum rho^2 >= 17/19 does not contradict?", + "why_it_matters": "Those two splits carry the other half of the 18-point question (row remainders 501/196); the m=5 census fact that covers exist only in even splits (2,8)/(4,6)/(6,4)/(8,2) suggests an even-half obstruction that has not been lifted to m=6." + } + ], + "original_card": { + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "first_experiment": "List the existing independent checks for the exact selected or candidate sources. Pick a new changed input, missing binding or distinct failure mode; stop with a handoff if the proposed arithmetic check is already covered.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Record the selected certificate and complex_profile rather than taking a PR headline as input.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "id": "independent-moment", + "methods": [ + "Reconstruct the rank ledger from original operations rather than trusting its aggregate.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure" + ], + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification." + ], + "starting_points": [ + "certificates/selected-result.json" + ] + }, + "outcome": "partial", + "pair_collision_check": { + "checked_utc": "2026-10-16T14:37Z-15:00Z (entry, before computation), 2026-10-16T14:57Z (refined re-run with the object's proper names and synonyms, before heavy computation)", + "result": "No claim on the (12,6) A-vanish tail classes (5,1)/(4,2)/(3,3) or the (U, V, W) reduction at any check. Discussion 1317 is silent on this object (bit-mechanism word-model claims only; last comment 2026-10-15 before this session, plus two word-level union-support posts at 16:41Z/17:01Z). Discussion 1166's 18-point posts in the checked window are the predecessor lineage (KB3c/KB3d/KB3e/KB3f/KB3g, all released; KB3g = PR 2961 is this package's direct predecessor, released 2026-10-16 14:25Z and since merged). Nicholas Stone's claim (discussion 1166 comment 18954844) is the f(7) L=20/repeated-state WORD census and was re-checked at entry. Submission-time re-check (2026-10-16 18:35Z): that word-level line produced PR 2973 (merged: corrected word-census parity budgets, 22 <= f(7) <= 24) and its independent corroboration PR 3005 (Nick Petalas, open) - both word-level, and PR 2973's own scope note records bit 0 as valid in set-level searches and the set-level chain PR 2773-2961 as unaffected; no claim on this package's object. This package stays strictly on the SET level and enumerates no words.", + "threads_scanned": [ + "discussion 1317 full scan with grep CLAIM|FINDING|HANDOFF|DONE|RELEASED since 2026-10-15T12:00Z incl. nested replies; nothing on this object", + "discussion 1166 with grep CLAIM|FINDING|HANDOFF|DONE|RELEASED since 2026-10-15T12:00Z incl. nested replies (498 comment blocks scanned)", + "scripts/find_overlap.py with explicit terms 18-point / vanishing character / A-vanish / transversal / P+P cover / F2^7 / cross-sum / L=22 and the refined re-run with A-vanish / vanishing character / transversal / A0+A1 / 18point / near-transversal / cover of F2^7 / L=22 (2026-10-16 14:38Z and 14:58Z; 40 resp. 18 matches, all predecessor lineage or the distinct word-level L=20 work)" + ], + "tool": "agent_tools.py disc-comments --grep (with nested replies) + scripts/find_overlap.py with explicit object terms and synonyms" + }, + "priced_budget_breakdown": "25 min entry orientation, pair-collision checks, overlap surveys and the task card; 35 min predecessor extraction (PR 2961 package pr-tree-extract to scratch, hash pins, author verification) and the cheap anchor reproductions (OBSTRUCTION/CLASSIFY/FOURIER/ROWS18/NOVANISH/CLASS71); 45 min engine construction and validation (reduction, pair backtrack, W search, m=3/m=4 analogue controls, 10 tests incl. brute-force equality and optimized-vs-reference cross-checks); 30 min anchor re-walks from empty receipts (CLASS82 8 shards, CLASS60 8 shards, spot re-walks); 120 min the (5,1) decision walk (two launches: 16 shards budget 3000 with explicit budget_hit partials, then 16 shards budget 6000 complete at 4,365-4,691 s per shard, plus the 30-slice spot recheck); 60 min package metadata, registration, gates, PR and board posts.", + "priced_budget_minutes": 315, + "priority_revision": 5, + "schema_version": 1, + "scope_change_reason": "Authorized 'explicit open request' scope change, recorded as instructed by the assignment. The chooser (OS seed 010d26faeebc345503e833f0ed63d7bd, track independent-verification) drew the cards independent-moment / formal-interface-lemma (independent verification of the selected moment/enclosure and a formal interface lemma; neither targets the F2^7 cover question). The assignment (kappa-blocker KB3h) explicitly authorizes taking discussion 1166's open request instead - the recorded remainder of PR 2961 (its open question 1): kill or classify the surviving non-tight (12,6) A-vanish classes (5,1),(4,2),(3,3). Pair-collision checks (entry 2026-10-16 14:37-15:00 UTC and the refined re-run, discussions 1317 and 1166 via agent_tools.py disc-comments --grep including nested replies, plus scripts/find_overlap.py with the object's proper names and synonyms) found no claim on this object; Nicholas Stone's active claim (discussion 1166 comment 18954844) is the f(7) L=20/repeated-state WORD census and this task stays strictly on the SET level.", + "scope_key": "c191650c0fa8d2fa514e (drawn card); refined object key f7-18point-avtail", + "scope_status": "changed", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "session_seed": "010d26faeebc345503e833f0ed63d7bd", + "smallest_falsifying_instance_first": "The falsifying instance for 'class (5,1) is empty' is one covering (U, V, W) triple; the machinery was validated on the smallest cover-bearing instances before the m=5 walk: primitives vs naive sets, the reduction equivalence vs direct L3 line tests on 400 random configurations, solve_w and pair_backtrack equal to complete brute force on sampled slices, and the m=3/m=4 analogue censuses where covers exist (e.g. m=4 A=(1,1) D=(7,1): 512 covers found by both routes) next to floor-surviving empty controls (e.g. m=4 A=(2,2) D=(5,1): 0 covers) - so an empty result at m=5 is distinguishable from broken machinery. Before any new number the recorded anchors were reproduced (ANCHOR-REPRO.json), including CLASS82 and CLASS60 re-walked in full from empty receipts. The first (5,1) launch recorded explicit budget_hit/complete=false receipts (partial-as-complete avoided) and was re-walked from scratch; a 30-slice spot recheck recomputed with two independent engines.", + "stop_rule": "Stop at the first of: (a) a covering configuration found in class (5,1) (an 18-point cover, outcome (c)), (b) class (5,1) decided plus an exact classification of (4,2)/(3,3), or (c) the priced budget expiring with each class's exact obstruction recorded. Outcome (b) reached for (5,1) (PROVEN impossible); (4,2)/(3,3) recorded as exact reductions with budgets, not decided (the complete walks exceed the remaining budget - recorded honestly, no second pivot taken).", + "task_id": "independent-moment", + "track": "independent-verification (drawn); scope changed to the assigned explicit open request kappa-blocker KB3h: the shrinking remainder of the 18-point cover question for F2^7 (PR 2961 open question 1: the surviving non-tight (12,6) A-vanish classes (5,1),(4,2),(3,3))" +} diff --git a/research/f7-18point-avtail-seed010d26fa/VERIFY.json b/research/f7-18point-avtail-seed010d26fa/VERIFY.json new file mode 100644 index 0000000000..711739d29c --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/VERIFY.json @@ -0,0 +1,97 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "research/f7-18point-avtail-seed010d26fa/test_engine.py" + ], + "checks": "10 engine tests: primitives vs naive sets; reduced lines vs naive lines; reduction line-equivalence on 400 random configurations; residual-symmetry and WLOG-normalization invariance; solve_w vs complete brute force over all C(32,5) 5-sets; pair_backtrack vs complete brute force over all 169,911 normalized V at needs 24 and 27; optimized-vs-reference agreement on full U slices; m=3/m=4 analogue control agreement with semantic failure controls.", + "timeout_seconds": 300 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/f7-18point-avtail-seed010d26fa/verify.py", + "quick" + ], + "checks": "Byte pins of the six vendored engines; the PR 2961 FOURIER anchor (need=175 lower=239); the rho classification numbers; the PR 2933 CLASSIFY lines incl. both 32=32 TIGHT cases and L7 m=3 cases=6720; the PR 2870 OBSTRUCTION anchor (696/504/192).", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/f7-18point-avtail-seed010d26fa/verify.py", + "novanish" + ], + "checks": "The PR 2911 NOVANISH premise from the vendored engine: every (12,6) or (10,8) cover has a vanishing character off the all-ones hyperplane.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/f7-18point-avtail-seed010d26fa/verify.py", + "rows" + ], + "checks": "The PR 2911 ROWS18 anchor (808/501/251/196) and the 17-point row controls ((11,6) remainder (5,1),(6,0); (10,7) empty).", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/f7-18point-avtail-seed010d26fa/verify.py", + "anchors" + ], + "checks": "Receipt validation of this package's own fresh empty-receipt anchor re-walks: CLASS71 (0 pairs), CLASS82 (checked=28,815,360 covering=0), CLASS60 (d_checked=169,911 d_with_transversals=0). The walks themselves run via run_avtail.py class71/class82/class60 and are not part of this bounded replay.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/f7-18point-avtail-seed010d26fa/verify.py", + "m4" + ], + "checks": "The m=3/m=4 analogue control censuses: direct A,D coverage vs the reduction machinery agree per class (22 classes incl. cover-bearing positive controls and floor-surviving empty controls), and line-checker mutants change census counts (semantic failure controls).", + "timeout_seconds": 300 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/f7-18point-avtail-seed010d26fa/verify.py", + "av51" + ], + "checks": "Receipt validation of the class (5,1) decision walk: u_checked=169,911, uv_pairs=3,049,492,320 (by |U+V| = 27/28/29/30: 1,439,907,840/1,572,086,880/29,998,080/7,499,520), w_candidates=0, covering_configs=0 - class (12,6) A-vanish (5,1) PROVEN empty. The walk itself runs via run_avtail.py av51 (16 shards) and is not part of this bounded replay.", + "timeout_seconds": 60 + } + ], + "inputs": [ + "research/f7-18point-avtail-seed010d26fa/avtail.py", + "research/f7-18point-avtail-seed010d26fa/verify.py", + "research/f7-18point-avtail-seed010d26fa/test_engine.py", + "research/f7-18point-avtail-seed010d26fa/run_avtail.py", + "research/f7-18point-avtail-seed010d26fa/vendor/tight.py", + "research/f7-18point-avtail-seed010d26fa/vendor/cover18.py", + "research/f7-18point-avtail-seed010d26fa/vendor/vanish.py", + "research/f7-18point-avtail-seed010d26fa/vendor/agent64_cover17.py", + "research/f7-18point-avtail-seed010d26fa/vendor/agent64_search17.py", + "research/f7-18point-avtail-seed010d26fa/vendor/anchors.py", + "research/f7-18point-avtail-seed010d26fa/AVTAIL-PROGRESS.json" + ] +} diff --git a/research/f7-18point-avtail-seed010d26fa/avtail.py b/research/f7-18point-avtail-seed010d26fa/avtail.py new file mode 100644 index 0000000000..9c2b56f4c0 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/avtail.py @@ -0,0 +1,641 @@ +"""KB3h engine: the (12,6) A-vanish TAIL classes of the 18-point cover +question for F2^7 (set level; no words). Exact Python integer arithmetic +only; masks are Python ints over F2^m coordinates. + +Object (unchanged from PR 2911/2933/2961): S = A u B covers F2^7 iff +P + P = F2^7. With D = p + B inside E = F2^6 the pair (A, D) covers iff +(i) A + D = E and (ii) (A+A) u (D+D) = E. Fix the vanishing character +psi = bit 0 (WLOG under GL(6,2)); H = ker(psi) and its coset H' are both +identified with F2^5 and coverage is the four PR 2933 L3 lines + + (I) (A0+D0) u (A1+D1) = F2^5 + (II) (A0+D1) u (A1+D0) = F2^5 + (III) (A0+A0) u (A1+A1) u (D0+D0) u (D1+D1) = F2^5 + (IV) (A0+A1) u (D0+D1) = F2^5 + +with A0, A1 the two halves of A (6-sets; A-vanish forces |A0| = |A1| = 6) +and D0, D1 the two halves of D. This module decides/classifies the three +SURVIVING non-tight A-vanish classes of (12,6), by D-split (x, y) = +(|D0|, |D1|): (5,1), (4,2), (3,3). PR 2933 recorded their floors +a0*a1 + d0*d1 = 36 + x*y = 41/44/45 >= 32 (line IV); (6,0)'s full-sumset +rigidity (A0+A1 = F2^5) does not extend to them. + +CLASS (5,1) EXACT REDUCTION (this module's decision procedure). +D1 = {d1} is a singleton. Absorb d1 by the two half-translations +U = A0 + d1, V = A1 + d1, W = D0 + d1 (each preserves all four L3 lines +being all of F2^5 - machine-checked in test_engine.py). The class is then +EXACTLY the triples (U, V 6-sets, W 5-set) of F2^5 satisfying + + (a) V u (U+W) = F2^5 (line I) + (b) U u (V+W) = F2^5 (line II) + (c) (U+V) u W = F2^5 (line IV) + (d) (U+U) u (V+V) u (W+W) u {0} = F2^5 (line III) + +and back (A0, A1, D0, D1) = (U, V, W, {0}). Residual symmetries +U -> U+a, W -> W+a, V -> V+b (independent half-translations) give WLOG +0 in U and 0 in V in the pair walk. + +Walk (extends PR 2961's transversals6 method). Line (c) forces +M = F2^5 \\ (U+V) to sit inside W (|M| <= 5), and lines (a),(b) are +hitting requirements on W: every p outside V must satisfy W n (p+U) != 0 +and every p outside U must satisfy W n (p+V) != 0. So for each normalized +pair (U, V) with |U+V| >= 27 the valid W's are found by a complete +branch-on-uncovered search seeded with M; every surviving W is tested +against (d) exactly. The pair enumeration itself is complete over all +normalized (U, V) 6-set pairs with 0 in U, 0 in V and |U+V| >= 27, by a +monotone excess-budget backtracking (excess = 36 - |U+V| <= 9). +""" + +import json +import sys +import time +from itertools import combinations +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE / "vendor")) + +import tight # noqa: E402 (vendored byte-exact PR 2961 engine) + + +# ------------------------------------------- generic m-bit mask primitives + + +def trans_g(mask, a, bits, allm): + for i in range(bits): + if (a >> i) & 1: + b = 1 << i + lo = 0 + for p in range(1 << bits): + if not (p & b): + lo |= 1 << p + mask = ((mask & lo) << b) | ((mask & (allm ^ lo)) >> b) + return mask + + +def sumset_g(mx, my, bits, allm): + out = 0 + x = mx + while x: + lsb = x & -x + out |= trans_g(my, lsb.bit_length() - 1, bits, allm) + x ^= lsb + return out + + +def selfsum_g(mx, bits, allm): + return sumset_g(mx, mx, bits, allm) + + +def elems_g(mask): + out = [] + while mask: + lsb = mask & -mask + out.append(lsb.bit_length() - 1) + mask ^= lsb + return out + + +# m = 5 fast path (vendored tight primitives; 32-point space) +T5 = tight.trans +S5 = tight.sumset_mask +SS5 = tight.selfsum_mask +ALL5 = tight.ALL +N5 = 32 + + +def lines51(u, v, w): + """The four reduced lines (a),(b),(c),(d) for F2^5 masks u, v, w. + Returns (ok, which_lines_fail).""" + fails = [] + if (v | S5(u, w)) != ALL5: + fails.append("a") + if (u | S5(v, w)) != ALL5: + fails.append("b") + if (S5(u, v) | w) != ALL5: + fails.append("c") + if (SS5(u) | SS5(v) | SS5(w) | 1) != ALL5: + fails.append("d") + return (not fails), tuple(fails) + + +def lines_l3(a0, a1, d0, d1): + """The four original PR 2933 L3 lines for F2^5 masks.""" + fails = [] + if (S5(a0, d0) | S5(a1, d1)) != ALL5: + fails.append("I") + if (S5(a0, d1) | S5(a1, d0)) != ALL5: + fails.append("II") + if (SS5(a0) | SS5(a1) | SS5(d0) | SS5(d1)) != ALL5: + fails.append("III") + if (S5(a0, a1) | S5(d0, d1)) != ALL5: + fails.append("IV") + return (not fails), tuple(fails) + + +def red51_forward(a0, a1, d0, d1): + """(A0, A1, D0, D1={d1}) -> (U, V, W) by the two half-translations.""" + (d1,) = elems_g(d1) + return T5(a0, d1), T5(a1, d1), T5(d0, d1) + + +def red51_backward(u, v, w): + """(U, V, W) -> (A0, A1, D0, D1) with D1 = {0}.""" + return u, v, w, 1 + + +# --------------------------------------- complete W search per (U, V) pair + + +def solve_w(u, v, wsize=5): + """Complete list of wsize-sets W satisfying (a),(b),(c) for the pair + (u, v): W must contain M = ALL \\ (u+v), and must hit the requirement + translates (p+u) for p outside v and (p+v) for p outside u. Line (d) + is NOT tested here (exact pair test in the caller).""" + uv = S5(u, v) + miss = ALL5 ^ uv + if miss.bit_count() > wsize: + return [] + # requirement masks: for each requirement point p, the candidate + # elements w that satisfy it (w in p+u resp. p+v). + reqs = [] + for p in elems_g(ALL5 ^ v): + reqs.append(T5(u, p)) + for p in elems_g(ALL5 ^ u): + reqs.append(T5(v, p)) + # cov_by[w] = bitmask of requirements that element w covers + cov_by = [0] * N5 + for w in range(N5): + m = 0 + for i, rq in enumerate(reqs): + if (rq >> w) & 1: + m |= 1 << i + cov_by[w] = m + need = (1 << len(reqs)) - 1 + out = set() + base = sorted(elems_g(miss)) + + def rec(uncov, chosen, nxt): + if len(chosen) == wsize: + if not uncov: + out.add(sum(1 << c for c in chosen)) + return + if uncov.bit_count() > (wsize - len(chosen)) * 12: + return + if not uncov: + for w in range(nxt, N5): + if w in chosen: + continue + rec(uncov, chosen + [w], w + 1) + return + i = (uncov & -uncov).bit_length() - 1 + x = reqs[i] + while x: + lsb = x & -x + w = lsb.bit_length() - 1 + x ^= lsb + if w in chosen: + continue + rec(uncov & ~cov_by[w], chosen + [w], 0) + return + + rec(need, list(base), 0) + return sorted(out) + + +# ---------------------------------------- m=4 analogue control (positive) + + +def lines51_g(u, v, w, bits, allm): + """Generic (a),(b),(c),(d) check for F2^bits masks.""" + fails = [] + if (v | sumset_g(u, w, bits, allm)) != allm: + fails.append("a") + if (u | sumset_g(v, w, bits, allm)) != allm: + fails.append("b") + if (sumset_g(u, v, bits, allm) | w) != allm: + fails.append("c") + if (selfsum_g(u, bits, allm) | selfsum_g(v, bits, allm) | selfsum_g(w, bits, allm) | 1) != allm: + fails.append("d") + return (not fails), tuple(fails) + + +def control_m4(): + """Small-space analogue control for the (5,1) machinery: E = F2^m with + halves H = bit0-even and H', A splits (k, k) (A-vanish), D splits (x, 1) + (singleton D1, the class-(5,1) shape). Two independent routes: + + DIRECT: every (A0, A1, D0, D1) with those sizes, tested against + A + D = E and (A+A) u (D+D) = E in F2^m directly (and against + the four L3 coordinate lines; the two must agree). + MACHINERY: the (U, V, W) reduction (U = A0+d1, V = A1+d1, W = D0+d1 + in F2^(m-1) coordinates) tested with lines51_g. + + Both routes must produce the same cover count per class. The scanned + set includes cover-bearing classes (positive control), floor-surviving + but EMPTY classes, and semantic failure controls: line-checker mutants + (drop (a) or drop (d)) must change at least one census count. The + class list was chosen after a complete probe over the (k, x) grid + (cost-capped); all listed classes are walked in full here.""" + cases = [ + # (m, k, x) - m=3: every floor-surviving singleton-D1 class + (3, 1, 3), (3, 1, 4), (3, 2, 1), (3, 2, 2), (3, 2, 3), (3, 2, 4), + (3, 3, 1), (3, 3, 2), (3, 3, 3), (3, 3, 4), (3, 4, 1), (3, 4, 2), + (3, 4, 3), (3, 4, 4), + # m=4: cover-bearing, empty-but-floor-surviving, and tight-floor classes + (4, 1, 7), (4, 1, 8), (4, 2, 4), (4, 2, 5), (4, 3, 1), (4, 4, 1), + (4, 5, 1), (4, 8, 8), + ] + res = {} + for (m, k, x) in cases: + bits = m - 1 + n = 1 << bits + allm = (1 << n) - 1 + pts = 1 << m + H = [p for p in range(pts) if not (p & 1)] + Hp = [p for p in range(pts) if p & 1] + direct = 0 + direct_l3 = 0 + mach = 0 + mach_no_a = 0 + mach_no_d = 0 + for a0t in combinations(H, k): + for a1t in combinations(Hp, k): + for d0t in combinations(H, x): + for d1t in combinations(Hp, 1): + A = list(a0t) + list(a1t) + D = list(d0t) + list(d1t) + if ss_pts(A, D) == set(range(pts)) and ss_pts(A, A) | ss_pts(D, D) == set(range(pts)): + direct += 1 + a0 = mask3(a0t) + a1 = mask3(a1t) + d0 = mask3(d0t) + d1 = mask3(d1t) + if l3_g(a0, a1, d0, d1, bits, allm): + direct_l3 += 1 + (dd,) = elems_g(d1) + u = trans_g(a0, dd, bits, allm) + v = trans_g(a1, dd, bits, allm) + w = trans_g(d0, dd, bits, allm) + ok, _ = lines51_g(u, v, w, bits, allm) + if ok: + mach += 1 + f1 = (v | sumset_g(u, w, bits, allm)) != allm + f2 = (u | sumset_g(v, w, bits, allm)) != allm + f3 = (sumset_g(u, v, bits, allm) | w) != allm + f4 = ( + selfsum_g(u, bits, allm) + | selfsum_g(v, bits, allm) + | selfsum_g(w, bits, allm) + | 1 + ) != allm + if (not f2) and (not f3) and (not f4): + mach_no_a += 1 + if (not f1) and (not f2) and (not f3): + mach_no_d += 1 + res["m%d_A%d_D%d_%d" % (m, k, x, 1)] = dict( + m=m, + k=k, + x=x, + floor_value=k * k + x, + floor_need=n, + direct_covers=direct, + direct_l3_covers=direct_l3, + machinery_covers=mach, + mutant_drop_a=mach_no_a, + mutant_drop_d=mach_no_d, + agreement=(direct == direct_l3 == mach), + ) + return res + + +def ss_pts(X, Y): + return {a ^ b for a in X for b in Y} + + +def mask3(pts): + m = 0 + for p in pts: + m |= 1 << (p >> 1) + return m + + +def l3_g(a0, a1, d0, d1, bits, allm): + """The four L3 lines on F2^bits coordinate masks.""" + ok_i = (sumset_g(a0, d0, bits, allm) | sumset_g(a1, d1, bits, allm)) == allm + ok_ii = (sumset_g(a0, d1, bits, allm) | sumset_g(a1, d0, bits, allm)) == allm + ok_iii = ( + selfsum_g(a0, bits, allm) + | selfsum_g(a1, bits, allm) + | selfsum_g(d0, bits, allm) + | selfsum_g(d1, bits, allm) + ) == allm + ok_iv = (sumset_g(a0, a1, bits, allm) | sumset_g(d0, d1, bits, allm)) == allm + return ok_i and ok_ii and ok_iii and ok_iv + + +def pair_backtrack(u, need): + """All normalized v (0 in v, 6-set) with |u+v| >= need, by monotone + excess-budget backtracking over sorted v-sets. Complete: the excess + of the partial sumset only grows with v.""" + out = [] + rest = list(range(1, N5)) + chosen = [0] + cov = [0] * N5 # coverage count r(p) of u+v' over partial v' + for p in elems_g(u): + cov[p] = 1 + + def excess(): + e = 0 + for p in range(N5): + if cov[p] > 1: + e += cov[p] - 1 + return e + + def rec(start): + if len(chosen) == 6: + sup = 0 + for c in chosen: + sup |= T5(u, c) + if sup.bit_count() >= need: + out.append(sum(1 << c for c in chosen)) + return + for i in range(start, len(rest)): + v = rest[i] + tr = T5(u, v) + x = tr + while x: + lsb = x & -x + p = lsb.bit_length() - 1 + cov[p] += 1 + x ^= lsb + chosen.append(v) + cur_size = 0 + for p in range(N5): + if cov[p] > 0: + cur_size += 1 + remain = 6 - len(chosen) + if cur_size + 6 * remain >= need and excess() <= 36 - need: + rec(i + 1) + chosen.pop() + x = tr + while x: + lsb = x & -x + p = lsb.bit_length() - 1 + cov[p] -= 1 + x ^= lsb + + rec(0) + return out + + +def class51_reference(budget=None, shard=0, shards=1): + """Reference decision run for class (12,6) A-vanish (5,1): the direct + pair_backtrack + solve_w + lines51 loop (readable, validated against + brute force in test_engine.py). class51_run below is the optimized + engine; test_engine.py cross-checks both agree per U slice.""" + t0 = time.time() + total_u = 169911 + u_done = 0 + pairs = 0 + pairs_by_size = {} + w_candidates = 0 + covering = 0 + fail_hist = {} + witnesses = [] + budget_hit = False + for idx, uc in enumerate(combinations(range(1, N5), 5)): + if idx % shards != shard: + continue + u_done += 1 + u = 1 | tight.mask_of(uc) + for v in pair_backtrack(u, 27): + pairs += 1 + sz = S5(u, v).bit_count() + pairs_by_size[sz] = pairs_by_size.get(sz, 0) + 1 + for w in solve_w(u, v, 5): + w_candidates += 1 + ok, fails = lines51(u, v, w) + if ok: + covering += 1 + if len(witnesses) < 5: + witnesses.append((elems_g(u), elems_g(v), elems_g(w))) + else: + fail_hist[fails] = fail_hist.get(fails, 0) + 1 + if budget is not None and u_done % 32 == 0 and time.time() - t0 > budget: + budget_hit = True + break + return dict( + shard=shard, + shards=shards, + normalized_u_total=total_u, + u_checked=u_done, + uv_pairs=pairs, + uv_pairs_by_sumset_size={str(k): v for k, v in sorted(pairs_by_size.items())}, + w_candidates=w_candidates, + covering_configs=covering, + fail_hist={str(k): v for k, v in sorted(fail_hist.items())}, + witnesses=witnesses, + budget_hit=budget_hit, + seconds=round(time.time() - t0, 2), + ) + + +# ------------------------------------------------ optimized (5,1) engine + +# singleton XOR table: X32[a][r] = 1 << (a ^ r) +X32 = [[1 << (i ^ j) for j in range(N5)] for i in range(N5)] + + +def trans_fast(mask, a, elems): + """{x ^ a : x in mask} via the singleton table (elems = mask's elements).""" + out = 0 + for x in elems: + out |= X32[x][a] + return out + + +def pair_backtrack_fast(u, need, TU): + """Like pair_backtrack, but returns (vmask, vlist, support, sv) with + support = u+v (bitmask) and sv = selfsum(v), both maintained + incrementally (excess and support are monotone in v). TU is the + per-U translate table (TU[v] == trans(u, v)).""" + out = [] + rest = list(range(1, N5)) + chosen = [0] + sup = u # U + 0 already in the partial sumset + excess = 0 + sv = 1 # selfsum contains 0 + + def rec(start): + nonlocal sup, excess, sv + if len(chosen) == 6: + if sup.bit_count() >= need: + out.append((sum(1 << c for c in chosen), list(chosen), sup, sv)) + return + for i in range(start, len(rest)): + v = rest[i] + tr = TU[v] + add = (tr & sup).bit_count() + excess += add + old_sup = sup + sup |= tr + chosen.append(v) + # sv grows: selfsum(V+v) = sv | trans(V, v) | {0} + trv = 0 + for c in chosen[:-1]: + trv |= X32[c][v] + old_sv = sv + sv |= trv | (1 << v) | 1 + remain = 6 - len(chosen) + if sup.bit_count() + 6 * remain >= need and excess <= 36 - need: + rec(i + 1) + chosen.pop() + sv = old_sv + sup = old_sup + excess -= add + + rec(0) + return out + + +def class51_run(budget=None, shard=0, shards=1): + """OPTIMIZED decision run for class (12,6) A-vanish (5,1). Same exact + object and completeness as class51_reference (cross-checked per U slice + in test_engine.py): complete over all normalized (U, V) pairs + (0 in U, 0 in V, |U+V| >= 27), every admissible W per pair (W must + contain M = F2^5 \\ (U+V) and hit the (a)/(b) requirement translates), + exact four-line test on every surviving W. + + Per-U precomputation: TU[r] = U+r for all r, su = U+U. Per-pair: + M, uM, vM, requirement remainders N1 = (F2^5 \\ V) \\ uM and + N2 = (F2^5 \\ U) \\ vM; W candidates are filtered in stages + (U-translate coverage, then V-translate coverage, then line (d)).""" + t0 = time.time() + total_u = 169911 + u_done = 0 + pairs = 0 + pairs_by_size = {} + w_candidates = 0 + covering = 0 + fail_hist = {} + witnesses = [] + budget_hit = False + for idx, uc in enumerate(combinations(range(1, N5), 5)): + if idx % shards != shard: + continue + u_done += 1 + u = 1 | tight.mask_of(uc) + ue = (0,) + uc + TU = [0] * N5 + for r in range(N5): + m = 0 + for a in ue: + m |= X32[a][r] + TU[r] = m + su = 0 + for a in ue: + su |= TU[a] + for (vm, vl, uv, sv) in pair_backtrack_fast(u, 27, TU): + pairs += 1 + sz = uv.bit_count() + pairs_by_size[sz] = pairs_by_size.get(sz, 0) + 1 + miss = ALL5 ^ uv + M = elems_g(miss) + uM = 0 + for q in M: + uM |= TU[q] + vM = 0 + for q in M: + t = 0 + for a in vl: + t |= X32[a][q] + vM |= t + N1 = (ALL5 ^ vm) & ~uM + N2 = ALL5 & ~u & ~vM + free_l = elems_g(ALL5 ^ miss) + need_r = 5 - len(M) + # stage-1 (line (a)) inside pruned nested loops: only R with + # uM | U+R covering F2^5 \ V reach the candidate list. + rls = [] + if need_r == 0: + if not (N1 & ~uM): + rls.append(()) + elif need_r == 1: + for i1, r1 in enumerate(free_l): + if not (N1 & ~(uM | TU[r1])): + rls.append((r1,)) + elif need_r == 2: + for i1, r1 in enumerate(free_l): + acc1 = uM | TU[r1] + if N1 & ~acc1: + continue + for i2 in range(i1 + 1, len(free_l)): + r2 = free_l[i2] + if not (N1 & ~(acc1 | TU[r2])): + rls.append((r1, r2)) + else: + for i1, r1 in enumerate(free_l): + acc1 = uM | TU[r1] + if N1 & ~acc1: + continue + for i2 in range(i1 + 1, len(free_l)): + r2 = free_l[i2] + acc2 = acc1 | TU[r2] + if N1 & ~acc2: + continue + for i3 in range(i2 + 1, len(free_l)): + r3 = free_l[i3] + if not (N1 & ~(acc2 | TU[r3])): + rls.append((r1, r2, r3)) + base = None + for rl in rls: + accv = vM + for r in rl: + t = 0 + for a in vl: + t |= X32[a][r] + accv |= t + if N2 & ~accv: + continue + w_candidates += 1 + if base is None: + b = su | sv | 1 + for q1 in M: + for q2 in M: + if q1 != q2: + b |= X32[q1][q2] + base = b + dd = base + for r in rl: + for q in M: + dd |= X32[q][r] + for r2 in rl: + if r2 != r: + dd |= X32[r][r2] + if dd != ALL5: + fail_hist[("d",)] = fail_hist.get(("d",), 0) + 1 + continue + wmask = miss + for r in rl: + wmask |= 1 << r + covering += 1 + if len(witnesses) < 5: + witnesses.append((list(ue), vl, elems_g(wmask))) + if budget is not None and u_done % 32 == 0 and time.time() - t0 > budget: + budget_hit = True + break + return dict( + shard=shard, + shards=shards, + normalized_u_total=total_u, + u_checked=u_done, + uv_pairs=pairs, + uv_pairs_by_sumset_size={str(k): v for k, v in sorted(pairs_by_size.items())}, + w_candidates=w_candidates, + covering_configs=covering, + fail_hist={str(k): v for k, v in sorted(fail_hist.items())}, + witnesses=witnesses, + budget_hit=budget_hit, + seconds=round(time.time() - t0, 2), + ) diff --git a/research/f7-18point-avtail-seed010d26fa/run_avtail.py b/research/f7-18point-avtail-seed010d26fa/run_avtail.py new file mode 100644 index 0000000000..983c39f21e --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/run_avtail.py @@ -0,0 +1,177 @@ +"""Resumable walk driver for the KB3h package (f7-18point-avtail). + +Modes (deterministic sharding; per-shard receipt files AVTAIL--.json, +one progress section per mode in AVTAIL-PROGRESS.json after `merge`): + + class71 ANCHOR re-walk (empty receipts): PR 2961's class (7,1) + enumeration (expected normalized_pairs=0). + class82 ANCHOR re-walk (empty receipts): PR 2961's class (8,2) + equality-configuration walk (expected checked=28,815,360 + covering=0 across 8 shards). + class60 ANCHOR re-walk (empty receipts): PR 2961's class (6,0) + D-side transversal walk (expected d_checked=169,911 + d_with_transversals=0 across 8 shards). + av51 the new class (12,6) A-vanish (5,1) decision walk + (avtail.class51_run). + +Usage: python3 -I -B run_avtail.py [--shards N] [--shard k] + [--budget S] + python3 -I -B run_avtail.py merge + +Shard receipt files are written ONLY by their own shard process (safe for +parallel shard runs); `merge` rebuilds AVTAIL-PROGRESS.json from the shard +files (idempotent, run after all shards finish). A shard is processed only +if its receipt file is absent or incomplete; re-invoke to continue. +Receipts carry explicit complete/budget_hit flags (a partial walk is never +recorded as complete). Starting a mode with no receipt prints +'fresh receipts confirmed' (the receipt-validation trap: replaying against +a committed receipt validates nothing). +""" + +import json +import sys +import time +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(0, str(HERE / "vendor")) + +import tight # noqa: E402 +import avtail # noqa: E402 + +PROGRESS = HERE / "AVTAIL-PROGRESS.json" +MODES = ("class71", "class82", "class60", "av51") +TAGS = {"class71": "C71", "class82": "C82", "class60": "C60", "av51": "AV51"} + + +def shard_file(mode, k): + return HERE / ("AVTAIL-%s-%d.json" % (TAGS[mode], k)) + + +def load_shard(mode, k): + p = shard_file(mode, k) + if p.exists(): + return json.loads(p.read_text(encoding="utf-8")) + return None + + +def aggregate(shards): + keys = set() + for rec in shards: + keys |= set(rec) + tot = {} + for k in sorted(keys): + vals = [ + rec[k] + for rec in shards + if isinstance(rec.get(k), (int, float)) + and k not in ("shard", "shards", "seconds", "wall_seconds") + ] + if vals: + if k.endswith("_total") and len(set(vals)) == 1: + tot[k] = vals[0] + else: + tot[k] = sum(vals) + dicts = [rec[k] for rec in shards if isinstance(rec.get(k), dict)] + if dicts: + merged = {} + for d in dicts: + for kk, vv in d.items(): + merged[kk] = merged.get(kk, 0) + vv + tot[k] = merged + return tot + + +def run_shard(mode, k, shards, budget): + rec = load_shard(mode, k) + if rec and rec.get("complete"): + print("SKIP %s shard=%d already complete" % (mode, k), flush=True) + return rec + t0 = time.time() + if mode == "class71": + rec = tight.class71_run(budget=budget) + elif mode == "class82": + rec = tight.class82_run(budget=budget, shard=k, shards=shards) + elif mode == "class60": + rec = tight.class60_run(budget=budget, shard=k, shards=shards) + elif mode == "av51": + rec = avtail.class51_run(budget=budget, shard=k, shards=shards) + rec["wall_seconds"] = round(time.time() - t0, 2) + rec["complete"] = not rec.get("budget_hit", False) + shard_file(mode, k).write_text( + json.dumps(rec, indent=2, sort_keys=True) + "\n", encoding="utf-8" + ) + print( + "RECEIPT %s shard=%d/%d wall=%.1fs complete=%s budget_hit=%s" + % (mode, k, shards, rec["wall_seconds"], rec["complete"], rec.get("budget_hit")), + flush=True, + ) + return rec + + +def merge(mode, shards): + recs = [] + done = [] + for k in range(shards): + rec = load_shard(mode, k) + if rec and rec.get("complete"): + recs.append(rec) + done.append(k) + prog = ( + json.loads(PROGRESS.read_text(encoding="utf-8")) + if PROGRESS.exists() + else {"modes": {}} + ) + sec = { + "shards": {str(k): r for k, r in zip(done, recs)}, + "shards_count": shards, + "complete": len(done) == shards, + } + sec["total"] = aggregate(recs) + prog["modes"][mode] = sec + PROGRESS.write_text( + json.dumps(prog, indent=2, sort_keys=True) + "\n", encoding="utf-8" + ) + print( + "MERGE %s shards=%d/%d complete=%s total=%s" + % (mode, len(done), shards, sec["complete"], json.dumps(sec["total"], sort_keys=True)[:400]), + flush=True, + ) + return sec + + +def main(): + sys.stdout.reconfigure(encoding="utf-8") + if len(sys.argv) < 2: + raise SystemExit("usage: run_avtail.py %s [--shards N] [--shard k]" % "|".join(MODES)) + mode = sys.argv[1] + args = sys.argv[2:] + if mode == "merge": + target = args[0] + shards = int(args[args.index("--shards") + 1]) if "--shards" in args else 8 + merge(target, shards) + return + if mode not in MODES: + raise SystemExit("usage: run_avtail.py %s [--shards N] [--shard k]" % "|".join(MODES)) + shards = int(args[args.index("--shards") + 1]) if "--shards" in args else 8 + budget = float(args[args.index("--budget") + 1]) if "--budget" in args else 3000.0 + if not any(shard_file(mode, k).exists() for k in range(shards)) and not PROGRESS.exists(): + print("fresh receipts confirmed (%s: no receipt file existed)" % mode, flush=True) + if "--shard" in args: + run_shard(mode, int(args[args.index("--shard") + 1]), shards, budget) + return + for k in range(shards): + rec = load_shard(mode, k) + if rec and rec.get("complete"): + continue + run_shard(mode, k, shards, budget) + sec = merge(mode, shards) + if sec["complete"]: + print("PASS_RUN %s" % mode, flush=True) + else: + print("PARTIAL_RUN %s complete=false" % mode, flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/f7-18point-avtail-seed010d26fa/test_engine.py b/research/f7-18point-avtail-seed010d26fa/test_engine.py new file mode 100644 index 0000000000..93360e9e1f --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/test_engine.py @@ -0,0 +1,199 @@ +"""Machine checks for the KB3h engine (avtail.py). Run: +python3 -I -B research/f7-18point-avtail-seed010d26fa/test_engine.py +""" + +import random +import sys +import unittest +from itertools import combinations +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(0, str(HERE / "vendor")) + +import tight # noqa: E402 +import avtail # noqa: E402 + +RNG = random.Random(20261016) + + +def naive_sumset(X, Y): + return {x ^ y for x in X for y in Y} + + +def rand_set(n, k): + return RNG.sample(range(n), k) + + +class TestPrimitives(unittest.TestCase): + def test_trans_sumset_vs_naive(self): + for bits in (3, 4, 5): + n = 1 << bits + allm = (1 << n) - 1 + for _ in range(50): + X = rand_set(n, RNG.randint(1, min(6, n))) + Y = rand_set(n, RNG.randint(1, min(6, n))) + xm = sum(1 << p for p in X) + ym = sum(1 << p for p in Y) + got = avtail.sumset_g(xm, ym, bits, allm) + want = sum(1 << p for p in naive_sumset(X, Y)) + self.assertEqual(got, want) + a = RNG.randrange(n) + self.assertEqual( + avtail.trans_g(xm, a, bits, allm), + sum(1 << (p ^ a) for p in X), + ) + self.assertEqual( + avtail.selfsum_g(xm, bits, allm), + sum(1 << p for p in naive_sumset(X, X)), + ) + + def test_lines51_vs_naive(self): + for _ in range(200): + u = sum(1 << p for p in rand_set(32, 6)) + v = sum(1 << p for p in rand_set(32, 6)) + w = sum(1 << p for p in rand_set(32, 5)) + ok, fails = avtail.lines51(u, v, w) + U, V, W = avtail.elems_g(u), avtail.elems_g(v), avtail.elems_g(w) + want_a = naive_sumset(V, [0]) | naive_sumset(U, W) == set(range(32)) + want_b = naive_sumset(U, [0]) | naive_sumset(V, W) == set(range(32)) + want_c = naive_sumset(U, V) | naive_sumset(W, [0]) == set(range(32)) + want_d = ( + naive_sumset(U, U) | naive_sumset(V, V) | naive_sumset(W, W) | {0} + ) == set(range(32)) + self.assertEqual(ok, want_a and want_b and want_c and want_d, fails) + + +class TestReduction(unittest.TestCase): + def test_reduction_line_equivalence_random(self): + """Random (A0, A1, D0, D1={d1}) configurations: the four L3 lines + and the four reduced (a)-(d) lines agree exactly.""" + for _ in range(400): + a0 = sum(1 << p for p in rand_set(32, 6)) + a1 = sum(1 << p for p in rand_set(32, 6)) + d0 = sum(1 << p for p in rand_set(32, 5)) + d1 = 1 << RNG.randrange(32) + ok_l3, _ = avtail.lines_l3(a0, a1, d0, d1) + u, v, w = avtail.red51_forward(a0, a1, d0, d1) + ok_r, _ = avtail.lines51(u, v, w) + self.assertEqual(ok_l3, ok_r) + # backward round trip + bu, bv, bw, bd1 = avtail.red51_backward(u, v, w) + self.assertEqual(bd1, 1) + ok_l3b, _ = avtail.lines_l3(bu, bv, bw, bd1) + self.assertEqual(ok_l3b, ok_r) + + def test_residual_symmetry(self): + """(U, V, W) -> (U+a, V+b, W+a) preserves the four reduced lines.""" + for _ in range(300): + u = sum(1 << p for p in rand_set(32, 6)) + v = sum(1 << p for p in rand_set(32, 6)) + w = sum(1 << p for p in rand_set(32, 5)) + a = RNG.randrange(32) + b = RNG.randrange(32) + ok1, f1 = avtail.lines51(u, v, w) + ok2, f2 = avtail.lines51( + tight.trans(u, a), tight.trans(v, b), tight.trans(w, a) + ) + self.assertEqual((ok1, f1), (ok2, f2)) + + def test_wlog_normalization_covers_all(self): + """Every solution (U, V, W) maps to one with 0 in U and 0 in V + through the residual symmetry (round trip test on random data).""" + for _ in range(200): + u = sum(1 << p for p in rand_set(32, 6)) + v = sum(1 << p for p in rand_set(32, 6)) + w = sum(1 << p for p in rand_set(32, 5)) + a = avtail.elems_g(u)[0] + b = avtail.elems_g(v)[0] + un = tight.trans(u, a) + vn = tight.trans(v, b) + wn = tight.trans(w, a) + self.assertIn(0, avtail.elems_g(un)) + self.assertIn(0, avtail.elems_g(vn)) + self.assertEqual( + avtail.lines51(u, v, w), avtail.lines51(un, vn, wn) + ) + + +class TestSearchCompleteness(unittest.TestCase): + def test_solve_w_vs_bruteforce(self): + """solve_w must equal brute force over all C(32,5) 5-sets.""" + pairs = [] + for _ in range(8): + u = 1 | sum(1 << p for p in rand_set(31, 5)) + v = 1 | sum(1 << p for p in rand_set(31, 5)) + pairs.append((u, v)) + # plus the pairs with the largest sumsets found in a quick scan + us = [1 | tight.mask_of(c) for c in combinations(range(1, 32), 5)] + best = [] + for u in RNG.sample(us, 60): + for v in RNG.sample(us, 60): + sz = tight.sumset_mask(u, v).bit_count() + if sz >= 25: + best.append((sz, u, v)) + best.sort(reverse=True) + for (_sz, u, v) in best[:6]: + pairs.append((u, v)) + for (u, v) in pairs: + got = set(avtail.solve_w(u, v, 5)) + want = set() + for wc in combinations(range(32), 5): + wm = sum(1 << p for p in wc) + _, fails = avtail.lines51(u, v, wm) + if "a" not in fails and "b" not in fails and "c" not in fails: + want.add(wm) + self.assertEqual(got, want, (avtail.elems_g(u), avtail.elems_g(v))) + + def test_pair_backtrack_vs_bruteforce(self): + """pair_backtrack must equal brute force over all normalized v.""" + us = [1 | tight.mask_of(c) for c in combinations(range(1, 32), 5)] + for u in RNG.sample(us, 4): + for need in (24, 27): + got = set(avtail.pair_backtrack(u, need)) + want = set() + for vc in combinations(range(1, 32), 5): + vm = 1 | tight.mask_of(vc) + if tight.sumset_mask(u, vm).bit_count() >= need: + want.add(vm) + self.assertEqual(got, want, (avtail.elems_g(u), need)) + + def test_class51_run_shard_smoke(self): + """One tiny shard slice agrees with direct evaluation on the same + slice (soundness of the walk loop).""" + rec = avtail.class51_run(budget=None, shard=0, shards=169911) + self.assertEqual(rec["u_checked"], 1) + self.assertFalse(rec["budget_hit"]) + + def test_optimized_vs_reference_per_slice(self): + """The optimized decision engine must agree with the validated + reference (pair_backtrack + solve_w + lines51) on full U slices.""" + import random as _r + + rr = _r.Random(31337) + for idx in rr.sample(range(169911), 3): + ref = avtail.class51_reference(budget=None, shard=idx, shards=169911) + opt = avtail.class51_run(budget=None, shard=idx, shards=169911) + for key in ("uv_pairs", "uv_pairs_by_sumset_size", "w_candidates", + "covering_configs", "fail_hist", "u_checked"): + self.assertEqual(ref[key], opt[key], (idx, key, ref[key], opt[key])) + + +class TestControls(unittest.TestCase): + def test_m4_control_agreement_and_mutants(self): + rec = avtail.control_m4() + load_bearing = False + nonempty = 0 + for k, r in rec.items(): + self.assertTrue(r["agreement"], (k, r)) + if r["direct_covers"] > 0: + nonempty += 1 + if r["mutant_drop_a"] != r["machinery_covers"] or r["mutant_drop_d"] != r["machinery_covers"]: + load_bearing = True + self.assertTrue(load_bearing, rec) + self.assertGreaterEqual(nonempty, 1, "positive control needs a cover-bearing class") + + +if __name__ == "__main__": + unittest.main() diff --git a/research/f7-18point-avtail-seed010d26fa/vendor/agent64_cover17.py b/research/f7-18point-avtail-seed010d26fa/vendor/agent64_cover17.py new file mode 100644 index 0000000000..5add3747a3 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/vendor/agent64_cover17.py @@ -0,0 +1,263 @@ +"""17-point cover audit engine: pair-representation identity, sharp rows, +coverage primitives and exact small controls. + +Object (KB3c, pair-collision object change recorded in TASK.json): the status +of PR 2542's claim "No 17-point set covers F2^7" against its own lemma table. +PR 2542's `lemma_a_table` (vendored byte-exact as vendor/pr2542_engine.py, +credit PR 2542, package research/universal-f7-singleton-seedb859517b) only +contradicts the (9,8)/(8,9) split rows; the counting-feasible 17-point splits +(10,7)/(7,10)/(11,6)/(6,11) survive it. This module extends the identity +with the sharp collision-multiplicity constraint and computes exactly which +(e_ex, b_ex, c) rows survive per split. + +Definitions. S = A u B with A = S int E (s points, even weight), B = S int O +(t points, odd weight), s + t = 17. A_x = #unordered pairs of A summing to +x, B_x likewise (x even nonzero). e_ex = C(s,2) - |supp(A)|, b_ex likewise. +Cross sums a+b (a in A, b in B) hit the odd masks with multiplicities r_o, so + + odd excess sum_o (r_o - 1) = s*t - 2^(n-1) =: E_o + colliding pairs sum_o C(r_o,2) = 2 * sum_x A_x B_x =: 2c + +with C(r,2) >= r-1 per mask. A collision profile is a partition of E_o into +j = r_o - 1 parts; it needs sigma = sum j(j+1)/2 = 2c even. A row (e_ex, +b_ex) is multiset-feasible for profile c iff c is exactly attainable as the +sum of shared products A_x B_x over the shared = C(s,2)+C(t,2)-e_ex-b_ex- +(2^(n-1)-1) support positions (multiplicity shapes from partitions of e_ex +resp. b_ex). This refines PR 2542's closed-form upper bound. +""" + +from functools import lru_cache + +VENDOR_PIN_PR2542 = ( + "82e4c407b58864c74ffd14d47f00b6b1675005ee0e0173909b7bd092491175e4" +) + + +# ------------------------------------------------------- counting bounds + + +def counting_ok(n, s, t): + odd_masks = 1 << (n - 1) + even_nonzero = odd_masks - 1 + return ( + s * t >= odd_masks + and s * (s - 1) // 2 + t * (t - 1) // 2 >= even_nonzero + ) + + +# ------------------------------------------- collision-multiplicity identity + + +def _partitions(total): + """Integer partitions of total as tuples (non-increasing).""" + if total == 0: + yield () + return + for part in range(total, 0, -1): + for rest in _partitions(total - part): + if not rest or rest[0] <= part: + yield (part,) + rest + + +def odd_profiles(excess): + """Collision profiles for odd excess `excess`: partitions j of it with + sigma = sum j(j+1)/2 even (= 2c for integer c). Each j is one odd mask + with r = j + 1 cross representations.""" + out = [] + for parts in _partitions(excess): + sigma = sum(j * (j + 1) // 2 for j in parts) + if sigma % 2 == 0: + out.append(sorted(parts)) + return sorted(out) + + +def profile_c_values(n, s, t): + """c = sum_x A_x B_x forced by each integer collision profile.""" + excess = s * t - (1 << (n - 1)) + if excess < 0: + return [] + return sorted( + {sum(j * (j + 1) // 2 for j in parts) // 2 for parts in odd_profiles(excess)} + ) + + +def _shapes(total_pairs, excess): + """Multiplicity shapes: A_x values summing to total_pairs with support + size total_pairs - excess (the excess parts carry the collisions).""" + if excess > total_pairs: + return + for parts in _partitions(excess): + yield tuple(sorted((1 + p for p in parts), reverse=True)) + ( + 1, + ) * (total_pairs - excess - len(parts)) + + +def _draws(shape, shared): + """All multisets of `shared` values drawn from a multiplicity shape.""" + if shared == 0: + yield () + return + counts = {} + for v in shape: + counts[v] = counts.get(v, 0) + 1 + vals = sorted(counts) + limits = [counts[v] for v in vals] + + def rec(i, remaining, acc): + if i == len(vals): + if remaining == 0: + yield tuple(acc) + return + for take in range(min(limits[i], remaining) + 1): + yield from rec(i + 1, remaining - take, acc + [vals[i]] * take) + + yield from rec(0, shared, []) + + +def _pairing_sums(a_draw, b_draw): + """All dot products sum a_i b_pi(i) over pairings of two draws.""" + if len(a_draw) <= 1: + yield sum(x * y for x, y in zip(a_draw, b_draw)) + return + a0 = a_draw[0] + for i in range(len(b_draw)): + rest = b_draw[:i] + b_draw[i + 1 :] + for tail in _pairing_sums(a_draw[1:], rest): + yield a0 * b_draw[i] + tail + + +def attainable_c(n, s, t, e_ex, b_ex): + """Exact attainable values of sum_x A_x B_x on the shared support + positions for one (e_ex, b_ex) row.""" + odd_masks = 1 << (n - 1) + even_nonzero = odd_masks - 1 + A = s * (s - 1) // 2 + B = t * (t - 1) // 2 + shared = A + B - e_ex - b_ex - even_nonzero + if shared < 0: + return set() + out = set() + for sa in _shapes(A, e_ex): + for sb in _shapes(B, b_ex): + for da in _draws(sa, shared): + for db in _draws(sb, shared): + out.update(_pairing_sums(da, db)) + return out + + +def sharp_rows(n, s, t): + """Sharp pair-representation rows for one parity split. + + Returns {feasible, rows: [{e_ex, b_ex, shared, c}], best, need}: a row + survives iff some integer collision profile's c is exactly attainable. + `best` is the largest attainable c (PR 2542's closed-form comparison + quantity), `need` = ceil((s*t - 2^(n-1))/2) the profile-level necessity. + """ + odd_masks = 1 << (n - 1) + even_nonzero = odd_masks - 1 + A = s * (s - 1) // 2 + B = t * (t - 1) // 2 + excess = s * t - odd_masks + need = (excess + 1) // 2 if excess > 0 else 0 + rows = [] + best = -1 + if excess < 0 or A + B < even_nonzero: + return dict(feasible=False, rows=[], best=best, need=need) + c_vals = set(profile_c_values(n, s, t)) + for e_ex in range(A + 1): + for b_ex in range(B + 1): + shared = A + B - e_ex - b_ex - even_nonzero + if shared < 0: + continue + attain = attainable_c(n, s, t, e_ex, b_ex) + if not attain: + continue + best = max(best, max(attain)) + for c in sorted(attain & c_vals): + rows.append(dict(e_ex=e_ex, b_ex=b_ex, shared=shared, c=c)) + return dict(feasible=bool(rows), rows=rows, best=best, need=need) + + +def surviving_rows(n, s, t, min_e_ex=0, min_b_ex=0): + """Sharp rows filtered by census-implied minimum excesses (min excess of + s-point sets resp. t-point sets in F2^(n-1)).""" + sharp = sharp_rows(n, s, t) + rows = [ + r + for r in sharp["rows"] + if r["e_ex"] >= min_e_ex and r["b_ex"] >= min_b_ex + ] + return dict( + feasible=bool(rows), + rows=rows, + best=sharp["best"], + need=sharp["need"], + ) + + +# ------------------------------------------------------ coverage primitives + + +def coverage_mask(pts): + """Bitmask of {a ^ b : a, b in pts} (self-pairs give mask 0).""" + mask = 1 # zero via a = b + for i in range(len(pts)): + pi = pts[i] + for j in range(i): + mask |= 1 << (pi ^ pts[j]) + return mask + + +def coverage_mask_dual(pts): + """Dual predicate (PR 2542's independent check): mask m is covered iff + (pts xor m) meets pts.""" + pset = set(pts) + limit = 1 << max(pts).bit_length() if pts else 1 + mask = 0 + for m in range(limit): + if any((p ^ m) in pset for p in pts): + mask |= 1 << m + return mask + + +# --------------------------------------------------- exact small controls + + +@lru_cache(maxsize=None) +def brute_force_set_census(n, k): + """Exact census of k-point sets S (0 in S, translation WLOG) over F2^n: + returns (number of covering sets, max |S+S|). Incremental DFS over + combinations with the pair-count upper-bound prune.""" + N = 1 << n + full_mask = (1 << N) - 1 + pairs_total = k * (k - 1) // 2 + state = {"covers": 0, "best": 0} + + sums = [0] + masks = [1] # stack of coverage masks + + def rec(next_pt, depth): + size = depth + 1 + if size == k: + mask = masks[-1] + covered = mask.bit_count() + if covered > state["best"]: + state["best"] = covered + if mask == full_mask: + state["covers"] += 1 + return + remaining_pairs = pairs_total - size * (size - 1) // 2 + if masks[-1].bit_count() + remaining_pairs < N: + return + for p in range(next_pt, N): + new = 1 << p + for q in sums: + new |= 1 << (p ^ q) + sums.append(p) + masks.append(masks[-1] | new) + rec(p + 1, depth + 1) + masks.pop() + sums.pop() + + rec(1, 0) + return state["covers"], state["best"] diff --git a/research/f7-18point-avtail-seed010d26fa/vendor/agent64_search17.py b/research/f7-18point-avtail-seed010d26fa/vendor/agent64_search17.py new file mode 100644 index 0000000000..ef17635967 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/vendor/agent64_search17.py @@ -0,0 +1,330 @@ +"""Exact Sidon/near-Sidon census for the 17-point cover question (F2^7). + +Established here (receipt in SIDON-RECEIPT.json): + + * F2^6 has no Sidon 10-set. A complete DFS of all 10-subsets of the even + group E (= F2^6) containing {0, 3} finds none; Sidon-ness is translation- + invariant and GL(6,2)-invariant, and GL(6,2) is transitive on nonzero + elements, so one shard decides existence. Consequences (recorded in the + package README with the removal argument): every 10-point set has + pair-sum excess >= 1, every 11-point set has excess >= 2. This kills + the extremal (10,7) row of cover17.sharp_rows (e_ex = 0) and the (11,6) + rows e_ex in {0, 1}. + +Remaining exact search domains (row-restricted; the handoff object): + + rows (10,7): (e_ex, b_ex, c) in {(1,0,3), (1,1,4), (2,0,3)} + rows (11,6): (e_ex, b_ex, c) = (e, 6-e, 1) with e in {2,3,4,5,6} + +`enumerate_sets` is the enumeration primitive a row-restricted search builds +on (per-A constrained B-side DFS; the B side is far too large to enumerate +outright: ~3.1e8 Sidon 7-sets in the odd coset). Domain completeness for a +search: fix 0, 3 in A (GL(6,2) transitivity + stabilizer arguments, see +README); do NOT fix any element of B (the stabilizer extension fixes the +coset shift u and cannot move B's elements to it). Standard library only. +""" + +import json +import sys +import time +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) + +N = 128 +EVEN = [x for x in range(N) if x.bit_count() % 2 == 0] +ODD = [x for x in range(N) if x.bit_count() % 2 == 1] +EVEN_NZ = sum(1 << x for x in EVEN if x) # 63 even nonzero masks +ODD_ALL = sum(1 << x for x in ODD) # 64 odd masks +RECEIPT = HERE / "SIDON-RECEIPT.json" + + +# ------------------------------------------------------------ enumeration + + +def enumerate_sets(pool, k, budget, fixed=()): + """All k-subsets of `pool` containing `fixed`, of pair-sum excess + <= budget. Yields (pts, support_mask, mult) where mult maps each + supported even mask to its pair multiplicity A_x. Free elements are + chosen in increasing pool order, so each set is yielded once.""" + fixed = tuple(sorted(fixed)) + pts = list(fixed) + mult = {} + for i in range(len(pts)): + for j in range(i): + x = pts[i] ^ pts[j] + mult[x] = mult.get(x, 0) + 1 + supp = 0 + for x in mult: + supp |= 1 << x + excess = sum(mult.values()) - bin(supp).count("1") + + def rec(idx, supp, excess): + if len(pts) == k: + yield (tuple(pts), supp, dict(mult)) + return + need = k - len(pts) + for p in range(idx, len(pool) - need + 1): + v = pool[p] + if v in pts: + continue + new_sums = [v ^ q for q in pts] if pts else [] + add = 0 + coll = 0 + for x in new_sums: + if supp >> x & 1: + coll += 1 + else: + add |= 1 << x + new_excess = excess + coll + if new_excess > budget: + continue + for x in new_sums: + mult[x] = mult.get(x, 0) + 1 + pts.append(v) + yield from rec(p + 1, supp | add, new_excess) + pts.pop() + for x in new_sums: + mult[x] -= 1 + if mult[x] == 0: + del mult[x] + + yield from rec(0, supp, excess) + + +def count_sets(pool, k, budget, fixed=(), exclude=()): + """(count, first) for the same domain as enumerate_sets, without + materializing leaves (fast path for receipts).""" + fixed = tuple(sorted(fixed)) + pts = list(fixed) + supp = 0 + excess = 0 + for i in range(len(pts)): + for j in range(i): + x = pts[i] ^ pts[j] + if supp >> x & 1: + excess += 1 + else: + supp |= 1 << x + state = {"count": 0, "first": None} + + def rec(idx, supp, excess): + if len(pts) == k: + state["count"] += 1 + if state["first"] is None: + state["first"] = tuple(pts) + return + need = k - len(pts) + for p in range(idx, len(pool) - need + 1): + v = pool[p] + if v in pts: + continue + add = 0 + coll = 0 + for q in pts: + x = v ^ q + if supp >> x & 1: + coll += 1 + else: + add |= 1 << x + new_excess = excess + coll + if new_excess > budget: + continue + pts.append(v) + rec(p + 1, supp | add, new_excess) + pts.pop() + + rec(0, supp, excess) + return state["count"], state["first"] + + +def hist_sets(pool, k, budget, fixed=(), exclude=(), floor=None): + """Exact-excess histogram over the same domain: dict excess -> count, + plus one example per excess value. `floor` restricts free elements to + values > floor (sub-shard partition by the smallest free element).""" + fixed = tuple(sorted(fixed)) + excl = set(exclude) + pts = list(fixed) + supp = 0 + excess = 0 + for i in range(len(pts)): + for j in range(i): + x = pts[i] ^ pts[j] + if supp >> x & 1: + excess += 1 + else: + supp |= 1 << x + hist = {} + examples = {} + + def rec(idx, supp, excess): + if len(pts) == k: + hist[excess] = hist.get(excess, 0) + 1 + if str(excess) not in examples: + examples[str(excess)] = tuple(pts) + return + need = k - len(pts) + for p in range(idx, len(pool) - need + 1): + v = pool[p] + if v in pts or v in excl: + continue + if floor is not None and v <= floor: + continue + add = 0 + coll = 0 + for q in pts: + x = v ^ q + if supp >> x & 1: + coll += 1 + else: + add |= 1 << x + new_excess = excess + coll + if new_excess > budget: + continue + pts.append(v) + rec(p + 1, supp | add, new_excess) + pts.pop() + + rec(0, supp, excess) + return hist, examples + + +# --------------------------------------------------------------- receipt + + +def sidon_receipt(): + """The load-bearing exact counts. Shard = sets through {0, 3} in E + (complete for existence by GL(6,2) transitivity) and through {1} in O + (B-side feasibility/sizing only, not used for completeness).""" + out = {"shard_e03": {}, "shard_o1": {}} + for k, budget in ((10, 0), (9, 0), (10, 1)): + t1 = time.time() + n, first = count_sets(EVEN, k, budget, fixed=(0, 3)) + out["shard_e03"][f"k{k}_budget{budget}"] = { + "count": n, + "first": first, + "seconds": round(time.time() - t1, 1), + } + RECEIPT.write_text(json.dumps(out, indent=2, sort_keys=True), encoding="utf-8") + print(f"SIDON k={k} budget={budget} shard(0,3) n={n}", flush=True) + t1 = time.time() + n, first = count_sets(ODD, 7, 0, fixed=(1,)) + out["shard_o1"]["k7_budget0"] = { + "count": n, + "first": first, + "seconds": round(time.time() - t1, 1), + } + out["controls"] = { + "small_space_agreement": "enumerate_sets == naive brute force on the " + "even subgroup < 32: k=4 420/420, k=5 840/840, k=6 168/168" + } + RECEIPT.write_text(json.dumps(out, indent=2, sort_keys=True), encoding="utf-8") + print(f"SIDON k=7 budget=0 shard(1) odd n={n}", flush=True) + return out + + +def raw11_census(budget=4): + """Raw-domain census of 11-sets through {0, 3} with pair-sum excess + <= budget, counting by exact excess (the histogram yields the level-3 + and level-4 counts in one walk). Sub-sharded by the smallest free + element (disjoint, complete), resumable via RAW11-PROGRESS.json.""" + prog_path = HERE / "RAW11-PROGRESS.json" + prog = {"budget": budget, "shards": {}} + if prog_path.exists(): + old = json.loads(prog_path.read_text(encoding="utf-8")) + if old.get("budget") == budget: + prog = old + for v0 in EVEN: + if v0 in (0, 3): + continue + key = f"v0={v0}" + if key in prog["shards"]: + continue + t1 = time.time() + hist, examples = hist_sets( + EVEN, 11, budget, fixed=(0, 3, v0), floor=v0 + ) + prog["shards"][key] = { + "hist": {str(k): v for k, v in sorted(hist.items())}, + "examples": examples, + "seconds": round(time.time() - t1, 1), + } + prog_path.write_text( + json.dumps(prog, indent=2, sort_keys=True), encoding="utf-8" + ) + print(f"RAW11 {key} hist={hist} seconds={prog['shards'][key]['seconds']}", flush=True) + total = {} + for rec in prog["shards"].values(): + for e, n in rec["hist"].items(): + total[e] = total.get(e, 0) + n + prog["total_hist"] = {str(k): v for k, v in sorted(total.items())} + prog["complete"] = True + prog_path.write_text(json.dumps(prog, indent=2, sort_keys=True), encoding="utf-8") + print(f"RAW11 total_hist={prog['total_hist']}", flush=True) + return prog + + +def main(): + mode = sys.argv[1] if len(sys.argv) > 1 else "receipt" + if mode == "receipt": + sidon_receipt() + elif mode == "deeper": + # Follow-up census: decide whether excess 2 is attainable at all for + # 10-sets (kills the last (10,7) row (2,0,3) if not) and size the + # 11-set side (rows (11,6) with e_ex in {2, 3}). + out = {} + if RECEIPT.exists(): + out = json.loads(RECEIPT.read_text(encoding="utf-8")) + out.setdefault("shard_e03", {}) + for k, budget in ((10, 2), (11, 2)): + t1 = time.time() + n, first = count_sets(EVEN, k, budget, fixed=(0, 3)) + out["shard_e03"][f"k{k}_budget{budget}"] = { + "count": n, + "first": first, + "seconds": round(time.time() - t1, 1), + } + RECEIPT.write_text( + json.dumps(out, indent=2, sort_keys=True), encoding="utf-8" + ) + print(f"SIDON k={k} budget={budget} shard(0,3) n={n}", flush=True) + elif mode == "deeper2": + # Pin min excess(10) exactly and push the (11,6) A-side rows: + # k=11 budget b decides rows (e, 6-e, 1) with e = b. + out = {} + if RECEIPT.exists(): + out = json.loads(RECEIPT.read_text(encoding="utf-8")) + out.setdefault("shard_e03", {}) + for k, budget in ((10, 3), (11, 3), (11, 4)): + t1 = time.time() + n, first = count_sets(EVEN, k, budget, fixed=(0, 3)) + out["shard_e03"][f"k{k}_budget{budget}"] = { + "count": n, + "first": first, + "seconds": round(time.time() - t1, 1), + } + RECEIPT.write_text( + json.dumps(out, indent=2, sort_keys=True), encoding="utf-8" + ) + print(f"SIDON k={k} budget={budget} shard(0,3) n={n}", flush=True) + elif mode == "raw11": + prog = raw11_census() + if RECEIPT.exists(): + out = json.loads(RECEIPT.read_text(encoding="utf-8")) + else: + out = {} + out["k11_raw_budget4"] = { + "domain": "11-sets through {0,3} (complete by GL(6,2) " + "transitivity), sub-sharded by the smallest free element", + "total_hist": prog["total_hist"], + "sub_shards": len(prog["shards"]), + "complete": True, + } + RECEIPT.write_text(json.dumps(out, indent=2, sort_keys=True), encoding="utf-8") + else: + raise SystemExit(f"unknown mode {mode}") + + +if __name__ == "__main__": + main() diff --git a/research/f7-18point-avtail-seed010d26fa/vendor/anchors.py b/research/f7-18point-avtail-seed010d26fa/vendor/anchors.py new file mode 100644 index 0000000000..d07fa31100 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/vendor/anchors.py @@ -0,0 +1,128 @@ +"""Resumable recomputation of the two heavy PR 2773 census anchors (KB3d). + +Established method (PR 2773, package research/f7-17point-cover-audit-seedcfa215c2, +Aaron Wang): raw-domain walk over the even group E = F2^6, complete +GL(6,2)-transitive domain through {0, 3}, sub-sharded by the smallest free +element (disjoint and complete), resumable with per-sub-shard receipts in +ANCHOR-PROGRESS.json. The enumeration itself is the vendored PR 2773 engine +(vendor/agent64_search17.py, byte-pinned; credit: Aaron Wang, PR 2773). + + anchors.py k10b3 [--seconds S] 10-sets through {0,3}, excess <= 3 + (recorded anchor: 149,990,400) + anchors.py k11b4 [--seconds S] 11-sets through {0,3}, excess <= 4 + (recorded anchor: level3 = level4 = 0) + +Each invocation processes sub-shards until the elapsed budget (default 540 s), +writes receipts after every sub-shard, and exits 0; re-invoke to continue. +A completed run prints PASS_ANCHORS_ with the exact totals and compares +them with the recorded anchor values. +""" + +import json +import sys +import time +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE / "vendor")) + +import agent64_search17 as s17 + +PROGRESS = HERE / "ANCHOR-PROGRESS.json" + +MODES = { + "k10b3": { + "k": 10, + "budget": 3, + "anchor_count": 149990400, + "description": "10-sets through {0,3}, pair-sum excess <= 3", + }, + "k11b4": { + "k": 11, + "budget": 4, + "anchor_count": 0, + "description": "11-sets through {0,3}, pair-sum excess <= 4", + }, +} + + +def load_progress(mode): + """Per-mode sections in one file (v1 kept one mode per file and lost the + other mode's receipts when switching; migrated on read).""" + data = {"modes": {}} + if PROGRESS.exists(): + old = json.loads(PROGRESS.read_text(encoding="utf-8")) + if "modes" in old: + data = old + elif "mode" in old: + data["modes"][old["mode"]] = { + k: v for k, v in old.items() if k != "mode" + } + return data["modes"].setdefault(mode, {"shards": {}}) + + +def save_progress(mode, prog): + data = {"modes": {}} + if PROGRESS.exists(): + old = json.loads(PROGRESS.read_text(encoding="utf-8")) + if "modes" in old: + data = old + elif "mode" in old: + data["modes"][old["mode"]] = { + k: v for k, v in old.items() if k != "mode" + } + data["modes"][mode] = prog + PROGRESS.write_text(json.dumps(data, indent=2, sort_keys=True), encoding="utf-8") + + +def main(): + mode = sys.argv[1] if len(sys.argv) > 1 else "" + if mode not in MODES: + raise SystemExit("usage: anchors.py k10b3|k11b4 [--seconds S]") + budget_seconds = 540.0 + if "--seconds" in sys.argv: + budget_seconds = float(sys.argv[sys.argv.index("--seconds") + 1]) + spec = MODES[mode] + prog = load_progress(mode) + prog["spec"] = {k: v for k, v in spec.items()} + t_start = time.time() + for v0 in sorted(s17.EVEN): + if v0 in (0, 3): + continue + key = f"v0={v0}" + if key in prog["shards"]: + continue + t1 = time.time() + hist, examples = s17.hist_sets( + s17.EVEN, spec["k"], spec["budget"], fixed=(0, 3, v0), floor=v0 + ) + prog["shards"][key] = { + "hist": {str(e): n for e, n in sorted(hist.items())}, + "examples": examples, + "seconds": round(time.time() - t1, 2), + } + save_progress(mode, prog) + print( + f"ANCHOR {mode} {key} hist={prog['shards'][key]['hist']}" + f" seconds={prog['shards'][key]['seconds']}" + f" done={len(prog['shards'])}/62", + flush=True, + ) + if time.time() - t_start > budget_seconds: + print(f"RECEIPT {mode} checkpoint shards={len(prog['shards'])}/62", flush=True) + return + total = {} + for rec in prog["shards"].values(): + for e, n in rec["hist"].items(): + total[e] = total.get(e, 0) + n + count = sum(total.values()) + prog["total_hist"] = {str(e): n for e, n in sorted(total.items())} + prog["complete"] = True + save_progress(mode, prog) + assert count == spec["anchor_count"], (mode, count, spec["anchor_count"]) + print(f"PASS_ANCHORS_{mode.upper()} count={count} total_hist={prog['total_hist']} shards=62", flush=True) + + +if __name__ == "__main__": + sys.stdout.reconfigure(encoding="utf-8") + main() diff --git a/research/f7-18point-avtail-seed010d26fa/vendor/cover18.py b/research/f7-18point-avtail-seed010d26fa/vendor/cover18.py new file mode 100644 index 0000000000..3faa640d79 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/vendor/cover18.py @@ -0,0 +1,741 @@ +"""KB3e engine: the 18-point cover question for F2^7. + +Object. In the PR943 prefix-walk model (Ross Richardson, +`research/universal-connector-boundary`, PR 943) a restored seven-source +singleton word is universal exactly when its prefix set `P` covers: +`P + P = F2^7` (every mask of F2^7 is a pair-sum `a + b` of two elements of the +set; self-pairs `a + a` cover mask 0, and the sumset is translation-invariant +so WLOG `0 in S`). PR 2542 (Aaron Wang) excludes length 18 and asserts "no +17-point set covers F2^7"; PR 2773 (Aaron Wang) audits it split-by-split and +PR 2870 (Aaron Wang) closes the remainder rows (5,1),(6,0) with an exact +odd-coverage Fourier/Parseval identity. This module asks the immediate +successor question: **does any 18-point set cover F2^7?** + +Parity splits. S = A u B with A = S int E (s points, even-weight coset) and +B = S int O (t points, odd-weight coset), s + t = 18. The counting-feasible +splits are (12,6), (11,7), (10,8), (9,9) and their mirrors; every 18-point +split has s and t of EQUAL parity (18 is even), which is exactly the case the +PR 2870 squeeze does not reach (its hypothesis is opposite parity). + +Three layers of evidence are computed here, all exact integer arithmetic: + +1. `fourier_profile_feasibility(n, s, t)` -- a per-character profile system + (necessary conditions for a cover): parity of characters, the odd-half + bound |f_hat g_hat| = |rho_hat| <= E_o with rho_hat == E_o (mod 2), the + even-half bound f_hat^2 + g_hat^2 <= s + t + 2*P - 2^n (P = C(s,2)+C(t,2)), + Parseval on both sides, and the exact attainable sums of squares of rho. + Infeasibility of the system PROVES the split impossible; feasibility only + says the Fourier layer does not exclude it. The system reproduces the + PR 2870 exclusion of (11,6)/(6,11) (control in test_engine.py). +2. `sharp_rows_fast(n, s, t)` -- PR 2773's pair-representation rows + (e_ex, b_ex, c), reusing its byte-vendored shape/draw primitives with a + contingency-table pairing-sums replacement that the vendored O(m!) pairing + loop cannot run at the 18-point row sizes. Census floors (min pair-sum + excess of k-sets in F2^6) demote rows exactly as in PR 2773. +3. `search_split(...)` / `search_direct(...)` -- a bounded, seeded local + search for a covering pair (A, D) resp. an 18-point set. A found cover is + a falsifying instance for "no 18-point cover exists"; a failed bounded + search is recorded as a scoped search failure, never as an exclusion. + +Reduction lemma (checked exhaustively at n = 3 in test_engine.py). Fix an +odd mask p and set D = p + B (a subset of E). Then S = A u B covers F2^n iff +(i) A + D = E and (ii) (A + A) u (D + D) = E. So every split (s, t) is a +two-set covering problem in the even group E =~ F2^6. + +All arithmetic is exact Python integers; no floats are used. +""" + +import random +import time +from collections import Counter +from functools import lru_cache +from itertools import combinations +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE / "vendor")) + +import agent64_cover17 as c17 # noqa: E402 + +# Byte pins of the vendored PR 2773 engine (credit: Aaron Wang, PR 2773, +# head 6739c799799621878a9249c93e2b12cc799c1482; extracted with +# agent_tools.py pr-tree-extract from PR 2870's hash-pinned vendor/). +VENDOR_PIN_COVER17 = ( + "082bc838134cba9754368cff894d53c729467a689b4cafee8374423688d93654" +) +VENDOR_PIN_SEARCH17 = ( + "9eb1bf79ffb99b0efcdaf57916c493bc781abd4a0096d584dc6bc6ca294bf674" +) + + +# ------------------------------------------------------------- coverage + + +def dot(s, x): + return (s & x).bit_count() & 1 + + +def coverage_mask(pts): + """Bitmask of {a ^ b : a, b in pts} (self-pairs give mask 0).""" + mask = 1 + for i in range(len(pts)): + pi = pts[i] + for j in range(i): + mask |= 1 << (pi ^ pts[j]) + return mask + + +def covers(pts, n=7): + return coverage_mask(pts) == (1 << (1 << n)) - 1 + + +def split_of(pts): + e = sum(1 for p in pts if not dot(127, p)) + return (e, len(pts) - e) + + +def even_masks(n=7): + return [x for x in range(1 << n) if not dot((1 << n) - 1, x)] + + +def odd_masks(n=7): + return [x for x in range(1 << n) if dot((1 << n) - 1, x)] + + +def _pair_mask(pts): + """Bitmask over the 128 masks of {a ^ b : a, b in pts} (0 via a = b).""" + return coverage_mask(pts) + + +def _covers_all(mask, universe): + return (mask & universe) == universe + + +def reduction_conditions(A, B, n=7): + """(odd_ok, even_ok) of the (A, D) reduction. D = p + B for an odd p; + A u B covers F2^n iff odd_ok and even_ok both hold.""" + p = 1 + D = [p ^ b for b in B] + ev = even_masks(n) + universe = 0 + for x in ev: + universe |= 1 << x + cross = 0 + for a in A: + for d in D: + cross |= 1 << (a ^ d) + selfs = _pair_mask(A) | _pair_mask(D) + return _covers_all(cross, universe), _covers_all(selfs, universe) + + +# ------------------------------------------------------- rho bookkeeping + + +def _partitions(total): + if total == 0: + yield () + return + for part in range(total, 0, -1): + for rest in _partitions(total - part): + if not rest or rest[0] <= part: + yield (part,) + rest + + +@lru_cache(maxsize=None) +def rho_square_values(excess): + """Attainable sums of squares sum rho_x^2 over integer rho >= 0 with + sum rho_x = excess (partition square sums). Domain guard: excess <= 24 + (all splits this package decides have E_o <= 17); beyond that the + partition enumeration is out of budget and callers must treat the split + as not attempted, never as excluded.""" + if excess > 24: + raise ValueError("rho_square_values: excess %d out of budget" % excess) + return sorted({sum(j * j for j in parts) for parts in _partitions(excess)}) + + +# ------------------------------------------------- Fourier profile system + + +def even_half_max(n, s, t): + """Max of f_hat^2 + g_hat^2 off the all-ones hyperplane, from the even + half of the covering condition: s + t + 2*P - 2^n, P = C(s,2)+C(t,2).""" + P = s * (s - 1) // 2 + t * (t - 1) // 2 + return s + t + 2 * P - (1 << n) + + +def shapes_fourier(n, s, t, nonzero_both=False): + """Admissible per-character shapes (f2, g2, p2) = (f_hat^2, g_hat^2, + (f_hat*g_hat)^2) off {0, 1}: character parities, |rho_hat| <= E_o with + rho_hat == E_o (mod 2), and the even-half bound. nonzero_both restricts + to shapes with both characters nonzero (the no-vanishing sub-case).""" + eo = s * t - (1 << (n - 1)) + if eo < 0: + return [] + bound = even_half_max(n, s, t) + out = [] + for a in range(0, s + 1): + if a % 2 != s % 2: + continue + if nonzero_both and a == 0: + continue + for b in range(0, t + 1): + if b % 2 != t % 2: + continue + if nonzero_both and b == 0: + continue + prod = a * b + if prod > eo or prod % 2 != eo % 2: + continue + if a * a + b * b > bound: + continue + out.append((a * a, b * b, prod * prod)) + return out + + +def _solve_counts(shapes, U, RF, RG, RP, cap=4000000): + """First nonneg integer solution of sum n_i = U, sum n_i f2_i = RF, + sum n_i g2_i = RG, sum n_i p2_i = RP, or None. Returns (solution, nodes) + with nodes = "cap" when the step cap is hit (caller must treat as + undecided, never as infeasible).""" + m = len(shapes) + if m == 0: + if U == 0 and RF == 0 and RG == 0 and RP == 0: + return ([], 0) + return (None, 0) + order = sorted(range(m), key=lambda i: -shapes[i][0]) + shp = [shapes[i] for i in order] + sol = [0] * m + nodes = [0] + + # suffix min/max of each coefficient for bound pruning + smin_f = [0] * (m + 1) + smax_f = [0] * (m + 1) + smin_g = [0] * (m + 1) + smax_g = [0] * (m + 1) + smin_p = [0] * (m + 1) + smax_p = [0] * (m + 1) + for i in range(m - 1, -1, -1): + f2, g2, p2 = shp[i] + smin_f[i] = min(f2, smin_f[i + 1]) + smax_f[i] = max(f2, smax_f[i + 1]) + smin_g[i] = min(g2, smin_g[i + 1]) + smax_g[i] = max(g2, smax_g[i + 1]) + smin_p[i] = min(p2, smin_p[i + 1]) + smax_p[i] = max(p2, smax_p[i + 1]) + + def rec(i, u_rem, rf, rg, rp): + nodes[0] += 1 + if nodes[0] > cap: + return "cap" + if i == m - 1: + f2, g2, p2 = shp[i] + if u_rem >= 0 and rf == u_rem * f2 and rg == u_rem * g2 and rp == u_rem * p2: + sol[i] = u_rem + return True + return False + f2, g2, p2 = shp[i] + hi = u_rem + if f2: + hi = min(hi, rf // f2) + if g2: + hi = min(hi, rg // g2) + if p2: + hi = min(hi, rp // p2) + for k in range(hi, -1, -1): + ru, rff, rgg, rpp = u_rem - k, rf - k * f2, rg - k * g2, rp - k * p2 + if ru < 0 or rff < 0 or rgg < 0 or rpp < 0: + continue + if rff > ru * smax_f[i + 1] or rff < ru * smin_f[i + 1]: + continue + if rgg > ru * smax_g[i + 1] or rgg < ru * smin_g[i + 1]: + continue + if rpp > ru * smax_p[i + 1] or rpp < ru * smin_p[i + 1]: + continue + sol[i] = k + got = rec(i + 1, ru, rff, rgg, rpp) + if got == "cap": + return "cap" + if got: + return True + sol[i] = 0 + return False + + got = rec(0, U, RF, RG, RP) + if got == "cap": + return (None, "cap") + if got: + out = [0] * m + for slot, orig in enumerate(order): + out[orig] = sol[slot] + return (out, nodes[0]) + return (None, nodes[0]) + + +def fourier_profile_feasibility(n, s, t, nonzero_both=False): + """Necessary-condition system for an (s,t) split at F2^n. `feasible` + False PROVES the odd half (hence the cover) impossible; `feasible` True + means only that this Fourier layer does not exclude the split. With + nonzero_both=True the system is restricted to per-characters with both + sides nonzero: infeasibility then PROVES every cover of this split must + have at least one vanishing character off {0, 1}.""" + eo = s * t - (1 << (n - 1)) + res = { + "n": n, + "split": (s, t), + "odd_excess": eo, + "nonzero_both": nonzero_both, + "even_half_max": even_half_max(n, s, t), + } + if eo < 0: + res["feasible"] = False + res["reason"] = "counting: fewer cross pairs than odd masks" + res["feasible_S"] = [] + return res + if eo > 24: + res["feasible"] = None + res["reason"] = "E_o out of the rho-square enumeration budget: not attempted" + res["feasible_S"] = [] + return res + shapes = shapes_fourier(n, s, t, nonzero_both=nonzero_both) + res["shapes"] = shapes + U = (1 << n) - 2 + RF = (1 << n) * s - 2 * s * s + RG = (1 << n) * t - 2 * t * t + res["parseval_remainders"] = (RF, RG) + feasible_S = [] + example = None + capped = False + for S in rho_square_values(eo): + RP = (1 << n) * S - 2 * eo * eo + sol, nodes = _solve_counts(shapes, U, RF, RG, RP) + if nodes == "cap": + capped = True + continue + if sol is not None: + feasible_S.append(S) + if example is None: + example = {"S": S, "counts": sol} + res["feasible_S"] = feasible_S + res["example"] = example + res["capped"] = capped + if capped: + res["feasible"] = True + res["reason"] = ( + "step cap hit for some S values: undecided for those (never a " + "proof of impossibility); S values listed are the feasible ones" + ) + elif feasible_S: + res["feasible"] = True + res["reason"] = ( + "profile system consistent for S in %s; no Fourier contradiction" + % sorted(feasible_S) + ) + else: + res["feasible"] = False + res["reason"] = ( + "profile system infeasible for every attainable rho square sum: " + "no integer character profile satisfies parity, |rho_hat| <= E_o, " + "the even-half bound and Parseval simultaneously" + ) + return res + + +def witness_constraints_ok(A, B, n=7): + """Direct validation of every profile-system constraint on an actual + covering pair (A, B). Used as the soundness control: a real cover can + never violate a constraint the system uses.""" + N = 1 << n + half = 1 << (n - 1) + eo = len(A) * len(B) - half + if eo < 0: + return False + s, t = len(A), len(B) + # odd half: r = 1_A * 1_B >= 1 on O + r = [0] * N + for a in A: + for b in B: + r[a ^ b] += 1 + odds = [x for x in range(N) if dot(N - 1, x)] + if any(r[x] < 1 for x in odds): + return False + rho = {x: r[x] - 1 for x in odds if r[x] > 1} + if sum(rho.values()) != eo: + return False + # even half: A_x + B_x >= 1 on E \ {0} + pairA = Counter() + pairB = Counter() + for i in range(len(A)): + for j in range(i): + pairA[A[i] ^ A[j]] += 1 + for i in range(len(B)): + for j in range(i): + pairB[B[i] ^ B[j]] += 1 + evs = [x for x in range(N) if not dot(N - 1, x) and x != 0] + if any(pairA[x] + pairB[x] < 1 for x in evs): + return False + P = s * (s - 1) // 2 + t * (t - 1) // 2 + bound = s + t + 2 * P - N + # characters off {0, 1} + for u in range(N): + if u in (0, N - 1): + continue + f_hat = sum(1 - 2 * dot(u, a) for a in A) + g_hat = sum(1 - 2 * dot(u, b) for b in B) + if f_hat % 2 != s % 2 or g_hat % 2 != t % 2: + return False + rho_hat = sum(c * (1 - 2 * dot(u, x)) for x, c in rho.items()) + if f_hat * g_hat != rho_hat: + return False + if abs(rho_hat) > eo or rho_hat % 2 != eo % 2: + return False + if f_hat * f_hat + g_hat * g_hat > bound: + return False + return True + + +def squeeze_numbers(n, s, t): + """The PR 2870-style Parseval deficit bookkeeping for one split, extended + to equal parity: per-side remainders vs the strongest uniform character + bound the parity class allows.""" + eo = s * t - (1 << (n - 1)) + N = 1 << n + res = {"n": n, "split": (s, t), "odd_excess": eo} + if eo < 0: + res.update( + bounded_side=None, + parseval_remainder=None, + max_allowed=None, + deficit=None, + contradiction=True, + reason="counting: fewer cross pairs than odd masks", + ) + return res + opposite = (s % 2) != (t % 2) + sides = [] + for name, card, par in (("A", s, s % 2), ("B", t, t % 2)): + remainder = N * card - 2 * card * card + if opposite and par == 0: + max_char = 2 * (eo // 2) # largest even <= E_o + elif (not opposite) and par == 1: + max_char = eo if eo % 2 == 1 else eo - 1 # largest odd <= E_o + else: + max_char = None # side can vanish: no uniform bound + allowed = None if max_char is None else (N - 2) * max_char * max_char + deficit = None if allowed is None else remainder - allowed + sides.append( + dict( + side=name, + cardinality=card, + max_char=max_char, + parseval_remainder=remainder, + max_allowed=allowed, + deficit=deficit, + ) + ) + res["opposite_parity"] = opposite + res["sides"] = sides + if opposite: + bounded = next(x for x in sides if x["max_char"] is not None) + res.update( + bounded_side=bounded["side"], + parseval_remainder=bounded["parseval_remainder"], + max_allowed=bounded["max_allowed"], + deficit=bounded["deficit"], + contradiction=bounded["deficit"] > 0, + reason=( + "PR 2870 squeeze applies (opposite parity): %d > %d" + % (bounded["parseval_remainder"], bounded["max_allowed"]) + if bounded["deficit"] > 0 + else "PR 2870 squeeze applies but reaches no contradiction" + ), + ) + else: + res.update( + bounded_side=None, + parseval_remainder=None, + max_allowed=None, + deficit=None, + contradiction=False, + reason=( + "equal character parities (s+t even): PR 2870's squeeze " + "hypothesis fails for this split; see sides[] for the " + "equal-parity remainders vs bounds" + ), + ) + return res + + +# ------------------------------------------------------ pairing sums + + +def pairing_sums(da, db): + """All sums sum_i a_i b_{pi(i)} over bijections pi of two equal-length + multisets, by contingency-table enumeration (the vendored O(m!) loop + cannot run at 18-point row sizes).""" + ca = Counter(da) + cb = Counter(db) + va = sorted(ca) + vb = sorted(cb) + acounts = [ca[v] for v in va] + bcounts = [cb[v] for v in vb] + out = set() + + def rec(i, caps, acc): + if i == len(va): + if all(c == 0 for c in caps): + out.add(acc) + return + need = acounts[i] + va_i = va[i] + + def dist(j, remaining, add): + if j == len(vb) - 1: + if remaining <= caps[j]: + caps[j] -= remaining + rec(i + 1, caps, acc + add + va_i * vb[j] * remaining) + caps[j] += remaining + return + for take in range(min(caps[j], remaining) + 1): + caps[j] -= take + dist(j + 1, remaining - take, add + va_i * vb[j] * take) + caps[j] += take + + dist(0, need, 0) + + rec(0, list(bcounts), 0) + return out + + +@lru_cache(maxsize=None) +def _pairing_sums_cached(da, db): + return frozenset(pairing_sums(da, db)) + + +@lru_cache(maxsize=None) +def draw_multisets(shared, budget, min_excess=0): + """Deduped draws: multisets of `shared` values >= 1 with total excess + sum(v-1) in [min_excess, budget]. (Embeddable in some multiplicity shape + of support `shared` + complement with total excess `budget`.)""" + out = set() + + def rec(lo, remaining, excess_left, acc): + if remaining == 0: + out.add(tuple(sorted(acc))) + return + for v in range(lo, excess_left + 2): + new_left = excess_left - (v - 1) + if new_left < 0: + break + rec(v, remaining - 1, new_left, acc + [v]) + + for used in range(min_excess, budget + 1): + rec(1, shared, used, []) + return sorted(out) + + +def attainable_c_values(n, s, t, e_ex, b_ex, targets=None, cap=200000): + """Exact attainable c = sum_x A_x B_x on the shared support positions + (targets given: only membership in targets is decided). Returns + (values_or_flags, status) with status in {"exact", "capped"}.""" + odd_masks_n = 1 << (n - 1) + even_nonzero = odd_masks_n - 1 + A = s * (s - 1) // 2 + B = t * (t - 1) // 2 + shared = A + B - e_ex - b_ex - even_nonzero + if shared < 0: + return (set(), "exact") + if shared == 0: + return ({0}, "exact") + comp_a = A - e_ex - shared + comp_b = B - b_ex - shared + das = draw_multisets(shared, e_ex, e_ex if comp_a == 0 else 0) + dbs = draw_multisets(shared, b_ex, b_ex if comp_b == 0 else 0) + found = set() + steps = 0 + for da in das: + for db in dbs: + steps += 1 + if steps > cap: + return (found, "capped") + vals = _pairing_sums_cached(da, db) + if targets is not None: + found |= vals & set(targets) + else: + found |= vals + return (found, "exact") + + +# ------------------------------------------------------------ rows + + +def max_attain(e_ex, b_ex, shared): + """Largest attainable c for one row (rearrangement on the extreme draws).""" + if shared <= 0: + return 0 + return (e_ex + 1) * (b_ex + 1) + shared - 1 + + +def sharp_rows_fast(n, s, t, min_e_ex=0, min_b_ex=0, cap=200000): + """PR 2773's sharp pair-representation rows for one split, with census + floors applied. Row status: "sharp" (exact attainability computed), + "interval" (kept conservatively: exact check capped), "dead" (dropped).""" + odd_masks_n = 1 << (n - 1) + even_nonzero = odd_masks_n - 1 + A = s * (s - 1) // 2 + B = t * (t - 1) // 2 + excess = s * t - odd_masks_n + need = (excess + 1) // 2 if excess > 0 else 0 + c_vals = c17.profile_c_values(n, s, t) + rows = [] + best = -1 + capped_rows = 0 + if excess < 0 or A + B < even_nonzero: + return dict(feasible=False, rows=[], best=best, need=need, c_vals=c_vals) + for e_ex in range(min_e_ex, A + 1): + for b_ex in range(min_b_ex, B + 1): + shared = A + B - e_ex - b_ex - even_nonzero + if shared < 0: + continue + attain, status = attainable_c_values(n, s, t, e_ex, b_ex, cap=cap) + if status == "capped": + capped_rows += 1 + best = max(best, max_attain(e_ex, b_ex, shared)) + hits = [c for c in c_vals if c <= max_attain(e_ex, b_ex, shared)] + for c in hits: + rows.append( + dict(e_ex=e_ex, b_ex=b_ex, shared=shared, c=c, status="interval") + ) + continue + if not attain: + continue + best = max(best, max(attain)) + for c in sorted(set(attain) & set(c_vals)): + rows.append( + dict(e_ex=e_ex, b_ex=b_ex, shared=shared, c=c, status="sharp") + ) + return dict( + feasible=bool(rows), + rows=rows, + best=best, + need=need, + c_vals=c_vals, + capped_rows=capped_rows, + ) + + +def surviving_rows_fast(n, s, t, min_e_ex=0, min_b_ex=0): + return sharp_rows_fast(n, s, t, min_e_ex=min_e_ex, min_b_ex=min_b_ex) + + +# ------------------------------------------------------------- search + + +def _score_pair(A, D, ev_index): + """Coverage score of a candidate (A, D) pair over the even group: + |A + D| + |(A+A) u (D+D)|, target 128 (two sets of 64).""" + cross = set(a ^ d for a in A for d in D) + selfs = set(a ^ a2 for i, a in enumerate(A) for a2 in A[i:]) + selfs |= set(d ^ d2 for i, d in enumerate(D) for d2 in D[i:]) + return len(cross) + len(selfs) + + +def search_split(s, t, restarts=20, seed=1, seconds=20.0, n=7): + """Bounded seeded local search for a covering pair (A, D) in the even + group E =~ F2^6 with |A| = s, |D| = t (reduction lemma). A found pair is + a falsifying instance; otherwise a scoped search failure.""" + rng = random.Random(seed) + ev = even_masks(n) + pool = ev[:] + best = (0, None) + t0 = time.time() + moves = 0 + for _ in range(restarts): + if time.time() - t0 > seconds: + break + A = rng.sample(pool, s) + D = rng.sample(pool, t) + sc = _score_pair(A, D, None) + improved = True + while improved and time.time() - t0 < seconds: + improved = False + for side, size in ((0, s), (1, t)): + cur = A if side == 0 else D + outside = [x for x in pool if x not in cur] + for i in range(size): + for v in outside: + moves += 1 + old = cur[i] + cur[i] = v + new = _score_pair(A, D, None) + if new > sc: + sc = new + improved = True + outside[outside.index(v)] = old + if sc == 128: + return dict( + found=True, + score=128, + A=sorted(A), + D=sorted(D), + restarts=_, + moves=moves, + seconds=round(time.time() - t0, 2), + ) + else: + cur[i] = old + if sc > best[0]: + best = (sc, (sorted(A), sorted(D))) + return dict( + found=False, + score=best[0], + best_pair=best[1], + restarts=restarts, + moves=moves, + seconds=round(time.time() - t0, 2), + ) + + +def search_direct(k=18, restarts=30, seed=1, seconds=20.0, n=7): + """Bounded seeded local search for a k-point cover of F2^n directly + (0 in S, translation WLOG).""" + rng = random.Random(seed) + pool = list(range(1 << n)) + best = (0, None) + t0 = time.time() + for _ in range(restarts): + if time.time() - t0 > seconds: + break + S = [0] + rng.sample(pool[1:], k - 1) + sc = coverage_mask(S).bit_count() + improved = True + while improved and time.time() - t0 < seconds: + improved = False + outside = [x for x in pool if x not in S] + for i in range(1, k): + for v in outside: + old = S[i] + S[i] = v + new = coverage_mask(S).bit_count() + if new > sc: + sc = new + improved = True + outside[outside.index(v)] = old + if sc == (1 << n): + return dict( + found=True, + score=sc, + S=sorted(S), + seconds=round(time.time() - t0, 2), + ) + else: + S[i] = old + if sc > best[0]: + best = (sc, sorted(S)) + return dict( + found=False, + score=best[0], + best_set=best[1], + restarts=restarts, + seconds=round(time.time() - t0, 2), + ) diff --git a/research/f7-18point-avtail-seed010d26fa/vendor/tight.py b/research/f7-18point-avtail-seed010d26fa/vendor/tight.py new file mode 100644 index 0000000000..2e0e151ccf --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/vendor/tight.py @@ -0,0 +1,760 @@ +"""KB3g engine: tight-class resolution for the 18-point cover question for +F2^7 (set level; no words). Exact Python integer arithmetic only. + +Object (unchanged from PR 2911/2933): S = A u B covers F2^7 iff P + P = F2^7. +With D = p + B inside E = F2^6 (PR 2911 reduction, PROVEN there) the pair +(A, D) covers iff (i) A + D = E and (ii) (A+A) u (D+D) = E. + +This module decides the two PR 2933 TIGHT classes of the (10,8) split and +the full-sumset class (6,0) of (12,6) by exact enumeration of the L7-forced +Sidon equality configurations. All arithmetic is integers; masks are Python +ints. + +Halves. Fix the character psi = bit 0 (WLOG under GL(6,2)). H = ker(psi) +and the coset H' are both identified with F2^5 = {0..31}; every cross sum is +the XOR of the two F2^5 coordinates (the coset offset cancels in pairs, and +H'-valued sums are read in H' coordinates). A = A0 u A1 with A0 in H, A1 in +H'; D = D0 u D1 likewise. Coverage is equivalent to the four L3 lines +(PR 2933, PROVEN): + + (i) (A0+D0) u (A1+D1) = H + (ii) (A0+D1) u (A1+D0) = H' + (iii) (A0+A0) u (A1+A1) u (D0+D0) u (D1+D1) = H + (iv) (A0+A1) u (D0+D1) = H' + +Half-translations (h on (A0,D0), h' on (A1,D1)) and a common GL(5,2) map M +preserve all four lines (each H'-valued sumset translates by h + h', which +preserves its being all of H'). Hence WLOG 0 in A0, 0 in A1. + +L7 (PR 2933, PROVEN; general pigeonhole valid at m = 6): at F1 equality +a0*a1 + d0*d1 = 32 with (iv) holding, |A0+A1| = a0*a1, |D0+D1| = d0*d1 (both +Sidon: all cross sums distinct) and the two cross sumsets are disjoint with +union H'. + +Class (10,8) A-vanish (7,1): A0, A1 5-sets with |A0+A1| = 25; D0 a 7-set, +D1 a singleton {d1}. (iv) forces D0 + d1 = T := H' \\ (A0+A1) (7 points). +Substituting D0 = T + d1 into (i)-(iii) and translating by d1 shows coverage +is INDEPENDENT of d1: + (I) (A0+T) u A1 = F2^5 + (II) (A1+T) u A0 = F2^5 + (III) (A0+A0) u (A1+A1) u (T+T) = F2^5 +and (iv) holds by construction. Each covering (A0, A1) yields 32 covering +configurations (one per d1) in the normalized chart. + +Class (10,8) D-vanish (8,2): D0, D1 4-sets with |D0+D1| = 16; A splits +(8,2): A0 an 8-set, A1 = {w, w+delta}, delta != 0. |A0+A1| = 16 iff +A0 u (A0+delta) = 16 points iff A0 n (A0+delta) = 0. Normalize instead on +the D side: 0 in D0, 0 in D1 (the class forces both nonempty), and WLOG +delta = 1 under GL(5,2). With T = D0+D1 (16 points) and C = H' \\ T, +(iv) forces A0 + w to choose one element of each pair {x, x+1} inside C, so +C must be 1-invariant; the choice is one of at most 2^8 sets A0t = A0 + w. +Coverage is then independent of w: + (I') (A0t+D0) u (D1+{0,1}) = F2^5 + (II') (A0t+D1) u (D0+{0,1}) = F2^5 + (III') (A0t+A0t) u {0,1} u (D0+D0) u (D1+D1) = F2^5 + +Class (12,6) A-vanish (6,0): A0, A1 6-sets with A0+A1 = H' (36 pairs, excess +exactly 4), D = D0 a 6-set in H, D1 empty. Lines reduce to + (I'') A0+D = F2^5, (II'') A1+D = F2^5, + (III'') (A0+A0) u (A1+A1) u (D+D) = F2^5. +Normalize 0 in A0, 0 in A1. +""" + +import json +import sys +import time +from itertools import combinations +from pathlib import Path + +ALL = (1 << 32) - 1 +N5 = 32 + + +# ------------------------------------------------------- mask primitives + + +def elems(mask): + out = [] + while mask: + lsb = mask & -mask + out.append(lsb.bit_length() - 1) + mask ^= lsb + return out + + +def mask_of(pts): + m = 0 + for p in pts: + m |= 1 << p + return m + + +# Precomputed per-bit XOR-translation block masks (5 bits, F2^5). +_BIT_LO = [] +_BIT_HI = [] +for _i in range(5): + _b = 1 << _i + _lo = 0 + for _p in range(N5): + if not (_p & _b): + _lo |= 1 << _p + _BIT_LO.append(_lo) + _BIT_HI.append(ALL ^ _lo) + + +def trans(mask, a): + """{x ^ a : x in mask} as a bitmask.""" + for i in range(5): + if (a >> i) & 1: + b = 1 << i + mask = ((mask & _BIT_LO[i]) << b) | ((mask & _BIT_HI[i]) >> b) + return mask + + +def sumset_mask(mx, my): + """{x ^ y : x in mx, y in my}.""" + out = 0 + x = mx + while x: + lsb = x & -x + out |= trans(my, lsb.bit_length() - 1) + x ^= lsb + return out + + +def selfsum_mask(mx): + """{x ^ y : x, y in mx} (includes 0).""" + return sumset_mask(mx, mx) + + +def delta_mask(mx): + """{x ^ y : x != y in mx} = selfsum minus {0}.""" + return selfsum_mask(mx) & ALL & ~1 + + +def sidon_cross(mx, my, px, py): + """|X+Y| = |X|*|Y| with sizes px, py (all cross sums distinct).""" + return sumset_mask(mx, my).bit_count() == px * py + + +# ------------------------------------------- class (7,1) at (10,8) + + +def class71_pairs(): + """All normalized Sidon 5-pairs: 0 in A0, 0 in A1, |A0+A1| = 25. + Backtracks A0 = {0, a1, a2, a3, a4} against the forbidden difference + set of A1 (condition Delta(A0) n Delta(A1) = 0).""" + out = [] + rest = list(range(1, N5)) + + def extend(a1m): + forb = delta_mask(a1m) + cand = [v for v in rest if not (forb >> v) & 1] + chosen = [0, 0, 0, 0, 0] + + def rec(depth, start): + if depth == 5: + out.append((mask_of(chosen), a1m)) + return + for i in range(start, len(cand)): + v = cand[i] + if v <= chosen[depth - 1]: + continue + ok = True + for j in range(1, depth): + if (forb >> (v ^ chosen[j])) & 1: + ok = False + break + if ok: + chosen[depth] = v + rec(depth + 1, i + 1) + + rec(1, 0) + + for bs in combinations(rest, 4): + a1m = 1 | mask_of(bs) + extend(a1m) + return out + + +def class71_check(a0m, a1m): + """The three translated coverage lines (I),(II),(III) for one pair. + Returns (ok, which_lines_fail).""" + sums = sumset_mask(a0m, a1m) + if sums.bit_count() != 25: + return False, ("sidon",) + tm = ALL ^ sums + fails = [] + if (sumset_mask(a0m, tm) | a1m) != ALL: + fails.append("I") + if (sumset_mask(a1m, tm) | a0m) != ALL: + fails.append("II") + if (selfsum_mask(a0m) | selfsum_mask(a1m) | selfsum_mask(tm)) != ALL: + fails.append("III") + return (not fails), tuple(fails) + + +def class71_run(progress=None, budget=None): + """Full decision run for class (7,1). Counts every normalized equality + configuration (A0, A1, d1) and every covering one; records witnesses.""" + t0 = time.time() + pairs = class71_pairs() + total = len(pairs) + checked = 0 + covering = 0 + fail_hist = {} + witnesses = [] + for (a0m, a1m) in pairs: + ok, fails = class71_check(a0m, a1m) + checked += 1 + if ok: + covering += 1 + if len(witnesses) < 5: + witnesses.append((elems(a0m), elems(a1m))) + else: + fail_hist[fails] = fail_hist.get(fails, 0) + 1 + if budget is not None and checked % 5000 == 0 and time.time() - t0 > budget: + break + return dict( + normalized_pairs=total, + checked=checked, + covering_pairs=covering, + equality_configs_normalized=total * 32, + covering_configs_normalized=covering * 32, + fail_hist={str(k): v for k, v in sorted(fail_hist.items())}, + witnesses=witnesses, + seconds=round(time.time() - t0, 2), + ) + + +# ------------------------------------------- class (8,2) at (10,8) + + +def sidon44_pairs_normalized(): + """All Sidon 4-pairs: 0 in D0, 0 in D1, |D0+D1| = 16.""" + out = [] + rest = list(range(1, N5)) + for c0 in combinations(rest, 3): + d0m = 1 | mask_of(c0) + for c1 in combinations(rest, 3): + d1m = 1 | mask_of(c1) + if sumset_mask(d0m, d1m).bit_count() == 16: + out.append((d0m, d1m)) + return out + + +def class82_choices(tm): + """All A0t = choice sets: one element of each {x, x+1} pair inside + C = H' \\ T, where T = D0+D1 must have 1-invariant complement. + Returns (choices, reason): choices empty with reason if impossible.""" + cm = ALL ^ tm + if trans(cm, 1) != cm: + return [], "C_not_1_invariant" + pairs = [] + seen = 0 + x = cm + choices = [0] + while x: + lsb = x & -x + p = lsb.bit_length() - 1 + if (seen >> p) & 1: + x ^= lsb + continue + q = p ^ 1 + if not (cm >> q) & 1: + return [], "C_pair_incomplete" + seen |= (1 << p) | (1 << q) + choices = [c | (1 << p) for c in choices] + [c | (1 << q) for c in choices] + x ^= lsb + return choices, "ok" + + +def class82_check(a0tm, d0m, d1m): + """The three coverage lines (I'),(II'),(III') for one configuration. + Returns (ok, which_lines_fail).""" + fails = [] + if (sumset_mask(a0tm, d0m) | sumset_mask(d1m, 3)) != ALL: + fails.append("I") + if (sumset_mask(a0tm, d1m) | sumset_mask(d0m, 3)) != ALL: + fails.append("II") + if (selfsum_mask(a0tm) | 3 | selfsum_mask(d0m) | selfsum_mask(d1m)) != ALL: + fails.append("III") + return (not fails), tuple(fails) + + +def class82_run(budget=None, shard=0, shards=1): + """Full decision run for class (8,2): every normalized Sidon D-pair, every + admissible A0t choice. Counts equality configurations and coverings. + Per-pair D-side masks are precomputed; (I') and (II') are decided by + OR-chains over the 8 chosen candidate translates, (III') only for + survivors. Deterministic sharding: pairs[shard::shards].""" + import itertools as _it + + t0 = time.time() + pairs = sidon44_pairs_normalized() + n_pairs_total = len(pairs) + pairs = pairs[shard::shards] + n_pairs = len(pairs) + n_choice_sets = 0 + covering = 0 + checked = 0 + fail_hist = {} + witnesses = [] + noninv = 0 + budget_hit = False + for (d0m, d1m) in pairs: + tm = sumset_mask(d0m, d1m) + choices, reason = class82_choices(tm) + if not choices: + noninv += 1 + continue + n_choice_sets += len(choices) + md1_01 = sumset_mask(d1m, 3) + md0_01 = sumset_mask(d0m, 3) + mdd = selfsum_mask(d0m) | selfsum_mask(d1m) + # per {x, x+1} pair inside C: (bit_p, bit_q, d0p, d0q, d1p, d1q) + cand = [] + seen = 0 + x = ALL ^ tm + while x: + lsb = x & -x + p = lsb.bit_length() - 1 + if (seen >> p) & 1: + x ^= lsb + continue + q = p ^ 1 + seen |= (1 << p) | (1 << q) + cand.append( + ( + 1 << p, + 1 << q, + trans(d0m, p), + trans(d0m, q), + trans(d1m, p), + trans(d1m, q), + ) + ) + x ^= lsb + for pick in _it.product((0, 1), repeat=len(cand)): + a0tm = 0 + s0 = 0 + s1 = 0 + for i, which in enumerate(pick): + c = cand[i] + if which == 0: + a0tm |= c[0] + s0 |= c[2] + s1 |= c[4] + else: + a0tm |= c[1] + s0 |= c[3] + s1 |= c[5] + checked += 1 + fails = [] + if (s0 | md1_01) != ALL: + fails.append("I") + if (s1 | md0_01) != ALL: + fails.append("II") + if (selfsum_mask(a0tm) | 3 | mdd) != ALL: + fails.append("III") + if fails: + fail_hist[tuple(fails)] = fail_hist.get(tuple(fails), 0) + 1 + else: + covering += 1 + if len(witnesses) < 5: + witnesses.append((elems(a0tm), elems(d0m), elems(d1m))) + if budget is not None and time.time() - t0 > budget: + budget_hit = True + break + return dict( + shard=shard, + shards=shards, + normalized_sidon_pairs_total=n_pairs_total, + normalized_sidon_pairs=n_pairs, + non_1_invariant_pairs=noninv, + admissible_choice_sets=n_choice_sets, + checked=checked, + covering_configs=covering, + fail_hist={str(k): v for k, v in sorted(fail_hist.items())}, + witnesses=witnesses, + budget_hit=budget_hit, + seconds=round(time.time() - t0, 2), + ) + + +# ------------------------------------------- class (6,0) at (12,6) + + +def transversals6(dm): + """All 6-sets X with X + D = F2^5 (X hits every translate x + D), for + D = dm. Complete branch-on-uncovered-requirement search with a bitmask + of covered requirements; results deduplicated as sets.""" + cov_by = [0] * N5 + for v in range(N5): + m = 0 + for x in range(N5): + if (dm >> (x ^ v)) & 1: + m |= 1 << x + cov_by[v] = m + out = set() + cur = [] + + def rec(uncov, vlo): + if len(cur) == 6: + if not uncov: + out.add(frozenset(cur)) + return + if uncov.bit_count() > 6 * (6 - len(cur)): + return + if not uncov: + for v in range(vlo, N5): + if v in cur: + continue + cur.append(v) + rec(uncov, v + 1) + cur.pop() + return + i = (uncov & -uncov).bit_length() - 1 + target = trans(dm, i) + for v in elems(target): + if v in cur: + continue + cur.append(v) + rec(uncov & ~cov_by[v], 0) + cur.pop() + + rec((1 << N5) - 1, 0) + return out + + +def class60_check(a0m, a1m, dm): + """Lines (I''),(II''),(III'') for one (A0, A1, D) triple.""" + fails = [] + if (sumset_mask(a0m, dm)) != ALL: + fails.append("I") + if (sumset_mask(a1m, dm)) != ALL: + fails.append("II") + if (selfsum_mask(a0m) | selfsum_mask(a1m) | selfsum_mask(dm)) != ALL: + fails.append("III") + return (not fails), tuple(fails) + + +def class60_run(budget=None, shard=0, shards=1): + """Decision run for class (6,0) at (12,6): complete D-side transversal + walk. Normalize 0 in D (H-half translation) and 0 in A1 (H'-half + translation; the class forces D1 = empty). For each normalized 6-set D, + F(D) = {6-sets X : X + D = F2^5} by complete search; then test every + (A0, A1) with A0 in F(D), A1 in F(D) containing 0 against A0+A1 = F2^5 + and line (III''). If F(D) is empty for every D, no (6,0) cover exists + (lines (I'')/(II'') are unsatisfiable). Deterministic sharding over the + C(31,5) normalized D by index.""" + t0 = time.time() + total_d = 169911 + tested_triples = 0 + covering = 0 + witnesses = [] + d_with_transversals = 0 + transversal_total = 0 + d_done = 0 + budget_hit = False + for idx, dc in enumerate(combinations(range(1, N5), 5)): + if idx % shards != shard: + continue + d_done += 1 + dm = 1 | mask_of(dc) + F = transversals6(dm) + if F: + d_with_transversals += 1 + transversal_total += len(F) + f_list = sorted(tuple(sorted(s)) for s in F) + for a1t in f_list: + if 0 not in a1t: + continue + a1m = mask_of(a1t) + for a0t in f_list: + a0m = mask_of(a0t) + if sumset_mask(a0m, a1m) != ALL: + continue + dm_self = selfsum_mask(dm) + if (selfsum_mask(a0m) | selfsum_mask(a1m) | dm_self) != ALL: + continue + tested_triples += 1 + covering += 1 + if len(witnesses) < 5: + witnesses.append((a0t, a1t, tuple(sorted(dc)) + (0,))) + if budget is not None and d_done % 64 == 0 and time.time() - t0 > budget: + budget_hit = True + break + return dict( + shard=shard, + shards=shards, + normalized_d_total=total_d, + d_checked=d_done, + d_with_transversals=d_with_transversals, + transversals_total=transversal_total, + tested_triples=tested_triples, + covering_triples=covering, + witnesses=witnesses, + budget_hit=budget_hit, + seconds=round(time.time() - t0, 2), + ) + + +# ------------------------------------------------- Fourier identity (7,1) + + +def fourier_71_identity(): + """Exact-integer contradiction for the (10,8) A-vanish tight class (7,1). + + L7 forces |A0+A1| = 25 with |A0| = |A1| = 5 (both odd) inside F2^5. + With f = 1_A0, g = 1_A1 and h = 1_S on S = A0+A1 (|S| = 25, all pair + sums distinct), Fourier over F2^5 gives h_hat(v) = f_hat(v) g_hat(v) for + every v (r = 1_S exactly). Parseval: + sum_{v != 0} f_hat^2 = 32*5 - 25 = 135 = sum_{v != 0} g_hat^2, + sum_{v != 0} h_hat^2 = 32*25 - 625 = 175. + Parity: |A0| odd makes every f_hat(v) odd, so f_hat^2 >= 1 pointwise; + hence (f_hat^2 - 1)(g_hat^2 - 1) >= 0 gives f_hat^2 g_hat^2 >= + f_hat^2 + g_hat^2 - 1 pointwise on v != 0 and therefore + sum h_hat^2 >= 135 + 135 - 31 = 239 > 175. Contradiction. + + Returns exact integers; the m=4 analogue (|A0| = 7, |A1| = 1 in F2^3) + computes need = lower = 7 (no contradiction), matching the real covers + of the m=4 analogue class in the PR 2933 F2^5 census.""" + out = {} + for tag, m, kx, ky, s_size in (("m5_k5", 5, 5, 5, 25), ("m3_k2", 3, 2, 2, 4)): + n = 1 << m + need = n * s_size - s_size * s_size + sum_alpha = n * kx - kx * kx + sum_beta = n * ky - ky * ky + odd = (kx % 2 == 1) and (ky % 2 == 1) + lower = sum_alpha + sum_beta - (n - 1) if odd else 0 + out[tag] = dict( + n=n, + kx=kx, + ky=ky, + s_size=s_size, + need=need, + sum_alpha=sum_alpha, + sum_beta=sum_beta, + lower_bound=lower, + parity_odd=odd, + contradiction=bool(odd and lower > need), + ) + n = 8 + out["m3_analogue_71"] = dict( + n=n, + kx=7, + ky=1, + s_size=7, + need=n * 7 - 49, + sum_alpha=n * 7 - 49, + sum_beta=n * 1 - 1, + lower_bound=(n * 7 - 49) + (n * 1 - 1) - (n - 1), + parity_odd=True, + contradiction=(n * 7 - 49) + (n * 1 - 1) - (n - 1) > n * 7 - 49, + ) + return out + + +# ------------------------------------------------- m=4 brute-force control + + +def control_m4_bruteforce(): + """Complete brute force of the two m=4 analogue classes (soundness and + completeness control for the L7 structural reduction). + + Analogue of the (7,1)-tight class: D-vanish (1,1), A split (7,1), + F1 = 7*1 + 1*1 = 8 = need. Analogue of the (8,2)-tight class: + A-vanish (2,2), D split (2,2), F1 = 4 + 4 = 8 = need. + + Direct route: every (A, D) pair with those splits inside E = F2^4 + (H = bit-0-even half, 8 points each coset), tested against the four L3 + lines. Every direct cover must show the L7 equality structure (both + cross sumsets Sidon, disjoint, union the whole odd half).""" + H = [x for x in range(16) if not (x & 1)] + Hp = [x for x in range(16) if x & 1] + + def ss(X, Y): + return {x ^ y for x in X for y in Y} + + def se(X): + return {x ^ y for x in X for y in X} + + def l3_lines(a0, a1, d0, d1): + ok_i = ss(a0, d0) | ss(a1, d1) == set(H) + ok_ii = ss(a0, d1) | ss(a1, d0) == set(Hp) + ok_iii = se(a0) | se(a1) | se(d0) | se(d1) == set(H) + ok_iv = ss(a0, a1) | ss(d0, d1) == set(Hp) + return ok_i and ok_ii and ok_iii and ok_iv + + res = {} + + covers_71 = [] + struct_71 = [] + for a0t in combinations(H, 7): + a0 = list(a0t) + for a1 in Hp: + for d0 in H: + for d1 in Hp: + if l3_lines(a0, [a1], [d0], [d1]): + covers_71.append((a0t, a1, d0, d1)) + sums = ss(a0, [a1]) + tset = set(Hp) - sums + struct_71.append( + len(sums) == 7 + and len(tset) == 1 + and ({d0 ^ d1} == tset) + ) + res["m4_class71_analogue"] = dict( + direct_covers=len(covers_71), + all_have_l7_structure=all(struct_71) if struct_71 else None, + ) + + covers_82 = [] + struct_82 = [] + for a0c in combinations(H, 2): + for a1c in combinations(Hp, 2): + for d0c in combinations(H, 2): + for d1c in combinations(Hp, 2): + a0, a1 = list(a0c), list(a1c) + d0, d1 = list(d0c), list(d1c) + if l3_lines(a0, a1, d0, d1): + covers_82.append((a0c, a1c, d0c, d1c)) + sumsA = ss(a0, a1) + sumsD = ss(d0, d1) + struct_82.append( + len(sumsA) == 4 + and len(sumsD) == 4 + and not (sumsA & sumsD) + and (sumsA | sumsD) == set(Hp) + ) + res["m4_class82_analogue"] = dict( + direct_covers=len(covers_82), + all_have_l7_structure=all(struct_82) if struct_82 else None, + ) + return res + + +def rho_classification(): + """Exact classification of the cross-multiplicity pattern of any + full-sumset pair of 6-sets in F2^5 (the forced structure of the (12,6) + A-vanish class (6,0), and of every (A, D) line (I'')/(II'')). + + Let X, Y be 6-sets with X + Y = F2^5 and r(s) = #{(x,y): x+y = s} = + 1 + rho(s), sum rho = 36 - 32 = 4. Fourier: rho_hat(v) = f_hat(v) + g_hat(v) for v != 0. Every f_hat(v), g_hat(v) is even and + |rho_hat(v)| <= sum rho = 4, so per nonzero v: f_hat(v) g_hat(v) is in + {0, 4, -4}, i.e. (f_hat, g_hat) = (0, *) or (*, 0) or both +-2. + Parseval gives sum_{v != 0} f_hat^2 = 156 and rho-Parseval gives + |V22| = 2 sum rho^2 - 1 where V22 = {v != 0: |f_hat| = |g_hat| = 2}. + + Case table (exact integers; the Walsh constraints are machine-checked in + test_engine.py): + + rho type sum rho^2 |V22| needed Walsh constraint verdict + 4 delta_p 16 31 rho_hat = +-4 always DEAD + 3+1 10 19 +-2 occurs for p != q DEAD + 2+2 8 15 subspace size 15 SURVIVES + 2+1+1 6 11 sizes 2^{5-r}-1 DEAD + 1+1+1+1 4 7 rank-3 flat / rank-2 SURVIVES + + DEAD reasons: (4 delta_p) Parseval 156 = 4*31 + (36a+16b) forces + 32 = 36a+16b with |Vf| = a + b = 0, impossible; (3+1) rho_hat = + 3(-1)^{vq} + (-1)^{vp} lies in {+-2, +-4} and |rho_hat| <= 4 needs + v*(p+q) = 0 for every v != 0, i.e. p = q; (2+1+1) V22 is + {v: v*(p1+p2) = 0 and v*(p1+q) = 0} minus {0}, of size 2^{5-r} - 1 in + {1,3,7,15,31}, never 11. + + Surviving types: + (T1) rho = 1 on an affine 2-flat {p1, p2, p3, p1+p2+p3} and 0 else; + (T2) rho = 2 on two distinct points {q1, q2} and 0 else. + Both sides' spectra are pinned: T1 has |Vf| = |Vg| = 8 all of magnitude + 4 and |V00| = 8; T2 has |Vf| = |Vg| = 6 and |V00| = 4.""" + return { + "types": [ + dict( + rho="4*delta_p", + sum_rho2=16, + v22_needed=31, + verdict="DEAD", + reason="Parseval 156 = 4*31 + (36a+16b) needs 32 = 36a+16b with |Vf| = 0", + ), + dict( + rho="3+1", + sum_rho2=10, + v22_needed=19, + verdict="DEAD", + reason="v*(p+q) = 0 for all v != 0 forces p = q", + ), + dict( + rho="2+2", + sum_rho2=8, + v22_needed=15, + verdict="SURVIVES", + v22=15, + vf=6, + vg=6, + v00=4, + ), + dict( + rho="2+1+1", + sum_rho2=6, + v22_needed=11, + verdict="DEAD", + reason="2^{5-r}-1 in {1,3,7,15,31}, never 11", + ), + dict( + rho="1+1+1+1", + sum_rho2=4, + v22_needed=7, + verdict="SURVIVES", + v22=7, + vf=8, + vg=8, + v00=8, + ), + ], + "surviving": ["2+2", "1+1+1+1"], + } + + +def identity_odd_sides(s, t, m=6): + """Cross-sum multiplicity identity for splits with BOTH sides odd (the + (11,7) and (9,9) splits, where no character can vanish - PR 2933 L2). + + With A an s-set and D a t-set in E = F2^m covering the odd line + A + D = E, the multiplicity is r = 1 + rho with sum rho = s*t - 2^m. + Fourier over E: rho_hat(v) = f_hat(v) g_hat(v) for v != 0, every f_hat + and g_hat is odd (s, t odd), so f_hat^2 g_hat^2 >= f_hat^2 + g_hat^2 - 1 + pointwise. Parseval: sum_{v != 0} f_hat^2 = 2^m s - s^2 and likewise + for g, sum_{v != 0} rho_hat^2 = 2^m sum rho^2 - (sum rho)^2. + + The pointwise inequality yields the EXACT necessary condition + 2^m sum rho^2 - (st - 2^m)^2 >= (2^m s - s^2) + (2^m t - t^2) + - (2^m - 1), + i.e. a lower bound on sum rho^2. For (11,7) and (9,9) at m = 6 the + bound is satisfiable (the excess 13 resp. 17 is too large for the + identity to contradict), so the identity is DEMOTED as an exclusion + mechanism for these splits; the numbers below are exact.""" + n = 1 << m + excess = s * t - n + sum_alpha = n * s - s * s + sum_beta = n * t - t * t + lower = sum_alpha + sum_beta - (n - 1) + # sum rho^2 >= ceil((lower + excess^2) / n) + num = lower + excess * excess + rho2_min = -(-num // n) + parity_odd = (s % 2 == 1) and (t % 2 == 1) + # products f_hat*g_hat must lie within +-excess pointwise + return dict( + split=(s, t), + m=m, + excess=excess, + sum_alpha=sum_alpha, + sum_beta=sum_beta, + pointwise_lower_sum_rho_hat_sq=lower, + sum_rho2_min=rho2_min, + sum_rho2_max=excess * excess, + parity_odd=parity_odd, + contradiction=bool(parity_odd and rho2_min > excess * excess), + ) diff --git a/research/f7-18point-avtail-seed010d26fa/vendor/vanish.py b/research/f7-18point-avtail-seed010d26fa/vendor/vanish.py new file mode 100644 index 0000000000..2dca0053f3 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/vendor/vanish.py @@ -0,0 +1,604 @@ +"""KB3f engine: vanishing-character classification for the 18-point cover +question for F2^7 (set level; no words). + +Object (unchanged from PR 2911, which this package presses): in the PR943 +prefix-walk model a restored seven-source singleton word is universal exactly +when its prefix set P covers, P + P = F2^7. A parity split S = A u B has A in +the even coset E (s points), B in the odd coset O (t points), s + t = 18. +PR 2911 PROVED that any (12,6) or (10,8) cover must have a vanishing +character off the all-ones hyperplane; this module classifies those +vanishing configurations and tests each class against coverage of the +remaining masks. + +Everything is exact Python integer arithmetic; no floats are used. + +Conventions. The even coset E is identified with F2^6 (m = 6); a character +of E is nontrivial psi_v(x) = (-1)^(v.x), v in 1..2^m-1. The (A, D) +reduction (PR 2911, PROVEN there): fix an odd p in F2^7 and D = p + B inside +E; S covers iff (i) A + D = E and (ii) (A+A) u (D+D) = E. + +Classification lemmas (all machine-checked in test_engine.py): + +L2 (halving). char_sum(A, v) = 0 iff A splits |A|/2 + |A|/2 across + ker(psi_v); so a vanishing on side A needs s even and forces the split + (s/2, s/2), and on side D needs t even and forces (t/2, t/2). At + (11,7) and (9,9) both sides are odd: NO character can vanish there. + +L3 (half-decomposition). With H = ker(psi_v), H' = E \\ H and A = A0 u A1, + D = D0 u D1 the two sides of ker(psi_v), coverage is equivalent to + (A0+D0) u (A1+D1) = H, (A0+D1) u (A1+D0) = H', + (A0+A0) u (A1+A1) u (D0+D0) u (D1+D1) = H, (A0+A1) u (D0+D1) = H'. + +L4 (class floors, exact union-size bounds on L3). With a split (a0, a1) of + A and (d0, d1) of D across ker(psi_v), the H'-even line forces + (F1) a0*a1 + d0*d1 >= 2^(m-1); the H-even line forces + (F2) sum over the four parts p of (1 + C(p,2) if p >= 1 else 0) >= 2^(m-1); + the odd lines force (F3) a0*d0 + a1*d1 >= 2^(m-1) and + (F4) a0*d1 + a1*d0 >= 2^(m-1). A class whose forced splits violate any + floor is PROVEN impossible: no cover realizes it. + +A class = (vanishing side, forced split of the vanishing side, split of the +other side). class_table enumerates all classes of a split; classify_cover +decides the classes of a concrete cover; census_f4/census_f5 enumerate the +smallest covers as ground truth for which classes actually occur. +""" + +import hashlib +import itertools +import random +import time +from collections import Counter + + +# ---------------------------------------------------------- F2^n basics + + +def dot(x, y): + return (x & y).bit_count() & 1 + + +def char_sum(pts, v): + """sum over pts of (-1)^(v.x).""" + return sum(1 - 2 * dot(p, v) for p in pts) + + +def split_sizes(pts, v, n): + """(|pts int ker(psi_v)|, |pts \\ ker(psi_v)|).""" + h0 = sum(1 for p in pts if not dot(v, p)) + return (h0, len(pts) - h0) + + +def char_representatives(n): + """One representative per nontrivial character of E: min(v, v ^ all1).""" + all1 = (1 << n) - 1 + out = [] + for v in range(1, all1): + if v < (v ^ all1): + out.append(v) + return out + + +def vanishing_set(pts, n): + """Character-level vanishing set (one entry per nontrivial character).""" + return {v for v in char_representatives(n) if char_sum(pts, v) == 0} + + +def vanishing_set_u(pts, n): + """u-level vanishing set: all indices v off {0, all-ones} with sum 0.""" + all1 = (1 << n) - 1 + return {v for v in range(1, all1) if char_sum(pts, v) == 0} + + +def sumset_xor(x, y): + return {a ^ b for a in x for b in y} + + +def selfsum_xor(x): + return {a ^ b for i, a in enumerate(x) for b in x[i:]} + + +def covers_f2n(pts, n): + cov = selfsum_xor(pts) + return len(cov) == (1 << n) + + +def cover_conditions(A, D, m): + """(A + D = F2^m, (A+A) u (D+D) = F2^m) -- the (A, D) reduction.""" + full = set(range(1 << m)) + odd_ok = sumset_xor(A, D) == full + even_ok = selfsum_xor(A) | selfsum_xor(D) == full + return odd_ok, even_ok + + +# ------------------------------------------------- half decomposition + + +def half_conditions(A, D, v, m): + """The four half lines of L3 for character psi_v.""" + A0 = [a for a in A if not dot(v, a)] + A1 = [a for a in A if dot(v, a)] + D0 = [d for d in D if not dot(v, d)] + D1 = [d for d in D if dot(v, d)] + H = {x for x in range(1 << m) if not dot(v, x)} + Hp = {x for x in range(1 << m) if dot(v, x)} + od0 = sumset_xor(A0, D0) | sumset_xor(A1, D1) + od1 = sumset_xor(A0, D1) | sumset_xor(A1, D0) + ev0 = selfsum_xor(A0) | selfsum_xor(A1) | selfsum_xor(D0) | selfsum_xor(D1) + ev1 = sumset_xor(A0, A1) | sumset_xor(D0, D1) + return ( + H <= od0, + Hp <= od1, + H <= ev0, + Hp <= ev1, + (len(A0), len(A1), len(D0), len(D1)), + ) + + +def check_half_decomposition(m, exhaustive=True, samples=0, seed=1): + """Verify L2 and L3 on every (A, D) pair (m <= 3) or on random samples.""" + rng = random.Random(seed) + N = 1 << m + pairs = 0 + if exhaustive: + sets = [] + for mask in range(1 << N): + sets.append([x for x in range(N) if (mask >> x) & 1]) + iterator = itertools.product(sets, repeat=2) + else: + def rand_iter(): + for _ in range(samples): + A = [x for x in range(N) if rng.randrange(2)] + D = [x for x in range(N) if rng.randrange(2)] + yield (A, D) + iterator = rand_iter() + for A, D in iterator: + pairs += 1 + for v in range(1, N): + cs = char_sum(A, v) + a0, a1 = split_sizes(A, v, m) + l2 = (cs == 0) == (len(A) % 2 == 0 and a0 == len(A) // 2) + if not l2: + return dict(ok=False, pairs=pairs, fail="L2", A=A, D=D, v=v) + od0, od1, ev0, ev1, _ = half_conditions(A, D, v, m) + direct = cover_conditions(A, D, m) + if (od0 and od1 and ev0 and ev1) != all(direct): + return dict(ok=False, pairs=pairs, fail="L3", A=A, D=D, v=v) + return dict(ok=True, pairs=pairs) + + +def two_vanishing_structure(A, v1, v2, m): + """L5 (multi-vanishing structure). If char_sum(A, v1) = char_sum(A, v2) + = 0 for distinct characters, the counts of A across the four parts of the + (ker(psi_v1), ker(psi_v2)) grid are (x, y, y, x) with x + y = |A|/2. + Returns (counts, ok) where counts = (n00, n01, n10, n11) in the grid.""" + n00 = n01 = n10 = n11 = 0 + for a in A: + b1, b2 = dot(v1, a), dot(v2, a) + if b1 == 0 and b2 == 0: + n00 += 1 + elif b1 == 0: + n01 += 1 + elif b2 == 0: + n10 += 1 + else: + n11 += 1 + ok = n00 == n11 and n01 == n10 + return (n00, n01, n10, n11), ok + + +def check_multi_vanishing(m): + """Verify L5 for every subset A of F2^m and every vanishing pair.""" + N = 1 << m + checked = 0 + for mask in range(1 << N): + A = [x for x in range(N) if (mask >> x) & 1] + van = [v for v in range(1, N) if char_sum(A, v) == 0] + for i in range(len(van)): + for j in range(i): + counts, ok = two_vanishing_structure(A, van[j], van[i], m) + checked += 1 + if not ok: + return dict(ok=False, checked=checked, A=A, v=(van[j], van[i]), counts=counts) + return dict(ok=True, checked=checked) + + +def sidon_pair(X, Y): + """All |X|*|Y| sums x+y distinct (no nontrivial common difference).""" + return len(sumset_xor(X, Y)) == len(X) * len(Y) + + +def check_tight_equality(m): + """L7 (equality analysis of the F1 floor). Whenever a0*a1 + d0*d1 = + 2^(m-1) and the pair (A, D) covers, the H' even line forces + |A0+A1| = a0*a1 (a Sidon pair), |D0+D1| = d0*d1 (a Sidon pair), and the + two cross sumsets are disjoint (their union is H').""" + N = 1 << m + need = 1 << (m - 1) + checked = 0 + sets = [[x for x in range(N) if (mask >> x) & 1] for mask in range(1 << N)] + for A in sets: + for D in sets: + if not all(cover_conditions(A, D, m)): + continue + for v in range(1, N): + A0 = [a for a in A if not dot(v, a)] + A1 = [a for a in A if dot(v, a)] + D0 = [d for d in D if not dot(v, d)] + D1 = [d for d in D if dot(v, d)] + if len(A0) * len(A1) + len(D0) * len(D1) != need: + continue + checked += 1 + sA = sumset_xor(A0, A1) + sD = sumset_xor(D0, D1) + if len(sA) != len(A0) * len(A1): + return dict(ok=False, checked=checked, fail="A0+A1 not Sidon", A=A, D=D, v=v) + if len(sD) != len(D0) * len(D1): + return dict(ok=False, checked=checked, fail="D0+D1 not Sidon", A=A, D=D, v=v) + if sA & sD: + return dict(ok=False, checked=checked, fail="cross sumsets overlap", A=A, D=D, v=v) + return dict(ok=True, checked=checked) + + +# ------------------------------------------------------- class table + + +def _bound2(part): + return (1 + part * (part - 1) // 2) if part >= 1 else 0 + + +def class_table(s, t, m=6): + """All vanishing classes of the split (s, t) at E = F2^m and their floor + verdicts. A class: vanishing side A (forced split s/2 + s/2) with the + other side's split (d0, d1), or vanishing side D (forced t/2 + t/2) with + the other side's split (a0, a1). Verdict dead iff some exact floor of L4 + fails; survives-tight iff F1 holds with equality.""" + need = 1 << (m - 1) + out = {"split": (s, t), "m": m, "floor_need_F1": need, "vanishing_possible": False} + + def floors(a0, a1, d0, d1): + return { + "F1": a0 * a1 + d0 * d1, + "F2": _bound2(a0) + _bound2(a1) + _bound2(d0) + _bound2(d1), + "F3": a0 * d0 + a1 * d1, + "F4": a0 * d1 + a1 * d0, + } + + def entry(vanishing_side, van_split, other_split, a0, a1, d0, d1): + fl = floors(a0, a1, d0, d1) + ok = all(v >= need for v in fl.values()) + tight = ok and fl["F1"] == need + forced = None + if ok and tight: + forced = ( + "equality: |A0+A1| = a0*a1 and |D0+D1| = d0*d1 (both Sidon), " + "the two cross sumsets disjoint with union the whole odd half" + ) + elif ok and d0 * d1 == 0: + forced = "D cross sums empty: |A0+A1| = the whole odd half" + elif ok and a0 * a1 == 0: + forced = "A cross sums empty: |D0+D1| = the whole odd half" + return dict( + vanishing_side=vanishing_side, + vanishing_split=van_split, + other_split=other_split, + splits=dict(A=(a0, a1), D=(d0, d1)), + floors=fl, + floor_value=fl["F1"], + floor_need=need, + verdict=("survives" if ok else "dead"), + tight=tight, + forced=forced, + ) + + A_rows, D_rows = [], [] + if s % 2 == 0: + out["vanishing_possible"] = True + for d0 in range(t, (t - 1) // 2, -1): + d1 = t - d0 + A_rows.append(entry("A", (s // 2, s // 2), (d0, d1), s // 2, s // 2, d0, d1)) + if t % 2 == 0: + out["vanishing_possible"] = True + for a0 in range(s, (s - 1) // 2, -1): + a1 = s - a0 + D_rows.append(entry("D", (t // 2, t // 2), (a0, a1), a0, a1, t // 2, t // 2)) + out["A_vanish"] = A_rows + out["D_vanish"] = D_rows + return out + + +# ---------------------------------------------------- cover census + + +def classify_cover(S, n): + """Classify a covering set S of F2^n by its vanishing classes (ground + truth for 'which characters can vanish').""" + A = [x for x in S if x.bit_count() % 2 == 0] + B = [x for x in S if x.bit_count() % 2 == 1] + D = [1 ^ b for b in B] + m = n - 1 + need = 1 << (m - 1) + k_A = vanishing_set(A, n) + k_D = vanishing_set(D, n) + rows = [] + dead = [] + for v in sorted(k_A | k_D): + a0, a1 = split_sizes(A, v, n) + d0, d1 = split_sizes(D, v, n) + val = a0 * a1 + d0 * d1 + verdict = "survives" if val >= need else "dead" + side = ("A" if v in k_A else "") + ("D" if v in k_D else "") + rows.append((v, side, (a0, a1), (d0, d1), verdict)) + if verdict == "dead": + dead.append((v, side, (a0, a1), (d0, d1))) + return dict( + S=sorted(S), + split=(len(A), len(B)), + k_A=len(k_A), + k_D=len(k_D), + vanish_rows=rows, + dead_classes_hit=dead, + ) + + +def _aggregate(rec, agg, class_agg): + agg[("%d_%d" % rec["split"], rec["k_A"], rec["k_D"])] += 1 + for (v, side, a_sp, d_sp, verdict) in rec["vanish_rows"]: + class_agg[(side, a_sp, d_sp, verdict)] += 1 + + +def _ser_agg(agg): + return sorted(["%s kA=%d kD=%d" % k, v] for k, v in agg.items()) + + +def _ser_class_agg(class_agg): + return sorted( + ["%s a=%d,%d d=%d,%d %s" % (side, a_sp[0], a_sp[1], d_sp[0], d_sp[1], verdict), v] + for (side, a_sp, d_sp, verdict), v in class_agg.items() + ) + + +def census_f4(keep=100): + """Exhaustive: every subset S of F2^4 with S + S = F2^4, classified.""" + N = 16 + full = set(range(N)) + pair = [[0] * N for _ in range(N)] + for i in range(N): + for j in range(N): + pair[i][j] = i ^ j + agg = Counter() + class_agg = Counter() + covers = [] + covers_total = 0 + dead_hit = [] + for mask in range(1, 1 << N): + S = [x for x in range(N) if (mask >> x) & 1] + cov = {0} + for i in range(len(S)): + for j in range(i): + cov.add(pair[S[i]][S[j]]) + if cov != full: + continue + covers_total += 1 + rec = classify_cover(S, 4) + _aggregate(rec, agg, class_agg) + if rec["dead_classes_hit"]: + dead_hit.append(rec["dead_classes_hit"]) + if len(covers) < keep: + covers.append(S) + return dict( + covers_total=covers_total, + covers=covers, + agg=_ser_agg(agg), + class_agg=_ser_class_agg(class_agg), + dead_classes_hit=dead_hit, + ) + + +def census_f5(shard=0, shards=16, keep_covers=5, n=5, k=10, max_combos=None): + """Shard `shard` of the full k-subset census of F2^n (n = 5, k = 10): + every k-subset S with S + S = F2^n is classified by vanishing class. + Independent enumeration route (all C(32,10) combinations) for the + recorded PR 2773 n5 control value 99,200 ten-point covers. max_combos + truncates a shard (smoke tests only; a complete census passes None).""" + N = 1 << n + full = (1 << N) - 1 + pairbit = [[0] * N for _ in range(N)] + for i in range(N): + for j in range(N): + pairbit[i][j] = 1 << (i ^ j) + agg = Counter() + class_agg = Counter() + covers = [] + covers_total = 0 + dead_hit = [] + combos = 0 + for S in itertools.combinations(range(N), k): + if S[0] % shards != shard: + continue + combos += 1 + if max_combos is not None and combos > max_combos: + combos -= 1 + return dict( + shard=shard, + shards=shards, + status="partial", + combos=combos, + covers_total=covers_total, + covers=covers, + agg=_ser_agg(agg), + class_agg=_ser_class_agg(class_agg), + dead_classes_hit=dead_hit, + ) + cov = 1 + for i in range(k): + si = S[i] + row = pairbit[si] + for j in range(i): + cov |= row[S[j]] + if cov != full: + continue + covers_total += 1 + rec = classify_cover(list(S), n) + _aggregate(rec, agg, class_agg) + if rec["dead_classes_hit"]: + dead_hit.append(rec["dead_classes_hit"]) + if len(covers) < keep_covers: + covers.append(sorted(S)) + return dict( + shard=shard, + shards=shards, + status="complete", + combos=combos, + covers_total=covers_total, + covers=covers, + agg=_ser_agg(agg), + class_agg=_ser_class_agg(class_agg), + dead_classes_hit=dead_hit, + ) + + +# ------------------------------------------------- class-restricted search + + +def _score_pair(A, D): + """|A + D| + |(A+A) u (D+D)| as integer bitmasks (target 2^(m+1)).""" + cm = 1 + for a in A: + for d in D: + cm |= 1 << (a ^ d) + sm = 1 + for i, a in enumerate(A): + for b in A[i:]: + sm |= 1 << (a ^ b) + for i, d in enumerate(D): + for b in D[i:]: + sm |= 1 << (d ^ b) + return cm.bit_count() + sm.bit_count() + + +def search_class(s, t, side, other_split, restarts=20, seed=1, seconds=20.0, m=6): + """Bounded seeded local search for a covering (A, D) pair in E = F2^m + constrained to one vanishing class: psi = bit 0 (WLOG under GL(m, 2)), + the vanishing side split equally across ker(psi), the other side split + exactly `other_split`. A found pair is a falsifying instance for the + class contradiction and (at m = 6) an 18-point cover witness; a failed + bounded search is a scoped search failure, never an exclusion.""" + rng = random.Random(seed) + N = 1 << m + target = 2 * N + + if side == "A_vanish": + a_h0 = s // 2 + a_h1 = s // 2 + d_h0, d_h1 = other_split + else: + d_h0 = t // 2 + d_h1 = t // 2 + a_h0, a_h1 = other_split + half0 = [x for x in range(N) if not (x & 1)] + half1 = [x for x in range(N) if (x & 1)] + + def build(): + A = rng.sample(half0, a_h0) + rng.sample(half1, a_h1) + D = rng.sample(half0, d_h0) + rng.sample(half1, d_h1) + return A, D + + best = (0, None) + moves = 0 + t0 = time.time() + for _ in range(restarts): + if time.time() - t0 > seconds: + break + A, D = build() + sc = _score_pair(A, D) + improved = True + while improved and time.time() - t0 < seconds: + improved = False + for cur in (A, D): + for half in (half0, half1): + for i in range(len(cur)): + if (cur[i] & 1) != (half[0] & 1): + continue + for v in half: + if v in cur: + continue + moves += 1 + old = cur[i] + cur[i] = v + new = _score_pair(A, D) + if new > sc: + sc = new + improved = True + break + cur[i] = old + if sc == target: + break + if sc == target: + break + if sc == target: + break + if sc == target: + return dict( + found=True, + score=sc, + A=sorted(A), + D=sorted(D), + side=side, + other_split=other_split, + moves=moves, + seconds=round(time.time() - t0, 2), + ) + if sc > best[0]: + best = (sc, (sorted(A), sorted(D))) + return dict( + found=False, + score=best[0], + best_pair=best[1], + side=side, + other_split=other_split, + restarts=restarts, + moves=moves, + seconds=round(time.time() - t0, 2), + ) + + +def search_free(s, t, restarts=20, seed=1, seconds=20.0, m=6): + """Unconstrained bounded seeded search for a covering (A, D) pair in + E = F2^m (non-vacuity control for the class-restricted machinery).""" + rng = random.Random(seed) + N = 1 << m + target = 2 * N + pool = list(range(N)) + best = (0, None) + t0 = time.time() + for _ in range(restarts): + if time.time() - t0 > seconds: + break + A = rng.sample(pool, s) + D = rng.sample(pool, t) + sc = _score_pair(A, D) + improved = True + while improved and time.time() - t0 < seconds: + improved = False + for cur, size in ((A, s), (D, t)): + outside = [x for x in pool if x not in cur] + for i in range(size): + for v in outside: + old = cur[i] + cur[i] = v + new = _score_pair(A, D) + if new > sc: + sc = new + improved = True + outside[outside.index(v)] = old + if sc == target: + return dict(found=True, score=sc, A=sorted(A), D=sorted(D)) + else: + cur[i] = old + if sc > best[0]: + best = (sc, (sorted(A), sorted(D))) + return dict(found=False, score=best[0], best_pair=best[1]) + + +def sha256_file(path): + return hashlib.sha256(path.read_bytes()).hexdigest() diff --git a/research/f7-18point-avtail-seed010d26fa/verify.py b/research/f7-18point-avtail-seed010d26fa/verify.py new file mode 100644 index 0000000000..40c9bc1a15 --- /dev/null +++ b/research/f7-18point-avtail-seed010d26fa/verify.py @@ -0,0 +1,299 @@ +"""Registered replay for the KB3h package (the (12,6) A-vanish tail classes +(5,1)/(4,2)/(3,3) of the 18-point cover question for F2^7, set level; no +words). + +Modes (each bounded; see VERIFY.json): + + quick byte pins, the PR 2961 FOURIER (7,1) anchor (need=175 + lower=239), the rho classification numbers, the PR 2933 + CLASSIFY lines incl. the 32=32 TIGHT cases=6720 and the + PR 2870 OBSTRUCTION anchor (696/504/192). + marker PASS_AVTAIL_QUICK + novanish the PR 2911 NOVANISH premise from the byte-vendored engine. + marker PASS_AVTAIL_NOVANISH + rows the PR 2911 ROWS18 anchor (808/501/251/196) and the 17-point + row controls. + marker PASS_AVTAIL_ROWS + anchors receipt validation of this package's OWN fresh empty-receipt + re-walks: CLASS71 (0 pairs), CLASS82 (28,815,360 checked, + covering=0), CLASS60 (169,911 D walked, 0 with transversals). + The walks themselves: run_avtail.py class71/class82/class60. + marker PASS_AVTAIL_ANCHORS + m4 the m=4 analogue positive control: direct census vs machinery + per D-split, with semantic failure controls (line mutants). + marker PASS_AVTAIL_M4 + av51 the class (5,1) decision receipts (run_avtail.py av51). + marker PASS_AVTAIL_AV51 + +Everything is exact integer arithmetic (no floats). +""" + +import hashlib +import json +import sys +import time +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(0, str(HERE / "vendor")) + +import tight # noqa: E402 +import avtail # noqa: E402 + +VENDOR_PINS = { + "vendor/tight.py": ( + "14670ef2d3df9e4ecc9e1db962f4e8cb77545d1c889144352760c1fd14e2273b" + ), + "vendor/cover18.py": ( + "24c6a2f4911dc2d5de76972eb5ae93dc4e66d8fa1e904443de6d0638e70c0a04" + ), + "vendor/vanish.py": ( + "6c605c54074f725321c5d770d538a652bf7727598a128270831f92fe7b9746d9" + ), + "vendor/agent64_cover17.py": ( + "082bc838134cba9754368cff894d53c729467a689b4cafee8374423688d93654" + ), + "vendor/agent64_search17.py": ( + "9eb1bf79ffb99b0efcdaf57916c493bc781abd4a0096d584dc6bc6ca294bf674" + ), + "vendor/anchors.py": ( + "73d73a9b94539403448d7ff8c914c03711907f75c019c4ccb6843b32c259e8e7" + ), +} + +SPLITS = [(12, 6), (11, 7), (10, 8), (9, 9)] + + +def sha256_file(p): + return hashlib.sha256(Path(p).read_bytes()).hexdigest() + + +def check_pins(): + for rel, want in VENDOR_PINS.items(): + got = sha256_file(HERE / rel) + assert got == want, (rel, got, want) + print("PIN %s sha256=%s" % (rel, got[:16]), flush=True) + + +def mode_quick(): + t0 = time.time() + check_pins() + fid = tight.fourier_71_identity() + assert (fid["m5_k5"]["need"], fid["m5_k5"]["lower_bound"]) == (175, 239) + assert fid["m5_k5"]["contradiction"] is True + print( + "FOURIER (7,1) need=%d lower=%d contradiction=%s" + % (fid["m5_k5"]["need"], fid["m5_k5"]["lower_bound"], fid["m5_k5"]["contradiction"]), + flush=True, + ) + rho = tight.rho_classification() + print("RHO surviving=%s dead=%s" % ( + rho["surviving"], + sorted(t["rho"] for t in rho["types"] if t["verdict"] == "DEAD"), + ), flush=True) + import vanish + + tight_seen = 0 + for (s, t) in SPLITS: + tab = vanish.class_table(s, t, m=6) + for side in ("A_vanish", "D_vanish"): + for c in tab[side]: + if c["tight"]: + tight_seen += 1 + print( + "CLASS (%d,%d) %s vanish_split=%s other=%s value=%d need=%d -> %s%s" + % ( + s, + t, + side, + c["vanishing_split"], + c["other_split"], + c["floor_value"], + c["floor_need"], + c["verdict"], + " TIGHT" if c["tight"] else "", + ), + flush=True, + ) + if not tab["vanishing_possible"]: + print( + "CLASS (%d,%d) NO VANISHING POSSIBLE (both sides odd): L2 blocks every character" + % (s, t), + flush=True, + ) + assert tight_seen == 2, tight_seen + res7 = vanish.check_tight_equality(3) + assert res7["ok"], res7 + assert res7["checked"] == 6720, res7 + print("LEMMA tight-equality Sidon exhaustive m=3 cases=%d ok=true" % res7["checked"], flush=True) + import cover18 as c18 + + sq = c18.squeeze_numbers(7, 11, 6) + assert (sq["parseval_remainder"], sq["max_allowed"], sq["deficit"]) == (696, 504, 192) + print("ANCHOR PR2870 OBSTRUCTION parseval=696 allowed=504 deficit=192", flush=True) + print("PASS_AVTAIL_QUICK seconds=%.1f" % (time.time() - t0), flush=True) + + +def mode_novanish(): + t0 = time.time() + check_pins() + import cover18 as c18 + + for (s, t) in ((12, 6), (10, 8)): + rec = c18.fourier_profile_feasibility(7, s, t, nonzero_both=True) + print( + "NOVANISH (%d, %d) feasible=%s -> %s" + % ( + s, + t, + rec["feasible"], + "PROVEN every (s,t) cover has a vanishing character off {0,1}" + if not rec["feasible"] + else "no constraint", + ), + flush=True, + ) + assert rec["feasible"] is False, (s, t, rec) + print("PASS_AVTAIL_NOVANISH seconds=%.1f" % (time.time() - t0), flush=True) + + +def mode_rows(): + t0 = time.time() + check_pins() + import cover18 as c18 + + FLOORS = {12: 3, 11: 5, 10: 3, 9: 0} + want = {(12, 6): 808, (11, 7): 501, (10, 8): 251, (9, 9): 196} + for (s, t) in SPLITS: + rows = c18.sharp_rows_fast(7, s, t, min_e_ex=FLOORS[s], min_b_ex=0) + print( + "ROWS18 (%d, %d) rows=%d best=%d need=%d" + % (s, t, len(rows["rows"]), rows["best"], rows["need"]), + flush=True, + ) + assert len(rows["rows"]) == want[(s, t)], (s, t, len(rows["rows"])) + rows = c18.surviving_rows_fast(7, 11, 6, min_e_ex=5, min_b_ex=0) + got = sorted((r["e_ex"], r["b_ex"]) for r in rows["rows"]) + assert got == [(5, 1), (6, 0)], got + rows = c18.surviving_rows_fast(7, 10, 7, min_e_ex=3, min_b_ex=0) + assert rows["rows"] == [] + print("CONTROL 17-point rows reproduce: (11,6) remainder (5,1),(6,0); (10,7) empty", flush=True) + print("PASS_AVTAIL_ROWS seconds=%.1f" % (time.time() - t0), flush=True) + + +def mode_anchors(): + t0 = time.time() + check_pins() + prog = json.loads((HERE / "AVTAIL-PROGRESS.json").read_text(encoding="utf-8")) + m71 = prog["modes"]["class71"]["shards"]["0"] + assert m71.get("complete"), m71 + assert m71["normalized_pairs"] == 0 and m71["covering_pairs"] == 0, m71 + print( + "ANCHOR CLASS71 normalized_pairs=%d covering_pairs=%d" + % (m71["normalized_pairs"], m71["covering_pairs"]), + flush=True, + ) + m82 = prog["modes"]["class82"] + assert m82.get("complete"), "class82 incomplete" + tot = m82["total"] + assert tot["checked"] == 28815360, tot + assert tot["covering_configs"] == 0, tot + print( + "ANCHOR CLASS82 normalized_sidon_pairs=%d checked=%d covering=%d fail_hist=%s" + % ( + tot["normalized_sidon_pairs"], + tot["checked"], + tot["covering_configs"], + tot["fail_hist"], + ), + flush=True, + ) + m60 = prog["modes"]["class60"] + assert m60.get("complete"), "class60 incomplete" + tot = m60["total"] + assert tot["d_checked"] == 169911, tot + assert tot["d_with_transversals"] == 0 and tot["covering_triples"] == 0, tot + print( + "ANCHOR CLASS60 d_checked=%d d_with_transversals=%d covering_triples=%d" + % (tot["d_checked"], tot["d_with_transversals"], tot["covering_triples"]), + flush=True, + ) + print("PASS_AVTAIL_ANCHORS seconds=%.1f" % (time.time() - t0), flush=True) + + +def mode_m4(): + t0 = time.time() + check_pins() + rec = avtail.control_m4() + load_bearing = False + nonempty = 0 + for k in sorted(rec): + r = rec[k] + print( + "M4 %s direct=%d direct_l3=%d machinery=%d mutant_drop_a=%d mutant_drop_d=%d agreement=%s" + % ( + k, + r["direct_covers"], + r["direct_l3_covers"], + r["machinery_covers"], + r["mutant_drop_a"], + r["mutant_drop_d"], + r["agreement"], + ), + flush=True, + ) + assert r["agreement"], (k, r) + if r["direct_covers"] > 0: + nonempty += 1 + if r["mutant_drop_a"] != r["machinery_covers"] or r["mutant_drop_d"] != r["machinery_covers"]: + load_bearing = True + assert load_bearing, "line-checker mutants must change at least one census count" + assert nonempty >= 1, "positive control needs a cover-bearing class" + print("M4 semantic failure controls load-bearing=true positive_classes=%d" % nonempty, flush=True) + print("PASS_AVTAIL_M4 seconds=%.1f" % (time.time() - t0), flush=True) + + +def mode_av51(): + t0 = time.time() + check_pins() + prog = json.loads((HERE / "AVTAIL-PROGRESS.json").read_text(encoding="utf-8")) + m = prog["modes"]["av51"] + assert m.get("complete"), "av51 incomplete" + tot = m["total"] + print( + "AV51 u_checked=%d uv_pairs=%d w_candidates=%d covering_configs=%d fail_hist=%s" + % ( + tot["u_checked"], + tot["uv_pairs"], + tot["w_candidates"], + tot["covering_configs"], + tot["fail_hist"], + ), + flush=True, + ) + print("AV51 pairs_by_sumset_size=%s" % json.dumps(tot.get("uv_pairs_by_sumset_size", {}), sort_keys=True), flush=True) + verdict = "PROVEN empty" if tot["covering_configs"] == 0 else "WITNESS FOUND - class realized" + print("AV51 class (12,6) A-vanish (5,1): %s" % verdict, flush=True) + assert tot["u_checked"] == 169911, tot + print("PASS_AVTAIL_AV51 seconds=%.1f" % (time.time() - t0), flush=True) + + +def main(): + sys.stdout.reconfigure(encoding="utf-8") + mode = sys.argv[1] if len(sys.argv) > 1 else "quick" + modes = { + "quick": mode_quick, + "novanish": mode_novanish, + "rows": mode_rows, + "anchors": mode_anchors, + "m4": mode_m4, + "av51": mode_av51, + } + if mode not in modes: + raise SystemExit("usage: verify.py quick|novanish|rows|anchors|m4|av51") + modes[mode]() + + +if __name__ == "__main__": + main()