acceptodds
Under review as a conference paper at ICLR 2027

HYBRIDQUANT: CALIBRATION-FREE ENTROPYCODED E8 LATTICE QUANTIZATION OF THE KV CACHE

Abstract

Compressing the key–value (KV) cache is central to long-context inference: for the compact and distilled models deployed where memory is scarce, the cache, not the weights, sets the limit. Established quantizers force a trade-off: calibration- free methods use fixed-rate scalar codes that leave a large gap to the rate–distortion limit, while entropy-coded compressors close the gap but fit their models to cal- ibration data. An entropy code needs no calibration if the vectors it sees are Gaussian, isotropic and nearly independent across coordinates. HybridQuant achieves this with three rounds of the randomized fast Walsh–Hadamard trans- form, 3d log2 d operations per vector instead of the d^2 of a dense random rotation, then rounds to the E8 lattice and codes with one static rANS code built for a Gaus- sian source; the step follows from the target rate alone, with every side bit counted. We prove how much rotation is needed: one round leaves a spike far from Gaus- sian (Kolmogorov distance 0.34), two bring every input close but leave a floor of order d −1/2 , and three lower it to order 1/d up to a logarithm (0.035 versus 0.0097 at d = 128, computed exactly). A dithered variant has input-independent errors, unbiased attention logits and an attention concentration bound that does not grow with context length, and an exact, calibration-free centering removes the collapse that the projection biases of Qwen2 models cause in rotation-based quantizers. On Qwen2.5-7B, Mistral-7B-v0.3 and Llama-3.1-8B the rate is within 0.003 bits of its target, and at 2.125 bits TurboQuant-MSE has 8.8%, 13.3% and 31.3% higher perplexity than HybridQuant, and a rotated entropy-coded scalar quantizer 2.3%, 3.0% and 6.5% higher, all significant under a paired bootstrap.

Primary area:
probabilistic methods (Bayesian methods, variational inference, sampling, UQ, etc.)
Keywords:
KV-Cache Compression, Large Language Models (LLMs), Vector Quantization, Fast Walsh-Hadamard Transform (FWHT), Wasserstein-2 Optimization, Cornish-Fisher Expansion, Talagrand Concentration, E8 Lattice, Bit Rate Distortion, Sub-Gaussian Tail Bounds, Long-Context Inference.

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_koDpOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper studies per-vector KV-cache quantization under three requirements: no calibration data or per-model fitting, a rate fixed in advance with all side information counted, and applicability across model families. HybridQuant applies three rounds of the randomized fast Walsh–Hadamard transform within each head, scales each row by its fp16 RMS, quantizes 8-dimensional blocks to the E8 lattice with the Conway–Sloane decoder, and codes the lattice points with a static, context-switched rANS model. The code tables, and the step size that meets a target rate, are computed offline by Monte Carlo on a Gaussian source. A dithered variant, HybridQuant-G, adds subtractive Voronoi dither. For models with key/value projection biases (Qwen2), the known biases (rotated by RoPE for keys) are subtracted before quantization and added back afterwards. On the theory side, Theorem 4.1 bounds the Kolmogorov distance to a Gaussian after one, two and three Hadamard rounds for a spike input. Theorem 4.2 applies the Zamir–Feder theorem to show that the dithered error does not depend on the input, and Theorem 4.3 bounds the concentration of the attention output independently of context length. Experiments on Qwen2.5-7B, Mistral-7B-v0.3 and Llama-3.1-8B report wikitext2/C4 perplexity at 2.1–5 effective bits against re-implemented TurboQuant-MSE and KIVI and a rotated entropy-coded scalar quantizer (Rot-ECSQ), with paired bootstrap tests. They add needle retrieval, LongBench-E subsets, one-at-a-time ablations, a sweep over the number of rounds, a check of the rate accounting against real rANS bitstreams, and a comparison under the protocol of two recent preprints.

Critical strengths

S1. Rate–distortion evaluation with fully counted rates and matched controls. Every reported rate includes the fp16 scale, coder flushes and escapes (Eq. 1). The accounting is checked against real rANS bitstreams that round-trip bit-exactly and come out 0.03–0.05% smaller than accounted (App. B.2), and measured rates fall within 0.003 bits of the target (Tables 2, 21). The ablations change one component at a time inside the same pipeline (Table 5: Z vs. E8, Rice vs. rANS, R = 0…3, centering). Rot-ECSQ and the Z-lattice control separate the contribution of E8 from that of entropy coding, and differences are tested with a paired bootstrap over windows and checked over five seeds. At ~2 bits the gains over fixed-rate quantizers are large and consistent across three model families and two datasets: wikitext2 perplexity is 8.8%, 13.3% and 31.3% higher for TurboQuant-MSE^c (Sec. 5.1; the percentages follow from Table 2). Together, these make the central empirical claim credible: a static entropy code designed for a Gaussian source works on real KV caches without calibration and beats fixed-rate scalar codes at equal rate.

S2. Exact projection-bias centering, and the diagnosis behind it. Sec. 3.2 and App. L.1 show that the k/v projection biases of Qwen2 make per-vector rotation quantizers collapse: TurboQuant-MSE without centering exceeds perplexity 4000 at every rate and finds 0/88 needles (Tables 3, 9). The fix is exact, needs no data, is consistent with RoPE and costs no bits (Prop. L.1). It also removes the divergence that recent work avoided by keeping layers in bf16 (Table 26). The fix is simple, but any per-vector KV quantizer can use it. The authors apply it to their baselines, so the comparison is not against a broken baseline.

Critical weaknesses

W1. The deployment setting the paper motivates — a variable-length, entropy-coded cache that attention decodes at every step — is not demonstrated. Requirement (ii) and the "drop-in component whose memory budget is known before the model is loaded" (Sec. 1) assume that the compressed cache can be stored and decoded online. Several points leave this open:

  • All quality results simulate quantization: code lengths are computed on the GPU from the static table, and real rANS encoding and decoding run only on the CPU, on one window per model, as a check of the accounting (Sec. 3.3, App. B.2).
  • There is no GPU decoder and no measurement of decode throughput. Table 23 excludes rANS (App. P.2). Every decoding step must decode all cached streams, each a sequential chain of 4608 symbols under a single 32-bit rANS state (App. B.2). Fixed-rate codes, by contrast, dequantize with a few independent operations per element.
  • The accounting leaves out the per-stream offsets that any implementation needs (Sec. 3.3, about +0.008 bits). This contradicts "with every side bit counted" in the abstract.
  • Only run-level average rates are reported. The spread across heads, layers and streams is not, yet it decides how much memory a fixed per-head budget in a paged cache must reserve.
  • Storage of the partial (up to 31-token) stream before encoding is not discussed; rANS encodes in reverse order, so a stream can only be encoded once it is complete.

The Limitations section disclaims speed. Still, the paper's case against fixed-rate rotation quantizers depends on entropy decoding being affordable in this position, rather than only for storage or transfer, which is where CacheGen and KVTC use it. The TurboQuant paper itself considered entropy-coding its codebook indices and chose not to, "to maintain simplicity and speed" (Zandieh et al., 2026, paragraph "Entropy Encoding Codebook Pointers"). Decode cost is therefore exactly the question this paper has to answer. What would resolve it: a standalone GPU decode benchmark (e.g., one layer at 32k tokens, 8 KV heads) compared with fixed-rate 2-bit dequantization and with the attention kernel; the spread of rates per stream and per head (e.g., maximum and 99th percentile); and headline rates that include the offsets.

W2. The gains from the paper's new ingredients are modest, and the largest margins come from simplified or uncontrolled comparisons.

  • Baselines. Both fixed-rate baselines are simplified re-implementations. TurboQuant-MSE leaves out the split into outlier and regular channels that the TurboQuant KV-cache experiments use, as well as the QJL residual. KIVI keeps no full-precision residual window (Sec. 5, App. Q.1). It is therefore unclear how much of the 8.8–31.3% margin at 2.125 bits survives against the published configurations. No calibration-free fixed-rate vector quantizer is included or cited, although one exists for exactly this setting. NSNQuant (Son et al., NeurIPS 2025) normalizes, centers and Hadamard-transforms each token so that it matches a standard normal, then quantizes with a single reusable codebook, with no calibration. This also makes inaccurate the statement in Sec. 2 that vector quantizers for the KV cache need calibration or training data. Without such a baseline, or at least a fixed-rate E8 codebook after the same rotation, the comparison cannot separate "vector vs. scalar" from "entropy-coded vs. fixed-rate".
  • Prior use of the core principle. Sec. 1 presents its key idea as one entropy code, designed offline for a Gaussian source and applied after a random rotation. The same principle appears in distributed mean estimation: EDEN (Vargaftik et al., ICML 2022, Sec. 4.3) applies a randomized Hadamard transform and entropy-codes quantization intervals with probabilities computed from N(0,1). TurboQuant also discusses entropy-coding its indices with probabilities derived from the coordinate law. Neither is discussed. The paper should position what is new — the KV-cache setting, E8, data-free rate targeting and centering — against them.
  • Matched control. The comparison that isolates the method's own components is Rot-ECSQ and the Z-lattice control, which share the rotation, rANS, rate targeting and centering. It gives 2.3%, 3.0% and 6.5% at 2.125 bits and 0.3–0.5% at 3.125 bits (Tables 2, 5), in line with the textbook 0.65 dB granular gain of E8.
  • Seed and selection. Table 2 reports seed 0. At 2.125 bits HybridQuant scores 6.921 with that seed, about 1.4 standard deviations below its five-seed mean of 6.941 ± 0.014 (Sec. 5). Measured against the mean, the E8-over-Z gain on Qwen shrinks to about 2.0% and the cost of HybridQuant-G to about 0.9%. The paired-bootstrap intervals cover only variation over windows. The default configuration was also chosen on Qwen2.5-7B wikitext2, which is a reported test set (Sec. 5.3).
  • Cross-paper comparison. The comparison with HyperQuant, OCTOPUS and TurboQuant (Sec. 5.1, Table 26) uses numbers reported under different harnesses (fp16 perplexity 7.25 vs. 10.03), with different protected layers, windows and compression ratios (7.5× vs. 2.9–3.0×). In the authors' own harness, TurboQuant-MSE^c loses 26.6% against the 63.0% reported, which shows how much harness and setting move these numbers.
  • Concluding claim. The conclusion that calibration-free and entropy-coded quantization "need not be" a trade-off is never tested against a calibrated entropy coder. KVTC and CacheGen are excluded, and Remark J.4 states that the transform-coding gain given up was not measured.

Why it matters: the evidence currently supports a gain of roughly 2–6.5% perplexity at ~2 bits, and at most 0.5% at ~3 bits, for what the method adds over an entropy-coded rotated scalar quantizer. The larger margins rest on the comparisons above, and the enabling principle has precedents the paper does not discuss. What would resolve it: see Questions 2, 3 and 6, plus a related-work discussion of EDEN, TurboQuant's entropy-coding remark and NSNQuant.

Questions for authors
  1. Can you report GPU rANS decode throughput for a full layer's cache (e.g., 32k tokens × 8 KV heads × K and V), next to fixed-rate 2-bit dequantization and the attention kernel time? Please also give the spread of the realized rate across streams and heads, and say how the partial stream is stored before it is encoded. If decoding is within a small constant factor of fixed-rate dequantization, or if you identify a target setting where decode cost is amortized and show the gains there, I would consider W1 largely resolved.

  2. Can you compare against TurboQuant in the outlier-channel configuration of its KV-cache experiments (e.g., 2.5 and 3.5 bits) and KIVI with its 128-token full-precision window, at matched effective rates that count the fp16 window? A comparison with NSNQuant at 2 bits (its native setting, with side information counted), or with a fixed-rate E8 codebook after the same rotation, would separate the gain from vector quantization from the gain from entropy coding. If HybridQuant keeps a significant margin, for example over 5% perplexity at about 2.5 bits on Llama-3.1-8B, I would consider the baseline part of W2 resolved.

  3. Please report the 2.125-bit rows of Table 2 averaged over the five seeds: HybridQuant, HybridQuant-G, the Z/Rot-ECSQ control, and TurboQuant-MSE^c, whose rotation is also seeded. Please also report tests that include seed variation. Is the default configuration still preferred when chosen on a split that is not used for reporting?

  4. The attention output o^\hat o is a convex combination of the v^t\hat v_t, so Var⟨w,o^⟩≤Vmax⁡2\mathrm{Var}\langle w,\hat o\rangle \le V_{\max}^2 holds trivially. The bound in Thm 4.3 is (4Δˉ2/π2)L2(4\bar\Delta^2/\pi^2)L^2 with L2≥4Vmax⁡2∥q∥2/dL^2 \ge 4V_{\max}^2\|q\|^2/d and Δˉ≥sσk\bar\Delta \ge s\sigma_k, so it is at least (16/π2) s2σq2σk2 Vmax⁡2(16/\pi^2)\,s^2\sigma_q^2\sigma_k^2\,V_{\max}^2. At the 2.125-bit step (s≈1.08s\approx 1.08, i.e., a design SNR of about 10.8 dB, cf. Table 20) this is about 1.9 (σqσk)2Vmax⁡21.9\,(\sigma_q\sigma_k)^2 V_{\max}^2, weaker than the trivial bound once σqσk≳0.73\sigma_q\sigma_k \gtrsim 0.73, i.e., whenever logits vary by order one. Prop. I.3 already gives a deterministic bound independent of T for any quantizer whose error stays in a bounded cell, with or without dither. What does Thm 4.3 add in practice? Could you evaluate the bound on real q,k,vq,k,v and compare it with the measured attention-output error? If there is a regime where the bound is informative, please state it; otherwise I suggest presenting the result as a qualitative statement, not a guarantee.

  5. Thm 4.1 concerns the law of one coordinate over the random signs. The deployed code sees one fixed sign draw shared by all tokens, so for a systematic outlier that recurs in every token, the relevant object is the empirical distribution of one rotated pattern. Remark E.8 covers only the expected empirical CDF. Can you state, or measure, a version for a fixed draw? On real models, R = 0 gives a lower rate and a higher SNR than R ≥ 1 without dither (Table 20, keys: 2.108 bits / 10.86 dB vs. 2.124 / 10.73), and R = 1, 2, 3 cannot be told apart over five seeds (Sec. 5.3). Is there any real-model case, such as layers or heads with massive activations or another model family, where R = 1 or R = 2 measurably misses the target rate? A positive answer would raise my assessment of the theory's practical value.

  6. [Suggestion] To support the conclusion that calibration-free and entropy-coded quantization need not trade off, report the transform-coding gain of Remark J.4, 12log⁡2(AM/GM)\tfrac12\log_2(\text{AM}/\text{GM}) of the per-head K/V covariance eigenvalues, on the three models. Alternatively, compare with one calibrated entropy coder (KVTC or CacheGen) at matched effective bits.

6 comments
AuthorsOpenReview ↗

Response to Reviewer 3 (1/6)

Response to Reviewer 3 (1/6)

Thank you for an unusually concrete review. You stated what would resolve each point, that led us to answer against those criteria. W2 is answered in three parts (baselines, prior principle, matched control and conclusion).

1. W1 / Q1. Is the online, entropy-coded cache deployable?

Reviewer's point. Quality results simulated quantization; there was no GPU decoder or decode-throughput measurement; per-stream offsets were not counted; only run-level average rates were reported; and storage of the partial stream was not discussed. The reviewer asks for GPU decode throughput next to fixed-rate dequantization and the attention kernel, the rate spread across streams and heads, and how the partial stream is stored.

Response: how it is resolved.

Fused GPU kernels decode rANS inside attention, with no fp16 copy (real data). Against fixed-rate E8 decoding in the same kernel design, the entropy-coded kernel runs at 0.85× its speed at saturation and 0.72× at batch 1. The comparator is our own fixed-rate E8 kernel, not a standard 2-bit dequantizer; we believe 0.85× meets the "small constant factor" criterion.

Where the decode cost is amortized: capacity at the largest batch and storage/transfer. On the RTX 5090 (Llama-3.1-8B, 2.1282.128 b stored) HQ-final holds 158 / 48 / 24 sequences at 4k / 16k / 32k against 162 / 44 / 21 for NSNQuant and 26 / 6 / 3 for fp16. Concessions: at batch 1 it is slower than fp16, and on the A100 its throughput is 0.54× / 0.78× / 0.59× fp16's.

Offsets: the block format stores int32 group offsets and charges them; the stored size of the submitted 2.125-b configuration is 2.1282.128 b/elem against 2.1242.124 b metered, so "every side bit counted" now holds for stored bytes.

Rate spread (real rANS bitstreams, submitted configuration, Qwen2.5-7B, one window): per-stream p99/mean is 1.0069 and max/mean 1.0117, so a paged allocator reserving 1.2% above the mean covers every stream measured. HQ-final's spread has not been measured.

Partial stream: rows that do not yet form a complete block are held in fp16, attended exactly and charged at 16 b (HQ-final's recent window). A block is rANS-encoded once it is complete, so reverse-order encoding is never a problem.

TurboQuant's remark that entropy coding costs simplicity and speed is fair, and we now cite it.

Where in the revised paper: App. Y.1, decode kernel against fixed-rate E8 and engine vs evaluation perplexity (p. 84, red); App. Y.2, rate spread per stream and head (p. 84, red); App. Y.3 (p. 85, red); Table 36 (p. 86, red); Sec. 3.3 (p. 6, red); App. B.2, Rate-exact rule and guaranteed mode (p. 21, red); Sec. 6, Limitations and conclusion (pp. 9–10, red); Sec. 2, paragraph "Calibration and precedents" (p. 3, red).

2. W2 (baselines) and Q2. TurboQuant's outlier configuration, KIVI's window, NSNQuant, and vector vs entropy-coded gains

Reviewer's point. Both fixed-rate baselines were simplified, and no calibration-free fixed-rate vector quantizer (NSNQuant) or fixed-rate E8 codebook was included, so "vector vs scalar" was not separated from "entropy-coded vs fixed-rate". The reviewer would consider the baseline part resolved by a margin over 5% at about 2.52.5 b on Llama-3.1-8B against TurboQuant's outlier configuration and KIVI with its window.

Response: how it is resolved.

TurboQuant (our re-implementation of its published channel split, with values at 2.1252.125 b our choice; real data): at K 2.50 / V 2.1252.125 b on Llama-3.1-8B the submitted configuration is −13.31% [−13.78, −12.88] (wikitext2) and −13.57% [−15.48, −12.01] (C4). This meets the >5\gt 5\\% criterion even with the submitted configuration.

NSNQuant (official code at its native 2-bit setting, 2.2382.238 b measured from its stored tensors): HQ-final is −6.44 / −9.21% on Llama-3.1-8B, −2.13 / −2.19% on Mistral and −7.89 / −3.61% on Llama-3.1-70B, with fewer bits; all intervals exclude 0. The submitted, uncentred configuration loses to NSNQuant; App. X.2 explains why, and centring alone is −0.7 to −2.7% against it at matched rate.

Fixed-rate E8 control (same rotation and centring, no entropy coder, exactly 2.1252.125 b; real data): at a fixed lattice, rotation and centring, rANS vs fixed-rate E8 is −1.5% to −3.0% in perplexity.

KIVI with its window: see Reviewer 2, point 2.

Where in the revised paper: Table 1 (p. 8, red); Sec. 5.1, paragraphs "Baselines" and "Perplexity" (p. 7, red); App. X.2 (p. 75, red); App. X.4 (p. 77, red); App. X.5 (p. 77, red); App. X.9, entropy coding against a fixed-rate E8 codebook (p. 78, red); App. Q.1, Baseline implementations (p. 58, red).

AuthorsOpenReview ↗

Response to Reviewer 3 (2/6)

Response to Reviewer 3 (2/6)

3. W2 (prior principle). EDEN, TurboQuant's entropy-coding remark, and the Sec. 2 claim about NSNQuant

Reviewer's point. The key idea, one entropy code designed offline for a Gaussian source after a random rotation, appears in EDEN and in TurboQuant's discussion of entropy coding, and NSNQuant contradicts the claim in Sec. 2 that KV vector quantizers need calibration.

Response: how it is resolved.

We concede both. NSNQuant is a calibration-free vector quantizer that came first, and Sec. 2 is corrected. EDEN already entropy-codes after a randomized Hadamard transform with N(0,1)N(0, 1) probabilities, and TurboQuant describes entropy-coding its indices as an option without adopting it; both are now cited as precedents.

The revised paper positions the contribution against them: the KV-cache setting, E8 with a context-modelled static rANS code, data-free targeting of the total rate, centring, and attention computed on the compressed cache. HyperQuant is cited as concurrent work with a near-identical recipe.

Where in the revised paper: Sec. 1, Contributions (p. 2, red); Sec. 2, paragraph "Calibration and precedents" (p. 3, red); App. M, pointer to the revised Sec. 2 and the PCA-basis comparison (p. 46, red).

4. W2 (matched control, cross-paper comparison, concluding claim)

Reviewer's point. Against the matched Rot-ECSQ / Z-lattice control the gains are 2.3–6.5% at 2.1252.125 b and 0.3–0.5% at 3.1253.125 b, in line with E8's granular gain; the cross-paper comparison mixes harnesses; and the conclusion that calibration-free and entropy-coded need not trade off was never tested against a calibrated coder.

Response: how it is resolved.

Matched control: we agree that E8 itself adds roughly the textbook granular gain at about 2 b and little at about 3 b. The larger new gains come from components HQ-final adds; in the preregistered test-split ablation the fp16 window, the key channel scales and the sink each improve perplexity (real data).

Cross-paper comparison: we agree that harness differences dominate. The revised Sec. 5.1 relies on same-harness runs and keeps the HyperQuant / OCTOPUS protocol comparison only as an appendix check. Our HyperQuant re-implementation matches its paper at 3.0 bps but does not reproduce its reported 2.0-bps gains. An official HyperQuant implementation is public; we did not run it, so the non-reproduction has not been checked against the official code. This is a limitation of our comparison.

Concluding claim: it is now restricted to the calibration-free regime, and we concede that calibrated KVTC is better at low rates (see point 8).

Where in the revised paper: Table 24, component and rounds ablation (p. 64, red); Sec. 5.3, paragraph "Components and rounds" (p. 9, red); Sec. 5.1, paragraphs "Baselines" and "Perplexity" (p. 7, red); App. X.5 (p. 77, red); App. T.2, protocol of HyperQuant and OCTOPUS (p. 65); Sec. 6, Limitations and conclusion (pp. 9–10, red).

5. Q3. Five-seed means, seed-inclusive tests, and selection on a split not used for reporting

Reviewer's point. Table 2 reported seed 0, which flattered HybridQuant on Qwen; the paired intervals covered only windows; and the default was chosen on a reported test set. The reviewer asks for five-seed means of the 2.125-bit rows, tests that include seed variation, and selection on a split not used for reporting.

Response: how it is resolved.

All 2.125-b rows are now reported over 5 × 5 seeds, fully paired on one GPU, with intervals over windows and seeds (real data). Against TurboQuant-MSE$^c$ the submitted configuration is −7.3 / −12.4 / −20.3% (Qwen / Mistral / Llama, wikitext2), and against Rot-ECSQ −1.9 / −2.5 / −6.1%. All 12 cells exclude 0.

The paper's Llama margin of 31.3% came from seed 0, TurboQuant-MSE$^c$'s worst Llama draw; Sec. 5.1 and App. T.1 are corrected. The cost of the submitted HybridQuant-G is +0.90 to +4.04% over the six cells (5 seeds), every interval excluding 0.

Selection is now on validation splits only, confirmed on test, and the preregistered rule holds separately at each of seeds 0–4. Disclosure: test perplexities of the earlier centred mode had been seen before the rule was written.

Where in the revised paper: Table 34 (p. 82, red); Table 1 (p. 8, red); Sec. 5.1, paragraphs "Baselines" and "Perplexity" (p. 7, red); App. T.1 (p. 65, red); App. X.3 (p. 76, red); App. Q, disclosures (p. 57, red); Figure 7 (p. 63, red); Figure 9 (p. 69, red).


AuthorsOpenReview ↗

Response to Reviewer 3 (3/6)

Response to Reviewer 3 (3/6)

6. Q4. What does Theorem 4.3 add?

Reviewer's point. The Theorem 4.3 bound is weaker than the trivial bound whenever logits vary by order one, and Prop. I.3 already gives a deterministic T-independent bound. The reviewer asks what Theorem 4.3 adds, for an evaluation on real data, and otherwise to present it as a qualitative statement.

Response: how it is resolved.

(a) As stated, nothing: your calculation is right, and we replace the theorem. Because o^\hat o is a convex combination of the v^t\hat v_t, Var⟨w,o^⟩≤Vmax⁡2\mathrm{Var}\langle w,\hat o\rangle \le V_{\max}^2 holds trivially. The submitted bound 4Δˉ2π2L2\frac{4\bar\Delta^2}{\pi^2}L^2 with L2≥4Vmax⁡2∣q∣2/dL^2 \ge 4V_{\max}^2\\|q\\|^2/d and Δˉ≥sσk\bar\Delta \ge s\sigma_k is at least 16π2s2σq2σk2Vmax⁡2\frac{16}{\pi^2}s^2\sigma_q^2\sigma_k^2V_{\max}^2; at 2.1252.125 b (s≈1.08s\approx1.08) this is about 1.9(σqσk)2Vmax⁡21.9(\sigma_q\sigma_k)^2V_{\max}^2, weaker than trivial once σqσk≳0.73\sigma_q\sigma_k \gtrsim 0.73, i.e. whenever logits vary by order one. With the paper's definitions it exceeds the trivial bound on all 552 measured head-contexts (simulation of a proved bound on real data).

(b) What replaces it: Theorem 4.3′ (proved; dithered modes only). Under (A1) subtractive Voronoi dither independent per position and block, (A2) no overload and (A3) exact arithmetic, each block error is uniform on ΔtVE8\Delta_t\mathcal V_{E_8} and independent of the input (Zamir–Feder). Efron–Stein with the Payne–Weinberger inequality, applied block by block, gives for every unit vector ww

Var⟨w,o^⟩≤4π2,E[∑ta^t2((ΔtV)2+(ΔtK)2∣q~∣2d⟨w,v^t−o^⟩2)]=:Btok(w),\mathrm{Var}\langle w,\hat o\rangle \le \frac{4}{\pi^2}\\,\mathbb E\Big[\sum_t \hat a_t^2\Big((\Delta^V_t)^2+(\Delta^K_t)^2\frac{\\|\tilde q\\|^2}{d}\langle w,\hat v_t-\hat o\rangle^2\Big)\Big] =: B_{\rm tok}(w),

and the chain

Btok≤4π2E[ΔˉV2∣a^∥22+ΔˉK2∣q~∣2d∑ta^t2(xt−f)2]≤4Δˉ2π2E∣a^∥22(1+4Vmax⁡2∣q~∣2/d)≤4Δˉ2π2L2,B_{\rm tok} \le \tfrac{4}{\pi^2}\mathbb E\big[\bar\Delta_V^2\\|\hat a\rVert_2^2+\bar\Delta_K^2\tfrac{\\|\tilde q\\|^2}{d}\textstyle\sum_t\hat a_t^2(x_t-f)^2\big] \le \tfrac{4\bar\Delta^2}{\pi^2}\mathbb E\\|\hat a\rVert_2^2\big(1+4V_{\max}^2\\|\tilde q\\|^2/d\big) \le \tfrac{4\bar\Delta^2}{\pi^2}L^2,

with xt=⟨w,v^t⟩x_t=\langle w,\hat v_t\rangle and f=⟨w,o^⟩f=\langle w,\hat o\rangle. The chain shows where the submitted bound lost: it replaced each row's own step Δt\Delta_t by the global Δˉ\bar\Delta, each row's deviation ⟨w,v^t−o^⟩2\langle w,\hat v_t-\hat o\rangle^2 by the worst case 4Vmax⁡24V_{\max}^2, and the attention concentration ∣a^∥22=∑ta^t2\\|\hat a\rVert_2^2=\sum_t\hat a_t^2 by L2L^2. Theorem 4.3′ keeps all three exact, and every member of the chain is independent of TT. Corollary A (proved) extends it to centred keys and adds the bias bound ∣⟨w,Eo^−o⟩∣≤2tanh⁡(rˉ/4),hw|\langle w,\mathbb E\hat o-o\rangle| \le 2\tanh(\bar r/4)\\,h_w; Corollary A′ (proved) extends Theorem 4.3′ up to the second inequality of the chain, Proposition I.11 and the bias bound to the guaranteed mode HQ-final-G, covering its fp16 sink and window rows, key scales and rate-exact steps. The last step, the comparison with the submitted constant LL, is not claimed.

(c) Evaluation on real q,K,Vq, K, V (simulation of a proved bound on real data; 3 models, T=4096T = 4096 and 3276832768). Corollary A is below the trivial bound on 4968/4968 validation head-contexts and on 2208/2208 at 32k (evaluated for the earlier centred dithered mode, which shares the inner quantizer with HQ-final-G; not re-run for HQ-final-G itself). Theorem 4.3′ for the submitted dithered mode is below it on 4967/4968. The deterministic bound of Prop. I.3, in centred form (Corollary B), beats the trivial bound on only 8/1104.

(d) Where it is informative. Because each token is weighted by a^t2\hat a_t^2, the bound is informative when attention is spread over many coded tokens (small ∣a^∥22\\|\hat a\rVert_2^2), the typical case in our measurements, and approaches the trivial bound when attention concentrates on a single coded token with large logit noise (our reading of the formula; the paper does not measure the threshold). It holds per forward pass with the layer inputs fixed; during generation, later tokens depend on earlier dither draws through the sampled tokens.

For the undithered default the statement is qualitative, and we say so. No bound of this form can hold (Proposition N1, proved): duplicate value rows receive identical errors under the shared rotation, so their errors add coherently. On real caches the Corollary A expression is exceeded on 134/552 head-contexts, all in layer 0. The correlation-robust Theorem U, fully explicit, beats the trivial bound on only 38/552 head-contexts, and with Monte Carlo marginals it is a median 648× above the measured error. An informative attention-level guarantee therefore needs dither, which is why the paper offers it only in the guaranteed mode.


Reviewer_39CcOpenReview ↗
Rating
2
Confidence
4
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

HybridQuant is a drop-in KV-cache quantizer built to satisfy three self-imposed requirements (§1, p.1): (i) no calibration data or per-model fitting, (ii) a rate fixed in advance with every side bit counted, and (iii) applicability across model families. The method (§3, pp.3-4) applies, per key/value vector within a head: an optional exact projection-bias centering for models such as Qwen2 (§3.2, p.3); three rounds of the randomized fast Walsh-Hadamard transform (3·d·log₂d additions); scaling by the fp16 row RMS and rounding to the E8 lattice; and a single static rANS entropy code built offline for a Gaussian source. The step size follows from the target rate alone via bisection, and side information is counted as 16/d + 32/4096 = 0.133 bit/element at d=128 (Eq. 1, p.16). Two modes are offered: HybridQuant (default, no dither) and HybridQuant-G (subtractive Voronoi dither). The theory (§4, p.5) characterizes how many rotation rounds bring an arbitrary input near Gaussian (Thm 4.1), gives input-independent error for the dithered mode via Zamir-Feder (Thm 4.2), and an attention-concentration bound independent of context length (Thm 4.3). Validation (§5, pp.6-9) covers three 7-8B families, perplexity at six rates, needle retrieval to 32k tokens, LongBench-E, a published protocol comparison, and matched component ablations with paired significance tests.

Critical strengths

S1 — The rate accounting is honest and reliable. Effective bits count all side information, for the baselines too: "fp16 scale and zero point per group for KIVI, the fp16 norm for TurboQuant, and the fp16 RMS and coder flushes for ours" (§5 Setup, p.6). Side information is quantified as 16/d + 32/4096 = 0.133 bit/element at d=128 (Eq. 1, p.16), and the rate is fixed in advance by a data-free bisection and hit within 0.003 bit of target in every run with R≥1 (2.123-2.128 for a 2.125 target; Table 2, p.7; Appendix B.2, p.18). This matters because the paper's promise is a memory budget known before the model loads; a fully-counted rate is what makes the perplexity-versus-rate comparison meaningful at all. S2 — Identifying K/V projection bias as the failure driver is valuable. On Qwen2 the key/value projection biases are known model weights that dominate each row's norm, so a per-vector-scale quantizer sizes its step for the bias and the token-specific part becomes noise; every rotation-based per-vector-scale quantizer the authors tried collapses, TurboQuant included (§3.2, p.3; Appendix L.1, p.34). Without centering, TurboQuant-MSE has wikitext2 perplexity 11093/11639/4207 at 2.125/3.125/4.125 bits (Appendix L.1, p.34; Table 9, p.35) and HybridQuant itself 11226 at 2.124 bits (Table 5, p.9); Mistral, which has no biases, is unaffected; centering is exact and costs no bits (Prop L.1, p.34). The bias breaks the Gaussian/isotropic premise the per-vector scale and the static code rest on, so the collapse-versus-degradation distinction is a concrete, transferable diagnostic for any calibration-free rotation pipeline.

Critical weaknesses

W1 — No end-to-end gains are demonstrated. The authors state this plainly: "Our kernels are unfused and rANS decoding runs on the CPU, so we make no end-to-end speed or memory-traffic claims; a deployment needs a fused GPU decoder and per-stream offsets" (§6, p.9). The only timing reported is per-call: Table 23 (p.49) gives FWHT rounds and the quantize-dequantize round trip for one layer's keys, the third round adding ≈0.05 ms over two and ≈+0.09 ms on 4096 tokens × 8 heads (§5.3, p.9), and the paper itself says these "numbers support the O(Rd log d) cost claim, not end-to-end speed-ups" (Appendix P.2, p.41). This is consequential because the method's value proposition is KV memory and bandwidth, and at these rates the entropy coder, currently on the CPU, is the costly part; without a fused decoder the practical payoff is unestablished. To be clear, the authors disclaim rather than overstate these claims — the objection is that the payoff is undemonstrated, not misrepresented. W2 — The baselines are re-implemented in weakened form. All baselines are the authors' own implementations in one harness (§5 Setup, p.6; Appendix Q.1, p.45). KIVI "unlike the original ... keeps no 128-token full-precision window" (§5 Setup, p.6), and TurboQuant-MSE "omits the two-tier outlier split used in the KV experiments of Zandieh et al. (2026) and the QJL residual" (§5 Setup, p.6). The headline numbers rest on these reductions: Table 2 (p.7) reports 8.8%/13.3%/31.3% lower perplexity than TurboQuant-MSE at 2.125 bits (Qwen/Mistral/Llama), and Table 3 (p.8) puts KIVI-2 at 3 bits at 84% needle accuracy against HybridQuant's 90% at 2.125 — but KIVI is stripped of exactly the recent-token protection that helps retrieval. In fairness, the paper discloses every omission, and offers a counterweight that in teacher-forced perplexity its KIVI's group statistics "include up to g−1 later tokens, a mild advantage to KIVI" (§5 Setup, p.6; Appendix Q.1, p.45). But Appendix Q.1 only labels these as implementation differences ("Hence the label 'TurboQuant-MSE (uniform rate)'") without arguing that removing the window or the outlier split yields a fair comparison; and the g−1 lookahead offsets part of the perplexity gap, not the retrieval gap, where the dropped window matters most.

Questions for authors
  1. On the third rotation round: the lower bounds of Theorem 4.1 are proved, but the R=3 upper bound is a proof sketch whose constants are certified numerically only for d ≤ 512 (Thm 4.1, p.5; Appendix G and Table 28, pp.52-53), and §6 states the third round "does not measurably change perplexity on the models we test" (p.9; cf. Table 5, p.9, where R=0/1/2/3 differ by ≤0.3%). On the real inputs you evaluate, what does the third round buy beyond lowering the two-round floor on synthetic spikes, and should the default be two rounds?
  2. Appendix T notes that "a planned Qwen2.5-14B run and a LongBench-E run of the final default on Qwen did not complete in time" (p.49), and §6 states LongBench-E on Qwen was run only for the initial configuration v1 (p.9; Table 4, p.8). What does the final default achieve on Qwen LongBench-E, given that the Qwen family is where projection-bias centering matters most?
  3. HybridQuant-G costs 1.1% (Qwen) to 3.5% (Llama) perplexity at 2.125 bits and at most 0.1% at 3.125 bits (§5.1, p.6; Table 5, p.9), while its input-independence and context-length-independent attention bound (Thm 4.2/4.3, p.5) are the paper's main theoretical selling point. When is the guaranteed mode the right default, given that the default HybridQuant carries no input-independence guarantee?
6 comments
AuthorsOpenReview ↗

Response to Reviewer 2 (1/6)

Response to Reviewer 2 (1/6)

Thank you for the detailed review. Your highlighted weaknesses are the points on which we did most new work; the three questions follow.

1. W1. No end-to-end gains were demonstrated

Reviewer's point. Kernels were unfused and rANS decoding ran on the CPU, so no end-to-end speed or memory-traffic claim was made; the method's payoff (KV memory and bandwidth) was undemonstrated rather than misrepresented.

Response: how it is resolved.

1. We now have a GPU engine (exact computation). In the submission the entropy coder ran on the CPU and attention used a decoded fp16 copy of the cache; both are gone.

  • Encoder. The GPU block-rANS encoder cuts each stream into independent blocks, each with its own rANS state and a stored offset, so thousands of GPU threads encode and decode blocks in parallel and attention can start reading at any block. Its output is bit-identical to the reference encoder (same bitstream, byte for byte), so every perplexity number in the paper also describes what the engine stores.
  • Fused attention. The kernels read the entropy-coded cache directly: each block is decoded in on-chip memory and used at once, and no fp16 copy of the cache is ever written to GPU memory, so the compressed size is also the resident size. Their attention scores match a float64 reference to 4.25e-6, so decoding inside the kernel adds no error beyond the quantization itself.
  • Streaming. In serving, the cache is built from a prefill and then extended token by token. Streaming prefill plus decode reproduces the one-shot cache exactly, so how the text arrives does not change the stored cache, its rate or its error.

2. Measurements (real data; Llama-3.1-8B, one RTX 5090, largest batch that fits).

4k16k32k
speed vs fp161.82×2.57×2.51×
speed vs NSNQuant0.83×0.99×1.00×
sequences held vs fp166.1×8.0×8.0×
sequences held vs NSNQuant0.98×1.09×1.14×

All capacity figures use the full stored rate, 2.1272.127–2.1282.128 b/elem, which includes block offsets, the fp16 sink, key-channel scales and the 64-token fp16 window.

  • Against fp16. Decoding is memory-bound, so fitting 6–8× more sequences raises total throughput 1.8–2.6× even though each step does extra decoding work. The 8.0× at 16k / 32k is above the 7.4–7.5× memory ratio per token because batch sizes are whole numbers: fp16 fits only 6 and 3 sequences, against 48 and 24 for HQ-final. At 4k it is 6.1× (158 against 26 sequences), because each sequence also holds 6.3 MB of fp16 buffers for its next 64 key and 32 value rows, about 9% of a 4k cache and about 1% of a 32k one.
  • Against NSNQuant, which stores 2.2382.238 b/elem, only about 0.110.11 b more. At 4k the two hold about the same number of sequences (0.98×), and NSNQuant's codebook lookup is cheaper per element than our entropy-plus-lattice decoding, so HQ-final is about 17% slower. At 16k / 32k HQ-final holds 9–14% more sequences, which pays for its slower step and leaves throughput equal. The capacity edge over NSNQuant is therefore about zero at 4k and small at long context; we state this plainly rather than claim a speed or capacity win over NSNQuant.

3. Concessions.

  • Batch 1. HQ-final is slower than fp16: with CUDA graphs it takes 39.2 / 35.4 ms per token at 4k / 32k, against 16.8 / 22.3 ms for fp16 (eager); eager against eager it is 0.34× / 0.50× fp16's speed. At batch 1 the GPU is not short of cache memory, so compression brings nothing and in-kernel decoding is pure extra work.
  • A100. HQ-final is slower than fp16 even at the largest batch (0.54× / 0.78× / 0.59× at 4k / 16k / 32k). The likely cause (inferred, not measured) is compute-bound kernels with launch parameters tuned on the RTX 5090; correctness does not depend on the GPU, as the A100 build passes all 144 CUDA tests.
  • Speed relative to fp16 therefore depends on the hardware, and we make no general speed claim.

4. What we claim: capacity against fp16, plus storage and transfer. Both follow from the stored size and hold on any GPU. Restoring a cached 32k-token prefix (e.g. a returning chat session or a shared system prompt; real data):

Restoring a cached 32k-token prefixTimevs HQ-final
HQ-final, from NVMe143 ms—
fp16 offload473 ms3.3× slower
recomputing the prefix4081 ms28.5× slower

The compressed cache loads directly into the format the fused kernel reads, so restoring is a transfer of about 7.5× fewer bytes with no decoding step. Restored caches are bit-identical, and the logits equal those of a run that never offloaded.

The "no speed claims" sentence of Sec. 6 is replaced by these results and their limitations.


AuthorsOpenReview ↗

Response to Reviewer 2 (2/6)

Response to Reviewer 2 (2/6)

1. W1. No end-to-end gains were demonstrated (continued)

Where in the revised paper: Table 36 (p. 86, red); App. Y.1 (p. 84, red); App. Y.3 (p. 85, red); App. Y.5 (p. 85, red); Sec. 3.3 (p. 6, red); Sec. 6, Limitations and conclusion (pp. 9–10, red).

2. W2. Baselines re-implemented in weakened form

Reviewer's point. All baselines were the authors' implementations: KIVI kept no 128-token full-precision window and TurboQuant-MSE omitted the outlier split and the QJL residual. The headline margins rest on these reductions, and the dropped window matters most for retrieval.

Response: how it is resolved.

Official code and full rate accounting (real data). KIVI, NSNQuant, SpinQuant and CacheGen are run from their official code. TurboQuant and KVTC have no official implementation that we could find at the time of our experiments, and HyperQuant's official code is public but we did not run it; these three are our re-implementations of the published configurations. Every rate counts all stored bits: payload, norms, scales, sinks, block offsets and fp16 windows. The windows matter: a full-precision window of recent tokens is cheap per token but not free, because it stores ww tokens at 16 b instead of bb bits, so leaving it out makes a method look cheaper than it is, most of all at short context. We charge KIVI's 128-token window and our own 64-token window the same way, so the comparisons below are at equal total stored bits.

KIVI with its official 128-token window (real data; Llama-3.1-8B; ours − KIVI, perplexity, wikitext2 / C4; negative = ours better):

Rate (both sides)Our earlier centred mode vs KIVI
2.4652.465 b−17.1 / −26.4%
3.2033.203 b−5.3 / −6.7%

The advantage shrinks as the rate rises, as expected: with more bits KIVI's per-group scalar error falls quickly and its fp16 window matters less. These rows use our earlier centred mode; the new default HQ-final is better again than that mode (Table 24), so they understate the current method.

Retrieval with KIVI's window (needle-in-a-haystack, 88 trials per model on the Instruct models, greedy decoding of the answer; real data). KIVI-2 with its official 128-token window scores 72 (Qwen) and 84 (Llama), against 88 and 88 for the submitted configuration at 3.03.0 b (ours − KIVI = +16 and +4 trials). Because HQ answers every trial correctly, every trial KIVI fails is a discordant pair in HQ's favour, so the exact McNemar test gives p=3.1×10−5p = 3.1 \times 10^{-5} for Qwen (significant) and p=0.125p = 0.125 for Llama (not significant; exact computation). The Llama +4 is also within the 2–6-trial spread we see between seeds on identical hardware. HQ-final at 2.1252.125 b, the lower rate, scores 88/88 on Llama-3.1-8B-Instruct.

TurboQuant in its published two-tier outlier configuration (re-implemented; no official implementation found at the time of our experiments). The published part is the key split: 32 outlier channels at 3 b plus 96 at 2 b, i.e. 2.252.25 b of payload, or 2.502.50 b per key element once the two fp16 norms are charged; the value rate of 2.1252.125 b is our pairing. At K 2.50 / V 2.1252.125 b the submitted configuration is −13.31% [−13.78, −12.88] (wikitext2) and −13.57% [−15.48, −12.01] (C4) on Llama-3.1-8B; the paired 95% intervals exclude zero. At K 3.75 / V 3.1253.125 b (64 channels at 4 b plus 64 at 3 b) the gap narrows but stays: −1.86 / −2.48%.

Rate accounting in the paper (App. Q.1). App. Q.1 now lists, for every baseline, each component the submission left out and what it costs in rate:

  • KIVI: its 128-token fp16 window is kept and charged; at group size 128 the measured rate is K 2.25 / V 2.67972.6797 b/elem (mean 2.4652.465 b, the rate in the KIVI table above).
  • NSNQuant: 2.23832.2383 b/elem, measured from the tensors it stores.
  • SpinQuant: b + 0.250.25 b/elem (fp16 scale and zero point per group of 128).
  • TurboQuant: two fp16 norms per key row (32 bits), which take the 2.252.25 b key payload to 2.502.50 b, plus a 128-bit outlier-channel mask per layer and head per sequence; values pay one fp16 norm per row on a 2 b payload (2.1252.125 b).
  • KVTC: sinks, the 128-token fp16 window and the PCA side information are charged.
  • HyperQuant: a Rice-coded payload of 2.0 / 2.5 / 3.0 bits per scalar, plus its side information. Our own side costs (fp16 sink, key-channel scales, 64-token window, block offsets) are charged the same way; HQ-final's stored total is 2.1272.127–2.1282.128 b/elem.

Where in the revised paper: Sec. 5.1, paragraphs "Baselines" and "Perplexity" (p. 7, red); Table 1 (p. 8, red); App. Q.1, Baseline implementations (p. 58, red); App. X.4 (p. 77, red); App. X.5 (p. 77, red); Table 32 (p. 80, red); Table 33 (p. 81, red).


AuthorsOpenReview ↗

Response to Reviewer 2 (3/6)

Response to Reviewer 2 (3/6)

3. Q1. What does the third round buy on real inputs? Should the default be two rounds?

Reviewer's point. The R=3R = 3 upper bound was a sketch, and the third round does not measurably change perplexity on the tested models. The reviewer asks what it buys on real inputs and whether the default should be two rounds.

Response: what the third round buys, and how it is resolved.

Short answer. On the real inputs we evaluate, nothing measurable. What it buys is a proved guarantee for the spike input that one or two rounds cannot give, at a cost of 2.7% of encode time and nothing at decode. We therefore keep it, and the paper now says plainly that it is a safety margin, not a source of the empirical gains.

1. What the rounds do, and why Gaussian coordinates matter. Before quantization each vector of dimension dd (d=128d = 128, one attention head) is rotated by RR rounds, y=HDR⋯HD1xy = H D_R \cdots H D_1 x, where HH is the normalized Walsh–Hadamard matrix and each DrD_r is an independent diagonal matrix of random signs. The E8 lattice quantizer and the entropy coder's probability tables are designed for coordinates that are close to Gaussian (our explanation: any gap between the real coordinate distribution and the Gaussian is a mismatch between the data and the model the coder assumes). The rotation is what makes the coordinates close to Gaussian, and we measure the remaining gap by dK(R)d_K(R), the Kolmogorov distance between one rotated, rescaled coordinate and N(0,1)N(0, 1).

The hardest input for a rotation is a spike: all the energy in one coordinate, like an extreme outlier channel, so the rotation must do all the mixing. Each round count behaves differently on it:

RoundsEach output coordinate isdKd_K for the spike
R=1R = 1exactly ±1/d\pm 1/\sqrt{d}, a two-point distributionorder 1 (not close to Gaussian at all)
R=2R = 2a sum of random signs on a fixed latticeproved floor ≥0.399/d+1\ge 0.399/\sqrt{d+1}
R≥3R \ge 3the lattice effect is smoothed outorder 1/d1/d

The spike is not only a theoretical case: key caches are known to contain outlier channels, which are partly spike-like, so the spike bound is a guarantee on exactly that structure (our explanation). Our real test inputs, however, do not need it (part 3).

2. What is proved. The App. Z results below are collected in the main text as Theorem 4.1(c).

  • Theorems Z.8 and Z.18 (three rounds, sharp rate). For the spike, dK(3)=c3/d+O(log⁡d/d2)d_K(3) = c_3/d + O(\log d / d^2), with c3=1.2314c_3 = 1.2314.
  • Theorem Z.23 (explicit constant). d⋅dK(3)≤C(d)d \cdot d_K(3) \le C(d) for every d=2md = 2^m with 16≤d≤22416 \le d \le 2^{24}; for example C(128)=1.2628C(128) = 1.2628 and C(4096)=1.2326C(4096) = 1.2326.
  • Theorems Z.25 and Z.27 and Proposition Z.2 (lower bounds). (a) Theorems Z.25 and Z.27. No number of rounds goes below order 1/d1/d; at d=4096d = 4096, dK(R)≥0.107/dd_K(R) \ge 0.107/d for every R≥3R \ge 3. So three rounds already reach the best possible order, and a fourth cannot improve it. (b) Proposition Z.2. Two rounds cannot reach it: dK(2)≥0.399/d+1d_K(2) \ge 0.399/\sqrt{d+1}.
  • At one attention head, d=128d = 128 (exact computation):
RoundsBound on dKd_KValue
R=2R = 2at least 0.399/1290.399/\sqrt{129}0.0351
R=3R = 3at most 1.2628/1281.2628/1280.0099

The exact distances at d=128d = 128 (p. 6) are 0.0352 after two rounds and 0.0097 after three. So on the spike, three rounds are guaranteed to be at least 3.6× closer to Gaussian than two rounds can ever be.

  • Scope. All of this is proved for the spike input only. We do not claim that the spike is the worst input.

3. What happens on real inputs (real data). Real key and value rows are not spikes: their energy is already spread over many channels, so a single round already brings them close to Gaussian (App. Z: on real K/V one round suffices). We tested whether that leaves any measurable gap.

  • Design. Preregistered non-inferiority test. A round count passes if the upper end of the paired 95% confidence interval for its perplexity change is ≤+0.20\le +0.20\\%; the rule was fixed before the test results were seen. Test splits, 3 models × 2 datasets, mean of seeds 0 and 1, inside HQ-final at exactly 2.1252.125 b, so the rate is identical across RR.
  • Result. R=2R = 2 and R=1R = 1 both stay within +0.2% of R=3R = 3 in 6/6 cells; the largest seed-mean changes are +0.04% (R=2R = 2) and +0.09% (R=1R = 1), i.e. ∣Δ∣≤0.09|\Delta| \le 0.09\\%.
  • The test is sensitive. Removing the fp16 sink fails the same test in 4/6 cells. The test does detect a component that matters, so the R=1R = 1 / R=2R = 2 result is not an artefact of a weak test.

4. What it costs (real data; fused encoder, RTX 5090, 32k-token Llama-3.1-8B cache).

RoundsRotation kernelEnd-to-end encode (median)
R=3R = 331.4 ms675 ms
R=2R = 222.2 ms656 ms
R=1R = 113.1 ms625 ms

Reviewer_g2X2OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper addresses the problem of KV cache compression for long-context LLM inference. The key insight is that entropy coding can close the gap to the rate-distortion limit, but existing entropy-coded KV compressors require calibration data to fit their probability models. HybridQuant eliminates this requirement by applying three rounds of the randomized fast Walsh-Hadamard transform (FWHT) to make every key/value vector approximately Gaussian and isotropic, then rounding to the E8 lattice and coding with a single static rANS code built offline for a Gaussian source. The step size is derived from the target rate alone, with all side bits accounted for. The paper proves that one FWHT round is insufficient for spiky inputs (Kolmogorov distance 0.34), two rounds bring inputs close to Gaussian but leave a floor of order d^{-1/2}, and three rounds lower it to order 1/d. A dithered variant (HybridQuant-G) provides input-independent errors and an attention concentration bound that does not grow with context length. The paper also identifies and fixes a failure mode where Qwen2's projection biases cause rotation-based quantizers to collapse, via an exact, calibration-free RoPE-correct centering. Experiments on Qwen2.5-7B, Mistral-7B-v0.3, and Llama-3.1-8B show that HybridQuant achieves perplexity within 0.003 bits of its target rate and outperforms TurboQuant-MSE by 8.8-31.3% at 2.125 bits.

Critical strengths

The paper's central contribution — achieving calibration-free entropy coding for the KV cache — is well-motivated and technically sound. The theoretical analysis of how many Hadamard rounds are needed (Theorem 4.1) is rigorous and provides actionable guidance: three rounds provably reduce the Gaussianity gap on spiky inputs, while one round suffices on real activations. The dithered variant's attention concentration bound (Theorem 4.3) that is independent of context length T is a strong theoretical result with clear practical relevance for long-context deployment. The projection-bias centering fix for Qwen2 models is an important practical discovery that addresses a real deployment blocker. The experimental methodology is thorough: paired bootstrap significance tests, multiple model families, six rate points, ablations isolating the contributions of entropy coding vs. E8 lattice, and bit-exact reproducibility checks. The rate accounting is unusually careful, counting every side bit including coder flushes and fp16 scales.

Critical weaknesses

(1) The theoretical analysis of the rotation's effectiveness is primarily conducted on a single spike input x = sqrt(d) * e_m. While this is the worst case for the one-round Berry-Esseen bound, the paper acknowledges that the upper bound for three rounds (Theorem 4.1c) is only a proof sketch with two lemmas resting on the local limit theorem, with constants certified numerically for d <= 512. The worst-case proof is therefore incomplete. (2) The experimental evaluation uses the authors' own implementations of all baselines (TurboQuant-MSE, KIVI, Rot-ECSQ) rather than the original codebases, which raises questions about whether baselines are optimally tuned. Notably, TurboQuant-MSE omits the two-tier outlier split used in the original KV experiments, and KIVI keeps no full-precision window, which disadvantages both. The paper does not compare against KVTC or CacheGen at all, dismissing them for requiring calibration — but a fair empirical comparison at deployment would still be informative. (3) The method is evaluated only on 7-8B models. While the authors argue that KV cache compression matters most for compact/distilled models, demonstrating on larger models (e.g., 70B) would strengthen the generality claims, especially given that the Qwen2 collapse issue may have different characteristics at scale. (4) The rANS coding is currently implemented on CPU only, with GPU code length computation as a proxy. Real deployment requires fused GPU rANS encode/decode kernels, and the latency implications of CPU offloading during inference are not discussed. The paper acknowledges that stream offset accounting (0.008 bits/element) is not included, suggesting the real deployment rate may be slightly higher than reported. (5) The three-round FWHT is justified as "insurance for inputs we have not seen," but on real activations one round already suffices (Section 5.3). This means the third round adds ~6% quantize-dequantize time for a benefit that is never observed empirically, which weakens the practical case for the default configuration.

Questions for authors

Q1. Theorem 4.1(c) is described as a proof sketch with constants certified numerically for d ≤ 512. Can you provide the complete proof, or at least certify the constants for larger d (e.g., d = 4096, which is relevant for models with larger head dimensions)? How sensitive is the 1/d convergence rate to the dimension in practice? Q2. All baselines (TurboQuant-MSE, KIVI, Rot-ECSQ) are reimplemented by the authors rather than evaluated with the original codebases. Could you run at least one baseline using the authors' official implementation? Specifically, TurboQuant-MSE without its two-tier outlier split and KIVI without a full-precision window are arguably disadvantaged — what are the results when these features are enabled? Q3. The method is evaluated only on 7–8B models. Have you tested HybridQuant on larger models (e.g., 70B) or models with grouped-query attention where the KV cache dimensions and channel statistics may differ? Does the Qwen2 projection-bias collapse manifest differently at scale? Q4. The rANS coding is currently CPU-only with GPU code-length as a proxy. What is the expected latency overhead of CPU offloading during inference? Have you prototyped fused GPU rANS kernels, and if so, what throughput do they achieve? Is the 0.008 bits/element stream offset accounting negligible in practice? Q5. Given that one FWHT round suffices on real activations, have you considered an adaptive strategy that applies additional rounds only when the input is detected as spiky (e.g., via kurtosis)? This could reduce the default cost while retaining the safety margin. Q6. The dithered variant (HybridQuant-G) provides input-independent errors and a context-length-independent attention bound. What is the practical cost of dithering in terms of randomness generation and reversibility? Is the bound tight enough to give meaningful quality guarantees at 2-bit rates on long contexts (e.g., 128K tokens)?

8 comments
AuthorsOpenReview ↗

Response to Reviewer 1 (1/8)

Response to Reviewer 1 (1/8)

Thank you for the positive assessment and the precise questions. We answer them in your order (weaknesses W1–W5 together with questions Q1–Q5, then Q6).

1. W1 / Q1. Theorem 4.1(c) was only a proof sketch, with constants certified for d≤512d \le 512

Reviewer's point. The three-round upper bound of Theorem 4.1(c) was a proof sketch whose two lemmas rested on a local limit theorem, with constants certified numerically only for d≤512d \le 512. The reviewer asks for a complete proof, or certified constants at larger dd (e.g. d=4096d = 4096), and how sensitive the 1/d1/d rate is to dd.

Response: how it is resolved.

Setting. Let d=2md = 2^m. For an input row x∈Rdx \in \mathbb{R}^d with unit RMS (∣x∣2=d\\|x\\|^2 = d), RR rounds give y(R)=HDR⋯HD1xy^{(R)} = H D_R \cdots H D_1 x, where HH is the orthonormal d×dd \times d Walsh–Hadamard matrix and D1,…,DRD_1, \dots, D_R are independent diagonal matrices of uniform random signs, so each coordinate of y(R)y^{(R)} has unit variance. Let dK(R)d_K(R) be the Kolmogorov distance between the law of a coordinate yi(R)y_i^{(R)} over the random signs and N(0,1)N(0, 1) (distribution function Φ\Phi). The spike input is x=d,emx = \sqrt{d}\\, e_m.

Theorems Z.8 and Z.18 (three rounds, sharp rate; proved). For the spike input, dK(3)=c3/d+O(log⁡d/d2)d_K(3) = c_3/d + O(\log d / d^2), with c3=1.2314c_3 = 1.2314.

Theorem Z.23 (explicit constant; proved, numerical value of a proved bound). For every d=2md = 2^m with 16≤d≤22416 \le d \le 2^{24}, d⋅dK(3)≤C(d)d \cdot d_K(3) \le C(d), for example C(16)=2.2119C(16) = 2.2119, C(128)=1.2628C(128) = 1.2628, C(4096)=1.2326C(4096) = 1.2326 and C(224)C(2^{24}) = 1.2315.

Dependence on dd (App. Z table, p. 96).

  • d⋅dK(3)d \cdot d_K(3) = 1.0901 (d=8d = 8), 1.1739 (d=16d = 16), 1.2071 (d=32d = 32). These are exact computations.
  • d⋅dK(3)d \cdot d_K(3) lies between 1.2310 and 1.2313 for 1024≤d≤40961024 \le d \le 4096. These are numerical evaluations.

Theorems Z.25 and Z.27 and Proposition Z.2 (lower bounds; proved). (a) Theorems Z.25 and Z.27. No number of rounds goes below order 1/d1/d. At d=4096d = 4096, dK(R)≥0.107/dd_K(R) \ge 0.107/d for every R≥3R \ge 3. (b) Proposition Z.2. Two rounds stay at order d−1/2d^{-1/2}: dK(2)≥0.399/d+1d_K(2) \ge 0.399/\sqrt{d+1}. These App. Z results are collected in the main text as Theorem 4.1(c).

Scope. Theorems Z.8, Z.18 and Z.23 are proved for the spike input only. We do not claim the spike is the worst input.

Explanation. The proof of Theorem 4.1(c) is now complete. The submitted sketch had one open step: an estimate, (M), on the characteristic function at intermediate frequencies. That step is now proved, and the argument assumes no expansion.

Theorem Z.23 makes the constant explicit for every power of two from 16 to 2242^{24}. Its closed forms are evaluated in IEEE double precision with explicit error allowances; this one step is not interval arithmetic.

The rate barely depends on dd. d⋅dK(3)d \cdot d_K(3) rises from 1.09 at d=8d = 8 to about 1.231 from d=1024d = 1024 onward, which matches c3c_3.

The lower bounds show why three rounds are used. With two rounds the distance stays at order d−1/2d^{-1/2}. From three rounds on it is order 1/d1/d, and more rounds cannot go below that order.

Where in the revised paper: Theorem 4.1(c) (revised), Sec. 4 (p. 6, red); App. Z.1–Z.6, complete proof of Theorem 4.1(c) (pp. 87–100, red); App. Z.4.2, explicit constant for 16≤d≤22416 \le d \le 2^{24} (p. 94, red); App. Z.5, the 1/d1/d floor for any number of rounds (p. 97, red); App. G, note on Theorem G.2 (p. 31, red); Supplement S3 (pp. 19–51).

AuthorsOpenReview ↗

Response to Reviewer 1 (2/8)

Response to Reviewer 1 (2/8)

2. W2 / Q2. Baselines were the authors' re-implementations; TurboQuant's outlier split, KIVI's window, KVTC and CacheGen

Reviewer's point. All baselines were the authors' own reduced implementations. TurboQuant-MSE omitted the two-tier outlier split and KIVI kept no full-precision window, both to the baselines' disadvantage, and KVTC and CacheGen were not compared. The reviewer asks for official code and for results with these features enabled.

Response: how it is resolved.

KIVI, NSNQuant, SpinQuant and CacheGen are run from their official code. TurboQuant and KVTC have no official implementation we could find, and HyperQuant's official code is public but we did not run it, so these three are our re-implementations of the published configurations. All rates are fully counted (windows, norms, sinks, side information). Real data throughout. Convention: ours − baseline; negative = ours better.

BaselineHow we ran itCode / referenceResult (ours − baseline, perplexity, wikitext2 / C4)
KIVIofficial code, with its 128-token fp16 window (window bits counted)github.com/jy-yuan/KIVI (commit 876b4d2)Earlier centred mode: −17.1 / −26.4% at 2.4652.465 b and −5.3 / −6.7% at 3.2033.203 b (Llama-3.1-8B). Llama-3.1-70B: HQ-final at 2.1242.124 b vs KIVI at 3.413.41 b, −5.21 / −2.24%
NSNQuantofficial code, native 2-bit setting (2.2382.238 b measured)github.com/DHdroid/NSNQuant (commit 604db3c)HQ-final −6.44 / −9.21% (Llama-3.1-8B), −2.13 / −2.19% (Mistral), with fewer bits
SpinQuantofficial code, KV quantization onlygithub.com/facebookresearch/SpinQuant (commit 8f47aa3)Earlier centred mode (hqc, 2.1252.125 b) vs SpinQuant at 2.252.25 b: −86.0 / −87.4% (Llama-3.1-8B), −49.5 / −56.0% (Mistral; SpinQuant collapses at this rate); −11.2 to −3.2% at 3.253.25 b (App. X.4)
CacheGenofficial code, its own protocol (Mistral)github.com/UChi-JCL/CacheGen (commit 6bed34c)−0.37% to −0.02%: better or tied at every level
TurboQuantre-implemented; no official implementation found at the time of our experiments. Published key split: 32 outlier channels at 3 b + 96 at 2 b (2.252.25 b payload; 2.502.50 b with the two fp16 norms per row charged), outliers from the prompt as in QJL; values at 2.1252.125 b are our pairingICLR 2026; arXiv:2504.19874Submitted configuration: −13.31% [−13.78, −12.88] / −13.57% [−15.48, −12.01] at K 2.50 / V 2.1252.125 b (Llama). At K 3.75 / V 3.1253.125 b (64 ch @4 b + 64 @3 b): −1.86 / −2.48%
HyperQuantre-implemented; its official code is public, but we did not run itarXiv:2606.23406; github.com/moonmath-ai/HyperQuantEarlier centred mode (hqc, 2.1252.125 b) vs our re-implementation: −29.7 to −9.2% (Llama and Mistral, wikitext2 and C4; App. X.5). Our re-implementation reproduces the reported 3.0-bit result (ΔPPL\Delta\mathrm{PPL} +0.261 against +0.25) but not the reported 2.0-bit gains; this has not been checked against the official code, a limitation of this comparison
KVTCre-implemented per layer and paper-faithfully; no official implementation found at the time of our experimentsICLR 2026; arXiv:2511.01815HQ-final better in 41 of 48 matched comparisons, tied in 2, worse in 5 (concession below)

Concession (KVTC, low rate). On Llama-3.1-8B wikitext2, in-domain-calibrated KVTC with 16 sinks is ahead at every tested rate (+0.37% to +3.07%). With its 4-sink default it is ahead below about 1.71.7 b (+1.52% [+0.97, +2.06] at 1.501.50 b). At 2.122.12 b it is also ahead on Qwen2.5-7B, by at most +0.30%. On Llama C4 and Mistral, HQ-final is better or indistinguishable. The scope of the claim is restated accordingly.

Where in the revised paper: Sec. 5.1, paragraphs "Baselines" and "Perplexity" (p. 7, red); Table 1 (p. 8, red); App. X.1 (p. 75, red); App. X.4 (p. 77, red); App. X.5 (p. 77, red); App. X.5, TurboQuant at K 3.75 / V 3.1253.125 b (p. 77, red); App. X.6 (p. 77, red); App. X.7 (p. 78, red); Table 35 (p. 82, red); Figure 10 (p. 83, red); App. Q.1, Baseline implementations (p. 58, red); Table 31 (p. 79, red).

AuthorsOpenReview ↗

Response to Reviewer 1 (3/8)

Response to Reviewer 1 (3/8)

3. W3 / Q3. Only 7–8B models; GQA; the Qwen2 collapse at scale

Reviewer's point. The method was evaluated only on 7–8B models. The reviewer asks for a larger model (e.g. 70B), models with grouped-query attention, and whether the Qwen2 projection-bias collapse behaves differently at scale.

Response: how it is resolved.

Llama-3.1 uses grouped-query attention (8 KV heads) at both 8B and 70B. We ran Llama-3.1-70B on 2 × H100 machines with bit-identical anchors (real data). Perplexity above fp16 (wikitext2 / C4): HQ-final +2.75 / +1.45% (3 seeds), NSNQuant +11.55 / +5.25%, the submitted configuration +28.49 / +15.03%. Paired against NSNQuant, HQ-final is −7.89% [−9.26, −6.59] / −3.61% [−4.22, −3.06]. The guaranteed mode costs +0.37% [+0.27, +0.46] / +0.07% against HQ-final.

We ran both: Llama-3.1-70B, the scale the reviewer asked about (Table 31), and Qwen2.5-14B (App. T; results below and in Table 25 (p. 66, red)). The 70B run answers the scale question but cannot test the Qwen2 bias collapse, because Llama models have no K/V projection biases; the 14B run tests it.

Qwen2.5-14B (new; real data). We have now also run the Qwen2 model the reviewer asked about, at 14B: all 9 methods, wikitext2 and C4, 64 × 4096-token windows, 5 rotation seeds per seeded method (fp16 and the two uncentred controls: one run). Perplexity is the seed mean; Δ\Delta is HQ-final minus the other method, paired per-window bootstrap pooled over seeds, 95% CI, negative = HQ-final better.

Method (2.1252.125 b)Perplexity, wikitext2 / C4HQ-final vs it, wikitext2HQ-final vs it, C4
fp164.9610 / 9.8127+1.58% [+1.23, +1.98]+0.79% [+0.70, +0.90]
HQ-final5.0394 / 9.8901——
HQ-final-G5.0525 / 9.9017−0.26% [−0.34, −0.18]−0.12% [−0.15, −0.08]
hqc (earlier centred mode)5.3556 / 10.1828−5.90% [−7.63, −4.31]−2.87% [−3.32, −2.53]
a3 (submitted)5.5199 / 10.3741−8.70% [−11.00, −6.58]−4.67% [−5.30, −4.16]
Rot-ECSQ5.6343 / 10.5105−10.56% [−13.19, −8.11]−5.90% [−6.67, −5.29]
TurboQuant-MSE$^c$5.9376 / 10.8603−15.13% [−18.38, −12.08]−8.93% [−9.92, −8.12]
ours without centring (seed 0)6.8991 / 13.7804
TurboQuant-MSE without centring (seed 0)9.4413 / 19.7671
  • HQ-final stays close to fp16 (+1.58% / +0.79%), in the same range as at 7B, and is better than every other compressed method on every seed. Its seed-to-seed standard deviation is 0.0027 / 0.0016 perplexity.
  • The Qwen2 bias problem shrinks with scale but does not disappear. Without centring, perplexity rises by +39% (ours) and +90% (TurboQuant) on wikitext2, against a collapse to about 10,000 at 7B. The 14B key-projection biases are about 13× smaller than at 7B (largest absolute value 32.8 against 414), which is consistent with the smaller damage; we did not measure them against activations. Centering removes the damage at both sizes, and the paper now words the collapse per model.
  • The guaranteed mode costs the same as at 7–8B: +0.26% / +0.12% (significant on all 5 seeds on wikitext2 and on 3 of 5 on C4).
  • The 14B runs use the released v4 code; the paper's 7B rows use the submission code, so the two sizes should be compared by Δ\Delta\\%, not by absolute perplexity.

Together with Llama-3.1-70B, this covers scale on both model families.

Where in the revised paper: Table 31 (p. 79, red); Table 25 (p. 66, red); Sec. 5.1, paragraphs "Baselines" and "Perplexity" (p. 7, red); Roadmap of the revision, before App. X (pp. 73–74, red).

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Rebuttal to Reviewers

General response to all reviewers

We thank the three reviewers for careful and specific reviews. Each reviewer thread below answers every point in the same order: the reviewer's point, how the revision resolves it, and where the change is in the revised paper (section, table, figure, theorem, appendix and page of the revised PDF; supplement parts S1–S6 where relevant). All changes in the revised PDF are in red. Comparisons name ours first: perplexity Δ\Delta\\% = (ours − reference)/reference, so negative means ours is better; scores (LongBench, needles) are ours − reference in points; speed and capacity are ours/reference. Each result is labelled proved, exact computation, simulation or real data. "HQ-final" is the new default configuration (hqc-final-2.125) and "HQ-final-G" the guaranteed mode (the default plus subtractive dither).

New default. HQ-final adds four calibration-free components to HybridQuant: pre-RoPE window-mean key centring, one fp16 attention-sink token, per-sequence 4-bit key channel scales and a 64-token fp16 recent window. Every side bit is charged at 2.1252.125 b/elem. The components were chosen on validation splits under a preregistered rule and confirmed on the test splits (6/6 cells, 5 seeds). We disclose that test perplexities of the earlier centred mode had been seen before the rule was written.

Guaranteed mode. HQ-final-G (the default plus subtractive Voronoi dither) is offered at ≥2.125\ge 2.125 b and replaces the earlier two-tier rule. Against HQ-final it costs +0.13 to +0.30% test perplexity on the 8B models and 16.5–23.6% throughput (real data).

Baselines. KIVI (with its 128-token window counted), NSNQuant, SpinQuant and CacheGen now run from their official code. TurboQuant (its published channel split) and KVTC, for which we found no official implementation at the time of our experiments, and HyperQuant, whose official implementation is public but was not run, are re-implemented. We concede that in-domain calibrated KVTC is better on Llama-3.1-8B wikitext2 at low rates.

Scale. Llama-3.1-70B (Table 31) and, new, Qwen2.5-14B (App. T, Table 25 (p. 66, red); 5 seeds): HQ-final +1.58% / +0.79% vs fp16 (wikitext2 / C4), better than every compressed method on every seed; without centring it degrades (+39% ours, +90% TurboQuant-MSE) but does not collapse as at 7B (key biases ~13× smaller).

Calibrated transform coding (KVTC). On centred key residuals of the three models the transform-coding headroom that a calibrated PCA basis can capture is 0.28–0.36 bits per coordinate (Remark J.4). Inside KVTC's own calibrated PCA basis our codec reaches KVTC's held-out error with 0.74–0.80× KVTC's bits (exact computation), so the gap is the basis, not our coder. We concede the low-rate regime to in-domain calibrated KVTC and restrict the claim to calibration-free compression at about 1.7–3 b/elem.

Deployment. A GPU encoder and fused decode-in-attention kernels read the entropy-coded cache directly. The claim is restated as capacity (6.1–8.0× fp16 on an RTX 5090) plus storage and transfer. Throughput relative to fp16 depends on the GPU, and batch-1 decoding is slower than fp16 (concessions). The released code (v4) passes 294 tests on one RTX 5090, with 1 skipped and none failed; 110 of them require CUDA.

Theory. Theorem 4.1(c) now has a complete proof (proved). Theorem 4.3 is replaced by Theorem 4.3′ and Corollaries A and A′, which hold for the dithered modes only (proved). For the undithered default we prove that no bound of Corollary A's form can hold and give a loose correlation-robust bound (Theorem U).

Positioning. Sec. 2 is corrected: NSNQuant is calibration-free and came first. EDEN and TurboQuant's remark on entropy coding are cited as precedents, and HyperQuant as concurrent work. Complete proofs are in the supplementary material, parts S1–S6.

Uploaded with this revision. The revised paper (changes in red), the supplementary proofs (parts S1–S6) and the anonymised code (supplementary material).

Where in the revised paper: Sec. 1, Contributions (p. 2, red); Sec. 2, paragraph "Calibration and precedents" (p. 3, red); Sec. 3, paragraph "Default configuration" (p. 4, red); Table 1 (p. 8, red); Table 31 (p. 79, red); Table 25 (p. 66, red); Table 3, operating modes (p. 20, red); Roadmap of the revision, before App. X (pp. 73–74, red); App. X.1 (p. 75, red); App. Y.1 (p. 84, red); Table 36 (p. 86, red); App. Y.6 (p. 85, red); App. Z.1–Z.6, complete proof of Theorem 4.1(c) (pp. 87–100, red); App. Z.7–Z.10, undithered default (pp. 101–106, red); Corollary A′, App. I (p. 36, red).

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.