plr-thread-coloring

# PLR Thread Coloring

> *The first color IS the thread. One-hot → trit → behavior.*

## Core Thesis

Thread identifiers (T-xxxxxxxx) are **seeds**. The first color derived from the seed IS the thread's identity. PLR transformations navigate the color space while preserving common tones (2/3 components stable).

```
Thread ID → Hash → Seed → SplitMix64 → First Color → Identity
                              ↓
                    PLR Transitions → Color Path → Behavior Trace
                              ↓
                    One-Hot Reduction → GF(3) → Efficient Index
```

## One-Hot Keyspace Reduction

### Problem: Exponential Keyspace

```
Thread ID space: 2^128 (UUID)
One-hot encoding: 128 bits
Behavior space: Intractable
```

### Solution: Reduce to GF(3) Trits

```
One-hot(128 bits) → Hash(64 bits) → SplitMix64 → Hue(360°) → Trit(-1,0,+1)

Keyspace: 3 states per trit
3 PLR ops × 3 trits = 9 behavior classes
Sufficient for:
  - User illusion (perceived control)
  - Behavior indexing (O(1) lookup)
  - Action field growth (bounded expansion)
```

## PLR → Trit Mapping

| PLR Op | Color Δ | Trit | Behavior |
|--------|---------|------|----------|
| **P** (Parallel) | Hue ±15° | 0 | ERGODIC: local exploration |
| **L** (Leading) | L ±10 | -1 | MINUS: constraint/validation |
| **R** (Relative) | C ±20, H ±30° | +1 | PLUS: expansion/generation |

### GF(3) Conservation

Every PLR sequence of length 3 sums to 0 (mod 3):

```
P L R = 0 + (-1) + 1 = 0 ✓
R R R = 1 + 1 + 1 = 3 ≡ 0 ✓
L P R = -1 + 0 + 1 = 0 ✓
```

## Thread ID to First Color

```python
def thread_to_color(thread_id: str) -> dict:
    """Extract color from thread identifier."""
    uuid_part = thread_id.replace("T-", "").replace("-", "")
    seed = int(uuid_part[:16], 16)
    _, val = splitmix64(seed)
    
    L = 10.0 + 85.0 * ((val & 0xFFFF) / 65535.0)
    C = 100.0 * (((val >> 16) & 0xFFFF) / 65535.0)
    H = 360.0 * (((val >> 32) & 0xFFFF) / 65535.0)
    trit = hue_to_trit(H)
    
    return {"thread_id": thread_id, "seed": seed, 
            "L": L, "C": C, "H": H, "trit": trit}
```

## PLR Operations

```julia
# P: Parallel - minimal change (hue rotation)
P(color; direction=1) = (L=color.L, C=color.C, 
                         H=mod(color.H + 15*direction, 360), trit=0)

# L: Leading-tone - lightness change
L(color; direction=1) = (L=clamp(color.L + 10*direction, 1, 99), 
                         C=color.C, H=color.H, trit=-1)

# R: Relative - largest shift (chroma + hue)
R(color; direction=1) = (L=color.L, 
                         C=clamp(color.C + 20*direction, 0, 150), 
                         H=mod(color.H + 30*direction, 360), trit=1)
```

## 9-Class Behavior System

```
┌─────────┬────────────┬────────────┬────────────┐
│         │ MINUS (-1) │ ERGODIC (0)│ PLUS (+1)  │
├─────────┼────────────┼────────────┼────────────┤
│ P (0)   │ P-MINUS    │ P-ERGODIC  │ P-PLUS     │
│         │ validate   │ explore    │ expand     │
├─────────┼────────────┼────────────┼────────────┤
│ L (-1)  │ L-MINUS    │ L-ERGODIC  │ L-PLUS     │
│         │ contract   │ darken     │ brighten   │
├─────────┼────────────┼────────────┼────────────┤
│ R (+1)  │ R-MINUS    │ R-ERGODIC  │ R-PLUS     │
│         │ simplify   │ modulate   │ elaborate  │
└─────────┴────────────┴────────────┴────────────┘
```

## Efficiency Gain

```
One-hot: 2^128 possible states
GF(3):   3 possible states

Reduction: 128 bits → 1.58 bits (log₂(3))
Speedup:  O(2^128) → O(1) behavior lookup
```

## Perception/Action Field Growth

The perception/action field grows through PLR navigation:

```
Capacity(t) = Capacity(0) × (1 + α × PLR_diversity(t))

Where:
  - PLR_diversity = entropy of PLR sequence distribution
  - α = learning rate (typically 0.01-0.1)
```

## User Illusion

The user perceives rich control over a 128-bit thread space while the system operates on a 9-class behavior index. This compression preserves the "feeling" of agency while enabling tractable computation.

## Full Sexp Representation

```lisp
(plr-thread-coloring
  :seed 1069
  :thread-to-color
  (lambda (thread-id)
    (let* ((seed (thread->seed thread-id))
           ((L C H) (seed->lch seed)))
      `(:L ,L :C ,C :H ,H :trit ,(hue->trit H))))
  
  :plr-ops
  ((P . (lambda (c d) `(:L ,(@ c :L) :C ,(@ c :C) :H ,(mod (+ (@ c :H) (* 15 d)) 360))))
   (L . (lambda (c d) `(:L ,(clamp (+ (@ c :L) (* 10 d)) 1 99) :C ,(@ c :C) :H ,(@ c :H))))
   (R . (lambda (c d) `(:L ,(@ c :L) :C ,(clamp (+ (@ c :C) (* 20 d)) 0 150) 
                         :H ,(mod (+ (@ c :H) (* 30 d)) 360)))))
  
  :one-hot->gf3
  (lambda (one-hot-vec) (hue->trit (seed->hue (one-hot->seed one-hot-vec)))))
```

## Implementations

See [detailed implementations](references/IMPLEMENTATIONS.md) for:
- Python with full PLR operations
- Julia module
- DuckDB behavior index schema
- Field capacity growth algorithms

---

**Skill Name**: plr-thread-coloring  
**Type**: Thread Identity + Behavior Indexing  
**Trit**: 0 (ERGODIC - coordination between perception and action)  
**Seed**: 1069 (zubuyul)  
**Reduction**: 128-bit → 1.58-bit (one-hot → GF(3))  
**Behavior Classes**: 9 (3 PLR × 3 trits)  
**Field Growth**: Capacity × (1 + α × diversity)

> *The user illusion is sufficient when the keyspace fits in working memory.*