| """Exact component/length frontier for interior uniform-angle audits. |
| |
| For n>=3 sampled normals k*pi/n, candidates are compact rectifiable subsets |
| of the closed unit disk with at most K connected components. The optimum is |
| (2*n - min(K,n)) * 2*sin(pi/(2*n)). |
| |
| Proof dependency: the classical Steiner minimum tree theorem for regular |
| N-gons, N>=6, due to Jarnik--Koessler and Du--Hwang--Weng (1987), DOI |
| 10.1007/BF02187871. Its minimum network length is (N-1) times the side length. |
| The numerical verification accompanying this module does NOT prove that |
| classical theorem or search all Steiner topologies. |
| |
| Every sampled tangent forces its unit-circle contact vertex into an interior |
| candidate. Connecting its terminal-meeting components by at most K-1 polygon |
| sides gives the Steiner lower bound (2n-K)*d. The projection lower bound n*d |
| also applies. Deleting min(K,n) edges of one parity attains their maximum. |
| |
| This is the sampled-angle INTERIOR problem, not unrestricted full opacity. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import math |
| import numpy as np |
|
|
| PI = math.pi |
| STEINER_DEPENDENCY = { |
| "authors": ["D. Z. Du", "F. K. Hwang", "J. F. Weng"], |
| "title": "Steiner minimal trees for regular polygons", |
| "journal": "Discrete & Computational Geometry", |
| "year": 1987, "volume": 2, "pages": "65-84", |
| "doi": "10.1007/BF02187871", |
| "primary_url": "https://doi.org/10.1007/BF02187871", |
| "used_statement": "For a regular N-gon with N>=6, a Steiner minimum tree is the polygon with one edge removed.", |
| "numerically_proved_here": False, |
| } |
|
|
|
|
| def _validate(n, components=1): |
| if isinstance(n, bool) or int(n) != n or n < 3: |
| raise ValueError("n must be an integer at least three") |
| if isinstance(components, bool) or int(components) != components or components < 1: |
| raise ValueError("Component budget must be a positive integer") |
| return int(n), int(components) |
|
|
|
|
| def side_length(n): |
| n, _ = _validate(n) |
| return 2 * math.sin(PI / (2 * n)) |
|
|
|
|
| def frontier_length(n, components): |
| n, components = _validate(n, components) |
| return (2 * n - min(components, n)) * side_length(n) |
|
|
|
|
| def frontier_lower_bounds(n, components): |
| n, components = _validate(n, components) |
| d = side_length(n) |
| return {"projection_bound": n * d, |
| "component_steiner_bound": (2 * n - components) * d, |
| "combined_bound": max(n * d, (2 * n - components) * d), |
| "steiner_connected_terminal_bound": (2 * n - 1) * d} |
|
|
|
|
| def regular_vertices(n): |
| n, _ = _validate(n) |
| theta = np.arange(2 * n) * PI / n |
| return np.column_stack((np.cos(theta), np.sin(theta))) |
|
|
|
|
| def construction(n, components, offset=1): |
| """Delete q=min(K,n) same-parity edges, starting at a cyclic offset.""" |
| n, components = _validate(n, components) |
| offset = int(offset) % (2 * n) |
| q = min(components, n) |
| vertices = regular_vertices(n) |
| deleted = (offset + 2 * np.arange(q)) % (2 * n) |
| keep = np.ones(2 * n, dtype=bool) |
| keep[deleted] = False |
| indices = np.flatnonzero(keep) |
| segments = np.stack((vertices[indices], vertices[(indices + 1) % (2 * n)]), axis=1) |
| return {"segments": segments, "vertices": vertices, |
| "retained_edge_indices": indices, "deleted_edge_indices": deleted, |
| "realized_components": q, "component_budget": components, |
| "length_formula": frontier_length(n, components), "offset": offset} |
|
|
|
|
| def graph_component_count(n, retained_edge_indices): |
| n, _ = _validate(n) |
| parent = list(range(2 * n)) |
|
|
| def root(v): |
| while parent[v] != v: |
| parent[v] = parent[parent[v]] |
| v = parent[v] |
| return v |
|
|
| for edge in retained_edge_indices: |
| a, b = int(edge), (int(edge) + 1) % (2 * n) |
| ra, rb = root(a), root(b) |
| parent[rb] = ra |
| return len({root(v) for v in range(2 * n)}) |
|
|
|
|
| def connected_repair_cost(n): |
| """Minimum extra length needed to connect the alternating selected edges. |
| |
| Steiner branching cannot improve this cost by the cited regular-polygon |
| theorem. Adding every unselected odd edge except one attains it. |
| """ |
| n, _ = _validate(n) |
| return (n - 1) * side_length(n) |
|
|
|
|
| def penalized_optimum(n, component_penalty): |
| """Exact minimum of length + lambda*(actual component count). |
| |
| On the frontier the objective is affine in K. The optimizer is the |
| alternating construction for lambda<d, a connected path for lambda>d, |
| and every K=1,...,n at lambda=d. No continuum/full-opacity assertion is |
| made by this finite-audit penalization formula. |
| """ |
| n, _ = _validate(n) |
| penalty = float(component_penalty) |
| if not math.isfinite(penalty) or penalty < 0: |
| raise ValueError("Component penalty must be finite and nonnegative") |
| d = side_length(n) |
| connected = (2 * n - 1) * d + penalty |
| alternating = n * d + n * penalty |
| if penalty < d: |
| minimizers = [n] |
| phase = "n components" |
| elif penalty > d: |
| minimizers = [1] |
| phase = "one component" |
| else: |
| minimizers = list(range(1, n + 1)) |
| phase = "all component counts tie" |
| return {"value": min(connected, alternating), |
| "connected_branch": connected, "alternating_branch": alternating, |
| "threshold": d, "penalty": penalty, |
| "minimizing_component_counts": minimizers, "phase": phase} |
|
|
|
|
| def joint_penalty_limit(c): |
| """Limit when lambda_n->0 and n*lambda_n->c>=0: min(2*pi,pi+c).""" |
| c = float(c) |
| if not math.isfinite(c) or c < 0: |
| raise ValueError("The scaled limiting penalty must be finite and nonnegative") |
| return min(2 * PI, PI + c) |
|
|
|
|
| def repair_segments(n, omitted_odd_edge=1): |
| n, _ = _validate(n) |
| omitted_odd_edge = int(omitted_odd_edge) % (2 * n) |
| if omitted_odd_edge % 2 != 1: |
| raise ValueError("The omitted edge must be unselected (odd indexed)") |
| vertices = regular_vertices(n) |
| indices = np.array([j for j in range(1, 2 * n, 2) if j != omitted_odd_edge]) |
| return np.stack((vertices[indices], vertices[(indices + 1) % (2 * n)]), axis=1) |
|
|
|
|
