File size: 8,057 Bytes
3b80460 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | """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
# q(eta)=c*eta^2/(A^2+(eta+B)^2) increases for eta>=0:
# the derivative's positive factor is A^2+B^2+B*eta.
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()
|