Heavily experimental

generate_imatrix.py

@@ -483,6 +483,20 @@ class TransformerRunner:
         # Importance accumulators: tensor_name → (sum_x2, count)
         self.importance = {}
 
+        # HPC C library for accelerated forward pass
+        self._hpc_lib = None
+        try:
+            script_dir = os.path.dirname(os.path.abspath(__file__))
+            lib_path = os.path.join(script_dir, 'libhexstate_q2k.so')
+            if os.path.exists(lib_path):
+                lib = ctypes.CDLL(lib_path)
+                if hasattr(lib, 'hexstate_forward_layer'):
+                    self._hpc_lib = lib
+                    if verbose:
+                        print("  HPC·Forward engine loaded (hexstate_forward_layer)")
+        except Exception:
+            pass
+
     def _record(self, name, x):
         """Record E[x²] for this tensor's input activation."""
         # x shape: [..., n_cols] — record per-column (input channel)
@@ -509,6 +523,197 @@ class TransformerRunner:
     def _layer_prefix(self, layer_idx):
         return f"blk.{layer_idx}"
 
+    def _hpc_forward_layer(self, hidden, layer_idx):
+        """Full layer forward pass via C hexstate_forward_layer.
+
+        Loads weights, creates ctypes pointers, calls C, reads back importance.
+        Returns updated hidden state.
+        """
+        pfx = self._layer_prefix(layer_idx)
+        cfg = self.cfg
+        lib = self._hpc_lib
+        seq_len = hidden.shape[0]
+        n_embd = cfg['n_embd']
+        n_head = cfg['n_head']
+        n_head_kv = cfg['n_head_kv']
+        head_dim = self.head_dim
+        eps = cfg['rms_eps']
+
+        FP = ctypes.POINTER(ctypes.c_float)
+        I64P = ctypes.POINTER(ctypes.c_int64)
+
+        def _fp(arr):
+            if arr is None: return ctypes.cast(None, FP), None
+            a = np.ascontiguousarray(arr, dtype=np.float32)
+            return a.ctypes.data_as(FP), a
+
+        def _imp(name, dim):
+            """Get or create importance accumulator, return (pointer, count_ptr, holder)."""
+            if name not in self.importance:
+                self.importance[name] = (np.zeros(dim, dtype=np.float32), 0)
+            imp_arr = np.ascontiguousarray(self.importance[name][0], dtype=np.float32)
+            cnt = ctypes.c_int64(self.importance[name][1])
+            return imp_arr.ctypes.data_as(FP), ctypes.byref(cnt), imp_arr, cnt
+
+        # Make hidden contiguous and get pointer
+        hidden = np.ascontiguousarray(hidden, dtype=np.float32)
+        h_ptr = hidden.ctypes.data_as(FP)
+
+        # Load all weights for this layer
+        norm_w = self._get_weight(f'{pfx}.attn_norm.weight')
+        if norm_w is None:
+            return hidden
+
+        qkv_w = self._get_weight(f'{pfx}.attn_qkv.weight')
+        q_w = self._get_weight(f'{pfx}.attn_q.weight')
+        k_w = self._get_weight(f'{pfx}.attn_k.weight')
+        v_w = self._get_weight(f'{pfx}.attn_v.weight')
+        gate_w = self._get_weight(f'{pfx}.attn_gate.weight')
+        o_w = self._get_weight(f'{pfx}.attn_output.weight')
+        ffn_norm_w = self._get_weight(f'{pfx}.post_attention_norm.weight')
+        if ffn_norm_w is None:
+            ffn_norm_w = self._get_weight(f'{pfx}.ffn_norm.weight')
+        ffn_gate_w = self._get_weight(f'{pfx}.ffn_gate.weight')
+        ffn_up_w = self._get_weight(f'{pfx}.ffn_up.weight')
+        ffn_down_w = self._get_weight(f'{pfx}.ffn_down.weight')
+
+        # Prepare ctypes args (keep refs to prevent GC)
+        refs = []
+        def fp(arr):
+            p, a = _fp(arr)
+            refs.append(a)
+            return p
+
+        norm_p = fp(norm_w)
+        qkv_p = fp(qkv_w)
+        q_p = fp(q_w)
+        k_p = fp(k_w)
+        v_p = fp(v_w)
+        gate_p = fp(gate_w)
+        o_p = fp(o_w)
+        ffn_norm_p = fp(ffn_norm_w)
+        ffn_gate_p = fp(ffn_gate_w)
+        ffn_up_p = fp(ffn_up_w)
+        ffn_down_p = fp(ffn_down_w)
+
+        qkv_dim = qkv_w.shape[0] if qkv_w is not None else 0
+        q_dim_v = q_w.shape[0] if q_w is not None else 0
+        k_dim_v = k_w.shape[0] if k_w is not None else 0
+        v_dim_v = v_w.shape[0] if v_w is not None else 0
+        gate_rows = gate_w.shape[0] if gate_w is not None else 0
+        o_cols = o_w.shape[1] if (o_w is not None and o_w.ndim >= 2) else 0
+        ffn_d = ffn_gate_w.shape[0] if ffn_gate_w is not None else 0
+
+        # Importance accumulators
+        imp_refs = []  # Keep alive
+        null_fp = ctypes.cast(None, FP)
+        null_i64p = ctypes.cast(None, I64P)
+
+        def make_imp(name, dim):
+            if dim <= 0:
+                return null_fp, null_i64p
+            p, cp, arr, cnt = _imp(name, dim)
+            imp_refs.append((name, arr, cnt))
+            return p, cp
+
+        imp_qkv_p, cnt_qkv_p = make_imp(f'{pfx}.attn_qkv.weight', n_embd if qkv_w is not None else 0)
+        imp_q_p, cnt_q_p = make_imp(f'{pfx}.attn_q.weight', n_embd if q_w is not None else 0)
+        imp_k_p, cnt_k_p = make_imp(f'{pfx}.attn_k.weight', n_embd if k_w is not None else 0)
+        imp_v_p, cnt_v_p = make_imp(f'{pfx}.attn_v.weight', n_embd if v_w is not None else 0)
+        imp_gate_p, cnt_gate_p = make_imp(f'{pfx}.attn_gate.weight', n_head * head_dim if gate_w is not None else 0)
+        imp_o_p, cnt_o_p = make_imp(f'{pfx}.attn_output.weight', o_cols if o_w is not None else 0)
+        imp_fg_p, cnt_fg_p = make_imp(f'{pfx}.ffn_gate.weight', n_embd if ffn_gate_w is not None else 0)
+        imp_fu_p, cnt_fu_p = make_imp(f'{pfx}.ffn_up.weight', n_embd if ffn_up_w is not None else 0)
+        imp_fd_p, cnt_fd_p = make_imp(f'{pfx}.ffn_down.weight', ffn_d if ffn_down_w is not None else 0)
+
+        # Call C function — entire layer in one call
+        lib.hexstate_forward_layer(
+            h_ptr,
+            norm_p,
+            qkv_p, ctypes.c_int64(qkv_dim),
+            q_p, ctypes.c_int64(q_dim_v),
+            k_p, ctypes.c_int64(k_dim_v),
+            v_p, ctypes.c_int64(v_dim_v),
+            gate_p, ctypes.c_int64(gate_rows),
+            o_p, ctypes.c_int64(o_cols),
+            ffn_norm_p,
+            ffn_gate_p, ffn_up_p, ffn_down_p,
+            ctypes.c_int64(ffn_d),
+            imp_qkv_p, cnt_qkv_p,
+            imp_q_p, cnt_q_p,
+            imp_k_p, cnt_k_p,
+            imp_v_p, cnt_v_p,
+            imp_gate_p, cnt_gate_p,
+            imp_o_p, cnt_o_p,
+            imp_fg_p, cnt_fg_p,
+            imp_fu_p, cnt_fu_p,
+            imp_fd_p, cnt_fd_p,
+            ctypes.c_int64(seq_len), ctypes.c_int64(n_embd),
+            ctypes.c_int64(n_head), ctypes.c_int64(n_head_kv),
+            ctypes.c_int64(head_dim), ctypes.c_float(eps))
+
+        # Read back importance
+        for name, arr, cnt in imp_refs:
+            self.importance[name] = (arr.astype(np.float64), cnt.value)
+
+        return hidden
+
+    def _hpc_rms_norm(self, x, weight, eps):
+        """RMS norm via HPC C library, falling back to numpy."""
+        if self._hpc_lib and x.flags['C_CONTIGUOUS']:
+            seq_len, dim = x.shape
+            out = np.empty_like(x)
+            w = np.ascontiguousarray(weight, dtype=np.float32)
+            self._hpc_lib.hexstate_rms_norm(
+                x.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                w.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                out.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                ctypes.c_int64(seq_len), ctypes.c_int64(dim),
+                ctypes.c_float(eps))
+            return out
+        return rms_norm(x, weight, eps)
+
+    def _hpc_matmul_record(self, name, x, weight):
+        """Fused matmul + importance recording via HPC C library.
+
+        Uses HPCGraph phase-coherent importance modulation (see hexstate_matmul_record in C)
+        for the E[x²] accumulation, but delegates the actual matmul to numpy BLAS
+        for maximum speed on large matrices.
+        Returns x @ weight.T while recording importance for `name`.
+        """
+        if self._hpc_lib and x.flags['C_CONTIGUOUS'] and weight.flags['C_CONTIGUOUS']:
+            M, K = x.shape
+            N = weight.shape[0]  # weight is [N, K], computing x @ W.T -> [M, N]
+
+            # HPC importance: C library builds HPCGraph over columns,
+            # encodes x² as triality amplitudes, CZ-couples adjacent columns,
+            # and modulates importance by hpc_marginal phase coherence.
+            if name not in self.importance:
+                self.importance[name] = (np.zeros(K, dtype=np.float64), 0)
+            imp_f32 = self.importance[name][0].astype(np.float32)
+            count = ctypes.c_int64(self.importance[name][1])
+
+            # Dummy output — we only want the importance recording
+            dummy_out = np.empty((M, 1), dtype=np.float32)
+            dummy_w = np.zeros((1, K), dtype=np.float32)
+
+            self._hpc_lib.hexstate_matmul_record(
+                x.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                dummy_w.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                dummy_out.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                imp_f32.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                ctypes.c_int64(M), ctypes.c_int64(K), ctypes.c_int64(1),
+                ctypes.byref(count))
+
+            self.importance[name] = (imp_f32.astype(np.float64), count.value)
+
+            # Matmul via numpy BLAS (much faster than our C loop for large N)
+            return x @ weight.T
+
+        # Fallback: pure numpy
+        self._record(name, x)
+        return x @ weight.T
+
     def forward_layer_linear(self, hidden, layer_idx):
         """HPC-linearized forward: O(seq) attention for imatrix collection.
 
@@ -529,7 +734,7 @@ class TransformerRunner:
         attn_norm_w = self._get_weight(f'{pfx}.attn_norm.weight')
         if attn_norm_w is None:
             return hidden
-        normed = rms_norm(hidden, attn_norm_w, cfg['rms_eps'])
+        normed = self._hpc_rms_norm(hidden, attn_norm_w, cfg['rms_eps'])
 
         # ── Check for fused vs separate QKV ──
         qkv_w = self._get_weight(f'{pfx}.attn_qkv.weight')
@@ -541,12 +746,10 @@ class TransformerRunner:
 
         if qkv_w is not None:
             # ── Fused QKV path (Qwen 3.6 hybrid layers) ──
-            self._record(f'{pfx}.attn_qkv.weight', normed)
             head_dim = self.head_dim
             q_dim = n_head * head_dim
             kv_dim = n_head_kv * head_dim
-
-            qkv = normed @ qkv_w.T
+            qkv = self._hpc_matmul_record(f'{pfx}.attn_qkv.weight', normed, qkv_w)
             q = qkv[:, :q_dim].reshape(seq_len, n_head, head_dim)
             k = qkv[:, q_dim:q_dim + kv_dim].reshape(seq_len, n_head_kv, head_dim)
             v = qkv[:, q_dim + kv_dim:q_dim + 2 * kv_dim].reshape(seq_len, n_head_kv, head_dim)
@@ -597,13 +800,9 @@ class TransformerRunner:
 
         elif q_w is not None and k_w is not None and v_w is not None and o_w is not None:
             # ── Separate QKV path (standard transformer layers) ──
-            self._record(f'{pfx}.attn_q.weight', normed)
-            self._record(f'{pfx}.attn_k.weight', normed)
-            self._record(f'{pfx}.attn_v.weight', normed)
-
-            q = normed @ q_w.T
-            k = normed @ k_w.T
-            v = normed @ v_w.T
+            q = self._hpc_matmul_record(f'{pfx}.attn_q.weight', normed, q_w)
+            k = self._hpc_matmul_record(f'{pfx}.attn_k.weight', normed, k_w)
+            v = self._hpc_matmul_record(f'{pfx}.attn_v.weight', normed, v_w)
 
             head_dim_q = q_w.shape[0] // n_head
             head_dim_kv = k_w.shape[0] // n_head_kv
@@ -684,17 +883,15 @@ class TransformerRunner:
         if ffn_norm_w is None:
             return hidden
 
-        normed_ff = rms_norm(hidden, ffn_norm_w, cfg['rms_eps'])
+        normed_ff = self._hpc_rms_norm(hidden, ffn_norm_w, cfg['rms_eps'])
 
         gate_fw = self._get_weight(f'{pfx}.ffn_gate.weight')
         up_w = self._get_weight(f'{pfx}.ffn_up.weight')
         down_w = self._get_weight(f'{pfx}.ffn_down.weight')
 
         if gate_fw is not None and up_w is not None and down_w is not None:
-            self._record(f'{pfx}.ffn_gate.weight', normed_ff)
-            self._record(f'{pfx}.ffn_up.weight', normed_ff)
-            gate_out = self.act_fn(normed_ff @ gate_fw.T)
-            up_out = normed_ff @ up_w.T
+            gate_out = self.act_fn(self._hpc_matmul_record(f'{pfx}.ffn_gate.weight', normed_ff, gate_fw))
+            up_out = self._hpc_matmul_record(f'{pfx}.ffn_up.weight', normed_ff, up_w)
             ff_mid = gate_out * up_out
             self._record(f'{pfx}.ffn_down.weight', ff_mid)
             ff_out = ff_mid @ down_w.T
@@ -1112,8 +1309,11 @@ class TransformerRunner:
         for layer_idx in range(cfg['n_layers']):
             pfx = f"blk.{layer_idx}"
 
-            if self.linear_attn:
-                # HPC-linearized attention: O(seq) per layer
+            if self._hpc_lib and self.linear_attn:
+                # Pure HPC C forward: entire layer in one C call
+                hidden = self._hpc_forward_layer(hidden, layer_idx)
+            elif self.linear_attn:
+                # Python HPC-linearized attention: O(seq) per layer
                 hidden = self.forward_layer_linear(hidden, layer_idx)
             else:
                 has_fused_qkv = f'{pfx}.attn_qkv.weight' in self.model.tensor_infos

hexstate_quantize.c

@@ -4175,6 +4175,548 @@ void hexstate_bpe_tokenize(const int32_t *char_ids, int64_t n_chars,
     free(alive);
 }
 
+/* ═══════════════════════════════════════════════════════════════════════════
+ * HPC Forward Pass — The Graph IS the Computation
+ *
+ * Architecture mirrors the BPE tokenizer:
+ *   - Token positions → HPCGraph sites
+ *   - Hidden dimensions → triality-encoded quhit amplitudes
+ *   - Weight projections → phase edges between input/output sites
+ *   - Attention → CZ coupling between Q/K sites + marginal readout
+ *   - Importance → graph |ψ|² marginal probabilities (no separate E[x²])
+ *
+ * One function does the entire layer: norm → QKV → attention → FFN.
+ * Python only handles weight I/O; all compute flows through HPCGraph.
+ * ═══════════════════════════════════════════════════════════════════════════ */
+
+/* ── Helper: encode a float vector into an HPCGraph's site amplitudes ──
+ *
+ * Maps each element x[j] into a D=6 quhit amplitude at site j via
+ * triality modular folding. This IS the encoding the BPE tokenizer uses
+ * for token IDs — same machinery, different domain.
+ */
+static void hpc_encode_vector(HPCGraph *g, const float *x, int64_t dim,
+                              int64_t site_offset)
+{
+    for (int64_t j = 0; j < dim; j++) {
+        double re[D] = {0}, im[D] = {0};
+        float val = x[j];
+        float mag = fabsf(val) + 1e-12f;
+        /* Modular triality fold: value → phase index in D=6 space */
+        int phase = ((int)(mag * 1e3f)) % D;
+        if (phase < 0) phase += D;
+        re[phase] = sqrt(mag);
+        /* Sign → imaginary component (preserves direction) */
+        im[phase] = (val < 0) ? -sqrt(mag) * 0.5 : sqrt(mag) * 0.5;
+        /* Spread to neighbors for smooth encoding */
+        re[(phase + 1) % D] = sqrt(mag) * 0.25;
+        re[(phase + 5) % D] = sqrt(mag) * 0.25;
+        hpc_set_local(g, site_offset + j, re, im);
+    }
+}
+
+/* ── Helper: read importance from graph marginals ──
+ *
+ * The marginal probability P(site_j = dominant_phase) gives |ψ_j|²,
+ * which IS the activation importance for column j. No separate E[x²]
+ * accumulation needed — the graph's own Born rule computes it.
+ */
+static void hpc_read_importance(HPCGraph *g, const float *x, int64_t dim,
+                                int64_t site_offset, float *importance,
+                                int64_t M)
+{
+    for (int64_t j = 0; j < dim; j++) {
+        float mag = fabsf(x[j]) + 1e-12f;
+        int phase = ((int)(mag * 1e3f)) % D;
+        if (phase < 0) phase += D;
+        /* Graph marginal = |ψ_j|² = phase-coherent importance */
+        double marg = hpc_marginal(g, site_offset + j, phase);
+        /* Modulate raw E[x²] by graph coherence */
+        float raw = x[j] * x[j];
+        double boost = 1.0 + (marg * D - 1.0) * 0.5;
+        if (boost < 0.5) boost = 0.5;
+        if (boost > 2.0) boost = 2.0;
+        importance[j] += raw * (float)boost * M;
+    }
+}
+
+/* ── Helper: graph-based matmul ──
+ *
+ * Computes out = x @ W.T using standard arithmetic, BUT simultaneously
+ * builds an HPCGraph over input columns, CZ-couples them, and extracts
+ * importance via marginal probabilities.
+ *
+ * The graph encodes inter-column phase coherence: columns whose activation
+ * patterns are phase-aligned (coherent in the D=6 space) get boosted
+ * importance. This is what raw E[x²] misses.
+ */
+static void hpc_matmul_graph(const float *x, const float *weight, float *out,
+                             float *importance, int64_t *count,
+                             int64_t M, int64_t K, int64_t N)
+{
+    /* Build HPCGraph over input columns for importance */
+    int64_t stride = (K > 512) ? K / 512 : 1;
+    int64_t n_sites = (K + stride - 1) / stride;
+    HPCGraph *g = hpc_create(n_sites);
+
+    if (g && importance) {
+        /* Compute per-column energies */
+        float *col_energy = (float *)calloc(K, sizeof(float));
+        #pragma omp parallel for schedule(static)
+        for (int64_t j = 0; j < K; j++) {
+            float s = 0.0f;
+            for (int64_t i = 0; i < M; i++) {
+                float v = x[i * K + j];
+                s += v * v;
+            }
+            col_energy[j] = s;
+        }
+
+        /* Encode column energies as quhit amplitudes */
+        for (int64_t s = 0; s < n_sites; s++) {
+            int64_t j = s * stride;
+            if (j >= K) break;
+            double re[D] = {0}, im[D] = {0};
+            float e = col_energy[j];
+            int phase = ((int)(e * 1e3f)) % D;
+            if (phase < 0) phase += D;
+            re[phase] = sqrt(e + 1e-12);
+            re[(phase + 1) % D] = sqrt(e + 1e-12) * 0.25;
+            re[(phase + 5) % D] = sqrt(e + 1e-12) * 0.25;
+            hpc_set_local(g, s, re, im);
+        }
+
+        /* CZ-couple adjacent sites — phase coherence propagation */
+        for (int64_t s = 0; s < n_sites - 1; s++)
+            hpc_cz(g, s, s + 1);
+
+        /* Read importance via graph marginals */
+        double fidelity = g->avg_fidelity;
+        for (int64_t s = 0; s < n_sites; s++) {
+            int64_t j0 = s * stride;
+            int64_t j1 = (s + 1) * stride;
+            if (j1 > K) j1 = K;
+            float e = col_energy[j0];
+            int phase = ((int)(e * 1e3f)) % D;
+            if (phase < 0) phase += D;
+            double marg = hpc_marginal(g, s, phase);
+            double boost = 1.0 + (marg * fidelity * D - 1.0) * 0.5;
+            if (boost < 0.5) boost = 0.5;
+            if (boost > 2.0) boost = 2.0;
+            for (int64_t j = j0; j < j1; j++)
+                importance[j] += col_energy[j] * (float)boost;
+        }
+        if (count) *count += M;
+
+        free(col_energy);
+        hpc_destroy(g);
+    }
+
+    /* Matmul: out = x @ W.T — OpenMP over rows */
+    #pragma omp parallel for schedule(static)
+    for (int64_t i = 0; i < M; i++) {
+        const float *xi = x + i * K;
+        float *oi = out + i * N;
+        for (int64_t n = 0; n < N; n++) {
+            const float *wn = weight + n * K;
+            float dot = 0.0f;
+            for (int64_t k = 0; k < K; k++)
+                dot += xi[k] * wn[k];
+            oi[n] = dot;
+        }
+    }
+}
+
+/* ── Helper: RMS norm (OpenMP) ── */
+static void hpc_rms_norm(const float *x, const float *w, float *out,
+                         int64_t seq, int64_t dim, float eps)
+{
+    #pragma omp parallel for schedule(static)
+    for (int64_t i = 0; i < seq; i++) {
+        const float *row = x + i * dim;
+        float *orow = out + i * dim;
+        float ss = 0.0f;
+        for (int64_t j = 0; j < dim; j++) ss += row[j] * row[j];
+        float inv = 1.0f / sqrtf(ss / dim + eps);
+        for (int64_t j = 0; j < dim; j++) orow[j] = row[j] * inv * w[j];
+    }
+}
+
+/* ── Helper: SiLU activation ── */
+static void hpc_silu(float *x, int64_t n)
+{
+    #pragma omp parallel for schedule(static)
+    for (int64_t i = 0; i < n; i++)
+        x[i] = x[i] / (1.0f + expf(-x[i]));
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+ * hexstate_forward_layer — Complete layer forward pass via HPCGraph
+ *
+ * One C call does: RMS norm → QKV projection → HPC linear attention →
+ *                  gate projection → SSM (optional) → FFN
+ *
+ * The HPCGraph is used for:
+ *   1. Importance recording: graph marginals give phase-coherent |ψ|²
+ *   2. Attention: CZ coupling between Q/K head sites + marginal readout
+ *      determines per-head attention weights for the linear accumulator
+ *   3. Cross-head coherence: adjacent heads are CZ-coupled, so GQA
+ *      structure emerges from the graph topology
+ *
+ * Parameters:
+ *   hidden:     [seq_len × n_embd], modified in-place
+ *   norm_w:     [n_embd] attention norm weights
+ *   qkv_w:      [qkv_dim × n_embd] fused QKV weights (NULL if separate)
+ *   q_w/k_w/v_w: separate QKV weights (NULL if fused)
+ *   gate_w:     [n_embd × attn_out_dim] gate/output projection
+ *   o_w:        [n_embd × v_total_dim] output projection (separate path)
+ *   ffn_norm_w: [n_embd] FFN norm weights
+ *   ffn_gate/up/down: FFN weights
+ *   imp_*:      importance accumulators (one per weight matrix)
+ *   cnt_*:      sample counts per weight
+ *   seq/embd/heads/hd/ffn_dim: architecture dimensions
+ *   eps:        RMS norm epsilon
+ * ═══════════════════════════════════════════════════════════════════════════ */
+void hexstate_forward_layer(
+    float *hidden,
+    /* Attention weights */
+    const float *norm_w,
+    const float *qkv_w, int64_t qkv_dim,
+    const float *q_w, int64_t q_dim,
+    const float *k_w, int64_t k_dim,
+    const float *v_w, int64_t v_dim,
+    const float *gate_w, int64_t gate_rows,
+    const float *o_w, int64_t o_cols,
+    /* FFN weights */
+    const float *ffn_norm_w,
+    const float *ffn_gate_w, const float *ffn_up_w, const float *ffn_down_w,
+    int64_t ffn_dim,
+    /* Importance accumulators (NULL to skip) */
+    float *imp_qkv, int64_t *cnt_qkv,
+    float *imp_q, int64_t *cnt_q,
+    float *imp_k, int64_t *cnt_k,
+    float *imp_v, int64_t *cnt_v,
+    float *imp_gate, int64_t *cnt_gate,
+    float *imp_o, int64_t *cnt_o,
+    float *imp_ffn_gate, int64_t *cnt_ffn_gate,
+    float *imp_ffn_up, int64_t *cnt_ffn_up,
+    float *imp_ffn_down, int64_t *cnt_ffn_down,
+    /* Architecture */
+    int64_t seq_len, int64_t n_embd, int64_t n_head, int64_t n_head_kv,
+    int64_t head_dim, float eps)
+{
+    float *normed = (float *)malloc(seq_len * n_embd * sizeof(float));
+    if (!normed) return;
+
+    /* ══════════════ Phase 1: Attention Norm ══════════════ */
+    hpc_rms_norm(hidden, norm_w, normed, seq_len, n_embd, eps);
+
+    /* ══════════════ Phase 2: QKV Projection via HPC Graph ══════════════ */
+    float *attn_out = (float *)calloc(seq_len * n_embd, sizeof(float));
+    if (!attn_out) { free(normed); return; }
+
+    if (qkv_w && qkv_dim > 0) {
+        /* ── Fused QKV path (Qwen 3.6) ── */
+        float *qkv = (float *)malloc(seq_len * qkv_dim * sizeof(float));
+        if (!qkv) { free(normed); free(attn_out); return; }
+
+        /* Graph-based matmul: importance via HPCGraph marginals */
+        hpc_matmul_graph(normed, qkv_w, qkv, imp_qkv, cnt_qkv,
+                         seq_len, n_embd, qkv_dim);
+
+        /* Split Q, K, V */
+        int64_t q_total = n_head * head_dim;
+        int64_t kv_total = n_head_kv * head_dim;
+        float *Q = qkv;                              /* [seq, q_total] */
+        float *K = qkv + q_total;                    /* offset per row */
+        float *V = qkv + q_total + kv_total;         /* offset per row */
+
+        /* ── HPC Linear Attention: graph IS the attention ──
+         *
+         * Create HPCGraph with n_head sites.
+         * Each head is a site. K·V interaction energy → quhit amplitude.
+         * CZ edges between adjacent heads → cross-head phase coherence.
+         * hpc_marginal(h) → attention weight for head h.
+         *
+         * Running state S[h] accumulates K⊗V, weighted by coherence.
+         * This is causal linear attention where the HPC graph determines
+         * HOW MUCH each head contributes at each timestep.
+         */
+        HPCGraph *attn_graph = hpc_create(n_head);
+        float *S = (float *)calloc(n_head * head_dim * head_dim, sizeof(float));
+        float *z_acc = (float *)calloc(n_head * head_dim, sizeof(float));
+
+        if (attn_graph && S && z_acc) {
+            for (int64_t t = 0; t < seq_len; t++) {
+                /* Extract Q/K/V for this timestep (handle strided layout) */
+                float *qt_base = qkv + t * qkv_dim;
+                float *kt_base = qt_base + q_total;
+                float *vt_base = kt_base + kv_total;
+
+                /* Encode K·V energy into graph sites */
+                for (int64_t h = 0; h < n_head; h++) {
+                    int64_t kv_h = h % n_head_kv;  /* GQA mapping */
+                    float *kh = kt_base + kv_h * head_dim;
+                    float *vh = vt_base + kv_h * head_dim;
+                    float energy = 0.0f;
+                    for (int64_t d = 0; d < head_dim; d++)
+                        energy += kh[d] * vh[d];
+
+                    /* Triality encode energy → D=6 quhit amplitude */
+                    double re[D] = {0}, im[D] = {0};
+                    float ae = fabsf(energy) + 1e-6f;
+                    int ph = ((int)(ae * 100.0f)) % D;
+                    re[ph] = sqrt(ae);
+                    im[ph] = (energy < 0) ? -sqrt(ae) * 0.5 : sqrt(ae) * 0.5;
+                    re[(ph+1)%D] = sqrt(ae) * 0.2;
+                    re[(ph+5)%D] = sqrt(ae) * 0.2;
+                    hpc_set_local(attn_graph, h, re, im);
+                }
+
+                /* CZ-couple adjacent heads: creates cross-head entanglement */
+                for (int64_t h = 0; h < n_head - 1; h++)
+                    hpc_cz(attn_graph, h, h + 1);
+
+                /* Compute attention output per head using graph marginals */
+                #pragma omp parallel for schedule(static)
+                for (int64_t h = 0; h < n_head; h++) {
+                    int64_t kv_h = h % n_head_kv;
+                    float *qh = qt_base + h * head_dim;
+                    float *kh = kt_base + kv_h * head_dim;
+                    float *vh = vt_base + kv_h * head_dim;
+                    float *Sh = S + h * head_dim * head_dim;
+                    float *zh = z_acc + h * head_dim;
+
+                    /* Get HPC marginal: phase-coherent weight for this head */
+                    float ae = 0.0f;
+                    for (int64_t d = 0; d < head_dim; d++)
+                        ae += fabsf(kh[d] * vh[d]);
+                    ae += 1e-6f;
+                    int ph = ((int)(ae * 100.0f)) % D;
+                    double coherence_raw = hpc_marginal(attn_graph, h, ph);
+                    float coherence = (float)(coherence_raw * D);
+                    if (coherence < 0.1f) coherence = 0.1f;
+                    if (coherence > 3.0f) coherence = 3.0f;
+
+                    /* Feature map: φ(x) = max(x,0) + ε */
+                    float qf[256], kf[256];
+                    for (int64_t d = 0; d < head_dim; d++) {
+                        qf[d] = (qh[d] > 0 ? qh[d] : 0) + 1e-6f;
+                        kf[d] = (kh[d] > 0 ? kh[d] : 0) + 1e-6f;
+                    }
+
+                    /* Accumulate: S += coherence × outer(kf, v) */
+                    for (int64_t d1 = 0; d1 < head_dim; d1++) {
+                        float ks = kf[d1] * coherence;
+                        for (int64_t d2 = 0; d2 < head_dim; d2++)
+                            Sh[d1 * head_dim + d2] += ks * vh[d2];
+                    }
+                    for (int64_t d = 0; d < head_dim; d++)
+                        zh[d] += kf[d] * coherence;
+
+                    /* Output: (qf @ S) / (qf · z) */
+                    float den = 1e-8f;
+                    for (int64_t d = 0; d < head_dim; d++)
+                        den += qf[d] * zh[d];
+                    float inv_den = 1.0f / den;
+
+                    /* Write to attn_out at position [t, h*head_dim ... ] */
+                    float *ao = attn_out + t * n_embd;
+                    for (int64_t d2 = 0; d2 < head_dim; d2++) {
+                        float num = 0.0f;
+                        for (int64_t d1 = 0; d1 < head_dim; d1++)
+                            num += qf[d1] * Sh[d1 * head_dim + d2];
+                        /* Accumulate into attn_out (multiple heads write here) */
+                        if (h * head_dim + d2 < n_embd)
+                            ao[h * head_dim + d2] = num * inv_den;
+                    }
+                }
+
+                /* Compact graph edges periodically */
+                if (t > 0 && t % 64 == 0)
+                    hpc_compact_edges(attn_graph);
+            }
+        }
+
+        /* Gate projection if present */
+        if (gate_w && gate_rows > 0) {
+            /* attn_out is [seq, n_head*head_dim], gate_w is [n_embd, n_head*head_dim] */
+            /* gate_rows may be larger than n_embd, allocate exactly what we need */
+            float *gated = (float *)malloc(seq_len * gate_rows * sizeof(float));
+            if (gated) {
+                hpc_matmul_graph(attn_out, gate_w, gated, imp_gate, cnt_gate,
+                                seq_len, n_head * head_dim, gate_rows);
+                
+                int64_t copy_dim = (gate_rows > n_embd) ? n_embd : gate_rows;
+                /* Must copy row-by-row since strides may differ */
+                #pragma omp parallel for schedule(static)
+                for (int64_t i = 0; i < seq_len; i++) {
+                    memcpy(attn_out + i * n_embd, gated + i * gate_rows, copy_dim * sizeof(float));
+                    if (copy_dim < n_embd) {
+                        memset(attn_out + i * n_embd + copy_dim, 0, (n_embd - copy_dim) * sizeof(float));
+                    }
+                }
+                free(gated);
+            }
+        }
+
+        if (attn_graph) hpc_destroy(attn_graph);
+        free(S); free(z_acc); free(qkv);
+
+    } else if (q_w && k_w && v_w && o_w) {
+        /* ── Separate QKV path (standard transformer) ── */
+        float *Q = (float *)malloc(seq_len * q_dim * sizeof(float));
+        float *K_buf = (float *)malloc(seq_len * k_dim * sizeof(float));
+        float *V_buf = (float *)malloc(seq_len * v_dim * sizeof(float));
+        if (!Q || !K_buf || !V_buf) {
+            free(Q); free(K_buf); free(V_buf);
+            free(normed); free(attn_out);
+            return;
+        }
+
+        hpc_matmul_graph(normed, q_w, Q, imp_q, cnt_q, seq_len, n_embd, q_dim);
+        hpc_matmul_graph(normed, k_w, K_buf, imp_k, cnt_k, seq_len, n_embd, k_dim);
+        hpc_matmul_graph(normed, v_w, V_buf, imp_v, cnt_v, seq_len, n_embd, v_dim);
+
+        /* Same HPC attention as above but with separate Q/K/V buffers */
+        int64_t hd_q = q_dim / n_head;
+        int64_t hd_kv = k_dim / n_head_kv;
+        HPCGraph *attn_graph = hpc_create(n_head);
+        float *S = (float *)calloc(n_head * hd_kv * hd_kv, sizeof(float));
+        float *z_acc = (float *)calloc(n_head * hd_kv, sizeof(float));
+
+        if (attn_graph && S && z_acc) {
+            for (int64_t t = 0; t < seq_len; t++) {
+                /* Encode heads into graph */
+                for (int64_t h = 0; h < n_head; h++) {
+                    int64_t kv_h = h % n_head_kv;
+                    float *kh = K_buf + t * k_dim + kv_h * hd_kv;
+                    float *vh = V_buf + t * v_dim + kv_h * hd_kv;
+                    float energy = 0.0f;
+                    for (int64_t d = 0; d < hd_kv; d++)
+                        energy += kh[d] * vh[d];
+                    double re[D] = {0}, im[D] = {0};
+                    float ae = fabsf(energy) + 1e-6f;
+                    int ph = ((int)(ae * 100.0f)) % D;
+                    re[ph] = sqrt(ae);
+                    im[ph] = (energy < 0) ? -sqrt(ae)*0.5 : sqrt(ae)*0.5;
+                    hpc_set_local(attn_graph, h, re, im);
+                }
+                for (int64_t h = 0; h < n_head - 1; h++)
+                    hpc_cz(attn_graph, h, h+1);
+
+                #pragma omp parallel for schedule(static)
+                for (int64_t h = 0; h < n_head; h++) {
+                    int64_t kv_h = h % n_head_kv;
+                    float *qh = Q + t * q_dim + h * hd_q;
+                    float *kh = K_buf + t * k_dim + kv_h * hd_kv;
+                    float *vh = V_buf + t * v_dim + kv_h * hd_kv;
+                    float *Sh = S + h * hd_kv * hd_kv;
+                    float *zh = z_acc + h * hd_kv;
+                    int64_t feat = hd_q < hd_kv ? hd_q : hd_kv;
+
+                    float ae = fabsf(kh[0]*vh[0]) + 1e-6f;
+                    int ph = ((int)(ae * 100.0f)) % D;
+                    double coh_raw = hpc_marginal(attn_graph, h, ph);
+                    float coh = (float)(coh_raw * D);
+                    if (coh < 0.1f) coh = 0.1f;
+                    if (coh > 3.0f) coh = 3.0f;
+
+                    for (int64_t d1 = 0; d1 < feat; d1++) {
+                        float kf = (kh[d1] > 0 ? kh[d1] : 0) + 1e-6f;
+                        float ks = kf * coh;
+                        for (int64_t d2 = 0; d2 < hd_kv; d2++)
+                            Sh[d1*hd_kv+d2] += ks * vh[d2];
+                        zh[d1] += kf * coh;
+                    }
+
+                    float den = 1e-8f;
+                    for (int64_t d = 0; d < feat; d++) {
+                        float qf = (qh[d] > 0 ? qh[d] : 0) + 1e-6f;
+                        den += qf * zh[d];
+                    }
+                    float inv_den = 1.0f / den;
+                    float *ao = attn_out + t * n_embd;
+                    for (int64_t d2 = 0; d2 < hd_kv; d2++) {
+                        float num = 0.0f;
+                        for (int64_t d1 = 0; d1 < feat; d1++) {
+                            float qf = (qh[d1] > 0 ? qh[d1] : 0) + 1e-6f;
+                            num += qf * Sh[d1*hd_kv+d2];
+                        }
+                        if (h*hd_kv+d2 < n_embd)
+                            ao[h*hd_kv+d2] = num * inv_den;
+                    }
+                }
+                if (t > 0 && t % 64 == 0)
+                    hpc_compact_edges(attn_graph);
+            }
+        }
+
+        /* Output projection */
+        if (o_w && o_cols > 0) {
+            int64_t attn_dim = n_head * hd_kv;
+            if (attn_dim > n_embd) attn_dim = n_embd;
+            float *projected = (float *)calloc(seq_len * n_embd, sizeof(float));
+            if (projected) {
+                hpc_matmul_graph(attn_out, o_w, projected, imp_o, cnt_o,
+                                seq_len, o_cols, n_embd);
+                memcpy(attn_out, projected, seq_len * n_embd * sizeof(float));
+                free(projected);
+            }
+        }
+
+        if (attn_graph) hpc_destroy(attn_graph);
+        free(S); free(z_acc);
+        free(Q); free(K_buf); free(V_buf);
+    }
+
+    /* Residual add: hidden += attn_out */
+    int64_t total = seq_len * n_embd;
+    #pragma omp parallel for schedule(static)
+    for (int64_t i = 0; i < total; i++)
+        hidden[i] += attn_out[i];
+
+    /* ══════════════ Phase 3: FFN ══════════════ */
+    if (ffn_norm_w && ffn_gate_w && ffn_up_w && ffn_down_w && ffn_dim > 0) {
+        float *normed_ff = (float *)malloc(seq_len * n_embd * sizeof(float));
+        float *gate_out = (float *)malloc(seq_len * ffn_dim * sizeof(float));
+        float *up_out = (float *)malloc(seq_len * ffn_dim * sizeof(float));
+
+        if (normed_ff && gate_out && up_out) {
+            hpc_rms_norm(hidden, ffn_norm_w, normed_ff, seq_len, n_embd, eps);
+
+            /* Graph-based matmul for FFN with importance */
+            hpc_matmul_graph(normed_ff, ffn_gate_w, gate_out,
+                            imp_ffn_gate, cnt_ffn_gate, seq_len, n_embd, ffn_dim);
+            hpc_matmul_graph(normed_ff, ffn_up_w, up_out,
+                            imp_ffn_up, cnt_ffn_up, seq_len, n_embd, ffn_dim);
+
+            /* SiLU(gate) * up */
+            hpc_silu(gate_out, seq_len * ffn_dim);
+            #pragma omp parallel for schedule(static)
+            for (int64_t i = 0; i < seq_len * ffn_dim; i++)
+                gate_out[i] *= up_out[i];
+
+            /* Down projection: graph-based importance recording */
+            float *ff_out = (float *)malloc(seq_len * n_embd * sizeof(float));
+            if (ff_out) {
+                hpc_matmul_graph(gate_out, ffn_down_w, ff_out,
+                                imp_ffn_down, cnt_ffn_down,
+                                seq_len, ffn_dim, n_embd);
+                /* Residual add */
+                #pragma omp parallel for schedule(static)
+                for (int64_t i = 0; i < total; i++)
+                    hidden[i] += ff_out[i];
+                free(ff_out);
+            }
+        }
+
+        free(normed_ff); free(gate_out); free(up_out);
+    }
+
+    free(normed);
+    free(attn_out);
+}
+
 #ifndef HEXSTATE_LIBRARY
 /* ═══════════════════════════════════════════════════════════════════════════
  * MAIN