From 71ba81c628ec1d80383f131b0735b18f34d254cf Mon Sep 17 00:00:00 2001 From: Gareth Davidson Date: Tue, 13 Oct 2026 07:12:23 +0100 Subject: [PATCH 1/2] Independent verification: certify all 47 outer inequalities with Bernstein coefficients --- .../outer-bernstein-certificate/CLAIM.json | 39 + .../outer-bernstein-certificate/EXPECTED.json | 3652 +++++++++++++++++ .../outer-bernstein-certificate/README.md | 223 + .../outer-bernstein-certificate/SOURCES.json | 37 + .../outer-bernstein-certificate/VALIDATION.md | 82 + .../outer-bernstein-certificate/algebra.py | 218 + .../crosscheck_sympy.py | 123 + .../source_model.py | 157 + .../test_verify.py | 180 + .../outer-bernstein-certificate/verify.py | 257 ++ 10 files changed, 4968 insertions(+) create mode 100644 research/outer-bernstein-certificate/CLAIM.json create mode 100644 research/outer-bernstein-certificate/EXPECTED.json create mode 100644 research/outer-bernstein-certificate/README.md create mode 100644 research/outer-bernstein-certificate/SOURCES.json create mode 100644 research/outer-bernstein-certificate/VALIDATION.md create mode 100644 research/outer-bernstein-certificate/algebra.py create mode 100644 research/outer-bernstein-certificate/crosscheck_sympy.py create mode 100644 research/outer-bernstein-certificate/source_model.py create mode 100644 research/outer-bernstein-certificate/test_verify.py create mode 100644 research/outer-bernstein-certificate/verify.py diff --git a/research/outer-bernstein-certificate/CLAIM.json b/research/outer-bernstein-certificate/CLAIM.json new file mode 100644 index 0000000000..154cca9727 --- /dev/null +++ b/research/outer-bernstein-certificate/CLAIM.json @@ -0,0 +1,39 @@ +{ + "assignment_seed": 79, + "drawn_at_utc": "2026-10-13T05:38:49.180785+00:00", + "track": "Independent verification or formalization", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "candidates": [ + "Independent quadratic-phase verification of selected cold wrappers; overlap PR702/712", + "Algebraic positivity certificates for all 47 selected outer-assembly inequalities, plus both exact selected witnesses", + "Reverse scalar/dirty-centre restoration verification; overlap PR745" + ], + "selection": "79 mod 3 = 1; choose the second candidate", + "scope": "Independently certify the retained 47-row outer arithmetic on its admitted parameter domain using exact multivariate Bernstein coefficients; bind the equations to the selected source and match native/conservative PR626 receipts. No supplier or all-size theorem claim.", + "method": "Sparse rational polynomials, denominator clearing, exact Bernstein conversion, independently interpreted source expressions and exact rational witness comparisons", + "expected_deliverable": "Written positivity argument, source-bound algebraic certificate, standard-library replay and mathematical controls; at most one focused PR", + "expected_finish_utc": "2026-10-13T06:25:00Z", + "coordination": "No pinned sprint issue exists; issue 650 requests Discussions. Local claim.", + "overlap_snapshot": { + "open_prs": 611, + "through_pr": 791, + "related_prs": [ + 183, + 294, + 701, + 706, + 678, + 771, + 766 + ] + }, + "status": "completed; prepared for one focused PR", + "attribution": "Prepared for Gareth Davidson (@bitplane) with substantial OpenAI Codex assistance; Apache-2.0", + "completed_at_utc": "2026-10-13T06:08:19Z", + "result": "README.md", + "reproduce": "python3 -B -I research/outer-bernstein-certificate/verify.py", + "result_summary": "All 47 admitted outer inequalities receive exact positive Bernstein certificates; 57 polynomial records, 2586 coefficients and all 94 selected native/conservative slacks verified. No new kappa.", + "overlap_refresh_through": 810, + "validation": "24 built-in controls, 12 tests, independent SymPy coefficient replay, Python 3.12/3.14, optimized/isolated/relocated/no-site replay and selected-record integrity pass.", + "scope_note": "The closed-form ceiling and written reduction are credited to PR183; the contribution is independent complete coefficient evidence and exact selected-instance binding." +} diff --git a/research/outer-bernstein-certificate/EXPECTED.json b/research/outer-bernstein-certificate/EXPECTED.json new file mode 100644 index 0000000000..145ef3b777 --- /dev/null +++ b/research/outer-bernstein-certificate/EXPECTED.json @@ -0,0 +1,3652 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "certificates": { + "branch:max(sigma - tau, Q(0))": { + "degrees": [ + 2, + 2, + 2, + 1, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 32, + 32, + 0, + 0, + 128, + 128, + 66, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 48, + 48, + 32, + 32, + 128, + 128, + 97, + 96, + 66, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 64, + 64, + 64, + 64, + 128, + 128, + 128, + 128, + 128, + 128 + ] + }, + "branch:min(1 - eps - delta, r - delta)": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 256, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 33, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + }, + "denominator": { + "degrees": [ + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 32, + "weights": [ + 32, + 32, + 32, + 32, + 32, + 32, + 33, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32 + ] + }, + "margin:Gaussian_arithmetic": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 96, + 192, + 0, + 96, + 192, + 0, + 96, + 192, + 0, + 99, + 192, + 0, + 96, + 192, + 0, + 96, + 192, + 0, + 96, + 192, + 0, + 96, + 192 + ] + }, + "margin:balanced_prefix": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 128, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 33, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + }, + "margin:bulk_exposure": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 2048, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12, + 16, + 0, + 24, + 32, + 0, + 0, + 0, + 0, + 24, + 32, + 2, + 49, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + 8, + 0, + 12, + 16, + 0, + 0, + 0, + 0, + 12, + 16, + 0, + 24, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "margin:compact_phase_layer": { + "degrees": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "scale": 1, + "weights": [ + 0 + ] + }, + "margin:coordinate_movement": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 2048, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12, + 16, + 0, + 24, + 32, + 0, + 0, + 0, + 0, + 24, + 32, + 2, + 49, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + 8, + 0, + 12, + 16, + 0, + 0, + 0, + 0, + 12, + 16, + 0, + 24, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "margin:dimension": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 128, + "weights": [ + 128, + 96, + 64, + 128, + 96, + 64, + 128, + 96, + 64, + 124, + 95, + 64, + 128, + 96, + 64, + 128, + 96, + 64, + 128, + 96, + 64, + 128, + 96, + 64 + ] + }, + "margin:scalar_work": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 224, + 448, + 0, + 224, + 448, + 0, + 224, + 448, + 0, + 231, + 448, + 0, + 224, + 448, + 0, + 224, + 448, + 0, + 224, + 448, + 0, + 224, + 448 + ] + }, + "slack:Gaussian_arithmetic_above_kappa": { + "degrees": [ + 1, + 1, + 1, + 2, + 1, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 0, + 96, + 96, + 192, + 192, + 0, + 0, + 96, + 96, + 192, + 192, + 0, + 0, + 96, + 96, + 192, + 192, + 32, + 0, + 107, + 99, + 192, + 192, + 0, + 0, + 96, + 96, + 192, + 192, + 0, + 0, + 96, + 96, + 192, + 192, + 0, + 0, + 96, + 96, + 192, + 192, + 0, + 0, + 96, + 96, + 192, + 192 + ] + }, + "slack:K_dominates_log": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 128, + "weights": [ + 0, + 8, + 8, + 0, + 8, + 8, + 0, + 8, + 8, + 4, + 9, + 8, + 0, + 8, + 8, + 0, + 8, + 8, + 0, + 8, + 8, + 0, + 8, + 8 + ] + }, + "slack:K_geometry": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 128, + "weights": [ + 0, + 24, + 56, + 0, + 24, + 56, + 0, + 24, + 56, + 0, + 25, + 56, + 0, + 24, + 56, + 0, + 24, + 56, + 0, + 24, + 56, + 0, + 24, + 56 + ] + }, + "slack:alpha_below_one": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 256, + "weights": [ + 256, + 224, + 192, + 256, + 224, + 192, + 256, + 224, + 192, + 256, + 225, + 192, + 256, + 224, + 192, + 256, + 224, + 192, + 256, + 224, + 192, + 256, + 224, + 192 + ] + }, + "slack:alpha_below_one_fourth": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 128, + "weights": [ + 32, + 16, + 0, + 32, + 16, + 0, + 32, + 16, + 0, + 29, + 15, + 0, + 32, + 16, + 0, + 32, + 16, + 0, + 32, + 16, + 0, + 32, + 16, + 0 + ] + }, + "slack:alpha_positive": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 256, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 8, + 35, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + }, + "slack:artificial_boundary": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 7168, + 7520, + 7872, + 7168, + 7520, + 7872, + 7168, + 7520, + 7872, + 7424, + 7651, + 7872, + 7168, + 7520, + 7872, + 7168, + 7520, + 7872, + 7168, + 7520, + 7872, + 7168, + 7520, + 7872 + ] + }, + "slack:balanced_prefix_above_kappa": { + "degrees": [ + 1, + 1, + 1, + 2, + 1, + 0, + 0 + ], + "scale": 128, + "weights": [ + 0, + 0, + 32, + 32, + 64, + 64, + 0, + 0, + 32, + 32, + 64, + 64, + 0, + 0, + 32, + 32, + 64, + 64, + 4, + 0, + 34, + 33, + 64, + 64, + 0, + 0, + 32, + 32, + 64, + 64, + 0, + 0, + 32, + 32, + 64, + 64, + 0, + 0, + 32, + 32, + 64, + 64, + 0, + 0, + 32, + 32, + 64, + 64 + ] + }, + "slack:beta_below_one": { + "degrees": [ + 2, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 32, + "weights": [ + 32, + 32, + 32, + 32, + 32, + 32, + 33, + 32, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:beta_positive": { + "degrees": [ + 2, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 64, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 32, + 32, + 32, + 32, + 32, + 32, + 33, + 32, + 64, + 64, + 64, + 64, + 64, + 64, + 64, + 64 + ] + }, + "slack:bit_positive": { + "degrees": [ + 2, + 2, + 2, + 1, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 8, + 16, + 16, + 0, + 0, + 16, + 16, + 33, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 8, + 8, + 0, + 0, + 8, + 8, + 16, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:bulk_exposure_above_kappa": { + "degrees": [ + 2, + 2, + 2, + 2, + 1, + 0, + 0 + ], + "scale": 2048, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 0, + 16, + 12, + 16, + 16, + 32, + 0, + 32, + 24, + 32, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 32, + 0, + 32, + 24, + 32, + 32, + 66, + 2, + 65, + 49, + 64, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 0, + 8, + 6, + 8, + 8, + 16, + 0, + 16, + 12, + 16, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 0, + 16, + 12, + 16, + 16, + 32, + 0, + 32, + 24, + 32, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:c_below_one": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3838, + 3584, + 4096, + 3836, + 3584, + 4096, + 3840, + 3584, + 4096, + 3836, + 3584, + 4092, + 3832, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3839, + 3584, + 4096, + 3838, + 3584, + 4096, + 3840, + 3584, + 4096, + 3838, + 3584, + 4096, + 3836, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584, + 4096, + 3840, + 3584 + ] + }, + "slack:c_positive": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 32, + 274, + 512, + 64, + 292, + 512, + 0, + 256, + 512, + 64, + 292, + 512, + 132, + 328, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 16, + 265, + 512, + 32, + 274, + 512, + 0, + 256, + 512, + 32, + 274, + 512, + 64, + 292, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512, + 0, + 256, + 512 + ] + }, + "slack:cell_above_band": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 512, + "weights": [ + 256, + 160, + 64, + 256, + 160, + 64, + 256, + 160, + 64, + 256, + 159, + 64, + 256, + 160, + 64, + 256, + 160, + 64, + 256, + 160, + 64, + 256, + 160, + 64 + ] + }, + "slack:compact_leaf": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 64, + 32, + 48, + 64, + 0, + 32, + 64, + 128, + 128, + 128, + 66, + 97, + 128, + 0, + 66, + 128, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 32, + 32, + 32, + 16, + 24, + 32, + 0, + 16, + 32, + 64, + 64, + 64, + 32, + 48, + 64, + 0, + 32, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:compact_phase_layer_above_kappa": { + "degrees": [ + 1, + 1, + 1, + 2, + 1, + 0, + 0 + ], + "scale": 128, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:compact_reservations": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 512, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 33, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + }, + "slack:complex_above_bit": { + "degrees": [ + 2, + 2, + 2, + 1, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 32, + 32, + 0, + 0, + 128, + 128, + 66, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 48, + 48, + 32, + 32, + 128, + 128, + 97, + 96, + 66, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 64, + 64, + 64, + 64, + 128, + 128, + 128, + 128, + 128, + 128 + ] + }, + "slack:complex_below_one_over32": { + "degrees": [ + 1, + 2, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 2048, + "weights": [ + 64, + 64, + 64, + 64, + 32, + 32, + 33, + 32, + 0, + 0, + 0, + 0, + 64, + 64, + 64, + 64, + 32, + 32, + 32, + 32, + 0, + 0, + 0, + 0 + ] + }, + "slack:coordinate_movement_above_kappa": { + "degrees": [ + 2, + 2, + 2, + 2, + 1, + 0, + 0 + ], + "scale": 2048, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 0, + 16, + 12, + 16, + 16, + 32, + 0, + 32, + 24, + 32, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 32, + 0, + 32, + 24, + 32, + 32, + 66, + 2, + 65, + 49, + 64, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 0, + 8, + 6, + 8, + 8, + 16, + 0, + 16, + 12, + 16, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 0, + 16, + 12, + 16, + 16, + 32, + 0, + 32, + 24, + 32, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:delta_below_one_eighth": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 128, + 96, + 64, + 128, + 96, + 64, + 128, + 96, + 64, + 132, + 97, + 64, + 128, + 96, + 64, + 128, + 96, + 64, + 128, + 96, + 64, + 128, + 96, + 64 + ] + }, + "slack:delta_positive": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 33, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + }, + "slack:dimension_above_kappa": { + "degrees": [ + 1, + 1, + 1, + 2, + 1, + 0, + 0 + ], + "scale": 128, + "weights": [ + 128, + 128, + 96, + 96, + 64, + 64, + 128, + 128, + 96, + 96, + 64, + 64, + 128, + 128, + 96, + 96, + 64, + 64, + 128, + 124, + 96, + 95, + 64, + 64, + 128, + 128, + 96, + 96, + 64, + 64, + 128, + 128, + 96, + 96, + 64, + 64, + 128, + 128, + 96, + 96, + 64, + 64, + 128, + 128, + 96, + 96, + 64, + 64 + ] + }, + "slack:epsilon_below_one": { + "degrees": [ + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 32, + "weights": [ + 0, + 16, + 0, + 16, + 0, + 16, + 1, + 16, + 0, + 16, + 0, + 16, + 0, + 16, + 0, + 16 + ] + }, + "slack:epsilon_positive": { + "degrees": [ + 0, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "scale": 2, + "weights": [ + 2, + 1 + ] + }, + "slack:gamma_sublinear": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 256, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 33, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + }, + "slack:guard_width": { + "degrees": [ + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 32, + "weights": [ + 0, + 16, + 0, + 16, + 0, + 16, + 1, + 16, + 0, + 16, + 0, + 16, + 0, + 16, + 0, + 16 + ] + }, + "slack:lambda_above_internal": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 16, + 32, + 0, + 33, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 8, + 0, + 8, + 16, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:lambda_above_sigma": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 8192, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 128, + 128, + 128, + 64, + 80, + 96, + 0, + 32, + 64, + 256, + 256, + 256, + 132, + 162, + 192, + 0, + 66, + 128, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 128, + 128, + 128, + 96, + 104, + 112, + 64, + 80, + 96, + 256, + 256, + 256, + 194, + 209, + 224, + 132, + 162, + 192, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 128, + 128, + 128, + 128, + 128, + 128, + 128, + 128, + 128, + 256, + 256, + 256, + 256, + 256, + 256, + 256, + 256, + 256 + ] + }, + "slack:lambda_above_tau": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 16, + 32, + 0, + 33, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 8, + 0, + 8, + 16, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:lambda_prime_above_lambda": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 16, + 32, + 0, + 33, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 8, + 0, + 8, + 16, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:lambda_prime_below_one": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 4, + 0, + 16, + 8, + 0, + 0, + 0, + 0, + 16, + 8, + 0, + 33, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 2, + 0, + 8, + 4, + 0, + 0, + 0, + 0, + 8, + 4, + 0, + 16, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:leaf_saving_above_bit": { + "degrees": [ + 2, + 2, + 2, + 1, + 0, + 0, + 0 + ], + "scale": 2048, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 32, + 32, + 16, + 16, + 0, + 0, + 64, + 64, + 33, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 16, + 8, + 8, + 0, + 0, + 32, + 32, + 16, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:literal_scalar_guard": { + "degrees": [ + 1, + 1, + 1, + 1, + 0, + 1, + 0 + ], + "scale": 32, + "weights": [ + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 33, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32 + ] + }, + "slack:phase_boundary": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 96, + 192, + 0, + 96, + 192, + 0, + 96, + 192, + 32, + 107, + 192, + 0, + 96, + 192, + 0, + 96, + 192, + 0, + 96, + 192, + 0, + 96, + 192 + ] + }, + "slack:phase_local": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 224, + 448, + 0, + 224, + 448, + 0, + 224, + 448, + 32, + 239, + 448, + 0, + 224, + 448, + 0, + 224, + 448, + 0, + 224, + 448, + 0, + 224, + 448 + ] + }, + "slack:prime_interval_packing": { + "degrees": [ + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 32, + "weights": [ + 0, + 16, + 0, + 16, + 0, + 16, + 1, + 16, + 0, + 16, + 0, + 16, + 0, + 16, + 0, + 16 + ] + }, + "slack:q_below_internal": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 2048, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 16, + 32, + 0, + 33, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 8, + 0, + 8, + 16, + 0, + 0, + 0, + 0, + 8, + 16, + 0, + 16, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:q_below_leaf": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 4096, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 64, + 64, + 64, + 32, + 48, + 64, + 0, + 32, + 64, + 128, + 128, + 128, + 66, + 97, + 128, + 0, + 66, + 128, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 32, + 32, + 32, + 16, + 24, + 32, + 0, + 16, + 32, + 64, + 64, + 64, + 32, + 48, + 64, + 0, + 32, + 64, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:q_below_reservations": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 512, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 33, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + }, + "slack:q_positive": { + "degrees": [ + 2, + 2, + 2, + 2, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 4, + 0, + 16, + 8, + 0, + 0, + 0, + 0, + 16, + 8, + 0, + 33, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 2, + 0, + 8, + 4, + 0, + 0, + 0, + 0, + 8, + 4, + 0, + 16, + 8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "slack:record_suffix": { + "degrees": [ + 1, + 1, + 1, + 1, + 0, + 0, + 0 + ], + "scale": 32, + "weights": [ + 0, + 16, + 0, + 16, + 0, + 16, + 1, + 16, + 0, + 16, + 0, + 16, + 0, + 16, + 0, + 16 + ] + }, + "slack:row_product_gap": { + "degrees": [ + 1, + 1, + 1, + 1, + 0, + 0, + 1 + ], + "scale": 32, + "weights": [ + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 33, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32, + 0, + 32 + ] + }, + "slack:scalar_work_above_kappa": { + "degrees": [ + 1, + 1, + 1, + 2, + 1, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 0, + 0, + 224, + 224, + 448, + 448, + 0, + 0, + 224, + 224, + 448, + 448, + 0, + 0, + 224, + 224, + 448, + 448, + 32, + 0, + 239, + 231, + 448, + 448, + 0, + 0, + 224, + 224, + 448, + 448, + 0, + 0, + 224, + 224, + 448, + 448, + 0, + 0, + 224, + 224, + 448, + 448, + 0, + 0, + 224, + 224, + 448, + 448 + ] + }, + "slack:short_record_fallback": { + "degrees": [ + 2, + 2, + 2, + 1, + 0, + 0, + 0 + ], + "scale": 1024, + "weights": [ + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1016, + 504, + 1008, + 496, + 1024, + 512, + 1008, + 496, + 991, + 480, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1020, + 508, + 1016, + 504, + 1024, + 512, + 1016, + 504, + 1008, + 496, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512, + 1024, + 512 + ] + }, + "slack:small_field_exposure": { + "degrees": [ + 1, + 1, + 1, + 2, + 0, + 0, + 0 + ], + "scale": 128, + "weights": [ + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 33, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64, + 0, + 32, + 64 + ] + } + }, + "controls": [ + "negative_weight", + "no_positive_weight", + "changed_positive_weight", + "missing_weight", + "negative_scale", + "floating_weight", + "missing_source_row", + "surplus_source_row", + "wrong_max_branch", + "wrong_min_branch", + "missing_target_charge", + "changed_gaussian_cap", + "altered_outer_receipt", + "altered_bootstrap_cutoff", + "target_at_ceiling", + "target_above_ceiling", + "zero_backoff", + "half_backoff", + "zero_beta", + "unit_beta", + "cap_equality", + "zero_literal_gap", + "zero_row_gap", + "nonexact_parameter" + ], + "counts": { + "coefficient_rows": 57, + "controls": 24, + "slacks": 47, + "weights": 2586, + "witnesses": 2 + }, + "format": "outer-bernstein-certificate-v1", + "identities": { + "1 - eps * (1 + c) == eta - eps * eta / 4": "0", + "1 - eps - r == eta / 2": "0", + "margins['balanced_prefix'] - minimum == eta": "0", + "min(margins.values()) == minimum": "0" + }, + "source_hashes": { + "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53", + "docs/research/community-k492-review.md": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47", + "research/community-k492-audit/SELECTED-SOURCE.json": "36e9e421230c4cb7b6a537d76a4bdfb6f667730d383e56062d4e45957484ab9e", + "research/community-k492-audit/pr626/replay/ASSEMBLY.json": "6127732e2fcdd470dab349c1c51d03cd9f0787ad0309b1b4a7c811a908028f4e", + "research/complex-k492-owner-repair/code/assemble.py": "1b1a9024ac910dc9b9d9e30150684e1fa9cb228a4c1c275b75ab04b57fdef1dd", + "research/complex-k492-owner-repair/vendor/multicold/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "variables": [ + "beta", + "32b", + "a/((1-beta)b)", + "2eta", + "kappa/G", + "L", + "R" + ], + "witnesses": { + "conservative": { + "bootstrap": [ + { + "cutoff_log2": "5241584540349", + "exponent": "65423439738924819069618914529678354274505375075036996832407268550124305943008511103532125431/40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "104828638263861812980979942053268536813742324963003167592731449875694056991488896467874569/40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "1953103211979608895", + "exponent": "13105619329242027328683071650313547094742729376907961874271766587022391306492087914090411728730183395797699360358193818509394315546125072997/8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "34346195708847836907244032777467521094103092038125728233412977608693507912085909588271269816604202300639641806181490605684453874927003/8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "727759349731166783788191", + "exponent": "2621130723834313584579859374698731146073376694237125677094923721640742833928310017535067057136276125495660723687912544625109705934618040222109588102460095874496127192576012521739683064239/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "11253233650724136404170533766379388001762874322905076278359257166071689982464932942863723874504339276312087455374890294065381959777890411897539904125503872807423987478260316935761/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "271175464702814842493035736858", + "exponent": "524226147013822422486919845970146162783701689008074659826528065467696114575054942445773189751993035323687776293676221153197184026274742360140959600244249772330572391901558184771404695534510576360942742056912089279372908209460564913293/320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "3687024573879309803706819706851250191925340173471934532303885424945057554226810248006964676312223706323778846802815973725257639859040399755750227669427608098441815228595304465489423639057257943087910720627091790539435086707/320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "101044572885187550035178519723971304", + "exponent": "104845229403500681390480878889031218524514737716609685779037402409874530062317191401945427311086992126673762581834431261350800206689460818420383696062473325529768090566417290420326103485340304738988425494258071207526029050070474608437052225675410477444646494682483780534021421437991/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "1208021678952265739377973595850123390314220962597590125469937682808598054572688913007873326237418165568738649199793310539181579616303937526674470231909433582709579673896514659695261011574505741928792473970949929525391562947774324589522555353505317516219465978578562009/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "37650919933849006658645955357847450631417", + "exponent": "20969045880700377486634122311723458605788564098868726573109116552022259846693600453375271281213701585520914261402172466129966949596501391297068738723724938269370649259231305855861890399402760432823286543377156921626320825957726400877945790219359671718655195324728375603521826187152178783129198736487913347766603135825831484745717/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "395797843919230660693833553469131273426890883447977740153306399546624728718786298414479085738597827533870033050403498608702931261276275061730629350740768694144138109600597239567176713456622843078373679174042273599122054209780640328281344804675271624396478173812847821216870801263512086652233396864174168515254283/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "14029370716187349431764514654976356656379995533", + "exponent": "4193809176140075576356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "129679736697259918659171829185022054460984823460247082711963192809202389702471770174675074069166275446198704174727625711123834550812483172629965561836008246053523874007199772255859574732755576273811917611665640795622112432465430334631843658556928497752937910370612644067696376870564503348009779757711481049497840582621307952234610228469753708559996600649121/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + ], + "bridge_gaps": [ + "1", + "23971789/25" + ], + "gain": "2096904588070037788178350464033017760519261307141418541599735765968706549686593659013899247203803160802990691945541168901843946732438088504148780252475345431054417629387623391523269382233619033333626809746803257100916416737475754861546154729387842756412516027616372531657367351784559400926433010636951460586404283167956627411635489079291286214233704629177987297924218570541284364047941532042666363453030246291440003399350879/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121000000000000000000000000", + "grid_successor_rejected": true, + "kappa": "1635527377506429/1000000000000000000", + "slacks": { + "Gaussian_arithmetic_above_kappa": "2048782734890612859834799420681034554479009785741434405657320062623210705354053253073553949944861252073696141729300292378732253488786691683804610092787375198274027708500794972922302636421353245080784387904144687626029958742735039523940735141307833553543279682236820696305708592754558479310891546737035923220605665833913164065795031348128576268922205269240633150316162165780294373811708184030362238885144950879/2051355047340912060461085364097500169328891279176790367166728906116829107269865716583328355624633354923001368435468490503597873316140336410097141646277276693026097165348666474703130257108739139119808506025851993950500586075285987059772424348153095834397319798068534349146486185082653363575831439303204204990301822684508033808063607084349550565976581991013769129227244726294857068751605933695994561038593600000000000000000000000", + "K_dominates_log": "2096904588070037788178670464033017760519261306821418541599735765968706549686593659013899247203803160802990691945541168901843946732438088504148780252475345431054417629387623391523269382233619033333626809746803257100916416737475754861546154729387842756412516027616372531657367351784559400926433010636951460586404283167956627411635489079291286214233704629177987297924218570541284364047941532042666363453030246291440003399350879/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121000000000000000000000000", + "K_geometry": "962096904588070037788178672560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121000000000000000000000000", + "alpha_below_one": "2559999999999999999999998722096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/2564193809176140075576356705121875211661114098970987958958411132646036384087332145729160444530791693653751710544335613129497341645175420512621427057846595866282621456685833093378912821385923923899760632532314992438125732594107483824715530435191369792996649747585667936433107731353316704469789299129005256237877278355635042260079508855436938207470727488767211411534055907868571335939507417119993201298242000000000000000000000000", + "alpha_below_one_fourth": "636854643117894943317731193255498179324202213950111591718797481072522197428480369908695989620098273425759081671970555548723820641973706783340494455285875687998290218199154103263748525271285399991726215057174448633367650434735653288959571236472769708994425047075966643360065699809886264481626242207111734479944276127923282807568487297061474161918084423179019159818561804462315881651075204187959033311986469753708559996600649121/2564193809176140075576356705121875211661114098970987958958411132646036384087332145729160444530791693653751710544335613129497341645175420512621427057846595866282621456685833093378912821385923923899760632532314992438125732594107483824715530435191369792996649747585667936433107731353316704469789299129005256237877278355635042260079508855436938207470727488767211411534055907868571335939507417119993201298242000000000000000000000000", + "alpha_positive": "4193809176140075576357983024970623591076310792635398020805302088986898593352666523594121512599649987678845964113347733650514769320148344814862309175773278572365145972304170080979680075195580983213943075904299476163782713791217667219311372325072739254737389820450340748211233028442911635821082575139579579525043460985477757451389916797760389949597449012783693064952172504826952333801650092039267012574030246291440003399350879/2564193809176140075576356705121875211661114098970987958958411132646036384087332145729160444530791693653751710544335613129497341645175420512621427057846595866282621456685833093378912821385923923899760632532314992438125732594107483824715530435191369792996649747585667936433107731353316704469789299129005256237877278355635042260079508855436938207470727488767211411534055907868571335939507417119993201298242000000000000000000000000", + "artificial_boundary": "71814201893636482418443428650190720537365764531606672369481973736344312747276567100949833194039910327918273331159406416331455413273179272907305360097103535484174655546087245758019009708281750593541980309403311836905909292652388280863385631114722724537118528996037026752914136898280755921535162221789765229587129612064270045830428640189899556091626669759814048324497100257885515900881354648923644244400747909261125679989801947363/10256775236704560302305426820487500846644456395883951835833644530584145536349328582916641778123166774615006842177342452517989366580701682050485708231386383465130485826743332373515651285543695695599042530129259969752502930376429935298862121740765479171986598990342671745732430925413266817879157196516021024951509113422540169040318035421747752829882909955068845646136223631474285343758029668479972805192968000000000000000000000000", + "balanced_prefix_above_kappa": "1280490010617198404940523255537116947135384760186552431969562213642985642732653310462266759078177198418464355378222227841586761398410946419696791502188065075982475531132202072399280828673602461276716461115288096114703861128500835361051654686920656968267610112851059055712298005817765097480777363519803429827021115482845213677072600867426877492119568127877735958701167458005155192560860096115044249301091/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121000000000000000000", + "beta_below_one": "999999999999999999999999/1000000000000000000000000", + "beta_positive": "1/1000000000000000000000000", + "bit_positive": "4193809176140075576356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "bulk_exposure_above_kappa": "6859089723617336356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "1277903095411929962211821327439062394169442950514506020520794433676981807956333927135419777734604153173124144727832193435251329177412289743689286471076702066858689271657083453310543589307038038050119683733842503780937133702946258087642234782404315103501675126207166031783446134323341647765105350435497371881061360822182478869960245572281530896264636255616394294232972046065714332030246291440003399350879/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "2096904588070037788178672560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cell_above_band": "2559999999999999999999996157903095411929962211821647439062394169442950514506020520794433676981807956333927135419777734604153173124144727832193435251329177412289743689286471076702066858689271657083453310543589307038038050119683733842503780937133702946258087642234782404315103501675126207166031783446134323341647765105350435497371881061360822182478869960245572281530896264636255616394294232972046065714332030246291440003399350879/5128387618352280151152713410243750423322228197941975917916822265292072768174664291458320889061583387307503421088671226258994683290350841025242854115693191732565242913371666186757825642771847847799521265064629984876251465188214967649431060870382739585993299495171335872866215462706633408939578598258010512475754556711270084520159017710873876414941454977534422823068111815737142671879014834239986402596484000000000000000000000000", + "compact_leaf": "64845342157806099405162271306020520794433676981807956333927135419777734604153173124144727832193435251329177412289743689286471076702066858689271657083453310543589307038038050119683733842503780937133702946258087642234782404315103501675126207166031783446134323341647765105350435497371881061360822182478869960245572281530896264636255616394294232972046065714332030246291440003399350879/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "1280488728520293816870485467358764386197778929629502946475582734437419319714461266796193894497954933022617528502366955673780196649740123831986535191474536152684542389821473729482734139217191768314754511234971829957207642065634538307309742329155439372582713614526185262878329789263899420822425128625153865324392996544206035859551470827672449773650464392513991575095461690977201258275192126361335689304490350879/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121000000000000000000000000", + "compact_reservations": "1/4000000000000000000000000", + "complex_above_bit": "129686490506436058734748315585022054460984823460247082711963192809202389702471770174675074069166275446198704174727625711123834550812483172629965561836008246053523874007199772255859574732755576273811917611665640795622112432465430334631843658556928497752937910370612644067696376870564503348009779757711481049497840582621307952234610228469753708559996600649121/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "5922358658114056595587/200000000000000000000000", + "coordinate_movement_above_kappa": "6859089723617336356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "delta_below_one_eighth": "999999999999999999999999/8000000000000000000000000", + "delta_positive": "1/8000000000000000000000000", + "dimension_above_kappa": "1277903095411929963492309098056260799109966206051622967656179193863534239925896140778405420467257463635390903806009391853715684555634517585276047869487648486555480773845148529293019120439240110449400512407444965057653594818234354202346095910905150464553329813127823000051056247174400703477403356253262469361838724341985908696981361055126744573337237123043271786352540173943450290731413749445158591911739096115044249301091/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121000000000000000000", + "epsilon_below_one": "2096904588070037788179632560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121", + "epsilon_positive": "1279999999999999999999998720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121", + "gamma_sublinear": "1/2000000000000000000000000", + "guard_width": "2096904588070037788179632560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121", + "lambda_above_internal": "4193809176140075576356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "129690684315612198810324672298531548024926088711931497689908731824378929455389058211482264866776572974428529499653556544848388352108308445004254438001457433570351244041637936247613521208881569074039661752090908040045838620547818668991048036444496032322603278526954087139198623932654132735365712061334610484994492572841550240753560730629171087252044366038892530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_tau": "4193809176140075576356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "4193809176140075576356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_below_one": "2096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "leaf_saving_above_bit": "129682296697259918659171829185022054460984823460247082711963192809202389702471770174675074069166275446198704174727625711123834550812483172629965561836008246053523874007199772255859574732755576273811917611665640795622112432465430334631843658556928497752937910370612644067696376870564503348009779757711481049497840582621307952234610228469753708559996600649121/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "literal_scalar_guard": "1", + "phase_boundary": "3355047340912060461086130000595581258853490998437806229123075559779621775886237377762032606441311256928503855246225107751046440285064242290576897606454105315840854635137551405197115798010796203261816569441300988538636194969720902276205285286798780655407440303316753461589686757779570741863222749338528331949587789858469305435488145710372748455451951259341410758140990931112685145900166668040626752925630246291440003399350879/2051355047340912060461085364097500169328891279176790367166728906116829107269865716583328355624633354923001368435468490503597873316140336410097141646277276693026097165348666474703130257108739139119808506025851993950500586075285987059772424348153095834397319798068534349146486185082653363575831439303204204990301822684508033808063607084349550565976581991013769129227244726294857068751605933695994561038593600000000000000000000000", + "phase_local": "16775236704560302305435778390596258574418607705599274896038700027096050855349103711075455104974730948933977597120187122142539704846409882679143482715560877420229516029803450217718144232967352682495840672849276790540980496113669141365902677899182118244686632577454150047534427088393025045188979962155348293156878527890604537689916483108575012361779915314417927667119896110540960152323901452018870907300030246291440003399350879/10256775236704560302305426820487500846644456395883951835833644530584145536349328582916641778123166774615006842177342452517989366580701682050485708231386383465130485826743332373515651285543695695599042530129259969752502930376429935298862121740765479171986598990342671745732430925413266817879157196516021024951509113422540169040318035421747752829882909955068845646136223631474285343758029668479972805192968000000000000000000000000", + "prime_interval_packing": "2096904588070037788179632560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121", + "q_below_internal": "4193809176140075576356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "64845342157806099405162271306020520794433676981807956333927135419777734604153173124144727832193435251329177412289743689286471076702066858689271657083453310543589307038038050119683733842503780937133702946258087642234782404315103501675126207166031783446134323341647765105350435497371881061360822182478869960245572281530896264636255616394294232972046065714332030246291440003399350879/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000000000", + "q_positive": "2096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "record_suffix": "2096904588070037788179632560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121/1282096904588070037788178352560937605830557049485493979479205566323018192043666072864580222265395846826875855272167806564748670822587710256310713528923297933141310728342916546689456410692961961949880316266157496219062866297053741912357765217595684896498324873792833968216553865676658352234894649564502628118938639177817521130039754427718469103735363744383605705767027953934285667969753708559996600649121", + "row_product_gap": "23971789/25", + "scalar_work_above_kappa": "10243918802840682651454148256118583016145472250935369970262518229938318818843034440032061208045195321951868016149922550564887526438616748769864075706790991684561871107746888236277699939932408997251769739041988502760134669965140385834671325137600038150455984404483598652864415829988255103187866673263777874113540804924122531599059676899660592218487441287658143286003633897013287606201212799166645434412127350879/10256775236704560302305426820487500846644456395883951835833644530584145536349328582916641778123166774615006842177342452517989366580701682050485708231386383465130485826743332373515651285543695695599042530129259969752502930376429935298862121740765479171986598990342671745732430925413266817879157196516021024951509113422540169040318035421747752829882909955068845646136223631474285343758029668479972805192968000000000000000000000000", + "short_record_fallback": "3271423130236837764912534661841087410456748983442619654768971924241534521974858645173089568950534432400918188818670586998667886425761861772829298681533003187293153001461204775332753776936784227011427171703177011903817299206553591729040421647876711197406386480345145220525683645935841484988024055849741195258914273845242343941169648508071232793276384462797121951426290583510353962846577451635108440778365031449561166384664432556567742178794802507454045313386147508872584073542580324736369589047619398445609862772936462061355939023112982938214985265590744805268078068048751879870856215245935815386617715384951450333899456093735493876281808934138282953368506039851604026437597207680807530141560725484426929240069129099678080417370891994675199779688085396141091286119907106398558072641/3282168075745459296737736582556000270926226046682864587466766249786926571631785146533325368999413367876802189496749584805756597305824538256155426634043642708841755464557866359525008411373982622591693609641363190320800937720457579295635878957044953335035711676909654958634377896132245381721330302885126727984482916295212854092901771334959280905562531185622030606763591562071771310002569493913591297661749760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000000000" + }, + "unit_coordinates": [ + "1/1000000000000000000000000", + "327641341885943404413/6250000000000000000000", + "4193809176140075576356713509493563941265251684414977945539015176539752917288036807190797610297528229825324925930833724553801295825272374288876165449187516827370034438163991753946476125992800227744140425267244423726188082388334359204377887567534569665368156341443071502247062089629387355932303623129435496651990220242288518950502159417378692047765389771530246291440003399350879/4193809176140075576486395806190823859924423513600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1/500000000000000000000000", + "21180854424949863714036585290294958485189837862394266099200061984502627011150093147419995280227640046556527212026344911962782266318004189130829601134863772166860870251024956636170500613736258086863511035909443862084900825915614117716202920149995307542123099718959595443876291167669661844410542896338693314760360181960518212309484291649044713765281585421497107550099253096461709783699500553953617053140443282381320191000000/21180854424949876648266166303363815762820821284256752945451876423926328784713067262766659062664678391949400928742840089917615623559980691961098790429043893242973915448359832237608781638723424579127543532795992495968852694317936917793395502317048916731439555834508813451084518704894539403297303137746984450367720031999561893046823122013043295093269743729070578766911298692336205697453954869117842055081113598903434377771221" + ] + }, + "native": { + "bootstrap": [ + { + "cutoff_log2": "5241584503068", + "exponent": "2616937594147472463181647404570379372418439180818281985196731206106637530094845293908902991/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "4193145545466516938348374298880934642580699181718014803268793893362469905154706091097009/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "1953103191224701871", + "exponent": "104844954818150428484708827670685349115927759847941873112467625821292334662854606326082292407756137687601789397603055352261069105711061527/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "274769567130720091003484085063166513035352058126887532374178707665337145393673917707592243862312398210602396944647738930894288938473/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "727759339440154320602349", + "exponent": "4193809165503528399730668112448731836316676666560588817383223110134206362911964356778916361020650856369756089354659046475316834661498113795980081507128991158283629349193952626951253919/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "18005173968461325133742084654980955141439411182616776889865793637088035643221083638979349143630243910645340953524683165338501886204019918492871008841716370650806047373048746081/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "271175459915285204679177783649", + "exponent": "167752367339168246853623402779449825855186361271761270070255341165562352632938228336409568311220624512326204561218333438582165111381186642879500110567715679925758619301837382578914065917609958599646827390849633763092178585324672743/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "1179847874056327068182833796718911048238729929744658834437647367061771663590431688779375487673795438781666561417834888618813357120499889432284320074241380698162617421085934082390041400353172609150366236907821414675327257/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "101044570746197251396547951913265190", + "exponent": "6710094693613846475718917933853346458300149001592414756775909837904655537716992093593213385799267506318691339267930445475464828442111875869138561838444135484365851890889826641851558626865433984927002325775154465693228406681570758565275104037923565645125941573586744834820428271/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "77313388271260051959927776061891207585243224090162095344462283007906406786614200732493681308660732069554524535171557888124130861438161555864515634148109110173358148441373134566015072997674224845534306771593318429241434724895962076434354874058426413255165179571729/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "37650919004517780698191096314858696156952", + "exponent": "268403787744556946498075103065830933612746585256446267565959706503481097617666109879115590535941191177192733503116977519193401916186814686953814164044100280696246475199559190601944014588801076377247575884907056660155874794041008521762354211647854137004591373019874475035844587314783174611649236170165644598653307538791125687/163840000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "5066212464690381321830301850455553732434040293496518902382333890120884409464058808822807266496883022480806598083813185313046185835955899719303753524800440809398055985411198923622752424115092943339844125205958991478237645788352145862995408626980125524964155412685216825388350763829834355401346692461208874313/163840000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + { + "cutoff_log2": "14029370320602884630187885694368931621808296827", + "exponent": "10736151509782278062239522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "331980130625387167465865472036386284430466272521694585029236743925387031254920258966060669485975807066860138659968768269319850692420644118770015031296942529989491500834462171827900553408740974379001599212288654316037529601318985769173497881974405544422195271249734821850509398255204841459926628775788040849973327434803362033060629730070566606412858561/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + ], + "bridge_gaps": [ + "1", + "23971789/25" + ], + "gain": "5368075754891139031119745185584286851710942618948673574639973757693457564644431376786971338870861028087655087065037284261929143017094457797795754685031607224281420657060707227311463636335996008807424063414110749472459999714696294452608341529911424994985984140928197607055267470305918021081742948396130955990295055831781167111025791350690973267275755253495942273060832269594621778415106257254780870269929433393587141439/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561000000000000000000000000", + "grid_successor_rejected": true, + "kappa": "51110230636731/31250000000000000", + "slacks": { + "Gaussian_arithmetic_above_kappa": "1225635860608096389876809385099493241132938793460842060032762341061833460186099216376865207235076191629834315811689518266993010743749700423800701961947231703707625754853762760922193404087087038032411845099526811114159976794110788948466640942074848974449837466504924176583522467200452054200781479293303225738317562469861304045532109701115769585234573419223146411683320427742517815230114031863904127941439/5251468921207825822449791600885856066788559957981918763575490746572267514022194665693605726409707399839605941745030469362218926234769096162945835426422285340655013218886723553849038996831356480337645727540459408555636273645271054530532728982721503551046508107354467837674839474460596823301568463556908270126407773657794406775647767673934763351634416856173267442400248966048207568112906570260573697600000000000000000000000", + "K_dominates_log": "5368075754891139031120564385584286851710942618129473574639973757693457564644431376786971338870861028087655087065037284261929143017094457797795754685031607224281420657060707227311463636335996008807424063414110749472459999714696294452608341529911424994985984140928197607055267470305918021081742948396130955990295055831781167111025791350690973267275755253495942273060832269594621778415106257254780870269929433393587141439/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561000000000000000000000000", + "K_geometry": "2462968075754891139031120569753660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561000000000000000000000000", + "alpha_below_one": "6553599999999999999999996728568075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/6564336151509782278062239501107320083485699947477398454469363433215334392527743332117007158012134249799507427181288086702773657793461370203682294283027856675818766523608404442311298746039195600422057159425574260694545342056588818163165911228401879438808135134193084797093549343075746029126960579446135337658009717072243008469559709592418454189543021070216584303000311207560259460141133212825717122000000000000000000000000", + "alpha_below_one_fourth": "1630347886367663291453317102737585692276864070511701712808019167938472944303419735593961239158095576522035488117612941040044656408617562991281630674558004223821026948440838182194863849853865103885678286080192324076891204486138099164755913851369618715302980232310800603119557396760757574697178112190070034629507275676107466715499046810544695479346968977192357981976861365840340513186301590536315938629730070566606412858561/6564336151509782278062239501107320083485699947477398454469363433215334392527743332117007158012134249799507427181288086702773657793461370203682294283027856675818766523608404442311298746039195600422057159425574260694545342056588818163165911228401879438808135134193084797093549343075746029126960579446135337658009717072243008469559709592418454189543021070216584303000311207560259460141133212825717122000000000000000000000000", + "alpha_positive": "10736151509782278062242772539244328594560916357647900809321690365360653828516097435290550344937985927841368677709080635648758039747779559638942896198959945133664682461262928382960836655933796219836003776201241096745131028009105376035563955730851144399053551237470596153829939008178932584562032671463799784995153591953285401890880587559918068038786290361788093773216436049724351848981712670113341870269929433393587141439/6564336151509782278062239501107320083485699947477398454469363433215334392527743332117007158012134249799507427181288086702773657793461370203682294283027856675818766523608404442311298746039195600422057159425574260694545342056588818163165911228401879438808135134193084797093549343075746029126960579446135337658009717072243008469559709592418454189543021070216584303000311207560259460141133212825717122000000000000000000000000", + "artificial_boundary": "183844356848313032897991700096338469936215815412636002203999755091440621776985468331789378879389884785199235845311955792690131748651904618449963471217378103818255834278910366695746573601404044626112492568566495401018851578896581319582700201126873226925087569043045556109812737190626574221689934182600345418675354636752645440228917193971966142429889378586495086323691242956459908049392717310889759244389190211699819238575683/26257344606039129112248958004429280333942799789909593817877453732861337570110973328468028632048536999198029708725152346811094631173845480814729177132111426703275066094433617769245194984156782401688228637702297042778181368226355272652663644913607517755232540536772339188374197372302984116507842317784541350632038868288972033878238838369673816758172084280866337212001244830241037840564532851302868488000000000000000000000000", + "balanced_prefix_above_kappa": "23938264507347112202498992504282105367050401099820621068984171401241212262759677348604126283958109330018734679011779470918678947862863225673550855529186976906952415317129386037586221869852735500590079221252080544947076641929332368024916455567001233894327282628368970178240644804201632657691328960421737281366921708490621878262428603143956363173079456850267217187020936091760187409371955125595909/102567752367340348094722492204801876304464061679334350851083803643989599883245989564328236843939597653117303549707626354730838403022833909432535848172310260559668226931381319411114042906862431256594643116024597823352270969634200283799467362943779366231377111471766949954586708485558531705108759053845864650906401829253797007336870462381538346711609704222134129734379862618129054064705206450401830031250000000000000", + "beta_below_one": "999999999999999999999999/1000000000000000000000000", + "beta_positive": "1/1000000000000000000000000", + "bit_positive": "10736151509782278062239522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "bulk_exposure_above_kappa": "17559269754109051039522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "3271431924245108860968879430246339958257150026261300772765318283392332803736128333941496420993932875100246286409355956648613171103269314898158852858486071662090616738195797778844350626980402199788971420287212869652727328971705590918417044385799060280595932432903457601453225328462126985436519710276932331170995141463878495765220145203790772905228489464891707848499844396219870269929433393587141439/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "5368075754891139031120569753660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cell_above_band": "6553599999999999999999990164231924245108860968880249446339958257150026261300772765318283392332803736128333941496420993932875100246286409355956648613171103269314898158852858486071662090616738195797778844350626980402199788971420287212869652727328971705590918417044385799060280595932432903457601453225328462126985436519710276932331170995141463878495765220145203790772905228489464891707848499844396219870269929433393587141439/13128672303019564556124479002214640166971399894954796908938726866430668785055486664234014316024268499599014854362576173405547315586922740407364588566055713351637533047216808884622597492078391200844114318851148521389090684113177636326331822456803758877616270268386169594187098686151492058253921158892270675316019434144486016939119419184836908379086042140433168606000622415120518920282266425651434244000000000000000000000000", + "compact_leaf": "166004078264203366010994975540772765318283392332803736128333941496420993932875100246286409355956648613171103269314898158852858486071662090616738195797778844350626980402199788971420287212869652727328971705590918417044385799060280595932432903457601453225328462126985436519710276932331170995141463878495765220145203790772905228489464891707848499844396219870269929433393587141439/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "766021182067031835588828729017276818085571092344286135508266250158002184741113411283665982583080492493474609974663352425354374944782726490868525535786841747094139380764878549000537944185914516421082324051486864651176105269067607482388244995188425283678753640040239949161302086959780707173107963253205869936072665666841363982893480520751807412311447847698015841692518454780722216970172493452462675141439/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561000000000000000000000000", + "compact_reservations": "1/4000000000000000000000000", + "complex_above_bit": "331997420376896949743928043556386284430466272521694585029236743925387031254920258966060669485975807066860138659968768269319850692420644118770015031296942529989491500834462171827900553408740974379001599212288654316037529601318985769173497881974405544422195271249734821850509398255204841459926628775788040849973327434803362033060629730070566606412858561/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "1184471731507676525497/40000000000000000000000", + "coordinate_movement_above_kappa": "17559269754109051039522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "delta_below_one_eighth": "999999999999999999999999/8000000000000000000000000", + "delta_positive": "1/8000000000000000000000000", + "dimension_above_kappa": "102232247632659651929215567502545235898034930824947754515966597455831021185738181836912975418820079695486822734250482975287896275988945561486143099690552965113882628597805657495838372410266954780991578753828137677237808251617880261147609278985553001793539344095234283939740574142810438473131885750355768006784927131167940274030051246109083531550818898921822233438699594232138163122315729641358357378121955125595909/102567752367340348094722492204801876304464061679334350851083803643989599883245989564328236843939597653117303549707626354730838403022833909432535848172310260559668226931381319411114042906862431256594643116024597823352270969634200283799467362943779366231377111471766949954586708485558531705108759053845864650906401829253797007336870462381538346711609704222134129734379862618129054064705206450401830031250000000000000", + "epsilon_below_one": "5368075754891139031123027353660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561", + "epsilon_positive": "3276799999999999999999996723200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561", + "gamma_sublinear": "1/2000000000000000000000000", + "guard_width": "5368075754891139031123027353660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561", + "lambda_above_internal": "10736151509782278062239522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "332008156528406732021990283078965907533516528593651028642952313459114509560335229729316744098944552146601172599299282293512783832281984150001745711446250109345372730819430874885370563917240139916829771311735245575063150599719773480519181844444804225436426097751852847444964976059933591725104778266389785645131867508174586245019779756743131803050825500370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_tau": "10736151509782278062239522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "10736151509782278062239522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_below_one": "5368075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "leaf_saving_above_bit": "331986684225387167465865472036386284430466272521694585029236743925387031254920258966060669485975807066860138659968768269319850692420644118770015031296942529989491500834462171827900553408740974379001599212288654316037529601318985769173497881974405544422195271249734821850509398255204841459926628775788040849973327434803362033060629730070566606412858561/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "literal_scalar_guard": "1", + "phase_boundary": "8588921207825822449793561597780311897420926862168209915449003722293775322967431011889118742511135967939883241451463295094026481055505518902484039593388609969911377739582039920701087448094676135424571891086388957836062616691341743402381710050475256637426524398853636735120070393029726759169916782236732253393210177504683707978938669076227230130182076318471233173154194537672459820755070104969917470269929433393587141439/5251468921207825822449791600885856066788559957981918763575490746572267514022194665693605726409707399839605941745030469362218926234769096162945835426422285340655013218886723553849038996831356480337645727540459408555636273645271054530532728982721503551046508107354467837674839474460596823301568463556908270126407773657794406775647767673934763351634416856173267442400248966048207568112906570260573697600000000000000000000000", + "phase_local": "42944606039129112248980936661204579051660758789843264217411990011363831411746093786312024381340735326363650221573340743969731420131890170685825745282529972589964253286476255316857074773520597486007482052924023180381157197775559865533297640936489460823458953816724987434477968235417019965443771009869812759024304808682310810570009364815280636667849501011541002774150058730502732272381351147264707870269929433393587141439/26257344606039129112248958004429280333942799789909593817877453732861337570110973328468028632048536999198029708725152346811094631173845480814729177132111426703275066094433617769245194984156782401688228637702297042778181368226355272652663644913607517755232540536772339188374197372302984116507842317784541350632038868288972033878238838369673816758172084280866337212001244830241037840564532851302868488000000000000000000000000", + "prime_interval_packing": "5368075754891139031123027353660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561", + "q_below_internal": "10736151509782278062239522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "166004078264203366010994975540772765318283392332803736128333941496420993932875100246286409355956648613171103269314898158852858486071662090616738195797778844350626980402199788971420287212869652727328971705590918417044385799060280595932432903457601453225328462126985436519710276932331170995141463878495765220145203790772905228489464891707848499844396219870269929433393587141439/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000000000", + "q_positive": "5368075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "record_suffix": "5368075754891139031123027353660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561/3282168075754891139031119750553660041742849973738699227234681716607667196263871666058503579006067124899753713590644043351386828896730685101841147141513928337909383261804202221155649373019597800211028579712787130347272671028294409081582955614200939719404067567096542398546774671537873014563480289723067668829004858536121504234779854796209227094771510535108292151500155603780129730070566606412858561", + "row_product_gap": "23971789/25", + "scalar_work_above_kappa": "6128192431712784968948603049976468420304860938704105254960720644036033731599281137370990270189696982417671178073301953911138459266064089041743917174324724574251480411801861021419851643032927268553260069611952906719321273061238057919969531042196701676008064948794889269087206523100946422495965650387675020962263128368740664713677487624998032763081246182157872491585208139335004196669490441585946291141439/26257344606039129112248958004429280333942799789909593817877453732861337570110973328468028632048536999198029708725152346811094631173845480814729177132111426703275066094433617769245194984156782401688228637702297042778181368226355272652663644913607517755232540536772339188374197372302984116507842317784541350632038868288972033878238838369673816758172084280866337212001244830241037840564532851302868488000000000000000000000000", + "short_record_fallback": "21439598626258124931101292881264129974404275501374429178121693356738637101796695075329847057941118586628107558475134128643348821876267659381100777661604154505707071609462050427606460513673449773677711347330630319279993837550634975939445317804130675657921776334644243023222281278135542805967297332859322796651359061903783324029192152334530094089406976716569013553861788888030895351056415331939539741071896287691251326291743420787762579824631032222236328814597894482389170048732845670360556369757933983640260687858520201282647643061865779109308941736746368218014339645011807356666135504333171105400199523828392924143365342233507208795909332417474909774821060827957915716623227090737399005091740976681631155157214161430950634990338551458343768942743364350986080123390990721/21510016701267254568754346397228466449565941587893939255605210097960007737434909350681009055374161509743025937387644802507648721857614217883426141906625680755322934144560019676565663731021236143462996900005721737443886176851030239357062057913227278545086497207723900263116142487390604588243224426729096274437766240902325890153053256392436790688294571442885703444071419764933458198990465311787309865369600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000000000" + }, + "unit_coordinates": [ + "1/1000000000000000000000000", + "65528268492323474503/1250000000000000000000", + "10736151509782278062239522579623103050256071956443613715569533727478305414970763256074612968745079741033939330514024192933139861340031231730680149307579355881229984968703057470010508499165537828172099446591259025620998400787711345683962470398681014230826502118025594455577804728750265178149490601744795158540073371224211959150026672565196637966939370269929433393587141439/10736151509782278062571509263848490217721937428480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1/500000000000000000000000", + "255622654994816107861836338978688155375343504841516928050899114924158193160865772323085076083688083067698690665930704323205674683511525354448609995347862683607423089058045720627242041497973667060451422738075920399530283248944363965547765355347806790797189950119186377538172734765046136179983618505496370613444371553614820525636196405206047160656915928651834760076808789122799051709364356025360185718925522901472000000/255622654994816144339035485027823183414806791378508265459046369413974169744972922704141492327183858480364527955477965917234721096052117037990274032620552724965781936050509867967212554111237905181305907781624321403450476176890299735838492453805305952142189720996580838431203212871710381956273473733149093142395002658656246052905990064318617774632178821595044870145753917599743894210243155107370517631901401590170816259" + ] + } + } +} diff --git a/research/outer-bernstein-certificate/README.md b/research/outer-bernstein-certificate/README.md new file mode 100644 index 0000000000..8efa5765e3 --- /dev/null +++ b/research/outer-bernstein-certificate/README.md @@ -0,0 +1,223 @@ +# Exact positive certificates for the 47 outer inequalities + +**Independent arithmetic verification; no new κ.** This supplies explicit +nonnegative-coefficient certificates for every one of the selected outer +engine's 47 strict inequalities on its retained parameter domain. It also +reproduces all 94 recorded slacks in the native and conservative PR626 +witnesses, including their seven-step bootstrap and strict grid rounding. + +The closed-form ceiling and the written reduction of the 47 rows belong to +[Romain Hedouin's PR183](https://github.com/CrocSwap/integer-mult-bounds/pull/183). +This corroborates that arithmetic with a different, complete algebraic +certificate: **57 polynomial records, 2,586 rational Bernstein coefficients, +1,268 positive coefficients**, and exact zero identities. No new ceiling, +supplier, multiplication exponent or practical speedup is claimed. + +## Reproduce + +Python 3.11+ and its standard library suffice, offline: + +```sh +python3 -B -I research/outer-bernstein-certificate/verify.py +python3 -B -I research/outer-bernstein-certificate/test_verify.py +``` + +Expected primary line, followed by 12 passing tests: + +```text +PASS_OUTER_BERNSTEIN_CERTIFICATE slacks=47 witnesses=2 coefficient_rows=57 weights=2586 controls=24 kappa=unchanged +``` + +The primary verifier reads the committed [EXPECTED.json](EXPECTED.json), +expands its positive basis with integer binomial arithmetic, and compares every +power coefficient with the expressions extracted from the pinned source. It +also regenerates the certificate independently by a power-to-Bernstein +transform. Source code is parsed as arithmetic syntax; no predecessor Python +is imported, compiled or executed. Checks remain active under `-O`. + +An optional third-party algebra implementation checks all 57 polynomial +identities separately. It needs SymPy; SymPy 1.14.0 was used in validation: + +```sh +python3 -B -I research/outer-bernstein-certificate/crosscheck_sympy.py +``` + +Expected: `PASS_SYMPY_OUTER_CERTIFICATE rows=57 weights=2586 identities=4 sympy=1.14.0`. +It imports none of the primary polynomial arithmetic, source interpreter or +verifier. The primary command and tests do not require SymPy. +`verify.py --write /new/path.json` creates a new certificate and refuses an +existing destination. [VALIDATION.md](VALIDATION.md) records observed checks. + +## Statement and parameter map + +Let `a` be the effective ordinary bit saving after bootstrap, `b` the complex +saving, `beta` the leaf backoff, `eta` the outer backoff, and `L,R` the two +literal/row bridge gaps. Assume + +```text +0 < beta < 1, 0 < eta < 1/2, +0 < b < 1/32, 0 < a < (1-beta)b, +L > 0, R > 0, +q = a(1-2eta), D = 1+q, +G = (1-eta)q/D, 0 < kappa < G. +``` + +Then all 47 slacks of the pinned selected `outer.py` are strictly positive, +its two `min`/`max` choices have the prescribed order, the minimum of its seven +margins is exactly `G`, and its three further prefix identities hold. This is +a statement about the displayed arithmetic under its stated assumptions. +In particular, positive bridge gaps are hypotheses, not a construction of +physical networks or a re-audit of the finite invoice. + +Introduce five independent open-unit coordinates: + +```text +u = beta, v = 32b, w = a/((1-beta)b), z = 2eta, t = kappa/G. +a = (1-u)vw/32, b = v/32, eta = z/2, kappa = tG. +``` + +Every point of the stated domain has these coordinates in `(0,1)^5`. +Conversely every such coordinate tuple, together with arbitrary positive +`L,R`, gives a point of that domain. Here `q=(1-u)vw(1-z)/32 > 0`, so `D>1`. +The bridge variables are **not** restricted to the unit interval. + +The source's `max(sigma-tau,0)` chooses zero because `b-a>0`. Its Gaussian +`min(1-epsilon-delta,r-delta)` chooses the second argument because +`1-epsilon-r=eta/2>0`. Both differences receive their own strict positivity +certificates. Thus branch choices do not depend on numerical sampling or an +uncertified symbolic simplification. + +## Certificate proof + +For `00`, hence `S>0`. +Zero coefficients are allowed; the domain is open, so no endpoint positivity +is asserted. The same argument handles the two unrestricted positive bridge +variables through ordinary monomials. + +The power-to-Bernstein transform uses the exact identity + +```text +x^j = sum_{k=j..n} binomial(k,j)/binomial(n,j) B[k,n](x). +``` + +The checking direction instead expands each `(1-x)^(n-k)` with integer +binomial coefficients and compares the resulting power map. It does not call +the nomination transform or the primary polynomial multiplication. The +optional SymPy checker expands both sides again with separate algebra. + +The 57 records consist of the denominator, 47 slacks, two branch-order +differences, and seven margin differences `margin-G`. Six margin differences +have strict certificates; the compact-phase difference is the identically +zero polynomial. This proves both the lower bound on every margin and an +attaining margin, so the source's minimum assertion is justified. Three +additional source equalities reduce to zero coefficient maps. The receipt's +four identity entries include the minimum assertion. + +This finite coefficient evidence, together with the positive-basis argument, +establishes the arithmetic statement for the whole parameter domain. The +tests of particular parameter points are supplementary. There is no Lean or +other proof-assistant formalization; correctness of the Python checker and +its arithmetic libraries is part of the executable trust boundary. + +## Binding to the selected construction + +Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +[SOURCES.json](SOURCES.json) pins six consumed files. The selected record binds +the full assembly receipt and review. The selected source inventory binds the +outer engine and its caller, and the receipt independently names the consumed +outer-engine hash `c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c`. +The AST interpreter accepts the fixed source grammar and complete row inventory; +it is not a general Python execution engine. + +Both native and conservative witnesses are reconstructed from the retained +complex and bit endpoints. For their common ordinary recursion parameter `s`, +the checker uses the closed form `a_j=s-s^j(s-a_0)`, with +`a_0=384599/10^10`, rather than the producer's update loop. All 14 exponents, +14 gap/cutoff records and 94 outer slacks match exactly. At the `10^-18` grid, +`kappa=(ceil(10^18 G)-1)/10^18`, so `kappa0`, while the altered gap is +`-10279/102460<0`. + +## Attribution, overlap and limits + +PR183 at `1f22094b12bdae7759124e6c51ab44d3ea2a10ab` is credited for the closed +form, the written 47-row reduction and its earlier point checks. No priority +for those mathematical statements is claimed. BigCactusLabs' PR701 at +`de07c015b38e5b157016db636f210c4f7f537058` gives a larger-domain Gaussian +envelope and separate factored finite comparisons; this stays inside the +retained `b<1/32` domain and adds a complete coefficient certificate for the +selected engine. PR294 and the existing domain audit provide related context. +No pending contribution's code is imported. + +The initial queue check covered 611 open PRs through PR791. PR678/706 verify +supplier moments, PR771 finite invoice guards, and PR766 assembly mutation +sites; those are distinct from this universal outer-arithmetic certificate. +The packaging refresh inspected arrivals through PR810 and confirmed unchanged +main and predecessor heads, with no matching Bernstein certificate found. +[CLAIM.json](CLAIM.json) records seed **79**, the three candidate tasks and +`79 mod 3 = 1`. No pinned coordination issue existed, so the claim is local. + +Credit also to eumemic / Anthropic Claude for the retained outer engine; +icekylinx, Zhihao Chen, James Chang and RaD / hipotures for its assembly +lineage; Rohan Arun for the ordinary bootstrap; Jeremy Kothe, Chafik Boukhalfa, +DreamingOfClouds and the retained selected-supplier contributors. Original +notices and files are unchanged. + +Prepared for **Gareth Davidson (@bitplane)** with substantial **OpenAI Codex +assistance** in algebra, code, verification and writing. Both implementations +were developed in one AI session; independent implementation does not mean +independent human review. New material is Apache-2.0 under the repository +[LICENSE](../../LICENSE). + +No production file, frontier pointer or `upstream/` source changes. This does +not discharge the inherited compiler, common-label/mutable-basis realization, +whole-call hosting, normalized residual, precision/tape/exact-recovery or +analytic-transfer assumptions, and is not a formal multiplication theorem. diff --git a/research/outer-bernstein-certificate/SOURCES.json b/research/outer-bernstein-certificate/SOURCES.json new file mode 100644 index 0000000000..446fc359e4 --- /dev/null +++ b/research/outer-bernstein-certificate/SOURCES.json @@ -0,0 +1,37 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "selected_source_head": "660de893d27bb7abd1d5b01b1640207528a5c851", + "files": { + "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53", + "research/community-k492-audit/SELECTED-SOURCE.json": "36e9e421230c4cb7b6a537d76a4bdfb6f667730d383e56062d4e45957484ab9e", + "research/community-k492-audit/pr626/replay/ASSEMBLY.json": "6127732e2fcdd470dab349c1c51d03cd9f0787ad0309b1b4a7c811a908028f4e", + "research/complex-k492-owner-repair/vendor/multicold/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "research/complex-k492-owner-repair/code/assemble.py": "1b1a9024ac910dc9b9d9e30150684e1fa9cb228a4c1c275b75ab04b57fdef1dd", + "docs/research/community-k492-review.md": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47" + }, + "related_work": { + "183": { + "head": "1f22094b12bdae7759124e6c51ab44d3ea2a10ab", + "author": "Romain Hedouin", + "inspected": "docs/research/assembly-ceiling.md", + "role": "Predecessor closed-form ceiling and written reduction of all 47 rows; independently corroborated, no code imported" + }, + "701": { + "head": "de07c015b38e5b157016db636f210c4f7f537058", + "author": "BigCactusLabs", + "role": "Related larger-domain Gaussian envelope and independent factored finite comparisons; no code imported" + }, + "706": { + "head": "0f7dbb54948775c010b5e5bc8ab3cf92a52a9b25", + "author": "arkfx", + "role": "Selected complex moment replay; explicitly excludes the 47 outer inequalities; no code imported" + }, + "771": { + "head": "340bedf9f0e65bb0e00ee6edb55d8fed11fcb7c7", + "author": "theon199", + "role": "Independent finite invoice guards; distinct from outer inequalities; no code imported" + } + }, + "license": "Apache-2.0", + "ai_assistance": "Substantial OpenAI Codex assistance; prepared for Gareth Davidson (@bitplane)" +} diff --git a/research/outer-bernstein-certificate/VALIDATION.md b/research/outer-bernstein-certificate/VALIDATION.md new file mode 100644 index 0000000000..e9151cb30a --- /dev/null +++ b/research/outer-bernstein-certificate/VALIDATION.md @@ -0,0 +1,82 @@ +# Observed validation + +2026-10-13, Linux x86_64. Exact base: +`66849e1475c930fd7732b1a0067ffee7e1e95f60`. +These checks were executed with substantial OpenAI Codex assistance; they do +not represent independent human review or a proof-assistant formalization. + +## Complete algebra and selected witnesses + +The standard-library command reproduces the committed certificate: + +```text +PASS_OUTER_BERNSTEIN_CERTIFICATE slacks=47 witnesses=2 coefficient_rows=57 weights=2586 controls=24 kappa=unchanged +``` + +Coverage is all 47 source rows, both piecewise branch decisions, all seven +minimum-margin comparisons, denominator positivity and the remaining source +identities. The 57 records have 2,586 exact coefficients, 1,268 positive. +Power-to-Bernstein nomination and direct integer-binomial reconstruction agree +coefficient by coefficient. Positivity follows from the written basis lemma, +not from sampling parameter values. + +Both retained PR626 witnesses reproduce all 94 fractions exactly. The closed +ordinary-recursion formula matches all 14 recorded exponent/gap/cutoff triples, +and strict grid rounding reproduces both κ values and excludes their next +`10^-18` grid points for these fixed parameters. Supplier endpoints and bridge +meanings are inherited, not re-established by these calculations. + +| Invocation | Observed result | +| --- | --- | +| `/usr/bin/python3.12 -B -I verify.py` (3.12.3) | Complete certificate matches; 24 controls reject | +| `/usr/bin/python3.12 -B -I test_verify.py` | All 12 tests pass | +| `/usr/bin/python3.14 -B -I -O verify.py` (3.14.4) | Complete certificate matches; 24 controls reject | +| `/usr/bin/python3.14 -B -I -O test_verify.py` | All 12 tests pass | +| `/usr/bin/python3.12 -B -I -S -O verify.py` | Pass with site packages disabled | +| `python3 -B -I crosscheck_sympy.py` (3.14.4, SymPy 1.14.0) | All 57 coefficient identities and four auxiliary identities match | + +Table filenames are relative to this package; the full public commands are +in README.md. The optional SymPy checker imports none of the primary package's +arithmetic or parsing modules. No timing or speedup claim is made. + +## Mathematical and packaging controls + +The 12 tests include de Casteljau evaluation of every certificate at two +asymmetric rational points, 64 closed-form tensor basis checks, 864 recursion +identities and strict-boundary failures. These finite tests supplement the +universal coefficient certificate. A tightened Gaussian cap is positive at +both selected points yet false inside the admitted domain; its reconstructed +polynomial has a negative Bernstein coefficient. + +The test suite copies only this package and the six pinned source files into +a temporary path containing spaces, invokes the verifier from `/tmp` with +`-B -I -O`, and confirms the same receipt. Altering a pinned source byte and +changing an integer certificate weight to `0.0` are rejected. + +Additional disposable-copy checks on Python 3.14.4 with `-B -I -O`: + +- Incrementing a default certificate weight is rejected by coefficient + reconstruction, before trusting the receipt's claimed result. +- Writing to an existing output path is refused, preserving its exact bytes. +- Removing the implementation's actual nonnegative-weight guard makes both + nonsampling regression tests fail with `ValueError not raised`. This checks + a mathematical failure mode, rather than relying on a checker source hash. + +`make selected-record-check` passes with the original source inventory and +κ `51110230636731/31250000000000000`. + +## Sources, overlap and remaining obligations + +The initial live snapshot covered 611 open PRs through PR791. The packaging +refresh inspected arrivals through PR810 and found no matching universal +Bernstein certificate. Main remained at the exact base. PR183 and PR701 heads +remained at the hashes in SOURCES.json; their written reduction and broader +Gaussian-envelope work retain credit. PR706/678 check moments, PR771 finite +invoice guards, and PR766 mutation sites, each with a distinct scope. + +No production or selected-source files change. The complete repository suite, +supplier cold replay, geometry, native phases/wrappers, owner hosting, finite +invoice, and moment enclosures were not rebuilt for this isolated arithmetic +addition. Remote CI is separate. No Lean check or full multiplication-theorem +verification is claimed; the inherited uniform, physical, precision/tape and +analytic assumptions remain. diff --git a/research/outer-bernstein-certificate/algebra.py b/research/outer-bernstein-certificate/algebra.py new file mode 100644 index 0000000000..bf3c99625c --- /dev/null +++ b/research/outer-bernstein-certificate/algebra.py @@ -0,0 +1,218 @@ +"""Exact sparse polynomials and independently reconstructed Bernstein evidence. + +Gareth Davidson / OpenAI Codex, Apache-2.0. No predecessor arithmetic imported. +The first five coordinates lie in (0,1); the last two are arbitrary positive. +""" +from fractions import Fraction as F +from itertools import product +from math import comb, lcm + +VARIABLES = ("beta", "32b", "a/((1-beta)b)", "2eta", "kappa/G", "L", "R") +ZERO = (0,) * len(VARIABLES) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +class Poly: + def __init__(self, terms=0): + if isinstance(terms, Poly): + self.terms = dict(terms.terms) + elif type(terms) in (int, F): + self.terms = {ZERO: F(terms)} if terms else {} + else: + self.terms = {tuple(k): F(v) for k, v in terms.items() if v} + require(all(len(k) == 7 and all(type(i) is int and i >= 0 for i in k) + for k in self.terms), "invalid monomial") + + @classmethod + def variable(cls, index): + k = list(ZERO) + k[index] = 1 + return cls({tuple(k): F(1)}) + + def __add__(self, other): + terms = dict(self.terms) + for k, value in Poly(other).terms.items(): + terms[k] = terms.get(k, F(0)) + value + return Poly(terms) + + __radd__ = __add__ + + def __neg__(self): + return Poly({k: -v for k, v in self.terms.items()}) + + def __sub__(self, other): + return self + -Poly(other) + + def __rsub__(self, other): + return Poly(other) - self + + def __mul__(self, other): + terms = {} + for a, x in self.terms.items(): + for b, y in Poly(other).terms.items(): + key = tuple(i + j for i, j in zip(a, b)) + terms[key] = terms.get(key, F(0)) + x * y + return Poly(terms) + + __rmul__ = __mul__ + + def __pow__(self, power): + require(type(power) is int and power >= 0, "invalid polynomial power") + result = Poly(1) + for _ in range(power): + result = result * self + return result + + def __eq__(self, other): + return self.terms == Poly(other).terms + + def evaluate(self, point): + require(len(point) == 7, "wrong point dimension") + total = F(0) + for alpha, coefficient in self.terms.items(): + term = coefficient + for x, power in zip(point, alpha): + term *= x ** power + total += term + return total + + def degrees(self): + return tuple(max((k[i] for k in self.terms), default=0) for i in range(7)) + + +class RationalPoly: + """Numerator / D**power for the single positive denominator D=1+q.""" + def __init__(self, numerator, denominator, power=0): + self.numerator = Poly(numerator) + self.denominator = Poly(denominator) + self.power = power + + def coerce(self, other): + if isinstance(other, RationalPoly): + require(other.denominator == self.denominator, "different denominators") + return other + return RationalPoly(other, self.denominator) + + def __add__(self, other): + other = self.coerce(other) + power = max(self.power, other.power) + left = self.numerator * self.denominator ** (power - self.power) + right = other.numerator * self.denominator ** (power - other.power) + return RationalPoly(left + right, self.denominator, power) + + __radd__ = __add__ + + def __neg__(self): + return RationalPoly(-self.numerator, self.denominator, self.power) + + def __sub__(self, other): + return self + -self.coerce(other) + + def __rsub__(self, other): + return self.coerce(other) - self + + def __mul__(self, other): + other = self.coerce(other) + return RationalPoly(self.numerator * other.numerator, self.denominator, + self.power + other.power) + + __rmul__ = __mul__ + + def __truediv__(self, other): + other = self.coerce(other) + require(other.power == 0, "unsupported division by rational polynomial") + if other.numerator == self.denominator: + return RationalPoly(self.numerator, self.denominator, self.power + 1) + require(set(other.numerator.terms) == {ZERO}, "unsupported denominator") + divisor = other.numerator.terms[ZERO] + require(divisor != 0, "zero denominator") + return RationalPoly(self.numerator * (1 / divisor), self.denominator, self.power) + + def cleared(self): + require(self.power <= 1, "source needs more than one denominator factor") + return self.numerator * self.denominator ** (1 - self.power) + + def evaluate(self, point): + d = self.denominator.evaluate(point) + require(d > 0, "nonpositive denominator") + return self.numerator.evaluate(point) / d ** self.power + + +def indices(degrees): + return product(*(range(n + 1) for n in degrees)) + + +def nominate(poly): + """Power-to-Bernstein transform; the checker below does not call this.""" + degrees = poly.degrees() + coefficients = [] + for k in indices(degrees): + value = F(0) + for alpha, coefficient in poly.terms.items(): + if alpha[5:] != k[5:] or any(a > b for a, b in zip(alpha[:5], k[:5])): + continue + term = coefficient + for i in range(5): + term *= F(comb(k[i], alpha[i]), comb(degrees[i], alpha[i])) + value += term + coefficients.append(value) + scale = lcm(*(x.denominator for x in coefficients)) + return {"degrees": list(degrees), "scale": scale, + "weights": [int(x * scale) for x in coefficients]} + + +def reconstruct(certificate, *, strict=True): + """Expand Bernstein basis directly into powers, using integer binomials. + + Deliberately does not use Poly multiplication or the nomination transform. + Last two coordinates retain ordinary positive monomials, without upper caps. + """ + require(set(certificate) == {"degrees", "scale", "weights"}, "certificate fields") + degrees, scale, weights = (certificate[k] for k in ("degrees", "scale", "weights")) + require(type(degrees) is list and len(degrees) == 7 and + all(type(n) is int and 0 <= n <= 8 for n in degrees), "invalid degrees") + require(type(scale) is int and scale > 0, "invalid scale") + count = 1 + for n in degrees: + count *= n + 1 + require(type(weights) is list and len(weights) == count, "wrong coefficient count") + require(all(type(n) is int and n >= 0 for n in weights), "negative or noninteger weight") + require(not strict or any(weights), "no strict-positive term") + expanded = {} + for k, weight in zip(indices(degrees), weights): + if not weight: + continue + factor = weight + for i in range(5): + factor *= comb(degrees[i], k[i]) + for j in product(*(range(degrees[i] - k[i] + 1) for i in range(5))): + coefficient = factor * (-1) ** sum(j) + for i in range(5): + coefficient *= comb(degrees[i] - k[i], j[i]) + alpha = tuple(k[i] + j[i] for i in range(5)) + k[5:] + expanded[alpha] = expanded.get(alpha, 0) + coefficient + return Poly({k: F(v, scale) for k, v in expanded.items() if v}) + + +def check_certificate(poly, certificate, *, strict=True): + require(reconstruct(certificate, strict=strict) == poly, + "Bernstein expansion differs from source polynomial") + + +def symbolic_inputs(): + u, v, w, z, t, literal, row = (Poly.variable(i) for i in range(7)) + a = (1 - u) * v * w * F(1, 32) + b = v * F(1, 32) + eta = z * F(1, 2) + q = a * (1 - z) + denominator = 1 + q + lift = lambda p: RationalPoly(p, denominator) + gain = RationalPoly((1 - eta) * q, denominator, 1) + return dict(bit_saving=lift(a), complex_saving=lift(b), beta=lift(u), + eta=lift(eta), kappa=lift(t) * gain, + bridge={"semantic": {"strict_literal_gap": lift(literal)}, + "rows": {"degree_gap": lift(row)}}), denominator diff --git a/research/outer-bernstein-certificate/crosscheck_sympy.py b/research/outer-bernstein-certificate/crosscheck_sympy.py new file mode 100644 index 0000000000..14b630e457 --- /dev/null +++ b/research/outer-bernstein-certificate/crosscheck_sympy.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python3 +"""Optional independent symbolic replay; requires SymPy, not package arithmetic. + +This second implementation imports none of algebra.py, source_model.py or +verify.py. It expands the same source equations and the committed positive +basis certificate separately through SymPy's rational-polynomial machinery. +Gareth Davidson / OpenAI Codex, Apache-2.0. +""" +import ast +from hashlib import sha256 +from itertools import product +import json +from pathlib import Path +import sympy as S + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def check(ok, message): + if not ok: + raise ValueError(message) + + +def crosscheck(): + receipt = json.loads((HERE / 'EXPECTED.json').read_text()) + pins = json.loads((HERE / 'SOURCES.json').read_text()) + path = 'research/complex-k492-owner-repair/vendor/multicold/engines/outer.py' + raw = (ROOT / path).read_bytes() + check(sha256(raw).hexdigest() == pins['files'][path], 'source hash differs') + variables = S.symbols('u v w z t L R') + u, v, w, z, t, literal, row = variables + a = (1-u)*v*w/32 + b, eta = v/32, z/2 + q = a*(1-z) + denominator = 1+q + gain = (1-z/2)*q/denominator + env = dict(bit_saving=a, complex_saving=b, eta=eta, beta=u, kappa=t*gain, + bridge={'semantic': {'strict_literal_gap': literal}, + 'rows': {'degree_gap': row}}) + branches = {} + + def expression(node): + if isinstance(node, ast.Constant): + check(type(node.value) in (str, int), 'nonexact literal') + return S.Integer(node.value) if type(node.value) is int else node.value + if isinstance(node, ast.Name): + return env[node.id] + if isinstance(node, ast.Tuple): + return tuple(expression(n) for n in node.elts) + if isinstance(node, ast.Subscript): + return expression(node.value)[expression(node.slice)] + if isinstance(node, ast.BinOp): + left, right = expression(node.left), expression(node.right) + operations = {ast.Add: lambda: left+right, ast.Sub: lambda: left-right, + ast.Mult: lambda: left*right, ast.Div: lambda: left/right} + return operations[type(node.op)]() + if isinstance(node, ast.Call) and isinstance(node.func, ast.Name): + name = node.func.id + if name == 'dict': + return {item.arg: expression(item.value) for item in node.keywords} + args = [expression(item) for item in node.args] + if name == 'Q': + return args[0] if len(args) == 1 else args[0]/args[1] + if name in ('min', 'max') and len(args) == 2: + x, y = args + branches[ast.unparse(node)] = y-x if name == 'max' else x-y + return y + raise ValueError('unsupported independent expression') + + function = next(n for n in ast.parse(raw).body if isinstance(n, ast.FunctionDef)) + for node in function.body: + if isinstance(node, ast.Assign): + value = expression(node.value) + for target in node.targets: + if isinstance(target, ast.Tuple): + env.update(zip((n.id for n in target.elts), value)) + else: + env[target.id] = value + elif isinstance(node, ast.Expr): + # Construct the seven charged margins directly, independent of the + # primary parser's dictionary-comprehension evaluation. + env['slacks'].update({name+'_above_kappa': value-env['kappa'] + for name, value in env['margins'].items()}) + elif isinstance(node, ast.Assert): + break + check(len(env['slacks']) == 47 and len(branches) == 2, 'independent row census') + polys = {'denominator': denominator} + for prefix, values in (('slack', env['slacks']), ('branch', branches), + ('margin', {k: val-env['minimum'] for k, val in env['margins'].items()})): + polys.update({prefix+':'+name: S.cancel(value*denominator) for name, value in values.items()}) + check(set(polys) == set(receipt['certificates']), 'certificate inventory differs') + count = 0 + for name, expected in polys.items(): + cert = receipt['certificates'][name] + degrees, scale, weights = (cert[k] for k in ('degrees', 'scale', 'weights')) + check(len(degrees) == 7 and all(type(d) is int and 0 <= d <= 8 for d in degrees), + 'invalid certificate degrees') + check(type(scale) is int and scale > 0, 'invalid certificate scale') + check(len(weights) == S.prod(d+1 for d in degrees), 'coefficient count differs') + check(all(type(c) is int and c >= 0 for c in weights), 'negative coefficient') + check(name == 'margin:compact_phase_layer' or any(weights), 'missing strict term') + total = S.Integer(0) + for index, coefficient in zip(product(*(range(d+1) for d in degrees)), weights): + term = S.Rational(coefficient, scale) + for axis in range(7): + term *= variables[axis]**index[axis] + if axis < 5: + term *= S.binomial(degrees[axis], index[axis]) * (1-variables[axis])**(degrees[axis]-index[axis]) + total += term + # A coefficient identity, not agreement at sampled evaluation points. + check(S.Poly(S.expand(total-expected), *variables).is_zero, 'symbolic mismatch: '+name) + count += len(weights) + identities = [env['margins']['compact_phase_layer']-gain, + env['margins']['balanced_prefix']-gain-eta, + 1-env['eps']-env['r']-eta/2, + 1-env['eps']*(1+env['c'])-eta+env['eps']*eta/4] + check(all(S.cancel(p) == 0 for p in identities), 'independent source identity') + print(f'PASS_SYMPY_OUTER_CERTIFICATE rows={len(polys)} weights={count} identities=4 sympy={S.__version__}') + + +if __name__ == '__main__': + crosscheck() diff --git a/research/outer-bernstein-certificate/source_model.py b/research/outer-bernstein-certificate/source_model.py new file mode 100644 index 0000000000..95a8300f96 --- /dev/null +++ b/research/outer-bernstein-certificate/source_model.py @@ -0,0 +1,157 @@ +"""Interpret only the pinned outer engine's arithmetic expression syntax. + +This never imports or executes predecessor Python. Source assertions are replaced +by coefficient identities/positivity obligations. Exact source hashes are checked +by verify.py before this parser is used. +Gareth Davidson / OpenAI Codex, Apache-2.0. +""" +import ast +from fractions import Fraction as F + +from algebra import RationalPoly, require + + +class Model: + def __init__(self, source, inputs): + self.env = dict(inputs) + self.symbolic = isinstance(inputs['bit_saving'], RationalPoly) + self.branches = {} + self.identities = {} + self.margin_gaps = {} + tree = ast.parse(source) + functions = [n for n in tree.body if isinstance(n, ast.FunctionDef)] + require(len(functions) == 1 and functions[0].name == 'assembly', 'source function') + function = functions[0] + require([a.arg for a in function.args.args] == + ['bit_saving', 'complex_saving', 'bridge', 'kappa', 'eta', 'beta'], + 'source signature') + assertions = 0 + updates = 0 + returns = 0 + for node in function.body: + if isinstance(node, ast.Assign): + value = self.expression(node.value) + for target in node.targets: + self.assign(target, value) + elif isinstance(node, ast.Expr): + call = node.value + require(isinstance(call, ast.Call) and isinstance(call.func, ast.Attribute) + and isinstance(call.func.value, ast.Name) + and call.func.value.id == 'slacks' and call.func.attr == 'update' + and len(call.args) == 1 and not call.keywords, 'unexpected source update') + new = self.expression(call.args[0]) + require(not set(new).intersection(self.env['slacks']), 'duplicate slack') + self.env['slacks'].update(new) + updates += 1 + elif isinstance(node, ast.Assert): + # First two assertions are cardinality and positivity, discharged + # explicitly by the complete certificate inventory in verify.py. + if assertions >= 2: + terms = node.test.values if isinstance(node.test, ast.BoolOp) else [node.test] + if isinstance(node.test, ast.BoolOp): + require(isinstance(node.test.op, ast.And), 'unexpected assertion connective') + for term in terms: + require(isinstance(term, ast.Compare) and len(term.ops) == 1 and + isinstance(term.ops[0], ast.Eq), 'unexpected source identity') + gap = self.expression(term.left) - self.expression(term.comparators[0]) + self.identities[ast.unparse(term)] = gap + assertions += 1 + elif isinstance(node, ast.Return): + returns += 1 # Returned formatting does not add arithmetic obligations. + else: + raise ValueError('unsupported source statement: ' + type(node).__name__) + require(assertions == 5 and updates == 1 and returns == 1, 'source statement inventory') + require(len(self.env['slacks']) == 47 and len(self.env['margins']) == 7, + 'source row inventory') + require(len(self.branches) == 2 and len(self.identities) == 4 and + len(self.margin_gaps) == 7, 'source proof inventory') + + def assign(self, target, value): + if isinstance(target, ast.Name): + require(target.id not in self.env, 'reassigned source name') + self.env[target.id] = value + elif isinstance(target, ast.Tuple): + require(isinstance(value, tuple) and len(value) == len(target.elts), 'tuple binding') + for name, item in zip(target.elts, value): + self.assign(name, item) + else: + raise ValueError('unsupported assignment') + + def expression(self, node): + if isinstance(node, ast.Constant): + require(type(node.value) in (int, str), 'nonexact source literal') + return F(node.value) if type(node.value) is int else node.value + if isinstance(node, ast.Name): + require(node.id in self.env, 'unknown source name') + return self.env[node.id] + if isinstance(node, ast.Tuple): + return tuple(self.expression(n) for n in node.elts) + if isinstance(node, ast.Subscript): + return self.expression(node.value)[self.expression(node.slice)] + if isinstance(node, ast.BinOp): + x, y = self.expression(node.left), self.expression(node.right) + if isinstance(node.op, ast.Add): + return x + y + if isinstance(node.op, ast.Sub): + return x - y + if isinstance(node.op, ast.Mult): + return x * y + if isinstance(node.op, ast.Div): + return x / y + if isinstance(node, ast.DictComp): + require(len(node.generators) == 1, 'comprehension arity') + gen = node.generators[0] + require(not gen.ifs and not gen.is_async and isinstance(gen.target, ast.Tuple) + and len(gen.target.elts) == 2, 'comprehension shape') + names = [x.id for x in gen.target.elts] + require(not any(n in self.env for n in names), 'comprehension shadows source name') + result = {} + for pair in self.expression(gen.iter): + self.env.update(zip(names, pair)) + key, value = self.expression(node.key), self.expression(node.value) + require(key not in result, 'duplicate generated row') + result[key] = value + for name in names: + del self.env[name] + return result + if isinstance(node, ast.Call): + return self.call(node) + raise ValueError('unsupported source expression: ' + type(node).__name__) + + def call(self, node): + if isinstance(node.func, ast.Attribute): + obj = self.expression(node.func.value) + require(type(obj) is dict and not node.args and not node.keywords, + 'unexpected attribute call') + require(node.func.attr in ('items', 'values'), 'unexpected dictionary method') + return list(obj.items()) if node.func.attr == 'items' else list(obj.values()) + require(isinstance(node.func, ast.Name), 'unexpected callable') + name = node.func.id + if name == 'dict': + require(not node.args and all(k.arg is not None for k in node.keywords), + 'unexpected dictionary syntax') + result = {k.arg: self.expression(k.value) for k in node.keywords} + require(len(result) == len(node.keywords), 'duplicate dictionary key') + return result + require(not node.keywords, 'unexpected call keywords') + args = [self.expression(n) for n in node.args] + if name == 'Q': + require(len(args) in (1, 2), 'fraction arity') + return args[0] if len(args) == 1 else args[0] / args[1] + if name in ('min', 'max') and len(args) == 2: + x, y = args + # The certified ordering chooses the second branch in both source + # calls. Numeric witness execution also verifies that actual order. + gap = y - x if name == 'max' else x - y + self.branches[ast.unparse(node)] = gap + if not self.symbolic: + require(gap > 0, 'branch ordering fails') + return y + if name == 'min' and len(args) == 1: + require(args[0] == list(self.env['margins'].values()), 'unexpected minimum list') + minimum = self.env['minimum'] + self.margin_gaps = {key: value - minimum for key, value in self.env['margins'].items()} + if not self.symbolic: + require(min(args[0]) == minimum, 'minimum margin mismatch') + return minimum + raise ValueError('unsupported source call: ' + name) diff --git a/research/outer-bernstein-certificate/test_verify.py b/research/outer-bernstein-certificate/test_verify.py new file mode 100644 index 0000000000..1bc43abe18 --- /dev/null +++ b/research/outer-bernstein-certificate/test_verify.py @@ -0,0 +1,180 @@ +#!/usr/bin/env python3 +"""Mathematical and packaging failure tests for the outer certificate. + +Gareth Davidson / OpenAI Codex, Apache-2.0. +""" +from copy import deepcopy +from fractions import Fraction as F +from itertools import product +from math import comb +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import algebra as A +import verify as V + + +def casteljau(certificate, point): + """Evaluate the Bernstein tensor by repeated affine interpolation. + + Uses neither power expansion nor the primary Poly arithmetic. + The two unrestricted positive variables are combined as ordinary powers. + """ + degrees = certificate['degrees'] + values = dict(zip(product(*(range(d+1) for d in degrees)), + (F(c, certificate['scale']) for c in certificate['weights']))) + reduced = {} + for index, value in values.items(): + key = index[:5] + reduced[key] = reduced.get(key, F(0)) + value*point[5]**index[5]*point[6]**index[6] + for axis in range(4, -1, -1): + result = {} + for prefix in product(*(range(degrees[i]+1) for i in range(axis))): + column = [reduced[prefix+(j,)] for j in range(degrees[axis]+1)] + while len(column) > 1: + column = [(1-point[axis])*left+point[axis]*right + for left, right in zip(column, column[1:])] + result[prefix] = column[0] + reduced = result + return reduced[()] + + +class CertificateTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.source, cls.receipt, cls.pins = V.inputs() + cls.model, cls.rows = V.obligations(cls.source) + cls.expected = V.parse_json((HERE/'EXPECTED.json').read_bytes()) + + def test_all_rows_by_de_casteljau(self): + # Asymmetric rational points exercise every coefficient and the two + # unbounded bridge coordinates, including values far above one. + points = [(F(1, 7), F(2, 9), F(4, 5), F(3, 8), F(5, 11), F(17), F(101)), + (F(5, 6), F(7, 8), F(1, 13), F(12, 13), F(17, 19), F(1, 37), F(10**6))] + for name, (poly, strict) in self.rows.items(): + for point in points: + value = casteljau(self.expected['certificates'][name], point) + self.assertEqual(value, poly.evaluate(point), name) + self.assertTrue(value > 0 if strict else value == 0, name) + + def test_basis_reconstruction_with_closed_form(self): + # Check all 64 tensor basis monomials of a cubic by cubic by cubic + # example, with a nontrivial positive-power bridge coordinate. + degrees = [3, 3, 3, 0, 0, 1, 0] + keys = list(product(*(range(d+1) for d in degrees))) + for a, b, c in product(range(4), repeat=3): + index = (a, b, c, 0, 0, 1, 0) + weights = [int(k == index) for k in keys] + poly = A.reconstruct(dict(degrees=degrees, scale=7, weights=weights)) + point = (F(2, 7), F(3, 5), F(4, 9), F(1, 2), F(1, 3), F(11), F(13)) + target = F(11, 7) + for x, k in zip(point[:3], (a, b, c)): + target *= comb(3, k)*x**k*(1-x)**(3-k) + self.assertEqual(poly.evaluate(point), target) + + def test_positive_sample_does_not_prove_positivity(self): + x = A.Poly.variable(0) + p = 1-10*(x-F(1, 2))**2 + self.assertGreater(p.evaluate([F(1, 2)]*7), 0) + self.assertLess(p.evaluate([F(1, 100)]*7), 0) + with self.assertRaisesRegex(ValueError, 'negative'): + A.check_certificate(p, A.nominate(p)) + + def test_wrong_gaussian_cap_passes_selected_but_fails_domain(self): + source = self.source.replace('Q(1,4)-r', 'Q(1,8)-r') + model, rows = V.obligations(source) + name = 'slack:alpha_below_one_fourth' + poly = rows[name][0] + for witness in self.expected['witnesses'].values(): + point = tuple(map(F, witness['unit_coordinates']+witness['bridge_gaps'])) + self.assertGreater(poly.evaluate(point), 0) + point = (F(1, 4), F(1, 2), F(1, 2), F(9, 10), F(1, 10), F(1), F(2)) + self.assertLess(poly.evaluate(point), 0) + with self.assertRaisesRegex(ValueError, 'negative'): + A.check_certificate(poly, A.nominate(poly)) + + def test_zero_requires_nonstrict_obligation(self): + certificate = A.nominate(A.Poly(0)) + with self.assertRaisesRegex(ValueError, 'strict'): + A.check_certificate(A.Poly(0), certificate) + A.check_certificate(A.Poly(0), certificate, strict=False) + + def test_changed_denominator_rejected(self): + cert = self.expected['certificates']['denominator'] + with self.assertRaisesRegex(ValueError, 'differs'): + A.check_certificate(self.rows['denominator'][0]+1, cert) + + def test_strict_boundaries(self): + args = [F(1, 100), F(1, 50), F(1, 4), F(1, 10), F(1, 1000), F(1), F(2)] + V.admit(*args) + for index, value in ((0, F(0)), (0, (1-args[2])*args[1]), (4, F(0)), + (1, F(1, 32)), (3, F(1, 2)), (2, F(1))): + changed = list(args) + changed[index] = value + with self.assertRaises(ValueError): + V.admit(*changed) + + def test_closed_bootstrap_equals_recursive_cost(self): + # Independent comparisons across 72 ordinary-recursion parameter pairs + # and 12 depths, including small and large finite cutoffs. + for numerator in range(1, 9): + s = F(numerator, 10) + for denominator in range(2, 11): + initial = s/denominator + value = initial + for depth in range(1, 13): + value = s*(1-s)+s*value + self.assertEqual(value, s-s**depth*(s-initial)) + + def test_primary_mutation_controls(self): + labels = V.controls(self.source, self.expected['certificates'], self.model, self.receipt) + self.assertEqual(labels, self.expected['controls']) + self.assertEqual(len(set(labels)), 24) + + def test_unsupported_source_syntax_rejected(self): + for before, after in (('q=a*(1-2*eta)', 'q=a**(1-2*eta)'), + ('q=a*(1-2*eta)', 'q=a*(1-2.0*eta)')): + with self.assertRaises(ValueError): + V.obligations(self.source.replace(before, after)) + + def test_duplicate_json_rejected(self): + with self.assertRaisesRegex(ValueError, 'duplicate'): + V.parse_json('{"slack":1,"slack":2}') + + def test_source_integrity_and_relocated_optimized_replay(self): + with tempfile.TemporaryDirectory(prefix='outer proof with spaces ') as temp: + root = Path(temp) + package = root/HERE.relative_to(V.ROOT) + shutil.copytree(HERE, package, ignore=shutil.ignore_patterns('__pycache__')) + for path in V.FILES.values(): + destination = root/path + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(V.ROOT/path, destination) + command = [sys.executable, '-B', '-I', '-O', str(package/'verify.py')] + passed = subprocess.run(command, cwd='/tmp', capture_output=True, text=True) + self.assertEqual(passed.returncode, 0, passed.stderr) + self.assertIn('PASS_OUTER_BERNSTEIN_CERTIFICATE', passed.stdout) + expected_path = package/'EXPECTED.json' + original = expected_path.read_bytes() + corrupted = V.parse_json(original) + corrupted['certificates']['slack:bit_positive']['weights'][0] = 0.0 + expected_path.write_text(V.json.dumps(corrupted)) + bad_type = subprocess.run(command, cwd='/tmp', capture_output=True, text=True) + self.assertNotEqual(bad_type.returncode, 0) + self.assertIn('noninteger weight', bad_type.stderr) + expected_path.write_bytes(original) + source = root/V.FILES['engine'] + source.write_bytes(source.read_bytes()+b'\n# changed source\n') + failed = subprocess.run(command, cwd='/tmp', capture_output=True, text=True) + self.assertNotEqual(failed.returncode, 0) + self.assertIn('source hash: engine', failed.stderr) + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/research/outer-bernstein-certificate/verify.py b/research/outer-bernstein-certificate/verify.py new file mode 100644 index 0000000000..97dc2202e0 --- /dev/null +++ b/research/outer-bernstein-certificate/verify.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +"""Independently check all 47 retained outer inequalities by exact algebra. + +Gareth Davidson / OpenAI Codex, Apache-2.0. Arithmetic certificate only; +supplier, bridge construction and full multiplication assumptions are inherited. +""" +import argparse +from copy import deepcopy +from fractions import Fraction as F +from hashlib import sha256 +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(HERE)) +from algebra import (Poly, VARIABLES, check_certificate, nominate, require, + symbolic_inputs) +from source_model import Model + +BASE = '66849e1475c930fd7732b1a0067ffee7e1e95f60' +FILES = { + 'selected': 'certificates/selected-result.json', + 'inventory': 'research/community-k492-audit/SELECTED-SOURCE.json', + 'receipt': 'research/community-k492-audit/pr626/replay/ASSEMBLY.json', + 'engine': 'research/complex-k492-owner-repair/vendor/multicold/engines/outer.py', + 'builder': 'research/complex-k492-owner-repair/code/assemble.py', + 'review': 'docs/research/community-k492-review.md', +} + + +def unique_object(pairs): + result = {} + for key, value in pairs: + require(key not in result, 'duplicate JSON key: ' + key) + result[key] = value + return result + + +def parse_json(raw): + return json.loads(raw, object_pairs_hook=unique_object) + + +def inputs(root=ROOT): + pins = parse_json((HERE / 'SOURCES.json').read_bytes()) + require(pins['base_commit'] == BASE and set(pins['files']) == set(FILES.values()), + 'source inventory differs') + raw = {} + for role, path in FILES.items(): + value = (root / path).read_bytes() + require(sha256(value).hexdigest() == pins['files'][path], 'source hash: ' + role) + raw[role] = value + selected, inventory, receipt = (parse_json(raw[n]) for n in ('selected', 'inventory', 'receipt')) + require(selected['certificate'] == FILES['receipt'] and + selected['certificate_sha256'] == sha256(raw['receipt']).hexdigest(), + 'selected receipt binding') + require(selected['source_manifest'] == FILES['inventory'], 'selected inventory binding') + require(selected['audited_source_head'] == pins['selected_source_head'], 'selected head binding') + require(selected['kappa'] == receipt['kappa'], 'selected kappa binding') + for role in ('engine', 'builder'): + require(inventory['files'][FILES[role]] == sha256(raw[role]).hexdigest(), + 'selected source inventory binding: ' + role) + require(selected['proof_supplements'][FILES['review']] == sha256(raw['review']).hexdigest(), + 'selected review binding') + require(receipt['input_sha256']['engines/outer.py'] == sha256(raw['engine']).hexdigest(), + 'consumed outer-engine binding') + return raw['engine'].decode(), receipt, pins + + +def obligations(source): + environment, denominator = symbolic_inputs() + model = Model(source, environment) + rows = {'denominator': (denominator, True)} + for label, values in (('slack', model.env['slacks']), ('branch', model.branches), + ('margin', model.margin_gaps)): + for name, expression in values.items(): + poly = expression.cleared() + strict = not (label == 'margin' and name == 'compact_phase_layer') + rows[label + ':' + name] = (poly, strict) + require(len(rows) == 57, 'proof obligation inventory') + require(model.margin_gaps['compact_phase_layer'].cleared() == Poly(0), + 'minimum is not attained by compact phase') + for name, gap in model.identities.items(): + require(gap.cleared() == Poly(0), 'source identity fails: ' + name) + return model, rows + + +def check_proof(source, certificates): + model, rows = obligations(source) + require(set(certificates) == set(rows), 'incomplete or surplus proof rows') + for name, (poly, strict) in rows.items(): + check_certificate(poly, certificates[name], strict=strict) + return model, rows + + +def ceil(value): + return -(-value.numerator // value.denominator) + + +def admit(a, b, beta, eta, kappa, literal, row): + require(all(type(x) is F for x in (a, b, beta, eta, kappa, literal, row)), + 'parameters must be exact fractions') + require(0 < beta < 1 and 0 < eta < F(1, 2), 'backoff domain') + require(0 < a < (1 - beta) * b and 0 < b < F(1, 32), 'supplier domain') + require(literal > 0 and row > 0, 'bridge gaps') + q = a * (1 - 2 * eta) + gain = (1 - eta) * q / (1 + q) + require(0 < kappa < gain, 'strict target ceiling') + return (beta, 32 * b, a / ((1 - beta) * b), 2 * eta, kappa / gain, literal, row) + + +def witness(source, model, receipt, conservative=False): + prefix = 'conservative_' if conservative else '' + b = F(receipt[prefix + 'complex_lower']) + bit = F(receipt['bit_lower']) + eta = beta = F(1, 10**24) + s = min(bit, (1 - beta) * b) - F(1, 10**27) + initial = F(384599, 10**10) + require(0 < initial < s < bit and s < (1 - beta) * b, 'bootstrap premise') + chain = [] + previous = initial + for depth in range(1, 8): + # Closed form, independently of the producer's recursive updates. + a = s - s**depth * (s - initial) + require(previous < a < s < 1 - a, 'bootstrap order') + gap = min(s - a, 1 - a - s, 1 - a - s * (1 - previous), 1 - s) + require(gap > 0, 'bootstrap gap') + cut = max(ceil(36 / gap**2), ceil(F(1032) / gap)) + require(cut * gap**2 >= 36 and cut * gap >= 1032, 'bootstrap cutoff') + chain.append(dict(exponent=str(a), gap=str(gap), cutoff_log2=str(cut))) + previous = a + require(chain == receipt[prefix + 'bootstrap'], 'bootstrap receipt differs') + q = a * (1 - 2 * eta) + gain = (1 - eta) * q / (1 + q) + kappa = F(ceil(gain * 10**18) - 1, 10**18) + require(kappa == F(receipt[prefix + 'kappa']), 'strict grid witness differs') + require(kappa < gain <= kappa + F(1, 10**18), 'grid maximality') + literal, row = F(1), F(10**6) - F(51 * 20161, 25) + point = admit(a, b, beta, eta, kappa, literal, row) + numeric = Model(source, dict(bit_saving=a, complex_saving=b, beta=beta, + eta=eta, kappa=kappa, bridge={'semantic': {'strict_literal_gap': literal}, + 'rows': {'degree_gap': row}})) + saved = {name: F(value) for name, value in receipt[prefix + 'outer'].items()} + direct = numeric.env['slacks'] + require(direct == saved, 'numeric source expressions differ from complete receipt') + values = {name: expr.evaluate(point) for name, expr in model.env['slacks'].items()} + require(values == direct and all(v > 0 for v in values.values()), 'polynomial witness differs') + require(all(value == 0 for value in numeric.identities.values()), 'numeric identities') + return dict(kappa=str(kappa), gain=str(gain), grid_successor_rejected=True, + unit_coordinates=[str(x) for x in point[:5]], + bridge_gaps=[str(literal), str(row)], bootstrap=chain, + slacks={name: str(value) for name, value in values.items()}) + + +def rejected(action, label): + try: + action() + except ValueError: + return label + raise ValueError('control unexpectedly accepted: ' + label) + + +def controls(source, certificates, model, receipt): + labels = [] + name = 'slack:compact_phase_layer_above_kappa' + poly = model.env['slacks']['compact_phase_layer_above_kappa'].cleared() + for label, change in ( + ('negative_weight', lambda c: c['weights'].__setitem__(0, -1)), + ('no_positive_weight', lambda c: c.update(weights=[0] * len(c['weights']))), + ('changed_positive_weight', lambda c: c['weights'].__setitem__(0, c['weights'][0] + 1)), + ('missing_weight', lambda c: c['weights'].pop()), + ('negative_scale', lambda c: c.update(scale=-c['scale'])), + ('floating_weight', lambda c: c['weights'].__setitem__(0, 0.0)), + ): + cert = deepcopy(certificates[name]) + change(cert) + labels.append(rejected(lambda: check_certificate(poly, cert), label)) + missing = dict(certificates) + del missing[name] + labels.append(rejected(lambda: check_proof(source, missing), 'missing_source_row')) + surplus = dict(certificates, unexpected=certificates[name]) + labels.append(rejected(lambda: check_proof(source, surplus), 'surplus_source_row')) + for label, before, after in ( + ('wrong_max_branch', 'max(sigma-tau,Q(0))', 'max(tau-sigma,Q(0))'), + ('wrong_min_branch', 'min(1-eps-delta,r-delta)', 'min(r-delta,1-eps-delta)'), + ('missing_target_charge', 'val-kappa', 'val'), + ('changed_gaussian_cap', 'Q(1,4)-r', 'Q(1,8)-r'), + ): + require(source.count(before) == 1, 'mutation anchor') + mutant = source.replace(before, after) + labels.append(rejected(lambda: check_proof(mutant, certificates), label)) + for label, edit in ( + ('altered_outer_receipt', lambda r: r['outer'].update(bit_positive='1')), + ('altered_bootstrap_cutoff', lambda r: r['bootstrap'][0].update(cutoff_log2='1')), + ): + mutant = deepcopy(receipt) + edit(mutant) + labels.append(rejected(lambda: witness(source, model, mutant), label)) + args = [F(1, 100), F(1, 50), F(1, 4), F(1, 10), F(1, 1000), F(1), F(2)] + a, b, beta, eta, _, literal, row = args + q = a * (1 - 2 * eta) + gain = (1 - eta) * q / (1 + q) + for label, index, value in ( + ('target_at_ceiling', 4, gain), ('target_above_ceiling', 4, gain + F(1, 10**12)), + ('zero_backoff', 3, F(0)), ('half_backoff', 3, F(1, 2)), + ('zero_beta', 2, F(0)), ('unit_beta', 2, F(1)), + ('cap_equality', 1, F(1, 32)), ('zero_literal_gap', 5, F(0)), + ('zero_row_gap', 6, F(0)), ('nonexact_parameter', 0, 0.01), + ): + altered = list(args) + altered[index] = value + labels.append(rejected(lambda: admit(*altered), label)) + return labels + + +def compute(root=ROOT, expected_certificates=None): + source, receipt, pins = inputs(root) + model, rows = obligations(source) + certificates = {name: nominate(poly) for name, (poly, _) in rows.items()} + check_proof(source, certificates if expected_certificates is None else expected_certificates) + witnesses = {name: witness(source, model, receipt, conservative) + for name, conservative in (('native', False), ('conservative', True))} + rejected_controls = controls(source, certificates, model, receipt) + return dict(format='outer-bernstein-certificate-v1', base_commit=BASE, + source_hashes=pins['files'], variables=list(VARIABLES), + certificates=certificates, + identities={name: '0' for name in model.identities}, + witnesses=witnesses, controls=rejected_controls, + counts=dict(slacks=47, witnesses=2, coefficient_rows=len(certificates), + weights=sum(len(c['weights']) for c in certificates.values()), + controls=len(rejected_controls))) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', type=Path, help='write a new certificate; never overwrite') + args = parser.parse_args() + if args.write: + require(not args.write.exists(), 'output already exists') + expected = None if args.write else parse_json((HERE / 'EXPECTED.json').read_bytes()) + report = compute(expected_certificates=None if expected is None else expected['certificates']) + if args.write: + with args.write.open('x') as out: + out.write(json.dumps(report, indent=2, sort_keys=True) + '\n') + else: + # Preserve JSON numeric types: Python otherwise equates 0, 0.0 and False. + require(json.dumps(expected, sort_keys=True) == json.dumps(report, sort_keys=True), + 'committed certificate differs') + counts = report['counts'] + print('PASS_OUTER_BERNSTEIN_CERTIFICATE ' + f"slacks=47 witnesses=2 coefficient_rows={counts['coefficient_rows']} " + f"weights={counts['weights']} controls={counts['controls']} kappa=unchanged") + + +if __name__ == '__main__': + main() From 5d3b961fca28c77cec74f5237a59acd361c8e851 Mon Sep 17 00:00:00 2001 From: Gareth Davidson Date: Tue, 13 Oct 2026 07:17:31 +0100 Subject: [PATCH 2/2] Record seed-79 result and PR link --- research/outer-bernstein-certificate/CLAIM.json | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/research/outer-bernstein-certificate/CLAIM.json b/research/outer-bernstein-certificate/CLAIM.json index 154cca9727..55912d0eba 100644 --- a/research/outer-bernstein-certificate/CLAIM.json +++ b/research/outer-bernstein-certificate/CLAIM.json @@ -27,7 +27,7 @@ 766 ] }, - "status": "completed; prepared for one focused PR", + "status": "completed; submitted as one focused PR", "attribution": "Prepared for Gareth Davidson (@bitplane) with substantial OpenAI Codex assistance; Apache-2.0", "completed_at_utc": "2026-10-13T06:08:19Z", "result": "README.md", @@ -35,5 +35,8 @@ "result_summary": "All 47 admitted outer inequalities receive exact positive Bernstein certificates; 57 polynomial records, 2586 coefficients and all 94 selected native/conservative slacks verified. No new kappa.", "overlap_refresh_through": 810, "validation": "24 built-in controls, 12 tests, independent SymPy coefficient replay, Python 3.12/3.14, optimized/isolated/relocated/no-site replay and selected-record integrity pass.", - "scope_note": "The closed-form ceiling and written reduction are credited to PR183; the contribution is independent complete coefficient evidence and exact selected-instance binding." + "scope_note": "The closed-form ceiling and written reduction are credited to PR183; the contribution is independent complete coefficient evidence and exact selected-instance binding.", + "submission_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/813", + "validated_code_commit": "71ba81c628ec1d80383f131b0735b18f34d254cf", + "publication_check": "PR813 is open, non-draft, against main; only this ten-file package is added. A committed minimal export passed the main verifier, all 12 tests and the independent SymPy replay. The immediate queue check also inspected distinct PR811." }