Datasets:
Formats:
json
Languages:
English
Size:
< 1K
ArXiv:
Tags:
mathematics
matroid-theory
hyperfields
lorentzian-polynomials
symbolic-mathematics
reproducibility
Download code/verify_strengthened_aggregation.py from PureOne/Ilyoxune-Sharp-Hyperfield-Aggregation: direct link, hf CLI and curl.
- Browser
- Download file 16.3 kB
-
https://huggingface.co/datasets/PureOne/Ilyoxune-Sharp-Hyperfield-Aggregation/resolve/main/code/verify_strengthened_aggregation.py
- Command line
-
hf download hf://datasets/PureOne/Ilyoxune-Sharp-Hyperfield-Aggregation/code/verify_strengthened_aggregation.py
-
curl -L -o verify_strengthened_aggregation.py https://huggingface.co/datasets/PureOne/Ilyoxune-Sharp-Hyperfield-Aggregation/resolve/main/code/verify_strengthened_aggregation.py
16.3 kB
| #!/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.") | |
| 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() | |