From c22549d3de5946d876215a6f6997240f63c5eb05 Mon Sep 17 00:00:00 2001 From: openresearch Date: Sat, 4 Jul 2026 20:52:52 +0000 Subject: [PATCH] =?UTF-8?q?docs(research):=20spherical=20chiral=20CRT=20?= =?UTF-8?q?=E2=80=94=20labels=20on=20S=C2=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The chiral implementation is positional on a sphere — labels live at (θ,φ) coordinates on S², and chiral crossings permute spherical positions. This is a ROTATION (not negation), which breaks the ring-automorphism invariance. The degree (winding number of the braid on S²) is the topological invariant connecting to HCMR's mixing rate: high degree = good mixing = low self-loop = high throughput Connections: - Dual quaternions: S³ rotations on S² - Rendering equation: hemisphere integral = half of S² - Observerless observer: rotational invariance on S² - HCMR: degree = mixing rate - (ω_i · n) = q-profile at each spherical position --- docs/research/SPHERICAL_CHIRAL_CRT.md | 165 ++++++++++++++++++++++++++ 1 file changed, 165 insertions(+) create mode 100644 docs/research/SPHERICAL_CHIRAL_CRT.md diff --git a/docs/research/SPHERICAL_CHIRAL_CRT.md b/docs/research/SPHERICAL_CHIRAL_CRT.md new file mode 100644 index 00000000..62f73904 --- /dev/null +++ b/docs/research/SPHERICAL_CHIRAL_CRT.md @@ -0,0 +1,165 @@ +# Spherical Chiral CRT: Labels on S² + +**Status:** REFINEMENT — chiral positions are on a sphere, not flat +**Date:** 2026-07-04 +**Depends on:** `CHIRAL_CRT_MULTIPLEXING.md`, `RENDERING_EQUATION_OBSERVERLESS.md`, +`DUAL_QUATERNION_SIDON_FILTER.md`, `pipeline_core.py` + +--- + +## 1. The Key Insight + +The chiral implementation is **positional on a sphere**. Labels live at +specific (θ, φ) coordinates on S², not in a flat array. The chiral +crossing swaps which strand is at which **spherical position**. + +This means: +1. The CRT moduli encode **geometric constraints at each spherical position** + (distance to corridor walls, angular position relative to corner, etc.) +2. The chiral permutation changes which label is at which spherical position +3. The **degree** (winding number of the braid on S²) is a topological + invariant that depends on the chiral configuration +4. The Sidon check operates on **spherical geometry**, not just flat CRT sums + +## 2. Why This Breaks Chiral Invariance + +The negation proof (CHIRAL_INVARIANCE_GENERALIZED.md) assumed flat CRT +embeddings where the chiral flip is x → -x mod L. On a sphere, the chiral +operation is a **rotation** (permutation of spherical positions), not a +negation. Rotations are NOT ring automorphisms of Z/LZ. + +Specifically: +- Flat: chiral flip = negation (x → -x) — ring automorphism, Sidon-invariant +- Spherical: chiral = rotation of positions (label moves to different (θ,φ)) + — NOT a ring automorphism, Sidon can change + +The spherical positions have different geometric meanings: +- Position at (0, 0): near the inner wall (poloidal/identity, modulus L₀) +- Position at (π/2, 0): at the corner (transition, modulus L₁) +- Position at (π, 0): near the outer wall (toroidal/reflection, modulus L₂) +- Position at (0, π/2): angular offset (modulus L₃) + +Different labels at different positions produce different CRT embeddings +because each position has a different modulus encoding a different +geometric constraint. + +## 3. The Degree (Winding Number) + +The braid on S² has a **degree** (winding number): + + deg(γ) = (1/4π) ∮ (γ × γ') · dγ + +where γ: [0,1] → S² is the braid trajectory. + +The degree counts how many times the braid wraps around the sphere. +It's a topological invariant — invariant under continuous deformation, +but NOT invariant under chiral permutation (which changes the trajectory). + +Connection to HCMR: +- Degree = mixing rate of the Markov chain on the sphere +- High degree = more wrapping = more mixing = lower self-loop +- Low degree = less wrapping = less mixing = higher self-loop +- Ring dispatch (degree = k) → self_loop = 0 (perfect mixing) +- AVX-512 (degree = 0) → self_loop = 0.885 (stuck, no wrapping) + +## 4. Spherical CRT Embedding + +Each label aᵢ is at a spherical position (θᵢ, φᵢ): + + F(aᵢ) = (aᵢ mod L₀(θᵢ, φᵢ), S - aᵢ mod L₁(θᵢ, φᵢ), ...) + +where Lⱼ(θ, φ) is a position-dependent modulus encoding the j-th +geometric constraint at position (θ, φ). + +The chiral permutation σ swaps positions: + σ: (θᵢ, φᵢ) → (θ_{σ(i)}, φ_{σ(i)}) + +This changes which label pairs with which modulus, breaking the +ring-automorphism invariance. + +## 5. Connection to Dual Quaternions + +Unit quaternions live on S³ (the 3-sphere). A rotation on S² is: + + R(q) = q · v · q⁻¹ + +where q ∈ S³ is a unit quaternion and v ∈ S² is the position. + +The chiral permutation on S² corresponds to a rotation in S³: + + σ ↔ q_σ ∈ S³ + +The dual quaternion product: + + q_i ⊛ q_j = r_i · r_j + ε · (r_i · t_j + t_i · r_j) + +where r_i, t_i are the rotation and translation quaternions at position i. +The spherical positions make r_i and t_i depend on (θᵢ, φᵢ), so the +chiral permutation changes the products non-trivially. + +## 6. Connection to the Rendering Equation + +The rendering equation integrates over the hemisphere (half of S²): + + L_o = L_e + ∫_Ω f_r(ω_i, ω_o) L_i(ω_i) (ω_i · n) dω_i + +The spherical chiral CRT is the DISCRETE version: +- Labels = sample points on S² (the hemisphere) +- CRT moduli = BRDF values at each sample point +- Chiral permutation = rearranging which sample point gets which label +- Sidon check = are all pairwise products distinct? + +The (ω_i · n) factor is the q-profile at each spherical position — +the angle between the sample direction and the surface normal. + +## 7. Implementation: Spherical Positions in pipeline_core.py + +The Config structure needs spherical positions: + +```python +@dataclass +class Config: + chiral: tuple # permutation of positions (not negation) + labels: tuple # Sidon labels (integers) + positions: tuple # (θ, φ) spherical coordinates per strand + S: int # reflection point + moduli: tuple # position-dependent CRT moduli + ... +``` + +The _embed_chiral_positional function becomes: + +```python +def _embed_chiral_positional(self, c): + # Permute positions (not labels) according to chiral config + permuted_positions = self._permute(c.positions, c.chiral) + embedded = [] + for label, (theta, phi) in zip(c.labels, permuted_positions): + # Modulus depends on spherical position + L0 = position_to_modulus(theta, phi, axis=0) + L1 = position_to_modulus(theta, phi, axis=1) + row = [label % L0, (c.S - label) % L1] + embedded.append(row) + return embedded +``` + +## 8. claim_boundary + +``` +spherical-chiral-crt:positional-permutation:refinement +``` + +The chiral implementation is positional on S² — labels live at spherical +coordinates, and the chiral crossing permutes positions. This is a rotation, +NOT a negation, and breaks the ring-automorphism invariance. + +The degree (winding number) of the braid on S² is the topological invariant +that connects to HCMR's mixing rate. High degree = good mixing = low +self-loop = high throughput. + +The spherical structure connects to: +- Dual quaternions (S³ rotations on S²) +- Rendering equation (hemisphere integral) +- Observerless observer (rotational invariance on S²) +- HCMR (degree = mixing rate) +```