diff --git a/docs/research/BRAIDSTORM_TREEBRAID_COUCH.md b/docs/research/BRAIDSTORM_TREEBRAID_COUCH.md new file mode 100644 index 00000000..7bc3c893 --- /dev/null +++ b/docs/research/BRAIDSTORM_TREEBRAID_COUCH.md @@ -0,0 +1,366 @@ +# BraidStorm × TreeBraid × COUCH: Chiral Batch Pipeline + +**Status:** DESIGN — connects existing SilverSight components to chiral batch encoding +**Date:** 2026-07-04 +**Depends on:** `DUAL_QUATERNION_SIDON_FILTER.md`, `CHIRAL_BATCH_ENCODING.md`, +`BraidEigensolid.lean`, `GCCL.lean`, `braid_group_action.md` +**Components:** +- BraidStorm = `formal/CoreFormalism/BraidEigensolid.lean` (8-strand, Sidon labels) +- TreeBraid = tree-organized braid (factorizes crossing space) +- COUCH = `formal/SilverSight/GCCL.lean` `couchStable` gate (moving sofa constraint) + +--- + +## 1. The Three Components + +### 1.1 BraidStorm (BraidEigensolid.lean) + +The 8-strand braid system: +``` +BraidState = { + strands: Fin 8 → BraidStrand, -- 8 strands with Sidon labels + step_count: Nat -- monotone counter +} +``` + +Sidon labels: {1, 2, 4, 8, 16, 32, 64, 128} (powers of 2, guaranteed Sidon). + +Each crossing σ_i has chirality: + σ_i⁺¹ = over-crossing (right-handed) + σ_i⁻¹ = under-crossing (left-handed) + +With k crossings in the braid word, there are 2^k chiral configurations. +For k=8 (one crossing per strand): 2^8 = 256 configurations in ONE braid structure. + +### 1.2 TreeBraid (tree-organized braid) + +From `ENHANCEMENT_PISSS_BRAID_INTEGRATION.md`: + `BraidField.rgFlow` = fold of `betaStep` over spike train = tree braid + `Mountain.merge` = tree node merge + `MMR.append` = tree rebalancing + +The TreeBraid factorizes the crossing space: +- Independent crossings = separate tree branches (can flip without affecting siblings) +- Dependent crossings = grouped in same subtree (must flip together) +- This means 256 configurations aren't flat — they're a TREE + +Example: if crossings 1-4 are independent from crossings 5-8: + Tree: [σ₁ σ₂ σ₃ σ₄] [σ₅ σ₆ σ₇ σ₈] + Each group has 2^4 = 16 chiral variants + Total: 16 × 16 = 256, but factorized as 16 + 16 instead of 256 + +This is the KEY to batch encoding: the TreeBraid lets us process +independent groups separately, reducing the search from exponential +to polynomial in each group. + +### 1.3 COUCH (GCCL.lean) + +The COUCH gate in the Admit pipeline: +``` +structure CandidateX where + ... + couchStable : Bool -- pressure/hysteresis stability + ... + +Admit(X) = ... && X.couchStable && ... +``` + +COUCH checks: "is the candidate's Omega in the stable range?" += "can the shape navigate the corridor?" (moving sofa constraint) += "apartment constraint x_i(t) ∈ Ω satisfied?" + +COUCH IS the geometric filter: it rejects chiral configurations +where the sofa can't make the turn. + +--- + +## 2. The Batch Pipeline + +### 2.1 Flow + +``` +BraidStorm (8 strands, 256 chiral variants) + ↓ generate all chiral configurations +TreeBraid (factorize into independent groups) + ↓ process groups separately (polynomial, not exponential) +COUCH (geometric filter) + ↓ reject configurations where sofa can't navigate +Sidon Filter (algebraic filter via dual quaternion products) + ↓ select configurations with unique pairwise signatures +Output: structurally meaningful chiral configurations +``` + +### 2.2 What Each Stage Does + +**Stage 1 — BraidStorm generates:** +- 8-strand braid with Sidon labels {1,2,4,8,16,32,64,128} +- Each crossing σ_i has chirality εᵢ ∈ {+1, -1} +- 2^8 = 256 chiral configurations encoded in ONE braid structure +- Each configuration = a different dual quaternion trajectory + +**Stage 2 — TreeBraid factorizes:** +- Identifies independent crossing groups (tree branches) +- If crossings {1,2,3,4} are independent from {5,6,7,8}: + - Process 2^4 = 16 variants per group separately + - Total: 16 + 16 = 32 checks instead of 256 +- The TreeBraid structure comes from the braid relations: + - σ_i σ_j = σ_j σ_i when |i-j| ≥ 2 (independent) + - σ_i σ_{i+1} σ_i = σ_{i+1} σ_i σ_{i+1} (dependent, Yang-Baxter) + +**Stage 3 — COUCH filters:** +- For each factorized chiral configuration: + - Check if the sofa shape can navigate the L-corridor + - COUCH_stable = True if the motion is geometrically valid + - COUCH_stable = False if the shape hits a wall +- This is the geometric filter from GCCL.lean + +**Stage 4 — Sidon filter (dual quaternion):** +- For each COUCH-passing configuration: + - Compute dual quaternion products q_i ⊛ q_j for all boundary pairs + - Check Sidon: are all products distinct? + - Sidon-clean = unique signatures (structurally meaningful) + - Degenerate = collision (ambiguous, uninformative) +- This is the algebraic filter from DUAL_QUATERNION_SIDON_FILTER.md + +### 2.3 Why This Is Hundreds per Run + +The BraidStorm generates 256 configurations in ONE structure. +The TreeBraid factorizes them into independent groups. +COUCH + Sidon filter each group. + +Total work: O(groups × 2^{group_size}) instead of O(2^k). +For 2 independent groups of 4: 2 × 16 = 32 instead of 256. +For 4 independent groups of 2: 4 × 4 = 16 instead of 256. + +But we still TEST all 256 — the factorization just makes it faster. +The filter rate (what % pass COUCH + Sidon) is the research signal. + +--- + +## 3. Connection to Dual Quaternions + +### 3.1 Braid Crossing → Dual Quaternion + +Each braid crossing σ_i^ε maps to a dual quaternion: + σ_i⁺¹ → q_r rotation (poloidal, over-crossing) + σ_i⁻¹ → q_r* conjugate rotation (poloidal, under-crossing) + Translation along strand → q_d (toroidal) + +The full braid word maps to a dual quaternion product: + Q = q_{σ₁}^ε₁ · q_{σ₂}^ε₂ · ... · q_{σₖ}^εₖ + +### 3.2 COUCH as Dual Quaternion Stability + +COUCH_stable checks if the dual quaternion trajectory stays +within the "corridor" — i.e., the translation component q_d +doesn't push the shape outside the L-corridor. + +In dual quaternion terms: + COUCH_stable ⟺ |q_d(t)| < corridor_width for all t + (the translation magnitude stays within the corridor) + +### 3.3 Sidon Filter on Dual Quaternion Products + +For each COUCH-passing configuration: +- Compute Q_{ij} = q_i ⊛ q_j for all boundary pairs (i,j) +- Sidon-clean: all Q_{ij} distinct (unique interaction signatures) +- Degenerate: some Q_{ij} = Q_{kl} (ambiguous interactions) + +The dual quaternion product captures BOTH rotation and translation +simultaneously — no tolerance band needed (algebraic equality, not metric). + +--- + +## 4. Implementation Plan + +### Phase 1: BraidStorm Chiral Batch (Python) + +```python +def braidstorm_chiral_batch(labels, S, moduli, braid_word): + """Batch-test all chiral configurations of a braid word. + + labels: Sidon labels [1,2,4,8,16,32,64,128] + S: reflection point + moduli: [L0, L1, ..., L7] (8 moduli, one per strand) + braid_word: [(strand_i, strand_j), ...] — which strands cross + + Returns: list of (chiral_config, is_sidon, sidon_score) + """ + k = len(braid_word) + configs = list(product([0, 1], repeat=k)) # 2^k configurations + + # Identity components (computed once) + id_comps = [a % moduli[0] for a in labels] + + results = [] + for config in configs: + embedded = [] + for a in labels: + row = [a % moduli[0]] + for j, (si, sj) in enumerate(braid_word): + Lj = moduli[j + 1] + if config[j] == 0: + row.append((S - a) % Lj) # over + else: + row.append((a - S) % Lj) # under + embedded.append(row) + + sidon = sidon_check(embedded, moduli) + results.append((config, sidon["is_sidon"], sidon["sidon_score"])) + + return results +``` + +### Phase 2: TreeBraid Factorization + +```python +def treebraid_factorize(braid_word): + """Factorize braid word into independent groups. + + Uses braid relations: σ_i σ_j = σ_j σ_i when |i-j| >= 2. + Returns list of groups, each group is a list of crossing indices. + """ + groups = [] + remaining = list(range(len(braid_word))) + + while remaining: + group = [remaining[0]] + for i in remaining[1:]: + si, sj = braid_word[i] + # Check if crossing i is independent of all in group + independent = True + for j in group: + gi, gj = braid_word[j] + if abs(si - gi) < 2 or abs(si - gj) < 2 or \ + abs(sj - gi) < 2 or abs(sj - gj) < 2: + independent = False + break + if independent: + group.append(i) + for g in group: + remaining.remove(g) + groups.append(group) + + return groups +``` + +### Phase 3: COUCH + Sidon Pipeline + +```python +def couch_sidon_pipeline(labels, S, moduli, braid_word, shape, motion): + """Full pipeline: BraidStorm → TreeBraid → COUCH → Sidon. + + 1. Generate all chiral configurations (BraidStorm) + 2. Factorize into independent groups (TreeBraid) + 3. Check COUCH stability (can shape navigate corridor?) + 4. Check Sidon property (unique dual quaternion products?) + """ + # Stage 1+2: Batch + factorize + groups = treebraid_factorize(braid_word) + + # Process each group independently + all_results = [] + for group in groups: + group_word = [braid_word[i] for i in group] + group_configs = list(product([0, 1], repeat=len(group))) + + for config in group_configs: + # Stage 3: COUCH — geometric filter + # (check if shape can navigate with this chiral config) + couch_ok = check_couch_stability(shape, motion, config) + + if not couch_ok: + all_results.append({ + "config": config, "group": group, + "couch_stable": False, "is_sidon": None, + }) + continue + + # Stage 4: Sidon — algebraic filter + sidon = check_sidon_chiral(labels, S, moduli, config) + all_results.append({ + "config": config, "group": group, + "couch_stable": True, "is_sidon": sidon["is_sidon"], + "sidon_score": sidon["sidon_score"], + }) + + return all_results +``` + +--- + +## 5. What This Enables + +### 5.1 Orders of Magnitude More Data + +Current: 75 configurations per run (5 shapes × 3 n × 5 q) +With BraidStorm batch: 75 × 256 = 19,200 configurations per run +With TreeBraid factorization: process in 32-64 checks instead of 256 +With COUCH pre-filter: only test Sidon on geometrically valid configs + +### 5.2 The COUCH Gate as Pre-filter + +COUCH is the CHEAP filter (geometric, O(1) per config). +Sidon is the EXPENSIVE filter (algebraic, O(n²) per config). + +By running COUCH first: +- Reject geometrically invalid configs (sofa can't navigate) +- Only run Sidon check on COUCH-passing configs +- If 50% pass COUCH: 128 Sidon checks instead of 256 + +### 5.3 The TreeBraid as Search Space Reduction + +The braid relations (σ_i σ_j = σ_j σ_i for |i-j| ≥ 2) mean many +chiral configurations are EQUIVALENT. The TreeBraid identifies +these equivalences and processes only unique configurations. + +For a typical 8-strand braid: +- 256 raw configurations +- ~64-128 unique after TreeBraid factorization (estimated) +- ~32-64 pass COUCH +- ~10-20 pass Sidon + +The final 10-20 configurations are the "structurally meaningful" ones. + +--- + +## 6. Connection to the Moving Sofa + +The COUCH gate's "apartment constraint" IS the moving sofa: + x_i(t) ∈ Ω (shape stays in corridor) + +The braid word describes the boundary point worldlines through the corner. +The chiral configurations describe different ways the boundary points +can cross (over/under) during the motion. + +COUCH filters: which chiral configurations correspond to physically +realizable sofa motions (shape doesn't hit walls). + +Sidon filters: which of those motions have unique boundary interactions +(no two pairs of boundary points produce the same dual quaternion product). + +The COMBINED filter (COUCH ∧ Sidon) selects motions that are BOTH +geometrically valid AND structurally meaningful — these are the +configurations where the octagon principle could detect the sofa's +chromatic structure from the spectrum. + +--- + +## 7. claim_boundary + +``` +braidstorm-treebraid-couch:batch-pipeline:design +``` + +This document connects three existing SilverSight components: +1. BraidStorm (8-strand, Sidon labels, chiral crossings) — generates 256 configs +2. TreeBraid (tree-organized, factorizes via braid relations) — reduces search +3. COUCH (GCCL gate, moving sofa constraint) — geometric pre-filter + +Combined with the dual quaternion Sidon filter, this pipeline batch-processes +hundreds of chiral configurations per run, with COUCH as the cheap geometric +pre-filter and Sidon as the expensive algebraic filter. + +The Hutter prize lesson applies: the batch doesn't COMPRESS 256 configs into 1 +(conservation law blocks that). It FILTERS 256 configs down to the ~10-20 +that are both geometrically valid and structurally meaningful. diff --git a/docs/research/CHIRAL_BATCH_ENCODING.md b/docs/research/CHIRAL_BATCH_ENCODING.md new file mode 100644 index 00000000..fcd2bddd --- /dev/null +++ b/docs/research/CHIRAL_BATCH_ENCODING.md @@ -0,0 +1,316 @@ +# Chiral Batch Encoding: Hundreds of Configurations per Run + +**Status:** REFINEMENT — connects chiral braid chirality to batch Sidon filtering +**Date:** 2026-07-04 +**Depends on:** `DUAL_QUATERNION_SIDON_FILTER.md`, `braid_group_action.md`, +`TOROIDAL_POLOIDAL_REFINEMENT.md`, `weird_machine_conservation_law.md` +**Key insight:** Chirality (over/under = ±1 per crossing) means a braid word of +length k encodes 2^k configurations. Batch-encode hundreds, Sidon-filter in one pass. + +--- + +## 1. The Chiral Braid Structure + +### 1.1 Chirality = Handedness = ±1 per Crossing + +In the braid group B_n, each generator σ_i has two chiral forms: + σ_i⁺¹ = over-crossing (right-handed) + σ_i⁻¹ = under-crossing (left-handed) + +A braid word of length k has 2^k possible chiral configurations: + w = σ_{i₁}^{ε₁} σ_{i₂}^{ε₂} ... σ_{iₖ}^{εₖ} where εⱼ ∈ {+1, -1} + +### 1.2 Chirality in the CRT Embedding + +The CRT embedding already has chirality built in: + Identity axis: a mod L₀ = poloidal (no reflection = "straight through") + Reflection axes: S-a mod Lᵢ = toroidal (reflection = "flipped") + +The S-a reflection IS the chiral operation: + S-a = "over" (positive chirality) + a-S = "under" (negative chirality, equivalent to -(S-a)) + +Each reflection axis Lᵢ contributes one chiral bit. With k reflection +axes, there are 2^k chiral configurations per identity axis choice. + +### 1.3 Chirality in Dual Quaternions + +Dual quaternions have natural chirality: + q = q_r + ε q_d (standard) + q* = q_r - ε q_d (conjugate = opposite chirality) + +The conjugate reverses the translation direction (toroidal flip) while +preserving the rotation (poloidal). This is exactly the S-a ↔ a-S flip. + +A dual quaternion pair (q_i, q_j) has 4 chiral configurations: + (q_i, q_j) — both standard + (q_i*, q_j) — i flipped + (q_i, q_j*) — j flipped + (q_i*, q_j*) — both flipped + +With n boundary points, there are 4^(n choose 2) chiral configurations +of the full pairwise product set. We don't test all of these — we +batch-encode a representative sample and Sidon-filter. + +--- + +## 2. Batch Encoding: How It Works + +### 2.1 The Problem with Sequential Testing + +Current approach (v2/v3): test one (shape, n, q) configuration per run. +- 5 shapes × 3 n-values × 5 q-values = 75 configurations +- Each takes ~10s = 12.5 minutes total +- Each is a separate Sidon check + +This is slow and doesn't exploit the braid structure. + +### 2.2 Chiral Batch Encoding + +The chiral braid allows encoding MANY configurations into a SINGLE run: + +1. Choose a base braid word w = σ₁ σ₂ σ₃ ... (the "spine") +2. For each crossing, choose chirality εᵢ ∈ {+1, -1} +3. A batch of B configurations = B different chirality assignments + ε¹ = (+1, +1, +1, ...), ε² = (+1, +1, -1, ...), etc. +4. All B configurations share the same braid SPINE (which strands cross) + but differ in CHIRALITY (how they cross) + +5. For each configuration, compute the CRT embedding with the chiral + reflection choices: + - εᵢ = +1 → S-a mod Lᵢ (standard reflection) + - εᵢ = -1 → a-S mod Lᵢ (flipped reflection) + +6. Apply the Sidon filter ONCE to the entire batch: + - For each configuration, check if the CRT-reconstructed sums are Sidon + - The filter selects which chiral configurations produce unique + pairwise signatures + +### 2.3 Why This Is Hundreds per Run + +With k reflection axes: +- 2^k chiral configurations per (identity, label_set) pair +- For k=8 (our standard 8-strand braid): 2^8 = 256 configurations +- For k=10: 2^10 = 1024 configurations + +Each run can batch-test ALL 256 (or 1024) chiral configurations with +a SINGLE CRT reconstruction pass — the identity axis is computed once, +and each chiral variant only changes the reflection components. + +The Sidon filter then selects which of the 256 configurations are +structurally meaningful (Sidon-clean) vs degenerate (collision). + +### 2.4 Connection to the Hutter Prize Filtering + +The Hutter prize lesson: compression is dead, filtering works. + +Batch encoding is the APPLICATION of this lesson: +- Don't compress 256 configurations into 1 (impossible — conservation law) +- Don't test 256 configurations sequentially (slow) +- DO: batch-encode all 256, then FILTER to the Sidon-clean ones + +The filter selects which chiral configurations have unique pairwise +signatures. The rest are noise (degenerate, collision). This is the +same filtering mechanism from the weird machine conservation law: + program (chiral configuration) + residual (dropped configs) ≥ K(data) +But we don't care about the residual — we care about which configurations +the filter KEEPS. + +--- + +## 3. The Chiral Sidon Filter (Concrete) + +### 3.1 Algorithm + +``` +Input: + - Label set A = {a₁, ..., aₙ} (Sidon in ℤ) + - Identity modulus L₀ + - Reflection moduli L₁, ..., Lₖ (pairwise coprime) + - Reflection point S + - Batch size B (number of chiral configurations) + +Output: + - For each of B chiral configurations: is_sidon (bool), sidon_score + +Algorithm: + 1. Compute identity component once: id_i = a_i mod L₀ for all i + 2. For each chiral configuration c ∈ {0, 1}^k (binary vector): + a. For each reflection axis j ∈ {1, ..., k}: + - If c[j] = 0: ref_i_j = (S - a_i) mod Lⱼ (standard) + - If c[j] = 1: ref_i_j = (a_i - S) mod Lⱼ (flipped) + b. CRT reconstruct: val_i = CRT(id_i, ref_i_1, ..., ref_i_k) + c. Check Sidon: all pairwise sums val_i + val_j distinct mod M? + 3. Return filter results for all B configurations +``` + +### 3.2 Computational Cost + +- Identity component: O(n) — computed ONCE +- Per configuration: O(n·k) for reflection + O(n²) for Sidon check +- Total: O(n) + B × O(n·k + n²) +- For n=21, k=8, B=256: 21 + 256 × (168 + 441) = 21 + 155,904 ≈ 156K ops +- vs sequential: 256 × (21 + 168 + 441) = 256 × 630 = 161K ops + +The speedup is modest for small k, but the REAL advantage is: +1. The identity component is shared (not recomputed) +2. The Sidon check can be parallelized across configurations +3. The filter selects which configurations are worth deeper analysis + +### 3.3 What the Filter Selects + +The chiral Sidon filter selects configurations where: +- The chiral choices (which axes are flipped) produce unique pairwise sums +- This means the chiral pattern is "informative" — it breaks symmetries + that would otherwise cause collisions + +Configurations that FAIL the filter: +- Have chiral choices that create sum collisions (degenerate) +- The chiral pattern doesn't break existing symmetries +- These are "uninformative" — the chirality doesn't help + +The filter rate (fraction of configurations that pass) measures how +much chiral information the braid structure carries: +- High pass rate (>50%): chirality doesn't matter much (symmetric problem) +- Low pass rate (<10%): chirality is critical (most configs degenerate) +- Medium pass rate (~30%): chirality selects a specific structural class + +--- + +## 4. Connection to q-Profile + +### 4.1 q-Profile as Chiral Ratio + +The q-profile = L₁/L₀ (reflection/identity = toroidal/poloidal). + +In the chiral batch: +- q < 1: L₁ < L₀ → reflection axis smaller → chiral flip has less impact +- q > 1: L₁ > L₀ → reflection axis larger → chiral flip has more impact +- q = 1: L₁ = L₀ → chiral flip is symmetric → degenerate + +The q-profile sweep showed q > 1 has 100% Sidon rate. In chiral terms: +larger reflection axis → chiral flips create more diverse products → +fewer collisions → higher Sidon rate. + +### 4.2 Chiral q-Sweep + +Instead of sweeping q across fixed chiral configurations: +1. Fix q at the optimal value (q > 1, e.g. q = 3/2) +2. Sweep chiral configurations (256 variants) +3. Measure: which chiral patterns have highest Sidon score? + +This separates the q-effect (axis ratio) from the chirality effect +(which axes are flipped). The q-profile sweep couldn't do this — +it tested one chirality per q value. + +--- + +## 5. Implementation Plan + +### Phase 1: Chiral Batch CRT (Python, exact arithmetic) + +```python +def chiral_batch_sidon(labels, S, L0, Ls, batch_configs=None): + """Batch-test chiral configurations for Sidon property. + + Ls = [L1, ..., Lk] reflection moduli + batch_configs = list of binary tuples (length k), each specifying + which axes are flipped (1 = flipped, 0 = standard) + If None, test ALL 2^k configurations. + """ + k = len(Ls) + if batch_configs is None: + batch_configs = list(product([0, 1], repeat=k)) + + # Identity component (computed once) + id_comp = [a % L0 for a in labels] + + results = [] + for config in batch_configs: + # Reflection components with chiral choices + embedded = [] + for a in labels: + row = [a % L0] # identity + for j, Lj in enumerate(Ls): + if config[j] == 0: + row.append((S - a) % Lj) # standard + else: + row.append((a - S) % Lj) # flipped + embedded.append(row) + + # CRT reconstruct + Sidon check + sidon = sidon_check(embedded, [L0] + Ls) + results.append({ + "config": config, + "is_sidon": sidon["is_sidon"], + "sidon_score": sidon["sidon_score"], + "collisions": sidon["collisions"], + }) + + return results +``` + +### Phase 2: Chiral q-Sweep + +1. Fix L₀ = 7 (optimal from capacity envelope) +2. For each q ∈ {3/2, 2, 5/2, 3}: + - Set L₁ = L₀ × q + - Batch-test all 2^k chiral configurations + - Measure: pass rate, best config, worst config +3. Compare to sequential q-sweep results + +### Phase 3: Dual Quaternion Chiral Filter + +1. For each chiral configuration, compute dual quaternion products +2. Apply Sidon filter to dual quaternion products (not CRT sums) +3. Compare: does the dual quaternion filter select different configs + than the CRT filter? + +--- + +## 6. What This Enables + +### 6.1 Orders of Magnitude More Configurations + +Current: 75 configurations per run (5 shapes × 3 n × 5 q) +With chiral batch: 75 × 256 = 19,200 configurations per run +With k=10: 75 × 1024 = 76,800 configurations per run + +### 6.2 Statistical Power + +With 256+ configurations per (shape, n, q): +- Can compute Sidon pass rate with statistical confidence +- Can identify which chiral patterns are optimal +- Can detect phase transitions (where pass rate drops sharply) + +### 6.3 Connection to the Moving Sofa + +The sofa motion through the L-corridor IS a braid: +- Boundary point worldlines = braid strands +- Corner navigation = braid crossings +- Each crossing has chirality (over/under = which strand is in front) + +Batch-encoding chiral braid configurations = batch-encoding different +sofa motion variants. The Sidon filter selects which motions have +unique boundary interactions (structurally meaningful) vs degenerate +(symmetric, uninformative). + +--- + +## 7. claim_boundary + +``` +chiral-batch-encoding:efficiency-multiplier:conceptual +``` + +The chiral braid structure allows batch-encoding 2^k configurations +per run (k = number of reflection axes). The Sidon filter then selects +which configurations are structurally meaningful. This is the Hutter +prize lesson applied: filtering works, compression doesn't, and +batching makes filtering efficient. + +**MEASURED:** q > 1 has 100% Sidon rate (from q-profile sweep) +**PREDICTED:** chiral batch will show ~30-50% pass rate per q value, + with specific chiral patterns being optimal +**OPEN:** does the chiral filter select different configs than the + CRT sum filter?