| """Sharp small-inflation cost when a circle must be retained. |
| |
| The old component is C=boundary(r D). An admissible finite segment network A |
| must make C union A connected and its convex hull contain (r+delta) D. |
| Only the length of A outside the old circle is charged. This is an |
| augmentation problem: it does not concern replacement of the old component. |
| |
| Analytic conclusions (proved in tmp/sharp_augmentation_proof.tex): |
| S >= 2*sqrt(2*r*delta), |
| inf S / (pi*sqrt(2*r*delta)) -> 1 as delta/r -> 0. |
| The scalar lower bound below and radial-spoke upper bound sandwich inf S. |
| Floating-point values are diagnostics, not interval-certified optima over all A. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import math |
| import numpy as np |
| from scipy.optimize import brentq |
|
|
| PI = math.pi |
|
|
|
|
| def _parameters(radius, inflation): |
| radius, inflation = float(radius), float(inflation) |
| if not math.isfinite(radius) or radius <= 0: |
| raise ValueError("radius must be finite and positive") |
| if not math.isfinite(inflation) or inflation <= 0: |
| raise ValueError("inflation must be finite and positive") |
| return radius, inflation |
|
|
|
|
| def covered_normal_width(length, radius=1.0, inflation=0.01): |
| """Upper bound on normals served by one anchored exterior component. |
| |
| A connected exterior piece of length ell has a circle anchor q; every x |
| in that piece has |x-q|<=ell. Thus u.x>=r+delta requires |
| u.q>=r+delta-ell. The resulting arc width is this scalar expression. |
| """ |
| radius, inflation = _parameters(radius, inflation) |
| length = float(length) |
| if not math.isfinite(length) or length < 0: |
| raise ValueError("length must be finite and nonnegative") |
| if length <= inflation: |
| return 0.0 |
| if length >= inflation + 2 * radius: |
| return 2 * PI |
| return 2 * math.acos(1 - (length - inflation) / radius) |
|
|
|
|
| def elementary_lower_bound(radius=1.0, inflation=0.01): |
| radius, inflation = _parameters(radius, inflation) |
| return 2 * math.sqrt(2 * radius * inflation) |
|
|
|
|
| def scalar_lower_bound(radius=1.0, inflation=0.01): |
| """Evaluate the exact one-variable lower-bound formula numerically. |
| |
| M=sup_{ell>0} w(ell)/ell and S>=2*pi/M. Writing |
| ell=r*(a+1-cos(phi)) reduces this to |
| pi*r*min_{0<phi<=pi} (a+1-cos(phi))/phi. |
| Its only possible interior minimum is the first root of |
| phi*sin(phi)+cos(phi)-1=a in (0,pi/2]; the endpoint pi is also checked. |
| The global reduction is analytic; the reported root/value use doubles. |
| """ |
| radius, inflation = _parameters(radius, inflation) |
| a = inflation / radius |
| candidates = [(PI, a + 2)] |
| if a < PI / 2 - 1: |
| def equation(phi): |
| return phi * math.sin(phi) - 2 * math.sin(phi / 2) ** 2 - a |
| phi = brentq(equation, 0.0, PI / 2, xtol=1e-15, rtol=1e-14) |
| candidates.append((phi, a + 2 * math.sin(phi / 2) ** 2)) |
| phi, denominator = min(candidates, key=lambda z: z[1] / z[0]) |
| value = PI * radius * denominator / phi |
| return {"lower_bound": value, "max_width_per_length": 2 * PI / value, |
| "maximizing_component_length": radius * denominator, |
| "maximizing_phi": phi, |
| "evaluation": "analytic scalar reduction; floating-point root"} |
|
|
|
|
| def spoke_cost(count, radius=1.0, inflation=0.01): |
| radius, inflation = _parameters(radius, inflation) |
| if isinstance(count, bool) or int(count) != count or count < 3: |
| raise ValueError("count must be an integer at least three") |
| count = int(count) |
| x = PI / count |
| sec_minus_one = 2 * math.sin(x / 2) ** 2 / math.cos(x) |
| return count * (inflation + (radius + inflation) * sec_minus_one) |
|
|
|
|
| def optimal_spoke_count(radius=1.0, inflation=0.01): |
| """Integer optimum within equal radial-arm constructions only. |
| |
| The continuous cost N*((r+delta)*sec(pi/N)-r) is strictly convex for N>=3. |
| A floating-point derivative root brackets the two candidate integers. |
| """ |
| radius, inflation = _parameters(radius, inflation) |
|
|
| def derivative(count): |
| x = PI / count |
| sec_minus_one = 2 * math.sin(x / 2) ** 2 / math.cos(x) |
| return inflation + (radius + inflation) * ( |
| sec_minus_one - x * math.tan(x) / math.cos(x)) |
|
|
| upper = 6.0 |
| while derivative(upper) < 0: |
| upper *= 2 |
| continuous = brentq(derivative, 3.0, upper, xtol=1e-10, rtol=1e-13) |
| candidates = sorted({3, max(3, math.floor(continuous)), math.ceil(continuous)}) |
| count = min(candidates, key=lambda n: spoke_cost(n, radius, inflation)) |
| return {"count": count, "cost": spoke_cost(count, radius, inflation), |
| "continuous_count": continuous, |
| "scope": "equal radial-arm constructions"} |
|
|
|
|
| def radial_arms(count, radius=1.0, inflation=0.01, rotation=0.0): |
| """Finite connected augmentation with an enclosing regular tip polygon.""" |
| radius, inflation = _parameters(radius, inflation) |
| spoke_cost(count, radius, inflation) |
| count = int(count) |
| theta = float(rotation) + 2 * PI * np.arange(count) / count |
| directions = np.column_stack((np.cos(theta), np.sin(theta))) |
| tip_radius = (radius + inflation) / math.cos(PI / count) |
| roots, tips = radius * directions, tip_radius * directions |
| return {"segments": np.stack((roots, tips), axis=1), |
| "roots": roots, "tips": tips, "tip_radius": tip_radius, |
| "count": count, "radius": radius, "inflation": inflation, |
| "cost_formula": spoke_cost(count, radius, inflation)} |
|
|
|
|
| def make_figure(path_png, path_pdf): |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
|
|
| plt.rcParams.update({"font.size": 10, "axes.spines.top": False, |
| "axes.spines.right": False, "figure.dpi": 160}) |
| fig, axes = plt.subplots(1, 3, figsize=(12.1, 3.5), layout="constrained") |
| ax = axes[0] |
| delta = 0.025 |
| optimum = optimal_spoke_count(1, delta) |
| data = radial_arms(optimum["count"], 1, delta) |
| theta = np.linspace(0, 2 * PI, 800) |
| ax.plot(np.cos(theta), np.sin(theta), color="#283b59", lw=1.6, |
| label="retained circle") |
| ax.plot((1 + delta) * np.cos(theta), (1 + delta) * np.sin(theta), |
| color="#cc6545", lw=1, ls="--", label="inflated disk") |
| for segment in data["segments"]: |
| ax.plot(segment[:, 0], segment[:, 1], color="#167f86", lw=2) |
| tips = np.vstack((data["tips"], data["tips"][0])) |
| ax.plot(tips[:, 0], tips[:, 1], color="#167f86", lw=.7, alpha=.7) |
| ax.set_aspect("equal") |
| ax.set_title("A Retain the circle; add radial arms", loc="left", fontsize=10) |
| ax.set_xlim(-1.13, 1.13); ax.set_ylim(-1.13, 1.13) |
| ax.set_xticks([-1, 0, 1]); ax.set_yticks([-1, 0, 1]) |
| ax.legend(frameon=False, loc="lower left", fontsize=8) |
|
|
| ratios = np.geomspace(1e-6, .1, 100) |
| scale = PI * np.sqrt(2 * ratios) |
| lower = np.array([scalar_lower_bound(1, d)["lower_bound"] for d in ratios]) |
| spoke = [optimal_spoke_count(1, d) for d in ratios] |
| upper = np.array([row["cost"] for row in spoke]) |
| ax = axes[1] |
| ax.semilogx(ratios, lower / scale, color="#283b59", lw=2, |
| label="scalar lower bound") |
| ax.semilogx(ratios, upper / scale, color="#167f86", lw=2, |
| label="radial-arm upper bound") |
| ax.axhline(1, color=".5", ls=":", lw=1) |
| ax.set_xlabel(r"relative inflation $\delta/r$") |
| ax.set_ylabel(r"length $/\,\pi\sqrt{2r\delta}$") |
| ax.set_title("B Matching sharp asymptotic", loc="left", fontsize=10) |
| ax.legend(frameon=False, fontsize=8) |
| ax.grid(alpha=.15) |
|
|
| ax = axes[2] |
| counts = np.array([row["count"] for row in spoke]) |
| ax.semilogx(ratios, counts * np.sqrt(ratios), color="#167f86", lw=1.7, |
| label=r"integer-optimal $N\sqrt{\delta/r}$") |
| ax.axhline(PI / math.sqrt(2), color="#283b59", ls="--", lw=1.2, |
| label=r"limit $\pi/\sqrt{2}$") |
| ax.set_xlabel(r"relative inflation $\delta/r$") |
| ax.set_ylabel("scaled arm count") |
| ax.set_title("C Arm count grows as inverse square root", loc="left", fontsize=10) |
| ax.legend(frameon=False, fontsize=8) |
| ax.grid(alpha=.15) |
| fig.savefig(path_png, dpi=200) |
| fig.savefig(path_pdf) |
| plt.close(fig) |
|
|
