# flenn-chess — STRATEGIC PLAN (G0 draft, rev 2026-07-06 per Tom's architecture)
Operationalizes /var/we/rnd/FLENN-ARCHITECTURE.md (Learn + Think) on chess. Approve G0 to open G1.

## The bet (revised — discovery, not hand-wiring)
A system that (a) holds board/game **memory-history**, (b) grows a compact library of high-leverage
logical **abstractions** by an interleaved **wake/dream** search against the (Zipfian) space of
position features, and (c) **decides** by proposing-and-evaluating combinations in that abstract
space, will evaluate positions and choose moves **more sample-efficiently and more interpretably**
than a plain net that buries all structure in opaque weights. The FLENN material is a set of ideas,
not experiments — chess is the cheap, oracle-backed place to find out if the architecture works.
(Corrected from the earlier "pre-wired logic wins": the claim is that DISCOVERED logic has leverage;
hand-wired motifs are an ablation the discovered ones must match or beat.)

## Why chess (unchanged, strengthened)
Logic-dense; free perfect oracle (Stockfish) → infinite exact labels, zero data risk; clean metrics;
and it exercises BOTH subsystems — memory-history (positions→outcomes) AND a propose-and-evaluate
thinking space (candidate moves/plans evaluated for best-action+best-future). "Do we need the world
abstracted to evaluate the future? Maybe" → yes: this project is where we test planning over
discovered abstractions vs. raw search.

## Operationalizing the architecture on chess
- **Base concept nodes (level 1):** cheap board predicates as fuzzy/boolean features — piece-on-square,
  attacks(x,y), defends(x,y), pinned(x), passed-pawn, king-exposure, mobility. These are the
  known-world entities.
- **Wake phase:** train the value net (predict Stockfish eval, and/or move policy) using the current
  concept library on sampled positions.
- **Dream phase (the core novelty, offline):** propose many pairwise (and small-tuple) combinations of
  current concept nodes via the fuzzy-logic ops (AND/OR/NOT/IMPLIES/XOR) + arithmetic recombination;
  evaluate each candidate's LEVERAGE = marginal reduction in eval-loss beyond the existing library,
  penalized by redundancy (conditional MI with the target given current nodes); keep the top few per
  "night" (respecting "only a few learnable per night"), discard the vast Zipfian tail. Over nights, a
  compact library of discovered abstractions grows (some may be recognizable tactics like fork/pin —
  or novel ones; that's the interesting part).
- **Decide phase (planning):** abstract the position into concept-node activations; search a SMALL
  space of abstract move/plan combinations, scoring each with the learned value over abstractions →
  best action + best future. (Compare vs. raw minimax/MCTS at matched node budget.)

## Success metrics + baselines (matched cost throughout)
1. **Sample-efficiency:** eval-prediction error vs. #positions — the full wake/dream FLENN vs. a plain
   MLP vs. a small CNN. Win = same error at materially fewer positions, or lower asymptote.
2. **Abstraction leverage (the architecture's own claim):** does the dream loop's discovered library
   beat (a) NO abstractions (plain net) and (b) HAND-WIRED motif nodes (the ablation)? Do wake/dream
   cycles measurably lift accuracy per night, then plateau (the "few per night" dynamic)?
3. **Planning:** does propose-and-evaluate over abstractions choose better moves (Elo, or top-1 vs
   Stockfish) than raw search at equal compute?
4. **Interpretability:** are the discovered abstractions readable — do they correspond to motifs,
   and can we show which fired in a given decision?
Kill criteria per metric (a clean negative is a cheap, valuable result).

## Doorway sequence
- **G0** strategic plan (this) — approve the revised architecture-driven scope + metrics + kill-criteria.
- **G1** model/architecture — concrete designs: base-predicate set; the fuzzy-logic concept-node
  layer; the DREAM loop (candidate generation, the leverage/redundancy criterion, per-night keep-k);
  the DECIDE search over abstractions; matched baselines; whether SLA (Tom's Newton-Raphson update) is
  a G1 variable or a later ablation (recommend later — one novelty at a time).
- **G2** dataset — Lichess games → Stockfish labels; sampling to avoid trivial/opening-book positions;
  eval-range balance; game-disjoint splits.
- **G3** development — plain baselines first; then the wake/dream abstraction-discovery loop; then the
  decide-phase search. Milestone-gated, Tom-reviewed.
- **G4** initial testing — the four metric batteries above; the per-night learning curves; the
  discovered-abstraction inspection.
- **G5** results + refine-loop — richer combinators, SLA arm, self-play Elo, deeper abstraction levels;
  or write up.

## Effort / risk
Small-to-moderate; oracle removes data risk. The novel build is the dream loop (candidate gen + leverage
scoring + prune) and the abstract decide-search — both have prior-art machinery (wake-sleep abstraction
learning; learned-model + search) to borrow from. Main risk = scope creep into engine-building; the
deliverable is an ARCHITECTURE TEST, not a champion. Me: architecture + leverage criterion + verdict;
sonnet agents: data pipeline, baselines, the wake/dream + search harness (≤4, -responsibly-primed).

## Portfolio role
Chess is the cheapest, cleanest test of Tom's Learn+Think architecture. If the wake/dream discovery and
abstract planning show leverage here, every FLENN app (speech, defense) inherits a validated engine —
and we'll have tested the RIGHT claim (discovered abstractions), not a strawman about hand-wiring.