p5b_cbell_m5_flux_holonomy.py

#!/usr/bin/env python3
"""
m5_flux (Option 2) — adiabatic Berry-phase / U(1)-flux module: the CONTINUOUS-FLUX BRIDGE.

Goal (pre-registration lock 2026-06-25): does threading a continuous U(1) flux Phi through the loop enclosing
Alice's vortex pair produce, MICROSCOPICALLY, exp(i delta P_psi) on her fusion qubit?  I.e. is the
parity-resolved Berry phase delta(Phi) geometric, P_psi-diagonal, continuous, endpoint-matching?

Honesty up front (criterion 5): the exactly-solvable Kitaev model has a Z2 gauge field and NEUTRAL Majoranas
-> continuous U(1) flux is NOT native.  Inserting it (complex Peierls phase on a Dirac string) makes the
hopping complex -> charged BdG fermions -> LEAVES the exactly-solvable model.  This is the allowed
U(1)-extension; labeled as such, not claimed native.

The 5 LOCKED criteria (GO iff all pass; else honest PARTIAL):
  (1) GEOMETRIC: delta(Phi) rate/grid-independent (Berry, not dynamical).
  (2) P_psi-DIAGONAL (core, complement to B2b): the flux-induced holonomy on Alice's MZM subspace is
      diagonal in the Z_A (fusion-channel) basis -> only the ENCLOSED fermion f_A=(g1+i g2)/2 gets a Berry
      phase; channel-mixing (X_A/Y_A) components ~ 0.
  (3) CONTINUOUS + endpoints: delta(Phi) continuous; Phi=0 -> delta=0; one flux quantum -> delta=pi.
  (4) COMPUTED: delta from the Berry/Wilson loop over Phi, never fitted to 2sqrt2 cos^2.
  (5) CONVERGENCE + honesty: grid (adiabaticity) and finite-size quantified -> 0; honest if only effective.

REPRODUCIBILITY (fixed 2026-07-07, review issue 3):
  The old version called spla.eigsh(H, k, sigma=0, which='LM') WITHOUT a start vector v0.  In the
  near-degenerate 4-mode null space (|eps|~0.004) ARPACK then returns a RANDOM basis per run, so the
  basis-dependent per-mode 'selectivity' varied 0.503/0.614/0.183/3.275 over 4 runs while the docstring
  falsely claimed 'deterministic (seed 0)'.  Now:
   - near_zero_subspace takes a deterministic v0 = np.random.default_rng(seed).normal (default seed 2026)
     -> same seed = bit-identical run (verified below, criterion (a) of the multi-seed demo).
   - The physics diagnosis rests on GAUGE-INVARIANT quantities: the EIGENPHASES of the full 4x4 flux
     holonomy W (parallel transport Phi:0->2pi via unitarized overlap-matrix products, closed on the
     Phi=0 start basis) and ||[W, Z_A]||_F, with Z_A = 1 - 2*P_enc built from the enclosed-localization
     operator (basis-covariant, so the norm is basis-independent).  These are seed-stable.
   - The OLD per-mode selectivity is kept ONLY as a demonstrably basis-/seed-dependent diagnostic
     (multi-seed demo, criterion (c)) — it is NOT a lock quantity anymore.
Imports verified m3b primitives.
"""
# Console guard: printed output contains non-ASCII (U+2014). That character is cp1252-encodable,
# so this is precaution against a future edit, not a fix for an observed failure.
import sys

if __name__ == "__main__" and hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")

import json
import time
from pathlib import Path
import numpy as np
import scipy.sparse as sp
import scipy.sparse.linalg as spla
from p5b_m3b_kitaev_realspace import (site_index, site_pos, NN_OFFSETS, BVEC_CELL,
                                   vortex_pair_string, flux_field)
np.set_printoptions(precision=5, suppress=True)
T_START = time.time()
SEED_DEFAULT = 2026
SEEDS_DEMO = [2026, 7, 424242]


def build_lattice_flux(L1, L2, kappa, flips, cut_bonds, Phi, J=1.0):
    """m3b lattice but NN bonds in `cut_bonds` carry phase e^{i Phi}; A anti-Hermitian -> i*A Hermitian.
    Returns a SPARSE (csr) complex matrix (only ~6 neighbors/site)."""
    N = 2 * L1 * L2
    rows, colsidx, vals = [], [], []
    def add(r, c, v):
        rows.append(r); colsidx.append(c); vals.append(v)
    flips = flips or set(); cut_bonds = cut_bonds or set()
    for n1 in range(L1):
        for n2 in range(L2):
            iA = site_index(n1, n2, 0, L1, L2)
            for (o1, o2) in NN_OFFSETS:
                jB = site_index(n1 + o1, n2 + o2, 1, L1, L2)
                b = frozenset((iA, jB))
                amp = J * (-1.0 if b in flips else 1.0) * (np.exp(1j * Phi) if b in cut_bonds else 1.0)
                add(iA, jB, amp); add(jB, iA, -np.conj(amp))
    for n1 in range(L1):
        for n2 in range(L2):
            for (o1, o2) in BVEC_CELL:
                for s, sign in ((0, -kappa), (1, +kappa)):
                    j = site_index(n1, n2, s, L1, L2); k = site_index(n1 + o1, n2 + o2, s, L1, L2)
                    add(j, k, sign); add(k, j, -sign)
    return sp.coo_matrix((vals, (rows, colsidx)), shape=(N, N), dtype=complex).tocsr()


def pos_array(L1, L2):
    N = 2 * L1 * L2; pos = np.zeros((N, 2))
    for n1 in range(L1):
        for n2 in range(L2):
            for s in (0, 1):
                pos[site_index(n1, n2, s, L1, L2)] = site_pos(n1, n2, s)
    return pos


def near_zero_subspace(A, k, seed=SEED_DEFAULT):
    """k eigenvectors of H=i*A closest to zero (columns), and their energies, via sparse shift-invert.
    DETERMINISTIC: ARPACK start vector v0 from np.random.default_rng(seed) — without it the basis of the
    near-degenerate null space is random per run (review issue 3)."""
    H = (1j * A).tocsc()
    v0 = np.random.default_rng(seed).normal(size=H.shape[0])
    w, v = spla.eigsh(H, k=k, sigma=0.0, which='LM', v0=v0)
    idx = np.argsort(np.abs(w))
    return w[idx], v[:, idx]


# ================================================================ CLEAN geometry: enclosed pair + FAR reference
# Enclosed fusion fermion f_A = vortices (v1,v2), well-separated (small split, localized).  A FAR reference
# fermion (v3,v4) tests P_psi-selectivity by LOCALITY: flux around (v1,v2) must phase ONLY f_A, not the
# distant fermion (no channel-leakage).  The Dirac string runs AWAY from the reference (no overlap).
L1, L2, KAPPA = 24, 18, 0.25
v1, v2 = (6, 12), (18, 12)     # enclosed pair: horizontal, separation 12 cells -> localized, small split
v3, v4 = (6, 4), (18, 4)       # reference pair: FAR (8 rows below), flux-free
flips = set()
flips ^= vortex_pair_string(v1, v2, L1, L2)
flips ^= vortex_pair_string(v3, v4, L1, L2)
pos = pos_array(L1, L2)
vortex_cells = sorted(c for c, w in flux_field(L1, L2, flips).items() if w == -1)
print("=== m5_flux — continuous-flux Berry-phase bridge (clean geometry) ===")
print(f"lattice {L1}x{L2}, vortices {vortex_cells}; flux loop encloses ENCLOSED pair {v1},{v2}; reference {v3},{v4} FAR")


def core_y(cell):
    iA = site_index(cell[0], cell[1], 0, L1, L2); jB = site_index(cell[0], cell[1], 1, L1, L2)
    return 0.5 * (pos[iA, 1] + pos[jB, 1])


# Dirac string: vertical column of z-bonds at n1=12 (between v1,v2), running UP from row 12 to the top
# boundary (n2 12..L2-1) -> a loop around the enclosed pair crosses it once; stays FAR from reference (row 4).
cut = set()
for n2 in range(12, L2):
    iA = site_index(12, n2, 0, L1, L2); jB = site_index(12, n2, 1, L1, L2)
    cut.add(frozenset((iA, jB)))

# bulk gap = 2x smallest |eps| of the vortex-free lattice (sparse, a few modes near 0)
wvf, _ = near_zero_subspace(build_lattice_flux(L1, L2, KAPPA, set(), set(), 0.0), 2)
gap = 2 * np.min(np.abs(wvf))
NZ = 4
w0, V0g = near_zero_subspace(build_lattice_flux(L1, L2, KAPPA, flips, set(), 0.0), NZ)
print(f"bulk gap {gap:.3f}; 4 near-zero |eps| = {np.sort(np.abs(w0))}")


def wnear_mask(cell):
    sel = (np.abs(pos[:, 0] - pos[site_index(cell[0], cell[1], 0, L1, L2), 0]) < 3) & \
          (np.abs(pos[:, 1] - core_y(cell)) < 3)
    return sel

MASK_ENC = wnear_mask(v1) | wnear_mask(v2)
MASK_REF = wnear_mask(v3) | wnear_mask(v4)


def build_ZA(V0):
    """Fusion-parity operator Z_A in the Phi=0 start basis, built DETERMINISTICALLY from the
    enclosed-localization operator N_enc = V0^dag diag(MASK_ENC) V0: its top-2 eigenvectors span the
    enclosed 2-mode subspace -> Z_A = 1 - 2 P_enc.  Basis-COVARIANT (V0 -> V0 G gives Z_A -> G^dag Z_A G),
    so ||[W,Z_A]||_F is basis-independent."""
    Nenc = V0.conj().T @ (V0 * MASK_ENC[:, None])
    evals, evecs = np.linalg.eigh(Nenc)          # ascending
    Penc = evecs[:, -2:] @ evecs[:, -2:].conj().T
    ZA = np.eye(NZ) - 2.0 * Penc
    return ZA, np.sort(evals)[::-1]


def flux_sweep(M, seed):
    """One Phi:0->2pi sweep on the NZ near-zero modes.  Returns BOTH
     - GAUGE-INVARIANT: holonomy W = prod of SVD-unitarized overlap matrices (parallel transport), loop
       CLOSED on the Phi=0 start basis (H(2pi)=H(0), same seed -> same basis -> exact back-projection);
     - OLD basis-dependent diagnostics: per-mode tracked Berry phases (max-overlap matching), enclosed/
       reference localization, min step-overlap.  Kept to DEMONSTRATE their seed-dependence."""
    Phis = np.linspace(0, 2 * np.pi, M, endpoint=False)
    _, V = near_zero_subspace(build_lattice_flux(L1, L2, KAPPA, flips, cut, 0.0), NZ, seed=seed)
    V0 = V.copy()
    Vprev_W = V.copy()       # chain for the Wilson-loop holonomy (raw bases)
    Vprev_t = V.copy()       # chain for the old per-mode tracking (permuted bases)
    W = np.eye(NZ, dtype=complex)
    phase = np.zeros(NZ)
    min_overlap = 1.0
    for i in range(1, M + 1):
        if i < M:
            _, Vc = near_zero_subspace(build_lattice_flux(L1, L2, KAPPA, flips, cut, Phis[i]), NZ, seed=seed)
        else:
            Vc = V0          # Phi=2pi == Phi=0: close the loop, back-projection onto the start basis
        # --- gauge-invariant Wilson loop: unitarized overlap factor (parallel transport) ---
        O = Vprev_W.conj().T @ Vc
        Uu, _s, Vh = np.linalg.svd(O)
        W = W @ (Uu @ Vh)
        Vprev_W = Vc
        # --- OLD method: per-mode max-overlap tracking (basis-dependent, kept as diagnostic) ---
        Ot = Vprev_t.conj().T @ Vc
        perm = np.argmax(np.abs(Ot), axis=1)
        if len(set(perm)) < NZ:                   # ambiguous matching -> crossing
            min_overlap = 0.0
        Vc_p = Vc[:, perm]
        diag = np.sum(Vprev_t.conj() * Vc_p, axis=0)
        min_overlap = min(min_overlap, np.min(np.abs(diag)))
        phase += np.angle(diag)
        Vprev_t = Vc_p
    # localization of the Phi=0 modes (OLD diagnostic): weight near enclosed vs reference pair
    enc = np.array([np.sum(np.abs(V0[MASK_ENC, m]) ** 2) for m in range(NZ)])
    ref = np.array([np.sum(np.abs(V0[MASK_REF, m]) ** 2) for m in range(NZ)])
    return {"W": W, "V0": V0, "phase": phase, "enc": enc, "ref": ref, "min_overlap": min_overlap}


def old_selectivity(sw):
    """The OLD basis-dependent quantity (ref/enc per-mode Berry-phase ratio) — deterministic per seed now,
    but DIFFERENT across seeds: this is exactly why the un-seeded runs were irreproducible."""
    ph = (sw["phase"] + np.pi) % (2 * np.pi) - np.pi
    enc_modes = np.where(sw["enc"] > sw["ref"])[0]
    ref_modes = np.where(sw["ref"] >= sw["enc"])[0]
    b_enc = np.abs(ph[enc_modes]).mean() if len(enc_modes) else 0.0
    b_ref = np.abs(ph[ref_modes]).mean() if len(ref_modes) else 0.0
    return b_ref / max(b_enc, 1e-9), b_enc, b_ref, ph, enc_modes, ref_modes


def eigenphases(W):
    lam = np.linalg.eigvals(W)
    return np.sort(np.angle(lam)), float(np.max(np.abs(np.abs(lam) - 1.0)))


# ================================================================ main run (seed 2026): M=64 + control M=128
sw64 = flux_sweep(64, SEED_DEFAULT)
sw128 = flux_sweep(128, SEED_DEFAULT)
sel64, berry_enc, berry_ref, ph64, enc_modes, ref_modes = old_selectivity(sw64)
_, _, _, ph128, _, _ = old_selectivity(sw128)
mo64 = sw64["min_overlap"]
geo_err = np.max(np.abs(np.sort(ph64) - np.sort(ph128)))

ZA, loc_eigs = build_ZA(sw64["V0"])
eph64, unit_dev64 = eigenphases(sw64["W"])
eph128, unit_dev128 = eigenphases(sw128["W"])
comm_norm = float(np.linalg.norm(sw64["W"] @ ZA - ZA @ sw64["W"], 'fro'))
eph_grid_err = float(np.max(np.abs(eph64 - eph128)))

print(f"\n[modes] enclosed-localized modes {list(enc_modes)} (Berry |phase| {np.abs(ph64[enc_modes])}),"
      f" reference modes {list(ref_modes)} (Berry |phase| {np.abs(ph64[ref_modes])})")
print(f"[track] min step-overlap M=64: {mo64:.3f} (~1 = adiabatic, no crossing)")
print(f"\n[gauge-invariant] holonomy W (4x4, parallel transport, closed on start basis):")
print(f"  W eigenphases M=64 : {eph64}   (unitarity dev {unit_dev64:.1e})")
print(f"  W eigenphases M=128: {eph128}   (grid err max|d eigenphase| = {eph_grid_err:.2e})")
print(f"  Z_A localization eigenvalues (want ~[1,1,0,0]): {loc_eigs}")
print(f"  ||[W, Z_A]||_F = {comm_norm:.4f}   (P_psi-diagonal holonomy iff << 1)")

# criterion 1 GEOMETRIC: grid-independence (gauge-invariant W eigenphases; old per-mode err reported too)
print(f"\n[crit 1] grid-independence: |eigenphases(W,64)-eigenphases(W,128)| = {eph_grid_err:.2e}"
      f"  (old per-mode err {geo_err:.2e})")
# criterion 2 P_psi-SELECTIVE: gauge-invariant commutator norm (old ratio kept as deprecated diagnostic)
print(f"[crit 2] gauge-invariant ||[W,Z_A]||_F = {comm_norm:.4f}  (locked: diagonal iff <<1, threshold 0.1)")
print(f"         [deprecated, basis-dependent] enclosed |phase| {berry_enc:.4f} vs reference {berry_ref:.4f},"
      f" ratio {sel64:.3f} — seed-dependent, see multi-seed demo")

# criterion 3 CONTINUOUS + endpoints: accumulate delta(Phi) for the enclosed fermion
def delta_curve(M=160, seed=SEED_DEFAULT):
    Phis = np.linspace(0, 2 * np.pi, M + 1)
    _, V = near_zero_subspace(build_lattice_flux(L1, L2, KAPPA, flips, cut, 0.0), NZ, seed=seed)
    enc0 = np.array([np.sum(np.abs(V[MASK_ENC, m]) ** 2) for m in range(NZ)])
    j = int(np.argmax(enc0)); u = V[:, j].copy(); acc = [0.0]; tot = 0.0
    for i in range(1, M + 1):
        _, Vc = near_zero_subspace(build_lattice_flux(L1, L2, KAPPA, flips, cut, Phis[i]), NZ, seed=seed)
        ov = Vc.conj().T @ u; jj = int(np.argmax(np.abs(ov))); un = Vc[:, jj]
        ph = np.angle(np.vdot(u, un)); tot += ph; acc.append(tot); u = un
    return np.array(acc)
dphi = delta_curve(160)
print(f"\n[crit 3] enclosed-fermion accumulated Berry phase: delta(0)={dphi[0]:.3f}, "
      f"delta(half-flux)={dphi[len(dphi)//2]:.3f}, delta(full)={dphi[-1]:.3f}")
cont = np.max(np.abs(np.diff(dphi))) < 0.4

# ================================================================ multi-seed reproducibility demo (M=64)
print("\n=== multi-seed demo (M=64): what is reproducible, what never was ===")
sw64_rep = flux_sweep(64, SEED_DEFAULT)                 # (a) same seed again
det_dW = float(np.max(np.abs(sw64_rep["W"] - sw64["W"])))
det_dsel = abs(old_selectivity(sw64_rep)[0] - sel64)
print(f"(a) determinism: seed {SEED_DEFAULT} twice -> max|dW| = {det_dW:.1e}, |d selectivity| = {det_dsel:.1e}")
seed_rows = {}
for sd in SEEDS_DEMO:
    sw = sw64 if sd == SEED_DEFAULT else flux_sweep(64, sd)
    eph, _ = eigenphases(sw["W"])
    ZAs, _ = build_ZA(sw["V0"])
    cn = float(np.linalg.norm(sw["W"] @ ZAs - ZAs @ sw["W"], 'fro'))
    sel, _, _, _, _, _ = old_selectivity(sw)
    seed_rows[sd] = {"eigenphases": eph, "comm_norm": cn, "old_selectivity": float(sel)}
eph_mat = np.array([seed_rows[sd]["eigenphases"] for sd in SEEDS_DEMO])
eph_spread = float(np.max(eph_mat.max(axis=0) - eph_mat.min(axis=0)))
cn_arr = np.array([seed_rows[sd]["comm_norm"] for sd in SEEDS_DEMO])
sel_arr = np.array([seed_rows[sd]["old_selectivity"] for sd in SEEDS_DEMO])
print(f"(b) gauge-invariant, seed-stable:")
for sd in SEEDS_DEMO:
    r = seed_rows[sd]
    print(f"      seed {sd:>6}: W eigenphases {r['eigenphases']}, ||[W,Z_A]||_F {r['comm_norm']:.4f}")
print(f"      eigenphase spread across seeds = {eph_spread:.2e}; ||[W,Z_A]||_F mean {cn_arr.mean():.4f} std {cn_arr.std():.1e}")
print(f"(c) OLD basis-dependent selectivity varies with seed: {np.round(sel_arr,3).tolist()}"
      f"  (mean {sel_arr.mean():.3f}, std {sel_arr.std():.3f})")
print(f"      -> THIS is why the un-seeded runs gave 0.503/0.614/0.183/3.275 (independent-countercheck finding): the number is")
print(f"         a property of ARPACK's random basis choice, not of the physics.  Locks use W instead.")

# ================================================================ honest verdict
print("\n=== m5_flux VERDICT (5 locked criteria) ===")
c1 = eph_grid_err < 2e-2 and mo64 > 0.5
c2 = comm_norm < 0.1
c3 = cont and abs(dphi[0]) < 0.1 and abs(abs(dphi[-1]) - np.pi) < 0.2
print(f"  (1) geometric (grid-independent, adiabatic) . {'PASS' if c1 else 'FAIL'}  (eigenphase err {eph_grid_err:.1e}, min-ov {mo64:.2f})")
print(f"  (2) P_psi-diagonal holonomy (core) .......... {'PASS' if c2 else 'FAIL'}  (||[W,Z_A]||_F {comm_norm:.3f}, gauge-invariant)")
print(f"  (3) continuous + delta(0)=0, delta(full)=pi . {'PASS' if c3 else 'FAIL'}  (delta(full) {dphi[-1]:.3f} vs pi)")
print(f"  (4) computed not fitted ..................... PASS (Berry/Wilson integral over Phi)")
print(f"  (5) U(1)-extension honestly labeled ......... PASS (leaves exactly-solvable Z2; stated)")
GO = c1 and c2 and c3
print(f"\n  >>> {'GO — continuous-flux bridge microscopically realized (U(1)-extension)' if GO else 'PARTIAL — bridge not cleanly established (honest, no fudge)'} <<<")
print("\n  DIAGNOSIS (revised 2026-07-08 per independent countercheck — gauge-invariant numbers authoritative):")
print("   - Continuous U(1) flux needs complex hopping -> LEAVES the neutral-Majorana Z2 model (crit 5); the")
print("     induced U(1) charge is artificial and does not map cleanly onto the enclosed fusion parity.")
print(f"   - The gauge-invariant 4x4 flux holonomy is NEAR-TRIVIAL: W ~ identity, ||[W,Z_A]||_F = {comm_norm:.3f}")
print("     << 0.1 -> NO channel mixing.  (The sealed 25.6. 'non-abelian, MIXES ~0.9' diagnosis was a basis")
print("     artifact of the unseeded ARPACK pipeline — revised; see conflict_resolution.)")
print(f"   - THE obstruction is crit 3: accumulated Berry phase misses delta=pi at one flux quantum (delta(full)")
print(f"     = {dphi[-1]:.3f}); the single-tracked-mode 'pi' arises as a DIABATIC branch exchange at true crossings")
print("     along Phi (intra-pair gaps ~2e-18, independent audit) — not a robust adiabatic result.")
print("   => the continuous-flux bridge is NOT microscopically established; continuous-delta stays EFFECTIVE")
print("      (effective Ising-TQFT monodromy), consistent with Stage B.  The Z2-NATIVE endpoints (delta=0,pi)")
print("      and the parity-selective fusion-qubit ALGEBRA (M0 + Stage B B2) remain rigorous.")

# ---- conflict gate: RESOLVED 2026-07-08 (independent countercheck, 2 routes) ----
# History: 2026-07-07 the gauge-invariant recomputation contradicted the sealed 25.6. c1/c2 diagnosis
# ('||[W,Z_A]||~0.9, flux MIXES channels') -> deposit was placed on CONFLICT-HOLD.
# countercheck verdict (internal audit record, 2026-07-08, + addendum):
# the gauge-invariant numbers are CORRECT (independent dense-LAPACK route ||[W,Z_A]||_F=0.0130; explicit
# invariance proof V0->V0*G at 1e-16); the sealed diagnosis was a basis artifact of the unseeded ARPACK
# pipeline; the single-mode pi is a DIABATIC branch exchange at TRUE crossings along Phi (intra-pair gaps
# ~2e-18) -> single-mode pi and W~1 answer DIFFERENT questions, no method conflict.  Seal mechanism revised;
# overall verdict stays PARTIAL (c3 FAIL stands).  Citable: gauge-invariant values only; legacy selectivity
# 0.9697 stays deprecated.
CONFLICT = bool(c1) or bool(c2)  # historical table had c1,c2 FAIL; PASS here = flip vs the (revised) old seal
resolution_note = ("RESOLVED (2026-07-08, independent countercheck, 2 routes): gauge-invariant numbers "
                   "confirmed (W~identity, ||[W,Z_A]||_F={:.4f}); sealed 25.6. c1/c2 diagnosis revised as "
                   "basis artifact of the unseeded ARPACK pipeline; single-mode delta==pi (mod 2pi: {:.4f}) "
                   "= diabatic crossing artifact, no method conflict with near-trivial W (eigenphases max "
                   "{:.1e}). Verdict stays PARTIAL (c3 FAIL). Ref: internal audit record, "
                   "2026-07-08 (+ addendum)."
                   ).format(comm_norm, float((dphi[-1] + np.pi) % (2 * np.pi) - np.pi),
                            float(np.max(np.abs(eph64))))
print("\n  CONFLICT RESOLVED (2026-07-08): " + resolution_note)

# ================================================================ JSON deposit — held back on conflict
result = {
    "milestone": "m5_flux (Option 2) — continuous-flux Berry-phase bridge",
    "verdict": "GO" if GO else "PARTIAL",
    "deposit_status": "OK (conflict RESOLVED 2026-07-08 per independent countercheck; citable = gauge-invariant values only)",
    "conflict_resolution": {"status": "RESOLVED", "date": "2026-07-08", "note": resolution_note,
                   "resolution_ref": "internal audit record, 2026-07-08 (+ addendum)",
                   "sealed_2026_06_25": {"c1": "FAIL (grid-err large)", "c2": "FAIL (||[W,Z_A]||~0.9)",
                                          "c3": "FAIL (delta!=pi)", "status": "c1/c2-Teil REVIDIERT (Basis-Artefakt); c3 steht"},
                   "recomputed_gauge_invariant": {"c1_pass": bool(c1), "c2_pass": bool(c2),
                                                   "comm_norm_W_ZA_fro": comm_norm,
                                                   "W_eigenphase_max": float(np.max(np.abs(eph64))),
                                                   "delta_full_mod_2pi": float((dphi[-1] + np.pi) % (2 * np.pi) - np.pi)}},
    "criteria": {
        "c1_geometric": {"pass": bool(c1), "eigenphase_grid_err_64_128": eph_grid_err,
                          "old_permode_grid_err": float(geo_err), "min_step_overlap_M64": float(mo64)},
        "c2_Ppsi_diagonal": {"pass": bool(c2), "comm_norm_W_ZA_fro": comm_norm, "threshold": 0.1,
                              "old_selectivity_deprecated": float(sel64),
                              "note": "gauge-invariant lock; old per-mode selectivity is basis-dependent (see multi_seed)"},
        "c3_continuous_endpoints": {"pass": bool(c3), "delta_0": float(dphi[0]),
                                     "delta_half_flux": float(dphi[len(dphi) // 2]),
                                     "delta_full_flux": float(dphi[-1]),
                                     "delta_full_flux_mod_2pi": float((dphi[-1] + np.pi) % (2 * np.pi) - np.pi),
                                     "target_full_flux": float(np.pi),
                                     "max_step_jump": float(np.max(np.abs(np.diff(dphi))))},
        "c4_computed_not_fitted": {"pass": True, "note": "Berry/Wilson integral over Phi, never fitted to 2sqrt2 cos^2"},
        "c5_honest_U1_extension": {"pass": True,
                                    "note": "complex Peierls hopping leaves the exactly-solvable Z2 model; labeled, not claimed native"},
    },
    "gauge_invariant": {
        "W_eigenphases_M64": eph64.tolist(), "W_eigenphases_M128": eph128.tolist(),
        "W_unitarity_dev_M64": unit_dev64, "comm_norm_W_ZA_fro": comm_norm,
        "ZA_localization_eigs": loc_eigs.tolist(),
        "construction": "W = product of SVD-unitarized overlap matrices over Phi:0->2pi, closed on the Phi=0 "
                        "start basis; Z_A = 1 - 2*P_enc from top-2 eigenvectors of the enclosed-localization "
                        "operator (basis-covariant)",
    },
    "multi_seed": {
        "seeds": SEEDS_DEMO,
        "determinism_same_seed_max_dW": det_dW,
        "determinism_same_seed_d_selectivity": float(det_dsel),
        "W_eigenphases_per_seed": {str(sd): seed_rows[sd]["eigenphases"].tolist() for sd in SEEDS_DEMO},
        "eigenphase_spread_across_seeds": eph_spread,
        "comm_norm_per_seed": cn_arr.tolist(),
        "comm_norm_mean": float(cn_arr.mean()), "comm_norm_std": float(cn_arr.std()),
        "old_selectivity_per_seed": sel_arr.tolist(),
        "old_selectivity_mean": float(sel_arr.mean()), "old_selectivity_std": float(sel_arr.std()),
        "m3_reference_unseeded_runs": [0.503, 0.614, 0.183, 3.275],
    },
    "system": {"lattice": [L1, L2], "kappa": KAPPA, "NZ": NZ, "bulk_gap": float(gap),
                "near_zero_abs_eps": np.sort(np.abs(w0)).tolist(),
                "enclosed_pair": [list(v1), list(v2)], "reference_pair": [list(v3), list(v4)]},
    "physics_statement": "honest PARTIAL: the gauge-invariant flux holonomy is NEAR-TRIVIAL (W~identity, "
                          "||[W,Z_A]||_F=0.013 -> NO channel mixing; the sealed 25.6. 'non-abelian mixing' "
                          "diagnosis was a basis artifact, revised per independent countercheck 2026-07-08). THE "
                          "obstruction is criterion 3: the accumulated Berry phase misses delta=pi at one flux "
                          "quantum (the single-mode 'pi' is a diabatic branch exchange at true crossings, not a "
                          "robust adiabatic result). Continuous-delta stays EFFECTIVE; Z2-native endpoints "
                          "delta=0,pi and the fusion-qubit algebra remain rigorous. Citable: gauge-invariant "
                          "values only; legacy selectivity deprecated.",
    "provenance": {"date": "2026-07-07 (fix) / 2026-07-08 (conflict resolved)",
                    "script": "original construction script m5_flux.py (reproduced for this deposit by this file)",
                    "seed_default": SEED_DEFAULT, "seeds_demo": SEEDS_DEMO,
                    "fix": "review issue 3: deterministic ARPACK v0 + gauge-invariant W/Z_A locks; "
                           "2026-07-08: physics_statement/DIAGNOSIS revised + conflict RESOLVED per independent audit",
                    "grids": {"main_M": 64, "control_M": 128, "delta_curve_M": 160}},
    "runtime_s": round(time.time() - T_START, 1),
}
if __name__ == "__main__":
    # Write the deposited JSON only when this file is RUN, never on import:
    # an import would otherwise overwrite p5b_m5_flux.json in the record.
    # Anchor the write path to this file's own directory, so running the script from any
    # working directory still writes next to the deposit rather than into the caller's cwd.
    out_path = Path(__file__).resolve().parent / "p5b_m5_flux.json"
    with open(out_path, "w", encoding="utf-8") as fh:
        json.dump(result, fh, indent=2)
    print(f"\n[json] wrote p5b_m5_flux.json (verdict {result['verdict']}, runtime {result['runtime_s']}s)")