| """Exact one-arc cosine-transform mass-budget relaxation. |
| |
| Coordinates are on R/(pi Z). The shifted orientation measure mu obeys |
| H'' + H = mu; equivalently H(t) = .5 integral |sin(t-u)| dmu(u). |
| The support function H is at least 1, and its integral is total mass L. |
| The numerical routines illustrate a proved continuum theorem. They do not |
| test geometric opacity or construct an opaque barrier. |
| """ |
| from dataclasses import dataclass |
| import math |
| import numpy as np |
| from scipy.optimize import brentq |
|
|
|
|
| @dataclass(frozen=True) |
| class SoftGapSolution: |
| beta: float |
| eta: float |
| regime: str |
| value: float |
| critical_budget: float |
| plateau_halfwidth: float |
| cap_width: float |
| dual_multiplier: float |
|
|
|
|
| def solve_soft_gap(beta, eta): |
| """Return the exact formula, with one scalar root in the middle regime.""" |
| beta, eta = float(beta), float(eta) |
| if not 0.0 < beta < math.pi / 2: |
| raise ValueError("beta must lie strictly between 0 and pi/2") |
| if eta < 0 or not math.isfinite(eta): |
| raise ValueError("eta must be finite and nonnegative") |
| critical = 2 * math.tan(beta / 2) |
| if eta <= critical: |
| b = 2*math.sin(beta/2)**2 / math.cos(beta) |
| value = math.pi + 2 * (math.tan(beta) - beta) - b * eta |
| return SoftGapSolution(beta, eta, "central atom", value, critical, |
| 0.0, beta, b) |
| if eta < 2 * beta: |
| s = brentq(lambda x: 2*x + 2*math.tan((beta-x)/2) - eta, |
| 0.0, beta, xtol=5e-15) |
| d = beta - s |
| value = math.pi + 4 * math.tan(d / 2) - 2 * d |
| return SoftGapSolution(beta, eta, "contact plateau", value, critical, |
| s, d, 2*math.sin(d/2)**2 / math.cos(d)) |
| return SoftGapSolution(beta, eta, "uniform", math.pi, critical, |
| beta, 0.0, 0.0) |
|
|
|
|
| def circle_coordinate(t): |
| return (np.asarray(t, dtype=float) + math.pi/2) % math.pi - math.pi/2 |
|
|
|
|
| def extremizer_h(t, solution): |
| """The primal continuum extremizer H, including all regimes.""" |
| a = np.abs(circle_coordinate(t)) |
| z = np.full_like(a, 1.0) |
| p = solution |
| if p.regime == "central atom": |
| mask = a < p.beta |
| A = (2 - p.eta*math.sin(p.beta)) / math.cos(p.beta) |
| z = np.where(mask, .5*(A*np.cos(a) + p.eta*np.sin(a)), z) |
| elif p.regime == "contact plateau": |
| mask = (a > p.plateau_halfwidth) & (a < p.beta) |
| cap = np.cos(a-(p.plateau_halfwidth+p.beta)/2) / math.cos(p.cap_width/2) |
| z = np.where(mask, cap, z) |
| return z |
|
|
|
|
| def dual_w(t, solution): |
| """The supported dual test function 0 <= w <= b*1_I.""" |
| a = np.abs(circle_coordinate(t)) |
| p = solution |
| if p.regime == "uniform": |
| return np.zeros_like(a) |
| d, s = p.cap_width, p.plateau_halfwidth |
| numerator = np.cos(np.maximum(a-s, 0.0)) - math.cos(d) |
| denominator = math.cos(d) |
| return np.where(a >= p.beta, 0.0, |
| np.where(a <= s, p.dual_multiplier, numerator/denominator)) |
|
|
|
|
| def measure_decomposition(solution): |
| """Return uniform-density intervals and (position, mass) atoms of mu. |
| |
| Arc endpoints +/-beta are excluded from the budget. Zero-width |
| intervals and coincident zero atoms have no effect. |
| """ |
| p = solution |
| if p.regime == "uniform": |
| return [(-math.pi/2, math.pi/2)], [] |
| intervals = [(-math.pi/2, -p.beta), (p.beta, math.pi/2)] |
| if p.regime == "central atom": |
| edge = math.tan(p.beta) - p.eta/(2*math.cos(p.beta)) |
| atoms = [(-p.beta, edge), (0.0, p.eta), (p.beta, edge)] |
| else: |
| s = p.plateau_halfwidth |
| if s > 0: |
| intervals.append((-s, s)) |
| mass = math.tan(p.cap_width/2) |
| atoms = [(-p.beta, mass), (-s, mass), (s, mass), (p.beta, mass)] |
| return intervals, atoms |
|
|
|
|
| def mass_in_open_arc(solution): |
| intervals, atoms = measure_decomposition(solution) |
| beta = solution.beta |
| diffuse = sum(max(0.0, min(b,beta)-max(a,-beta)) for a,b in intervals) |
| atomic = sum(m for x,m in atoms if -beta < x < beta) |
| return diffuse + atomic |
|
|
|
|
| def total_mass(solution): |
| intervals, atoms = measure_decomposition(solution) |
| return sum(b-a for a,b in intervals) + sum(m for x,m in atoms) |
|
|
|
|
| def value_curve(beta, budgets): |
| return np.array([solve_soft_gap(beta, eta).value for eta in budgets]) |
|
|
