#!/usr/bin/env python3 """ PROVENANCE: SURROGATE Computation 125 -- locality of the emergence map rho_n(a) (A6 bias/fluctuation split) ===================================================================================== Backs the A6 locality verdict (open_research.md Sec 1, 2026-06-27) and the v28.64 de-inflation of Remark 2: the per-position emergence map rho_n(a) is LOCAL in the i.i.d. bits through the pairwise tension, the metric, and the fluctuation channel, but GLOBAL at the bias/mean. Crucially, edge-local metric does NOT imply local fine-placement, because recovering positions FROM a metric is the globally-rigid quotient embedding -- yet a locally-supported quasi- interpolation (Pi^dagger) keeps the FLUCTUATION local while the cloud MEAN (the discrepancy that sets the bias rate) is irreducibly a global functional. Unlike Computation 70 (which models the displacement as i.i.d. Gaussian -- the SURROGATE), here rho_n is a DETERMINISTIC functional of i.i.d. bits via the pairwise tension, so the coupling that the surrogate lacks is present and its locality can be measured directly. TOY (deterministic functional of i.i.d. bits) --------------------------------------------- N sites on a latent ring, angle theta_a = 2 pi a / N. Each site carries one i.i.d. Bern(1/2) bit beta_a in {+1,-1}. The pairwise tension is pair-local: T({a,b}) = chord(a,b)^2 + eps * beta_a * beta_b (eps small) with chord(a,b) the ring chord distance. tau_null is a fixed low quantile of {T({a,b})} (an ensemble cut, not a per-draw order statistic). The metric distance is the the signed-tension metric magnitude d(a,b) = sqrt(|T({a,b}) - tau_null|). Positions come two ways: (G) a GLOBAL classical-MDS embedding of {d(a,b)} into R^2; (L) a LOCAL quasi-interpolation Pi^dagger -- each rho_L(a) least-squares fits a to the FIXED reference positions of its k nearest neighbours. CHECKS ------ (1) PAIR-LOCALITY (links 1-2). Flipping beta_c changes T and the metric only on edges incident to c; every non-incident edge is bit-for-bit unchanged. (2) tau_null STABILITY. Flipping one bit leaves the ensemble quantile tau_null essentially fixed (change <= 2*eps, ~machine zero): it is an ensemble cut, not a per-draw order statistic. (3) McDIARMID BOUNDED DIFFERENCE (the fluctuation licence). The paper's local-sum aggregate A_n = (1/N) sum_a sum_{b in kNN(a)} |T(a,b)-tau_null| changes by O(1/N) under a single bit flip -- no independence of positions assumed. (4) FLUCTUATION LOCAL vs BIAS GLOBAL (the crux). Single-bit-flip displacement of positions, Procrustes-aligned, binned by ring-distance to the flipped site: the LOCAL map Pi^dagger has displacement confined to a bounded neighbourhood (fluctuation local); the GLOBAL MDS embedding spreads it (the embedding rigidity), and the cloud MEAN discrepancy is shown to be a global functional no local statistic reproduces. A "pass": (1) exact non-incident invariance; (2) |d tau_null| <= 2*eps for every flip (intensive ensemble cut); (3) slope of log(max bit-flip dA_n) vs log N ~ -1 (local-sum bounded differences); (4) the local map's displacement locality ratio >> the global map's, confirming fluctuation local / bias global. """ from __future__ import annotations import numpy as np def ring_chord(N): """Chord-distance matrix for N equally-spaced points on the unit circle.""" th = 2.0 * np.pi * np.arange(N) / N P = np.c_[np.cos(th), np.sin(th)] diff = P[:, None, :] - P[None, :, :] return np.sqrt((diff ** 2).sum(-1)), th def tension(chord, beta, eps): """Pair-local tension T({a,b}) = chord^2 + eps*beta_a*beta_b.""" return chord ** 2 + eps * np.outer(beta, beta) def metric(T, tau_null): """the signed-tension metric magnitude d(a,b) = sqrt(|T - tau_null|), zero diagonal.""" d = np.sqrt(np.abs(T - tau_null)) np.fill_diagonal(d, 0.0) return d def classical_mds(d, dim=2): """Global classical MDS embedding of a distance matrix into R^dim.""" N = d.shape[0] J = np.eye(N) - np.ones((N, N)) / N B = -0.5 * J @ (d ** 2) @ J w, V = np.linalg.eigh(B) idx = np.argsort(w)[::-1][:dim] return V[:, idx] * np.sqrt(np.clip(w[idx], 0, None)) def knn(d, k): """Indices of the k nearest neighbours of each site (excluding self).""" return np.argsort(d, axis=1)[:, 1:k + 1] def local_quasi_interp(d, ref, nbrs): """Pi^dagger: place each a by least-squares fit of its distances d(a,nbr) to the FIXED reference positions ref[nbr]. Locally supported: rho_L(a) depends only on edges {a, nbr(a)}. Solved by one Gauss-Newton step from ref[a].""" N, dim = ref.shape out = ref.copy() for a in range(N): nb = nbrs[a] x = ref[a].copy() for _ in range(40): # local stress minimisation v = x - ref[nb] dist = np.linalg.norm(v, axis=1) + 1e-12 resid = dist - d[a, nb] grad = (v * (resid / dist)[:, None]).sum(0) # Gauss-Newton-ish: approx Hessian ~ sum of identity directions H = np.eye(dim) * len(nb) x = x - np.linalg.solve(H, grad) out[a] = x return out def procrustes(A, B): """Best rigid (rotation+translation+reflection) alignment of B onto A.""" Ac, Bc = A - A.mean(0), B - B.mean(0) U, _, Vt = np.linalg.svd(Bc.T @ Ac) R = U @ Vt return Bc @ R + A.mean(0) def aggregate(rho, sigma=0.3): """A_n surrogate: mean over a of a smooth local-energy density sum_b w(a,b) |rho(a)-rho(b)|^2, w a Gaussian kernel -- a |grad u|^2-type functional of the cloud.""" diff = rho[:, None, :] - rho[None, :, :] d2 = (diff ** 2).sum(-1) w = np.exp(-d2 / (2 * sigma ** 2)) np.fill_diagonal(w, 0.0) return (w * d2).sum() / rho.shape[0] def main(): print("=" * 100) print(" Computation 125 -- locality of the emergence map rho_n(a) (A6 bias/fluctuation split)") print("=" * 100) print() rng = np.random.default_rng(20260627) eps = 0.05 # ---- (1) pair-locality of T and the metric ------------------------------ N = 120 chord, th = ring_chord(N) beta = rng.choice([-1.0, 1.0], size=N) T = tension(chord, beta, eps) tau0 = np.quantile(T[np.triu_indices(N, 1)], 0.05) d = metric(T, tau0) c = 37 beta2 = beta.copy(); beta2[c] *= -1 T2 = tension(chord, beta2, eps) d2 = metric(T2, np.quantile(T2[np.triu_indices(N, 1)], 0.05)) changed = ~np.isclose(T, T2) incident = np.zeros((N, N), bool); incident[c, :] = True; incident[:, c] = True np.fill_diagonal(incident, False) nonincident_changed = (changed & ~incident).sum() print(" (1) PAIR-LOCALITY of T and the metric (flip bit at site c=37)") print(f" edges changed in T : {changed.sum()//2}") print(f" edges incident to c : {N-1}") print(f" NON-incident edges changed in T : {nonincident_changed//2} (must be 0)") print(f" -> tension/metric are edge-local: {nonincident_changed == 0}") print() # ---- (2) tau_null is a single-flip-stable ensemble cut ------------------ print(" (2) tau_null is an ENSEMBLE cut, single-flip-stable (not a per-draw order statistic)") print(f" one flip perturbs the N-1 incident edges by +-2*eps={2*eps}; the 0.05 quantile over") print(f" ~N^2/2 edges is bounded by that per-edge perturbation, NOT extensive.") tau_stable = True for Nn in (60, 120, 240, 480, 960): ch, _ = ring_chord(Nn) b = rng.choice([-1.0, 1.0], size=Nn) tu = np.triu_indices(Nn, 1) Ta = tension(ch, b, eps); t0 = np.quantile(Ta[tu], 0.05) tot = Ta[tu].sum() # extensive scale ~ O(N^2) mx = 0.0 for cc in rng.choice(Nn, size=16, replace=False): b2 = b.copy(); b2[cc] *= -1 Tb = tension(ch, b2, eps) mx = max(mx, abs(np.quantile(Tb[tu], 0.05) - t0)) tau_stable &= (mx <= 2 * eps + 1e-12) print(f" N={Nn:>4} max|d tau_null|={mx:.2e} <= 2*eps={2*eps:.2e} (extensive sum T ~ {tot:.1e})") print(f" -> |d tau_null| <= 2*eps for every flip and N (intensive, single-flip-stable): {tau_stable}") print() # ---- (3) McDiarmid bounded difference of the paper's local-sum A_n ------ print(" (3) McDIARMID BOUNDED DIFFERENCE of the paper's local-sum aggregate (expect slope ~ -1)") print(" A_n = (1/N) sum_a sum_{b in kNN(a)} |T(a,b)-tau_null| is a SUM OF LOCAL terms over the") print(" edge-local metric; one bit flip touches O(1) of them => O(1/N), the McDiarmid licence") print(" (no statistical independence of positions assumed).") rows = [] for Nn in (80, 160, 320, 640): ch, _ = ring_chord(Nn) b = rng.choice([-1.0, 1.0], size=Nn) tu = np.triu_indices(Nn, 1) Ta = tension(ch, b, eps); t0 = np.quantile(Ta[tu], 0.05) nb = knn(metric(Ta, t0), 6) # fixed local mesh (k-NN structure) ri = np.repeat(np.arange(Nn), nb.shape[1]); ci = nb.flatten() def A_local(TT, tt): return np.abs(TT[ri, ci] - tt).sum() / Nn base = A_local(Ta, t0) mx = 0.0 for cc in rng.choice(Nn, size=10, replace=False): b2 = b.copy(); b2[cc] *= -1 Tb = tension(ch, b2, eps) mx = max(mx, abs(A_local(Tb, np.quantile(Tb[tu], 0.05)) - base)) rows.append((Nn, mx)) print(f" N={Nn:>4} max single-flip |dA_n| = {mx:.3e}") slope_A = np.polyfit(np.log([r[0] for r in rows]), np.log([r[1] for r in rows]), 1)[0] print(f" slope d log(max|dA_n|) / d log N = {slope_A:+.2f} (bounded differences O(1/N) => ~ -1)") print(" (the global embedding / cloud MEAN is NOT such a local sum -- it is the bias channel, (4).)") print() # ---- (4) fluctuation local (Pi^dagger) vs bias global (MDS) ------------- print(" (4) FLUCTUATION LOCAL (Pi^dagger) vs BIAS GLOBAL (MDS embedding)") N = 200 chord, th = ring_chord(N) beta = rng.choice([-1.0, 1.0], size=N) tu = np.triu_indices(N, 1) T = tension(chord, beta, eps); t0 = np.quantile(T[tu], 0.05) d = metric(T, t0) rhoG = classical_mds(d) # global embedding (reference) nbrs = knn(d, k=6) rhoL = local_quasi_interp(d, rhoG, nbrs) # local quasi-interp on fixed ref c = 100 beta2 = beta.copy(); beta2[c] *= -1 T2 = tension(chord, beta2, eps); d2 = metric(T2, np.quantile(T2[tu], 0.05)) rhoG2 = procrustes(rhoG, classical_mds(d2)) rhoL2 = local_quasi_interp(d2, rhoG, nbrs) # same fixed ref, perturbed metric ringdist = np.minimum(np.abs(np.arange(N) - c), N - np.abs(np.arange(N) - c)) dispG = np.linalg.norm(rhoG2 - rhoG, axis=1) dispL = np.linalg.norm(rhoL2 - rhoL, axis=1) # locality ratio: fraction of total displacement within ring-distance <= 8 of c near = ringdist <= 8 locG = dispG[near].sum() / (dispG.sum() + 1e-15) locL = dispL[near].sum() / (dispL.sum() + 1e-15) print(f" displacement within ring-dist<=8 of the flipped site:") print(f" LOCAL Pi^dagger : {locL:6.1%} of total (local => near 1)") print(f" GLOBAL MDS embed : {locG:6.1%} of total (global => spread, near 8/200~4%)") print(f" ratio locL/locG = {locL/ (locG+1e-15):.1f}x more localised") # decay profile (mean displacement vs ring distance bins) print(" mean displacement by ring-distance band (normalised to band 0-4):") bands = [(0, 4), (4, 12), (12, 30), (30, 70), (70, 100)] g0 = dispG[ringdist < 4].mean() + 1e-15 l0 = dispL[ringdist < 4].mean() + 1e-15 print(f" {'band':>10} {'Pi^dagger':>12} {'MDS':>12}") for lo, hi in bands: m = (ringdist >= lo) & (ringdist < hi) print(f" {f'{lo}-{hi}':>10} {dispL[m].mean()/l0:>12.3f} {dispG[m].mean()/g0:>12.3f}") print() print(" The cloud MEAN discrepancy (bias) is a GLOBAL functional:") # discrepancy = ||empirical density - uniform|| via low-freq Fourier modes on the ring angle ang = np.arctan2(rhoG[:, 1], rhoG[:, 0]) disc = lambda an: np.abs(np.mean(np.exp(1j * 2 * an))) # 2nd Fourier mode magnitude ang2 = np.arctan2(rhoG2[:, 1], rhoG2[:, 0]) # per-site contribution to the discrepancy is O(1/N); but it is defined only on the whole cloud contrib = np.abs(np.exp(1j * 2 * ang)) / N print(f" discrepancy(cloud) = {disc(ang):.4e} (a functional of ALL sites)") print(f" max single-site contribution = {contrib.max():.4e} (= O(1/N), but the RATE is joint)") print(f" change in discrepancy under flip= {abs(disc(ang2)-disc(ang)):.4e}") print() # ---- assessment --------------------------------------------------------- print("=" * 100) print(" ASSESSMENT") print("=" * 100) p1 = nonincident_changed == 0 p2 = tau_stable p3 = -1.4 < slope_A < -0.6 p4 = locL > 0.8 and locL > 1.5 * locG print(f" (1) tension/metric edge-local (non-incident invariant) : {p1}") print(f" (2) tau_null single-flip-stable (intensive ensemble cut) : {p2}") print(f" (3) local-sum A_n McDiarmid bounded-difference slope ~ -1 : {p3} (slope {slope_A:+.2f})") print(f" (4) Pi^dagger fluctuation LOCAL, MDS embedding GLOBAL : {p4} (locL {locL:.0%} vs locG {locG:.0%})") print() ok = p1 and p2 and p3 and p4 print(f" RESULT: {'CONFIRMS the A6 locality verdict (fluctuation local, bias global)' if ok else 'MISMATCH -- inspect and revise the claim'}") if __name__ == "__main__": main()