#!/usr/bin/env python3 """Reproduce the finite-model scientific figures for AEQIRION. Requires NumPy, SciPy, and Matplotlib. These are mathematical model plots, not image experiments or physical measurements. Source data and numerical validation are saved in results/figure_data.json. """ from __future__ import annotations from itertools import product from datetime import datetime, timezone import json from math import comb, sqrt from pathlib import Path import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt from matplotlib.colors import BoundaryNorm, ListedColormap from matplotlib.patches import Patch, Rectangle from matplotlib.ticker import MaxNLocator import numpy as np from scipy.optimize import brentq ROOT = Path(__file__).resolve().parents[1] FIGURES = ROOT / "figures" RESULTS = ROOT / "results" def configure_style(): plt.rcParams.update({ "font.family": "DejaVu Sans", "font.size": 10, "axes.titlesize": 13, "axes.titleweight": "semibold", "axes.labelsize": 10, "axes.edgecolor": "#73808b", "axes.labelcolor": "#203344", "xtick.color": "#415565", "ytick.color": "#415565", "text.color": "#203344", "grid.color": "#dbe2e8", "grid.linewidth": 0.7, "axes.spines.top": False, "axes.spines.right": False, "legend.frameon": False, "savefig.facecolor": "white", "figure.facecolor": "white", "pdf.fonttype": 42, "ps.fonttype": 42, }) def save_figure(fig, name): for suffix in ("pdf", "png"): fig.savefig(FIGURES / f"{name}.{suffix}", dpi=200, bbox_inches="tight", pad_inches=0.08, metadata={"Creator": "AEQIRION reproducible model figures", "CreationDate": datetime(2026, 10, 20, tzinfo=timezone.utc), "ModDate": datetime(2026, 10, 20, tzinfo=timezone.utc)} if suffix == "pdf" else None) plt.close(fig) def optimal_one_nonnegative(n): # Rationalized form avoids cancellation in the displayed closed formula. return 2.0 * n / (2.0 * n + 1.0 + sqrt(4.0 * n * n + 1.0)) def local_point_eigenvalue(n): """Smallest eigenvalue of H0 + e_v e_v^T by its secular equation. H0 is the unscaled binary edge-sum Gram matrix. Its eigenvalue 2k has multiplicity binom(n,k), and e_v has squared projection binom(n,k)/2^n on that eigenspace. """ weights = np.array([comb(n, k) / (2 ** n) for k in range(n + 1)]) eigenvalues = np.arange(n + 1, dtype=float) * 2.0 def secular(x): return 1.0 + float(np.sum(weights / (eigenvalues - x))) answer = brentq(secular, 1e-18, 2.0 - 1e-12, xtol=1e-20, rtol=1e-14) assert 0.0 < answer < 2.0 assert answer <= 1.0 / (2 ** n) + 1e-13 assert abs(secular(answer)) < 2e-12 return answer def direct_cube_gram(n): size = 2 ** n out = n * np.eye(size) for x in range(size): for bit in range(n): out[x, x ^ (1 << bit)] = 1.0 return out def make_spectral_figure(): points = [] for n in range(1, 25): points.append({ "n": n, "vertices": 2 ** n, "one_local_point_row": local_point_eigenvalue(n), "one_optimal_nonnegative_row": optimal_one_nonnegative(n), "two_parity_rows_total_energy_one": 0.5, "one_signed_parity_row": 1.0, }) validation = [] for n in range(1, 9): size = 2 ** n gram = direct_cube_gram(n) point = np.zeros(size) point[0] = 1.0 even = np.array([float(x.bit_count() % 2 == 0) for x in range(size)]) even /= np.linalg.norm(even) local_numeric = float(np.linalg.eigvalsh(gram + np.outer(point, point))[0]) nonnegative_numeric = float(np.linalg.eigvalsh(gram + np.outer(even, even))[0]) local_error = abs(local_numeric - points[n - 1]["one_local_point_row"]) optimum_error = abs(nonnegative_numeric - optimal_one_nonnegative(n)) assert local_error < 2e-12 assert optimum_error < 2e-12 validation.append({"n": n, "direct_matrix_size": size, "local_formula_absolute_error": local_error, "optimal_formula_absolute_error": optimum_error}) fig, ax = plt.subplots(figsize=(7.1, 4.7)) fig.subplots_adjust(bottom=0.24, top=0.87) n_values = [p["n"] for p in points] ax.plot(n_values, [p["one_signed_parity_row"] for p in points], color="#84919b", linestyle=":", linewidth=1.7, label="One signed parity row") ax.plot(n_values, [p["two_parity_rows_total_energy_one"] for p in points], color="#5278b6", linestyle="--", linewidth=1.7, label="Two nonnegative parity rows") ax.plot(n_values, [p["one_optimal_nonnegative_row"] for p in points], color="#008b86", linewidth=2.1, marker="o", markevery=3, markersize=4.2, label="Best single nonnegative row") ax.plot(n_values, [p["one_local_point_row"] for p in points], color="#b84c69", linewidth=2.0, marker="s", markevery=3, markersize=4.0, label="One local point row") ax.set_yscale("log") ax.set_xlabel("Number of binary coordinates, n") ax.set_ylabel("Minimum eigenvalue of completed Gram matrix") ax.set_title("Sensor design controls spectral stability", loc="left", pad=14) ax.set_xlim(1, 24) ax.set_xticks([1, 4, 8, 12, 16, 20, 24]) ax.set_ylim(2e-8, 1.8) ax.grid(axis="y", which="major") ax.legend(loc="lower left", fontsize=9.2) fig.text(0.125, 0.015, "Baseline: all unscaled cube edge sums. Added rows have total squared norm 1.\n" "Synthetic finite-dimensional model; dense masks have an acquisition cost.", fontsize=8.5, color="#596d7d", va="bottom") save_figure(fig, "spectral_stability") return {"model": "H0=A^T A for all unscaled binary edge sums", "added_measurement_energy": 1, "points": points, "direct_matrix_validation": validation} def make_channel_figure(): rows = [] for q in range(2, 13): row = {"q": q, "separable_channels": q} for n in (2, 3, 6): size = q ** n rank = size - (q - 1) ** n row[f"arbitrary_channels_n{n}"] = (size + rank - 1) // rank rows.append(row) fig, ax = plt.subplots(figsize=(7.1, 4.6)) fig.subplots_adjust(bottom=0.24, top=0.87) q_values = [row["q"] for row in rows] ax.plot(q_values, q_values, color="#73818c", linestyle="--", linewidth=1.7, label="Separable masks: all n") for n, color, marker in ((2, "#b84c69", "s"), (3, "#008b86", "o"), (6, "#5278b6", "^")): ax.step(q_values, [row[f"arbitrary_channels_n{n}"] for row in rows], where="mid", color=color, linewidth=1.8, label=f"Arbitrary masks: n = {n}") ax.scatter(q_values, [row[f"arbitrary_channels_n{n}"] for row in rows], color=color, marker=marker, s=24, zorder=3) ax.set_xlabel("Common alphabet size, q") ax.set_ylabel("Minimum number of complete channels") ax.set_title("Coding lowers the exact channel threshold", loc="left", pad=14) ax.set_xlim(1.7, 12.3) ax.set_xticks(q_values) ax.yaxis.set_major_locator(MaxNLocator(integer=True)) ax.set_ylim(0.6, 12.7) ax.grid(axis="y") ax.legend(loc="upper left", fontsize=9.0) fig.text(0.125, 0.015, "Known positive diagonal masks; all coordinate-line sums in each channel.\n" "Counts include the unmodulated baseline. No conditioning guarantee is implied.", fontsize=8.5, color="#596d7d", va="bottom") save_figure(fig, "channel_thresholds") return {"formula_arbitrary": "ceil(q^n/[q^n-(q-1)^n])", "formula_generic_separable": "q", "counts_include_baseline": True, "points": rows} def line_multisets(array): signatures = [] shape = array.shape for axis in range(array.ndim): remaining = [i for i in range(array.ndim) if i != axis] for values in product(*(range(shape[i]) for i in remaining)): selector = [slice(None)] * array.ndim for i, value in zip(remaining, values): selector[i] = value signatures.append(tuple(sorted(array[tuple(selector)].tolist()))) return signatures def make_trade_figure(): f = np.zeros((3, 3, 3), dtype=int) g = np.zeros_like(f) for index in product(range(2), repeat=3): f[index] = 2 if sum(index) % 2 == 0 else 5 g[index] = 5 if sum(index) % 2 == 0 else 2 assert int(np.sum(f != g)) == 8 assert line_multisets(f) == line_multisets(g) assert len(line_multisets(f)) == 27 for tensor in (f, g): assert int(np.sum(tensor == 2)) == int(np.sum(tensor == 5)) == 4 cmap = ListedColormap(["#e7edf2", "#8dcfca", "#b84c69"]) norm = BoundaryNorm([-0.5, 1, 3.5, 5.5], cmap.N) fig, axes = plt.subplots(2, 3, figsize=(7.7, 5.15)) for row, (tensor, name) in enumerate(((f, "F"), (g, "G"))): for k in range(3): ax = axes[row, k] slice_values = tensor[:, :, k] ax.imshow(slice_values, cmap=cmap, norm=norm, interpolation="nearest") for i, j in product(range(3), repeat=2): value = int(slice_values[i, j]) ax.text(j, i, str(value), va="center", ha="center", fontsize=12, fontweight="semibold", color="white" if value == 5 else "#203344") ax.set_xticks([0, 1, 2]) ax.set_yticks([0, 1, 2]) ax.set_xticks(np.arange(-0.5, 3, 1), minor=True) ax.set_yticks(np.arange(-0.5, 3, 1), minor=True) ax.grid(which="minor", color="white", linewidth=1.6) ax.tick_params(which="both", length=0) ax.set_title(f"{name}, x₃ = {k}", fontsize=11, pad=6) if k == 0: ax.set_ylabel("x₁") if row == 1: ax.set_xlabel("x₂") if k < 2: ax.add_patch(Rectangle((-0.5, -0.5), 2, 2, fill=False, edgecolor="#203344", linewidth=1.5)) for spine in ax.spines.values(): spine.set_visible(False) fig.suptitle("A minimal eight-site ambiguity at every temperature", x=0.10, ha="left", y=1.015, fontsize=13, fontweight="semibold") legend = [Patch(facecolor="#e7edf2", label="Unchanged score 0"), Patch(facecolor="#8dcfca", label="Score 2"), Patch(facecolor="#b84c69", label="Score 5")] fig.legend(handles=legend, loc="lower center", bbox_to_anchor=(0.5, -0.055), ncol=3, fontsize=9) fig.subplots_adjust(wspace=0.22, hspace=0.38) save_figure(fig, "minimal_trade") return {"shape": [3, 3, 3], "F": f.tolist(), "G": g.tolist(), "changed_entries": 8, "equal_coordinate_line_multisets": True, "coordinate_line_multisets_checked": 27, "multiplicity_each_moved_score": 4, "interpretation": "Score tensors with exact equal line multisets; hence equal soft projections at every positive temperature."} def main(): FIGURES.mkdir(parents=True, exist_ok=True) RESULTS.mkdir(parents=True, exist_ok=True) configure_style() report = {"status": "PASS", "scope": "Mathematical model figures, not empirical performance", "spectral_stability": make_spectral_figure(), "channel_thresholds": make_channel_figure(), "minimal_trade": make_trade_figure()} (RESULTS / "figure_data.json").write_text(json.dumps(report, indent=2) + "\n") print(json.dumps({"status": "PASS", "vector_figures": [ "figures/spectral_stability.pdf", "figures/channel_thresholds.pdf", "figures/minimal_trade.pdf"], "direct_spectral_validations": len(report["spectral_stability"]["direct_matrix_validation"]), "trade_lines_checked": 27}, indent=2)) if __name__ == "__main__": main()