Replace Shor's with accelerated sieve

hexstate_quantize.c

@@ -19,7 +19,9 @@
  * ─────────────────────────────────────────────────
  * HPCGraph + CZ edges       →  Block sensitivity graph
  * Complex Amplitude BP      →  Importance propagation
- * MCMC period sampler       →  Optimal scale search
+ * SIEVE sequential selector →  Optimal scale search (replaces Shor
+ *   (log-sieve + parity       Griffiths-Niu IDFT6 measurement;
+ *    back-action)              see sieve_measure_graph)
  * try_period() validation   →  Error bound checking
  * LLL lattice reduction     →  (future) Adaptive bit allocation
  *
@@ -648,7 +650,7 @@ static int is_attention_tensor(const char *gguf_name)
  *
  * Nothing in the live pipeline calls the legacy BP sensitivity graph
  * (build_sensitivity_graph + compute_block_error_q2k + SCALE_TABLE) or the
- * llm-compressor MSE grid search (mse_grid_search_q2k_subblock); the Shor /
+ * llm-compressor MSE grid search (mse_grid_search_q2k_subblock); the sieve /
  * Viterbi path superseded them. They are preserved behind this flag instead
  * of silently shipping as dead code that still costs an init pass.
  * ════════════════════════════════════════════════════════════════════════ */
@@ -675,7 +677,7 @@ static void init_scale_table(void) {
 /* ═══════════════════════════════════════════════════════════════════════════
  * THREAD-LOCAL HPCGRAPH REUSE — Eliminates 776K malloc/free cycles
  *
- * The sub-block Shor measurement uses a 16-node linear-chain graph that
+ * The sub-block sieve selection uses a 16-node linear-chain graph that
  * is identical in topology every time. Instead of hpc_create()/hpc_destroy()
  * inside the OMP hot loop, we reset the same graph to a clean state.
  *
@@ -1209,14 +1211,10 @@ static float hpc_make_qp_quants(int n, int nmax, const float *x,
  * (HPC_W6_RE / HPC_W6_IM) — the file-local duplicates were unused. */
 static const double INV_SQRT6 = 0.40824829046386301637;  /* 1/√6 */
 
-/* ── Collapse + Back-Action core (ported from tesseract_factor.c) ──
- * After sampling an outcome, collapse the target site to |outcome⟩,
- * absorb all edge weights into neighbor local states (Magic Pointer
- * disentanglement), and remove dead edges from the graph.
- *
- * This is the EXACT same back-action protocol used in Shor's algorithm
- * for the semi-classical QFT: measurement of one site conditions all
- * remaining sites through the CZ phase correlations. */
+/* ── Collapse + Back-Action core (SUPERSEDED by sieve_collapse_site) ──
+ * Kept for reference. Previously: the back-action protocol from Shor's
+ * algorithm for the semi-classical QFT. The sieve path uses real-only
+ * parity back-action instead (no complex CZ phases). */
 static void shor_collapse_site(HPCGraph *graph, int target_site, int outcome)
 {
     /* Step 1: Collapse local state to |outcome⟩ */
@@ -1286,22 +1284,8 @@ static void shor_collapse_site(HPCGraph *graph, int target_site, int outcome)
 }
 
 /* ═══════════════════════════════════════════════════════════════════════════
- * SHOR SEQUENTIAL MEASUREMENT — Griffiths-Niu Protocol for Quantization
- *
- * Ported 1:1 from tesseract_factor.c lines 2343-2500.
- *
- * Measures sites MSB→LSB. For each site k:
- * 1. Compute feed-forward phase correction θ_k from previously measured sites
- * 2. Compute neighbor contribution C_k(d) analytically
- * 3. Bake C_k into locals
- * 4. Apply phase correction: α(d) *= e^{-2πi d θ_k}
- * 5. Apply IDFT6: β(v) = (1/√6) Σ_d α'(d) × e^{2πi dv/6}
- * 6. Compute |β(v)|² as measurement probabilities
- * 7. Sample/argmax → outcome
- * 8. Collapse + back-action via shor_collapse_site()
- *
- * Returns: marginals are written into marg_out[n_sites][6].
- * measured_out[n_sites] receives the measurement outcomes.
+ * SHOR SEQUENTIAL MEASUREMENT — Griffiths-Niu Protocol (SUPERSEDED)
+ * Kept for reference only; all call sites now use sieve_measure_graph.
  * ═══════════════════════════════════════════════════════════════════════════ */
 static void shor_measure_graph(HPCGraph *graph, int64_t n_sites,
                                 double (*marg_out)[6], int *measured_out,
@@ -1453,6 +1437,204 @@ static void shor_measure_graph(HPCGraph *graph, int64_t n_sites,
     }
 }
 
+/* ══════════════════════════════════════════════════════════════��════════════
+ * SIEVE SEQUENTIAL MEASUREMENT (replaces Shor Griffiths-Niu above)
+ *
+ * Ported concepts from sieve.py (SLAB quadratic sieve):
+ *  - column-first pass: per-bin progressions, O(sites*degree) real ops,
+ *    no per-site complex IDFT6 (cf. sieve 85x fewer trial divisions;
+ *    cf. sieve Gamma lesson: no dense BxB matmul on the fast path).
+ *  - smoothness filter: keep bins within SIEVE_LOG_SLACK of the best
+ *    log-score (cf. sieve.py LOG_SLACK over the log sieve).
+ *  - parity back-action: collapsing site k to |outcome> multiplicatively
+ *    biases still-unmeasured neighbors AWAY from the same bin
+ *    (SIEVE_SAME_PENALTY < 1). Equal-bin runs keep DC/vesica error
+ *    in phase; diverse bins cancel in the dot product — the real-domain
+ *    analogue of sieve parity vectors whose F_2 kernel marks
+ *    error-cancelling sets.
+ *
+ * What was dropped vs shor_measure_graph:
+ *  - feed-forward phase theta_k (semi-classical QFT correction),
+ *  - coherent complex neighbor product C_k(d),
+ *  - in-place IDFT6 interference transform,
+ *  - complex CZ phase absorption in the collapse.
+ * What was kept: single-pass MSB->LSB order, Boltzmann-encoded locals,
+ * real back-action conditioning, same output signature so the beam
+ * search / Viterbi / sub-block consumers are untouched.
+ * ═══════════════════════════════════════════════════════════════════════════ */
+
+#define SIEVE_SAME_PENALTY 0.85   /* anti-correlation: same-bin discount  */
+#define SIEVE_LOG_SLACK    1.5    /* log-domain slack, cf. sieve LOG_SLACK */
+
+static void sieve_collapse_site(HPCGraph *graph, int target_site, int outcome)
+{
+    /* Step 1: Collapse local state to |outcome> (real one-hot). */
+    for (int v = 0; v < 6; v++) {
+        graph->locals[target_site].edge_re[v] = (v == outcome) ? 1.0 : 0.0;
+        graph->locals[target_site].edge_im[v] = 0.0;
+    }
+    graph->locals[target_site].primary = VIEW_EDGE;
+    graph->locals[target_site].dirty = DIRTY_VERTEX | DIRTY_DIAGONAL | DIRTY_FOLDED;
+    graph->locals[target_site].delta_valid = 0;
+
+    /* Step 2: Real back-action. Neighbor bin d gets multiplied by
+     * SIEVE_SAME_PENALTY when d == outcome, 1.0 otherwise, then the
+     * neighbor is renormalized to unit norm. No complex phases. */
+    HPCAdjList *adj = &graph->adj[target_site];
+    for (uint64_t ei = 0; ei < adj->count; ei++) {
+        uint64_t eid = adj->edge_ids[ei];
+        HPCEdge *edge = &graph->edges[eid];
+        if (edge->fidelity < 0.0) continue;  /* skip dead edges */
+        uint64_t partner = (edge->site_a == (uint64_t)target_site) ?
+                            edge->site_b : edge->site_a;
+
+        TrialityQuhit *pq = &graph->locals[partner];
+        double norm2 = 0.0;
+        for (int d = 0; d < 6; d++) {
+            double f = (d == outcome) ? SIEVE_SAME_PENALTY : 1.0;
+            pq->edge_re[d] *= f;
+            pq->edge_im[d] *= f;
+            norm2 += pq->edge_re[d] * pq->edge_re[d]
+                   + pq->edge_im[d] * pq->edge_im[d];
+        }
+        if (norm2 > 1e-30) {
+            double inv = 1.0 / sqrt(norm2);
+            for (int d = 0; d < 6; d++) {
+                pq->edge_re[d] *= inv;
+                pq->edge_im[d] *= inv;
+            }
+        }
+        pq->dirty = DIRTY_VERTEX | DIRTY_DIAGONAL | DIRTY_FOLDED;
+        pq->delta_valid = 0;
+    }
+
+    /* Step 3: Remove edges touching this site (same bookkeeping as Shor). */
+    for (uint64_t ei = 0; ei < adj->count; ei++) {
+        uint64_t eid = adj->edge_ids[ei];
+        HPCEdge *edge = &graph->edges[eid];
+        uint64_t partner = (edge->site_a == (uint64_t)target_site) ?
+                            edge->site_b : edge->site_a;
+
+        HPCAdjList *padj = &graph->adj[partner];
+        for (uint64_t pi = 0; pi < padj->count; pi++) {
+            if (padj->edge_ids[pi] == eid) {
+                padj->edge_ids[pi] = padj->edge_ids[--padj->count];
+                break;
+            }
+        }
+        edge->fidelity = -1.0; /* Mark as dead */
+    }
+    adj->count = 0;
+}
+
+/* Drop-in signature match for shor_measure_graph. */
+static void sieve_measure_graph(HPCGraph *graph, int64_t n_sites,
+                                double (*marg_out)[6], int *measured_out,
+                                int deterministic)
+{
+    /* MSB->LSB to preserve downstream order assumptions. */
+    for (int64_t k = n_sites - 1; k >= 0; k--) {
+        int site_k = (int)k;
+
+        /* Step 1: local distribution from |amplitude|^2. */
+        double p0[6], total0 = 0.0;
+        for (int d = 0; d < 6; d++) {
+            p0[d] = graph->locals[site_k].edge_re[d] * graph->locals[site_k].edge_re[d]
+                  + graph->locals[site_k].edge_im[d] * graph->locals[site_k].edge_im[d];
+            total0 += p0[d];
+        }
+        if (total0 > 1e-30) {
+            for (int d = 0; d < 6; d++) p0[d] /= total0;
+        } else {
+            for (int d = 0; d < 6; d++) p0[d] = 1.0 / 6.0;
+        }
+
+        /* Step 2: column-first real neighbor bias. For each bin d,
+         * bias[d] = prod over live neighbors of
+         *   sum_w q_j[w] * (w == d ? SIEVE_SAME_PENALTY : 1).
+         * Done in log domain so the slack filter is exact. */
+        double log_score[6];
+        for (int d = 0; d < 6; d++)
+            log_score[d] = log(p0[d] + 1e-30);
+
+        const HPCAdjList *adj = &graph->adj[site_k];
+        for (uint64_t ei = 0; ei < adj->count; ei++) {
+            uint64_t eid = adj->edge_ids[ei];
+            const HPCEdge *edge = &graph->edges[eid];
+            if (edge->fidelity < 0.0) continue;
+            uint64_t partner = (edge->site_a == (uint64_t)site_k) ?
+                                edge->site_b : edge->site_a;
+
+            const TrialityQuhit *pq = &graph->locals[partner];
+            double q[6], qt = 0.0;
+            for (int w = 0; w < 6; w++) {
+                q[w] = pq->edge_re[w] * pq->edge_re[w]
+                     + pq->edge_im[w] * pq->edge_im[w];
+                qt += q[w];
+            }
+            if (qt > 1e-30) {
+                for (int w = 0; w < 6; w++) q[w] /= qt;
+            } else {
+                for (int w = 0; w < 6; w++) q[w] = 1.0 / 6.0;
+            }
+            for (int d = 0; d < 6; d++) {
+                double mix = 0.0;
+                for (int w = 0; w < 6; w++)
+                    mix += q[w] * ((w == d) ? SIEVE_SAME_PENALTY : 1.0);
+                log_score[d] += log(mix + 1e-30);
+            }
+        }
+
+        /* Step 3: smoothness filter — bins further than SIEVE_LOG_SLACK
+         * below the best log-score get zeroed (sieve LOG_SLACK analog). */
+        double best = log_score[0];
+        for (int d = 1; d < 6; d++)
+            if (log_score[d] > best) best = log_score[d];
+
+        double probs[6], total = 0.0;
+        for (int d = 0; d < 6; d++) {
+            if (best - log_score[d] > SIEVE_LOG_SLACK)
+                probs[d] = 0.0;
+            else
+                probs[d] = exp(log_score[d] - best);
+            total += probs[d];
+        }
+        if (total > 1e-30) {
+            for (int d = 0; d < 6; d++) probs[d] /= total;
+        } else {
+            for (int d = 0; d < 6; d++) probs[d] = 1.0 / 6.0;
+        }
+
+        for (int v = 0; v < 6; v++)
+            marg_out[k][v] = probs[v];
+
+        /* Step 4: outcome selection (MAP for quantization). */
+        int outcome;
+        if (deterministic) {
+            outcome = 0;
+            double max_p = probs[0];
+            for (int v = 1; v < 6; v++) {
+                if (probs[v] > max_p) { max_p = probs[v]; outcome = v; }
+            }
+        } else {
+            static unsigned int sieve_rng = 271828;
+            sieve_rng = sieve_rng * 1664525u + 1013904223u;
+            double r01 = (double)(sieve_rng >> 8) / 16777216.0;
+            double cumul = 0.0;
+            outcome = 5;
+            for (int v = 0; v < 6; v++) {
+                cumul += probs[v];
+                if (r01 <= cumul) { outcome = v; break; }
+            }
+        }
+
+        measured_out[k] = outcome;
+
+        /* Step 5: real collapse + back-action. */
+        sieve_collapse_site(graph, site_k, outcome);
+    }
+}
+
 /* ═══════════════════════════════════════════════════════════════════════════
  * HPC-OPTIMIZED Q4_0 QUANTIZATION (for attention tensors)
  *
@@ -1766,14 +1948,14 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
             for (int64_t i = 0; i < graph_blocks - 1; i++)
                 hpc_cz(graph, i, i + 1);
 
-            /* ── Shor's Griffiths-Niu Sequential Measurement ──
-             * Replaces BP with exact marginals via IDFT6 + feed-forward +
-             * collapse/back-action (ported 1:1 from tesseract_factor.c).
+            /* ── Sieve sequential selection ──
+             * Replaces Shor/BP with real-domain log-sieve + parity
+             * back-action (see sieve_measure_graph).
              * Single pass, no iteration, no message damping. */
             double (*marg)[6] = (double (*)[6])calloc(graph_blocks, sizeof(double[6]));
             int *shor_measured = (int *)calloc(graph_blocks, sizeof(int));
 
-            shor_measure_graph(graph, graph_blocks, marg, shor_measured, 1);
+            sieve_measure_graph(graph, graph_blocks, marg, shor_measured, 1);
 
             free(shor_measured);
 
@@ -2248,12 +2430,12 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
 }
 
 /* ════════════════════════════════════════════════════════════════════════
- * Q8_0 HPC QUANTIZER — Shor pipeline at 8 bits
+ * Q8_0 HPC QUANTIZER — Sieve pipeline at 8 bits
  *
  * Same pipeline as Q4_0: WLS scale + tight candidate grid scored on the
  * extended objective (weighted SSE + DC + vesica/wave), triality-quhit
  * graph with Boltzmann-encoded candidate errors, CZ chain entanglement,
- * Shor Griffiths-Niu sequential measurement for bin consensus, greedy
+ * sieve sequential selection for bin consensus, greedy
  * override (HEX_GREEDY_OVERRIDE_RATIO), then per-block ULP polish, the
  * vesica/DC error-shaping descent with an extended-objective guard, and
  * the candidate floor. Intended for embedding / LM-head tensors (tied
@@ -2363,7 +2545,7 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
         best_candidate[blk] = 11;   /* ×1.0000 neutral seed */
     }
 
-    /* ── Phase 3: Shor graph — triality quhits, CZ chain, GN measurement ── */
+    /* ── Phase 3: Sieve graph — sequential selector, CZ chain ── */
     int shor_ran = 0;
     if (n_blocks >= 2) {
         int64_t graph_blocks = (n_blocks > 200) ? 200 : n_blocks;
@@ -2435,9 +2617,9 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
             double (*marg)[6] = (double (*)[6])calloc(graph_blocks, sizeof(double[6]));
             int *measured = (int *)calloc(graph_blocks, sizeof(int));
             if (marg && measured) {
-                shor_measure_graph(graph, graph_blocks, marg, measured, 1);
+                sieve_measure_graph(graph, graph_blocks, marg, measured, 1);
 
-                /* Per-block selection: best candidate inside the Shor-
+                /* Per-block selection: best candidate inside the sieve-
                  * measured bin, then greedy override against the global
                  * argmin — identical Step-F semantics to Q2_K/Q4_0. */
                 for (int64_t i = 0; i < graph_blocks; i++) {
@@ -2880,7 +3062,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
     }
 
     /* ══════════════════════════════════════════════════════════════════
-     * PHASE 3: HPC Graph — Shor's Griffiths-Niu Measurement
+     * PHASE 3: HPC Graph — Sieve Sequential Selection
      * ══════════════════════════════════════════════════════════════════ */
 
     int *best_candidate = (int *)malloc(n_blocks * sizeof(int));
@@ -3003,7 +3185,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
             double (*shor_marg)[6] = (double (*)[6])calloc(n_sites, sizeof(double[6]));
             int *shor_measured = (int *)calloc(n_sites, sizeof(int));
 
-            shor_measure_graph(graph, n_sites, shor_marg, shor_measured, 1);
+            sieve_measure_graph(graph, n_sites, shor_marg, shor_measured, 1);
 
             double (*coarse_marg)[6] = (double (*)[6])calloc(graph_blocks, sizeof(double[6]));
             double (*fine_marg)[6]   = (double (*)[6])calloc(graph_blocks, sizeof(double[6]));
@@ -3022,15 +3204,15 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
              * PHASE 3 — DETERMINISTIC VITERBI DP
              *
              * Replaces the probabilistic beam-search + Born-rule Monte-Carlo
-             * shots with an exact, fully-deterministic DP over the 36-state
-             * Shor quhit space (6 coarse bins × 6 fine bins).
+              * shots with an exact, fully-deterministic DP over the 36-state
+              * sieve quhit space (6 coarse bins × 6 fine bins).
              *
              * For each graph block i and combined state s = qi_d*6 + qi_m:
              *
              *   bin_best_err[i][s]  = min candidate error in that (d,m)-bin
              *                         aggregated over the stride group
-             *   bin_log_prior[i][s] = log P_coarse(qi_d) + log P_fine(qi_m)
-             *                         from Shor marginals → HPC prior bonus
+              *   bin_log_prior[i][s] = log P_coarse(qi_d) + log P_fine(qi_m)
+              *                         from sieve marginals → HPC prior bonus
              *
              * Local Viterbi cost (lower = better):
              *   vcost[i][s] = bin_best_err[i][s]
@@ -3098,7 +3280,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                         }
                     }
 
-                    /* HPC log-prior from Shor marginals */
+                    /* HPC log-prior from sieve marginals */
                     for (int v = 0; v < 6; v++) {
                         c_tot += coarse_marg[vit_gi][v];
                         f_tot += fine_marg  [vit_gi][v];
@@ -3364,7 +3546,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
          * DC residual (written by the sequential Phase 3.9 pre-pass). */
         float dc_adj = (block_dc_bias) ? block_dc_bias[blk] : 0.0f;
 
-        /* Adjusted weight view — WLS and Shor work on this array;
+        /* Adjusted weight view — WLS and sieve work on this array;
          * the final error is always reported against the original block_x. */
         float adj_block_x[QK_K];
         {
@@ -3470,7 +3652,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                 memset(sub_marg, 0, sizeof(sub_marg));
                 memset(sub_measured, 0, sizeof(sub_measured));
 
-                shor_measure_graph(sg, N_SUB, sub_marg, sub_measured, 1);
+                sieve_measure_graph(sg, N_SUB, sub_marg, sub_measured, 1);
 
                 for (int j = 0; j < N_SUB; j++) {
                     double best_prob = -1.0;
@@ -4334,7 +4516,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
             fidelity_icon = "★☆☆☆";
         }
 
-        printf("\n  ┌──── Shor Measurement Q2_K Report ────────────────────────────────┐\n");
+        printf("\n  ┌──── Sieve Selection Q2_K Report ──────────────────────────────────┐\n");
         printf("  │  Elements:      %-12lld  Blocks:     %-12lld          │\n",
                (long long)n_elements, (long long)(n_elements / QK_K));
         printf("  │  Weight σ:      %-12.4e  Range: [%.4e, %.4e]   │\n",
@@ -4344,7 +4526,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                rmse, rmse_over_sigma);
         printf("  │  Fidelity:      %s %-14s                        │\n",
                fidelity_icon, fidelity_class);
-        printf("  │  Engine:        Shor Griffiths-Niu (IDFT6 + feed-forward)       │\n");
+        printf("  │  Engine:        Sieve sequential (log-sieve + parity)           │\n");
         printf("  └─────────────────────────────────────────────────────────────────┘\n");
     }
 }
@@ -4656,7 +4838,7 @@ static int write_gguf(const char *output_path, const STMultiFile *mf,
             else                       fid = "★☆☆☆ STD";
 
             if (verbose) {
-                printf("\n  [Q2_K·Shor] %-47s\n", gguf_names[i]);
+                printf("\n  [Q2_K·Sieve] %-47s\n", gguf_names[i]);
                 printf("         %10ld elements → %ld bytes  σ=%.2e  RMSE=%.4e  %s\n",
                        (long)ti->n_elements,
                        (long)(n_blocks * sizeof(BlockQ2K)),
@@ -4731,7 +4913,7 @@ static int write_gguf(const char *output_path, const STMultiFile *mf,
             else                       fid4 = "★☆☆☆ STD";
 
             if (verbose) {
-                printf("\n  [Q4_0·Shor] %-47s\n", gguf_names[i]);
+                printf("\n  [Q4_0·Sieve] %-47s\n", gguf_names[i]);
                 printf("         %10ld elements → %ld bytes  σ=%.2e  RMSE=%.4e  %s\n",
                        (long)ti->n_elements,
                        (long)(n_blocks_q4 * sizeof(BlockQ4_0)),
@@ -4820,12 +5002,12 @@ static int write_gguf(const char *output_path, const STMultiFile *mf,
     else                             { overall_fid = "STANDARD";        overall_icon = "★☆☆☆"; }
 
     printf("\n  ╔════════════════════════════════════════════════════════════════╗\n");
-    printf("  ║  SHOR-OPTIMIZED QUANTIZATION SUMMARY                          ║\n");
+    printf("  ║  SIEVE-OPTIMIZED QUANTIZATION SUMMARY                           ║\n");
     printf("  ╠════════════════════════════════════════════════════════════════╣\n");
     printf("  ║                                                              ║\n");
-    printf("  ║  Engine:         Griffiths-Niu Sequential Measurement        ║\n");
-    printf("  ║  Protocol:       IDFT6 → feed-forward → Born → collapse      ║\n");
-    printf("  ║  Origin:         tesseract_factor.c (Shor's algorithm)       ║\n");
+    printf("  ║  Engine:         Sieve Sequential Selection                    ║\n");
+    printf("  ║  Protocol:       log-sieve → slack filter → parity collapse   ║\n");
+    printf("  ║  Origin:         sieve.py (SLAB quadratic sieve)               ║\n");
     printf("  ║                                                              ║\n");
     printf("  ╠════════════════════════════════════════════════════════════════╣\n");
     printf("  ║  Tensors quantized:      %-33d  ║\n", quant_count);
@@ -4988,10 +5170,10 @@ int main(int argc, char **argv)
     printf("\n");
     printf("  ���════════════════════════════════════════════════════════════════╗\n");
     printf("  ║                                                              ║\n");
-    printf("  ║   HExState GGUF QUANTIZER v3.0 — Shor-Optimized             ║\n");
+    printf("  ║   HExState GGUF QUANTIZER v3.0 — Sieve-Optimized              ║\n");
     printf("  ║                                                              ║\n");
     printf("  ║   Architecture: HPCGraph Sensitivity Propagation             ║\n");
-    printf("  ║   Optimization: Shor's Griffiths-Niu Measurement + iMatrix  ║\n");
+    printf("  ║   Optimization: Sieve Sequential Selection + iMatrix         ║\n");
     printf("  ║   Output: GGUF v3 (Q2_K, 2.625 bpw)                        ║\n");
     printf("  ║                                                              ║\n");
     printf("  ║   \"The weight and the quantized are opposite faces.\"         ║\n");

hexstate_requantize.py

@@ -70,7 +70,7 @@ def _load_hexstate_lib():
             ctypes.c_int,                     # verbose
         ]
 
-        # Q8_0 HPC quantizer (Shor pipeline; tied embeddings / LM head)
+        # Q8_0 HPC quantizer (Sieve pipeline; tied embeddings / LM head)
         if hasattr(lib, 'hexstate_quantize_tensor_q8_0_hpc'):
             lib.hexstate_quantize_tensor_q8_0_hpc.restype = None
             lib.hexstate_quantize_tensor_q8_0_hpc.argtypes = [
@@ -657,7 +657,7 @@ def should_quantize(name, n_dims, dims, tied_embeddings=False):
       - altup, laurel — small Gemma-specific tensors
       - token_embd.weight / output.weight — always excluded here.
         When embeddings are TIED, main() routes token_embd.weight to
-        Q8_0 (HPC Shor pipeline) instead: the same tensor serves as both
+        Q8_0 (HPC sieve pipeline) instead: the same tensor serves as both
         embedding lookup AND LM head, and Q2_K/Q4_0 there destroys logit
         precision → looping / repetitive generation. --keep-embd keeps
         it at source precision instead.
@@ -819,7 +819,7 @@ def main():
             if keep_embd:
                 print("  ⚠ Tied embeddings detected — token_embd.weight kept at source precision (--keep-embd)")
             else:
-                print("  ⚠ Tied embeddings detected — token_embd.weight → Q8_0 via Shor pipeline (serves as LM head;")
+                print("  ⚠ Tied embeddings detected — token_embd.weight → Q8_0 via sieve pipeline (serves as LM head;")
                 print("    Q2_K/Q4_0 here destroys logit precision — classic looping-output symptom)")
             print()
 
@@ -839,7 +839,7 @@ def main():
                 # code (should_quantize always returned False for
                 # token_embd), so the tensor was silently kept at F16/BF16.
                 # Now: Q8_0 (8.5 bpw, ~2x smaller than F16) via the HPC
-                # Shor pipeline — transparent for both embedding lookup
+                # Sieve pipeline — transparent for both embedding lookup
                 # and logit projection.
                 will_quant = 'EMBD_Q8'
                 total_embd += 1
@@ -867,7 +867,7 @@ def main():
         else:
             print(f"  Tensors to quantize (Q2_K):     {total_quant}")
             print(f"  Tensors to promote (Q4_0·HPC):  {total_attn}")
-            print(f"  Tied embd → Q8_0 (Shor·HPC):    {total_embd}")
+            print(f"  Tied embd → Q8_0 (Sieve·HPC):   {total_embd}")
             print(f"  Tensors to keep as-is:          {total_keep}")
         print()
 
@@ -885,7 +885,7 @@ def main():
                     out_type = GGML_TYPE_Q8_0
                     n_blocks = ti['n_elements'] // 32
                     out_size = n_blocks * 34
-                    print(f"  [EMBD→Q8_0·Shor] {ti['name']} ({ti['n_elements']:,} elements)")
+                    print(f"  [EMBD→Q8_0·Sieve] {ti['name']} ({ti['n_elements']:,} elements)")
                 elif quant_plan[i] == 'ATTN_Q4':
                     # Attention tensor → Q4_0 HPC (4.5 bpw)
                     out_type = GGML_TYPE_Q4_0
@@ -1077,7 +1077,7 @@ def main():
                 raw_data = fin.read(ti['data_size'])
 
                 if quant_plan[i] == 'EMBD_Q8':
-                    # ── Tied embedding → Q8_0 via the HPC Shor pipeline ──
+                    # ── Tied embedding → Q8_0 via the HPC sieve pipeline ──
                     if ti['type'] == GGML_TYPE_BF16:
                         f32 = bf16_to_f32(raw_data, ti['n_elements'])
                     elif ti['type'] == GGML_TYPE_F16:
@@ -1118,7 +1118,7 @@ def main():
                         )
                         fout.write(output_buf.tobytes())
                         rmse8 = float(np.sqrt(error.value / max(n_el, 1)))
-                        print(f"\n  [Q8_0·Shor] {ti['name']} RMSE={rmse8:.6e}")
+                        print(f"\n  [Q8_0·Sieve] {ti['name']} RMSE={rmse8:.6e}")
                     else:
                         q8_bytes, n_blocks_q8, sse8 = quantize_tensor_q8_0(f32)
                         fout.write(q8_bytes)