Phase-Operator Move Engine: Notebook Supplement

Status: working supplement — occupies the §11 slot in chess_spectral_research_notebook.md and will be merged in place once experimental validation is complete. Internal numbering §11.1 through §11.9 matches the target slot exactly. Prior-art cross-references assume the current notebook state through §9r (polarization reframing) and §10 (phase-space Othello).

Framing: this supplement investigates 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 ever consulting the 2D board coordinates. The goal is data, not theory. Each step defines a concrete computation and a concrete decision point. We do not know in advance whether the phase-operator formulation provides anything that the geometric generator does not. The point of the experiment is to find out.

Language discipline: throughout this supplement, movement is "phase transition," pieces are "polarization states" (or "locked-phase excitations"), the board is "the lattice domain" or "the coprime cyclic phase space," and decisions are thermodynamic (gradient-following) rather than strategic. Specific chess terminology is retained only where it references the validation ground truth (python-chess legal move sets).

Connection to UTLP S4: the central mechanism is the Chinese Remainder Theorem aliasing horizon from UTLP S4, applied spatially rather than temporally. Where S4 uses the horizon to detect temporal partitions between network nodes (HD vector similarity below threshold indicates temporal phase recovery is ambiguous), this supplement uses an analogous horizon to detect spatial partitions between polarization reachable sets (phase-tuple transformations beyond the polarization's characteristic horizon produce ambiguous destinations). Same mathematics, different domain.

---

§11.1. The Phase-Operator Hypothesis

§11.1.1 Statement

For each of the six polarization states {N, B, R, Q, K, P} parameterized in §9r (angle θ, mass/damping, T-symmetry class, Z₂ charge), there exists a characteristic phase-shift operator P_polarization such that:

• Applied to the phase tuple φ_origin of any lattice node, P_polarization generates a discrete set of reachable destination phase tuples {φ_dest}.
• The generated set is identical (as a set of lattice nodes, after phase-to-lattice inversion) to the legal reachable set computed by the geometric generator from §5 and used throughout the existing notebook.
• The operator is defined purely in terms of the coprime generators from §9f (67 for row-axis, 7 for column-axis, mod 640) and the polarization's quantum numbers from §9r.

§11.1.2 What this hypothesis would establish if confirmed

If the phase operators reproduce the geometric reachable sets exactly, then the 2D lattice coordinates are redundant representation. The lattice domain is already encoded, in full, by the coprime phase-tuple structure of the 640-dim HDC space. Every legal transition corresponds to a phase-arithmetic operation in this space. The 2D board is a visualization of the phase structure, not the substrate of it.

This would be a strong claim. It is the reason the experiment is worth running even if it produces nothing operationally new — confirming or refuting it tells us something structural about the field representation.

§11.1.3 What this hypothesis would not establish

Nothing about whether phase-space computation is faster, more accurate, or more revealing than geometric computation. Nothing about whether phase-space similarity corresponds to thermodynamic similarity. Nothing about fog-of-war, partial observation, or the aliasing horizon beyond demonstrating that the full horizon contains the full legal reachable set.

Those are downstream experiments (§11.3–§11.6). §11.1 just tests the equivalence.

§11.1.4 The null hypothesis

The phase-operator formulation may fail in one of three ways:

1. Incomplete reach: the operators produce a subset of the legal reachable set (some legal destinations are missed).
2. Excess reach: the operators produce a superset (some generated phase tuples correspond to illegal destinations).
3. State-dependent failure: the operators work for unobstructed positions but fail when other excitations block paths for sliding polarization states.

Case 3 is the most likely failure mode. Sliding polarization states (R, B, Q) have their reachable set truncated by other excitations along the ray. A pure phase operator does not know about other excitations — it operates on the origin phase alone. Resolving this will require either phase-space representation of occupation (possible via the existing 640-dim encoding, which already represents occupation globally) or admission that the phase operator generates the unobstructed reachable set and a separate occupation check is required to prune.

Either outcome is informative. Data first, interpretation after.

---

§11.2. Phase Operator Specifications

§11.2.1 Coordinate conventions

Row index r ∈ {0, 1, …, 7}. Column index c ∈ {0, 1, …, 7}. The origin phase tuple for lattice node (r, c) is:

φ(r, c) = (r × 67 + c × 7) mod 640

This extends §9f's coprime roll binding from the historical 512-dim encoder (mod 512) to the production 640-dim encoder (mod 640). Both moduli admit the same generators 67 and 7: gcd(67, 512) = gcd(67, 640) = gcd(7, 512) = gcd(7, 640) = 1. The 64-point image of Z₈ × Z₈ under φ is verified distinct (no collisions) for both moduli. §11 operates at mod 640 throughout; any reference to §9f's mod 512 formulation should be read as the antecedent of this extended form.

The phase tuple is a single integer in [0, 640), but it carries two components: r × 67 mod 640 (row phase) and c × 7 mod 640 (column phase), which are individually recoverable because 67 and 7 are coprime to 640 (640 = 2⁷ × 5; 67 is prime and not 2 or 5; 7 is prime and not 2 or 5).

Subgroup structure. The image set {φ(r, c) : (r, c) ∈ [0, 7]²} is not a subgroup of Z₆₄₀ — closure fails (e.g., 384 + 384 = 128 mod 640, which is not in the image). This is the correct structure for the problem: phase-op shifts that carry an origin off the lattice land in the off-image complement of Z₆₄₀, where §11.3.2 inversion fails, and §11.3.3 pruning catches them. A subgroup image would close under piece-operator addition and eliminate the boundary-detection mechanism.

§11.2.2 Phase operator for the rook (massless, θ = 0° and 90°, T-symmetric)

The rook propagates along orthogonal rays. The two primary D4 axes correspond to pure row phase shifts and pure column phase shifts:

P_rook(φ_origin) = {φ_origin + k × 67 mod 640 : k ∈ {±1, ±2, …, ±7}} ∪ {φ_origin + k × 7 mod 640 : k ∈ {±1, ±2, …, ±7}}

Unobstructed reachable set: up to 14 destinations (7 in each orthogonal direction). The upper bound is the path graph diameter minus 1.

§11.2.3 Phase operator for the bishop (massless, θ = 45° and 135°, T-symmetric)

The bishop propagates along diagonal rays. Diagonal phase shifts are combinations of row and column phases at equal magnitude:

P_bishop(φ_origin) = {φ_origin + k × (67 + 7) mod 640 : k ∈ {±1, ±2, …, ±7}} ∪ {φ_origin + k × (67 − 7) mod 640 : k ∈ {±1, ±2, …, ±7}}

Note: 67 + 7 = 74 is the NE/SW diagonal generator; 67 − 7 = 60 is the NW/SE diagonal generator.

§11.2.4 Phase operator for the queen (massless, θ ∈ {0°, 45°, 90°, 135°}, T-symmetric)

The queen is the superposition of rook and bishop operators:

P_queen(φ_origin) = P_rook(φ_origin) ∪ P_bishop(φ_origin)

Unobstructed reachable set: up to 28 destinations (14 orthogonal + 14 diagonal).

§11.2.5 Phase operator for the king (massive, all θ at radius r = 1, T-symmetric)

The king is a localized excitation — k = ±1 only, all 8 directions:

P_king(φ_origin) = {φ_origin + s mod 640 : s ∈ {±67, ±7, ±74, ±60}}

Unobstructed reachable set: up to 8 destinations.

§11.2.6 Phase operator for the knight (tunneling, knight-offset θ class, T-symmetric)

The knight occupies its own θ class in the §9r polarization framework — disjoint from {axial, diagonal}. Its 8 destinations are the D4 orbit of (1, 2), with angles {26.57°, 63.43°, 116.57°, 153.43°, 206.57°, 243.43°, 296.57°, 333.43°} (arctan(½) is one representative, not the full class). The 8 destinations correspond to 8 distinct linear combinations of the row and column generators:

P_knight(φ_origin) = {φ_origin + s mod 640 : s ∈ {±(2×67 + 7), ±(2×67 − 7), ±(67 + 2×7), ±(67 − 2×7)}} = {φ_origin + s mod 640 : s ∈ {±141, ±127, ±81, ±53}}

Unobstructed reachable set: up to 8 destinations.

§11.2.7 Phase operator for the pawn (massive, forward-only, T-violating, Z₂-charge-dependent)

The pawn operator depends on Z₂ charge. For white (charge +V):

P_pawn_white(φ_origin, move_type) = - if move_type = advance and on starting rank: {φ_origin + 67, φ_origin + 2×67} mod 640 - if move_type = advance: {φ_origin + 67} mod 640 - if move_type = capture: {φ_origin + 67 + 7, φ_origin + 67 − 7} mod 640

For black (charge −V): replace +67 with −67 throughout.

The T-violation is explicit: there is no inverse operator. The phase operator is non-Hermitian, consistent with §9m's identification of the pawn's antisymmetric fiber.

Empty-board comparison caveat (§11.3). python-chess does not report diagonal captures as legal moves when no enemy piece occupies the target square. The §11.3 equivalence check against python-chess therefore compares advance destinations only; capture destinations are validated in §11.4 (occupation-aware) where enemy pieces are present on the board. This is a quirk of the reference implementation, not of the phase operator — the capture phases are arithmetically correct, they just lack validation targets on an empty board.

§11.2.8 What these operators do and do not include

Included: the unobstructed reachable set for each polarization from any origin. The mathematics is pure phase arithmetic modulo 640.

Not included: - Occupation-based ray truncation (handled in §11.4 via Solutions A/B/C) - Castling (handled in §11.4 via P_castle composite operator; see §11.4.3.1) - En passant (handled in §11.4 via ep_square pass-through; see §11.4.3.2) - Promotion (handled in §11.4 via last-rank move expansion; see §11.4.3.3) - Check/checkmate legality (a global constraint on the king's phase tuple, deferred to §11.5)

Of the original five exclusions, four have been closed. Check/checkmate legality remains — it requires the full king-safety filter (the §11.5 is_check check we validated in two paths) and is structurally distinct from per-piece move generation.

The base experiment (§11.3) tests only the unobstructed set. Subsequent experiments extend to the full legal set.

---

§11.3. Experiment 1: Equivalence on Empty Board

§11.3.1 Protocol

For each polarization state p ∈ {N, B, R, Q, K, P_white, P_black}, and for each origin square (r, c) ∈ {0, …, 7}²:

1. Compute the phase-operator reachable set: apply P_p to φ(r, c), obtain a set of output phase tuples, invert each output phase tuple back to (r', c') coordinates. Prune any (r', c') outside [0, 7]² (boundary handling).
2. Compute the geometric reachable set: instantiate a position with only polarization p at (r, c) (appropriate color for pawn) in python-chess, enumerate legal moves, collect destination squares.
3. Compare as sets. Record: positions where sets match, positions where phase-operator set is missing destinations, positions where phase-operator set has extra destinations.

§11.3.2 Inversion from phase tuple to coordinates

Given a phase tuple φ_out ∈ [0, 640), recover (r', c') by:

• φ_out mod 7 gives information about the column (but with collisions every 7 values)
• φ_out mod 67 gives information about the row (with collisions every 67 values)

Since 640 = 2⁷ × 5 is not coprime with 7 or 67, the inversion is not a simple modular division. The correct inversion is: search over all (r', c') ∈ [0, 7]² and find the one whose φ(r', c') equals φ_out. This is a 64-entry table lookup.

§11.3.3 Boundary handling

The phase operators are defined modulo 640, so they naturally wrap. A rook at (0, 0) moving 7 units in the +row direction produces φ = 7 × 67 = 469 mod 640 = 469, which inverts to (7, 0) — correct. But a rook at (7, 0) moving 1 unit in the +row direction produces φ = 8 × 67 = 536 mod 640 = 536, which inverts to... nothing in [0, 7]².

Boundary condition: destinations must satisfy r', c' ∈ {0, …, 7}. Any phase tuple that does not invert to a valid lattice node is outside the boundary and must be pruned.

This means the phase operator generates a torus reachable set which is then clipped to the finite 8×8 domain. This is the same structure as the DCT eigenbasis being extended periodically beyond the board and then truncated — consistent with the existing framework.

§11.3.4 Success criteria

Full equivalence: for all polarizations, for all origins, phase-operator set = geometric set.

Partial equivalence: full equivalence for some polarizations, failure for others. Record which and analyze.

Failure: phase-operator set systematically differs from geometric set. Record the pattern of differences.

§11.3.5 Data to collect

Per (polarization, origin) pair: - phase_op_destinations: set of (r', c') produced by phase operator + inversion + boundary clipping - geometric_destinations: set of (r', c') from python-chess on an empty-board-with-one-piece position - set_equal: boolean - missing: geometric_destinations − phase_op_destinations - extra: phase_op_destinations − geometric_destinations

Total rows: 7 polarizations × 64 origins = 448 rows. Small enough to inspect manually if needed.

§11.3.6 Decision point

Result (validated). §11.3 produced full equivalence: 416/416 (polarization, origin) pairs match python-chess's legal moves on the empty board (7 polarizations × 64 origins − 32 back-rank pawn pairs; see reference implementation at docs/chess-maths/phase_operators/). The phase-operator formulation reproduces the geometric unobstructed reachable set exactly. Proceeding to §11.4.

---

§11.4. Experiment 2: Occupation-Aware Phase Operators

§11.4.1 The occupation problem

Sliding polarizations (R, B, Q) have rays truncated by other excitations. A rook at d1 in the starting position cannot reach d8 because d2 is occupied by a pawn. The phase operator from §11.2 produces the unobstructed set — it does not know about d2.

§11.4.2 Candidate solutions

Solution A: Post-hoc geometric pruning. Generate the unobstructed set via phase operators, then use the geometric board state to prune blocked destinations. This is a hybrid — phase-space generation followed by geometric filtering. It works but undermines the goal of pure phase-space computation.

Solution B: Phase-space occupation field. The 640-dim HDC encoding already represents the global occupation state. For each ray direction, compute the "occupation phase" — the phase tuple(s) of the nearest occupied node along the ray. Truncate the unobstructed set at the occupation phase. Purely phase-space, but requires defining "nearest along ray" in phase-space terms.

Solution C: Incremental phase operator. Instead of generating all k ∈ {±1, …, ±7} at once, iterate k = 1, 2, 3, … and halt when the generated phase tuple matches an occupied node's phase tuple. This is purely phase-space and matches the physical intuition of a ray propagating until it hits something.

Solution C is cleanest and most consistent with the lattice-fermion framing — the ray propagates step by step, interacts with the first excitation it encounters, and terminates. This is the phase-space analog of the Green's function collapsing at a scattering site.

§11.4.3 Protocol for Solutions B and C

Both solutions represent occupancy as a set of phases Φ_occ = {φ(r, c) : (r, c) is occupied in the current position}, annotated with the Z₂ charge at each occupied phase. Both are phase-native in the specific sense that the blocker check is a set-membership test on Φ_occ, not a lookup on a python-chess Board object. They differ in how the truncation happens.

Solution B — Phase-space occupation field (batch / set-intersection).

For each sliding polarization p ∈ {R, B, Q} and for each origin φ_origin:

1. For each ray direction d with phase-shift unit u_d:
2. Generate the full candidate phase set Φ_ray = {(φ_origin + k × u_d) mod 640 : k ∈ {1, ..., 7}} in order of increasing k.
3. Clip Φ_ray at the first on-board phase that is off-lattice (boundary halt) — all k beyond that are dropped regardless of occupation.
4. Find Φ_ray ∩ Φ_occ. The lowest-k intersection is the blocker.
5. Destinations are: all pre-blocker phases from Φ_ray, plus the blocker itself if its Z₂ charge is opposite (capture allowed), plus nothing if the blocker's charge matches (own-charge block).

Solution C — Incremental phase operator (sequential / early halt).

For each sliding polarization p ∈ {R, B, Q} and for each origin φ_origin:

1. For each ray direction d with phase-shift unit u_d:
2. Initialize k = 1.
3. Compute φ_k = (φ_origin + k × u_d) mod 640.
4. Check if φ_k corresponds to a valid lattice node (inside [0, 7]²). If not, halt the ray (boundary reached).
5. Check Φ_occ for membership. If absent (unoccupied), include φ_k in destinations and continue with k := k + 1. If present with same Z₂ charge, halt before φ_k. If present with opposite Z₂ charge, include φ_k (capture) and halt.

Equivalence claim. B and C must produce identical destination sets for every (position, polarization, origin) triple where both are well-defined. Their difference is the order of operations, not the answer. Any observed disagreement is a bug in one or the other, not a property of chess.

Non-sliding pieces. King, knight, and pawn operators from §11.2 are already localized (k = ±1 only for king/pawn; discrete shell for knight). The occupation-aware version of these is the unobstructed set minus own-charge-occupied destinations, plus opposite-charge destinations as captures. Both B and C reduce to the same localized filter for these pieces; the B vs C distinction only matters for {R, B, Q}.

Solution A — Post-hoc geometric pruning (four-way cross-validation channel). While §11.4.2 presented A as a hybrid undermining the phase-native goal, A is still useful as an independent validation channel. A generates the full unobstructed phase set per §11.2, inverts to (r, c), and intersects against python-chess's legal-move set. When A, B, C, and python-chess all converge on the same destination set for a given (position, polarization, origin) triple, the §11.4 framework has four independent channels of agreement rather than three. A also serves as the reference timing baseline for the cost of the python-chess fallback that §11.4.3.1 and §11.5 both defer to.

§11.4.3.1 Castling as a composite operator P_castle

Castling is a coupled two-polarization transition (king + rook move simultaneously), excluded from the per-piece base operators in §11.2.8. It is handled in §11.4 as a composite operator P_castle layered on top of the king operator.

Phase arithmetic. The four castle destinations are specified by phase shifts from the king's and rook's origin phases:

Castle	King shift (phase)	Rook shift (phase)	King (r, c)	Rook (r, c)
White kingside	+2·COL_GEN = +14	−2·COL_GEN = −14	(0,4)→(0,6)	(0,7)→(0,5)
White queenside	−2·COL_GEN = −14	+3·COL_GEN = +21	(0,4)→(0,2)	(0,0)→(0,3)
Black kingside	+2·COL_GEN = +14	−2·COL_GEN = −14	(7,4)→(7,6)	(7,7)→(7,5)
Black queenside	−2·COL_GEN = −14	+3·COL_GEN = +21	(7,4)→(7,2)	(7,0)→(7,3)

The reference implementation constructs this table at module load from the φ(r, c) injection; the phase shifts are not hard-coded. The king shift is always ±2·COL_GEN because castling is definitionally a two-file king move.

Availability predicate. Which of the four castles is currently available in a given position depends on:

1. Side-to-move matches the castle's color.
2. The castle's castling rights have not been forfeited (no prior king or rook movement).
3. Squares between king and rook are unoccupied.
4. King is not currently in check.
5. King does not pass through or land on a square attacked by the opposite charge.

Conditions 1–3 are phase-native (set-membership tests against Φ_occ and against the side-to-move register). Conditions 4–5 require an attack map — the set of phases attacked by the opposite charge's operators — which is a separate P_attack-like operator that is outside the §11.4 scope and deferred to §11.5. The reference implementation delegates conditions 4–5 to python-chess's board.is_legal() on the canonical castling UCI move — after explicitly verifying that the king and rook sit on their canonical home squares. Without the home-square guards, python-chess may parse the castling UCI as a non-castling piece slide (e.g., a rook on e1 makes "e1c1" a legal rook move), and is_legal returns True for reasons unrelated to castling. The home-square guards turn the delegation into an unambiguous castling check. This makes P_castle a composite operator in the §11.4-scoped sense: its geometry is expressed by φ() arithmetic, its home-square preconditions are phase-native (set-membership in the occupation field with piece-type discrimination), and only its full attack-map predicate borrows one primitive from the geometric reference.

Integration. P_castle's king-side destinations are unioned into the king output of all three solutions (A, B, C). The rook component is implicit: when the king appears at the castle target, the rook must also have moved to its paired target, but for move-generation purposes only the king destination is enumerated (per python-chess's convention that castling is emitted as a king move).

§11.4.3.2 En passant as ep_square pass-through

En passant is a state-dependent capture where the destination square is empty but capturing is nevertheless legal because the opposite side's pawn just moved two squares and is on an adjacent file. The destination is the phantom square the two-step pawn would have occupied if it had only advanced one.

The phase arithmetic is identical to an ordinary diagonal pawn capture — the destination phase is (φ_origin ± DIAG_NE_SW_GEN) or (φ_origin ± DIAG_NW_SE_GEN) per §11.2.7. What differs is the occupation-field predicate: the diagonal is empty, not occupied by opposite charge.

Integration. The pawn_destinations generator accepts an optional ep_phase parameter. When present, it matches against the two capture diagonals; if a match is found, that diagonal is added to destinations even though the occupation field shows the square as empty. The ep_phase is derived from python-chess's board.ep_square — an int | None field on the Board object that is part of FEN state, not HDC state.

This is a state-dependent filter, not a new phase operator: the phase arithmetic was already producing the capture phase; the ep_square pass-through is what lifts it from "drop if empty" to "keep if empty and equals ep_phase."

§11.4.3.3 Promotion as last-rank move expansion

When a pawn advances or captures onto the last rank (row 7 for white, row 0 for black), the move is structurally a single phase transition whose destination corresponds to a polarization-identity change: the pawn becomes a queen, rook, bishop, or knight. python-chess represents this as four distinct chess.Move objects, one per promotion piece, sharing the same (from, to) pair.

The phase operators produce the destination correctly in a single call — the diagonal capture phase or the forward advance phase per §11.2.7. The phase arithmetic does not distinguish "pawn arriving on last rank" from "pawn arriving anywhere else"; the distinction is a boundary property of the destination coordinate.

Integration. A small wrapper at the move-emission boundary (where destinations become chess.Move objects) tests whether the destination row is the last rank for the mover's charge. If yes, the single destination expands into four Move objects with promotion set to each of QUEEN, ROOK, BISHOP, KNIGHT. This matches python-chess's emission order.

This is not a phase-native operation. The encoder's polarization- identity change (pawn → queen) is a separate structural question that §11 does not address. The expansion here is a wrapper-layer formality that makes the phase generator's output set-equal to python-chess's legal move enumeration; the underlying phase destination is a single point per advance, and the four promotion variants are the same point with four different "tag" values.

Promotion under-promotion (emitting =N/=B/=R when =Q is usually best) is always included because python-chess's legal_moves emits all four; whether the move is good is a search question, not a move-generation question.

§11.4.4 Data to collect

For positions sampled from an existing corpus (e.g., sweep_chain_lichess_drnykterstein_2026-04-14_N10):

• position_fen
• polarization and origin
• phase_op_legal_set: set of (r', c') after occupation-aware phase operator
• geometric_legal_set: set of (r', c') from python-chess legal moves for that polarization from that origin
• set_equal: boolean
• missing, extra: as in §11.3

Sample 100 positions uniformly from the corpus. For each position, iterate over all polarizations and all origins with that polarization's Z₂ charge. Expected: ~30 polarization-origin pairs per position × 100 positions = ~3000 rows.

§11.4.5 Decision point

Result (validated). On 100 sampled positions from the sweep_chain_lichess_drnykterstein_2026-04-14_N10 corpus (1153 piece-origin triples), the four channels converge as follows:

Agreement	Rate	Note
A matches python-chess	1153/1153 (100.00%)	closes the castling gap
B matches C	1153/1153 (100.00%)	primary §11.4.3 equivalence claim
B matches python-chess	1086/1153 (94.19%)	residual is moves-into-check
C matches python-chess	1086/1153 (94.19%)	same residual as B
A matches B	1086/1153 (94.19%)	same residual, A filters check
A matches C	1086/1153 (94.19%)	same residual, A filters check

Timing (mean per call on sampled middlegame positions). The reference scope matters — python-chess's legal_moves includes king-safety filtering (move-into-check detection), while pseudo_legal_moves does not. Solutions B and C are phase-native and scoped to pseudo-legal generation; Solution A delegates to whichever python-chess method the benchmark was invoked with. The apples-to-apples comparison is A against pseudo_legal_moves, where all three solutions operate at the same scope. Numbers below are from benchmark_solutions.py --n-positions 50 --repeats 5 --warmup 2 on the same sampled corpus.

Reference scope	Solution A	Solution B	Solution C	B speedup	C speedup
pseudo_legal (phase-native parity)	48 μs	7.4 μs	6.4 μs	6.5×	7.5×
legal (check-filtered)	75 μs	72 μs	69 μs	1.05×	1.10×

Two structural findings:

1. The ~7× speedup at pseudo-legal scope is the phase-vs-geometric delta at parity. Solutions B and C compute the same set as python-chess's pseudo_legal_moves in ~15% of the wall-clock time. No vectorization, no compilation, no caching — naive Python integer arithmetic against python-chess's reference implementation in the same language. The advantage is purely algorithmic: phase arithmetic replaces board iteration plus bounds checking plus Board state inspection.

2. The check filter dominates legal-scope runtime. Both B and C lose their parity advantage when the reference is switched to legal_moves — C's total jumps from 6.4 μs to 69 μs, a factor of ~11×. The geometric check filter costs ~60 μs per call regardless of how the candidate moves were generated (A's smaller delta, 48 → 75 μs, reflects that A's pseudo variant already iterates pseudo_legal_moves, so the switch to legal_moves adds only the incremental king-safety work rather than a full second iteration). This frames the §11.5 / §11.6 research question operationally: any phase-native check filter at |ρ| > 0.3 correlation with "move-into-check" has a large budget to beat before it becomes neutral, and any filter faster than ~60 μs with usable precision is operationally interesting.

Solution C's early-halt advantage over B is consistent with the lattice-fermion framing — rays terminate at the first scattering site, and most rays in a populated middlegame terminate within 1–3 steps. B's batch generation pays for the full k ∈ {1..7} candidate set even when the ray blocks at k=1; C's sequential step halts immediately. The effect is visible at both pseudo-legal (B 7.4 μs vs C 6.4 μs, ~14% faster) and legal (B 72 μs vs C 69 μs, ~4% faster) scopes; the latter compresses because both pay the same ~60 μs filter on top.

Interpretation. Solutions B and C are operationally complete for move generation against board.pseudo_legal_moves once castling is folded in via §11.4.3.1's P_castle. The residual ~5.81% gap between A (which inherits legal_moves filtering) and B/C (which do not model check/pin) is the check-filtering constraint — a separate §11.2.8 exclusion that is the subject of §11.5 (a P_attack / P_pin operator defined over the phase-space attack map rather than per-piece).

Proceeding to §11.5.

---

§11.5. Experiment 3: Phase-Tuple Similarity as Field Gradient Indicator

§11.5.1 Motivation

§11.3 and §11.4 succeeded — we have a phase-space move generator that reproduces python-chess's pseudo-legal move set across four independent channels at 100% agreement, with the ~5.81% residual against legal_moves accounted for by check/pin filtering (§11.2.8). The next question is whether phase-space operations reveal thermodynamic structure that geometric operations do not.

Specifically: for any candidate transition (φ_origin → φ_dest) under polarization operator P_p, does the phase-tuple similarity between the pre-transition and post-transition 640-dim encodings correlate with the thermodynamic gradient Δ from the earlier experiments?

Two paths, one experiment. The §11.4.5 benchmark showed check-filtering dominates legal-scope runtime by roughly 10× over move generation. Two distinct research paths target this cost:

• Path 1: phase-native check detection. Reformulate python-chess's is_check operation in phase space. The natural formulation ("reverse phase-cast") casts inverse attack operators outward from the king and intersects with opponent-occupation-by-type. This is mathematically equivalent to bitboard-based attack detection — same asymptotic complexity, same correctness. It offers no algorithmic advantage over what optimized engines already do, and in a naive Python implementation runs ~38× slower than python-chess's bitboard is_check. Its value is as a reference path: a phase-space operation with known-correct answer by construction.

• Path 2: phase-native check prediction via similarity. If phase-tuple similarity between pre-move and post-move encodings correlates with is_check_unsafe at usable precision (|ρ| > 0.3 as a loose threshold), phase space contributes a cheap approximate signal that the geometric filter does not provide — a pre-filter for the expensive geometric confirmation step. This is structurally different from path 1; it is not a faster reimplementation of an existing operation, it is a new signal whose presence or absence the experiment must determine.

§11.5 runs both paths in the same experiment: path 1 as a reference channel with known correct answers, path 2 as the correlation target with unknown outcome. Having the path-1 reference in the CSV lets us compare any path-2 signal against what a straight phase-space reformulation already achieves by construction. If phase_similarity correlates with is_check_unsafe at a strength comparable to or exceeding what path 1 achieves at its correctness level, phase similarity is carrying information that the direct geometric computation does not expose. If it underperforms, phase similarity is a weaker signal than direct computation and the §11.5.6 decision for the check-filter use case is negative (though the broader thermodynamic correlations may still be informative).

§11.5.2 What phase-tuple similarity measures

The 640-dim encoding is a superposition over all current excitations. A transition modifies the encoding by removing the origin's contribution and adding the destination's contribution (and, for captures, removing the annihilated excitation's contribution). The cosine similarity between pre- and post-transition encodings measures how much the field configuration changes.

Large change (low similarity) = transition perturbs the field significantly = large gradient. Small change (high similarity) = transition perturbs the field minimally = small gradient.

This is a field-theoretic quantity, not a geometric one.

§11.5.3 Protocol

For each position in the sample corpus (§11.4), for each pseudo-legal transition:

1. Compute enc_before = encode_640(position_before).
2. Compute enc_after = encode_640(position_after_transition).
3. Compute phase_similarity = cosine(enc_before, enc_after).
4. Record phase_similarity alongside the Δ value from the earlier experiment (if position is in the Stockfish corpus, record Stockfish eval too).

Population note. The protocol iterates board.pseudo_legal_moves rather than board.legal_moves because the correlation target is_check_unsafe has zero variance on the legal-move set by construction (every legal move is check-safe). Pseudo-legal is also the §11.4 candidate-set scope that a phase-similarity-based check filter would operate on, so this is the correct operational population for the §11.4.5 optimization question.

§11.5.4 Data to collect

Per pseudo-legal transition: - position_fen - transition_uci - polarization_type - phase_similarity (cosine in [−1, 1]) - delta_v1 (from prior experiment, if available) - stockfish_eval (from prior experiment, if available) - kappa_annihilate, kappa_threat (from prior experiment) - is_check_unsafe (boolean: does applying this transition leave mover's king in check, per python-chess; the geometric reference) - is_check_unsafe_phasecast (boolean: same question, computed via path-1 reverse phase-cast; correct-by-construction reference channel) - phasecast_matches_chess (boolean: is_check_unsafe == is_check_unsafe_phasecast; expected to be True for every row) - was_played (boolean)

Columns from prior experiments. The delta_v1, stockfish_eval, kappa_annihilate, and kappa_threat columns require a pre-computed Stockfish sweep with κ-quantity extraction. If that data is not attached to the corpus at experiment run time, those columns remain empty in the CSV and their correlations with phase_similarity are not answered by this run. A follow-up experiment with the full Stockfish sweep attached is the appropriate vehicle for that analysis; it is not a blocker for the §11.5.6 decision on the check-filter path.

§11.5.5 Analysis

Compute Spearman ρ between phase_similarity and each of: delta_v1, stockfish_eval, kappa_annihilate, kappa_threat, is_check_unsafe. Break down by polarization type and by capture/non-capture.

Path-1 reference correctness. Assert phasecast_matches_chess == True for every row before running any correlation. If any row disagrees, the path-1 implementation has a bug that must be fixed before the path-2 analysis is trustworthy. Record the mismatched rows in the summary and halt analysis.

Path-2 correlation analysis. The |ρ(phase_similarity, is_check_unsafe)| value answers the operational question from §11.5.1. If |ρ| > 0.3 in any polarization slice, phase similarity is a candidate component of a faster-than-geometric check filter at approximate precision. If |ρ| < 0.1 across all slices, the §11.4.5 optimization path via phase similarity is closed; the check filter remains strictly a geometric operation and path-1's 38× slowdown in naive Python is the floor without bitboard-level engineering.

Timing comparison. Record the per-call cost of (a) python-chess is_check and (b) path-1 phase-cast is_check on the same positions. This extends the §11.4.5 table to include check-filter costs explicitly. The expected result: python-chess wins by ~30–40× in naive Python because its is_check is bitboard-backed. This is a reference datum, not a research finding.

§11.5.6 Result — validated null for path-2 check filtering

Run parameters: 100 positions sampled from sweep_chain_lichess_drnykterstein_2026-04-14_N10, 3393 pseudo-legal transitions total.

Path-1 reference correctness. phasecast_matches_chess: 3393/3393 (100.00%). The reverse phase-cast is_check detector matches python-chess across every sampled transition by construction. Path 1 is validated as a correct phase-space reformulation of the geometric check operation; it is not faster than python-chess's bitboard is_check (138 µs vs 22 µs in the run's naive-Python benchmark), but correctness is unimpeachable.

Path-2 correlation result. Max |Spearman ρ(phase_similarity, is_check_unsafe)| across all nine slices: 0.097 (king-move slice). All other slices (knight, bishop, rook, queen, pawn, captures, non-captures, all-transitions) fell below this value. Per the §11.5.6 threshold of |ρ| < 0.1 for "no correlation," this is a validated null: phase-tuple similarity between pre-move and post-move encode_640 vectors does not carry information about whether the move leaves the mover's king in check.

Structural interpretation. The 640-dim encoder's ten channels — five D4 irreps, three symmetric fiber channels, FA antisymmetric pawn fiber, FD diagonal deviation — are each derived from a specific mathematical object of the lattice and its piece operator content. None of those derivations produces king-attack geometry as a first-order output. The null result is consistent with the encoder's construction: it faithfully represents the board's field-theoretic structure and its symmetry content, and king-attack relationships happen to not be field-theoretic in the same sense. A move that exposes the king changes the encoding by roughly the same amount as any other move of the same piece type; the differential signal is below the 0.1 threshold.

What remains open. This result closes path 2 for the check-filter use case. It does not close the broader §11.5 hypothesis for thermodynamic gradients — phase_similarity's correlation with delta_v1, stockfish_eval, kappa_annihilate, kappa_threat is untested in this run because those columns require a pre-computed Stockfish sweep that was not attached. A follow-up experiment with the full sweep attached is the appropriate vehicle for that analysis.

What this motivates. The null result raises a structural research question independent of §11.5's stated scope: should the encoder family be extended to include king-attack content, and is there a principled derivation that produces such a channel naturally? This question is addressed in a parallel experiment (§12 — to be documented after the parallel king-attack encoder returns data). It is not a modification of the existing 640-dim encoder; it is a separate instrument built from the same mathematical discipline, tested against the same CSV produced by §11.5.

Timing (mean per call, naive Python, same positions): - python-chess is_check (reference): 22 µs - path-1 phasecast is_check: 138 µs (~6× slower, consistent with naive-Python-vs-bitboard gap) - path-2 phase_similarity: 1190 µs (dominated by two encode_640 calls)

The path-1 timing extends the §11.4.5 table with check-filter cost explicitly; the path-2 timing is a data point about the encoder's per-call cost at the current implementation level, not a claim about phase similarity being fast.

Decision: §11.6 unblocked. §12 (parallel king-attack encoder) added as a sibling experiment.

---

§11.6. Experiment 4: Aliasing Horizon as Partition Detection

§11.6.1 The UTLP S4 mechanism, applied spatially

In UTLP S4, partition detection uses HD vector similarity between nodes. When similarity drops below threshold, the nodes have drifted beyond the CRT aliasing horizon and phase-lock fallback becomes necessary. S4's "CRT aliasing horizon" is the literal Chinese Remainder Theorem — coprime temporal moduli lose unambiguous recovery past a specific range.

Spatial analog (as framework, not theorem): consider two positions P₁ and P₂. Compute similarity(enc_640(P₁), enc_640(P₂)). If the positions are close in phase space (high similarity), they are in the same similarity cell — field-theoretically similar and expected to have similar thermodynamic gradients. If similarity drops below threshold, the positions are in different similarity cells — the phase representation cannot reliably extrapolate between them.

This gives a partition detector for phase space. Positions within the same partition should have consistent local gradients. Positions across a partition boundary should have discontinuous gradients.

Mathematical honesty caveat. The enc_640 vector is a bundled HDC superposition of piece states, not a literal coprime-residue encoding of position. A similarity drop is a high-dimensional noise-floor crossing in that bundled representation, not a CRT-recovery ambiguity event. The "similarity cell" framing is metaphorically useful and S4-analogous, but claiming CRT-specific partition-detection guarantees requires either (a) a proof that the bundled HDC similarity structure factorizes into per-axis aliasing kernels — the Vector Function Architecture product-kernel result from Frady et al. 2022 (arXiv:2109.03429) and the Residue HDC kernel theorem from Kymn et al. 2024 (arXiv:2311.04872) are the relevant tools, or (b) reframing §11.6 as an empirical partition-detection experiment with no appeal to CRT guarantees. This supplement takes path (b) for the experimental phase and flags (a) as a downstream analytical task.

§11.6.2 Why this matters for the depth-of-search question

The σ estimator from earlier experiments measures gradient roughness across fiber-neighbor transitions. Aliasing horizon detection is the complementary concept at the position level: it asks whether the current position is in a region of phase space where local gradients are reliable.

A position with low σ in a small CRT cell: gradient is reliable, local decision suffices. A position with high σ or near a partition boundary: gradient is unreliable or inapplicable, deeper exploration needed.

§11.6.3 Protocol (Phase A: partition detection)

For each game in the corpus:

1. Compute enc_640 for every ply.
2. Compute pairwise cosine similarities between all plies in the game (upper triangular matrix over plies).
3. Identify phase clusters — maximal sequences of consecutive plies whose pairwise similarities with every other ply in the cluster are above a threshold τ.
4. Identify partition boundaries — consecutive ply pairs where similarity drops below τ, crossing from one phase cluster into another.

For each ply, record: - position_fen - game_id, ply_index - cluster_id (integer per-game cluster assignment) - cluster_size (number of plies in this ply's cluster) - distance_to_nearest_boundary (in plies, signed: negative if the previous boundary is nearer, positive if the next boundary is nearer, zero if this ply is itself a boundary) - similarity_to_previous_ply, similarity_to_next_ply - similarity_to_cluster_centroid (mean cosine to all other plies in the same cluster)

Threshold τ. The choice of τ is a hyperparameter. Phase A produces the analysis across a sweep of τ ∈ {0.70, 0.80, 0.85, 0.90, 0.95}, reporting cluster statistics per threshold. The researcher inspects the sweep and picks a canonical τ for §11.6.6 interpretation, or reports the full sweep if no single τ dominates.

Data already available for cross-references. The following columns are populated from existing data where it exists, and left empty otherwise:

• sigma_local — the σ estimator from §11.6.4 (currently not available; column left empty; §11.6.4 cross-reference is deferred to Phase B)
• stockfish_cp — Stockfish centipawn evaluation at a single reference depth (available from stockfish_correlation/stockfish_evaluations_v2.csv for games overlapping that corpus; left empty otherwise)
• stockfish_depth_gap — shallow vs deep disagreement magnitude (currently not available as shallow+deep pairs do not exist for this corpus; column left empty; §11.6.5 cross-reference deferred to Phase B)
• kappa_annihilate, kappa_threat, delta_v1 — populated where the corpus overlaps with stockfish_correlation/stockfish_evaluations_v2.csv; empty otherwise

Phase A's primary output is the partition structure itself. Cross-reference analyses (§11.6.4, §11.6.5) run in Phase B when prerequisite data becomes available.

§11.6.4 Cross-reference with the σ experiment (Phase B — deferred)

Status. Deferred. The σ estimator referenced here is not materialized as a CSV in docs/chess-maths/results/ at the time §11.6 Phase A runs. Implementing σ is a separate experiment outside §11.6's scope.

Intended analysis (pending σ availability). For plies where σ data exists: does high σ correlate with distance_to_nearest_boundary being small? Does low σ correlate with being deep inside a phase cluster (high similarity_to_cluster_centroid)?

This tests whether the position-level partition structure (§11.6) is the same thing as the move-level gradient roughness (σ), viewed at different scales.

Phase B will be scheduled once σ data exists on a corpus that overlaps with the §11.6 Phase A output.

§11.6.5 Cross-reference with Stockfish depth-gap (Phase B — deferred)

Status. Deferred. The existing stockfish_correlation/stockfish_evaluations_v2.csv is single-depth (depth 12) and does not contain the shallow+deep pairs needed to compute depth-gap magnitudes. Re-running Stockfish at multiple depths on the corpus is outside this experiment's compute budget.

Intended analysis (pending depth-gap data). For plies where Stockfish evaluations at multiple depths exist: do depth-gap peaks (positions where shallow and deep evaluations disagree most) align with partition boundaries (small distance_to_nearest_boundary)? Previous data showed the A₁ channel correlates with depth-gap at ρ=+0.452. Phase B asks whether partition-proximity correlates more strongly than A₁ alone.

Phase B will be scheduled once multi-depth Stockfish data exists on the §11.6 Phase A corpus.

§11.6.6 Decision point (Phase A)

Phase A produces partition structure itself, not the cross-reference verdicts. Phase A's decision point is narrower than the original §11.6.6 question: does the phase-space similarity structure exhibit well-defined partitions at all, or does it look like a continuous drift with no natural cluster boundaries?

Three possible Phase A outcomes:

1. Clear partitions. At some threshold τ, games decompose into a small number of internally-coherent clusters with sharp boundaries. cluster_size distribution has a modal peak; similarity_to_cluster_centroid is tight within clusters and drops cleanly across boundaries. This is the setup Phase B wants — partitions that can be cross-referenced with σ and depth-gap data.

2. Continuous drift. Pairwise similarity decays monotonically with ply distance. No natural cluster boundaries; every τ choice is arbitrary. cluster_size varies smoothly with τ without a plateau. This closes the partition-detection hypothesis for the 640-dim encoder: the encoder sees games as continuous trajectories, not as a sequence of phase-cells, and the "similarity cell" framing is descriptive rather than structural.

3. Mixed behavior. Some games partition cleanly, others do not. Examine whether the partitioning behavior correlates with game characteristics (opening type, time control, result, Elo) — this is itself an interesting structural finding even if Phase B is partially blocked.

Phase B decision (deferred). Once σ and depth-gap data become available, Phase B answers the original §11.6 question: do partition boundaries align with computational-difficulty indicators?

• If boundaries align with both σ and depth-gap peaks: the phase-space partition structure IS the structure that determines when local computation suffices versus when search is required. Meta-cognitive signal confirmed.
• If boundaries are unrelated to both: the phase-space partitions are a structural feature of the encoding that does not correspond to computational difficulty. Null result for the meta-cognitive hypothesis; still structurally informative about how enc_640 organizes game trajectories.
• If boundaries align with one but not the other: partial signal. The decomposition between σ (move-level roughness) and depth-gap (position-level evaluation instability) tells us which scale of computational difficulty the partitions track.

All Phase B outcomes are informative. Phase A must complete cleanly first.

§11.6.6.1 Result — validated null for phase-space partition detection (three-corpus confirmation)

Phase A outcome: DRIFT. Ran partition_experiment.py on three structurally distinct corpora spanning human-vs-engine play, classical-vs-blitz time controls, and standard-vs-custom starting positions:

Corpus	Source / style	Games	Plies	τ=0.70 ρ	τ=0.80 ρ	τ=0.85 ρ	τ=0.90 ρ	τ=0.95 ρ
drnykterstein_2026-04-14_N10	Magnus Carlsen (GM human, classical, standard FEN)	10	796	+0.461	+0.563	+0.598	+0.711	+0.778
sweep_chain_lichess_ashchess_2026-04-21_N50	ashchess (FM 2544, lichess rated blitz 180+0, standard FEN)	50	4863	+0.571	+0.622	+0.645	+0.690	+0.758
sweep_hf_2026-04-20_N50	Stockfish fishtest (engines, ~41s+0.4s, custom setup FEN)	50	5070	+0.669	+0.727	+0.761	+0.797	+0.839

Totals. 110 games, 14,729 plies, 14,646 drift data points at each τ. All 15 drift-ρ measurements are strongly positive (+0.46 to +0.84). Cluster counts per game rise monotonically with τ on every corpus (drnykterstein 10.1 → 26.2; ashchess 15.2 → 30.2; fishtest 20.5 → 42.9) without a plateau.

The null is robust across every orthogonal dimension: player identity (GM / FM / engines), purpose (tournament / ranked ladder / regression sparring), time control (classical / 3-min blitz / ~41s blitz), starting position (standard / standard / custom setup FEN), and sample size (1× / 5× / 5×). The outcome does not change.

Volatility gradient. A secondary structural datum deserves explicit note: drift-ρ magnitude orders cleanly at every τ as Carlsen-classical < ashchess-blitz < fishtest-engines, and cluster-count-per-game at τ=0.70 orders the same way (10.1 < 15.2 < 20.5). This is consistent with a reading that encode_640 does not produce discrete partitions but is sensitive to a continuous "volatility of play" signal that scales with engine-like tactical jumpiness. The effect is suggestive, not established here — it rests on three data points. It is flagged for follow-up rather than claimed as a finding.

Structural interpretation. Combined with §11.5.6's result, encode_640 has now produced two nulls with the same signature: it does not expose king-attack geometry (§11.5.6), and it does not produce phase-space partitions (§11.6.6.1). Both are consistent with the encoder being a content descriptor (what pieces are at what phases) rather than a discontinuity detector. The encoder's ten channels — five D4 irreps, three symmetric fiber channels, FA antisymmetric pawn fiber, FD diagonal deviation — are each bundled-HDC superpositions derived from the lattice's symmetry content, and none of those derivations produces discrete cluster boundaries as a first-order output. Game trajectories therefore render as continuous paths through 640-dim space even when the chess-theoretic narrative (piece trades, pawn breaks, tactical shots) has natural phase-transition points.

Scope of the null. Phase A's partition-detection hypothesis is closed for encode_640 across the three-corpus durability check. The broader §11.6 question — whether phase-space partitions exist for some encoder and align with computational-difficulty indicators — is not closed by this result. A follow-up encoder that exposes discontinuity structure (e.g., the parallel king-attack instrument stubbed in §12, or any threshold-gated or rank-detecting channel) could produce a different Phase A outcome on the same corpora. Phase B (σ and depth-gap cross-references) also remains deferred under its original prerequisites; it is not blocked by Phase A's null because Phase B would only run against a corpus that did partition cleanly, and the current encoder does not.

CSVs on disk (all gitignored per docs/chess-maths/results/*/ policy): - docs/chess-maths/results/phase_operator_experiments/exp4_partitions.csv — drnykterstein N=10 - docs/chess-maths/results/phase_operator_experiments/exp4_partitions_ashchess_N50.csv — ashchess N=50 - docs/chess-maths/results/phase_operator_experiments/exp4_partitions_hf_N50.csv — fishtest N=50

Regenerate via:

python partition_experiment.py --corpus ../results/sweep_chain_lichess_drnykterstein_2026-04-14_N10
python partition_experiment.py --corpus ../results/sweep_chain_lichess_ashchess_2026-04-21_N50 \
    --out ../results/phase_operator_experiments/exp4_partitions_ashchess_N50.csv
python partition_experiment.py --corpus ../results/sweep_hf_2026-04-20_N50 \
    --out ../results/phase_operator_experiments/exp4_partitions_hf_N50.csv

Decision: §11.6.6 closed as validated null for path-1 partition detection on encode_640. §12 (parallel king-attack encoder) remains the natural next probe for whether a principled derivation CAN produce discontinuity structure; it is sibling work, not a follow-up for §11.6. §11.6 Phase B remains deferred under its original prerequisites. The volatility-gradient observation is a deferred open question: whether the drift-ρ ordering by play style is a robust structural signal or a coincidence across three data points.

---

§11.7. Open Infrastructure Requirements

§11.7.1 What Claude Code needs to build

1. phase_operators.py — the seven operator functions from §11.2, implemented as pure arithmetic on 640-dim phase tuples.
2. phase_to_coords.py — the inversion lookup table from phase tuple to (r, c), and the boundary check.
3. equivalence_check.py — §11.3 experimental protocol. Runs in minutes.
4. occupation_aware_phase_op.py — §11.4 Solution C implementation. Uses phase_operators.py + a minimal occupation check against a python-chess Board object.
5. phase_similarity_analysis.py — §11.5 experimental protocol. Reuses the existing encoder.
6. partition_detector.py — §11.6 experimental protocol. Produces phase cluster assignments per game.

§11.7.2 Data flow

All experiments produce CSV outputs with the schema specified in each §11.3–§11.6 data-to-collect block. Outputs go to docs/chess-maths/results/phase_operator_experiments/.

§11.7.3 Dependencies

• python-chess (already in the project per §analyze_delta_sigma.py)
• numpy
• The existing spectral_py.py encoder for the 640-dim encode_640 function
• No new installs expected

§11.7.4 What to not do

• Do not tune phase operator definitions to match geometric results. If §11.3 fails, record the failure — do not adjust the operators to fit. The point is to test whether the §11.2 operators as specified produce the legal reachable set.
• Do not produce visualizations during the experiment runs. Raw CSV + summary text only.
• Do not attempt to interpret results during the collection phase. Interpretation happens after all data is collected.
• Do not optimize for runtime. §11.3 runs in seconds; §11.4 and §11.5 run in minutes; §11.6 runs per-game. None of this is compute-bound.

---

§11.8. What We Will Ask After Data Collection

We are deliberately not specifying the post-data questions here. The point of this experimental arc is to generate data that may change what questions are worth asking. Some preliminary guesses at what the data might force us to ask:

• If §11.3 fails for the knight but succeeds for others, does the phase-shifted harmonic at arctan(½) require a different operator structure than linear combinations of row/column generators?
• If §11.5 shows phase_similarity uncorrelated with all thermodynamic quantities, is the phase representation measuring something we have not yet named?
• If §11.6 partition boundaries align with depth-gap peaks, can we use phase-cluster membership to replace depth-15 Stockfish with a phase-arithmetic classifier?
• If the phase operators work but offer no operational advantage, have we demonstrated that the 2D lattice is a convenient redundancy over a more fundamental coprime-cyclic structure?

These are placeholders. The real questions emerge from the data.

---

§11.9. Success and Failure Both Produce Knowledge

The explicit stance of this supplement: we do not know if the phase-operator move engine is a better abstraction than the geometric move generator. We do not know if it reveals structure the geometric representation hides. We do not know if UTLP S4's aliasing horizon mechanism transfers cleanly from temporal synchronization to spatial move generation.

We know what experiments would answer each of these questions, and we know the data each experiment would produce. We are running the experiments because the answer — whatever it is — will change what we understand about the chess lattice as a field-theoretic object.

If the phase operators reproduce the geometric generator exactly and offer no additional structure, we will have demonstrated that the geometric representation is the efficient one and the phase representation is a redundant alternative. That is a real result.

If the phase operators reveal partition structure that corresponds to computational difficulty, we will have found the meta-cognitive signal for search-budget allocation. That is a different real result.

If the phase operators fail to reproduce the geometric generator, we will have learned something specific about which polarization states resist phase-arithmetic description. That is another real result.

All three outcomes advance the research. None of them is wasted effort.

---

§12. Parallel King-Attack Encoder

Status. Working experiment. Triggered by §11.5.6's validated null for path-2 check filtering in the 640-dim encoder (encode_640 in the chess_spectral package). Asks whether a separate HDC instrument, derived from the same mathematical discipline that produced encode_640 but targeting king-attack structure specifically, can expose the signal that encode_640 does not.

Lives in PHASE_OPERATOR_SUPPLEMENT_12.md as a standalone document pending experimental validation. See that file for derivation, construction, and comparison protocol.

Important scoping. §12 does not modify encode_640. The existing 640-dim encoder remains the validated instrument for §9 and §11's experiments. §12 is a parallel instrument built to answer a specific question encode_640 did not answer. If §12 succeeds, the HDC encoder family has a king-attack member; if §12 fails, the existing encoder's construction pattern does not support king-attack content naturally and the null result from §11.5 reflects a structural property of that construction pattern, not a gap.