Update mixer.c with actual ternary weight decoding from model

mixer.c

@@ -142,6 +142,39 @@ static int parse_header(system_t *s, const char *path) {
     return 0;
 }
 
+/* Decode packed ternary weight to oscillator lens (omega) — matches phoenix_brain.c */
+static void decode_ternary_to_lens(const uint8_t *packed, int col, int stride, float *omega) {
+    memset(omega, 0, N_OSC * sizeof(float));
+    const uint8_t *w = packed + (size_t)col * stride;
+    for (int i = 0; i < N_OSC; i++) {
+        int byte_idx = i / 4;
+        int bit_idx = (i % 4) * 2;
+        if (byte_idx >= stride) break;
+        int val = (w[byte_idx] >> bit_idx) & 0x03;
+        if (val == 0)      omega[i] = -0.5f;   /* counter-rotating */
+        else if (val == 2)  omega[i] =  0.5f;   /* co-rotating */
+        /* val=1 or val=3 → 0.0 (zero weight, drops out) */
+    }
+}
+
+/* Get weight bytes for layer l, column c — matches phoenix_brain.c layout */
+static const uint8_t *get_layer_weights(system_t *s, int layer, int col) {
+    /* Packed ternaries: 2 bits per weight, 4 per byte */
+    /* stride = ceil(D / 4) bytes per column */
+    size_t qw = (s->D * s->q_dim + 3) / 4;
+    size_t kw = (s->D * s->kv_dim + 3) / 4;
+    size_t ow = (s->q_dim * s->D + 3) / 4;
+    size_t gw = (s->D * s->FFN + 3) / 4;
+    size_t uw = (s->D * s->FFN + 3) / 4;
+    size_t layer_bytes = (qw + 2*kw + ow + gw + uw) * 3;
+
+    /* Weights start at offset 36 (32-byte header + 4-byte n_layers) */
+    char *base = s->mmap_base + 36;
+    /* Q weights: layer_bytes * layer, offset = col * (D/4) */
+    size_t col_stride = (s->D + 3) / 4;  /* bytes per column */
+    return (const uint8_t *)(base + (size_t)layer * layer_bytes + (size_t)col * col_stride);
+}
+
 static float *get_embedding(system_t *s, int t) {
     size_t emb_size = (size_t)s->V * s->D * sizeof(float);
     char *emb_ptr = s->mmap_base + s->file_size - emb_size;
@@ -159,14 +192,47 @@ static float *get_lm_head_row(system_t *s, int d) {
     return (float *)(s->mmap_base + lm_offset + (size_t)d * s->V);
 }
 
-static void init_ring(ring_t *r, int tok) {
+/* Initialize a ring from model weights at a given layer (matches phoenix_brain.c
+ * traveling wave activation: theta[i] = 2*pi*i/N + x[i]*pi/4,
+ * omega decoded from ternary weights, lens = gradient-weighted profile) */
+static void init_ring_from_model(system_t *s, ring_t *r, int tok, int layer) {
     r->tok = tok;
     r->energy = 1.0f;
     r->coherence = 1.0f;
+    /* Traveling wave activation */
     for (int i = 0; i < N_OSC; i++) {
         r->theta[i] = (2.0f * (float)M_PI * i / N_OSC) + ((float)tok * (float)M_PI / 4.0f);
-        r->omega[i] = 1.0f + (float)(i - N_OSC/2) * 0.01f;
-        r->lens[i] = 1.0f;
+    }
+    /* Decode ternary weights from model into omega (lens profile) */
+    int col = layer % (s->D / N_OSC);  /* which weight column for this layer */
+    size_t col_stride = (s->D + 3) / 4;
+    const uint8_t *wp = get_layer_weights(s, layer, 0);
+    decode_ternary_to_lens(wp, col, (int)col_stride, r->lens);
+    /* Copy lens to omega (same frequency encoding as phoenix) */
+    for (int i = 0; i < N_OSC; i++) {
+        r->omega[i] = r->lens[i];
+    }
+}
+
+static void init_ring(ring_t *r, int tok, int use_model) {
+    r->tok = tok;
+    r->energy = 1.0f;
+    r->coherence = 1.0f;
+    /* Traveling wave activation: theta[i] = 2*pi*i/N + x[i]*pi/4 */
+    for (int i = 0; i < N_OSC; i++) {
+        r->theta[i] = (2.0f * (float)M_PI * i / N_OSC) + ((float)tok * (float)M_PI / 4.0f);
+    }
+    if (use_model) {
+        /* Use lens profile from model weights */
+        for (int i = 0; i < N_OSC; i++) {
+            r->omega[i] = r->lens[i];
+        }
+    } else {
+        /* Placeholder for test mode */
+        for (int i = 0; i < N_OSC; i++) {
+            r->omega[i] = 1.0f + (float)(i - N_OSC/2) * 0.01f;
+            r->lens[i] = 1.0f;
+        }
     }
 }
 
@@ -284,11 +350,12 @@ int main(int argc, char **argv) {
         int nt = sizeof(tokens)/sizeof(tokens[0]);
         for (int i = 0; i < s.n_rings; i++) {
             int tok = tokens[i % nt] + (i * 17) % 1000;
-            init_ring(&s.rings[i], tok);
+            init_ring(&s.rings[i], tok, 0);
         }
     } else {
+        /* Model mode: decode ternary weights from model for each ring */
         for (int i = 0; i < s.n_rings; i++) {
-            init_ring(&s.rings[i], i * (s.V / s.n_rings));
+            init_ring_from_model(&s, &s.rings[i], i * (s.V / s.n_rings), i);
         }
     }