Ilyoxune-Sharp-Hyperfield-Aggregation / code /verify_strong_parameter_bound.py
PureOne's picture
Upload Ilyoxune standalone research dataset and reproducibility certificates
ea14529 verified
Raw History Blame Contribute Delete
6.48 kB
#!/usr/bin/env python3
"""Exact strong T_2 inputs whose merge fails T_(20/9).
Only standard-library rational arithmetic is used. The universal all-rank
extension is a written theorem; this executable certifies the rank-three
integer witnesses and all 225 indexed strong input relations.
"""
from fractions import Fraction
from itertools import combinations
from math import isqrt
from pathlib import Path
import json
def rational(value):
value = Fraction(value)
return {"numerator": value.numerator, "denominator": value.denominator}
def sqrt_interval(value, digits=80):
"""Rational endpoints proved to contain sqrt(value) by squaring."""
value = Fraction(value)
scale = 10 ** digits
integer = isqrt(value.numerator * scale * scale // value.denominator)
lower = Fraction(integer, scale)
upper = lower if lower * lower == value else Fraction(integer + 1, scale)
assert lower * lower <= value <= upper * upper
return lower, upper
def certify(scale, small_coefficient):
coefficients = {}
for subset in combinations(range(1, 7), 3):
key = frozenset(subset)
if key == frozenset((1, 3, 5)):
value = 4 * scale - 1
elif key in (frozenset((1, 2, 6)), frozenset((3, 4, 6))):
value = small_coefficient
elif 6 in key:
value = 5 * scale
else:
value = scale
coefficients[key] = value
strict_count = tautological_count = 0
minimum_slack_bound = None
relation_certificates = []
for I_tuple in combinations(range(1, 7), 2):
I = frozenset(I_tuple)
for J_tuple in combinations(range(1, 7), 4):
J = frozenset(J_tuple)
values = [coefficients[I | {j}] * coefficients[J - {j}]
for j in sorted(J - I)]
if len(values) == 2:
assert values[0] == values[1]
tautological_count += 1
else:
index = max(range(len(values)), key=values.__getitem__)
intervals = [sqrt_interval(value) for value in values]
lower_slack = sum(intervals[j][0] for j in range(len(values))
if j != index) - intervals[index][1]
assert lower_slack > 0
strict_count += 1
if minimum_slack_bound is None or lower_slack < minimum_slack_bound:
minimum_slack_bound = lower_slack
relation_certificates.append({
"I": list(I_tuple), "J": list(J_tuple),
"products": values,
"exact_root_intervals": [[rational(lo), rational(hi)]
for lo, hi in intervals],
"positive_polygon_slack_lower_bound": rational(lower_slack),
})
assert strict_count == 135 and tautological_count == 90
merged = {}
for i, j in combinations(range(1, 5), 2):
merged[f"{i}{j}"] = (coefficients[frozenset((i, j, 5))]
+ coefficients[frozenset((i, j, 6))])
A = Fraction(merged["13"] * merged["24"], scale ** 2)
B = Fraction(merged["14"] * merged["23"], scale ** 2)
C = Fraction(merged["12"] * merged["34"], scale ** 2)
left_lower = Fraction(6019, 1000)
first_right_upper = Fraction(5016, 1000)
second_right_upper = Fraction(1001, 1000)
# Since 1/(20/9)=9/20, each interval claim becomes an integer-power
# comparison after raising to the positive twentieth power.
differences = [A ** 9 - left_lower ** 20,
first_right_upper ** 20 - B ** 9,
second_right_upper ** 20 - C ** 9]
assert all(difference > 0 for difference in differences)
output_defect_bound = left_lower - first_right_upper - second_right_upper
assert output_defect_bound == Fraction(1, 500)
# The baseline has peak r<4 and small coefficient epsilon<=1/4;
# diagonal weight 5 on element 6 and global scale N give this array.
peak = Fraction(4 * scale - 1, scale)
epsilon = Fraction(small_coefficient, 5 * scale)
assert 1 < peak < 4 and 0 < epsilon <= Fraction(1, 4)
assert peak * epsilon <= 1
return {
"arithmetic": "exact rational arithmetic and certified rational root intervals",
"input_parameter": rational(2),
"failed_output_parameter": rational(Fraction(20, 9)),
"global_coefficient_scale": scale,
"element6_coefficient_weight": 5,
"baseline_peak": rational(peak),
"baseline_small_coefficient": rational(epsilon),
"input_coefficients": {"".join(map(str, sorted(k))): v
for k, v in coefficients.items()},
"strict_input_relations": strict_count,
"tautological_input_relations": tautological_count,
"minimum_input_root_polygon_slack_lower_bound": rational(minimum_slack_bound),
"input_relation_certificates": relation_certificates,
"merged_coefficients": merged,
"normalized_output_products": {"A": rational(A), "B": rational(B),
"C": rational(C)},
"root_exponent": rational(Fraction(9, 20)),
"left_root_lower_bound": rational(left_lower),
"first_right_root_upper_bound": rational(first_right_upper),
"second_right_root_upper_bound": rational(second_right_upper),
"positive_twentieth_power_comparison_differences": [rational(d)
for d in differences],
"normalized_output_defect_strictly_greater_than": rational(output_defect_bound),
"status": "all certificates passed",
}
def main():
results = {
"theorem_consequence": "The universal strong-input repair at q=2 is strictly greater than 20/9.",
"qualification": "The strict inequality for the universal infimum follows by continuity in the output parameter, using this fixed strict witness.",
"witnesses": [certify(100000, 5), certify(1000, 1)],
}
output = Path(__file__).with_name("strong_parameter_bound_results.json")
output.write_text(json.dumps(results, indent=2) + "\n")
print(json.dumps({"output": str(output.resolve()), "witnesses": 2,
"indexed_input_relations_per_witness": 225,
"arithmetic": "exact only", "status": "all checks passed"},
indent=2))
if __name__ == "__main__":
main()