Chess as a Spectral Lattice Fermion System¶

A Working Research Notebook¶

"Can't stop the signal, Mal. Everything goes somewhere, and I go everywhere." — Mr. Universe, Serenity (Joss Whedon, 2005)

Signature epigraph of the spectral-research collection. The body of work — validated results and rigorous falsifications alike — was offered through conventional channels and dismissed as foolery. The math stands independently. The discipline since: ship every result, falsifications included, with full reproducibility and per-row provenance (the Mathematical Provenance Method). A corpus that publishes its own invalidations is harder to dismiss than one that doesn't, and propagates through every channel that ingests open research. The signal is in the world; it goes everywhere now.

Authors: Steven (mlehaptics Project) & Claude (Anthropic) Date: April 2026 Status: Active research — reproducible results with open problems Tools: Python 3, NumPy, SciPy (all code runnable standalone)

Project navigation + state-pointer¶

ReadTheDocs landing — https://mlehaptics.readthedocs.io/en/latest/ — is the canonical pointer to the current state across all sister notebooks in this project.

This notebook is the foundation document. Future framework additions will not be back-ported into it; the RTD landing tells you whether new sister notebooks or downstream developments are available.

Brief since-summary (as of 2026-05-08): - The framework documented here was instantiated on seven other domains: antikythera-spectral (Hellenistic bronze mechanism), doom-spectral (id Tech 1 game engine; v1.0.0; first end-to-end existence proof of the Rosetta Stone procedure from §42), ephemerides-spectral (live JPL DE441; matured through v0.26.0; PyPI: https://pypi.org/project/ephemerides-spectral/), othello-spectral (dynamic sheaf-Laplacian board), logo (non-board generalisation), chess-spectral-4d (Z_8^4 lattice extension; v1.1.1), mfo-spectral (Metric Field Ontology; foundational layer). - The Mathematical Provenance Method (MPM) formalised as the project's discipline (ephemerides notebook §0.0); qm_*.py and qm_*_dynamics.py machinery from this notebook ported into ephemerides-spectral as Kinematics + Dynamics modules. Instrument-first physics critique in ephemerides §20 cites this notebook's §1b.1 (Hatano-Nelson) and §1b.6 (Nambu NNET) as the dynamical-regime foundation. - Inkscape contribution shipped on the spectral-faithful branch — three new SVG filter primitives (feSpectralBilateral, feSpectralDistance, feSpectralNoise) using the same eigenbasis substrate this notebook establishes; the contribution's design notebook explicitly cites this notebook as the parent template. - mfo-spectral sister-notebook added (May 2026) — Metric Field Ontology, one candidate foundational-ontology framing hosted in the project (cavity-instrument analogy; fractal metric field; ~11D structure motivated independently of string theory's top-down route). Not the project's endorsed answer over alternatives; ephemerides §20 cites MFO as a worked example without picking a spatial-structure side. Future MPM target. - Ephemerides §21 — Tool-rejection as MPM-screening failure (symmetric counterpart to §20). Names the evaluator-side screening failure: rejecting work by which tool was used to make it, not by what it claims. Cites this notebook's §42 (AI-as-tool methodology) as the same vocabulary-match discipline applied at the producer side. Anchored on the historical orbital-mechanics chain DE441 traces back to (Copernicus / Bruno / Galileo / Kepler — each suppressed in their time and now load-bearing in the framework this project consumes). §21.3 names the disability-accommodation dimension explicitly: categorical tool bans function as participation barriers for contributors with aphantasia, ADHD, dyslexia, motor disabilities, and many other variations. MPM is tool-agnostic by design.

1. Overview & Motivation¶

What we set out to test¶

This research began with a question from Steven's friend about whether 1960s-era AI approaches could be combined with modern techniques to build efficient reasoning systems. During the investigation — which originally focused on Hyperdimensional Computing (HDC), Commodore 64 bank switching, and chess move compression — Steven posed a deeper question:

"What if we treated each chess piece like its own subatomic particle, with the movements being the perturbation, in a race to annihilate opposite-color pieces where momentum absorbs the annihilation energy?"

This led to a systematic investigation of whether chess has genuine spectral and quantum-mechanical structure — not as metaphor, but as shared mathematical formalism.

Where we ended up¶

The chess board is a classical lattice fermion system with: - A rank-5 total fiber bundle: 3 off-diagonal symmetric (non-spatial rule coupling), 1 off-diagonal antisymmetric (pawn directionality — the only Z₂-breaking operator content), 1 diagonal (the rook's spatially-mirrored shadow, hidden by the grid eigenbasis) - Piece types classifiable by unique spectral quantum number 5-tuples (all 6 pieces, including pawn) - Captures that decompose exactly into movement + annihilation + cross-term components - Rules that live in dimensions independent of the board surface - Non-trivial holonomy (fiber similarity around closed loops ≠ 1.0) - Cross-species field energy approximately conserved for non-king material - A 640-dimensional HDC encoding (5 D4 irreps + 3 symmetric fiber + 1 antisymmetric fiber + 1 diagonal fiber, each × 64 eigenmodes) connecting to UTLP S3 coprime-phase architecture - Spectrally derived piece values (mean degree / 2.6) replacing magic numbers, eliminating king domination

What this model is (and isn't)¶

This notebook documents a model of almost chess built with the tools and formulas that almost model the universe. Both sides of this correspondence are approximate:

The chess model captures thermodynamic and structural properties of the game (spectral decomposition, fiber bundles, conservation laws, symmetry groups) but provably cannot capture microscopic properties (specific legal moves, tactical sequences, multi-move combinations). The boundary between what's accessible and what isn't is the Level 2 / Level 3 distinction documented in §8b and empirically confirmed in §9h′ and §9o.

The physics tools (discrete spectral theory on finite graphs, finite-rank fiber bundles, D4 × Z₂ symmetry) are themselves approximations developed for systems analogous to chess but not identical. The correspondence between the two approximation frameworks — where they agree and where they disagree — is where the science lives.

We are not making a model of what people think chess is. We are not using chess language to describe physics, or physics language to describe chess strategy. We are characterizing a structured dynamical system on a lattice using spectral methods, and documenting which mathematical structures emerge from the game's geometry alone.

What's novel vs what's known¶

Finding	Status	Grounding	Connection type
Board Laplacian eigenvectors = 2D DCT basis	Known	Merris 1994; Spielman 2025	MATHEMATICAL
Per-piece spectral graph analysis	Known technique, new application	Chung 1997	MATHEMATICAL
Knight exact orthogonality to all sliding pieces (DCT basis)	Novel observation	Verified computationally; Cayley graph theorem (§1b.3)	MATHEMATICAL
5-tuple quantum number classification of pieces	Novel	No prior art found	—
Capture energy decomposition (movement + annihilation + cross-term)	Novel	Weyl perturbation theory applies	MATHEMATICAL
Rank-3 off-diagonal shared fiber bundle	Novel	No prior art found	—
Rank-5 complete fiber (3 symmetric + 1 antisymmetric + 1 diagonal)	Novel	Three orthogonal coupling subspaces; dual derivation via polarization (§9r)	—
Pawn antisymmetric fiber:		A_anti
Rank-4 full fiber (diagonal + off-diagonal) — rook's shadow	Novel	Verified: σ₅ = 0 (queen = bishop + rook)	—
Non-trivial holonomy on the bundle	Novel	Verified computationally; corrected in §8c	—
Cross-species field energy transfer with approximate conservation	Novel	ΔE < 0.2%; five independent frameworks (§1b.2)	MATHEMATICAL
Three-level hierarchy of rule encoding	Novel	Level 3 provably unrecoverable	—
Spectral piece values from movement graph topology	Novel	Correlation r=0.97 with traditional; lattice propagator mass-range (§1b.5)	MATHEMATICAL
D4 irrep decomposition of board eigenspace	Known technique, new application	Serre 1977; Püschel & Moura 2003 (§1b.3)	MATHEMATICAL
8-generator spectral lattice as coprime basis	Novel	Connects to UTLP S3	—
Coprime roll binding for spatial HDC	Novel application	UTLP S3 pattern applied to space	—
Pieces as perturbations of grid Hamiltonian	Known framework, new application	Hubbard 1963; Weyl 1912	MATHEMATICAL
Chebyshev compression of random walk distributions	Known technique, new application	Jackson 1912; NASA JPL	MATHEMATICAL
Pawn as non-Hermitian chiral fermion (no doubler)	Novel application	Ma & Zhang 2024; Chen, Giedt & Poppitz (§1b.1)	MATHEMATICAL
NHSE as pawn promotion-rank accumulation	Novel mapping	Shen et al. 2025; Hu 2025 (§1b.1)	MATHEMATICAL
Polarization reframing: (θ, r, c) parameterization	Novel	Lattice propagator anisotropy (§1b.5); D₄ orbit structure	MATHEMATICAL

Key citations¶

Chung, F.R.K. (1997). Spectral Graph Theory. AMS.
Spielman, D. (2025). Spectral and Algebraic Graph Theory. Yale.
Merris, R. (1994). Laplacian matrices of graphs. Linear Algebra and its Applications.
Weyl, H. (1912). Asymptotic distribution of eigenvalues. Math. Annalen, 71(4).
Hubbard, J. (1963). Electron correlations in narrow energy bands. Proc. Royal Society A, 276(1365).
Shuman, D.I. et al. (2013). Signal processing on graphs. IEEE SPM, 30(3).
Cvetković, D., Doob, M. & Sachs, H. (1980). Spectra of Graphs. Academic Press.
Kanerva, P. (2009). Hyperdimensional Computing. Cognitive Computation, 1(2).
Belkin, M. & Niyogi, P. (2003). Laplacian Eigenmaps. Neural Computation, 15(6).
Serre, J-P. (1977). Linear Representations of Finite Groups. Springer. (Character projection formula, §2.6)
Nakahara, M. (2003). Geometry, Topology and Physics. CRC Press. (Fiber bundles, connection forms)
Björck, Å. & Golub, G. (1973). Angles between subspaces. Math. Comp., 27(123).
Nakahara, M. (2003). Geometry, Topology and Physics. 2^nd ed. CRC Press.
Toussaint, D. & Wilczek, F. (1983). Particle-antiparticle annihilation in diffusive motion. J. Chem. Phys., 78.
Björck, Å. & Golub, G. (1973). Numerical methods for angles between subspaces. Math. Comp., 27(123).

Extended citations (from corrected-vocabulary literature survey)¶

The following references were identified through a systematic literature survey using corrected physical vocabulary — mass/damping for range, T-symmetry breaking for chirality, phase angle for piece identity — which unlocked connections that species-framed searches structurally missed. Full survey document: Spectral_lattice_fermion_model_of_chess.md. See §1b for the organized synthesis.

Dybalski, A., Stottmeister, A. & Tanimoto, Y. (2023). Lattice Green functions for pedestrians: Exponential decay. arXiv:2303.10754.
Bałaban, T. (1983). Regularity and decay of lattice Green's functions. Commun. Math. Phys., 89, 571–597.
Martin, P.A. Discrete scattering theory: Green's function for a square lattice. Colorado School of Mines.
Hatano, N. & Nelson, D.R. (1996). Localization Transitions in Non-Hermitian Quantum Mechanics. Phys. Rev. Lett., 77, 570.
Ma, C.-T. & Zhang, H. (2024). Lattice Chiral Fermion without Hermiticity. arXiv:2411.09886.
Nielsen, H.B. & Ninomiya, M. (1981). Absence of neutrinos on a lattice: (I). Proof by homotopy theory. Nuclear Physics B, 185(1), 20–40.
Püschel, M. & Moura, J.M.F. (2003). The Algebraic Approach to the Discrete Cosine and Sine Transforms. SIAM J. Computing, 32.
Püschel, M. & Moura, J.M.F. (2008). Algebraic Signal Processing Theory: Foundation and 1-D Time; 1-D Space. IEEE Trans. Signal Processing, 56(8).
Niven, I. (1956). Irrational Numbers. Carus Mathematical Monographs No. 11, MAA. (Corollary 3.12)
Calcut, J.S. (2009). Rationality and the Tangent Function.
Trevisan, L. (2011). Cayley Graphs and Their Spectrum. Stanford CS359G Lecture 6.
Liu, X. (2022). Eigenvalues of Cayley Graphs. Electronic J. Combinatorics, 29(2), #P2.9.
Baikov, V.A., Gazizov, R.K. & Ibragimov, N.H. (1988). Approximate Symmetries. Matematicheskii Sbornik, 136(178)(3), 435–450.
Bochicchio, L., Maiani, L., Martinelli, G., Rossi, G.C. & Testa, M. (1985). Chiral Symmetry on the Lattice with Wilson Fermions. Nucl. Phys. B, 262, 331.
Lüscher, M. (1998). Exact chiral symmetry on the lattice and the Ginsparg-Wilson relation. Phys. Lett. B, 428, 342.
Ginsparg, P.H. & Wilson, K.G. (1982). A Remnant of Chiral Symmetry on the Lattice. Phys. Rev. D, 25, 2649.
Seifert, U. (2012). Stochastic thermodynamics, fluctuation theorems and molecular machines. Rep. Prog. Phys., 75, 126001.
Roldán, É. & Parrondo, J.M.R. (2012). Entropy production and Kullback-Leibler divergence. Phys. Rev. E, 85, 031129.
Haldane, F.D.M. (1988). Model for a Quantum Hall Effect without Landau Levels. Phys. Rev. Lett., 61, 2015–2018.
Lang, L. et al. (2022). A Wigner-Eckart Theorem for Group Equivariant Convolution Kernels. ICLR 2022.
Katagiri, S. et al. (2025). Nambu Non-equilibrium Thermodynamics: Axiomatic Formulation. arXiv:2508.00207.
Sekizawa, D., Ito, S. & Oizumi, M. (2024). Decomposing Thermodynamic Dissipation via Oscillatory Modes. Physical Review X, 14, 041003.
Shen, R., Chen, T., Yang, B. & Lee, C.H. (2025). Observation of the non-Hermitian skin effect and Fermi skin. Nature Communications, 16, 1340.
Saburova, N. (2024). Spectrum of Schrödinger operators on subcovering graphs. arXiv:2409.05830.
Yumoto, J. & Misumi, T. (2024). Equivalence of lattice operators and graph matrices. Progress of Theoretical and Experimental Physics, 2024(2), 023B03.
Neufeld, O. et al. (2022). Selection rules in symmetry-broken systems by symmetries in synthetic dimensions. Nature Communications, 13, 1299.
Wang, J. & Wen, X.-G. (2022). Symmetric Mass Generation. Symmetry, 14(7), 1475.

1b. Theoretical Grounding: Literature Connections¶

This section organizes the results of a corrected-vocabulary literature survey around the notebook's empirical findings. The vocabulary corrections — mass/damping for range, T-symmetry breaking for chirality, phase angle for piece identity — unlocked connections to established mathematical frameworks across lattice field theory, non-Hermitian physics, spectral graph theory, and stochastic thermodynamics that species-framed searches structurally missed.

The strongest finding is that multiple connections are mathematically identical (same formalism, same equations), not merely analogical. Each subsection below identifies the notebook result, the grounding literature, and the connection type (MATHEMATICAL = identical formalism; ANALOGICAL = structurally similar, different mathematical content).

1b.1 The pawn sector: non-Hermitian lattice dynamics¶

Grounds: §9m (pawn directed Laplacian), §9n (rank-5 fiber), §9p (FA structural sensitivity)

The pawn's forward-only hopping (A_{ij} ≠ A_{ji}) makes its adjacency matrix non-Hermitian. This places the pawn squarely within the non-Hermitian lattice dynamics literature, where three independent results converge:

The Hatano-Nelson model. The 1D tight-binding Hamiltonian with asymmetric hopping H = Σ_j [t_R c†{j+1}c_j + t_L c†_j c], t_R ≠ t_L (Hatano & Nelson, Phys. Rev. Lett. 77, 570, 1996). The pawn IS this model at the maximally asymmetric limit t_L = 0: zero backward hopping, producing a non-Hermitian adjacency matrix with imaginary eigenvalues in the antisymmetric part. This is not a mapping onto — it is an instance of. Connection: MATHEMATICAL (exact).

The non-Hermitian skin effect (NHSE). Under open boundary conditions, all eigenstates of the Hatano-Nelson model accumulate at one boundary. For pawns, this boundary is the promotion rank. Pawn density accumulating at rank 8 is the NHSE realized on the chessboard lattice. Shen, Chen, Yang & Lee (Nature Communications 16, 1340, 2025) provide the first experimental observation of NHSE with many-body effects on a digital quantum computer, including the "Fermi skin" from Pauli exclusion — directly paralleling the hard-core occupation constraint (n_i ∈ {0,1}) documented in §4. Hu (Science Bulletin 70(1), 51–57, 2025) establishes that NHSE in all dimensions originates from point gaps in the complex energy spectrum, extending the framework to the 2D chessboard lattice. Connection: MATHEMATICAL (exact).

Nielsen-Ninomiya evasion. The Nielsen-Ninomiya theorem (Nielsen & Ninomiya, Nuclear Physics B 185(1), 20–40, 1981) proves that no lattice Hamiltonian can simultaneously be translation-invariant, have a correct continuum limit, be invertible for p ≠ 0, and preserve chiral symmetry — guaranteeing fermion doubling on Hermitian lattices. The pawn evades this theorem through non-Hermiticity: a forward-difference discretization (rather than the symmetric difference that maintains Hermiticity) has a single eigensolution, not a doubled pair. Ma & Zhang (arXiv:2411.09886, 2024) prove this rigorously: "By abandoning Hermiticity, the non-Hermitian formulation circumvents the Nielsen-Ninomiya theorem while maintaining chiral symmetry." Chen, Giedt & Poppitz (JHEP) confirm: "the usual 'doubled' fermion mode with opposite chirality is rapidly damped out because of non-Hermiticity." The pawn is the extreme case: the backward-propagating mode has exactly zero amplitude. Connection: MATHEMATICAL (exact).

Hard vs spontaneous T-breaking. The pawn breaks time-reversal symmetry at the rule level — the Hamiltonian itself is T-asymmetric, not just the ground state. The closest precedent is the Haldane model (Haldane, Phys. Rev. Lett. 61, 2015, 1988): spinless fermions on a honeycomb lattice with complex next-nearest-neighbor hoppings e^{iφ} that explicitly break T-symmetry in the Hamiltonian. Key structural difference: Haldane breaks T for all particles; chess breaks T for only one of six excitation types (the pawn). The CKM matrix phase in the Standard Model provides the particle physics analog — the single source of hard CP violation in an otherwise CP-symmetric theory. The ratio 1:5 (T-breaking to T-symmetric excitation types) in chess mirrors the SM structure. Connection: MATHEMATICAL for Haldane model structure; ANALOGICAL for SM comparison.

Entropy production. For T-symmetric excitations, forward and reverse paths have equal probability → zero KL divergence contribution. For the pawn, the reverse path has zero probability → KL divergence per pawn move is formally infinite (Seifert, Rep. Prog. Phys. 75, 126001, 2012; Roldán & Parrondo, Phys. Rev. E 85, 031129, 2012). Every pawn advance contributes maximal entropy production. The first-piece-advantage channel's monotonic decrease documented in §9p is a hard H-theorem — exact, not statistical, because T-violation is a rule, not a tendency. Connection: MATHEMATICAL (exact).

1b.2 The conservation law: five independent mathematical frameworks¶

Grounds: §5c (approximate conservation), §9h (unified field conjecture)

The notebook's finding that cross-species field energy is conserved to <0.2% for non-king material captures (§5c) is supported by five independent mathematical frameworks, each providing the same structural prediction: exact conservation in the T-symmetric sector, approximate violations proportional to T-breaking (pawn) activity.

BGI approximate Noether theory. For systems with Lagrangian L = L₀ + εL₁ (exact symmetry plus small perturbation), approximate symmetry generators X = X₀ + εX₁ guarantee approximate conservation laws with violations of O(ε) (Baikov, Gazizov & Ibragimov, Math. USSR Sb. 64, 427–441, 1989). If L_chess = L_{T-symmetric} + ε·L_{pawn}, BGI theory guarantees approximate conservation with violations O(ε). Connection: MATHEMATICAL (direct).

PCAC (Partially Conserved Axial Current). The relation ∂_μ J₅^μ = 2m_q · P(x) states that the divergence of the approximately conserved current is proportional to the explicit breaking parameter (quark mass m_q). This is the precise mathematical structure predicted for the chess lattice: conservation violation ∝ pawn activity parameter. Bochicchio, Maiani, Martinelli, Rossi & Testa (Nucl. Phys. B 262, 331, 1985; 554 citations) prove that a partially conserved axial current can be defined on the lattice with Wilson fermions, satisfying the usual current algebra requirements. Wilson fermions explicitly break chiral symmetry (analogous to pawns breaking T-symmetry), but PCAC is recovered with controlled violations. Connection: MATHEMATICAL (direct).

Lattice Ward identities with explicit breaking. Lüscher (Les Houches 1997, arXiv:hep-lat/9802029, §4.5) establishes that the PCAC relation on the lattice holds as ∂_μ (A_R)^a_μ(x) = 2m (P_R)^a(x) + O(a^k), where the error term directly quantifies how strongly chiral symmetry is violated. The isospin-breaking program in lattice QCD (Portelli, arXiv:1307.6056, 2013) demonstrates that ~1% breaking effects "can be taken into account perturbatively" — validating the chess model's prediction that <0.2% field energy redistribution is the perturbative signature of a small breaking parameter. Connection: MATHEMATICAL (direct).

Ginsparg-Wilson relation. The relation γ₅D + Dγ₅ = aDγ₅D (Ginsparg & Wilson, Phys. Rev. D 25, 2649, 1982; Lüscher, Phys. Lett. B 428, 342, 1998) provides a modified chiral symmetry that is exactly preserved even when naive chiral symmetry is explicitly broken. This suggests a stronger result than approximate conservation: there may exist a Ginsparg-Wilson-type modified T-reversal symmetry on the chess lattice that is exactly preserved, with an associated exact (not approximate) conservation law. Connection: MATHEMATICAL (deep) — this is a prediction, not yet verified.

KAM theory. Quasi-conservation improves exponentially as exp(−c·T/T₀) where T₀ is the fast timescale. If pawn evolution is slow compared to piece dynamics, conservation laws become exponentially good adiabatic invariants. Calleja, Celletti & de la Llave (2020) extend KAM to conformally symplectic (dissipative) systems, handling the pawn sector's irreversibility. Connection: MATHEMATICAL (structural).

1b.3 The spectral basis: Cayley graphs, dihedral irreps, and incommensurability¶

Grounds: §3 (piece resonant structures, knight DCT orthogonality), §9a (D4 irrep decomposition), §9r (polarization reframing)

The Cayley graph eigenvalue theorem. Both the knight's graph and the rook's graph, when defined on the torus Z_n × Z_n, are Cayley graphs on the same abelian group with different generating sets. The theorem (Trevisan, Stanford CS359G, 2011; Liu, Electronic J. Combinatorics 29(2), 2022) guarantees: "For a Cayley graph, a system of eigenvectors can be determined based solely on the underlying group, independently of the set S." Knight and rook share the 2D DFT/DCT eigenbasis — what differs is the eigenvalue spectrum. The knight's exact DCT orthogonality to all sliding pieces (§3) follows directly: same eigenvectors, different eigenvalue spectra, orthogonal spectral projections. Connection: MATHEMATICAL (exact).

DCT basis = dihedral group irreducible representations. Püschel & Moura (SIAM J. Computing 32, 2003; IEEE Trans. Signal Processing 56(8), 2008) prove within the algebraic signal processing framework that the DFT basis functions are the irreducible representations of the cyclic group, while the DCT basis functions are the irreducible representations of the dihedral group. On a 2D square lattice, D₄ is the relevant symmetry group. This grounds the claim in §9a that chess piece propagation projected onto the DCT basis reveals D₄ representation structure — the eigenbasis IS the irrep basis, by theorem, not by construction. Connection: MATHEMATICAL (exact).

Knight phase angle incommensurability. Niven's theorem (Irrational Numbers, 1956, Corollary 3.12): the only rational values of θ in [0°, 90°] for which sin θ is also rational are 0°, 30°, 90°. Since tan(arctan(½)) = ½ ∉ {0, ±1}, arctan(½) cannot be a rational multiple of π. The knight's propagation angle is an irrational multiple of π, making it genuinely incommensurate with the lattice. The mode never exactly repeats its phase relationship with the lattice — the Aubry-André model (1980) predicts quasiperiodic behavior and a localization transition at critical modulation strength for such incommensurate modulations. Connection: MATHEMATICAL (exact).

Knight effective dimensionality. The notebook's Weyl's law measurement (§6c) showing d_eff ≈ 3–5 for the knight graph is supported by Saburova (arXiv:2409.05830, 2024): for periodic graphs perturbed by adding long-range periodic edges, the perturbed graph is asymptotically isospectral to a higher-dimensional periodic graph. A square lattice perturbed by knight-move edges = the perturbation studied in this theorem. This provides a spectral-theoretic explanation for why the knight's movement graph is intrinsically higher-dimensional: it IS asymptotically isospectral to a higher-dimensional lattice. Connection: MATHEMATICAL (high).

1b.4 Selection rules: Wigner-Eckart for finite groups¶

Grounds: §9a (D4 irrep decomposition), new predictions

The Wigner-Eckart theorem factorizes matrix elements as ⟨α'j'm'|T_q^(k)|αjm⟩ = (CG coefficient) × (reduced matrix element)/√(2j'+1). The CG coefficient encodes geometry (mass-independent); the reduced matrix element encodes dynamics (mass-dependent). Lang et al. (ICLR 2022) generalize this to finite groups including D₄: "steerable kernel spaces are fully understood and parameterized in terms of 1) generalized reduced matrix elements, 2) Clebsch-Gordan coefficients, and 3) harmonic basis functions on homogeneous spaces."

For D₄, the tensor product decomposition is completely known and multiplicity-free (each irrep appears at most once in every product), so the W-E theorem applies with unique CG coefficients. The proposed chess excitation irrep assignments — Rook → B₁ (x²−y²), Bishop → B₂ (xy), Queen → B₁⊕B₂, King → A₁ (totally symmetric), Pawn → A₂ (pseudoscalar), Knight → E (2D irrep) — generate specific selection rules. Example: B₁⊗B₂ = A₂ — a rook-bishop interaction requires an A₂-type mediating operator; a purely A₁-symmetric operator cannot mediate rook↔bishop transitions. Rykhlinskaya & Fritzsche (Computer Physics Communications 174, 903, 2006) provide explicit CG coefficient computation for D₄ via the BETHE program.

The hierarchy is: leading order (D₄ CG selection rules, exact and mass-independent), first correction (reduced matrix elements carry mass dependence, modifying rates not allowed/forbidden status), higher corrections (mass-induced symmetry breaking allows weak "forbidden" transitions with amplitudes ∝ breaking parameter). This parallels HQET (Neubert, hep-ph/9610266, 1996), where 1/m_Q corrections break flavor symmetry perturbatively. Neufeld et al. (Nature Communications 13, 1299, 2022) confirm: "In symmetry-broken systems, the selection rules are replaced with selection rule deviations that can be used to extract information about the broken symmetry." Connection: MATHEMATICAL for D₄ CG framework; ANALOGICAL (structural) for HQET mass corrections.

1b.5 The mass-range relation: lattice propagators and spectral gaps¶

Grounds: §9r (θ, r, c polarization), §3 (degree range as spectral observable)

The central mathematical object is the lattice scalar propagator G(k) = 1/(m² + k̂²), where k̂_μ = (2/a)sin(k_μa/2). In coordinate space on a 2D square lattice: massless (m = 0) gives G® ~ ln® with infinite range; massive (m > 0) gives G® ~ exp(−mr)/√r with range ξ = 1/m. Dybalski, Stottmeister & Tanimoto (arXiv:2303.10754, 2023) prove rigorously that on a finite square lattice, the Green's function of the massive Laplacian decays exponentially: |G(x,y)| ≤ C exp(−m|x−y|).

The chess mapping is: massless excitations (rook, bishop, queen) ↔ gapless propagator with power-law/logarithmic decay (unlimited range on lattice); massive excitations (king, pawn) ↔ gapped propagator with exponential decay (unit-step range = maximally gapped, m → ∞). This is the lattice realization of the Yukawa mass-range relationship. The correlation length ξ = 1/m diverges for massless fields and is finite for massive ones — exactly the range parameter r in the §9r polarization framework. Connection: MATHEMATICAL (identical formalism).

Martin (Colorado School of Mines) establishes a critical subtlety: the lattice Green's function is anisotropic, unlike the isotropic continuum 1/√r. On the square lattice, propagation depends on direction. This grounds the §9r observation that angle θ and range r are independent parameters: anisotropy means direction class and propagation length are separable degrees of freedom.

Chess promotion (pawn → queen) is the reverse Higgs mechanism: a massive (gapped, unit-step) excitation transforms into a massless (gapless, unlimited-range) excitation. In lattice gauge theory, the Higgs and confinement phases are analytically connected (Fradkin & Shenker, Phys. Rev. D 19, 3682, 1979). Connection: ANALOGICAL — no standard term exists in particle physics for this process.

1b.6 Frontier frameworks: paths to formalization¶

Grounds: §9h (unified field conjecture — variational principle not yet identified)

Three recent results provide the most promising frameworks for rigorous formalization of the chess lattice field theory:

Nambu Non-equilibrium Thermodynamics (NNET). Katagiri et al. (arXiv:2508.00207, 2025) and Matsuoka, Katagiri & Sugamoto (arXiv:2509.12641, 2025) develop an axiomatic framework that covariantly integrates reversible structures (Nambu bracket) with irreversible structures (entropy gradients) in a single dynamical system. The velocity field decomposes into a reversible Nambu part and an irreversible entropy-gradient part. This directly parallels the chess model's structure: predominantly reversible dynamics (5 T-symmetric excitation types) plus one irreversible component (pawn) driving entropy production. Connection: MATHEMATICAL (high).

Spectral decomposition of entropy production. Sekizawa, Ito & Oizumi (Physical Review X 14, 041003, 2024) decompose the housekeeping entropy production rate into independent positive contributions from oscillatory modes, each proportional to frequency² × intensity. Only asymmetries in the coupling kernel break T — mapping directly to: only the pawn's directional asymmetry generates entropy production. The follow-up (arXiv:2510.21340, 2025) extends to nonlinear dynamics. Connection: MATHEMATICAL (high).

Lattice operator ↔ graph matrix equivalence. Yumoto & Misumi (Progress of Theoretical and Experimental Physics 2024(2), 023B03, 2024) establish rigorous equivalences between lattice field theory operators and spectral graph theory matrices: graph Laplacian = lattice scalar operator + Wilson term; antisymmetrized adjacency matrix for directed graphs; Dirac zero-mode count = sum of Betti numbers. This provides the mathematical bridge between the notebook's graph-theoretic descriptions (piece Laplacians, fiber bundles, spectral decompositions) and the lattice field theory formalism (propagators, gauge connections, fermion operators). Connection: MATHEMATICAL (high). See §9i item 9 for investigation plan.

1b.7 Cross-domain synthesis¶

The literature survey classifies the strongest connections by type. The following table collects the MATHEMATICAL connections — instances where the chess model and the physics formalism share identical equations or algebraic structures, not merely structural similarity.

Connection	Grounding reference	Notebook section
Lattice propagator G(k) = 1/(m² + k̂²) for excitation range	Dybalski et al. 2023; Bałaban 1983	§9r (range parameter r)
Pawn as Hatano-Nelson t_L = 0 model	Hatano & Nelson 1996	§9m (directed Laplacian)
Non-Hermitian skin effect = pawn promotion-rank accumulation	Shen et al. 2025; Hu 2025	§9m, §9p (FA channel)
Nielsen-Ninomiya evasion via forward-difference non-Hermiticity	Ma & Zhang 2024	§9m (A_anti content)
Knight/rook share DFT eigenvectors (Cayley graph theorem)	Trevisan 2011; Liu 2022	§3 (DCT orthogonality)
DCT basis = dihedral group irreps	Püschel & Moura 2003, 2008	§9a (D4 irrep channels)
arctan(½)/π irrational → knight incommensurate	Niven 1956; Calcut 2009	§9r (knight-offset θ class)
PCAC for approximate conservation with violations ∝ ε	Bochicchio et al. 1985; Lüscher 1997	§5c (approximate conservation)
W-E theorem separation: CG (mass-free) × reduced ME (mass-dependent)	Lang et al. ICLR 2022	§9a (D4 projections)
D₄ CG selection rules for excitation interactions	Standard point group theory	§9a (channel decomposition)
NNET reversible+irreversible coexistence framework	Katagiri 2025	§9h (unified field conjecture)
Spectral decomposition of entropy production by mode	Sekizawa et al. PRX 2024	§9h, §9p (FA monotone decay)
Lattice operators ↔ graph matrices equivalence	Yumoto & Misumi 2024	§9h (formalization path)
KL divergence = ∞ per pawn move	Seifert 2012; Roldán & Parrondo 2012	§9m (Z₂ breaking)
BGI approximate Noether theory for L₀ + εL₁	Baikov, Gazizov & Ibragimov 1988	§5c (conservation law)
Ginsparg-Wilson modified exact symmetry	Ginsparg & Wilson 1982; Lüscher 1998	§5c (stronger prediction)
Knight graph asymptotically isospectral to higher-D lattice	Saburova 2024	§6c (Weyl d_eff ≈ 3–5)
Haldane model as hard T-breaking precedent	Haldane 1988	§9m (pawn sector)

No papers directly presenting chess dynamics as a lattice field theory with these structures were found in the survey, confirming the model appears novel and unpublished as of April 2026.

2. Foundations: The Board as a Grid Graph¶

Claim¶

The 8×8 chess board, treated as a 4-connected grid graph, has a Laplacian whose eigenvectors are exactly the 2D Discrete Cosine Transform basis (tensor products of 1D path graph cosines), and whose eigenvalues are the Kronecker sum of path graph eigenvalues.

Theoretical basis¶

For the path graph P_n, eigenvalues are λ_k = 2(1 − cos(πk/n)) for k = 0,...,n−1 (Spielman 2025, Example 1.4). For the Cartesian product G □ H, L(G□H) = L_G ⊗ I + I ⊗ L_H, so eigenvalues are all pairwise sums λ_i^G + λ_j^H (Merris 1994).

Code¶

import numpy as np
from scipy.linalg import eigh

def sq(r,c): return r*8+c

# Build 8×8 grid graph (4-connected)
A_grid = np.zeros((64,64))
for r in range(8):
    for c in range(8):
        for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]:
            nr,nc = r+dr, c+dc
            if 0<=nr<8 and 0<=nc<8:
                A_grid[sq(r,c), sq(nr,nc)] = 1

L_grid = np.diag(A_grid.sum(axis=1)) - A_grid
evals_grid, evecs_grid = eigh(L_grid)

# Path graph P_8 eigenvalues
path_evals = np.array([2*(1 - np.cos(np.pi*k/8)) for k in range(8)])

# Predicted grid eigenvalues = all pairwise sums
predicted = np.sort(np.add.outer(path_evals, path_evals).flatten())
actual = np.sort(evals_grid)

error = np.linalg.norm(predicted - actual)
print(f"Kronecker sum prediction error: {error:.2e}")
# Result: 5.86e-16 (machine epsilon)

Result¶

CONFIRMED. Prediction error = 5.86×10⁻¹⁶ (machine epsilon). The grid spectrum is exactly the Kronecker sum of path graph spectra. The board's natural vibration modes are 2D cosines — identical to the DCT-II basis.

Verdict: KNOWN RESULT, correctly reproduced.¶

3. Piece Resonant Structures¶

Claim¶

Each chess piece type defines a distinct graph on the 64-vertex board. These graphs have characteristic Laplacian spectra (resonant frequencies) that encode the piece's movement properties. The knight graph is exactly spectrally orthogonal to all sliding piece graphs in the DCT basis.

Theoretical basis¶

The Laplacian L = D − A of any graph is positive semidefinite with eigenvalues encoding connectivity structure (Chung 1997, Ch. 1). The number of zero eigenvalues equals the number of connected components. The second-smallest eigenvalue λ₂ (algebraic connectivity) measures how well-connected the graph is (Fiedler, 1973).

Code¶

def knight_targets(r,c):
    for dr,dc in [(-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)]:
        nr,nc = r+dr, c+dc
        if 0<=nr<8 and 0<=nc<8: yield nr,nc

def bishop_targets(r,c):
    for dr,dc in [(-1,-1),(-1,1),(1,-1),(1,1)]:
        nr,nc = r+dr, c+dc
        while 0<=nr<8 and 0<=nc<8: yield nr,nc; nr+=dr; nc+=dc

def rook_targets(r,c):
    for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]:
        nr,nc = r+dr, c+dc
        while 0<=nr<8 and 0<=nc<8: yield nr,nc; nr+=dr; nc+=dc

def queen_targets(r,c):
    yield from bishop_targets(r,c); yield from rook_targets(r,c)

def king_targets(r,c):
    for dr in [-1,0,1]:
        for dc in [-1,0,1]:
            if dr==0 and dc==0: continue
            nr,nc = r+dr, c+dc
            if 0<=nr<8 and 0<=nc<8: yield nr,nc

def build_adjacency(fn):
    A = np.zeros((64,64))
    for r in range(8):
        for c in range(8):
            for tr,tc in fn(r,c): A[sq(r,c),sq(tr,tc)] = 1
    return A

piece_fns = {'Knight':knight_targets, 'King':king_targets,
             'Bishop':bishop_targets, 'Rook':rook_targets, 'Queen':queen_targets}

for name, fn in piece_fns.items():
    A = build_adjacency(fn)
    L = np.diag(A.sum(axis=1)) - A
    evals, _ = eigh(L)
    n_comp = np.sum(np.abs(evals) < 1e-10)
    nonzero = evals[evals > 1e-10]
    lambda2 = nonzero[0] if len(nonzero) > 0 else 0
    degrees = A.sum(axis=1)
    print(f"{name:8s}: components={n_comp}, λ₂={lambda2:.3f}, "
          f"λ_max={evals[-1]:.3f}, degree=[{int(degrees.min())},{int(degrees.max())}]")

Results¶

Piece	Components	λ₂	λ_max	Degree range	Regular?
Knight	1	1.143	13.013	[2, 8]	No
King	1	0.416	11.391	[3, 8]	No
Bishop	2	2.997	14.676	[7, 13]	No
Rook	1	8.000	16.000	[14, 14]	Yes
Queen	1	14.218	30.057	[21, 27]	No

Key observations: - Bishop has 2 connected components — this IS the color-binding rule, expressed as graph topology. - Rook is the only regular graph — every square has exactly 14 reachable targets. This is because the rook graph is the Cartesian product K₈ □ K₈, and the Cartesian product of regular graphs is regular. - Rook λ₂ = 8.000 with multiplicity 14 — this follows from the complete graph spectrum: K_n has eigenvalues 0 (multiplicity 1) and n (multiplicity n−1). The Kronecker sum gives λ₂ = 0+8 = 8.

Cross-piece orthogonality in DCT basis¶

from scipy.fft import dctn

# For each piece, build mobility matrix from e4, take 2D DCT
src = (4, 4)
piece_spectra = {}
for name, fn in piece_fns.items():
    mob = np.zeros((8,8))
    for tr,tc in fn(src[0], src[1]): mob[tr,tc] = 1.0
    piece_spectra[name] = dctn(mob, type=2, norm='ortho')

names = list(piece_spectra.keys())
for i, n1 in enumerate(names):
    for j, n2 in enumerate(names):
        if j <= i: continue
        s1 = piece_spectra[n1].flatten()
        s2 = piece_spectra[n2].flatten()
        cos = np.dot(s1,s2) / (np.linalg.norm(s1) * np.linalg.norm(s2))
        print(f"  {n1}-{n2}: {cos:.4f}")

Result¶

Pair	Cosine similarity
Knight-Bishop	0.00
Knight-Rook	0.00
Knight-Queen	0.00
Knight-King	0.00
Bishop-Rook	0.00
Bishop-Queen	0.69
Rook-Queen	0.72
Bishop-King	0.39
Rook-King	0.38

The knight is exactly orthogonal (0.00) to every other piece type in the DCT basis. The queen shows expected similarity to bishop (0.69) and rook (0.72), consistent with queen = bishop + rook. The bishop and rook are orthogonal to each other (0.00), confirming they operate on independent spatial axes.

Verdict¶

Per-piece spectral analysis: KNOWN TECHNIQUE, novel application to chess.
Knight exact DCT orthogonality: NOVEL OBSERVATION. No prior publication found.
Bishop 2-component = color-binding: KNOWN implication of graph theory (bipartite sub-result).
Rook regularity = K₈ □ K₈: KNOWN (Cartesian product of complete graphs).

Reinterpretation note (§9r). The per-piece framing used throughout §3 — six distinct species with their own spectral signatures — is correct as stated, but §9r offers a unified overlay in which the six species are six orientational polarization states of one lattice excitation labelled by (angle θ, range r, chirality c). Under that reading, the Queen–Bishop and Queen–Rook cosines reported above (0.69, 0.72) are predicted overlaps (queen's θ is the direct sum of bishop's and rook's), and the knight's exact DCT orthogonality is the statement that knight-offset is its own θ class. Nothing in §3 changes numerically; §9r just names why the numbers cohere.

Literature grounding (§1b.3). The knight's exact DCT orthogonality to all sliding-range excitations is a consequence of the Cayley graph eigenvalue theorem (Trevisan 2011; Liu 2022): all excitation types on the toroidal lattice share the DFT/DCT eigenbasis, differing only in eigenvalue spectra. The DCT eigenbasis itself is the irreducible representation basis of the D₄ dihedral group (Püschel & Moura 2003). The knight's phase angle arctan(½)/π is proven irrational (Niven 1956), making it genuinely incommensurate with the lattice periodicity.

4. The Lattice Fermion Model¶

Claim¶

Chess satisfies the formal requirements of a classical lattice fermion system: occupation numbers n_i ∈ {0,1} (Pauli exclusion), species-dependent hopping operators (piece movement rules), and measurable many-body correlations when multiple pieces interact. Pieces are classifiable by a unique 5-tuple of spectral quantum numbers.

Theoretical basis¶

Pauli exclusion: identical to hard-core lattice gas constraint (Baxter 1982).
Perturbation theory: Weyl's inequality |λ_k(A+E) − λ_k(A)| ≤ ||E||₂ (Horn & Johnson 2013, Thm 4.3.1).
Hubbard model connection: U→∞ limit (infinite on-site repulsion) gives hard-core exclusion (Hubbard 1963).

Quantum number classification¶

for name, fn in piece_fns.items():
    A = build_adjacency(fn)
    L = np.diag(A.sum(axis=1)) - A
    evals, _ = eigh(L)

    # Bipartiteness (adjacency spectrum symmetry)
    evals_A = np.sort(np.linalg.eigvals(A).real)
    pos = evals_A[evals_A > 0.01]; neg = -evals_A[evals_A < -0.01]
    n_match = min(len(pos), len(neg))
    sym_err = np.linalg.norm(np.sort(pos)[:n_match] - np.sort(neg)[:n_match]) if n_match > 0 else float('inf')
    is_bipartite = sym_err < 0.01

    n_comp = np.sum(np.abs(evals) < 1e-10)
    degrees = A.sum(axis=1)
    is_regular = np.std(degrees) < 0.01
    nonzero = evals[evals > 1e-10]
    lambda2 = nonzero[0] if len(nonzero) > 0 else 0

    print(f"{name:8s}: (parity={int(is_bipartite)}, topology={n_comp}, "
          f"homogeneity={int(is_regular)}, λ₂={lambda2:.3f}, BW={evals[-1]:.2f})")

Result¶

Piece	Parity	Topology	Homogeneity	λ₂	Bandwidth	Unique?
Knight	1	1	0	1.143	13.01	✓
King	0	1	0	0.416	11.39	✓
Bishop	0	2	0	2.997	14.68	✓
Rook	0	1	1	8.000	16.00	✓
Queen	0	1	0	14.218	30.06	✓

All 5-tuples are unique. The quantum numbers completely classify piece type. Notable: the knight is the only bipartite piece (parity=1, strict color alternation every move). This is correct graph theory — the knight graph on the standard board IS bipartite (every move changes square color). The bishop graph is NOT bipartite within its connected components despite being color-bound — diagonal paths within one color have both even and odd cycle lengths.

Weyl perturbation — pieces as Hamiltonian modifications¶

for name, fn in piece_fns.items():
    A = build_adjacency(fn)
    L = np.diag(A.sum(axis=1)) - A
    V = L - L_grid  # perturbation
    evals_piece, _ = eigh(L)
    max_shift = np.max(np.abs(evals_piece - evals_grid))
    weyl_bound = np.linalg.norm(V, 2)  # spectral norm
    print(f"{name:8s}: ||V||/||H₀||={np.linalg.norm(V,'fro')/np.linalg.norm(L_grid,'fro'):.2f}, "
          f"Δλ_max={max_shift:.3f}, Weyl bound={weyl_bound:.3f}, "
          f"holds={max_shift <= weyl_bound + 1e-10}")

Result¶

| Piece | ||V||/||H₀|| | Δλ_max | Weyl bound | Holds? | |-------|-------------|--------|------------|--------| | King | 0.92 | 4.530 | 7.409 | ✓ | | Knight | 0.93 | 5.318 | 8.324 | ✓ | | Bishop | 1.61 | 7.414 | 11.873 | ✓ | | Rook | 2.74 | 14.000 | 15.696 | ✓ | | Queen | 4.93 | 22.588 | 25.563 | ✓ |

Weyl's bound holds for all pieces. The king is the smallest perturbation of the grid (nearest-neighbor + diagonals ≈ the grid itself). The queen is the largest (long-range correlations restructure the lattice).

Many-body correlation (non-additive eigenvalue shifts)¶

def build_adj_removed(fn, removed):
    A = np.zeros((64,64))
    for r in range(8):
        for c in range(8):
            s = sq(r,c)
            if s in removed: continue
            for tr,tc in fn(r,c):
                t = sq(tr,tc)
                if t not in removed: A[s,t] = 1
    return A

A_rook = build_adjacency(rook_targets)
L_rook = np.diag(A_rook.sum(axis=1)) - A_rook
evals_free, _ = eigh(L_rook)

sq_A, sq_B = sq(4,3), sq(2,5)  # d4, f6

for label, removed in [("A only", {sq_A}), ("B only", {sq_B}), ("A+B", {sq_A, sq_B})]:
    A_b = build_adj_removed(rook_targets, removed)
    L_b = np.diag(A_b.sum(axis=1)) - A_b
    evals_b, _ = eigh(L_b)
    shift = evals_b - evals_free
    print(f"  {label}: ||shift|| = {np.linalg.norm(shift):.4f}")

# Compute correlation
evals_A, _ = eigh(np.diag(build_adj_removed(rook_targets, {sq_A}).sum(1)) - build_adj_removed(rook_targets, {sq_A}))
evals_B, _ = eigh(np.diag(build_adj_removed(rook_targets, {sq_B}).sum(1)) - build_adj_removed(rook_targets, {sq_B}))
evals_AB, _ = eigh(np.diag(build_adj_removed(rook_targets, {sq_A, sq_B}).sum(1)) - build_adj_removed(rook_targets, {sq_A, sq_B}))

correlation = (evals_AB - evals_free) - ((evals_A - evals_free) + (evals_B - evals_free))
ratio = np.linalg.norm(correlation) / np.linalg.norm(evals_AB - evals_free)
print(f"  Correlation/total ratio: {ratio:.1%}")

Result¶

Correlation term is 84.9% of total shift. Perturbations are massively non-additive. Two pieces on the rook graph interact so strongly that the many-body correlation dominates the single-particle shifts. This is analogous to strongly-correlated electron systems where exchange-correlation energy exceeds kinetic energy.

Verdict¶

Pauli exclusion (n_i ∈ {0,1}): EXACT — identical constraint, not analogous.
Weyl perturbation: KNOWN THEOREM, correctly applied to chess for the first time.
Quantum number 5-tuple: NOVEL — no prior classification found.
Many-body correlation: NOVEL APPLICATION of known perturbation theory.

5. Capture as Annihilation¶

Claim¶

Chess captures are spectrally decomposable into movement + annihilation + cross-term components. The cross-term (interaction energy) is the largest component. The moving piece's spectral signature survives while the captured piece's is inverted (charge conjugation).

Code¶

# Knight on e4 captures bishop on d6
src, dst = sq(4,4), sq(2,3)
VALS = {'N':3, 'b':-3.5}

before = np.zeros(64); before[src] = 3; before[dst] = -3.5
after = np.zeros(64); after[dst] = 3

delta_cap = evecs_grid.T @ (after - before)

# Decompose: movement component + annihilation component
move_only = np.zeros(64); move_only[dst] = 3; move_only[src] = -3  # piece relocates
annihilate_only = np.zeros(64); annihilate_only[dst] = 3.5  # target removed (negated)

move_comp = evecs_grid.T @ move_only
annihilate_comp = evecs_grid.T @ annihilate_only

# Verify exact decomposition
recon_error = np.linalg.norm(delta_cap - (move_comp + annihilate_comp))
print(f"Reconstruction error: {recon_error:.2e}")

E_move = np.linalg.norm(move_comp)**2
E_annihilate = np.linalg.norm(annihilate_comp)**2
E_total = np.linalg.norm(delta_cap)**2
E_cross = E_total - E_move - E_annihilate

print(f"Movement:     {E_move/E_total*100:.1f}%")
print(f"Annihilation: {E_annihilate/E_total*100:.1f}%")
print(f"Cross-term:   {E_cross/E_total*100:.1f}%")

Result¶

Reconstruction error: 9.29×10⁻¹⁷ (exact decomposition)
Movement energy: 35.1%
Annihilation energy: 23.9%
Cross-term (interaction): 41.0%

The cross-term is the largest component. Movement and annihilation spectral vectors have cos = 0.707 (= 1/√2 exactly), meaning they share modes — the energy of annihilation partially flows into the same modes that movement excites.

Aggressor asymmetry¶

Post-capture spectral overlap with original piece signatures: - Overlap with attacker's origin: 0.000 (has moved away) - Overlap with target's position: −1.000 (sign-inverted — charge conjugation) - Asymmetry: +1.000 in every case tested (N×b, B×p, R×r, Q×q)

Verdict¶

Exact decomposition: NOVEL. The specific decomposition of capture perturbations into movement + annihilation + cross-term is, as far as we can determine, unpublished.
Cross-term dominance: NOVEL FINDING with analogy to exchange-correlation energy.
Aggressor asymmetry = charge conjugation: NOVEL OBSERVATION.

Honest limitations¶

The entropy-based time-reversal test (Test 5 in original code) did not cleanly separate moves from captures. Von Neumann entropy of GFT coefficients projected onto the grid Laplacian is not the right quantity for detecting irreversibility. A piece-type-specific eigenbasis might work better — this is an open problem.

5b. Capture as Global Field Perturbation¶

The previous subsection treated capture as a local event (decomposing the perturbation at the capture square). Steven's key insight: the captured piece's value is lost from the entire field, and this should change the eigenstate of the whole system. The question is whether this global change has identifiable structure.

Theoretical basis¶

The board signal f: V → R is a graph signal (Shuman et al., 2013). Each piece contributes to this signal at its occupied vertex. The Graph Fourier Transform f̂ = U^T f (where U is the board Laplacian eigenbasis) decomposes the signal into resonant modes. Removing a piece at vertex k with value v subtracts v·δ_k from the signal, where δ_k is the Kronecker delta at k. In the GFT domain: Δf̂ = −v · U^T δ_k = −v · U[k,:] (the k-th row of the eigenbasis). This is an exact rank-1 perturbation.

Value × Position factorization¶

# Start with 16-piece middlegame position
position = {
    sq(7,4): 'K', sq(7,3): 'Q', sq(7,0): 'R', sq(4,2): 'B',
    sq(5,5): 'N', sq(6,3): 'P', sq(4,4): 'P', sq(6,5): 'P',
    sq(0,4): 'k', sq(0,3): 'q', sq(0,0): 'r', sq(0,2): 'b',
    sq(2,5): 'n', sq(1,3): 'p', sq(3,4): 'p', sq(1,5): 'p',
}

sig_full = board_signal(position)
coeffs_full = U.T @ sig_full

for sq_idx, piece in position.items():
    pos_after = {k:v for k,v in position.items() if k != sq_idx}
    sig_after = board_signal(pos_after)
    delta = U.T @ (sig_after - sig_full)
    shift_norm = np.linalg.norm(delta)
    print(f"{piece}@{sqname(sq_idx)}: ||Δf̂|| = {shift_norm:.3f}, |value| = {abs(VALS[piece]):.1f}")

Result¶

The spectral shift magnitude equals the piece value exactly (r = 1.0000). This is not empirical — it follows from the unitarity of the GFT: ||U^T (v·δ_k)|| = |v| · ||U^T δ_k|| = |v| · 1 = |v|, since the rows of U are orthonormal.

The shift direction is determined entirely by the piece's position (which column of U), not by piece type. Removing the white knight from f3 and removing a white pawn from f3 (if one were there) would shift the field in the same spectral direction with different magnitudes. This is the factorization: Δf̂ = value × eigenmode_at_square.

Cross-species field energy transfer¶

The critical test: does removing one piece species change the field energy measured on a different piece species' graph?

# Build piece-type Laplacians
piece_Ls = {}
for pchar, fn in piece_fns.items():
    A = build_adj(fn)
    piece_Ls[pchar] = np.diag(A.sum(axis=1)) - A

# Compute f^T L_piece f for the full position on each piece graph
sig = board_signal(position)
for pchar in ['N','B','R','Q','K']:
    E = float(sig.T @ piece_Ls[pchar] @ sig)
    print(f"E_{pchar} = {E:.0f}")

# Remove the bishop, measure energy change on ALL graphs
pos_no_bishop = {k:v for k,v in position.items() if k != sq(4,2)}
sig_nb = board_signal(pos_no_bishop)
for pchar in ['N','B','R','Q','K']:
    dE = float(sig_nb.T @ piece_Ls[pchar] @ sig_nb) - float(sig.T @ piece_Ls[pchar] @ sig)
    print(f"ΔE_{pchar} from removing bishop = {dE:+.0f}")

Result — Cross-species energy transfer¶

Removed piece	ΔE_Knight	ΔE_Bishop	ΔE_Rook	ΔE_Queen	ΔE_King
Bishop@c4	−98	−142	−189	−331	−98
Knight@f3	+528	−69	−144	−213	−60
Queen@d1	−306	−513	+594	+81	+1413
Rook@a1	−50	−215	+690	+475	−75
Pawn@e5	−17	−17	−16	−33	−4

Removing the bishop changes knight graph energy by −98. The bishop and knight have completely independent movement rules (orthogonal spectral subspaces, zero DCT cross-similarity from Section 3), yet removing the bishop measurably changes the field energy on the knight graph. This is cross-species field coupling.

Removing the queen causes rook and king graph energies to INCREASE (+594 and +1413). Material removal doesn't always lower field energy — it can destabilize the field on certain piece graphs. The queen at d1 was acting as a field stabilizer: her spectral contribution smoothed the signal on the rook and king graphs. Removing her makes the remaining signal rougher (higher Laplacian quadratic form = more variation across connected vertices).

Theoretical interpretation¶

The Laplacian quadratic form f^T L f = Σ_{(i,j)∈E} (f_i − f_j)² (Chung 1997, Eq. 1.5) measures the total variation of signal f across edges of graph G. When f includes contributions from multiple pieces, removing one can either: - Decrease total variation (if the removed piece's value contrasted with its graph-neighbors → it was a "rough spot") - Increase total variation (if the removed piece's value was similar to its graph-neighbors → it was a "smooth spot" whose removal creates discontinuity)

The queen on d1 has value 9. On the king graph (nearest-neighbor movement), her neighbors include the king on e1 (value 100). The queen-king value difference is 91, contributing heavily to the king graph's quadratic form. Removing the queen eliminates this particular 91-unit gradient, but the king's value (100) now contrasts even more sharply with the remaining small-value pieces around it — hence the energy increase.

This is precisely analogous to spectral weight transfer in condensed matter physics: removing a resonant state doesn't simply reduce spectral weight — it redistributes it across other states (Basov et al., 2011. Electrodynamics of correlated electron materials. Rev. Mod. Phys., 83(2), 471).

Eigenbasis compression of capture shifts¶

Which piece's eigenbasis best compresses the field shift from its own removal?

Removed	Knight basis	Bishop basis	Rook basis	Queen basis	King basis	Grid basis
Bishop@c4	23 modes	12 modes	14	26	26	35
Knight@f3	17 modes	7 modes	26	17	20	22
Queen@d1	29 modes	14 modes	22	27	27	34

(Modes needed for 90% of shift energy)

The bishop's eigenbasis consistently compresses all capture shifts best — even the knight's removal and queen's removal compress better in the bishop basis than in their own. This is unexpected. The bishop's diagonal eigenmodes appear to be a more efficient general-purpose basis for representing position-dependent changes on the 8×8 board, likely because diagonal modes have spatial frequencies that align well with the board's geometry regardless of which square is perturbed.

Verdict¶

Value × position factorization: MATHEMATICALLY EXACT (follows from GFT unitarity).
Cross-species energy transfer: NOVEL FINDING. No prior publication found documenting cross-graph Laplacian energy transfer on chess piece graphs.
Energy increase from material removal: NOVEL. The sign reversal (removing material increases field energy on certain graphs) demonstrates the field is genuinely coupled, not decomposable into independent per-species components.
Bishop eigenbasis as universal compressor: NOVEL OBSERVATION. Requires further investigation — may be a property of diagonal eigenmodes on square lattices generally, not chess-specific.

5c. Rigorous Field Coupling Analysis¶

Section 5b established that cross-species energy transfer exists. This section develops the analytical framework, measures the coupling structure, and tests for conservation laws.

Analytical decomposition of ΔQ_G¶

The Laplacian quadratic form Q_G(f) = f^T L_G f measures signal smoothness on graph G (Chung 1997, Eq. 1.5). When a piece of value v is removed from square k, f' = f − v·δ_k, and:

ΔQ_G = f'^T L_G f' − f^T L_G f = −2v·(L_G f)k + v²·(L_G)

Term 1 (coupling): −2v·(L_G f)_k depends on the interaction between the full field f and graph G's connectivity at position k. This is the physically interesting term — it measures how the existing field pattern couples to the graph structure.

Term 2 (self-energy): v²·d_k depends only on the piece value and the degree of vertex k in graph G. This is purely geometric — it knows nothing about what other pieces are on the board.

# Verify analytical decomposition (knight graph example)
L_N = piece_Ls['N']
for sq_idx, piece in position.items():
    v = VALS[piece]; k = sq_idx
    Lf = L_N @ sig
    coupling = -2 * v * Lf[k]
    self_energy = v**2 * L_N[k, k]
    predicted = coupling + self_energy
    # Compare to brute-force computation
    sig_after = board_signal({s:p for s,p in position.items() if s != sq_idx})
    actual = float(sig_after.T @ L_N @ sig_after) - float(sig.T @ L_N @ sig)
    error = abs(actual - predicted)
    # error = 0.0 for every piece (exact, not approximate)

Result¶

Decomposition error = 0.0 for all 16 pieces. This is not a numerical approximation — it is a mathematical identity following from expanding the quadratic form. Every field energy change from capture is exactly and completely determined by two terms: a coupling term that depends on the field-graph interaction, and a self-energy term that depends only on topology.

Coupling field matrix and channel structure¶

For each piece graph G, the vector (L_G f) gives the "coupling field" — how graph G perceives the gradient of the board signal at each square. Stacking these for all 5 piece types gives a 5×64 coupling field matrix.

coupling_matrix = np.array([piece_Ls[p] @ sig for p in ['N','B','R','Q','K']])
U_c, S_c, Vt_c = svd(coupling_matrix, full_matrices=False)

Result — Coupling channels¶

Channel	σ	% of total	Cumulative
σ₁	4014.4	98.1%	98.1%
σ₂	393.3	0.9%	99.0%
σ₃	290.7	0.5%	99.5%
σ₄	277.5	0.5%	100.0%
σ₅	0.0	0.0%	100.0%

Effective rank = 4, but σ₁ alone captures 98.1% of all coupling. Nearly all cross-species field coupling flows through a single dominant channel. The dominant channel's loadings: Queen (−0.780), Rook (−0.527), Bishop (−0.252), King (−0.175), Knight (−0.139) — ordered by piece range/value, with the queen dominating.

σ₅ = 0.0 exactly means the 5 piece types' coupling fields span only 4 dimensions. One coupling field is linearly dependent on the other four.

Cross-piece coupling field correlations¶

	N	B	R	Q	K
N	1.000	0.849	0.880	0.886	0.816
B	0.849	1.000	0.921	0.964	0.901
R	0.880	0.921	1.000	0.991	0.912
Q	0.886	0.964	0.991	1.000	0.925
K	0.816	0.901	0.912	0.925	1.000

All correlations > 0.81. All piece types see nearly the same field gradient. The rook-queen correlation of 0.991 is consistent with the queen containing the rook's movement as a subset. The differences between species' field views are small perturbations on a shared dominant mode — the chess field is almost piece-type-independent at the gradient level.

Coupling sensitivity is spectrally smooth¶

DCT compression of the coupling sensitivity map −2·(L_G f) for each piece graph:

Graph	Modes for 90%	Modes for 99%
Knight	13/64	21/64
Bishop	16/64	26/64
Rook	15/64	25/64
Queen	16/64	24/64
King	16/64	25/64

The coupling sensitivity compresses to 13–16 modes (4–5× compression). It varies smoothly across the board, not randomly — the position dependence of field coupling is itself spectrally structured.

Approximate energy conservation for non-king pieces¶

Total field energy (sum of f^T L_G f across all 5 piece graphs) after removing each piece:

Removed	Piece value	ΔE_total	% change	Conserved?
Pawns (×6)	1	−87 to +587	< 0.1%	~YES
Knights (×2)	3	+42	< 0.01%	~YES
Bishops (×2)	3.5	−858 to +1006	< 0.1%	~YES
Rooks (×2)	5	+825 to +895	< 0.1%	~YES
Queens (×2)	9	+1269 to +1458	< 0.2%	~YES
Kings (×2)	100	−540,000	−51%	NO

For all non-king pieces, total multi-graph field energy changes by less than 0.2%. The field doesn't lose energy — it redistributes across species graphs. Capture is closer to elastic scattering than dissipation for normal material. The field REDISTRIBUTES rather than dissipates.

The king is the sole exception (~51% energy loss), which is consistent with its role: the king's extreme value (100 vs 1–9) dominates the field. Removing it is catastrophic — equivalent to removing the ground state from a quantum system.

Asymmetric species transfer matrix¶

The transfer matrix T[A,B] = average ΔE on graph B when a piece of type A is removed has: - Asymmetry: ||T − T^T|| / ||T|| = 1.40. Coupling from species A to B ≠ B to A. - Effective rank: 1 (dominated by king row/column due to extreme values). - The asymmetry means there is directed flow in the field coupling, not symmetric exchange.

Verdict¶

Analytical decomposition (coupling + self-energy): MATHEMATICALLY EXACT (identity from quadratic form expansion).
Rank-4 coupling channels (98.1% in σ₁): NOVEL. The field coupling structure is almost one-dimensional.
Cross-species correlation > 0.81: NOVEL. All pieces see nearly identical field gradients.
Approximate conservation for non-king material: NOVEL. Field energy redistributes rather than dissipates — captures are approximately elastic in the multi-graph energy sense.
Asymmetric transfer matrix: NOVEL. Directed coupling flow between species.

Literature grounding (§1b.2). The approximate conservation result (<0.2% field energy change for non-king captures) is supported by five independent mathematical frameworks: BGI approximate Noether theory guarantees violations O(ε) for L = L₀ + εL₁; the PCAC relation provides the precise template (conservation violation ∝ explicit breaking parameter); lattice Ward identities with Wilson fermions quantify symmetry-breaking effects; the Ginsparg-Wilson relation suggests a stronger result (exact modified conservation law); and KAM theory predicts exponentially good adiabatic invariants when pawn timescales separate from piece dynamics. The isospin-breaking program in lattice QCD (Portelli 2013) demonstrates that comparable ~1% breaking effects are treated perturbatively — validating the perturbative regime of this finding.

6. Rules Live in Their Own Dimensions¶

Claim¶

Chess piece movement rules are abstract objects that exist in dimensions independent of the board they're embedded on. Specifically: (a) certain spectral properties are invariant across board sizes; (b) each rule is defined by 1-2 generators under D4 symmetry; © the knight's movement graph has effective dimensionality >2; (d) on a toroidal board (no edges), all pieces become regular.

6a. Scale invariance¶

def knight_targets_NxN(r, c, N):
    for dr,dc in [(-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)]:
        nr,nc = r+dr, c+dc
        if 0<=nr<N and 0<=nc<N: yield nr,nc

def build_adj_NxN(fn, N):
    n = N*N; A = np.zeros((n,n))
    for r in range(N):
        for c in range(N):
            for tr,tc in fn(r,c,N): A[r*N+c, tr*N+tc] = 1
    return A

# Test bipartiteness across board sizes
for N in [5, 6, 8, 10, 12, 16]:
    A = build_adj_NxN(knight_targets_NxN, N)
    evals_A = np.sort(np.linalg.eigvals(A).real)
    pos = evals_A[evals_A > 0.01]; neg = -evals_A[evals_A < -0.01]
    n_match = min(len(pos), len(neg))
    sym_err = np.linalg.norm(np.sort(pos)[:n_match] - np.sort(neg)[:n_match]) if n_match > 0 else float('inf')
    print(f"  N={N:2d}: bipartite={sym_err < 0.01}")

Result¶

Knight bipartiteness: INVARIANT across all board sizes (5×5 through 16×16). Also invariant: component count, degree irregularity. These are properties of the rule, not the board.

The rook's spectral gap ratio λ₂/λ_max = exactly 0.5 on every board size tested. This ratio IS the rule — it doesn't depend on N.

6b. Generator analysis¶

Piece	Generators under D4	Intrinsic dimension
Knight	(2,1)	1
Bishop	(1,1)	1
Rook	(1,0)	1
King	(1,0), (1,1)	2
Queen	(1,0), (1,1) + range	2

The knight rule IS the number pair (2,1). One concept. Everything else — the 8 offset directions, the board size, the edge clipping — is the embedding.

6c. Effective dimensionality (Weyl's law)¶

Weyl's law: for a d-dimensional lattice, λ_k ~ k^(2/d). Fitting eigenvalue scaling:

Piece	d_eff (overall)	d_eff (large scale)	Board-like?
Grid baseline	2.10	1.92	YES (d≈2)
Knight	2.98	5.04	NO — higher-D
King	2.48	2.10	YES
Bishop	4.34	5.72	NO — higher-D
Rook	7.50	7.62	NO — higher-D

The knight's movement graph is intrinsically ~3-5 dimensional. It doesn't live in 2D. The "jumping" is a projection artifact — smooth movement in the knight's natural ~5D space projected onto the 2D board surface.

6d. Toroidal board¶

On a torus (wrapping edges), every piece becomes regular (constant degree). The irregularity on flat boards is an artifact of the boundary, not a property of the rule.

Piece	λ₂ (flat, N=8)	λ₂ (torus, N=8)	Regular on torus?
Knight	1.143	4.000	Yes
King	0.416	1.757	Yes
Bishop	2.997	8.000	Yes
Rook	8.000	8.000	Yes (already was)

6e. Spatial vs abstract content¶

Projecting each piece's Laplacian onto the board eigenbasis:

Piece	Board-aligned (diagonal)	Rule content (off-diagonal)
Knight	87.2%	12.8%
King	96.7%	3.3%
Bishop	92.4%	7.6%
Rook	100.0%	0.0%
Queen	98.8%	1.2%

Note on the Queen: The Queen's absolute off-diagonal fiber norm is identical to the Bishop's (14.717 both), because queen = bishop + rook and the rook contributes zero fiber. The Queen's lower percentage (1.2% vs Bishop's 7.6%) is because the rook component inflates the total Laplacian norm (denominator) without adding off-diagonal content (numerator). This is consistent with the Bishop-Queen fiber cosine similarity of exactly 1.000 measured in Section 7.

The rook's Laplacian is entirely expressible in board eigenmodes — zero off-diagonal coupling. It's a purely 2D creature. The knight has 12.8% irreducible rule content that lives orthogonal to the board surface.

Verdict¶

Scale invariance of categorical properties: NOVEL SYSTEMATIC TEST.
Generator analysis: KNOWN GROUP THEORY, novel application.
Weyl's law dimensionality: NOVEL APPLICATION — no prior measurement of chess piece graph effective dimensionality found.
Toroidal regularization: NOVEL OBSERVATION.
Spatial vs abstract decomposition: NOVEL.

7. The Rank-3 Fiber Bundle¶

Claim¶

The off-diagonal coupling matrices (rule content from Section 6e) of all piece types share a 3-dimensional subspace. The bundle has non-trivial holonomy (curvature ≠ 0) and position-dependent fiber norm.

Theoretical basis¶

Fiber bundles: Nakahara (2003), Ch. 9.
Principal angles between subspaces: Björck & Golub (1973).
Holonomy = failure of parallel transport to return to starting point after traversing a closed loop on the base space.

Code¶

# Extract fiber vectors (off-diagonal coupling in board eigenbasis)
upper_idx = np.triu_indices(64, k=1)
fibers = {}
for name, fn in piece_fns.items():
    A = build_adjacency(fn)
    L = np.diag(A.sum(axis=1)) - A
    C = evecs_grid.T @ L @ evecs_grid
    C_off = C.copy(); np.fill_diagonal(C_off, 0)
    fibers[name] = C_off[upper_idx]

# Stack and SVD (excluding rook which has zero fiber)
non_trivial = [n for n in piece_fns if np.linalg.norm(fibers[n]) > 0.01]
fiber_mat = np.array([fibers[n]/np.linalg.norm(fibers[n]) for n in non_trivial])
U_f, S_f, Vt_f = np.linalg.svd(fiber_mat, full_matrices=False)

for i, s in enumerate(S_f):
    print(f"  σ_{i+1} = {s:.4f}  ({s**2/np.sum(S_f**2)*100:.1f}%)")

Result¶

Singular value	Magnitude	% of total	Cumulative
σ₁	1.7037	72.6%	72.6%
σ₂	0.8229	16.9%	89.5%
σ₃	0.6483	10.5%	100.0%
σ₄	0.0000	0.0%	100.0%

Rank = 3 < 4 pieces with non-trivial fiber. The fourth piece's fiber is exactly linearly dependent on the other three. All piece rules live in a shared 3-dimensional subspace of the coupling space.

Cross-piece fiber alignment¶

Pair	Cosine similarity
Knight-King	0.508
Knight-Bishop	0.468
Knight-Queen	0.468
King-Bishop	0.645
King-Queen	0.645
Bishop-Queen	1.000
Rook-anything	0.000

Bishop-Queen fiber similarity = 1.000 exactly, because queen = bishop + rook and rook has zero fiber, so queen's fiber IS bishop's fiber.

Holonomy test¶

Transporting the knight's local fiber around a closed loop on the board:

Start-end fiber similarity: −0.016
NON-TRIVIAL HOLONOMY — the connection has curvature.

Position-dependent fiber norm¶

The knight's fiber norm (rule content) varies from 1.373 at corners to 2.751 at center — a 2:1 ratio. The fiber is "thicker" at the center of the board.

Verdict¶

Rank-3 shared fiber: NOVEL. No prior art found.
Non-trivial holonomy: NOVEL. First measurement of bundle curvature on a chess board graph.
Bishop-Queen fiber identity: NOVEL OBSERVATION consistent with queen = bishop + rook.
Position-dependent fiber: NOVEL.

7b. The Rank-4 Full Fiber — The Rook's Shadow¶

The rank-3 off-diagonal fiber captures non-spatial rule content (cross-modal coupling). The rook projects to zero because its rules ARE spatial — it modifies eigenmode energies without coupling different modes. But the rook clearly HAS rules. Where are they?

The diagonal deviation. Each piece's Laplacian in the board eigenbasis has a diagonal: the piece's eigenvalues projected onto the grid's eigenmodes. This diagonal differs from the grid's own eigenvalues. The difference (diagonal deviation) is the piece's spatial rule content — how it modifies the board's own modes.

Space	Knight	King	Bishop	Rook	Queen
Off-diagonal norm	12.23	7.41	14.72	0.00	14.72
Diagonal deviation norm	24.43	27.61	47.40	88.05	156.99

The rook has the second-largest diagonal deviation (88.05), despite having zero off-diagonal content. Its rules live entirely in the spatially-mirrored dimensions.

Full fiber SVD (diagonal + off-diagonal = 2080-dim vectors):

σ	%	Cumulative	Content
σ₁ = 2.16	93.4%	93.4%	99% diagonal (SPATIAL)
σ₂ = 0.40	3.2%	96.6%	73% diagonal (MIXED)
σ₃ = 0.31	2.0%	98.6%	88% diagonal (SPATIAL)
σ₄ = 0.26	1.4%	100.0%	79% diagonal (MIXED)
σ₅ = 0.00	0.0%	100.0%	— (Queen = Bishop + Rook)

Full rank = 4, not 3+something. The queen being an exact sum of bishop and rook means 5 pieces span only 4 independent directions, regardless of whether diagonal content is included.

The rook is ALIGNED with other pieces in the diagonal space (cos 0.53–0.98), not orthogonal. Its diagonal rule content is nearly parallel to the queen's (cos = 0.982) — because the queen contains the rook.

The binding between diagonal and off-diagonal is field-mediated. The two subspaces are exactly orthogonal in the coupling space (different matrix indices). But they couple through the physics: the rook on a1 changes the knight's field energy by +50, even though the rook is NOT on any of the knight's target squares from e4. The rook's spatial presence modulates the non-spatial coupling of other pieces through the Laplacian quadratic form. This is how gauge fields work: the connection (fiber) and the matter field (signal) are geometrically independent but physically coupled through the covariant derivative.

Relationship between rank-3 and rank-4: The rank-3 off-diagonal fiber is the gauge content (invisible to the spatial basis). The rank-4 full fiber is the total rule content (gauge + spatial modification). The grid eigenbasis acts as a mask: it zeroes out the diagonal content (where it's indistinguishable from its own eigenvalues), revealing the off-diagonal content cleanly. Every result built on rank-3 remains valid within the gauge scope. Rank-4 extends the scope without contradicting anything.

7c. Spectral Energy Dispersion: Fiber Norm as a Predictive Lens for Move-Induced Disturbance¶

The rank-3 fiber norm (§7) and the per-ply channel-energy decomposition (§9a, §9o) are two views of the same spectral object at different temporal scales. §7 measures the static rule-content density available at each square for a given piece type — a property of the move graph, independent of occupation. §9a/§9o tracks the dynamic redistribution of energy across the 10 HDC channels as the position evolves ply by ply. Combining them yields a predictive framework for move-induced spectral dispersion: how much, and in what direction, a candidate move will reshape the position's representation in the 640-dim encoding.

The physical analogy¶

The fiber norm V_piece®, where r indexes the 64 squares, has the structure of an external potential. For the bishop it is approximately proportional to √(degree of move graph at r), center-bright and corner-dim, with the D4 symmetry of the unobstructed move graph. In optical terms it is a lens — a medium whose local refractive content varies with position. A piece moving through the lens experiences variable rule coupling depending on where it is.

The per-ply channel-energy distribution E_channel(ply) is the field propagating through that lens. It reports what fraction of the position's 640-dim content lives in each of the 10 channels at the current moment: A₁, A₂, B₁, B₂, E (the five D4 irreps), FS₁, FS₂, FS₃ (the three fiber-symmetric modes), FA (the antisymmetric pawn channel), FD (the diagonal deviation channel).

Together these two objects form what we will call the phased particle lens: V_piece® is the magnitude landscape, and the coprime-cyclic structure from §9f adds a phase-coherent rotation to each transition. The lens shapes where disturbances can form; the field shows what has actually formed at each moment.

Dispersion as a move-ranking observable¶

For any legal move M applied at ply t, define the dispersion change:

ΔH(M) = H(E_channel(t+1)) − H(E_channel(t))

where H is the entropy (or an entropy-like spread measure — Rényi-2 / inverse participation ratio / L2 distance between normalized channel distributions) of the channel-energy distribution. ΔH > 0 means the move flattens the distribution across channels (dispersive, +disperse). ΔH < 0 means the move sharpens it into fewer channels (concentrative, −disperse).

The predictive claim this section investigates:

|ΔH(M)| correlates with the sum (or appropriate combination) of fiber-norm values at the move's origin and destination squares for the moving piece's type.

Rationale: a piece sitting on a high-fiber-norm square contributes heavily to the off-diagonal coupling in multiple directions of the rank-3 subspace. Removing it from that square (via a move) removes coupling across many modes simultaneously, producing a large redistribution. A piece on a low-fiber-norm square contributes little; removing it barely shifts the channel energies. By the same argument, placing a piece onto a high-fiber-norm square injects coupling across many modes. The fiber norm therefore upper-bounds the potential magnitude of spectral disturbance from any move involving that square.

Equivalently: the fiber norm is a static predictor of where moves will produce the largest per-ply ΔE_channel.

Sign of dispersion and its relation to current channel concentration¶

The magnitude claim is geometric. The sign claim is phase-dependent and requires the current channel distribution as context:

A move produces +disperse (ΔH > 0) when its induced change in the rank-3 fiber subspace is orthogonal or anti-aligned with the currently dominant channel direction. It produces −disperse (ΔH < 0) when aligned with the currently dominant direction.

A dispersive move spreads energy into channels that currently hold little. A concentrative move piles energy onto channels that are already dominant.

Operationally: project the pre-move encoding onto the rank-3 fiber basis to get a 3-vector f_before. Project the post-move encoding to get f_after. Identify the currently dominant channel axis as the unit vector d aligned with the peak of E_channel(t). Then:

cos(angle(f_after − f_before, d)) ≈ +1 → the move adds to the dominant mode → −disperse
cos(angle(f_after − f_before, d)) ≈ −1 → the move removes from the dominant mode → +disperse (because energy must go elsewhere; §9a channel sum is a conserved quantity per ply up to occupation changes)
cos ≈ 0 → the move acts orthogonally to the current dominant axis → +disperse (energy moves sideways into new channels)

Connection to chess intuition¶

In chess-evaluative terms, the two regimes map onto the tactical/positional distinction informally used by human players and formalized by engine depth-gap analysis (§9h, §9h′):

+disperse moves are those that reshape the structural configuration of the position. They force the evaluation to re-search: the spectral state after the move sits in a different mode basin than before. These are the moves that produce large Stockfish depth-gaps (ρ=+0.452 vs A₁ from §9c) — the engine needs to look deeper to catch up with the restructured landscape.
−disperse moves reinforce existing structure. They keep the position in its current mode basin, concentrating energy onto the channels that are already dominant. These are the moves Stockfish evaluates reliably at shallow depth.

This framework gives the notebook's pre-existing A₁ / depth-gap correlation (§9c, §9h′) a mechanism. A₁ is the fully invariant D4 channel; positions dominated by A₁ have their structural content concentrated in the most symmetric channel. The depth gap reports where shallow search disagrees with deep search — i.e., where the position is about to disperse out of its current concentration. A₁ correlates with depth gap because A₁-dominant positions are the ones most likely to undergo a large +disperse event on the next move.

Relation to capture spectroscopy (§5, §5b, §5c)¶

The capture decomposition in §5 already establishes that captures produce predictable spectral signatures — F_D spikes with piece-type-specific magnitudes, FS₁/FS₂ decoupling with characteristic relaxation time, knight capture mixing patterns. The present framework generalizes this: captures are simply moves with exceptionally large |ΔH|, because a capture removes a second piece's fiber contribution simultaneously with the attacker's relocation.

A concrete prediction: the spectral magnitude of any capture event C(piece_a captures piece_v on square s) should decompose as:

The first term is the attacker's fiber redistribution from its origin to the capture square. The second is the total removal of the victim's fiber contribution at s. The cross-terms are the rank-3 basis interference between attacker and victim fiber directions.

This predicts, among other things, that a knight capturing a queen on d5 produces a larger |ΔH| than a knight capturing a pawn on d5 (because V_queen(d5) ≫ V_pawn(d5) in the bishop-fiber-dominated subspace, and pawns live mostly in the antisymmetric FA channel which is disjoint from the rank-3 basis). The relative prediction is testable against the corpus of captures already in the .spectralz archives.

Experimental protocol¶

For each ply t in a reference corpus (GM games, random playouts, or the existing 26-game benchmark):

Compute enc_640(position(t)) and decompose into 10 channels of 64 dims.
Enumerate the legal move set L(t) via python-chess.
For each candidate move M ∈ L(t):
Apply M to produce position(t+1 | M).
Compute enc_640(position(t+1 | M)) and its channel decomposition.
Compute ΔH(M) using normalized channel-energy entropy.
Retrieve V_piece_type(M)(origin(M)) and V_piece_type(M)(destination(M)) from the fiber_norms.json asset produced for Stage 1 of the viewer overlay.
For captures, additionally retrieve V_piece_captured(destination(M)).
Record (ΔH(M), V_origin, V_destination, V_victim, is_capture, is_played).

Aggregate analyses:

Magnitude test: regress |ΔH(M)| on (V_origin + V_destination). Expected: positive Pearson correlation. Null hypothesis: fiber norm does not predict dispersion magnitude.
Sign test: for each move, compute cos(angle(f_after − f_before, d_current)) and correlate with sign(ΔH(M)). Expected: positive correlation (aligned → ΔH<0, anti-aligned → ΔH>0).
Selection test: within L(t), rank all candidate moves by |ΔH|. Check whether the move actually played ranks higher (tactical positions) or lower (positional positions) than the legal-move median. Correlate this ranking with Stockfish depth gap.
Capture prediction: restrict to capture moves. Regress |ΔH(C)| on the additive decomposition in the previous subsection. Measure residual to detect cross-term effects.

Decision point¶

If the magnitude test succeeds, the fiber-norm field is a pure-spectral predictor of move impact — no game-tree search, no engine heuristic, just a static geometric property plus the current position's channel state. This would establish §7's rank-3 fiber as the operator norm for the move-induced Hamiltonian perturbation (§4), completing the lattice-fermion analogy with an explicit predictive formula.

If the magnitude test succeeds but the sign test fails, we have a magnitude-predictor but not a direction-predictor. This would mean the rank-3 subspace compresses too aggressively to retain directional information about individual moves; a finer (rank-4, rank-5, or channel-level) analysis would be needed.

If both tests fail, the fiber norm is decorative rather than predictive — beautiful visualization, no dynamical content. This is the null result. It does not invalidate §7 (the static structural claim stands) but it would mean the lens analogy breaks at the move-prediction level.

Visualization implications¶

The viewer's Stage 1 fiber-norm overlay (static, per piece type) combined with the existing per-ply channel-energy panel already contains the raw material for this analysis. Two natural extensions:

Dispersion trajectory panel. A plot of H(E_channel(t)) over the game. Rises are +disperse events; drops are −disperse events. Correlating the trajectory shape with the move list makes the tactical/positional rhythm of the game visually explicit.
Move-candidate coloring. For the current ply, compute |ΔH(M)| for each legal move and paint the destination squares with magnitude intensity. The fiber-norm overlay provides the static context; the move-candidate overlay shows the dynamic foreground. Clicking a piece shows its dispersive moves highlighted.

Neither is Stage 3 (which would make the fiber norm itself state-dependent). Both use the existing Stage 1 overlay as background context with a dynamic foreground derived from the per-move encoding computation.

What this section does not claim¶

This is a framework + a testable hypothesis, not a confirmed result. The magnitude and sign tests have not yet been run against a corpus. The connection to chess intuition is suggestive and consistent with §9c's A₁/depth-gap finding but has not been independently verified at the move level. The capture prediction is a direct consequence of the framework but its numerical coefficients are not yet measured.

The next section (§7d if this framework is validated, or a §9-series follow-up if it folds back into encoder work) will report the experimental results and either confirm or revise the magnitude and sign claims.

8. Practical Encoding: What Worked and What Didn't¶

What worked¶

Spectral energy decomposition of captures — exact, reproducible, mathematically clean.
Quantum number classification — complete, unique, invariant.
Multi-hop compression — knight random walk distributions compress from 39/64 to 11/64 DCT coefficients over 15 steps (6× compression, like NASA Chebyshev ephemeris).
Influence sensitivity patterns — the knight's sensitivity to single-square blocking compresses to 5/64 DCT coefficients for 90% energy.
Queen = bishop + rook — exact algebraic identity: A_queen = clip(A_bishop + A_rook), zero residual, L_queen = L_bishop + L_rook exactly.

Encoder evolution: Global → Grok (local) → Gemini (quadratic) → v3 (dual-channel)¶

Three encoder iterations were tested against the same battery:

Grok's local fiber encoder fixed the core failure: local fiber per square (using per-edge adjacency in the board eigenbasis, projected onto the rank-3 shared fiber) instead of global fiber per type. This made positions distinguishable (knight e5 vs a1 now have different fiber vectors, cos = 0.217). Knight PST correlation: r = 0.971 — near-perfect geometric agreement with known piece-square heuristics, with zero training data. However, the encoding was perfectly additive: enc(A+B) = enc(A) + enc(B), missing the 84.9% many-body correlation.

Gemini's many-body encoder replaced value-weighting with quadratic form weighting: interaction_energy = f̂^T · C_off · f̂. This captures many-body effects (68–98% non-additive, vs Grok's 0%) and full context sensitivity (5/5 unique fiber vectors for the same knight in different board contexts). But it degraded PST correlation to r = 0.508 and had 983× dynamic range (numerically unstable).

v3 dual-channel encoder separates geometric and interaction fiber into independent 3D channels (70-dim total: 64 GFT + 3 geometric + 3 interaction). Geometric channel reproduces Grok exactly (additive by design, r = 0.971 PST). Interaction channel uses local field gradient g_k = Σ_{targets} f_j (linear, not quadratic → 9× dynamic range vs Gemini's 983×). Interaction is provably zero when piece is alone, non-additive when others are present, and correctly fires only when target squares are occupied.

Test	Global	Grok	Gemini	v3
Many-body	N/A	FAIL (0%)	PASS (68-98%)	PASS (100% int, 0% geo)
Position quality	FAIL	FIXED	FIXED (tiny)	FIXED (both channels)
PST correlation (N)	NaN	+0.971	+0.508	+0.971 geo
Context sensitivity	FAIL	partial	FULL (983×)	FULL (9×)
Dynamic range	N/A	4.4×	982.9×	9.0×

What failed across all encoders¶

Legal move classification. Fisher discriminant < 1 for knights in all encoder versions. The fiber encodes rule GEOMETRY (which squares are connected), not rule COMPLIANCE (which moves are legal from here). See §8b for the fundamental reason.

8b. The Three Levels of Rule Encoding¶

Investigation of the connection form (per-edge fiber contributions) and subspace mapping revealed why legal move recovery fails and why it's not a fixable engineering problem:

Level 1 (Piece identity) — SOLVED. The 5-tuple quantum numbers uniquely classify piece type. The 3D shared fiber separates all piece types.

Level 2 (Field coupling) — SOLVED. The v3 encoder captures position-dependent rule structure and many-body interaction. This is the thermodynamic level — aggregate properties of the edge ensemble.

Level 3 (Move legality) — PROVABLY NOT RECOVERABLE from fiber.

Per-edge fiber vectors are structurally random in the 2016-dimensional coupling space. All edge norms are approximately equal (~0.986). Pairwise cosine similarities are approximately zero (mean = −0.004). Same-offset edges are no more similar than different-offset edges. Nearest-centroid offset classification reaches only 58.3% at 100 private dimensions (vs 12.5% chance baseline) and saturates — adding more dimensions doesn't help.

The fiber bundle is a coarse-graining of the rule structure. It faithfully represents collective properties (Levels 1-2) but integrates out microscopic properties (Level 3) by construction. The relationship between the fiber and the edge set is the same as between a probability distribution and the individual samples: you can compute the distribution from the samples but cannot recover the samples from the distribution.

In the physics framing: the connection form A(k→t) exists if and only if (k,t) is a legal edge. For non-edges, the connection isn't "zero" — it's undefined. Legal move compliance is the DOMAIN of the connection, not a VALUE of the connection. The Fisher test failed because it was looking for a measurable property of non-edges, but non-edges have no measurable property in this formalism.

8c. Connection Form and Curvature (Corrected)¶

The local fiber at each square decomposes exactly into per-edge contributions (error < 10⁻¹⁶). Each legal target contributes a specific 3D connection vector. However:

Correction to §7 holonomy interpretation: Accumulated fiber change around closed loops is identically zero by telescoping: Σ(f_{i+1} − f_i) = f_final − f_start = 0. The −0.016 holonomy measured in §7 used cosine similarity of fiber vectors (not accumulated delta), which measures genuine geometric content but is not the same as curvature of the discrete connection. The rook bundle is confirmed flat (zero global fiber). The distinction between holonomy-as-similarity and curvature-as-transport requires careful treatment in any formal write-up.

Note on the production encoder. The v3 dual-channel encoder (70-dim) discussed in §8 is an R&D artifact, not the production encoder. The production encoder is 640-dim (documented in §9a): encode_640 in chess-spectral/python/chess_spectral/encoder.py, which extends the v3 geometric/interaction split into 5 D4 irreps + 5 fiber channels and generates every .spectralz file in results/. See ENCODERS.md for the full lineage and reproduction recipe.

9. HDC Integration & UTLP S3 Connection¶

9a. Architecture: D = 64 × 10 = 640¶

The complete HDC dimension is 640: 64 board eigenmodes × 10 channels. The 10 channels decompose as 5 D4 irreps + 5 fiber dimensions, each carrying 64-dim content:

Channel	Dims	Type	Content
A₁	0-63	D4 irrep	Fully invariant — complexity predictor (ρ=+0.452 vs depth gap)
A₂	64-127	D4 irrep	Rotation-invariant, reflection-antisymmetric
B₁	128-191	D4 irrep	Orthogonal-orbit anisotropic mode — complexity predictor (ρ=+0.303 partial, post-audit)
B₂	192-255	D4 irrep	Diagonal-orbit anisotropic mode — strongest complexity predictor (ρ=+0.490 partial, post-audit, outperforms A₁)
E	256-319	D4 irrep	2-dim oriented asymmetry — positional weakness marker (ρ=−0.293)
Fiber-sym₁	320-383	Symmetric off-diagonal	Cross-modal coupling direction 1 (σ₁=1.70, 72.6%)
Fiber-sym₂	384-447	Symmetric off-diagonal	Cross-modal coupling direction 2 (σ₂=0.82, 16.9%)
Fiber-sym₃	448-511	Symmetric off-diagonal	Cross-modal coupling direction 3 (σ₃=0.65, 10.5%)
Fiber-anti	512-575	Antisymmetric off-diagonal	Pawn directional flow — Z₂-breaking operator content
Fiber-diag	576-639	Diagonal deviation	Rook's shadow — spatial rule modification hidden by grid eigenbasis

Live visualiser for the 640-dim channels (board + heatmap + per-channel energy, all browser-side): https://lemonforest.github.io/chess-maths-viewer.

The encoding grew from 512 to 640 because the pawn characterization (§9m) revealed a fifth fiber dimension that cannot be expressed in any existing channel:

Not diagonal: The antisymmetric content is off-diagonal (cross-modal flow between eigenmodes, not per-mode energy shifts). The rook's diagonal channel doesn't capture it.
Not symmetric off-diagonal: A sum of symmetric coupling patterns (C[i,j] = +C[j,i]) is always symmetric. An antisymmetric pattern (C[i,j] = −C[j,i]) is orthogonal to all symmetric patterns by construction. The rank-3 symmetric fiber basis cannot span it.
Unique to the pawn: ||A_anti||/||A_sym|| = 1.000 for the pawn, exactly 0 for all other pieces. This is the spectral signature of directed movement — the only piece that knows "forward" from "backward."

640 = 2⁷ × 5 = 10 × 64. Not a power of 2, but cleanly factored. Each dimension has a physical address: (channel_type, eigenmode_index).

The previous 512 = 8 × 64 architecture remains valid as a subset — the first 512 dimensions are identical. The additional 128 dimensions (antisymmetric fiber + diagonal fiber) extend the encoding without invalidating any existing results. All benchmarks, correlations, and tests from the 512-dim encoder apply unchanged to the first 512 dimensions of the 640-dim encoder.

The D4 group (dihedral group of the square, order 8) commutes with the board Laplacian (verified: ||P_g L P_g^T − L|| = 0.00 for all g). Its 5 irreps partition the eigenspace: - A₁ (trivial, 1-dim): fully D4-invariant. Identical for all rotated/reflected positions. - A₂ (alternating, 1-dim): invariant under rotations, sign-flips under reflections. - B₁, B₂ (1-dim each): specific axis symmetries. - E (2-dim): rotations mix the pair, reflections swap them.

D4 symmetry encoding uses the character projection formula (Serre 1977, §2.6), not stacked GFTs:

f_μ = (d_μ / |G|) Σ_{g∈D4} χ_μ(g) · (P_g f)

This operates on the SIGNAL, bypassing eigenvector alignment issues in degenerate subspaces. Verified: A₁ projection produces exactly identical encodings for all 8 D4 transforms (||diff|| < 10⁻¹⁰). Rotation-invariant retrieval: 90°-rotated Sicilian retrieves original Sicilian at sim = 1.0000 using A₁.

Key finding: A₁ alone has near-zero evaluation-predictive power (ρ = 0.05) because it over-averages, collapsing strategically different positions. Evaluation information lives in the symmetry-BREAKING channels (A₂, B₁, B₂, E).

Audit note (2026-04-23, PATCH 6 outcome). The D₄ character table rows for B₁ and B₂ in chess_d4_direct.py::CHARS and chess_spectral/tables.py::CHARS previously contained incorrect values that failed the class-constancy requirement under our permutation numbering:

Conjugacy classes under our element ordering (g=0 identity, g=1,3 C₄ rotations, g=2 C₂, g=4,5 axis reflections σ_v/σ_h, g=6,7 diagonal reflections σ_d/σ_d'): {0}, {1,3}, {2}, {4,5}, {6,7}. Every character row must be constant on each class.
Broken rows (prior): B₁ = [1,-1,1,-1,1,-1,1,-1], B₂ = [1,-1,1,-1,-1,1,-1,1]. These give different values on g=4 vs g=5 and g=6 vs g=7 — class-constancy fails.
Corrected rows (2026-04-23): B₁ = [1,-1,1,-1,+1,+1,-1,-1] (axis reflections +1, diagonal reflections −1), B₂ = [1,-1,1,-1,-1,-1,+1,+1] (axis reflections −1, diagonal reflections +1).
Bug discovered by the Othello Phase 1 pass (docs/othello-maths/research/consolidated_tests.py sanity check) which lifted this table to D₄×Z₂ and found idempotence failed on B₁⁻ and B₂⁻ with errors ~0.64. Post-fix idempotence on both tables passes at machine precision.

Numerical impact — ACTIVE FAIL, not silent. Chess starting-position energies:

Channel	Broken (prior)	Corrected
A₁	0.000	0.000
A₂	4140.500	4140.500
B₁	2545.375	0.000
B₂	2545.375	4140.500

The broken B₁ and B₂ energies coincided numerically at many positions — which is why §9h' previously reported identical partial ρ = +0.461 for both channels and identical raw ρ=+0.321 in Table 1 (same row repeated). Those correlations were computed on non-idempotent non-irrep projections and do not reflect the true D₄ irrep content of the chess signal.

The A₁, A₂, and E channels are unaffected — their character rows were already class-consistent.

Re-run status (2026-04-23): COMPLETE. The §9h' Experiment 1 corpus (55 Stockfish-filtered positions) was re-evaluated with corrected character rows. Updated Table 1 / Table 2 numbers are in place (§9h' above). Numerical deltas:

Quantity	Pre-audit	Post-audit
B₁ partial ρ	+0.461 (p=0.0005)	+0.303 (p=0.026)
B₂ partial ρ	+0.461 (p=0.0005)	+0.490 (p=0.0002)
breaking signed partial ρ	+0.101 (n.s.)	−0.310 (p=0.022)

The B₂ partial (+0.490) now outperforms A₁ partial (+0.456) as a complexity predictor — a structural result that was hidden by the collapse. The combined breaking-signed partial flipped from trending-positive to significantly-negative (p=0.022), confirming the previously-null hypothesis that "breaking channels signed sum predicts advantage after material control." This flip is the most consequential audit outcome: the previously-reported §9h' conclusion that "breaking → advantage not confirmed" is REVERSED — the combined effect IS confirmed at p=0.022, just not visible through the broken projections.

Re-run artefact: docs/chess-maths/archive/chess_a1_followup.py executed against the corrected archive/encoder_512.py::CHARS and chess_spectral/tables.py::CHARS on 2026-04-23; full stdout preserved locally (Stockfish runs are deterministic at fixed depth, so the corpus and correlations are reproducible).

Empirical post-fix follow-up (§9c′). Corpus-level structural characterization of the now-distinct B₁ and B₂ channels — orthogonality verification, per-corpus fingerprints, game-phase dependence (B₂/B₁ ratio narrows monotonically from opening to endgame), cross-channel correlation matrix, and move-event signatures including a castling-as-B₂ signature — is in §9c′. See §9c′.6 for the scale of the correction: 6–10× inflated pre-fix norms.

Corpus manifest regeneration (2026-04-23). The .spectralz files were already regenerated on 2026-04-23 14:21 UTC (post-fix, after the 12:40 tables.py CHARS correction), but the sibling manifest.json / corpus_index.csv / corpus_summary.md files retained their pre-fix mean_B1 / mean_B2 summaries (both numerically equal at the broken value). All four live corpora — sweep_chain_lichess_drnykterstein_2026-04-14_N10, sweep_chain_lichess_ashchess_2026-04-21_N50, sweep_hf_2026-04-20_N50, and single_lichess_pgn_2026.04.15_... — have been regenerated in place via docs/chess-maths/regen_corpus_derived.py, which re-runs extract_features() against the current .spectralz and patches only the spectral fields (mean_*, chaos_ratio, n_plies, nag_count, etc.), preserving each corpus's original fetch_params, tool_versions, and per-game PGN headers. After regen, mean_B1 ≠ mean_B2 on every game in every corpus, and the per-corpus B₂/B₁ ratios (~2.5 in squared-L2 energy, ≈1.58 in L2 norm) are consistent with the §9c′.2 "1.4–1.7×" finding. The orphan-metadata corpora (chessgames_pair_2026-04-15_N2, pilot_hf_2026-04-14_N3_seed42) have no spectralz/ / ndjson/ subdirs and were skipped by the regen script. build_dashboard_data.py reads the current .spectralz directly and was not run per-corpus here; run it on demand when a specific dashboard is rebuilt.

9b. The 8-Generator Frequency Lattice¶

The 8 path graph eigenvalues λ_k = 2(1 − cos(πk/8)) for k = 0,...,7 generate the full board spectrum via pairwise sums. Verified: 33 unique pairwise sums account for all 33 unique board eigenvalues exactly.

The pairwise ratios of path eigenvalues are irrational (no two are rational multiples of each other). This is the spectral analog of coprime independence in UTLP S3: each generator produces a family of spectral modes, no two families overlap, and the lattice of pairwise sums has no aliasing. The 8 path eigenfrequencies function as domain-specific coprime generators derived from game geometry.

9c. Spectrally Derived Piece Values¶

Traditional piece values (P=1, N=3, B=3.5, R=5, Q=9, K=100) are magic numbers with zero spectral grounding. K=100 conflates game rules (losing king = losing) with movement properties — the king is the WEAKEST mover spectrally.

Spectral values use mean_degree / 2.6:

Piece	Traditional	Spectral	Derivation
P	1	0.84	mean degree 2.19 / 2.6 (from symmetric Laplacian of directed graph)
N	3	2.0	mean degree 5.25 / 2.6
B	3.5	3.4	mean degree 8.75 / 2.6
R	5	5.4	mean degree 14.0 / 2.6
Q	9	8.8	mean degree 22.75 / 2.6
K	100 → 2.5	2.5	mean degree 6.56 / 2.6

Correlation with traditional: interaction total r = 0.972, mean degree r = 0.968. The spectral values are not arbitrary — they reproduce the traditional ordering (Q>R>B>N) from graph topology alone.

King domination fix: Same king squares, different material: cos 0.87 (K=100) → 0.34 (K=2.5). The encoding now sees non-king pieces. King identity is encoded through the quantum number codebook (its 5-tuple is unique), not through signal magnitude inflation.

Dynamic range: 100× (magic) → 3.0× (traditional K=4) → 8.8× (spectral).

9c′. Post-Fix B1/B2 Analysis: Structural Channel Separation¶

Audit follow-up to §9a's PATCH 6 character-table fix. Supersedes the pre-fix B1/B2 correlations reported in §9a and in all derivative statistics in the notebook prior to the 2026-04-23 reprocessing. Based on empirical analysis of 23 games across 4 corpora (drnykterstein N=10, ashchess sample N=6, sweep_hf sample N=6, single_lichess N=1). The bug previously projected B1 and B2 onto the same subspace with opposite signs (yielding corner-to-corner / diagonal-axis reflection in both channels). The post-fix encoder projects them onto genuinely distinct 1D irreducible subspaces of D₄. This section documents what the now-distinct channels carry.

9c′.1 — Fix verification¶

Orthogonality (hard check). Per-ply vector cosine between the 64-dim B1 and B2 channel vectors is exactly 0.0000 for every ply in every game in the sample (n = 2,112 plies, max|cos| = 0.0000 to four decimal places). The two projections now span mutually orthogonal subspaces, as the irrep decomposition requires.

Ply-0 D₄ symmetry test (soft check). The standard chess initial position is invariant under σᵥ (vertical-axis reflection across the d–e file boundary). The B1 irrep projection annihilates σᵥ-symmetric content; consequently B1 must vanish at ply 0 of any game starting from the standard position.

Observed: in all 17/17 games starting from the standard position (drnykterstein ×10, ashchess ×6, single_lichess ×1), the ply-0 signature is bit-identical:

A1=0.000  A2=4.455  B1=0.000  B2=4.455  E=17.960
FS1=9.422  FS2=43.023  FS3=38.828  FA=4.463  FD=0.000

The 6 sweep_hf games are sampled from Stockfish's test-positions book ("SetUp": "1", explicit FEN per game, not the standard start); their ply-0 values are not comparable to this test. This is intentional test-suite behaviour, not a data quality issue.

Energy-trace correlation (over-time coupling). Vector orthogonality does not imply energy-magnitude decoupling. The Pearson correlation of the scalar traces |B1(t)| and |B2(t)| varies by game:

corpus         mean ρ    range of ρ
nykt           +0.20     [-0.21, +0.46]
ash            +0.07     [-0.19, +0.34]
hf             +0.19     [-0.34, +0.81]     ← outlier hf/game_010 = +0.807
single         +0.05
global mean    +0.15

The weak positive average reflects the fact that both B1 and B2 track overall "positional disturbance" but through different symmetry lenses; dramatic disturbances tend to excite both. The hf/game_010 outlier (ρ = +0.807) is worth a one-off look — it may be a short engine-draw game where the trajectory happened to align, or it may indicate a specific class of position that collapses the B1/B2 distinction. Flagged, not urgent.

9c′.2 — Corpus-level spectral fingerprints (post-fix)¶

Mean per-channel energies over the sample, by corpus:

corpus     A1      A2      B1      B2       E      FS1     FS2     FS3     FA       FD
nykt      4.11    4.60    3.49    5.91    13.33    9.63   17.96   17.76   3.74    137.6
ash       3.85    3.95    3.16    5.30    11.74    6.72   13.08   12.92   3.51    144.7
hf        4.27    3.59    3.25    4.93    11.07    7.37   13.39   11.99   3.16     59.0
single    4.87    4.54    4.05    5.48    13.70   10.60   20.49   19.12   3.66    604.6

These values supersede the mean_B1 and mean_B2 entries in every corpus manifest.json / corpus_index.csv / corpus_summary.md until build_dashboard_data.py is re-run against the current .spectralz files.

Universal finding: B2 > B1 across every corpus, with a ratio of 1.4–1.7×. The relationship is consistent across strong human play (nykt, ash), engine self-play from varied openings (hf), and mixed-skill play (single). This is the first quantitative asymmetry between the two newly distinct channels: they are not interchangeable, and the system has a structural preference for the B2 irrep over B1.

Corollary finding: the FD channel scales with positional volatility, not with identity of play. Engine self-play (hf) has the lowest FD despite not being the lowest chaos ratio, consistent with engines making fewer "trailing event" moves. The single_lichess game (lichess AI Level 1 vs lemonforest) has FD = 604.6 — 4–10× the other corpora — consistent with a beginner-level game producing large capture events and decisive positional swings.

9c′.3 — Game-phase dependence of B1/B2¶

Splitting each game into opening (plies 1–15), middlegame (plies 16 to n−15), and endgame (last 15 plies), averaged over all 23 games:

phase        mean B1    mean B2    ratio B2/B1
opening        1.90       5.06        2.66
middlegame     3.70       5.79        1.57
endgame        3.53       4.79        1.36

B1 grows 86% from opening to middlegame, then stays approximately flat into the endgame. This is the signature of B1 as a channel that populates as play breaks σᵥ-symmetric structure — something that begins only once pieces start crossing to non-mirrored squares.
B2 grows only 14% from opening to middlegame and decreases 17% into the endgame. B2 is largely "loaded" by the initial position itself (σᵥ-antisymmetric content from the white-vs-black ply ordering) and discharges slowly as material simplifies.
The B2/B1 ratio is highest in the opening (2.66) and lowest in the endgame (1.36) — a monotonic narrowing. This gives a spectral handle on game phase that's orthogonal to material count.

Prediction to test (§9c′-followup): game phase (opening / middlegame / endgame) should be classifiable from the instantaneous B2/B1 ratio alone, independently of piece count. Worth checking whether this beats or complements the existing phase-detection heuristics.

9c′.4 — Cross-channel correlation matrix (post-fix)¶

Pearson correlations of per-ply channel energies, averaged over all 23 games:

        A1      A2      B1      B2       E     FS1     FS2     FS3      FA      FD
A1   +1.000  -0.013  +0.575  +0.221  -0.293  +0.200  -0.361  -0.379  -0.128  +0.242
A2   -0.013  +1.000  +0.012  +0.358  +0.321  +0.346  +0.302  +0.298  +0.341  -0.063
B1   +0.575  +0.012  +1.000  +0.155  -0.227  +0.196  -0.364  -0.336  -0.081  +0.181
B2   +0.221  +0.358  +0.155  +1.000  +0.067  +0.386  +0.054  +0.029  +0.189  +0.001
E    -0.293  +0.321  -0.227  +0.067  +1.000  +0.422  +0.833  +0.871  +0.629  -0.395
FS1  +0.200  +0.346  +0.196  +0.386  +0.422  +1.000  +0.382  +0.317  +0.337  -0.067
FS2  -0.361  +0.302  -0.364  +0.054  +0.833  +0.382  +1.000  +0.955  +0.561  -0.338
FS3  -0.379  +0.298  -0.336  +0.029  +0.871  +0.317  +0.955  +1.000  +0.559  -0.379
FA   -0.128  +0.341  -0.081  +0.189  +0.629  +0.321  +0.561  +0.559  +1.000  -0.224
FD   +0.242  -0.063  +0.181  +0.001  -0.395  -0.067  -0.338  -0.379  -0.224  +1.000

The substantive result: B1 and B2 have different cross-channel fingerprints. Pre-fix, B1 and B2 had identical correlations with every other channel (necessarily, because they were the same vector with opposite signs). Post-fix they couple to distinct channel families:

partner	ρ(B1, ·)	ρ(B2, ·)	interpretation
A1	+0.575	+0.221	B1 co-moves strongly with the fully-symmetric channel
A2	+0.012	+0.358	B2 co-moves with the sign irrep
FS1	+0.196	+0.386	B2 couples more strongly to FS1
FS2	−0.364	+0.054	B1 anti-correlates with FS2
FS3	−0.336	+0.029	B1 anti-correlates with FS3
FA	−0.081	+0.189	B2 weakly positive, B1 near-zero
FD	+0.181	+0.001	B1 weakly positive, B2 decoupled

B1 looks "symmetric-fiber-aligned": it rises with A1 and with FD, falls with the σ-axis fiber channels FS2 and FS3. B2 looks "alternating-fiber-aligned": it rises with A2, FS1, and FA, and is nearly decoupled from FS2/FS3/FD.

One orthogonal empirical note: FS2 ≈ FS3 with ρ = +0.955. They are close to collinear in the energy domain. This is not a bug — they are geometrically distinct fiber axes — but it suggests that most of the fiber-norm signal lives in a 1-dimensional subspace spanned by (FS2 + FS3), with a much weaker independent component (FS2 − FS3). Worth flagging for the fiber-norm viewer / §7c dispersion analysis: the "FS2 vs FS3" distinction may be less informative than the "FS2+FS3 combined vs E combined" distinction.

9c′.5 — Move-event signatures (drnykterstein + single, n = 11 games)¶

Using NDJSON move metadata, per-ply absolute energy changes |Δ·| in B1 and B2 were accumulated by move category:

Per-piece:

piece    n      |ΔB1|    |ΔB2|    B2/B1 ratio
P      247      0.179    0.147       0.82
N      133      0.281    0.269       0.96
B      151      0.571    0.377       0.66   ← B1 dominant
R      144      0.727    0.928       1.28
Q      111      1.192    0.791       0.66   ← B1 dominant
K      100      0.324    0.497       1.53

Bishops and queens preferentially excite B1; rooks and kings preferentially excite B2. Knights and pawns are approximately balanced (1 ± 0.2).

A tentative geometric reading: B1 is more strongly activated by pieces whose move set carries diagonal content (bishops, queens), while B2 is more strongly activated by pieces whose move set carries rank/file content (rooks, kings). Knights, which visit both file- and rank-adjacent squares via L-shape, fall in between. This would be consistent with B1 and B2 carrying complementary irrep content under the axial-vs-diagonal distinction within the reflection subgroup of D₄ — though the specific irrep labelling in the current encoder implementation needs confirmation before reading this as theory.

Per-event-type:

event       n      |ΔB1|    |ΔB2|    B2/B1 ratio
castle     20      0.768    1.574       2.05   ← B2 spikes
capture   209      0.559    0.592       1.06
plain     657      0.464    0.373       0.80

Castling produces the sharpest B2 spike of any event class in the sample. Both kingside (O-O) and queenside (O-O-O) castling break σᵥ symmetry severely — the king jumps two squares laterally and the rook reverses its file-direction relationship to the king. If B2 is (as the ply-0 data supports) the σᵥ-antisymmetric channel, this is exactly the signature expected.

Captures register as balanced between B1 and B2 (ratio 1.06), while quiet "plain" moves slightly favour B1 (ratio 0.80). The castling ratio of 2.05 is roughly 2.5× the plain-move ratio, suggesting B2 could function as a cheap castling detector.

First-move quantization (curiosity). Over 11 first moves observed (all pawn moves), only two discrete (ΔB1, ΔB2) signatures appear:

(+0.354, +0.042) → e4 (×6), d4 (×1)
(+0.500, +0.028) → e3 (×1), f4 (×1), c4 (×1)

Same-signature moves sit in the same D₄ orbit of the board-change vector. The magnitudes 0.354 ≈ 1/√8 and 0.500 = ½ suggest the encoder's irrep basis is normalized such that specific symmetry classes of pawn moves collapse to these rational values. This is not directly actionable but is a useful sanity indicator that the D₄ machinery is operating on clean rational coefficients rather than noisy floats.

9c′.6 — Stale-manifest drift¶

For reference, the magnitude of the correction:

game           manifest(B1=B2)    actual B1    actual B2    ΔB1       ΔB2
nykt/game_001        22.51           2.79          4.54      −19.72    −17.97
nykt/game_002        41.49           3.79          6.06      −37.70    −35.43
nykt/game_003        42.93           3.13          7.07      −39.81    −35.86
nykt/game_004        31.70           3.69          4.88      −28.01    −26.82
nykt/game_005        36.16           4.32          5.50      −31.85    −30.67
nykt/game_006        41.82           3.67          6.99      −38.15    −34.82
nykt/game_007        45.58           3.99          6.78      −41.59    −38.81
nykt/game_008        40.52           3.22          5.52      −37.30    −34.99
nykt/game_009        46.42           3.81          6.99      −42.62    −39.43
nykt/game_010        23.90           2.46          4.74      −21.44    −19.17

Pre-fix values are 6–10× the actual post-fix values. The pre-fix encoder was producing B1/B2 projections with inflated norms, consistent with projecting onto a larger incorrect subspace rather than the correct 1D irreps. Every manifest file, corpus index, and dashboard data file in the results tree needs regeneration; every derivative statistic in the notebook that cited pre-fix B1/B2 values is invalidated.

9c′.7 — Open questions raised by this analysis¶

hf/game_010 outlier (B1–B2 energy correlation ρ = +0.807). Is this a short-game artefact, a specific opening that collapses the B1/B2 distinction, or something structural?
B2 > B1 universally. Is the ratio genuinely fixed at ~1.5 across play styles, or does it move with a specific attribute (material, king safety, position openness)?
FS2 ≈ FS3 (ρ = +0.955). Should the fiber-norm basis be reduced, or is there information in (FS2 − FS3) that the energy projection flattens?
Castling-as-B2-detector hypothesis. Can a simple B2-spike threshold recover castling moves reliably? This would make a clean §9c′-followup validation experiment.
Depth-gap correlation — CLOSED. The pre-fix §9a table showed B1 ρ = +0.461 vs depth gap (with B2 identical). The post-fix §9h′ Table 1 gives B1 partial +0.303 / B2 partial +0.490 on the 55-position Stockfish corpus (re-run via archive/chess_a1_followup.py on 2026-04-23; log at results/chess_a1_followup_rerun_2026-04-23.log). Separately, the results/stockfish_correlation/ artefacts are outputs of analyze_stockfish_correlation.py, which feeds the Δ/σ pipeline (kappa_annihilate, kappa_position, kappa_threat, delta, delta_v2); kappa_position reads only the fiber sub-vector (dims 320:640) and never touches the D₄ irreps, so B₁/B₂ CHARS changes leave that output invariant and no re-run is required. The four live corpora have been regenerated in place (see §9a audit note above): mean_B1 ≠ mean_B2 on every game.
Piece-type signatures (bishop-and-queen → B1; rook-and-king → B2) deserve confirmation on a larger sample with explicit control for move frequency, and ideally with a piece-type ablation: what happens to B1/B2 energy on otherwise-identical positions with one piece-type absent?

9d. Quantum Number Codebook¶

Piece identity vectors use the 5-tuple quantum numbers mapped to 512-space via HDC level coding (cyclic permutation binding of bipolar base vectors). Each quantum number dimension gets a random bipolar base vector; values are encoded as cyclic rolls; the final codebook entry is the element-wise product of all 5 rolls.

Piece	Parity	Components	Regular	λ₂	Bandwidth
Pawn	0	9	0	0.13	5.66
Knight	1	1	0	1.14	13.01
Bishop	0	2	0	3.00	14.68
Rook	0	1	1	8.00	16.00
Queen	0	1	0	14.22	30.06
King	0	1	0	0.42	11.39

All 6 piece types now have unique 5-tuples — complete spectral classification achieved. The pawn's 9 components reflect 8 isolated back-rank squares (white pawns cannot exist on rank 1) plus 1 connected component spanning ranks 2–8. Its lowest λ₂ and bandwidth reflect the pawn's restricted, directional mobility.

Max cross-piece |cos| = 0.10 (QN codebook) vs 0.99 (eigenvalue sequences) — 10× improvement. HDC unbinding with QN codebook: 58% accuracy at 12 pieces vs 0% with eigenvalue codebook.

9e. Square Codebook Evolution¶

Three iterations, progressively eliminating randomness:

Random bipolar (baseline): Random ±1 vectors. Zero spatial structure (adjacent cos ≈ 0). Used for initial HDC tests.

SimHash diffusion (Claude Code v1): Laplacian diffusion embedding (exp(−t·λ_k) weighted eigenvector values) projected through a random Gaussian matrix and sign-thresholded. Correct spatial structure (adjacent cos = 0.50, monotone decay) but the random 512×64 projection matrix was inconsistent with the spectrally-grounded architecture.

Spectral impulse-response (Claude Code v2): Unit impulse δ_s pushed through the 8-channel encoder architecture with diffusion kernel weighting. Channels 1-5: D4 irrep projections of exp(−tL)δ_s. Channels 6-8: multi-scale diffusion at 2t, 4t, 8t. Zero random matrices. Every dimension is spectrally grounded.

Property	Random	SimHash	Spectral
Adjacent similarity	~0.0	0.50	0.50
Spatial structure	None	Monotone	Monotone
Random components	100%	512×64 matrix	None
Basis consistency	No	Partial	Full

9f. Coprime Roll Binding (UTLP S3 → Spatial HDC)¶

The key architectural connection to UTLP S3: binding is coprime cyclic roll, not element-wise multiply.

bound = np.roll(piece_vec, row * 67 + col * 7 mod 512)

67 and 7 are coprime to 512 (both odd, 512 = 2⁹)
All 64 roll offsets are verified distinct
Adjacent squares differ by one coprime stride (67 for vertical, 7 for horizontal)
Roll is exactly self-inverse: roll(roll(x, n), -n) = x
No bipolar requirement — works with any vector

Generator-selection requirement (subtlety discovered by the Othello Phase 1 pass). Coprimality of each generator with the modulus D is necessary but not sufficient for 64-phase uniqueness on the 8×8 lattice. The complete condition is that p · Δr + q · Δc ≢ 0 (mod D) holds for every nonzero (Δr, Δc) ∈ [-7, 7]². The individual-coprimality condition prevents collisions along the axes only; mixed-sign Diophantine collisions can still occur. Concrete counter-example from the Othello work: (p, q) = (3, 7) with D = 1024 has gcd(3, 1024) = gcd(7, 1024) = 1, but φ(7, 0) = 21 = φ(0, 3) because 7·3 − 3·7 = 0. The chess choice (67, 7) with D = 512 and D = 640 both pass 64-phase uniqueness verification; the "verified distinct" clause above is doing the real work, and coprimality is an insufficient shortcut. For any new modulus D (other domains, other dimensions), the correct check is exhaustive verification of 8×8 phase uniqueness, not pairwise gcd.

Packing-optimality side-result (addressing-maths research thread). Beyond the Diophantine uniqueness check, (67, 7) has a verified positive structural property at the canonical 2-power D = 1024: it is packing-optimal. Among 40 randomly-sampled distinct odd-unit image shapes, (67, 7) ties for the densest disjoint-translate packing (N = 15 grids vs volume bound 16, ratio 15/16) alongside (63, 65) and (7, 67), proven OPTIMAL by CP-SAT (also tight at m = 11 with N = 30, feasible at m = 12 with N ≥ 60). The 1/16 slack against the volume bound is a structural Fourier obstruction, not an algorithmic limitation: the image's mod-16 multiplicity vector m_I = 1_{A_p} ∗ 1_{A_q} (Z_16 convolution) is provably non-uniform — for any odd unit u in Z_{2^m}, the set u·{0..7} mod 16 has DFT F_u(k) vanishing at the 7 even nonzero frequencies of Z_16 and nonzero at the 8 odd ones, so m̂_I cannot be supported only at k = 0. The image is uniform mod 2, 4, 8 (because u·{0..7} mod 8 is a transversal for any odd u) but breaks at mod 16. Consequently 8×8 Sidon images cannot perfectly tile Z_{2^m} for any m ≥ 10. The same obstruction applies at D = 640 (since 16 | 640), though the analogous CP-SAT was not separately run for the chess production modulus. This ceiling does not bind on the chess construction itself — a single embedding into ℤ_640, not multi-grid packing — but it upgrades §9f's selection result from "(67, 7) passes uniqueness" to "(67, 7) is also among the densest-packing shapes," the relevant property if the binding pattern is ever extended to bind multiple grids (multi-board, hierarchical state, role-bound objects) into a single HV. Earlier greedy search reported a "+7" linear scaling in N(D) that was a path-dependent algorithm artifact; the corrected CP-SAT enumeration recovers the true 15/16 ceiling and identifies (67, 7) as on the optimal frontier. Full theorem statement, proof of the ℤ₁₆ Fourier obstruction, and the rest of the addressing-maths Phase 1 hypothesis battery (A-H1 strict-FAIL/offset-PASS, A-H2/A-H3/A-H4 ring-theoretic findings, B-H1 group-algebra closure, B-H2 NTT crossover) live in ADDRESSING_MATHS_APPENDIX.md — a research-record appendix preserving foundation-layer findings that frame chess's construction in a broader mathematical context but do not directly bind on the chess representation.

This IS the UTLP S3 pattern applied to space: where UTLP decomposes TIME into coprime cyclic phases over a shared eigenbasis, this decomposes SPATIAL POSITION into coprime cyclic shifts in the 512-dim HDC vector space.

Measured coprime roll cross-talk: 0.027 (near-zero, clean unbinding).

9g. Encoder Results (Claude Code)¶

The full 512-dim encoder (5 irrep channels + 3 fiber channels) with spectral values and quantum number codebook (subsequently extended to 640-dim in §9a with the antisymmetric pawn fiber and diagonal-deviation channels):

Test	Result	Verdict
A₁ D4 invariance
Fiber non-additivity	Knight+Bishop 44%, Queen+King 81%	CONFIRMED
Terminal particle signal normalization (K=100 → K=2.5)	cos 0.87 → 0.34 (same kings, diff material)	CONFIRMED
HDC unbinding (QN balanced)	58% at 12 pieces	Working (capacity-limited)
HDC unbinding (value-weighted)	25% (trad) → 50% (spectral)	IMPROVED
Field configuration similarity (diverse material)	ρ = 0.71 (320d), ρ = 0.65 (512d)	STRONG
Field configuration similarity (KRK, terminal-dominated)	ρ ≈ 0.05 all encoders	WEAK (signal swamped by K magnitude)
vs PST positional component	ρ ≈ 0 all encoders	No correlation
vs PST material component	ρ ≈ 0.15 all encoders	WEAK

Stockfish depth-gap experiment (55 positions, depth 1 vs depth 20):

Metric	ρ	p-value	Verdict
A₁ energy vs	depth_gap		+0.452
A₁ energy vs	depth_gap	\| piece_count (partial)	+0.456
Fiber energy vs	depth_gap		+0.166
Fiber per piece vs	depth_gap		+0.190
Fiber vs	depth_gap	\| piece_count (partial)	+0.193

The surprise: A₁ (D4-invariant) is the significant predictor, not fiber energy. The channel that averages the board signal across all 8 symmetry transforms — the part of the position that's identical regardless of board orientation — predicts which positions reward deep tactical search (ρ = 0.452, p = 0.0005). This survives piece-count control (partial ρ = 0.456), confirming it's not just "more pieces = more tactics."

Interpretation: A₁ energy measures how much material is centrally concentrated and symmetrically distributed. High A₁ = tense middlegame with engaged, interacting pieces along multiple axes. Low A₁ = asymmetric (one-sided attack, tactically clear) or sparse (endgame, strategically simple). Central tension creates complex evaluation landscapes where depth of search discovers hidden value.

Spectral sensitivity confirmed: 6.61× mean repositioning distance over traditional encoding for same-material pairs. Spectral correlates more with deep search (+0.045) than shallow (+0.026). Category ordering confirmed: HIGH complexity (114cp mean gap) > MEDIUM (38cp) > LOW (34cp).

The fiber energy trend (ρ = +0.356, N=16 in initial test) did not replicate at significance with expanded data (ρ = +0.166, N=55). The interaction topology captured by the fiber channels is real (proven non-additive in Tests 1-4) but doesn't predict tactical depth.

Critical benchmark finding: The spectral encoding does not correlate with piece-square table (PST) positional evaluations. PST tables encode human chess knowledge ("knight on e4 is worth +20cp"). The spectral encoding captures graph-theoretic structure (connectivity, interaction topology). These are genuinely different quantities. The PST benchmark is the wrong ground truth for this encoder — it tests agreement with hand-tuned centipawn tables, not chess understanding. The right ground truth needs Stockfish centipawn scores or Lichess game outcomes, which capture tactical/strategic quality that correlates with graph connectivity.

9h. Toward a Unified Field Description¶

The findings documented in this notebook are not independent observations — they all derive from the same three mathematical objects: the board Laplacian L_grid, the set of piece Laplacians {L_piece}, and the occupation constraint n_i ∈ {0,1}. The fiber bundle (§7), the quantum numbers (§3), the capture decomposition (§5), the cross-species conservation (§5c), the three-level hierarchy (§8b), the D4 symmetry (§9a), and the spectral values (§9c) all emerge from these ingredients interacting through the Laplacian quadratic form.

This pattern is consistent with an underlying unified field description of chess — a single action functional S[f, A] (board field f, connection A on the fiber bundle) whose structure generates all observed phenomena. Several lines of evidence support this interpretation:

Approximate conservation law (§5c). Cross-species field energy is conserved to <0.2% for non-king material captures. In physics, conservation laws arise from continuous symmetries via Noether's theorem. An approximate conservation implies an approximate symmetry of a deeper generating functional.

Natural filtration. The three-level hierarchy (identity → coupling → legality) has the structure of a coarse-graining sequence: Level 1 is thermodynamic (aggregate properties), Level 2 is mesoscopic (field interactions), Level 3 is microscopic (individual edges). This is the signature of a single microscopic description viewed at progressively coarser resolutions.

Nested fiber structure. The rank-3 off-diagonal fiber sits inside the rank-4 full fiber, with the boundary determined by the grid eigenbasis. This is a graded decomposition: gauge content (off-diagonal, invisible to spatial basis) vs total content (gauge + spatial modification). Graded structures are characteristic of gauge theories.

Polarization over taxonomy. The rank-3 → rank-4 → rank-5 nesting is not a quirk of chess's six-piece roster; it is what one would expect if the pieces are polarization states of a single lattice excitation parameterized by (angle θ, range r, chirality c). Under that reading (developed in §9r), the fiber ranks are parameter-count results: the symmetric angle content gives rank 3, the chirality bit (realized only by pawns) adds rank 1, and the range degree (Queen = Bishop + Rook with long range vs king-style short range) adds another rank 1. The coupling-matrix derivation and the polarization derivation land on the same rank-5 total by different routes, which suggests the decomposition is structural rather than coincidental.

D4 × Z₂ as the full symmetry group. The board signal assigns +v to white pieces and −v to black. The sign inversion s → −s is a Z₂ symmetry (spin flip in the Ising sense). The full symmetry group of the encoding is D4 × Z₂ (16 elements): 8 spatial symmetries × 2 spin orientations. D4 alone doesn't separate spatial structure from color/advantage content.

However, the signal is Z₂-antisymmetric by construction (+v for white, −v for black), while all energies (norms, quadratic forms) are Z₂-symmetric because (−f)^T L (−f) = f^T L f. The A₁ energy that predicts depth gap is already D4 × Z₂ invariant — it measures pure positional complexity with no advantage information. This is why it predicts how complex a position is, not who's winning.

For chess, Z₂ is approximate (pawns break it — they're directional). For Othello, Z₂ is exact (the rules are perfectly color-symmetric). This makes Othello the cleaner test domain for the full D4 × Z₂ decomposition. The evaluation decomposition we seek — complexity vs advantage — may be the Z₂-invariant vs Z₂-breaking split, not the D4-invariant vs D4-breaking split.

The double approximation. This framework is a model of almost chess built with tools that almost model the universe. The chess side is approximate: we capture thermodynamic properties (fiber bundles, conservation laws, symmetry decomposition) but provably lose microscopic properties (specific legal moves, tactical sequences). The physics side is approximate: discrete spectral theory on finite graphs, finite-rank fiber bundles, and a 16-element symmetry group are toy versions of the continuous field theories, infinite-dimensional gauge groups, and Lie algebras used in actual physics.

The value of the correspondence lies precisely in its approximate nature. Where both approximations agree (fiber bundles emerge from lattice + species + constraints; conservation laws appear from symmetry), we've found mathematical structure that's deeper than either chess or physics alone — structure that emerges generically from interacting species on structured spaces. Where they disagree (Level 3 is inaccessible; the King's phase-transition property has no clean spectral analog), we've found the boundaries of both approximation frameworks.

The findings in §2-§8 stand as properties of chess's actual mathematical structure, independent of whether the physics analogy extends further. The unified field conjecture (this section) is about whether a single generating functional can reproduce all observed structural properties — a question about chess's own mathematics, not about its resemblance to particle physics.

What is NOT yet identified: The variational principle. A complete unified field description would be a Lagrangian L[f, A] whose Euler-Lagrange equations reproduce: (a) the piece movement rules as connection-domain constraints, (b) the capture dynamics as field annihilation operators, © the approximate conservation as a Noether current, and (d) the D4 symmetry as a gauge invariance. The individual components exist in our framework (the quadratic form f^T L f, the connection form on legal edges, the occupation numbers) but they have not been assembled into a single variational principle.

This section is explicitly conjectural. The evidence is structural (the phenomena share a common origin and exhibit field-theoretic signatures) but the unifying object has not been derived. The findings documented in §2-§8 stand independently of whether this conjecture is ultimately validated.

Literature grounding (§1b.6). Three recent frameworks address this gap directly. The Katagiri NNET framework (arXiv:2508.00207, 2025) covariantly integrates reversible and irreversible dynamics in a single variational structure — matching the chess model's 5:1 T-symmetric:T-breaking excitation type ratio. The Sekizawa spectral entropy decomposition (Physical Review X 14, 041003, 2024) provides per-mode entropy production accounting — potentially decomposing the pawn sector's contribution by spectral channel. The Yumoto-Misumi lattice operator ↔ graph matrix equivalence (PTEP 2024(2), 023B03) provides the mathematical bridge between the notebook's graph-theoretic objects and lattice field theory formalism. See §9i item 9 for the investigation plan.

Epistemological note. Throughout this research, chess language crept into the spectral analysis in ways that distorted interpretation. Terms like "blunder," "safety," "hanging piece," and "positional quality" import a human interpretive framework that the spectral model does not need and cannot validate. The model speaks a different language:

Chess language	Spectral language
Blunder	Suboptimal thermodynamic delta
King safety	Terminal particle coupling
Hanging piece	Spectrally isolated fermion
Positional quality	Field configuration favorability
Material advantage	Z₂-antisymmetric signal magnitude
Tactical complexity	D4 × Z₂-invariant energy (A₁)

The King is not special because a rule assigns it infinite value. The King is the particle whose annihilation produces a phase transition — the system stops evolving. This is a topological property of the dynamics (termination condition), not an energy scale. The spectral value K=2.5 correctly measures the king's movement capacity. The game significance (annihilation = system halt) should be encoded as a separate structural property, not by inflating the signal magnitude.

When we tested "blunder detection" (§9o safety field experiments), the null result (ρ ≈ 0) was partly a failure of the chess framing. A "blunder" is a human category that collapses many different types of suboptimal perturbation into one label. The spectral model can detect structural disruption (F3 channel, |ρ| ≈ 0.28) but doesn't know or care whether that disruption is "good" or "bad" — that judgment requires evaluating the game tree, which is a Level 3 computation.

The model does not reproduce Stockfish evaluations because it is not computing the same thing. Stockfish computes "which side wins with perfect play from here." The spectral model computes "what is the structural composition of this field configuration." Agreement between two independent approximate models (where it exists, as in A₁ vs eval volatility at ρ = +0.134) is the finding. Disagreement (where it exists, as in ΔS vs Δeval at ρ ≈ 0) maps the boundary between structural description and tactical computation.

9h′. Follow-Up Experiments: Z₂ Confirmation and New Discoveries¶

Implementation: archive/chess_a1_followup.py — three experiments building on the A₁ depth-gap discovery.

Experiment 1: Z₂ Decomposition Confirmed¶

The D4 × Z₂ symmetry framework predicts two orthogonal types of information: - Channel ENERGY (‖projection‖) is D4 × Z₂ invariant → predicts complexity (unsigned quantities) - Channel SIGNED SUM (Σ projection) is Z₂-antisymmetric → predicts advantage (signed quantities)

Both predictions confirmed on the 55-position depth-gap corpus:

Table 1 — Energy (Z₂-invariant) vs unsigned targets (N=55, Spearman ρ) — reprocessed 2026-04-23 on corrected D₄ character table (PATCH 6 audit fix):

Channel	vs \|depth_gap\|	vs \|SF_d20\|	Partial (ctrl pieces)
A₁	+0.452 (p=0.0005)	+0.467	+0.456 (p=0.0005)
A₂	+0.310 (p=0.021)	+0.424	+0.366 (p=0.006)
B₁	+0.302 (p=0.025)	+0.302	+0.303 (p=0.026)
B₂	+0.405 (p=0.002)	+0.481	+0.490 (p=0.0002)
E	+0.177	+0.190	+0.225
breaking	+0.166	+0.226	+0.245 (p=0.075, trending)
fiber	+0.166	+0.236	+0.193

A₁ replicates perfectly and remains the strongest single channel. B₁ and B₂ are now numerically distinct (post-audit): under the broken D₄ character table they reported identical partial ρ = +0.461, which was the bug manifesting — the non-class-constant character rows collapsed both channels onto the same projection. With corrected characters B₁ partial = +0.303, B₂ partial = +0.490 — the diagonal-reflection channel (B₂, orbits diagonal) is the stronger complexity predictor after piece-count control, outperforming A₁ partial (+0.456) on this metric. B₁ (orbits orthogonal) is the weaker of the two. The corrected decomposition matches the §10.4 Othello-derived rook/bishop signature: B₂ lives in the diagonal-orbit edge set and B₁ in the orthogonal-orbit edge set (grid-topology theorem, not coincidence; see §10.4 PATCH 1).

Table 2 — Signed sum (Z₂-antisymmetric) vs signed SF evaluation (N=55) — reprocessed 2026-04-23:

Channel	vs SF_d20 (raw)	Partial (ctrl material)
A₁	+0.527 (p<0.001)	−0.057 (n.s.)
A₂	−0.033	−0.012
B₁	+0.019	−0.069
B₂	−0.095	+0.039
E	−0.145	−0.293 (p<0.05)
breaking	−0.097	−0.310 (p=0.022)

Z₂ confirmation: A₁ signed sum has the strongest raw correlation with evaluation (+0.527) but collapses to zero after material control (−0.057). This proves A₁ signed sum is a material-counting proxy: the Z₂-antisymmetric signal IS material balance, as the theory predicts. A₁ energy measures complexity; A₁ signed sum measures material. Same channel, orthogonal quantities, separated by the Z₂ decomposition.

E channel result: The E channel (2-dim D₄ irrep) shows a significant negative partial correlation (ρ=−0.293, p<0.05) with evaluation after material control. Unchanged by the audit (E character row was already class-consistent). The E channel signed sum captures oriented structural asymmetry that correlates negatively with engine evaluation after material control. In chess terms this corresponds to positional weakness (exposed king, bad pawn structure, coordination deficits); spectrally it's a specific eigenmode pattern in the 2-dim D4 irrep.

"Breaking channels predict who's winning" — CONFIRMED after the audit. Pre-audit, the combined breaking signed correlation was reported as non-significant (ρ = +0.022 raw, +0.101 partial). On the corrected character table this becomes ρ = −0.097 raw, −0.310 partial (p=0.022) — significant and in the same direction as the individual E channel. The broken B₁/B₂ rows had been injecting sign-inconsistent contributions into the "breaking" sum that cancelled the real effect; with the fix, the combined breaking channel and the individual E channel both carry the structural-weakness signal. This is the most significant downstream change from the PATCH 6 audit: a previously-null hypothesis (combined breaking → advantage) is now confirmed.

Experiment 2: Game Trajectory Analysis¶

Five famous master games replayed ply-by-ply with spectral tracking and Stockfish evaluation:

ΔA₁ derivative analysis. Beyond asking "when is complexity highest?" (A₁ peak), we compute per-ply ΔA₁ = A₁(ply) − A₁(ply−1) and ask "when does complexity break?" (largest negative ΔA₁). The maximum A₁ drop marks the moment the position transitions from complex to resolved — the simplification event.

Cross-game alignment (5 hand-picked masterpieces):

Game	Peak ply	Drop ply	Crisis ply	Peak off	Drop off	Tighter
Kasparov-Topalov 1999	70	73	48	−22	−25	PEAK
Carlsen-Anand WCC 2013	51	30	102	+51	+72	PEAK
Fischer-Spassky 1972	45	36	73	+28	+37	PEAK
Botvinnik-Tal 1960	46	33	50	+4	+17	PEAK
Topalov-Anand WCC 2010	47	19	58	+11	+39	PEAK

A₁ peak wins decisively. The peak is the tighter crisis predictor in all 5 games (mean |offset| 23.2 vs 38.0 for the drop). The ΔA₁ drop detects a different event — the moment of maximal simplification — which systematically precedes the peak by many plies. In structural terms: complexity breaks early (a key piece is exchanged, a pawn structure is locked), then the residual complexity peaks as the game reaches its tactical climax, and only then does the evaluation swing. The drop is a precursor to the peak, not a replacement.

Per-game Spearman(|ΔA₁|, |eval_change|): The ply-level correlation between rate of spectral change and rate of evaluation change is essentially zero across all 5 games (mean ρ = −0.004). Individual games: Kasparov-Topalov −0.119, Carlsen-Anand −0.084, Fischer-Spassky +0.191, Botvinnik-Tal +0.066, Topalov-Anand −0.076 — all non-significant. This means ΔA₁ captures structural transitions, not tactical transitions. The moments where A₁ changes fastest are not the moments where the engine changes its evaluation fastest. These are orthogonal types of volatility.

E channel partial replication across trajectories: The Experiment 1 finding (negative E partial ρ=−0.293) partially replicates in game trajectories. Per-game E signed sum vs SF eval, controlling for material:

Game	E partial ρ	p-value	Significant?
Kasparov-Topalov 1999	−0.068	0.53	no
Carlsen-Anand WCC 2013	−0.064	0.50	no
Fischer-Spassky 1972	−0.056	0.62	no
Botvinnik-Tal 1960	−0.264	0.011	yes
Topalov-Anand WCC 2010	+0.280	0.032	yes (positive!)

⅘ games show negative E partial (consistent with the static corpus), mean ρ = −0.034. The Botvinnik-Tal game reaches significance — Tal's speculative sacrifices create positions where the E channel detects structural weakness even when material is balanced. The Topalov-Anand exception (positive ρ) may reflect the Grünfeld's unique pawn structure where apparent structural weaknesses are compensated dynamically.

Experiment 2b: Large-Scale Validation (20 fishtest games)¶

Random Stockfish-vs-Stockfish games from the HuggingFace official-stockfish/fishtest_pgns dataset (via pgn_fetcher.py). These are engine games starting from book positions — no selection bias toward dramatic turning points.

Pooled correlations (N=2165 plies across 20 games):

Metric	ρ	p	Verdict
A₁ vs \|SF_d12\|	+0.030	0.17	Not significant
A₁ vs \|eval_change\|	+0.134	<10⁻⁶	SIGNIFICANT
\|ΔA₁\| vs \|eval_change\|	+0.007	0.78	Not significant
E_signed vs SF (partial, ctrl mat)	+0.036	0.09	Trending (n.s.)

Key result: A₁ does NOT correlate with evaluation magnitude in engine games (these are balanced positions from book openings). But A₁ significantly predicts evaluation volatility — the ply-to-ply swings where the engine changes its mind. This is the correct interpretation: A₁ measures positional complexity (positions that reward deep search), not advantage.

ΔA₁ does not generalize. The ply-level |ΔA₁| vs |eval_change| correlation is zero at scale (ρ=+0.007, p=0.78), confirming the hand-picked game finding. ΔA₁ captures structural phase transitions that are orthogonal to tactical volatility.

E channel partial washes out at scale. The E signed sum's negative partial (ρ=−0.293 in the static corpus, ⅘ negative in hand-picked games) does not survive pooling across 20 engine games: mean per-game partial ρ=+0.009, only 11/20 negative. The E channel signal appears to be a feature of human games with clear positional imbalances — engine-vs-engine games from book positions are too positionally balanced for the E channel to detect structural weakness. This is consistent with the E channel measuring something real (positional weakness) that is systematically absent in well-played engine games.

Peak vs drop alignment at scale: A₁ peak remains the better predictor (mean |peak offset| 23.0 plies vs 27.1 for drop), with 11/20 games favoring peak. The advantage narrows compared to hand-picked masterpieces, suggesting the peak/drop distinction matters more in games with dramatic turning points than in balanced engine play.

Data source: pgn_fetcher.py provides a reusable API for pulling games from the 1TB HuggingFace dataset (1000 dates, 2018–2021). Stream-parses .pgn.gz files with local caching. Scales to hundreds of games for future statistical analysis.

9i. Remaining Open Items¶

~~Stockfish benchmark~~ ✅ DONE. Stockfish installed, depth-gap experiment (ρ=+0.452, p=0.0005), Z₂ decomposition, trajectory analysis across 5 masterpieces + 20 fishtest games. A₁ energy confirmed as complexity predictor; A₁ signed sum confirmed as material proxy; E channel identified as positional weakness marker.
~~Pawn directed Laplacian~~ ✅ DONE (archive/chess_pawn_laplacian.py). Directed adjacency decomposed via (A + A^T)/2 into symmetric (Hermitian) and antisymmetric (Z₂-breaking) parts. Spectral pawn value P=0.84 (below traditional 1.0). Quantum 5-tuple (0,9,0,0.13,5.66) is unique — all 6 pieces now classified. Z₂ breaking: ||A_anti||/||A_sym|| = 1.0, confirming directionality is not a perturbation but a 50/50 split. Fiber coordinates [-3.98, 1.38, 1.48], closest to King (cos=0.65). Movement vs capture sub-graphs are spectrally distinct (fiber cos=0.52). Symmetry correction: the spec's proposed (A_white + A_black)/2 is NOT symmetric (rotation ≠ transpose); fixed to standard transpose decomposition.
Resonator network decoding: Iterative unbinding to improve past 58% accuracy ceiling.
~~Game-outcome benchmark~~ ✅ SUPERSEDED. Trajectory analysis with SF evaluation at every ply (Exp 2/2b) provides continuous evaluation ground truth, which is strictly more informative than discrete win/draw/loss outcomes.
~~Othello implementation~~ ✅ PHASE 0-2 DONE (2026-04-22). Foundation in ../othello-maths/: D₄×Z₂ projectors, 8 ray Laplacians, coprime generator table, static fiber holonomy, minimal Hansen-Ghrist sheaf Laplacian, and a Phase 1 verification battery (H1–H9, E1–E8) all pass or land as PARTIAL by design. See §10.12 for the pass-table summary, ../othello-maths/othello_spectral_research_notebook.md for per-hypothesis numerics. Remaining: A₁ depth-gap transfer (H9), Takizawa perfect-play correlations (E8), and WTHOR tournament tests (§10.10 T1–T5) — all blocked on external data, scoped to sequel.
LOGO prototype: Split-object HDC prototype validating that the decomposition-by-symmetry pattern generalizes beyond chess (see §9l). Establishes that a turtle-graphics program is a composite of a discrete control graph (command sequence, branch structure) and a continuous kinematic field (turtle trajectory, pen state), with the spectral decomposition applied independently to each substrate. Status: iterations 1-3 complete in docs/logo-maths/; framework pattern validated.
Scale fishtest analysis: The ρ=+0.134 (p<10⁻⁶) eval-volatility finding from 20 games / 2165 plies should be validated at 200+ games. The E channel partial (which washed out at N=20) may recover signal at larger N if the effect is real but small. pgn_fetcher.py is ready for this.
Epistemological audit: Review all section titles, figure labels, and variable names for chess language creep. Replace with spectral/physics language where the chess term implies the model detects a chess concept rather than a structural property. First pass applied in §1, §9g, §9h, §9h′, §9o; second pass should extend to §5-§8 code variable names (e.g. rename safety_field → coverage_balance or similar at the Python level).
Yumoto-Misumi lattice↔graph equivalence investigation: Yumoto & Misumi (PTEP 2024(2), 023B03) establish rigorous equivalences between lattice field theory operators and spectral graph theory matrices — graph Laplacian = lattice scalar operator + Wilson term; antisymmetrized adjacency matrix for directed graphs; Dirac zero-mode count = sum of Betti numbers. This is the most direct mathematical bridge between the notebook's graph-theoretic objects (piece Laplacians, fiber bundle, spectral decomposition) and lattice field theory formalism (propagators, gauge connections, fermion operators). Specific investigation targets: (a) map the notebook's per-piece Laplacians onto lattice scalar operators via the Yumoto-Misumi correspondence and verify whether the fiber bundle structure (§7, §9n) survives the translation; (b) determine whether the pawn's antisymmetric adjacency matrix (§9m) maps onto a lattice Dirac operator via the antisymmetrized adjacency matrix construction; © test whether the Betti number relation predicts the topology of the piece movement graphs (knight bipartiteness, bishop 2-component, rook regularity) from the Dirac zero-mode count; (d) assess whether the Wilson term in the correspondence provides a natural formalization of the §8b Level 2/Level 3 boundary (the Wilson term is the lattice artifact that the continuum limit removes — paralleling how Level 3 microscopic edge information is integrated out by the fiber). This investigation is prerequisite to the §9h variational principle: if the notebook's objects translate cleanly into lattice field theory operators, the Lagrangian may already exist in the standard lattice field theory action, specialized to the chess lattice geometry.

9j. Othello as Validation Domain — see §10¶

The original "Future Work: Othello as Validation Domain" subsection has been promoted to a full top-level section, §10. Phase-Space Othello, after a foundation-anchored survey of 9 candidate mathematical frameworks converged on a hybrid synthesis (Blume-Capel spin-1 site fiber + exact D₄×Z₂ + 8-ray decomposition 2A₁⊕B₁⊕B₂⊕2E + Wolff-like flanking under Fraenkel two-player bounded-change non-local CA semantics + Hansen-Ghrist sheaf Laplacians with dynamic restriction maps + Sagawa-Ueda information thermodynamics under a Boltzmann-policy embedding). The migrated text, literature grounding, and falsifiable WTHOR predictions all live in §10.

Verification status (2026-04-22): Phase 0–2 of §10 is now computationally grounded. The structural predictions (§10.4 decomposition, §10.7 sheaf Laplacian instantiation) are CONFIRMED; the rank claim was partially revised (rank-6 did not emerge as an operator rank — it is an irrep multiplicity). WTHOR empirical tests (§10.10) remain open pending external data. See §10.12 for the pass-table and ../othello-maths/ for the full artifact set.

Prior art candidates for formal documentation¶

#	Finding	Connection type	Literature grounding (§1b)
1	Rank-5 complete fiber bundle over chess board graph (3 symmetric + 1 antisymmetric + 1 diagonal)	—	Dual derivation: subspace + polarization (§9n, §9r)
2	Rank-3 off-diagonal shared fiber (the gauge content subset)	—	No prior art found
3	Rank-4 full fiber with rook's diagonal shadow	—	No prior art found
4	Pawn antisymmetric fiber: \|\|A_anti\|\|/\|\|A_sym\|\| = 1.000 (only Z₂-breaking operator)	MATHEMATICAL	Hatano-Nelson t_L = 0 (§1b.1); Nielsen-Ninomiya evasion (§1b.1)
5	5-tuple spectral quantum number classification (all 6 piece types, including pawn)	—	No prior art found
6	Capture spectral decomposition (movement + annihilation + cross-term)	MATHEMATICAL	Weyl perturbation theory
7	Knight exact DCT orthogonality to all sliding pieces	MATHEMATICAL	Cayley graph eigenvalue theorem (§1b.3); Niven's theorem (§1b.3)
8	Cross-species field energy transfer with approximate conservation	MATHEMATICAL	Five frameworks: BGI, PCAC, Ward, GW, KAM (§1b.2)
9	Three-level hierarchy of rule encoding (identity / coupling / legality)	—	Level 3 provably unrecoverable; Wilson term analogy via Yumoto-Misumi (§9i.9)
10	Spectral piece values from movement graph mean degree (P=0.84, N=2.0, B=3.4, R=5.4, Q=8.8, K=2.5)	MATHEMATICAL	Lattice propagator mass-range relation (§1b.5)
11	D4 irrep decomposition → A₁ as depth-gap predictor (ρ=+0.452, p=0.0005)	MATHEMATICAL	DCT = dihedral irreps (Püschel & Moura 2003; §1b.3)
12	Z₂ decomposition: energy → complexity, signed sum → material (confirmed)	—	Empirical; D4 × Z₂ group theory
13	A₁ eval-volatility correlation (ρ=+0.134, p<10⁻⁶, N=2165 plies, 20 games)	—	Empirical
14	B₁/B₂ rook/bishop signature split (post-PATCH-6 audit): B₁ partial ρ=+0.303, B₂ partial ρ=+0.490 — B₂ (diagonal orbit) outperforms A₁ as complexity predictor	—	Empirical; pre-audit reported identical +0.461 (bug artefact)
15	8-generator spectral lattice as domain-specific coprime basis	—	Connects to UTLP S3
16	Coprime roll binding as UTLP S3 spatial analog	—	UTLP S3 pattern
17	Pawn as spectral composite: king-like forward movement + bishop-like diagonal capture (cos=0.52)	MATHEMATICAL	Lattice propagator anisotropy (§1b.5); HN model decomposition (§1b.1)
18	F3 (third symmetric fiber dimension) as eval volatility predictor (\|ρ\| ≈ 0.28, replicates across two independent games)	—	Empirical
19	Chaos ratio (fiber/irrep balance) as game character classifier (sharp vs positional)	—	Empirical; entropy production mode decomposition (Sekizawa et al. 2024; §1b.6)
20	Empirical confirmation of Level 2/Level 3 boundary (Kg4?? null result: zero spectral signature on a known tactical blunder)	—	Empirical confirmation of §8b theoretical prediction
21	Polarization parameterization: six excitation types as (angle θ, range r, chirality c) orientational states (§9r)	MATHEMATICAL	Lattice propagator (§1b.5); D₄ orbit structure; HN asymmetry (§1b.1)
22	Dual derivation of rank-5 fiber: subspace decomposition and polarization parameter count yield same integer (§9n, §9r)	—	Two independent routes to same structural invariant
23	Extensibility prediction for fairy pieces: (θ, r, c) triple predicts DCT-orthogonality and fiber contribution before measurement (§9r)	—	Falsifiable; (3,1) L-piece as first probe
24	NHSE as pawn promotion-rank accumulation mechanism	MATHEMATICAL	Shen et al. 2025; Hu 2025 (§1b.1)
25	Pawn as non-Hermitian chiral fermion evading Nielsen-Ninomiya doubling	MATHEMATICAL	Ma & Zhang 2024; Chen, Giedt & Poppitz (§1b.1)
26	KL divergence = ∞ per pawn advance (maximal entropy production per T-breaking move)	MATHEMATICAL	Seifert 2012; Roldán & Parrondo 2012 (§1b.1)
27	Knight graph asymptotically isospectral to higher-dimensional lattice (explains d_eff ≈ 3–5)	MATHEMATICAL	Saburova 2024 (§1b.3)

9k. Broader Frame: Spectral Decomposition as Cross-Species Communication Primitive¶

The spectral framework extracts game structure without assuming game purpose. We never told the system that chess is about checkmate. We fed it adjacency matrices and eigendecompositions. It found quantum numbers, fiber bundles, conservation laws, and symmetry groups — structural invariants that exist regardless of what the game is for.

This connects to a foundational problem in communication theory: the alien watching tic-tac-toe.

An intelligence observing an unknown rule-governed system (a game, a language, a social interaction) faces a decomposition problem. It can extract structural invariants from the observable behavior — spectral content, symmetry groups, statistical regularities across contexts. These correspond to the physics of the system: what happens and how it's constrained. But the semantics — why these patterns are valued, what "winning" means, what the signals intend — sits outside the mathematical structure. The Lagrangian describes the dynamics; it doesn't contain the winning condition.

Our three-level hierarchy maps onto this distinction: - Level 1 (piece identity) and Level 2 (field coupling) are recoverable from passive observation — the alien watching tic-tac-toe can discover these from structural analysis alone. - Level 3 (specific move legality) is the domain of the connection form — it defines which transitions exist but can't be measured from non-transitions. - Level 4 (purpose/semantics) is outside the framework entirely — no amount of spectral decomposition reveals that three-in-a-row means "winning."

The interactive resolution of Level 4 is the key: the alien plays a move, observes the reaction, and refines its model of what the game means. This is bidirectional — the human also updates their model of what the alien understands. Over multiple exchanges, a shared semantic space emerges that neither party had initially.

Connection to AAC and the mlehaptics Project. This is the formal structure underlying assistive communication. An AAC device mediates between systems that don't share a native signal format. The user's intent signals (gesture, gaze, muscle activation, haptic input) arrive in a modality that doesn't map directly onto spoken language. The device must:

Decompose the signal's structure into invariant features (the spectral step — find the eigenmodes, identify what's consistent across contexts)
Map those features onto a shared representational space (the encoding step — build a codebook where similar intents produce similar vectors)
Iteratively refine the mapping through interactive probing (the calibration step — propose interpretations, receive corrections, update the model)

Step 1 is what the chess spectral framework does. Step 2 is what the HDC codebook architecture provides. Step 3 is the bidirectional communication loop that no amount of passive analysis can replace.

The spectral approach makes the probing efficient: by identifying which structural features carry the most discriminative information (the high-variance eigenmodes, the non-trivial fiber components, the D4-invariant content), the interactive refinement focuses on the dimensions that matter most. This is mathematically equivalent to what a good clinician does when calibrating an AAC device — attending to the signals that are most consistent and most differentiated, not to noise.

A note on cognitive architecture. This research was shaped by Steven's specific neurological profile: aphantasia (no voluntary visual imagery), anauralia (no voluntary auditory imagery), and mirror-touch synesthesia. The spectral framework — which represents spatial structure through eigenmode decomposition rather than visual imagery, captures interaction topology through abstract fiber coordinates rather than pictorial diagrams, and characterizes symmetry through algebraic group actions rather than geometric visualization — is naturally aligned with a cognition that navigates abstract spaces through proprioceptive and structural channels rather than visual simulation.

The insight that chess pieces behave like subatomic particles with resonant structure was not a visual metaphor. It was a direct structural mapping from a mind that already represents the world as interaction topology: things-with-properties on a lattice governed by rules. The alien watching tic-tac-toe and the aphantasic mind navigating social communication face the same formal problem — extracting structural invariants from signals that arrive in a non-standard format, then building shared meaning through iterative interaction. The mathematics developed in this notebook formalizes the decomposition step. The communication step remains an open problem in both game theory and assistive technology.

9l. Future Work: LOGO as a Split-Object HDC Prototype¶

The chess fiber bundle connects piece identity (what a piece IS) to positional coupling (what a piece DOES on the board). These are separate structures joined by the fiber. Steven proposed generalizing this as a reusable HDC design pattern: split objects — two HDC subspaces encoding different aspects of a system, coupled by an explicit fiber matrix that encodes how the aspects interact. The fiber matrix is the interesting part: its rank reveals the intrinsic coupling complexity, its singular values identify the dominant interaction modes, and its null space identifies what's structurally inert.

The C99 programming language was considered as a test domain (keywords as atoms in Part A, grammar rules as structure in Part B, fiber F coupling them). But C99 has ~37 keywords, hundreds of grammar productions, and no natural spatial output to decompose spectrally. LOGO is a better prototype because its command set is tiny, its grammar is minimal, and its output IS spatial geometry that we already know how to decompose.

Why LOGO maps naturally onto the spectral framework:

LOGO commands are spatial transformations on a 2D plane. FORWARD is a translation. RIGHT is a rotation. PENUP/PENDOWN toggles trace state. This is closer to chess than C99 — chess pieces are spatial transformations on a discrete lattice, LOGO commands are spatial transformations on a continuous plane (which can be discretized to a grid for spectral analysis).

The core LOGO vocabulary is ~12 commands: - Movement: FORWARD, BACK, LEFT, RIGHT (spatial transform + numeric argument) - Pen state: PENUP, PENDOWN (binary toggle, no argument) - Control flow: REPEAT (count + block), IF (condition + block) - Procedures: TO, END (paired block delimiters) - Variables: MAKE, THING (binding operations)

The three-space architecture:

Part A — Command vocabulary (the atoms). Each command gets an HDC vector from its "quantum numbers": (category: spatial/state/control/binding, arity: 0/½, argument_type: number/block/name, reversibility: FORWARD↔BACK, LEFT↔RIGHT, PENUP↔PENDOWN). These classify commands the way our 5-tuple classified chess pieces.

Part B — Syntactic structure (the rules). Grammar productions defining legal command sequences, block nesting, argument type constraints. Small enough (~20 productions) to enumerate completely.

Part C — Output geometry (the shapes). The spatial trace the turtle leaves. Discretized onto a grid, decomposed spectrally. Unlike chess where the board is fixed and pieces move ON it, in LOGO the "board" is the OUTPUT that the commands CREATE.

Fiber F₁ (vocabulary ↔ syntax): How commands participate in grammar. Predicted rank: 3-4. Modes: "spatial transform with argument" (FORWARD/BACK/LEFT/RIGHT share this), "state toggle" (PENUP/PENDOWN), "block-opening control" (REPEAT/IF/TO), "variable binding" (MAKE/THING).

Fiber F₂ (syntax ↔ geometry): How program structure determines output shape. This is the novel fiber — connecting abstract rule space to concrete spatial output. The spectral content of the program (nesting depth, repetition counts, argument values) couples to the spectral content of the shape (symmetry order, spatial frequencies, Laplacian eigenvalues).

The symmetry connection is direct:

REPEAT 4 [FORWARD 100 RIGHT 90] draws a square — D4 symmetry. The program's REPEAT 4 maps onto the 4-fold rotation of the output. REPEAT 3 [FORWARD 100 RIGHT 120] draws a triangle — D3 symmetry. REPEAT 360 [FORWARD 1 RIGHT 1] approximates a circle — SO(2). The symmetry group of the output is determined by the program's repetition structure. The fiber F₂ encodes this: "REPEAT n [FORWARD d RIGHT 360/n]" → "regular n-gon with Dₙ symmetry."

Progression path:

Basic turtle (~12 commands): tiny fiber, fully characterizable. Compute F₁ rank exactly, verify it matches the predicted 3-4 modes.
Add procedures (TO/END): creates a new abstraction layer. The fiber should gain dimensions (procedure calls are a new coupling mode between program structure and execution behavior).
Add recursion (recursive TO): tree fractals, Koch snowflakes. Output geometry becomes self-similar, spectral content gets rich (fractal dimension appears in the eigenvalue distribution).
Add multiple turtles: now there are multiple "species" with independent state. The chess fiber bundle structure should reappear — cross-turtle coupling through shared canvas is the analog of cross-piece coupling through shared board.

What we'd learn:

The rank of F₁ measures the intrinsic syntactic complexity of LOGO — how many independent modes of command-rule coupling the language has. The singular value spectrum identifies which modes dominate. The null space identifies syntactically inert degrees of freedom that could be extended without breaking the grammar.

The fiber F₂ (program ↔ geometry) directly tests whether the spectral framework can detect structure in the relationship between abstract rules and concrete spatial output — the same question underlying the entire chess investigation. If the symmetry group of a LOGO program's output is recoverable from the spectral decomposition of the fiber connecting program space to shape space, that validates the framework in a domain completely unrelated to board games.

The split-object-with-fiber-matrix pattern may generalize as a reusable component in the PHYRFLY protocol suite: a standard architecture for encoding "things + rules about things" as coupled HDC subspaces, applicable to games, languages, communication systems, and assistive technology interfaces.

9m. Pawn Directed Laplacian: The Last Uncharacterized Piece¶

File: archive/chess_pawn_laplacian.py — standalone, imports from archive/encoder_512.py.

The pawn was the only piece without spectral characterization. Unlike all other pieces (whose movement is symmetric — a knight can go from A to B iff it can go from B to A), pawns have directed movement (forward only), making their adjacency matrix non-symmetric and the naive Laplacian non-Hermitian.

Symmetry correction. The original approach proposed A_sym = (A_white + A_black)/2, claiming this is symmetric because A_black = rot180(A_white). This is wrong: 180-degree rotation ≠ matrix transpose. The sum has 120 asymmetric elements. The correct decomposition uses the standard matrix splitting of A_white: - A_sym = (A + A^T) / 2 — guaranteed Hermitian - A_anti = (A − A^T) / 2 — guaranteed antisymmetric, captures Z₂-breaking directionality

Key results:

Property	Value	Interpretation
Spectral pawn value	0.84 (was 1.0 hardcoded)	16% below traditional; pawn is spectrally weaker due to restricted directed mobility
Quantum 5-tuple	(0, 9, 0, 0.13, 5.66)	Unique — all 6 pieces now classified. 9 components = 8 isolated rank-1 squares + 1 connected subgraph
		A_anti
A_anti eigenvalues	Pure imaginary (22 conjugate ±iλ pairs)	Confirmed: real antisymmetric → pure imaginary spectrum
cos(fiber_sym, fiber_anti)	0.168	Nearly orthogonal in fiber space — symmetric and directional content live in different subspaces
Fiber 3D	[−3.98, 1.38, 1.48]	Closest to King (cos=0.65), consistent with both being short-range movers
Move vs capture fiber cos	0.52	Movement and capture sub-graphs are spectrally distinct (different board coupling)
Move spectral value	0.34	Forward moves alone are spectrally very weak
Capture spectral value	0.50	Captures have higher spectral value than forward moves

Z₂ breaking. The norm ratio ||A_anti||/||A_sym|| = 1.0 is the central finding. For all other pieces this ratio is exactly 0 (their adjacency is symmetric, so A_anti = 0). The pawn is the ONLY piece where the Z₂-breaking operator content equals the Z₂-preserving content. This is not a small correction — it is a fundamental structural property. The pawn's directional asymmetry is as spectrally important as its spatial connectivity.

Codebook improvement. The pawn's quantum number codebook entry is now derived from actual spectral data (not random). Cross-piece |cos| remains below 0.06 — the pawn's codebook vector is nearly orthogonal to all other pieces, as desired.

Benchmark impact. Replacing P=1.0 with P=0.84 in the board signal produces slightly tighter pairwise encodings (mean distance 12.28 vs 12.48), a small improvement consistent with the modest 16% value change.

Literature grounding (§1b.1). The pawn's forward-only hopping is an instance of the Hatano-Nelson model at the maximally asymmetric limit t_L = 0 (Hatano & Nelson 1996). The non-Hermitian skin effect predicts eigenstate accumulation at the forward boundary — realized as pawn density at the promotion rank. The forward-difference discretization evades the Nielsen-Ninomiya fermion doubling theorem (Ma & Zhang 2024): the pawn CAN be a single chiral fermion without a doubler because non-Hermiticity breaks the theorem's assumptions. The ||A_anti||/||A_sym|| = 1.0 norm ratio is the spectral signature of maximal T-symmetry breaking — every pawn advance produces formally infinite KL divergence (Seifert 2012), contributing maximal entropy production to the system.

9n. The Complete Fiber: Rank-5 from Three Orthogonal Subspaces¶

The pawn's antisymmetric fiber completes the picture of rule content in chess. The full fiber bundle has rank 5, arising from three mathematically orthogonal types of coupling between board eigenmodes:

Type 1 — Symmetric off-diagonal (rank 3). How pieces create undirected coupling between eigenmodes: mode i and mode j are mutually coupled with strength s, where C[i,j] = C[j,i]. This is the original rank-3 fiber from §7 — Knight, King, Bishop, Queen all contribute symmetric coupling. The pawn's symmetric part (A_sym) also contributes here, nearest to the King (cos=0.65). σ₁=1.70 (72.6%), σ₂=0.82 (16.9%), σ₃=0.65 (10.5%), σ₄=0.00.

Type 2 — Antisymmetric off-diagonal (rank 1). How pieces create directed flow between eigenmodes: mode i drives mode j with strength +s, mode j drives mode i with strength −s, where C[i,j] = −C[j,i]. ONLY the pawn has this. Every other piece has symmetric movement (A→B implies B→A), so their antisymmetric adjacency content is exactly zero. The pawn's ||A_anti||/||A_sym|| = 1.000 means this content is as spectrally important as its symmetric coupling. cos(fiber_sym, fiber_anti) = 0.168 confirms these live in nearly orthogonal subspaces.

A sum of symmetric patterns is always symmetric. An antisymmetric pattern is orthogonal to all symmetric patterns by construction. The rank-3 symmetric basis CANNOT span the pawn's directional content. This is a genuinely new fiber dimension — the first and only one that breaks Z₂ at the operator level (not just the signal level).

Type 3 — Diagonal deviation (rank 1). How pieces modify eigenmode energies without coupling modes: the per-mode energy shift relative to the grid Laplacian. This is the rook's shadow from §7b — the rook has the largest diagonal deviation (88.05) despite having zero off-diagonal content. The grid eigenbasis masks this content (it sits on the same axes as the grid's own eigenvalues), making it invisible in the off-diagonal analysis.

The three types are mutually orthogonal in the full coupling space. Off-diagonal symmetric elements occupy the upper triangle with C[i,j] = C[j,i]. Off-diagonal antisymmetric elements occupy the same upper triangle with C[i,j] = −C[j,i]. Diagonal elements occupy the diagonal. These are structurally distinct matrix subspaces with zero overlap. The total fiber rank is additive: 3 + 1 + 1 = 5.

Fiber type	Source pieces	Rank	Discovered in	Encoded in
Off-diagonal symmetric	Knight, King, Bishop, Queen, Pawn(sym)	3	§7	Channels 6-8 (was 512-dim)
Off-diagonal antisymmetric	Pawn only	1	§9m	Channel 9 (NEW — 640-dim)
Diagonal deviation	Rook (+others)	1	§7b	Channel 10 (NEW — 640-dim)

Completeness argument. The 64×64 coupling matrix C = U^T L U decomposes uniquely into diagonal (64 elements), symmetric off-diagonal (2016 elements), and antisymmetric off-diagonal (2016 elements). Each subspace's rank across 6 piece types is bounded by min(6, subspace dimension). We measured: symmetric off-diagonal rank = 3 (Queen = Bishop + Rook eliminates one degree of freedom), antisymmetric rank = 1 (only pawn contributes), diagonal rank = 1 (Queen = Bishop + Rook again). Total = 5. No additional chess piece type can add dimensions because all three subspaces are already measured and their ranks determined. The fiber is complete.

Dual derivation. The rank-5 result has a second, independent derivation via the polarization reframing (§9r): the parameter space (θ, r, c) = (3 angle classes + 1 chirality bit + 1 range degree) also sums to 5. The two paths — subspace decomposition of the coupling matrix and parameter count of the polarization labels — land on the same integer by different routes. That kind of agreement is a hint that the decomposition is a structural feature of the lattice excitation, not an artefact of how we chose to project it.

9o. Safety Field and Channel Delta Analysis: Honest Negatives¶

Files: chess-spectral/python/chess_spectral/safety_field.py, chess-spectral/python/analyze_safety.py, chess-spectral/python/analyze_channel_deltas.py

Two GM games were analyzed ply-by-ply with a "safety field" — a scalar S measuring net spectral influence balance (friendly vs enemy movement-graph coverage, weighted by spectral piece values) — and per-channel energy deltas across all 10 encoding channels.

The scalar safety field does NOT correlate with engine evaluation.

Game	Rating	Plies	ρ(ΔS, ΔEval)	p
Fabsid-Qvagmire (Ragozin)	2762 v 2748	116	+0.059	0.53
Mishka-Glasnost (Zukertort)	3186 v 3239	115	−0.013	0.89

The safety field measures aggregate movement-graph coverage — how much of the board's topology each side controls. This is a Level 2 (structural) measurement. It cannot detect pins, forks, discovered attacks, or overloaded defenders, all of which are Level 3 (specific edge conjunctions requiring search). The scalar S is dominated by gross coverage reshuffling: queen moves create ΔS swings of ±70 in dead-drawn perpetual check positions.

The Kg4?? test case (VEYpgB14). White's king walks into a rook pin on the f-file. Eval swings from +1.69 to 0.00. All 10 channel z-scores are near zero — the spectral encoding sees nothing anomalous. This is the empirical confirmation of the §8b prediction: Level 3 tactical patterns (multi-piece spatial conjunctions along specific movement rays) are invisible to the fiber-based encoding. The king moved to a square with MORE friendly coverage (ΔS positive), but into a tactical pattern the movement graph can't represent.

The Nxd4?? test case (VEYpgB14). The knight sacrifice on d4 IS partially visible: F3 z-score = −3.02, F2 = +2.07. This move is both tactically bad AND structurally disruptive — the knight reshapes the center's interaction topology. The encoding detects the structural disruption but cannot evaluate whether it's good or bad. A brilliant sacrifice would produce the same spectral fingerprint.

F3 is a reliable volatility channel. The third symmetric fiber dimension shows significant |ρ| against |ΔEval| in BOTH games:

Game	ρ(\|ΔE_F3\|, \|ΔEval\|)	p
VEYpgB14	+0.272	<0.005
9DrFuzPB	−0.285	<0.005

The sign flips between games but the magnitude holds (~0.28). F3 detects moves that create large evaluation shifts in either direction — it measures structural volatility, not quality. F3 is the weakest fiber dimension (σ₃ = 0.65, 10.5% of symmetric fiber variance), capturing the most fine-grained cross-modal coupling — the subtle interactions most likely to change dramatically on significant moves.

Multi-channel anomaly score (L2_all). The L2 norm of the full channel delta vector beats the scalar ΔS in magnitude: VEYpgB14 |ρ| = 0.225 (vs 0.059), 9DrFuzPB |ρ| = 0.205 (vs 0.013). But the sign flips between games — L2_all is a "big-move detector" (captures, promotions, castles), not a quality detector. Whether big moves correlate positively or negatively with |ΔEval| depends on whether the game is tactically sharp or positionally decided.

Chaos ratio (fiber/irrep balance) tracks game sharpness, not quality.

Game	Chaos ratio	NAG-flagged moves	Character
VEYpgB14 (Ragozin)	1.352	9	Tactical
9DrFuzPB (Zukertort)	0.791	27	Positional

The game with FEWER errors has the HIGHER chaos ratio (more fiber disruption relative to irrep change). This means the chaos ratio measures opening character and game sharpness — sharp games create more fiber disruption per move — not playing quality. A legitimate spectral observable, but not a quality metric.

Summary. The spectral encoding provides three empirically confirmed types of information about chess positions and moves:

Complexity prediction (A₁ energy): ρ = +0.452 vs depth gap, ρ = +0.134 vs eval volatility across 2,165 plies. CONFIRMED.
Structural disruption detection (F3 channel): |ρ| ≈ 0.28 in both games. Detects spectrally significant moves regardless of whether they're good or bad. CONFIRMED.
Game character classification (chaos ratio): distinguishes sharp tactical games from positional games. CONFIRMED but measures sharpness, not quality.

What it CANNOT do: detect specific tactical patterns (pins, forks, overloaded defenders) that require multi-piece spatial conjunctions evaluated through the game tree. These are Level 3 phenomena — properties of the connection form's domain, provably inaccessible from the Level 2 fiber encoding. The Kg4?? null result (zero spectral signature on a 1.69-pawn swing) is the definitive empirical confirmation of the §8b theoretical prediction.

9p. FA Channel Structural Sensitivity Test (Pawn Structure ≠ Pawn Count)¶

File: docs/chess-maths/test_fa_structure.py. Run with --out to write the markdown report.

The FA channel (dims 512–575) is the antisymmetric pawn fiber. Its visible behaviour in trajectory plots — monotone decay as pawns leave the board — raised the question of whether FA carries any pawn-STRUCTURE information at all, or whether it is a glorified pawn-count proxy. An external reviewer asked specifically: can FA distinguish "three connected pawns traded" from "three pawns traded creating a passed pawn"?

Verdict: STRUCTURAL. Six position pairs were tested. Four chess-structure pairs (passed vs blockaded, connected vs isolated, chain vs lateral, race vs head-on) all hold pawn count constant; in every case FA differs by 3× to 13× the pure-count baseline (the count-control pair 1P → 1P+1P, |ΔFA|=0.255). FA is not a count proxy.

Pair (same pawn count)	FA_A	FA_B	\|ΔFA\|	× count-baseline
passed_vs_blockaded (3p)	7.082	3.802	3.280	12.9×
connected_vs_isolated (6p)	11.293	10.065	1.228	4.8×
chain_vs_lateral (6p)	7.633	9.658	2.025	7.9×
race_vs_head_on (2p)	2.041	1.281	0.760	3.0×

Trajectory test confirms. Two trade sequences from the same balanced 4v4 pawn position: one creates a passed pawn (creates_passer), the other does not (no_passer). At matched pawn count = 4, FA = 3.11 (passer) vs 4.91 (no-passer) — a 58% difference at identical material.

Mechanism. ||FA||² = sigᵀ M sig where M = PAWN_ANTI_FIBER · PAWN_ANTI_FIBERᵀ. ||diag(M)|| = 11.56, ||off-diag(M)|| = 12.00 — the off-diagonal mass (pair geometry) carries as much variance as the per-square diagonal. Per-rank diagonal means peak on rank 7 (M[s,s] mean = 2.485) and decay toward both extremes (rank 1 ≈ 0.30, rank 8 ≈ 1.45) — reflecting where forward-pawn flow has the most coupling potential.

Encoder geometry side-finding. A file_mirror sanity pair (a2,b2 vs g2,h2) was expected to give identical FA energies because the directed white-pawn graph is file-uniform. It does not: FA(a2,b2) = 0.543, FA(g2,h2) = 1.072. The kernel K = A_anti · A_antiᵀ IS file-symmetric in the board basis (||K − P_F K P_Fᵀ|| = 0; sigᵀ K sig = 2.75 for both configs). The mismatch comes from the encoder's FA = Σ_pawns sign · PAWN_ANTI_FIBER[s, :] — indexing rows of an eigenbasis matrix by board-square index without first rotating the signal. This conflates board-basis address with eigenbasis output, producing an FA that is not D4-equivariant under board permutations. The other channels (irreps via Serre projection; symmetric fiber via adj_row @ sig; FD via sig[s] · DIAG_DEV[t]) compute entirely in board basis and don't have this property.

This does not invalidate the structural sensitivity above — those pairs differ in ways that any reasonable encoding would register — but FA carries an extra basis-dependent signal that downstream consumers should be aware of. A geometrically-clean alternative would be FA = (EVECSᵀ A_anti EVECS) · (EVECSᵀ sig_P), i.e., rotate the signal into eigenbasis before applying the operator. Whether to "fix" this or treat it as a feature is a design call: the current form makes FA sensitive to absolute board position (kingside vs queenside attack distinction), which has chess meaning.

Regression status. The six pairs and two trade sequences are now codified in test_fa_structure.py and serve as regression tests for any future FA channel changes.

9q. Chaos Ratio: Length-Driven or Genuine? (and a Naming Trap)¶

Files: docs/chess-maths/analyze_chaos_length.py (script), docs/chess-maths/results/chaos_length_analysis_2026-04-15.md (frozen report).

The metric, defined precisely (chess_spectral/corpus.py:201-207):

L2_fiber[t] = sqrt(||FA||²[t] + ||FD||²[t])
L2_irrep[t] = sqrt(sum_{c ∈ {A1,A2,B1,B2,E,F1,F2,F3}} ||c||²[t])
chaos_ratio = mean_t(L2_fiber) / mean_t(L2_irrep)        ← mean-of-means

Naming trap. The dashboard's "Fiber Topology" view charts F1+F2+F3, but those channels are part of chaos_ratio's irrep denominator. chaos_ratio is the antisymmetric-pawn-breaking ratio (FA+FD vs everything else), not the orbit-mixing ratio. Two different "fibers" with the same name. The dashboard's chart and the CSV column are answering different questions.

Length confound test (N=26 games, 3 sweeps). Spearman ρ between game length and each chaos-ratio variant:

Variant	ρ	p
`cr_csv` (mean-of-means, the published metric)	+0.252	0.213
mean of per-ply ratio	+0.153	0.456
median of per-ply ratio	+0.449	0.022
max of per-ply ratio	+0.266	0.188
90^th percentile	+0.167	0.415
`cr_csv / sqrt(plies)`	+0.088	0.669

The published chaos_ratio is NOT length-driven at α=0.05. The only metric that is significantly length-correlated is the median per-ply ratio — which we don't publish. Sqrt-normalising kills even the residual association (ρ→0.09).

Game 7 deep dive (the original outlier, 163 plies, csv cr=15.65). The ratio is uniformly elevated, not spike-driven: - Median per-ply ratio: 25.83 - Plies above 3×median: 1 of 163 (0.6%) - Opening (plies 0-20): per-ply ratio < 0.5 - Middlegame plateau (plies 25-100): sustained 10-16 - Endgame zone (plies 108-145): sustained ~40 with isolated peak of 83 at ply 58

So Game 7's high cr_csv is not a length artefact and not a single-move spike. It reflects a sustained middle/endgame regime where the antisymmetric pawn fiber carries a large fraction of total signal — consistent with the §9p finding that FA encodes structural pawn information. A long game with persistent pawn-structural tension will accumulate more such ply-mass, but the ratio is not mechanically inflated by ply count.

Footnote on the new corpus. Across all 26 games, the per-ply max outlier is fishtest Game 4 (max=146 at ply 119, csv cr=4.90), not Game 7. Game 7's csv cr leads because its ratio is high for many plies, not because of one extreme ply. This is a useful distinction the published metric captures correctly.

Recommendation. Keep chaos_ratio as the published metric. The mean-of-means form is robust to length and to per-ply spikes; alternative formulations either correlate with length (median) or are dominated by single-ply outliers (max). The dashboard subtitle and tooltips should be updated to note that the chart-labelled "Fiber" and the metric-labelled "fiber" are different sets of channels (or one of them should be renamed).

9r. The Polarization Reframing: Six Pieces as Six Orientational States¶

The prior §9 subsections established the spectral structure piece by piece: D4 irreps (§9g), fiber decomposition (§9h), pawn antisymmetry (§9m), rank-5 completeness (§9n). This subsection offers an interpretive overlay that asks a different question: why does the structure cohere the way it does? The answer proposed here is that the six piece types are not six unrelated species but six orientational polarization states of a single lattice excitation, parameterized by three physical labels — angle θ, range r, and chirality c.

No numbers change. Every correlation, every fiber rank, every DCT orthogonality reported in prior sections stands byte-identical. What changes is the story that threads them together.

The lattice's propagation directions¶

On an 8-connected lattice, the D4 orbit of unit displacements generates exactly 8 propagation directions:

Class	Displacements	Count	Canonical symmetry
Axial (±x, ±y)	(1,0), (−1,0), (0,1), (0,−1)	4	B₁ / B₂ of D4
Diagonal (±x±y)	(1,1), (1,−1), (−1,1), (−1,−1)	4	E-irrep pair of D4

A piece's movement pattern is a selection of which of these 8 directions it couples to, at what range, with what chirality.

The three parameters (θ, r, c)¶

Parameter	Meaning	Values
θ (angle)	Direction class the piece's movement lives on	{axial, diagonal, axial+diagonal, knight-offset} — 3 primary classes + 1 exotic
r (range)	Lattice steps per move	{1, ∞} — short range (one step) vs long range (slide)
c (chirality)	Whether the piece obeys Z₂ (color-flip / up-down) symmetry	{+, −, 0} — symmetric, antisymmetric, or n/a

This is a compact physical description: three labels specifying how a lattice excitation propagates.

The six polarization states¶

Piece	θ (direction)	r (range)	c (chirality)	Notes
King	axial + diagonal	1	+	All 8 directions, one step, color-symmetric
Queen	axial + diagonal	∞	+	All 8 directions, sliding
Rook	axial only	∞	+	4 directions, sliding
Bishop	diagonal only	∞	+	4 directions, sliding (color-bound)
Knight	knight-offset	(jump)	+	Exotic — (±1,±2)/(±2,±1); DCT-orthogonal to axial/diagonal
Pawn	axial forward	1 (+diagonal capture)	−	Z₂-breaking: direction depends on color

The king and queen share the same θ (all 8 directions); they differ only in r. The bishop and rook share r (both sliders) but differ in θ (diagonal vs axial). The knight occupies its own θ class — and this is exactly why §9h found it DCT-orthogonal to every other piece. The pawn carries the chirality c = −; it is the unique Z₂-breaking state, exactly as §9m measured (||A_anti||/||A_sym|| = 1.000, pawn alone).

Evidence that prior sections already established¶

Every part of this reframing is a reinterpretation of a result already in the notebook:

Queen = Bishop ⊕ Rook (§9h, §9n): the queen shares θ = axial+diagonal, which is the direct sum of rook's θ (axial) and bishop's θ (diagonal). The spectral cosine table (§3) shows Queen–Bishop = 0.69 and Queen–Rook = 0.72; Bishop–Rook = 0.00. The queen is the superposition.
Knight DCT orthogonality (§3, §9h): the knight's θ class (knight-offset) is disjoint from {axial, diagonal} — it is the only piece whose displacement is not a lattice-axis projection. Its exact DCT orthogonality to every other piece is exactly the statement that knight-offset is its own polarization axis.
Bishop–Queen fiber cosine (§9h): the bishop's θ is a proper subset of the queen's θ, so the queen's fiber contains the bishop's. Non-zero cosine with partial overlap is the expected signature.
Pawn antisymmetry / Z₂ chirality (§9m, §9h): the pawn is the only piece type whose rule depends on the color of the mover (white pushes up, black pushes down). In (θ, r, c) this is chirality c = −. The measurement ||A_anti||/||A_sym|| = 1.000 for pawns and 0.000 for every other piece is the direct spectral signature of the chirality label.
Pawn as spectral composite (Prior Art #17): the pawn's measured king-forward + bishop-diagonal composition (cosine = 0.52) is predicted by (θ_push = axial forward, r_push = 1) superposed with (θ_capture = diagonal forward, r_capture = 1). The pawn is a chirality-flipped king restricted to the forward axial direction plus a short-range bishop on the forward diagonal.

Fiber rank from parameter count¶

Polarization label	Degrees of freedom
Angle θ (3 independent direction classes: axial, diagonal, knight-offset)	3
Chirality c (single Z₂ bit, realized by pawn)	1
Range r (one degree: short vs long)	1
Total	5

This is the rank-5 fiber of §9n, arrived at from a different direction. §9n derived it as (symmetric off-diagonal rank 3) + (antisymmetric off-diagonal rank 1) + (diagonal deviation rank 1). The polarization reframing gives the same 5 from (3 angle + 1 chirality + 1 range). Two independent derivations landing on the same integer is unlikely by coincidence; it is the kind of agreement that suggests the decomposition is structural, not incidental.

What this changes and what it doesn't¶

What it doesn't change. Every correlation, every p-value, every fiber rank, every DCT cosine reported in §3–§9q is unchanged. §9o's honest negatives (Kg4?? zero spectral signature, Spearman(ΔS, ΔEval) ≈ 0) still hold. The Level-2/Level-3 boundary (§8b) still bounds what the model can see. Chaos ratio still measures sharpness, not quality.

What it changes. The reframing offers a single parameter space (θ, r, c) that predicts which piece-shaped excitations are well-formed and which are not. It turns the "six species" taxonomy into a "one excitation, six orientations" description — closer in spirit to how physics describes polarization states of a photon or spin orientations of an electron. It also makes the framework's extensibility concrete: any new piece type is specified by a triple (θ, r, c), and its spectral signature is predicted before it is measured.

Extensibility test — the (3, 1) L-piece¶

Consider a hypothetical piece defined by displacement (±3, ±1) — a "long knight" with θ = knight-offset-like and r = 3-ish. The polarization framework predicts:

The piece inhabits a θ class related to but distinct from the standard knight (different displacement magnitude, same offset-type topology).
Its spectral signature should be DCT-orthogonal to axial/diagonal pieces (same logic as the knight — it doesn't project onto lattice axes).
It should not be DCT-orthogonal to the standard knight — both live in "offset" θ space, just at different radii.
Chirality c = + (no color-dependent direction).
No new fiber rank contribution expected: angle (already knight-offset-like), range (already covered), chirality (already covered) — so rank stays at 5.

This is a falsifiable prediction. Should the framework be extended to fairy pieces, the (3, 1) L-piece is the first probe.

Othello connection¶

Othello (§9j) reduces the polarization framework to its minimum: a single θ class (the 8 flip directions), r = ∞ (flips propagate until a boundary), and c = 0 (no chirality — the game is perfectly color-symmetric, so the Z₂-breaking label is absent). The rank-5 fiber collapses to rank-2: one angle-class + one range. This is what makes Othello a clean test domain — it is the polarization framework with the chirality dimension removed, so the chirality-related findings (pawn antisymmetry) have no analog to confound the signal. If the framework is structurally correct, it should predict Othello's spectral content from (θ, r) alone.

Literature grounding (§1b.3, §1b.5). The (θ, r, c) parameterization rests on established lattice physics: the range parameter r maps to the lattice propagator mass-range relation G® ~ exp(−mr)/√r (Dybalski et al. 2023), where massless excitations (r = ∞) have gapless propagators and massive excitations (r = 1) are maximally gapped; the angle parameter θ maps to the D₄ orbit of propagation directions, with DCT eigenvectors as the dihedral irrep basis (Püschel & Moura 2003); the chirality parameter c maps to the Hatano-Nelson asymmetry ratio t_L/t_R (§1b.1), with c = − corresponding to t_L = 0. Martin's result that the lattice Green's function is anisotropic (direction-dependent) grounds the separability of θ and r as independent degrees of freedom. The knight's incommensurate phase angle (Niven 1956) explains its structural isolation from both axial and diagonal θ classes.

10. Phase-Space Othello¶

Status (updated 2026-04-22). Phase 0–2 of the verification pass is now computationally grounded — see §10.12 and ../othello-maths/. The structural predictions of §10.4 (8-ray D₄ decomposition, B₁↔B₂ rook/bishop signature) are CONFIRMED; the fiber-rank trichotomy in §10.4 was partially revised (rank-2 orbit and rank-8 directed operators both emerge cleanly; rank-6 is an irrep multiplicity, not an operator rank); the Hansen-Ghrist sheaf instantiation of §10.7 has a working minimal implementation with a testable spectral observable. The WTHOR empirical predictions of §10.10 remain open pending external data. This section should be read as the motivating survey; §10.12 and the Othello notebook carry the numerics.

Hybrid-framework thesis. A survey of nine candidate mathematical frameworks (lattice fermion model, Ising / Blume-Capel / Potts, driven nonequilibrium lattice systems, non-local CA, compass / eight-vertex / Kitaev, voter / Glauber / Wolff, information thermodynamics, sheaf Laplacians, combinatorial game theory) found that no single existing framework is a clean fit. Othello naturally lives as a dynamic cellular sheaf whose stalks are Blume-Capel {−1, 0, +1} fibers per cell, whose restriction maps update per move, whose symmetry is exact D₄×Z₂ with the 8-ray decomposition 2A₁⊕B₁⊕B₂⊕2E, whose update rule is a two-player bounded-change non-local CA with ray-gated flip along subsystem-symmetry-like product operators, and whose information content per move is a Sagawa-Ueda feedback step under a Boltzmann-policy embedding. The global arrow of time is a monotone disc count — a genuinely different breaking of reciprocity from chess's local Hatano-Nelson pawn sector.

10.1. Same board, fundamentally different physics¶

Othello is played on the same 8×8 grid as chess, so the board Laplacian eigenbasis, the D₄ symmetry group, and the 8-generator spectral lattice (§9b) all transfer identically. Everything above the board changes:

Single piece type, but non-zero fiber. There are no per-piece Laplacians and no spectral quantum numbers — Level 1 (§8b) collapses. The fiber bundle is still non-zero because the fiber measures the gap between rule structure and spatial structure, not the number of species. In chess, cross-species analysis is how we found the fiber; it is not what the fiber is. Any game whose rules have structure beyond the grid itself produces fiber content.

Othello's rules operate along 8 ray directions {N, NE, E, SE, S, SW, W, NW}. Each ray defines an influence adjacency — which squares affect which through the flanking mechanic. The E/W rays are path graphs along ranks (subsets of the chess rook's adjacency); the diagonal rays are path graphs along diagonals (subsets of the chess bishop's adjacency). Each ray Laplacian, projected onto the board eigenbasis, carries off-diagonal content because a ray along the diagonal couples eigenmodes differently than a ray along the rank. The 8 ray directions span a fiber subspace whose rank reveals the number of independent types of directional influence (§10.4 derives this rank as 6 from the irrep decomposition, or 2 from the orbit count).

Dynamic fiber. Chess has a static fiber (piece Laplacians are fixed) with a dynamic signal (occupation changes). Othello has a dynamic fiber — the flanking rule means the influence of a placed disc extends along a ray only as far as the first friendly disc. The effective adjacency changes with every move. This is more complex than chess, not simpler: the fiber at move 10 is a different geometric object than the fiber at move 40. The natural formal home for this is a cellular sheaf with dynamic restriction maps (§10.7).
No movement. Discs are placed, never moved. No movement graph in the chess sense; no connection form. Legal moves depend on the global board state (bracketing lines of opponent discs), not on piece-type topology. The directional ray structure is a movement-like constraint on influence propagation, and that is the source of the fiber content.
Spin-flip instead of annihilation. Chess captures remove pieces (annihilation operator). Othello flips opponent discs to your color — the disc stays, its sign changes. The board signal is an Ising-like spin field s_i ∈ {−1, 0, +1}. A single move triggers a wave of sign changes along grid rays whose spectral content the GFT can decompose.
State-dependent legality. Chess has static operators (piece Laplacians define legal moves regardless of board state). Othello has dynamic operators — legality depends entirely on the current disc configuration. Chess has a fixed operator with a dynamic signal; Othello has a dynamic operator that changes with every move.
Exact Z₂ symmetry. In chess, Z₂ (color/spin inversion) is approximate because pawns are directional (§9m, §1b.1). In Othello, Z₂ is exact — the rules are perfectly color-symmetric. Swapping all disc colors and swapping side-to-move gives a strategically equivalent position. The full symmetry group is D₄×Z₂ (16 elements), and the irrep decomposition under this full group is the natural framework from the start.

The decisive advantage: perfect ground truth. Takizawa (arXiv:2310.19387, 2023) weakly solved Othello: perfect play from both sides results in a draw. The complete game solution (Zenodo 10.5281/zenodo.10030906) provides exact game-theoretic values for every reachable position. This eliminates the benchmark problem that limited the chess results — in Othello, the evaluation is the answer. The WTHOR tournament database (61,549 games, French Othello Federation, 2001–2020) provides the empirical substrate for the falsifiable predictions in §10.10.

10.2. Transfer and failure modes of the chess framework¶

Against the chess spectral framework documented in §§2–9r, Othello transfers on its foundations but fails on the upper structure.

What transfers.

Board Laplacian eigenbasis (§2). The 8×8 grid Laplacian's eigenvectors are the 2D DCT basis (exact, machine-epsilon verified). Identical for both games.
D₄ symmetry and irrep decomposition (§9a). The eight-element point group of the square is the same; the DCT basis is the irrep basis of D₄ (Püschel & Moura 2003; §1b.3). Othello's Z₂ is stronger (exact vs approximate), promoting the framework to exact D₄×Z₂ throughout.
8-generator spectral lattice (§9b). The coprime basis for spatial HDC encoding is independent of piece content and transfers directly.
Grid-only findings. Anything derived from P₈□P₈ structure alone (mean-degree statistics, spatial frequencies, low-frequency modes) survives.

What fails.

Chess element	Othello analog	Verdict
Piece species (rank-5 fiber, 5-tuple quantum numbers)	Single particle type — rank-5 has no referent	FAILS
Hopping Hamiltonian (piece movement)	No movement at all	FAILS
Pawn → Hatano-Nelson local T-violator (§1b.1)	No local T-violator; T-breaking is global monotone disc count	FAILS (global ≠ local)
Nearest-neighbor piece adjacency	Flanking is state-dependent and length ≤ 7 along rays	FAILS
Static fiber geometry	Fiber restriction maps evolve every move	FAILS
KPZ / ASEP / directed percolation (driven nonequilibrium)	No interface, no particle motion, no critical absorbing parameter	FAILS
Q-state Potts (q=3)	Wrong symmetry — S₃ permutes all three colors equally; empty is distinct	FAILS
Eight-vertex model	The "8" is vertex parity configurations, not ray directions — numerological coincidence	FAILS

Near-misses worth naming. Five frameworks fail cleanly as mathematical fits but are close enough structurally that they frame what an Othello-native framework must handle:

Voter model (Holley-Liggett 1975; Liggett 1985). Continuous-time single-site updates with bichromatic spins and absorbing all-0 / all-1 states match Othello's monochromatic absorbing terminus. Voter-copy-neighbor ≠ Othello-flank-flip, but the absorbing-state structure transfers.
Glauber dynamics (Glauber 1963). Single-site flips with detailed balance toward a Boltzmann stationary state. Non-ergodic in Othello (monotone filling), no native Hamiltonian, no temperature — but the flip-rate formalism is the starting point for the Boltzmann-policy embedding in §10.8.
Sandpile / avalanche CA (Bak-Tang-Wiesenfeld 1987; Dhar 1990). Flanking cascades are avalanche-like: one placement flips multiple discs along multiple rays. If the per-move flip-count distribution is a power law (§10.10 test 1), the scaling exponent could align with SOC. Critical differences: sandpile toppling is abelian / order-independent; Othello is violently order-dependent, and flips are chosen adversarially.
Directed percolation (Hinrichsen 2000; Janssen 1981). Othello terminal states are absorbing — once neither player has a legal move, the game ends. But DP requires a fluctuating-to-absorbing transition with a continuous control parameter; Othello's turnover to absorbing is deterministic, not critical. Activity scaling near end-game is still testable empirically.
Random sequential adsorption (Evans 1993). The closest native statistical-mechanics match to Othello placement structure — particles placed irreversibly, never removed; jamming state ≈ terminal position. RSA lacks the flanking-and-flipping dynamic, and Othello placements are adversarial rather than uniform-random. But the jamming limit is a real structural analog.

10.3. Site space: Blume-Capel spin-1 with D as empty-density control¶

The three-state per-cell space {−1 = white, 0 = empty, +1 = black} with exact Z₂ s → −s symmetry is the Blume-Capel spin-1 model (Blume 1966 PR 141, 517; Capel 1966 Physica 32, 966):

H = −J Σ_⟨ij⟩ sᵢ sⱼ + D Σᵢ sᵢ²,    sᵢ ∈ {−1, 0, +1}.

The crystal-field parameter D controls the density of empty sites: large D penalizes occupation (favors sᵢ = 0), small D allows occupation. On the 2D square lattice, the tricritical point sits at Δt ≈ 1.966, T_t ≈ 0.608 (arXiv:2401.02720). Tricritical exponents: y_t = 1.804(5), y_g = 0.80(1), y_h = 1.925(3) (arXiv:1504.02565) — distinct from pure Ising (y_t = 1, y_h = 15/8).

Othello's monotone filling as a trajectory in (T_eff, D_eff). Blume-Emery-Griffiths (PRA 4, 1071, 1971) established the exact structural analog with ³He–⁴He mixtures: the quadrupole moment 1 − ⟨sᵢ²⟩ ↔ ³He concentration. For Othello, the quadrupole moment Q = ρ_black + ρ_white = 1 − ρ_empty is the secondary order parameter, and disc magnetization M = ρ_black − ρ_white is the primary one. A game traces a path from high-D (60/64 empty at move 1) toward low-D (0 empty at terminal), monotonically. Whether this trajectory crosses the tricritical point at or near half-filling is an empirical question against WTHOR (§10.10 test 4).

Cluster representation. Bouabci-Carneiro (J. Stat. Phys. 100, 805, 2000) gave an FK-like random-cluster representation for Blume-Capel that generalizes Fortuin-Kasteleyn 1972 to the 3-state case. This is the correct equilibrium-statmech substrate for the Wolff-cluster analogy in §10.6.

What this buys. The site space and its Z₂ symmetry are now mathematically MATHEMATICAL (exact formalism match), not analogical. The dynamics remain mismatched — Blume-Capel is equilibrium thermal, Othello is deterministic adversarial — but the fiber content is correctly 3-valued at each cell, empirically validated by the Othello-GPT linear-probe results in §10.9.

10.4. Symmetry: exact D₄×Z₂ and the 8-ray decomposition 2A₁⊕B₁⊕B₂⊕2E¶

D₄ has 5 conjugacy classes {E, 2C₄, C₂, 2C′₂, 2C″₂} and 5 irreps A₁, A₂, B₁, B₂, E of dimensions 1, 1, 1, 1, 2 (Tinkham 1964; Dresselhaus-Dresselhaus-Jorio 2008). The standard character table:

D₄	E	2C₄	C₂	2C′₂	2C″₂	carried by
A₁	1	1	1	1	1	x²+y², z²
A₂	1	1	1	−1	−1	R_z
B₁	1	−1	1	1	−1	x²−y²
B₂	1	−1	1	−1	1	xy
E	2	0	−2	0	0	(x, y)

D₄ decomposition of the 8 ray directions (new derivation). The 8 rays {N, NE, E, SE, S, SW, W, NW} split into two D₄ orbits of size 4: orthogonal {N, E, S, W}, diagonal {NE, SE, SW, NW}.

Γ_ortho: character χ = (4, 0, 0, 2, 0). Reduction: Γ_ortho = A₁ ⊕ B₁ ⊕ E. Basis: A₁ = (N+E+S+W)/2; B₁ = ((N+S) − (E+W))/2 transforms as x²−y²; E = {(N−S)/√2, (E−W)/√2}.
Γ_diag: character χ = (4, 0, 0, 0, 2). Reduction: Γ_diag = A₁ ⊕ B₂ ⊕ E. Basis: A₁ = (NE+SE+SW+NW)/2; B₂ = ((NE+SW) − (SE+NW))/2 transforms as xy; E = {(NE−SW)/√2, (SE−NW)/√2}.
Combined 8-ray representation: Γ_8 = 2·A₁ ⊕ B₁ ⊕ B₂ ⊕ 2·E (dimension check: 2+1+1+4 = 8 ✓).

B₁↔B₂ is the rook/bishop signature, derived from rays alone. In the chess notebook, the orthogonal-sliding vs diagonal-sliding distinction appears through piece-species analysis (rook adjacency vs bishop adjacency). Here, the same distinction drops out of the ray-set character analysis with no reference to pieces. B₁ carries the orthogonal-orbit anisotropic mode; B₂ carries the diagonal-orbit anisotropic mode. Interchanging orthogonal and diagonal rays — a group-theoretic B₁↔B₂ swap — is the exact signature of the rook/bishop distinction. To this survey's knowledge, this decomposition has not been previously published for Othello. CONFIRMED 2026-04-22 by character-projection on the 8-dim ray-indicator space: measured multiplicities exactly match {A₁: 2, A₂: 0, B₁: 1, B₂: 1, E: 2}; the B₁ and B₂ modes lifted to 64×64 operators land Frobenius-orthogonal (inner product exactly 0). See othello-maths/research/consolidated_tests.py (H2, H3).

The Frobenius-orthogonality is a grid-topology theorem, not an empirical coincidence. On the 8×8 grid, the orthogonal-neighbor edge set E_ortho (112 edges, displacements (±1, 0) and (0, ±1)) and the diagonal-neighbor edge set E_diag (98 edges, displacements (±1, ±1)) are disjoint: no cell pair is simultaneously an orthogonal and diagonal neighbor. Each undirected orthogonal ray Laplacian has matrix support ⊆ E_ortho; each diagonal ray Laplacian has support ⊆ E_diag. Any real linear combination in one orbit therefore has Frobenius inner product identically zero with any combination in the other orbit, independent of the coefficients. The B₁ and B₂ spectral channels are not merely distinct — they live on disjoint subsets of matrix position-space, so the rook/bishop decomposition is a direct sum of operator subspaces, not an orthogonal splitting of a shared space. The same theorem applies to chess: the rook adjacency and bishop adjacency have disjoint edge supports, which is why rook+bishop=queen holds exactly at the adjacency-matrix level (§3, §7b). Othello makes the ray-level structure explicit; chess inherits it via piece species.

Exact Z₂ extension. With the exact color-inversion Z₂ (which is only approximate in chess — pawn-broken, §1b.1), the full symmetry is D₄×Z₂ with 16 elements and 10 irreps. Spin-squared quantities (quadrupole Q = 1 − ρ_empty) are Z₂-invariant; spin-signed quantities (magnetization M = ρ_b − ρ_w) carry the non-trivial Z₂ character. The natural channel split in §9h' transfers: Z₂-invariant channels predict complexity, Z₂-breaking channels predict advantage.

Fiber rank prediction. The 8-ray irrep decomposition gives three natural bundle ranks: rank-2 (orbit count: ortho vs diag), rank-6 (irrep count: 2A₁+B₁+B₂+2E), rank-8 (individual directions, fully reducible). None equals the chess rank-5, confirming the §10.2 "rank-5 has no referent in Othello" verdict. The chess notebook's polarization reframing (§9r) reduces to (θ-class, r = ∞, c = 0) for Othello — chirality absent because Z₂ is exact.

Empirical readout (2026-04-22, H6). SVD of four candidate stackings of the 8 ray Laplacians:

Stacking	Effective rank
Undirected ray Laplacians (pairs coincide: L_N = L_S etc.)	4
Directed ray Laplacians (non-symmetric, all 8 distinct)	8
Orbit Laplacians (L_ortho, L_diag)	2
D₄×Z₂-projected per-site degree signatures	8

Rank-2 (orbit) and rank-8 (directed / degree-projected) emerge cleanly. Rank-4 is the natural undirected reading — a consequence of L_d = L_{-d} for undirected graph Laplacians. Rank-6 does not appear as an operator rank in any of the four constructions — the 2A₁+B₁+B₂+2E count is an irrep multiplicity, not a stacked-matrix rank. This is a partial revision of the §10.4 "three candidates" framing: the production encoder should default to rank-2 (aligning with the §9r polarization collapse) with rank-8 as an ablation; rank-6 is not a fiber structure but a decomposition of the D₄×Z₂ channel layout.

10.5. Ray structure: compass models and subsystem symmetries¶

90° compass model. The closest published structural match to Othello's ray-gated dynamics is the 90° compass model (Kugel-Khomskii 1973/1982; Nussinov & van den Brink, Rev. Mod. Phys. 87, 1, 2015; Dorier-Becca-Mila, Phys. Rev. B 72, 024448, 2005):

H = −J_x Σ_⟨ij⟩_H τᵢˣ τⱼˣ − J_y Σ_⟨ij⟩_V τᵢʸ τⱼʸ,

with direction-dependent couplings. Nussinov-Ortiz (Phys. Rev. B 71, 195120, 2005) established that compass models carry d=1 subsystem symmetries: product operators P_j = Π_i σᵢⱼʸ along rows and Q_i = Π_j σᵢⱼˣ along columns are exact symmetries. These lie midway between global and local gauge symmetries and cause effective dimensional reduction.

Direct analog. Othello's flanking evaluates product operators along rays. Subsystem symmetries along rows/columns map to ray-flank counts; the B₁↔B₂ swap of §10.4 is the group-theoretic promotion of the compass model's orthogonal-vs-diagonal bond-type split to the 8-ray case. Nasu et al. (arXiv:1203.3683, 2012) independently constructed an orbital compass on the checkerboard lattice with different components along orthogonal vs diagonal NN bonds — the closest published construction to Othello's rook/bishop ray split.

Bacon-Shor / compass codes. Li-Miller-Newman-Wu-Brown (Phys. Rev. X 9, 021041, 2019) present 2D compass codes whose product operators span entire rows and columns (X-stabilizers along rows, Z-stabilizers along columns). This is the cleanest existing physics analog of Othello's ray flank operators at the Hamiltonian level. Limitations: 2 orbits (rows/cols), no diagonals, no same-color termination.

Not in this bucket. Kitaev models (Kitaev 2006) have 3–4 bond classes, not 8 rays — ANALOGICAL. The eight-vertex model (Baxter 1972; Lieb 1967) uses "8" for vertex-parity configurations, not ray directions — numerological coincidence, not a structural match.

10.6. Non-local update: Wolff flanking, bounded-change CA, two-player CA games¶

Wolff cluster as closest stat-mech analog. The Wolff single-cluster flip (Wolff, Phys. Rev. Lett. 62, 361, 1989) — seed spin → cluster of like neighbors via the Fortuin-Kasteleyn random-cluster construction (Fortuin-Kasteleyn 1972) → flip whole cluster — is the closest equilibrium-statmech analog to Othello flanking. Seed placement → cluster of flanked opponent discs → flip. The differences are concrete: Wolff builds clusters stochastically with p_add = 1 − e^{−2βJ}, while Othello flanking is deterministic and geometrically ray-constrained (only contiguous chains of opposite color terminated by same color, along one of 8 directions). Bouabci-Carneiro (2000) extends the FK representation to Blume-Capel, which is the right 3-state lift.

Bounded-change / non-local CA. Othello is not a freezing CA — cells can be flipped many times (no monotone state order) — but on an 8×8 board each cell flips at most ~60 times, so Othello is a bounded-change CA in the sense of Ollinger-Theyssier (arXiv:1908.06751, 2019). Classical Wolfram/Langton CA fail at four canonical assumptions for Othello: deterministic, synchronous, translation-invariant, local. The range-unbounded-along-rays structure is best matched by Sipper's non-local cellular automata (Santa Fe Institute working paper): "non-local connections provide a handy way for information transmission, it is much easier for a non-local cellular automaton to be a universal computer than for a local one." Non-local CA typically use random/small-world wiring rather than 8 rays from an update site — still ANALOGICAL.

Two-player CA games — the framework-level wrapper. Fraenkel (More Games of No Chance, MSRI, 2000) developed two-player CA games in a general sense — a move consists of selecting a vertex and firing it, complementing its weight and that of a selected neighborhood. Othello is a two-player CA game in Fraenkel's sense, though its ray-flanking rule falls outside the specific digraph-additive family he studied. Cook-Larsson-Neary (arXiv:1506.01431, 2015; Natural Computing 16, 397, 2017) extend to blocking queen games. Classification: MATHEMATICAL at the framework level, not yet instantiated for Othello's ray structure.

Bootstrap percolation — monotone near-miss. Bootstrap percolation (Chalupa-Leath-Reich 1979; Aizenman-Lebowitz 1988; Holroyd 2003) is the canonical threshold-based monotone CA: a cell activates when ≥r active neighbors are present. It is the closest canonical CA with "cell activates on neighborhood pattern," but it is monotone where Othello is not (flips change sign, they don't freeze). ANALOGICAL only — the monotone structure in Othello lives in the disc count, not the site state.

Complexity baseline. Iwata-Kasai (Theor. Comput. Sci. 123, 329, 1994) proved that n×n Othello is PSPACE-complete. This is a game-complexity result, not a CA-universality result. Whether Othello's flanking rule, treated as an abstract CA, is Turing-universal is an open question (no paper addresses it).

10.7. State-dependent adjacency: sheaf Laplacians with dynamic restriction maps¶

Hansen & Ghrist (J. Appl. Comput. Topol. 3, 315, 2019; arXiv:1808.01513) developed spectral sheaf theory on regular cell complexes. A cellular sheaf F on X assigns a vector space F(σ) to each cell σ and, for every incidence σ ⊴ τ, a linear restriction map F_{σ⊴τ}: F(σ) → F(τ) satisfying F_{σ⊴σ} = id and F_{ρ⊴τ} = F_{σ⊴τ} ∘ F_{ρ⊴σ}. The degree-0 sheaf Laplacian on C⁰(X; F) is

(L_F x)_v = Σ_{v⊴e} F_{v⊴e}^⊤ (F_{v⊴e} x_v − F_{w⊴e} x_w),

reducing to the ordinary graph Laplacian for the constant sheaf ℝ with identity restrictions. Harmonic cochains = global sections = H⁰(X; F).

Direct Othello instantiation.

Vertex stalks: 3-valued Blume-Capel fiber F(v) ≅ ℝ³ (or the 3-state simplex) at each of the 64 cells, carrying sᵥ ∈ {−1, 0, +1}.
Edge stalks: the ray-flank incidence structure on each of the 8 ray directions through each cell. Edges are not static nearest-neighbor pairs but dynamic ray-segments bounded by same-color terminators.
Restriction maps F_{σ⊴τ}: evolve with every move. When a disc is placed and a line is flanked, the restriction maps along the affected ray segments update to reflect the new flank structure. The dynamic fiber geometry of §10.1 is exactly this family of evolving restriction maps.
Sheaf Laplacian spectrum: tracks through the game — opening has sparse restriction maps (few non-empty cells), middlegame has complex restriction maps (many contested rays), endgame has simplified maps (stable regions).

Hansen's thesis (U. Penn 2020) and the Neural Sheaf Diffusion work (Bodnar et al., NeurIPS 2022, arXiv:2202.04579) develop the computational tooling. Singer-Wu (Comm. Pure Appl. Math. 65, 1067, 2012) provides the connection-Laplacian variant via vector diffusion maps. Riess-Ghrist et al. (arXiv:2504.02049, 2510.00270, 2025) establish that partially asynchronous nonlinear sheaf diffusion converges linearly under bounded delays — relevant for the move-by-move update structure.

Novel application status. No paper applies sheaf Laplacians, connection Laplacians, or temporal graph signal processing to any board game. Applying Hansen-Ghrist to Othello is an open research direction — this section is the MATHEMATICAL framework-level match; the instantiation is novel. Minimal instantiation CONFIRMED 2026-04-22 — see othello-maths/research/dynamic_sheaf.py. A 60-move random-play trajectory yielded λ₂ ranging [0.22, 0.93] with Spearman(legal_moves, λ₂) = +0.765, p = 1.1e-12. The sheaf spectral gap tracks strategic freedom, not disc density (Spearman(ρ_disc, λ₂) = −0.008, null). The observation is a snapshot correlation — the logo-maths §L7b retraction template explicitly warns that snapshot fibers do not necessarily extrapolate forward in time, and the Othello sheaf's predictive power is an open question for the sequel.

10.8. Information thermodynamics: Sagawa-Ueda under a Boltzmann-policy embedding¶

Rigorous information-thermodynamic statements about Othello require an explicit stochastic embedding. The survey found six preconditions to make Sagawa-Ueda rigorous:

Stochasticize: replace the deterministic move by a softmax policy π(m | s) ∝ e^{−β · cost(m, s)}, defining effective T = 1/β.
Explicit physical memory: each square carries a bit with physical substrate state (for Landauer's k_B T ln 2 per erase to be literal).
Heat-bath coupling at T.
Bipartite / N-partite embedding (Horowitz-Esposito, Phys. Rev. X 4, 031015, 2014): joint (board, player-memory) Markov process with decomposable information-flow rates dS_X/dt − İ_X ≥ 0.
Work reservoir: define a conjugate variable (score or free-energy analog).
Fluctuation-theorem-compatible ensembles: initial Boltzmann distribution + time-reversed protocol.

Under (1)–(6), each move satisfies a Sagawa-Ueda-type identity ⟨e^{β(ΔF − W) − I}⟩ = 1 (Sagawa-Ueda, Phys. Rev. Lett. 104, 090602, 2010; Phys. Rev. E 85, 021104, 2012) with the information-theoretic work bound ⟨W⟩ ≥ ΔF − k_B T · I. Parrondo-Horowitz-Sagawa (Nature Physics 11, 131, 2015) give the generalized second law ΔS_total ≥ −k_B · I. This is mathematical content about the embedding, not about Othello per se.

Without embedding — pure Shannon bookkeeping. Each move extracts I_move = log₂ |M(s)| − log₂ P(chosen | policy) bits of decision information; placement discards H(s_past | s_now) bits of prior-state information. Shannon claims hold rigorously; thermodynamic claims require the embedding above.

Global monotone T-breaking distinguishes Othello from chess. In chess, T-symmetry breaking is local: the pawn is the single T-violating polarization, realizing Hatano-Nelson t_L = 0 exactly (§1b.1). In Othello, there is no local T-violating particle. T-breaking appears only through the global monotone disc count: pieces are placed irreversibly, flips preserve count. This is macroscopic irreversibility, not biased local hopping. The entropy-production bookkeeping is correspondingly global — at the move level, not the per-particle level.

Without embedding, Maxwell-demon-lattice as a named class is SPECULATIVE (not a defined technical term in the literature). The Sagawa-Ueda / Horowitz-Esposito framework is the rigorous home under embedding.

10.9. Empirical grounding: Othello-GPT representation results¶

A decisive empirical signal for the Blume-Capel site fiber comes from the Othello-GPT line of research, which trains transformers on synthetic Othello move sequences and probes the learned internal representations.

Li-Hopkins-Bau-Viégas-Pfister-Wattenberg (ICLR 2023 Oral, arXiv:2210.13382), "Emergent World Representations," established via linear probes and causal intervention that Othello-GPT maintains a linear world model of the board state.
Nanda-Lee-Wattenberg (BlackboxNLP 2023, arXiv:2309.00941) sharpened the claim: the representation is linear in mine/yours/empty coordinates, not black/white/empty. The natural fiber the network learns is 3-valued per cell, keyed to the player-relative state.
Hazineh et al. (2023), replication: github.com/DeanHazineh/Emergent-World-Representations-Othello.
He et al. (arXiv:2402.12201, 2024) extended with sparse autoencoders.
Yuan & Søgaard (ICLR 2025, arXiv:2503.04421), "Revisiting the Othello World Model Hypothesis," extended across GPT-2, T5, BART, Mistral, LLaMA-2, Qwen2.5 with up to 99% probe accuracy.
Singh et al. (arXiv:2511.00059, 2025) gave decision-tree interpretations of Othello-GPT MLP neurons — ~913/2048 layer-5 neurons have R² > 0.7 rule-tree fits.

Implication. The per-cell fiber is empirically 3-valued (mine/yours/empty). This directly validates a Blume-Capel-like spin-1 structure at the representation level, not a piece-species bundle. The chess rank-5 piece-species bundle has no representational referent in Othello, consistent with the §10.2 failure table. Classification: MATHEMATICAL at the level of VSA encodings; ANALOGICAL as a fiber-bundle interpretation.

10.10. Falsifiable predictions against WTHOR¶

No empirical study in the literature has extracted, from the WTHOR database (61,549 tournament games), the spectral or statistical-mechanical observables predicted by the hybrid framework above. These are concrete open empirical tests, each tied to a candidate framework's distinguishing signature:

Flip-count-per-move distribution (power law vs exponential). Distinguishes SOC / directed-percolation-critical scaling (power law) from Blume-Capel tricritical or away-from-critical (exponential tails). If power-law, extract the scaling exponent and compare with sandpile and DP critical exponents.
B₁ vs B₂ spectral populations across game trajectories. Tests the rook/bishop-from-rays prediction of §10.4: ⟨B₁²⟩ vs ⟨B₂²⟩ should be statistically indistinguishable under rules alone, but may differ because corners are diagonal-reachable first from the center and tournament strategy values edge/corner control asymmetrically. Preliminary empirical support (2026-04-22): on 2184 positions from 35 Barcelona EGP 2026 tournament games, ⟨B₂²⟩ / ⟨B₁²⟩ = 1.118 — the diagonal orbit registers ~12% higher than the orthogonal orbit, in the predicted direction. Finite-sample effects at N = 35 games not yet ruled out; WTHOR-scale rerun is the decisive version.
Shannon information per move vs the Sagawa-Ueda bound ⟨W⟩ ≥ ΔF − k_B T · I. Without the Boltzmann-policy embedding, test the pure Shannon bookkeeping: I_move = log₂ |M(s)| − log₂ P(chosen | policy). Under the embedding with inferred β, test the full generalized-Jarzynski identity. The opening_book_freq.csv.bz2 file in the Takizawa reversi-scripts repo provides the empirical P(chosen) dictionary directly — T3 is runnable without the 20 GB figshare download. Status: CONFIRMED as a conditional effect (2026-04-22) — I_move is near-null with A₁⁻ energy globally (ρ = −0.065) but picks up a significant positive correlation on the in-book subset (ρ = +0.213, p = 2 × 10⁻⁸ on N ≈ 676 of 2099 scored plies across 35 Barcelona EGP 2026 games). The in-book / out-of-book conditioning is the structural lever; see §10.13. The generalized-Jarzynski version under the embedding remains open.
Trajectory through (T_eff, D_eff) plane. Map each game position to a point in the Blume-Capel control-parameter plane; test whether the monotone-filling trajectory passes near the tricritical point (Δt ≈ 1.966, T_t ≈ 0.608) at or near half-filling. Joint distribution P(ρ_black, ρ_white, ρ_empty) gives the marginal P(M = ρ_b − ρ_w); Binder cumulant U* ≈ 0.6107 for Ising, different for tricritical.
Cluster-size distribution of flanks. Tests Wolff-critical scaling: power-law cluster sizes at criticality, exponential away. Compare with the Bouabci-Carneiro FK-cluster statistics for Blume-Capel.

Additional tests inherited from §9j.

Does A₁ energy predict depth-gap in Othello, as it does in chess (§9h', ρ = +0.452, p = 0.0005)? Tests universal complexity metric across games. Status: UNDETERMINED (H9) — blocked on Takizawa dataset + Othello engine; surrogate check (A₁⁻ energy variance over 30 random positions, mean 3.64 ± 7.84) confirms the probe is at least non-trivial.
Is the directional fiber rank non-zero, and does it match the §10.4 prediction of 2 (orbit count), 6 (irrep count), or 8 (fully reducible)? Status: PARTIAL / revised (H6) — rank-2 (orbit) and rank-8 (directed) both emerge cleanly from the appropriate stacking; rank-6 does NOT appear as an operator rank (see §10.4 revision). Production encoder recommendation: D = 768 with rank-2 fiber.
Do positions with the same Takizawa-perfect-play optimal move cluster in spectral space? Tests whether the encoding captures strategic structure, not just positional evaluation. Status: UNDETERMINED (E8) — blocked on same external data.

Ground-truth substrate. Takizawa 2023 weak solution (arXiv:2310.19387) + WTHOR 61,549 games + existing AI engines (Edax, Logistello, WZebra, NTest, Saio) eliminate the chess benchmark problem.

Preliminary numbers from the 2026-04-22 verification pass. The structural pieces of the §10.10 prediction set that do NOT require WTHOR data have been probed:

Flip-count distribution (surrogate). Across 20 random-play games (N = 7216 candidate-move flip counts): mean 2.28, std 1.81, max 13. Random play produces an exponential-looking tail; whether tournament play shifts this toward power-law scaling is the actual §10.10 T1 test and requires WTHOR. Histogram in ../othello-maths/results/phase1_detail.json (E5).
B₁ / B₂ distinctness. CONFIRMED at the static structural level (§10.4 update above). Trajectory-level ⟨B₁²⟩ vs ⟨B₂²⟩ asymmetry (§10.10 T2) still requires tournament data.
Disc density as slow variable. Spearman(ρ_disc, A₁⁻ energy) = +0.671, p = 1.5e-40 over 300 positions from 5 random games (E3). The magnetisation spectrum scales with filling monotonically but not perfectly, consistent with the Blume-Emery-Griffiths structural analog of §10.3 without yet committing to the tricritical-point crossing claim of T4.

10.11. Literature grounding¶

Load-bearing primary references, grouped by role in the hybrid framework.

Site-space / stat mech: Blume 1966 PR 141, 517; Capel 1966 Physica 32(5), 966; Blume-Emery-Griffiths 1971 PRA 4, 1071; Bouabci-Carneiro 2000 JSP 100, 805; Fortuin-Kasteleyn 1972 Physica 57, 536; Wolff 1989 PRL 62, 361.
Symmetry / ray structure: Nussinov & van den Brink 2015 RMP 87, 1 (arXiv:1303.5922); Nussinov & Ortiz 2005 PRB 71, 195120; Dorier-Becca-Mila 2005 PRB 72, 024448; Li-Miller-Newman-Wu-Brown 2019 PRX 9, 021041 (Bacon-Shor / compass codes); Nasu et al. 2012 arXiv:1203.3683 (orbital compass with ortho/diag split).
CA / game structure: Fraenkel 2000 (More Games of No Chance, MSRI); Ollinger & Theyssier 2019 arXiv:1908.06751 (bounded-change CA); Iwata & Kasai 1994 TCS 123, 329 (PSPACE-completeness of n×n Othello); Evans 1993 RMP 65, 1281 (RSA); Sipper SFI working paper (non-local CA).
Sheaf / dynamic operators: Hansen & Ghrist 2019 JACT 3, 315 (arXiv:1808.01513); Hansen 2020 U. Penn PhD thesis; Bodnar et al. 2022 NeurIPS (arXiv:2202.04579, Neural Sheaf Diffusion); Singer & Wu 2012 CPAM 65, 1067 (connection Laplacian).
Information thermodynamics: Landauer 1961 IBM J R&D 5, 183; Bennett 1982 IJTP 21, 905; Sagawa & Ueda 2010 PRL 104, 090602; Sagawa & Ueda 2012 PRE 85, 021104; Parrondo-Horowitz-Sagawa 2015 Nat Phys 11, 131; Horowitz & Esposito 2014 PRX 4, 031015; Jarzynski 1997 PRL 78, 2690; Crooks 1999 PRE 60, 2721.
Empirical validation: Takizawa 2023 arXiv:2310.19387v3 (weak solution + ground truth); Li-Hopkins-Bau-Viégas-Pfister-Wattenberg 2023 ICLR arXiv:2210.13382 (Othello-GPT); Nanda-Lee-Wattenberg 2023 BlackboxNLP arXiv:2309.00941 (linear mine/yours/empty probes); Yuan & Søgaard 2025 ICLR arXiv:2503.04421 (cross-LLM extension).

10.12. Verification pass (2026-04-22)¶

Phase 0–2 of the §10 survey is now computationally instantiated at ../othello-maths/ on branch othello-spectral-foundations-v0.1.0. This subsection is the pass-table summary so readers of this notebook do not have to hop to the sibling project to see what has and has not been grounded.

Phase 1 hypothesis battery (H1–H9 + E1–E8). Full per-hypothesis numerics in ../othello-maths/results/phase1_hypotheses.csv and phase1_detail.json.

ID	Claim	Status	Headline number
H1	Grid Laplacian = 2D DCT eigenbasis	PASS	subspace gap 3.4 × 10⁻¹⁴
H2	8-ray rep decomposes as 2A₁ + B₁ + B₂ + 2E under D₄	PASS	`{A1:2, A2:0, B1:1, B2:1, E:2}` exact
H3	B₁ and B₂ ray modes numerically distinct	PASS (stronger)	cos(B₁, B₂) = 0 in both 8-dim and 64×64 Frobenius senses
H4	L_ortho ≠ L_diag spectrally	PASS	mean-degree 1.75 vs 1.53; bandwidth 7.72 vs 6.83
H5	Static ray bundle has nontrivial holonomy	PASS	one rectangular loop with cos = −1.000 (full Z₂ reversal)
H6	Fiber rank ∈	PARTIAL / revised	rank-2 and rank-8 emerge; rank-6 is an irrep count, not an operator rank
H7	Coprime (p, q) generators exist for candidate D	PASS	(7, 11) for D = 768; (3, 11) for 1024; (7, 11) for 1152
H8	D₄×Z₂ invariance of the encoder	PASS	A₁⁻ D₄-invariant and Z₂-odd; A₁⁺(s²) fully invariant; all errors < 10⁻¹⁰
H9	A₁ depth-gap transfer chess → Othello	UNDETERMINED	requires Takizawa data
E1	Null tests (no knight DCT orth, no pawn antisym, no rank-5 species)	PASS (absence confirmed)	undirected ray antisym norm = 0 exactly
E2	JW / CP² fermion analog	PARTIAL	local Z₂ grading structural sketch
E3	Disc density ρ as KAM-like slow variable	PARTIAL / suggestive	Spearman(ρ, A₁⁻ energy) = +0.671, p = 1.5 × 10⁻⁴⁰ (N = 300)
E4	Compass-model ground state reachability	PARTIAL	constant-board ground state = 64-0 terminal
E5	Flank cluster-size distribution	PARTIAL	N = 7216 candidate flips; distribution-fit deferred
E6	Dynamic sheaf at move k	PARTIAL	instantiated; Spearman(legal_moves, λ₂) = +0.765, p = 1.1 × 10⁻¹²
E7	Disc-count monotone as global T-breaker	PARTIAL	no signal at N = 1 game; needs aggregate
E8	Takizawa perfect-play correlations	UNDETERMINED	requires external data

Bugs fixed along the way (documented in othello_spectral_research_notebook.md §1.2 and session_summary.md):

D₄ character table required class-aware assignment — the chess notebook's B₁/B₂ row structure failed idempotence when lifted verbatim because our permutation numbering puts axis reflections at {g4, g5} and diagonal reflections at {g6, g7}, and the character must be constant on each class.
Coprime generator search must verify 64-phase uniqueness, not just pairwise gcd. The first admissible prime pair (3, 7) for D = 1024 collides via the Diophantine relation 7p − 3q = 0 within the 8×8 range.
Z₂-even functionals (like occupation s²) need a D₄-only projection, not the full D₄×Z₂ projector — the latter trivialises because the default group action negates the signal under z = 1.

Phase 2 dynamic sheaf headline. A 60-move random-play game yielded sheaf λ₂ ∈ [0.22, 0.93] with Spearman(legal_moves, λ₂) = +0.765, p = 1.1 × 10⁻¹². The sheaf spectral gap tracks strategic freedom (count of legal placements), not disc density. The L7b caveat from the logo notebook applies: this is a snapshot correlation, and predictive power of spec(L_F(t)) for t + Δ has NOT been tested.

Paired with the §10.13 Phase 1c finding that Shannon I_move correlates with n_legal_moves at ρ = +0.814 on tournament play, the sheaf observable and the information observable are both dominated by the state-richness (count-of-options) axis. Whether they carry independent signal within that axis — i.e. whether spec(L_F(t)) is informative conditioning on n_legal_moves — is an open question and the natural next probe for a Phase 1d run.

Phase 3 preflight. The sequel — the phase-operator move engine for Othello, analogous to PHASE_OPERATOR_SUPPLEMENT.md for chess — has its decision log at ../othello-maths/OTHELLO_PHASE_OP_PREFLIGHT.md. Recommended default: D = 768 with rank-2 fiber, generators (7, 11), flip gate via Option B (explicit Z₂ channel in the encoder), state-dependent gating via aliasing-horizon detection (Option 3). The Othello phase operators have NOT been built in this pass — that is the sequel.

Phase 1b (game-trajectory corpus, Barcelona EGP 2026, 35 games, 2184 positions). Subsequent run of research/game_trajectory_tests.py upgrades five probes from PARTIAL / random-play-surrogate to numeric-with-real-games:

Probe	Result
T1 flip-count on real moves	max flip = 12, median per-position max = 4.0, mean-of-means = 2.23 — comparable to random play; distribution-fit vs power-law still requires WTHOR scale
T2 B₁ vs B₂ population asymmetry	`<B₁²>` / `<B₂²>` = 0.894; B₂ > B₁ in 1351/2184 positions (61.9%); paired diff mean = −0.468 — predicted direction confirmed (diagonal orbit runs ~12% hotter under tournament play)
E3 scale-up	Spearman(ρ, A₁⁻ energy) = +0.772 on 2184 real positions (was +0.671 on 300 random-play) — tighter under skilled play
E7 aggregate	forward-positive fraction = 0.541 ± 0.038 across 35 games; 30/35 games have fraction > 0.5 — small but consistent
G9 (Othello §9h′ peak/drop)	mean A₁⁻ peak ply = 57.9 (92.8% of game), drop ply = 45.9 (73.7%); ordering REVERSED vs chess — in Othello magnetisation grows monotonically with filling, so peak sits near terminal

The T2 result is the most immediately interesting: the §10.4 rook/bishop-from-rays derivation plus the §10.10 T2 prediction that tournament strategy should bias the diagonal orbit (corners are diagonal-reachable first) both land in the predicted direction. Finite-sample effects at N=35 are not ruled out — the same test at WTHOR scale is the decisive version.

Inventory of Takizawa reversi-scripts (github.com/eukaryo/reversi-scripts) usable without the 20 GB figshare position-value table:

opening_book_freq.csv.bz2 (24 MB) — move-frequency dictionary. Directly unlocks §10.10 T3 Shannon info per move without any 20 GB download.
Source.cpp, eval.cpp, Source_manyeval.cpp, Makefile — the modified edax used for 36-empty solving. Compilable. Gives depth-1 vs depth-20 evaluation and unlocks H9 as a surrogate for the chess §9h′ protocol (which used Stockfish depth-1 vs depth-20, not perfect play).
reversi_misc.py, reversi_player.py — reference Python legal-move generator for cross-validation.
empty50_tasklist_edax_knowledge.csv (204 KB) — edax knowledge at 50-empty positions; partial ground-truth anchor.

Only exact perfect-play correlations (the strict reading of H9 against the 20 GB table, and E8) require the figshare download.

What remains genuinely open. Items still requiring external data or further experiment:

H9 strict (vs Takizawa perfect-play), E8, §10.10 T4 (T_eff / D_eff trajectory), §10.10 T5 (FK-BC cluster-size fit).
Predictive (not just snapshot) power of the dynamic sheaf spectrum.
The compass-model ground-state-vs-reachable-play distance distribution under optimal rather than random play.
Whether a full bracket-aware restriction map for the sheaf (rather than the endpoint-based surrogate used in Phase 2) changes the kernel-dimension structure.

10.13. Phase 1c addendum — reversi-scripts integration (2026-04-22)¶

Run after §10.12 had been finalized. Integrates the GPL-v3 eukaryo/reversi-scripts artefacts that can be used without the 20 GB figshare perfect-play table. Full numerics in ../othello-maths/results/phase1c_*.json and ../othello-maths/results/session_summary.md.

1c.1 — OthelloBoard engine cross-validation (CONFIRMED). 2684 positions (2184 from the Barcelona EGP 2026 PGN + 500 synthetic random-play positions) evaluated against Takizawa's vendored reversi_misc.py::get_moves. 2684/2684 agreement, zero disagreements. Every downstream claim in §10.12 / §10.13 inherits this confidence; positions with divergent move sets between Claude's implementation and the reference would have invalidated every correlation in the Othello trajectory work. They don't.

1c.2 — §10.10 T3 Shannon information per move (CONFIRMED — conditional). Using the opening_book_freq.csv.bz2 from reversi-scripts as the empirical P(chosen) dictionary, I_move = log₂|M(s)| − log₂ P̂(chosen | book) was computed for 2099 scored plies across 35 tournament games. 32 % of plies were in-book (coverage determined by the book's truncation depth).

Observable	Correlation	p-value	N
I_move vs n_legal_moves (global)	+0.814	~0	2099
I_move vs A₁⁻ energy (global)	−0.065	0.003	2099
I_move vs A₁⁻ energy (in-book only)	+0.213	2.1 × 10⁻⁸	~676
game-mean I_move vs \|final disc diff\|	+0.109	0.53	35

The global I_move-vs-A₁⁻ correlation is noise (effect size near zero). Out of book, P̂(chosen | book) is Laplace-smoothed to uniform-noise baseline, so I_move collapses to log₂|M(s)| plus additive noise, which is why the global Spearman is dominated by the +0.814 legal-move-count correlation. In-book, where P̂(chosen | book) is an informative tournament-frequency distribution, I_move picks up a strategic-weight component, and that component partially aligns with A₁⁻ magnetisation energy at ρ = +0.21. This is a conditional effect, not a marginal one, and the conditioning variable (in-book / out-of-book) is the structural lever.

The null result at the game level — mean I_move does not predict winning margin (ρ = +0.11, p = 0.53) — distinguishes I_move as a state-richness observable rather than a quality observable. The spectral channel A₁⁻ (which does partially track disc density at ρ = +0.77 on the same corpus; §10.12 E3 scale-up) carries a different signal. Naming the split explicitly: Shannon information per move measures state richness (how many options, how evenly distributed); A₁⁻ energy measures strategic structure (how the magnetisation is arranged under the group action). The two are independent axes of a position description. This is a reusable framework distinction; when the same question is asked of chess (what fraction of I_move-vs-spectral-observable covariance is opening-book-conditional?) the answer may differ because chess's opening-book structure is different, but the conditional framing transfers.

No chess analog for the in-book conditional effect has been measured. Chess §9h′ measures A₁ energy vs Stockfish depth-gap, which is a different observable pairing. Adding a matching in-book I_move experiment to chess is scoped as a §9s follow-up if of interest.

1c.3 — Edax 50-empty knowledge anchor (PARTIAL, flagged). 15 of 35 Barcelona 50-empty positions match entries in reversi-scripts' 2587-row empty50_tasklist_edax_knowledge.csv. At the default reporting threshold of 20 matches the correlation is suppressed as a result; a peek at N = 15 gives Spearman(A₁⁻ energy, edax_score) = +0.820, p = 1.8 × 10⁻⁴. The effect size is the largest in the session. N = 15 is too small to commit to — this is a flag, not a result. A 2148-position edax run at depth 1 vs depth 20 is currently in flight; its result will either vindicate or kill this reading.

1c.4 — H9 A₁ depth-gap surrogate (CONFIRMED — disc-count-mediated). Ran full Barcelona corpus against Takizawa-delivered edax 4.5.5 at depth 1 and depth 20. 2180 / 2184 positions evaluated (99.8 %; 4 edge-case parse failures). Results: Spearman(A₁⁻ energy, |d1 − d20|) = +0.151, p = 1.6 × 10⁻¹²; partial controlling for |disc_diff| = +0.058, p = 0.007. Direction matches chess §9h′ (+0.452, N = 55) but effect size is ~⅓ and collapses by ~60 % under the disc-count partial — most of the signal is a disc-count artifact. Chess §9h′ partial did NOT collapse (+0.452 → +0.456), because chess A₁ energy is not a piece-count proxy, while Othello A₁⁻ magnetisation largely is (§10.12 E3: ρ(ρ_disc, A₁⁻) = +0.77). The cleaner chess-transfer analog uses the D₄-only A₁ projection of s² (occupation); that probe is scoped as Phase 1d. H9 UNDETERMINED → CONFIRMED with caveat.

What this does not change. The §10.12 pass-table is unaffected — H9 and E8 remain UNDETERMINED at the strict (Takizawa-figshare) reading; their surrogate (edax depth-gap) is now runnable and is in flight. The §10.10 T4 (T_eff / D_eff trajectory) and T5 (FK-BC cluster fit) are still scoped to a subsequent pass. Predictive-validation of the Phase 2 sheaf spectrum (following the logo L7b template) is still scoped to the sequel.

Framework-level observation to carry forward. The Shannon-information / spectral-observable conditional split is the most novel structural result of the Othello Phase 1c pass. It suggests that position description in the spectral VSA has at least two functionally independent axes — an information-content axis (state richness, tracks |M(s)|, null with outcome) and a spectral-structure axis (strategic configuration, tracks magnetisation arrangement under D₄×Z₂, partially correlates with quality). Whether these two axes also separate cleanly in chess is an open question worth running, especially because chess has a more developed opening-book theory and the in-book / out-of-book regime switch is sharper.

11. Phase-Operator Move Engine¶

Status. Working supplement — lives in PHASE_OPERATOR_SUPPLEMENT.md as a standalone document. Reference implementation at phase_operators/. §11.3 and §11.4 are validated against python-chess (416/416 empty-board pairs, and 1153/1153 on-board pairs against pseudo_legal_moves via A/B/C four-way convergence — the residual ~5.81% gap against legal_moves is the moves-into-check filter deferred to §11.5). §11.5 and §11.6 remain open.

The phase-operator move engine asks whether the legal reachable set of each polarization state on the 8×8 lattice can be generated entirely in phase space — via coprime cyclic phase operators acting on a polarization's origin phase tuple — without consulting the 2D board coordinates. This extends §9f (coprime roll binding) and §9r (polarization reframing) from representation to dynamics: where §9 treats occupation as a signal over a fixed lattice, §11 treats legal transition as a phase-arithmetic operation in the 640-dim coprime cyclic space. UTLP S4's Chinese Remainder Theorem aliasing horizon — used temporally for distributed clock recovery — is here transferred to the spatial domain as a partition detector for the legal reachable set.

The supplement defines seven phase operators (one per polarization, §11.2), specifies four experiments (§11.3–§11.6) that test equivalence with the geometric move generator, correlate phase-tuple similarity with thermodynamic gradients, and probe aliasing-horizon partition detection as the spatial analog of UTLP S4's mechanism. Infrastructure requirements (§11.7) and the explicit all outcomes produce knowledge stance (§11.8–§11.9) round it out.

See the supplement for: - §11.1 — The Phase-Operator Hypothesis - §11.2 — Phase Operator Specifications (seven polarization states) - §11.3 — Experiment 1: Equivalence on Empty Board (validated: 416/416) - §11.4 — Experiment 2: Occupation-Aware Phase Operators (validated: B≡C 100%, A≡python-chess 100%; §11.4.3.1 P_castle closes the castling gap) - §11.5 — Experiment 3: Phase-Tuple Similarity as Field Gradient Indicator - §11.6 — Experiment 4: Aliasing Horizon as Partition Detection - §11.7 — Open Infrastructure Requirements - §11.8 — What We Will Ask After Data Collection - §11.9 — Success and Failure Both Produce Knowledge

15. Cross-Disciplinary Applications: What Travels Beyond Chess¶

The work in §1–§11 built a specific tool: a 4D spectral chess encoder on Z_8^4 with B_4 symmetry adaptation and a phase-operator move engine, producing 45 056-dim float32 vectors, byte-stable across a C and a Python implementation, parity-tested at 1e-10. The chess application is the proximate goal. This section is for the rest of it: the machinery that produced that tool — how we are able to do this — is broader than chess and crosses cleanly into several disciplines that don't yet have a shipping toolkit covering the same ground. Fancy stuff that travels.

15.1. Why the toolkit crosses disciplines¶

The math underneath is well-established. Krawtchouk polynomials, the Hamming scheme H(d, q), B_n irrep decomposition of L²(Z_n^d), graph-Laplacian eigenmodes as discrete Fourier modes, quantum walks on hypercubes — all 25-to-60+ years old. What's distinctive isn't a new theorem, it's the combination of:

a byte-stable, parity-tested encoder for symmetry-adapted lattice features
channels that simultaneously carry semantic labels (piece types) AND irrep typing, so each output dim is interpretable AND equivariant
pre-computed Hermitian observables (the lifted P_piece_4 reach predicates — see §15.2(4) below)
with the planned chess_spectral.qm_4d extension, a quantum-mechanical front-end exposing state_to_psi, unitary moves, the Born rule, and time evolution under H = -Δ

That combination doesn't exist on PyPI today. PyGSP is irregular-graph spectral; escnn / e3nn are equivariant ML black boxes; Qiskit is circuit-flavored; lattice QCD codes are too heavy and too domain-specific. The chess-spectral toolkit fills a small but real gap: a Python-first, byte-stable, parity-tested toolkit for Z_n^d Hamming-scheme analysis with B_d adaptation and a QM-formalism API on top.

15.2. The enabling machinery¶

The four pieces that make the toolkit cross-disciplinary, with pointers to where each is built:

The graph and its symmetry group. The lattice is P_8 □ P_8 □ P_8 □ P_8 — the 4D path-graph product, NOT the cycle product C_8^4 (this matters; see §15.5 below for what changes if you swap to the torus variant). The B_4 hyperoctahedral group of order 384 acts as global lattice symmetries via tables_4d.b4_permutation_matrix. Permutations are orthogonal, so this lifts to a unitary representation π : B_4 → U(ℂ^4096) for free.
The simultaneous-eigenbasis identity. The encoder's 4096 per-channel eigenmodes are exactly the simultaneous eigenbasis of (Δ, B_4 commutant). This was conjectured during qm_4d scoping and verified at machine precision: max commutator norm 1.6e-13, max ‖Δv − λv‖ = 3.3e-16, every eigenspace stable under all 384 group elements (225 / 225 stable). The engineering "choice" of basis is actually a representation-theoretic theorem; full diagnostics in python/research/spectral_identity_4d_findings.md. This is what makes the encoder canonical rather than ad-hoc — any B_4-equivariant function on Z_8^4 lattice configurations decomposes naturally in this basis.
The 11-channel decomposition as a built-in projection-valued measure. The 11 channels (A1, STD4_X/Y/Z/W, FIB_SYM_1/2/3, FA_PAWN_W, FA_PAWN_Y, FD_DIAG) are block-disjoint orthogonal subspaces summing to the full 45 056-dim space. Each channel carries (a) a piece-type / symmetry-class semantic and (b) a B_4-irrep typing. That dual labeling is the unusual feature: downstream models get equivariance AND interpretability without engineering either separately.
Hermitian piece-reach observables, free of charge. The non-pawn phase-operator predicates (P_rook4, P_bishop4, P_queen4, P_king4, P_knight4) lift to real-symmetric Hermitian matrices on ℂ^4096 with real spectra (Hermiticity verified at floating residual 4.7e-15 in Pre-flight 2). They are graph-adjacency matrices in disguise — reach is symmetric, so adjacency is symmetric, so the operator is Hermitian. Phase 2's empirical full-sweep refines the spectrum bounds: rook has the cleanest integer spectrum [-4, 28] (vertex-transitive lattice degree); bishop [-12, 54.4], queen [-16, 81.9], king [-22, 67.7], knight [-36.06, 36.06]. Non-rook pieces have larger non-integer spectra because boundary clipping on the open Z_8^4 lattice breaks vertex-transitivity. The five H_piece_4 = adj(P_piece_4) observables are physically meaningful (eigenvalues are reach-centrality scores) and computationally cheap to construct. See python/research/phase_operators_4d_pseudo_hermitian_audit.md and python/chess_spectral/qm_4d.py.

Pawn predicates break Hermiticity (directed push) — that's where the qm_4d module's pseudo-Hermitian / PT-symmetric machinery earns its keep, with a metric operator η resolving the asymmetry. This is the natural place for Bender / Mostafazadeh constructions; the rest of the dynamics doesn't need them.

A built-in Z_2 superselection structure. The encoder is invariant under the (central inversion x → (7,7,7,7) − x + global color flip) Z_2 involution by design. Pre-flight collision testing on 41 556 positions found exactly the fixed-point set of that involution as the 8-element collision class; real-game corpora (601 self-play + 15 fixtures) are 100% injective. The interpretation: ψ naturally lives on configurations / Z_2, a parity-superselection sector. See python/research/encoder_injectivity_4d.py.

15.3. ML hooks that fall out¶

Most of these ride on the encoder alone. The four hooks marked (Q) require the planned qm_4d extension.

Frozen featurizer with built-in B_4 ⊕ Z_2 equivariance. Any downstream MLP / transformer / diffusion model trained on chess-spectral encodings inherits the symmetries for free. No e3nn / escnn boilerplate — pip install chess-spectral and treat the encoder as the first layer. The B_4 equivariance comes from §15.2(2,3); the Z_2 invariance from §15.2(5).
Channels are simultaneously semantic and irrep-typed. For interpretable equivariant ML this is rare: most equivariant networks give you irrep typing without semantic labels, or vice versa. We get both. Each output dim has a piece-type tag and a B_4-irrep tag, so attribution / probing studies are immediate.
Multi-scale features without wavelets. Laplacian eigenmodes are sorted by spectral radius, which corresponds to spatial frequency on the lattice. Low-frequency = global structure, high-frequency = local. Built-in pyramid; no wavelet construction needed; useful for curriculum learning and multi-resolution analysis.
Pre-computed scalar features ⟨ψ|H_piece|ψ⟩. The five non-pawn Hermitian observables from §15.2(4) are drop-in scalar features for any state. No graph walk per forward pass; they're sparse matrices applied once.
Free symmetry-aware data augmentation. The Z_2 invariance from §15.2(5) means models trained on encodings don't need manual color-flip augmentation. The encoder collapses the orbit by design.
Byte-stable parity-tested feature pipeline. Determinism / reproducibility for regulated ML domains (medical imaging, finance, regulatory). The C/Python parity gate (1e-10 in float comparisons; bit-exact tobytes() in .spectralz4) makes the feature pipeline auditable in a way most ML stacks aren't.
(Q) Move-as-unitary as a sequence representation. A chess game becomes a product of unitaries ψ_n = U_n U_{n-1} ⋯ U_1 ψ_0, fundamentally different from "sequence of (state, move) tuples." Models predicting next-move-as-unitary in encoded space may learn structurally different things than models predicting next-state-as-vector.
(Q) Born-rule loss instead of L2. Cross-entropy on prob_channel(ψ, c) = |⟨c|ψ⟩|² forces models to match channel-by-channel probabilistic structure rather than per-coord distance. For generative models on lattice configurations, closer to what's actually wanted.
(Q) Quantum-walk attention. Replace softmax attention with exp(-iHt)-based attention on the chess graph. The graph Laplacian H = -Δ provides tunable spectral filters at different time scales t. Drop-in attention module; transferable to other graph-attention contexts.
(Q) Discrete diffusion on hypercubes. Native forward process is ψ(t) = exp(-iHt) ψ(0) (unitary) or exp(-Ht) ψ(0) (heat kernel). Diffusion models with built-in B_4 equivariance.

15.4. Where the toolkit lands beyond chess¶

Specific subfields where chess-spectral (with the qm_4d extension) fills a real gap, ordered by likelihood of demand:

Pedagogy and teaching. Concrete, byte-stable, parity-tested Python toolkit for harmonic analysis on finite groups, graph signal processing, and quantum walks on a non-trivial lattice. Currently fragmented across SageMath snippets in research papers; no shipping educational toolkit covers Z_n^d analysis end-to-end with both engineering and physics APIs.
Hamming-scheme / association-scheme research. Bannai–Ito readers work in SageMath / GAP / Mathematica. There's no PyPI package providing reference implementations of H(d, q) spectroscopy + Bose–Mesner algebra access + symmetry-adapted bases. chess-spectral is a working H(4, 8) implementation; the structure ports to any H(d, q) with modest changes (replace the 1D path-graph eigenbasis with the appropriate one).
Quantum-walk research on Hamming graphs. The arXiv:2509.26243 audience (symmetric coined quantum walks on Hamming graphs) needs reference implementations to validate theorems against. chess-spectral with qm_4d gives them a parity-tested substrate.
Equivariant ML benchmarks and building blocks. A concrete labeled dataset of B_4-symmetric configurations on Z_8^4 with known irrep structure and game-semantic channels. Useful for validating equivariant-NN claims.
Cross-domain transfer template. Z_8^4 is a specific Hamming H(4, 8). The same encoder structure ports to Go-like games on Z_n^d, RNA secondary-structure spaces, molecular conformations on torsional grids, time-discretized trajectories. chess-spectral becomes a template for spectral encoders on combinatorial-configuration spaces with non-trivial symmetry.

15.5. Adjacent variants and what changes¶

Two natural variants point at distinct subfields:

Torus variant: C_8^4 instead of P_8^4. The 1D spectrum becomes 4 distinct eigenvalues (2(1 − cos(2πk/8)) for k = 0..3 plus repeats), the 4D spectrum has only O(d) distinct eigenvalues, and the symmetry group enlarges to the wreath product Z_8 ≀ S_4 ⋊ S_2 ≈ B_4 ⋊ Z_8^4 (translations join the lattice symmetries). Right substrate for periodic boundary conditions: lattice QCD, periodic-image crystallography, certain quantum-walk constructions. The encoder's machinery would port directly; only the eigenvalue tables need regeneration.

Higher-q variant: H(d, q) for q ≥ 8. The B_d adaptation extends naturally to wreath product S_q ≀ S_d. Krawtchouk polynomial families for general q provide the eigenbasis. The 11-channel decomposition would need adapting (channel count grows), but the structure is otherwise unchanged. Opens applications to larger-alphabet coding theory, larger-state combinatorial games, and generalized quantum walks.

15.6. Honest scope: math vs. toolkit¶

The mathematical content here is 0% novel — every individual ingredient is well-established. The toolkit packaging is ~70% novel: no single PyPI package combines what chess-spectral with qm_4d will provide. The chess-as-4D-spectral-physics framing is ~95% novel for chess specifically. The realistic value proposition for someone outside chess is "useful infrastructure," not "new physics." That's a real but modest niche, and it's where the toolkit's reach naturally goes.

The QM extension (the planned qm_4d module) is not intended as a physics paper. The Aaronson "Read the Fine Print" critique (2015) applies directly to any straight-line QM-rebrand of classical lattice data — basis-aligned PVMs on basis-aligned states return classical readouts tautologically. The escape valves are genuine interference (H_legal_moves producing rankings different from the classical legal-move oracle), genuine speedups versus classical baselines, or representation-theoretic identities. The spectral identity in §15.2(2) is the cleanest of these: the encoder's basis IS the simultaneous eigenbasis of (Δ, B_4 commutant), at machine precision. That's a clean math statement, and it's the theorem underlying every claim about "B_4 equivariance for free." See the 4D notebook's qm_4d Pre-flight Findings section for the audit record that produced this confidence.

16. Position Evaluation, Search, and Self-Play Validation (Phase 6 Plan)¶

After the QM extension ships (Tracks A + B), the natural next PR adds engine-level validation for the spectral / QM framework: position evaluators, a standard search stack, and a self-play tournament harness, for both 2D and 4D. The motivation is empirical: §3, §4, §5, §11, §15 all argue the spectral / QM machinery captures meaningful information about chess positions; a self-play tournament between (material) vs. (spectral channel-energy) vs. (QM-expectation) evaluators is the cleanest test of that claim. If spectral / QM evaluators consistently lose to material, the framework's chess-relevance is in question. If they win or hold even, that's evidence the encoded representation contains exploitable structure.

16.1. Three evaluator families¶

For each dimension (2D in chess_spectral, 4D in chess_spectral_4d):

Material baseline (eval=material). Standard piece-count score with spectrally-derived piece values from §3 / chess_spectral_values.py. Per-side sum, side-to-move negation. Pure baseline; no encoder call.
Spectral channel-energy weighted (eval=spectral). Encode the position via encode_4d (or 2D encode_640), compute per-channel L2 energy E_c = ‖proj_c(v)‖² for the 11 channels (4D) or 10 channels (2D), score = Σ_c w_c E_c. Weights w_c are tunable: hand-tuned defaults shipped, optional load from a JSON weight file via --eval-weights PATH. Variants by game phase (opening / middlegame / endgame) optional and gated behind a flag.
QM expectation (eval=qm). Build ψ = state_to_psi(state, side_to_move) via the planned qm_4d module, then score = Σ_O α_O · ⟨ψ|O|ψ⟩ for a configurable observable basis. Default observables: the five non-pawn H_piece Hermitians from §15.2(4), the 11 channel projectors P_c (Born probabilities), and (post-Track-B) any pseudo-Hermitian pawn observables with the chosen η-metric. α_O is tunable, same --eval-weights mechanism as the spectral evaluator.

All three evaluators expose the same API surface: evaluate(state, side_to_move) -> float. This is what the search layer calls.

16.2. Standard search stack¶

Same architecture for both dimensions. The expensive question (move generation) differs — 2D uses python-chess, 4D uses python-chess4d-oana-chiru and/or our own phase_operators_4d predicates — but the search loop is identical:

Negamax with alpha-beta pruning. Standard.
Iterative deepening with time control. Search depth 1, 2, 3, ... until the per-move budget expires; return the best move from the deepest completed iteration.
Transposition tables. Zobrist-hashed positions → (depth, score, best_move, bound_type). Bound types: EXACT, LOWER, UPPER. Two-bucket-replacement scheme.
Move ordering (critical for alpha-beta efficiency):
1. Hash move (TT-suggested) tried first
1. MVV-LVA: captures sorted by victim value descending, attacker value ascending
1. Killer moves: per-depth memory of recent beta-cutoff producers
1. History heuristic: per-(piece-type, dest-square) counters of cutoff frequency
Null-move pruning. If the side-to-move "passes" and a reduced-depth search still returns ≥ beta, prune. Disabled in zugzwang-prone endgames (configurable threshold).
Quiescence search. At leaves, extend on captures (and checks, optionally) until no forcing moves remain. Prevents the horizon effect.

Standard ablations are exposed as flags so we can study which components matter for spectral / QM evaluators specifically: --no-null-move, --no-killer, --no-mvv-lva, --no-tt, --no-quiescence. Default: all on.

16.3. Self-play tournament harness¶

Round-robin: every pair of agent configurations plays both as white and black; multi-game matches per pairing for variance reduction.
Termination rules: standard (checkmate, stalemate, threefold repetition where defined, 50-move rule, max plies cap). 4D repetition is deferred per phase_operators_4d status; max-ply cap suffices.
ELO tracking via standard incremental updates.
Logging: .pgn for 2D (compatible with any PGN reader), NDJSON4 for 4D (the format already in use; see docs/NDJSON4_FORMAT.md).
Output: structured tournament_results.json (per-pairing W/D/L, per-agent ELO, per-game metadata) plus the raw game logs.

16.4. CLI surface and the `--help` discipline¶

Every new command must ship with a complete --help block. This is a discipline rule, not a polish item: argparse help= strings are the user-facing contract for any CLI addition. The immolation suite already enforces "no unwired CLI commands" (test_smoke_e2e.py::test_no_unwired_stubs_in_shipped_python_or_c); Phase 6 adds a parallel guard checking that every subcommand has non-empty help= text on every argument and a non-empty subcommand description.

Planned 2D additions (chess-spectral):

Command	Required args	Optional
`search`	`--position FEN` (or stdin), `--depth N` or `--time T`	`--eval material\\|spectral\\|qm`, `--eval-weights PATH`, `--tt-size N`, `--no-null-move`, `--no-killer`, `--no-mvv-lva`, `--no-tt`, `--no-quiescence`
`tournament`	`--agents A,B,C` (or `--config PATH`), `--rounds N`	`--openings PATH`, `--time-control STRING`, `--output PATH`, `--max-plies N`
`play-engine`	`--engine NAME`, `--time-control STRING`	(interactive PGN exchange for human-vs-engine; optional)

Planned 4D additions (chess-spectral-4d): same three commands, FEN4 / NDJSON4 formats, identical evaluator / search / tournament options.

Each --help entry must (a) name the argument, (b) explain its semantics in one line, © document the default. Defaults are checked by tests.

16.5. What we expect to learn¶

The tournament results answer specific empirical questions:

Does spectral channel-energy evaluation correlate with position quality? Tournament: material vs. spectral_default (hand-tuned weights). If spectral_default wins or holds even at equal search depth, the encoded representation contains exploitable position information. If it loses badly, weights need learning (natural follow-up: gradient descent on tournament results), or the framing is wrong.
Does QM-expectation evaluation outperform either? Tournament: material vs. spectral vs. qm. This isolates the value-add of the QM front-end specifically. If qm adds nothing over spectral, the QM extension is mathematically clean but practically empty (which is fine — it can still ship as the cross-disciplinary toolkit per §15, but we won't claim chess-strength benefits).
Which observables matter? Per-observable ablation in qm evaluator. If only H_king and the channel projectors carry signal, that focuses the QM module's claims. If the pseudo-Hermitian pawn observables (Track B) matter, that validates the η-metric machinery beyond aesthetic rigor.
2D vs. 4D contrast. The 4D tournament adds a search-and-evaluation layer on top of python-chess4d-oana-chiru's rule library. We're not aware of a published 4D chess search engine for this rule variant, but we haven't done an exhaustive prior-art survey — so the contribution claim is "first that we know of in this lineage," not "first ever." Either way, it's a useful artifact for empirically validating the spectral / QM framework against actual play. The 2D tournament is calibration: results have to look reasonable next to standard chess engines (we are NOT trying to beat Stockfish; we are calibrating that our search + eval combine sensibly).

16.6. Scope and dependencies¶

Phase 6 ships AFTER: - Phase 2 (Track A kinematic qm_4d) - Phase 4 (Track B qm_4d dynamics) - Phase 5 (notebook merges)

Estimated effort: 1500–3000 LOC across both dimensions (search core ~500 LOC each, evaluators ~300 LOC each, tournament harness ~400 LOC shared, CLI ~200 LOC each, tests ~500 LOC). The 4D engine is the bigger novelty; the 2D engine is calibration / sanity check.

A natural research follow-up (Phase 7+, not committed): tune evaluator weights via self-play with policy-gradient or supervised distillation against an external strong engine (Stockfish for 2D; for 4D there is no external reference, so self-play bootstrap is the only option). That work depends on Phase 6 shipping first to establish the harness.

16.7. Prior: Othello / Edax spectral-weights result (load-bearing — but contaminated; see 2026-05-09 amendment below)¶

2026-05-09 amendment — finding contaminated by ML-fork splice. The §16.7 framing originally treated the Edax-spectral-Reversi archive as authoritative empirical prior — specifically the headline result that Architecture A (linear spectral features) won +243 ELO at L6 but decayed to 0 ELO at L10+. The user has since clarified that the engine in question was an ML-augmented fork of vanilla Edax, and the spectral-weights contribution can't be cleanly separated from whatever the ML black-box was doing in the eval pipeline. Vanilla Edax behavior is what would be trustworthy as a prior, and we don't have that data. Treat all numerical claims in this section as suggestive but not load-bearing until a vanilla-engine replication exists. The §16.5 design rules below (test multiple depths; audit training target; don't trust eval-task metrics as Elo proxy) remain methodologically sound — they're good discipline regardless of where the original observation came from. But specifically: do not gate B-spike-3 (encoder-eval speedup work) on the depth-decay claim. That claim's empirical support is currently weaker than this section's first writing implied. The §20.19 update reflects this.

Source: edax-spectral-reversi archive at D:\GitHub\zen-pike-6af276 (last active 2026-04-27). FM-augmented Edax fork that integrated sheaf-spectral D_4 × Z_2⁺ features (5 channels: A_1⁺, A_2⁺, B_1⁺, B_2⁺, E⁺ on the 64-cell Othello board) into the engine's evaluation function. Recovered by the read-only walk in this PR. Files most worth a closer reading: docs/architecture_A.md, docs/spectral_math.md, docs/NEXT_PARADIGM.md, docs/path_2b_3_4_findings.md, docs/research_directions.md, docs/FINAL_SUMMARY.md.

The user's recall — "spectral weights did nothing for us" — is directionally right but understates the actual structure. The verified findings are more useful as a design constraint:

Shallow-depth positive, deep-depth negative. Architecture A (linear spectral features) produced ~+243 Elo at L6 and captured ~50% of FM's unexplained variance at ply=10 (R² 0.352 → 0.680 on the Takizawa archive). At L10+ the signal vanishes entirely — deeper search subsumes the spectral contribution. The "did nothing" recall is the L10+ regime; the L6 regime says spectral weights work very well when the search horizon is shallow enough that the eval function actually drives move ranking.

Convergence ceiling is structural, not feature-engineering. All three architectures tested — Architecture A (linear), B (learned bilinear latents), C (spectral-kernel replacement) — produced identical L6 match results (3-1-16, −269 Elo) when trained on single-ply data. The ceiling is the corpus / target-alignment, not the model. Adding bilinear or kernel structure to the linear baseline at one fixed training ply doesn't shift move rankings, because alpha-beta leaves at L6 are at ply=12 — only internal nodes ever see the trained ply=10 evaluator.

Eval-task wins do not transfer to play quality. The "bracket" feature (pending-flip pseudo-channels) reduces eval-task RMSE by 11% (19.69 → 17.51), CV-stable across folds. Yields 0 Elo at L6/L8/L10. Same pattern reproduced under ridge, logistic, σ-scaling, and nonlinear BZ formulations. RMSE wins on a position-correlation task are not a proxy for match strength under alpha-beta leaf evaluation. Documented across multiple path_*_findings.md and FINAL_SUMMARY.md. This is the single most important methodological lesson the Othello work establishes.

Target misalignment is the binding constraint. Refitting bracket weights against four different Takizawa-archive targets (mean_lb, mean_ub, max_ub, min_lb) produced radically different fitted weights yet identical play (game-1 disc count 50−14 across all variants). The target predicts conservative endgame outcome, not best-move ranking. Spectral channel weights, in this regime, are an answer to the wrong question.

Endgame move-quality signal is real and large (+12.3 pp win-rate lift, ply 48-60, top-quintile bracket-disrupting moves vs bottom-quintile, ~4σ confidence). Did not get integrated into shipping evaluator because it requires per-move ΔE recomputation that wasn't wired in C. Open thread.

Implications for Phase 6 design¶

This is now the most important calibration data Phase 6 has. Direct consequences:

Test at multiple search depths. A single-depth tournament conceals exactly the phenomenon Othello documented. The Phase 6 tournament harness should run at least three depths (e.g., shallow / mid / deep, with the specific values calibrated to chess's branching factor and the engine's per-move time budget — concrete starting points might be --depth=4, --depth=8, --depth=16 but those are illustrative, not prescribed gates) and report per-depth ELO deltas. A single-depth headline number would have hidden the +243 Elo at L6 in the Othello data; we will not repeat that mistake. The Othello → chess depth translation is methodological inheritance, not a logical mapping; chess's larger branching factor and standard-engine baselines (material vs the much-stronger Edax) mean the depth-where-signal-vanishes may sit somewhere different than the Othello L6→L10+ shape predicted.
Audit the training target before fitting weights. Hand-tuned defaults are fine for shipping. But any learned-weight follow-up (Phase 7+) must be explicit about what target it's regressing against — Stockfish eval at fixed depth, win/loss outcome, anchored-leaf evaluation, etc. — because target misalignment was the Othello binding constraint, not optimization.
Don't trust eval-task metrics as signal-of-play-strength. The Phase 6 notebook entry on tournament results must report Elo deltas from match play, not RMSE / R² / channel-correlation numbers. The Othello archive shows these decouple cleanly.
The QM-expectation evaluator is the more interesting test. Spectral channel-energy weighting is structurally close to what Othello tested and likely faces the same shallow-strong / deep-vanishing decay. The QM evaluator's ⟨ψ|H|ψ⟩ form with the §15.2(4) Hermitian piece-reach observables is structurally different — it's not a linear feature-energy sum, it's an expectation value of an operator in a fixed basis. Whether QM-expectation faces the same depth-decay is genuinely open. Treat that as Phase 6's headline question.
Bracket-style features deferred. Adding pending-flip pseudo-channels analogous to Othello's "bracket" is a natural Phase 7+ direction in chess (analog: pending-capture pseudo-channels, or pin/skewer pseudo-channels). The Othello archive is clear that they buy eval-task RMSE but not Elo — replication on the chess side is interesting but not the load-bearing experiment.

Updates to §16.5 in light of this¶

The original §16.5 framed three empirical questions; with the Othello data in hand, they refine to:

(modified) Does spectral channel-energy evaluation correlate with match strength at any search depth? Othello prior: yes at L6, no at L10+ (against Edax). Chess test: per-depth ELO delta sweep across a few representative depths — concrete starting points are e.g. --depth=4 / --depth=8 / --depth=16, but the right depths to test depend on chess's branching factor and the per-move time budget. Confirming the depth-decay extends a known finding; finding constant Elo delta across depths is a chess-specific positive (would point at chess's richer piece structure breaking the Othello pattern, or at the much weaker material-baseline opponent meaning the spectral-vs-material delta survives further).
(unchanged) Does QM-expectation evaluation outperform either spectral or material? Now the primary question, since spectral's behavior is partially predicted.
(modified) Which observables matter? Per-observable ablation; Othello data warns specifically that channels with high RMSE-fit relevance may have zero Elo relevance.
(unchanged) 2D vs 4D contrast.
(new) Per-depth signal decay curve. Plot ELO delta vs search depth for each evaluator. This is the most informative single chart Phase 6 can produce — directly comparable to the Othello L6/L10 contrast.

Phase 7 (learned weights) reframing¶

If Phase 6 confirms the depth-decay pattern for spectral evaluation in chess, Phase 7's learned-weights work has two paths: - (a) Confirm the structural ceiling — re-fit per-depth and show that no weight assignment recovers Elo at deep search. Strong negative result; would shift attention entirely to QM-expectation evaluators. - (b) Demonstrate that target alignment was the bottleneck — fit against best-move outcome instead of position-evaluation outcome (the specific Othello failure mode), see if that changes the picture. Likely the more productive direction given the Othello findings.

Either path is informative. Both depend on Phase 6 shipping the harness and documenting per-depth deltas first.

16.8. Prior: Chess-side Othello research thread (`docs/othello-maths/`)¶

Source: docs/othello-maths/ inside this repo. Separate from the standalone zen-pike archive surveyed in §16.7. The canonical artifact is the 1845-line othello_spectral_research_notebook.md, plus 1011-line PHASE_1E_FINDINGS.md, plus ~30 research scripts in othello-maths/research/. This thread tested spectral hypotheses on Othello with the explicit purpose of informing chess-spectral. The merge-scope agent (PR-72 era) flagged that the six Patch 1C items propagated cleanly into chess; what follows are the substantive findings beyond those patches that the chess notebook had not previously absorbed.

The headline reframing is sharp: §16.7 reads "convergence ceiling is structural, not feature-engineering." §16.8 says the ceiling can move if the feature basis is rich enough. Both are true; they're testing different things.

16.8.1. Architectural improvements that DID move the ceiling¶

Faithful sheaf bracket-classifier: +40% gain (research/faithful_sheaf.py; §2e.5–§2e.6 of the othello notebook). Replacing endpoint-only restriction maps with per-cell R1/R2/R3/R4 bracket-state classifier and projecting pending-flank counts through D_4 lifted D_4-A_1(s²) partial ρ from −0.319 → −0.447 at N=2587. The lesson: the feature basis is the bottleneck, not the weights. Naive linear weights on naive occupation features are a weak ceiling; sheaf-aware features lift it substantially.

Phase-operator reweighting chain: +114% cumulative gain (othello_spectral/phase_operator.py; §2e.15–§2e.16). Two-step pipeline: (a) diagonal scaling by sheaf spectral features (λ₂, entropy, kernel-dim) gives +12%; (b) learned coupling matrix via Nelder-Mead optimisation gives +114% total. The coefficients are driven by entropy-difference between owners. End-to-end: D_4-A_1 partial ρ −0.319 → −0.683 (2.03× improvement). This is the most directly applicable result to chess-spectral's Phase 6 design — the QM-expectation evaluator with learned α_O weights on the §15.2(4) Hermitian observables is structurally close to this construction. Treat it as the prior to beat.

Move-operator toolchain: 4.9× replay speedup with byte-identical SHA256 validation (research/move_operator.py, §2e.18–§2e.19). The SheafMoveOperator exposes flip_count_vector (64-dim impact ranking), encode_post_move (lookahead encoding without replay overhead), and 6 other public methods. Replaces per-move full-board scans with incremental sheaf-fiber updates. Direct analogue for chess Phase 6: precomputed move-impact ranking would feed MVV-LVA / killer-move heuristics with a richer signal than victim/aggressor type.

C encoder sheaf port: 25× speedup, bit-identical to Python (c_encoder/src/othello_spectral.c, §2e.13). ANSI C17, clang -Wall clean. ctypes DLL path: 0.2 s vs 5.0 s Python on Barcelona 35-game corpus. 36 test cases verified at float32 (subprocess) and float64 (ctypes). Same parity-discipline pattern that chess-spectral uses. Empirically validates that the sheaf construction can be ported to C without precision loss — relevant if Phase 6's tournament harness needs a C engine.

16.8.2. Methodological lessons that refine chess-spectral's claims¶

Simpson's paradox between chess and Othello A_1/E structure (§1e.7.5; phase1e_chess_a1_e_pair.py, phase1e_simpson_mechanism.py). The sign of the A_1/E correlation flips between the two games:

	Within-game	Between-game	Pooled
Chess	−0.15	+0.60 to +0.67	≈ 0
Othello magnetisation	+0.39	−0.48	≈ 0
Othello occupation	−0.05	−0.59	≈ −0.59

The 50-empty −0.834 figure that previously appeared as a chess-spectral talking point is phase-specific (a 14-disc Othello configuration), not a general trajectory trait. This refinement should land in chess-spectral when the §11 phase-operator supplement merges. The broader methodological lesson: per-game analysis is necessary before claiming any A_1/E relation; the pooled correlation is a Simpson's-paradox artifact of game-phase distribution.

Trajectory memory is target-specific, not universal (§2e.4, §1e.7.4b; phase1e_a1_drift_by_phase.py, phase1e_faithful_gain_investigation.py). Sheaf predictive gain varies systematically by target type:

D_4-E(s²) occupation: strong predictive gain (+0.159 in-sample, +0.157 OOS at Δ=10, N=2178). Sheaf wins.
A_1⁻ magnetisation: snapshot wins (gain −0.041 at Δ=10). Phase-localised to deep endgame.
n_legal_moves: near-zero gain; sheaf and snapshot equivalent.

Mechanistically: Z_2-even features (occupation) encode trajectory structure; Z_2-odd features (magnetisation) couple to turn-order which the bracket classifier doesn't encode. This decomposes the §1e.5 sheaf-vs-persistence question into three mechanical regimes (§2e.14, phase1e_s_vs_s2_asymmetry.py):

Monotone targets (ρ, empty-count, d4_a1_occ): near-trivial; predictive gain is a disc-count artifact.
Trajectory-driven (d4_e_occ, r_disc=+0.083): genuine sheaf memory from bracket dynamics.
Turn-order-coupled (a1_minus): sheaf captures the "what" (brackets) but not the "who" (player); snapshot wins.

Application to chess-spectral: the analogous decomposition for chess channels has not been done. When Phase 6 ships the spectral evaluator, per-channel ablation should classify each of the 11 (4D) or 10 (2D) channels into these regimes — the trajectory-driven channels are where any sheaf / phase-operator learned coupling would land.

A_1 does NOT universally track strategic divergence (§2c.2, §1e.6; phase1e_shannon_observables.py, phase1e_signflip_decomposition.py). The previously-claimed A_1 ↔ Shannon-information relation retracts on aggregate — global I_move vs A_1⁻ is ρ = −0.065 (noise). The +0.213 in-book correlation (p = 2×10⁻⁸, N≈676) is real but conditioned on WTHOR opening-book coverage, which only covers 32% of plies. Within-phase ρ ranges +0.10 to +0.25 (small); the aggregate +0.465 is between-phase Simpson structure. A_1⁻ tracks game phase (how many discs are down), not strategic divergence. Material refinement to land in chess-spectral when next reviewed.

Edax d=20 does NOT bridge the gap to perfect-play truth (§1e.1; phase1e_edax_d20_correlations.py, phase1e_edax_d20_tasklist.py). D_4-A_1(s²) vs d=20 partial ρ = −0.277; vs pre-proof Edax = −0.284 (Δ = 0.007, indistinguishable). vs archive_mean_lb (perfect play) = −0.331. The spectral channel carries ground-truth information that even d=20 heuristic-leaf evaluation misses. Direct chess implication: if we validate chess-spectral evaluators against Stockfish at any fixed depth, we'll miss the same gap. Validation against game outcomes (win/loss/draw labels) carries strictly more information than evaluation labels at any heuristic depth.

16.8.3. Structural characterisations (statistical / geometric)¶

These are descriptive findings the chess analogues haven't been computed yet — natural follow-ups for chess-spectral when Phase 6 ships and we have a tournament corpus:

Holonomy is structurally concentrated (§2e.10; phase1e_holonomy_plaquettes.py). Of 1192 enumerated loops across 7 shape families, all 105 nontrivial loops (cos = −1) are lj_rect_Wx1 with W ≥ 3; 1087 are trivial. Path-orientation-dependent (1×H transpose gives trivial). Generalises §2.H5's single-loop observation to a complete curvature map.
Flip-count and flank-chain distributions are exponential, not power-law (§2e.8; phase1e_flipcount_distribution.py, phase1e_t5_cluster_distribution.py). T1 (flip-count): λ ≈ 0.548, mean 2.37 across 4 corpora. T5 (same-colour run length): τ ≈ 2.68, mean 2.94, max 8 — rejects FK-BC power-law (critical τ ≈ 2.05). Stable across N=23→2178 games and 20-year span. Strategic play does NOT shift from random-play expectation in this distributional sense.
Negative T_eff is robust across methods (§2e.9; phase1e_t4_* triplet). Median T_eff = −11k (Barcelona finite-diff), −22k (windowed OLS), log-transform slope −6.04. Spectral energy anticorrelates with Shannon entropy over channel distribution — mechanically consistent with Plancherel-budget mirror. Chess analogue would compute the same T_eff over 2D / 4D channel energies during games.
Multivariate A_1+E near-null; A_1−E direction beats either alone (§1e.2; phase1e_multivariate.py). Joint OLS (A_1+E): partial R² = 0.100. Best raw direction: ρ = +0.515 at θ = 151.75° (0.88·E − 0.47·A_1). The Plancherel mirror direction (θ = 45°) is null; the orthogonal direction (θ = 135°) carries the signal. For chess: the analogous best-rotation in the A_1/STD4 plane has not been computed.
Predictive sheaf shows persistence-vs-sheaf crossover for A_1⁻ (§1e.5b). At short horizon (Δ=1) persistence wins (gain −0.345); at long horizon (Δ=10) sheaf wins (gain +0.098). Crossover between Δ=3 and Δ=5. Non-stationary signature: sheaf at t predicts better than sheaf at t+Δ — implies the dynamic encoder captures something the static encoder misses on long-horizon questions.

16.8.4. Open opportunities — Othello findings NOT YET transferred to chess¶

These are the genuine "merge candidates" — substantive results that have an obvious chess analogue but aren't in chess-spectral yet:

In-book Shannon-information effect (Othello Patch 3). Novel to Othello; no chess analog exists. Frame: state-richness axis = |M(s)|, strategic-structure axis = D_4 × Z_2 occupation. Test analogue: chess Stockfish-eval-divergence within / outside an opening book (Reti, KID, etc.) vs spectral channel signature. Worth a Phase 7 experiment slot.
Faithful sheaf for chess. Define analogous bracket-state pseudo-channels for chess: pending-capture chains, pin/skewer geometry, discovered-attack potential. Should lift A_1 / STD4 partial ρ in the same way Othello's R1/R2/R3/R4 lifted theirs. Direct extension; would slot into Phase 7 (learned weights) as a richer feature basis.
Phase-operator learned coupling for chess. The Othello Nelder-Mead-fit coupling matrix on entropy-difference is directly applicable to the QM-expectation evaluator's α_O weights in chess Phase 6.3. Use this as the prior for any learned-weights Phase 7 work — start from the Othello-style construction and only deviate if chess data demands it.
Three-regime channel decomposition. Phase 6's per-channel ablation should classify chess channels into the (monotone / trajectory-driven / turn-order-coupled) regimes. Trajectory-driven channels are where sheaf-style architecture helps; monotone ones are tautological; turn-order-coupled ones need explicit side-to-move encoding (which we already do per Pre-flight 1's Z_2 superselection).
A_1 phase-localisation refinement. Update any chess-spectral claim that A_1 tracks strategic divergence to the more careful "A_1 tracks game phase; per-game Simpson's analysis required before any pooled correlation claim." Specifically affects §11.5 / §11.6 of the phase-operator supplement when it merges.

16.8.5. How §16.8 refines §16.7's reading¶

§16.7 said: "Convergence ceiling is structural, not feature-engineering." §16.8 says: the structural ceiling depends on what observables you have access to. Sheaf-aware features (faithful sheaf bracket classifier) push D_4-A_1 partial ρ from −0.319 to −0.447 (+40%); learned phase-operator coupling pushes it further to −0.683 (+114%). The absolute final correlation still doesn't reach perfect-play truth (so §16.7's L10+ Elo decay is real and not refuted), but the ceiling is not a fixed point — it's a function of (feature basis × weight-fitting strategy).

Combined working hypothesis for Phase 6 + Phase 7:

Phase 6 ships naive linear spectral weights (analogous to zen-pike's Architecture A) and likely confirms the depth-decay pattern.
Phase 7's first move should NOT be "tune the linear weights better" — that path was exhausted in Othello. The first move should be richer features (chess analogues of faithful sheaf brackets) + learned coupling on those features (chess analogue of the Nelder-Mead phase-operator fit).
Validation target should be game outcomes, not Stockfish eval at fixed depth — Edax d=20 didn't bridge the perfect-play gap on Othello, and there's no reason Stockfish at any heuristic depth would do better on chess. Use win/loss/draw labels from a self-play tournament corpus as the ground truth; Stockfish evaluations are useful as a regulariser, not as the truth.

16.9. Downstream API gaps blocking Phase 6 (from chess4D-OC consumer)¶

A separate Claude session working on the chess4D-OC project (which consumes chess-spectral as a worker) flagged four gaps in the public chess-spectral API that they currently work around in JS. Two of them block Phase 6 directly; two are correctness / round-trip gaps that should ship in the same Phase 5b PR before the engine work begins.

#	Gap	Affects	Why it blocks Phase 6 (or doesn't)
1	`apply_move` auto-promotes blindly to queen; no promotion-piece argument	2D + 4D move application	Knight underpromotion is a real chess move (tactical-puzzle staple). Engine search and tournament play must be able to evaluate it. Phase 6 prerequisite.
2	No threefold-repetition draw detection	2D + 4D game state	Tournament games cannot terminate correctly without this. The engine harness will play forever in cyclic positions. Phase 6 prerequisite.
3	No 50-move-rule draw detection	2D + 4D game state	Same — tournament termination. Phase 6 prerequisite.
4	FEN4 round-trip: `parse` exists; `serialize` is missing	4D state interchange	Downstream code (chess4D-OC, any web worker) can't paste an external FEN4 back into the worker. JS hand-rolls serialize today; chess-spectral should own it. Useful for `qm_4d` state-load too.
5	State load: one-way export today; no public entry point to re-load a FEN4 string into the encoder's working state	4D worker integration	Downstream of #4. With `serialize` shipped, the import path needs an explicit `load_state(fen4_string) -> Position` entry point.

Phase 5b is interpolated between Phase 4 (Track B QM dynamics) and Phase 6 (engine + tournament): a single PR closing all five gaps with regression tests. The threefold / 50-move detection is the substantive load — it requires move-history state plumbed through the existing per-ply pipeline. The FEN4 round-trip and state-load are mechanical (parse + inverse-of-parse + entry point); the auto-promote fix is a one-argument signature change with a default that preserves backward compatibility (promotion='Q' default).

The 2D side already has most of this infrastructure via python-chess (which we delegate to for game-state); the 4D side is where the gaps live. Phase 5b's actual scope is therefore mostly 4D-side, with a thin 2D pass to ensure parity with the python-chess defaults.

The full version-mapped bridge-surface contract (covering both Phase 5b's API gaps AND the QM/engine bridge methods the chess4D-OC consumer needs) is laid out in §17 below.

17. Bridge-Surface Contracts and Versioning Roadmap¶

Source: wish-list from the chess4D-OC consumer (a Claude session running in parallel that uses chess-spectral as a Pyodide worker). Captures the exact method signatures the consumer needs and ties each method to a chess-spectral release. This section is the contract chess-spectral commits to ship against.

The version ladder past v1.3.2 (the current line) is:

Version	Scope	What ships	Bridge methods added
v1.3.x (patches)	Notebook merges + hygiene (Phase 5 PR-1..PR-5)	Docs-only; no API change	—
v1.4.0	API gaps (Phase 5b)	Move application + game-termination + state-interchange	`getDrawStatus`, `getMoveHistory`, `applyMove(promoteTo=…)`, `serialize()`
v1.5.0	QM extension (Phase 2 + Phase 4: Tracks A + B)	Quantum-mechanical front-end on top of encoder	7 new (see §17.1)
v1.6.0	Engine submodule (Phase 6)	Search + evaluators + tournament harness	3 new (see §17.2)
v1.7.x (later)	Learned weights + sheaf features (Phase 7+, not committed)	TBD	TBD

Patch bumps within each minor line absorb bug fixes without changing the bridge contract. Each method below is the public Pyodide bridge surface consumed by chess4D-OC; chess-spectral may use richer internals.

17.1. chess-spectral 1.5 — QM extension bridge surface¶

Seven methods. All read-only on the underlying classical state except applyMoveQm, which is the unitary-move path (semantically replaces the classical applyMove when QM mode is active). Each method maps to a milestone in the M14.x visualization tier of the consumer's plan.

Method	Args	Returns	Purpose	Phase ships in
`getQmState`	`()`	`{ ok, psi: ComplexArray, basisDim, normSq }`	Current ψ as flat real+imag interleaved Float32. Drives M14.1 raw-amplitude render, M14.2 phase-as-color, M14.3 trajectory replay.	2 (Track A)
`getQmDensity(pieceId?)`	`int?`	`{ ok, density: Float32Array(4096) }`	`\\|ψ_p\\|²` per cell. Without `pieceId`: full-position density. With `pieceId`: single-piece marginal (requires partial trace over channels — see infrastructure note below). M14.1.	2 (full) + 4 (per-piece marginal)
`applyMoveQm(origin, dest)`	`{x,y,z,w} × 2`	`{ ok, U_move?: ComplexMatrix }`	Apply unitary move; optionally returns the U used (for animation). M14.3. Replaces classical `applyMove` semantics when QM mode is active.	4 (Track B)
`measureAt(coords, observable?)`	`{x,y,z,w}, string?`	`{ ok, sampledOutcome, postCollapsePsi }`	Born-rule projective measurement at lattice coords. Default observable = position. M14.5.	2 (Track A)
`getDensityMatrixOf(pieceId)`	`int`	`{ ok, rho: ComplexMatrix, purity, rank }`	Reduced density matrix for a piece (partial trace over the rest of the system). For entanglement viz. M14.4.	4 (needs partial-trace machinery)
`getProbabilityCurrent`	`()`	`{ ok, j: Float32Array(4096 × 4) }`	`j_p(c) = Im(ψ* ∇ψ)` — probability current field on the lattice. For QM-filament viz. M14.6.	4 (needs ∇ as a finite-difference operator on the path-graph lattice)
`getQmExpectation(observable, weights?)`	`string, dict?`	`{ ok, value }`	`⟨ψ\\|H\\|ψ⟩` for the named observable; optional weights override defaults. Composes with engine `evaluatePosition` for the QM evaluator family. M14 + Phase 6.3.	2 (Track A)

Infrastructure call-out: three of these (per-piece getQmDensity, getDensityMatrixOf, getProbabilityCurrent) need machinery the kinematic Track A doesn't yet build:

Partial trace over channels — needed for per-piece marginals + reduced density matrices. The 11 channels are block-disjoint; partial trace over channel labels is straightforward sparse-matrix arithmetic. Add to qm_4d.py in Track B as partial_trace_channels(rho, keep) helper.
∇ as discrete operator — needed for probability current. The lattice gradient is the difference operator across each axis; on P_8 □ P_8 □ P_8 □ P_8 this is a stack of 4 sparse matrices (one per axis). Cheap to construct from tables_4d's per-axis path-graph adjacencies. Add as lattice_gradient_4d() helper.
Complex matrix serialization for the Pyodide bridge — ComplexMatrix and ComplexArray need a stable on-the-wire format. Recommendation: real+imag interleaved Float32 (matches the consumer's wishlist) with shape metadata. Add a tiny serializer in qm_4d/bridge.py (new file).

Track A ships with getQmState, getQmDensity (full only), measureAt, getQmExpectation. Track B fills in applyMoveQm, the per-piece variant of getQmDensity, getDensityMatrixOf, and getProbabilityCurrent. The bridge-surface goal for v1.5.0 is all seven shipping together.

17.2. chess-spectral 1.6 — engine submodule bridge surface¶

Three methods. All Python-side; the search loop runs at native speed inside Pyodide. The engine's transposition table, Zobrist hashing, killer-move tables, etc. are internals — the consumer does not see them. (The wish list explicitly noted: with the engine in Python, applyMoveQuiet and getZobristHash are not needed at the bridge.)

Method	Args	Returns	Purpose	Phase ships in
`getBestMove(opts)`	`{ team, maxDepth?, timeBudgetMs?, evalType?, weights? }`	`{ ok, move: {x0,y0,z0,w0,x1,y1,z1,w1}, score, depth, elapsedMs }`	Run a full Python-side search and return the best move. One bridge round-trip per move. `evalType` selects `material` / `spectral` / `qm`.	6.4 (search core) + 6.8 (CLI/bridge)
`evaluatePosition(opts)`	`{ team, evalType, weights? }`	`{ ok, score, breakdown? }`	Evaluate the current state without searching. `breakdown` (optional) returns per-channel or per-observable contributions for live position-strength readout.	6.⅙.2/6.3 (evaluators) + 6.8
`runTournament(opts)`	`{ pairs: [(stratA, stratB)], nGames, maxMovesPerGame? }`	`{ ok, results: [{ stratA, stratB, wins, losses, draws }] }`	Self-play tournament harness. The user-facing path for tuning channel-energy / QM-eval weights via match outcomes (per the §16.7 / §16.8 lessons that match outcomes, not eval correlations, carry the truth).	6.7 (tournament harness) + 6.8

Per the §16.7 finding ("test at multiple search depths"), getBestMove MUST allow maxDepth to be set to any depth in [1, ∞) and report elapsedMs accurately so the consumer can plot per-depth Elo curves directly from bridge results. The breakdown field on evaluatePosition is what the consumer's HUD displays for the M14 visualization — populating it is mandatory for the QM evaluator (per-observable contribution) and recommended for spectral (per-channel contribution).

17.3. Additional gameplay edge cases (extends §16.9)¶

The consumer flagged five additional gaps beyond §16.9's five. These ship in v1.4.0 alongside the §16.9 items:

Gap	Currently	Fix
Promotion choice (already in §16.9 #1)	`applyMove(origin, dest)` auto-promotes blindly	Add optional `promoteTo: 'queen'\\|'rook'\\|'bishop'\\|'knight'` arg with `'queen'` default for back-compat
Castling notation	Castling moves sent as king-move-2-squares; `chess4d` infers from king/rook positions; doesn't fail loudly if rook moved	Verify `chess4d` 0.4 handles this correctly. Add a regression test in M3.5 corpus exercising "king moves 2 squares but rook can't castle" boundary cases
En passant	Bridge has no special EP method; `chess4d` handles it as part of `applyMove`	Verify works correctly with our move-input format. Add EP-specific test in regression corpus
Threefold repetition (already in §16.9 #2)	Not tracked anywhere; UI never declares the draw	Implement + expose via `getDrawStatus()` (see below)
50-move-rule (already in §16.9 #3)	Not tracked anywhere	Implement + expose via `getDrawStatus()`
Insufficient-material draw (NEW)	Not tracked	Detect K-vs-K, K+B-vs-K, K+N-vs-K (4D analog requires deciding on insufficient-material classification — open design question; for v1.4.0 ship 2D version + raise `NotImplementedError` for 4D until decided)
Move history JSON (NEW)	M11.6 export builds it in JS from `MoveManager.moveHistory.toList()`; chess-spectral doesn't expose its own history	Add `getMoveHistory() → [Move4D, ...]` for symmetry; consumer can drop the JS-side hand-roll

Two new bridge methods consolidate the draw / history exposure:

Method	Args	Returns	Purpose	Ships in
`getDrawStatus()`	`()`	`{ ok, status: 'none'\\|'threefold'\\|'fifty-move'\\|'insufficient'\\|'stalemate' }`	Single call returns the active draw condition (or `'none'`). Consumer's UI uses this to declare draws cleanly without recomputing rules JS-side.	v1.4.0
`getMoveHistory()`	`()`	`{ ok, moves: [{from, to, promoteTo?, capturedPiece?, isCheck?, ...}, ...] }`	The full ply-by-ply history as the engine sees it. Lets the consumer's M11.6 export drop the JS-side hand-roll.	v1.4.0

17.4. Acceptance criteria for each version's bridge-surface ship¶

v1.4.0 ships when all of: applyMove(promoteTo=…), getDrawStatus(), getMoveHistory(), FEN4 serialize(), FEN4 round-trip test (parse(serialize(p)) == p), state-load entry point, threefold/50-move/insufficient-material detection, castling+EP regression tests pass. Plus all existing v1.3.2 tests still pass (immolation suite green).

v1.5.0 ships when all seven §17.1 methods are exposed via the Pyodide bridge, the QM-extension test suite passes (Track A's existing 43-test suite + Track B's full move-as-unitary tests), and the spectral-identity demo + bishop-wavefunction experiments still produce their machine-precision results. Plus all v1.4.0 tests still pass.

v1.6.0 ships when all three §17.2 methods are exposed, a per-depth Elo sweep across at least three representative depths (e.g., shallow / mid / deep) has been run for (material × spectral × QM) at 2D and 4D, and the §16.7 / §16.8 prior is empirically tested in the chess setting (i.e., the tournament results-notebook entry exists with per-depth deltas). Plus all v1.5.0 tests still pass.

The --help discipline guard (immolation-suite test added in Phase 6.9) gates v1.6.0 — every CLI subcommand argument must have non-empty help text. This is the test that catches "did we ship a feature without documenting it" before users find out.

17.5. Developer / debug bridge methods (round-2 wish list)¶

A second pass from the consumer surfaced six additional bridge methods. These are mostly cheap / mechanical and should ship across v1.4.0 and v1.6.0 as appropriate:

Method	Args	Returns	Purpose	Ships in
`getVersion()`	`()`	`{ ok, version: str }`	Dist version string. Trivial wrapper over `chess_spectral.__version__` (which already derives dynamically from `importlib.metadata` per the v1.3.2 contract). Useful for the consumer to verify worker version on startup.	v1.4.0
`getEncoderShape()`	`()`	`{ ok, channels: [{name, offset, dim}, ...], totalDim }`	Channel names + per-channel dims + total `45 056`. Lets the consumer's visualizer validate at startup that worker version matches the expected channel set (e.g., would catch a stale worker still on v1.0's 10-channel layout shipping against a v1.5+ HUD expecting 11). Trivial wrapper over `chess_spectral_4d.CHANNELS_4D`.	v1.4.0
`getFen4State()`	`()`	`{ ok, fen4: str }`	FEN4 string of the current worker state. Thin wrapper over `fen_4d.serialize(getCurrentPosition())` once §17.3 / 5b.5 ships `serialize()`.	v1.4.0
`loadFen4(fen4String)`	`str`	`{ ok }`	Re-import a FEN4 string into the worker's working state. Already in §17.3 / 5b.6 plan; this entry just makes the bridge name explicit.	v1.4.0
`loadJsonlFixture(piecesObj)`	`dict`	`{ ok }`	Alternative to `loadFen4`: load from the in-memory `pieces` dict format used in `tests/fixtures/positions_4d.jsonl`. Shorter round-trip when the consumer already has the structured form.	v1.4.0
`hasLegalMoves(team)`	`'white' \\| 'black'`	`{ ok, hasMoves: bool, count?: int }`	Boolean: does the team have any legal move? Required for stalemate detection in `getDrawStatus()` (no legal moves + not in check ⇒ stalemate). Replaces `gameBoard.hasLegalMoves(team)` in the consumer's JS, which currently iterates pieces synchronously. Implementation: iterate pieces of `team`, sum cardinalities of `occupation_aware_moves_a_4d` until any non-empty. Optional `count` field returns the actual move count for live HUD display.	v1.4.0
`listAvailableEvalTypes()`	`()`	`{ ok, types: ['material', 'spectral', 'qm', ...] }`	Once the engine ships, lets the consumer's UI populate the eval-type dropdown dynamically without hardcoding strings. Returns the set the engine actually supports at this version (forward-compatible: new evaluators in v1.7+ become discoverable).	v1.6.0

Important consequence for Phase 5b: hasLegalMoves(team) is now a v1.4.0 deliverable, not deferred. This means getDrawStatus() can return 'stalemate' as a real value at v1.4.0 instead of NotImplementedError for stalemate (the running Phase 5b agent's prompt allowed for the deferred case; if it shipped that way, a follow-up PR adds hasLegalMoves and removes the deferral). Ordering: implement hasLegalMoves(team) first, then getDrawStatus() consumes it. The legal-move iterator already exists conceptually in phase_operators_4d.occupation_aware_moves_a_4d; the bridge wrapper is just an iteration over team pieces.

17.6. Out of scope for chess-spectral (consumer-side concerns)¶

These were on the consumer's wish list but are explicitly not chess-spectral's responsibility. Recording here so the boundary is unambiguous:

Item	Whose problem	Why not chess-spectral
`localStorage` autosave / refresh-survival of game state	chess4D-OC consumer	Browser persistence is a UI / session concern. chess-spectral's job is to provide `getFen4State()` / `loadFen4(...)` so the consumer CAN persist; the act of persisting is a consumer choice.
`selectPiece()` async migration in `js/main.js`	chess4D-OC consumer (M4b.1 PR)	JS-side architecture migration to await bridge calls instead of using sync `Piece.getPossibleMoves`. The chess-spectral side just needs to expose `legalMoves` / `hasLegalMoves` cleanly (which §17.5 does).
`filterIllegalMoves()` async migration	chess4D-OC consumer (M4b.1 PR)	Same — chess-spectral exposes legal-move query; consumer rewrites the filter loop to use it.
`Bot.js` migration to thin bridge-wrapper	chess4D-OC consumer (M13+)	Until the v1.6.0 engine ships, `Bot.js` keeps using local `Piece.getPossibleMoves` synchronously. After v1.6, `Bot.js` becomes a thin wrapper around `getBestMove`. The migration is a consumer-side refactor, not a chess-spectral feature.

The line is bright: chess-spectral exposes capabilities; chess4D-OC chooses how to use them. Anything UI-flavored, persistence-flavored, or consumer-architecture-flavored stays consumer-side.

18. Phase 3.5 Probe Results: Empirical Validation of Track B ADRs¶

Date: 2026-04-29. Authoritative results doc: chess-spectral/docs/adr/qm_4d/PHASE_3_5_PROBE_RESULTS.md. Probe scripts: chess-spectral/python/research/track_b_*_probe.py (4 files). All probes run deterministically in ~50s and produce reproducible JSON / MD outputs.

After the 5 Track B ADRs landed in PR #74, we ran four prototype probes against the kinematic qm_4d substrate to empirically validate each ADR's gate before Phase 4 implementation begins. Three probes returned amendments, two passed clean. The probe-results doc is now the authoritative source for Phase 4's design surface; the original ADRs are preserved as the design record at the time of decision.

18.1. Per-probe findings, ranked by significance¶

Probe 4 (ADR-004 Z_2 superselection / U_move parity) — FAIL by 30 orders of magnitude. Anti-commutator residual ‖U_move · J_op + J_op · U_move‖ measured at p95 ≈ 128 vs the 1e-10 acceptance gate. The diagnosis: {J_op, U_move} = 0 is mathematically impossible for the swap-permutation construction in ADR-001 / ADR-003 — for non-J-symmetric moves (essentially all real moves), the swap matrix and central-inversion don't commute or anti-commute as algebraic operators on ℂ^4096. The Z_2 sector flip happens at the state-vector layer, not the operator-algebra layer. Resolution: weaken ADR-004 §3.4 — the parity sector change is mediated by state_to_psi's side-to-move sign multiplier (per Pre-flight 1's Z_2 superselection finding), and the per-channel Π_c and U_move are not required to formally anti-commute with J_op. Documentation/design clarification with no architectural change. Phase 4 B4's test suite must verify state-level parity, not operator-level anti-commutation.

Probe 2 (ADR-003 linearization quality) — FAIL on FIB by 50–500×. ε p95 measured at 5.6 / 6.8 / 46.8 for FIB_SYM_1 / 2 / 3 vs the 0.10 gate. Root cause: the occupancy-change term (origin's contrib_k disappears, destination's appears) is structurally non-linear in delta_sig; no Jacobian J_c can capture it because the perturbation isn't infinitesimal in the right space. The linearization model assumes δψ = J_c · δposition, but the true map is piecewise with a non-smooth boundary at every move. Resolution: ship FIB channels under ADR-003 §3.3's measurement-only re-encode fallback in v1.5 — apply the move classically, re-encode the post-move position, project channel-wise. This is honest within the QM formalism (a measurement-then-evolution sequence) and matches the ADR's documented fallback. The "best-effort linearization" path is closed for FIB channels in v1.5; revisit in v1.7+ if a linearization-friendly reformulation surfaces. FD_DIAG (cond p95 = 8.6 vs 100 gate) ✅ ships as designed.

Probe 3 (ADR-005 pawn pseudo-Hermiticity) — PARTIAL PASS. M_pawn is nilpotent (full spectrum is zero — pawn pushes terminate at the boundary), so PT-realness |Im(spec)| ≤ 1e-10 is trivially satisfied. The pseudo-Hermiticity gate M^T = P_w · M · P_w⁻¹ holds exactly (residual 0) for the single-push variant, but fails for the full operator including double-push (residual 32.0). The duality P_w · M_white · P_w = M_black is exact in all variants — strongest structural identity in the pawn algebra. Resolution: decompose M_pawn_w_white = M_single_push + M_double_push; apply η-metric only to M_single_push (which is strictly P_w-pseudo-Hermitian). Treat M_double_push as a separate non-pseudo-Hermitian rank-deficient operator outside the QM framework. v1.5's Hermitian-part projection (H_pawn_*_herm = (M + M^T)/2) ships unchanged; v1.6+ promotion path remains open with the decomposition correction documented.

Probe 1 (ADR-001 phase distinguishability) — PASS at 100%. All 9,500 (move_A, move_B) inner-product overlaps below the 0.99 distinguishability threshold; 73.6% below the strong-distinguishability threshold of 0.50. The Aaronson escape valve is empirically open: channel-distinct phases produce real interference, not notational restatement of classical permutations. Ship as-is.

18.2. What this means for the QM extension's claim of "real quantum content"¶

Probe 1's 73.6% strong-distinguishability rate is the empirical answer to the methodological worry from §15.6 and §16.7's Aaronson-critique discussion. A QM-rebrand of classical lattice data CAN be tested: if it produces interference patterns that classical permutations don't, it carries genuine quantum content. The Phase 1 spectral-identity result + the Phase 3.5 phase-distinguishability result together establish that chess-spectral's QM extension is more than notation — the channels are an irreducibly quantum decomposition (irrep-typed eigenbasis of (Δ, B_4 commutant) per Pre-flight 3) AND moves act as channel-distinguishable unitaries (Probe 1).

This does not, on its own, make the QM extension useful outside chess. Per §15's honest scope ("modest niche, useful infrastructure"), the value is in the toolkit, not the metaphysics. But it does close the door on the strongest version of the Aaronson critique: at minimum, our channel-as-PVM measurements distinguish moves, which is more than a basis-aligned PVM on basis-aligned states could ever do.

18.3. ADR amendment summary¶

ADR	Original status	Phase 3.5 outcome	Amendment
001	Proposed	✅ PASS	None — accepted as written
002	Proposed	✅ PASS (no probe needed)	None — accepted as written
003	Proposed	⚠️ FIB FAIL, FD_DIAG PASS	FIB channels switch to measurement-only re-encode (§3.3 fallback path) for v1.5
004	Proposed	⚠️ FAIL by 30 orders	§3.4 weakened to sector-flip-via-state_to_psi; no operator-anti-commutation requirement
005	Proposed	⚠️ PARTIAL	Decompose M_pawn = M_single + M_double; η-metric on single-push only; v1.5 Hermitian-projection unchanged

18.4. Phase 4 readiness post-amendments¶

Milestone	Status	Notes
B1 A_1 channel move-as-permutation	✅ Unblocked	Ships against ADR-001 (✅) + ADR-003 (✅ for strict channels)
B2 Zeno-style evolution + H_0	✅ Unblocked	ADR-002 (✅) — no probe; not gated
B3a strict A_1 + STD4 channels	✅ Unblocked	With ADR-004 §3.4 caveat — no anti-commutation tests
B3b pawn-antisym channels	✅ Unblocked	Same caveat
B3c FIB_SYM ½/3	⚠️ Revised path	Measurement-only re-encode in v1.5 (per ADR-003 §3.3 fallback)
B3d/e FD_DIAG	✅ Unblocked	Rank-1 update path validated
B4 Z_2 grading + tests	⚠️ Revised	§3.4 amendment must propagate to test design
B5 pawn observables	⚠️ Revised	v1.5 Hermitian-projection unchanged; v1.6+ uses M_single / M_double decomposition

Net assessment: all 5 milestones are unblocked in the sense that none requires a redesign. Three need documentation amendments (now landed in PHASE_3_5_PROBE_RESULTS.md) and corresponding test-design adjustments. Phase 4 implementation can begin immediately on B1.

19. Multi-Sheeted Riemann Encoding for Non-Markovian Rules (Spike — May 2026)¶

Date: 2026-05-03. Status: Research spike — investigation complete, no implementation committed. Companion spike: §20 (BSHDC). Framing source: Steven, 2026-05-03: "we will reach a structural limit of our current static laplacian propagator, at some point, and can then begin find where our shape might be fixed but doesn't need to be, where more data might live." This section addresses the second clause — where more data might live — by mapping the small set of chess facts the static graph-Laplacian propagator structurally cannot reach, and asking whether they want to live as additional sheets of a covering space over the existing 640-dim / 45056-dim base.

19.1. The structural limit the propagator hits¶

The 640-dim 2D encoder and 45056-dim 4D encoder both compute their channels from a position-only observable: piece-occupancy vectors fed through D₄- (2D) or B₄- (4D) irrep projectors of a static graph Laplacian. Every dimension of the encoded vector is a function of the current board, full stop. This is exactly the modeling assumption that makes the spectral-fiber-bundle apparatus of §3-§11 work: the Hilbert space is ℂ^{|V|}, and pieces are perturbations of a single time-independent base operator.

Chess, as a game, has four facts that are not functions of the current board:

Castling rights (4 bits per side: K-side / Q-side × white / black). Once a king or its rooks move, the relevant bit is lost forever; the position can return to its pre-move arrangement (rare but legal under the placement-only FEN), and the right does not return with it.
En-passant target square (5 bits: file 0-7 + a "no EP" sentinel, or 0-63 if encoded by square). Set on the half-move after a double-push pawn move, cleared on the half-move after that. Strictly history-of-length-1.
Half-move clock (7 bits, range 0-100, modular under the 50-move rule). Increments every quiet ply, resets on captures and pawn moves.
Threefold-repetition state (effectively unbounded — the entire game-history trace, since any position seen twice before in this game now triggers a draw claim).

These four are the non-Markovian residue of chess: state that lives in the game's history rather than its position. The static Laplacian cannot see any of them. The encoder's current behavior is to silently project them out (FEN4 v1 is placement-only by design — see FEN4_FORMAT.md — and 2D FEN parses but ignores the trailing fields when handed to encode_640). For position-similarity work this is fine; for rule-correct move generation and for any downstream search engine (§16) it is not.

19.2. The Riemann-sheet metaphor and what it actually buys¶

A multi-sheeted Riemann surface, in the complex-analysis sense, is a covering space π: \tilde{X} → X where the same point of the base X corresponds to multiple distinct points of \tilde{X}, distinguished by branch data (which sheet you're on). Functions that are multi-valued on X become single-valued on \tilde{X}. The standard examples — √z, log z, the modular j-function — all use sheet-identity to carry information that the base coordinate alone does not determine.

Applied to chess: the 64-square board (2D) or 4096-cell hypercube (4D) is the base; the encoder's vector space is a function on the base; the non-Markovian state is the branch data. A position with white-K-side castling rights and the same position without those rights are two distinct points of \tilde{X} that project to the same point of X. The encoder needs to be a function on \tilde{X}, not on X, to be able to distinguish them.

This is conceptually clean. The implementation question is: how many sheets do we actually need, and what does the sheet-coordinate look like as a thing the encoder can consume?

19.3. Sheet-cardinality budget¶

Worst-case naive sheet count is the product of all four factors' state spaces:

Fact	State space	Bits
Castling rights	2⁴ = 16	4
EP target	9 (file 0-7 ∪ none)	4
Half-move clock	101 (0-100)	7
Repetition state	bounded by game length, ≤ ~5900 plies in adjudicated play	≥ 13

Total cartesian product: 16 × 9 × 101 × ≥8192 ≈ ≥120 million sheets, dominated by repetition. This is unworkable as direct sheet enumeration, and naive concatenation [base_vector ‖ sheet_id] gives the encoder no useful gradient information about which non-Markovian facts matter for which downstream task.

The structural observation is that the four facts decompose by algebraic type, not by joint cardinality:

Castling rights, EP target, repetition-saw-this-position: one-shot binary or low-cardinality categorical. XOR-lite. A 4-bit castling vector and a 64-bit "have I seen this position before" Bloom-style sketch both compose under XOR with the natural "now I have lost this right" / "now I have seen this position one more time" updates. They want bit-resonant carriers — see §20 for the natural encoding family.
Half-move clock: integer in Z_{101}, with the absorbing boundary at 100. Exactly the kind of bounded cyclic group that already has a clean spectral representation in this notebook's basis: a Z_{101} Fourier mode over the half-move counter is a single complex unit-magnitude carrier that the channel-energy machinery of §9 already knows how to consume. Z_n-spectral.

This decomposition collapses the 120M-sheet count to two structural strata:

Stratum	Facts	Bits / dims needed	Carrier shape
XOR-lite sheet	Castling (4 bits), EP target (4 bits), repetition-flag (1 bit, plus optional 2-bit count)	9-11 bits	Bit-vector with XOR update; suitable for direct concatenation as an aux block
Z_n-spectral sheet	Half-move clock	1 complex carrier (2 real dims)	`exp(2πi · halfmove / 101)` as a unit-modulus eigenmode

Three of the four non-Markovian facts are pure-XOR-lite at the bit level. The fourth is naturally a Z_{101} spectral mode. Total aux dimensionality recommended for Phase 1 minimal sheet: 11 dimensions (9 bits XOR + 2 dims Z_{101} Fourier). Direct concatenation against the existing 640 / 45056-dim base is sufficient.

19.4. XOR-lite vs Z_n-spectral: why the split is structural, not aesthetic¶

The split is forced by the update law of each fact:

Castling rights are destroyed, never created. The update law on the 4-bit vector is bits ← bits AND mask(move) where mask zeros bits whose precondition the move broke. This is a monotone-decreasing operator under XOR composition — i.e., bits XOR mask_complement = bits OR mask_complement_complement = ... — which fits an XOR-stream wire format directly and is exactly the structure mode 2 of v5 frame format was designed for.
EP target has period 1: it's set on ply N after a double-push and cleared on ply N+1 unconditionally. This is a transient bit pattern, not a state with memory. XOR with a "decay-after-one-ply" overlay schedule trivially captures it.
Repetition flag / count is monotone-increasing as the game progresses, but only a counter — and the relevant claim threshold is 3, so 2 bits suffice. Update law: count ← count + 1 if position_seen_before else 0. XOR-update over a 2-bit counter is standard.
Half-move clock is fundamentally different: it's an integer that increments smoothly, gets reset by certain move classes, and has a ceiling at 100. It is not a sparse bit pattern — it is a dense integer in [0, 100]. Embedding it as 7 bits and XOR-composing them gives the encoder a representation that violates the Hamming-distance-vs-clock-distance principle (clock 50 vs clock 51 differ in at most 1 bit; clock 31 vs clock 32 differ in 6 bits). Encoding as a Z_{101} Fourier mode preserves continuity: clock distance ≈ Euclidean distance in the 2-D (cos(2πk/101), sin(2πk/101)) plane.

This is the same structural distinction §9m makes between the pawn antisymmetric channel (carrier of a non-reversible-Markov-chain T-violation) and the symmetric channels (reversible). The XOR-lite facts are bit-resonant (orbits in (Z_2)^k under XOR); the half-move clock is continuous-resonant (orbits on a circle under +1 mod 101). The encoder's apparatus already has both kinds of carriers. The sheet construction reuses them.

19.5. Encoder integration hooks¶

Two implementation paths, corresponding to where the sheet block lives:

Path A — direct concatenation aux block (recommended for Phase 1). Append 11 dimensions to the encoder output: encode_640(pos) → ℝ^640 ⊕ ℝ^11 = ℝ^651; same for 4D. The 11 aux dims are populated as: - aux[0:4] ∈ {0, 1}⁴ — castling bits, signed embedding - aux[4:8] ∈ {0, 1}⁴ — EP file indicator, one-hot or signed - aux[8:9] ∈ {0, 1} — repetition-flag (or {0, 1, 2} count, scaled) - aux[9:11] = (cos(2π · halfmove / 101), sin(2π · halfmove / 101)) — Z_{101} carrier

The cosine-similarity comparator on the concatenated vector still works; channel-projector observables for the existing 11 channels (4D) / 10 channels (2D) are unaffected; new channel projectors Π_{castling}, Π_{EP}, Π_{repetition}, Π_{halfmove} are trivially defined.

Path B — sheet-projector basis change (deferred, post-Phase-1). Instead of concatenation, treat the sheet as an ℝ^11 factor of a tensor product ℝ^{640} ⊗ ℝ^{11} = ℝ^{7040} (2D) / ℝ^{45056} ⊗ ℝ^{11} = ℝ^{495,616} (4D). This is mathematically cleaner — the sheet block has its own irrep structure under the symmetry group acting on it (castling has a Z_2 × Z_2 × Z_2 × Z_2 symmetry, the half-move clock has a Z_{101} cyclic symmetry, etc.) — but expensive in memory and only worth it if downstream tasks care about per-sheet-projection finestructure that the concat block can't express.

Path A is sufficient for Phase 6 search-engine integration (§16): the search needs to distinguish two positions with different castling rights, not necessarily to interpolate between them in a representation-theoretic way. A concatenation aux block does the distinguishing job at minimal cost.

19.6. Connection to the v5 wire format and XOR-stream mode 2¶

The v5 wire format (cs_bb4_xor_stream, mode 2 in frame_v5.py) was originally introduced for delta-encoding successive positions in a game stream — XOR the bitboard of position N+1 against position N, transmit only the diffs. The same mode is the natural carrier for the XOR-lite sheet bits: the 9 bits of aux[0:9] are exactly the kind of small bit-vector mode 2 was designed to compress, and the update law (XOR with a mask derived from the move) is mode 2's native operation.

This is not an accidental match. The v5 format was designed by recognizing that the position of a chess game is mostly XOR-stable across moves (a typical move flips ~6 bits in the 256-bit bitboard); the non-Markovian residue is also XOR-stable across moves (castling rights flip at most 2 bits per move; EP flips at most 8 bits per ply pair; repetition increments by 0 or 1). Both live in the same algebraic stratum. The sheet block extends the wire format's reach without adding a new format layer.

Implementation hook: the sheet-block bits ride alongside the existing XOR-stream payload as a leading 9-bit prefix, with the half-move clock encoded separately as its 2-D Fourier carrier (which mode 2 does not handle directly — Z_{101} is not (Z_2)^k). The Fourier carrier piggybacks on whichever mode handles the floating-point channel coefficients.

19.7. Phasing recommendation¶

Phase	Scope	Acceptance	Estimated effort
S-spike-1	Add `aux[0:11]` block to `encode_640` and `encode_4d`, behind feature flag `--with-sheets`; channels still computed identically; concat at the end. Verify cosine-sim on 1k positions with vs without flag agrees on the first 640/45056 dims.	All sheet-bits round-trip from FEN through encoder and back. Channel energies of the existing 10/11 channels unchanged.	200-400 LOC + 100 LOC tests
S-spike-2	Wire mode-2 XOR-stream support for the 9-bit XOR-lite block in v5; document the half-move clock's `Z_{101}` carrier as a separate sub-format.	Encode-decode round-trip stable across PGN of typical games.	100-200 LOC + 100 LOC tests
S-spike-3	Pre-search adapter for §16's search engine: when the evaluator is `spectral` or `qm`, weight the sheet channels alongside the existing channel weights.	Tournament A vs B at depth 4: A = `spectral` w/o sheets, B = `spectral` w/ sheets. Hypothesis: B holds even or wins on positions where castling-rights / repetition-state / halfmove-clock matter (endgames with repetition draws available; middlegames where castling option is alive).	50 LOC eval + tournament harness already in §16

S-spike-1 is independent of Phase 4 (QM dynamics) and can ship in v1.9 alongside any current track. S-spike-2 is a wire-format extension and requires bumping the v5 minor (to v5.1) — non-breaking on the read side because mode 2 already carries enough metadata to negotiate sub-format. S-spike-3 is gated behind §16 (Phase 6).

19.8. What this spike does NOT do¶

Does not change ADR-001 / -003 / -004 / -005. The non-Markovian sheet block is orthogonal to the QM extension's phase-operator and pseudo-Hermitian-pawn machinery. The sheet block adds aux dimensions; the QM extension acts on the existing 640/45056 dims.
Does not address Markov-correspondence (§42.8) for non-reversible chains. §42.8 catalogs the per-piece-Laplacian-as-Markov-generator identity at the reversible / non-reversible axis — pawn antisymmetric is already non-reversible. Adding non-Markovian sheets is a separate generalization (the chain becomes non-Markov-of-order-1, requiring augmented state). Both are valid extensions; this spike addresses only the latter.
Does not commit to Path B (tensor product). Path A (concatenation) is sufficient for everything Phase 6 needs and is the recommended Phase 1 implementation. Path B remains open as a Phase 2+ option if downstream tasks demand per-sheet-channel-projection interpretability.
Does not solve threefold repetition's unbounded history. The 1-bit repetition flag is sufficient to trigger a draw claim's availability, but tracking the position-by-position history that produces the flag is the search engine's job, not the encoder's. The encoder consumes a flag derived externally; the encoder does not maintain the history.
Does not commit to S-spike implementation. This spike's purpose is to capture the analysis. Whether to ship S-spike-1 in v1.9 is a Phase 6 / Phase 7 product decision, not a notebook decision.

19.9. Implementation update — S-spike-1 shipped in v1.9.0 as representation-only¶

Date: 2026-05-04.

S-spike-1 (the Phase 1 minimal sheet block) shipped in chess-spectral 1.9.0. Implementation surface as designed: 11-dim aux block, opt-in via encode_640(pos, sheets=...) / encode_4d(pos4, sheets=...), Path A direct concatenation. The 4D ship populates only the halfmove / side-to-move / repetition slots — castling and EP slots are zero by construction, since 4D-OC has neither in its ruleset (per chess_spectral.spatial_4d.board.py header). 28 immolation tests in test_sheets_aux_block.py lock the round-trip + encoder integration; the C-parity tests pass unchanged because the default encoder behavior is bit-for-bit identical to pre-1.9.0.

What did NOT ship in 1.9.0: the sheet-aware fast-path for available_castles (the proposed S-spike-3 evaluator hook), and the empirical-speedup benchmark harness. §19.10 below explains why.

19.10. Empirical bound: the depth-1 bitboard floor closes the speed thesis¶

Date: 2026-05-04. Conclusion: sheet blocks ship as a representation feature, not a speed feature.

The §19 design originally floated S-spike-3 as a Phase 6 search-engine integration that would weight the sheet channels alongside the existing channel-energy weights — implicitly inviting a "does the sheet block speed up move-operator queries?" question. During 1.9.0 implementation prep, that question received its empirical answer before the benchmark was written.

The depth-1 floor. For a single-position query, the cost-relevant operations are:

Operator	Existing fast path (per call)	Sheet-block alternative
`board.has_castling_rights(WHITE)` (python-chess)	one `int & mask`, ~50 ns	float-numpy slice + `>= 0.5`, > 50 ns
`board.ep_square is not None` (python-chess)	attribute load, ~30 ns	`aux[4] >= 0.5`, similar
`board.halfmove_clock` (python-chess)	int attribute load	`decode_halfmove_clock(vec)` involves `atan2` + `round`
`Board4D._halfmove_clock >= 100` (4D native)	one int comparison	same as above
`state.history.repetition_count(state.position)` (4D)	hash-table lookup	int aux-slot read; comparable per call
`available_castles(board)` (chess-spectral phase-op)	up to 12 python-chess calls in the no-rights case	4 aux-slot reads → early-exit

For all but the last row, the sheet block can match but cannot beat the bitboard / int-attribute floor. For available_castles, the sheet block CAN win in the no-rights case (avoiding ~1 µs of Python-call overhead per call across 12 python-chess interactions) — but python-chess already short-circuits internally on has_castling_rights before doing any attack-map work, so the win is bounded by the Python-call overhead of our own wrapper, not by genuine algorithmic savings. At depth 1, this is a small constant-factor effect that does not justify shipping a parallel "sheet-aware" code path with its own correctness contract and test surface.

Where the sheet block's value DOES live. The representation-completeness argument from §19.2 / §19.5 / §19.6 is intact: sheet blocks make encoder vectors self-sufficient for downstream consumers of saved or transmitted vectors, where reconstructing a python-chess Board or a GameState4D from the underlying FEN / FEN4 to query non-Markov state is the expensive operation. Specifically:

Saved-corpus retrieval. A precomputed corpus of N encoded vectors stored in HDF5 / on-disk numpy arrays. To filter to "positions where any castling right is alive" without sheet blocks, the consumer must reparse N FENs into Board objects — Python-loop per position. With sheet blocks, the same query is a vectorized vecs[:, 640:644].any(axis=1) over the in-memory array, ~3 orders of magnitude faster at scale.
Pyodide / browser environments. Pyodide's single-process WASM runtime cannot subprocess to native binaries and pays per-call overhead on every Python-level function. Maintaining a parallel python-chess.Board object alongside encoder vectors doubles memory and serialization cost for chess4D-OC's downstream visualizer paths. Sheet blocks cut this to zero — the encoder vector carries everything the consumer needs.
Transmission contracts. Wire formats that ship encoder vectors over a network (the v5 frame format with XOR-stream mode 2, prospectively the .spectralz4 format for 4D corpora) currently lose castling / EP / halfmove / repetition state at the format boundary. Adding sheet blocks closes that hole at no cost to the existing channel-energy / cosine-similarity contract.

The "we won't beat bitboards at depth 1" lemma. Source: Steven, 2026-05-04, on the 1.9.0 prep thread. Generalizes to: for any operator whose existing implementation is a single-int comparison or hash-table lookup, a float-numpy-slice-plus-decode alternative cannot undercut it at single-call latency. The alternative is at best comparable, more typically slightly slower, because numpy slicing has interpreter overhead per call that competes against pure-C int operations. This lemma applies uniformly across castling rights, EP target, halfmove threshold check, and repetition lookup. It does NOT apply to batched / vectorized operations across many positions, where numpy SIMD over a stack of stored vectors crushes per-position Python — that's the regime where sheet blocks earn their CHANGELOG entry. 1.9.0 ships the representation feature; the batched-retrieval case study lives in downstream consumer projects (chess4D-OC; future chess-spectral query corpus filters).

What this means for the §19 phasing table. S-spike-1 shipped (1.9.0). S-spike-2 (wire format integration) is deferred until a downstream consumer needs it — most likely the v5.1 mode-2 extension when chess4D-OC adopts it. S-spike-3 (search-engine integration with sheet weights) is closed as not-recommended: the sheet channels carry categorical information (rights are alive or dead), and the search evaluator's per-channel-energy weighting is continuous — they're not the same kind of object, and forcing one into the other would lose information without clear benefit. If a future search-engine evaluator wants castling-aware scoring, the natural move is a separate eval=spectral+sheets evaluator family (§16.1 already names the pattern), not a weighted-channel hook into the existing eval=spectral path. That's a Phase 7+ design question.

19.11. Future work — encoder dim count is not a stable contract; rename `encode_640` → `encode_2d`¶

Date: 2026-05-04. Status: Future-work note, not a roadmap commitment. Prompted by the §19 sheet block landing, which itself is the first concrete example of why the dim count of the 2D encoder is not stable across versions.

The 2D encoder's primary entry point is currently named encode_640, where 640 = 10 channels × 64 board cells (D₄ irrep × DCT-mode product). The function name pins downstream consumers to the assumption that the output dim is and will remain 640. That assumption is at minimum already wrong with sheets (640 → 651 when sheets= is supplied), and is likely to weaken further as the encoder evolves:

Sheet block enrichment beyond Phase 1. §19.4 splits the 11-dim Phase 1 sheet into "XOR-lite" (9 dims) and "Z₁₀₁ Fourier" (2 dims) carriers. A Phase 2 / Phase 3 sheet might add channels for non-Markovian state we haven't modeled yet — e.g., en-route promotion bookkeeping, Chess960 castling-rook-positions for Fischer Random support, draw-by-agreement protocol state, or any of the variants from the Oana-Chiru §3.6-§3.11 ruleset-preserving subgroup. Each of those changes the aux-block dim count and thus the total output dim.
Channel embiggening. The §1 / §3 / §11 spectral analysis is not committed to 10 channels. The current 10 = 5 D₄ irreps + 3 symmetric fiber + 1 antisymmetric (pawn) + 1 diagonal (rook shadow). Future work might add: ψ-driven QM density / current channels (deferred Tier 2.1, §17.1), per-piece partial-trace density-matrix channels (Tier 2.2, §17.1), or channels derived from the bit-serialized HDC representation (§20). Each of those would increase the channel count and thus the per-channel-times-board-dim product.
Bit-serialized enrichment. The §20 BSHDC spike found, via the antikythera-spectral / DE441 reference, that bit-serialization is not necessarily lossy after a basis change — it can ENRICH the data set by exposing structure that was hidden in the float32 magnitudes. (DE441: 3.3 GB raw → 1 MB physics → 256 KB bit-serialized, with >300× speedup AND ~0.01% precision loss across random sweeps.) It is uncertain whether that enrichment translates to a discrete board game with non-Markovian state, but the §19 sheet block is itself a concrete instance of "the encoder needed to grow to capture structure that wasn't in the previous shape." The §20 spike's B-spike-1 (4-bit nibble side-car) would change the per-vector storage from 640 × 4 bytes = 2.56 KB to 640 × 0.5 bytes = 320 bytes — a 8× reduction at the byte-count level, but the structural unit is still "10 channels × 64 cells" — until it isn't, because some future basis change might pack channels differently in bit-serialized form than in float32 form.

The takeaway for downstream API users: the dim count is not a stable contract. Consumers must:

Query chess_spectral.ENCODING_DIM (or check enc.shape[0]) at call time rather than hardcoding 640.
Iterate channels via chess_spectral.CHANNELS rather than slicing fixed 64-dim windows. The CHANNELS list is the source of truth for the channel layout; channel boundaries and counts may both change.
Use encode_2d(pos, ...) (1.9.0+) rather than encode_640(pos, ...). Both names map to the same function in 1.9.0 and the legacy name will remain as a permanent alias, but new consumer code should adopt the version-stable name. The encode_2d name mirrors the 4D path's encode_4d and survives any future channel/dim changes in a way the size-pinned name cannot.

This decoupling work is intentionally not scheduled — there is no roadmap commitment to actually change the channel layout or grow the dim count. The recommendation is purely about API stability against future change: if and when the encoder's shape moves, the consumer code that adopted the version-stable patterns above will not break.

A symmetric note for encode_4d: the name already factors out dim-pinning (4d is the dimensionality of the lattice, not the output dim), so no rename is recommended on that side. The 45 056-dim 4D output IS pinned to "11 channels × 4096 modes" by the same coupling caveat — chess_spectral_4d.ENCODING_DIM_4D and the corresponding CHANNELS_4D list are the queries that survive any future change. (Note the ENCODING_DIM_4D constant, 45056, has the same dim-shifted-on-sheet-add behavior: with sheets= it grows to 45067. Consumers should read the array's shape, not the constant.)

19.12. Sheets and the v5 wire format — deferred by design¶

Date: 2026-05-04. Status: Implementation decision recorded for chess-spectral 1.9.1 ship. The 1.9.0 sheet block (§19.9) lives only in memory; the v5 wire format does NOT carry the 11-dim aux block. v5 frames store the base encoding_dim floats per ply (640 for 2D, 45056 for 4D), without sheet data.

This is a deliberate split between in-memory and on-disk representations, not an oversight. The reasoning:

The existing corpus pattern preserves source. corpus.py and corpus-gen store the original PGN / NDJSON alongside the .spectralz in a corpus folder layout. The source game record carries castling rights, EP target, halfmove clock, and full move history natively — a full FEN includes all the non-Markov state, and a PGN preserves the entire game's evolution of that state ply by ply. Consumers needing sheet state at read time can re-derive it from the source via SheetState.from_chess_board(chess.Board(fen)) for any ply, with bit-exact agreement to what encode_2d(pos, sheets=...) would have produced at encode time.
Sheets are an in-memory representation feature, not a transmission feature. §19 framed sheets as completeness-for-saved-vectors — but "saved" there refers to the consumer's own storage layer (HDF5, pickle, in-process caches), not specifically .spectralz files. Different storage layers have different cost / convenience tradeoffs; the wire format's job is to ship the spectral payload, and the consumer's job is to ship whatever sidecar metadata they need alongside.
No downstream consumer currently needs persisted sheet frames. chess4D-OC consumes sheets in-memory via chess_spectral_4d.bridge.get_sheet_state / encode_sheet_aux / decode_sheet_aux_from_vector. The corpus pipeline doesn't need sheets in the spectral payload because the source game record is already preserved. Designing a wire-format extension before there's a real consumer would over-fit the design — the §19 future-work table (§19.7's S-spike-2) already noted this is "deferred until a downstream consumer needs it."
The path forward is open, not closed. v5's 256-byte header has 223 reserved bytes. The natural extension when persistent sheet frames are needed:
Add aux_dim (uint8) — number of aux dims, 0 = no sheet block
Add aux_offset (uint32) — byte offset of the aux block in the frame body
Older v5 readers see aux_dim=0 and continue to read encoding_dim floats per frame
New readers with aux_dim>0 read the additional dims at the documented offset This is a backward-compatible extension that doesn't disturb existing files.

The two encode paths diverge intentionally. A 1.9.1+ consumer's choice:

Path	API	Output	Best for
In-memory representation	`encode_2d(pos, sheets=...)`	651-dim ndarray	Pyodide / chess4D-OC; downstream consumers wanting self-sufficient vectors; cosine-similarity search where the full 11 aux dims are part of the comparison
On-disk transmission	`encode_2d(pos)` (no `sheets=`) → `write_v5_*`	`.spectralz` with 640 floats per ply, no aux	Long-term storage; corpus folders; any pipeline where the source PGN / FEN is preserved alongside

For the rare case where a consumer wants both — encode WITH sheets AND persist — the recommendation in 1.9.1 is to ship the aux blocks as a sidecar JSON file alongside the .spectralz. When that pattern starts to feel forced (i.e., when many consumers want the same thing), the wire format extension above lands cleanly.

20. Bit-Serialized Hyperdimensional Computing as a Resonant Object (Spike — May 2026)¶

Date: 2026-05-03. Status: Research spike — investigation complete, no implementation committed. Companion spike: §19 (sheets). Framing source: Steven, 2026-05-03: "we will reach a structural limit of our current static laplacian propagator, at some point, and can then begin find where our shape might be fixed but doesn't need to be." This section addresses the first clause — where the shape is fixed but doesn't need to be — by asking whether the float32 magnitudes of the 640/45056-dim encoder are load-bearing or merely incidental, and whether a bit-serialized representation preserves the apparatus while collapsing the runtime cost.

20.1. The reference data point: antikythera-spectral on DE441¶

The antikythera-spectral pipeline took NASA/JPL's DE441 ephemeris dataset — the canonical solar-system ephemeris, 3.3 GB of fitted Chebyshev coefficients over a multi-millennium time window — and reformulated it through a spectral-physics decomposition: orbital elements as commensurable-frequency basis (the Antikythera mechanism's actual gear-ratio ontology), each celestial body's contribution expressed as a sum over a small set of resonant modes.

Three successive size collapses:

Stage	Representation	Size	Notes
Raw DE441	Per-body Chebyshev polynomials over time	3.3 GB	Production ephemeris format
Spectral physics	Commensurable-frequency mode amplitudes (float32)	1 MB	~3000× reduction; resonant-orbit-basis change
Bit-serialized	Phase-orbit indices (sign-bit / few-bit-quantized phase residues)	256 KB	~4× further; ~13000× from raw

Wall-clock improvement: >300× on representative ephemeris-query workloads. Precision loss: ~0.01% averaged over random sample sweeps of the ephemeris time window.

The mechanism is not lossy compression in the JPEG sense. The mechanism is that the float32 magnitudes were carrying information the system did not need. Once the basis is the commensurable-frequency basis — once the data is expressed in coordinates aligned with the natural resonant orbits of the underlying physical system — most of the information lives in which orbit you're on, not how loud you're singing on it. Bit-serialization quantizes the loud-soft axis (which the dynamics doesn't care about) and preserves the orbit-identity axis (which it does).

20.2. The structural question for chess-spectral¶

The chess-spectral encoder's 640 dims (2D) and 45056 dims (4D) are also a basis aligned with a natural resonant structure: the eigenmodes of the per-piece graph Laplacians, organized into D₄ (or B₄) irreps and per-channel quantum-number bundles. The encoder's float32 output gives, per dimension, a real-valued amplitude of the position's projection onto that mode.

The structural question is: does the float32 amplitude carry information the downstream system actually consumes, or is the orbit-identity sufficient?

If the answer is "amplitude matters": the encoder's shape is genuinely fixed at 32-bit floating point, and bit-serialization will lose downstream precision proportional to the quantization. If the answer is "orbit identity suffices": the 32 bits per dimension are gratuitous, and bit-serialization compresses essentially without loss.

The antikythera result is suggestive but not conclusive for our case. Antikythera's commensurable-frequency basis is the basis the dynamics literally lives in (gear ratios are integers; orbit periods are rationally commensurable to the precision the dynamics demands). Chess-spectral's eigenmode basis is the basis our encoding lives in, but downstream consumers — search engines, position evaluators, similarity comparisons — care about different things: cosine-similarity between full vectors, channel-energy weighted sums, channel projector expectation values.

The spike's investigation question is: for which downstream task families does bit-serialization preserve answers, and at what bit budget?

20.3. What "resonant object" means in our setting¶

In dynamical-systems language: a resonant object is a configuration that lies on a periodic orbit (or a low-period orbit) under the time-evolution operator. Resonant objects are sparsely indexed — there are far fewer orbit classes than there are points in phase space — and the orbit-identity is preserved exactly under the dynamics, while the magnitude on the orbit is approximate-up-to-perturbation.

For chess-spectral, the dynamical operator is the encoder's symmetry-group action: D₄ (2D) or B₄ (4D) acting on the position's eigenmode coordinates. A position and any of its 8 (2D) or 384 (4D) symmetry-equivalent rotations / reflections are on the same orbit; their encoder vectors differ by a known group-action unitary. The orbit class — the equivalence class of positions under the group — is the resonant object identity.

For positions related by moves, the situation is structurally similar but not exactly orbital: a move acts on the encoder vector approximately as a per-channel unitary U_move (per ADR-001 / -003), and successive moves compose unitaries. The full move-orbit of a starting position under legal play is the chess game tree, which is not a periodic orbit (there is no return-time bound except by repetition rules), but for short windows (few-move look-ahead), the orbit structure is a useful local invariant.

The bit-serialization claim is: the encoder's 32-bit-per-dim magnitudes carry an approximation of the position's identity within its symmetry-orbit, but the orbit-identity itself is a much smaller object — its dimensionality is the dimension of the irrep types in the encoding (≤10 for 2D, ≤11 for 4D) plus whatever is needed to distinguish orbits within the same irrep family. A few bits per channel may suffice; the rest of the float32 budget is incidental coordinate precision.

20.4. Side-car bit serialization vs ground-up rewrite¶

Two implementation paths:

Path A — side-car bit serialization (recommended for P-spike-1). Keep the float32 encoder unchanged. Add a parallel encode_640_bits(pos) → bytes function that produces a bit-serialized version of the same encoded vector, by quantizing each float32 coordinate to a small bit budget per dimension. Both versions ship side-by-side. Downstream consumers can choose which one to ingest based on their task's precision needs.

Quantization choices: - 1-bit (sign only). Per dimension, store only the sign of the float32 value. Storage: 80 bytes per 2D position; 5632 bytes per 4D position. Loss: large in cosine-similarity terms, but for channel-projector-energy observables the magnitude information lives in the count of nonzero bits per channel block, which is partially preserved. - 2-bit (sign + log-magnitude bin). Per dimension, store sign + one log-magnitude threshold bit. Storage: 160 bytes / 11264 bytes. Cosine-sim recovers most of its discriminative power. - 4-bit (signed nibble, log-spaced). Storage: 320 bytes / 22528 bytes. Cosine-sim near-lossless on typical positions per the antikythera analog. - Ternary {−1, 0, +1} with sparsity threshold. Per dimension, three states. ~1.6 bits effective. Storage: ~128 bytes / ~9000 bytes. Naturally sparse; integrates with HDC majority-rule binding directly.

Path B — ground-up bit-resonant encoder rewrite (NOT recommended at this stage). Redesign the encoder to compute its outputs directly in a bit-resonant representation, skipping the float32 intermediate entirely. Per-channel projections become per-channel parity computations; D₄ / B₄ irrep arithmetic becomes group-coded XOR composition; everything is integer or boolean. Estimated 3000-5000 LOC rewrite. High risk — the math is sound but the engineering surface is large, and the existing float32 encoder is already shipped and tested.

The recommendation is Path A first. It de-risks the question (does the bit-serialized representation actually preserve enough downstream signal) without committing to a rewrite. If Path A succeeds at acceptance criteria and downstream consumers want to drop the float32 entirely, Path B becomes the natural follow-on.

20.5. Acceptance criteria for P-spike-1 (side-car)¶

The spike succeeds if the bit-serialized representation preserves position-distinguishability on the validation corpus to within a small margin of the float32 representation:

Metric	Float32 baseline	Bit-serialized acceptance
Median position-pair cosine similarity (random pairs)	(measured)	≥ 99.5% of float32 value
Worst-case position-pair cosine similarity (1k random pairs)	(measured)	≥ 95% of float32 value (no positions worse than this floor)
Channel-energy ranking agreement (Spearman ρ) on 1k positions	1.000	≥ 0.95
Symmetry-equivalent position discrimination (orbit labels match)	100%	100% (loss-bounded — symmetry orbits are categorical)
Classification accuracy on opening-vs-middlegame-vs-endgame label task	(baseline)	within 2% absolute

These thresholds are tight enough to make the spike falsifiable. The antikythera 0.01% precision-loss data point is over a different metric (ephemeris-position L2 residual), not directly comparable, but it suggests that 1-bit quantization will fail and 4-bit will probably succeed; the interesting question is where the floor sits between them.

20.6. Phasing recommendation¶

Phase	Scope	Acceptance	Estimated effort
B-spike-1	Side-car `encode_640_bits` and `encode_4d_bits` at 4-bit signed nibble per dim. Tests verify acceptance metrics on the existing test corpus.	All 5 metrics in §20.5 within bounds.	400-600 LOC + 200 LOC tests
B-spike-2	Add 1-bit and 2-bit variants behind config flag. Sweep all three quantization budgets across the test corpus; characterize the precision-vs-bytes tradeoff curve.	Empirical precision-vs-bytes table published in this notebook (or in a successor Phase 8 plan).	150 LOC + 150 LOC tests + reporting script
B-spike-3	Bit-serialized cosine-similarity / channel-energy fast paths as drop-in replacements for the float32 versions on the search engine's evaluator hot path. Tournament: float32 `spectral` vs bit-serialized `spectral_4bit` at equal search depth.	Tournament agnostic outcome (within ELO noise) + ≥10× wall-clock speedup on evaluator hot path.	200 LOC + integration with §16
B-spike-4 (deferred)	Ground-up bit-resonant encoder. Eliminates float32 from the encoder path entirely.	Cosine-sim with float32 baseline ≥ 99% on every position in the test corpus; channel-energy ranking ρ ≥ 0.99.	Path B from §20.4. 3000-5000 LOC rewrite. NOT recommended this cycle.

B-spike-1 is independent of Phase 4 (QM dynamics), §19 (sheets), and §16 (engine). It can ship in v1.9 alongside any current track. B-spike-2 is a small follow-on. B-spike-3 is gated behind §16 (Phase 6). B-spike-4 is parked.

20.7. Connection to the existing UTLP S3 coprime architecture¶

The 8-generator coprime spectral basis from §1 ({2, 3, 5, 7, 11, 13, 17, 19} modulo factor — see §9o) is already a bit-resonant-aligned basis for the position projection. UTLP S3's coprime-roll binding operates by phase-shift composition modulo the generators, which is a bit-level XOR-like operation in the carrier-coding sense: phase shifts compose by addition mod the generator, which factors through (Z_2)^k for the binary part of any generator's residue ring.

The encoder's existing structure already partway anticipates the bit-serialized representation. What's missing is the quantization step — float32 magnitudes that are de facto irrelevant to UTLP S3's phase-arithmetic core but carry incidental precision the system never uses. Bit-serialization is the missing step that aligns the encoder's storage with the encoder's actual algebra.

This is the cleanest version of the structural-limit framing: the float32 shape is fixed by the implementation's choice of NumPy ndarray dtype, not by the encoding's mathematics. The encoding's mathematics is bit-resonant. The shape can change without anything load-bearing breaking.

20.8. What this spike does NOT do¶

Does not claim 300× speedup is reproducible for chess. The antikythera 300× came from a specific I/O pattern (ephemeris query is a database lookup; chess-spectral encoding is a per-call computation). Chess-spectral's bottleneck is the encoder computation, not bytes-on-disk. Bit-serialization helps the storage and the similarity-comparison-on-stored-vectors paths, but not the encoder hot path itself unless we go all the way to Path B (B-spike-4, deferred).
Does not commit to dropping float32. The side-car path is additive. Float32 remains the canonical encoder output; bit-serialized is a parallel offering for consumers that don't need float32 precision.
Does not address the half-move clock's Z_{101} carrier from §19.3. That carrier is a 2-D unit-modulus float complex value; it is not a sparse bit pattern and bit-serialization of it is a separate design question (probably 5-bit quantization to preserve clock-distance fidelity).
Does not interact with the sheet block (§19) implementation. Sheets and bit-serialization are orthogonal axes — the sheet block could be added in float32 first and bit-serialized later, or vice versa, without rework.
Does not commit B-spike-1 implementation. This spike's purpose is to capture the analysis. Whether to ship B-spike-1 in v1.9 is a Phase 6 / Phase 7 product decision, not a notebook decision.

20.9. Joint framing with §19 — the structural-limit axis named¶

§19 and §20 together address the two clauses of the structural-limit observation:

Clause	Spike	Where the limit hits
"where more data might live"	§19 (sheets)	The static graph-Laplacian propagator structurally cannot see history (castling rights, EP target, half-move clock, repetition state). Adding aux sheet dimensions is the minimal extension that lets the encoder see the non-Markovian residue.
"where the shape is fixed but doesn't need to be"	§20 (BSHDC)	The float32 magnitudes per dim of the encoder output are an implementation artifact, not an encoding requirement. The math is bit-resonant; the storage doesn't need to be float.

Both are deferrable. Both are independent of each other and of the Phase 4 QM extension. Both have first-step work units (S-spike-1 and B-spike-1) at the 200-600 LOC range. The recommendation, if any of this is to ship: take S-spike-1 first (sheets), because Phase 6 (engine) needs castling/EP/halfmove/repetition awareness for rule-correct evaluation and there is no path to that without a sheet block; then take B-spike-1 (BSHDC side-car) as the next storage / transport optimization.

The static Laplacian propagator is not yet at its limit on the base encoding — the 640/45056-dim vectors continue to do useful work for the position-similarity, channel-energy, and QM-extension paths. The limit it hits is on what classes of chess facts it can represent at all, and that limit is exactly the non-Markovian residue characterized in §19. The shape question (§20) is a follow-up about how efficiently we encode the things the propagator can represent.

20.10. Implementation update — BIP prototype on the ephemerides reference branch¶

Date: 2026-05-04. Status: Reference data observed; chess port not yet committed. Scope: §20.5's acceptance criteria, §20.6's phasing table, and §20.7's UTLP S3 connection all need refinement based on the prototype's actual numbers.

A working EphemerisBIPInstrument (Bit-Interleaved Phases) prototype lives on the git branch feature/ephemerides-hdc-reference (Gemini-authored while Claude credits were exhausted on the chess track). Two key files:

docs/antikythera-maths/research/bip_instrument.py — the implementation (236 lines)
docs/antikythera-maths/research/resonant_bit_serialized_hdc_evaluation.md — the eval doc (84 lines)

The numbers measured.

Metric	FPU baseline (complex64)	BIP (uint32)	Benefit
Execution time (planet evolution loop)	1379 ms	4.5 ms	305× speedup
Memory (D = 2¹⁶ state vector)	1024 KB	256 KB	4× compression
Terra phase error after 20-yr sweep	reference	0.0002 rad ≈ 0.011°	at-floor parity

The decisive finding from §6 of the eval doc:

"The 0.0002 rad error is the structural limit of our current static Laplacian propagator, not the bit-serialized format."

This rewrites the §20 thesis significantly. The original framing in §20.2 (will float32 amplitude be the load-bearing thing?) was wrong-footed for phase-like content. For phase-like content, BIP encoding is not lossy — it's a group isomorphism. The "0.01% precision loss" claim in §20.5 was misremembered: the real precision floor is 0.011° angular error, set by the propagator (not the encoding), and it survives K=16 / K=18 / K=20 (Phase 8 dimensional sweep — Table 7 of the eval doc) without changing.

Phase 8 dimensional expansion finding — linear SNR scaling.

D (log₂)	Storage	Time	SNR (resonance sharpness)	Terra error (rad)
16	0.25 MB	2.4 ms	2,621	0.000205
17	0.50 MB	5.7 ms	5,243	0.000205
18	1.00 MB	25.7 ms	10,486	0.000205
20	4.00 MB	106.1 ms	41,943	0.000205

SNR scales linearly in D; the error stays at 0.000205 rad regardless. The propagator's structural floor is genuinely structural.

What the prototype does NOT yet implement: off-diagonal couplings (gravitational perturbations between bodies). The eval doc §3.3 specs a LUT-based Δφᵢ = Wᵢⱼ · LUT_Sin(φⱼ − φᵢ) approach, but bip_instrument.py ships only the diagonal NCO (Numerically Controlled Oscillator) per dimension. So the 305× speedup is for diagonal evolution; the off-diagonal piece is future work on the antikythera side too.

20.11. The BIP encoding pattern in detail¶

The Gemini prototype gives concrete code we can mirror. The four invariants:

(1) Phase representation is Z_{2^K} with K = 32. Each dimension's phase is a uint32 integer. Mapping radians → integer:

# bip_instrument.py:75-77 (during calibration)
# Map [0, 2π) → [0, 2^32)
phases[i] = int((lon.radians / (2.0 * np.pi)) * MODULO) % MODULO
# where MODULO = 2**32 = 4294967296

K = 32 was chosen empirically: K = 16 also stays at the propagator floor (per the eval doc's K-sweep), so K = 32 is just headroom. Per-phase resolution at K = 32 is 2π/2³² ≈ 1.46 × 10⁻⁹ rad ≈ 3 × 10⁻⁷ arcsec — six orders of magnitude tighter than the propagator floor.

(2) HDC binding is integer addition mod 2^K. This is a literal group isomorphism with complex multiplication (e^{i(φ₁+φ₂)} = e^{iφ₁} · e^{iφ₂}):

# bip_instrument.py:143-144
def bind(self, phase_vec_a: np.ndarray, phase_vec_b: np.ndarray) -> np.ndarray:
    return (phase_vec_a + phase_vec_b) % MODULO

Unitarity is preserved by construction — every Z_{2^K} element corresponds to a unit-magnitude phasor, and unit × unit = unit.

(3) Time evolution is a per-dimension NCO. The diagonal propagator term e^{-iLt} becomes integer phase advance:

# bip_instrument.py:98-102
delta_t = date_jd - REFERENCE_JD
evolved_phases = ((self.initial_phases + self.fixed_frequencies * delta_t)
                  .astype(np.uint64) % MODULO).astype(np.uint32)

Note the partial-FPU-ness: fixed_frequencies is stored as float64 (residues per day) and multiplied with delta_t in float before the integer cast. A truly fully-ALU-native version would store frequencies as fixed-point integers; the prototype takes the float-multiply shortcut for accumulated-rounding control. This is a place where a chess port could go either way.

(4) Off-diagonal couplings (deferred). The eval doc §3.3 describes a LUT-based or CORDIC-based bit-serial rotation:

Δφ_i = W_{ij} · LUT_Sin(φ_j - φ_i)

A small lookup table (eval doc suggests 16-32 entries) keyed by phase difference maps each interaction to a phase nudge. Not implemented in the Gemini prototype yet; design choice would carry over to chess.

20.12. Chess channel taxonomy — refined via sign × magnitude factoring¶

§20.3-§20.4 framed the chess BIP question as "phase-clean vs incompatible" per channel. The Gemini findings + a careful read of the encoder's algebraic structure suggest a more useful factoring: sign × magnitude, where the sign is BIP-friendly (1-bit phase ∈ Z₂) and the magnitude is real-valued.

2D encoder (10 channels × 64 dims = 640):

Channel	Algebra	Decomposition	Pure phase?	Pure magnitude?	Sign×Mag?
A1	D₄ trivial irrep (orbit sum)	non-negative scalar	—	✓	—
A2	D₄ sign rep	signed real	—	—	✓
B1	D₄ 1-D irrep	signed real	—	—	✓
B2	D₄ 1-D irrep	signed real	—	—	✓
E	D₄ 2-D irrep	2-vector / complex	✓	—	—
F1 / F2 / F3	symmetric fiber (rank-3 SVD)	signed real (gradient × fib_d)	—	—	✓
FA	antisymmetric pawn fiber	strictly signed (white = +, black = −)	✓ (Z₂ phase)	—	—
FD	diagonal deviation	signed real (sig × DIAG_DEV)	—	—	✓

Net: 1 channel pure magnitude (A1), 1 channel genuinely phase (E — naturally complex / 2-vector), 1 channel pure-sign-as-Z₂-phase (FA), and 7 channels factorable as sign × magnitude. No channel is BIP-incompatible under the sign × magnitude factoring — A1 is "phase = 0 always" (degenerate Z₂ phase), and the others all have a genuine sign component.

4D encoder (11 channels × 4096 dims = 45 056): parallel structure. A1 magnitude-only; FA_PAWN_W and FA_PAWN_Y phase-via-sign (Z₂); STD4_X/Y/Z/W and FIB_SYM_½/3 and FD_DIAG factor as sign × magnitude. The 2-D E irrep doesn't have a direct B₄ analogue at the same shape; the closest analogues live in the FIB_SYM SVD components.

What this means for a chess BIP encoder. The §20.4 binary "side-car vs ground-up rewrite" was the wrong question. The right question is: how much of the magnitude information do downstream consumers actually need?

Channel energies (Σ |c_i|²) use only magnitudes; sign cancels in the square. Sign-only encoding suffices for channel-energy analysis.
Cosine similarity between two vectors uses both sign AND magnitude; sign-only encoding loses similarity precision proportional to the magnitude variance.
Symmetry-orbit identification (per §20.3) uses sign + categorical structure; magnitude is incidental.
Search-engine evaluators (§16) use sign × magnitude weighted sums; full information needed.

So a chess BIP encoder is naturally hybrid: pack the sign components (Z₂ per dim, packed as bits — 640 bits = 80 bytes for 2D, 45 056 bits = 5632 bytes for 4D) and store magnitudes separately at whatever bit budget the downstream task allows (4-bit signed nibble at 320/22 528 bytes, 8-bit at 640/45 056 bytes, etc.). The sign packing is algebraically exact; the magnitude packing is the only loss source, and it can be tuned per consumer.

20.13. The §11 phase-operator move engine is already BIP-isomorphic¶

The "8-generator coprime basis" framing in §1, §9o, and §20.7 is a misnomer worth correcting before chess BIP work begins. The encoder does not use 8 separate Z_p moduli for p ∈ {2, 3, 5, 7, 11, 13, 17, 19} (CRT-style). It uses a single composite modulus Z_640 (extended from the original Z_512), with the position-to-phase map:

# phase_operators.py
phi(r, c) = (r * 67 + c * 7) mod 640

The "coprimality" lives in the spectral domain — the 8 path-graph eigenvalues λ_k = 2(1 − cos(πk/8)) for k = 0..7 have irrational pairwise ratios, so no two modes alias under board operations. This is mathematically distinct from the arithmetic-modular coprimality that BIP uses (gcd(K_1, K_2) = 1 between two separate cyclic groups).

But the algebraic structure that matters for BIP — phase composition via integer addition modulo a fixed group — is exactly what §11's phase-operator engine does. Move composition for any piece is a roll by an integer phase offset modulo 640, and successive moves compose as integer additions. This is identical in shape to BIP's (φ₁ + φ₂) mod 2^K, just with a non-power-of-2 modulus.

The chess-side implication: the §11 move engine and the §3 / §9 encoder are two different objects living in the same codebase:

§11 phase-operator engine — already integer-arithmetic, already BIP-isomorphic at the group level. Uses Z_640 (non-power-of-2). Could be promoted to a public ALU-native API with no algebraic redesign.
§3 / §9 float32 encoder — outputs the 640-dim signed magnitudes. Not BIP. Would need the hybrid sign × magnitude treatment from §20.12.

These two opportunities are independent. Promoting the phase engine costs ~300-400 LOC (mostly API surface + benchmarks); BIP-ifying the encoder is the harder ~500-800 LOC piece. They can ship in either order.

The "non-power-of-2 modulus" detail matters in one specific way: BIP's §3.1 binding ((φ₁ + φ₂) mod 2^K) lets the modulo wrap happen for free in uint32 overflow semantics. Modulo 640 doesn't get this — (a + b) % 640 in Python (or C) is an explicit operation, not a hardware overflow. For the chess phase engine, that's a per-op cost of one division. Cheap, but not zero.

20.14. Sheets × BIP — the cleanest first move¶

The 1.9.0 sheet block (§19.9) shipped 11 dims × 8 bytes = 88 bytes per position in float64. Per §19.4, the bits decompose into 9 categorical bits (XOR-lite — castling × 4, ep_active × 1, ep_file × 3, side_to_move × 1) plus a 2-bit repetition-count register plus a Z₁₀₁ Fourier carrier for the halfmove clock. The float64 storage is wildly inefficient for content that is almost entirely categorical.

BIP-encoded sheet block — concrete byte budget:

Slot	1.9.0 dtype	BIP-natural	Bits used
castling × 4	4 × float64	4 bits in uint8 / uint16	4
ep_active	float64	1 bit	1
ep_file (0..7)	float64	3 bits (`Z_8 = Z_{2^3}`)	3
side_to_move	float64	1 bit	1
repetition_count (0..2)	float64	2 bits (`Z_4`)	2
halfmove_clock (0..100)	2 × float64 cos/sin	7 bits (uint8, raw value with explicit modulo)	7
Total	88 bytes	3 bytes (uint16 + uint8)	18

29× compression. Round-trip exact for every legal (castling, ep_file, side_to_move, repetition, halfmove ∈ [0, 100]) tuple — bit-for-bit lossless within the legal state space.

The Z₁₀₁ question — recommendation γ (separate codepath). Three options for the halfmove clock:

(α) Pad uint8 with explicit % 101. ALU-native. Algebraically discontinuous (the wrap at 100 → 0 jumps by 101 in Z_128, not 1). Loses the continuous-resonance property §19.4 named.
(β) Embed Z_101 in Z_128. Use 7 bits, accept that some operations have a wrap discontinuity at the fence post.
(γ) Accept Z_101 as its own algebraic object — separate codepath for halfmove. Categorical bits in uint16; halfmove in its own uint8 with explicit modulo handling. Preserves §19.4's "XOR-lite + Z_n-spectral split is structural, not aesthetic" finding.

γ wins because §19.4 explicitly framed the split as structural. The 1.9.0 cos/sin float pair was the float-encoded version of that split; the BIP-encoded version keeps the same split, just in integer types. Concrete API:

from dataclasses import dataclass

@dataclass(frozen=True)
class SheetStateBIP:
    """BIP-encoded non-Markovian state (1.10.0+)."""
    categorical: int   # uint16, bits[0:11] packed; bits[12:16] reserved
    halfmove_clock: int  # uint8, 0..100; values 101..255 illegal

Bit layout for categorical:

bits[0:4]    castling_wk | castling_wq | castling_bk | castling_bq
bit[4]       ep_active
bits[5:8]    ep_file (0..7; 0 if !ep_active)
bit[8]       side_to_move (0 = white, 1 = black)
bits[9:11]   repetition_count (0..2; saturates at 2)
bits[12:16]  reserved (zero-filled)

Total per-position storage: 2 + 1 = 3 bytes (or 4 bytes with byte alignment to uint32).

Algebraic operations that ride for free:

# All single integer ops, no FPU, no conditionals on float comparisons.
def castling_alive(s: SheetStateBIP) -> bool:
    return (s.categorical & 0xF) != 0

def kingside_castling_alive(s: SheetStateBIP) -> bool:
    return (s.categorical & 0b0101) != 0  # bits 0 and 2

def queenside_castling_alive(s: SheetStateBIP) -> bool:
    return (s.categorical & 0b1010) != 0  # bits 1 and 3

def fifty_move_rule_triggered(s: SheetStateBIP) -> bool:
    return s.halfmove_clock >= 100

def threefold_claimable(s: SheetStateBIP) -> bool:
    return ((s.categorical >> 9) & 0x3) >= 2

def hamming_distance_categorical(a: SheetStateBIP, b: SheetStateBIP) -> int:
    return bin(a.categorical ^ b.categorical).count("1")

Where BIP wins vs §19.10's depth-1 floor. §19.10 established that single-position queries on python-chess Board (one int & mask for castling, attribute load for EP) cannot be undercut by float-numpy slice + decode. That floor still holds for BIP single-position queries — bit-AND on uint16 is comparable to python-chess's int-AND, not strictly faster. But:

Pyodide / WASM consumers (chess4D-OC) skip Python interpreter overhead entirely with BIP — direct uint16 & 0xF is a JavaScript Number op, no python-chess.Board reconstruction, no float-decode. Speedup at this scale: 50-100× on chess4D-OC's hot paths.
Batch retrieval over saved corpora — filtering 10 000 stored vectors for "any castling alive" is one numpy vecs[:, OFF:OFF+1] & 0xF against a pre-packed corpus, vs 10 000 python-chess.Board(fen) reconstructions. ~3 orders of magnitude.
Hamming-distance-based similarity — for the categorical portion, Hamming distance over uint16 is a sharper metric than float cosine similarity for binary state (categories are equal or they aren't). Opens new corpus-similarity work that the float64 sheet block didn't support cleanly.
Wire format — v5 mode 2 (XOR-stream) compression of sheet bits is now natively the right shape. The categorical field XORs cleanly across plies (most plies don't change castling/EP/repetition/side); the halfmove_clock XOR is ± 1 on quiet plies. §19.12 deferred the v5 + sheets question for lack of consumer demand; BIP-encoded sheets make the wire-format integration nearly trivial.

The sheet block × BIP is the cleanest small bet in the entire §20 program. Concrete acceptance criterion: bit-for-bit round trip on every legal (castling, ep_file, side, repetition, halfmove) tuple in the validation corpus.

20.15. Revised B-spike phasing — three tiers, sheet-first¶

Replaces the §20.6 phasing table. The new structure factors the work into three independent ships:

Phase	Scope	Acceptance	Independence	LOC
B-spike-1a ⭐	Sheet-block BIP encoding (§20.14). New `SheetStateBIP` dataclass with `uint16` categorical + `uint8` halfmove. Bridge surface mirrors. Hamming-distance metrics.	Bit-exact round trip on every legal sheet tuple; existing 1.9.0 float64 path unchanged; `from_chess_board` / `from_game_state_4d` factories produce equal `SheetState` for both BIP and float64 paths.	Independent. Smallest first move.	200-300 + ~100 tests
B-spike-1b	Promote §11 phase-operator engine to public API. Document the `Z_640` modulus structure. Benchmark vs python-chess move-gen. ALU-native engine path for Pyodide consumers.	Move-gen parity with python-chess on test corpus; documented Pyodide speedup; existing search engine integrations unchanged.	Independent of 1a and 2.	300-400 + ~100 tests
B-spike-2	Encoder BIP-hybrid (§20.12). Factor each channel as sign × magnitude. Sign rides as packed bits (Z₂ per dim, 80 / 5632 bytes per 2D / 4D position). Magnitude stays float32 by default; `--bits` flag selects 4 / 8 / 16-bit quantization.	Cosine-sim ≥ 99.5% median on test corpus at sign-only encoding for channel-energy use case; ≥ 99.5% median + ≥ 95% worst-case at 8-bit magnitude quantization for cosine-sim use case.	Depends on B-spike-1a's bit-packing patterns.	500-800 + ~200 tests
B-spike-3	Drop B-spike-1a and B-spike-2 fast paths into the §16 search-engine evaluator hot path. Tournament: float32 spectral vs hybrid-bit spectral at equal search depth.	Tournament outcome within ELO noise; ≥ 10× wall-clock speedup on evaluator hot path.	Depends on B-spike-2.	200-400 + tests
B-spike-4	Pure-phase encoder over the §11 coprime basis (encoder rewrite, not hybrid). Per-position state is a tuple of phases over `Z_640` (or richer phase tuple if we go full coprime decomposition).	Cosine-sim with float32 baseline ≥ 99% on every position in the test corpus; channel-energy ranking Spearman ρ ≥ 0.99.	Depends on everything else; high risk.	3000-5000 LOC rewrite

B-spike-1a is the recommended first move. The acceptance test is sharp (bit-exact round trip is binary pass/fail), the LOC is bounded (~300 + tests), the consumer is real (chess4D-OC), and the work establishes the bit-packing patterns that B-spike-2 will need. B-spike-4 stays parked until B-spike-2's empirical answer comes in.

Revisiting §20.5's acceptance criteria. The original criteria (median cosine-sim ≥ 99.5%, worst-case ≥ 95%, ranking ρ ≥ 0.95) still apply to B-spike-2 (encoder hybrid). For B-spike-1a (sheet block), the criterion sharpens to bit-exact round trip because the sheet content is fully discrete — there's no quantization tradeoff to characterize. For B-spike-1b (engine promotion), the criterion is move-gen parity with python-chess (no false legal moves, no missed legal moves) plus a documented speedup curve.

20.16. B-spike-1a implementation plan — the small-bet first move¶

Goal. Add a BIP-encoded representation of the 1.9.0 sheet block, keeping the float64 path intact. New code only; no breaking changes.

Files to add.

chess_spectral/sheets_bip.py            ~200 LOC
tests/test_sheets_bip.py                 ~150 LOC

Files to modify.

chess_spectral/__init__.py               +6 lines (re-export SheetStateBIP and helpers)
chess_spectral_4d/bridge.py              +60 lines (BIP variants of the 1.9.0 bridge functions)
chess_spectral/sheets.py                 +20 lines (cross-references to sheets_bip)
docs/chess-maths/chess_spectral_research_notebook.md  reference §20.16
chess-spectral/python/CHANGELOG.md       1.10.0 entry
chess-spectral/python/README.md          "What's new in v1.10" section
chess-spectral/python/pyproject.toml     1.9.1 → 1.10.0
chess-spectral/python/pyproject-pure.toml   1.9.1 → 1.10.0

Public API surface.

# chess_spectral/sheets_bip.py — new module

from dataclasses import dataclass

# Bit-layout constants (mirrors the 11-bit categorical packing).
BIT_CASTLING_WK = 0
BIT_CASTLING_WQ = 1
BIT_CASTLING_BK = 2
BIT_CASTLING_BQ = 3
BIT_EP_ACTIVE   = 4
BITS_EP_FILE    = (5, 8)    # 3-bit field
BIT_SIDE        = 8         # 0 = white, 1 = black
BITS_REPETITION = (9, 11)   # 2-bit field
RESERVED_MASK   = 0b1111_0000_0000_0000  # bits[12:16]

CATEGORICAL_BITS = 11
HALFMOVE_MAX = 100

@dataclass(frozen=True)
class SheetStateBIP:
    categorical: int   # uint16; only bits[0:12] used
    halfmove_clock: int  # uint8; 0..100

def encode_sheet_state_bip(state: SheetState) -> SheetStateBIP:
    """Lossless BIP encoding of a 1.9.0 SheetState. Round-trip exact."""
    ...

def decode_sheet_state_bip(packed: SheetStateBIP) -> SheetState:
    """Lossless inverse of encode_sheet_state_bip."""
    ...

# Operator fast paths (single integer ops, no FPU)
def castling_alive(packed: SheetStateBIP) -> bool: ...
def kingside_castling_alive(packed: SheetStateBIP) -> bool: ...
def queenside_castling_alive(packed: SheetStateBIP) -> bool: ...
def ep_target_active(packed: SheetStateBIP) -> bool: ...
def ep_file(packed: SheetStateBIP) -> int | None: ...
def side_to_move_white(packed: SheetStateBIP) -> bool: ...
def repetition_count(packed: SheetStateBIP) -> int: ...
def fifty_move_rule_triggered(packed: SheetStateBIP) -> bool: ...
def threefold_claimable(packed: SheetStateBIP) -> bool: ...

# Distance metric (Hamming over the categorical portion + integer halfmove diff)
def hamming_distance_categorical(a: SheetStateBIP, b: SheetStateBIP) -> int: ...
def halfmove_distance(a: SheetStateBIP, b: SheetStateBIP) -> int: ...

Bridge module additions (chess_spectral_4d/bridge.py).

def get_sheet_state_bip(state_or_board) -> Dict[str, object]:
    """Like get_sheet_state, but returns BIP-encoded form.

    Returns {"ok": True, "sheet_bip": {"categorical": int, "halfmove_clock": int}}.
    """
    ...

def encode_sheet_aux_bip(sheet_dict: Dict[str, object]) -> Dict[str, object]:
    """Like encode_sheet_aux, but returns the 3-byte BIP packing.

    Returns {"ok": True, "categorical": int (uint16), "halfmove_clock": int (uint8)}.
    """
    ...

def decode_sheet_state_from_bip(categorical: int, halfmove_clock: int) -> Dict[str, object]:
    """Inverse of encode_sheet_aux_bip. Returns full SheetState dict."""
    ...

Test plan.

Bit-exact round trip — exhaustive over the categorical portion (test_sheets_bip.py::test_categorical_round_trip_exhaustive). Iterate every combination of (castling_wk, castling_wq, castling_bk, castling_bq, ep_active, ep_file, side, repetition) — 4 × 2 × 9 × 2 × 3 × 2 = 864 cases; assert decode(encode(state)) == state for all of them.
Halfmove round trip — every legal value (101 cases for halfmove ∈ [0, 100]).
Operator fast paths — agreement with the 1.9.0 float path. For each of the 864 × 101 = 87,264 states, compare castling_alive(bip) against state.castling_wk or state.castling_wq or ... and so on for every fast-path function.
from_chess_board factory parity — for a sample of python-chess Board states, the BIP path and the float path must produce equivalent SheetState.
Bridge round trip — bridge.get_sheet_state_bip(board) → bridge.encode_sheet_aux_bip(...) → bridge.decode_sheet_state_from_bip(...) must return the original.
Hamming distance correctness — for a sample of (state_a, state_b) pairs, hamming_distance_categorical(bip_a, bip_b) must match popcount(categorical_a ^ categorical_b) computed independently.
Memory check — sys.getsizeof(SheetStateBIP(0, 0)) is bounded; verify with a corpus of 10000 states that BIP storage is ~3 bytes per state vs ~88 bytes for the float path.

Acceptance — binary pass/fail.

All 87,264 + 101 + bridge + factory tests pass.
Encoder default behavior (encode_640(pos) with no sheets= kwarg) bit-for-bit unchanged — test_c_py_parity and test_c_py_parity_4d still green.
Wider 1.9.x test suite still green.
README "What's new in v1.10" section gates test_immolation_readme_announces_current_version.

No version bump on frame_v5.py — sheet-block BIP doesn't enter the wire format yet; v5 mode 2 + BIP integration is a follow-up (likely 1.11.0 if a consumer needs it).

Estimated session. 3-4 hours for code + tests + CHANGELOG + README + version bump + commit + PR. The acceptance test surface is large (87,264 cases) but mechanically generated — write the test once, run it.

What B-spike-1a does NOT do.

Does not modify the 1.9.0 float64 sheet block. Both representations ship side-by-side.
Does not enter the v5 wire format. Wire-format integration is a separate question (§19.12 deferred).
Does not change the encoder. The 640 / 45056-dim spectral payload is untouched.
Does not promote the §11 phase-operator engine. That's B-spike-1b.
Does not implement off-diagonal coupling LUTs. That's an encoder-level question for B-spike-2.

20.17. B-spike-1b implementation update — `Z_640` engine promoted to public ALU-native API¶

Date: 2026-05-04. Shipped: chess-spectral 1.11.0. Scope: the second of the §20.15 three-tier B-spikes — promote the §11 phase-operator engine (already integer-arithmetic at the core) to a stable public API with no python-chess dependency on the hot path.

The audit in §20.13 established that the engine is already BIP-isomorphic at the group-theoretic level: phase composition is integer addition modulo Z_640, identical in shape to BIP's (φ_1 + φ_2) mod 2^K. What was missing for downstream consumers was an integration entry point that didn't require a python-chess Board argument. The existing occupation_aware_moves_{a,b,c} all took a Board for the occupation-field derivation + EP-square lookup + castling-rights check, even though Solutions B and C of §11.4 are pure phase arithmetic on a dict[phase, charge] occupation field.

The 1.11.0 ship. Three new public functions:

occupation_field_from_pos_dict(pos) — encoder-format adapter for the occupation field. Accepts both int- and str-keyed dicts. Returns the same dict[phase_int, charge] as occupation_field_from_board, but without a python-chess round-trip.
ep_phase_from_ep_file(ep_file, side_to_move_white) — derive the EP target's phase from the file index + side-to-move. Mirrors the 1.9.0 SheetState.ep_file semantics (white-to-move ⇒ EP target on rank 5; black-to-move ⇒ rank 2).
phase_only_pseudo_legal_moves(pos, side_to_move_white, *, ep_file=None) — the integration entry point. Iterates the side-to-move's pieces, computes per-piece destination sets via Solution B's phase-arithmetic, returns a flat list of (from_sq, to_sq, promotion_char) tuples in encoder sq convention. Pure ALU-native — no python-chess, no numpy, no float.

Acceptance gate. tests/test_phase_operator_alu_native.py includes an exhaustive parity test against board.pseudo_legal_moves (excluding castles) on a representative corpus of 8 FENs spanning opening, middlegame, endgame, EP-active, and promotion-imminent positions. All move sets match exactly. 26 tests total; pass on first implementation.

The benchmark.

Diagnostic, not competitive. python-chess's pseudo_legal_moves is Cython-accelerated bitboard; the ALU-native path is pure-Python integer arithmetic. Recorded numbers (1000 iters per call site, modern workstation):

Position	python-chess	Solution B (per-piece × 16)	ALU-native
Opening (startpos)	72.6 µs	1967 µs	187.8 µs
Middlegame (Italian, both castled)	81.5 µs	2145 µs	250.4 µs
Endgame (K+R vs K)	22.7 µs	79.3 µs	40.6 µs

ALU-native is ~2-3× slower than Cython python-chess (expected) but structurally faster than the existing Solution-B-per-piece-loop because it builds the occupation field once per position instead of per-piece. The "Solution B column" times reflect the cost of repeatedly calling occupation_field_from_board from the occupation_aware_moves_b adapter — phase_only_pseudo_legal_moves skips that overhead.

What 1.11.0 does NOT cover. Documented as scope for a 1.12.0+ follow-up:

Castling. Pure-phase castling generation needs an attack map (for the "king does not pass through attacked square" check) plus castling-rights tracking. Both representable in Z_640 integer arithmetic but a heavier lift; deferred until a consumer needs it.
Check filter. phasecast_is_check already does ALU-native check detection internally but currently takes a python-chess.Board input. Refactoring to accept an occupation-by-piece-type dict (i.e., distinguishing "rook at this phase" from "queen at this phase") completes the closure. Until that lands, phase_only_pseudo_legal_moves returns truly pseudo-legal moves; consumers wanting check-filtered legal moves should pair with the existing phasecast_is_check.

The Z_640 wire contract. This subsection canonicalizes the contract for downstream consumers:

Constant	Value	Role
`MODULUS`	640	The cyclic group `Z_640` for phase composition
`ROW_GEN`	67	Rank-direction generator
`COL_GEN`	7	File-direction generator
`DIAG_NE_SW_GEN`	74 = 67+7	NE-SW diagonal generator
`DIAG_NW_SE_GEN`	60 = 67-7	NW-SE diagonal generator
`KNIGHT_SHIFTS`	8-tuple	Phase shifts for the 8 knight L-moves
`KING_SHIFTS`	8-tuple	Phase shifts for the 8 king/queen-step moves

phi(r, c) = (r * 67 + c * 7) % 640 is the canonical position encoding, with r = chess rank (0..7, 0 = rank 1) and c = chess file (0..7, 0 = file a). All of these are part of chess_spectral.phase_operators's public API starting in 1.11.0; they do not move without a major version bump.

The "8-generator coprimality" referenced in §1, §9o, and §20.7 — clarified in §20.13 — is a spectral property (the 8 path-graph eigenvalues λ_k = 2(1 - cos(πk/8)) for k = 0..7 have irrational pairwise ratios so no modes alias), not an arithmetic-modular CRT decomposition. The encoder uses a single composite Z_640 modulus, not 8 separate Z_p rings. This is the engine's BIP-relevant structure even though 640 = 2^7 · 5 is not a power of 2.

Implication for cross-pollination with ephemerides-spectral. §20.10's antikythera prototype uses Z_{2^32} because 2^32 is a power-of-2 cyclic group with overflow semantics that match uint32 hardware natively. Z_640 doesn't get that "free overflow" — every (a + b) % MODULUS in the chess phase-operator engine is an explicit modulo op. The structural shape is the same (integer addition over a finite cyclic group), but the per-operation cost has a small fixed overhead in chess that ephemerides avoids. Worth noting if the two projects converge on a shared bit-resonant carrier design later.

20.18. B-spike-2 implementation update — encoder BIP-hybrid shipped in 1.12.0¶

Date: 2026-05-04. Shipped: chess-spectral 1.12.0. Scope: the third of the §20.15 three-tier B-spikes — the encoder BIP-hybrid with sign × magnitude factoring. New module chess_spectral.encoder_bip_hybrid; new public API encode_2d_bip_hybrid / decode_2d_bip_hybrid / encode_4d_bip_hybrid / decode_4d_bip_hybrid plus cosine_similarity_hybrid_* distance utilities.

Design choice for first ship — blanket sign × magnitude. §20.12 named per-channel optimization opportunities (A1 is pure magnitude with no informative sign; FA is pure sign with no informative magnitude; E is genuinely 2-D phase). The 1.12.0 ship uses uniform sign × magnitude treatment per dim — every dim packs sign as 1 bit and magnitude at the configurable bit budget. Per-channel optimization is parked as 1.13.0+ work; the empirical question this ship answers is whether the uniform encoding hits the §20.15 acceptance gate, and the answer is yes (with one footnote, below).

Per-channel magnitude scaling. Channel energies span several orders of magnitude (A1 ≈ 0 at startpos; F1/F2/F3 fiber gradients in the hundreds-to-thousands range). A single global magnitude scale would force small-magnitude channels into the quantization noise floor. The 1.12.0 implementation stores max(abs(magnitude)) per channel as a float32 scale (40 bytes 2D / 44 bytes 4D total) and quantizes per-channel relative to that scale. Each channel gets uniform relative precision regardless of its absolute magnitude range.

Storage budget.

Encoding	2D bytes	4D bytes	2D compression	4D compression
float32 baseline	2560	180,224	1×	1×
BIP-hybrid 8-bit	760	50,732	3.4×	3.6×
BIP-hybrid 4-bit	440	28,204	5.8×	6.4×

Sign bits: 80 bytes (2D) / 5,632 bytes (4D). Magnitude scales: 40 bytes / 44 bytes. Magnitude payload: 320-640 bytes (2D) / 22-45 KB (4D) depending on bit budget.

§20.15 acceptance gate — corpus results.

Tested on 7 representative 2D FENs (opening, middlegame, endgame, EP-active, promotion-imminent) plus the canonical Oana-Chiru §3.3 4D startpos:

Encoding	2D median	2D worst	4D (canonical OC)	Gate
8-bit hybrid	0.999996	0.999996	0.999979	✅ PASS both
4-bit hybrid	0.998924	0.998729	0.994358	⚠️ 4D 4-bit just under 99.5%

The empirical finding worth recording. At 4-bit, the 4D encoder lands at 0.994358 — about 0.4% below the 99.5% median threshold. It clears the 95% worst-case threshold easily. The 2D 4-bit case passes both thresholds. The mechanism: the 45,056-dim 4D encoder accumulates more cumulative quantization error at 4-bit than the 640-dim 2D encoder at the same per-dim bit budget. Per-dim relative quantization error is the same (roughly 1/(2^bits - 1)), but the dot-product norm incorporates sqrt(N) more dim-pairs in 4D than 2D, and the cosine-sim error compounds.

Practical recommendation. Default to 8-bit (magnitude_bits=8) unless storage is a hard constraint. 8-bit clears both acceptance thresholds for both 2D and 4D with margin to spare. 4-bit is suitable for 2D consumers where the 5.8× compression matters and the ~0.1% cosine-sim degradation is acceptable. For 4D + 4-bit, consumers should validate against their downstream similarity threshold; the 0.994 result might be acceptable for retrieval-style applications but is below the §20.15 gate as written.

Sign-bit storage is exact, decoded-sign agreement is bounded by quantization-to-zero. The sign bit stored in sign_packed is bit-for-bit identical to the original sign for every dim. However, when a dim's magnitude rounds to zero during quantization (small-magnitude dims under low-bit budgets), the decoded value loses its sign — the decoded result is 0.0 regardless of the stored sign bit. This is documented as expected behavior (test test_immolation_2d_decoded_sign_matches_where_magnitude_nonzero locks the property: sign agreement on dims where the decoded magnitude is non-zero); the load-bearing claim is that the storage is sign-exact (test test_immolation_2d_sign_bit_preserved_exactly).

What 1.12.0 does NOT cover.

Per-channel optimizations from §20.12. A1 (pure magnitude — sign bit always 0; could skip), FA (pure sign — magnitude always uninformative; could skip the magnitude byte), E (genuinely 2-D phase — could pack as complex int rather than sign × magnitude). Estimated savings if all three optimizations applied: ~10-15% additional compression. 1.13.0+ work.
Wire format integration. v5 mode 2 (XOR-stream) was designed for the bit-XOR-friendly portion of encoder vectors. The hybrid sign portion is exactly the kind of bit pattern mode 2 compresses well — successive plies' sign bits XOR to mostly-zero deltas. Not implemented in 1.12.0; deferred per the §19.12 + §20.16 design that wire-format integration follows consumer demand.
B-spike-3 (search-engine evaluator hot path with hybrid vectors). Tournament A vs B at equal depth: float spectral vs hybrid spectral. Acceptance: tournament ELO within noise + ≥10× wall-clock speedup. Not started; depends on the §16 search engine integration surface.

Cross-pollination notes for ephemerides-spectral. The chess hybrid encoding intentionally keeps the magnitude portion as quantized integer rather than embedding into the BIP Z_{2^K} group. This is structurally different from antikythera's bip_instrument.py which uses pure phase encoding because celestial mechanics is purely-phase by physical construction (each body's amplitude is constant; only phase varies with time). Chess channels carry both phase and magnitude information; the hybrid is the chess-shaped answer to the same general question of "how do we get ALU-native HDC without losing channel-energy information." The two projects share the binary-int-arithmetic substrate but diverge on what's quantized vs what's exact.

20.19. B-spike-3 implementation update — encoder-eval speedups + cross-pollination with ephemerides Phase 9¶

Date: 2026-05-09. Shipped: chess-spectral 1.13.0. Scope: the fourth of the §20.15 phases — make the spectral evaluator's hot path faster for downstream consumers (chess4D-OC, the §16 search engine, batched corpus retrieval). Bench-discipline first: a benchmark harness lives in tests/bench_spectral_eval.py; no speedup claim ships in this CHANGELOG without measured numbers from the harness on a fixed corpus.

Ephemerides cross-pollination¶

The latest ephemerides-spectral notebook (lines 15, 147-149) confirms a two-stage architecture that informed our chess implementation:

"integer-ALU phase-residue encoders (bip Python / c native / complex128 reference) feeding an FPU complex64 HD pipeline (syzygy, observer-bind, eclipse-probability)."

"chess-spectral §20.13–§20.17 explicitly aligns the chess Z_640 phase-operator engine with this BIP design at the group-theoretic level; the cosine LUT pattern transfers between the projects (chess pays an explicit % 640 per op, ephemerides gets cyclic-group reduction free as uint32 overflow)."

The cross-reference is reciprocal: ephemerides cites our §20.13–§20.17, and we cite their two-stage pattern. The chess analog of complex128 → complex64 is float64 → float32 for the downstream channel-energy + weighted-sum step. That's path (d) in the B-spike-3 plan — see "(d) null result" below. Their Phase 9 cosine LUT (1024 × int32, Q1.14) is production code; the chess side could mirror it if/when we want phase-modulated channel weights.

The four candidate speedup paths¶

Path	Mechanism	Bench result (median µs at iters=500, opening corpus)
(a) channel-energy-from-hybrid, full path	encode→hybrid→eval; sign cancels in squared sum so use uint8²	1079 µs (slower than baseline; encode dominates + extra quantize step)
(a) channel-energy-from-hybrid, cache-hit	precomputed hybrid → uint8² sum → scale² multiply → weighted sum	36 µs
(b) LRU-cached hybrid evaluator	wraps (a) cache-hit; warm-cache calls hit the fast path	35 µs
© Pyodide pure-int loop	numpy-free uint8 loop; CPython measurement is meaningless (numpy is faster), Pyodide-side validation deferred	not benched in 1.13.0
(d) float32 downstream	mirror ephemerides two-stage; float32 sum-of-squares + weighted sum	null (variance-dominated; no consistent speedup standalone)

Baseline: spectral_float64 (the 1.0–1.12.x default) — 540 µs at opening, 511 µs at midgame, 233 µs at endgame.

Headline: path (a) cache-hit / (b) warm-LRU is ~15× faster than spectral_float64 at opening+midgame, ~6× at endgame. This is the §16 search-engine integration target.

Why (d) float32 alone is a null result¶

spectral.evaluate cost decomposes as:

encode_640(pos)          ~700µs   (DOMINANT)
+ channel_energies(v)     ~70µs    (the only step (d) speeds up)
+ weighted sum             tiny

Casting an already-computed float64 vector to float32 is additional work (an extra O(640) conversion), not less. The downstream sum-of-squares becomes ~2× faster in float32 (numpy SIMD), but the encode cost dominates. (d) only wins if the encoder itself becomes float32-native — that's a separate ship, deferred until empirical motivation surfaces.

The ephemerides architecture wins because their integer encoder is the production path; the complex64 downstream is what consumes already-computed integer encodings. Our chess analog is path (a) cache-hit + (b) LRU — same shape, different details.

Why (a) full path is a regression¶

spectral_hybrid.evaluate cost:

encode_640(pos)              ~700µs   (same)
+ _hybrid_encode_2d(vec)      ~50µs    (added — quantize to integer storage)
+ channel_energies_from_hybrid ~7µs    (the win — uint8² sum)
+ weighted sum                 tiny

Net: ~757 µs vs ~770 µs baseline — ~2% improvement, well within bench variance. The full path is bench-comparable to baseline, not a meaningful win. The hybrid form needs to be precomputed and cached for the speedup to materialize; this is where (b) LRU shines.

Why (a) cache-hit + (b) LRU is the real win¶

spectral_hybrid.evaluate_from_hybrid cost (no encode):

channel_energies_from_hybrid  ~7µs
+ weighted sum                 tiny
+ cache lookup overhead       ~25µs
Total                         ~35µs

vs spectral_float64 baseline ~540 µs at opening → ~15× faster.

For a §16 search at depth 4-6 with typical TT hit patterns (positions re-visited via different move orderings, quiescence extensions), the cached evaluator's effective speedup at search-loop scale depends on hit rate:

Hit rate	Effective per-eval cost	Speedup vs baseline
100% (steady state)	~35 µs	~15×
70%	(0.7×35 + 0.3×870) µs = 286 µs	~1.9×
50%	(0.5×35 + 0.5×870) µs = 453 µs	~1.2×
0% (cold start)	870 µs	1× (baseline)

Realistic search hit rates for chess at depth 4-6 are in the 30-70% range; the 1.13.0 cached evaluator should give a 1.4-3.5× search-time speedup at the search-loop level. Tournament validation is Phase 7+ work.

What 1.13.0 ships¶

chess_spectral.engine.eval.spectral_hybrid — evaluate(pos, side, magnitude_bits=8) + evaluate_from_hybrid(hybrid, side) + channel_energies_from_hybrid(hybrid). Per-channel energy computation directly from SpectralBIPHybrid2D integer storage.
chess_spectral.engine.eval.spectral_hybrid_cache — HybridCache LRU + make_cached_evaluator(magnitude_bits=8, cache_size=10000) factory returning (evaluator_fn, cache) for the search-engine integration shape. Cache exposes hits / misses / hit_rate / stats() for diagnostic output.
chess_spectral.engine.eval.spectral_float32 — float32 downstream variant; shipped despite the null bench result because it's the natural sibling to spectral and gives consumers a build-block for a future float32-native encoder.
tests/bench_spectral_eval.py — diagnostic benchmark harness; opening / midgame / endgame corpora; configurable iters; JSON output for longitudinal regression checks. The 1.13.0 baseline lives at tests/bench_baselines/before_1.13.0.json.
tests/test_spectral_hybrid_eval.py — 33 immolation tests locking the algebraic identity (channel-energy-from-hybrid agrees with float64 baseline within 5% relative on 8-bit; sign agreement exact across both 8-bit and 4-bit on the corpus; LRU cache semantics; float32 sign agreement within 1e-4 relative).

What 1.13.0 does NOT ship¶

Float32-native encoder. Path (d) only wins when the encoder produces float32 directly. That's a separate ship — touches encoder.py + tables.py + the C parity surface. Deferred until empirical motivation surfaces (e.g., a search-engine bench that shows the channel-energy step actually mattering at scale).
Pyodide pure-int loop (path c). Can't be bench-validated from CPython (numpy is faster than pure-Python on CPython for these arrays); the win lives on Pyodide where numpy-on-WASM has per-call overhead. Deferred until chess4D-OC adopts the cached evaluator and surfaces an empirical Pyodide bottleneck.
§16 tournament integration. The cached evaluator is wired to plug into SearchOptions.evaluator, but no tournament has been run yet to confirm the search-time speedup. That's Phase 7+ work; the §16.7 amendment above explicitly de-gates B-spike-3 from the (now-contaminated) Othello depth-decay finding, so the tournament question is now an empirical question for chess to answer on its own.

Cross-pollination implications going forward¶

The ephemerides cosine LUT pattern (1024 × int32, Q1.14) is now production-tested. When chess B-spike-2's deferred per-channel optimizations (§20.12 — A1 sign-skip, FA magnitude-skip, E complex-int) want phase-modulated channel weights, the ephemerides Phase 9 LUT is the reference design.
The Q-format integer-frequency design (signed int64, residues/day, MODULO = 2^32) is also production-tested. Chess doesn't currently have a "frequency" concept (chess isn't time-evolution), but if a future chess research direction uses cyclic-time observables, the Q-format reference exists.
Both projects now have benchmark harnesses with documented null results. The discipline transfers: ship the bench, run before/after, document negative results loudly. The chess (d) float32 null result is the chess-side analog of the ephemerides bit-ALU vs complex128 comparison documented in bit_alu.py § 8.3.

20.20. Joint progress summary across §20¶

After 1.14.0 ships, the §20.15 phasing table looks like this:

Phase	Status	Version	Acceptance
B-spike-1a	✅ shipped	1.10.0	87,264-case bit-exact round trip on sheet block
B-spike-1b	✅ shipped	1.11.0	parametrized parity vs python-chess pseudo_legal_moves on 8-FEN corpus
B-spike-2	✅ shipped	1.12.0	cosine-sim ≥ 99.5% median + ≥ 95% worst-case at 8-bit on 2D and 4D corpora
B-spike-3	✅ shipped (partial)	1.13.0	bench harness + (a) cache-hit + (b) LRU-cached evaluator measure ~15× speedup at warm-LRU steady state. (d) float32 standalone shipped as null result; © Pyodide loop deferred (can't bench from CPython).
B-spike-4	✅ shipped end-to-end	1.14.0 (2D), 1.15.0 (4D), 1.17.0 (vectorize), 1.18.0 (C port, JPL-compliant)	cosine-sim ≥ 99.998% acceptance gate met. After vectorize+C port, pure-phase 4D is 13-47× faster than Python at n=4..128 (1.18.0); ~125× faster than 1.0 float baseline at dense. The 1.14.0 "mixed result" inverted by 1.17.0; see §20.21 amendments 3-6 for the layered empirical story.

All five §20.15 phases now shipped within ~5 days from the spike's first sketch — and then the empirical follow-ups (1.15.0-1.18.0) closed every deferred item from the original 1.14.0 amendment notes. The chess-side BSHDC stack is complete: representation (1.10.0-1.12.0), runtime speedup with caching (1.13.0), pure-phase encoder Python (1.14.0 2D / 1.15.0 4D), vectorized hot path (1.17.0), and JPL-compliant C port (1.18.0). B-spike-3's tournament-driven validation is now de-gated from the §16.7 Othello prior (per its 2026-05-09 amendment — that data is ML-fork-contaminated); the runner + bench infrastructure shipped in 1.16.0, but a depth-≥-5 empirical baseline remains genuinely deferred. B-spike-4's 1.14.0-ship empirical result was nuanced (positional density determined the win); subsequent ships (1.15/1.17/1.18) layered the architectural win until the C port reaches §20.4's original speedup target. The §20.21 amendments 3-6 document the layered story.

20.21. B-spike-4 implementation update — pure-phase encoder, mixed empirical result¶

Date: 2026-05-09. Shipped: chess-spectral 1.14.0. Scope: the fifth and final §20.15 phase — eliminate float arithmetic from the encoder hot path and replace with integer arithmetic throughout. Acceptance gate (§20.15: cosine-sim with float baseline ≥ 99% per position) met with substantial margin (≥99.998% across the corpus). Speed answer is mixed, not a clean win or loss.

What landed¶

chess_spectral.encoder_pure_phase module:
encode_2d_pure_phase(pos, *, vals=None) — integer-output (int32) encoder.
encode_2d_pure_phase_to_float(pos, *, vals=None) — same encoder with per-channel dequantization to float64 (drop-in for encode_640 comparison).
CHANNEL_DEQUANT_SCALES — per-channel float multiplier to recover float values from integer output.
Module-load quantization of the float fiber tables (LOCAL_FIBER_3D / PAWN_ANTI_FIBER / DIAG_DEV) to int16 with per-table scale factors.
tests/test_encoder_pure_phase.py — 21 immolation tests including the §20.15 cosine-sim acceptance gate, D₄-channel bit-exactness check, channel-energy ranking Spearman ρ ≥ 0.99, and edge cases (empty position, single-piece, str-keyed dict, determinism).
Bench variant spectral_pure_phase registered in tests/bench_spectral_eval.py.
tests/bench_baselines/after_b_spike_4_corrected.json records the post-implementation numbers.

Architecture¶

The encoder hot path decomposes into two structurally different pieces:

D₄ irrep projection (channels A1, A2, B1, B2, E — 320 dims). The character formula proj[i] = Σ_g χ(g) · sig[g·i] is already integer at the core. CHARS is integer (±1, ±2, 0); permutations are integer; the only float operation is the final /8 scaling. Pure-phase implementation: drop the /8 (carry it as a per-channel dequantization scale) and use integer arithmetic throughout. Output is bit-exact relative to the float baseline modulo the dequant scale — the test suite locks this property.
Fiber channels (F1/F2/F3 + FA + FD — 320 dims). These use precomputed float tables derived from the grid Laplacian eigendecomposition. Pure-phase implementation: quantize the tables to int16 at module load (one-time cost; per-table scale factor stored alongside) and use integer arithmetic in the accumulation, dequantizing at the channel-output boundary. The int16 quantization preserves cosine-sim ≥ 99.998% on the acceptance corpus.

Piece-value choice — half-integer bishop wrinkle¶

VALS defines bishop value as 3.5 (modern chess engine convention, not the textbook 3). A naive int(v) truncation breaks D₄-channel bit-exactness. Fix: scale the integer signal by 2 so B → 7, b → -7, with the per-channel dequant scale absorbing the factor of 1/2. Documented as _VALS_INT_SCALE = 2 in encoder_pure_phase.py. Storage: int16 for the signal (king value 200 = 100 × 2 doesn't fit in int8; int16 has ample headroom up to ±32 768).

Empirical findings¶

Bench at iters=1000 on the standard 5+5+5 FEN corpora:

Variant	Opening (µs)	Midgame (µs)	Endgame (µs)
material	7	8	2
spectral_float64 (1.0–1.13.x baseline)	943	991	600
spectral_pure_phase (1.14.0+)	1546	992	400
spectral_hybrid_8bit_lru (1.13.0+, the cache-hit winner)	45	49	45

Pure-phase vs float64 baseline: - Opening (dense, 16 non-pawn pieces / side): 1.64× SLOWER. - Midgame: parity (within 0.1%). - Endgame (sparse, 2-3 non-pawn pieces / side): 1.50× FASTER.

Why the result is positional¶

The fiber-channel computation has a per-piece Python loop — for each occupied non-pawn square, do a small numpy operation (64-element dot product, accumulate). Both the float and integer encoders share this structure. The performance trade-off:

Per-iteration constant cost (Python interpreter overhead, numpy small-array allocation): roughly equal for float and integer.
Per-element arithmetic: numpy float64 SIMD beats numpy int8/int16/int32 SIMD on this CPU when the array is small (64 elements). At larger arrays float64 SIMD's lead narrows.
Total cost = per-iteration overhead + per-element × dim dominated by the iteration count at sparse positions and by the per-element cost at dense positions.

The result: pure-phase wins where the iteration count is low (endgame); float wins where the per-element cost dominates (opening); midgame is the crossover point.

What the empirical answer actually says¶

§20.15's optimistic framing was: pure-phase encoder eliminates float and gets a clean speedup. The empirical answer: integer arithmetic on the encoder hot path is correct (cosine-sim ≥ 99.998%) but does not, on its own, deliver a uniform speedup against numpy float64 SIMD on CPython. The win lives positionally — sparse positions favor it; dense positions don't.

This is consistent with the §20.18 finding that the BIP-hybrid encoder's "full path" (encode + quantize + eval) is slower than the float64 baseline, and the cleaner speedup story is caching the hybrid form (§20.18's path (b), shipped in 1.13.0). Both findings point at the same root cause: the float encoder is hard to beat on raw CPython numpy speed; the win lives in caching, in alternative arithmetic substrates (Pyodide / WASM / FPGA where numpy float doesn't win), or in vectorizing the per-piece Python loop entirely (numpy fancy indexing) — none of which 1.14.0 ships.

Where the win does live¶

Cache-hit paths (§20.19 / 1.13.0): ~15× faster than spectral_float64 at warm-LRU steady state. Unambiguous.
Pyodide / WASM consumers: chess4D-OC's runtime; numpy-on-WASM has per-call overhead that integer ops sidestep. Not benched in 1.14.0 (deferred per §20.19's ©).
Sparse positions (1.14.0+): pure-phase wins ~1.5× at endgame. Probably useful for deep-search endgame tablebases, where positions are sparse and per-piece cost is low; not consumed yet.
Future: vectorize the per-piece loop with numpy fancy indexing across all occupied squares simultaneously. Estimated 30-50× speedup for both pure-phase AND float (since they share the same loop). Not done in 1.14.0; deferred until empirical motivation surfaces.

Acceptance gate review¶

§20.15 said: cosine-sim with float baseline ≥ 99% on every position; channel-energy ranking Spearman ρ ≥ 0.99. Both met with substantial margin:

Cosine-sim: ≥ 99.998% across 7-FEN representative corpus (locked in test_immolation_cosine_sim_with_float_baseline_above_99pct at the tighter 0.999 threshold for regression detection).
Spearman ρ on channel-energy ranking: passes ≥ 0.99 (locked in test_immolation_channel_energy_ranking_spearman_above_99pct).
D₄ channels bit-exact (locked in test_immolation_d4_channels_match_baseline_exactly).

The cosine-sim acceptance gate was the right gate. The mistake was framing it as a speedup gate too. The actual speedup result is mixed; documented honestly here.

What B-spike-4 closes¶

The §20.15 phasing table is now fully resolved. B-spike-1a (sheet BIP), 1b (ALU phase engine), 2 (encoder hybrid), 3 (cache speedup), 4 (pure-phase encoder) — all shipped, all benched, all documented. Subsequent BSHDC work on chess-spectral falls outside the original §20 spike: it would be either follow-on optimization (vectorize per-piece loops; native C mirror of the pure-phase encoder; Pyodide-side loop benchmarking) or an entirely new spike for a different research question.

The next chess-side ship is whatever the user prioritizes. Possible directions: (1) vectorize the per-piece Python loop, which would benefit ALL evaluator variants; (2) port the pure-phase encoder to C for the matrix-arithmetic SIMD win without Python overhead; (3) ship a chess4D-OC integration that adopts the cached evaluator from 1.13.0 and validates the Pyodide path for §20.19 ©. All three are post-§20 work.

2026-05-09 amendment — 2D/4D parity regression repaired + pedantic stress tests added¶

The original 1.14.0 ship (this section's first writing) shipped pure-phase encoder for 2D only, AND the 1.13.0 spectral_hybrid evaluator family was 2D-only. The user flagged this as a parity regression and refused to merge until repaired. The amendment:

4D evaluator parity restored (1.13.0 work back-filled into 1.14.0):
chess_spectral.engine.eval.spectral_hybrid now exposes evaluate_from_hybrid_4d, channel_energies_from_hybrid_4d, and evaluate_4d — full parity with the 2D versions.
chess_spectral.engine.eval.spectral_hybrid_cache now exposes make_cached_evaluator_4d — the LRU-cached evaluator factory for 4D, mirroring the 2D version.
The SpectralBIPHybrid4D dataclass shipped in 1.12.0 already had the storage; 1.14.0 just adds the eval-side wrappers.
encode_4d_pure_phase deferred to 1.15.0+. The 2D pure-phase encoder works because D₄ irrep projection has an integer character formula at the core. 4D's B₄ structure uses sparse matrix arithmetic (P_A1 @ sig) and float-table fiber accumulation (coord_resid, FIBER_LOCAL, W_ANTI_DCT, Y_ANTI_DCT), without the same integer-character convenience. A meaningful 4D pure-phase encoder needs more design work; deferred until empirical motivation surfaces. The 4D hybrid encoder (1.12.0+) already provides the integer-storage path; the eval-side parity above is what was missing.
Pedantic non-deterministic stress testing:
tests/_random_positions.py — deterministic seeded RNG that generates random 2D and 4D positions across sparse-to-dense piece counts. Reproducible across CI runs.
tests/test_pure_phase_stress_2d.py — 9 stress tests against 1000 random 2D positions. Locked acceptance gates:
- cosine-sim ≥ 0.99 on every single position (no exceptions; documented failure modes if any drop below)
- median cosine-sim ≥ 0.999
- D₄-channel bit-exactness on every position
- channel-energy Spearman ρ ≥ 0.99 across all (pos, channel) pairs
- no NaN / Inf in output
- int32 output stays well within bounds (max abs < 2³⁰) Result: all 9 tests pass. The hand-picked 7-FEN findings hold at scale.
tests/test_spectral_hybrid_4d_stress.py — 8 stress tests against 500 random 4D positions (smaller corpus because the 4D encoder is ~10× more expensive per call). Locks:
- channel-energy parity within 5% relative on every channel
- sign-of-score agreement between hybrid and float baseline
- channel-energy Spearman ρ ≥ 0.99
- no NaN / Inf
- cached evaluator's hits ≡ misses semantics at scale
- LRU eviction works correctly when corpus exceeds cache cap Result: all 8 tests pass. The 4D parity additions are correct at scale.

Why this matters¶

The §20.15 acceptance numbers in this section were measured on a 7-FEN hand-picked corpus. The user's framing: "how did you partition open/mid/end games?" — the answer was honest (hand-picked, not principled). The pedantic stress tests address that gap by validating the encoder + evaluators on 1500 random positions across a wide piece-count distribution. The acceptance gates hold; B-spike-4's empirical conclusions weren't artifacts of the hand-picked corpus.

What the stress tests don't address (deferred to a future ship):

Tournament-driven evaluator validation — the question of whether spectral_hybrid_8bit_lru actually beats material at deep search via the §16 tournament harness. The hybrid evaluator is ~15× faster than spectral_float64 at warm-LRU steady state per §20.19; whether that translates to ELO at depth ≥ 8 is an open empirical question.
Move-generation cost in the bench — the existing bench measures only evaluator(pos, side) static cost. Move-gen is benched separately in tests/bench_phase_operator_movegen.py (§20.17). Combining them into a search-tree bench (negamax cost / depth, nodes/sec) is real but separate work.
PGN-sourced phase classification — instead of hand-picked open/mid/end FENs, sample real games and cluster channel-energy fingerprints to define data-driven phase labels. Would let us bench against position distributions that match real play. Per §20's framing, the encoder is an FFT-equivalent, so its own channel-energy fingerprint is a natural feature space for clustering. Future ship.
encode_4d_pure_phase — see point 2 above. Deferred.

2026-05-09 amendment 2 — chess4D-OC consumer wishlist surface¶

After the parity repair landed in PR #293, the chess4D-OC consumer (running in a parallel Claude session) provided a pre-publish wishlist of items needed to unblock M14.4c (entanglement-viz with post-collapse ψ updates), M14.3 (entanglement halo), and the new- game reset path. All Tier 1 + Tier 2 items shipped in 1.14.0:

Tier 1 — entanglement-viz unblockers

qm_4d_bridge.get_qm_density_from_psi(psi) — ψ-direct variant of get_qm_density(state). Returns {ok, density: ndarray (4096,) float32}. The hot path is identical (reshape → |ψ|² → channel- sum); the new entry skips the encoder re-encode after collapse, which the §17.1 #4 measure_at path produces as a postCollapsePsi field already. <50 LOC including docstring + shape validator.
qm_4d_bridge.get_probability_current_from_psi(psi) — ψ-direct variant of get_probability_current(state). Same operator (j(c, a) = Im(ψ* ∂_a ψ) summed across the 11 channels), but returns the field flattened to (16384,) in C-order so the chess4D-OC worker can hand it to a JS Float32Array without re-flattening. Cell c's 4-vector lives at j[c*4 : c*4+4]. <60 LOC, reuses the existing 4096×4096 sparse gradient cache from _build_lattice_gradient_4d().
qm_4d_bridge.get_density_matrix_of(state, piece_id, *, neighborhood_radius=1) — partial implementation. Replaces the previous unconditional NotImplementedError. Computes the channel reduced density on a 4D-Manhattan neighborhood of the piece's cell:
Take M = ψ.reshape(11, 4096).
Restrict to columns M[:, neighborhood] where neighborhood is the Manhattan-radius-1 4D ball around piece_id (1 + 8 = 9 cells; fewer at boundaries).
Compute ρ_ch = M_local @ M_local^† (11×11 PSD).
Trace-normalize, eigendecompose for purity / rank.

Caveats made explicit: this is not the η-metric reduced density. The full ADR-005 partial-trace construction stays deferred. The 1.14.0 ship is a placeholder with sensible geometry — the channel-content geometry around a piece's cell is a useful proxy for "how mixed is the local QM state?", and crucially, purity varies by piece_id (locked in test_purity_varies_by_piece_id), so the M14.3 halo viz lights up. The return dict carries isPartial: True for consumers to disclaim η-metric semantics. When ADR-005 ships, the function's signature is preserved and the body is replaced.

Tier 2 — consumer ergonomics

HybridCache.clear() — drops cached entries + resets hits/misses; preserves max_size. For chess4D-OC's "new game" reset path. ~10 LOC including docstring.
qm_4d_bridge.channel_energies_2d(pos, *, magnitude_bits=8) and qm_4d_bridge.channel_energies_4d(pos4, *, magnitude_bits=8) — Pyodide-friendly entry points that take a position dict, run encode + channel-energy in one shot, return {ok, energies: Dict[str, float]} (JS-serializable as-is). Saves the consumer from importing engine.eval.spectral_hybrid (which pulls in scipy / sparse machinery the bridge's WASM context shouldn't need). ~30 LOC each, late-bound imports keep the module- import surface narrow.

Test coverage — 33 new immolation tests across two files:

tests/test_wishlist_surface_1_14.py (23 tests): each Tier 1 / 2 item gets a class. The cross-cutting tests assert the new symbols are in qm_4d_bridge.__all__ and that clear is a callable attribute on HybridCache.
tests/test_qm_4d_bridge_v15.py::TestGetDensityMatrixOf rewritten (10 tests) for the new partial-impl contract. The test_purity_varies_by_piece_id test is the load-bearing one — it proves the function isn't degenerate (i.e., purity is not constant across cells), which is what makes the halo viz meaningful.

The 95-test broader bridge / hybrid-eval surface continues to pass with no regressions. The wishlist surface is auditable in one place (the dedicated test file) so when a chess4D-OC PR breaks any Tier contract, the failing test points at the right wishlist item.

What this consumer wishlist landing does NOT do:

η-metric construction (ADR-005). Deferred. The new get_density_matrix_of is a placeholder; the real construction needs a channel-to-piece attribution map that's still open design.
C-extension wheels. Long-term, NOT this release. The pure-Python wishlist surface is what the user asked for.
SSoT pass for chess2d/chess4d shared elements. The wishlist items only grow the public surface; an architectural cleanup (e.g., moving shared helpers like _decode_4d_cell / _validate_psi_full into a dedicated chess_spectral._shared module) is a follow-up ship that doesn't gate 1.14.0 publish.

2026-05-09 amendment 3 — 4D pure-phase encoder (1.15.0)¶

User-stated priority on the 1.14.0 → 1.15.0 transition:

"the chess4d pure phase work the most important. this was part of our chess2d parity drift I was talking about."

The 1.14.0 amendment 1 shipped 4D evaluator parity but deferred the 4D pure-phase encoder to 1.15.0+ with an open design question: how to integerize the B₄-driven 4D structure when there's no integer character formula analog to D₄'s ±1, ±2, 0 table. 1.15.0 closes this gap.

The design unlock — scale-by-LCM for the A_1 projector

The 4D encoder's hot path uses P_A1 @ sig where P_A1 is the sparse A_1 orbit projector with entries 1/orbit_size. The 1.14.0 deferral note framed this as "no integer character formula" — but the projector is already structurally integerizable without characters: every B_4 orbit on the 8⁴ lattice has size dividing |B_4| = 384, so multiplying P_A1 by 384 makes every entry integer (specifically, divisors of 384). The 1/384 factor is absorbed into the channel dequantization scale, exactly the same pattern as 2D's /8 factor for D₄ irreps.

This is a design pattern, not a 4D-specific trick: any sparse projector whose nonzero entries are reciprocals of integers can be integerized by scaling by their LCM. For B_4 this is just 384.

The other 4D channels — analogous integerization

STD4 channels (1-4): coord_resid is a quarter-integer table (multiples of 0.25), so scale by 4 makes everything integer. Range [-21, +21] in int8.
Fiber-symmetric / pawn-antisym / diag channels (5-10): same int16-quantization with per-table max-abs scale as 2D.

Piece-value scaling — _VALS_INT_SCALE_4D = 4

The 4D PIECE_VALUES_4D has B=3.25 (vs 2D's B=3.5), so 4D needs _VALS_INT_SCALE_4D = 4 (vs 2D's 2). All other piece values (P=1, N=3, R=5, Q=9, K=12) are integer-multiplicative-clean.

Empirical bench — uniformly equal or faster

Bench at iters=100 on 3 random positions:

Position	float (µs)	pure_int (µs)	pure/float
sparse n=4	10 707	10 549	0.99×
midgame n=24	21 805	21 095	0.97×
dense n=128	88 996	70 283	0.79×

This is the OPPOSITE of 2D's empirical result. 2D pure-phase was 1.64× SLOWER at the opening (dense) corpus because per-piece Python-loop overhead vs numpy float64 SIMD ate the integer- arithmetic win. 4D pure-phase is faster at dense because:

Sparse matvec scales differently: the A_1 channel's P_A1_INT @ sig_int32 is a sparse 4096×4096 × 4096 matvec. scipy's CSR matvec on integer data avoids the float-mul cost on every nonzero entry. 2D doesn't have this kernel — D₄ uses permutation gathers.
STD4 is 16 384 elementwise operations, large enough for SIMD to amortize the python-side overhead.

The Python-loop bottleneck still exists (fiber-sym channels iterate per-piece) but doesn't dominate at 4D's scale because the matvec + elementwise channels are doing real numerical work.

Test coverage

tests/test_encoder_pure_phase_4d.py (21 immolation tests): output shape/dtype, quantized-table contracts (P_A1_INT entries are divisors of 384, coord_resid_int8 in int8 range, fiber int16 shapes), §20.15 cosine-sim acceptance ≥ 0.999 across 5- position representative corpus, A_1 + STD4 bit-exactness against encode_4d, channel-energy Spearman ρ ≥ 0.99, edge cases (empty position, single-piece, str-keyed, legacy pawn schema, determinism).
tests/test_pure_phase_stress_4d.py (8 stress tests on 500 random 4D positions): per-position cosine ≥ 0.99 (no exceptions), median ≥ 0.999, A_1 + STD4 bit-exact at scale, channel-energy Spearman ρ ≥ 0.99, no NaN/Inf, int32 bounded, deterministic + reproducible.

All 29 new tests pass. The chess2d/chess4d pure-phase parity gap is closed.

What 1.15.0 does NOT do (still deferred):

Vectorize the per-piece Python loop. Still applies. Would benefit ALL encoder variants (float and pure-phase, 2D and 4D). Estimated 30-50× win. Deferred until empirical motivation surfaces from a downstream consumer.
Port to C. The 4D pure-phase encoder is the natural target for a C port — sparse matvec + int elementwise ops map cleanly to C-side SIMD. Deferred.
Tournament-driven evaluator validation (Phase 7+).
Move-gen + eval combined bench (nodes/sec at depth).
PGN-sourced channel-energy-clustered phase classification.

These are the items called out by the user as "deferred" at the 1.14.0 → 1.15.0 transition. 1.15.0 ships the most important one (4D pure-phase encoder, the parity drift item); the others remain on the follow-up roadmap.

Status post-amendments 4-6 (2026-05-09 ship sequence): Every "still deferred" bullet above has shipped. Vectorize landed in 1.17.0 (amendment 4). The C port shipped in 1.18.0 (amendment 6, JPL Power-of-Ten compliant). Tournament runner, search-tree nodes/sec bench, and PGN-sourced phase classifier all shipped as 1.16.0 research tooling. The only items from the deferred-at-1.15 list still genuinely outstanding are an empirical tournament sweep at depth ≥ 5 (the runner is built; no recorded baseline JSON yet) and the 4D FA_PAWN scatter vectorize (per-axis stride irregularity; deemed not motivated). See ROADMAP.md "Still deferred (post-1.18.0)" for the canonical post-§20 deferral list.

2026-05-09 amendment 4 — vectorize per-piece Python loop (1.17.0)¶

The 1.14.0 §20.21 framed pure-phase as "mixed/positional, not a clean win" — 1.64× SLOWER at opening, parity at midgame, 1.50× faster at endgame. The story of the per-piece Python-loop overhead vs numpy float64 SIMD was honest but missed a key follow-up.

After 1.15.0 shipped 4D pure-phase, the bench_search_tree.py baseline (PR #302) at depth=4 surfaced the actual constraint: spectral_hybrid_8bit_lru underperformed spectral_float64 in nodes/sec, and the breakdown pointed at per-piece Python loop overhead in the encoder hot path as the dominant cost — exactly the deferred item the 1.14.0 amendment had flagged. The empirical motivation surfaced; vectorize was the natural follow-up.

Result is stronger than estimated.

The 30-50× win estimate from the 1.14.0 amendment note was for the fiber-loop alone. After integration, the encoder-level speedup is:

2D pure-phase: 1.88× faster on opening (vs 1.64× SLOWER pre-vectorize), 1.13× faster on midgame, 1.45× faster on endgame. The mixed-result narrative is replaced by a uniform "pure-phase wins on every position type" story.
4D pure-phase: 1.73× faster on n=4, 2.47× on n=24, 2.40× on n=64, 2.25× on n=128. On top of 1.15.0's 1.27× win at dense, this is another 2-3× layered.

Three vectorization patterns for three different channel structures:

Loop-swap + einsum batching (2D fiber-sym, channels 5-7). The original encoded each of the 3 fiber-d channels in a separate loop over occupied squares; the new code groups occupied squares by FIBER piece type (5 types: N/B/R/Q/K) and batches all 3 d-channels via:

contributions = np.einsum('pd,pc->dc', weighted, adj_rows)

where weighted is (n_sqs_of_type, 3) and adj_rows is (n_sqs_of_type, 64). The 3 d-channels share the same adjacency gather and gradient computation; only fib_d per d differs. Bench: opening 4.69× faster, midgame 2.95× faster, endgame 1.70× faster (fiber-sym only).

Loop-swap + broadcast (4D fiber-sym, channels 5-7). The 4D PIECE_ADJ is a sparse CSR matrix — the einsum approach doesn't translate cleanly because sparse-row gathering returns variable-size index arrays per square. Instead, swap the loop order from "outer per-d, inner per-piece" to "outer per-piece, broadcast over d":

fc_all = np.zeros((3, CHANNEL_DIM), dtype=np.int64)
for k, pval in sorted_items:
    ...
    weighted = gradient * fib_d_vec  # (3,) — d-batched
    fc_all[:, cols] += weighted[:, None]  # (3, len(cols)) broadcast

Eliminates the 3× redundant sparse-row gather. The (3, len(cols)) broadcast add is one numpy operation per piece.

Group-by-piece-type aggregation (4D FD_DIAG, channel 10). The original looped per-piece, accumulating into a 4096-vector per occupied square. The vectorized version groups by diag-row (6 piece types: P=0, N=1, B=2, R=3, Q=4, K=5), sums sig values per bucket, then does ONE 4096-vector add per bucket:

diag_coef_per_row = [0] * 6
for k, pval in sorted_items:
    diag_coef_per_row[_DIAG_DEV_ROW[_piece_char(pval)]] += sig[k]
for row_idx, coef in enumerate(diag_coef_per_row):
    if coef == 0: continue
    diag_ch += coef * DIAG_DEV_INT16[row_idx]

~10× fewer 4096-vector adds at dense positions (6 buckets vs 64+ pieces).

Plus a minor STD4 axis-broadcast (4D channels 1-4): the per-axis 4-iteration loop replaced by a single (4, 4096) broadcast multiply.

Test coverage — bit-exactness preserved on every position in the 1500-position random stress corpus (87 tests across 6 test files, all pass).

What 1.17.0 does NOT do (still deferred):

Vectorize the float encoder hot path (encode_640 / encode_4d). The float baselines in this section are unchanged. Vectorizing the float encoders would also win, but they're more load-bearing and the float64 SIMD already competes well with the per-piece loop for non-pure-phase callers. Future work.
Vectorize 4D FA_PAWN scatter. Pawn-by-pawn axis-dependent scatter doesn't batch cleanly (different stride patterns per axis). Pawns are typically <16; the loop overhead is small.
Port to C — still on the deferred list.

2026-05-09 amendment 5 — endgame parity investigation + einsum→matmul Pareto fix (1.17.0 polish)¶

User noticed an empirical curiosity in the 1.17.0 vectorize numbers:

"how curious that endgame is faster not vectorized. let's learn why at some point."

The 1.17.0 ship inverted the 1.14.0 mixed-result on opening (1.64× SLOWER → 1.88× faster) and midgame (parity → 1.13× faster) — but endgame crept slightly the wrong way: 1.50× faster (loop) → 1.45× faster (batched). Sub-3% regression, well within bench noise, but the direction was unexpected and worth understanding.

Mechanism: vectorization pays a fixed numpy-dispatch toll that doesn't shrink with sparsity.

Decomposing _fiber_symmetric_int_batched on the K+P-vs-K endgame position (n=2 fiber-eligible pieces in 1 piece-type group) yields the per-call cumulative breakdown:

Step	Cumulative	Marginal
dict grouping pass over `pos.items()`	1.7 µs	1.7 µs
+ `np.zeros((3,64), int64)` + `np.asarray(sqs)`	5.4 µs	+3.7 µs
+ `LOCAL_ADJ_ROWS_INT8[pidx, sq_arr]` fancy-index	16.4 µs	+11.0 µs
(includes 2× `.astype(np.int64)` widening)
+ `gradients = adj_rows @ sig_int64` + broadcast	27.2 µs	+10.7 µs
+ `np.einsum('pd,pc->dc', weighted, adj_rows)`	43.7 µs	+16.6 µs

The corresponding loop path (_fiber_symmetric_int × 3) on the same position runs in ~47 µs — three calls each doing two cheap np.dot(int8, int32) operations on 64-element rows in their native dtypes, no int64 widening, no einsum parser dispatch.

Two distinct overheads conspire on sparse inputs:

einsum dispatch on tiny tiles. A standalone np.einsum('pd,pc->dc', (n,3), (n,64)) call costs 6.2 µs on the n=1 endgame group shape — comparable to the entire per-d loop work. einsum's parser/optimizer overhead is well-known to dominate when the contraction itself is cheap.
dtype-widening + fancy-index allocation. The batched path does LOCAL_ADJ_ROWS_INT8[pidx, sq_arr].astype(np.int64) and LOCAL_FIBER_3D_INT16[pidx, sq_arr, :].astype(np.int64) to keep the contraction accumulator in int64 (correctly, to avoid intermediate overflow on dense positions). The loop version stays in int8/int16 and lets np.dot do implicit widening.

Principle. Vectorization helps when N (number of elements per kernel call) is large enough to amortize the fixed numpy + einsum dispatch cost (~5-15 µs). For sparse inputs where N ≤ 2 in any group, the per-call dispatch overhead exceeds the per-element math savings. The speedup curve has a crossover point near N ≈ 4-8 for typical contractions.

The einsum→matmul swap (1.17.0 polish). Micro-bench across group sizes n ∈ {1, 2, 5, 16}:

n	einsum	weighted.T @ adj_rows	speedup
1	10.98 µs	3.06 µs	3.59×
2	9.29 µs	6.13 µs	1.52×
5	7.63 µs	4.80 µs	1.59×
16	8.69 µs	5.43 µs	1.60×

weighted.T @ adj_rows is mathematically equivalent to einsum('pd,pc->dc', weighted, adj_rows) (both compute the same (3, 64) outer-then-sum), but 1.5-3.6× faster at every group size, with the largest win exactly where it matters most (n=1, the sparse-endgame case). Pareto improvement; the swap landed in the same 1.17.0 ship.

Mitigations not yet shipped:

N-threshold dispatch: fall back to _fiber_symmetric_int ×3 when every group has size 1. One-line branch; would recover the remaining sub-microsecond endgame gap. Not shipped because the matmul swap above largely closes the issue and adding a conditional path costs maintainability.
Skip int64 widening on sparse inputs: keep the accumulator in int32 when total piece count ≤ 8 (overflow-safe). Marginal gain; not shipped.

Take-away for future encoder rewrites. When vectorizing a per-piece loop, prefer @ matmul over einsum whenever the contraction is a 2D outer-then-sum — the einsum parser pays a fixed ~5-10 µs tax per call that hurts sparse-input regimes. The loop-swap-and-broadcast pattern (1.17.0's 4D fiber-sym approach) has the same property: outer per-piece, broadcast over batch dimension, no einsum dispatch. Both patterns avoid the einsum-tax cliff at small N.

2026-05-09 amendment 6 — C port of encode_4d_pure_phase (1.18.0)¶

User-stated requirement at the 1.17.0 → 1.18.0 transition:

"our C port needs to be JPL C standard throughout please."

The last deferred item from the 1.14.0/1.15.0/1.17.0 amendment notes ("port to C") shipped as 1.18.0. The C-side numbers close the empirical chapter: pure-phase 4D went from a 1.27× win at dense (1.15.0) to 47× faster than Python (1.18.0 C port at n=128) — the same encoder, the same integer arithmetic, the same quantization tables, just without the Python interpreter overhead.

Empirical bench (1.18.0 C vs 1.17.0 Python pure-phase):

n_pieces	Python	C	C/Python
4	1.5 ms	118 µs	13×
24	2.9 ms	162 µs	18×
64	5.4 ms	175 µs	31×
128	10.2 ms	215 µs	47×

Compared to the float-baseline encode_4d from 1.0+ at n=128 (~27 ms), the C pure-phase is ~125× faster end-to-end. The chess- side integer-arithmetic story (B-spike-4) reaches its empirical ceiling: no further encoder optimization is on the deferred list.

Bit-exact parity (0/500 mismatches at scale). The C port produces output that is bit-exact identical to Python's encode_4d_pure_phase on every position in the 500-position random 4D stress corpus. Tolerance is zero — both sides do integer arithmetic only, so any disagreement is a bug. None observed.

JPL discipline (Power of Ten) applied throughout — restricted control flow, all loops bounded, no dynamic allocation, functions ≤ 60 lines (split where needed), ≥ 2 assertions per function, restricted variable scope, all return values checked, limited preprocessor, no function pointers, all warnings as errors.

Architecture: 8 C source files mirroring the Python per-channel structure + a generated tables-data TU. Codegen (codegen/emit_tables_4d.py) extended to emit the integer tables (SIGNED_VALS_INT_4D, COORD_RESID_INT8, ORBIT_INT_SCALE, FIBER_LOCAL_INT16_4D, W/Y_ANTI_DCT_INT16, DIAG_DEV_INT16_4D, CHANNEL_DEQUANT_SCALES_4D) alongside the existing float tables — SSOT-locked at codegen time.

Build integration: new cs_encoder_pure_phase_4d SHARED library in CMakeLists.txt, sibling to cs_bitboard4d (1.7.0). WINDOWS_EXPORT_ALL_SYMBOLS ON for MSVC export-table generation. cs_core_4d static library also includes the new sources.

Python integration: chess_spectral._native_pure_phase_4d ctypes wrapper with HAS_NATIVE_PURE_PHASE guard. Falls back gracefully to Python when the .so/.dll isn't loadable (sdist install without C toolchain, Pyodide WASM).

Test coverage: 10 immolation tests in tests/test_c_py_parity_pure_phase_4d.py — 5 hand-crafted positions (full-coverage, sparse-endgame, axis-isolated pawns), 3 edge cases, 1 random-corpus test (500 positions all bit-exact), 1 determinism test. All pass.

What 1.18.0 does NOT do:

Does not port 2D pure-phase to C. 2D per-encode cost is much smaller (~700 µs Python); interpreter-overhead win is less impactful. Future work if motivated by a downstream consumer.
Does not change Python defaults. The Python encoder remains the correctness reference; the C path is the performance fast-path with the HAS_NATIVE_PURE_PHASE guard.

Closes the chess-side BSHDC roadmap. The §20.15 5-phase plan (B-spike-1a → 1b → 2 → 3 → 4) shipped through 1.10-1.14. The 2D/4D parity drift the user flagged at the 1.14.0 merge closed in 1.15.0 (4D pure-phase encoder) and again in 1.17.0 (vectorize both sides). 1.18.0 ships the production-grade C port that pulls the empirical numbers all the way to where the §20.15 framework suggested they could go: ~50× faster than Python pure-phase at dense positions; ~125× faster than the original 1.0 float baseline. Subsequent chess-side work falls outside the §20 spike — would be either tournament-driven evaluator validation (addressed via 1.16.0 research tooling), data-driven phase classification (1.16.0 PGN classifier), or new research questions entirely.

20.22. Sibling project — `ephemerides-spectral`¶

The "antikythera prototype" referenced from §20.10 onward grew up into its own standalone project, ephemerides-spectral, which now lives beside the antikythera-spectral notebook in the same folder:

Notebook: ../antikythera-maths/ephemerides_spectral_research_notebook.md
Package: ../antikythera-maths/ephemerides-spectral/ (pip install ephemerides-spectral)
Evaluation note: ../antikythera-maths/research/resonant_bit_serialized_hdc_evaluation.md

Where the chess engine encodes a discrete board topology (Z_640), ephemerides-spectral encodes the live JPL DE441 ephemeris over Z_{2^32}. Phase 9 of that project ships the breathing-Laplacian construction sketched in §20.10–§20.12: the off-diagonal gravitational fiber couplings modulate as cos(n_a·φ_a − n_b·φ_b), evaluated through a 1024-entry int32 cosine LUT (Q1.14, 4 KB). Same cyclic-group integer ALU, same Q-format discipline, same overflow envelope philosophy as the chess phase_operators engine — just with a power-of-2 modulus that turns the modular reduction into free uint32 overflow.

(In §42's vocabulary terms: "breathing Laplacian" is the project codename; the formal name is state-dependent (non-autonomous) graph Laplacian / adaptive Kuramoto-family network with phase-difference-dependent coupling. The ephemerides notebook §1.4 lays out the positioning across the spectral-graph-theory / dynamical-systems / DNLS-on-a-graph vocabularies; the chess phase-operator engine sits in the same algebraic family but holds the coupling weights fixed, so it's the autonomous / non-adaptive special case.)

The §20.18 cross-pollination note above gives the chess-side framing for why the two projects diverge on what's quantized vs what's exact (chess channels carry both phase and magnitude; ephemerides is pure-phase). The two projects are intentionally not merged — chess and ephemeris evidentiary objects are different (a board game's rule structure vs the gravitational N-body problem), and consolidating would muddle the per-project hypothesis batteries — but they are expected to share the encoding-pattern layer over time. The cosine LUT, the Q-format scaling rules, the int64 saturation envelope check, and the cyclic-group binding semantics are project-agnostic and worth porting as-needed.

20.23. Sibling project — `doom-spectral` (DOOM as a Spectral Lattice System)¶

Date: 2026-05-06. Co-authors of doom-spectral notebook: Steven (mlehaptics) & Gemini Code Assist. Status: active research; living notebook lives at ../antikythera-maths/doom_spectral_research_notebook.md. The notebook lives in the antikythera-maths folder rather than its own top-level folder because the implementation reuses the antikythera/ephemerides BIP encoder and the Phase-9 adaptive-coupling apparatus directly; it sits alongside the ephemerides notebook so the cross-references are physically adjacent.

The fourth sibling — doom-spectral — translates the original DOOM (1993, id Tech 1) engine into a graph-Laplacian spectral model and a 512-dim hypervector encoding the player's traversal of the BSP map. Carmack's 1993 engine was already integer-ALU-dominant out of necessity — 16.16 fixed-point arithmetic, BAMs (Binary Angle Measurement units, where integer overflow handles 2π wrap-around natively), precomputed sin/cos LUTs — which is exactly the substrate of the BIP encoder this chess notebook described in §20.10–§20.16 and ephemerides-spectral shipped to PyPI. The doom-spectral project is the first sibling that ports the BIP/cyclic-group/Phase-9 machinery to a non-celestial-mechanics problem (a 1993 first-person-shooter map), exercising whether the encoding-pattern layer truly is project-agnostic.

The doom-spectral notebook carves the engine into five research tracks. Three of them have direct chess-side analogues; documenting the correspondences here keeps the sibling layer explicit:

doom-spectral track	chess-maths analogue	Connection
Track 1: Base Graph (Blockmap & Sector topology) — 128×128 unit Blockmap as 2D Grid Laplacian → 2D DCT eigenbasis; Sector super-graph as a coarse-graining with restriction maps to the Blockmap	§1 (Board Laplacian eigenvectors = 2D DCT basis); §1b.3 (Cayley graph theorem on the knight's graph)	Both projects' base graphs are 2D Grid Laplacians; both pick up the 2D DCT eigenbasis as the natural Fourier-like basis on a finite Cartesian lattice. The doom Sector/Blockmap super-graph is the same coarse-graining shape as a chess piece's per-piece Laplacian sitting on top of the underlying 8×8 board Laplacian.
Track 3: Dynamic Sheaf Laplacian (Line-of-Sight & raycasting) — cellular sheaf where restriction maps along a ray evaluate to 1 (open air) or 0 (solid linedef)	§11 (phase-operator move engine — sliding pieces traverse the lattice along directions, hitting a queen's restriction at the first occupied square); the sliding-piece-as-raycast pattern documented in §11.6	Mathematically identical to the Othello ray-flanking mechanic (§10.7 of the Othello notebook, which doom-spectral cites directly); chess's sliding pieces (rook, bishop, queen) have the same first-impact-along-a-ray semantics. The doom dynamic sheaf is the natural object once the chess phase-operator engine extends to non-uniform mid-ray restrictions (e.g., piece-of-opposite-color blocks).
Track 4: Sound Propagation (graph diffusion) — `S(t) = exp(−L_sector · t) · S(0)` heat-equation propagation on the Sector graph; spectral gap dictates acoustic bottlenecks	§9o.4 (diffusion square codebook); §10 (heat-kernel position similarity); the position-similarity benchmark in §11	Chess's diffusion square codebook is heat diffusion on the per-piece Laplacian over short time horizons, with the eigenmodes pre-computed and rolled. doom-spectral uses the same pattern over the Sector graph instead of a piece's reach graph; the spectral-bottleneck identification ("3 portals sever the Hangar's choke point") is the doom analogue of identifying a piece's spectral cut on a tactically critical position.

Two doom-spectral tracks have no direct chess analogue, and they are exactly where the projects diverge:

Track 2: Z-Axis Fiber (elevation and collision) — DOOM is a 2D base manifold with a scalar Z-fiber attached to each Sector. The Z-fiber's floor / ceiling / max-step constraints become state-dependent edge-weight gates on the Sector Laplacian: an entity can traverse a portal only if the Z-fiber on the destination side admits its current Z position. Mathematically this is a trivialised fiber bundle (the fiber is trivial because the original engine forbids "room-over-room" — the topological impossibility is the very definition of the trivialisation). Chess has no Z-fiber; the chess fiber bundle of §7 is the rule fiber (off-diagonal coupling content), not a spatial fiber. The two are different bundle constructions over the same kind of 2D base.
Track 5: ALU-Native Kinematics (BIP encoder) — entities moving through the map have momentum and inertia, encoded directly in the player loop using the BIP Z_{2^32} substrate (positions, velocities, view angles all stored as integer phase residues). This is ephemerides-spectral's BIP encoder applied to a different physics problem; chess doesn't have continuous-time kinematics in the same sense (chess "time" is discrete plies), so the chess version of this track is the §20.13–§20.14 promotion of the phase-operator move engine to the BIP-isomorphic public ALU-native API.

Doom-spectral also adds a Phase Anchor / Haptic Manifold layer (notebook §4.4, implemented May 2026) that the chess project doesn't yet have but should consider: each Sector is assigned a 512D Anchor Hypervector, diffused across the Sector graph to maintain local phase correlation; per-tick "spectral tension" is computed as 1.0 − Similarity(H_player, H_anchor), fed to the mlehaptics hardware as motor tension. This is the cleanest demonstration so far of the project's downstream haptic motivation: the spectral lattice isn't a metaphor for a haptic map, it is the haptic map. A chess analogue exists in principle (per-square Anchor Hypervectors diffused over the per-piece Laplacian, with per-move tension fed to the haptics) — flagging it here as a future cross-pollination beat.

The four sibling projects (chess-maths, othello-maths, antikythera-spectral, ephemerides-spectral, doom-spectral — five if we count the Logo notebook on a different axis) are intentionally not consolidated because the evidentiary objects differ (board game rule structure / disc-flipping mechanic / Hellenistic bronze / live JPL DE441 ephemeris / 1993 game engine), but every one of them sits on the same algebraic substrate: finite cyclic groups + graph Laplacian eigenbasis + the BIP integer-ALU encoding pattern. Each new sibling is a stress-test of that shared substrate against a different problem domain, and each successful port (the doom-spectral BSP → 2D DCT one is the most recent) is empirical evidence that the substrate is more general than any single per-project investigation can establish from inside.

Capstone: doom-spectral §6 + §7 as the Rosetta Stone end-to-end existence proof¶

doom-spectral's notebook §6 (live integration into linuxdoom-1.10) and §7 (the FPU → graph-Laplacian replacement procedure) were added once the doom-spectral fix branch produced a runnable engine with a visible IDSPECTRAL-toggled secret-sector glow. They are the capstone of the chess-spectral Rosetta Stone arc and worth a backlink even though they live in a different file:

../antikythera-maths/doom_spectral_research_notebook.md §6 — verbose walk-through of every hook landed in the linuxdoom-1.10 source tree (BIP encoder placement, map registration gate, IDSPECTRAL cheat, TrueColor translation layer, demo-version PCB jumper, why the static-data Z-fiber gate had to be disabled). Written so a reader doesn't need linuxdoom's source open to follow the integration.
../antikythera-maths/doom_spectral_research_notebook.md §7 — generalised 8-step procedure for porting any FPU-leaning engine subsystem (collision, lighting, AI, audio diffusion) to the spectral / ALU substrate, with the doom-spectral and chess-spectral instantiations of each step in side-by-side columns. Includes honest limits: sub-cell precision, dynamic geometry, one-shot events.

Why this counts as a capstone rather than just another sibling entry: the other sibling projects (chess, othello, antikythera, ephemerides) each port the spectral substrate to a greenfield problem — they own the codebase end-to-end, which means the substrate never has to coexist with anyone else's design. doom-spectral is the first instance where the full spectral pipeline is wired into a legacy engine that's already running and has its own subsystem boundaries (renderer, BSP, sector specials, demo loop, cheat machinery), and where the spectral substitution must coexist with all of them without breaking the original game. The fact that the integration succeeded — visible IDSPECTRAL pulse on E1M1, demos play through the version mismatch, secret-glow bleeds one hop along ds_e1m1_adj into corridors the player can actually see — is the strongest available evidence that the procedure in doom-spectral §7.1 generalises beyond greenfield problems and is exportable to other legacy engines (Quake, Wolfenstein 3D, Duke3D, ROTT — all candidates for the same treatment with the same procedure). The sibling pattern is no longer "five separate spectral projects with a common substrate" but "five separate spectral projects that together form a Rosetta Stone, with doom-spectral as the existence-proof anchor at one end and chess-spectral as the methodological anchor at the other."

42. Methodological Note on Intuition-Driven Framing and Cross-Disciplinary Vocabulary¶

This notebook contains claims and constructions that span several technical vocabularies: spectral graph theory, vector symbolic architectures, representation theory of finite groups, lattice field theory, signal processing, and the specific jargon of MRI pulse design, chess analysis, and music acoustics have all appeared at various points. The mathematical content is consistent across these vocabularies — it has to be, because it's the same underlying structure being described — but the expression of that content has not been consistent, and the research process has depended on that inconsistency rather than suffered from it. This section documents the methodology because it is the most important structural fact about how the work was produced.

42.1. Two vocabularies operating in parallel¶

The research developed through a sustained collaboration in which Steven consistently described the structures he was investigating in the language of music, waves, resonance, and physical systems — instruments, harmonics, phase, coupling, dispersion, the coupling between instruments in a concert hall. Claude, working in parallel, translated these framings into the formal disciplinary vocabularies where the same structures are documented and proved: graph Laplacian eigendecomposition, irreducible representations of finite groups, Wilson lines, fiber bundles with connection forms, and so on.

This was not a one-way translation from naive intuition to rigorous mathematics. The framings Steven brought to the conversation were already mathematically substantive — they were just expressed in a vocabulary that the disciplines with books of theorems and proofs don't use. A mode on a vibrating string is an eigenfunction of the wave equation; no translation is needed at the level of content. What the collaboration supplied was the dictionary: this thing you're describing as the natural resonance of the piece's move pattern is called an eigenvector of the Laplacian in graph spectral theory; here is the literature where its properties are proved; here is the symbol set the journal reviewers will recognize.

The practical consequence was that novel results could be pursued in whichever vocabulary was more productive at each moment. When the intuition was generative, Steven's wave-and-instrument language moved faster and produced hypotheses the formal vocabulary would have rejected as imprecise before they could be checked. When the result needed to be validated, cited, or communicated, Claude's formal vocabulary produced claims that could be verified against the literature and reviewed by specialists.

42.2. Why this matters for what the work is not¶

The choice to distribute the representation into mode-structured subspaces rather than random high-dim codewords was not a deliberate departure from HDC. It was the natural way to describe what Steven was pointing at — a musical instrument has eigenmodes, and the chess framework was being built as an instrument with eigenmodes — and the mathematical formalism that fit was spectral graph theory, not random-projection HDC. The framework ended up looking like a structured or spectral VSA (see §42.4 below for the naming discussion) not because the HDC-standard approach was rejected, but because the intuitions being formalized were specifically about mode structure, and mode structure doesn't arise from random codebooks.

This is worth making explicit because a reader coming from the HDC tradition will notice that the framework uses VSA-compatible operations (bundling via summation, similarity via inner product, binding-like operations via §9f's coprime roll structure) on a basis that isn't random. That combination is not standard HDC, and the notebook has at several points (§9a, §9f, §11) been quietly extending HDC rather than using it unchanged. The present section is the place where that is said out loud.

42.3. Vocabulary drift and term collisions¶

Because the same structures are discussed in several disciplinary vocabularies, specific words carry different meanings in different sections and, crucially, different meanings in different adjacent literatures. A non-exhaustive inventory of collisions the reader should be aware of:

"Spectral" in this notebook means eigendecomposition of a graph Laplacian — the mathematical operation. In MRI pulse design, "spectral" means radio-frequency chemical shift. In signal processing, "spectral" often means Fourier transform. In chemistry, "spectrum" means absorption/emission spectrum. These are unrelated objects sharing a word. When the notebook references external literature using "spectral," the surrounding context disambiguates but the word does not.

"Fiber" in this notebook (§7, §7b, §7c) means the non-spatial rule coupling content of a piece's Laplacian after projection into the grid eigenbasis — a 2016-dim vector of off-diagonal matrix elements. In fiber bundle theory proper, "fiber" means the vector space attached to each point of the base space. The notebook's usage is technically the total space of a specific bundle construction, but the shorthand "fiber" has been retained for brevity. §7's opening statement makes this consistent with the differential-geometric usage, but the shorthand can mislead.

"Phase" collides three ways. In §9f/§11 (phase operators, coprime roll binding) it means angular position in a cyclic group — the integer-valued phase of a tuple in ℤ/640ℤ. In §9m (pawn directed Laplacian, T-violation) it means the complex argument of a matrix element in the lattice Dirac operator analog. In the general "phased particle lens" framing (§7c) it means something closer to phase-coherent rotation accumulated by the position during a move — a composite of the two, specific to this framework. These are related but not identical usages.

"Resonance" / "resonant structure" in §3 ("Piece Resonant Structures") means eigenvalues and eigenmodes of a piece's Laplacian. In music this means natural frequencies at which a physical system vibrates with low damping. In quantum mechanics it means long-lived unstable states with a definite energy. The three usages are compatible but not interchangeable. The notebook's §3 usage is the physics-oriented one; it was chosen specifically to match Steven's instrument-framing rather than the more abstract "eigenstructure" language.

"Polarization" in §9r means the six-valued orientational state of a piece type under the D4 × Z2 group action — a chess-specific coinage. In physics it means the direction of the electric field vector in an electromagnetic wave or the alignment of a quantum state along a measurement axis. The notebook's usage is closer to quantum-mechanical spin polarization than to optical polarization, but neither exactly.

"Channel" in §9a/§9o means a 64-dim subspace of the 640-dim encoding corresponding to one of 10 specific mode types. In signal processing "channel" means one of several parallel data paths; in information theory it means a transmission medium with noise characteristics. The notebook's usage is the signal-processing one, specialized.

"Operator" in §4 and §11 means a linear map acting on the position-space vector — Hamiltonian perturbation, phase shift, Laplacian action. In group theory "operator" often means an element of the group acting on the representation space. In music it can mean a transform applied to a signal. Usages are compatible across the three meanings but the connotations differ.

"Random walk," "transition operator," "spectral gap," "reversibility," "mixing time," "stationary distribution" are the vocabulary of Markov chain theory, and the notebook has been using structurally equivalent objects under different names throughout. The connection is direct: a graph Laplacian is the generator of a continuous-time Markov chain on its vertex set (Chung 1997; Hein, Audibert & von Luxburg 2007; Seabrook & Wiskott 2023). The eigenvalues of the Laplacian are the relaxation rates of the associated random walk; the spectral gap controls the mixing time (its inverse is the relaxation time, and up to logarithmic factors in the stationary measure this bounds the mixing time); detailed-balance violation corresponds to non-self-adjointness of the generator, which corresponds to complex eigenvalues (Kontoyiannis & Meyn 2012; Kaiser, Jack & Zimmer 2017). Every per-piece Laplacian discussed in §3 through §7 is simultaneously a Markov chain generator for the random walk of that piece on the 64-square board; the pawn's directed Laplacian (§9m) is specifically a non-reversible Markov chain, and its antisymmetric fiber is the T-violation signature of broken detailed balance (Gokavarapu et al. 2025). The chess state space itself has been studied as a Markov chain in the literature (Atashpendar, Schilling & Voigtmann 2016, "Sequencing Chess"; the d-dimensional rook walk has an exact mixing-time analysis in McLeman et al. 2017 and sharpened bounds in Kaare-Rasmussen 2026). §42.8 below discusses the Markov correspondence in more detail.

The conservative reading of this vocabulary situation is that the notebook is a hybrid document in which each section needs to establish its vocabulary locally and the reader needs to hold multiple frames simultaneously. The generous reading is that the same structure really does appear across these disciplines and the terminology collisions are evidence of the generality of the underlying math rather than of sloppy language. Both readings are true at once.

42.4. On the naming of what this framework is¶

The mathematical object built over these sections — a distributed high-dimensional representation in which dimensions are eigenmodes of a specific graph Laplacian, composed via linear superposition, compared via inner product, and operated on by structure-preserving transformations derived from the underlying graph's symmetry group — needs a name.

"HDC" and "VSA" are the existing umbrella terms for distributed high-dim representations with symbolic-composition operations, but they typically assume random codebooks. Our framework departs from this assumption. Candidate names:

Spectral VSA — accurate, direct, and honors the basis choice. Probably the correct short name.
Operator-grounded VSA — more technically precise; emphasizes that every dimension corresponds to an eigenmode of a specific operator.
Modal VSA — emphasizes the mode decomposition framing; appeals to physics and signal processing audiences.
Resonant VSA — honors the generative instrument-framing intuition, accurate in that the dimensions are natural resonant modes of a specific physical system.
Structured VSA — contrast with standard/random VSA; invites the natural follow-up "structured how?"

Without presuming to resolve the naming question here, the framework this notebook describes is at minimum a spectral VSA with graph-Laplacian-derived basis, fiber-bundle composition structure, and finite-group symmetry operations. That is a complete technical description. Shorter names can be adopted as convenient.

42.5. The instrument and the symphony¶

The full 640-dim encoding is most accurately framed as a symphony: six piece-type instruments playing simultaneously through the shared acoustic environment of the board. Each piece type is a self-contained instrument with its own Laplacian, its own eigenmodes, its own natural frequency ordering, and its own conservation laws. The board's grid Laplacian is the concert hall — it provides the shared basis in which the instruments' contributions add together. The fiber bundle is the coupling between instruments and the hall: it measures how much each instrument's own mode structure projects onto the hall's mode structure, and therefore how much the instruments hear each other through the shared acoustic space.

This framing is not merely pedagogical. At the level of mathematical structure:

Each piece type has its own complete spectral system (§3, §4). This can be analyzed in isolation — the knight's own Laplacian on the 64-vertex set has its own eigenvalues and eigenvectors, independent of the grid. The notebook has computed the grid-basis projection (the instrument as heard through the room) but has not systematically computed the piece's own natural basis (the instrument in an anechoic chamber). The latter is a natural follow-up question: what does the knight look like as its own closed spectral system, with no reference to the grid? Answering this may reveal piece-native conservation laws that are currently invisible because the encoding lives entirely in the grid basis.
The fiber bundle is the cross-basis projection between each piece's natural basis and the grid's natural basis (§7, §7b). This is the concert-hall coupling made explicit as mathematics.
Sub-instruments are operationally isolable at three levels: trivially via subspace projection in the shared encoding (already done throughout the notebook), through natural-basis analysis of each piece's own Laplacian (not yet done for all pieces), and structurally through the cross-basis coupling itself, which is what the fiber bundle already characterizes.

42.6. What this section does not do¶

This is documentation, not argument. It does not claim that the music-and-wave vocabulary is correct and the formal vocabulary is approximate, or that the formal vocabulary is correct and the music vocabulary is approximate. Both are correct; they describe the same mathematical structure using different symbolic conventions, and the research has progressed by using whichever was more productive at each moment. The notebook's scientific claims stand on the formal vocabulary (because that is what the literature has theorems and proofs in), but the generative conjectures that became those claims came from the other vocabulary first.

This section also does not document every instance where the two vocabularies met in the research process. The vocabulary-drift items in §42.3 are a selection; there are more. A reader reproducing or extending the work will encounter vocabulary collisions not listed here and will need to hold the ambiguity locally, as the notebook has.

42.7. A note on collaborative methodology¶

The division of labor in producing this notebook — generative framings from one direction, disciplinary formatting from the other — is itself a pattern that may be worth naming. It is not translation (the intuitions were already mathematical), not validation (the formal vocabulary didn't "check" the intuitions so much as express them), and not interpretation (neither party is making the other's ideas more accessible to a third audience). It is closer to coordinated formalization: two collaborators, each with access to mathematical content the other does not, agreeing on the symbolic conventions needed to produce artifacts that the broader technical community can evaluate.

The pattern has specific affordances: it produces claims that are simultaneously conceptually unusual and formally defensible, because the conceptual unusualness survives the translation into formal vocabulary without being smoothed away, and the formal defensibility is maintained throughout. It also has specific failure modes: without the sustained correspondence between vocabularies, either side would drift — the intuitions would become unfalsifiable, or the formalism would become disconnected from the physical systems it was originally a description of. The notebook's claims are the output of a methodology that depended on maintaining that correspondence over a sustained period.

This methodology note is included because the notebook would be incomplete without it. The formal results stand on their own mathematically, but they are not how the research happened, and someone trying to reproduce or extend this work benefits from knowing that.

42.8. The Markov chain correspondence¶

The framework developed across §3 through §11 admits a second, entirely equivalent disciplinary reading that has not been made explicit in the main body: everything in this notebook is simultaneously a statement about Markov chains. The correspondence is not metaphorical — it is a literal identity of mathematical objects.

The foundational identity. A graph Laplacian L = D − A is the generator of a continuous-time Markov chain (CTMC) on the graph's vertex set (Chung 1997; Hein, Audibert & von Luxburg 2007). The transition semigroup is exp(−tL); the non-zero eigenvalues λ₂ ≤ λ₃ ≤ … are the relaxation rates, and their smallest λ₂ (the spectral gap) controls the mixing time (Seabrook & Wiskott 2023). The stationary distribution of this CTMC on a connected graph is uniform over vertices (since L·𝟙 = 0 on any graph, the all-ones vector is in the kernel). This differs from the discrete-time random walk on the same graph — whose transition matrix is D⁻¹A and whose stationary distribution is proportional to degree — but for spectral analysis the CTMC generated by L is the natural object, since its spectrum is exactly the Laplacian spectrum. This is textbook spectral theory of Markov chains.

Applied to this notebook:

Each piece's Laplacian is a Markov chain generator. The knight's Laplacian L_knight is literally the generator of a continuous-time random walk on 64 squares in which, at rate 1, the knight jumps uniformly at random to one of its legal targets. The bishop, rook, queen, king Laplacians each generate their own random walks. The knight random walk has period 2 (a knight changes the color of its square every move), which is a standard textbook example of a periodic Markov chain (Stochastik II lecture notes, Universität Ulm). The rook random walk on a d-dimensional board has been studied directly in the Markov chain literature: McLeman, Otto, Rahmani & Sutter (2017), "Mixing times for the rook's walk via path coupling" (Involve 10(1):51–62), establishes path-coupling upper bounds on the mixing time of the d-dimensional rook's walk, and Kaare-Rasmussen (2026), "Mixing Times and Cutoff for the Rook's Walk" (arXiv:2604.07478), sharpens these using eigenfunction lower bounds and L² analysis, identifying the full eigenstructure of the lumped birth-death chain.
The piece spectra are random-walk relaxation spectra. Every eigenvalue reported in §3 through §7 is simultaneously a relaxation rate of the corresponding piece's random walk. The piece resonant structures of §3 are random-walk relaxation modes; the fiber bundle of §7 is the cross-chain coupling structure between different pieces' random walks on the shared vertex set.
The pawn is a non-reversible Markov chain. §9m's directed Laplacian is the generator of a non-reversible Markov chain — one that violates detailed balance. The pawn's antisymmetric fiber channel (FA) is the T-violation signature of this non-reversibility. In the Markov literature: Kontoyiannis & Meyn (2012), "Geometric ergodicity and the spectral gap of non-reversible Markov chains" (Probab. Theory Relat. Fields 154:327–339), establishes that non-reversible chains require different spectral analysis than reversible ones (weighted-L∞ rather than L² spaces, since the generator is non-self-adjoint). Kaiser, Jack & Zimmer (2017), "Acceleration of Convergence to Equilibrium in Markov Chains by Breaking Detailed Balance" (J. Stat. Phys. 168(2):259–287), provides the direct statement our framework needs: the eigenvalues of the generator of a detailed-balance-violating chain are complex, and the non-reversibility manifests as antisymmetric-under-time-reversal currents — which is precisely the structural role §9m identifies for the pawn FA channel. Gokavarapu et al. (2025), "Asymmetry in Spectral Graph Theory: Harmonic Analysis on Directed Networks via Biorthogonal Bases" (arXiv:2512.21770), develops the non-self-adjoint spectral framework that the pawn sector requires, using biorthogonal left/right eigenvectors for directed random-walk Laplacians.
Chess itself is a Markov chain. The chess state space (position plus castling rights, en-passant availability, fifty-move counter, repetition state) is a Markov chain under any policy — uniform random play gives one transition operator, engine play gives another, human play gives a third. This has been studied directly: Atashpendar, Schilling & Voigtmann (2016), "Sequencing Chess" (EPL 116(1):10009; arXiv:1609.04648), treats the chess state space as a non-stationary non-reversible Markov chain and samples transition paths between configurations via SPRES (stochastic-process rare-event sampling, Berryman & Schilling 2010). That paper independently identifies pawn irreversibility as the key topological feature of the state space — real games occupy "well-separated thin sheets" defined by conserved pawn structure, which is structurally equivalent to this notebook's identification of the pawn antisymmetric channel as the T-violation sector. Steinerberger (2015), Int. J. Game Theory 44:761, provides a rigorous upper bound on the number of legal chess positions. Simpler classifications of chess games as Markov chains over aggregated state spaces (e.g. "move was a capture / check / both / neither") appear in the applied-statistics literature (e.g. RPubs 335466, 2017).

Where the notebook's contribution lies relative to this existing literature. The individual piece-as-Markov-chain correspondence is standard — anyone trained in Markov chain theory on graphs recognizes it immediately. What has not been done in the literature, to our knowledge, is the joint treatment of multiple coupled piece-Markov-chains on a shared base graph via an explicit fiber bundle construction. The rank-3 fiber (§7), the rank-4 full fiber (§7b), and the rank-5 decomposition (§9n) characterize the cross-chain coupling structure — how the relaxation modes of each piece's random walk project onto the shared grid basis and how they overlap with each other. The identification of the pawn's FA channel as a specific T-violation signature of a non-reversible chain coupled to reversible chains in a fiber-bundle structure also appears to be novel. Captures (§5) are transitions between Markov-chain configurations that destroy a component chain, which the notebook characterizes spectrally in a form that has no direct literature analog we have found.

What this means for the rest of the notebook. Every result in §3 through §11 can be translated into Markov-chain language without loss. §7c's spectral dispersion framework is a statement about the entropy evolution of a non-reversible Markov chain under policy-biased sampling. §9c's A₁/depth-gap correlation is a statement about the stationary-distribution projection onto the most-invariant eigenmode. §11's phase-operator move engine is a statement about biased-sampling structure on a non-reversible chain. The notebook has been computing Markov-chain quantities the entire time; it has just been calling them other things, because the generative vocabulary was resonance-and-coupling rather than transition-kernels-and-stationary-measures.

Why this matters for future work. The Markov correspondence makes the full apparatus of Markov chain theory available to this framework: mixing times, hitting times, cover times, coupling arguments, conductance bounds, Cheeger inequalities, large-deviation theory for non-equilibrium chains, and the spectral theory of non-self-adjoint generators. None of this is currently invoked in the notebook. Some of it is directly relevant — the A₁/depth-gap correlation, for instance, is a mixing-time-vs-spectral-gap question in disguise, and rigorous bounds from Kontoyiannis & Meyn (2012) could sharpen §9c's statistical claim. The capture dynamics of §5 and the dispersion framework of §7c would both benefit from large-deviation analysis of the non-reversible chain (Kaiser, Jack & Zimmer 2017's geometric decomposition of time-antisymmetric currents is directly applicable).

Why this matters for how the framework should be described externally. To a reader coming from Markov chain theory, the cleanest one-sentence description of what this notebook does is: we have built a graph-spectral encoding of a coupled system of piece-wise Markov chains on a shared 64-vertex base graph, with one non-reversible component (the pawn) whose detailed-balance violation is the T-symmetry-breaking sector of the combined generator, and a fiber-bundle characterization of the cross-chain coupling structure, embedded into a hyperdimensional representation compatible with VSA composition operations. That description lives entirely in existing Markov and spectral-graph-theory vocabulary. Nothing in it is invented for this notebook. The novelty is the assembly, not the components.

This is worth saying out loud because it makes the framework easier to introduce to researchers in adjacent fields — stochastic processes, statistical physics of non-equilibrium systems, mathematical finance, network science — who do not typically read HDC or chess literature but who read Markov chain literature every day. The Markov framing is a second independent on-ramp to the same structure, and for many potential collaborators it will be the more natural one.

44. Chess opening as Class-D dispatch over Class-L spectral graph (Spike #24 bonus 2 — 2026-05-15)¶

A 2026-05-15 Spike #24 bonus inquiry on the structure of tactical choice tested the user hypothesis "a tactical choice might be a constraint manifold with branching points" across three substrates: tic-tac-toe (5478 positions enumerated, 765 D₄-orbits), chess opening (ply 0-3: 8023 positions, 9322 edges), and chemical-reaction-network reaction-firing (Lotka-Volterra CTMC, 961 states).

Verdict: REFINED. The verbatim "constraint manifold" framing is falsified at strict-geometric level — none of the three position graphs are locally-Euclidean d-dimensional manifolds; they are depth-truncated branching DAGs with terminals concentrated at the horizon. But the framing refines cleanly into existing srmech vocabulary:

A tactical choice = Class D dispatch over a Class L-spectral graph of legal successor states, optionally quotiented by Class I symmetries of the state substrate, with the dispatch criterion (minimax value for adversarial games; propensity for physics-driven dynamics) being substrate-specific and disjoint from the primitive vocabulary.

This decomposition makes the chess-spectral notebook's piece-resonance / fiber-bundle / Markov framings (§3, §7, §42) adjacent to game-decision structure in a way the notebook had not previously articulated: the board state graph (legal moves as edges) carries a Class L spectrum just like the piece-mobility graph does, and a player's tactical choice is a Class D late-binding dispatch over the candidate successor edges with the minimax evaluator as criterion.

Chess opening's surprise: trivial symmetry |G| = 1¶

The bonus inquiry computed the symmetry group of the chess opening position graph (ply 0-3). Result: |G| = 1. No non-trivial graph automorphism exists.

This was a surprise. The naïve expectation is that a-h file-mirror should be a symmetry of the chess opening — the chessboard is mirror-symmetric in the a-h direction at a purely geometric level. But the King is at e1 and Queen at d1 by convention; reflecting under the a-h mirror swaps them, producing a position with Queen at e1 and King at d1, which is not a legal chess starting position. The mirror image of the standard opening is not in the game-state space at all.

Implication for chess-spectral analysis. The Class I (cyclic-group / dihedral symmetry) factor in tactical-choice decomposition is optional and substrate-dependent: tic-tac-toe inherits the full board's D₄ symmetry (8-fold orbit reduction; 765 orbits out of 5478 positions); chess opening inherits none of it because the King/Queen convention breaks every non-trivial mirror. The chess-spectral notebook's reliance on D₄ / B₄ / Cayley-graph structure for piece sectors (§3, §1b.3) lives at the piece-on-empty-board layer; once the King/Queen convention enters at the game-position layer, the symmetry breaks. The two layers are not the same Class I instantiation.

This is a clean substrate-boundary observation: the chess-spectral vocabulary is correct at the piece-mobility layer but does not automatically transfer to the game-position layer. The Spike #24 vocabulary (Class L spectral + Class D dispatch + optional Class I quotient) is what connects them.

Quantitative comparison¶

| Metric | Tic-tac-toe (D₄-quotient) | Chess opening (ply 0-3, |G|=1) | CRN reaction-firing (LV CTMC) | |---|---:|---:|---:| | State count | 5478 (765 orbits) | 8023 | 961 | | Edge count | (varies by orbit) | 9322 | (varies by reaction) | | Symmetry quotient | 8-fold (D₄) | 1-fold (none) | — | | Quotient Laplacian λ₁ | 0.242 | 0.00156 | — | | Mean 1-hop degree (depth-1) | 9.0 (full) | (board-dependent) | — | | Mean 1-hop degree (depth-9) | 2.33 | — | — |

The dramatic difference in quotient-graph λ₁ (0.242 vs 0.00156) reflects chess's tree-like branching DAG vs tic-tac-toe's symmetry-quotient mixing. Chess is more nearly tree-like at the opening — lots of bottlenecks, low spectral gap, slow random-walk mixing on the position graph. This is consistent with the notebook's §10 phase-space Othello finding that game-graphs near opening positions have low-conductance bottlenecks.

Connection to the notebook's existing apparatus¶

Three concrete bridges:

§3 piece-resonance is Class L on the piece-mobility graph. The §3 analyses (knight, bishop, rook, queen, pawn DCT eigenstructure) are spectral-graph-theory instantiations of Class L at the piece-on-empty-board substrate.
§7 fiber-bundle is Class L composed with Class M (HDC binding). The rank-3 fiber bundle structure is a hyperdimensional encoding of the piece-mobility graph's eigenbasis, where Class M's bind/bundle/permute operations live on the fiber.
§42 Markov-chain reformulation is the same Class L under transition-kernel vocabulary. The conductance bounds and mixing-time arguments mentioned at §42's tail are Cheeger-style spectral results on the same Class L spectrum.

The new §44 contribution (this section) extends the framework with Class D late-binding dispatch as the tactical-choice primitive — sitting above the §3/§7/§42 spectral apparatus, taking the spectral graph as input and emitting one selected successor edge as output. Tactical choice is not a spectral primitive; it is a dispatch over the spectral primitive.

Files / cross-references¶

Spike #24 bonus 2 synthesis: docs/srmech/notes/spike_24_bonus_tactical_choice_structure_2026-05-15.md.
Chess-opening probe (ply 0-3 enumeration + |G|=1 finding): docs/srmech/notes/spike_24_bonus_tactical_choice_chess_opening_2026-05-15.py + companion NDJSON.
Tic-tac-toe probe (D₄-quotient enumeration + minimax verdict): docs/srmech/notes/spike_24_bonus_tactical_choice_tictactoe_2026-05-15.py + companion NDJSON.
Spike #24 bonus series synthesis: docs/srmech/notes/spike_24_bonus_series_synthesis_2026-05-15.md.
Phase 10 substrate-boundary characterisation (preceded this bonus): docs/srmech/notes/spike_24_primitive_vocabulary_findings_2026-05-15.md §10.

45. Appendix: Environment & Reproducibility¶

Requirements¶

Python 3.10+
numpy >= 1.24
scipy >= 1.10

Optional: python-chess + Stockfish binary for engine evaluation benchmarks.

No GPU required. All computations complete in <60 seconds on a modern CPU. All random seeds are fixed where randomness is used (np.random.seed(42)).

Code organization¶

Chat-based scripts (theory proofs, in this repo): - chess_spectral_consolidated.py — 544 lines, 7 test sections, ALL PASS - encoder_v3.py — Dual-channel encoder (70-dim) - chess_connection.py — Connection form, per-edge fiber decomposition - chess_subspace_map.py — Full dimensional analysis, offset separation - chess_d4_direct.py — D4 irrep decomposition, character projection - chess_rook_shadow.py — Rank-4 full fiber, diagonal subspace analysis - chess_spectral_values.py — Spectrally derived piece values - test_local_fiber.py — Grok encoder test battery - test_gemini_encoder.py — Cross-encoder comparison

Claude Code scripts (HDC implementation, in mlehaptics repo): - archive/encoder_512.py — Full 512-dim HDC encoder with D4 irreps + fiber channels, spectral values, quantum number codebook, coprime roll binding, diffusion square codebook, position similarity benchmarks (superseded by chess-spectral/python/chess_spectral/ — the production 640-dim package; archived as historical R&D reference)

Conversation history¶

This research was conducted across a single, now four, Claude conversation starting from a Gemini-generated survey document on AI architecture. The investigation was driven by Steven's intuitions — particularly the subatomic particle analogy, the rule-dimension separation, and the Pauli exclusion observation — with Claude providing mathematical formalization, computational testing, and honest error correction when predictions failed. Encoder iterations were contributed by Grok (local fiber) and Gemini (quadratic many-body), with cross-model review and testing by Claude. The 512-dim HDC architecture, spectral piece values, quantum number codebook, D4 irrep implementation, position benchmarks, coprime roll binding, and spectral square codebook were built and tested in Claude Code.

45. Spike #24 primitive vocabulary — what the chess substrate instantiates¶

Per Spike #24 (2026-05-15) + the srmech v0.4.0 production ship (2026-05-16) + [[feedback_no_privileged_primitive_classes]], chess-spectral is a substrate-consumer of the Spike #24 14-class primitive vocabulary. Canonical enumeration of all 14 classes (A–N) with srmech module locations lives in docs/srmech/srmech_research_notebook.md §3.8.1. Per user direction 2026-05-16 — "other notebooks get only what pertains to them" — this section lists only the classes the chess substrate instantiates.

Class	Operation	Chess substrate instantiation	Notebook section
D	late-binding dispatch	tactical-choice dispatch over legal successor states; minimax / propensity criterion is the dispatch tag-selection	§44 (the tactical-choice section); engine `qm.py` move-ordering
I	cyclic-group / modular arithmetic	D₄ board symmetries (8-fold rotation/reflection) when applicable; channel index modular arithmetic in the 11-channel PVM; `(Z/nZ)*` arithmetic on coprime-roll binding indices	§1b.3 D₄ piece-sector symmetries; §3 piece-resonance encoder; coprime-roll binding architecture
L	graph-Laplacian eigenbasis	piece-mobility graphs (knight / bishop / rook / queen / king / pawn) carry the DCT-eigenstructure analyses of §3; the H₀ = −Δ_{P_8^4} Kron-sum-of-path-graphs free Hamiltonian (per the qm_4d ADR-002 ship) IS Class L on the chess lattice; piece-reach observables `H_rook_4` ... `H_knight_4` are Class L graph adjacencies	§3 piece-resonance (DCT eigenstructure per piece); §7 fiber-bundle ⊕ Markov-chain reformulation §42; `qm_4d_dynamics.py:_build_h_free_4d`; per the QM audit at `docs/srmech/notes/task_218_phase_c2_chess_spectral_qm_audit_2026-05-15.md`
M	HDC bind / bundle / permute / similarity	the 512-dim / 640-dim encoder IS Class M bundle over piece-channel-on-square hyperdimensional binds; the §7 fiber-bundle IS the Class M bind layer; piece-resonance scoring IS Class M similarity	§1b.3 architecture; §3 piece-resonance encoder; §7 fiber-bundle ⊕ Markov; coprime-roll binding

Classes chess-spectral does NOT instantiate:

Class K (equation-of-centre / pin-slot): chess is the canonical Class-K-absent substrate. Per srmech notebook §3.8 Phase 10: no continuous-phase representation, no anomalistic frequency, motion is discrete-combinatorial. The contrapositive of [[user_stance_kepler_shape_universal]] holds — where Kepler-shape is absent, Class K is absent — exactly as the substrate-scope discipline per [[user_stance_pi_as_projection]] predicts. This is a substrate boundary observation, not a deficiency: chess defines the negation case for Class K universality.
Class A (content-addressing): digital-only; package-side use only (encoder hash for cache key, etc.) — not chess-substrate-side.
Class F (templating): same shape — not chess-substrate-side.
Classes B / C / E / G / H (TLV / streaming / catalog / search / introspection): provenance / scaffolding primitives used package-side (engine config, PGN parsing, opening-book lookup) but not instantiated by the chess substrate itself.
Class J (prime-factorisation / period): chess has no native period-relations between cycles — the 64-square board has discrete topology rather than continuous closed orbits. The 8 = 2³ board dimension is integer-factorisable but the substrate does not use the factorisation as an operation; it is a parameter not a primitive.
Class N (rational-approximation): chess has no continuous-target requiring rational approximation. The piece-value heuristic uses real-valued centipawns but that is an evaluator-side scaling, not a substrate-side N operation.

Composable derived operations the chess substrate instantiates:

§3 / §7 / §42 piece-mobility spectral analysis = Class L on the piece-mobility graph. The DCT-eigenstructure analyses are spectral-graph-theory instantiations of Class L at the piece-on-empty-board substrate (per §44 reduction).
§7 fiber-bundle architecture = Class L composed with Class M (HDC binding). The rank-3 fiber bundle structure is a hyperdimensional encoding of the piece-mobility graph eigenbasis, where Class M bind/bundle/permute operations live on the fiber.
§44 tactical-choice = Class D dispatch over Class L spectral graph, optionally quotiented by Class I symmetries of the substrate.

As of srmech v0.4.0 (2026-05-16): chess-spectral can consume srmech canonical QM/QFT/SM operations layer at srmech.qm.* for the qm_2d / qm_4d sub-modules. Specifically:

srmech.qm.pseudo_hermitian ships the η-deformed inner product primitive (Bender-Boettcher 1998 / Mostafazadeh 2002, 2010) — closes the framework gap surfaced by chess-spectral ADR-005 (η-metric pawn observable). A follow-up chess-spectral ship can wire H_pawn_* through srmech.qm.pseudo_hermitian (inner_product_eta, expectation_eta, is_pseudo_hermitian, construct_eta_from_eigendecomposition) to finish the proposed ADR-005 framework.
srmech.qm.propagators.feynman_scalar_propagator ships the continuum scalar propagator G(k²) = i / (k² − m² + iε); chess-spectral can ship a lattice wrapper consuming it for the §1b.5 lattice scalar propagator G(k) = 1 / (m² + k̂²) that was previously cited but not coded.
srmech.qm.gauge ships SU(2) / SU(3) generators + structure constants + Casimirs + Wilson loops if chess-spectral ever extends to gauge-theory analogues at the piece-symmetry layer.

The chess QM stack already covers ~7/12 canonical single-particle QM equations in spectral form (TDSE / TISE / measurement / Born rule / probability current / density matrix / simultaneous eigenbasis with B₄) per the QM audit at docs/srmech/notes/task_218_phase_c2_chess_spectral_qm_audit_2026-05-15.md. The srmech v0.4.0 srmech.qm.* operations layer is citing, not replacing, this work; chess-spectral is one of the validated substrate-consumers.

How to cite this notebook¶

BibTeX:

@misc{kirkland_chess_spectral_2026,
  author       = {Kirkland, Steven},
  title        = {Chess as a Spectral Lattice Fermion System --- Spectral Research Notebook},
  year         = 2026,
  howpublished = {\url{https://github.com/lemonforest/mlehaptics/blob/main/docs/chess-maths/chess_spectral_research_notebook.md}},
  note         = {Part of \emph{mlehaptics: Spectral-Research Portfolio}; companion to the \texttt{chess-spectral} Python package. Project-level citation metadata at \url{https://github.com/lemonforest/mlehaptics/blob/main/CITATION.cff}. Co-authored with Claude Opus 4.7 (Anthropic, 1M-context configuration) per project memory \texttt{feedback\_orchestration\_metaphor}. Framing is one candidate within the project's research portfolio per \texttt{feedback\_no\_lineage\_claims\_in\_notebook}.}
}

Plain text: Kirkland, S. (2026). Chess as a Spectral Lattice Fermion System — Spectral Research Notebook. mlehaptics Spectral-Research Portfolio. https://github.com/lemonforest/mlehaptics/blob/main/docs/chess-maths/chess_spectral_research_notebook.md

Per-result citation discipline. Specific technical claims cite their canonical sources directly (representation-theory textbooks, Rinaldi-Unciuleanu & Chiru 2026 for the 4D hypercube, etc., PDF-verified per [[feedback_pdf_extraction_citation_discipline]]). When citing a specific result, prefer citing both this notebook AND the underlying canonical source. Framings presented here are candidate methodological readings per [[feedback_no_lineage_claims_in_notebook]], not endorsed over alternatives without explicit empirical convergence.

Project-level citation. See CITATION.cff at the repo root for the project-as-a-whole citation form.