#!/usr/bin/env python3 """Finite certificates for strengthened hyperfield aggregation theorems. Exact rational, exact algebraic, formal-polynomial, and numerical checks are distinguished in the output. These computations supplement the written proofs; they do not establish any universal assertion by numerical extrapolation. Requires Python 3 and mpmath 1.3.0 for the explicitly numerical checks. """ from __future__ import annotations import argparse from collections import Counter from fractions import Fraction as Q from functools import lru_cache from itertools import combinations, combinations_with_replacement, product import json from math import isqrt from pathlib import Path import random def rational_string(x): x = Q(x) return str(x.numerator) if x.denominator == 1 else f"{x.numerator}/{x.denominator}" def multiply(a, b): return [[sum(a[i][k] * b[k][j] for k in range(len(b))) for j in range(len(b[0]))] for i in range(len(a))] def transpose(a): return [list(row) for row in zip(*a)] def congruence(a, l): return multiply(transpose(l), multiply(a, l)) def matrix_equal(a, b): return a == b def products_for_quartet(a, quartet): i, j, k, l = quartet return [a[i][j] * a[k][l], a[i][k] * a[j][l], a[i][l] * a[j][k]] def all_matrix_quartets(a): for quartet in combinations_with_replacement(range(len(a)), 4): yield quartet, products_for_quartet(a, quartet) def check_matrix_exact(a, parameter): assert parameter in (1, 2) count = 0 smallest = None for quartet, terms in all_matrix_quartets(a): if parameter == 1: margin = sum(terms) - 2 * max(terms) else: x, y, z = terms margin = 2 * (x*y + x*z + y*z) - x*x - y*y - z*z assert margin >= 0, (parameter, quartet, terms, margin) smallest = margin if smallest is None else min(smallest, margin) count += 1 return dict(quartet_count=count, minimum_exact_polynomial_margin=rational_string(smallest)) def determinant_magnitudes(columns): return [[abs(u[0]*v[1] - u[1]*v[0]) for v in columns] for u in columns] def rational_matrices(): rng = random.Random(186741) cases = [] sources = [ [(1, 0), (0, 1), (1, 1), (1, -1), (0, 0), (1, 0)], [(1, 0), (0, 1), (2, 1), (3, 2), (-2, 3), (1, 0)], [(0, 0), (1, 2), (2, 4), (1, -1), (3, 1), (0, 1)], ] for trial in range(8): columns = sources[trial % len(sources)] l1 = [[Q(rng.choice([0, 0, 1, 2, 3]), rng.choice([1, 2, 3])) for _ in range(4)] for _ in range(6)] l2 = [[Q(rng.choice([0, 1, 2, 3]), rng.choice([1, 2])) for _ in range(3)] for _ in range(4)] if trial == 0: for row in l1: row[-1] = Q(0) cases.append((columns, l1, l2)) return cases def exact_congruence_checks(cases): out = [] for trial, (columns, l1, l2) in enumerate(cases, 1): minors = determinant_magnitudes(columns) for q in (1, 2): a = [[Q(x)**q for x in row] for row in minors] source = check_matrix_exact(a, q) h1 = congruence(a, l1) h2 = congruence(h1, l2) direct = congruence(a, multiply(l1, l2)) assert matrix_equal(h2, direct) assert all(x >= 0 for row in h2 for x in row) out.append(dict(trial=trial, input_parameter=q, source_check=source, first_substitution=check_matrix_exact(h1, q), composed_substitution=check_matrix_exact(h2, q), nonzero_diagonal_after_first=sum(h1[i][i] > 0 for i in range(4)), exact_composition_identity=True, arithmetic="exact rational")) return out def polynomial_add(a, b): out = Counter(a) out.update(b) return {k: v for k, v in out.items() if v} def polynomial_multiply(a, b): out = Counter() for m, c in a.items(): for n, d in b.items(): out[tuple(sorted(m+n))] += c*d return dict(out) def formal_tensor_factorizations(): n = 3 def asym(i, j): return "A" + str(min(i, j)) + str(max(i, j)) def entry(a, b): out = Counter() for i, j in product(range(n), repeat=2): out[tuple(sorted((asym(i, j), f"L{i}{a}", f"L{j}{b}")))] += 1 return dict(out) pairings = [((0, 1), (2, 3)), ((0, 2), (1, 3)), ((0, 3), (1, 2))] out = [] for pairing in pairings: (a, b), (c, d) = pairing lhs = polynomial_multiply(entry(a, b), entry(c, d)) rhs = Counter() for indices in product(range(n), repeat=4): i, j, k, l = indices rhs[tuple(sorted((asym(indices[a], indices[b]), asym(indices[c], indices[d]), f"L{i}0", f"L{j}1", f"L{k}2", f"L{l}3")))] += 1 assert lhs == dict(rhs) out.append(dict(pairing=pairing, expanded_monomials=len(lhs), total_summands=sum(lhs.values()), status="identity verified")) return dict(arithmetic="exact commutative polynomial identities", source_indices=n, target_indices=4, factorizations=out) def numerical_congruence_checks(cases): import mpmath as mp mp.mp.dps = 90 def m(x): x = Q(x) return mp.mpf(x.numerator) / x.denominator samples = ["0.25", "0.5", "1", "1.5", "2", "3", "4", "8"] out = [] for trial, (columns, l1, l2) in enumerate(cases, 1): minors = determinant_magnitudes(columns) ml1 = [[m(x) for x in row] for row in l1] ml2 = [[m(x) for x in row] for row in l2] for qs in samples: q = mp.mpf(qs) p = max(q, mp.mpf(1)) a = [[m(x)**q for x in row] for row in minors] h1 = congruence(a, ml1) h2 = congruence(h1, ml2) hd = congruence(a, multiply(ml1, ml2)) for row1, row2 in zip(h2, hd): for x, y in zip(row1, row2): assert abs(x-y) <= mp.mpf("1e-78") * max(abs(x), abs(y), 1) for stage, h in (("first", h1), ("composed", h2)): count = 0 smallest = mp.mpf(1) for quartet, terms in all_matrix_quartets(h): roots = [x**(1/p) for x in terms] scale = max(roots) rel = mp.mpf(0) if not scale else (sum(roots)-2*scale)/scale assert rel >= -mp.mpf("1e-76"), (trial, qs, stage, quartet, rel) smallest = min(smallest, rel) count += 1 out.append(dict(trial=trial, input_parameter=qs, output_parameter=mp.nstr(p, 15), stage=stage, quartet_count=count, minimum_relative_root_polygon_slack=mp.nstr(smallest, 30), precision_decimal_digits=90, arithmetic="high-precision numerical; not an exact certificate")) return out def minimal_threshold_certificate(): columns = [(1, 0), (0, 1), (1, 64), (64, -1)] mm = determinant_magnitudes(columns) input_lengths = [mm[0][1]*mm[2][3], mm[0][2]*mm[1][3], mm[0][3]*mm[1][2]] assert input_lengths == [4097, 4096, 1] assert sum(input_lengths)-2*max(input_lengths) == 0 assert mm[0][2] == mm[1][3] == 64 assert mm[0][3] == mm[1][2] == 1 output_root_lengths = [4*4097, 81**2, 81**2] defect = max(output_root_lengths) - sum(output_root_lengths[1:]) assert output_root_lengths == [16388, 6561, 6561] assert defect == 3266 return dict(input_parameter="1/2", columns=columns, input_root_product_lengths=input_lengths, normalized_output_products=["2*sqrt(4097)", "81", "81"], output_root_product_lengths=output_root_lengths, exact_output_root_defect=defect, input_support="U_(2,4); all six minors nonzero", arithmetic="exact integers and stated algebraic square roots") def strong_relation_products(coeff, d, n): for raw_i in combinations(range(n), d-1): i = frozenset(raw_i) for raw_j in combinations(range(n), d+1): j = frozenset(raw_j) yield i, j, [coeff[i | {a}]*coeff[j - {a}] for a in sorted(j-i)] def weak_relation_products(coeff, d, n): for cc in combinations(range(n), d-2): c = frozenset(cc) for i, j, k, l in combinations(sorted(set(range(n))-c), 4): yield c, (i, j, k, l), [coeff[c | {i, j}]*coeff[c | {k, l}], coeff[c | {i, k}]*coeff[c | {j, l}], coeff[c | {i, l}]*coeff[c | {j, k}]] def two_peak_coefficients(d, n, peak1, peak2, default): c = set(range(6, d+3)) u, v = frozenset(c | {0, 2, 4}), frozenset(c | {1, 3, 5}) coeff = {frozenset(s): Q(default) for s in combinations(range(n), d)} coeff[u], coeff[v] = Q(peak1), Q(peak2) return coeff, c def two_peak_weak_checks(): out = [] for d, n in ((3, 6), (4, 7), (5, 8), (4, 8)): coeff, _ = two_peak_coefficients(d, n, 2, 2, 1) count = 0 types = Counter() for _, _, terms in weak_relation_products(coeff, d, n): assert sum(terms)-2*max(terms) >= 0 types[tuple(sorted(terms))] += 1 count += 1 strong_failures = 0 for _, _, terms in strong_relation_products(coeff, d, n): strong_failures += sum(terms)-2*max(terms) < 0 assert strong_failures > 0 out.append(dict(rank=d, ground_size=n, weak_relations=count, root_product_patterns={str(tuple(rational_string(t) for t in k)): v for k, v in types.items()}, failed_strong_relations=strong_failures, arithmetic="exact rational root products")) return dict(instances=out, universal_output_products=["(1+2^q)^2", "4", "4"], necessary_output_parameter="p >= 2*log_2((1+2^q)/2)", qualification="The universal formula requires the written symbolic proof.") @lru_cache(maxsize=None) def sqrt_interval(x, digits=80): x = Q(x) scale = 10**digits k = isqrt((x.numerator*scale*scale)//x.denominator) lo = Q(k, scale) hi = lo if lo*lo == x else Q(k+1, scale) assert lo*lo <= x <= hi*hi return lo, hi def two_peak_strong_checks(): out = [] for d, n in ((3, 6), (4, 7), (5, 8), (4, 8), (5, 9)): roots, _ = two_peak_coefficients(d, n, 2, Q(3, 2), 1) weak_count = genuine_count = taut_count = 0 root_patterns = Counter() for _, _, terms in strong_relation_products(roots, d, n): assert sum(terms)-2*max(terms) >= 0 root_patterns[tuple(sorted(terms))] += 1 if len(terms) == 2: taut_count += 1 else: genuine_count += 1 for _, _, terms in weak_relation_products(roots, d, n): assert sum(terms)-2*max(terms) >= 0 weak_count += 1 integer, c = two_peak_coefficients(d, n, 23, 14, 6) smallest = None strict_count = 0 for i, j, terms in strong_relation_products(integer, d, n): if len(terms) == 2: assert terms[0] == terms[1] continue largest = max(range(len(terms)), key=terms.__getitem__) intervals = [sqrt_interval(t) for t in terms] certified_margin = sum(lo for k, (lo, hi) in enumerate(intervals) if k != largest) - intervals[largest][1] assert certified_margin > 0, (d, n, i, j, terms) smallest = certified_margin if smallest is None else min(smallest, certified_margin) strict_count += 1 g = {str(i+1)+str(j+1): integer[frozenset(c | {i, j, 4})] + integer[frozenset(c | {i, j, 5})] for i, j in combinations(range(4), 2)} assert g["13"] == 29 and g["24"] == 20 assert all(g[t] == 12 for t in ("12", "14", "23", "34")) products_out = [g["13"]*g["24"], g["12"]*g["34"], g["14"]*g["23"]] assert products_out == [580, 144, 144] squared_excess = products_out[0] - 24**2 assert squared_excess == 4 out.append(dict(rank=d, ground_size=n, weak_relation_count=weak_count, strong_genuine_relation_count=genuine_count, strong_tautological_relation_count=taut_count, strong_root_peak_values=["2", "3/2"], strict_integer_coefficient_values=[6, 14, 23], strict_integer_input_relations_certified=strict_count, exact_minimum_root_margin_lower_bound=rational_string(smallest), output_coefficients={k: rational_string(v) for k, v in g.items()}, output_products=[int(x) for x in products_out], exact_squared_output_excess=int(squared_excess), arithmetic="exact rational root products and rational square-root intervals")) return dict(instances=out, universal_two_peak_output_products=["(1+2^q)*(1+(3/2)^q)", "4", "4"], necessary_output_parameter="p >= log_2(((1+2^q)*(1+(3/2)^q))/4)", exact_boundary_q2_output_products=["65/4", "4", "4"], boundary_q2_necessary_output_parameter="p >= log_2(65/16) > 2", qualification="Universal validity requires the written all-rank proof.") def source_size_relation_counts(): out = [] for d in range(2, 7): for corank in (0, 1, 2, 3): n = d+corank counts = Counter() for i in combinations(range(n), d-1): for j in combinations(range(n), d+1): counts[len(set(j)-set(i))] += 1 largest = max(counts, default=0) assert largest <= corank+1 if corank <= 1: assert largest <= 2 if corank <= 2: assert largest <= 3 out.append(dict(rank=d, ground_size=n, corank=corank, strong_term_counts=dict(sorted(counts.items())), maximum_summands=largest)) return dict(arithmetic="exact finite combinatorial enumeration", instances=out) def main(): parser = argparse.ArgumentParser() parser.add_argument("--output", type=Path, default=Path(__file__).with_name("strengthened_verification_results.json")) args = parser.parse_args() cases = rational_matrices() result = dict( title="Strengthened aggregation reproducibility certificates", scope="Finite checks supplement the self-contained mathematical proofs.", exact_quadratic_congruence=exact_congruence_checks(cases), formal_tensor_factorizations=formal_tensor_factorizations(), numerical_quadratic_congruence=numerical_congruence_checks(cases), exact_minimal_threshold=minimal_threshold_certificate(), exact_two_peak_weak=two_peak_weak_checks(), exact_two_peak_strong=two_peak_strong_checks(), exact_corank_relation_counts=source_size_relation_counts(), ) args.output.parent.mkdir(parents=True, exist_ok=True) args.output.write_text(json.dumps(result, indent=2)+"\n") print(json.dumps(dict(output=str(args.output.resolve()), exact_congruence_instances=len(result["exact_quadratic_congruence"]), numerical_congruence_instances=len(result["numerical_quadratic_congruence"]), weak_two_peak_instances=len(result["exact_two_peak_weak"]["instances"]), strong_two_peak_instances=len(result["exact_two_peak_strong"]["instances"]), status="all checks passed"), indent=2)) if __name__ == "__main__": main()