From 153b93c1c0e9ee1c50677ae04d48f1f7f0b1700e Mon Sep 17 00:00:00 2001 From: Aaron Wang Date: Fri, 16 Oct 2026 01:29:12 -0400 Subject: [PATCH] Add research/fstar-entry-class-scope-seed63d5f999: F-star residue class iii entry-class scope, no kappa Settles the statement of open problem F-star residue class (iii) "non-dyadic entries" (research/root-unit-decoder-lemmas section 7): Lemma SC (exact per-total 2-adic content criterion for Lemma AN's normalization hypothesis), Lemma SG (scale-invariant anchor with exact reach S_gamma = {t : v_2(M_tt) = gamma}), the pattern-invariance proposition (F-star is entry-class-independent), the Lemma MX scope remark, the entry-class settlement of tied_min and cex_min_1 with all recorded calibration anchors reproduced, and a smallest-first entry-class falsifier search (84 instances, v = 3..10, zero falsifiers). Residue class (iii) is mis-stated and empty as an obstruction; it merges into the cancellation residue. --- .../CERTIFICATE.json | 2518 +++++++++++++++++ .../README.md | 339 +++ .../SOURCES.json | 24 + .../TASK-CARD.md | 96 + .../TASK.json | 87 + .../VERIFY.json | 20 + .../data/cex_min_1.B22.json | 1 + .../data/cex_min_1.json | 1 + .../data/cex_min_1.witness.json | 1 + .../data/tied_min.json | 1 + .../verify.py | 1199 ++++++++ 11 files changed, 4287 insertions(+) create mode 100644 research/fstar-entry-class-scope-seed63d5f999/CERTIFICATE.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/README.md create mode 100644 research/fstar-entry-class-scope-seed63d5f999/SOURCES.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/TASK-CARD.md create mode 100644 research/fstar-entry-class-scope-seed63d5f999/TASK.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/VERIFY.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.B22.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.witness.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/data/tied_min.json create mode 100644 research/fstar-entry-class-scope-seed63d5f999/verify.py diff --git a/research/fstar-entry-class-scope-seed63d5f999/CERTIFICATE.json b/research/fstar-entry-class-scope-seed63d5f999/CERTIFICATE.json new file mode 100644 index 0000000000..1119d2812f --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/CERTIFICATE.json @@ -0,0 +1,2518 @@ +{ + "digest": "39f5c167c495f4574faf6bb77fb60d9edad4b70190e6aadbed465c709ecbf09a", + "fails": [], + "generated_by": "verify.py", + "package": "research/fstar-entry-class-scope-seed63d5f999", + "results": { + "controls": { + "brute_agree": 3, + "chi_checks": 4, + "corrupt_rejects": 2, + "diag_cert": 3, + "mas_checks": 3, + "mp_control": 3, + "scope_controls": { + "SC1_dyadic_negative_content": true, + "SC2_positive_content_scaled": true, + "SC3_oddden_anchor_verbatim": true, + "SC4_reach_witness_replay": "3/2_nonempty" + } + }, + "fixtures": { + "cex_min_1.json": { + "AN_hypothesis_holds": true, + "anchor_reach": 8, + "anchor_reach_lines": [ + 0, + 4, + 5, + 6, + 8, + 11, + 14, + 15 + ], + "arcs_Z": 114, + "chain_anchor": 22, + "chi_exhaustive": true, + "chi_unconstrained": "le3", + "diag_v2": [ + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1 + ], + "dichromatic_with_D": false, + "engine_witness": 18, + "entry_class": "integer", + "gamma": 0, + "mas_of_Z": 10, + "mp_anchor": 16, + "mp_bound": 16, + "mp_deficit_vs_v": 3, + "mp_maps": 6144, + "mp_worst": 10, + "mutual_pairs": 25, + "mx_form": "all-T (MP)", + "mx_maps_evaluated": 2048, + "mx_value": 16, + "naive_odd_count": 8, + "omega_mutual": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "pr2747_anchor_good": 8, + "recorded_cert": 18, + "scope_identity": true, + "threshold": 12, + "untouchable_by_anchor": 11, + "v": 19 + }, + "tied_min.json": { + "AN_hypothesis_holds": true, + "anchor_reach": 0, + "anchor_reach_lines": [], + "arcs_Z": 72, + "chain_anchor": null, + "chi_exhaustive": true, + "chi_unconstrained": 3, + "diag_v2": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "dichromatic_with_D": false, + "engine_witness": 11, + "entry_class": "integer", + "gamma": 0, + "mas_of_Z": 4, + "mp_anchor": 9, + "mp_bound": 9, + "mp_deficit_vs_v": 3, + "mp_maps": 4096, + "mp_worst": 5, + "mutual_pairs": 24, + "mx_form": "all-T (MP)", + "mx_maps_evaluated": 4096, + "mx_value": 9, + "naive_odd_count": 0, + "omega_mutual": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "pr2747_anchor_good": 0, + "recorded_cert": 11, + "scope_identity": true, + "threshold": 8, + "untouchable_by_anchor": 12, + "v": 12 + } + }, + "search": { + "AN_hypothesis_failures": 56, + "certified_at_or_above_threshold": 84, + "entry_class_counts": { + "2-integral-oddden": 28, + "dyadic": 28, + "general-Q": 28 + }, + "falsifiers": [], + "families": [ + "evenden", + "oddden", + "mixed" + ], + "instances": 84, + "instances_with_anchor_reach_below_threshold": 66, + "instances_with_negative_gamma": 56, + "instances_with_untouchable_lines": 83, + "min_best_known_ratio": 1.0, + "records": [ + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "dyadic", + "exact_cert": 3, + "exact_exhausted": true, + "family": "evenden", + "gamma": -4, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 1, + "per_total_contents_c": [ + -4, + -2, + -3 + ], + "scope_identity": true, + "seed": 3741, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "dyadic", + "exact_cert": 3, + "exact_exhausted": true, + "family": "evenden", + "gamma": -5, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 0, + "per_total_contents_c": [ + -3, + -3, + -5 + ], + "scope_identity": true, + "seed": 3872, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "dyadic", + "exact_cert": 3, + "exact_exhausted": true, + "family": "evenden", + "gamma": -6, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 0, + "per_total_contents_c": [ + -6, + -4, + -3 + ], + "scope_identity": true, + "seed": 4003, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "dyadic", + "exact_cert": 3, + "exact_exhausted": true, + "family": "evenden", + "gamma": -6, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 0, + "per_total_contents_c": [ + -6, + -4, + -2 + ], + "scope_identity": true, + "seed": 4134, + "thr": 2, + "untouchable_by_anchor": 3, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 3, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "2-integral-oddden", + "exact_cert": 3, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 3622, + "thr": 2, + "untouchable_by_anchor": 0, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 1, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "2-integral-oddden", + "exact_cert": 3, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 1, + "per_total_contents_c": [ + 1, + 0, + 1 + ], + "scope_identity": true, + "seed": 3753, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 2, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "2-integral-oddden", + "exact_cert": 3, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 2, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 3884, + "thr": 2, + "untouchable_by_anchor": 1, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 2, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "2-integral-oddden", + "exact_cert": 3, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 2, + "per_total_contents_c": [ + 1, + 0, + 0 + ], + "scope_identity": true, + "seed": 4015, + "thr": 2, + "untouchable_by_anchor": 1, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "general-Q", + "exact_cert": 3, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -1, + -2 + ], + "scope_identity": true, + "seed": 3535, + "thr": 2, + "untouchable_by_anchor": 3, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "general-Q", + "exact_cert": 3, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 0, + "per_total_contents_c": [ + -1, + -2, + -1 + ], + "scope_identity": true, + "seed": 3666, + "thr": 2, + "untouchable_by_anchor": 3, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "general-Q", + "exact_cert": 3, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + -1, + -1 + ], + "scope_identity": true, + "seed": 3797, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 3, + "chain_min": null, + "engine_witness": 3, + "entry_class": "general-Q", + "exact_cert": 3, + "exact_exhausted": true, + "family": "mixed", + "gamma": -1, + "mp_bound": 3, + "mp_maps": 27, + "mx_form": "all-T (MP)", + "mx_value": 3, + "naive_odd_count": 1, + "per_total_contents_c": [ + -1, + -1, + -1 + ], + "scope_identity": true, + "seed": 3928, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 3, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "dyadic", + "exact_cert": 4, + "exact_exhausted": true, + "family": "evenden", + "gamma": -6, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -6, + -4 + ], + "scope_identity": true, + "seed": 4741, + "thr": 2, + "untouchable_by_anchor": 3, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "dyadic", + "exact_cert": 4, + "exact_exhausted": true, + "family": "evenden", + "gamma": -4, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -2, + -4 + ], + "scope_identity": true, + "seed": 4872, + "thr": 2, + "untouchable_by_anchor": 4, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "dyadic", + "exact_cert": 4, + "exact_exhausted": true, + "family": "evenden", + "gamma": -4, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 1, + "per_total_contents_c": [ + -4, + -2, + -3 + ], + "scope_identity": true, + "seed": 5003, + "thr": 2, + "untouchable_by_anchor": 3, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "dyadic", + "exact_cert": 4, + "exact_exhausted": true, + "family": "evenden", + "gamma": -5, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -5, + -4 + ], + "scope_identity": true, + "seed": 5134, + "thr": 2, + "untouchable_by_anchor": 4, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 1, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "2-integral-oddden", + "exact_cert": 4, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 1, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 4622, + "thr": 2, + "untouchable_by_anchor": 3, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 3, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "2-integral-oddden", + "exact_cert": 4, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 3, + "per_total_contents_c": [ + 0, + 0, + 1 + ], + "scope_identity": true, + "seed": 4753, + "thr": 2, + "untouchable_by_anchor": 1, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 2, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "2-integral-oddden", + "exact_cert": 4, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 2, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 4884, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 1, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "2-integral-oddden", + "exact_cert": 4, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 1, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 5015, + "thr": 2, + "untouchable_by_anchor": 3, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "general-Q", + "exact_cert": 4, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + -2, + -1 + ], + "scope_identity": true, + "seed": 4535, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 3, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "general-Q", + "exact_cert": 4, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + -2, + -1 + ], + "scope_identity": true, + "seed": 4666, + "thr": 2, + "untouchable_by_anchor": 1, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "general-Q", + "exact_cert": 4, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 4797, + "thr": 2, + "untouchable_by_anchor": 4, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 4, + "chain_min": null, + "engine_witness": 4, + "entry_class": "general-Q", + "exact_cert": 4, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 4, + "mp_maps": 81, + "mx_form": "all-T (MP)", + "mx_value": 4, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + 0, + -2 + ], + "scope_identity": true, + "seed": 4928, + "thr": 2, + "untouchable_by_anchor": 2, + "v": 4, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "dyadic", + "exact_cert": 5, + "exact_exhausted": true, + "family": "evenden", + "gamma": -6, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 0, + "per_total_contents_c": [ + -5, + -6, + -4 + ], + "scope_identity": true, + "seed": 5741, + "thr": 3, + "untouchable_by_anchor": 4, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "dyadic", + "exact_cert": 5, + "exact_exhausted": true, + "family": "evenden", + "gamma": -5, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 1, + "per_total_contents_c": [ + -4, + -3, + -5 + ], + "scope_identity": true, + "seed": 5872, + "thr": 3, + "untouchable_by_anchor": 5, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "dyadic", + "exact_cert": 5, + "exact_exhausted": true, + "family": "evenden", + "gamma": -6, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -3, + -6 + ], + "scope_identity": true, + "seed": 6003, + "thr": 3, + "untouchable_by_anchor": 5, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "dyadic", + "exact_cert": 5, + "exact_exhausted": true, + "family": "evenden", + "gamma": -6, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -4, + -6 + ], + "scope_identity": true, + "seed": 6134, + "thr": 3, + "untouchable_by_anchor": 5, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 2, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "2-integral-oddden", + "exact_cert": 5, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 2, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 5622, + "thr": 3, + "untouchable_by_anchor": 3, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 4, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "2-integral-oddden", + "exact_cert": 5, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 4, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 5753, + "thr": 3, + "untouchable_by_anchor": 1, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 2, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "2-integral-oddden", + "exact_cert": 5, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 2, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 5884, + "thr": 3, + "untouchable_by_anchor": 3, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 2, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "2-integral-oddden", + "exact_cert": 5, + "exact_exhausted": true, + "family": "oddden", + "gamma": 0, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 2, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 6015, + "thr": 3, + "untouchable_by_anchor": 3, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "general-Q", + "exact_cert": 5, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 2, + "per_total_contents_c": [ + -2, + -2, + -1 + ], + "scope_identity": true, + "seed": 5535, + "thr": 3, + "untouchable_by_anchor": 4, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "general-Q", + "exact_cert": 5, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 5666, + "thr": 3, + "untouchable_by_anchor": 3, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "general-Q", + "exact_cert": 5, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 5797, + "thr": 3, + "untouchable_by_anchor": 3, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 5, + "chain_min": null, + "engine_witness": 5, + "entry_class": "general-Q", + "exact_cert": 5, + "exact_exhausted": true, + "family": "mixed", + "gamma": -2, + "mp_bound": 5, + "mp_maps": 243, + "mx_form": "all-T (MP)", + "mx_value": 5, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 5928, + "thr": 3, + "untouchable_by_anchor": 4, + "v": 5, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -5, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -4, + -5 + ], + "scope_identity": true, + "seed": 6741, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -4, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -4, + -3 + ], + "scope_identity": true, + "seed": 6872, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 1, + "per_total_contents_c": [ + -6, + -4, + -6 + ], + "scope_identity": true, + "seed": 7003, + "thr": 4, + "untouchable_by_anchor": 4, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -6, + -6 + ], + "scope_identity": true, + "seed": 7134, + "thr": 4, + "untouchable_by_anchor": 6, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 3, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 6622, + "thr": 4, + "untouchable_by_anchor": 3, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 4, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 4, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 6753, + "thr": 4, + "untouchable_by_anchor": 2, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 2, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 2, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 6884, + "thr": 4, + "untouchable_by_anchor": 4, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 1, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 1, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 7015, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 0, + "per_total_contents_c": [ + 0, + -2, + -2 + ], + "scope_identity": true, + "seed": 6535, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 6666, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 2, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 6797, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 6, + "chain_min": null, + "engine_witness": 6, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 6, + "mp_maps": 729, + "mx_form": "all-T (MP)", + "mx_value": 6, + "naive_odd_count": 2, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 6928, + "thr": 4, + "untouchable_by_anchor": 4, + "v": 6, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 1, + "per_total_contents_c": [ + -5, + -4, + -6 + ], + "scope_identity": true, + "seed": 7741, + "thr": 4, + "untouchable_by_anchor": 7, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -5, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 0, + "per_total_contents_c": [ + -5, + -3, + -5 + ], + "scope_identity": true, + "seed": 7872, + "thr": 4, + "untouchable_by_anchor": 6, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 0, + "per_total_contents_c": [ + -4, + -4, + -6 + ], + "scope_identity": true, + "seed": 8003, + "thr": 4, + "untouchable_by_anchor": 7, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 3, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 7622, + "thr": 4, + "untouchable_by_anchor": 4, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 4, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 4, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 7753, + "thr": 4, + "untouchable_by_anchor": 3, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 3, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 7884, + "thr": 4, + "untouchable_by_anchor": 4, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -1, + -1 + ], + "scope_identity": true, + "seed": 7535, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 4, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -1 + ], + "scope_identity": true, + "seed": 7666, + "thr": 4, + "untouchable_by_anchor": 3, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 7, + "chain_min": null, + "engine_witness": 7, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 7, + "mp_maps": 2187, + "mx_form": "all-T (MP)", + "mx_value": 7, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 7797, + "thr": 4, + "untouchable_by_anchor": 5, + "v": 7, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -5, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 0, + "per_total_contents_c": [ + -3, + -4, + -5 + ], + "scope_identity": true, + "seed": 8741, + "thr": 5, + "untouchable_by_anchor": 8, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 1, + "per_total_contents_c": [ + -6, + -5, + -6 + ], + "scope_identity": true, + "seed": 8872, + "thr": 5, + "untouchable_by_anchor": 8, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 1, + "per_total_contents_c": [ + -5, + -6, + -4 + ], + "scope_identity": true, + "seed": 9003, + "thr": 5, + "untouchable_by_anchor": 8, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 5, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 5, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 8622, + "thr": 5, + "untouchable_by_anchor": 3, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 4, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 4, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 8753, + "thr": 5, + "untouchable_by_anchor": 4, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 4, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 4, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 8884, + "thr": 5, + "untouchable_by_anchor": 4, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 8535, + "thr": 5, + "untouchable_by_anchor": 6, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 5, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 8666, + "thr": 5, + "untouchable_by_anchor": 3, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 8, + "chain_min": null, + "engine_witness": 8, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 8, + "mp_maps": 6561, + "mx_form": "all-T (MP)", + "mx_value": 8, + "naive_odd_count": 2, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 8797, + "thr": 5, + "untouchable_by_anchor": 7, + "v": 8, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -5, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 1, + "per_total_contents_c": [ + -5, + -5, + -5 + ], + "scope_identity": true, + "seed": 9741, + "thr": 6, + "untouchable_by_anchor": 8, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 0, + "per_total_contents_c": [ + -6, + -5, + -6 + ], + "scope_identity": true, + "seed": 9872, + "thr": 6, + "untouchable_by_anchor": 9, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 0, + "per_total_contents_c": [ + -6, + -5, + -4 + ], + "scope_identity": true, + "seed": 10003, + "thr": 6, + "untouchable_by_anchor": 9, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 6, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 6, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 9622, + "thr": 6, + "untouchable_by_anchor": 3, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 3, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 9753, + "thr": 6, + "untouchable_by_anchor": 6, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 6, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 6, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 9884, + "thr": 6, + "untouchable_by_anchor": 3, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 2, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 9535, + "thr": 6, + "untouchable_by_anchor": 7, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 4, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 9666, + "thr": 6, + "untouchable_by_anchor": 8, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 3, + "best_known": 9, + "chain_min": null, + "engine_witness": 9, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 9, + "mp_maps": 19683, + "mx_form": "all-T (MP)", + "mx_value": 9, + "naive_odd_count": 2, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 9797, + "thr": 6, + "untouchable_by_anchor": 6, + "v": 9, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 1, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 0, + "per_total_contents_c": [ + -6, + -6, + -4 + ], + "scope_identity": true, + "seed": 10741, + "thr": 6, + "untouchable_by_anchor": 9, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 0, + "per_total_contents_c": [ + -6, + -5, + -5 + ], + "scope_identity": true, + "seed": 10872, + "thr": 6, + "untouchable_by_anchor": 10, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 0, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "dyadic", + "exact_cert": null, + "exact_exhausted": false, + "family": "evenden", + "gamma": -6, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 0, + "per_total_contents_c": [ + -5, + -5, + -6 + ], + "scope_identity": true, + "seed": 11003, + "thr": 6, + "untouchable_by_anchor": 10, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 4, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 4, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 10622, + "thr": 6, + "untouchable_by_anchor": 6, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 6, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 6, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 10753, + "thr": 6, + "untouchable_by_anchor": 4, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": true, + "anchor_reach": 3, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "2-integral-oddden", + "exact_cert": null, + "exact_exhausted": false, + "family": "oddden", + "gamma": 0, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 3, + "per_total_contents_c": [ + 0, + 0, + 0 + ], + "scope_identity": true, + "seed": 10884, + "thr": 6, + "untouchable_by_anchor": 7, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 7, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 0, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 10535, + "thr": 6, + "untouchable_by_anchor": 3, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 5, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 10666, + "thr": 6, + "untouchable_by_anchor": 5, + "v": 10, + "verdict": "certified>=thr" + }, + { + "AN_hypothesis_holds": false, + "anchor_reach": 5, + "best_known": 10, + "chain_min": null, + "engine_witness": 10, + "entry_class": "general-Q", + "exact_cert": null, + "exact_exhausted": false, + "family": "mixed", + "gamma": -2, + "mp_bound": 10, + "mp_maps": 59049, + "mx_form": "all-T (MP)", + "mx_value": 10, + "naive_odd_count": 1, + "per_total_contents_c": [ + -2, + -2, + -2 + ], + "scope_identity": true, + "seed": 10797, + "thr": 6, + "untouchable_by_anchor": 5, + "v": 10, + "verdict": "certified>=thr" + } + ], + "v_range": [ + 3, + 10 + ] + } + } +} \ No newline at end of file diff --git a/research/fstar-entry-class-scope-seed63d5f999/README.md b/research/fstar-entry-class-scope-seed63d5f999/README.md new file mode 100644 index 0000000000..57a710410c --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/README.md @@ -0,0 +1,339 @@ +# fstar-entry-class-scope-seed63d5f999 + +**Settling the statement of F-star residue class (iii) "non-dyadic entries" (no +kappa, no frontier change).** Open problem F-star of +`research/root-unit-decoder-lemmas` (section 7, OPEN) asks whether +`cert(M) >= floor(2v/3)` holds for every exact 3-total rational decoder +`M = sum_{j<=3} p_j q_j^T`. [PR 2717](https://github.com/CrocSwap/integer-mult-bounds/pull/2717) +proved Lemma AN (the mod-2 anchor) and demoted a three-part residue; its item +(c) reads: "for non-dyadic entries (odd primes in denominators) the mod-2 +anchor does not apply at all". +[PR 2774](https://github.com/CrocSwap/integer-mult-bounds/pull/2774) recorded +this class as mathematically murky: odd-denominator rationals are 2-integral, +so the anchor may already cover them. This package determines the precise +scope of Lemma AN and Lemma MX with respect to entry denominators and +**collapses residue class (iii)**: it is mis-stated and empty as an +obstruction, and it merges into the cancellation residue that class (i) +already attacks. **F-star itself is not proved and not refuted here.** Every +claim below is labelled PROVEN, CHECKED or DEMOTED. + +## The object + +A `T = 3` exact decoder on `v` lines is `M = sum_{j=1..3} p_j q_j^T` over the +rationals with `M_tt != 0` on every line. Row support `pi(t) = {j : p_j(t) != 0}`, +column support `sigma(t) = {j : q_j(t) != 0}`, `D(t) = pi(t) intersect sigma(t)` +(nonempty). An *L8 labelling* is F2 vectors `a(t)` supported in `pi(t)` and +`b(t)` supported in `sigma(t)`, with `K_ts = a(t) . b(s) mod 2`; `cert(M)` is +the largest `|S|` admitting an order with `K_tt = 1` on `S` and `K_ts = 0` at +every incidence `M_ts = 0` with `t` before `s` (`t, s` in `S`). The proven +chain `cost >= sum_j r_j >= cert(M)` is from the merged +`research/root-unit-decoder-lemmas` package; this package does not restate its +proof. **F-star** is `cert(M) >= floor(2v/3)` for every exact 3-total rational +decoder. Write `v_2` for the 2-adic valuation of a nonzero rational +(`v_2(a/b) = v_2(a) - v_2(b)` in lowest terms; `Z_(2) = {x : v_2(x) >= 0}` is +the ring of odd-denominator rationals, and `Z[1/2]` is the ring of dyadic +rationals). + +## 1. Lemma SC: the exact scope of Lemma AN's normalization hypothesis — PROVEN + +Fix a factorization `M = sum_j p_j q_j^T`. For total `j` define + +``` +m_j = min { v_2(p_j(t)) : p_j(t) != 0 }, n_j = min { v_2(q_j(s)) : q_j(s) != 0 }, +c_j = m_j + n_j. +``` + +> **Lemma SC.** (a) `c_j = min { v_2(p_j(t) q_j(s)) : p_j(t) q_j(s) != 0 }`, the +> 2-adic content of the rank-1 matrix `p_j q_j^T`; `c_j` is invariant under +> every rescaling `(p_j, q_j) -> (lambda p_j, lambda^{-1} q_j)` of the total. +> (b) A per-total power-of-two rescaling makes both factors 2-integral (all +> entries in `Z_(2)`) if and only if `c_j >= 0` for every `j`. In particular +> Lemma AN's hypothesis ("after per-total powers of two the factorization is +> 2-integral") holds exactly on the factorizations with `c_j >= 0` for all +> totals. + +*Proof.* (a) The nonzero entries of `p_j q_j^T` are exactly the products +`p_j(t) q_j(s)` with both factors nonzero, so the minimum valuation of the +nonzero entries is `min_t v_2(p_j(t)) + min_s v_2(q_j(s)) = m_j + n_j`. Under +`(p_j, q_j) -> (lambda p_j, lambda^{-1} q_j)` the two minima shift by +`v_2(lambda)` and `-v_2(lambda)`, so `c_j` is unchanged. (b) After the +rescaling `(2^alpha p_j, 2^{-alpha} q_j)` the two minima are `m_j + alpha` and +`n_j - alpha`; both are nonnegative for some integer `alpha` exactly when the +interval `[-m_j, n_j]` is nonempty, i.e. `c_j = m_j + n_j >= 0`. `QED` + +**Entry-class coverage (PROVEN, immediate from Lemma SC).** If all entries lie +in `Z_(2)` (odd denominators, i.e. exactly the rationals whose denominators +contain odd primes but no factor of 2, and every integer), then +`m_j, n_j >= 0`, so `c_j >= 0` and Lemma AN applies verbatim, with no +rescaling at all. If entries lie in `Z[1/2]` (dyadic), Lemma AN applies exactly +when every total has `c_j >= 0`; dyadic entryhood alone does not imply this. +For general `Q` the same per-total criterion applies. This settles the +demoted claim (c) of PR 2717 as **mis-stated**: "non-dyadic" entries (odd +primes in denominators) are 2-integral and are precisely where the mod-2 +anchor applies without any change; what can fail is not the denominator's +odd part but the total's 2-adic content. + +## 2. Lemma SG: the scale-invariant anchor and its exact reach — PROVEN + +Let `gamma = min_j c_j` for the given factorization. + +> **Lemma SG.** (a) After the single global rescaling `M -> 2^{-gamma} M` the +> factorization admits a per-total 2-integral normalization, for every rational +> factorization of every entry class; Lemma AN applies to it verbatim. (b) With +> the reduced labels `K_ts = 2^{-gamma} M_ts mod 2`, so `K_ts = 0` at every +> incidence and `K_tt = 1` exactly on `S_gamma = {t : v_2(M_tt) = gamma}`; +> hence `cert(M) >= |S_gamma|`. (c) The reach is exact: every line satisfies +> `v_2(M_tt) >= gamma`, and no mod-2 anchor built from any power-of-two +> normalization of any per-total rescaling of this factorization anchors a line +> outside `S_gamma`. So the anchor family's reach on a fixed factorization is +> exactly `S_gamma`. + +*Proof.* (a) The rescaled totals have contents `c_j - gamma >= 0`; apply Lemma +SC (b) per total. (b) The mod-2 reduction of a 2-integral factorization +satisfies `sum_j a_j(t) b_j(s) = 2^{-gamma} M_ts mod 2`; at an incidence +`M_ts = 0` this is 0, and on the diagonal it is 1 exactly when +`v_2(M_tt) - gamma = 0`. The set `S_gamma` is then feasible in any order. +(c) Each summand `p_j(t) q_j(t)` of `M_tt` has valuation at least `c_j >= +gamma`, so `v_2(M_tt) >= gamma`. A power-of-two normalization at global +exponent `s` needs `c_j + s >= 0` for every `j`, i.e. `s >= -gamma`, and its +anchor marks only lines with `v_2(M_tt) = -s`; combined with `v_2(M_tt) >= +gamma` this forces `v_2(M_tt) = gamma` and `s = -gamma`. `QED` + +**Corollary (repaired form of Lemma AN's corollary).** `cert(M) >= v - #{t : +v_2(M_tt) > gamma}`, and F-star holds on `M` whenever at most `floor(v/3)` +lines have `v_2(M_tt) > gamma` (the *cancellation lines*). Lemma AN's count +`#{t : M_tt odd}` is the special case `gamma = 0` of `|S_gamma|`; when +`gamma != 0` the two counts differ (control SC2 below: `M = 2 I_3` has naive +count 0 and reach 3). PR 2717's corollary sentence ("F-star holds for dyadic +decoders with at most one-third even diagonals") is correct under Lemma AN's +stated hypothesis, but dyadic entries do not by themselves deliver that +hypothesis (control SC1: `p = q = (1/2)(1,1)` on two lines has `c_1 = -2`); +Lemma SG closes that normalization gap for all dyadic, and in fact all +rational, decoders. + +## 3. Pattern invariance: F-star is entry-class-independent — PROVEN + +> **Proposition.** For every `lambda` in `Q*`, `lambda M` has the same +> `(pi, sigma, Z)` as `M`, hence `cert(lambda M) = cert(M)`, and +> `cost_B(lambda M) = cost_B(M)` for every admissible pairing `B`. Moreover +> every rational decoder's `(pi, sigma, Z)` is realized by an integer-entry +> factorization. + +*Proof.* Per-total scaling `(p_j, q_j) -> (a_j p_j, b_j q_j)` with `a_j b_j = +lambda` changes no support (`pi`, `sigma` are zero patterns of the factors) +and multiplies `M` by `lambda`, which changes no off-diagonal zero. The chain +cost uses only `R_j = supp p_j`, `A_j = supp q_j` and F2 ranks of submatrices +of `B`, all unchanged. For the integer realization, let `d` be the least +common multiple of the denominators of all entries of all `p_j` and `q_j`; +then `(d p_j)(d q_j)^T = d^2 p_j q_j^T`, the factorization `d^2 M = sum_j +(d p_j)(d q_j)^T` has integer factors with the same supports, and `d^2 M` has +the same zero pattern and nonzero diagonal. `QED` + +Consequences: the set of realizable `(pi, sigma, Z)` is identical over `Z`, +`Z[1/2]`, `Z_(2)` and `Q`, and F-star holds for all rational decoders if and +only if it holds for integer-entry decoders. No residue of F-star can live in +entry denominators: **residue class (iii) is empty as an obstruction.** Entry +classes gate only coefficient-dependent proof tools (the anchors); the +combinatorial question is shared. + +## 4. Scope of Lemma MX and the coefficient-free lemmas — PROVEN (corollary) + +Lemma MX (PR 2747) mixes three line sets: `A` (anchor lines, labelled by the +mod-2 anchor `a0`, `b0`), `U` (one-sided repairs of the anchor labels) and `T` +(matched pivots `a(t) = b(t) = e_{c(t)}`, `c(t)` in `D(t)`), bounding +`cert(M) >= |A| + |U| + sum_i MAS(Z[C_i])`. Its `A` and `U` parts use the +anchor labels; by Lemma SG those exist for every rational decoder after one +global rescaling, with `A` a subset of `S_gamma`. Its `T` part uses only +supports and the zero digraph. Lemmas SF, MP and RK (PR 2717) are +coefficient-free entirely. So none of the four lemmas carries an +entry-denominator restriction; only the anchor count `|S_gamma|` varies with +the coefficients. No necessity or "exactly when" claim is made for any lemma +hypothesis; each remains sufficient as stated. The only iff statements in this +package are Lemma SC (b) and Lemma SG (c), both proved in both directions. + +## 5. Fixture settlement — CHECKED + +`verify.py`, stdlib, deterministic; certificate digest `39f5c167c495f457`. + +| quantity | `tied_min` (12 lines) | `cex_min_1` (19 lines) | +|---|---|---| +| entry class of `p, q` | integer | integer | +| per-total contents `c_j` | 0, 0, 0 | 0, 0, 0 | +| `gamma` | 0 | 0 | +| `v_2(M_tt)` per line | 1 on all 12 lines | 0 on 8 lines, 1 on 11 lines | +| anchor reach `S_gamma` | 0 of 12 | 8 of 19 (lines 0, 4, 5, 6, 8, 11, 14, 15) | +| PR 2747 `anchor_good` | 0 | 8 | +| anchor-untouchable (`v_2(M_tt) > gamma`) | 12 of 12 | 11 of 19 | +| PR 2747 `tied_isotropic` | 12 | 11 | +| scope identity `K_ts = M_ts mod 2` | checked | checked | +| Lemma AN hypothesis (`c_j >= 0`) | holds | holds | + +Both fixtures are integer-entry decoders (`Z`-entries), so class (iii) is +already empty on the canonical data, and on both fixtures the anchor reach +equals PR 2747's `anchor_good` count exactly while the anchor-untouchable set +equals its `tied_isotropic` count exactly (it records 0 `repairable_1s` on +both). The merge of class (iii) into the cancellation residue is therefore +exact on both canonical instances. On `tied_min` every diagonal sits at +`v_2(M_tt) = 1 > gamma = 0`: all 12 lines are cancellation lines, which is why +the anchor is vacuous there. + +Calibration anchors, all reproduced: + +| anchor | recorded by | recorded | here | +|---|---|---|---| +| `tied_min` one-copy L8 | [PR 2111](https://github.com/CrocSwap/integer-mult-bounds/pull/2111) by DreamingOfClouds (CP-SAT, CHECKED (recorded)) | 11 | 11 (hill-climb re-found, replayed; upper bound `v = 12`) | +| `cex_min_1` one-copy L8 | [PR 2111](https://github.com/CrocSwap/integer-mult-bounds/pull/2111) by DreamingOfClouds (CP-SAT, CHECKED (recorded)) | 18 | 18 (stored witness replayed) | +| chain on the stored pairing | [PR 2111](https://github.com/CrocSwap/integer-mult-bounds/pull/2111) by DreamingOfClouds | 22 (`10+6+6`) | 22 (admissibility re-checked) | +| Lemma MP on `tied_min` | [PR 2747](https://github.com/CrocSwap/integer-mult-bounds/pull/2747) by Aaron Wang (navinor) | 9 (4096 pivot maps) | 9 (exhaustive) | +| Lemma MP on `cex_min_1` | [PR 2747](https://github.com/CrocSwap/integer-mult-bounds/pull/2747) by Aaron Wang (navinor) | 16 (6144 pivot maps) | 16 (exhaustive) | +| Lemma MX on `tied_min` / `cex_min_1` | [PR 2747](https://github.com/CrocSwap/integer-mult-bounds/pull/2747) by Aaron Wang (navinor) | 9 / 16 | 9 / 16 (all-T wins; 2048 mixed maps evaluated on `cex_min_1`, matching its recorded mixing obstruction) | +| `chi(Z)` unconstrained | [PR 2774](https://github.com/CrocSwap/integer-mult-bounds/pull/2774) by Aaron Wang (navinor) | 3 / 3 | 3 (exhaustive subset DP) / 3 (3-colouring decision plus a mutual-zero triangle forcing `>= 3`) | +| non-3-dichromatic under `D(t)` | [PR 2774](https://github.com/CrocSwap/integer-mult-bounds/pull/2774) by Aaron Wang (navinor) | no / no | no / no (matched-pivot value `9 < 12`, `16 < 19`) | + +## 6. Smallest-first falsifier search in the entry-class domain — CHECKED (scoped negative) + +Smallest falsifying instance first (`v` ascending from 3), three generator +families aimed at the statement under audit, deterministic seeds per instance +in `CERTIFICATE.json`. Falsifier criterion: an explicit admissible pairing `B` +with chain cost below `floor(2v/3)`, or exact `cert` below threshold where +exhaustive a-enumeration terminates. An instance is *certified* when a +machine-checked L8 witness of size at or above `floor(2v/3)` is replayed by +the independent checker, which rules a falsifier out on that instance. + +| family | entries | instances | class | Lemma AN hypothesis | falsifiers | certified | +|---|---|---:|---|---|---:|---:| +| `evenden` | halves, quarters | 28 | dyadic | fails on 28 (`gamma < 0`) | 0 | 28 | +| `oddden` | thirds, fifths | 28 | 2-integral (odd denominators) | holds on 28 | 0 | 28 | +| `mixed` | halves and thirds | 28 | general `Q` | fails on 28 (`gamma < 0`) | 0 | 28 | + +Totals: 84 instances, `v = 3..10`, 0 falsifiers, 84 of 84 certified at or +above `floor(2v/3)` (minimum best-known ratio 1.0; exact `cert = v` on all 36 +instances where exhaustive a-enumeration terminates, `v = 3..5`). 56 instances +lie outside Lemma AN's literal hypothesis (negative total contents) and were +covered by Lemma SG's scaling; 66 of 84 have anchor reach below threshold, so +the certificate there was carried by the coefficient-free matched-pivot or +general-labelling witness, exactly as Sections 3-4 predict. The scope identity +`K_ts = M_ts mod 2` was machine-checked on every instance. + +**Early kill and the exact obstruction (recorded).** By the pattern-invariance +proposition the entry-class axis cannot produce a falsifier beyond the shared +combinatorial `(pi, sigma, Z)` space, so the search was a regression test of +the scope machinery rather than a new domain; after 84 instances with zero +falsifiers and per-instance certificates the search was stopped at the +declared domain. The falsifier criterion (admissible-B chain cost) was armed +but never needed to fire. The true residual obstruction of the F-star residue +is exactly: (i-prime) the cancellation lines `{t : v_2(M_tt) > gamma}`, which +now contains PR 2747's tied-minimum/repair/ordering problem and the anchor- +count axis of Lemma AN; and (ii) the zero-digraph structure of PR 2774. Entry +denominators contribute nothing. + +## 7. What is proved, what is checked, what is demoted (the merged residue) + +- **PROVEN:** Lemma SC (the exact per-total criterion for Lemma AN's + normalization hypothesis, with the entry-class coverage of `Z_(2)`, `Z[1/2]` + and `Q`); Lemma SG (the scale-invariant anchor with exact reach + `S_gamma = {t : v_2(M_tt) = gamma}`, subsuming Lemma AN's count); the + pattern-invariance proposition (F-star is entry-class-independent; every + rational pattern has an integer representative); the Lemma MX / SF / MP / RK + scope remark (no entry-denominator restriction). +- **CHECKED (machine, `verify.py`, stdlib, deterministic, ~5 s):** controls + (brute-force-over-all-labellings agreement 3/3 at `v = 3`, diagonal decoder + `cert = 3`, corrupted-witness rejection 2/2, subset-DP MAS hand values 3/3, + dichromatic hand values 4/4, `MP = 3` on the diagonal decoder) and four scope + controls (SC1: the dyadic instance `p = q = (1/2)(1,1)` where Lemma AN's + hypothesis fails with `c = -2` and the scale-invariant anchor still anchors + both lines; SC2: `M = 2 I_3` where the naive odd-diagonal count is 0 and the + reach is 3; SC3: an odd-denominator instance where the anchor applies + verbatim; SC4: reach-witness replay 3/3); the fixture settlement and every + calibration anchor of Section 5; and the 84-instance search of Section 6. +- **DEMOTED / OPEN:** residue class (iii) as stated is demoted: mis-stated + (odd primes in denominators are 2-integral and anchor-covered verbatim) and + empty as an obstruction (no residue can live in entry denominators because + `cert(M)` and the chain are entry-class-invariant). The residue classification + is renamed to two classes: (i-prime) the cancellation lines + `{t : v_2(M_tt) > gamma}` (PR 2747's repair/ordering territory, now including + the anchor-count axis), and (ii) the zero digraphs (PR 2774's territory). + F-star for general rational decoders is neither proved nor refuted. No + necessity claim is made beyond the proved directions of Lemmas SC and SG. The + fixture limits 11/18 rest on PR 2111's recorded CP-SAT optimality, not + re-verified here. `chi(Z) >= 4` above `v = 13` remains budget-limited. + +## Open next questions + +1. **Anchor plus repairs against the threshold.** Is + `|S_gamma| + (PR 2747 repairable count) >= floor(2v/3)` for every rank-3 + decoder? Why it matters: it would prove F-star for every entry class through + the anchor route alone, with no zero-digraph hypothesis; the fixtures show + the bare anchor is short (0 of 12 on `tied_min`), so repairs or pivots must + carry the residue. First step: enumerate tied-heavy decoders at `v <= 8` + with controlled `gamma` (all diagonals above `gamma`, then one, then two + lines at `gamma`) and test the anchor-plus-repair count. Blocker: nothing + structural; needs a dedicated enumeration session. +2. **The best factorization for the anchor reach.** `gamma` and `S_gamma` + depend on the chosen 3-total factorization; a `GL_3(Q)` re-split of the same + `M` can change both. What is `max |S_gamma|` over factorizations of a fixed + pattern? Why it matters: it would sharpen Lemma SG from "for every + factorization" to a pattern-level bound. First step: sample `GL_3(Z)` + re-splits of the fixtures' stored factorizations and track `gamma` and the + reach, checking consistency with the recorded limits 11/18. Blocker: nothing + structural; small linear algebra over `Z_(2)`. + +## Reproduce + +Python 3.10+, standard library only, from the repository root: + +```sh +python3 -B research/fstar-entry-class-scope-seed63d5f999/verify.py +python3 scripts/research_package.py --package research/fstar-entry-class-scope-seed63d5f999 --check-only +python3.12 scripts/research_package.py --package research/fstar-entry-class-scope-seed63d5f999 +``` + +Expected markers: `PASS_FSC_CONTROLS`, `PASS_FSC_FIXTURES`, `PASS_FSC_SEARCH`, +`PASS_FSTAR_ENTRY_CLASS_SCOPE`, and `CERTIFICATE.json` with digest +`39f5c167c495f457` (full digest printed by the run). The registered CPython +3.12 replay prints `PASS_REGISTERED_RESEARCH_PACKAGE +research/fstar-entry-class-scope-seed63d5f999 outcome=completed`. `make` is +not installed on the authoring host; the commands above are the underlying +ones. + +## Credit and provenance + +F-star, the `cert(M)` definition, L8 labellings and the proven chain +`cost >= sum_j r_j >= cert(M)` are from the merged +`research/root-unit-decoder-lemmas` package +([PR 1590](https://github.com/CrocSwap/integer-mult-bounds/pull/1590) by +DreamingOfClouds, with Claude Opus 5.5 (Anthropic) via Claude Code +assistance). The rank-3 configuration model, the named instances `tied_min` +and `cex_min_1`, their recorded one-copy certificate limits (11 and 18, CP-SAT, +CHECKED (recorded)) and the stored cost-22 pairing `data/cex_min_1.B22.json` +are DreamingOfClouds' work in +[PR 2111](https://github.com/CrocSwap/integer-mult-bounds/pull/2111) and +[PR 2162](https://github.com/CrocSwap/integer-mult-bounds/pull/2162); +`data/tied_min.json` and `data/cex_min_1.json` are byte-identical copies of +their data files (sha256 +`670ed90924b601ade22f0d4adaff46d1667e5449326a0f7ba7b88dd8f5906f93` and +`86064701dde94b4f35427bc3e19275eaf1e40e9e90d4fea28e7857f3564d4dd7`). The +residue statement, Lemmas SF/MP/RK/AN and the exact-completion engine design +this package adapts are Aaron Wang's work in +[PR 2717](https://github.com/CrocSwap/integer-mult-bounds/pull/2717); Lemma MX +and the class-(i) closure are Aaron Wang's +[PR 2747](https://github.com/CrocSwap/integer-mult-bounds/pull/2747); the +class-(ii) machinery and the record that class (iii) is murky are Aaron Wang's +[PR 2774](https://github.com/CrocSwap/integer-mult-bounds/pull/2774); the +falsifier census frontier is Aaron Wang's +[PR 2335](https://github.com/CrocSwap/integer-mult-bounds/pull/2335); the +exact cost 12 of `tied_min` is Aaron Wang's +[PR 2379](https://github.com/CrocSwap/integer-mult-bounds/pull/2379); the +exact cost 21 of `cex_min_1` is Nick Petalas' +[PR 2206](https://github.com/CrocSwap/integer-mult-bounds/pull/2206). The +stored 18-witness `data/cex_min_1.witness.json` is from PR 2717's package. +[PR 2613](https://github.com/CrocSwap/integer-mult-bounds/pull/2613) by +thakrarsagar is a same-motif, different-object neighbor (a mod-2 2-integral +rank floor for a bit register model); it does not state the entry-class scope +of Lemma AN/MX. This package does not claim their results; the new content is +Lemmas SC and SG with their proofs, the pattern-invariance proposition, the +Lemma MX scope remark, the entry-class settlement of the two fixtures and the +smallest-first entry-class search. + +Prepared by **Aaron Wang** with help from opencode (substantial AI assistance; +no independent human review claimed). New work in this package is Apache-2.0. diff --git a/research/fstar-entry-class-scope-seed63d5f999/SOURCES.json b/research/fstar-entry-class-scope-seed63d5f999/SOURCES.json new file mode 100644 index 0000000000..e6b602dc35 --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "544a7e82810e30cab61c297cb2e2ea86127fe944", + "files": [ + { + "path": "certificates/selected-result.json", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "usage": "provenance" + }, + { + "path": "docs/research/agent-task-catalog.json", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6", + "usage": "provenance" + }, + { + "path": "research/root-unit-decoder-lemmas/README.md", + "git_blob": "de305484c78226a3f8da5f3277ced78974116fbb", + "sha256": "e3c856bc361a57cc2424c829001dba94e8f3a1bc8f6616f9c2f740e9665506a9", + "usage": "input" + } + ] +} diff --git a/research/fstar-entry-class-scope-seed63d5f999/TASK-CARD.md b/research/fstar-entry-class-scope-seed63d5f999/TASK-CARD.md new file mode 100644 index 0000000000..9a54142bb7 --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/TASK-CARD.md @@ -0,0 +1,96 @@ +# TASK CARD — KB5d: the statement of F-star residue class (iii) "non-dyadic entries" + +```text +Task ID / proposed scope key: KB5d (explicit open request; scope change recorded + in TASK.json) — scope key of the drawn card p104-side-correction + (c5367b1a1b7bed20db53) retained in TASK.json as the drawn card, with the + change reason recorded. +Base commit; exact predecessor and dependency heads: + base 544a7e82810e30cab61c297cb2e2ea86127fe944 (frozen assignment pin); + predecessors PR 2717 head 7aed56bd440a3d8cbca8028cf2cbd0888c07d9b3 + (re-checked at writing; moved from the 10644c90 head recorded in its DONE + comment), PR 2747 head a2bab9978c8149dc5965558ea9277da07bc750e7, + PR 2774 head ceaf5acf976cee2f70a680f2d513f12baa634870 (all three OPEN PRs + by Aaron Wang at entry 23:25 UTC 2026-10-15; re-checked before submission). +Concrete object and question: + Open problem F-star of research/root-unit-decoder-lemmas section 7 (merged, + PR 1590): cert(M) >= floor(2v/3) for every exact 3-total rational decoder + M = sum_{j<=3} p_j q_j^T. PR 2717 proved Lemma AN (mod-2 anchor, + cert(M) >= #{t : M_tt odd} under a 2-integral factorization) and named a + three-part residue; PR 2747 closed class (i) (tied-minimum/isotropic) on the + fixtures with Lemma MX; PR 2774 handled class (ii) (non-3-dichromatic zero + digraphs) and recorded class (iii) "non-dyadic entries" as mathematically + murky. Question: what is the precise scope of Lemma AN/MX with respect to + entry denominators (entries in Z[1/2] vs odd-denominator Z_(2) vs general + Q)? Either collapse residue (iii) — prove the existing lemmas cover all + exact 3-total rational entry classes up to the remaining gap and merge/rename + the classification — or isolate the TRUE residual obstruction with a precise + definition and settle it on tied_min / cex_min_1 and a small falsifier search. +Scope status: changed (authorized explicit open request, KB5d); reason for + change: the assignment names this open request; the chooser draw + (seed 63d5f999cdfe9e1cd9ddf8083f34a9a8) landed on saturated cards + (p104-side-correction, complex-rank-shape-decoder, complex-new-helper-inventory). +Existing restriction being changed (or exact claim being audited): + PR 2717's demoted residue item (c): "for non-dyadic entries (odd primes in + denominators) the mod-2 anchor does not apply at all" — audited, plus the + exact scope of Lemma AN's hypothesis ("after per-total powers of two the + factorization is 2-integral") and Lemma MX's anchor premise. +Method; explicit parameter ranges/candidate alphabet: + Exact stdlib rational (fractions.Fraction) and F2 arithmetic. (P1) State and + prove the exact per-total 2-adic content criterion for Lemma AN's + normalization hypothesis (Lemma SC), a scale-invariant anchor (Lemma SG), + and the entry-class invariance of (pi, sigma, Z), cert and the chain cost + (the collapse). (P2) Settle on the canonical fixtures tied_min (v = 12) and + cex_min_1 (v = 19): entry classes, contents c_j, gamma = min_j c_j, anchor + reach {t : v_2(M_tt) = gamma}, mixed anchor+pivot Lemma-MX values, with the + recorded calibration anchors reproduced (PR 2717: tied_min 11/12, + cex_min_1 18/19, chain 22; PR 2747: MP/MX 9 and 16; PR 2774: chi(Z) = 3 + unconstrained, non-3-dichromatic under D(t)). (P3) smallest-first bounded + falsifier search over entry classes with even denominators (totals with + negative 2-content), odd denominators (2-integral non-integer) and mixed + general-Q entries, v = 3..10, deterministic seeds, exact cert where + exhaustive a-enumeration terminates, engine witnesses elsewhere, admissible-B + chain cost as falsifier criterion, early kill at the first falsifier. +Nearest overlapping PRs and why this adds something: + PR 2717 (Aaron Wang: Lemmas SF/MP/RK/AN and the residue statement; its + demoted item (c) is the object audited here), PR 2747 (Aaron Wang: Lemma MX, + class (i) closure), PR 2774 (Aaron Wang: class (ii); records (iii) as + murky), PR 2335 (Aaron Wang: falsifier census), PR 2111/2162 + (DreamingOfClouds: fixtures, recorded certificate limits), PR 1590 + (DreamingOfClouds: F-star itself). PR 2613 (thakrarsagar) is a same-motif, + different-object neighbor (a mod-2 2-integral rank floor for a bit register + model); it does not state the entry-class scope of Lemma AN/MX. +Declared milestone: audit / scoped proof (no kappa, no supplier, no frontier). +Optimistic full cost budget; required observable improvement: + No kappa or supplier budget in play; the evidence is the written proofs plus + one bounded stdlib replay below 600 s. +Unresolved consumer/restoration costs; family expansion decision if continuing: + None (missing-lemma work); no expansion decision needed. +Success evidence; falsification test; time/compute cap: + PASS markers from verify.py plus README proofs; falsification = an explicit + admissible pairing B with chain cost below floor(2v/3) (proven chain + cost >= cert(M)) or exact cert below threshold where exhaustive; corrupted + witnesses must fail the independent checker; one session, single-process + stdlib Python 3.12, registered verify below 600 s. +Predecessor authors; intended artifact and reproduction command: + F-star and cert(M): DreamingOfClouds, PR 1590 (with Claude Opus 5.5 + (Anthropic) via Claude Code assistance). Fixtures and recorded limits: + DreamingOfClouds, PR 2111 and PR 2162. Lemmas SF/MP/RK/AN, the residue + statement, the exact-completion engine design: Aaron Wang, PR 2717. + Lemma MX: Aaron Wang, PR 2747. Class (ii) machinery: Aaron Wang, PR 2774. + Artifact: research/fstar-entry-class-scope-seed63d5f999/; reproduce with + python3 -B research/fstar-entry-class-scope-seed63d5f999/verify.py then + python3.12 scripts/research_package.py --package + research/fstar-entry-class-scope-seed63d5f999. +``` + +Pair-collision check before computation (toolkit `disc-comments --grep`, +discussions 1317 and 1166, nested replies included, 2026-10-15 23:24-23:26 +UTC): no live claim on residue class (iii) or the entry-class question. +Bounded overlap survey (scripts/find_overlap.py, explicit terms "F-star", +"cert(M)", "3-total decoder", "dyadic", "2-integral", "odd denominator", +"residue class", "non-dyadic", "Lemma AN", "Lemma MX", --refresh, +2026-10-15 23:25-23:27 UTC, complete pagination: 722 open PRs, 1463 +discussion records): only the known predecessors and unrelated dyadic +packages; nearest neighbor PR 2613 (different object). A refined re-run is +required before submission. diff --git a/research/fstar-entry-class-scope-seed63d5f999/TASK.json b/research/fstar-entry-class-scope-seed63d5f999/TASK.json new file mode 100644 index 0000000000..98d006f4fd --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/TASK.json @@ -0,0 +1,87 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 5, + "base_commit": "544a7e82810e30cab61c297cb2e2ea86127fe944", + "original_card": { + "id": "p104-side-correction", + "question": "Which unresolved physical correction, endpoint transport or hosting obligation in a pinned P104 follow-up can be closed or decisively rejected?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 row in research-family-status.md and its exact pending source heads before choosing a task. #1991 is the reviewed channel; #2586 is a pending physical dual with explicit added transport costs, not an admitted supplier.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Check live claims, pin the chosen follow-up and reproduce only the evidence needed for one unresolved obligation. Compare its complete correction/transport/hosting invoice with the target budget; test legal chronological access. Do not rebuild #1991 or assume #2586 has solved global admission.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.", + "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991", + "2586", + "endpoint transport", + "physical dual", + "relay composition" + ] + }, + "scope_status": "changed", + "actual_scope": "Kappa-blocker KB5d (authorized explicit open request): SETTLE THE STATEMENT of open problem F-star residue class (iii) 'non-dyadic entries' of research/root-unit-decoder-lemmas section 7 (cert(M) >= floor(2v/3) for exact 3-total rational decoders). PR 2717 demoted exactly: (c) for non-dyadic entries (odd primes in denominators) the mod-2 anchor does not apply at all; PR 2774 recorded this class as mathematically murky (odd-denominator rationals are 2-integral, so Lemma AN's mod-2 anchor may already apply to 'non-dyadic' entries). Three parts: (P1) state and prove the precise scope of Lemma AN and Lemma MX with respect to entry denominators (entries in Z[1/2] vs odd-denominator Z_(2) vs general Q): the exact per-total 2-adic content criterion (Lemma SC), the scale-invariant anchor with exact reach S_gamma = {t : v_2(M_tt) = gamma} (Lemma SG), and the entry-class invariance of (pi, sigma, Z), cert(M) and the chain cost; (P2) settle the statement on the canonical fixtures tied_min (12 lines) and cex_min_1 (19 lines) with the recorded calibration anchors reproduced; (P3) a smallest-first bounded falsifier search over entry classes with even denominators (totals with negative 2-content), odd denominators (2-integral non-integer) and mixed general-Q entries. Residue class (iii) collapses: it is mis-stated and empty as an obstruction, and merges into the cancellation residue {t : v_2(M_tt) > gamma}.", + "scope_change_reason": "Authorized 'explicit open request' scope change to kappa-blocker KB5d, recorded per the assignment. The chooser OS draw (seed 63d5f999cdfe9e1cd9ddf8083f34a9a8, track complex-mechanisms) landed on the cards p104-side-correction, complex-rank-shape-decoder and complex-new-helper-inventory; the assignment names the draw landing on saturated cards as the recorded reason for taking the KB5d request instead. Pair-collision check before computation (toolkit disc-comments --grep on discussions 1317 and 1166 including nested replies, 2026-10-15 23:24-23:26 UTC) found no live claim on residue class (iii) or the entry-class question: KB5 (PR 2717) DONE/RELEASED 18:20 UTC, KB5b residue (i) (PR 2747) DONE/RELEASED 19:50 UTC, KB5c residue (ii) (PR 2774) DONE/RELEASED 21:27 UTC. A re-check after the session resumed (2026-10-16 00:05 UTC) found only this session's own CLAIM (comment 18961350). Refined overlap re-run on the object's proper names (F-star, cert, 3-total decoder, dyadic, 2-integral, odd denominator, residue class, non-dyadic, Lemma AN, Lemma MX) at 2026-10-15 23:25-23:27 UTC with complete pagination found only the known predecessors and unrelated dyadic packages; nearest neighbor PR 2613 (thakrarsagar) is a same-motif, different-object 2-integral mod-2 rank floor for a bit register model.", + "existing_restriction_being_changed": "Nothing is relaxed. The restriction being audited is PR 2717's demoted residue item (c): 'for non-dyadic entries (odd primes in denominators) the mod-2 anchor does not apply at all', together with the exact scope of Lemma AN's hypothesis ('after per-total powers of two the factorization is 2-integral') and Lemma MX's anchor premise. Every claim carries its exact status label; no 'exactly when' or necessity wording is used beyond the parts proved in both directions (Lemma SC's criterion and Lemma SG's reach).", + "method": "Exact stdlib rational (fractions.Fraction) and F2 arithmetic. Lemma SC: the per-total contents c_j = min_t v_2(p_j(t)) + min_s v_2(q_j(s)), invariant under per-total rescaling; the factorization normalizes to 2-integral iff every c_j >= 0. Lemma SG: one global power-of-two rescaling by 2^{-gamma}, gamma = min_j c_j, makes every rational factorization of every entry class 2-integral; the mod-2 anchor then anchors exactly S_gamma = {t : v_2(M_tt) = gamma} and no power-of-two normalization anchors any other line. Pattern invariance: (pi, sigma, Z), cert(M) and every chain cost are invariant under global rescaling, so F-star's truth domain is entry-class-independent. Engine (signature/opts, exact-completion DP, independent witness checker, hill_climb/exact_cert, chain machinery, zero-digraph MAS/MP/chi) adapted from PR 2774 / PR 2747 / PR 2717 (Aaron Wang), which adapt DreamingOfClouds' PR 2111 model. New: the scope machinery above, the mixed anchor+pivot Lemma-MX values with A = S_gamma (both order forms, U = empty), and the entry-class generators evenden / oddden / mixed.", + "parameter_ranges": "T = 3 totals exactly; rational decoders with nonzero diagonal. Fixtures: PR 2111's tied_min (v = 12) and cex_min_1 (v = 19), byte-identical data copies (sha256 670ed90924b601ade22f0d4adaff46d1667e5449326a0f7ba7b88dd8f5906f93 and 86064701dde94b4f35427bc3e19275eaf1e40e9e90d4fea28e7857f3564d4dd7), plus the stored cost-22 pairing cex_min_1.B22.json (sha256 15f5039069a175831f92c4ffe023a23a6f6e6bd6665f0ca2c2734bbe672b51ef) and the stored 18-witness cex_min_1.witness.json (sha256 153f4d2e8dc262f547a91f2daff9724cab88beb4d45c399497efc68a8ed2c933). Search: v = 3..10, three families (evenden: entries with even denominators, 28 instances; oddden: odd denominators, 28; mixed: halves and thirds, 28), deterministic seeds per instance in CERTIFICATE.json.", + "nearest_overlapping_prs": "https://github.com/CrocSwap/integer-mult-bounds/pull/2717 (Aaron Wang: Lemmas SF/MP/RK/AN and the residue statement; its demoted item (c) is the object audited here). https://github.com/CrocSwap/integer-mult-bounds/pull/2747 (Aaron Wang: Lemma MX and the class-(i) closure; states class (iii) untouched). https://github.com/CrocSwap/integer-mult-bounds/pull/2774 (Aaron Wang: class (ii); records class (iii) as mathematically murky). https://github.com/CrocSwap/integer-mult-bounds/pull/2335 (Aaron Wang: the 196-instance falsifier census; that domain is not repeated). https://github.com/CrocSwap/integer-mult-bounds/pull/2111 and https://github.com/CrocSwap/integer-mult-bounds/pull/2162 (DreamingOfClouds: the fixtures, their recorded certificate limits and the T = 3 model). https://github.com/CrocSwap/integer-mult-bounds/pull/2379 (Aaron Wang: exact cost 12 of tied_min) and https://github.com/CrocSwap/integer-mult-bounds/pull/2206 (Nick Petalas: exact cost 21 of cex_min_1) are cited as context and not recomputed. https://github.com/CrocSwap/integer-mult-bounds/pull/2613 (thakrarsagar) is a same-motif, different-object neighbor (a mod-2 2-integral rank floor for a bit register model); it does not state the entry-class scope of Lemma AN/MX.", + "optimistic_full_cost_budget": "No kappa, supplier, word or moment budget is in play (missing-lemma work). The whole-construction price is the evidence itself: every computational claim is recomputed by verify.py in one bounded stdlib run.", + "bottleneck_link": "F-star is the named route to closing every open T = 3 window at once (research/root-unit-decoder-lemmas section 7, consequence PROVEN given F-star). Residue class (iii) was the last unexamined named residue and the only one stated in terms of coefficient denominators; settling its statement decides whether any entry-denominator obstruction to the mod-2 anchor route exists at all (it does not: the anchor covers every entry class after one global rescaling), which merges the residue into the cancellation lines and zero digraphs that classes (i) and (ii) already attack.", + "stop_rule": "Stop at the first exact falsifier (smallest falsifying instance first: an explicit admissible B with chain cost below floor(2v/3), or exact cert below threshold where exhaustive a-enumeration terminates), or, absent one, at the declared domain v = 3..10 with every instance certified at or above threshold and the exact obstruction recorded. One bounded pivot maximum; early kill with the exact obstruction recorded. Compute cap: one session, single-process stdlib Python, the registered verify command below 600 s.", + "success_evidence": "PASS markers from verify.py (PASS_FSC_CONTROLS, PASS_FSC_FIXTURES, PASS_FSC_SEARCH, PASS_FSTAR_ENTRY_CLASS_SCOPE) plus the written proofs in README.md: controls 3/3 brute-force agreement, 2/2 corrupted-witness rejection, 3/3 MAS hand values, 4/4 chi hand values and 4 scope controls (dyadic negative-content example, scaled positive-content example, odd-denominator anchor verbatim, reach-witness replay); fixture anchors reproduced (tied_min engine witness 11, cex_min_1 stored witness 18, chain engine 22, exhaustive Lemma MP 9 and 16 over 4096 / 6144 pivot maps, mixed Lemma MX 9 and 16, chi(Z) = 3 unconstrained and non-3-dichromatic under D(t)); the entry-class settlement (both fixtures integer-entry, gamma = 0, anchor reach 0/12 and 8/19 equal to PR 2747's anchor_good counts, untouchable 12/12 and 11/19 equal to its tied_isotropic counts); and the smallest-first entry-class search (84 instances, v = 3..10, 0 falsifiers, 84 machine-checked certificates at or above floor(2v/3), 56 instances where Lemma AN's literal hypothesis fails and the scale-invariant anchor applies).", + "falsification_test": "An explicit admissible pairing B with cost(B) = sum_j rank_F2 B[R_j,A_j] < floor(2v/3) refutes F-star on that instance (the chain cost >= cert(M) is proven), as does exact cert < floor(2v/3) where exhaustive a-enumeration terminates; a machine-checked L8 witness of size >= floor(2v/3) rules a falsifier out on that instance; corrupted witnesses must fail the independent checker.", + "time_compute_cap": "One session; single-process stdlib Python 3.12; no SAT solver, no third-party packages; the registered verify command below 600 s (observed about 5 s); package registered with timeout_seconds 600.", + "predecessor_authors": "F-star, the cert(M) definition, L8 labellings and the proven chain cost >= sum_j r_j >= cert(M): research/root-unit-decoder-lemmas, PR 1590 by DreamingOfClouds (with Claude Opus 5.5 (Anthropic) via Claude Code assistance). The rank-3 configuration model, the named instances tied_min and cex_min_1, their recorded one-copy certificate limits (11 and 18, CP-SAT) and the stored cost-22 pairing: DreamingOfClouds, PR 2111 and PR 2162. Lemmas SF/MP/RK/AN, the residue statement and the exact-completion engine design this package adapts: Aaron Wang, PR 2717. Lemma MX and the class-(i) closure: Aaron Wang, PR 2747. Class (ii) machinery: Aaron Wang, PR 2774. The falsifier census frontier: Aaron Wang, PR 2335. Exact cost 12 of tied_min: Aaron Wang, PR 2379. Exact cost 21 of cex_min_1: Nick Petalas (petalas), PR 2206.", + "intended_artifact": "research/fstar-entry-class-scope-seed63d5f999/ with TASK.json, SOURCES.json pins, VERIFY.json, TASK-CARD.md, verify.py, data/ (byte-identical fixture copies, the stored cost-22 pairing and the stored 18-witness, sha256 recorded), CERTIFICATE.json (written by verify.py) and README.md; reproduction: python3 -B research/fstar-entry-class-scope-seed63d5f999/verify.py then python3.12 scripts/research_package.py --package research/fstar-entry-class-scope-seed63d5f999.", + "outcome": "completed", + "evidence": "RESIDUE CLASS (iii) SETTLED: IT IS MIS-STATED AND EMPTY AS AN OBSTRUCTION; THE MOD-2 ANCHOR HAS NO ENTRY-DENOMINATOR RESTRICTION. PROVEN (written proofs in README.md): Lemma SC (the exact per-total criterion: the factorization normalizes to 2-integral after per-total powers of two iff every total's 2-content c_j >= 0; odd-denominator Z_(2) entries satisfy it verbatim, dyadic Z[1/2] entries exactly when the contents are nonnegative, general Q by the same criterion); Lemma SG (one global rescaling by 2^{-gamma}, gamma = min_j c_j, covers every rational factorization of every entry class; the mod-2 anchor then anchors exactly S_gamma = {t : v_2(M_tt) = gamma} and no power-of-two normalization anchors any other line; cert(M) >= |S_gamma|); the pattern invariance ((pi, sigma, Z), cert(M) and every chain cost are invariant under global rescaling, so F-star is entry-class-independent and residue class (iii) is empty as an obstruction). CHECKED (verify.py, stdlib, deterministic, certificate digest 39f5c167c495f457): controls 3/3 brute-force agreement, diagonal cert 3, 2/2 corrupted-witness rejection, 3/3 MAS hand values, 4/4 chi hand values, MP = 3 on the diagonal decoder, and 4 scope controls including the dyadic p = q = (1/2,1/2) instance where Lemma AN's literal hypothesis fails (c = -2) and the scale-invariant anchor still anchors all lines, the scaled M = 2*I_3 instance where the naive odd-diagonal count is 0 but the reach is 3, and an odd-denominator (non-dyadic) instance where the anchor applies verbatim. Calibration reproduces every recorded anchor: tied_min 11/12 (hill-climb re-found, replayed), cex_min_1 18/19 (stored witness replayed), chain engine 22 on PR 2111's stored pairing, Lemma MP 9 and 16 exhaustive over 4096 / 6144 pivot maps, Lemma MX (mixed anchor+pivot, U = empty) 9 and 16 with the all-T construction winning (matching PR 2747's recorded obstruction), chi(Z) = 3 unconstrained on both fixtures (exhaustive on tied_min; 3-colouring decision plus a mutual-zero triangle on cex_min_1) and non-3-dichromatic under D(t) on both. Fixture settlement: both fixtures are integer-entry decoders (so class (iii) is already empty on the canonical data), gamma = 0, anchor reach 0/12 and 8/19 equal to PR 2747's anchor_good counts, anchor-untouchable 12/12 and 11/19 equal to its tied_isotropic counts - the merge of (iii) into the cancellation residue is exact on both fixtures. Smallest-first falsifier search (v = 3..10, 84 instances: 28 evenden with even denominators, 28 oddden with odd denominators, 28 mixed; 56 instances with gamma < 0 where Lemma AN's literal hypothesis fails): 0 falsifiers, 84/84 machine-checked L8 certificates at or above floor(2v/3) (66 of them with anchor reach below threshold, carried by the coefficient-free matched-pivot certificate), exact cert = v on all 36 instances where exhaustive a-enumeration terminates (v = 3..5), minimum best-known ratio 1.0. DEMOTED / OPEN: F-star for general rational decoders is neither proved nor refuted; the residue collapses to (i-prime) the cancellation lines {t : v_2(M_tt) > gamma} (the repair/ordering problem of PR 2747, now including the anchor-count axis) and (ii) the zero digraphs of PR 2774; residue class (iii) as stated is DEMOTED (mis-stated: odd primes in denominators are 2-integral and anchor-covered; and empty: no residue can live in entry denominators because cert is entry-class-invariant). No 'exactly when' or necessity claim beyond the two proved directions of Lemma SC and Lemma SG. The fixture limits 11/18 rest on PR 2111's recorded CP-SAT optimality, not re-verified here. The falsifier criterion (admissible-B chain cost) was armed but never triggered because every searched instance carried a replayed certificate.", + "author": "Aaron Wang (with help from opencode)", + "ai_assistance": "Substantial AI assistance: this package was produced by Aaron Wang with help from opencode (opencode agent harness). No independent human review claimed. No model is cited per orchestrator attribution rules.", + "open_questions": [ + { + "question": "Does the scale-invariant anchor reach |S_gamma| plus one-sided repairs always reach floor(2v/3)? Concretely: for every rank-3 decoder, is |{t : v_2(M_tt) = gamma}| plus the PR 2747 repairable count at least floor(2v/3)?", + "why_it_matters": "It would prove F-star for every entry class through the anchor route alone, with no zero-digraph hypothesis; the fixtures show the pure anchor is short (0/12 on tied_min), so the repairs or the pivots must carry the residue.", + "first_step": "Enumerate tied-heavy decoders at v <= 8 with controlled gamma (force all diagonals above gamma, then one, then two lines at gamma) and test the anchor+repair count against floor(2v/3).", + "blocked_by": "Nothing structural; needs a dedicated enumeration session." + }, + { + "question": "What is the maximum, over factorizations of a fixed decoder pattern, of the scale-invariant anchor reach |{t : v_2(M_tt) = gamma}|?", + "why_it_matters": "gamma and S_gamma depend on the chosen 3-total factorization; a GL_3(Q) re-split of the same M can change both. A characterization would sharpen Lemma SG from 'for every factorization' to a pattern-level bound.", + "first_step": "On tied_min and cex_min_1, sample GL_3(Z) re-splits of the stored factorization and track gamma and the reach; test whether the reach can exceed the recorded anchor_good counts without violating the recorded certificate limits 11/18.", + "blocked_by": "Nothing structural; small linear algebra over Z_(2)." + } + ] +} diff --git a/research/fstar-entry-class-scope-seed63d5f999/VERIFY.json b/research/fstar-entry-class-scope-seed63d5f999/VERIFY.json new file mode 100644 index 0000000000..2d3038c54c --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/root-unit-decoder-lemmas/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "F-star residue class (iii) entry-class-scope package: controls (brute-force-over-all-labellings agreement 3/3 at v = 3, diagonal decoder cert = 3, corrupted-witness rejection 2/2, subset-DP MAS hand values 3/3, dichromatic hand values 4/4, MP = 3 on the diagonal decoder) and four scope controls (the dyadic p = q = (1/2,1/2) instance where Lemma AN's literal hypothesis fails and the scale-invariant anchor still anchors every line; the scaled M = 2*I_3 instance where the naive odd-diagonal count is 0 but the reach is 3; the odd-denominator instance where the anchor applies verbatim; reach-witness replay); fixture calibration reproducing PR 2717 anchors (tied_min engine witness 11, cex_min_1 stored witness 18, PR 2111 stored pairing chain cost 22) and PR 2747 anchors (exhaustive Lemma MP 9 on tied_min over 4096 pivot maps and 16 on cex_min_1 over 6144; Lemma MX with A = S_gamma 9 and 16), the entry-class settlement of both fixtures (integer entries, gamma = min_j c_j = 0, anchor reach {t : v_2(M_tt) = gamma} 0/12 and 8/19 equal to PR 2747's anchor_good counts, scope identity K_ts = M_ts mod 2 machine-checked), the chi(Z) = 3 unconstrained and non-3-dichromatic-under-D calibration, and the smallest-first entry-class falsifier search (v = 3..10, evenden/oddden/mixed families, exact cert where exhaustive, engine witnesses, admissible-B chain cost as falsifier criterion, early kill); prints PASS_FSC_CONTROLS, PASS_FSC_FIXTURES, PASS_FSC_SEARCH and PASS_FSTAR_ENTRY_CLASS_SCOPE and writes CERTIFICATE.json" + } + ] +} diff --git a/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.B22.json b/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.B22.json new file mode 100644 index 0000000000..0161536922 --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.B22.json @@ -0,0 +1 @@ +[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]] \ No newline at end of file diff --git a/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.json b/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.json new file mode 100644 index 0000000000..4629aa02b1 --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.json @@ -0,0 +1 @@ +[[[1, -1, 0], [1, 0, -1]], [[1, -1, 1], [0, 1, -1]], [[1, -1, 1], [1, -1, 0]], [[1, -1, 1], [1, 0, 1]], [[1, 0, -1], [0, 1, -1]], [[1, 0, -1], [0, 1, 1]], [[1, 0, -1], [1, -1, 0]], [[1, 0, -1], [1, 1, -1]], [[1, 0, 1], [1, 1, 0]], [[1, 0, 1], [1, 1, 1]], [[1, 1, -1], [0, 1, -1]], [[1, 1, -1], [1, -1, 1]], [[1, 1, -1], [1, 0, -1]], [[1, 1, -1], [1, 1, 0]], [[1, 1, 0], [0, 1, 1]], [[1, 1, 0], [1, 0, 1]], [[1, 1, 1], [0, 1, 1]], [[1, 1, 1], [1, 0, 1]], [[1, 1, 1], [1, 1, 0]]] \ No newline at end of file diff --git a/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.witness.json b/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.witness.json new file mode 100644 index 0000000000..602d784e98 --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/data/cex_min_1.witness.json @@ -0,0 +1 @@ +{"a": [3, 2, 2, 4, 4, 5, 5, 4, 1, 1, 2, 7, 5, 1, 2, 3, 6, 1, 1], "b": [1, 6, 0, 5, 6, 6, 1, 4, 3, 7, 6, 2, 1, 3, 6, 5, 2, 5, 3], "order": [16, 6, 11, 14, 5, 12, 0, 18, 17, 15, 3, 13, 10, 9, 8, 7, 4, 1], "kept": [16, 6, 11, 14, 5, 12, 0, 18, 17, 15, 3, 13, 10, 9, 8, 7, 4, 1]} \ No newline at end of file diff --git a/research/fstar-entry-class-scope-seed63d5f999/data/tied_min.json b/research/fstar-entry-class-scope-seed63d5f999/data/tied_min.json new file mode 100644 index 0000000000..ae11f01fab --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/data/tied_min.json @@ -0,0 +1 @@ +[[[1, -1, -1], [0, 1, 1]], [[1, -1, -1], [1, -1, 0]], [[1, -1, -1], [1, 0, -1]], [[1, -1, 1], [0, 1, -1]], [[1, -1, 1], [1, -1, 0]], [[1, -1, 1], [1, 0, 1]], [[1, 1, -1], [0, 1, -1]], [[1, 1, -1], [1, 0, -1]], [[1, 1, -1], [1, 1, 0]], [[1, 1, 1], [0, 1, 1]], [[1, 1, 1], [1, 0, 1]], [[1, 1, 1], [1, 1, 0]]] \ No newline at end of file diff --git a/research/fstar-entry-class-scope-seed63d5f999/verify.py b/research/fstar-entry-class-scope-seed63d5f999/verify.py new file mode 100644 index 0000000000..820b72a301 --- /dev/null +++ b/research/fstar-entry-class-scope-seed63d5f999/verify.py @@ -0,0 +1,1199 @@ +#!/usr/bin/env python3 +"""F-star residue class (iii): the exact entry-class scope of Lemma AN / Lemma MX. + +Exact stdlib computation over rank-3 rational decoders M = sum_j p_j q_j^T. +New scope machinery: the per-total 2-adic contents c_j and gamma = min_j c_j; +the exact mod-2 anchor reach S_gamma = {t : v_2(M_tt) = gamma} after the +scale-invariant normalization (Lemma SC/SG); entry-class classification +(integer / dyadic / 2-integral odd-denominator / general Q); the mixed +anchor+pivot Lemma-MX values with A = S_gamma; and a smallest-first falsifier +search over entry classes with even and odd denominators. + +Engine credit: the model (signature/opts), the exact-completion engine +(bfeas_tables/blockers_pred/complete/reconstruct), the independent witness +checker, hill_climb/exact_cert, the chain machinery (block_rank/chain_cost/ +min_chain_cost) and the zero-digraph machinery (ac_mas_tables/mp_exact/ +chi_exact_dp/chi_le3_backtrack/omega_mutual) are adapted from Aaron Wang's +PR 2774 research/fstar-zero-digraph-residue-seede9937f18, PR 2747 +research/fstar-tied-residue-seeddcc97691 and PR 2717 +research/fstar-proof-lemmas-seed3096ed3f, which adapt DreamingOfClouds' +PR 2111 rank-3 model. New in this file: v2/contents/gamma, anchor_labels +(scale-invariant mod-2 reduction), scope identity checks, reach witnesses, +mx_anchor_pivot (Lemma MX with U = empty and A = S_gamma), the entry-class +generators and the scope controls. Apache-2.0. +""" + +import hashlib +import itertools +import json +import os +import random +import sys +import time +from fractions import Fraction + +sys.setrecursionlimit(10000) + +HERE = os.path.dirname(os.path.abspath(__file__)) +DATA = os.path.join(HERE, "data") +T0 = time.time() + + +def log(msg): + print(f"[{time.time() - T0:7.2f}s] {msg}", flush=True) + + +# ---------------------------------------------------------------- model ---- +def signature(P, Q): + v = len(P) + M = [[sum(P[t][j] * Q[s][j] for j in range(3)) for s in range(v)] for t in range(v)] + pi = [sum(1 << j for j in range(3) if P[t][j]) for t in range(v)] + sg = [sum(1 << j for j in range(3) if Q[t][j]) for t in range(v)] + Z = [[M[t][s] == 0 for s in range(v)] for t in range(v)] + assert all(M[t][t] != 0 for t in range(v)), "decoder must have nonzero diagonal" + return M, pi, sg, Z + + +def opts(pi_t): + return [m for m in range(1, 8) if not (m & ~pi_t)] + + +def threshold(v): + return (2 * v) // 3 + + +# --------------------------------------------- exact completion engine ---- +def bfeas_tables(pi, sg): + tabs = [] + for t in range(len(pi)): + tab = [[False] * 256 for _ in range(8)] + for am in range(1, 8): + if am & ~pi[t]: + continue + for bset in range(256): + ok = False + for b in range(1, 8): + if b & ~sg[t] or ((am & b).bit_count() & 1) == 0: + continue + good, bs = True, bset + while bs: + lb = bs & -bs + if (((lb.bit_length() - 1) & b).bit_count() & 1): + good = False + break + bs ^= lb + if good: + ok = True + break + tab[am][bset] = ok + tabs.append(tab) + return tabs + + +def blockers_pred(Z, v): + pred = [0] * v + for t in range(v): + m = 0 + for s in range(v): + if s != t and Z[s][t]: + m |= 1 << s + pred[t] = m + return pred + + +def complete(a, pi, sg, Z, v, tabs): + """Exact max |S| over (b, order, S) for fixed a-labels. Returns (value, bestT, f).""" + pred = blockers_pred(Z, v) + N = 1 << v + Abits = bytearray(N) + for U in range(1, N): + lb = U & -U + Abits[U] = Abits[U ^ lb] | (1 << a[lb.bit_length() - 1]) + f = bytearray(N) + f[0] = 1 + best, bestT = 0, 0 + for T in range(1, N): + ok, U = 0, T + while U: + lb = U & -U + u = lb.bit_length() - 1 + prev = T ^ lb + if f[prev] and tabs[u][a[u]][Abits[prev & pred[u]]]: + ok = 1 + break + U ^= lb + f[T] = ok + if ok and T.bit_count() > best: + best, bestT = T.bit_count(), T + return best, bestT, f + + +def reconstruct(a, sg, Z, v, tabs, bestT, f): + pred = blockers_pred(Z, v) + + def ab(U): + r, x = 0, U + while x: + lb = x & -x + r |= 1 << a[lb.bit_length() - 1] + x ^= lb + return r + + rev, T = [], bestT + while T: + found, U = None, T + while U: + lb = U & -U + u = lb.bit_length() - 1 + prev = T ^ lb + if f[prev] and tabs[u][a[u]][ab(prev & pred[u])]: + found = u + break + U ^= lb + assert found is not None + rev.append(found) + T ^= 1 << found + order = rev[::-1] + kept, bs = [], [0] * v + for t in order: + bset = 0 + for s in kept: + if Z[s][t]: + bset |= 1 << a[s] + for cand in range(1, 8): + if cand & ~sg[t] or ((a[t] & cand).bit_count() & 1) == 0: + continue + good, x = True, bset + while x: + lb = x & -x + if (((lb.bit_length() - 1) & cand).bit_count() & 1): + good = False + break + x ^= lb + if good: + bs[t] = cand + break + kept.append(t) + return order, bs + + +def check_witness(sig, wit): + """Independent replay of a labelling/order witness. True iff valid.""" + M, pi, sg, Z = sig + a, b, order = wit["a"], wit["b"], wit["order"] + if sorted(order) != sorted(set(order)) or not order: + return False + for t in order: + if not (1 <= a[t] <= 7) or (a[t] & ~pi[t]) or (b[t] & ~sg[t]): + return False + if (((a[t] & b[t]).bit_count() & 1)) != 1: + return False + for i, t in enumerate(order): + for s in order[i + 1:]: + if M[t][s] == 0 and (((a[t] & b[s]).bit_count() & 1)) == 1: + return False + return True + + +def hill_climb(sig, tabs, iters=240, seed=5, start=None): + """Deterministic hill-climb over a-labels with exact completion; returns witness dict.""" + M, pi, sg, Z = sig + v = len(M) + rng = random.Random(seed) + a = list(start) if start else [rng.choice(opts(pi[t])) for t in range(v)] + best, bestT, bestF = complete(a, pi, sg, Z, v, tabs) + for _ in range(iters): + t = rng.randrange(v) + old = a[t] + cand = [m for m in opts(pi[t]) if m != old] + if not cand: + continue + a[t] = rng.choice(cand) + val, T, F = complete(a, pi, sg, Z, v, tabs) + if val >= best: + best, bestT, bestF = val, T, F + else: + a[t] = old + order, bs = reconstruct(a, sg, Z, v, tabs, bestT, bestF) + wit = {"a": a, "b": bs, "order": order} + assert check_witness(sig, wit), "hill-climb produced an invalid witness" + return best, wit + + +def exact_cert(sig, tabs, cap=200000): + """Exact cert by enumerating all a-labelings, when the product of option + counts is within cap. Returns (value, exhausted).""" + M, pi, sg, Z = sig + v = len(M) + counts = [len(opts(pi[t])) for t in range(v)] + total = 1 + for c in counts: + total *= c + if total > cap: + return None, False + best = 0 + for pick in itertools.product(*[opts(pi[t]) for t in range(v)]): + val, T, _ = complete(list(pick), pi, sg, Z, v, tabs) + if val > best: + best = val + if val == v: + break + return best, True + + +# ---------------------------------------- zero-digraph machinery ---- +def pred_masks_from_Z(Z, v): + return blockers_pred(Z, v) + + +def ac_mas_tables(pred, v): + """acyclic[U] and mas[U] for every subset U of [v] (bitmask), O(v * 2^v).""" + N = 1 << v + ac = bytearray(N) + ac[0] = 1 + mas = [0] * N + for U in range(1, N): + ok = 0 + x = U + while x: + lb = x & -x + t = lb.bit_length() - 1 + if (pred[t] & U) == 0 and ac[U ^ lb]: + ok = 1 + break + x ^= lb + ac[U] = ok + if ok: + mas[U] = U.bit_count() + else: + best, x = 0, U + while x: + lb = x & -x + m = mas[U ^ lb] + if m > best: + best = m + x ^= lb + mas[U] = best + return ac, mas + + +def mas_subset(ac, mas, U): + """One acyclic induced subset A of U with |A| = mas[U] (greedy reconstruction).""" + if ac[U]: + return U + best = mas[U] + x = U + while x: + lb = x & -x + if mas[U ^ lb] == best: + return mas_subset(ac, mas, U ^ lb) + x ^= lb + raise AssertionError("mas reconstruction failed") + + +def sink_first_order(Z, S): + """Repeatedly take sinks (no outgoing Z-edge inside the remainder) first.""" + order = [] + rem = S + while rem: + found = None + x = rem + while x: + lb = x & -x + t = lb.bit_length() - 1 + if not any(Z[t][s] for s in range(len(Z)) if s != t and (rem >> s) & 1): + found = t + break + x ^= lb + assert found is not None, "subset not acyclic" + order.append(found) + rem ^= 1 << found + return order + + +def mp_exact(sig, mas, mp_cap=5000000): + """Exact Lemma MP value: max over pivot maps c: [v] -> D(t) of + sum_i MAS(Z[C_i]). Returns (value, worst, nmaps, best_pick) or + (None, None, nmaps, None) when nmaps > mp_cap.""" + M, pi, sg, Z = sig + v = len(M) + Dopts = [pi[t] & sg[t] for t in range(v)] + lists = [[b for b in (1, 2, 4) if Dopts[t] & b] for t in range(v)] + nmaps = 1 + for cl in lists: + nmaps *= len(cl) + if nmaps > mp_cap: + return None, None, nmaps, None + best, worst, best_pick = 0, v, None + for pick in itertools.product(*lists): + c1 = c2 = c3 = 0 + for t, m in enumerate(pick): + if m == 1: + c1 |= 1 << t + elif m == 2: + c2 |= 1 << t + else: + c3 |= 1 << t + val = mas[c1] + mas[c2] + mas[c3] + if val > best: + best, best_pick = val, pick + if val < worst: + worst = val + return best, worst, nmaps, best_pick + + +def omega_mutual(sig): + """Exact size of the largest mutual-zero clique (Lemma RK (a): <= 3).""" + M, pi, sg, Z = sig + v = len(M) + mnei = [0] * v + for t in range(v): + for s in range(v): + if s != t and Z[t][s] and Z[s][t]: + mnei[t] |= 1 << s + N = 1 << v + clq = bytearray(N) + clq[0] = 1 + best = 0 + for U in range(1, N): + lb = U & -U + t = lb.bit_length() - 1 + rest = U ^ lb + if clq[rest] and (mnei[t] & rest) == rest: + clq[U] = 1 + if U.bit_count() > best: + best = U.bit_count() + return best + + +def chi_exact_dp(pred, v): + """Exact dichromatic number by subset DP (exact for v <= 13).""" + N = 1 << v + ac, mas = ac_mas_tables(pred, v) + chi = [99] * N + chi[0] = 0 + for S in range(1, N): + best = 99 + A = S + while A: + if ac[A]: + val = 1 + chi[S ^ A] + if val < best: + best = val + A = (A - 1) & S + chi[S] = best + return chi[N - 1] + + +def chi_le3_backtrack(pred, v, allowed=None, budget=2000000): + """Decide 3-colourability into acyclic classes with optional per-vertex + allowed colours; returns (result, exhausted), result None when budget ends.""" + if allowed is None: + allowed = [7] * v + order = sorted(range(v), key=lambda t: -((pred[t].bit_count()) + + sum(1 for s in range(v) if s != t and (pred[s] >> t) & 1))) + cls = [0, 0, 0] + nodes = [0] + succ = [[s for s in range(v) if s != t and ((pred[s] >> t) & 1)] for t in range(v)] + + def adds_cycle(t, cmask): + seen = 0 + stack = [u for u in succ[t] if (cmask >> u) & 1] + while stack: + u = stack.pop() + if u == t: + return True + if (seen >> u) & 1: + continue + seen |= 1 << u + for w in succ[u]: + if w == t: + return True + if (cmask >> w) & 1 and not ((seen >> w) & 1): + stack.append(w) + return False + + def rec(k): + nodes[0] += 1 + if nodes[0] > budget: + return None + if k == v: + return True + t = order[k] + for bi in (0, 1, 2): + if not (allowed[t] & (1 << bi)): + continue + if adds_cycle(t, cls[bi]): + continue + cls[bi] |= 1 << t + r = rec(k + 1) + cls[bi] ^= 1 << t + if r is not None: + return r + return False + + r = rec(0) + return r, nodes[0] > budget + + +def mutual_pair_count(sig): + M, pi, sg, Z = sig + v = len(M) + return sum(1 for t in range(v) for s in range(t + 1, v) if Z[t][s] and Z[s][t]) + + +def arc_count(sig): + M, pi, sg, Z = sig + v = len(M) + return sum(1 for t in range(v) for s in range(v) if s != t and Z[t][s]) + + +# ---------------------------------------------------- chain / B search ---- +def block_rank(rows_mask, Rj, Aj, v): + cols = [c for c in range(v) if (Aj >> c) & 1] + mat = [] + for t in range(v): + if (Rj >> t) & 1: + row = 0 + for i, c in enumerate(cols): + if (rows_mask[t] >> c) & 1: + row |= 1 << i + mat.append(row) + rank = 0 + for i in range(len(cols)): + piv = None + for r in range(rank, len(mat)): + if (mat[r] >> i) & 1: + piv = r + break + if piv is not None: + mat[rank], mat[piv] = mat[piv], mat[rank] + for r in range(len(mat)): + if r != rank and ((mat[r] >> i) & 1): + mat[r] ^= mat[rank] + rank += 1 + return rank + + +def chain_cost(Brows, pi, sg, v): + total = 0 + for j in range(3): + Rj = sum(1 << t for t in range(v) if (pi[t] >> j) & 1) + Aj = sum(1 << t for t in range(v) if (sg[t] >> j) & 1) + total += block_rank(Brows, Rj, Aj, v) + return total + + +def min_chain_cost(sig, budget_free=12, local_evals=30, seed=7): + """Minimum chain cost over admissible B; exhaustive when few free pairs, + else bounded deterministic local search. Any B found bounds cert from + above through the proven chain cost >= cert(M).""" + M, pi, sg, Z = sig + v = len(M) + free = [(t, s) for t in range(v) for s in range(v) if t != s and Z[t][s]] + f = len(free) + + def cost_of(bits): + Brows = [1 << t for t in range(v)] + for k, (t, s) in enumerate(free): + if (bits >> k) & 1: + Brows[t] |= 1 << s + return chain_cost(Brows, pi, sg, v) + + best_bits = 0 + best = cost_of(0) + if f <= budget_free: + for bits in range(1, 1 << f): + c = cost_of(bits) + if c < best: + best, best_bits = c, bits + best_bits = bits + else: + rng = random.Random(seed) + for start in range(local_evals): + bits = 0 if start == 0 else rng.getrandbits(f) + cur = cost_of(bits) + improved = True + while improved: + improved = False + for k in range(f): + nxt = bits ^ (1 << k) + c = cost_of(nxt) + if c < cur: + best, best_bits, cur, improved, bits = c, nxt, c, True, nxt + elif c == cur and rng.random() < 0.02: + bits, cur = nxt, c + return best, best_bits + + +# ------------------------------------------------- scope machinery (new) ---- +def v2(x): + """2-adic valuation of a Fraction; 0 maps to +10**9.""" + if x == 0: + return 10 ** 9 + n, d = x.numerator, x.denominator + k = 0 + while n % 2 == 0: + n //= 2 + k += 1 + while d % 2 == 0: + d //= 2 + k -= 1 + return k + + +def total_contents(P, Q): + """c_j = min_t v2(p_j(t)) + min_s v2(q_j(s)) = 2-content of total j's + rank-1 matrix p_j q_j^T (invariant under per-total rescaling).""" + v = len(P) + cs = [] + for j in range(3): + ps = [v2(P[t][j]) for t in range(v) if P[t][j] != 0] + qs = [v2(Q[t][j]) for t in range(v) if Q[t][j] != 0] + if not ps or not qs: + cs.append(None) # zero total + else: + cs.append(min(ps) + min(qs)) + return cs + + +def gamma_of(cs): + fin = [c for c in cs if c is not None] + return min(fin) + + +def anchor_labels(P, Q): + """Scale-invariant mod-2 anchor (Lemma SC/SG): gamma = min_j c_j; per total + j rescale p_j by 2^{-m_j} (m_j = min_t v2(p_j(t))) and q_j by 2^{-gamma+m_j}. + Every total is then 2-integral; reduce mod 2 to labels a(t), b(t). + Returns (a, b, gamma, cs, diagv2) with K_ts = a(t).b(s) == [v2(M_ts) == gamma] + for M_ts != 0 and 0 at every zero (the scope identity, machine-checked).""" + v = len(P) + cs = total_contents(P, Q) + gamma = gamma_of(cs) + a = [0] * v + b = [0] * v + for j in range(3): + if cs[j] is None: + continue + m = min(v2(P[t][j]) for t in range(v) if P[t][j] != 0) + for t in range(v): + if P[t][j] != 0 and v2(P[t][j]) == m: + a[t] |= 1 << j + qmin = gamma - m + for s in range(v): + if Q[s][j] != 0 and v2(Q[s][j]) == qmin: + b[s] |= 1 << j + M = [[sum(P[t][j] * Q[s][j] for j in range(3)) for s in range(v)] for t in range(v)] + diagv2 = [v2(M[t][t]) for t in range(v)] + return a, b, gamma, cs, diagv2 + + +def scope_identity_ok(sig, a, b, gamma): + """Machine identity of the anchor: K_ts == 1 iff v2(M_ts) == gamma.""" + M, pi, sg, Z = sig + v = len(M) + for t in range(v): + for s in range(v): + k = 1 if (((a[t] & b[s]).bit_count() & 1)) else 0 + want = 1 if (M[t][s] != 0 and v2(M[t][s]) == gamma) else 0 + if k != want: + return False + return True + + +def entry_class(P, Q): + entries = [x for row in P + Q for x in row] + if all(x.denominator == 1 for x in entries): + return "integer" + if all(x.denominator & (x.denominator - 1) == 0 for x in entries): + return "dyadic" + if all(v2(x) >= 0 for x in entries): + return "2-integral-oddden" + return "general-Q" + + +# ------------------------------------ mixed anchor+pivot (Lemma MX, U=0) ---- +def mx_anchor_pivot(sig, a0, b0, anchor_set, ac, mas, mp_best, map_cap=200000): + """Lemma MX (PR 2747) with U = empty and A = anchor_set (labels a0, b0): + max over pivot maps c on T = [v] \\ A of |A| + sum_i MAS(Z[C_i]) under the + A-first hypothesis (ii) or the T-first hypothesis (ii'), together with the + pure matched-pivot value mp_best (the A = empty special case). + Returns (value, form, nmaps_evaluated).""" + M, pi, sg, Z = sig + v = len(M) + A = anchor_set + Tmask = ((1 << v) - 1) ^ A + Dopts = [pi[t] & sg[t] for t in range(v)] + lists = [[b for b in (1, 2, 4) if Dopts[t] & b] for t in range(v) if (Tmask >> t) & 1] + tids = [t for t in range(v) if (Tmask >> t) & 1] + nmaps = 1 + for cl in lists: + nmaps *= len(cl) + if nmaps > map_cap: + return mp_best, "all-T (MP only; mixed maps over cap)", 0 + best, form = mp_best, "all-T (MP)" + evaluated = 0 + for pick in itertools.product(*lists): + evaluated += 1 + cmap = dict(zip(tids, pick)) + classes = [0, 0, 0] + for t, m in zip(tids, pick): + classes[(m.bit_length() - 1)] |= 1 << t + base = A.bit_count() + mas[classes[0]] + mas[classes[1]] + mas[classes[2]] + if base <= best: + continue + ok_a_first = True + for t in range(v): + if not (A >> t) & 1: + continue + for s in tids: + if M[t][s] == 0 and (a0[t] & cmap[s]): + ok_a_first = False + break + if not ok_a_first: + break + if ok_a_first: + best, form = base, "A-first (A=S_gamma)" + continue + ok_t_first = True + for t in tids: + for s in range(v): + if (A >> s) & 1 and M[t][s] == 0 and (cmap[t] & b0[s]): + ok_t_first = False + break + if not ok_t_first: + break + if ok_t_first: + best, form = base, "T-first (A=S_gamma)" + return best, form, evaluated + + +def mx_witness(sig, a0, b0, anchor_set, pick, tids, ac, mas): + """Build the MX witness: A lines with anchor labels, T lines with matched + pivots; order A first (any order), then each class sink-first.""" + M, pi, sg, Z = sig + v = len(M) + a = [0] * v + b = [0] * v + order = [] + for t in range(v): + if (anchor_set >> t) & 1: + a[t] = a0[t] + b[t] = b0[t] + order.append(t) + classes = [0, 0, 0] + for t, m in zip(tids, pick): + a[t] = m + b[t] = m + classes[m.bit_length() - 1] |= 1 << t + for cmask in classes: + sub = mas_subset(ac, mas, cmask) + order.extend(sink_first_order(Z, sub)) + return {"a": a, "b": b, "order": order} + + +# ---------------------------------------------------------- generators ---- +def _accept(P, Q): + return all(sum(P[t][j] * Q[t][j] for j in range(3)) != 0 for t in range(len(P))) + + +def gen_evenden(rng, v): + """Entries with even denominators (negative 2-valuation): totals whose + content c_j < 0, where Lemma AN's literal normalization hypothesis fails + and only the scale-invariant anchor applies.""" + box = [Fraction(1, 2), Fraction(-1, 2), Fraction(1, 4), Fraction(-1, 4), + Fraction(3, 2), Fraction(-3, 2), Fraction(1), Fraction(-1), + Fraction(2), Fraction(-2), Fraction(1, 8)] + while True: + P = [[rng.choice(box) for _ in range(3)] for _ in range(v)] + Q = [[rng.choice(box) for _ in range(3)] for _ in range(v)] + if _accept(P, Q): + return (P, Q), signature(P, Q) + + +def gen_oddden(rng, v): + """Entries in Z_(2) \\ Z (odd denominators): 2-integral, non-integer, + non-dyadic. Lemma AN applies to these verbatim (residue (iii) audit).""" + box = [Fraction(1, 3), Fraction(-1, 3), Fraction(2, 3), Fraction(-2, 3), + Fraction(1, 5), Fraction(-1, 5), Fraction(3, 5), Fraction(2), + Fraction(-2), Fraction(1), Fraction(-1), Fraction(4, 3)] + while True: + P = [[rng.choice(box) for _ in range(3)] for _ in range(v)] + Q = [[rng.choice(box) for _ in range(3)] for _ in range(v)] + if _accept(P, Q): + return (P, Q), signature(P, Q) + + +def gen_mixed(rng, v): + """General Q: halves and thirds mixed.""" + box = [Fraction(1, 2), Fraction(-1, 2), Fraction(1, 3), Fraction(-1, 3), + Fraction(3, 2), Fraction(2, 3), Fraction(1), Fraction(-1), + Fraction(6, 5), Fraction(-6, 5), Fraction(1, 6)] + while True: + P = [[rng.choice(box) for _ in range(3)] for _ in range(v)] + Q = [[rng.choice(box) for _ in range(3)] for _ in range(v)] + if _accept(P, Q): + return (P, Q), signature(P, Q) + + +# ------------------------------------------------------------- controls ---- +def brute_cert(sig): + """Definition-level brute force over all labellings; MAS of D_K on V(K).""" + M, pi, sg, Z = sig + v = len(M) + best = 0 + for a in itertools.product(range(8), repeat=v): + for t in range(v): + if a[t] & ~pi[t]: + break + else: + for b in itertools.product(range(8), repeat=v): + for t in range(v): + if b[t] & ~sg[t]: + break + else: + Vk = [t for t in range(v) if ((a[t] & b[t]).bit_count() & 1)] + if len(Vk) <= best: + continue + n = len(Vk) + D = [[0] * n for _ in range(n)] + for i, t in enumerate(Vk): + for j, s in enumerate(Vk): + if t != s and M[t][s] == 0 and ((a[t] & b[s]).bit_count() & 1): + D[i][j] = 1 + pred = [0] * n + for i in range(n): + for j in range(n): + if D[j][i]: + pred[i] |= 1 << j + _, mas = ac_mas_tables(pred, n) + if mas[(1 << n) - 1] > best: + best = mas[(1 << n) - 1] + return best + + +def load_cfg(name): + with open(os.path.join(DATA, name), "r", encoding="utf-8") as fh: + cfg = json.load(fh) + P = [[Fraction(x) for x in c[0]] for c in cfg] + Q = [[Fraction(x) for x in c[1]] for c in cfg] + return (P, Q), signature(P, Q) + + +def frac_json(x): + return x.numerator if x.denominator == 1 else f"{x.numerator}/{x.denominator}" + + +def main(): + fails = [] + results = {} + + # ---- controls ---- + log("controls") + brute_agree = 0 + for seed in (11, 22, 33): + # three tiny random instances (v = 3) from the integer model + rng = random.Random(seed) + while True: + P = [[Fraction(rng.choice([-1, 0, 1])) for _ in range(3)] for _ in range(3)] + Q = [[Fraction(rng.choice([-1, 0, 1])) for _ in range(3)] for _ in range(3)] + if _accept(P, Q): + break + sig = signature(P, Q) + tabs = bfeas_tables(sig[1], sig[2]) + ec, exh = exact_cert(sig, tabs, cap=100000) + bb = brute_cert(sig) + if ec == bb: + brute_agree += 1 + else: + fails.append(f"brute/engine disagree (seed {seed}): {bb} vs {ec}") + + P3 = [[Fraction(x) for x in row] for row in [[1, 0, 0], [0, 1, 0], [0, 0, 1]]] + sig_diag = signature(P3, P3) + tabs_diag = bfeas_tables(sig_diag[1], sig_diag[2]) + diag_cert, _ = exact_cert(sig_diag, tabs_diag, cap=100000) + if diag_cert != 3: + fails.append(f"diagonal control: cert {diag_cert} != 3") + + rng = random.Random(999) + while True: + Pc = [[Fraction(rng.choice([-1, 0, 1])) for _ in range(3)] for _ in range(4)] + Qc = [[Fraction(rng.choice([-1, 0, 1])) for _ in range(3)] for _ in range(4)] + if _accept(Pc, Qc): + break + sig_c = signature(Pc, Qc) + tabs_c = bfeas_tables(sig_c[1], sig_c[2]) + _, wit_c = hill_climb(sig_c, tabs_c, iters=60, seed=4) + if not check_witness(sig_c, wit_c): + fails.append("checker rejected a true witness") + corrupt_rejects = 0 + w1 = json.loads(json.dumps(wit_c)) + w1["a"][w1["order"][0]] = 0 + if not check_witness(sig_c, w1): + corrupt_rejects += 1 + w2 = json.loads(json.dumps(wit_c)) + w2["b"][w2["order"][0]] = 0 + if not check_witness(sig_c, w2): + corrupt_rejects += 1 + if corrupt_rejects != 2: + fails.append(f"corrupted witnesses accepted: {2 - corrupt_rejects}/2") + + mas_checks = 0 + pred_tri = [0b110, 0b101, 0b011] + _, mas_tri = ac_mas_tables(pred_tri, 3) + if mas_tri[7] == 1: + mas_checks += 1 + else: + fails.append(f"MAS bidirected triangle {mas_tri[7]} != 1") + pred_c3 = [1 << 2, 1 << 0, 1 << 1] + _, mas_c3 = ac_mas_tables(pred_c3, 3) + if mas_c3[7] == 2: + mas_checks += 1 + else: + fails.append(f"MAS directed 3-cycle {mas_c3[7]} != 2") + _, mas_e4 = ac_mas_tables([0, 0, 0, 0], 4) + if mas_e4[15] == 4: + mas_checks += 1 + else: + fails.append(f"MAS empty-4 {mas_e4[15]} != 4") + if mas_checks != 3: + fails.append(f"MAS controls {mas_checks}/3") + + chi_checks = 0 + if chi_exact_dp(pred_tri, 3) == 3: + chi_checks += 1 + else: + fails.append("chi bidirected triangle != 3") + pred_k4 = [sum(1 << s for s in range(4) if s != t) for t in range(4)] + if chi_exact_dp(pred_k4, 4) == 4: + chi_checks += 1 + else: + fails.append("chi bidirected K4 != 4") + pred_chain = [0, 1 << 0, 1 << 1] + if chi_exact_dp(pred_chain, 3) == 1: + chi_checks += 1 + else: + fails.append("chi acyclic chain != 1") + if chi_exact_dp(pred_c3, 3) == 2: + chi_checks += 1 + else: + fails.append("chi directed 3-cycle != 2") + if chi_checks != 4: + fails.append(f"chi controls {chi_checks}/4") + + pred_diag = pred_masks_from_Z(sig_diag[3], 3) + _, mas_diag = ac_mas_tables(pred_diag, 3) + mp_v, mp_worst, mp_nmaps, mp_pick = mp_exact(sig_diag, mas_diag) + if mp_v != 3: + fails.append(f"MP diagonal control {mp_v} != 3") + + # ---- scope controls (new) ---- + log("scope controls") + scope_ctl = {} + + # SC1: dyadic entries, c_j < 0 (Lemma AN literal hypothesis fails), M = (1/4)J_2 + Pf = [[Fraction(1, 2), Fraction(0), Fraction(0)], [Fraction(1, 2), Fraction(0), Fraction(0)]] + Qf = [[Fraction(1, 2), Fraction(0), Fraction(0)], [Fraction(1, 2), Fraction(0), Fraction(0)]] + sig_f = signature(Pf, Qf) + a_f, b_f, g_f, cs_f, dv_f = anchor_labels(Pf, Qf) + reach_f = sum(1 for t in range(2) if dv_f[t] == g_f) + ok_f = scope_identity_ok(sig_f, a_f, b_f, g_f) + entry_f = entry_class(Pf, Qf) + an_hyp_f = gamma_of(cs_f) >= 0 + sc1 = (entry_f == "dyadic" and not an_hyp_f and g_f == -2 and reach_f == 2 and ok_f) + scope_ctl["SC1_dyadic_negative_content"] = sc1 + if not sc1: + fails.append(f"SC1 failed: entry={entry_f} ANhyp={an_hyp_f} gamma={g_f} reach={reach_f} id={ok_f}") + + # SC2: scaled integer decoder M = 2*I_3 (p_j = 2 e_j, q_j = e_j): gamma = 1, + # all diagonals at level gamma although every M_tt is even (naive odd count 0) + P2 = [[Fraction(2), Fraction(0), Fraction(0)], [Fraction(0), Fraction(2), Fraction(0)], + [Fraction(0), Fraction(0), Fraction(2)]] + Q2 = [[Fraction(1), Fraction(0), Fraction(0)], [Fraction(0), Fraction(1), Fraction(0)], + [Fraction(0), Fraction(0), Fraction(1)]] + sig_2 = signature(P2, Q2) + a_2, b_2, g_2, cs_2, dv_2 = anchor_labels(P2, Q2) + reach_2 = sum(1 for t in range(3) if dv_2[t] == g_2) + ok_2 = scope_identity_ok(sig_2, a_2, b_2, g_2) + naive_odd_2 = sum(1 for t in range(3) if dv_2[t] == 0) + sc2 = (g_2 == 1 and reach_2 == 3 and naive_odd_2 == 0 and ok_2) + scope_ctl["SC2_positive_content_scaled"] = sc2 + if not sc2: + fails.append(f"SC2 failed: gamma={g_2} reach={reach_2} odd={naive_odd_2} id={ok_2}") + + # SC3: odd-denominator (non-dyadic) entries: Lemma AN applies verbatim + Po = [[Fraction(1, 3), Fraction(2, 3), Fraction(0)], [Fraction(0), Fraction(1, 5), Fraction(3, 5)], + [Fraction(2, 3), Fraction(0), Fraction(1, 5)]] + Qo = [[Fraction(1, 5), Fraction(2, 3), Fraction(0)], [Fraction(0), Fraction(3, 5), Fraction(1, 3)], + [Fraction(1, 3), Fraction(0), Fraction(2, 5)]] + sig_o = signature(Po, Qo) + a_o, b_o, g_o, cs_o, dv_o = anchor_labels(Po, Qo) + reach_o = sum(1 for t in range(3) if dv_o[t] == g_o) + ok_o = scope_identity_ok(sig_o, a_o, b_o, g_o) + entry_o = entry_class(Po, Qo) + an_hyp_o = all(c is not None and c >= 0 for c in cs_o) + sc3 = (entry_o == "2-integral-oddden" and an_hyp_o and ok_o and reach_o >= 1) + scope_ctl["SC3_oddden_anchor_verbatim"] = sc3 + if not sc3: + fails.append(f"SC3 failed: entry={entry_o} ANhyp={an_hyp_o} id={ok_o} reach={reach_o}") + + # SC4: reach witness replay on all three scope controls plus identity + def reach_witness(sig, a, b, diagv2, gamma): + kept = [t for t in range(len(diagv2)) if diagv2[t] == gamma] + if not kept: + return None + wit = {"a": a, "b": b, "order": kept, "kept": kept} + return wit + + sc4 = 0 + for (sigx, ax, bx, gx, dvx) in ((sig_f, a_f, b_f, g_f, dv_f), + (sig_2, a_2, b_2, g_2, dv_2), + (sig_o, a_o, b_o, g_o, dv_o)): + wtx = reach_witness(sigx, ax, bx, dvx, gx) + if wtx is not None and check_witness(sigx, wtx): + sc4 += 1 + elif wtx is not None: + fails.append("reach witness failed replay in scope controls") + scope_ctl["SC4_reach_witness_replay"] = f"{sc4}/2_nonempty" # SC1, SC2 nonempty; SC3 may be + if sc4 < 2: + fails.append(f"SC4 reach witness replay only {sc4}/2") + + log(f"controls: brute_agree={brute_agree}/3 diagonal_cert={diag_cert} " + f"corrupt_rejects={corrupt_rejects}/2 mas={mas_checks}/3 chi={chi_checks}/4 " + f"mp_diagonal={mp_v}") + results["controls"] = {"brute_agree": brute_agree, "diag_cert": diag_cert, + "corrupt_rejects": corrupt_rejects, "mas_checks": mas_checks, + "chi_checks": chi_checks, "mp_control": mp_v, + "scope_controls": scope_ctl} + if not fails: + print("PASS_FSC_CONTROLS") + + # ---- fixtures: calibration anchors + entry-class settlement ---- + log("fixtures") + fixtures = {} + for name, recorded, anchor_mp, anchor_good_rec in (("tied_min.json", 11, 9, 0), + ("cex_min_1.json", 18, 16, 8)): + (P, Q), sig = load_cfg(name) + M, pi, sg, Z = sig + v = len(M) + thr = threshold(v) + pred = pred_masks_from_Z(Z, v) + t_ac = time.time() + ac, mas = ac_mas_tables(pred, v) + log(f"{name}: subset DP done ({time.time() - t_ac:.1f}s)") + mp_v, mp_worst, mp_nmaps, mp_pick = mp_exact(sig, mas) + if mp_v != anchor_mp: + fails.append(f"{name}: MP {mp_v} != PR 2747 anchor {anchor_mp}") + # scope settlement (new) + a0, b0, gamma, cs, diagv2 = anchor_labels(P, Q) + ident = scope_identity_ok(sig, a0, b0, gamma) + if not ident: + fails.append(f"{name}: scope identity failed") + reach = [t for t in range(v) if diagv2[t] == gamma] + naive_odd = sum(1 for t in range(v) if diagv2[t] == 0) + entry = entry_class(P, Q) + an_hyp = all(c is not None and c >= 0 for c in cs) + if len(reach) != anchor_good_rec: + fails.append(f"{name}: anchor reach {len(reach)} != PR 2747 anchor_good {anchor_good_rec}") + if naive_odd != anchor_good_rec: + fails.append(f"{name}: naive odd count {naive_odd} != PR 2747 anchor_good {anchor_good_rec}") + # mixed anchor+pivot MX value with A = S_gamma + anchor_mask = sum(1 << t for t in reach) + mx_v, mx_form, mx_maps = mx_anchor_pivot(sig, a0, b0, anchor_mask, ac, mas, mp_v) + # replay the winning MX witness (pure MP witness when that wins) + if mx_v >= mp_v and mx_form.startswith("all-T"): + classes = [0, 0, 0] + for t, m in enumerate(mp_pick): + classes[m.bit_length() - 1] |= 1 << t + order = [] + wit_mp = {"a": [0] * v, "b": [0] * v, "order": []} + for t, m in enumerate(mp_pick): + wit_mp["a"][t] = m + wit_mp["b"][t] = m + for cmask in classes: + sub = mas_subset(ac, mas, cmask) + order.extend(sink_first_order(Z, sub)) + wit_mp["order"] = order + if not check_witness(sig, wit_mp): + fails.append(f"{name}: matched-pivot witness failed replay") + if mx_v != anchor_mp: + fails.append(f"{name}: MX {mx_v} != PR 2747 anchor {anchor_mp}") + # engine witness + tabs = bfeas_tables(pi, sg) + if name == "tied_min.json": + wit_val, wit = hill_climb(sig, tabs, iters=400, seed=9) + if wit_val < recorded: + fails.append(f"{name}: engine witness {wit_val} < recorded {recorded}") + if not check_witness(sig, wit): + fails.append(f"{name}: hill-climb witness failed replay") + if wit_val > recorded: + log(f"{name}: NOTE engine witness {wit_val} exceeds recorded CP-SAT limit {recorded}") + else: + with open(os.path.join(DATA, "cex_min_1.witness.json"), "r", encoding="utf-8") as fh: + stored = json.load(fh) + if not check_witness(sig, stored): + fails.append("cex_min_1 stored witness failed replay") + wit_val = len(stored["order"]) + chain_anchor = None + if name == "cex_min_1.json": + with open(os.path.join(DATA, "cex_min_1.B22.json"), "r", encoding="utf-8") as fh: + B22 = json.load(fh) + rows = [0] * v + for t in range(v): + for s in range(v): + if B22[t][s]: + rows[t] |= 1 << s + adm = all(B22[t][t] == 1 for t in range(v)) and all( + B22[t][s] == 0 or Z[t][s] + for t in range(v) for s in range(v) if t != s) + chain_anchor = chain_cost(rows, pi, sg, v) + if chain_anchor != 22 or not adm: + fails.append(f"{name}: chain engine {chain_anchor} (admissible={adm}) != 22") + if v <= 13: + chi_val = chi_exact_dp(pred, v) + chi_exh = True + else: + r, exh_budget = chi_le3_backtrack(pred, v, budget=300000) + chi_val = ("le3" if r else ("gt3" if r is False else "unknown")) + chi_exh = not exh_budget + om = omega_mutual(sig) + fixtures[name] = { + "v": v, "threshold": thr, + "entry_class": entry, "per_total_contents_c": cs, "gamma": gamma, + "diag_v2": diagv2, "anchor_reach": len(reach), + "anchor_reach_lines": reach, + "naive_odd_count": naive_odd, "pr2747_anchor_good": anchor_good_rec, + "untouchable_by_anchor": v - len(reach), + "scope_identity": ident, "AN_hypothesis_holds": an_hyp, + "mp_bound": mp_v, "mp_worst": mp_worst, "mp_maps": mp_nmaps, + "mp_anchor": anchor_mp, "mx_value": mx_v, "mx_form": mx_form, + "mx_maps_evaluated": mx_maps, + "engine_witness": wit_val, "recorded_cert": recorded, + "chain_anchor": chain_anchor, + "mas_of_Z": mas[(1 << v) - 1], "omega_mutual": om, + "chi_unconstrained": chi_val, "chi_exhaustive": chi_exh, + "mp_deficit_vs_v": v - mp_v, + "dichromatic_with_D": (mp_v == v), + "arcs_Z": arc_count(sig), "mutual_pairs": mutual_pair_count(sig), + } + log(f"{name}: v={v} thr={thr} entry={entry} gamma={gamma} reach={len(reach)}/{v} " + f"MP={mp_v} MX={mx_v} ({mx_form}) witness={wit_val} chi={chi_val}") + results["fixtures"] = fixtures + if not fails: + print("PASS_FSC_FIXTURES") + + # ---- search: smallest-first in the entry-class domain ---- + log("search (smallest first)") + search_records = [] + falsifiers = [] + certified = 0 + min_ratio = None + fams = (("evenden", gen_evenden), ("oddden", gen_oddden), ("mixed", gen_mixed)) + search_v = list(range(3, 11)) + for v in search_v: + thr = threshold(v) + for fam, gen in fams: + n_inst = 4 if v <= 6 else 3 + for k in range(n_inst): + seed = 1000 * v + 131 * k + sum(ord(ch) for ch in fam) + rng = random.Random(seed) + (P, Q), sig = gen(rng, v) + M, pi, sg, Z = sig + a0, b0, gamma, cs, diagv2 = anchor_labels(P, Q) + ident = scope_identity_ok(sig, a0, b0, gamma) + reach = [t for t in range(v) if diagv2[t] == gamma] + entry = entry_class(P, Q) + an_hyp = all(c is not None and c >= 0 for c in cs) + pred = pred_masks_from_Z(Z, v) + ac, mas = ac_mas_tables(pred, v) + mp_v, mp_worst, mp_nmaps, mp_pick = mp_exact(sig, mas, mp_cap=300000) + anchor_mask = sum(1 << t for t in reach) + mx_v, mx_form, mx_maps = mx_anchor_pivot(sig, a0, b0, anchor_mask, ac, mas, + mp_v if mp_v is not None else 0, + map_cap=300000) + tabs = bfeas_tables(pi, sg) + if v <= 5: + exact, exh = exact_cert(sig, tabs, cap=200000) + else: + exact, exh = None, False + wit_val, wit = hill_climb(sig, tabs, iters=120, seed=seed % 97) + best_known = max(x for x in [wit_val, mx_v or 0, exact or 0] if x is not None) + verdict = "certified>=thr" if best_known >= thr else "below-thr-pending" + chain_min = None + if best_known < thr: + chain_min, _ = min_chain_cost(sig) + if chain_min < thr: + verdict = "FALSIFIER" + falsifiers.append({"v": v, "seed": seed, "family": fam, + "chain_min": chain_min, "thr": thr}) + else: + certified += 1 + ratio = best_known / v + if min_ratio is None or ratio < min_ratio: + min_ratio = ratio + rec = {"family": fam, "v": v, "seed": seed, "thr": thr, + "entry_class": entry, "per_total_contents_c": cs, + "gamma": gamma, "anchor_reach": len(reach), + "naive_odd_count": sum(1 for t in range(v) if diagv2[t] == 0), + "untouchable_by_anchor": v - len(reach), + "scope_identity": ident, "AN_hypothesis_holds": an_hyp, + "mp_bound": mp_v, "mp_maps": mp_nmaps, + "mx_value": mx_v, "mx_form": mx_form, + "exact_cert": exact, "exact_exhausted": exh, + "engine_witness": wit_val, "best_known": best_known, + "chain_min": chain_min, "verdict": verdict} + search_records.append(rec) + if not ident: + fails.append(f"search v={v} {fam} seed={seed}: scope identity failed") + if falsifiers: + break + if falsifiers: + break + if falsifiers: + break + results["search"] = {"instances": len(search_records), + "v_range": [search_v[0], search_v[-1]], + "families": [f for f, _ in fams], + "falsifiers": falsifiers, + "certified_at_or_above_threshold": certified, + "min_best_known_ratio": min_ratio, + "entry_class_counts": { + ec: sum(1 for r in search_records if r["entry_class"] == ec) + for ec in sorted({r["entry_class"] for r in search_records})}, + "AN_hypothesis_failures": sum( + 1 for r in search_records if not r["AN_hypothesis_holds"]), + "instances_with_negative_gamma": sum( + 1 for r in search_records if r["gamma"] < 0), + "instances_with_anchor_reach_below_threshold": sum( + 1 for r in search_records if r["anchor_reach"] < r["thr"]), + "instances_with_untouchable_lines": sum( + 1 for r in search_records if r["untouchable_by_anchor"] > 0), + "records": search_records} + log(f"search: {len(search_records)} instances, falsifiers={len(falsifiers)}, " + f"certified={certified}, min ratio={min_ratio}") + if not fails: + print("PASS_FSC_SEARCH") + + if not fails: + print("PASS_FSTAR_ENTRY_CLASS_SCOPE") + + cert_obj = {"package": "research/fstar-entry-class-scope-seed63d5f999", + "generated_by": "verify.py", "results": results, + "fails": fails} + blob = json.dumps(cert_obj, sort_keys=True, indent=1).encode("utf-8") + digest = hashlib.sha256(blob).hexdigest() + cert_obj["digest"] = digest + with open(os.path.join(HERE, "CERTIFICATE.json"), "w", encoding="utf-8") as fh: + json.dump(cert_obj, fh, sort_keys=True, indent=1) + print(f"CERTIFICATE digest {digest[:16]}") + if fails: + print("FAIL_FSTAR_ENTRY_CLASS_SCOPE") + for f in fails: + print(" FAIL:", f) + sys.exit(1) + print("ALL_CHECKS_PASS") + + +if __name__ == "__main__": + main()