| """Independent arithmetic-engine tests and high-precision scalar diagnostics. |
| |
| The lower-bound proof is analytic. Its strict numeric hypotheses are checked |
| by certify_disk_bound.py with exact rational interval arithmetic. This file |
| tests that engine's square-root enclosures directly against exact rational |
| squares and evaluates the final formulas independently with Decimal at two |
| precisions. Decimal evaluations are diagnostics, not the proof certificate. |
| """ |
|
|
| from decimal import Decimal as D, localcontext |
| from fractions import Fraction |
| from pathlib import Path |
| import json |
| import random |
|
|
| from certify_disk_bound import I |
|
|
|
|
| def engine_checks(): |
| rng = random.Random(319843) |
| count = 0 |
| for digits in (20, 80, 120): |
| for _ in range(100): |
| q = Fraction(rng.randrange(0, 10**18), rng.randrange(1, 10**12)) |
| enclosure = I(q).sqrt(digits) |
| assert enclosure.lo**2 <= q <= enclosure.hi**2 |
| assert enclosure.hi - enclosure.lo <= Fraction(1, 10**digits) |
| count += 1 |
| for q in (Fraction(0), Fraction(1), Fraction(4), Fraction(9, 4), |
| Fraction(1, 10**100)): |
| enclosure = I(q).sqrt(120) |
| assert enclosure.lo**2 <= q <= enclosure.hi**2 |
| count += 1 |
| try: |
| I(-1).sqrt() |
| except AssertionError: |
| pass |
| else: |
| raise AssertionError("negative radical was accepted") |
| try: |
| I(1) / I(-1, 1) |
| except AssertionError: |
| pass |
| else: |
| raise AssertionError("division through zero was accepted") |
| return count |
|
|
|
|
| def scalar_diagnostics(precision): |
| with localcontext() as context: |
| context.prec = precision |
| r, t, delta = D('.00004057804'), D('.9661517984'), D('2.6864358e-6') |
| a = 1 + r |
| sqrt2 = D(2).sqrt() |
| S, C = (2 - sqrt2).sqrt() / 2, (2 + sqrt2).sqrt() / 2 |
| w = (a*a - t*t).sqrt() |
| eta0 = (1 - t) / 2 |
| omega = ((a**4 - t*t).sqrt() + w) / (a*a - 1) |
| A, B = 2*(t*S - w*C), 2*(t*C + w*S) |
| D_neighbor = sqrt2*(t + w) |
| denominator = A*A + (eta0+B)**2 |
| q0 = eta0*eta0*A*A / (4*a*denominator) |
| derivative = A*A*eta0*(A*A+B*B+B*eta0)/(2*a*denominator**2) |
| def q(value): |
| return value*value*A*A/(4*a*(A*A+(value+B)**2)) |
| def qp(value): |
| return A*A*value*(A*A+B*B+B*value)/(2*a*(A*A+(value+B)**2)**2) |
| maximum_flow = 2*eta0 |
| reward = q(4*eta0/3)+q(2*eta0/3) |
| reward_derivative = 4*qp(4*eta0/3)/3+2*qp(2*eta0/3)/3 |
| values = { |
| "packing_reward_contradiction_margin": reward-delta, |
| "additive_monotonicity_slack": 1-omega*reward_derivative/2, |
| "final_eta_positive_for_W_at_most_delta": eta0-omega*delta/2, |
| "eta_positive_at_certified_initial_reward": eta0-omega*reward/2, |
| "neighbor_branch_dominates_on_whole_eta_interval": |
| 2*a*(A*A+B*B)-D_neighbor*(A*A+(sqrt2*maximum_flow+B)**2), |
| "opposed_second_derivative_positive_on_whole_eta_interval": |
| (A*A+B*B)**2-3*(A*A+B*B)*maximum_flow**2-2*B*maximum_flow**3, |
| "opposed_localized_projection_slack": 1-t*S-w*C, |
| "neighbor_localized_projection_slack": 1-t*C-w*S, |
| "near_coefficient_dominates_far": omega-sqrt2/(1-1/(sqrt2*t)), |
| } |
| assert min(values.values()) > 0 |
| return {"precision": precision, |
| "positive_values": {key: str(value) for key, value in values.items()}, |
| "certified_initial_packing_reward": str(reward)} |
|
|
|
|
| def main(): |
| root = Path(__file__).parent |
| certificate = json.loads((root / 'DISK_BOUND_CERTIFICATE.json').read_text()) |
| assert certificate['status'] == 'PASS' |
| count = engine_checks() |
| records = [scalar_diagnostics(80), scalar_diagnostics(120)] |
| |
| |
| |
| with localcontext() as context: |
| context.prec = 130 |
| for record in records: |
| for key, scalar in record['positive_values'].items(): |
| lo, hi = map(D, certificate['positive_intervals'][key]) |
| value = D(scalar) |
| tolerance = max(D('1e-80'), abs(value)*D('1e-43')) |
| assert lo-tolerance <= value <= hi+tolerance, key |
| output = { |
| "status": "PASS", |
| "scope": "Arithmetic-engine validation and independent high-precision scalar diagnostics of the complete disk-bound certificate.", |
| "summary": {"all_assertions_passed": True, "exact_sqrt_enclosure_cases": count, |
| "decimal_precisions": [80, 120], |
| "negative_radical_rejected": True, |
| "division_through_zero_rejected": True, |
| "all_final_scalar_margins_positive": True}, |
| "diagnostics": records} |
| (root / 'DISK_BOUND_VERIFICATION.json').write_text(json.dumps(output, indent=2)+'\n') |
| print(json.dumps(output['summary'], indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
