optimizations for normal llama

hexstate_quantize.c

@@ -1761,76 +1761,39 @@ static const int Q4_CAND_TO_QUHIT[Q4_N_CAND] = {
  *
  *   E(block) = Σᵢ wᵢeᵢ²
  *            + (HEX_DC_LAMBDA / n) · (Σᵢeᵢ)²
- *            + (HEX_VW_LAMBDA / n) · Σ_pairs (eᵢ + eⱼ)²,  j = i+n/2
+ *            + (HEX_VW_LAMBDA / n) · Σ_{i<n/2} (eᵢ+eⱼ)²,  j = i+n/2
  *
- * Vesica guiding: DC = Σ_pairs (eᵢ+eⱼ), so zeroing EACH pair vesica is
- * a strict DC floor ((Σ v_p)² ≤ n_pairs Σ v_p²). The older 4·eᵢeⱼ
- * (= vesica² − wave²) credited anti-phase amplitude and let vesicas
- * cancel across pairs — that raises |v_p| while looking like DC win.
- * Pair-joint code search (hex_vesica_guide_pairs) is the last move.
- *
- * applied CONSISTENTLY to: Q2_K/Q4_0 candidate scoring, the closed-form
- * (d, dmin) refit acceptance, the shaping accept guards, every polish
- * move, and the Phase-4.7 floor — so no stage optimises a different
- * objective than its acceptance test measures. The closed-form solvers
- * incorporate the DC term as a rank-1 augmented observation and act as
- * proposal generators; acceptance always uses the full extended E.
- * λ = 0 on both knobs reduces exactly to the pure weighted-SSE objective.
- * Positive-definiteness: the fold coupling adds ±2λ_vw/n off-diagonal —
- * negligible against any sane wᵢ, so E stays a valid quadratic objective.
- * NOTE: reported RMSE stays pure reconstruction RMSE; with λ > 0 a small
- * RMSE increase is the *intended* price for lower output error. Per-block
- * terms are a proxy for row-level structure (the API sees a flat stream);
- * the Phase-3.9 rolling-DC pass handles cross-block linkage. */
+ * Pair vesica v = eᵢ+eⱼ is the DC of that fold pair; block DC is Σ v.
+ * Penalising Σ v² (not v²−w²) lowers both |DC| and mean vesica. The old
+ * 4 eᵢeⱼ = v²−w² wave-credit paid for anti-phase amplitude and could
+ * raise vesica while looking like a win. λ = 0 on both knobs is pure SSE.
+ * NOTE: reported RMSE stays reconstruction RMSE.
+ */
 #ifndef HEX_DC_LAMBDA_DEFAULT
-#define HEX_DC_LAMBDA_DEFAULT 4.0f
+#define HEX_DC_LAMBDA_DEFAULT 1.0f
 #endif
 #ifndef HEX_VW_LAMBDA_DEFAULT
-#define HEX_VW_LAMBDA_DEFAULT 4.0f
+#define HEX_VW_LAMBDA_DEFAULT 1.0f
 #endif
 #ifndef HEX_DC_DECAY_DEFAULT
-#define HEX_DC_DECAY_DEFAULT 1.0f
+#define HEX_DC_DECAY_DEFAULT 0.85f
 #endif
-/* Smoke: vesica-guided pair snap (near nearest-int, live DC) plus
- * Σ(e_i+e_j)² in E.  λ=(4,4) decay=1 cuts |DC| ~4× and mean pair
- * vesica ~6% vs λ=0 at ~+1.5% RMSE.  Wave-credit (4 e_i e_j) is gone. */
-/* Runtime knobs (defaults = previous compile-time 1, 1, 0.85).  The
- * greedy shaper used to descend 4·Σ(e_i+e_j)² + DC², which is not the
- * extended objective below; it now descends the same E.  Sweep from
- * Python via hexstate_set_spectral_params.  λ = 0, 0 recovers pure
- * weighted SSE. */
-
-static float hex_dc_lambda = HEX_DC_LAMBDA_DEFAULT;
-static float hex_vw_lambda = HEX_VW_LAMBDA_DEFAULT;
-static float hex_dc_decay  = HEX_DC_DECAY_DEFAULT;
-
-#define HEX_DC_LAMBDA hex_dc_lambda
-#define HEX_VW_LAMBDA hex_vw_lambda
+
+static float g_hex_dc_lambda = HEX_DC_LAMBDA_DEFAULT;
+static float g_hex_vw_lambda = HEX_VW_LAMBDA_DEFAULT;
+static float g_hex_dc_decay  = HEX_DC_DECAY_DEFAULT;
+#define HEX_DC_LAMBDA (g_hex_dc_lambda)
+#define HEX_VW_LAMBDA (g_hex_vw_lambda)
 
 void hexstate_set_spectral_params(float dc_lambda, float vw_lambda, float dc_decay)
 {
-    hex_dc_lambda = dc_lambda;
-    hex_vw_lambda = vw_lambda;
+    g_hex_dc_lambda = dc_lambda;
+    g_hex_vw_lambda = vw_lambda;
     if (dc_decay >= 0.0f && dc_decay <= 1.0f)
-        hex_dc_decay = dc_decay;
-}
-
-void hexstate_get_spectral_params(float *dc_lambda, float *vw_lambda, float *dc_decay)
-{
-    if (dc_lambda) *dc_lambda = hex_dc_lambda;
-    if (vw_lambda) *vw_lambda = hex_vw_lambda;
-    if (dc_decay)  *dc_decay  = hex_dc_decay;
-}
-
-/* Spectral penalty of the extended objective for one block: residuals e[n],
- * fold at n/2. Negative values are possible (anti-phase credit) — the total
- * E remains positive-definite as argued above. */
-static inline float hex_spectral_from_moments(float dc, float vesica_ssq, int n)
-{
-    return (HEX_DC_LAMBDA / (float)n) * dc * dc
-         + (HEX_VW_LAMBDA / (float)n) * vesica_ssq;
+        g_hex_dc_decay = dc_decay;
 }
 
+/* Spectral penalty: DC² + Σ vesica². Always ≥ 0 (no wave credit). */
 static inline float hex_spectral_penalty(const float *e, int n)
 {
     if (HEX_DC_LAMBDA == 0.0f && HEX_VW_LAMBDA == 0.0f) return 0.0f;
@@ -1841,434 +1804,8 @@ static inline float hex_spectral_penalty(const float *e, int n)
         dc  += v;
         ves += v * v;
     }
-    return hex_spectral_from_moments(dc, ves, n);
-}
-
-#ifndef HEX_VESICA_SSE_EPS
-#define HEX_VESICA_SSE_EPS 1.0f
-#endif
-
-typedef struct { float v; int i; } hex_fold_kv;
-
-static int hex_fold_kv_cmp(const void *a, const void *b)
-{
-    const hex_fold_kv *pa = (const hex_fold_kv *)a;
-    const hex_fold_kv *pb = (const hex_fold_kv *)b;
-    if (pa->v < pb->v) return -1;
-    if (pa->v > pb->v) return 1;
-    return pa->i - pb->i;
-}
-
-/* Fold's layout, in-place: k-th smallest at k, k-th largest at k+128.
- * Pair-sum ≈ constant, 16-wide scale groups become homogeneous.
- * Stored order IS decode order — stock llama, no sidecar. */
-static void hex_fold_interleave_block(float *x, float *w_row)
-{
-    hex_fold_kv kv[QK_K];
-    float xt[QK_K], wt[QK_K];
-    memcpy(xt, x, sizeof(xt));
-    if (w_row) memcpy(wt, w_row, sizeof(wt));
-    for (int i = 0; i < QK_K; i++) {
-        kv[i].v = xt[i];
-        kv[i].i = i;
-    }
-    qsort(kv, (size_t)QK_K, sizeof(kv[0]), hex_fold_kv_cmp);
-    int half = QK_K / 2;
-    for (int k = 0; k < half; k++) {
-        int lo = kv[k].i;
-        int hi = kv[QK_K - 1 - k].i;
-        x[k] = xt[lo];
-        x[k + half] = xt[hi];
-        if (w_row) {
-            w_row[k] = wt[lo];
-            w_row[k + half] = wt[hi];
-        }
-    }
-}
-
-/* Vesica subcode: among L2-optimal 4x4 points (Edge), pick the one
- * on the best pair-sum lattice σ=deq_i+deq_j. Independent nearest-int
- * breaks those ties without looking at the partner, so the two
- * estimates of s disagree. Primary SSE, secondary v² — reversing this
- * was the 0.51 basin. */
-static void hex_vesica_subcode_q(float xi, float xj,
-                                 float di, float mi, float dj, float mj,
-                                 float wi, float wj,
-                                 int vertex_first,
-                                 int *qi_out, int *qj_out,
-                                 float *ei_out, float *ej_out)
-{
-    float best_sse = 1e30f, best_v = 1e30f;
-    int bqi = 0, bqj = 0;
-    float bei = 0.0f, bej = 0.0f;
-    for (int qi = 0; qi <= 3; qi++) {
-        float deqi = di * (float)qi - mi;
-        float ei = xi - deqi;
-        for (int qj = 0; qj <= 3; qj++) {
-            float deqj = dj * (float)qj - mj;
-            float ej = xj - deqj;
-            float sse = wi * ei * ei + wj * ej * ej;
-            float v2 = (ei + ej) * (ei + ej);
-            int better;
-            if (vertex_first)
-                better = (v2 < best_v - 1e-12f) ||
-                         (v2 <= best_v + 1e-12f && sse < best_sse);
-            else
-                better = (sse < best_sse - 1e-12f) ||
-                         (sse <= best_sse + 1e-12f && v2 < best_v);
-            if (better) {
-                best_sse = sse;
-                best_v = v2;
-                bqi = qi;
-                bqj = qj;
-                bei = ei;
-                bej = ej;
-            }
-        }
-    }
-    *qi_out = bqi;
-    *qj_out = bqj;
-    *ei_out = bei;
-    *ej_out = bej;
-}
-
-static void hex_vesica_bake_subcodes(const float *x, const float *w_row,
-                                     float dm, float mm,
-                                     const uint8_t *Ls, const uint8_t *Lm,
-                                     uint8_t *L, int vertex_first)
-{
-    for (int p = 0; p < QK_K / 2; p++) {
-        int i = p, j = p + QK_K / 2;
-        int si = i >> 4, sj = j >> 4;
-        float di = dm * (float)Ls[si], mi = mm * (float)Lm[si];
-        float dj = dm * (float)Ls[sj], mj = mm * (float)Lm[sj];
-        float wi = w_row ? w_row[i] : 1.0f;
-        float wj = w_row ? w_row[j] : 1.0f;
-        int qi, qj;
-        float ei, ej;
-        hex_vesica_subcode_q(x[i], x[j], di, mi, dj, mj, wi, wj, vertex_first,
-                             &qi, &qj, &ei, &ej);
-        L[i] = (uint8_t)qi;
-        L[j] = (uint8_t)qj;
-    }
-}
-
-static float hex_block_sse(const float *x, const float *w_row,
-                           float dm, float mm,
-                           const uint8_t *Ls, const uint8_t *Lm,
-                           const uint8_t *L)
-{
-    float sse = 0.0f;
-    for (int j = 0; j < QK_K / 16; j++) {
-        float d_sub = dm * (float)Ls[j];
-        float m_sub = mm * (float)Lm[j];
-        for (int k = 0; k < 16; k++) {
-            int idx = 16 * j + k;
-            float w = w_row ? w_row[idx] : 1.0f;
-            float e = x[idx] - (d_sub * (float)L[idx] - m_sub);
-            sse += w * e * e;
-        }
-    }
-    return sse;
-}
-
-static void hex_wls_d_dmin(const float *x, const float *w_row,
-                           const uint8_t *Ls, const uint8_t *Lm,
-                           const uint8_t *L, float *dm, float *mm)
-{
-    double Saa = 0, Sab = 0, Sbb = 0, Sxa = 0, Sxb = 0;
-    for (int j = 0; j < QK_K / 16; j++) {
-        float ls_f = (float)Ls[j];
-        float lm_f = (float)Lm[j];
-        for (int k = 0; k < 16; k++) {
-            int idx = 16 * j + k;
-            float xv = x[idx];
-            float w = w_row ? w_row[idx] : 1.0f;
-            float a = ls_f * (float)L[idx];
-            float b = lm_f;
-            Saa += w * a * a;
-            Sab += w * a * b;
-            Sbb += w * b * b;
-            Sxa += w * xv * a;
-            Sxb += w * xv * b;
-        }
-    }
-    double det = Saa * Sbb - Sab * Sab;
-    if (fabs(det) <= 1e-30)
-        return;
-    double d_new  = (Sbb * Sxa - Sab * Sxb) / det;
-    double m_new  = (Sab * Sxa - Saa * Sxb) / det;
-    if (d_new > 0.0 && d_new < 4.0 * ((double)*dm + 1e-10))
-        *dm = gguf_fp16_to_fp32(gguf_fp32_to_fp16((float)d_new));
-    if (m_new > 0.0 && m_new < 4.0 * ((double)*mm + 1e-10))
-        *mm = gguf_fp16_to_fp32(gguf_fp32_to_fp16((float)m_new));
-}
-
-/* Tie complementary (ls,lm) when it lowers 32-weight SSE (Fold's
- * homogeneous group as ordinary nibbles). σ-bake + WLS, never Edge
- * after WLS — that was the mismatched-scalar basin. Keep only if
- * block SSE drops. */
-static void hex_vesica_commit(const float *x, const float *w_row,
-                              float *dm, float *mm,
-                              uint8_t *Ls, uint8_t *Lm, uint8_t *L)
-{
-    uint8_t L0[QK_K], Ls0[16], Lm0[16];
-    memcpy(L0, L, QK_K);
-    memcpy(Ls0, Ls, 16);
-    memcpy(Lm0, Lm, 16);
-    float dm0 = *dm, mm0 = *mm;
-    float sse0 = hex_block_sse(x, w_row, dm0, mm0, Ls0, Lm0, L0);
-
-    for (int p = 0; p < 8; p++) {
-        int A = p, B = p + 8;
-        uint8_t tLs[16], tLm[16], tL[QK_K];
-        float best32 = 1e30f;
-        uint8_t bA_ls = Ls[A], bA_lm = Lm[A], bB_ls = Ls[B], bB_lm = Lm[B];
-        uint8_t cand_lsA[4] = { Ls[A], Ls[A], Ls[B], (uint8_t)((Ls[A] + Ls[B] + 1) / 2) };
-        uint8_t cand_lmA[4] = { Lm[A], Lm[A], Lm[B], (uint8_t)((Lm[A] + Lm[B] + 1) / 2) };
-        uint8_t cand_lsB[4] = { Ls[B], Ls[A], Ls[B], (uint8_t)((Ls[A] + Ls[B] + 1) / 2) };
-        uint8_t cand_lmB[4] = { Lm[B], Lm[A], Lm[B], (uint8_t)((Lm[A] + Lm[B] + 1) / 2) };
-        for (int t = 0; t < 4; t++) {
-            memcpy(tLs, Ls, 16);
-            memcpy(tLm, Lm, 16);
-            tLs[A] = cand_lsA[t]; tLm[A] = cand_lmA[t];
-            tLs[B] = cand_lsB[t]; tLm[B] = cand_lmB[t];
-            memcpy(tL, L, QK_K);
-            hex_vesica_bake_subcodes(x, w_row, *dm, *mm, tLs, tLm, tL, 0);
-            float s32 = 0.0f;
-            for (int k = 0; k < 16; k++) {
-                int i = 16 * A + k, j = 16 * B + k;
-                float di = *dm * (float)tLs[A], mi = *mm * (float)tLm[A];
-                float dj = *dm * (float)tLs[B], mj = *mm * (float)tLm[B];
-                float ei = x[i] - (di * (float)tL[i] - mi);
-                float ej = x[j] - (dj * (float)tL[j] - mj);
-                float wi = w_row ? w_row[i] : 1.0f;
-                float wj = w_row ? w_row[j] : 1.0f;
-                s32 += wi * ei * ei + wj * ej * ej;
-            }
-            if (s32 < best32) {
-                best32 = s32;
-                bA_ls = tLs[A]; bA_lm = tLm[A];
-                bB_ls = tLs[B]; bB_lm = tLm[B];
-            }
-        }
-        Ls[A] = bA_ls; Lm[A] = bA_lm;
-        Ls[B] = bB_ls; Lm[B] = bB_lm;
-    }
-
-    for (int it = 0; it < 3; it++) {
-        hex_vesica_bake_subcodes(x, w_row, *dm, *mm, Ls, Lm, L, 1);
-        hex_wls_d_dmin(x, w_row, Ls, Lm, L, dm, mm);
-    }
-    hex_vesica_bake_subcodes(x, w_row, *dm, *mm, Ls, Lm, L, 0);
-
-    float sse1 = hex_block_sse(x, w_row, *dm, *mm, Ls, Lm, L);
-    if (!(sse1 < sse0)) {
-        memcpy(L, L0, QK_K);
-        memcpy(Ls, Ls0, 16);
-        memcpy(Lm, Lm0, 16);
-        *dm = dm0;
-        *mm = mm0;
-    }
-}
-
-/* Vesica + triality. Cooley-Tukey DFT6 = 2 x 3: antipodal fold is
- * vesica/wave; the 3-cycle Edge/Vertex/Diagonal is triality_rotate.
- *   Vertex:   min v^2 + DC^2          (in-phase / DC floor)
- *   Diagonal: min w^2, keep v and DC  (anti-phase / leftover RMSE)
- *   Edge:     min SSE, keep v and DC  (computational RMSE)
- * RMSE^2 = (v^2 + w^2)/2 per pair, so Diagonal+Edge shrink RMSE
- * without giving back the Vertex cancellation. Two sweeps/view. */
-static void hex_vesica_guide_pairs(const float *x, const float *w_row,
-                                   float dm, float mm,
-                                   const uint8_t *Ls, const uint8_t *Lm,
-                                   uint8_t *L)
-{
-    float e[QK_K];
-    float dc = 0.0f;
-    for (int i = 0; i < QK_K; i++) {
-        int s = i >> 4;
-        float d_s = dm * (float)Ls[s];
-        float m_s = mm * (float)Lm[s];
-        e[i] = x[i] - (d_s * (float)L[i] - m_s);
-        dc += e[i];
-    }
-
-    /* Vertex (vesica+DC), then Edge (RMSE with vesica/DC held).
-     * Diagonal/wave is implied: RMSE^2 = (v^2+w^2)/2 at fixed v. */
-    for (int rot = 0; rot < 2; rot++) {
-        for (int sweep = 0; sweep < 2; sweep++) {
-            for (int p = 0; p < QK_K / 2; p++) {
-                int i = p, j = p + QK_K / 2;
-                int si = i >> 4, sj = j >> 4;
-                float di = dm * (float)Ls[si], mi = mm * (float)Lm[si];
-                float dj = dm * (float)Ls[sj], mj = mm * (float)Lm[sj];
-                float wi = w_row ? w_row[i] : 1.0f;
-                float wj = w_row ? w_row[j] : 1.0f;
-
-                int q0i = 0, q0j = 0;
-                if (di >= 1e-15f) {
-                    q0i = gguf_nearest_int((x[i] + mi) / di);
-                    if (q0i < 0) q0i = 0; if (q0i > 3) q0i = 3;
-                }
-                if (dj >= 1e-15f) {
-                    q0j = gguf_nearest_int((x[j] + mj) / dj);
-                    if (q0j < 0) q0j = 0; if (q0j > 3) q0j = 3;
-                }
-
-                float v_old = e[i] + e[j];
-                float dc_rest = dc - v_old;
-                float dc_abs0 = dc * dc;
-                float ves0 = v_old * v_old;
-                float cur_sse = wi * e[i] * e[i] + wj * e[j] * e[j];
-                float best = (rot == 0) ? 1e30f : cur_sse;
-                int bqi = (int)L[i], bqj = (int)L[j];
-                float bei = e[i], bej = e[j];
-
-                int qi0 = q0i - 1, qi1 = q0i + 1;
-                int qj0 = q0j - 1, qj1 = q0j + 1;
-                if (qi0 < 0) qi0 = 0; if (qi1 > 3) qi1 = 3;
-                if (qj0 < 0) qj0 = 0; if (qj1 > 3) qj1 = 3;
-
-                for (int qi = qi0; qi <= qi1; qi++) {
-                    float ei = x[i] - (di * (float)qi - mi);
-                    for (int qj = qj0; qj <= qj1; qj++) {
-                        float ej = x[j] - (dj * (float)qj - mj);
-                        float v  = ei + ej;
-                        float sse = wi * ei * ei + wj * ej * ej;
-                        float dc_n = dc_rest + v;
-                        float sc;
-                        if (rot == 0)
-                            sc = v * v + dc_n * dc_n
-                               + HEX_VESICA_SSE_EPS * sse;
-                        else {
-                            /* Edge: cut RMSE only if vesica and DC do not grow. */
-                            if (v * v > ves0 * 1.05f) continue;
-                            if (dc_n * dc_n > dc_abs0 * 1.05f) continue;
-                            sc = sse;
-                        }
-                        if (sc < best) {
-                            best = sc;
-                            bqi = qi; bqj = qj;
-                            bei = ei; bej = ej;
-                        }
-                    }
-                }
-                L[i] = (uint8_t)bqi;
-                L[j] = (uint8_t)bqj;
-                dc = dc_rest + bei + bej;
-                e[i] = bei;
-                e[j] = bej;
-            }
-        }
-    }
-}
-
-/* Joint HPC-graph decode of a vesica sub-block pair (A, A^8).
- * Edge 4x4 is L2-optimal codes for a fixed scale pair and is separable.
- * Vertex (Σv²) and DC² on the 32-weight group are not: they couple the
- * two HPC 6-states. Fold's RMSE win is that pair-sum; scoring
- *   Edge SSE + λ_vw Vertex + λ_dc DC²
- * picks complementary (ls,lm) so WLS (d, dmin) sees one s, not two.
- * Stock layout, no permutation. */
-static void hex_joint_fold_subpairs(const float *x, const float *w_row,
-                                    float dm, float mm,
-                                    uint8_t state_ls[][6], uint8_t state_lm[][6],
-                                    uint8_t *Ls, uint8_t *Lm, uint8_t *L)
-{
-    for (int p = 0; p < 8; p++) {
-        int A = p, B = p + 8;
-        float best = 1e30f;
-        int bva = 0, bvb = 0;
-        uint8_t bqA[16], bqB[16];
-
-        for (int va = 0; va < 6; va++) {
-            float dA = dm * (float)state_ls[A][va];
-            float mA = mm * (float)state_lm[A][va];
-            for (int vb = 0; vb < 6; vb++) {
-                float dB = dm * (float)state_ls[B][vb];
-                float mB = mm * (float)state_lm[B][vb];
-                float sse = 0.0f, ves = 0.0f, dcg = 0.0f;
-                uint8_t qA[16], qB[16];
-                for (int k = 0; k < 16; k++) {
-                    int i = 16 * A + k;
-                    int j = 16 * B + k;
-                    float wi = w_row ? w_row[i] : 1.0f;
-                    float wj = w_row ? w_row[j] : 1.0f;
-                    float bestp = 1e30f;
-                    int bqi = 0, bqj = 0;
-                    float bei = 0.0f, bej = 0.0f;
-                    for (int qi = 0; qi <= 3; qi++) {
-                        float ei = x[i] - (dA * (float)qi - mA);
-                        for (int qj = 0; qj <= 3; qj++) {
-                            float ej = x[j] - (dB * (float)qj - mB);
-                            float sc = wi * ei * ei + wj * ej * ej;
-                            if (sc < bestp) {
-                                bestp = sc;
-                                bqi = qi;
-                                bqj = qj;
-                                bei = ei;
-                                bej = ej;
-                            }
-                        }
-                    }
-                    qA[k] = (uint8_t)bqi;
-                    qB[k] = (uint8_t)bqj;
-                    sse += bestp;
-                    ves += (bei + bej) * (bei + bej);
-                    dcg += bei + bej;
-                }
-                float sc = HEX_VESICA_SSE_EPS * sse
-                         + HEX_VW_LAMBDA * ves
-                         + HEX_DC_LAMBDA * dcg * dcg;
-                if (sc < best) {
-                    best = sc;
-                    bva = va;
-                    bvb = vb;
-                    memcpy(bqA, qA, 16);
-                    memcpy(bqB, qB, 16);
-                }
-            }
-        }
-        Ls[A] = state_ls[A][bva];
-        Lm[A] = state_lm[A][bva];
-        Ls[B] = state_ls[B][bvb];
-        Lm[B] = state_lm[B][bvb];
-        memcpy(L + 16 * A, bqA, 16);
-        memcpy(L + 16 * B, bqB, 16);
-    }
-}
-
-/* Edge 4x4 on every fold pair for committed (d, dmin, Ls, Lm). */
-static void hex_pair_edge_codes(const float *x, const float *w_row,
-                                float dm, float mm,
-                                const uint8_t *Ls, const uint8_t *Lm,
-                                uint8_t *L)
-{
-    for (int p = 0; p < QK_K / 2; p++) {
-        int i = p, j = p + QK_K / 2;
-        int si = i >> 4, sj = j >> 4;
-        float di = dm * (float)Ls[si], mi = mm * (float)Lm[si];
-        float dj = dm * (float)Ls[sj], mj = mm * (float)Lm[sj];
-        float wi = w_row ? w_row[i] : 1.0f;
-        float wj = w_row ? w_row[j] : 1.0f;
-        float best = 1e30f;
-        int bqi = 0, bqj = 0;
-        for (int qi = 0; qi <= 3; qi++) {
-            float ei = x[i] - (di * (float)qi - mi);
-            for (int qj = 0; qj <= 3; qj++) {
-                float ej = x[j] - (dj * (float)qj - mj);
-                float sc = wi * ei * ei + wj * ej * ej;
-                if (sc < best) {
-                    best = sc;
-                    bqi = qi;
-                    bqj = qj;
-                }
-            }
-        }
-        L[i] = (uint8_t)bqi;
-        L[j] = (uint8_t)bqj;
-    }
+    return (HEX_DC_LAMBDA / (float)n) * dc * dc
+         + (HEX_VW_LAMBDA / (float)n) * ves;
 }
 
 /* Robust temperature estimator for the HExState measurement model.
@@ -2905,14 +2442,13 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
             }
 
             float v_live[QK4_0 / 2];
-            float vesica_cur = 0.0f, dc_cur = 0.0f, cross_cur = 0.0f;
+            float vesica_cur = 0.0f, dc_cur = 0.0f;
             for (int j = 0; j < QK4_0 / 2; j++) {
                 v_live[j] = e_live[j] + e_live[j + QK4_0 / 2];
                 vesica_cur += v_live[j] * v_live[j];
-                cross_cur  += e_live[j] * e_live[j + QK4_0 / 2];
             }
             for (int j = 0; j < QK4_0; j++) dc_cur += e_live[j];
-            float metric_cur = hex_spectral_from_moments(dc_cur, vesica_cur, QK4_0);
+            float metric_cur = 4.0f * vesica_cur + dc_cur * dc_cur;
 
             /* Deterministic greedy descent: only strict improvements.
              * The previous SA acceptance called rand() inside an OpenMP
@@ -2942,7 +2478,7 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
 
                     float vesica_alt = vesica_cur - v_old * v_old + v_new * v_new;
                     float dc_alt     = dc_cur     + de;
-                    float metric_alt = hex_spectral_from_moments(dc_alt, vesica_alt, QK4_0);
+                    float metric_alt = 4.0f * vesica_alt + dc_alt * dc_alt;
 
                     float delta = metric_cur - metric_alt;
                     if (delta > best_delta) {
@@ -2966,7 +2502,7 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
 
                     vesica_cur += v_new_commit * v_new_commit - v_old_commit * v_old_commit;
                     dc_cur     += de_commit;
-                    metric_cur  = hex_spectral_from_moments(dc_cur, vesica_cur, QK4_0);
+                    metric_cur  = 4.0f * vesica_cur + dc_cur * dc_cur;
 
                     v_live[pi_commit] = v_new_commit;
                     e_live[best_k]    = e_new_commit;
@@ -3277,16 +2813,15 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
             int8_t qs_shaped[QK8_0];
             memcpy(qs_shaped, qs, QK8_0);
             float e_live[QK8_0], v_live[QK8_0 / 2];
-            float vesica_cur = 0.0f, dc_cur = 0.0f, cross_cur = 0.0f;
+            float vesica_cur = 0.0f, dc_cur = 0.0f;
             for (int k = 0; k < QK8_0; k++)
                 e_live[k] = bw[k] - (float)qs_shaped[k] * d;
             for (int p = 0; p < QK8_0 / 2; p++) {
                 v_live[p] = e_live[p] + e_live[p + QK8_0 / 2];
                 vesica_cur += v_live[p] * v_live[p];
-                cross_cur  += e_live[p] * e_live[p + QK8_0 / 2];
                 dc_cur     += v_live[p];
             }
-            float metric_cur = hex_spectral_from_moments(dc_cur, vesica_cur, QK8_0);
+            float metric_cur = 4.0f * vesica_cur + dc_cur * dc_cur;
             for (int pass = 0; pass < QK8_0; pass++) {
                 int best_k = -1, best_q_alt = 0;
                 float best_delta = 0.0f;
@@ -3301,8 +2836,7 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
                     float ves_a = vesica_cur - v_live[pi] * v_live[pi]
                                              + v_new * v_new;
                     float dc_a  = dc_cur + de;
-                    float delta = metric_cur
-                        - hex_spectral_from_moments(dc_a, ves_a, QK8_0);
+                    float delta = metric_cur - (4.0f * ves_a + dc_a * dc_a);
                     if (delta > best_delta) {
                         best_delta = delta; best_k = k; best_q_alt = q_try;
                     }
@@ -3316,7 +2850,7 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
                     float v_new = v_live[pi] + de;
                     vesica_cur += v_new * v_new - v_live[pi] * v_live[pi];
                     dc_cur     += de;
-                    metric_cur  = hex_spectral_from_moments(dc_cur, vesica_cur, QK8_0);
+                    metric_cur  = 4.0f * vesica_cur + dc_cur * dc_cur;
                     v_live[pi]      = v_new;
                     e_live[best_k]  = e_new;
                     qs_shaped[best_k] = (int8_t)best_q_alt;
@@ -4101,6 +3635,8 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
      * this array (safe: written sequentially before the parallel loop).
      * ══════════════════════════════════════════════════════════════════ */
 
+    #define DC_DECAY (g_hex_dc_decay)
+
     float *block_dc_bias = (float *)calloc(n_blocks, sizeof(float));
 
     if (block_dc_bias) {
@@ -4129,7 +3665,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                                  dm0, mm0, dc_Ls, dc_Lm);
 
             /* Bias applied to THIS block's WLS targets */
-            float dc_bias       = (hex_dc_decay * rolling_dc) / (float)QK_K;
+            float dc_bias       = (DC_DECAY * rolling_dc) / (float)QK_K;
             block_dc_bias[blk]  = dc_bias;
 
             /* Quick round-nearest quant to estimate DC residual for NEXT block.
@@ -4201,7 +3737,6 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
         uint16_t prev_dm16 = 0, prev_mm16 = 0;
         for (int ls_iter = 0; ls_iter < 5; ls_iter++) {
 
-            uint8_t L[QK_K];
             uint8_t state_ls[N_SUB][6];
             uint8_t state_lm[N_SUB][6];
             float state_err[N_SUB][6];
@@ -4284,11 +3819,6 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
 
                 for (int j = 0; j < N_SUB - 1; j++)
                     hpc_cz(sg, j, j + 1);
-                /* Vesica partners (sub j <-> j^8) share fold pairs i <-> i+128.
-                 * Entangle them so sieve back-action diversifies complementary
-                 * bins (triality pair: each view of one is a role of the other). */
-                for (int j = 0; j < 8; j++)
-                    hpc_cz(sg, j, j + 8);
 
                 double sub_marg[N_SUB][6];
                 int sub_measured[N_SUB];
@@ -4297,11 +3827,33 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
 
                 sieve_measure_graph(sg, N_SUB, sub_marg, sub_measured, 1);
 
-                hex_joint_fold_subpairs(
-                    adj_block_x,
-                    imat_importance ? (imat_importance + blk * QK_K) : NULL,
-                    dm, mm, state_ls, state_lm,
-                    Ls_blk, Lm_blk, L);
+                for (int j = 0; j < N_SUB; j++) {
+                    double best_prob = -1.0;
+                    int best_v = 0;
+                    for (int v = 0; v < 6; v++) {
+                        if (sub_marg[j][v] > best_prob) {
+                            best_prob = sub_marg[j][v];
+                            best_v = v;
+                        }
+                    }
+                    Ls_blk[j] = state_ls[j][best_v];
+                    Lm_blk[j] = state_lm[j][best_v];
+                }
+            }
+
+            uint8_t L[QK_K];
+            for (int j = 0; j < N_SUB; j++) {
+                float d_sub = dm * (float)Ls_blk[j];
+                float m_sub = mm * (float)Lm_blk[j];
+                if (d_sub < 1e-15f) {
+                    for (int k = 0; k < 16; k++) L[16*j+k] = 0;
+                    continue;
+                }
+                for (int k = 0; k < 16; k++) {
+                    int q = gguf_nearest_int((adj_block_x[16*j+k] + m_sub) / d_sub);
+                    if (q < 0) q = 0; if (q > 3) q = 3;
+                    L[16*j+k] = (uint8_t)q;
+                }
             }
 
             double Saa = 0, Sab = 0, Sbb = 0, Sxa = 0, Sxb = 0;
@@ -4365,7 +3917,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                         float d_sub = trial_dm * (float)Ls_blk[j];
                         float m_sub = trial_mm * (float)Lm_blk[j];
                         for (int k = 0; k < 16; k++) {
-                            float x = block_x[16*j+k];
+                            float x = adj_block_x[16*j+k];
                             float w = (imat_importance) ?
                                       imat_importance[blk * QK_K + 16*j+k] : 1.0f;
                             int q;
@@ -4391,7 +3943,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
         }
 
         for (int j = 0; j < N_SUB; j++) {
-            const float *sx = block_x + 16 * j;
+            const float *sx = adj_block_x + 16 * j;
             float best_sub_err = 1e30f;
             uint8_t best_ls = Ls_blk[j], best_lm = Lm_blk[j];
             for (int try_ls = 0; try_ls <= 15; try_ls++) {
@@ -4446,45 +3998,50 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
          */
         uint8_t L[QK_K];
         {
-            hex_vesica_bake_subcodes(
-                block_x,
-                imat_importance ? (imat_importance + blk * QK_K) : NULL,
-                dm, mm, Ls_blk, Lm_blk, L, 0);
-            int q_base_all[QK_K];
-            int q_shaped_all[QK_K];
-            for (int i = 0; i < QK_K; i++)
-                q_base_all[i] = (int)L[i];
+            float q_cont_all[QK_K];
+            int   q_base_all[QK_K];
+            int   q_shaped_all[QK_K];
+
+            for (int i = 0; i < QK_K; i++) {
+                int   jj  = i >> 4;
+                float d_s = dm * (float)(output[blk].scales[jj] & 0xF);
+                float m_s = mm * (float)(output[blk].scales[jj] >> 4);
+                if (d_s < 1e-15f) {
+                    q_cont_all[i] = 0.0f;
+                    q_base_all[i] = 0;
+                } else {
+                    /* Quantize the DC-adjusted target */
+                    float qc = (adj_block_x[i] + m_s) / d_s;
+                    q_cont_all[i] = qc;
+                    int qr = gguf_nearest_int(qc);
+                    if (qr < 0) qr = 0; if (qr > 3) qr = 3;
+                    q_base_all[i] = qr;
+                }
+            }
             memcpy(q_shaped_all, q_base_all, QK_K * sizeof(int));
 
             float e_live[QK_K];
+            float dc_cur = 0.0f;
             for (int i = 0; i < QK_K; i++) {
                 int   jj  = i >> 4;
                 float d_s = dm * (float)(output[blk].scales[jj] & 0xF);
                 float m_s = mm * (float)(output[blk].scales[jj] >> 4);
-                /* Decoder semantics: deq = d_s·q − m_s, which is −m_s when
-                 * d_s == 0 (NOT 0 — the −dmin·lm term always applies). */
                 float deq = d_s * (float)q_shaped_all[i] - m_s;
-                /* Residual against the adjusted target (DC-corrected view) */
+                /* Vesica on ORIGINAL residuals. DC on the rolling-adjusted
+                 * residual so this block still absorbs Phase 3.9's target. */
                 e_live[i] = block_x[i] - deq;
+                dc_cur   += adj_block_x[i] - deq;
             }
 
             float v_live[QK_K / 2];
-            float vesica_cur = 0.0f, dc_cur = 0.0f, cross_cur = 0.0f;
+            float vesica_cur = 0.0f;
             for (int i = 0; i < QK_K / 2; i++) {
                 v_live[i] = e_live[i] + e_live[i + QK_K / 2];
                 vesica_cur += v_live[i] * v_live[i];
-                cross_cur  += e_live[i] * e_live[i + QK_K / 2];
             }
-            for (int i = 0; i < QK_K; i++) dc_cur += e_live[i];
-            float sse_cur = 0.0f;
-            for (int i = 0; i < QK_K; i++) {
-                float w = (imat_importance) ? imat_importance[blk * QK_K + i] : 1.0f;
-                sse_cur += w * e_live[i] * e_live[i];
-            }
-            float metric_cur = HEX_VESICA_SSE_EPS * sse_cur
-                             + hex_spectral_from_moments(dc_cur, vesica_cur, QK_K);
+            float metric_cur = 4.0f * vesica_cur + dc_cur * dc_cur;
 
-            /* Deterministic greedy: Edge SSE + Vertex/DC in one metric. */
+            /* Deterministic greedy descent: accept only strict improvements */
             for (int pass = 0; pass < QK_K; pass++) {
                 int   best_k     = -1;
                 int   best_q_alt = 0;
@@ -4498,8 +4055,11 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int   q_cur = q_shaped_all[k];
                     float m_s   = mm * (float)(output[blk].scales[jj] >> 4);
                     int   pi    = (k < QK_K / 2) ? k : k - QK_K / 2;
-                    float wk    = (imat_importance) ? imat_importance[blk * QK_K + k] : 1.0f;
 
+                    /* Try ALL alternate codes, not just ±1.  A weight at q=0
+                     * with strong positive DC bias may need to jump to q=2 or
+                     * q=3; the old ±1 path took multiple passes to walk there
+                     * one step at a time, if it got there at all. */
                     for (int q_try = 0; q_try <= 3; q_try++) {
                         if (q_try == q_cur) continue;
 
@@ -4510,12 +4070,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
 
                         float vesica_alt = vesica_cur - v_live[pi]*v_live[pi] + v_new*v_new;
                         float dc_alt     = dc_cur + de;
-                        float sse_alt    = sse_cur
-                            - wk * e_live[k] * e_live[k]
-                            + wk * e_new * e_new;
-                        float met_alt = HEX_VESICA_SSE_EPS * sse_alt
-                            + hex_spectral_from_moments(dc_alt, vesica_alt, QK_K);
-                        float delta = metric_cur - met_alt;
+                        float delta      = metric_cur - (4.0f * vesica_alt + dc_alt * dc_alt);
 
                         if (delta > best_delta) {
                             best_delta = delta;
@@ -4536,14 +4091,9 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     float de_c    = e_new_c - e_live[best_k];
                     int   pi_c    = (best_k < QK_K / 2) ? best_k : best_k - QK_K / 2;
                     float v_new_c = v_live[pi_c] + de_c;
-                    float wk_c    = (imat_importance)
-                        ? imat_importance[blk * QK_K + best_k] : 1.0f;
-                    sse_cur      += wk_c * (e_new_c * e_new_c
-                                            - e_live[best_k] * e_live[best_k]);
                     vesica_cur   += v_new_c * v_new_c - v_live[pi_c] * v_live[pi_c];
                     dc_cur       += de_c;
-                    metric_cur    = HEX_VESICA_SSE_EPS * sse_cur
-                        + hex_spectral_from_moments(dc_cur, vesica_cur, QK_K);
+                    metric_cur    = 4.0f * vesica_cur + dc_cur * dc_cur;
                     v_live[pi_c]  = v_new_c;
                     e_live[best_k]= e_new_c;
                 }
@@ -4888,8 +4438,8 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int   pi         = j & 7;          /* fold-pair index    */
                     int   pj         = j ^ 8;          /* partner sub-block  */
                     const float *ppe = pe + 16 * pj;   /* partner residuals  */
-                    float dc_rest    = dc_tot    - sub_dc[j];
-                    float ves_rest   = ves_tot   - pair_ves[pi];
+                    float dc_rest    = dc_tot  - sub_dc[j];
+                    float ves_rest   = ves_tot - pair_ves[pi];
 
                     /* Extended score of the CURRENT committed state */
                     float best_sub = sub_sse[j]
@@ -4898,13 +4448,13 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int     best_ls = -1, best_lm = 0;
                     uint8_t best_q[16];
                     float   best_e[16];
-                    float   best_sse = 0.0f, best_dcc = 0.0f, best_cxc = 0.0f;
+                    float   best_sse = 0.0f, best_dcc = 0.0f, best_ves = 0.0f;
 
                     for (int try_ls = 0; try_ls <= 15; try_ls++) {
                         float d_sub = dm * (float)try_ls;
                         for (int try_lm = 0; try_lm <= 15; try_lm++) {
                             float m_sub = mm * (float)try_lm;
-                            float sub_err = 0.0f, dcc = 0.0f, cxc = 0.0f;
+                            float sub_err = 0.0f, dcc = 0.0f, vesc = 0.0f;
                             uint8_t q_loc[16];
                             float   e_loc[16];
                             int     aborted = 0;
@@ -4918,24 +4468,23 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                                     if (q < 0) q = 0; if (q > 3) q = 3;
                                 }
                                 q_loc[k] = (uint8_t)q;
-                                /* deq = d·ls·q − dmin·lm; −m_sub at ls==0 */
                                 float e = x - (d_sub * (float)q - m_sub);
                                 e_loc[k] = e;
                                 sub_err += e * e * w;
                                 dcc     += e;
                                 {
-                                    float vpk = e + ppe[k];
-                                    cxc += vpk * vpk;
+                                    float v = e + ppe[k];
+                                    vesc += v * v;
                                 }
-                                if (HEX_VW_LAMBDA == 0.0f &&
-                                    sub_err >= best_sub) { aborted = 1; break; }
+                                /* Spectral terms are ≥ 0, so SSE is a valid prune. */
+                                if (sub_err >= best_sub) { aborted = 1; break; }
                             }
                             if (aborted) continue;
                             float score = sub_err
                                 + (HEX_DC_LAMBDA / (float)QK_K)
                                   * (dc_rest + dcc) * (dc_rest + dcc)
                                 + (HEX_VW_LAMBDA / (float)QK_K)
-                                  * (ves_rest + cxc);
+                                  * (ves_rest + vesc);
                             if (score < best_sub) {
                                 best_sub = score;
                                 best_ls  = try_ls;
@@ -4944,7 +4493,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                                 memcpy(best_e, e_loc, sizeof(e_loc));
                                 best_sse = sub_err;
                                 best_dcc = dcc;
-                                best_cxc = cxc;
+                                best_ves = vesc;
                             }
                         }
                     }
@@ -4954,11 +4503,11 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                         pl_Lm[j] = (uint8_t)best_lm;
                         memcpy(L  + 16 * j, best_q, 16);
                         memcpy(pe + 16 * j, best_e, sizeof(best_e));
-                        sub_sse[j]     = best_sse;
-                        sub_dc[j]      = best_dcc;
-                        pair_ves[pi]   = best_cxc;
-                        dc_tot         = dc_rest    + best_dcc;
-                        ves_tot        = ves_rest   + best_cxc;
+                        sub_sse[j]   = best_sse;
+                        sub_dc[j]    = best_dcc;
+                        pair_ves[pi] = best_ves;
+                        dc_tot       = dc_rest  + best_dcc;
+                        ves_tot      = ves_rest + best_ves;
                         pol_improved = 1;
                     }
                 }
@@ -5075,11 +4624,8 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                             float t_mm = gguf_fp16_to_fp32((uint16_t)cm16);
 
                             float err = 0.0f;
-                            /* SSE-partial prune valid only without the
-                             * signable vesica/wave credit */
-                            for (int j = 0;
-                                 j < N_SUB && (HEX_VW_LAMBDA != 0.0f ||
-                                               err < best_err); j++) {
+                            int pruned = 0;
+                            for (int j = 0; j < N_SUB; j++) {
                                 float d_sub = t_dm * (float)pl_Ls[j];
                                 float m_sub = t_mm * (float)pl_Lm[j];
                                 for (int k = 0; k < 16; k++) {
@@ -5090,11 +4636,10 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                                                (d_sub * (float)L[idx] - m_sub);
                                     err += e_u[idx] * e_u[idx] * w;
                                 }
+                                if (err >= best_err) { pruned = 1; break; }
                             }
-                            if (HEX_DC_LAMBDA != 0.0f || HEX_VW_LAMBDA != 0.0f)
-                                err = (err < best_err || HEX_VW_LAMBDA != 0.0f)
-                                      ? err + hex_spectral_penalty(e_u, QK_K)
-                                      : err;
+                            if (pruned) continue;
+                            err += hex_spectral_penalty(e_u, QK_K);
                             if (err < best_err) {
                                 best_err = err;
                                 best_d16 = (uint16_t)cd16;
@@ -5119,34 +4664,20 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
             output[blk].dmin = gguf_fp32_to_fp16(mm);
         }
 
-        /* Bake vesica subcodes into stock 2-bit + nibble fields.
-         * Accept only if block SSE drops; 4.7 is the backstop. */
-        {
-            uint8_t gLs[16], gLm[16];
-            const float *wrow = imat_importance
-                ? (imat_importance + blk * QK_K) : NULL;
-            for (int sj = 0; sj < N_SUB; sj++) {
-                gLs[sj] = output[blk].scales[sj] & 0xF;
-                gLm[sj] = output[blk].scales[sj] >> 4;
-            }
-            hex_vesica_commit(block_x, wrow, &dm, &mm, gLs, gLm, L);
-            for (int sj = 0; sj < N_SUB; sj++)
-                output[blk].scales[sj] = gLs[sj] | (gLm[sj] << 4);
-            output[blk].d    = gguf_fp32_to_fp16(dm);
-            output[blk].dmin = gguf_fp32_to_fp16(mm);
-            memcpy(Ls_blk, gLs, 16);
-            memcpy(Lm_blk, gLm, 16);
-        }
-
-        /* ══ PHASE 4.7: CANDIDATE FLOOR ══
+        /* ══ PHASE 4.7: CANDIDATE FLOOR (worst-case bound) ══
          *
-         * candidate_errors is pure nearest-int SSE (the "theoretical floor"
-         * Fold beat by changing coordinates). Compare that to pipeline SSE
-         * only — never SSE+spectral. Adding the vesica/DC penalty here made
-         * fin_err > g_best whenever λ>0, so every block snapped back to
-         * independent nearest-int and threw away HPC+triality+vesica. */
+         * candidate_errors[blk][c] is the EXACT weighted SSE of a directly
+         * encodable configuration (fp16 d/dmin + derived Ls/Lm + nearest
+         * rounding vs the original weights). The multi-stage assembly
+         * (DC-shifted WLS, shaping, diffusion, polish) usually improves on
+         * its seed, but each stage optimises a slightly different objective
+         * and coordinate descent can land in a worse basin. Compare the
+         * finished block against the best raw candidate and fall back when
+         * the pipeline ended up worse — guaranteeing
+         *     final weighted SSE ≤ min_c candidate_errors[blk][c].          */
         {
             float fin_err = 0.0f;
+            float e_f[QK_K];
             for (int j = 0; j < N_SUB; j++) {
                 float d_sub = dm * (float)(output[blk].scales[j] & 0xF);
                 float m_sub = mm * (float)(output[blk].scales[j] >> 4);
@@ -5154,11 +4685,12 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int   idx = 16 * j + k;
                     float w   = (imat_importance) ?
                                 imat_importance[blk * QK_K + idx] : 1.0f;
-                    float e = block_x[idx] -
-                              (d_sub * (float)L[idx] - m_sub);
-                    fin_err += e * e * w;
+                    e_f[idx] = block_x[idx] -
+                               (d_sub * (float)L[idx] - m_sub);
+                    fin_err += e_f[idx] * e_f[idx] * w;
                 }
             }
+            fin_err += hex_spectral_penalty(e_f, QK_K);
 
             float g_best = candidate_errors[blk][0];
             int   g_cand = 0;
@@ -5198,22 +4730,6 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
             }
         }
 
-            if (HEX_VW_LAMBDA != 0.0f || HEX_DC_LAMBDA != 0.0f) {
-            uint8_t gLs[16], gLm[16];
-            const float *wrow = imat_importance
-                ? (imat_importance + blk * QK_K) : NULL;
-            for (int sj = 0; sj < N_SUB; sj++) {
-                gLs[sj] = output[blk].scales[sj] & 0xF;
-                gLm[sj] = output[blk].scales[sj] >> 4;
-            }
-            float sse_pre = hex_block_sse(block_x, wrow, dm, mm, gLs, gLm, L);
-            uint8_t Lpre[QK_K];
-            memcpy(Lpre, L, QK_K);
-            hex_vesica_guide_pairs(block_x, wrow, dm, mm, gLs, gLm, L);
-            if (hex_block_sse(block_x, wrow, dm, mm, gLs, gLm, L) > sse_pre)
-                memcpy(L, Lpre, QK_K);
-        }
-
         for (int j = 0; j < QK_K; j += 128) {
             for (int l = 0; l < 32; l++) {
                 output[blk].qs[j / 4 + l] = L[j + l]

hexstate_requantize.py

@@ -3,11 +3,9 @@
 HexState GGUF Re-Quantizer — GGUF-to-GGUF Q2_K quantization.
 
 Reads a source GGUF (F16/BF16/F32), copies all metadata verbatim,
-and re-quantizes eligible weight tensors to Q2_K.  Fold-interleave is ON
-by default: each Q2_K block is order-stat paired (k-th smallest at k,
-k-th largest at k+128) then written as ordinary 84-byte Q2_K — stored
-order is decode order, no sidecar.  Pass --no-fold-interleave for
-identity-layout Q2_K.  Optional --fold-basis is a shared dimension perm.
+and re-quantizes eligible weight tensors to Q2_K.  When
+libhexstate_q2k.so is available, the C HExState optimizer is used for the
+Q2_K/Q4_0/Q8_0 paths; otherwise the numpy fallback is used.
 
 This bypasses the tokenizer parsing problem entirely — the source GGUF
 (from llama.cpp's convert_hf_to_gguf.py) has correct metadata.
@@ -22,7 +20,6 @@ import time
 import os
 import io
 import ctypes
-import re as _re
 import numpy as np
 
 # ─── HExState C Library (HPC-optimized Q2_K quantization) ──────────────────
@@ -116,19 +113,9 @@ def _load_hexstate_lib():
         if hasattr(lib, 'hexstate_set_spectral_params'):
             lib.hexstate_set_spectral_params.restype = None
             lib.hexstate_set_spectral_params.argtypes = [
-                ctypes.c_float, ctypes.c_float, ctypes.c_float,
-            ]
+                ctypes.c_float, ctypes.c_float, ctypes.c_float]
 
         lib.hexstate_init()
-        dc_l = os.environ.get('HEX_DC_LAMBDA')
-        vw_l = os.environ.get('HEX_VW_LAMBDA')
-        dc_d = os.environ.get('HEX_DC_DECAY')
-        if hasattr(lib, 'hexstate_set_spectral_params') and (dc_l or vw_l or dc_d):
-            lib.hexstate_set_spectral_params(
-                ctypes.c_float(float(dc_l) if dc_l else 4.0),
-                ctypes.c_float(float(vw_l) if vw_l else 4.0),
-                ctypes.c_float(float(dc_d) if dc_d else 1.0),
-            )
         _HEXSTATE_LIB = lib
         return lib
     except Exception as e:
@@ -317,7 +304,6 @@ GGML_TYPE_F16   = 1
 GGML_TYPE_Q4_0  = 2
 GGML_TYPE_Q8_0  = 8
 GGML_TYPE_Q2_K  = 10
-GGML_TYPE_I16   = 25
 GGML_TYPE_BF16  = 30
 
 TYPE_NAME = {
@@ -330,12 +316,12 @@ TYPE_NAME = {
 TYPE_BLOCK_SIZE = {
     0: 1, 1: 1, 2: 32, 3: 32, 6: 32, 7: 32,
     8: 32, 9: 32, 10: 256, 11: 256, 12: 256,
-    13: 256, 14: 256, 15: 256, 25: 1, 30: 1,
+    13: 256, 14: 256, 15: 256, 30: 1,
 }
 TYPE_BLOCK_BYTES = {
     0: 4, 1: 2, 2: 18, 3: 20, 6: 20, 7: 22,
     8: 34, 9: 36, 10: 84, 11: 110, 12: 144,
-    13: 176, 14: 210, 15: 292, 25: 2, 30: 2,
+    13: 176, 14: 210, 15: 292, 30: 2,
 }
 
 
@@ -411,540 +397,6 @@ def f32_to_bf16(f32_array):
     return bf16.tobytes()
 
 
-def _src_to_f32(raw_data, ti):
-    if ti['type'] == GGML_TYPE_BF16:
-        return bf16_to_f32(raw_data, ti['n_elements'])
-    if ti['type'] == GGML_TYPE_F16:
-        return f16_to_f32(raw_data, ti['n_elements'])
-    if ti['type'] == GGML_TYPE_F32:
-        return np.frombuffer(raw_data, dtype=np.float32).copy()
-    return None
-
-
-def _f32_to_src_bytes(f32, ttype):
-    if ttype == GGML_TYPE_F32:
-        return np.ascontiguousarray(f32, dtype=np.float32).tobytes()
-    if ttype == GGML_TYPE_F16:
-        return f32_to_f16(f32)
-    if ttype == GGML_TYPE_BF16:
-        return f32_to_bf16(np.ascontiguousarray(f32, dtype=np.float32))
-    return None
-
-
-# ─── Fold-basis (stock-llama equivalent network) ──────────────────────────
-# One permutation of the hidden dim + one per-layer permutation of the
-# FFN intermediate dim. Applied to every tensor that touches that axis
-# (weights, embeddings, norms) so W'x' = Wx. Ordinary Q2_K GGUF; llama.cpp
-# loads it as the same model in a rotated basis.
-#
-# Column statistics, not per-block argsort: a data-dependent shuffle
-# inside each 256-block would be a valid Q2_K file that llama cannot
-# matmul correctly.
-
-def _fb_tensor_perms(name):
-    """Return list of (perm_key, axis) for this tensor.
-    axis: 0 → permute dims[0] (columns/input, what blocks span)
-          1 → permute dims[1] (rows/output)
-          '1d' → 1D parameter (norms)
-    """
-    perms = []
-    if _re.match(r'blk\.\d+\.attn_(q|k|v|qkv)\.weight', name) or \
-       _re.match(r'blk\.\d+\.attn_gate\.weight', name) or \
-       _re.match(r'blk\.\d+\.ssm_(in_qkv|in_z|in_x|out)\.weight', name) or \
-       _re.match(r'blk\.\d+\.ffn_(gate|up)\.weight', name) or \
-       name in ('token_embd.weight', 'output.weight'):
-        perms.append(('hidden', 0))
-        # Square hidden→hidden maps need PᵀWP. Mismatched axis is a no-op.
-        if _re.match(r'blk\.\d+\.(attn_gate|ssm_out)\.weight', name):
-            perms.append(('hidden', 1))
-    if _re.match(r'blk\.\d+\.attn_output\.weight', name) or \
-       _re.match(r'blk\.\d+\.ffn_down\.weight', name):
-        perms.append(('hidden', 1))
-    if _re.match(r'blk\.\d+\.(attn|ffn)_norm\.weight', name) or \
-       name == 'output_norm.weight':
-        perms.append(('hidden', '1d'))
-    m = _re.match(r'blk\.(\d+)\.ffn_down\.weight', name)
-    if m:
-        perms.append((f'inter_{m.group(1)}', 0))
-    m = _re.match(r'blk\.(\d+)\.ffn_(gate|up)\.weight', name)
-    if m:
-        perms.append((f'inter_{m.group(1)}', 1))
-    return perms
-
-
-def _fb_compute_perm(energies, block_size=QK_K):
-    """Stride-interleave: pair low-energy with high-energy columns at
-    fold-complementary positions, dealt across QK_K blocks."""
-    dim = len(energies)
-    n_blocks = dim // block_size
-    half = block_size // 2
-    remainder = dim % block_size
-
-    if n_blocks == 0 or remainder != 0:
-        return np.arange(dim, dtype=np.intp)
-
-    sorted_idx = np.argsort(energies)
-    low = sorted_idx[:dim // 2]
-    high = sorted_idx[dim // 2:][::-1]
-
-    low_blocks = low.reshape(half, n_blocks).T
-    high_blocks = high.reshape(half, n_blocks).T
-
-    perm = np.empty(dim, dtype=np.intp)
-    for b in range(n_blocks):
-        s = b * block_size
-        perm[s:s + half] = low_blocks[b]
-        perm[s + half:s + block_size] = high_blocks[b]
-    return perm
-
-
-def _fb_apply(f32, dims, perm, axis):
-    if axis == '1d':
-        if len(perm) != len(f32):
-            return f32
-        return f32[perm].copy()
-    d0 = int(dims[0])
-    d1 = int(dims[1]) if len(dims) > 1 else 1
-    if axis == 0 and len(perm) != d0:
-        return f32
-    if axis == 1 and len(perm) != d1:
-        return f32
-    M = f32.reshape(d1, d0)
-    if axis == 0:
-        M = M[:, perm]
-    else:
-        M = M[perm, :]
-    return M.reshape(-1).copy()
-
-
-def _fb_apply_tensor(f32, ti, fb_perms, imat_full=None):
-    if not fb_perms:
-        return f32, imat_full
-    for key, axis in _fb_tensor_perms(ti['name']):
-        perm = fb_perms.get(key)
-        if perm is None:
-            continue
-        f32 = _fb_apply(f32, ti['dims'], perm, axis)
-        if imat_full is not None:
-            if imat_full.size == f32.size:
-                imat_full = _fb_apply(imat_full, ti['dims'], perm, axis)
-            elif imat_full.size == len(perm) and axis in (0, '1d'):
-                imat_full = imat_full[perm].copy()
-    return f32, imat_full
-
-
-def _chunk_max_elems():
-    """Peak f32 elements per tensor chunk. Override with HEX_CHUNK_ELEMS."""
-    raw = os.environ.get('HEX_CHUNK_ELEMS', '2000000')
-    try:
-        n = int(raw)
-    except ValueError:
-        n = 2_000_000
-    return max(QK_K, n)
-
-
-def _elem_nbytes(ttype):
-    if ttype == GGML_TYPE_F32:
-        return 4
-    if ttype in (GGML_TYPE_F16, GGML_TYPE_BF16):
-        return 2
-    return None
-
-
-def _bytes_to_f32(raw, ttype, n_elements):
-    if ttype == GGML_TYPE_F32:
-        return np.frombuffer(raw, dtype=np.float32).copy()
-    if ttype == GGML_TYPE_F16:
-        return f16_to_f32(raw, n_elements)
-    if ttype == GGML_TYPE_BF16:
-        return bf16_to_f32(raw, n_elements)
-    return None
-
-
-def _fb_axis_maps(ti, fb_perms):
-    """Compose fold-basis into (row_perm, col_perm, is_1d)."""
-    if not fb_perms:
-        return None, None, False
-    row_perm = col_perm = vec_perm = None
-    for key, axis in _fb_tensor_perms(ti['name']):
-        perm = fb_perms.get(key)
-        if perm is None:
-            continue
-        if axis == '1d':
-            vec_perm = perm
-        elif axis == 0:
-            col_perm = perm
-        else:
-            row_perm = perm
-    if vec_perm is not None:
-        return vec_perm, None, True
-    return row_perm, col_perm, False
-
-
-def _read_src_rows(fin, abs_offset, ttype, d0, src_rows):
-    """Load selected source rows as float32 [n_rows, d0], coalescing runs."""
-    src_rows = np.asarray(src_rows, dtype=np.intp)
-    nbytes = _elem_nbytes(ttype)
-    if nbytes is None:
-        raise ValueError(f'cannot stream type {ttype}')
-    row_bytes = d0 * nbytes
-    n = int(src_rows.size)
-    out = np.empty((n, d0), dtype=np.float32)
-    i = 0
-    while i < n:
-        j = i + 1
-        while j < n and int(src_rows[j]) == int(src_rows[j - 1]) + 1:
-            j += 1
-        r0 = int(src_rows[i])
-        nr = j - i
-        fin.seek(abs_offset + r0 * row_bytes)
-        raw = fin.read(nr * row_bytes)
-        if len(raw) != nr * row_bytes:
-            raise IOError(f'short read at row {r0}: {len(raw)}/{nr * row_bytes}')
-        out[i:j] = _bytes_to_f32(raw, ttype, nr * d0).reshape(nr, d0)
-        i = j
-    return out
-
-
-def _load_dest_chunk_f32(fin, abs_offset, ttype, d0, r0, r1, row_perm, col_perm):
-    dest = np.arange(r0, r1, dtype=np.intp)
-    src = row_perm[dest] if row_perm is not None else dest
-    M = _read_src_rows(fin, abs_offset, ttype, d0, src)
-    if col_perm is not None:
-        M = M[:, col_perm]
-    return np.ascontiguousarray(M.reshape(-1))
-
-
-def _stream_col_mean(fin, data_section_start, ti):
-    """Column mean of a 2D tensor without loading it whole."""
-    d0 = int(ti['dims'][0])
-    d1 = int(ti['dims'][1]) if ti['n_dims'] > 1 else 1
-    ttype = ti['type']
-    if _elem_nbytes(ttype) is None:
-        return None
-    abs_offset = data_section_start + ti['offset']
-    acc = np.zeros(d0, dtype=np.float64)
-    rows_per = max(1, _chunk_max_elems() // max(d0, 1))
-    for r0 in range(0, d1, rows_per):
-        r1 = min(d1, r0 + rows_per)
-        M = _read_src_rows(fin, abs_offset, ttype, d0,
-                           np.arange(r0, r1, dtype=np.intp))
-        acc += M.astype(np.float64, copy=False).sum(axis=0)
-        del M
-    return acc / max(d1, 1)
-
-
-def _copy_bytes(fin, fout, abs_offset, data_size, chunk=16 * 1024 * 1024):
-    fin.seek(abs_offset)
-    left = int(data_size)
-    while left > 0:
-        n = min(left, chunk)
-        buf = fin.read(n)
-        if not buf:
-            raise IOError('short copy from source GGUF')
-        fout.write(buf)
-        left -= len(buf)
-    return int(data_size)
-
-
-def _imat_chunk(ti, imatrix_data, r0, r1, row_perm, col_perm):
-    if not imatrix_data:
-        return None
-    iw = imatrix_data.get(ti['name'])
-    if iw is None:
-        return None
-    iw = np.asarray(iw, dtype=np.float32).reshape(-1)
-    d0 = int(ti['dims'][0])
-    n_rows = r1 - r0
-    n_el = int(ti['n_elements'])
-    if iw.size == d0:
-        row = iw[col_perm] if col_perm is not None else iw
-        return np.ascontiguousarray(np.tile(row, n_rows))
-    if iw.size == n_el and ti['n_dims'] >= 2:
-        M = iw.reshape(-1, d0)
-        rows = row_perm[r0:r1] if row_perm is not None else slice(r0, r1)
-        M = M[rows]
-        if col_perm is not None:
-            M = M[:, col_perm]
-        return np.ascontiguousarray(M.reshape(-1))
-    return None
-
-
-def _quantize_q4_0_numpy(f32):
-    n_el = len(f32)
-    if n_el % 32:
-        pad = 32 - (n_el % 32)
-        f32 = np.concatenate([f32, np.zeros(pad, dtype=np.float32)])
-        n_el = len(f32)
-    n_blocks = n_el // 32
-    blocks = f32.reshape(-1, 32)
-    amax = np.max(np.abs(blocks), axis=1)
-    d = amax / 7.0
-    d[d == 0] = 1.0
-    qs = np.clip(np.round(blocks / d[:, None]) + 8, 0, 15).astype(np.uint8)
-    d_fp16 = (amax / 7.0).astype(np.float16)
-    out_buf = bytearray(n_blocks * 18)
-    for b in range(n_blocks):
-        off = b * 18
-        struct.pack_into('<e', out_buf, off, float(d_fp16[b]))
-        for j in range(16):
-            out_buf[off + 2 + j] = int(qs[b, j]) | (int(qs[b, j + 16]) << 4)
-    return bytes(out_buf), n_blocks
-
-
-def _stream_keep(fin, fout, ti, abs_offset, fb_perms):
-    """Passthrough, optionally applying fold-basis without a full-tensor copy."""
-    row_perm, col_perm, is_1d = _fb_axis_maps(ti, fb_perms)
-    ttype = ti['type']
-    nbytes = _elem_nbytes(ttype)
-    if row_perm is None and col_perm is None:
-        return _copy_bytes(fin, fout, abs_offset, ti['data_size'])
-    if is_1d:
-        if nbytes is None:
-            return _copy_bytes(fin, fout, abs_offset, ti['data_size'])
-        fin.seek(abs_offset)
-        raw = fin.read(ti['data_size'])
-        f32 = _bytes_to_f32(raw, ttype, ti['n_elements'])
-        if f32 is None:
-            fout.write(raw)
-            return len(raw)
-        f32 = f32[row_perm].copy()
-        outb = _f32_to_src_bytes(f32, ttype)
-        fout.write(outb)
-        return len(outb)
-    if nbytes is None or ti['n_dims'] < 2:
-        return _copy_bytes(fin, fout, abs_offset, ti['data_size'])
-    d0 = int(ti['dims'][0])
-    d1 = int(ti['dims'][1])
-    rows_per = max(1, _chunk_max_elems() // max(d0, 1))
-    written = 0
-    for r0 in range(0, d1, rows_per):
-        r1 = min(d1, r0 + rows_per)
-        f32 = _load_dest_chunk_f32(fin, abs_offset, ttype, d0, r0, r1,
-                                   row_perm, col_perm)
-        outb = _f32_to_src_bytes(f32, ttype)
-        fout.write(outb)
-        written += len(outb)
-        del f32
-    return written
-
-
-def apply_fold_interleave(f32_data, block_size=QK_K):
-    """In-place: k-th smallest at k, k-th largest at k+128.
-    Returns uint8 perm: stored[i] = orig[perm[i]]."""
-    n = len(f32_data)
-    n_blocks = n // block_size
-    half = block_size // 2
-    all_perms = np.empty(n, dtype=np.uint8)
-    x = np.ascontiguousarray(f32_data, dtype=np.float32).reshape(n_blocks, block_size)
-    sorted_idx = np.argsort(x, axis=1, kind='mergesort')
-    perm = np.empty_like(sorted_idx)
-    perm[:, :half] = sorted_idx[:, :half]
-    perm[:, half:] = sorted_idx[:, ::-1][:, :half]
-    f32_data[:] = np.take_along_axis(x, perm, axis=1).reshape(-1)
-    all_perms[:] = perm.astype(np.uint8).reshape(-1)
-    return all_perms
-
-
-def apply_fold_interleave_importance(importance, perm_flat, block_size=QK_K):
-    n = len(importance)
-    n_blocks = n // block_size
-    blocks = np.ascontiguousarray(importance, dtype=np.float32).reshape(n_blocks, block_size)
-    perms = perm_flat[:n].reshape(n_blocks, block_size).astype(np.intp)
-    return np.take_along_axis(blocks, perms, axis=1).reshape(-1)
-
-
-def _stream_quantize(fin, fout, ti, abs_offset, kind, fb_perms, imatrix_data,
-                     use_hpc, fold_interleave=False):
-    """Quantize one tensor in row chunks. kind: 'q2k' | 'q4' | 'q8'.
-    Returns (n_out_bytes, rmse_or_None). Copies raw if source is already quant.
-    """
-    ttype = ti['type']
-    if _elem_nbytes(ttype) is None:
-        n = _copy_bytes(fin, fout, abs_offset, ti['data_size'])
-        return n, None, None
-    if ti['n_dims'] < 2 or not ti['dims']:
-        n = _copy_bytes(fin, fout, abs_offset, ti['data_size'])
-        return n, None, None
-
-    d0 = int(ti['dims'][0])
-    d1 = int(ti['dims'][1])
-    row_perm, col_perm, is_1d = _fb_axis_maps(ti, fb_perms)
-    if is_1d:
-        col_perm = None
-
-    if kind == 'q2k':
-        align = QK_K
-    else:
-        align = 32
-
-    if d0 % align != 0:
-        raise ValueError(f'{ti["name"]} dim0={d0} not aligned to {align}')
-
-    rows_per = max(1, _chunk_max_elems() // max(d0, 1))
-    total_se = 0.0
-    total_ss = 0.0
-    total_n = 0
-    written = 0
-    n_chunks = (d1 + rows_per - 1) // rows_per
-
-    for r0 in range(0, d1, rows_per):
-        r1 = min(d1, r0 + rows_per)
-        f32 = _load_dest_chunk_f32(fin, abs_offset, ttype, d0, r0, r1,
-                                   row_perm, col_perm)
-        imp = _imat_chunk(ti, imatrix_data, r0, r1, row_perm, col_perm)
-        n_valid = int(f32.size)
-        total_ss += float(np.vdot(f32, f32))
-        total_n += n_valid
-
-        if kind == 'q2k' and fold_interleave:
-            perm_u8 = apply_fold_interleave(f32)
-            if imp is not None:
-                imp = apply_fold_interleave_importance(imp, perm_u8)
-
-        if kind == 'q2k':
-            if use_hpc:
-                qbytes, n_blocks = quantize_tensor_q2k_hpc(
-                    f32, opt_mode=2, importance=imp, row_width=d0)
-            else:
-                qbytes, n_blocks = quantize_tensor_q2k(f32)
-            fout.write(qbytes)
-            written += len(qbytes)
-            try:
-                deq = dequant_q2k_fast(qbytes, n_blocks)
-                n_cmp = min(n_valid, len(deq))
-                diff = f32[:n_cmp] - deq[:n_cmp]
-                total_se += float(np.sum(diff ** 2))
-            except Exception:
-                pass
-        elif kind == 'q4':
-            n_blocks = n_valid // 32
-            if (use_hpc and _HEXSTATE_LIB is not None
-                    and hasattr(_HEXSTATE_LIB, 'hexstate_quantize_tensor_q4_0_hpc')):
-                output_buf = np.zeros(n_blocks * 18, dtype=np.uint8)
-                error = ctypes.c_float(0.0)
-                f32_c = np.ascontiguousarray(f32, dtype=np.float32)
-                imat_ptr = None
-                if imp is not None:
-                    imat_ptr = imp.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
-                _HEXSTATE_LIB.hexstate_quantize_tensor_q4_0_hpc(
-                    f32_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
-                    ctypes.c_int64(n_valid),
-                    output_buf.ctypes.data_as(ctypes.c_void_p),
-                    ctypes.byref(error),
-                    imat_ptr,
-                    ctypes.c_int(0),
-                )
-                qbytes = output_buf.tobytes()
-                total_se += float(error.value)
-            else:
-                qbytes, n_blocks = _quantize_q4_0_numpy(f32)
-            fout.write(qbytes)
-            written += len(qbytes)
-        else:
-            n_blocks = n_valid // 32
-            if (use_hpc and _HEXSTATE_LIB is not None
-                    and hasattr(_HEXSTATE_LIB, 'hexstate_quantize_tensor_q8_0_hpc')):
-                output_buf = np.zeros(n_blocks * 34, dtype=np.uint8)
-                error = ctypes.c_float(0.0)
-                f32_c = np.ascontiguousarray(f32, dtype=np.float32)
-                imat_ptr = None
-                if imp is not None:
-                    imat_ptr = imp.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
-                _HEXSTATE_LIB.hexstate_quantize_tensor_q8_0_hpc(
-                    f32_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
-                    ctypes.c_int64(n_valid),
-                    output_buf.ctypes.data_as(ctypes.c_void_p),
-                    ctypes.byref(error),
-                    imat_ptr,
-                    ctypes.c_int(0),
-                )
-                qbytes = output_buf.tobytes()
-                total_se += float(error.value)
-            else:
-                qbytes, n_blocks, sse8 = quantize_tensor_q8_0(f32)
-                total_se += float(sse8)
-            fout.write(qbytes)
-            written += len(qbytes)
-
-        del f32, imp
-        if n_chunks > 1:
-            pct = 100.0 * r1 / d1
-            print(f"\r    → {ti['name'][:40]}  {r1}/{d1} rows ({pct:.0f}%)",
-                  end='', flush=True)
-
-    if n_chunks > 1:
-        print()
-    rmse = (np.sqrt(total_se / max(total_n, 1)) if total_n else None)
-    sigma = (np.sqrt(total_ss / max(total_n, 1)) if total_n else None)
-    return written, rmse, sigma
-
-
-def _fb_prepass(fin, tensor_infos, data_section_start):
-    """P_hidden from first 3 W_q column means; P_inter_N from each W_down."""
-    print("  ┌── Fold-Basis pre-pass: computing dimension permutations ──┐")
-
-    perms = {}
-    hidden_stat = None
-    hidden_dim = None
-    hidden_count = 0
-
-    _HIDDEN_SAMPLE = 3
-    for ti in tensor_infos:
-        if hidden_count >= _HIDDEN_SAMPLE:
-            break
-        if not (_re.match(r'blk\.\d+\.attn_q\.weight', ti['name']) or
-                _re.match(r'blk\.\d+\.attn_qkv\.weight', ti['name'])):
-            continue
-        if ti['n_dims'] < 2:
-            continue
-        d0 = int(ti['dims'][0])
-        if d0 % QK_K != 0:
-            continue
-
-        col_mean = _stream_col_mean(fin, data_section_start, ti)
-        if col_mean is None:
-            continue
-
-        if hidden_stat is None:
-            hidden_dim = d0
-            hidden_stat = col_mean
-        else:
-            hidden_stat += col_mean
-        hidden_count += 1
-        print(f"  │  P_hidden sample: {ti['name']}")
-
-    if hidden_stat is not None:
-        perms['hidden'] = _fb_compute_perm(hidden_stat)
-        print(f"  │  P_hidden:  dim={hidden_dim}, from {hidden_count} Q/QKV tensors")
-
-    n_inter = 0
-    for ti in tensor_infos:
-        m = _re.match(r'blk\.(\d+)\.ffn_down\.weight', ti['name'])
-        if not m:
-            continue
-        if ti['n_dims'] < 2:
-            continue
-        d0 = int(ti['dims'][0])
-        if d0 % QK_K != 0:
-            continue
-
-        layer = m.group(1)
-        col_mean = _stream_col_mean(fin, data_section_start, ti)
-        if col_mean is None:
-            continue
-
-        perms[f'inter_{layer}'] = _fb_compute_perm(col_mean)
-        n_inter += 1
-
-    if n_inter > 0:
-        print(f"  │  P_inter:   {n_inter} layers (from W_down column means)")
-
-    print(f"  └── {len(perms)} permutations computed ──┘")
-    print()
-    return perms
-
-
 # ─── Q2_K quantization — faithful port of ggml quantize_row_q2_K_ref ───────
 # Vectorized with numpy for performance. Uses make_qkx2_quants algorithm:
 # - Weighted MAD error with weights[i] = |x[i]|
@@ -1272,6 +724,190 @@ def _expand_imatrix(ti, imatrix_data):
     return np.ascontiguousarray(np.tile(iw, n_el // row_width))
 
 
+def _chunk_max_elems():
+    try:
+        return max(QK_K, int(os.environ.get('HEX_CHUNK_ELEMS', '2000000')))
+    except ValueError:
+        return 2_000_000
+
+
+def _src_elem_nbytes(ttype):
+    if ttype == GGML_TYPE_F32:
+        return 4
+    if ttype in (GGML_TYPE_F16, GGML_TYPE_BF16):
+        return 2
+    return None
+
+
+def _load_rows_f32(fin, abs_offset, ttype, d0, r0, r1):
+    n = (r1 - r0) * d0
+    es = _src_elem_nbytes(ttype)
+    if es is None:
+        raise ValueError(f'cannot decode type {ttype} to f32')
+    fin.seek(abs_offset + r0 * d0 * es)
+    raw = fin.read(n * es)
+    if ttype == GGML_TYPE_F32:
+        return np.frombuffer(raw, dtype=np.float32).copy()
+    if ttype == GGML_TYPE_F16:
+        return np.frombuffer(raw, dtype=np.float16).astype(np.float32, copy=False)
+    u = np.frombuffer(raw, dtype=np.uint16)
+    return (u.astype(np.uint32) << 16).view(np.float32).copy()
+
+
+def _imat_chunk(ti, imatrix_data, r0, r1, d0):
+    if not imatrix_data:
+        return None
+    iw = imatrix_data.get(ti['name'])
+    if iw is None:
+        return None
+    iw = np.asarray(iw, dtype=np.float32).reshape(-1)
+    n_rows = r1 - r0
+    if iw.size == int(ti['n_elements']):
+        return np.ascontiguousarray(iw[r0 * d0:r1 * d0])
+    if iw.size == d0:
+        return np.ascontiguousarray(np.tile(iw, n_rows))
+    return None
+
+
+def _copy_bytes(fin, fout, abs_offset, n_bytes):
+    fin.seek(abs_offset)
+    left = n_bytes
+    buf = 16 * 1024 * 1024
+    written = 0
+    while left > 0:
+        chunk = fin.read(min(buf, left))
+        if not chunk:
+            break
+        fout.write(chunk)
+        written += len(chunk)
+        left -= len(chunk)
+    return written
+
+
+def _stream_quantize(fin, fout, ti, abs_offset, kind, imatrix_data, use_hpc):
+    """Quantize one tensor in row chunks. kind: 'q2k' | 'q4' | 'q8'.
+    Returns (n_out_bytes, rmse_or_None, sigma_or_None).
+    """
+    ttype = ti['type']
+    if _src_elem_nbytes(ttype) is None:
+        n = _copy_bytes(fin, fout, abs_offset, ti['data_size'])
+        return n, None, None
+    if ti['n_dims'] < 2 or not ti['dims']:
+        n = _copy_bytes(fin, fout, abs_offset, ti['data_size'])
+        return n, None, None
+
+    d0 = int(ti['dims'][0])
+    n_rows = int(ti['n_elements']) // d0
+    align = QK_K if kind == 'q2k' else 32
+    if d0 % align != 0:
+        raise ValueError(f'{ti["name"]} dim0={d0} not aligned to {align}')
+
+    rows_per = max(1, _chunk_max_elems() // max(d0, 1))
+    total_se = 0.0
+    total_ss = 0.0
+    total_n = 0
+    written = 0
+
+    for r0 in range(0, n_rows, rows_per):
+        r1 = min(n_rows, r0 + rows_per)
+        f32 = _load_rows_f32(fin, abs_offset, ttype, d0, r0, r1)
+        imp = _imat_chunk(ti, imatrix_data, r0, r1, d0)
+        n_valid = int(f32.size)
+        total_ss += float(np.vdot(f32, f32))
+        total_n += n_valid
+
+        if kind == 'q2k':
+            if use_hpc:
+                qbytes, n_blocks = quantize_tensor_q2k_hpc(
+                    f32, opt_mode=2, importance=imp, row_width=d0)
+            else:
+                qbytes, n_blocks = quantize_tensor_q2k(f32)
+            fout.write(qbytes)
+            written += len(qbytes)
+            try:
+                deq = dequant_q2k_fast(qbytes, n_blocks)
+                n_cmp = min(n_valid, len(deq))
+                diff = f32[:n_cmp] - deq[:n_cmp]
+                total_se += float(np.sum(diff ** 2))
+            except Exception:
+                pass
+            del qbytes
+        elif kind == 'q4':
+            n_el = n_valid
+            n_blocks_q4 = n_el // 32
+            lib = _load_hexstate_lib() if use_hpc else None
+            q4_hpc = lib is not None and hasattr(lib, 'hexstate_quantize_tensor_q4_0_hpc')
+            if q4_hpc:
+                output_buf = np.zeros(n_blocks_q4 * 18, dtype=np.uint8)
+                error = ctypes.c_float(0.0)
+                f32_c = np.ascontiguousarray(f32, dtype=np.float32)
+                imat_ptr = None
+                if imp is not None:
+                    imat_c = np.ascontiguousarray(imp, dtype=np.float32)
+                    imat_ptr = imat_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+                lib.hexstate_quantize_tensor_q4_0_hpc(
+                    f32_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                    ctypes.c_int64(n_el),
+                    output_buf.ctypes.data_as(ctypes.c_void_p),
+                    ctypes.byref(error),
+                    imat_ptr,
+                    ctypes.c_int(0),
+                )
+                fout.write(output_buf.tobytes())
+                written += output_buf.size
+                total_se += float(error.value)
+                del output_buf, f32_c
+            else:
+                blocks = f32.reshape(-1, 32)
+                amax = np.max(np.abs(blocks), axis=1)
+                d = amax / 7.0
+                d_safe = np.where(d == 0, 1.0, d)
+                qs = np.clip(np.round(blocks / d_safe[:, None]) + 8, 0, 15).astype(np.uint8)
+                d_fp16 = d.astype(np.float16)
+                out_buf = bytearray(n_blocks_q4 * 18)
+                for b in range(n_blocks_q4):
+                    off = b * 18
+                    struct.pack_into('<e', out_buf, off, float(d_fp16[b]))
+                    for j in range(16):
+                        out_buf[off + 2 + j] = int(qs[b, j]) | (int(qs[b, j + 16]) << 4)
+                fout.write(bytes(out_buf))
+                written += len(out_buf)
+        else:
+            n_el = n_valid
+            n_blocks_q8 = n_el // 32
+            lib = _load_hexstate_lib() if use_hpc else None
+            if lib is not None and hasattr(lib, 'hexstate_quantize_tensor_q8_0_hpc'):
+                output_buf = np.zeros(n_blocks_q8 * 34, dtype=np.uint8)
+                error = ctypes.c_float(0.0)
+                f32_c = np.ascontiguousarray(f32, dtype=np.float32)
+                imat_ptr = None
+                if imp is not None:
+                    imat_c = np.ascontiguousarray(imp, dtype=np.float32)
+                    imat_ptr = imat_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+                lib.hexstate_quantize_tensor_q8_0_hpc(
+                    f32_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                    ctypes.c_int64(n_el),
+                    output_buf.ctypes.data_as(ctypes.c_void_p),
+                    ctypes.byref(error),
+                    imat_ptr,
+                    ctypes.c_int(0),
+                )
+                fout.write(output_buf.tobytes())
+                written += output_buf.size
+                total_se += float(error.value)
+                del output_buf, f32_c
+            else:
+                q8_bytes, _, sse8 = quantize_tensor_q8_0(f32)
+                fout.write(q8_bytes)
+                written += len(q8_bytes)
+                total_se += float(sse8)
+        del f32
+
+    rmse = float(np.sqrt(total_se / max(total_n, 1))) if total_n else None
+    sigma = float(np.sqrt(total_ss / max(total_n, 1))) if total_n else None
+    return written, rmse, sigma
+
+
 def should_quantize(name, n_dims, dims, tied_embeddings=False):
     """Should this tensor be quantized to Q2_K?
 
@@ -1345,9 +981,7 @@ def should_quantize(name, n_dims, dims, tied_embeddings=False):
 def main():
     if len(sys.argv) < 3:
         print("Usage: python3 hexstate_requantize.py <input.gguf> <output.gguf>"
-              " [--keep-metadata] [--imatrix FILE] [--keep-embd] [--q2all]"
-              " [--fold-basis] [--no-fold-interleave]")
-        print("  Fold interleave is ON by default (in-block Q2_K layout, no extra tensors).")
+              " [--keep-metadata] [--imatrix FILE] [--keep-embd] [--q2all]")
         print("  HEX_CHUNK_ELEMS  max f32 elements per tensor chunk (default 2000000)")
         sys.exit(1)
 
@@ -1356,9 +990,7 @@ def main():
     keep_metadata = '--keep-metadata' in sys.argv
     quantize_none = '--quantize-none' in sys.argv
     q2all = '--q2all' in sys.argv
-    keep_embd = '--keep-embd' in sys.argv
-    fold_basis = '--fold-basis' in sys.argv
-    fold_interleave = '--no-fold-interleave' not in sys.argv
+    keep_embd = '--keep-embd' in sys.argv   # keep tied embedding at source precision instead of Q8_0
 
     # Check for imatrix
     imatrix_data = None
@@ -1381,17 +1013,13 @@ def main():
     print("  ║  GGUF → Q2_K GGUF with metadata passthrough                  ║")
     if q2all:
         print("  ║  Mode: --q2all  ALL eligible tensors → Q2_K (test mode)      ║")
-    if fold_interleave:
-        print("  ║  Fold-interleave: ON  (in-block Q2_K, same file size)        ║")
-    if fold_basis:
-        print("  ║  Fold-basis: ON  (shared dim perm, optional)                 ║")
-    print(f"  ║  Chunk: {_chunk_max_elems():<7d} f32 elems/tensor (HEX_CHUNK_ELEMS)     ║")
     if use_hpc and imatrix_data:
         print("  ║  Engine: HPC + iMatrix (calibrated sensitivity propagation)  ║")
     elif use_hpc:
         print("  ║  Engine: HPC (BP + MSE Grid + Sensitivity Propagation)       ║")
     else:
         print("  ║  Engine: Python (numpy vectorized)                           ║")
+    print(f"  ║  Chunk: {_chunk_max_elems():<7d} f32 elems/tensor (HEX_CHUNK_ELEMS)     ║")
     print("  ╚════════════════════════════════════════════════════════════════╝")
     print()
 
@@ -1452,10 +1080,6 @@ def main():
         print(f"  Data section starts at: {data_section_start:,}")
         print()
 
-        fb_perms = {}
-        if fold_basis:
-            fb_perms = _fb_prepass(fin, tensor_infos, data_section_start)
-
         # ── Detect tied embeddings ──
         # If no separate output.weight tensor exists, token_embd.weight
         # doubles as the LM head. Must preserve it at full precision.
@@ -1677,8 +1301,8 @@ def main():
             # Header
             fout.write(struct.pack('<I', GGUF_MAGIC))
             fout.write(struct.pack('<I', GGUF_VERSION))
-            fout.write(struct.pack('<Q', len(out_tensor_infos)))
-            fout.write(struct.pack('<Q', len(updated_kv)))
+            fout.write(struct.pack('<Q', n_tensors))
+            fout.write(struct.pack('<Q', n_kv))
 
             # KV pairs (passthrough)
             for key, vtype, raw_value in updated_kv:
@@ -1725,45 +1349,39 @@ def main():
 
                 if plan == 'EMBD_Q8':
                     nbytes, rmse, sigma = _stream_quantize(
-                        fin, fout, ti, abs_offset, 'q8', fb_perms,
-                        imatrix_data, use_hpc)
+                        fin, fout, ti, abs_offset, 'q8', imatrix_data, use_hpc)
                     if rmse is not None:
-                        print(f"\n  [Q8_0·Sieve] {ti['name']} RMSE={rmse:.6e}  σ={sigma:.4f}  rel={rmse/max(sigma,1e-30):.4f}")
+                        print(f"\n  [Q8_0·Sieve] {ti['name']} RMSE={rmse:.6e}"
+                              f"  σ={sigma:.4f}  rel={rmse / max(sigma, 1e-30):.4f}")
                     quant_count += 1
                     total_quant_bytes += nbytes
 
                 elif plan in ('Q4_0', 'Q4_HPC'):
                     q4_hpc = (plan == 'Q4_HPC' and use_hpc)
                     nbytes, rmse, sigma = _stream_quantize(
-                        fin, fout, ti, abs_offset, 'q4', fb_perms,
-                        imatrix_data, q4_hpc)
+                        fin, fout, ti, abs_offset, 'q4', imatrix_data, q4_hpc)
                     tag = 'Q4_0·HPC' if q4_hpc else 'Q4_0'
                     if rmse is not None:
-                        print(f"\n  [{tag}] {ti['name']} RMSE={rmse:.6e}  σ={sigma:.4f}  rel={rmse/max(sigma,1e-30):.4f}")
+                        print(f"\n  [{tag}] {ti['name']} RMSE={rmse:.6e}"
+                              f"  σ={sigma:.4f}  rel={rmse / max(sigma, 1e-30):.4f}")
                     quant_count += 1
                     total_quant_bytes += nbytes
 
                 elif plan:
                     nbytes, rmse, sigma = _stream_quantize(
-                        fin, fout, ti, abs_offset, 'q2k', fb_perms,
-                        imatrix_data, use_hpc,
-                        fold_interleave=fold_interleave)
+                        fin, fout, ti, abs_offset, 'q2k', imatrix_data, use_hpc)
                     if rmse is not None:
                         q2k_rmse_sum += rmse
                         q2k_tensor_count += 1
-                        tag = '·Fold' if fold_interleave else ''
-                        print(f"\n  [Q2_K{tag}] {ti['name'][:50]}  RMSE={rmse:.6e}  σ={sigma:.4f}  rel={rmse/max(sigma,1e-30):.4f}")
+                        print(f"\n  [Q2_K] {ti['name'][:50]}  RMSE={rmse:.6e}"
+                              f"  σ={sigma:.4f}  rel={rmse / max(sigma, 1e-30):.4f}")
                     else:
                         print(f"\n  [Q2_K] {ti['name'][:55]}  RMSE=n/a")
                     quant_count += 1
                     total_quant_bytes += nbytes
-                    pad = align_offset(fout.tell()) - fout.tell()
-                    if pad > 0:
-                        fout.write(b'\x00' * pad)
-                    continue
 
                 else:
-                    nbytes = _stream_keep(fin, fout, ti, abs_offset, fb_perms)
+                    nbytes = _copy_bytes(fin, fout, abs_offset, ti['data_size'])
                     total_keep_bytes += nbytes
 
                 # Alignment padding