| """Reproduce component-frontier constructions and algebraic certificates. |
| |
| All n=3..60, K=1..n+2, and 2n cyclic deletion offsets are checked. Complete |
| offset coverage follows an independently checked geometric rotation identity; |
| actual interval unions are checked at every sampled normal for the base offset. |
| The classical regular-polygon SMT theorem is an explicit proof dependency, |
| not a numerical conclusion of this script. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import math |
| from pathlib import Path |
|
|
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| import numpy as np |
|
|
| from complexity_frontier import ( |
| PI, STEINER_DEPENDENCY, side_length, frontier_length, frontier_lower_bounds, |
| regular_vertices, construction, graph_component_count, |
| connected_repair_cost, repair_segments, penalized_optimum, joint_penalty_limit, |
| ) |
| from finite_audit import alternating_polygon, missed_length_at_angle, maximal_required_gap |
|
|
| HERE = Path(__file__).resolve().parent |
|
|
|
|
| def verify(): |
| records = [] |
| offset_case_count = 0 |
| maxima = {"length_error": 0.0, "sampled_missed_length": 0.0, |
| "sampled_required_gap": 0.0, "lower_bound_formula_error": 0.0, |
| "rotation_equivariance_error": 0.0, "repair_length_error": 0.0, |
| "repair_steiner_lower_bound_error": 0.0} |
| for n in range(3, 61): |
| vertices = regular_vertices(n) |
| indices = np.arange(2 * n) |
| d = side_length(n) |
| rotations = [] |
| |
| |
| for offset in range(2 * n): |
| phi = offset * PI / n |
| rotation = np.array([[math.cos(phi), -math.sin(phi)], |
| [math.sin(phi), math.cos(phi)]]) |
| error = float(np.max(np.abs(vertices @ rotation.T |
| - vertices[(indices + offset) % (2 * n)]))) |
| assert error < 3e-14 |
| maxima["rotation_equivariance_error"] = max(maxima["rotation_equivariance_error"], error) |
| |
| normals = np.mod(np.arange(n) * PI / n + phi, PI) |
| expected = np.arange(n) * PI / n |
| nearest_grid_error = np.min(np.abs( |
| (normals[:, None] - expected[None, :] + PI / 2) % PI - PI / 2), axis=1) |
| assert float(nearest_grid_error.max()) < 3e-14 |
| rotations.append(error) |
| for budget in range(1, n + 3): |
| q = min(budget, n) |
| base = construction(n, budget, offset=1) |
| length = float(np.linalg.norm(base["segments"][:, 1] |
| - base["segments"][:, 0], axis=1).sum()) |
| expected = frontier_length(n, budget) |
| length_error = abs(length - expected) |
| lower = frontier_lower_bounds(n, budget) |
| lower_error = abs(lower["combined_bound"] - expected) |
| normals = np.arange(n) * PI / n |
| missed = max(missed_length_at_angle(base["segments"], theta) for theta in normals) |
| gap = max(maximal_required_gap(base["segments"], theta) for theta in normals) |
| assert length_error < 2e-12 and lower_error < 2e-12 |
| assert missed < 2e-10 and gap < 2e-10 |
| |
| |
| for offset in range(2 * n): |
| shifted = construction(n, budget, offset) |
| removed = shifted["deleted_edge_indices"] |
| assert len(set(map(int, removed))) == q |
| assert np.all(removed % 2 == offset % 2) |
| retained = set(map(int, shifted["retained_edge_indices"])) |
| opposite_parity = {j for j in range(2 * n) if j % 2 != offset % 2} |
| assert opposite_parity.issubset(retained) |
| assert graph_component_count(n, shifted["retained_edge_indices"]) == q |
| |
| assert len(retained) == 2 * n - q |
| assert len(retained) + (q - 1) == 2 * n - 1 |
| offset_case_count += 1 |
| maxima["length_error"] = max(maxima["length_error"], length_error) |
| maxima["sampled_missed_length"] = max(maxima["sampled_missed_length"], missed) |
| maxima["sampled_required_gap"] = max(maxima["sampled_required_gap"], gap) |
| maxima["lower_bound_formula_error"] = max(maxima["lower_bound_formula_error"], lower_error) |
| records.append({"n": n, "K": budget, "realized_components": q, |
| "side_length": d, "formula_length": expected, |
| "measured_length": length, |
| "projection_lower_bound": lower["projection_bound"], |
| "component_steiner_lower_bound": lower["component_steiner_bound"], |
| "combined_lower_bound": lower["combined_bound"], |
| "max_base_sample_missed_length": missed, |
| "max_base_sample_gap": gap, |
| "verified_cyclic_offsets": 2 * n}) |
| alternating = alternating_polygon(n) |
| added = repair_segments(n) |
| repaired = np.concatenate((alternating, added), axis=0) |
| added_length = float(np.linalg.norm(added[:, 1] - added[:, 0], axis=1).sum()) |
| total = float(np.linalg.norm(repaired[:, 1] - repaired[:, 0], axis=1).sum()) |
| steiner_minimum = (2 * n - 1) * d |
| error = abs(added_length - connected_repair_cost(n)) |
| lower_error = abs(total - steiner_minimum) |
| assert error < 2e-12 and lower_error < 2e-12 |
| assert graph_component_count(n, [j for j in range(2 * n) if j != 1]) == 1 |
| maxima["repair_length_error"] = max(maxima["repair_length_error"], error) |
| maxima["repair_steiner_lower_bound_error"] = max(maxima["repair_steiner_lower_bound_error"], lower_error) |
| return records, offset_case_count, maxima |
|
|
|
|
| def make_figure(): |
| plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 10, |
| "axes.titlesize": 12, "axes.labelsize": 10}) |
| fig, axes = plt.subplots(3, 2, figsize=(12.6, 12.8)) |
| fig.patch.set_facecolor("#f8fafc") |
| for ax in axes.ravel(): |
| ax.set_facecolor("white") |
| ax.spines[["top", "right"]].set_visible(False) |
| ax = axes[0, 0] |
| example = construction(12, 3, offset=1) |
| theta = np.linspace(0, 2 * PI, 601) |
| ax.plot(np.cos(theta), np.sin(theta), ls="--", lw=1, color="#94a3b8") |
| palette = ["#2563eb", "#8b5cf6", "#0891b2"] |
| |
| for index, segment in zip(example["retained_edge_indices"], example["segments"]): |
| group = 0 if index == 2 else (1 if index == 4 else 2) |
| ax.plot(segment[:, 0], segment[:, 1], lw=4, color=palette[group], |
| solid_capstyle="round") |
| for index in example["deleted_edge_indices"]: |
| points = example["vertices"][[index, (index + 1) % 24]] |
| ax.plot(points[:, 0], points[:, 1], ls=":", color="#dc2626", lw=1.8) |
| ax.set_aspect("equal"); ax.set_xlim(-1.12, 1.12); ax.set_ylim(-1.12, 1.12) |
| ax.set_title("A. Exact construction: $n=12$, $K=3$", loc="left", fontweight="bold") |
| ax.set_xlabel("$x$"); ax.set_ylabel("$y$") |
| ax.text(0.04, 0.03, "Delete three edges of one parity.\nRetain every required contact vertex.", |
| transform=ax.transAxes, fontsize=8, color="#475569", |
| bbox={"facecolor": "white", "edgecolor": "none", "alpha": .9}) |
|
|
| ax = axes[0, 1] |
| for n, color in zip([8, 16, 32, 64], ["#94a3b8", "#0891b2", "#8b5cf6", "#2563eb"]): |
| budgets = np.arange(1, int(1.3 * n) + 1) |
| values = [frontier_length(n, int(k)) / PI for k in budgets] |
| ax.plot(budgets / n, values, color=color, lw=2, label=f"$n={n}$") |
| ax.axhline(1, color="#64748b", ls="--", lw=1) |
| ax.axvline(1, color="#cbd5e1", ls=":", lw=1) |
| ax.set_xlim(0, 1.25); ax.set_ylim(.96, 2.04) |
| ax.set_xlabel("Relative component budget $K/n$") |
| ax.set_ylabel("Exact sampled optimum / $\\pi$") |
| ax.set_title("B. The sharp complexity / length frontier", loc="left", fontweight="bold") |
| ax.legend(frameon=False, fontsize=8) |
| ax.grid(alpha=.15) |
|
|
| ax = axes[1, 0] |
| counts = np.arange(3, 257) |
| for k, color in zip([1, 2, 4, 8], ["#2563eb", "#8b5cf6", "#0891b2", "#64748b"]): |
| ax.plot(counts, [frontier_length(int(n), k) for n in counts], lw=2, |
| color=color, label=f"Fixed $K={k}$") |
| ax.axhline(2 * PI, ls="--", color="#dc2626", lw=1.5, label="Limit: $2\\pi$") |
| ax.set_xscale("log", base=2); ax.set_xlim(3, 256); ax.set_ylim(2.9, 6.5) |
| ax.set_xlabel("Audited normal count $n$") |
| ax.set_ylabel("Total length") |
| ax.set_title("C. Fixed component budgets restore the full limit", loc="left", fontweight="bold") |
| ax.legend(frameon=False, fontsize=8, loc="lower right") |
| ax.grid(alpha=.15) |
| ax = axes[2, 0] |
| n = 16 |
| d = side_length(n) |
| scaled = np.linspace(0, 2.1, 501) |
| connected = np.array([penalized_optimum(n, float(t * d))["connected_branch"] |
| / (n * d) for t in scaled]) |
| alternating = np.array([penalized_optimum(n, float(t * d))["alternating_branch"] |
| / (n * d) for t in scaled]) |
| ax.plot(scaled, alternating, color="#2563eb", lw=1.8, |
| label="$n$-component branch") |
| ax.plot(scaled, connected, color="#8b5cf6", lw=1.8, |
| label="Connected branch") |
| ax.plot(scaled, np.minimum(connected, alternating), color="#0f172a", lw=2.7, |
| ls="--", label="Exact penalized optimum") |
| ax.axvline(1, color="#dc2626", ls=":", lw=1.4) |
| ax.scatter([1], [2], s=35, color="#dc2626", zorder=5) |
| ax.set_xlim(0, 2.1); ax.set_ylim(.95, 2.2) |
| ax.set_xlabel("Component penalty / side length $\\lambda/d$") |
| ax.set_ylabel("$J_n(\\lambda)/(nd)$") |
| ax.set_title("E. Exact penalty transition at $\\lambda=d$", loc="left", fontweight="bold") |
| ax.legend(frameon=False, fontsize=8, loc="lower right") |
| ax.grid(alpha=.15) |
|
|
| ax = axes[2, 1] |
| scaled_cost = np.linspace(0, 2 * PI, 501) |
| for n, color in zip([8, 32, 128], ["#94a3b8", "#8b5cf6", "#2563eb"]): |
| values = [penalized_optimum(n, float(c / n))["value"] for c in scaled_cost] |
| ax.plot(scaled_cost / PI, values, lw=1.9, color=color, label=f"$n={n}$") |
| ax.plot(scaled_cost / PI, [joint_penalty_limit(float(c)) for c in scaled_cost], |
| color="#0f172a", lw=2.6, ls="--", label="$\\min(2\\pi,\\pi+c)$") |
| ax.axvline(1, color="#dc2626", lw=1.2, ls=":") |
| ax.set_xlim(0, 2); ax.set_ylim(2.95, 6.55) |
| ax.set_xlabel("Scaled penalty $c/\\pi=n\\lambda/\\pi$") |
| ax.set_ylabel("Penalized optimum $J_n(c/n)$") |
| ax.set_title("F. Joint limit with $n\\lambda\\to c$", loc="left", fontweight="bold") |
| ax.legend(frameon=False, fontsize=8, loc="lower right") |
| ax.grid(alpha=.15) |
|
|
| ax = axes[1, 1] |
| selected = np.array([n * side_length(int(n)) for n in counts]) |
| repairs = np.array([connected_repair_cost(int(n)) for n in counts]) |
| ax.plot(counts, selected, color="#2563eb", lw=2.4, label="Alternating audit length") |
| ax.plot(counts, repairs, color="#dc2626", lw=2.4, label="Exact minimum connection repair") |
| ax.axhline(PI, color="#64748b", ls="--", lw=1.3, label="Each tends to $\\pi$") |
| ax.set_xscale("log", base=2); ax.set_xlim(3, 256); ax.set_ylim(1.9, 3.3) |
| ax.set_xlabel("Audited normal count $n$") |
| ax.set_ylabel("Length") |
| ax.set_title("D. Connecting the sampled optimum costs another $\\pi$", loc="left", fontweight="bold") |
| ax.legend(frameon=False, fontsize=8, loc="lower right") |
| ax.grid(alpha=.15) |
| fig.suptitle("Component complexity controls the exact audit frontier", |
| x=.055, y=1.01, ha="left", fontsize=17, fontweight="bold", color="#0f172a") |
| fig.tight_layout(h_pad=2.4, w_pad=2.5, rect=(0, .035, 1, .985)) |
| fig.text(.055, .005, |
| "Interior finite-angle model: $L(n,K)=[2n-\\min(K,n)]\\,2\\sin(\\pi/(2n))$. " |
| "The lower bound uses the classical regular-polygon Steiner theorem (Du-Hwang-Weng,1987).\n" |
| "No unrestricted opaque-disk optimum or numerical proof of that Steiner theorem is claimed.", |
| fontsize=9, color="#475569", linespacing=1.6) |
| directory = HERE / "figures" |
| directory.mkdir(exist_ok=True) |
| fig.savefig(directory / "complexity_frontier.png", dpi=185, |
| bbox_inches="tight", facecolor=fig.get_facecolor()) |
| fig.savefig(directory / "complexity_frontier.pdf", bbox_inches="tight", |
| facecolor=fig.get_facecolor()) |
| plt.close(fig) |
|
|
|
|
| def verify_penalties(): |
| cases = [] |
| maximum_error = 0.0 |
| for n in range(3, 61): |
| d = side_length(n) |
| penalties = [factor * d for factor in [0, .25, .75, 1, 1.25, 2, 5]] |
| penalties += [.02, .1, .5] |
| for penalty in penalties: |
| exact = penalized_optimum(n, penalty) |
| objectives = np.array([frontier_length(n, k) + penalty * k |
| for k in range(1, n + 1)]) |
| error = abs(float(objectives.min()) - exact["value"]) |
| assert error < 2e-12 |
| maximum_error = max(maximum_error, error) |
| for k in exact["minimizing_component_counts"]: |
| assert abs(objectives[k - 1] - exact["value"]) < 2e-12 |
| if penalty == d: |
| assert len(exact["minimizing_component_counts"]) == n |
| assert float(np.ptp(objectives)) < 2e-12 |
| cases.append({"n": n, "penalty": penalty, |
| "threshold": d, "value": exact["value"], |
| "phase": exact["phase"], "enumeration_error": error}) |
| limits = [] |
| for c in [0, .5 * PI, PI, 1.5 * PI, 2 * PI]: |
| sequence = [{"n": 2**power, |
| "value": penalized_optimum(2**power, c / 2**power)["value"]} |
| for power in range(2, 15)] |
| target = joint_penalty_limit(c) |
| assert abs(sequence[-1]["value"] - target) < 3e-4 |
| limits.append({"scaled_penalty_c": c, "limit": target, "sequence": sequence}) |
| fixed = [] |
| for penalty in [.01, .1, 1.0]: |
| n = 32768 |
| value = penalized_optimum(n, penalty)["value"] |
| target = 2 * PI + penalty |
| assert abs(value - target) < 2e-4 |
| fixed.append({"fixed_penalty": penalty, "n": n, |
| "value": value, "limit": target}) |
| return {"case_count": len(cases), "maximum_enumeration_error": maximum_error, |
| "cases": cases, "joint_limit_sequences": limits, |
| "fixed_positive_penalty_checks": fixed} |
|
|
|
|
| def main(): |
| records, offsets, maxima = verify() |
| penalties = verify_penalties() |
| make_figure() |
| report = {"status": "PASS", "n_range": [3, 60], |
| "component_budget_range": "K=1,...,n+2 for each n", |
| "base_family_count": len(records), "all_cyclic_offset_case_count": offsets, |
| "offset_validation": "All edge subsets and graph components checked explicitly; geometric rotation equivariance transfers complete base sampled-interval-union certificates to every cyclic offset.", |
| "scope": "Exact component-budget frontier for interior uniform-normal audits.", |
| "arithmetic": "Exact integer edge counts plus geometric analytic formulas evaluated in float64.", |
| "proof_dependency": STEINER_DEPENDENCY, |
| "not_claimed": ["Independent proof or numerical verification of the Steiner minimum tree theorem", |
| "The unrestricted fully opaque disk optimum", |
| "Interval-arithmetic certification"], |
| "max_observed_errors": maxima, |
| "fixed_budget_limit": "2*pi for each fixed positive integer K", |
| "repair_cost_formula": "(n-1)*2*sin(pi/(2*n))", |
| "repair_cost_limit": "pi", |
| "penalty_formula": "J_n(lambda)=min((2*n-1)*d+lambda,n*d+n*lambda)", |
| "penalty_threshold": "lambda=d=2*sin(pi/(2*n))", |
| "joint_penalty_limit": "If lambda_n->0 and n*lambda_n->c, J_n(lambda_n)->min(2*pi,pi+c)", |
| "fixed_positive_penalty_limit": "2*pi+lambda", |
| "penalty_verification": penalties, |
| "versions": {"numpy": np.__version__, "matplotlib": matplotlib.__version__}, |
| "cases": records} |
| (HERE / "COMPLEXITY_VERIFICATION.json").write_text(json.dumps(report, indent=2) + "\n") |
| summary = {key: report[key] for key in ["status", "base_family_count", |
| "all_cyclic_offset_case_count", "max_observed_errors"]} |
| summary["penalty_case_count"] = penalties["case_count"] |
| summary["max_penalty_enumeration_error"] = penalties["maximum_enumeration_error"] |
| print(json.dumps(summary, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
