| """Exact rational certificate for amplified complete-disk barrier lower bound. |
| |
| This combines exact angular exterior waste, convex-reward cap-capacity |
| packing, and localized additive redundancy with the classical overlap lemma. |
| All verification uses fractions and integer square roots. Decimal strings |
| are display-only, never inputs to a verification inequality. |
| """ |
|
|
| from fractions import Fraction as F |
| from math import isqrt |
| from decimal import Decimal, localcontext |
| import json |
| from pathlib import Path |
|
|
|
|
| class I: |
| def __init__(self, lo, hi=None): |
| self.lo = F(lo) |
| self.hi = self.lo if hi is None else F(hi) |
| assert self.lo <= self.hi |
|
|
| @staticmethod |
| def wrap(value): |
| return value if isinstance(value, I) else I(value) |
|
|
| def __add__(self, other): |
| other = I.wrap(other) |
| return I(self.lo + other.lo, self.hi + other.hi) |
|
|
| __radd__ = __add__ |
|
|
| def __neg__(self): |
| return I(-self.hi, -self.lo) |
|
|
| def __sub__(self, other): |
| return self + (-I.wrap(other)) |
|
|
| def __rsub__(self, other): |
| return I.wrap(other) - self |
|
|
| def __mul__(self, other): |
| other = I.wrap(other) |
| products = [x * y for x in (self.lo, self.hi) for y in (other.lo, other.hi)] |
| return I(min(products), max(products)) |
|
|
| __rmul__ = __mul__ |
|
|
| def __truediv__(self, other): |
| other = I.wrap(other) |
| assert other.lo * other.hi > 0, "interval division through zero" |
| return self * I(1 / other.hi, 1 / other.lo) |
|
|
| def __rtruediv__(self, other): |
| return I.wrap(other) / self |
|
|
| def square(self): |
| return self * self |
|
|
| def sqrt(self, digits=70): |
| assert self.lo >= 0 |
| scale = 10**digits |
| lower = isqrt((self.lo.numerator * scale**2) // self.lo.denominator) |
| upper = isqrt((self.hi.numerator * scale**2) // self.hi.denominator) + 1 |
| return I(F(lower, scale), F(upper, scale)) |
|
|
| def display(self): |
| with localcontext() as context: |
| context.prec = 45 |
| return [str(Decimal(x.numerator) / Decimal(x.denominator)) |
| for x in (self.lo, self.hi)] |
|
|
|
|
| def main(): |
| r = I(F(4057804, 10**11)) |
| t = I(F(9661517984, 10**10)) |
| delta = I(F(26864358, 10**13)) |
| a = 1 + r |
| root2 = I(2).sqrt() |
| sine = (2 - root2).sqrt() / 2 |
| cosine = (2 + root2).sqrt() / 2 |
| w = (a.square() - t.square()).sqrt() |
| eta = (1 - t) / 2 |
| omega = ((a.square().square() - t.square()).sqrt() + w) / (a.square() - 1) |
| far_coefficient = root2 / (1 - 1 / (root2 * t)) |
| final_eta = eta - omega * delta / 2 |
| A = 2 * (t * sine - w * cosine) |
| B = 2 * (t * cosine + w * sine) |
| D_opposed = 2 * a |
| A_neighbor, B_neighbor = A / root2, B / root2 |
| D_neighbor = root2 * (t + w) |
| opposed_rhs = eta.square() * A.square() / ( |
| 2 * D_opposed * (A.square() + (eta + B).square())) |
| neighbor_rhs = eta.square() * A_neighbor.square() / ( |
| 2 * D_neighbor * (A_neighbor.square() + (eta + B_neighbor).square())) |
| denominator = A.square() + (eta + B).square() |
| C0 = A.square() + B.square() |
| opposed_first_derivative = A.square() * eta * (C0 + B * eta) / ( |
| D_opposed * denominator.square()) |
|
|
| def q(value): |
| return value.square() * A.square() / ( |
| 2 * D_opposed * (A.square() + (value + B).square())) |
|
|
| def q_prime(value): |
| den = A.square() + (value + B).square() |
| return A.square() * value * (C0 + B * value) / ( |
| D_opposed * den.square()) |
|
|
| maximum_flow = 2 * eta |
| reward = q(4 * eta / 3) + q(2 * eta / 3) |
| reward_derivative = 4 * q_prime(4 * eta / 3) / 3 + 2 * q_prime(2 * eta / 3) / 3 |
| opposed_second_derivative_sign = ( |
| C0.square() - 3 * C0 * maximum_flow.square() |
| - 2 * B * maximum_flow.square() * maximum_flow) |
| conditions = { |
| "r_positive": r, |
| "r_below_sec_lambda_minus_one": 1 / cosine - 1 - r, |
| "t_above_a_cos_lambda": t - a * cosine, |
| "t_below_one": 1 - t, |
| "w_squared_positive": a.square() - t.square(), |
| "eta_positive": eta, |
| "final_eta_positive_for_W_at_most_delta": final_eta, |
| "eta_positive_at_certified_initial_reward": eta - omega * reward / 2, |
| "far_radius_exceeds_near_annulus": root2 * t - a, |
| "far_radius_exceeds_one": root2 * t - 1, |
| "near_coefficient_dominates_far": omega - far_coefficient, |
| "strip_numerator_positive": A, |
| "t_exceeds_w_for_neighbor_enclosing_disc": t - w, |
| "opposed_localized_projection_slack": 1 - t * sine - w * cosine, |
| "neighbor_localized_projection_slack": 1 - t * cosine - w * sine, |
| "neighbor_branch_dominates_on_whole_eta_interval": |
| 2 * a * C0 - D_neighbor * (A.square() + (root2 * maximum_flow + B).square()), |
| "opposed_second_derivative_positive_on_whole_eta_interval": opposed_second_derivative_sign, |
| "additive_monotonicity_slack": 1 - omega * reward_derivative / 2, |
| "packing_reward_contradiction_margin": reward - delta, |
| } |
| for name, interval in conditions.items(): |
| assert interval.lo > 0, name |
| |
| |
| assert A.lo > 0 and B.lo > 0 and A_neighbor.lo > 0 and B_neighbor.lo > 0 |
| result = { |
| "status": "PASS", "arithmetic": "Exact rational interval arithmetic and integer-square-root enclosures; decimal strings are display-only.", |
| "method": "Exact orientation-dependent exterior Crofton waste, convex-reward cap-capacity packing, and localized additive projection redundancy, using the classical four-cap strip lemma.", |
| "parameters": {"r": str(r.lo), "t": str(t.lo), "delta": str(delta.lo), |
| "lambda": "pi/8; sine and cosine evaluated by exact radical enclosures"}, |
| "bound": "Every conventional rectifiable opaque barrier of the unit disk has length strictly greater than pi+2.6864358e-6.", |
| "scope": "Unconditional complete-barrier lower-bound improvement; the unrestricted optimum is not determined. Independent literature priority remains to be checked.", |
| "analytic_dependencies": [ |
| "Kawamura--Moriyama--Otachi--Pach strip-overlap lemma and its normal-window-localized proof: https://doi.org/10.4230/LIPIcs.SoCG.2016.46, Section 6.", |
| "Kiderlen--Pausinger disk-cap geometry: https://doi.org/10.1007/s10474-026-01606-x, Section 3.2.", |
| "The accompanying manuscript proves exact orientation-position exterior waste, convex-reward capacity packing with disjoint material allocations, redundancy additivity, and the final monotonicity argument."], |
| "exact_exterior_coefficient": omega.display(), |
| "far_exterior_coefficient": far_coefficient.display(), |
| "initial_good_mass_eta0": eta.display(), |
| "final_good_mass_at_W_equal_delta": final_eta.display(), |
| "opposed_overlap_derivative_at_eta0": opposed_first_derivative.display(), |
| "packing_reward_derivative_at_eta0": reward_derivative.display(), |
| "maximum_flow_for_convexity_and_branch_comparison": maximum_flow.display(), |
| "capacity_packing_reward": "R(eta)=q(4*eta/3)+q(2*eta/3). The alternative 2*q(eta) is at least q(4*eta/3), since the quadratic denominator of q increases on nonnegative arguments.", |
| "positive_intervals": {name: interval.display() for name, interval in conditions.items()}, |
| "opposed_overlap_bound": opposed_rhs.display(), |
| "neighbor_overlap_bound": neighbor_rhs.display(), |
| "certified_initial_packing_reward": reward.display(), |
| "published_selected_parameter_increment": "1.0764570174055761e-6 (floating reconstruction; background only)", |
| "improvement_over_published_displayed_1_076457e_6": str( |
| delta.lo - F(1076457, 10**12)), |
| } |
| output = Path(__file__).with_name("DISK_BOUND_CERTIFICATE.json") |
| output.write_text(json.dumps(result, indent=2) + "\n") |
| print(json.dumps(result, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
