Paper deep dive
CurveTQ: Rotation-Free Trellis Quantization of LLM Weights via Curvature-Weighted Search
Guanhua Ding, Zi Wang, Ruichao Li, Jack Liu
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 10/8/2026, 7:16:05 AM
Summary
CurveTQ is a rotation-free trellis quantization method for Large Language Model (LLM) weights that improves upon existing methods like QTIP and Proteus. It utilizes the diagonal of the Hessian's LDL factorization as curvature weights in the Viterbi branch metric, eliminating the need for random orthogonal rotations. CurveTQ employs a factored scale field and a closed-form quantile table to handle weight amplitude and shape, and stores a start state per coding block to adapt to residuals from error feedback. This approach achieves higher downstream accuracy and faster decoding speeds compared to baselines at 2-bit and 3-bit quantization levels.
Entities (13)
Relation Signals (10)
CurveTQ → eliminates → Rotation
confidence 95% · CurveTQ, a trellis codec with no rotation... This also explains the rotation: it removes this within-block variation, so weighting in the native basis and rotating are substitutes.
CurveTQ → improvesupon → QTIP
confidence 95% · At two bits CurveTQ is 1-3 points higher in mean downstream accuracy than QTIP and Proteus...
CurveTQ → improvesupon → Proteus
confidence 95% · At two bits CurveTQ is 1-3 points higher in mean downstream accuracy than QTIP and Proteus...
CurveTQ → uses → Viterbi algorithm
confidence 95% · We put these weights into the Viterbi branch metric, so the search follows the curvature within each coding block.
CurveTQ → appliesto → Llama-2-7B
confidence 90% · We quantize six public checkpoints: Llama-2-7B... On three models the weighted native search matches...
CurveTQ → appliesto → Llama-3-8B
confidence 90% · We quantize six public checkpoints: ... Llama-3-8B...
CurveTQ → appliesto → Qwen3.6-35B-A3B
confidence 90% · It also leads on a 35B mixture of experts... Qwen3.6- 35B-A3B mixture of experts
Proteus → uses → Rotation
confidence 90% · QTIP and Proteus... rotate each weight matrix by a random orthogonal transform...
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:The best two-bit weight quantizers for large language models, such as QTIP and Proteus, rotate each weight matrix by a random orthogonal transform, which must be undone at every decoding step, then encode it with a trellis or lattice code under a Euclidean search; the layer Hessian enters only through error feedback between coding blocks. We show that this leaves part of the Hessian unused. Error feedback turns the loss into a weighted sum of per-coordinate rounding errors whose weights, the diagonal of the Hessian's LDL factorization, existing quantizers compute but never read. We put these weights into the Viterbi branch metric, so the search follows the curvature within each coding block. This also explains the rotation: it removes this within-block variation, so weighting in the native basis and rotating are substitutes. On three models the weighted native search matches a full-dimension randomized Hadamard to within about one point of downstream accuracy, and weighting after the rotation gains little. Around this search we build CurveTQ, a trellis codec with no rotation, which handles the weights' amplitude and marginal shape with a factored scale field and a closed-form quantile table, and stores a start state per coding block so the trellis can adapt to the residual that error feedback carries into it. At two bits CurveTQ is 1-3 points higher in mean downstream accuracy than QTIP and Proteus on three 4-8B Instruct models, even after both are given our start state, which alone lifts either baseline by 1-3 points. It also leads on a 35B mixture of experts, to our knowledge the first trellis-coded result on such a model. With no rotation to undo, our decoder is the fastest of the three at all tested batch sizes and bit widths.
Tags
Links
- Source: https://arxiv.org/abs/2610.09212v1
- Canonical: https://arxiv.org/abs/2610.09212v1
Trouble viewing inline? Open PDF directly →
Full Text
133,141 characters extracted from source content.
Expand or collapse full text
CURVETQ: ROTATION-FREE TRELLIS QUANTIZATION OF LLM WEIGHTS VIA CURVATURE-WEIGHTED SEARCH Guanhua Ding ∗ Zi Wang ∗ Ruichao LiJack Liu Black Sesame Technologies gding2793, zwang84.utk, ruichaoli809@gmail.com, jack.liu@bst.ai ABSTRACT The best two-bit weight quantizers for large language models, such as QTIP and Proteus, share a recipe. Each weight matrix is first rotated by a random orthogonal transform so that its entries look Gaussian, and this rotation has to be undone at every decoding step. The rotated weights are then encoded with a trellis or lattice code under a Euclidean search, and the layer Hessian is used only in the error-feedback step between coding blocks. We show that this recipe leaves part of the Hessian unused. Error feedback turns the loss into a weighted sum of per-coordinate rounding errors, and the weights, the diagonal of the Hessian’s LDL factorization, are computed by existing quantizers but never read. We put these weights into the search’s distance, the Viterbi branch metric, so that the search follows the curvature within each coding block. This also explains what the rotation is for. The rotation removes this within-block variation, so after it the weight has little left to exploit. Weighting in the native basis and rotating are therefore substitutes. We confirm this on three models: the weighted native search matches the baselines’ rotation, a full-dimension randomized Hadamard, to within about one point of downstream accuracy, and weighting after the rotation gains little. Around this search we build CURVETQ, a trellis codec with no rotation. The rotation also flattened the amplitude and the marginal shape of the weights, which we handle directly with a factored scale field and a closed-form quantile table. In either basis, error feedback passes each block’s residual on to the next, so we store a start state per coding block that lets the trellis adapt to it. At two bits CURVETQ is 1–3 points higher in mean downstream accuracy than QTIP and Proteus on three 4–8B Instruct models, even after both are given our start state, which by itself lifts either baseline by 1–3 points. It also leads on a 35B mixture of experts, to our knowledge the first trellis-coded result on such a model. With no rotation to undo, our decoder is the fastest of the three at all tested batch sizes and bit widths. 1INTRODUCTION When a large language model (LLM) generates text one token at a time, the cost of each step is dominated by reading the model’s weights from memory. Storing fewer bits per weight therefore directly translates into faster decoding. At four bits per weight, post-training quantization (PTQ) is by now routine (Frantar et al., 2023; Lin et al., 2024). The open frontier is two to three bits, where quantized models still lose a large amount of accuracy, and where the choice of the code, how groups of weights are jointly mapped to a small set of stored indices, matters more than the choice of the scalar grid (Tseng et al., 2024b; Egiazarian et al., 2024). The strongest two-bit trellis and lattice codecs today follow the same three-step recipe, which we call transform-and- flatten (Figure 1a). First, each weight matrix is rotated by a random orthogonal transform, so that its entries look like independent Gaussian samples (Chee et al., 2023; Tseng et al., 2024a). Second, the rotated weights are encoded with a high-dimensional code, a trellis or a lattice, using a Euclidean search and a Gaussian-shaped reconstruction. Third, the layer Hessian, which says how sensitive the layer output is to an error in each input coordinate, enters only through an error-feedback step between coding blocks (LDLQ). QTIP (Tseng et al., 2024b) is the canonical instance; Proteus (Yang et al., 2026) replaces its lookup table by a computed code but keeps the rotation and the Euclidean search. The recipe has a cost at every decoding step: the rotation has to be undone at inference time, either on the activations or on the weight-decoding path. * Equal contribution. 1 arXiv:2610.09212v1 [cs.LG] 6 Oct 2026 What error feedback leaves unused. It is tempting to think that the feedback step has taken care of the Hessian, so that the search inside a block can safely be Euclidean. In fact, feedback only rearranges the loss of a row into a weighted sum of its per-coordinate rounding errors (Eq. 1). The weights are the diagonal D of the Hessian’s LDL factorization, the same quantity GPTQ divides its residuals by (Chee et al., 2023; Frantar et al., 2023). In the native basis these weights differ by orders of magnitude between input channels, because a few channels carry outlier activations. Yet, to our knowledge, every trellis and lattice quantizer ignores them and minimizes the unweighted error inside the block; QTIP computes their block form as part of its feedback step and never reads it. Our first step is simply to use them. Placed in the Viterbi branch metric, they change neither the code nor the decoder, and, as we show next, they make the rotation unnecessary. Why the rotation then becomes unnecessary. Once the weight is in the search, the random rotation turns out to act on the same quantity. The rotation is meant to make all coordinates look alike, and for the raw Hessian diagonal it does. For the LDL diagonal it does not: Figure 2(a) shows that it turns the jagged native weights into a smooth ramp along the coding order, nearly flat within one 64-column block. A weight that is constant within a block does not change which path the block’s search selects, so after rotation the weighted and the Euclidean search coincide: the rotation removes the structure the weight exploits. Proposition 1 relates the weighted search’s gain over the Euclidean one, in the high-resolution limit, to the within-block variation of these weights, which is large in the native basis and near zero after rotation. Weighting and rotating are therefore substitutes, which Section 4.2 confirms on three models. A rotation also flattens the local amplitude and the marginal shape of the weights; we handle both directly, with a factored group scale and a closed-form quantile table (Section 3.3), so the decoder needs no transform (Figure 1b). What else the block boundary changes. Taking the feedback block seriously has a second consequence, for the trellis termination. Under feedback, the first columns of each block carry the residual pushed forward from the previous block, so the boundary is where the search needs the most freedom. QTIP’s tail-biting trellis ties each tile’s first coordinates to its last, constraining exactly this boundary, and stores no start state; we instead let each block start in any trellis state and store the choice (Section 3.1). The 14 stored bits per block are 0.22 bpw, our largest single component, and not specific to our codec: given to QTIP and Proteus, the same state is worth 1–3 downstream points at two bits. Removing the state costs 2–4 perplexity and 5 downstream points, ten times the cost of a group-scale field of the same size. At decode time it is one load per block, 1–3% of throughput. Contributions. (1) We show that the curvature weight and the random rotation are substitutes: the LDL diagonal in the branch metric exploits what a rotation removes (Sections 3.1–3.2). On three models the weighted native search matches, to within about a point of mean accuracy, the full-dimension rotation QTIP deploys at equal rate (Section 4.2). The loss identity (Chee et al., 2023) and weighted trellis search (Fischer & Wang, 1992) are both known; what is new is that together they make the rotation unnecessary. (2) We replace QTIP’s tail-biting termination by a block-local trellis with a stored start state per block, our largest single rate component and the one that creates the two-bit downstream margin (Sections 3.1, 4.3). It is not specific to our codec: transferred unchanged to QTIP and Proteus, it lifts each by 1–3 points (Section 4.1). (3) Using (1), we build CURVETQ, a rotation-free trellis codec; in the native basis, its per-module quantile table and factored scale field handle the marginal shape and the local amplitude that a rotation would have flattened (Section 3.3). Against QTIP and Proteus given our start state it is 1–3 points higher downstream at two bits on three Instruct models (Section 4.1). It also leads on a 35B mixture of experts, to our knowledge the first trellis-coded result on one; at 32B the start state alone closes most of the baselines’ gap. (4) With no rotation to undo, our decoder is faster than both baselines’ kernels at batch 1 to 128 (Section 4.4). 2RELATED WORK Incoherence processing. QuIP (Chee et al., 2023) introduced random orthogonal preprocessing that makes weights and Hessians incoherent, together with LDLQ, the error-feedback rounding whose loss identity we use (Eq. 1); QuIP# (Tseng et al., 2024a) made the transform a randomized Hadamard and added the E 8 lattice codebook, block LDLQ and a fine-tuning stage. Later work moves rotations into the activation path or makes them data-aware (Ashkboos et al., 2024; Liu et al., 2025b; Sun et al., 2025; Chen et al., 2026a). Our view is that a rotation flattens three separate quantities at once, the local amplitude, the marginal shape and the block-local LDL diagonal, and that each can be flattened explicitly in the native basis. Trellis, lattice and vector codes. Two lines of work are closest to ours. The first is trellis-coded quantization. Its weighted and feedback variants (Marcellin & Fischer, 1990; Fischer & Wang, 1992; Atal & Schroeder, 1979; Eyuboglu & Qureshi, 1988) are classical; QTIP (Tseng et al., 2024b) brought TCQ to LLM weights with the bitshift trellis and two decoders, a lookup code and a computed one. Proteus (Yang et al., 2026) makes the computed code 2 (a) QTIP-style (b) CurveTQ Prepare Emission Encode Decode + GEMM W, H Rotation W 0 W, H 64-group absmax Z ̂ s g : factored scale field i.i.d. Gaussian Gaussian emitter Z empirical CDF F z F −1 z T: 128 × int8 LUT equiprobable quantiles LDLQ target Euclidean Viterbi min ∑ i η 2 i 0101 c Tail-biting, no start bits 2 16 surv. LDLQ target Weighted Viterbi min ∑ i D i η 2 i c g b g ̂ s g Stored start b g : 14 b per 64-column block D i from LDL: encoder only 2 14 surv. 0101 c Gaussian emitter × s ̂ W 0 x R in ̂ W 0 x 0 R T out y b g Load state Edge emitter T c g × ̂ s g ̂ W x ̂ Wx y Schematic CDF offline ⋅ feedback in both Figure 1: Transform-and-flatten (a) versus our recipe (b); schematic, not measured data. The Encode row is the mechanism: the LDL diagonal D, which (a) flattens within each block by rotation, becomes in (b) the weight of the Viterbi branch metric, so the search minimizes P i D i η 2 i rather than P i η 2 i . The rotation’s other two effects are obtained by the factored group scale ˆs g and the quantile table T , and the decoder needs no transform. central and argues from decode bandwidth that a lookup-free trellis is the right target. All of these keep the search Euclidean and confine curvature to the feedback step; Proteus does use a Hessian-weighted objective, but to select its code per layer, not inside the search. The second line is lattice and additive vector quantization (Egiazarian et al., 2024; van Baalen et al., 2024; Liu et al., 2024; Zhang et al., 2025b; van der Ouderaa et al., 2026), which trades decode arithmetic for shaping gain (we compare against trellis codecs only, which decode faster: LLVQ reports its single- shell kernel slightly slower than QTIP’s, and an independent multi-shell implementation measures QTIP’s kernel 2.27× faster (Malandrino, 2026)). This line does optimize an input-weighted error: AQLM’s beam search, and the Hessian-weighted k-means of GPTVQ, VPTQ and SqueezeLLM (Kim et al., 2024). The cost is several dependent codebook reads per weight at decode, where a trellis needs one table read, or none. Our codec is a trellis code that optimizes the weighted objective of vector quantization, at a trellis decoder’s cost. Solvers and side information. GPTQ (Frantar et al., 2023) rounds columns one at a time with Hessian feedback, and its error-normalization constant is the same diagonal D we place in the search. On side information, group scales are universal (Lin et al., 2024; Shao et al., 2024), and storing them on a second, coarser grid goes back to QLoRA and SpQR (Dettmers et al., 2023; 2024); our factored scale field is a structured version of this idea. For mixtures of experts, QMoE (Frantar & Alistarh, 2023) quantizes with one Hessian per expert, which we adopt; no trellis or lattice codec has been reported on such a model. Finally, post-quantization fine-tuning is worth more at two bits than the spread between any two codes (Malinovskii et al., 2024), and QuIP#, QTIP, AQLM and Proteus all publish their headline numbers after such a stage; to isolate the code, we run every method without it (Section 4). Appendix C discusses this literature in more detail. 3METHOD Preliminaries: error feedback and the bitshift trellis. Let W ∈ R R×C be a linear layer with input Hessian H = E[x ⊤ ], damped as H + δI ; all identities below hold for the damped loss. Weight-only PTQ chooses ˆ W to minimize P r e ⊤ r He r , e r = w r − ˆw r . Fix a coding order over the C input coordinates and write H = (I + ̄ U )D(I + ̄ U ) ⊤ . Column-wise feedback quantizes coordinate j against w j + P i<j ̄ U ij e i and defines η j as that target minus ˆw j ; then η = (I + ̄ U ) ⊤ e and e ⊤ He = C X i=1 D i η 2 i (1) 3 holds for any quantizer and any code (Appendix A). Under block feedback with blocks of G = 64 columns (QuIP#’s block LDLQ at our block size), the exact form for the block factor is e ⊤ He = P b η ⊤ b D b η b with D b the Schur complement of the trailing submatrix of H onto block b (our default column factor approximates it; Appendix H): feedback handles the triangular factor, diag(D b ) is additive and is what we place in the search, and the off-diagonal part is omitted. The code. We use QTIP’s bitshift trellis: an L-bit state s t , a k-bit code a t per weight (k ∈ 2, 3, 4), the transition s t+1 = ((s t ≪ k)|a t ) mod 2 L , and a reconstruction from the emission window (Section 3.3); decoding walks the state machine, encoding is a Viterbi search over 2 L states. 3.1CURVATURE-WEIGHTED TRELLIS SEARCH Rows are coded in blocks of G = 64 columns, left to right; the residual of a coded block is propagated onto the not-yet-coded columns through the triangular factor of H . Each block is coded by a Viterbi search that minimizes P ⋆ = arg min P X i∈b ω i ̃z i − T (k i (P )) 2 , ω i = 1 d 2 i ,(2) where ̃z is the feedback-corrected, scale-normalized target of the block, k i (P ) the code index of coordinatei on pathP , T the reconstruction table, and d i the i-th diagonal entry of the Cholesky factor of H −1 (GPTQ’s error-normalization constant). Because Eq. 2 is additive over coordinates, Viterbi minimizes it exactly at unchanged complexity, and the packed format is that of the Euclidean search (ω ≡ 1): the weight changes which path is chosen, not how it is stored. We make two further approximations. First, Eq. 2 keeps only the diagonal of D b and omits the in-block coupling. Second, 1/d 2 i conditions on all columns after i, including in-block columns that block feedback never corrects. Ap- pendix B compares 1/d 2 i , our default, with the feedback-free H i . Block-local trellis with an explicit start state. A trellis code must decide how one coding block’s path relates to the next. We let each block’s Viterbi start in any of the 2 L states and store the chosen state, the boundary-state field b g (the discrete counterpart of the amplitude field s g of Section 3.2), as L bits per (row, block). This boundary adaptation rate, L/G = 14/64 = 0.219 bpw, is counted in every reported rate (Appendix J). The decoder loads the state and walks the block; nothing else changes. QTIP instead codes 256-weight tiles as tail-biting sequences: the first state is a function of the tile’s own last bits, so no start state is stored and the rate is exactly k (Tseng et al., 2024b). That construction is right for a long tile over a rotated, near-i.i.d. source. Under error feedback, however, the block boundary is where the inherited residual lands, and tying the first⌈L/k⌉ coordinates of a 64-column block to its own last ones is the wrong constraint. Section 4.3 compares this choice with tail-biting and chained terminations; Section 4.1 also equips the baselines with it. 3.2WHY THE ROTATION BECOMES UNNECESSARY Factor each weight as w i = s g(i) z i , with s g the scale of its 64-group and z i ∈ [−1, 1]. The block objective Eq. 2 then has three factors at three granularities: the amplitude field s g , the marginal law of z, and the curvature weight D i . A random orthogonal transform flattens all three: block energies concentrate, so one scale per row suffices; the marginal tends to a Gaussian, so a universal emitter fits; and the raw diagonal concentrates, H ′ i → tr(H)/C. The LDL diagonal, however, does not flatten: it becomes a smooth ramp along the coding order (Appendix B). Define the anisotropy of D and its block-local version, in bits per weight, Γ(H) = 1 2 log 2 AM(D) GM(D) ,Γ b (H) = 1 2 log 2 P b tr(D b ) P b G GM(diagD b ) ≥ 0,(3) with equality in Γ b iff diagD b is constant within every block. Proposition 1 (weights and floors). With the feedback rule of Eq. 1: (i) e ⊤ He = P i D i η 2 i for any quantizer. (i) If the residuals have equal second moments E[η 2 i ] = σ 2 —the high-resolution behaviour of a Euclidean search with one alphabet for all coordinates—then E[e ⊤ He] = σ 2 tr(D) ≥ Cσ 2 GM(D) = Cσ 2 det(H) 1/C , with equality iff all D i are equal. (i) The lower bound in (i) is attained, under the high-resolution rate model, by a code whose per-coordinate step is proportional to D −1/2 i (Huang & Schultheiss, 1963; Zador, 1982). Proofs are in Appendix A. In words: within the high-resolution relaxation of (i)–(i), weighting can gain at most Γ(H) over a Euclidean search in a given basis, and a block-local code at most Γ b (H). Since det(RHR ⊤ ) = detH , the floor is the same in every basis; within this relaxation only the Euclidean loss σ 2 tr(D) is not, and that is what a rotation changes. 4 The substitution hypothesis. A Haar or sign-randomized Hadamard rotation turns D ′ i into a smooth ramp from the harmonic to the arithmetic mean of the damped spectrum (Appendix B; checked numerically). Where the ramp is flat across a block, the search weight D ′ i is nearly constant within it, so the two searches nearly coincide: after rotation, weighting is redundant. The converse, that native weighting matches rotation, is not implied by Proposition 1 (Appendix A, Proposition 2); it is a hypothesis about trained LLM Hessians, whose outlier input channels put large block-local anisotropy into the native D, and it predicts that the weighted metric’s gain tracks Γ b natively and vanishes after rotation. Section 4.2 tests both on three models. We therefore keep the basis and the weight, and flatten the amplitude and the marginal shape explicitly (Figure 1b). 3.3CURVETQ: THE ROTATION-FREE CODEC Group scale and quantile table. The scale of a 64-group is its absmax s g , stored on the factored grid described below as ˆs g ≥ s g ; the coder operates on z i = w i /ˆs g , so encoder and decoder share the normalization. Each coded linear layer has its own alphabet of N = 128 int8 values at the equiprobable quantiles of a sample of its normalized weights, indexed by a 7-bit hash of the emission window, with no interpolation at decode. The sample is a deterministic stride over the layer’s 64-groups, so the table is closed-form and the build is a deterministic function of the calibration set. A quantile grid is a heuristic rather than the rate–distortion-optimal reproduction law, but it matches an EM fit of the same 128 entries (Section 4.3). Emission window. QTIP emits from a 16-bit state and searches 2 16 survivors; we instead emit from the edge (s t ,a t ) of a 14-bit state (the same code family, and at k = 2 the same 16-bit window) and search 2 14 . This is the Mealy form (outputs on transitions rather than on states) of QTIP’s node-emitting trellis; an exact Viterbi run confirms identical costs and reconstructions on every tested row, with a quarter of the survivors. Table-free emission. The 128-entry table can be removed altogether: in the table-free variant the reconstruction is computed from the emission window, like QTIP’s 1MAD code, with one global scale in place of the table (details in Appendix I). Nothing else changes, so the difference between the two variants isolates the table (Appendix D). Factored scale field. A fp16 scale per 64 weights costs 0.25 bpw. Second-level quantization stores first-level scales on a low-bit grid with a fp16 constant per block (Dettmers et al., 2023; 2024), treating them as a flat sequence. We treat them instead as a two-dimensional field over rows and column groups, whose row and column-group effects carry much of the variance (about half over the linear layers of Llama-2-7B, by a two-way decomposition log 2 s r,g = μ +α r +β g +ε r,g ). We store ˆs r,g = A r B g ˆ R r,g with fp16 row and column-group factors (geometric means along each axis) and only the residual on a 4-bit linear grid with a fp16 absmax per 256, both rounded up against the stored fp16 factors, so that ˆs ≥ s holds for every group. The cost is 0.068 bpw on Qwen3-4B and 0.067 on Llama-3 (per-term arithmetic in Appendix J), against 0.25 for fp16 scales and 0.125 for int8 second-level quantization. The fp16-scale variant of every build is reported in Appendix D; every rate we report counts all of this side information, the emission table and the start state (Appendix J). Mixture-of-experts models. The codec applies to a mixture of experts unchanged; only the Hessians differ. Fol- lowing QMoE (Frantar & Alistarh, 2023), expert e receives its own H (e) = P t→e x t x ⊤ t over the tokens the router sends it. Under top-8-of-256 routing that is a few thousand tokens for a 2048-dimensional input, so H (e) is often rank-deficient and its LDL diagonal damping-dominated, which leaves the weighted metric close to Euclidean. 4EXPERIMENTS Setup. We quantize six public checkpoints: Llama-2-7B, Llama-3-8B- and Llama-3.1-8B-Instruct (Grattafiori et al., 2024), Qwen3-VL-4B- and -32B-Instruct (Qwen Team, 2025) (Qwen3-4B, Qwen3-32B below) and the Qwen3.6- 35B-A3B mixture of experts, all with the same 128 calibration segments of 2048 tokens from C4 (Raffel et al., 2020); our build is deterministic given the calibration set. QTIP (Tseng et al., 2024b) and Proteus (Yang et al., 2026) run from one trellis/LDLQ implementation at L = 16, each at its published rate and in two strengthened forms, with an added 64-group fp16 scale (x.25 bpw) and with our per-block stored start state (Section 3.1; 2.19–2.22 bpw at two bits, 3.16–3.20 at three), so that the second form carries our start-state side information. Appendix D also gives them both at once, at x.31–x.34 bpw, above ours. HIGGS (Malinovskii et al., 2025) and 64-group GPTQ (Frantar et al., 2023) run at x.25 bpw. Table G.1 gives the per-model protocol. We report WikiText-2 perplexity (Merity et al., 2017) at context 4096 and mean accuracy over a fixed suite (4 to 34 tasks per model; Appendix G) run through one harness 5 Table 1: Perplexity and mean downstream accuracy at two and three bits (four bits in Appendix D); protocol in Section 4. + : published rate plus 0.003 bpw of sign bits; ours include the per-block start state (Appendix J). +start : the baseline with our stored start state, charged net (Appendix J). ∗ Llama-2-7B: ARC-c/ARC-e/PIQA/WinoGrande, 0-shot, the suite of the QTIP and Proteus papers. No method is fine-tuned; Proteus is its discrete solver, without learned scales or distillation. Bold: best in tier. “–”: not run; “×”: no valid outputs. WikiText-2 perplexity↓Downstream accuracy (%)↑ MethodbpwL2-7B Q3-4B L3-8B L3.1-8B Q3-32BL2-7B ∗ Q3-4B L3-8B L3.1-8B Q3-32B fp16165.219.727.686.676.17 66.6 (43.1/76.3/77.7/69.2)62.061.863.270.2 QTIP2.00 + 6.8615.3611.5310.317.21 61.7 (36.0/70.0/75.0/65.7)46.848.849.865.4 Proteus2.00 + 6.7314.2110.9910.027.09 61.8 (35.5/70.0/74.5/67.0)48.048.851.565.0 CurveTQ2.296.4411.509.919.166.9062.9 (38.6/71.6/74.3/67.0)51.853.254.066.3 QTIP +g64 2.25 + 6.7213.7211.1910.037.07 61.6 (35.8/68.9/74.6/67.1)47.948.448.865.0 Proteus +g64 2.25 + 6.7013.9910.8110.056.97 61.6 (36.0/68.7/74.9/66.6)47.348.351.065.8 QTIP +start 2.19 + 6.4913.9910.229.426.93 63.1 (36.7/72.0/75.8/67.9)49.851.150.966.1 Proteus +start 2.22 + 6.3113.159.839.306.88 63.0 (37.3/70.8/75.7/68.2)51.052.152.566.1 HIGGS2.2510.9521.2319.0918.40– 55.8 (28.9/60.7/70.1/63.6)36.840.139.8– GPTQ (g64)2.25156740.75536530– 37.3 (21.5/26.1/52.4/49.3)17.1 × ×– QTIP3.00 + 5.5010.688.307.326.38 65.7 (42.1/75.1/77.0/68.4)58.958.660.269.2 Proteus3.00 + 5.4710.738.157.236.37 65.6 (42.4/75.2/76.6/68.3)59.059.260.069.3 CurveTQ3.295.4210.288.167.096.3265.9 (42.1/75.8/77.5/68.1)60.059.960.969.7 QTIP +start 3.16 + 5.4810.628.127.276.37 65.1 (41.1/74.5/77.7/67.2)59.659.261.269.3 Proteus +start 3.20 + 5.4110.438.167.126.31 66.4 (41.9/76.1/77.3/70.3)60.059.761.269.4 (Gao et al., 2024; Zhang et al., 2025a); main comparisons are paired differences to each baseline over tasks, with bootstrap 95% intervals (Appendix E). 4.1MAIN RESULTS Table 1 reports the trellis methods at two and three bits and, at two bits, HIGGS and GPTQ, which fall far behind the trellis codecs (other rows and baselines in Appendix D; confidence intervals for every difference below in Appendix E). GPTQ is the only other rotation-free row: its scalar grid collapses at two bits, and its gap to our build is what the code is worth without a rotation. Two bits. At 2.29 bpw CURVETQ has lower perplexity than QTIP and Proteus at 2.00 and 2.25 bpw on all four Instruct models. Downstream it leads them by +2.5 to +5.2 points on the three 4- and 8B Instruct models, all twelve contrasts excluding zero, and by +0.5 to +1.3 on Qwen3-32B (Table E.1). The +start rows add our per-block start state to the baselines’ own trellis. It is worth +1.0 to +3.3 points to them, more than the group scale, and it closes the perplexity gap on the Llamas and Qwen3-32B. The downstream margin survives: +0.9 to +3.1 points against QTIP +start and Proteus +start on the three models, five of six contrasts excluding zero. It is concentrated on generative tasks (GSM8K, IFEval), while multiple-choice tasks move by about a point. A 128-group scale on top of the start state changes little: at a rate above ours (2.31–2.34 bpw), the margin is +0.4 to +2.7 points, five of six contrasts excluding zero, and the scale adds little over the start state alone (Appendix D). On Llama-2-7B and Qwen3-32B, where generative tasks lose less, the start state is most of the difference: without it the baselines trail by 1–2 points, with it they come within 0.2 points on both. Our Llama-2-7B QTIP reproduction is within 0.05 perplexity of its paper. Three and four bits. At three bits CURVETQ (3.29 bpw) leads the 3.00-bpw rows downstream on every model. Once the baselines carry our start state (3.16–3.20 bpw) they draw level: CURVETQ is ahead of or level with the baseline in twelve of the sixteen (model, metric, baseline) comparisons on the four models, and all eight paired contrasts lie within ±0.7 points (Table E.1). The per-group-scale rows are in Appendix D. At four bits all trellis codecs are within 0.35 perplexity and one point (Appendix D). Mixture of experts. Table 2 reports Qwen3.6-35B-A3B (40 MoE layers, 256 experts, top-8 routing) quantized with one Hessian per expert by the same code. At 2.29 bpw, the exact element-weighted rate, our build has lower perplexity and higher mean accuracy than Proteus and QTIP at 2.00 bpw, by +2.1 [+1.4, +3.0] and +2.5 [+1.9, +3.3] paired points over the 30 tasks; the 64-group scale gains the baselines nothing downstream, our start state +0.6 to +2.0 points. At equal side information CURVETQ is still ahead of both, by +0.6 [−0.1, +1.3] points over QTIP +start and 6 Table 2: Qwen3.6-35B-A3B (MoE) at two bits: PPL and mean accuracy over 30 tasks (per task: Appendix G). Methodbpwppl↓Mean↑ fp16166.1271.3 CurveTQ2.296.7668.2 Proteus2.00 + 6.9966.0 QTIP2.00 + 7.1065.6 QTIP +g64 2.25 + 6.9965.3 Proteus +g64 2.25 + 7.0865.1 QTIP +start 2.19 + 6.8167.6 Proteus +start 2.22 + 6.7866.6 firstcoding orderlast 0.5 0.6 0.7 0.8 0.9 D i , 16-bin mean (a) D i along the coding order native full RHT Haar 0 15 30 native (b) b per matrix, G = 64 10 5 10 3 10 1 0 15 30 act-order full RHT 10 5 10 3 10 1 Haar 10 2 10 1 10 0 held-out b (bit) -10 0 1 10 100 gain, % of Euclidean loss (c) Gain of 1/d 2 i weighting native, = + 0.97 after RHT, = + 0.16 b (bit) matrices Figure 2: Within-block curvature anisotropy Γ b (Eq. 3, G = 64), and what a rotation does to it; all panels Llama-2-7B. (a) The LDL diagonal along the coding order for one matrix (layer 15, q/k/v input, 16-bin means): native is jagged (whole-layer max/ min 2503×), the full-dimension randomized Hadamard and the dense Haar rotation both produce the smooth ramp of Appendix B (2.7×, 3.9×). (b) Γ b over 128 public Llama-2-7B Hessians, one histogram per transform; medians (dashed) 0.038 native, 0.0089 act-order, 0.00013 full RHT, 0.00016 Haar. (c) Realized gain of 1/d 2 i weighting on a held-out layer objective, as a fraction of the Euclidean loss (1− L W /L E ), against Γ b computed from the full held-out Hessian, 224 matrices: the gain follows Γ b natively (Spearman +0.97, filled) and not after the RHT (+0.16, hollow); the other two models in Figure 3. Symlog vertical axis; details in Appendix B. +1.5 [+0.5, +2.8] over Proteus +start , winning 18 and 21 of the 30 tasks (Table E.1). Expert Hessians are estimated from few tokens, so their LDL diagonals are damping-dominated and the weight is nearly inert here (Section 3.3). 4.2ROTATION AND CURVATURE Section 3.2 predicts that after a mixing rotation the curvature weight has little left to exploit, and that in the native basis it can substitute for the rotation. We test both with a 2× 2 design,rotation, none×Euclidean, 1/d 2 i , in the CURVETQ format of Table 1 (k = 2, factored int4 scales, per-module table, 2.29 bpw) so that only rotation and metric vary. The rotation is the full-dimension randomized Hadamard H 2 m ⊗ H K that QuIP# and QTIP apply to the whole input dimension (dense, but with an O(C logC) transform), drawn per matrix; table, factored scales and weight are recomputed from RHR ⊤ in each cell; each cell is built on n = 4 disjoint calibration slices and scored on the model’s full task suite of Table 1, reported as paired difference ± s.d. The models are Qwen3-4B, Llama-3-8B-Instruct and Llama-2-7B; the last is included because public 6144-sequence Hessians exist for it (Tseng et al., 2024a), which make Figure 2(b) exact. Results. Figure 2(a,b) shows what the rotation does to D: it does not flatten it, but within a 64-column block the ramp it produces is flat. The within-block anisotropy Γ b of Eq. 3 falls on every one of the 128 matrices, by a median of two and a half orders of magnitude (0.038 → 0.00013 bit). Table 3 reports the realized contrasts, and three things hold on the models where they can be measured. First, in the native basis the weight gains (P1): +2.44 ± 0.57 points on Qwen3-4B and +4.29± 1.04 on Llama-2-7B, positive on all four slices of both. On Llama-3-8B the native Euclidean search collapses across the suite (MMLU at chance, GSM8K under 3%), an instance of the two-bit fragility of Llama-3 that Huang et al. (2024) document, so we report only the contrasts that do not involve that cell. Second, after the rotation the weight adds little (S1): +0.36, +0.08 and−0.13 points, each inside its slice spread. Third, the substitution: the rotated Euclidean search and the weighted native search are within about a point of each other (SUB), +1.10± 0.63, +0.39± 0.66 and +0.07± 0.84. On the two Llamas it is smaller than its slice s.d. On Qwen3-4B the 7 Table 3: Rotation (full RHT)× metric at 2.29 bpw: mean accuracy over each model’s suite of Table 1 (34, 4 and 14 tasks), paired difference over n = 4 slices± s.d. P1/S1: weighted− Euclidean, native/rotated; R-e/R-w: rotated− native, Euclidean/weighted; SUB: rotated Euclidean− native weighted. “–”: the native Euclidean search collapses on Llama-3-8B, so contrasts against it are not reported. Qwen3-4BLlama-2-7BLlama-3-8B P1+2.44± 0.57+4.29± 1.04– S1+0.36± 0.51+0.08± 0.53 −0.13± 0.19 R-e+3.54± 0.71+4.68± 1.40– R-w+1.46± 0.42+0.48± 0.14 −0.06± 0.67 SUB+1.10± 0.63+0.39± 0.66+0.07± 0.84 Table 4: Component ablation, Qwen3-4B at two bits: PPL and mean accuracy over 34 tasks. Blocks: components added one per row up to the full recipe; one removed; search ablations from the quantile-fit row; block terminations. Paired differences with 95% CIs: Appendix H. Configurationbpwpplacc. Building up the codec (one component per row) 128-entry table, EM fit (start)2.46913.3250.4 + closed-form quantile fit2.46913.0550.8 + int8 second-level scales2.34513.4650.9 + edge-indexed emission2.34512.1951.9 + int4 scales (flat grid)2.28212.7751.0 + factored int4 scales, per-module table2.28911.5051.8 Removing one component from CURVETQ − factored scales (fp16 scales)2.46911.8652.2 − emission table (computed code)2.28913.6350.7 Ablating the search (from the quantile-fit row) − error feedback2.46913.3848.2 Euclidean metric instead of 1/d 2 i 2.46912.8147.4 Block termination (from CURVETQ) chained trellis, one state per row2.07313.5946.4 tail-biting block, no start state2.06915.6046.8 same, T =256 (QTIP’s tile)2.06913.3847.7 rotated search is ahead on 25 of the 34 tasks, by 1.1 points on average, while WikiText-2 perplexity favours the native weighted search by 0.36. A dense Haar rotation gives the same picture (Appendix B). Figure 2(c) adds the per-matrix view on a held-out layer objective: in the native basis the weighted search’s gain tracks Γ b matrix by matrix (Spearman +0.97 on Llama-2-7B, +0.67 and +0.99 on the other two), and after the rotation it does not (+0.16,−0.11,−0.01). The weighted native search therefore matches the rotation QTIP deploys to within about a point at equal rate with no transform at all. The weight’s value is not a lower loss than the rotation’s but the native basis it lets us keep. In that basis a per-module quantile table and a factored scale field, components a rotated, Gaussian-coded design has no use for, are what separate CURVETQ from the +start baselines of Table 1; consistently, the table-free build ties Proteus +start (Appendix D). The rotation lets the baselines search without a weight; Section 4.4 measures what it costs at decode. 4.3ABLATIONS Building up the codec. Table 4 ablates the codec on Qwen3-4B at two bits (all models and rates in Appendix H). Read with the bpw column, the ladder has two kinds of step. Equal-rate steps change only accuracy: the closed-form quantile fit matches an EM fit of the same 128 entries (0.28 perplexity, within twice the seed noise of Appendix H) and makes the build deterministic, and the edge-indexed emission is the largest single step, 1.27 perplexity and about one downstream point at equal bits. Rate-buying steps trade accuracy for bits: int8 second-level scales save 0.124 bpw for 0.41 perplexity, and moving them to a flat int4 grid a further 0.062 bpw for 0.58 perplexity and 0.8 points. The last step recovers what the flat grid gave up—the factored int4 scale field with a per-module table is 1.26 perplexity and 0.8 points better at 0.006 bpw more—so the ladder is not monotone in accuracy, and its intermediate rate-buying rows are cheaper but worse than their neighbours. End to end the recipe saves 0.18 bpw, 1.82 perplexity and 1.4 [+0.5, +2.4] downstream points. 8 Table 5: Batch-1 decode throughput (tokens/s), one RTX 3090. Llama-2-7B QTIP and fp16 are QTIP’s published numbers; the rest, and all batch 64/128 numbers, are ours. Batch 64/128 and the +rotation /−start-state arms are in Appendix I. CTQ: CURVETQ. Modelbitsfp16QTIPProt.CTQ L2-7B252.5127.0105.9139.0 3119.0103.5125.7 4109.0102.6 114.9 Q3-4B274.3153.6117.9160.8 3144.2115.4151.7 4137.2113.2146.2 Removing one component. fp16 scales in place of the factored field cost 0.18 bpw for 0.35 perplexity worse and 0.4 [−0.3, +1.1] points better: the field saves its bits at no downstream cost. Removing the emission table costs 2.13 perplexity and 1.2 [0.2, 2.2] points at two bits and is within noise at four (0.11 perplexity, 0.2 points): the table matters only at the lowest rate. Ablating the search. We remove, one at a time, the two components Section 3.1 argues for, starting from the quantile-fit configuration (fp16 scales). Removing error feedback costs 0.34 perplexity and−2.5 [−4.3,−1.4] down- stream points, concentrated on GSM8K (−27) and IFEval (−6). Replacing the 1/d 2 i branch metric by the Euclidean one, feedback kept, costs −3.3 [−4.5, −2.3] points while lowering WikiText-2 perplexity by 0.24. Perplexity and downstream accuracy thus disagree on what the weight is worth; we report both. Ablating the block termination. The last block of Table 4 replaces our block-local trellis by the two constructions that store no per-block state, the recipe otherwise identical: a row-long chained trellis and a per-block tail-biting one (QTIP’s construction on a 64-weight block). Both save ≈ 0.22 bpw and cost 2.09 and 4.10 perplexity and −5.5 [−7.0, −4.2] and −5.1 [−6.9, −3.5] downstream points, against the 0.4 points the factored scale field moves for a comparable 0.18 bpw two rows above. Lengthening the tail-biting sequence to QTIP’s own tile length recovers 2.22 of the 4.10 perplexity but is still−4.2 [−6.4,−2.5] points behind. 4.4DECODE THROUGHPUT We implemented the decoder of Section 3.3 (row Decode + GEMM of Figure 1b) as a fused dequantize-and-multiply CUDA kernel and measured decoding on an RTX 3090 in QTIP’s own benchmark setting, at three bit widths and three batch sizes (Table 5; full table and setup in Appendix I, Table I.1). Our harness reproduces QTIP’s published fp16 figure on Llama-2-7B (52.25 against 52.5 tokens/s), so at batch 1 we quote their published QTIP numbers there; QTIP publishes no batch 64/128 figures, so those, and all of Qwen3-4B, we run with its released kernels; Proteus, which has no public kernel, is our implementation throughout. Three things follow. First, our decoder is the fastest of the three in every cell: at batch 1 it is 1.05–1.09× QTIP and 1.12–1.36× Proteus, and at batch 64 and 128 it stays ahead by 1–13%. Second, the rotation is expensive at batch 1. Adding QTIP’s activation-side Hadamard to our own decoder, so that only the transform changes, costs 5–9 tokens/s on Llama-2-7B and 13–17 on Qwen3-4B, 4–11% of throughput. That is most of, or more than, our whole margin over QTIP: with the rotation added our decoder is about as fast as QTIP’s (0.93–1.02×), so at batch 1 most of the lead is the transform a rotation-free decoder does not pay for. Third, the stored start state is cheap to decode: removing it gains only 1–5 tokens/s, 1–3%, so the 0.22 bpw it costs returns 1–3 downstream points (Section 4.1) at almost no cost in speed. 5CONCLUSION We showed that the curvature weight and the random rotation are substitutes: the LDL diagonal that error feedback already computes, placed in the Viterbi branch metric, exploits the within-block variation a rotation removes, and on three models the weighted native search matches the baselines’ rotation to within about a point. On this basis we built CURVETQ, a trellis codec with no rotation to undo at inference, whose factored group scale and quantile table handle the amplitude and the marginal shape directly. Its block-local trellis with a stored start state also lifts QTIP and Proteus by 1–3 points; against them so strengthened, CURVETQ is still 1–3 points higher downstream at two bits, leads on a 35B mixture of experts, and decodes faster at every batch size we tested. 9 REFERENCES Saleh Ashkboos, Amirkeivan Mohtashami, Maximilian L. Croci, Bo Li, Pashmina Cameron, Martin Jaggi, Dan Alis- tarh, Torsten Hoefler, and James Hensman. QuaRot: Outlier-free 4-bit inference in rotated LLMs. In Advances in Neural Information Processing Systems (NeurIPS), 2024. arXiv:2404.00456. Bishnu S. Atal and Manfred R. Schroeder. Predictive coding of speech signals and subjective error criteria. IEEE Transactions on Acoustics, Speech, and Signal Processing, 27(3):247–254, 1979. Jerry Chee, Yaohui Cai, Volodymyr Kuleshov, and Christopher De Sa. QuIP: 2-bit quantization of large language mod- els with guarantees. In Advances in Neural Information Processing Systems (NeurIPS), 2023. arXiv:2307.13304. Jiale Chen, Vage Egiazarian, Roberto L. Castro, Torsten Hoefler, and Dan Alistarh. WUSH: Near-optimal adap- tive transforms for LLM quantization.In International Conference on Machine Learning (ICML), 2026a. arXiv:2512.00956. Jiale Chen, Yalda Shabanzadeh, Elvir Crn ˇ cevi ́ c, Torsten Hoefler, and Dan Alistarh. The geometry of LLM quantiza- tion: GPTQ as Babai’s nearest plane algorithm. In International Conference on Learning Representations (ICLR), 2026b. arXiv:2507.18553. Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. QLoRA: Efficient finetuning of quantized LLMs. In Advances in Neural Information Processing Systems (NeurIPS), 2023. arXiv:2305.14314. Tim Dettmers, Ruslan Svirschevski, Vage Egiazarian, Denis Kuznedelev, Elias Frantar, Saleh Ashkboos, Alexander Borzunov, Torsten Hoefler, and Dan Alistarh. SpQR: A sparse-quantized representation for near-lossless LLM weight compression. In International Conference on Learning Representations (ICLR), 2024. arXiv:2306.03078. Vage Egiazarian, Andrei Panferov, Denis Kuznedelev, Elias Frantar, Artem Babenko, and Dan Alistarh. Extreme compression of large language models via additive quantization. In International Conference on Machine Learning (ICML), 2024. arXiv:2401.06118. M. Vedat Eyuboglu and Shahid U. H. Qureshi. Reduced-state sequence estimation with set partitioning and decision feedback. IEEE Transactions on Communications, 36(1):13–20, 1988. Thomas R. Fischer and Min Wang. Entropy-constrained trellis-coded quantization. IEEE Transactions on Information Theory, 38(2):415–426, 1992. Elias Frantar and Dan Alistarh. QMoE: Practical sub-1-bit compression of trillion-parameter models. arXiv preprint arXiv:2310.16795, 2023. Elias Frantar, Saleh Ashkboos, Torsten Hoefler, and Dan Alistarh. GPTQ: Accurate post-training quantization for generative pre-trained transformers. In International Conference on Learning Representations (ICLR), 2023. arXiv:2210.17323. Leo Gao, Jonathan Tow, Baber Abbasi, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence Gold- ing, Jeffrey Hsu, Alain Le Noac’h, Haonan Li, Kyle McDonell, Niklas Muennighoff, Chris Ociepa, Jason Phang, Laria Reynolds, Hailey Schoelkopf, Aviya Skowron, Lintang Sutawika, Eric Tang, Anish Thite, Ben Wang, Kevin Wang, and Andy Zou. The language model evaluation harness. Zenodo, 2024. Aaron Grattafiori et al. The Llama 3 herd of models. arXiv preprint arXiv:2407.21783, 2024. Babak Hassibi and David G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Advances in Neural Information Processing Systems (NeurIPS), 1993. Xing Hu, Zhixuan Chen, Dawei Yang, Zukang Xu, Chen Xu, Zhihang Yuan, Sifan Zhou, and Jiangyong Yu. MoE- Quant: Enhancing quantization for mixture-of-experts large language models via expert-balanced sampling and affinity guidance. In International Conference on Machine Learning (ICML), 2025. arXiv:2505.03804. J. J. Y. Huang and Peter M. Schultheiss. Block quantization of correlated Gaussian random variables. IEEE Transac- tions on Communications Systems, 11(3):289–296, 1963. Wei Huang, Xingyu Zheng, Xudong Ma, Haotong Qin, Chengtao Lv, Hong Chen, Jie Luo, Xiaojuan Qi, Xianglong Liu, and Michele Magno. An empirical study of LLaMA3 quantization: From LLMs to MLLMs. Visual Intelli- gence, 2:36, 2024. arXiv:2404.14047. 10 Venugopalan Iyengar. BCJR-QAT: A differentiable relaxation of trellis-coded weight quantization. arXiv preprint arXiv:2605.10655, 2026. Yi Jiang, William W. Hager, and Jian Li. The geometric mean decomposition. Linear Algebra and its Applications, 396:373–384, 2005. Sehoon Kim, Coleman Hooper, Amir Gholami, Zhen Dong, Xiuyu Li, Sheng Shen, Michael W. Mahoney, and Kurt Keutzer. SqueezeLLM: Dense-and-sparse quantization. In International Conference on Machine Learning (ICML), 2024. arXiv:2306.07629. Deokjae Lee and Hyun Oh Song. Q-Palette: Fractional-bit quantizers toward optimal bit allocation for efficient LLM deployment. In Advances in Neural Information Processing Systems (NeurIPS), 2025. arXiv:2509.20214. Shiyao Li, Xuefei Ning, Luning Wang, Tengxuan Liu, Xiangsheng Shi, Shengen Yan, Guohao Dai, Huazhong Yang, and Yu Wang. Evaluating quantized large language models. In International Conference on Machine Learning (ICML), 2024. arXiv:2402.18158. Xinlin Li, Osama Hanna, Christina Fragouli, and Suhas Diggavi. ICQuant: Index coding enables low-bit LLM quan- tization. In Conference on Language Modeling (COLM), 2025. arXiv:2505.00850. Ji Lin, Jiaming Tang, Haotian Tang, Shang Yang, Wei-Ming Chen, Wei-Chen Wang, Guangxuan Xiao, Xingyu Dang, Chuang Gan, and Song Han. AWQ: Activation-aware weight quantization for on-device LLM compression and acceleration. In Machine Learning and Systems (MLSys), 2024. arXiv:2306.00978. Ruikang Liu, Yuxuan Sun, Manyi Zhang, Haoli Bai, Xianzhi Yu, Tiezheng Yu, Chun Yuan, and Lu Hou. Quantization hurts reasoning? an empirical study on quantized reasoning models. In Conference on Language Modeling (COLM), 2025a. arXiv:2504.04823. Yifei Liu, Jicheng Wen, Yang Wang, Shengyu Ye, Li Lyna Zhang, Ting Cao, Cheng Li, and Mao Yang. VPTQ: Extreme low-bit vector post-training quantization for large language models. In Empirical Methods in Natural Language Processing (EMNLP), 2024. arXiv:2409.17066. Zechun Liu, Changsheng Zhao, Igor Fedorov, Bilge Soran, Dhruv Choudhary, Raghuraman Krishnamoorthi, Vikas Chandra, Yuandong Tian, and Tijmen Blankevoort. SpinQuant: LLM quantization with learned rotations. In International Conference on Learning Representations (ICLR), 2025b. arXiv:2405.16406. Pier-Jean Malandrino. Unfolding the Leech lattice: Fused multi-shell decoding and VRAM layouts for 2-bit LLM weights. arXiv preprint arXiv:2609.02652, 2026. Vladimir Malinovskii, Denis Mazur, Ivan Ilin, Denis Kuznedelev, Konstantin Burlachenko, Kai Yi, Dan Alistarh, and Peter Richtarik. PV-Tuning: Beyond straight-through estimation for extreme LLM compression. In Advances in Neural Information Processing Systems (NeurIPS), 2024. arXiv:2405.14852. Vladimir Malinovskii, Andrei Panferov, Ivan Ilin, Han Guo, Peter Richtarik, and Dan Alistarh. HIGGS: Pushing the limits of large language model quantization via the linearity theorem. In North American Chapter of the Association for Computational Linguistics (NAACL), 2025. arXiv:2411.17525. Michael W. Marcellin and Thomas R. Fischer. Trellis coded quantization of memoryless and Gauss-Markov sources. IEEE Transactions on Communications, 38(1):82–93, 1990. Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. In Interna- tional Conference on Learning Representations (ICLR), 2017. Qwen Team. Qwen3-VL technical report. arXiv preprint arXiv:2511.21631, 2025. Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1–67, 2020. Wenqi Shao, Mengzhao Chen, Zhaoyang Zhang, Peng Xu, Lirui Zhao, Zhiqian Li, Kaipeng Zhang, Peng Gao, Yu Qiao, and Ping Luo. OmniQuant: Omnidirectionally calibrated quantization for large language models. In International Conference on Learning Representations (ICLR), 2024. arXiv:2308.13137. 11 Yuxuan Sun, Ruikang Liu, Haoli Bai, Han Bao, Kang Zhao, Yuening Li, Jiaxin Hu, Xianzhi Yu, Lu Hou, Chun Yuan, Xin Jiang, Wulong Liu, and Jun Yao. FlatQuant: Flatness matters for LLM quantization. In International Conference on Machine Learning (ICML), 2025. arXiv:2410.09426. Albert Tseng, Jerry Chee, Qingyao Sun, Volodymyr Kuleshov, and Christopher De Sa. QuIP#: Even better LLM quantization with Hadamard incoherence and lattice codebooks. In International Conference on Machine Learning (ICML), 2024a. arXiv:2402.04396. Albert Tseng, Qingyao Sun, David Hou, and Christopher De Sa. QTIP: Quantization with trellises and incoherence processing. In Advances in Neural Information Processing Systems (NeurIPS), 2024b. arXiv:2406.11235. Albert Tseng, Zhaofeng Sun, and Christopher De Sa.Model-preserving adaptive rounding.arXiv preprint arXiv:2505.22988, 2025. Mart van Baalen, Andrey Kuzmin, Ivan Koryakovskiy, Markus Nagel, Peter Couperus, Cedric Bastoul, Eric Mahurin, Tijmen Blankevoort, and Paul Whatmough. GPTVQ: The blessing of dimensionality for LLM quantization. arXiv preprint arXiv:2402.15319, 2024. Tycho F. A. van der Ouderaa, Mart van Baalen, Paul Whatmough, and Markus Nagel. Leech lattice vector quantization for efficient LLM compression. arXiv preprint arXiv:2603.11021, 2026. Miles Williams and Nikolaos Aletras. On the impact of calibration data in post-training quantization and pruning. In Association for Computational Linguistics (ACL), 2024. arXiv:2311.09755. Zhengwu Yang, Xunchao Li, Ke Cheng, Kunlong Liu, Jianfeng Yang, Haoshuang Wang, Kaipeng Deng, Qingqing Dang, Yanlin Sha, Yanjun Ma, and Dianhai Yu. Proteus: Lookup-free trellis-coded quantization by lattice-breaking compute codes for 2-bit LLMs. In International Conference on Machine Learning (ICML), 2026. Paul L. Zador. Asymptotic quantization error of continuous signals and the quantization dimension. IEEE Transactions on Information Theory, 28(2):139–149, 1982. Kaichen Zhang, Bo Li, Peiyuan Zhang, Fanyi Pu, Joshua Adrian Cahyono, Kairui Hu, Shuai Liu, Yuanhan Zhang, Jingkang Yang, Chunyuan Li, and Ziwei Liu. LMMs-Eval: Reality check on the evaluation of large multimodal models. In Findings of the Association for Computational Linguistics: NAACL, 2025a. arXiv:2407.12772. Xi Zhang, Xiaolin Wu, Jiamang Wang, and Weisi Lin. Learning grouped lattice vector quantizers for low-bit LLM compression. In Advances in Neural Information Processing Systems (NeurIPS), 2025b. arXiv:2510.20984. 12 APROOFS AND EXAMPLES FOR PROPOSITION 1 Throughout, H ∈ R C×C is the damped input Hessian of one layer (δ = 10 −2 of the mean diagonal in every build), H = (I + ̄ U )D(I + ̄ U ) ⊤ its LDL factorization in a fixed coding order with ̄ U strictly upper triangular and D = diag(D 1 ,...,D C )≻ 0, w ∈ R C one output row, ˆw its quantization and e = w− ˆw. A.1THE LOSS IDENTITY Lemma 1 (identity (i)). Let column-wise error feedback quantize coordinate j against the target τ j = w j + P i<j ̄ U ij e i and define η j = τ j − ˆw j . Then η = (I + ̄ U ) ⊤ e and e ⊤ He = C X i=1 D i η 2 i for every ˆw ∈ R C . Under block feedback with blocks b of consecutive coordinates, the same argument gives e ⊤ He = P b η ⊤ b D b η b with D b the Schur complement of the trailing submatrix of H onto block b. Proof. By definition η j = w j − ˆw j + P i<j ̄ U ij e i = e j + ( ̄ U ⊤ e) j , i.e. η = (I + ̄ U ) ⊤ e. Hence e ⊤ He = e ⊤ (I + ̄ U )D(I + ̄ U ) ⊤ e = η ⊤ Dη. For block feedback replace the scalar LDL factorization by the block one, H = (I + ̄ U B )D B (I + ̄ U B ) ⊤ with D B = blockdiag(D b ); the same substitution gives the block form. No property of ˆw is used. The per-step quantity D i η 2 i is the optimal-brain-surgeon loss of rounding coordinate i given all later coordinates (Hassibi & Stork, 1993), and D i = 1/[H −1 F i ] i is the reciprocal of the quantity by which GPTQ normalizes its residuals (Frantar et al., 2023); Lemma 1 states that these per-step losses add exactly to the layer loss. A.2PROOF OF PROPOSITION 1, PARTS (I) AND (I) Proof of (i). By Lemma 1 the loss has no cross terms in η, so E[e ⊤ He] = P i D i E[η 2 i ]. Under the hypothesis E[η 2 i ] = σ 2 for all i this equals σ 2 tr(D). Since det(I + ̄ U ) = 1, Q i D i = detH , and the inequality of arithmetic and geometric means gives tr(D)≥ C ( Q i D i ) 1/C = C det(H) 1/C , with equality iff all D i are equal. Proof of (i). Under the high-resolution rate model R i = h i − 1 2 log 2 (cσ 2 i ), fixing P i R i fixes Q i σ 2 i =: σ 2C . Minimizing P i D i σ 2 i subject to Q i σ 2 i = σ 2C by a Lagrange multiplier gives D i σ 2 i = λ for all i; the constraint then yields λ = σ 2 ( Q i D i ) 1/C = σ 2 GM(D) and the minimum Cσ 2 GM(D). This is the transform-coding-gain argument of Huang & Schultheiss (1963). For the second statement, the change of variables y = D 1/2 x maps the weighted norm ∥D 1/2 ·∥ to the Euclidean norm and scales the density by det(D) −1/2 ; Zador’s high-resolution formula for fixed-rate vector quantization (Zador, 1982) depends on the density only through a factor that scales by det(D) 1/C , which gives the same floor Cσ 2 GM(D) for a code shaped to the weighted norm. Remark 1 (on the hypothesis of (i)). Equal residual second moments across coordinates is the high-resolution be- haviour of a single alphabet applied to every coordinate. At two bits, with per-group absmax normalization and overload, it holds only approximately, so (i) is an idealization of the Euclidean search rather than a bound on it: with E[η 2 i ] = σ 2 + ε i the loss is σ 2 tr(D) + P i D i ε i , whose second term has no fixed sign. The realized gain of the weighted search is measured directly in Section 4.2. A.3A ROTATION FLATTENS D ONLY PARTIALLY; A DATA-AWARE ONE FLATTENS IT EXACTLY Example 1. Let H = diag(10, 1). In the native basis D = (10, 1), AM(D)/GM(D) = 1.74, i.e. Γ(H) = 0.40 bit: feedback has nothing to propagate and the anisotropy is entirely available to a weighted search. A rotation by 45 ◦ gives H ′ = 5.5 −4.5 −4.5 5.5 , whose raw diagonal is flat but whose LDL diagonal in coding order is D ′ = (1.82, 5.5): AM/GM = 1.16, Γ(H ′ ) = 0.10 bit, and Q i D ′ i = detH = 10 as Proposition 1(i) requires. With H ′ as the native Hessian, a raw-diagonal weight H ′ i sees no anisotropy, the LDL weight sees the residual 0.10 bit, and feedback recovers the rest: the Euclidean loss is 11σ 2 without feedback, σ 2 tr(D ′ ) = 7.32σ 2 with it, against the floor 2σ 2 √ 10 = 6.32σ 2 . 13 The rotation that equalizes the LDL diagonal exactly is not the 45 ◦ one but the geometric-mean decomposition of H 1/2 (Jiang et al., 2005), here the angle θ with 10 sin 2 θ + cos 2 θ = √ 10, i.e. θ ≈ 29.3 ◦ ; after it a Euclidean search with feedback attains the floor. That rotation depends on H . A random rotation does not, and the example shows that it need not flatten D; Appendix B describes what it does instead. A.4THE SUBSTITUTION HYPOTHESIS IS NOT A THEOREM Write, for a fixed block size G and coding order, Λ nat,W = P b G GM(diagD b ) for the high-resolution proxy loss (per unit residual variance) of the weighted search in the native basis, and Λ rot,E = E R P b tr(D ′ b ) for that of the Euclidean search after a random rotation R, both under block feedback with in-block residuals of second-moment matrix σ 2 I (Appendix B). Proposition 2. Neither Λ nat,W ≤ Λ rot,E nor Λ nat,W ≥ Λ rot,E holds for all positive definite H . Proof. Fix C = 4, G = 2, H A = diag(10, 1, 10, 1) and H B = diag(10, 10, 1, 1). Both have spectrum10, 10, 1, 1, so for Haar-distributed R the law of RHR ⊤ is the same for both and Λ rot,E (H A ) = Λ rot,E (H B ) =: Φ. For every orthogonal R, with H ′ = RHR ⊤ , two bounds hold. Each D ′ b is a Schur complement of H ′ , so (D ′ b ) i ≥ D ′ i , the scalar LDL diagonal of H ′ ; since Q i D ′ i = detH , the inequality of arithmetic and geometric means gives P b tr(D ′ b ) ≥ P i D ′ i ≥ C det(H) 1/C . A Schur complement is dominated by its block, so P b tr(D ′ b ) ≤ P b tr(H ′ b ) = trH . The first bound is attained only if all D ′ i coincide and the second only if H ′ is block diagonal, events of Haar measure zero for H ̸= cI ; hence C det(H) 1/C < Φ < trH , i.e. 4 √ 10 < Φ < 22 (numerically Φ = 17.73± 0.01 over 2· 10 4 draws). In the native basis D b = diag(H b ), so Λ nat,W (H A ) = 2· 2 √ 10 = 4 √ 10 < Φ and Λ nat,W (H B ) = 2· 10 + 2· 1 = 22 > Φ. The two matrices differ only in where the anisotropy of D sits. In H A it lies inside every coding block, the weighted search attains the floor C det(H) 1/C and a random rotation can only lose; in H B it lies between blocks, the weighted search has nothing to exploit and the rotation’s mixing lowers the Euclidean loss. Interleaving or grouping the eigen- values extends the construction to any C and G with 2 ≤ G ≤ C/2; the boundary cases are one-directional (with a single block the rotated Euclidean proxy equals trH for every R, and with G = 1 both native proxies equal trH ). Whether native weighting matches rotation is therefore a property of where the Hessians of trained language models put their anisotropy, not of positive definite matrices in general. Their native D is dominated by outlier input channels that place large anisotropy inside coding blocks (Figure 2a,b), the regime of H A ; Section 4.2 tests the hypothesis on that population. A.5WHEN THE TWO CURVATURE WEIGHTS COINCIDE Remark 2. Within a block, multiplying all weights ω i by a common factor leaves the Viterbi argmin unchanged. Hence the LDL weight ω i = 1/d 2 i = D i and the raw-diagonal weight ω i = H i select the same path for every target if D i /H i is constant within the block. Since D i is the residual second moment of x i after linear prediction from x >i and H i = E[x 2 i ], this ratio is 1− R 2 i , with R 2 i the uncentred squared multiple correlation of channel i with the channels coded after it. The two weights therefore agree exactly on blocks whose channels are equally predictable from later ones, and differ most where a few channels are strongly correlated with the rest. This is the sense in which the near-tie between H i and 1/d 2 i observed on the feedback axis (Appendix B) is expected. BROTATION AND CURVATURE: THE RAMP, THE PROXIES, AND EXTENDED ANALYSIS Table B.1: The three heterogeneities that a rotation homogenizes, and how the rotation-free recipe handles each. HeterogeneityMechanismInference cost local amplitude s g per-(row, 64) group scale with factored second-level quanti- zation (§3.3) one multiply per weight; 0.07 bpw normalized shape of zclosed-form quantile table, or computed code (§3.3)128-entry int8 table, or none curvature D i weighted branch metric Eq. 2none (encode side) coupling ̄ Uinter-block: error feedback; intra-block: omittednone (encode side) 14 Ramp property. After a Haar or sign-randomized Hadamard rotation, D ′ i follows a smooth ramp from the harmonic mean of the damped spectrum to its arithmetic mean along the coding order (checked numerically, not proved). Its two ends are exact: D ′ C = u ⊤ Hu and D ′ 1 = 1/(v ⊤ H −1 v), with u and v the last and first columns of R, so the two ends fluctuate on different scales, set by H and by H −1 . What the argument needs is only that the ramp is locally flat on the scale of a block, which we measure directly: the within-block s.d. of lnD ′ i has median 0.013 on the 128 public Llama-2-7B Hessians (0.116 natively). Where it is flat, Γ ′ b ≈ 0 and the possible gain of weighting is small: after rotation, weighting is redundant (prediction S1). The substitution hypothesis. Whether native weighting matches rotation is not implied by (i)–(i); both sides are computable from H alone. Under block feedback with in-block residuals of second-moment matrix E[η b η ⊤ b ] = σ 2 I (equal and uncorrelated; equal diagonal alone does not suffice, since E[η ⊤ b D b η b ] = tr(D b E[η b η ⊤ b ])), the high- resolution proxy losses of the four conditions in Section 4.2 are Λ nat,E = P b tr(D b ), Λ nat,W = P b G GM(diagD b ), Λ rot,E = E R P b tr(D ′ b ) and Λ rot,W ≈ Λ rot,E ; in this notation Γ b of Eq. 3 is 1 2 log 2 (Λ nat,E /Λ nat,W ), the block-local gain of Section 3.2. The hypothesis is Λ nat,W ≈ Λ rot,E per layer. Neither ordering holds for general matrices (Appendix A), so this is a statement about the Hessians of trained LLMs, where outlier input channels put large, block-local anisotropy into the native D. It predicts: (P1) in the native basis, the realized gain of the weighted metric tracks Γ b ; (P2) after rotation it vanishes wherever Γ ′ b ≈ 0. The H -only proxies on the public Llama-2-7B Hessians. With the 128 public Hessians (6144 sequences, damping 10 −2 of the mean diagonal, G = 64): after the full-dimension RHT or a Haar rotation, Γ ′ b has median 0.0001 and maximum 0.04 (RHT) or 0.20 (Haar) bit, and Λ rot,W is within 2% of Λ rot,E in 125 of 128 matrices, so S1 holds on H alone. In the native basis Γ b has median 0.038 bit (mean 0.085) and is large only where the spectrum collapses: 1.69 bit for the first layer’s attention input (erank = 4), 0.97 for the second layer’s down-projection (erank = 1), 0.80 for the last layer’s. The rotation’s own proxy gain for a Euclidean search, Λ nat,E /Λ rot,E , has median 1.105 (0.072 bit) and reaches 2.2 (0.58 bit) in those layers. The substitution ratio Λ nat,W /Λ rot,E has median 0.998 (interquartile 0.996–1.096) and is ≤ 1 in 96 of 128 matrices; native weighting wins by a wide margin exactly where the rotation gains most, and loses on the attention output projections (median 1.077, ten of 32 above 1.1). These proxies assume equal per-coordinate residual variance and bound the anisotropy mechanism only. 10 2 10 1 10 0 held-out b (bit) -10 0 1 10 100 gain, % of Euclidean loss (a) Qwen3-VL-4B, n = 252 native, = + 0.67 after RHT, =0.11 10 2 10 1 10 0 held-out b (bit) (b) Llama-2-7B, n = 224 native, = + 0.97 after RHT, = + 0.16 10 2 10 1 10 0 held-out b (bit) (c) Llama-3-8B-Instr., n = 224 native, = + 0.99 after RHT, =0.01 Figure 3: The plane of Figure 2(c) on all three models: realized per-matrix gain of 1/d 2 i weighting on the held-out layer objective, as a fraction of the Euclidean loss (1−L W /L E ), against Γ b of Eq. 3 computed from the full held-out Hessian (64 sequences no cell calibrated on), native (filled circles) and after the full-dimension randomized Hadamard (hollow squares). The native gain tracks Γ b on every model (Spearman +0.67, +0.97, +0.99) and the rotated one does not (−0.11, +0.16,−0.01); the rotation lowers the median Γ b from 0.075, 0.032, 0.103 to 0.0027, 0.0003, 0.0005 bit, and the median native gains follow the native medians (11.7%, 4.6%, 13.2%; per-matrix medians, whereas the model-level percentages below sum over matrices). Figure 2(c) plots panel (b) alone. Symlog vertical axis (|·| < 1% linear). Held-out layer objective. Scoring every cell on tr(EHE ⊤ )/tr(WHW ⊤ ) with H from 64 sequences no cell cal- ibrated on (summed over coded matrices; rotation-invariant, so rotated and native cells compare directly) separates what the metric does from what the rotation does, and the two do not agree with the tasks in the same way. The metric’s effect tracks tasks: P1 removes 17.2± 0.3% of the Euclidean loss on Qwen3-4B, 10.3± 0.2% on Llama-3-8B and 5.8± 0.03% on Llama-2-7B, on all four slices of each; S1 is −0.14%, −0.01% and −0.01% (the two rotated searches agree to 2× 10 −3 percentage points in weight-space error on every model); and matrix by matrix the native gain follows Γ b at Spearman +0.67, +0.97 and +0.99 (Figure 3) while after the RHT it does not (−0.11, +0.16, −0.01). The rotation’s effect does not track tasks: on Qwen3-4B the full-dimension RHT lowers the held-out objec- tive of a Euclidean search by 31.9± 0.8%, twice the metric’s gain, and the rotated Euclidean cell sits 17.7± 0.7% 15 below the weighted native one on this objective on all four slices, yet the two are within about a point on the 34-task mean (SUB +1.10± 0.63) and WikiText-2 perplexity leans to the native weighted one (0.36± 0.29, all four slices); on Llama-3-8B and Llama-2-7B the same two cells differ by 0.33± 0.02% and 0.32± 0.03% on the layer objective, fifty times less, and by no more on tasks (+0.07± 0.84 and +0.39± 0.66). Qwen3-4B is the one model of three where this objective sees the rotation at all. A per-layer quadratic loss is the wrong yardstick for a rotation, which changes the error’s direction in every layer at once; we report it for the metric, where it agrees with every other measure, and read the rotation on end-to-end quantities only. End-to-end perplexity on Qwen3-4B (WikiText-2, context 4096, n = 4) tells the same story for the metric: P1−1.19± 0.73, S1−0.27± 0.19, SUB +0.36± 0.29, R-w +0.09± 0.17; P1, S1 and SUB each carry their sign on all four slices, so on this yardstick the weight retains a small residual value after the rotation and the native weighted search is 0.36 perplexity ahead of the rotated Euclidean one. Weighting and feedback. The branch weight and the LDLQ feedback address the same quantity from two sides, so we separate them on Qwen3-4B in the format of Table 1, scored on the same 34-task suite as Table 3. Switching the feedback off (round-to-nearest within the trellis search) and the weight off costs 10.3 points; restoring either one alone recovers most of it: the feedback alone is worth +7.85± 0.47 points and the H i branch weight alone, with no feedback, +8.73± 0.29, each positive on all four calibration slices. Using both buys +10.29± 0.34 (1/d 2 i ) or +10.47± 0.35 (H i ), not +16.6: the interaction is−6.3 points, negative on all four slices, so the two mechanisms are near-substitutes rather than complements, and once the feedback is on the weight is worth +2.44± 0.57 (1/d 2 i , the P1 of Table 3) or +2.62± 0.56 (H i ). Weight-only exceeds feedback-only by +0.88± 0.27 points, and the two curvature weights under feedback differ by less than a fifth of a point (−0.18± 0.12), consistent with Section 3.1. Every contrast is paired over the same four calibration slices; the arm with neither mechanism uses no Hessian and is a single build. Two format caveats apply to the feedback-free arms, and both are small relative to the effect: they code each row as a single trellis sequence and so pay one start state per row rather than one per 64-column block (2.068 against 2.288 bpw, in their favour), and the factored scale field is defined only on the block-feedback path, so they use the flat int4 grid (worth about−0.8 points, against them, Section 4.3). The missing start state is itself worth 4–5 points (Table 4), so charging it in full still leaves both single-mechanism effects above +2 points. Which rotation. The rotation of Table 3 is the one the baselines deploy: a sign-randomized Hadamard on the full input dimension, H 2 m ⊗ H K with a Sloane Hadamard matrix H K for non-power-of-two widths (K = 20 for the 2560-wide and K = 172 for the 11008-wide inputs, K = 28 for 14336, K = 1 for 4096, as in QTIP’s tables; K = 76, a Paley-I matrix QTIP never needed, for Qwen3-4B’s 9728-wide down-projection input), the construction of QuIP# and QTIP. A blocked Hadamard on 256 columns, the cheaper stand-in we used in an earlier version of this experiment, leaves the rotated Euclidean search 1.3–2.8 points behind the weighted native search on all three models; the full-dimension transform closes that gap entirely (Table 3), as does a dense per-matrix Haar rotation on Qwen3-4B, on the same 34-task suite (+1.32± 0.70 against native weighted, as against +1.10 for the RHT; +0.22± 0.34 against the RHT; weighting after it−0.27± 0.87). The two dense rotations are indistinguishable from each other and within about a point of the weighted native search; the block Hadamard’s shortfall was a mixing effect, not evidence about the weight. What the native basis carries. The native basis is heterogeneous in three ways, and the codec meets each where it lives: the amplitude field s g carries local magnitude, the branch weight D i carries local sensitivity, and the boundary- state field b g of Section 3.1 carries the local non-stationarity that feedback itself creates at a block boundary. The last is not something a rotation removes: it comes from the feedback, which the baselines use as well, and the start state lifts them in the rotated basis too (Section 4.1). CEXTENDED RELATED WORK What a rotation repairs. QuIP’s Table 2 shows that for a scalar grid at two bits, removing incoherence is a cliff: outlier input channels overwhelm a grid that has no local scale. That cliff is the amplitude and shape job of the rotation, which our group scales and quantile table do in the native basis; it is not evidence about the curvature job. Leech-lattice VQ (van der Ouderaa et al., 2026) reports the same from the other side: with a norm-preserving correction in place of plain GPTQ, dropping the rotation moves Llama-2-7B at two bits from 191.9 to 6.9 perplexity, leaving the Hadamard worth about 0.2: part of what a rotation buys is compensation for a mismatch between solver and code, not a property of the weights. Trellis successors. Proteus (Yang et al., 2026) keeps QTIP’s rotation, block LDLQ and Euclidean Viterbi but re- places the lookup table with a computed Gaussianizing code, chosen per layer from a small candidate pool by a 16 Hessian-weighted selection objective (curvature enters the choice of code, not the branch cost), and then learns per- channel scales and distills per-layer affines. Its throughput advantage at large batch is attributed to codebook shared- memory traffic rather than to the rotation. Q-Palette (Lee & Song, 2025) derives the optimal bit allocation for Gaus- sianized weights and provides fractional-bit trellis, vector and scalar quantizers; BCJR-QAT (Iyengar, 2026) replaces the Viterbi argmax by forward–backward marginals so that the trellis can be trained through, and puts the curvature in the training objective. Fine-tuning, and what a published “two bits” contains. PV-Tuning (Malinovskii et al., 2024) holds the code fixed and varies only the fine-tuner: AQLM at 2.01 bpw on Llama-2-7B moves from 7.38 WikiText-2 perplexity with calibration alone to 6.69, 6.41 and 5.90 as the fine-tuner strengthens. QTIP’s own end-to-end stage is worth about one perplexity point at 7B and about 0.2 at 70B. Converted through the no-fine-tuning rate slope this is 0.7–1.1 effective bits at 7B, more than the spread between any two codes we compare. Even tuning per-column scales alone moves QuIP# and QTIP by more than a perplexity point in a common pipeline (van der Ouderaa et al., 2026). QuIP#, QTIP, AQLM and Proteus all publish their headline low-bit numbers after such a stage, and the rates they publish differ in what they charge for its parameters and for metadata. We therefore fix the fine-tuning protocol at none for every method we run and compare at matched rate; how the margins change under a fine-tuning stage is left to future work. Other relevant lines. GPTQ’s column-wise feedback has recently been identified with Babai’s nearest-plane algo- rithm on the Hessian lattice (Chen et al., 2026b), whose error bound is a quadratic form in the same diagonal D that we place in the search. YAQA (Tseng et al., 2025) improves which Hessian is used and measures quantized models by their KL divergence to the original. ICQuant (Li et al., 2025) codes outlier positions by their index gaps; HIGGS (Malinovskii et al., 2025) derives MSE-optimal grids for Hadamard-rotated weights; NF4 is the Gaussian-quantile construction that our empirical quantile table generalizes. For mixtures of experts, MoEQuant (Hu et al., 2025) studies calibration imbalance across experts and recent work allocates bits across experts. Calibration-set sensitivity is docu- mented by Williams & Aletras (2024); for a deterministic codec its consequence is sharper, since the calibration slice is the only replicate axis. Quantization is known to hurt multi-step reasoning first (Li et al., 2024; Liu et al., 2025a), which is where our two-bit gains concentrate. DFULL PERPLEXITY AND ACCURACY TABLES Tables D.1 and D.2 extend Table 1 with the NF baseline (a Hessian-aware quantile grid with a Hadamard transform). The x.25 + rows are not a handicap: a 64-group fp16 scale is the cheapest way either baseline can spend comparable extra bits, and in nine of ten (model, codec) cells it gives that baseline its own best two-bit perplexity, so the comparison is against a strengthened baseline. Both rate rows are kept because the exchange rate is not transferable: the same scale is worth−1.64 perplexity to QTIP on Qwen3-4B and only−0.22 to Proteus, so a baseline cannot be interpolated to our rate. The +start rows spend comparable side information on our stored start state instead (Appendix H), and Section 4.3 bounds the question from our side with a variant of our own recipe at 2.07 bpw. Both side channels at once. The +start+g128 rows give each baseline our stored start state and a 128-group fp16 scale, 2.31 bpw for QTIP and 2.34 for Proteus, so for the first time the baseline rate lies above ours. On the four dense models the ordering does not move: at two bits our margin is +1.0 to +2.7 downstream points on five of six contrasts (Table E.1) and 1.5–2.8 perplexity on Qwen3-4B, with the Llamas within 0.25; above two bits every contrast lies within±1.1 points and 0.31 perplexity. The second channel adds little to the first—−0.7 to +0.8 points over the +start rows, and a higher perplexity in five of the eighteen cells on the three 4–8B models (e.g. QTIP on Qwen3-4B at two bits, 13.99 → 14.31; Proteus on Qwen3-4B at three and four bits)—so the two kinds of side information are not additive, and neither one interpolated to our rate would close the gap. On Qwen3-32B the same holds for perplexity (6.99 and 6.89 against our 6.90). We did not run these arms on the mixture of experts. Removing the table. The table-free variant of Section 3.3 (CURVETQ no LUT in Tables D.1 and D.2) is within noise of the table variant at three and four bits: over the six model× tier cells above two bits, four paired differences include zero, the others are−0.5 [−0.8,−0.2] and +0.7 [+0.1, +1.6] (Table E.2), and perplexity moves by at most 0.11. At two bits the table matters on two of the four models: removing it costs 2.1 perplexity and 1.2 points on Qwen3-4B, and 2.6 points on Llama-3.1-8B, where perplexity changes by only 0.06; once more, perplexity understates a downstream change. On the other two it is close to free (0.5 points on Llama-3-8B) or slightly negative (Llama-2-7B). 17 Table D.1: WikiText-2 perplexity (context 4096; lower is better), all methods. Baselines: QTIP (Tseng et al., 2024b), Proteus (Yang et al., 2026), HIGGS (Malinovskii et al., 2025), GPTQ (Frantar et al., 2023); GPTQ (g64) is a symmetric int-k grid with one fp16 scale per 64 weights and no zero point, k + 0.25 bpw. Bold: best in tier; the fp16-scale variant of our build ( fp16 , x.47 bpw) is listed for reference and not ranked. MethodbpwRot. Qwen3-4B Llama-3-8B Llama-3.1-8B Qwen3-32B fp1616none9.727.686.676.17 QTIP2.00 + RHT15.3611.5310.317.21 Proteus2.00 + RHT14.2110.9910.027.09 CurveTQ2.29none11.509.919.166.90 CurveTQ no LUT 2.29none13.6310.019.23– QTIP +g64 2.25 + RHT13.7211.1910.037.07 Proteus +g64 2.25 + RHT13.9910.8110.056.97 QTIP +start 2.19 + RHT13.9910.229.426.93 Proteus +start 2.22 + RHT13.159.839.306.88 QTIP +start+g128 2.31 + RHT14.3110.179.356.99 Proteus +start+g128 2.34 + RHT13.029.829.036.89 HIGGS2.25Had.21.2319.0918.40– GPTQ (g64)2.25none40.75536530– CurveTQ fp16 2.47none11.869.859.29– QTIP3.00 + RHT10.688.307.326.38 Proteus3.00 + RHT10.738.157.236.37 CurveTQ3.29none10.288.167.096.32 CurveTQ no LUT 3.29none10.348.067.11– QTIP +g64 3.25 + RHT10.518.307.286.36 Proteus +g64 3.25 + RHT10.758.207.236.35 QTIP +start 3.16 + RHT10.628.127.276.37 Proteus +start 3.20 + RHT10.438.167.126.31 QTIP +start+g128 3.31 + RHT10.298.177.21– Proteus +start+g128 3.34 + RHT10.568.147.22– HIGGS3.25Had.11.068.577.79– NF (Hessian)3.25Had.11.03234108– GPTQ (g64)3.25none11.859.728.93– CurveTQ fp16 3.47none10.188.067.08– QTIP4.00 + RHT9.997.816.86– Proteus4.00 + RHT9.837.776.80– CurveTQ4.29none9.687.756.77– CurveTQ no LUT 4.29none9.797.786.79– QTIP +g64 4.25 + RHT10.027.806.84– Proteus +g64 4.25 + RHT9.887.826.80– QTIP +start 4.13 + RHT10.117.826.83– Proteus +start 4.19 + RHT9.927.776.80– QTIP +start+g128 4.31 + RHT9.797.816.82– Proteus +start+g128 4.34 + RHT9.997.766.77– HIGGS4.25Had.10.017.876.88– NF (Hessian)4.25Had.9.797.9612.77– GPTQ (g64)4.25none10.338.157.18– CurveTQ fp16 4.47none9.837.766.75– 18 Table D.2: Mean downstream accuracy (%) over the task suite of Section 4 (n = 34 tasks for the Qwen3 models, 14 for each Llama model), all methods. “×”: the model fails to produce valid outputs on most tasks. Bold: best in tier; the fp16-scale variant ( fp16 ) is listed for reference and not ranked. MethodbpwQwen3-4B Llama-3-8B Llama-3.1-8B Qwen3-32B fp161662.061.863.270.2 QTIP2.00 + 46.848.849.865.4 Proteus2.00 + 48.048.851.565.0 CurveTQ2.2951.853.254.066.3 CurveTQ no LUT 2.2950.752.751.4– QTIP +g64 2.25 + 47.948.448.865.0 Proteus +g64 2.25 + 47.348.351.065.8 QTIP +start 2.19 + 49.851.150.966.1 Proteus +start 2.22 + 51.052.152.566.1 QTIP +start+g128 2.31 + 49.150.551.3– Proteus +start+g128 2.34 + 50.652.953.0– HIGGS2.2536.840.139.8– GPTQ (g64)2.2517.1×– CurveTQ fp16 2.4752.252.553.5– QTIP3.00 + 58.958.660.269.2 Proteus3.00 + 59.059.260.069.3 CurveTQ3.2960.059.960.969.7 CurveTQ no LUT 3.2960.259.461.7– QTIP +g64 3.25 + 58.859.560.969.4 Proteus +g64 3.25 + 59.859.161.369.4 QTIP +start 3.16 + 59.659.261.269.3 Proteus +start 3.20 + 60.059.761.269.4 QTIP +start+g128 3.31 + 59.358.861.3– Proteus +start+g128 3.34 + 59.659.960.6– HIGGS3.2555.257.658.7– NF (Hessian)3.2555.2– GPTQ (g64)3.2550.852.352.0– CurveTQ fp16 3.4760.260.161.5– QTIP4.00 + 61.561.162.1– Proteus4.00 + 61.761.262.7– CurveTQ4.2961.861.563.0– CurveTQ no LUT 4.2961.661.262.6– QTIP +g64 4.25 + 61.660.962.7– Proteus +g64 4.25 + 61.961.062.7– QTIP +start 4.13 + 61.561.362.5– Proteus +start 4.19 + 61.861.463.0– QTIP +start+g128 4.31 + 61.661.162.4– Proteus +start+g128 4.34 + 61.561.062.9– HIGGS4.2561.260.662.7– NF (Hessian)4.2561.459.962.1– GPTQ (g64)4.2559.559.361.5– CurveTQ fp16 4.4761.761.562.5– 19 EPAIRED COMPARISONS Table E.1 lists, for every comparison quoted in Section 4.1, the mean paired difference in accuracy over tasks between our build and a trellis baseline at the neighbouring rate, with a bootstrap 95% confidence interval (4000 resamples of the task set) and the number of tasks on which ours scores higher. The interval answers whether the margin depends on the task mix; it does not cover calibration-set variability, which Section 4.2 measures on three models at about 0.3–0.6 points s.d. per build and which is of the same order as the smaller margins in this table. A win counts the same whether the margin is 20 points or 0.5, so the last column shows how broad each gain is: at two bits our build is higher on 82% of all task comparisons pooled over the four dense models and the four trellis baselines (313 of 384), 69% at three bits (266 of 384) and 65% at four bits (161 of 248). The margin shrinks with model size, as quantization loss does in general (Li et al., 2024), and is largest on generative tasks (GSM8K +14 to +21 points against +2 to +3 on multiple choice), but survives their removal: without GSM8K the margin over Proteus is +2.8 instead of +3.6 points and every contrast but one remains significant. The table-free variant across cells. Across the nine model× tier cells of Table E.2, the table-free build stays ahead of QTIP in all nine and is ahead of Proteus or within 0.2 points of it in all nine. Table E.1: Paired differences in downstream accuracy (points) between our build and each trellis baseline, over tasks. ModelTierContrast∆95% CI wins/n Qwen3-4B2-bit CurveTQ− Proteus+3.89 [+2.69, +5.13]29/34 Qwen3-4B2-bit CurveTQ− QTIP+5.00 [+3.39, +7.03]31/34 Qwen3-4B2-bit CurveTQ− Proteus +g64 +4.54 [+2.83, +6.98]30/34 Qwen3-4B2-bit CurveTQ− QTIP +g64 +3.97 [+2.53, +5.62]29/34 Qwen3-4B2-bit CurveTQ− Proteus +start +0.86 [−0.21, +1.88]24/34 Qwen3-4B2-bit CurveTQ− QTIP +start +2.03 [+1.14, +2.97]27/34 Qwen3-4B2-bit CurveTQ− Proteus +start+g128 +1.26 [+0.29, +2.22]24/34 Qwen3-4B2-bit CurveTQ− QTIP +start+g128 +2.69 [+1.64, +3.88]28/34 Qwen3-4B3-bit CurveTQ− Proteus+0.93 [+0.40, +1.48]26/34 Qwen3-4B3-bit CurveTQ− QTIP+1.06 [+0.28, +1.90]25/34 Qwen3-4B3-bit CurveTQ− Proteus +g64 +0.21 [−0.58, +0.94]22/34 Qwen3-4B3-bit CurveTQ− QTIP +g64 +1.18 [+0.26, +2.09]26/34 Qwen3-4B3-bit CurveTQ− QTIP +start +0.35 [−0.29, +0.95]22/34 Qwen3-4B3-bit CurveTQ− Proteus +start −0.05 [−0.79, +0.65]18/34 Qwen3-4B4-bit CurveTQ− Proteus+0.03 [−0.43, +0.51]20/34 Qwen3-4B4-bit CurveTQ− QTIP+0.25 [−0.29, +0.88]23/34 Qwen3-4B4-bit CurveTQ− Proteus +g64 −0.24 [−0.75, +0.19]19/34 Qwen3-4B4-bit CurveTQ− QTIP +g64 +0.06 [−0.63, +0.71]19/34 Llama-3-8B2-bit CurveTQ− Proteus+4.45 [+2.37, +7.40]13/14 Llama-3-8B2-bit CurveTQ− QTIP+4.42 [+2.39, +7.11]13/14 Llama-3-8B2-bit CurveTQ− Proteus +g64 +4.90 [+3.03, +7.43]13/14 Llama-3-8B2-bit CurveTQ− QTIP +g64 +4.81 [+3.22, +7.17]14/14 Llama-3-8B2-bit CurveTQ− Proteus +start +1.17 [+0.09, +2.39]9/14 Llama-3-8B2-bit CurveTQ− QTIP +start +2.17 [+0.99, +3.68]13/14 Llama-3-8B2-bit CurveTQ− Proteus +start+g128 +0.36 [−0.54, +1.26]7/14 Llama-3-8B2-bit CurveTQ− QTIP +start+g128 +2.72 [+0.92, +5.10]11/14 Llama-3-8B3-bit CurveTQ− Proteus+0.71 [−0.11, +1.67]11/14 Llama-3-8B3-bit CurveTQ− QTIP+1.28 [+0.76, +1.88]13/14 Llama-3-8B3-bit CurveTQ− Proteus +g64 +0.83 [+0.14, +1.52]11/14 Llama-3-8B3-bit CurveTQ− QTIP +g64 +0.44 [−0.27, +1.05]11/14 Llama-3-8B3-bit CurveTQ− QTIP +start +0.67 [+0.17, +1.18]12/14 Llama-3-8B3-bit CurveTQ− Proteus +start +0.17 [−0.28, +0.68]8/14 Llama-3-8B4-bit CurveTQ− Proteus+0.31 [−0.20, +1.03]8/14 Llama-3-8B4-bit CurveTQ− QTIP+0.37 [+0.08, +0.67]12/14 Llama-3-8B4-bit CurveTQ− Proteus +g64 +0.48 [−0.00, +1.19]10/14 Llama-3-8B4-bit CurveTQ− QTIP +g64 +0.65 [+0.32, +0.95]11/14 Llama-3.1-8B2-bit CurveTQ− Proteus+2.49 [+0.19, +5.25]10/14 Llama-3.1-8B2-bit CurveTQ− QTIP+4.20 [+2.05, +6.55]11/14 Llama-3.1-8B2-bit CurveTQ− Proteus +g64 +3.02 [+1.22, +5.00]11/14 Llama-3.1-8B2-bit CurveTQ− QTIP +g64 +5.15 [+2.75, +8.08]12/14 Llama-3.1-8B2-bit CurveTQ− Proteus +start +1.44 [+0.30, +2.76]10/14 20 Table E.1 continued ModelTierContrast∆95% CI wins/n Llama-3.1-8B2-bit CurveTQ− QTIP +start +3.10 [+1.39, +5.16]11/14 Llama-3.1-8B2-bit CurveTQ− Proteus +start+g128 +1.02 [+0.13, +1.94]10/14 Llama-3.1-8B2-bit CurveTQ− QTIP +start+g128 +2.62 [+0.67, +5.07]10/14 Llama-3.1-8B3-bit CurveTQ− Proteus+0.95 [+0.22, +1.73]11/14 Llama-3.1-8B3-bit CurveTQ− QTIP+0.70 [+0.00, +1.43]12/14 Llama-3.1-8B3-bit CurveTQ− Proteus +g64 −0.38 [−0.86, +0.12]5/14 Llama-3.1-8B3-bit CurveTQ− QTIP +g64 +0.06 [−0.66, +0.73]10/14 Llama-3.1-8B3-bit CurveTQ− QTIP +start −0.27 [−1.05, +0.37]9/14 Llama-3.1-8B3-bit CurveTQ− Proteus +start −0.29 [−0.98, +0.35]8/14 Llama-3.1-8B4-bit CurveTQ− Proteus+0.28 [−0.16, +0.85]9/14 Llama-3.1-8B4-bit CurveTQ− QTIP+0.90 [+0.30, +1.71]11/14 Llama-3.1-8B4-bit CurveTQ− Proteus +g64 +0.34 [−0.28, +1.03]10/14 Llama-3.1-8B4-bit CurveTQ− QTIP +g64 +0.36 [−0.21, +0.92]9/14 Qwen3-32B2-bit CurveTQ− Proteus+1.24 [+0.35, +2.24]25/34 Qwen3-32B2-bit CurveTQ− QTIP+0.88 [+0.06, +1.71]25/34 Qwen3-32B2-bit CurveTQ− Proteus +g64 +0.47 [−0.20, +1.16]22/34 Qwen3-32B2-bit CurveTQ− QTIP +g64 +1.27 [+0.43, +2.24]25/34 Qwen3-32B2-bit CurveTQ− Proteus +start +0.23 [−0.37, +0.90]13/34 Qwen3-32B2-bit CurveTQ− QTIP +start +0.23 [−0.52, +0.96]22/34 Qwen3-32B3-bit CurveTQ− Proteus+0.40 [−0.12, +0.90]21/34 Qwen3-32B3-bit CurveTQ− QTIP+0.49 [+0.05, +0.96]22/34 Qwen3-32B3-bit CurveTQ− Proteus +g64 +0.28 [−0.16, +0.73]21/34 Qwen3-32B3-bit CurveTQ− QTIP +g64 +0.28 [−0.14, +0.71]19/34 Qwen3-32B3-bit CurveTQ− QTIP +start +0.43 [+0.06, +0.82]20/34 Qwen3-32B3-bit CurveTQ− Proteus +start +0.35 [−0.04, +0.74]21/34 Qwen3.6-35B-A3B 2-bit CurveTQ− Proteus+2.13 [+1.42, +2.99]28/30 Qwen3.6-35B-A3B 2-bit CurveTQ− QTIP+2.54 [+1.85, +3.27]28/30 Qwen3.6-35B-A3B 2-bit CurveTQ− QTIP +g64 +2.89 [+1.31, +4.92]26/30 Qwen3.6-35B-A3B 2-bit CurveTQ− Proteus +g64 +3.06 [+1.59, +4.88]25/30 Qwen3.6-35B-A3B 2-bit CurveTQ− QTIP +start +0.56 [−0.10, +1.27]18/30 Qwen3.6-35B-A3B 2-bit CurveTQ− Proteus +start +1.52 [+0.45, +2.81]21/30 Table E.2: The table-free variant: paired differences in downstream accuracy (points) of CURVETQ no LUT against the table variant and against QTIP and Proteus at the neighbouring rate, over tasks, with bootstrap 95% CIs. vs. CurveTQ (with table)vs. QTIPvs. Proteus ModelTier∆ [95% CI] wins/n∆ [95% CI] wins/n∆ [95% CI] wins/n Qwen3-4B2-bit −1.18 [−2.26,−0.21]10/34 +3.82 [+2.09, +5.86]26/34 +2.71 [+1.41, +3.91]27/34 3-bit +0.27 [−0.28, +0.85]17/34 +1.33 [+0.57, +2.15]26/34 +1.20 [+0.65, +1.75]28/34 4-bit −0.20 [−0.70, +0.29]17/34 +0.05 [−0.42, +0.51]20/34 −0.16 [−0.71, +0.31]20/34 Llama-3-8B2-bit −0.55 [−1.18, +0.15]4/14 +3.86 [+2.17, +6.22]13/14 +3.90 [+2.30, +6.37]14/14 3-bit −0.52 [−0.83,−0.24]2/14 +0.76 [+0.11, +1.44]9/14 +0.19 [−0.62, +1.01]10/14 4-bit −0.34 [−0.92, +0.08]5/14 +0.03 [−0.38, +0.38]8/14 −0.02 [−0.47, +0.43]6/14 Llama-3.1-8B 2-bit −2.59 [−4.89,−0.58]3/14 +1.61 [+0.69, +2.44]11/14 −0.10 [−1.09, +0.87]8/14 3-bit +0.74 [+0.05, +1.57]9/14 +1.44 [+0.23, +2.89]11/14 +1.69 [+0.81, +2.99]13/14 4-bit −0.40 [−0.92, +0.05]4/14 +0.50 [+0.02, +1.06]11/14 −0.12 [−0.35, +0.10]6/14 FWEIGHT-SPACE ERROR Table F.1 reports the relative weight-space error under the Hessian norm for every build of Table D.1. Our build has the lowest relative weight-space error in every cell but one (Qwen3-4B at two bits, where Proteus +start+g128 is lower by 0.01). Weight-space error is a build-time diagnostic; the ordering of the other methods on it does not carry over to perplexity or tasks. 21 Table F.1: Relative weight-space error∥W − ˆ W∥ H /∥W∥ H in percent (lower is better), same builds as Table D.1. Bold: best in tier; the fp16-scale variant ( fp16 ) is listed for reference and not ranked. MethodbpwQwen3-4B Llama-3-8B Llama-3.1-8B Qwen3-32B QTIP2.00 + 10.259.419.4310.41 Proteus2.00 + 10.019.179.1910.15 CurveTQ2.298.017.217.228.04 CurveTQ no LUT 2.298.357.607.62– QTIP +g64 2.25 + 10.169.399.4110.43 Proteus +g64 2.25 + 9.909.149.1610.16 QTIP +start 2.19 + 8.748.008.028.86 Proteus +start 2.22 + 8.107.397.418.19 QTIP +start+g128 2.31 + 8.657.998.018.87 Proteus +start+g128 2.34 + 8.007.387.398.19 HIGGS2.2517.3415.6015.63– CurveTQ fp16 2.477.977.187.19– QTIP3.00 + 2.772.502.512.78 Proteus3.00 + 2.582.342.342.60 CurveTQ3.291.981.771.771.99 CurveTQ no LUT 3.292.171.951.95– QTIP +g64 3.25 + 2.672.462.472.73 Proteus +g64 3.25 + 2.512.312.312.56 QTIP +start 3.16 + 2.462.222.222.46 Proteus +start 3.20 + 2.151.941.942.15 QTIP +start+g128 3.31 + 2.382.192.20– Proteus +start+g128 3.34 + 2.091.921.93– HIGGS3.254.674.194.20– NF (Hessian)3.255.985.525.52– CurveTQ fp16 3.471.951.741.75– QTIP4.00 + 0.870.760.76– Proteus4.00 + 0.670.600.60– CurveTQ4.290.520.470.47– CurveTQ no LUT 4.290.550.490.49– QTIP +g64 4.25 + 0.790.730.73– Proteus +g64 4.25 + 0.640.590.59– QTIP +start 4.13 + 0.820.710.71– Proteus +start 4.19 + 0.570.510.51– QTIP +start+g128 4.31 + 0.750.690.70– Proteus +start+g128 4.34 + 0.550.500.51– HIGGS4.251.131.021.02– NF (Hessian)4.251.261.171.17– CurveTQ fp16 4.470.490.440.44– 22 GTASK SUITE AND PER-TASK RESULTS Table G.1: Per-model protocol. “LM linears”: only the language-model linear layers are quantized; the vision tower stays in bf16 and is outside the reported rate, which covers the coded linear layers. Llama-2-7B is the model on which QTIP and Proteus report their headline numbers, so we follow their context length and their four zero-shot tasks and our reproductions can be checked against the published values. CheckpointShort nameCtx. QuantizedTasksMethods run Llama-2-7B (base)Llama-2-7B4096 all linears4 zero-shot (QTIP’s)all, + no-LUT Llama-3-8B-InstructLlama-3-8B4096 all linears14 textall, + no-LUT Llama-3.1-8B-InstructLlama-3.1-8B 4096 all linears14 textall, + no-LUT Qwen3-VL-4B-InstructQwen3-4B4096 LM linears34 (14 + 4 LiveBench + 16 M) all, + no-LUT Qwen3-VL-32B-InstructQwen3-32B4096 LM linears34QTIP, Proteus, ours Qwen3.6-35B-A3B (MoE) MoE4096 expert + attn. linears 30QTIP, Proteus, ours Coverage of the table-free variant. The table-free variant of Section 3.3 is run on the four dense models up to 8B. Tasks and settings. Text tasks other than LiveBench are run through lm-evaluation-harness (Gao et al., 2024) with a vLLM backend, LiveBench (release 2024-11-25; reasoning, mathematics, data analysis and language) through its offi- cial framework, and all multimodal tasks through lmms-eval (Zhang et al., 2025a), with one configuration per task for every method. Few-shot settings follow the Open LLM Leaderboard v1 convention: MMLU 5-shot, GSM8K 5-shot (exact match, flexible answer extraction), ARC-challenge 25-shot, HellaSwag 10-shot (normalized accuracy), Wino- Grande 5-shot; MMLU-Pro and MMLU-ProX (English) use the harness’s 5-shot generative configuration; ARC-easy, PIQA, BoolQ, TruthfulQA (MC2), GPQA-Diamond, IFEval (prompt-level strict accuracy), INCLUDE (43 languages, averaged) and LiveBench are zero-shot. Generation is greedy (temperature 0, one sample per prompt), with a limit of 256 new tokens for GSM8K, 1280 for IFEval, 2048 for MMLU-Pro and MMLU-ProX, and 4096 for LiveBench and for all multimodal tasks, whose task-level limits are raised to the harness’s model-level default of 4096. Text tasks use the harness’s plain completion prompts, without the chat template, for the Qwen3-VL and Llama models; this lowers absolute IFEval scores relative to chat-formatted evaluations but is the same for every method. Qwen3.6-35B-A3B, whose template enables a reasoning mode, is run with its chat template and reasoning disabled, again for every method. LiveBench and all multimodal tasks always apply the model’s chat template, and images are resized to at most 401,408 pixels. Multimodal tasks use the default lmms-eval metric of each benchmark. The tables below list every task behind the means of Table D.2; MMLU 0-shot was also run and is omitted from the means to avoid counting MMLU twice. Reading the tables. Rows are methods grouped by bit tier, with the bits per weight after the method name ( + : published rate plus 0.003 bpw of sign bits); columns are tasks. Within a tier, CURVETQ is the factored-scale build (x.29 bpw) and CURVETQ fp16 the fp16-scale build (x.47 bpw), listed for reference and not ranked. Bold marks the best quantized entry per task within a tier. “–” marks a configuration that was not run. The weaker baselines produce near-zero scores on isolated tasks, e.g. HIGGS on MMLU-Pro at three bits (0.5) and GPTQ on several generative and long-context tasks at two bits; we report these runs as measured and do not re-run or drop them. Likewise, NF (Hessian) has an outlying perplexity on Llama-3.1-8B at four bits (12.77) while its downstream mean is normal. The last column is the unweighted mean over the tasks shown; for Qwen3-4B the means of Table D.2 are over the union of the text and multimodal tables. HABLATIONS: FULL PERPLEXITY LADDER The approximations behind the branch metric. Three approximations are made. First, the block form P b η ⊤ b D b η b of Lemma 1 is exact for the residual of the block factor U −1 b ; by default we propagate each block’s residual through GPTQ’s column factor (divided by diag(U b ), U the upper Cholesky factor of H −1 ), so the block form evaluated on the residual the search sees differs from the true loss by a correction of no fixed sign; in our tests the block factor gave a slightly higher weight-space error. Second, Eq. 2 keeps only the diagonal of D b ; the dropped in-block coupling is corrected neither by the search nor by the between-block feedback. The baselines’ Euclidean search omits both parts; we keep the diagonal. Third, 1/d 2 i conditions on all columns after i, including in-block columns that block feedback never corrects, so it under-weights early in-block columns relative to diag(D b ). The raw diagonal ω i = H i is the weight of the objective without feedback and is kept as a control. Appendix B compares H i with 1/d 2 i on the 34-task suite; both Hessian-derived weights repair the few matrices on which the Euclidean search fails outright, and 1/d 2 i is our default. 23 Table G.2: Llama-3-8B-Instruct: per-task accuracy (%) for every method and bit tier. Method (bpw) MMLUMMLU-Pro TruthfulQA GPQA GSM8K ARC-c ARC-e HellaSwag WinoGr. PIQA BoolQ IFEval MMLU-ProX INCLUDE Mean fp1666.740.852.436.475.462.578.878.875.578.984.544.741.049.3 61.8 2-bit tier CurveTQ 2.2957.227.347.032.847.554.572.672.072.776.382.337.527.438.3 53.2 CurveTQ no LUT 2.2955.426.548.234.945.253.473.771.672.176.980.535.526.537.3 52.7 CurveTQ fp16 2.4756.526.548.728.346.255.272.771.170.776.983.535.126.537.0 52.5 QTIP 2.00 + 51.621.747.531.828.648.170.467.769.975.182.232.522.034.4 48.8 Proteus 2.00 + 52.423.048.130.826.548.871.869.370.375.178.432.023.033.6 48.8 QTIP +g64 2.25 + 52.821.444.930.329.250.967.968.269.874.280.732.521.433.8 48.4 Proteus +g64 2.25 + 52.723.847.524.228.648.868.569.170.773.878.232.424.034.4 48.3 HIGGS 2.2541.814.947.523.28.139.560.655.464.271.373.819.414.926.4 40.1 QTIP +start 2.19 + 56.725.946.933.337.552.370.070.071.376.180.731.626.236.4 51.1 Proteus +start 2.22 + 56.026.848.827.841.853.674.372.173.776.580.536.026.634.5 52.1 3-bit tier CurveTQ 3.2964.237.251.433.871.561.178.177.375.877.584.841.837.446.7 59.9 CurveTQ no LUT 3.2964.637.250.232.370.961.077.277.274.977.483.341.437.446.4 59.4 CurveTQ fp16 3.4765.238.052.034.973.259.876.877.474.978.085.040.938.347.0 60.1 QTIP 3.00 + 63.435.951.032.867.359.377.576.574.778.084.239.636.244.2 58.6 Proteus 3.00 + 64.437.152.128.369.859.076.877.075.377.284.044.437.146.1 59.2 QTIP +g64 3.25 + 64.137.851.232.869.160.676.776.474.677.083.744.938.245.3 59.5 Proteus +g64 3.25 + 64.036.351.535.968.360.375.676.775.378.083.539.036.446.2 59.1 HIGGS 3.2561.634.050.337.461.358.175.075.474.376.983.242.034.242.9 57.6 GPTQ 3.2556.926.948.334.941.555.269.673.472.075.180.135.527.535.1 52.3 QTIP +start 3.16 + 64.036.650.631.368.860.877.677.075.877.383.843.136.546.1 59.2 Proteus +start 3.20 + 64.837.353.033.869.261.277.077.275.177.484.142.737.346.0 59.7 4-bit tier CurveTQ 4.2966.140.052.236.475.262.077.978.575.778.884.345.340.248.6 61.5 CurveTQ no LUT 4.2965.940.052.432.875.362.478.978.275.278.384.344.539.748.6 61.2 CurveTQ fp16 4.4766.140.652.135.974.762.079.078.775.678.984.843.440.748.7 61.5 QTIP 4.00 + 66.039.851.634.975.162.377.778.374.778.484.944.039.948.4 61.1 Proteus 4.00 + 66.540.151.632.373.662.077.978.377.078.584.645.740.148.5 61.2 QTIP +g64 4.25 + 65.539.552.434.373.362.179.577.975.277.884.043.239.348.0 60.9 Proteus +g64 4.25 + 66.140.051.831.374.062.678.178.575.878.584.744.240.448.5 61.0 HIGGS 4.2565.639.451.533.873.160.778.577.875.277.683.943.839.647.8 60.6 NF 4.2565.239.151.332.371.660.277.877.875.876.583.442.039.346.7 59.9 GPTQ 4.2564.037.051.031.366.461.977.976.775.478.384.042.937.345.6 59.3 QTIP +start 4.13 + 66.139.753.434.375.462.078.278.075.178.385.144.539.948.3 61.3 Proteus +start 4.19 + 66.040.151.937.974.261.876.878.476.478.884.544.440.248.5 61.4 24 Table G.3: Llama-3.1-8B-Instruct: per-task accuracy (%) for every method and bit tier. Method (bpw) MMLUMMLU-Pro TruthfulQA GPQA GSM8K ARC-c ARC-e HellaSwag WinoGr. PIQA BoolQ IFEval MMLU-ProX INCLUDE Mean fp1668.343.354.533.377.961.479.680.478.681.385.345.843.152.4 63.2 2-bit tier CurveTQ 2.2959.926.750.927.349.750.973.273.574.977.982.741.826.839.4 54.0 CurveTQ no LUT 2.2957.324.543.429.836.653.873.672.672.977.882.034.424.935.6 51.4 CurveTQ fp16 2.4758.425.948.827.347.352.473.772.375.378.781.941.426.039.4 53.5 QTIP 2.00 + 54.321.444.426.335.151.875.869.871.678.180.832.521.733.2 49.8 Proteus 2.00 + 54.524.447.033.333.952.773.271.374.078.882.535.924.334.7 51.5 QTIP +g64 2.25 + 53.921.139.927.330.251.472.669.471.376.781.733.621.632.7 48.8 Proteus +g64 2.25 + 54.522.147.831.338.151.673.470.773.277.081.735.121.934.9 51.0 HIGGS 2.2539.611.941.927.311.137.261.156.464.272.574.920.712.027.1 39.8 QTIP +start 2.19 + 56.924.642.425.236.552.374.071.073.278.378.038.324.836.8 50.9 Proteus +start 2.22 + 58.726.447.428.847.453.270.872.973.277.981.633.827.136.3 52.5 3-bit tier CurveTQ 3.2966.438.651.534.971.758.676.578.977.780.485.144.238.749.8 60.9 CurveTQ no LUT 3.2966.638.554.039.472.859.879.278.978.080.584.243.638.549.2 61.7 CurveTQ fp16 3.4766.539.653.934.372.460.079.378.977.180.385.643.440.049.3 61.5 QTIP 3.00 + 66.038.450.430.870.459.475.878.275.780.284.746.438.648.3 60.2 Proteus 3.00 + 65.637.051.630.370.259.578.278.676.279.884.542.537.847.9 60.0 QTIP +g64 3.25 + 66.038.353.532.370.159.178.678.777.080.484.446.438.448.8 60.9 Proteus +g64 3.25 + 65.238.553.336.472.558.878.278.677.081.085.345.539.148.9 61.3 HIGGS 3.2564.334.452.028.867.558.576.576.576.079.083.645.734.244.9 58.7 GPTQ 3.2555.724.047.230.340.254.075.273.572.878.179.237.324.336.0 52.0 QTIP +start 3.16 + 66.238.452.033.871.859.479.578.577.680.084.747.938.448.7 61.2 Proteus +start 3.20 + 65.738.853.935.970.761.278.878.777.380.784.843.638.648.3 61.2 4-bit tier CurveTQ 4.2968.042.153.737.478.460.878.580.278.181.585.144.942.051.7 63.0 CurveTQ no LUT 4.2967.841.454.334.976.160.579.480.178.580.684.945.341.551.5 62.6 CurveTQ fp16 4.4767.641.754.231.376.760.879.180.377.581.385.045.341.851.8 62.5 QTIP 4.00 + 67.741.154.232.377.260.078.779.777.780.585.342.541.851.0 62.1 Proteus 4.00 + 67.941.954.034.377.061.379.279.978.781.184.545.741.851.3 62.7 QTIP +g64 4.25 + 67.441.353.734.976.361.177.779.778.081.285.846.841.651.7 62.7 Proteus +g64 4.25 + 67.841.954.533.876.760.378.679.977.781.085.047.142.051.4 62.7 HIGGS 4.2567.441.853.934.976.360.480.379.778.080.685.147.141.550.8 62.7 NF 4.2566.741.053.935.476.760.878.579.676.881.085.443.840.949.5 62.1 GPTQ 4.2565.437.653.036.971.259.379.879.077.980.285.150.137.948.0 61.5 QTIP +start 4.13 + 68.041.453.635.475.861.479.879.777.580.985.344.041.651.0 62.5 Proteus +start 4.19 + 67.841.353.935.477.061.379.780.178.481.085.447.141.951.9 63.0 25 Table G.4: Qwen3-VL-4B-Instruct, text tasks: per-task accuracy (%) for every method and bit tier. Method (bpw) MMLU MMLU-ProTruthfulQA GPQA LB-Lang GSM8KARC-cARC-e HellaSwag WinoGr. PIQABoolQ LB-Reason LB-Math LB-DA IFEval MMLU-ProX INCLUDE Mean fp1664.856.659.835.934.187.465.378.569.666.2 77.086.155.941.052.8 54.356.954.6 60.9 2-bit tier CurveTQ 2.2963.935.055.625.823.668.756.370.662.663.4 74.586.312.69.928.3 43.135.342.1 47.6 CurveTQ no LUT 2.2962.132.053.930.321.563.254.165.360.464.0 73.584.06.76.131.2 32.031.840.6 45.1 CurveTQ fp16 2.4763.834.257.229.821.269.559.373.862.964.2 74.885.211.510.327.0 41.034.542.2 47.9 QTIP 2.00 + 59.425.954.127.816.339.552.269.358.962.5 73.084.210.87.015.2 34.925.939.8 42.0 Proteus 2.00 + 60.425.456.327.815.055.852.466.259.062.9 73.985.216.25.022.9 33.125.636.2 43.3 QTIP +g64 2.25 + 59.425.647.928.316.347.553.562.358.863.7 72.783.511.36.722.2 30.925.837.6 41.9 Proteus +g64 2.25 + 59.929.053.627.318.530.754.267.461.064.7 72.583.65.95.020.4 35.729.240.9 42.2 HIGGS 2.2546.615.847.225.89.121.242.759.149.059.3 69.181.810.13.78.7 24.216.127.5 34.3 GPTQ 2.2524.02.749.923.71.51.523.630.837.452.7 55.642.90.01.40.0 10.22.825.6 21.5 QTIP +start 2.19 + 62.828.354.928.317.358.557.269.860.466.1 73.386.19.38.224.4 40.528.840.7 45.3 Proteus +start 2.22 + 63.230.854.133.321.764.254.875.060.865.1 74.484.37.59.124.2 34.230.542.6 46.1 3-bit tier CurveTQ 3.2970.852.258.232.829.185.862.577.467.765.7 76.786.743.038.048.4 54.553.051.9 58.6 CurveTQ no LUT 3.2970.552.057.534.930.985.962.677.668.067.6 76.086.642.035.146.1 51.852.251.7 58.3 CurveTQ fp16 3.4771.251.957.935.431.584.663.577.667.665.9 76.286.548.237.945.9 53.252.052.4 58.9 QTIP 3.00 + 70.048.856.930.329.083.162.579.067.167.0 76.086.240.730.641.4 55.548.750.1 56.8 Proteus 3.00 + 69.548.957.634.929.285.161.777.266.865.2 75.986.141.335.050.2 50.149.750.9 57.5 QTIP +g64 3.25 + 69.748.958.733.828.284.063.578.067.065.8 77.083.632.930.447.7 53.449.351.0 56.8 Proteus +g64 3.25 + 70.051.159.131.332.978.762.979.768.666.1 76.485.741.437.446.1 53.251.151.9 58.0 HIGGS 3.2568.50.555.831.830.880.460.974.565.366.7 75.184.930.024.538.0 46.045.448.4 51.5 NF 3.2566.343.457.330.822.874.560.277.366.566.4 77.084.822.124.336.4 46.644.046.9 52.6 GPTQ 3.2563.132.255.127.822.661.156.770.064.366.5 74.684.77.35.227.2 40.932.540.9 46.2 QTIP +start 3.16 + 70.551.258.030.829.983.563.175.367.067.3 75.386.947.433.951.5 53.451.551.0 58.2 Proteus +start 3.20 + 69.851.560.029.832.186.563.074.567.865.8 76.385.449.333.247.1 56.452.051.9 58.5 4-bit tier CurveTQ 4.2972.155.359.532.830.887.665.678.969.367.1 77.086.651.640.153.2 53.855.353.6 60.6 CurveTQ no LUT 4.2972.255.459.636.433.588.065.279.268.867.2 77.386.452.238.851.7 55.355.953.8 60.9 CurveTQ fp16 4.4772.355.859.935.432.288.964.878.769.366.8 76.986.853.741.151.9 54.056.253.5 61.0 QTIP 4.00 + 71.854.659.634.934.687.464.879.169.166.1 76.986.452.941.152.9 55.154.853.5 60.9 Proteus 4.00 + 72.055.259.236.933.887.965.478.569.065.8 76.786.350.841.851.1 52.555.753.3 60.6 QTIP +g64 4.25 + 71.954.959.931.833.687.564.579.168.966.8 76.786.348.237.152.2 54.955.253.3 60.2 Proteus +g64 4.25 + 72.154.959.533.333.688.064.578.669.467.1 76.786.852.942.453.0 52.755.353.5 60.8 HIGGS 4.2571.554.660.135.936.078.564.176.768.467.0 76.886.253.637.453.2 53.855.153.3 60.1 NF 4.2571.453.959.736.431.083.065.678.969.266.1 77.585.652.037.254.2 55.854.252.7 60.2 GPTQ 4.2570.651.758.531.827.885.062.378.767.766.3 76.887.145.438.349.0 47.551.751.6 58.2 QTIP +start 4.13 + 71.653.958.833.333.887.065.780.268.666.7 77.186.552.237.353.5 52.954.153.3 60.4 Proteus +start 4.19 + 72.655.059.433.335.688.164.577.869.167.1 76.786.450.244.152.7 55.655.253.9 61.0 26 Table G.5: Qwen3-VL-4B-Instruct, multimodal tasks: per-task accuracy (%) for every method and bit tier. The vision tower is kept in bf16 for all methods. Method (bpw) MMMU MMMU-ProMMStarRealWorldQASimpleVQA AI2D DocVQA InfoVQA MMLongB-Doc BLINKMuirBench VSI-BenchHRB-4K HRB-8K V ∗ -attr V ∗ -pos Mean fp1653.437.663.071.826.1 81.994.879.722.164.452.853.675.772.885.776.3 63.2 2-bit tier CurveTQ 2.2944.928.754.566.813.0 75.293.072.022.757.847.543.274.167.976.567.1 56.6 CurveTQ no LUT 2.2944.032.355.166.912.8 74.492.271.121.156.046.644.974.969.580.967.1 56.9 CurveTQ fp16 2.4744.732.755.266.711.7 74.492.971.520.560.350.139.074.070.182.665.8 57.0 QTIP 2.00 + 41.826.451.862.910.3 70.988.864.522.855.637.932.768.462.871.367.1 52.2 Proteus 2.00 + 42.225.851.664.010.7 70.789.365.022.955.242.434.471.166.577.461.8 53.2 QTIP +g64 2.25 + 44.728.352.864.813.3 72.590.668.722.957.137.738.772.066.675.767.1 54.6 Proteus +g64 2.25 + 43.628.851.863.512.9 70.190.569.018.449.238.436.769.263.975.767.1 53.0 HIGGS 2.2536.821.241.056.32.2 55.366.545.50.839.214.223.463.254.456.556.6 39.6 GPTQ 2.2525.714.221.814.20.0 17.610.915.91.06.91.30.87.910.217.428.9 12.2 QTIP +start 2.19 + 45.026.452.664.812.8 73.691.468.923.256.241.737.271.066.878.368.4 54.9 Proteus +start 2.22 + 43.428.855.668.013.5 74.391.971.322.155.842.042.273.667.981.771.0 56.5 3-bit tier CurveTQ 3.2951.633.761.671.522.1 81.194.478.322.962.447.151.174.871.684.376.3 61.6 CurveTQ no LUT 3.2951.435.061.372.323.2 79.894.579.222.062.351.551.777.074.082.681.6 62.5 CurveTQ fp16 3.4751.633.562.670.522.6 80.994.478.822.462.848.652.075.671.085.273.7 61.6 QTIP 3.00 + 50.734.762.471.021.9 80.093.777.922.461.653.147.474.672.284.372.4 61.3 Proteus 3.00 + 51.135.059.470.120.9 79.694.678.022.662.449.447.474.171.280.076.3 60.8 QTIP +g64 3.25 + 48.233.659.471.121.7 80.394.277.322.661.154.951.073.970.184.372.4 61.0 Proteus +g64 3.25 + 51.433.858.970.624.3 79.294.477.922.161.951.650.975.270.582.682.9 61.8 HIGGS 3.2548.731.758.869.719.3 79.193.876.520.559.547.045.873.168.481.775.0 59.3 NF 3.2547.130.557.766.820.2 75.593.473.922.257.250.146.570.566.078.372.4 58.0 GPTQ 3.2542.728.154.666.518.1 74.791.770.721.856.942.644.871.066.577.467.1 56.0 QTIP +start 3.16 + 51.836.459.969.920.7 79.294.177.022.361.149.351.176.074.582.673.7 61.2 Proteus +start 3.20 + 49.732.160.270.622.5 79.994.678.322.561.850.451.475.572.185.281.6 61.8 4-bit tier CurveTQ 4.2952.836.662.772.325.4 81.594.679.222.463.651.653.075.672.686.180.3 63.1 CurveTQ no LUT 4.2948.434.062.771.524.1 81.494.578.722.563.952.952.775.872.585.276.3 62.3 CurveTQ fp16 4.4752.136.262.871.824.6 81.394.879.522.264.150.952.875.972.182.675.0 62.4 QTIP 4.00 + 52.636.563.071.424.6 81.194.879.222.362.952.652.676.172.580.973.7 62.3 Proteus 4.00 + 54.138.662.372.424.7 81.394.979.322.463.352.053.076.272.284.376.3 63.0 QTIP +g64 4.25 + 52.437.163.570.625.0 81.194.579.322.763.751.952.876.572.087.081.6 63.2 Proteus +g64 4.25 + 52.237.562.270.824.5 81.394.879.122.063.451.754.076.673.287.080.3 63.2 HIGGS 4.2551.434.762.171.224.1 81.294.879.422.364.051.952.874.871.984.379.0 62.5 NF 4.2551.735.162.970.724.9 80.894.879.021.963.149.152.176.073.286.181.6 62.7 GPTQ 4.2548.733.260.370.223.3 80.594.277.621.762.148.251.273.870.285.275.0 61.0 QTIP +start 4.13 + 52.335.562.172.924.6 81.394.579.222.464.750.751.974.972.084.381.6 62.8 Proteus +start 4.19 + 51.637.762.970.324.9 81.394.879.722.064.351.253.875.171.886.175.0 62.7 27 Table G.6: Qwen3-VL-32B-Instruct at the 2- and 3-bit tiers: per-task accuracy (%) on multimodal tasks (top) and text tasks (bottom); the same 34-task suite as Qwen3-4B. Method (bpw) MMMU MMMU-Pro MMStar RealWorldQASimpleVQA AI2D DocVQA InfoVQA MMLongB-Doc BLINK MuirBenchVSI-Bench HRB-4K HRB-8K V ∗ -attr V ∗ -pos Mean fp1661.847.373.677.526.6 86.996.087.622.367.559.560.979.477.086.189.5 68.7 2-bit tier CurveTQ 2.2956.941.968.473.720.8 84.595.584.022.466.257.658.677.475.183.580.3 65.4 QTIP 2.00 + 57.643.266.272.919.6 84.395.383.622.463.251.157.977.174.084.385.5 64.9 Proteus 2.00 + 55.842.367.573.521.0 83.996.083.422.464.052.454.178.174.187.884.2 65.0 QTIP +g64 2.25 + 57.641.368.074.219.8 84.895.684.122.263.254.958.175.473.186.182.9 65.1 Proteus +g64 2.25 + 55.742.767.575.020.3 84.195.784.122.365.254.859.577.175.287.081.6 65.5 QTIP +start 2.19 + 56.440.567.573.120.2 84.595.783.522.466.857.858.977.073.987.084.2 65.6 Proteus +start 2.22 + 56.739.968.873.921.9 84.895.884.022.463.554.958.676.273.482.684.2 65.1 3-bit tier CurveTQ 3.2959.944.272.179.025.8 86.796.287.222.368.261.061.278.576.888.786.8 68.4 QTIP 3.00 + 59.444.673.076.524.9 87.096.386.822.366.360.360.178.476.186.186.8 67.8 Proteus 3.00 + 60.345.872.376.525.0 86.195.886.422.365.957.160.578.877.587.085.5 67.7 QTIP +g64 3.25 + 59.246.772.375.624.7 86.496.286.622.566.957.560.979.276.986.186.8 67.8 Proteus +g64 3.25 + 60.946.871.478.726.1 86.395.986.322.668.156.659.677.076.586.188.2 67.9 QTIP +start 3.16 + 59.444.472.476.525.4 86.196.187.022.466.558.860.378.977.487.086.8 67.8 Proteus +start 3.20 + 60.644.971.577.726.4 86.296.087.322.467.658.259.579.677.886.186.8 68.0 Method (bpw) MMLU MMLU-Pro TruthfulQA GPQA LB-LangGSM8K ARC-c ARC-eHellaSwag WinoGr. PIQA BoolQ LB-ReasonLB-Math LB-DA IFEval MMLU-ProX INCLUDE Mean fp1683.774.060.640.949.888.574.784.884.078.2 82.090.772.052.764.2 66.474.166.7 71.5 2-bit tier CurveTQ 2.2980.366.959.137.947.686.370.883.880.577.3 81.090.458.840.458.9 56.466.963.7 67.1 QTIP 2.00 + 79.564.256.241.940.988.769.185.879.677.1 81.690.057.637.956.3 52.164.162.8 65.9 Proteus 2.00 + 79.864.458.439.936.987.769.683.279.475.8 80.890.157.036.252.0 52.564.362.7 65.1 QTIP +g64 2.25 + 79.365.858.538.440.877.469.983.779.776.9 80.589.854.741.148.8 54.965.963.0 64.9 Proteus +g64 2.25 + 80.264.158.741.440.589.770.185.480.276.1 80.690.656.738.256.9 53.064.363.1 66.1 QTIP +start 2.19 + 80.266.461.343.945.082.069.082.680.377.0 80.890.061.637.552.3 56.266.663.7 66.5 Proteus +start 2.22 + 80.767.259.538.442.186.871.085.380.476.3 81.390.259.342.953.0 58.467.064.7 66.9 3-bit tier CurveTQ 3.2983.172.860.841.950.887.273.485.983.577.2 81.790.968.851.463.4 63.673.266.2 70.9 QTIP 3.00 + 83.072.860.642.948.988.972.581.783.378.8 81.990.871.148.361.6 62.572.766.6 70.5 Proteus 3.00 + 82.372.460.639.948.689.971.784.683.078.5 82.290.770.753.760.3 65.672.167.0 70.8 QTIP +g64 3.25 + 82.772.661.841.949.788.673.484.883.578.1 81.390.571.351.961.6 62.772.667.2 70.9 Proteus +g64 3.25 + 82.873.060.539.450.189.273.885.783.378.4 82.090.770.249.462.1 63.673.066.6 70.8 QTIP +start 3.16 + 82.872.459.142.951.188.274.182.683.177.5 81.090.667.352.860.5 64.572.666.9 70.6 Proteus +start 3.20 + 83.072.960.338.948.986.973.283.783.378.5 81.590.870.850.264.8 63.672.765.8 70.5 The two yardsticks. The search ablations of Section 4.3 separate perplexity from downstream accuracy. The curva- ture weight protects the coordinates with large D i , the outlier input channels, and the two yardsticks disagree on what that protection is worth: a 0.24 improvement in perplexity accompanies a 3.3-point loss downstream, far outside the 0.4-point spread we see on re-evaluating one model. The same decoupling appears in the table-free variant at two bits (Section 4.1), where a 0.06 change in perplexity accompanied a 2.6-point downstream change on Llama-3.1-8B, and it is why we report both yardsticks throughout. Table H.1 repeats the ablation of Table 4 with the rate deltas and the paired downstream differences with bootstrap confidence intervals; the intermediate tail-biting length (T =128) is included there. Table H.2 gives the component ladder of Table 4 on all three dense models and at all three rates, on WikiText-2 perplexity (context 4096). All rows are single calibration-slice builds. The fp16-scale build, at 0.18 bpw more, is not uniformly better than the factored int4 build: it is 0.36 worse on Qwen3-4B at two bits (11.86 against 11.50) and within±0.13 of it, in either direction, on the other eight cells. The removal row also splits the last step of the ladder, which adds the per-module table and the factored field together: of its 1.27 on Qwen3-4B, the factored field over fp16 scales accounts for 0.36 and the per-module table for the rest. The seed noise of the 256-entry EM base, measured on Qwen3-4B with n = 5 seeds, is 0.19 at two bits, 0.09 at three and 0.04 at four; differences below about twice these values should be read as noise. Two regularities hold across models and rates. The edge-indexed row widens the emission window from the 14-bit state of 28 Table G.7: Qwen3.6-35B-A3B (mixture of experts) at the 2-bit tier: per-task accuracy (%) on multimodal tasks (top) and text tasks (bottom); the mean is over 30 tasks. + : published rate plus 0.003 bpw of sign bits. Method (bpw) MMMU-Pro MMStar RealWorldQASimpleVQA AI2D DocVQA InfoVQA MMLongB-DocBLINK VSI-Bench HRB-4KHRB-8K V ∗ -attr V ∗ -pos Mean fp16 1645.371.375.731.6 88.095.886.722.369.660.879.575.986.184.2 69.5 CurveTQ 2.2935.369.676.128.9 85.994.882.121.866.257.477.674.584.382.9 67.0 QTIP 2.00 + 32.666.575.026.5 81.593.780.022.160.355.973.070.285.279.0 64.4 Proteus 2.00 + 33.166.974.427.3 85.894.279.322.760.156.274.470.579.180.3 64.6 QTIP +g64 2.25 + 34.863.975.326.0 69.394.580.521.542.257.076.972.481.782.9 62.8 Proteus +g64 2.25 + 35.966.074.029.1 84.194.681.821.755.252.176.173.884.364.5 63.8 QTIP +start 2.19 + 38.871.973.930.1 85.593.980.522.365.657.875.573.886.177.6 66.7 Proteus +start 2.22 + 31.069.175.028.5 71.193.681.322.563.257.075.171.286.173.7 64.2 Method (bpw) MMLU MMLU-ProGPQALB-LangGSM8K ARC-c HellaSwag WinoGr. PIQABoolQ LB-Reason LB-MathLB-DA IFEvalMMLU-ProXINCLUDEMean fp16 1682.478.146.052.588.872.082.876.2 82.885.073.354.864.3 82.477.768.0 72.9 CurveTQ 2.2981.973.545.041.688.970.481.275.2 82.488.065.642.353.8 80.072.964.3 69.2 QTIP 2.00 + 80.872.439.436.087.469.879.873.9 81.287.557.839.949.8 76.771.862.5 66.7 Proteus 2.00 + 81.072.940.437.187.569.580.274.5 81.988.655.640.953.3 77.172.863.2 67.3 QTIP +g64 2.25 + 81.072.541.435.989.570.080.173.3 81.089.957.343.150.4 79.771.362.6 67.4 Proteus +g64 2.25 + 80.771.141.933.587.869.180.775.6 81.187.249.736.549.5 80.470.963.6 66.2 QTIP +start 2.19 + 81.673.842.936.487.271.280.776.1 81.588.862.040.055.2 79.573.963.6 68.4 Proteus +start 2.22 + 81.273.847.540.788.468.581.374.6 81.283.165.643.854.9 78.273.564.1 68.8 Table H.1: Table 4 in full: rate deltas, and paired differences to the reference row with 95% CIs over the 34 tasks. WikiText-2 pplDownstream (34 tasks) Configurationbpw∆bpwppl∆ mean ∆ [95% CI] Building up the codec (each row adds one component to the row above) 128-entry table, EM fit (start)2.46913.3250.4 + closed-form quantile fit2.469 +0.000 13.05 −0.2850.8 +0.3 [−0.6, +1.3] + int8 second-level scales2.345 −0.124 13.46+0.4150.9 +0.1 [−0.6, +1.0] + edge-indexed emission2.345 +0.000 12.19 −1.2751.9 +1.0 [−0.6, +2.4] + int4 scales (flat grid)2.282 −0.062 12.77+0.5851.0 −0.8 [−1.9, +0.0] + factored int4 scales, per-module table (= CURVETQ)2.289+0.00611.50−1.2651.8+0.8 [−0.0, +1.7] Removing one component from CURVETQ − factored scales (fp16 scales)2.469 +0.180 11.86+0.3552.2 +0.4 [−0.3, +1.1] − emission table (computed code)2.289 −0.000 13.63+2.1350.7 −1.2 [−2.2,−0.2] Ablating the search (from the quantile-fit row above) − error feedback2.469 +0.000 13.38+0.3448.2 −2.5 [−4.3,−1.4] Euclidean branch metric instead of 1/d 2 i 2.469 +0.000 12.81 −0.2447.4 −3.3 [−4.5,−2.3] Block termination (from CURVETQ; Section 3.1) chained trellis, one start state per row2.073 −0.216 13.59+2.0946.4 −5.5 [−7.0,−4.2] tail-biting block, no start state2.069 −0.220 15.60+4.1046.8 −5.1 [−6.9,−3.5] same, two rows per sequence (T =128)2.069 −0.220 14.62+3.1246.8 −5.0 [−6.5,−3.5] same, four rows per sequence (T =256)2.069 −0.220 13.38+1.8847.7 −4.2 [−6.4,−2.5] the row above to 16 bits at the same 2 14 survivors; it is not a difference from QTIP’s node-emitting form, which emits from the same 16-bit window (Section 3.3). Every component’s effect shrinks with rate: the edge-indexed emission is worth 1.27 perplexity on Qwen3-4B at two bits, 0.17 at three and 0.01 at four, and the emission table 2.13, 0.06 and 0.11. And the effects are larger on Qwen3-4B than on the two Llama models, whose two-bit steps are all within 0.3 perplexity of zero; the bit savings of the rate-buying steps are the same on all models. The search ablations were run at two bits only. 29 Table H.2: WikiText-2 perplexity (context 4096) of every configuration of Table 4, three models× three rates. bpw as in Table 4 (the x in x.469 etc. is the code rate). fp16: Qwen3-4B 9.72, Llama-3-8B 7.68, Llama-3.1-8B 6.67. Qwen3-4BLlama-3-8BLlama-3.1-8B Configurationbpw2-bit3-bit 4-bit2-bit 3-bit 4-bit 2-bit 3-bit 4-bit 128-entry table, EM fitx.469 13.32 10.469.81 10.108.177.809.357.096.79 + quantile fitx.469 13.05 10.249.80 10.128.127.739.157.126.77 + int8 scalesx.345 13.46 10.159.78 10.148.147.789.167.166.78 + edge emissionx.345 12.19 10.319.799.938.037.829.187.096.76 + int4 scales (flat)x.282 12.77 10.379.959.788.117.789.127.126.77 + factored int4 scales (CURVETQ)x.28911.5010.289.689.918.167.759.167.096.77 CURVETQ− factored scales (fp16) x.469 11.86 10.189.839.858.067.769.297.086.75 CURVETQ− tablex.289 13.63 10.349.79 10.018.067.789.237.116.79 quantile fit− error feedbackx.469 13.38– quantile fit, Euclidean metricx.469 12.81– Ablating the block termination: the full comparison. The last block of Table 4 replaces our block-local trellis by the two constructions that store no per-block state, at an otherwise identical recipe. A row-long chained trellis, in which each block starts in the state the previous block ended in, saves 0.216 bpw and costs 2.09 perplexity and −5.5 [−7.0, −4.2] downstream points; a per-block tail-biting trellis, QTIP’s construction applied to the 64-weight block, saves 0.220 bpw and costs 4.10 perplexity and−5.1 [−6.9,−3.5] points, although its weight-space error is the lower of the two. The chained variant loses on all 34 tasks and the tail-biting one on 32, most on the generative ones (GSM8K−19 and−26, IFEval−14 and−12). Read against Table 1, the chained variant at 2.07 bpw still edges QTIP and Proteus with per-group scales on perplexity (13.59 against 13.72 and 13.99 at 2.25 + ) but not downstream (46.4 against 47.9 and 47.3), and the tail-biting variant trails on both (15.60 against QTIP’s 15.36 at 2.00 + ). Lengthening the tail-biting sequence by stacking rows, at the same 2.07 bpw, recovers 0.98 and 2.22 of the 4.10 perplexity at T = 128 and T = 256; the longer one passes the chained variant (13.38 against 13.59) but still trails the stored start state by 1.84 (Appendix J). Downstream the recovery is smaller and slower than perplexity suggests: the first doubling returns nothing measurable (+0.1 [−1.1, +1.2] over the 64-length block for 0.98 perplexity) and the second returns +0.8 [−0.8, +2.2], so at QTIP’s own tile length the construction is still −4.2 [−6.4, −2.5] points behind the stored start state and loses on 31 of 34 tasks. For comparison, the factored scale field saves 0.18 bpw at a cost of 0.4 [−0.3, +1.1] downstream points two rows above: the start state is the side channel on which a bit buys the most, which is why we keep it and charge it. How much of the margin is the extra rate? The T =256 variant also bounds how much of our margin over the baselines is bought with rate rather than designed, without any assumption about how perplexity trades against bits. It is our recipe with QTIP’s termination and QTIP’s tile length, storing no start bits and carrying a 14-bit state against QTIP’s 16, and it sits at 2.0685 bpw, 0.066 above the baselines’ published 2.003 and 0.219 below ours. At that rate it reaches 13.38 perplexity against QTIP’s 15.36 and Proteus’s 14.21. Our perplexity margin over QTIP on this model therefore splits into 1.98 from the weighted search, the quantile table and the factored scales, spent at 0.066 bpw, and 1.84 from the block-local start state, spent at 0.219 bpw (both halves measured against the same rebuild; 0.04 of the 3.86 in Table 1 is the rebuild’s GPU difference). The two halves are comparable, so on perplexity the stored state is not what creates the gap—it is what doubles it. Downstream the split is one-sided in the other direction: at 47.7 points the variant is +0.8 [−0.9, +2.2] over QTIP and +0.4 [−1.4, +2.0] over Proteus with per-group scales, neither measurable, while the start state is worth +4.2 [+2.5, +6.4]. Without a stored start state the other components recover perplexity at this rate but not accuracy; with one they deliver both. We report the variant as a control, not a configuration to use (it is 1.84 perplexity and 4.2 points worse than the build we ship), and it is run on Qwen3-4B only. The start state transfers. The +start rows of Tables 1, D.1 and D.2 are QTIP from its released code and Proteus from our implementation, each with one change: every 256-weight tile’s trellis is split into four 64-weight segments, each coded by one Viterbi pass whose start and end states are free, i.e. our block-local construction on their trellis and code. Nothing else differs from the published baseline (same rotation, LDLQ, scale and code). At two bits the state is worth 0.7–1.4 perplexity and +1.0 to +3.3 downstream points to the baselines on the three Instruct models, more than the 64-group scale buys them. The gain shrinks with rate: at three bits it is−0.2 to +0.7 points and at four bits within ±0.5. Against these strengthened baselines our two-bit margin is +0.9 to +3.1 points (five of six contrasts exclude zero; Table E.1), +1.2 where Proteus +start has the lower perplexity (Llama-3-8B, 9.83 against 9.91). As in Appendix E, the margin is largest on generative tasks (GSM8K, IFEval and the LiveBench categories: +3.6 to 30 +8.4 points on average) but does not depend on them: over the multiple-choice tasks alone it is +1.5, +1.2 and +2.2 against QTIP +start on the three models, all excluding zero, and +0.2, +0.8 and +0.8 against Proteus +start , within noise; at three and four bits the twelve contrasts lie within±0.7 and two are marginally significant. On Llama-2-7B and Qwen3-32B the start state alone brings the baselines level with us (62.9–63.1, 65.2–66.4 and 66.1–66.9 points on Llama-2-7B at two, three and four bits; 66.0–66.1 on Qwen3-32B at two bits, from 65.0–65.8 without it). IIMPLEMENTATION AND THROUGHPUT MEASUREMENTS Table I.1: Decode throughput (tokens/s) on one RTX 3090 at batch 1, 64 and 128 and at 2, 3 and 4 bits. Llama-2-7B QTIP at batch 1 and fp16 are the published numbers (Tseng et al., 2024b), which our harness reproduces (fp16: 52.25); QTIP publishes batch 1 only, so its batch 64/128 rows, Qwen3-4B fp16 and QTIP, and all Proteus rows are our measurements. “+rot.”: our decoder with QTIP’s activation-side Hadamard added; “−start”: without the stored start state. Bold: fastest of the three codecs. batch 1batch 64batch 128 Model bits fp16 QTIPProt.CTQ +rot. −start QTIP Prot.CTQ QTIP Prot.CTQ L2-7B252.5 127.0 105.9139.0 130.0141.3 1011 10381082 1715 18301927 3119.0 103.5125.7 117.6126.8999 10251071 1702 18051916 4109.0 102.6 114.9 109.9117.3985 10111063 1690 17821907 Q3-4B274.3 153.6 117.9160.8 143.5165.3 1007 10121021 2186 22272268 3144.2 115.4151.7 138.9155.3 1002 10031016 2178 22122246 4137.2 113.2 146.2 133.0148.3997 10001012 2163 21942236 Setup. All kernels are measured on one RTX 3090 in the benchmark setting of QTIP (Tseng et al., 2024b): end- to-end decode steps at batch 1, 64 and 128 and at 2, 3 and 4 bits, captured in a CUDA graph; the reported figure is the median over steps. Our harness reproduces QTIP’s published fp16 throughput on Llama-2-7B (52.25 against their 52.5 tokens/s), so for that model we quote QTIP’s published batch-1 numbers at 2, 3 and 4 bits rather than re- measure them. QTIP reports batch 1 only, so its batch 64/128 rows, and all of its Qwen3-4B rows (a model QTIP does not report), are our runs of its released kernels. Proteus has no public kernel, so all of its rows use a kernel written from its description, and its published throughput is measured on an H800, which we do not have. Its rows here should therefore be read as what that description yields in our harness on this GPU, not as a reproduction of Proteus’s published results; the anchored comparison in this table is the one against QTIP, whose released kernels we run and whose published fp16 figure our harness reproduces. QTIP runs its released HYB code (L = 16, V = 2), the code of its published results and kernels, for accuracy and throughput alike. QTIP and Proteus include the Hadamard transform on the activations that incoherence processing requires at inference; our decoder does not need one. Our decoder is a fused dequantize-and-multiply kernel: one warp per output row loads the block’s start state, walks the trellis, reconstructs each weight by one table read from the emission window (in the table-free variant, the (14+k)-bit window is mixed by one multiply and one xor-shift and the four bytes of the result are summed, centred and divided by the exact standard deviation p 4(256 2 − 1)/12, giving a unit-variance code value; one global scale is then chosen by a nine-point line search on 16 calibration rows, so the stored table of 0.0001 bpw disappears), applies the group scale reconstructed from the factored field, and accumulates against the activation. The “+rot.” arm of Table I.1 runs the same decoder with an activation-side Hadamard inserted before each quantized layer, following QTIP’s transform, so that its cost measures what incoherence processing adds to a decoder that would otherwise not need it; the “−start” arm runs it with every block started from a fixed state, so that its gain measures the decode-time cost of the stored start state. Both arms are decode-only measurements: the resulting models are not the ones evaluated for accuracy. JRATE ACCOUNTING AND STREAM AUDIT Rate accounting. Every bits-per-weight figure in this paper counts the k code bits, all scale side information, the emission table and the L-bit start state of every block; for QTIP and Proteus we add their reported 0.003 bpw of sign bits, marked + . The per-tensor arithmetic and a byte-level audit of the serialized stream follow. Why the start state and not a tail-biting block. QTIP instead codes 256-weight tiles as tail-biting sequences, whose first state is a function of the tile’s own last bits, so no start state is stored and the rate is exactly k (Tseng et al., 2024b). The construction is right for its setting: a long tile over a rotated, near-i.i.d. source, coded without weights, where the tile boundary falls on nothing in particular and the constraint removes only L/256 of the path freedom. Under error feedback it has a cost that the i.i.d. setting hides. The block is the 64-column feedback block, 31 so the constraint removes L/64 of the freedom; and the block is not stationary: its target ̃z carries the residual pushed forward from the previous block, concentrated on the first coordinates, and ω i varies across it. Tail-biting ties the first⌈L/k⌉ coordinates of a block to its last ones, so the coordinates that carry the inherited residual are the ones the search may not choose freely, and their error is passed on again. We measure this directly: with a tail-biting block the reconstruction error at the first block position is 2.6–2.9× the within-block mean, and lengthening the sequence by stacking rows improves it monotonically but has not reached the stored-state result by QTIP’s own tile length (15.60 → 14.62 → 13.38 at T = 64, 128, 256, against 11.54; Table J.3): block length is part of the problem, but where the constraint falls matters as much as how much freedom it removes. The freedom is spent where the feedback puts the difficulty: on the built models the error at the first block position is 0.55× the within-block mean and recovers to the mean by position eight. What is counted. For the +start baselines the stored stream of a 64-weight segment is the L-bit start state followed by the code bits; a node-emitting trellis emits from the state itself, so its last KV code bits are never emitted and the segment costs L−KV bits over tail-biting (12 per block for QTIP, V = 2; 14 for Proteus, V = 1; 0.19 and 0.22 bpw at two bits), whereas our edge-emitting trellis uses every code bit and is charged the full L = 14. The reported rate splits into a payload term and the side information the decoder needs, R = R payload + R scale + R state + R table , with the boundary adaptation rate R state = L/G (Section 3.1). Term by term: for a tensor of R rows and C columns coded at k bits with blocks of G = 64, the reported rate is the sum of: k bits per weight for the trellis path; L/G = 14/64 bits per weight for the L-bit start state of every (row, block) pair (Section 3.1); 4/G bits for the int4 residual of the factored scale field, 16/(G· 256) for its fp16 block absmax, 16/C for the fp16 row factor and 16⌈C/G⌉/(RC) for the fp16 column factor; and 128· 8 + 32 bits per tensor for the emission table. Both levels of the scale field are rounded up against the stored fp16 factors, so ˆs ≥ s holds exactly for every group; the builder checks that no normalized weight leaves [−1, 1]. The fp16-scale variant replaces the four scale terms by 16/G. Summed over the coded tensors of each model this gives the “Reported” column of Table J.1; the start-state term is 0.219 bpw for every model, the rest varies with tensor shapes in the fourth decimal. Embeddings, output head, norms, router and vision tower stay in bf16 and are outside the reported rate, which covers the coded linear layers. For reference the table also lists the rate a row-long trellis with one stored state per row would have; that construction is evaluated in Section 4.3. The start state is stored in full: a variant that keeps the top L− b bits of the previous block’s end state and spends only the low b = 8 freely, at 0.125 instead of 0.219 bpw, saves 0.094 bpw and costs 0.51, 0.43 and 0.44 perplexity at two bits on Qwen3-4B, Llama-3-8B and Llama-3.1-8B respectively. Every reported build stores all L bits. Table J.1: Stored rate of every built model. “Code, scales, table” excludes start states; “one state per row” is the hypothetical row-long trellis of Section 4.3; “one state per block” is our coder and the rate reported throughout. ModelkCoded weightsCode + scales + table+ 1 state/row+ 1 state/block (reported) Qwen3-4B23.63 B2.06852.07342.2872 Qwen3-4B33.63 B3.06853.07343.2872 Qwen3-4B43.63 B4.06854.07344.2872 Qwen3-4B, no table23.63 B2.06852.07342.2872 Qwen3-4B, fp16 scales23.63 B2.25002.25492.4688 Llama-2-7B26.48 B2.06692.07032.2857 Llama-3-8B26.98 B2.06672.06992.2855 Llama-3-8B36.98 B3.06673.06993.2855 Llama-3-8B46.98 B4.06674.06994.2855 Llama-3.1-8B26.98 B2.06672.06992.2855 Qwen3-32B231.2 B2.06592.06822.2846 Qwen3-32B331.2 B3.06593.06823.2846 Qwen3.6-35B-A3B230.3 B2.0720–2.2908 Stream audit. To check the arithmetic against bytes, we instrumented the builder to serialize, for every tensor, exactly what a decoder needs: the k-bit symbol stream, the int4 residual codes packed two per byte, the fp16 block absmax, row and column factors, the 128 int8 knots with their fp32 step, and the start states. A separate routine reads those bytes back, regenerates the emission index through the mixer of Section 3.3, walks the trellis and rescales, and compares the result with the tensor the coder wrote into the checkpoint. Table J.2 shows the first decoder layer of Qwen3-4B at k = 2: every component matches its formula to the byte, the full model is recovered bit-exactly from the stream, and the two decoding rows show that the per-block state is what a decoder needs: given one state per row instead, 10.2% of the weights differ. The same check was run on the whole model and on the chained and tail- biting variants of Section 4.3 (Table J.3); all decode bit-exactly at their stated rates. Two further variants lengthen the tail-biting sequence by coding two and four consecutive rows of one 64-column block as a single sequence, leaving 32 feedback and scales per row; the second is QTIP’s length of 256. Both decode bit-exactly with zero stored start bits, their first and last states agree in all 252 modules, and both pack to the same 2.0685 bpw as the 64-length block. Perplexity falls monotonically with sequence length (15.60, 14.62, 13.38 at T = 64, 128, 256), so roughly half of the tail-biting penalty is the shortness of the sequence. The remainder is not: at T = 256 (QTIP’s own tile length, and the length at which its rate argument is stated) the construction still trails a stored start state by 1.84 ppl. The two doublings return−0.98 and−1.24, so we cannot claim the curve has saturated, only that it has not reached the stored- state result by the length the comparison method uses. With a 64-length tail-biting block the error at the first position of a block is 2.6–2.9× the within-block mean (above); lengthening the sequence dilutes that boundary term across more coordinates without removing it. Downstream the ladder does not halve: the two doublings return +0.1 [−1.1, +1.2] and +0.8 [−0.8, +2.2] suite-mean points, neither measurable, against the start state’s +4.2 [+2.5, +6.4]; at T = 256 the construction is still−4.2 points behind and loses on 31 of 34 tasks. The perplexity recovery is therefore not evidence that sequence length can substitute for the stored state, only that perplexity is the less demanding of the two measures here (Section 4.3). Table J.2: Serialized stream of the first decoder layer of Qwen3-4B at k = 2, and whether the checkpoint tensors are recovered from the stream alone. Component (Qwen3-4B, layer 0, 7 tensors, 100.9 M weights)Bytesbpw Trellis payload (k = 2)25,231,3602.000000 Start state, one 14-bit state per (row, 64-weight block)2,759,6800.218750 Scale field: int4 residual788,4800.062500 Scale field: fp16 block absmax (1 per 256 residuals)12,3200.000977 Scale field: fp16 row factor61,4400.004870 Scale field: fp16 column factor8320.000066 Emission table (128 int8 knots + fp32 step, per tensor)9240.000073 Total28,855,0362.287236 Decodes bit-exactly from the stream aboveyes (0 of 100.9 M differ) Decodes from one start state per row insteadno (10.17% of weights differ) Table J.3: Qwen3-4B at k = 2 with the block terminations of Section 4.3 plus a T =256 tail-biting variant, same recipe otherwise. “Packed” is the rate a decoder needs, verified from the serialized stream. The rebuild of our coder was made on a different GPU type from the checkpoint of Table 1 and lands 0.04 perplexity from it (11.54 against 11.50); same-GPU rebuilds are bit-identical, and the checkpoints we release are those of Table 1. Block terminationPacked bpwStart bpwRel. W-errWiki2 ppl Block-local, stored start state (CURVETQ)2.28720.21880.080111.54 Chained, one stored state per row2.07340.00490.114813.59 Per-block tail-biting, no start bits2.068500.109315.60 Tail-biting, two rows (T =128), no start bits2.068500.102614.62 Tail-biting, four rows (T =256), no start bits2.068500.100513.38 33