docs(silversight): symbolic regression design + GP-ELITE citation

Design doc for SilverSight-native symbolic regression using existing
HachimojiCodec, chaos game, spectral profile, and QUBO infrastructure.
No external imports — reimplement GP-ELITE concepts natively.

Added GP-ELITE (Sabri Hakou, MIT) to CITATION.cff as inspiration source.

Build: 2987 jobs, 0 errors

CITATION.cff

@@ -59,6 +59,16 @@ references:
     license: Apache-2.0
     notes: "Parent research repository (https://github.com/allaunthefox/Research-Stack). SilverSight ports proven Lean modules (`Semantics.FixedPoint`, `Semantics.SidonSets`, `Semantics.SieveLemmas`, `Semantics.InteractionGraphSidon`, `Semantics.BraidEigensolid`, `Semantics.BraidSpherionBridge`, etc.), agent contracts, and the no-Float compute doctrine from this source."
 
+  - type: software
+    title: "GP_ELITE: Régression symbolique par programmation génétique"
+    authors:
+      - name: "Sabri Hakou"
+    version: 0.1.0
+    date-released: 2026-06-13
+    license: MIT
+    repository-code: "https://github.com/ariel95500-create/gp-elite"
+    notes: "Inspired SilverSight's native symbolic regression design. GP-ELITE uses genetic programming with asymmetric island model, BIC fitness, linear scaling (Keijzer 2003), ε-lexicase selection, and stigmergic memory. SilverSight reimplements these concepts using existing infrastructure: HachimojiCodec classification, chaos game search, spectral profiles, and QUBO optimization. See `docs/SYMBOLIC_REGRESSION_DESIGN.md`."
+
   # NOTE: The following four references are domain sources used by
   # `formal/PVGS_DQ_Bridge/` and `formal/BindingSite/`. They are recorded as
   # `unpublished` until DOIs, arXiv IDs, or journal pages are confirmed.

docs/SYMBOLIC_REGRESSION_DESIGN.md

@@ -0,0 +1,131 @@
+# SilverSight Symbolic Regression — Design Document
+
+## Principle
+
+**No external imports.** Use existing SilverSight infrastructure:
+- `EquationShape` + `classifyEquation` — structural classification
+- `spectral_profile` — 8D spectral features
+- `chaos_game` — IFS contraction search
+- `sidon_address` — deterministic addressing
+- `qubo/` — binary optimization
+
+## Architecture
+
+```
+Input: (X, y) data points
+  ↓
+1. Generate candidate expression trees
+  ↓
+2. Classify each with classifyEquation → Hachimoji state
+  ↓
+3. Compute spectral profile for each expression
+  ↓
+4. Apply linear scaling (solve for a, b)
+  ↓
+5. Compute fitness = BIC(scaled_expression, data)
+  ↓
+6. Use chaos game to navigate state space
+  ↓
+7. Use QUBO to select optimal expression
+  ↓
+Output: Best expression with R² score
+```
+
+## Missing Pieces (to implement)
+
+### 1. Expression Tree Data Structure
+
+```python
+@dataclass
+class ExprNode:
+    op: str           # '+', '-', '*', '/', 'sqrt', 'sin', 'cos', 'log', 'exp', 'x', 'const'
+    left: Optional['ExprNode']
+    right: Optional['ExprNode']
+    value: Optional[float]  # for const nodes
+    depth: int = 0
+    size: int = 0
+```
+
+### 2. Linear Scaling (Keijzer 2003)
+
+Given expression g(x) and target y, solve:
+```
+f(x) = a·g(x) + b
+where a, b = argmin Σ(f(x_i) - y_i)²
+```
+
+Closed-form solution:
+```
+a = cov(g, y) / var(g)
+b = mean(y) - a·mean(g)
+```
+
+### 3. BIC Fitness
+
+```
+fitness = n·ln(MSE) + k·ln(n)
+where:
+  n = data points
+  k = tree complexity (weighted: var=1, const=3)
+  MSE = mean squared error after linear scaling
+```
+
+### 4. Chaos Game Search
+
+Use existing `chaos_game.py` to navigate expression space:
+- Each expression maps to a spectral profile
+- Spectral profile maps to a Sidon address
+- Chaos game contracts toward good expressions
+
+### 5. ε-Lexicase Selection
+
+Select on individual data points, not aggregate fitness:
+- For each data point, keep only expressions within ε of best
+- This preserves behavioral diversity
+
+### 6. Operator Diversity via Hachimoji States
+
+- Φ (trivial): simple expressions (x, x², √x)
+- Σ (symmetric): balanced expressions (x·y, x+y)
+- Λ (quantified): expressions with constants
+- Π (complex): deep expressions (sin(1/x), exp(x²))
+- Ω (contradiction): degenerate expressions (constant, NaN)
+
+Force diversity by requiring expressions in multiple Hachimoji states.
+
+## Implementation Plan
+
+### Phase 1: Core Infrastructure
+1. `python/expr_tree.py` — expression tree data structure
+2. `python/linear_scaling.py` — Keijzer linear scaling
+3. `python/bic_fitness.py` — BIC fitness function
+
+### Phase 2: Search
+4. `python/chaos_game_search.py` — chaos game navigation
+5. `python/lexicase_selection.py` — ε-lexicase selection
+
+### Phase 3: Integration
+6. `python/symbolic_regression.py` — main entry point
+7. `tests/test_symbolic_regression.py` — verification
+
+### Phase 4: QUBO Enhancement
+8. Use QUBO to select optimal expression from candidates
+9. Use Hachimoji states to enforce diversity
+
+## Key Advantage Over GP-ELITE
+
+GP-ELITE uses genetic programming (random mutation + crossover).
+SilverSight uses **chaos game** (deterministic IFS contraction) + **Hachimoji states** (structural classification).
+
+This means:
+- Deterministic: same input → same output
+- Structured: expressions are classified by type, not just fitness
+- Efficient: chaos game contracts faster than random search
+
+## Test Cases
+
+1. **Kepler's Third Law**: T = a^1.5 from 8 planets
+2. **Simple polynomial**: y = 2x² + 3x + 1
+3. **Trigonometric**: y = sin(x) + 0.5·cos(2x)
+4. **Exponential**: y = exp(-x²)
+5. **BMCTE entropy**: H(p) = f(N, p) from experiment data