# Revisiting RaBitQ and TurboQuant: A Symmetric Comparison of Methods, Theory, and Experiments
**Authors**:
- Jianyang Gao
- ETH Zurich
- &Yongyi Yang (University of Michigan)
- &Shuolin Li (Tsinghua University)
- &Raymond Chi-Wing Wong
- &Cheng Long (Nanyang Technological University)
## Abstract
This technical note revisits the relationship between RaBitQ and TurboQuant under a unified comparison framework. We compare the two methods in terms of methodology, theoretical guarantees, and empirical performance, using a reproducible, transparent, and symmetric setup. Our results show that, despite the claimed advantage of TurboQuant, TurboQuant does not provide a consistent improvement over RaBitQ in directly comparable settings; in many tested configurations, it performs worse than RaBitQ. We further find that several reported runtime and recall results in the TurboQuant paper could not be reproduced from the released implementation under the stated configuration. Overall, this note clarifies the shared structure and genuine differences between the two lines of work, while documenting reproducibility issues in the experimental results reported by the TurboQuant paper.
## 1 Introduction
Vector quantization in high-dimensional Euclidean spaces has become a fundamental problem in modern AI systems, including vector databases and large language model (LLM) serving. In these settings, the goal of quantization is to (1) reduce memory usage by compressing high-dimensional vector data; (2) reduce computational costs related to the vectors; and (3) preserve the geometric quantities needed by downstream tasks, especially inner products.
Recently, TurboQuant, first posted on arXiv in April 2025 and later accepted at ICLR 2026 https://openreview.net/forum?id=tO3ASKZlok, has drawn substantial public attention through claims such as “at least 6x memory reduction and up to 8x speedup, all with zero accuracy loss” (Zandieh et al., 2025a; Zandieh and Mirrokni, 2026). However, these public-facing claims are framed primarily against an uncompressed baseline, and thus, do not by themselves explain how TurboQuant should be understood relative to prior quantization methods.
One of the most directly relevant prior methods is RaBitQ. The original 1-bit RaBitQ was submitted to SIGMOD 2024 in October 2023, accepted, and posted on arXiv in May 2024 (Gao and Long, 2024); its multi-bit extension was posted on arXiv in September 2024 and later accepted at SIGMOD 2025 (Gao et al., 2025b). TurboQuant and RaBitQ are closely related: the two lines overlap in application scenarios, share important method-level structure, and emphasize closely related theoretical guarantees. Yet the TurboQuant paper does not provide an accurate and balanced account of that relationship in three respects. At the method level, RaBitQ is not described or compared with sufficient accuracy. At the theory level, some characterizations of RaBitQ’s theoretical guarantees are factually incorrect and unsupported. At the experimental level, the setup used for the RaBitQ baseline is not fully disclosed; subsequent email correspondence reveals that the baseline was run under conditions highly unfavorable to RaBitQ.
This technical note is written to address this gap. Our purpose is to place RaBitQ and TurboQuant within a single comparison framework and to characterize precisely what is shared, what is genuinely different, and what conclusions about theory and experiments are justified under a reproducible, transparent and symmetric standard. The report serves two purposes simultaneously: it provides a citable technical comparison and it offers a clear answer to the broader public question of how RaBitQ and TurboQuant are actually compared to each other. Our experimental comparison further shows that the empirical claims in the TurboQuant paper are difficult to reconcile with reproducible evaluations using the released artifacts. In directly comparable inner-product estimation and nearest-neighbor search settings, TurboQuant does not consistently improve over RaBitQ; in many tested configurations, it performs worse. For quantization time, we find that the reported TurboQuant results cannot be reproduced from the released implementation under the stated hardware configuration, with our measured running times differing substantially from the reported numbers. We also observe inconsistencies between the reported and reproduced RaBitQ recall and runtime results. These discrepancies indicate that the reported experimental results in the TurboQuant paper are not reproducible from the released artifacts under the stated experimental configuration. In addition, the undisclosed use of asymmetric hardware and parallelism settings for the RaBitQ baseline further weakens the reported comparison as evidence of a consistent empirical advantage over RaBitQ.
We emphasize that this note is not intended to provide a comprehensive survey or benchmark of vector quantization methods in vector databases, LLM serving systems, or broader application domains We recently became aware of related works, DRIVE (Vargaftik et al., 2021) and EDEN (Vargaftik et al., 2022), which study random rotation followed by quantization for vector reconstruction in the context of federated learning. We include these citations for transparency and to acknowledge related prior work. In this report, we focus on the comparison between TurboQuant and RaBitQ.. It focuses exclusively on the overlap between RaBitQ and TurboQuant and on establishing how they should be compared on common technical ground. Both methods involve several versions of practical implementations; in the technical note, we specify the version in detail for transparency. We also provide code for reproducing all experimental results in this report to facilitate independent evaluation. Throughout this note, we use RaBitQ to refer to the current RaBitQ line of work, including the original 1-bit RaBitQ (Gao and Long, 2024), its multi-bit extension (Gao et al., 2025b), its GPU version (Shi et al., 2026), and the optimized implementations in the RaBitQ Library (Gao et al., 2025a). https://github.com/VectorDB-NTU/RaBitQ-Library
The remainder of this note is organized as follows. We first compare the methodology of both methods under the same comparison framework, followed by a symmetric comparison of their theoretical claims. We next examine the experimental setup and baseline disclosure issues relevant to their reported empirical comparison. We conclude with what we believe is the most accurate characterization of the relationship between the two lines of work.
## 2 Comparison of Methodology
Table 1: Comparison of RaBitQ and TurboQuant.
| Preprocessing | Random rotation/JL Transformation. | Random rotation/JL Transformation. |
| --- | --- | --- |
| Codebook | Uniform codebook obtained by shifting unsigned integers. | Non-uniform codebook constructed by $k$ -means. |
| Quantization Algorithm | Select a rescaling factor $t$ , rescale the rotated and normalized vector, and quantize each coordinate to its nearest codebook entry. A scalar factor is additionally stored for vector reconstruction or inner-product estimation. | Quantize each coordinate of the rotated and normalized vector to its nearest codebook entry, and store the norm of the input vector. For unbiased inner-product estimation, TurboQuant additionally applies QJL to the residual. |
| Quantization Code | One scalar and $D$ unsigned integers of $B$ bits each. | One scalar and $D$ unsigned integers of $B$ bits each; for unbiased inner-product estimation, one additional scalar is required. |
| Inner Product Estimation | Based on native arithmetic of unsigned integers without decoding. | Requires codebook lookup for decoding. |
| Theoretical Guarantee | Optimal: provides a sub-Gaussian tail bound on the error: the required bit-width scales as $\log\log(1/δ)$ . | Suboptimal: provides a bound on the mean squared error: the required bit-width scales as $\log(1/δ)$ . |
### 2.1 Problem Setting
Both RaBitQ and TurboQuant are generic vector quantization methods for high-dimensional vectors in Euclidean space, aiming to preserve geometric quantities from compressed representations. In applications such as approximate nearest neighbor search and LLM systems, a central goal is to preserve inner products between vectors In approximate nearest neighbor search, preserving inner products can also help preserve Euclidean distances, since computing Euclidean distances can be reduced to computing inner products..
A quantization algorithm operates in two stages. In the quantization stage, each input data vector is mapped to a compact representation called a quantization code. In the estimation stage, the quantization code is used to estimate the inner product between the data vector and an arbitrary query vector.
The performance of a quantization algorithm is usually evaluated along five dimensions: (1) quantization time, (2) space consumption, (3) accuracy of inner-product estimation, (4) inner-product estimation time, and (5) theoretical guarantees. Throughout the paper, $\|·\|$ denotes the $\ell_2$ norm unless otherwise specified.
### 2.2 Methodology
In their original papers and artifacts, RaBitQ and TurboQuant are described using different terminology. To compare the two methods clearly, we describe the algorithmic procedures of both RaBitQ and TurboQuant under the same framework. A summary comparison between RaBitQ and TurboQuant is provided in Table 1.
#### 2.2.1 Preprocessing of Both RaBitQ and TurboQuant.
Both RaBitQ and TurboQuant encode the norm and direction of a vector separately. In practice, once the norm is stored, the core quantization procedure of each method focuses on quantizing the normalized vector.
Both RaBitQ and TurboQuant apply a random rotation, which is a form of Johnson–Lindenstrauss Transformation (Johnson and Lindenstrauss, 1984), as the first step for all vectors. Both methods use the distributional information of vectors after random rotation to design their quantization algorithms. Specifically, both methods sample and store a random rotation matrix, and apply the same random rotation to all vectors. In the following sections, without further specification, we assume that all vectors have been rotated by this random matrix.
#### 2.2.2 Quantization of RaBitQ.
RaBitQ constructs its codebook from shifted grids of unsigned integers. Let $B$ denote the bit-width per dimension. For an input vector $x$ , RaBitQ first rescales the vector by a factor $t$ , then rounds each coordinate of the rescaled vector $t·x$ to the nearest point in a scalar codebook:
$$
≤ft\{i-\frac{2^B-1}{2} \middle| i=0,1,…,2^B-1\right\},
$$
and stores the corresponding unsigned integer for each coordinate.
Across the RaBitQ line and its implementations, three strategies are used to decide the rescaling factor $t$ , where the first two strategies decide $t$ on a per-vector basis and the last strategy uses the same $t$ for all vectors:
- enumerating all critical rescaling factors that yield distinct quantization codes and selecting the one that maximizes the cosine similarity between the original vector and its quantized counterpart (Gao et al., 2025b);
- enumerating candidate rescaling factors from a prescribed set and selecting the one that maximizes the same cosine similarity (Shi et al., 2026);
- sampling random vectors uniformly from the unit sphere, precomputing the optimal rescaling factor for each, and using the expected value of these optimal factors for fast quantization (Gao et al., 2025a).
Let $x_u∈\{0,1,…,2^B-1\}^D$ denote the vector of $B$ -bit unsigned integers produced by the procedure above, and define its shifted-grid representation as
$$
\hat{x}:=x_u-\frac{2^B-1}{2} 1_D,
$$
where $1_D$ is the all-ones vector in $ℝ^D$ . The vector $\hat{x}$ determines the quantized direction; an additional scalar factor is stored to incorporate the norm of the original vector and to support different objectives.
Let $cos(a,b):=≤ft⟨\frac{a}{\|a\|}, \frac{b}{\|b\|}\right⟩$ denote the cosine similarity of two vectors. For unbiased inner-product estimation, RaBitQ stores the scalar
$$
\frac{\|x\|}{\|\hat{x}\|}·\frac{1}{cos(x,\hat{x})}.
$$
We note that while RaBitQ was originally designed for unbiased inner-product estimation, it has also been adapted for vector reconstruction in the RaBitQ library. Specifically, to instead minimize the reconstruction error, it suffices to replace the scaling factor with
$$
\frac{\|x\|}{\|\hat{x}\|}·\cos(x,\hat{x})
$$
#### 2.2.3 Estimation of RaBitQ.
Given a query vector, RaBitQ estimates the inner products between the data vectors and the query vector using the quantized representations. Since all data vectors have been rotated, RaBitQ rotates the query vector by the same matrix to preserve inner products; let $y$ denote this rotated query vector.
RaBitQ estimates the inner product between a data vector $x$ and the vector $y$ as follows.
$$
⟨x,y⟩ ≈ \frac{\|x\|}{\|\hat{x}\|}·\frac{1}{cos(x,\hat{x})}·⟨\hat{x},y⟩.
$$
Based on the distribution of vectors after Johnson-Lindenstrauss Transformation, as proved in (Gao and Long, 2024; Gao et al., 2025b), the above estimator is unbiased and has a rigorous error bound. The scalar factor $\frac{\|x\|}{\|\hat{x}\|}·\frac{1}{cos(x,\hat{x})}$ in the estimator is precomputed and stored during the quantization stage. The remaining term $⟨\hat{x},y⟩$ is computed as
$$
⟨\hat{x},y⟩=⟨x_u,y⟩-\frac{2^B-1}{2}∑_i=1^Dy[i].
$$
where $x_u$ is the stored $B$ -bit code of the data vector. The term $∑_i=1^Dy[i]$ depends only on the rotated query and can be computed once and reused across all data vectors. As a result, RaBitQ computes inner-product estimates directly from the compressed representation, i.e., $x_u$ , without any decoding step.
Furthermore, the structure of RaBitQ’s quantization code naturally supports incremental estimation. It can decompose a quantization code into two parts, e.g., the most significant bit and the remaining bits. During estimation, RaBitQ can first produce a coarse estimate of the inner product by accessing only the most significant bit. When higher accuracy is needed, it can access the remaining bits to refine the estimate, which helps significantly speed up the estimation in practice.
When using RaBitQ for vector reconstruction, based on the precomputed scalar factor $\frac{\|x\|}{\|\hat{x}\|}·cos(x,\hat{x})$ , RaBitQ can reconstruct a vector $x$ as follows.
$$
x≈\frac{\|x\|}{\|\hat{x}\|}·\cos(x,\hat{x})·\hat{x}
$$
#### 2.2.4 Quantization of TurboQuant.
The TurboQuant method includes two variants: one optimized for vector reconstruction and the other for unbiased inner-product estimation.
For vector reconstruction, TurboQuant constructs a scalar codebook according to the Lloyd–Max condition. Specifically, after normalization and random rotation, the coordinates of a rotated vector follow the distribution induced by the uniform spherical measure, as characterized in (Khokhlov, 2006). For a target bit-width of $B$ , TurboQuant constructs a scalar codebook with $2^B$ centroids by solving the corresponding one-dimensional continuous $k$ -means problem under this distribution. Each coordinate is then quantized to the index of its nearest centroid, and the compressed representation stores these centroid indices for all coordinates. Note that it can compute the reconstructed vector, denoted by $\bar{x}$ , by looking-up the codebook based on the stored indices.
For inner-product estimation, TurboQuant introduces a residual-correction stage. Given a total budget of $B$ bits per coordinate, it first applies $(B-1)$ bits to obtain a reconstruction, denoted by $\bar{x}$ , based on the quantization algorithm for vector-reconstruction, and then computes the residual
$$
r=\frac{x}{\|x\|}-\bar{x}.
$$
TurboQuant then applies Quantized Johnson–Lindenstrauss (QJL) (Zandieh et al., 2025b) transform to this residual:
$$
q=(Sr),
$$
where $S$ is a $D× D$ random Gaussian matrix and $sign(·)$ is the sign function where $sign(x)=+1$ if $x≥ 0$ and $sign(x)=-1$ if $x<0$ . In addition to the first-stage quantization codes and the sign vector $q$ , the quantized representation stores the vector’s norm $||x||$ and the residual norm $\|r\|$ .
#### 2.2.5 Estimation of TurboQuant.
Given a query vector, similarly, TurboQuant estimates the inner products between the data vectors and the query vector using the quantized representations. Since all data vectors have been rotated, TurboQuant also rotates the query vector by the same matrix to preserve inner products; let $y$ denote this rotated query vector.
To estimate the inner products between the data vectors and a query vector, TurboQuant combines the first-stage quantization code (using $(B-1)$ bits per dimension) with a QJL-based estimator of the residual (using 1 bit per dimension) (Zandieh et al., 2025b) as follows.
$$
⟨x,y⟩ ≈ \|{x}\|·≤ft<\bar{x}+√{\frac{π}{2}}·\frac{\|r\|}{D}S^⊤q,y\right>=\|x\|·≤ft<\bar{x},y\right>+√{\frac{π}{2}}\frac{\|x\|·\|r\|}{D}≤ft<q,Sy\right>
$$
where $\bar{x}$ corresponds to the reconstructed vector based on the quantization codes with $(B-1)$ bits per dimension. This estimator is unbiased as proved in (Zandieh et al., 2025a). The first component of the estimator still requires decoding the quantization code through the scalar codebook, while the second component uses the stored sign vector and residual norm to correct the bias.
When using TurboQuant for vector reconstruction, we can reconstruct a vector $x$ as follows.
$$
x≈\|x\|·\bar{x}
$$
## 3 Comparison of Theoretical Guarantees
In this section, we compare in detail the theoretical guarantees of RaBitQ and TurboQuant on inner-product estimation.
We focus on the inner-product-oriented variant of each method, since the reconstruction-oriented variant is optimized for reconstruction error and does not provide unbiased inner-product estimation. Under this scope, both RaBitQ and TurboQuant provide unbiased estimators of the inner product between unit vectors.
We first note that both RaBitQ and TurboQuant are randomized algorithms whose estimation error is a random variable. Rather than providing a deterministic guarantee, both methods can provide a probabilistic guarantee: the additive error of inner product between unit vectors is bounded by $ε$ with probability at least $1-δ$ , where $ε,δ∈(0,1)$ . The key quantity of interest is therefore the trade-off among the error bound $ε$ , the failure probability $δ$ , and the bit-width $B$ .
In 2017, Alon and Klartag (Alon and Klartag, 2017) established the optimal trade-off for approximate inner-product sketches under additive-error guarantees, providing matching upper and lower bounds on the bit-width $B$ required to ensure that the additive error of inner-product estimation between unit vectors is bounded by $ε$ with probability at least $1-δ$ . Specifically, as adapted from the proof of Theorem 4.1 in (Alon and Klartag, 2017), when $\frac{1}{ε^2}\log\frac{1}{δ}≥ D≥\log\frac{1}{δ}$ , the optimal bit-width satisfies
$$
B=Θ≤ft(\log≤ft(\frac{1}{D}·\frac{\log\frac{1}{δ}}{ε^2}\right)\right).
$$
RaBitQ is proved to match this optimal trade-off; see Theorem 3.2 of (Gao et al., 2025b). It is worth emphasizing that in the optimal case, the bit-width $B$ grows with $1/δ$ at the rate of $\log\log(1/δ)$ .
In contrast, TurboQuant provides only a guarantee on the variance of the inner-product estimation error; see Theorem 2 of (Zandieh and Mirrokni, 2026). A variance guarantee can be converted into a tail bound via Chebyshev’s inequality, which we restate as follows.
**Lemma 3.1 (Chebyshev’s inequality(Durrett,2010))**
*Let $X$ be a random variable with mean $0$ and variance $σ^2$ . Then for any $t>0$ ,
$$
ℙ≤ft\{|X|≥ t\right\}≤\frac{σ^2}{t^2}.
$$*
However, TurboQuant’s theoretical guarantee implies only a suboptimal trade-off between the bit-width $B$ and the failure probability $δ$ . More precisely, TurboQuant bounds only the variance of the estimator and such a guarantee does not directly yield a sub-Gaussian tail bound. If one applies Chebyshev’s inequality to this variance bound, the resulting dependence requires $B$ to scale as $\log(1/δ)$ . This is exponentially worse than the $\log\log(1/δ)$ dependence attained by RaBitQ, which Alon and Klartag (Alon and Klartag, 2017) showed to be optimal.
## 4 Comparison of Experimental Results
We follow the TurboQuant paper and evaluate RaBitQ and TurboQuant in the following aspects: namely (1) quantization accuracy, (2) quantization efficiency, (3) nearest neighbor search. It is important to note that the efficiency of inner-product estimation is also a key evaluation criterion for quantization methods. RaBitQ supports efficient inner-product estimation through a combination of algorithmic and system-level techniques, including bitwise operations (Gao and Long, 2024), FastScan (André et al., 2017), and incremental estimation (Gao et al., 2025b). In contrast, the publicly released TurboQuant codebase only provides a conceptual Python implementation for inner-product estimation, rather than an optimized implementation suitable for efficiency benchmarking. Under these circumstances, a fair empirical comparison of estimation efficiency is not possible. We therefore do not include such efficiency experiments in this report. We also attempted to reproduce the KV-cache results reported for TurboQuant based on the publicly available materials in OpenReview. However, those materials are incomplete for the LLM experiments and therefore do not support a reliable reproduction of the reported results. We will continue our reproduction efforts and update this report if we are able to resolve the remaining implementation issues and complete the evaluation.
For TurboQuant, we use the PyTorch implementation made available on OpenReview https://openreview.net/forum?id=tO3ASKZlok. For RaBitQ, we use by default the C++ implementation open-sourced in the RaBitQ library https://github.com/VectorDB-NTU/RaBitQ-Library, with the faster_quant flag disabled and a random orthogonal matrix for vector rotation (consistent with TurboQuant). We note that faster RaBitQ implementations are available in the same library; we use this configuration for reproducibility, as the TurboQuant paper compares against a Python counterpart of it.
We use a cloud instance with Nvidia A100 GPU (80 GiB VRAM) and 16 VCPUs by following the original setup of the papers and a dual-socket server equipped with two Intel Xeon Gold 6418H processors (48 cores / 96 threads in total). For the reproducibility, we compile all the source codes we use for the experiments in this paper here: https://github.com/VectorDB-NTU/rabitq-turboquant-comparison.
### 4.1 Quantization Accuracy
Following the TurboQuant paper, we use the DBpedia Entities dataset (1,536-dimensional) and randomly sample 100,000 points as the training set and extract 1,000 distinct entries as the query set.
In the TurboQuant paper, two versions are provided, namely one denoted by TurboQuant prod for unbiased inner product estimation and the other denoted by TurboQuant mse for vector reconstruction (with minimized MSE). As discussed in Section 2.2.3, RaBitQ can also support inner product estimation and vector reconstruction. We denote the RaBitQ for unbiased inner product estimation by RaBitQ prod and that for vector reconstruction by RaBitQ mse. We then use the two versions of both methods to quantize the training set and estimate the inner products between the training set and the query set based on the quantization codes of training set. We vary the bit widths for quantization and measure the estimation error distributions. We note that RaBitQ mse was not designed for inner-product estimation; we include it here solely for completeness of the comparison. In the rest part of this section, unless otherwise specified, RaBitQ refers to RaBitQ prod.
The results are shown in Figures 1 and 2 for RaBitQ and TurboQuant, respectively. We make the following observations.
Mean error.
Both RaBitQ prod and TurboQuant prod maintain a mean error of approximately zero across all bit widths, confirming that both variants are effectively unbiased estimators for inner-product estimation. For the MSE-optimized variants, both methods exhibit a slight positive bias that diminishes as the bit width increases.
Standard deviation and maximum error.
For the inner product estimation, RaBitQ prod achieves lower standard deviation and maximum error than TurboQuant prod at bit widths greater than 1, indicating that RaBitQ produces more tightly concentrated and reliable estimates in the setting where both methods are directly comparable.
Summary.
Taken together, these results show that TurboQuant offers no clear and consistent advantage over RaBitQ. In the setting most relevant to inner-product estimation, where the comparison is between the unbiased variants RaBitQ prod and TurboQuant prod, RaBitQ is more stable with smaller std and max errors across most of the tested bit widths.
<details>
<summary>2604.19528v1/content/figures/rabitq_ip_mat.png Details</summary>
### Visual Description
## Histograms: Inner Product Distortion Distribution by Bitwidth
### Overview
The image contains eight histograms arranged in a 2x4 grid, comparing the distribution of **Inner Product Distortion** across four bitwidths (1–4) for two metrics:
- **Top row (a)**: Frequency of RaBitQ_prod (y-axis: 0–1e6)
- **Bottom row (b)**: RaBitQ_mse (y-axis: 0–1e7)
Each subplot includes a legend with statistical summaries (mean, standard deviation, max) and uses distinct colors for clarity.
---
### Components/Axes
#### Labels and Titles
- **X-axis**: "Inner Product Distortion" (range: -0.15 to 0.15)
- **Y-axis (Top row)**: "Frequency" (log scale: 0–1e6)
- **Y-axis (Bottom row)**: "RaBitQ_mse" (log scale: 0–1e7)
- **Subplot Titles**: "Bitwidth = [1–4]"
- **Legend Labels**: "mean=[value]", "std=[value]", "max=[value]"
#### Color Coding
- **Top row (a)**: Blue histograms
- **Bottom row (b)**: Brown histograms (Bitwidth=1–3), Dark green (Bitwidth=4)
---
### Detailed Analysis
#### Top Row (RaBitQ_prod)
1. **Bitwidth=1**:
- **Mean**: 0.0001
- **Std**: 0.0192
- **Max**: 0.1074
- **Trend**: Broad, symmetric distribution centered near 0.
2. **Bitwidth=2**:
- **Mean**: 0.0000
- **Std**: 0.0094
- **Max**: 0.0517
- **Trend**: Narrower than Bitwidth=1, slightly left-skewed.
3. **Bitwidth=3**:
- **Mean**: -0.0000
- **Std**: 0.0270
- **Max**: 0.0297
- **Trend**: Sharp peak at 0, minimal spread.
4. **Bitwidth=4**:
- **Mean**: 0.0000
- **Std**: 0.0158
- **Max**: 0.0158
- **Trend**: Extremely narrow, near-perfect symmetry.
#### Bottom Row (RaBitQ_mse)
1. **Bitwidth=1**:
- **Mean**: 0.0310
- **Std**: 0.0263
- **Max**: 0.3632
- **Trend**: Broad distribution with a slight right skew.
2. **Bitwidth=2**:
- **Mean**: 0.0103
- **Std**: 0.0113
- **Max**: 0.1219
- **Trend**: Narrower than Bitwidth=1, centered near 0.
3. **Bitwidth=3**:
- **Mean**: 0.0032
- **Std**: 0.0054
- **Max**: 0.0405
- **Trend**: Sharp peak at 0, minimal spread.
4. **Bitwidth=4**:
- **Mean**: 0.0010
- **Std**: 0.0028
- **Max**: 0.0166
- **Trend**: Extremely narrow, near-perfect symmetry.
---
### Key Observations
1. **Bitwidth Correlation**:
- Higher bitwidths (3–4) show significantly narrower distributions, indicating reduced distortion.
- **RaBitQ_prod** and **RaBitQ_mse** both improve with increased bitwidth, but **RaBitQ_mse** values are consistently higher.
2. **Statistical Trends**:
- **Mean**: All distributions are centered near 0, with negligible bias.
- **Standard Deviation**: Decreases with bitwidth (e.g., Bitwidth=1: std=0.0192 → Bitwidth=4: std=0.0028).
- **Max Values**: Drop sharply with higher bitwidths (e.g., Bitwidth=1: max=0.1074 → Bitwidth=4: max=0.0158).
3. **Color Consistency**:
- Legends match histogram colors (e.g., Bitwidth=4 in dark green across both rows).
---
### Interpretation
The data demonstrates that **higher bitwidths improve precision** in inner product calculations:
- **RaBitQ_prod** and **RaBitQ_mse** both show reduced distortion as bitwidth increases, with Bitwidth=4 achieving near-zero mean and minimal spread.
- The **log-scale y-axes** highlight the exponential improvement in precision (e.g., RaBitQ_mse drops from ~0.36 to ~0.016 as bitwidth increases).
- The **narrowing histograms** visually confirm that higher bitwidths reduce variability, aligning with the statistical summaries.
This suggests that increasing bitwidth enhances computational accuracy, likely due to reduced quantization errors in fixed-point arithmetic.
</details>
Figure 1: Distribution of Inner Product error for RaBitQ.
<details>
<summary>2604.19528v1/content/figures/turbo_ip.png Details</summary>
### Visual Description
## Histograms: TurboQuant Performance by Bitwidth
### Overview
The image contains eight histograms arranged in a 2x4 grid, comparing TurboQuant performance metrics (TurboQuant_prod and TurboQuant_mse) across four bitwidths (1-4). Each bitwidth has two subplots: one for product distortion frequency and one for mean squared error (MSE). The histograms show distributions of inner product distortion values with statistical summaries.
### Components/Axes
- **X-axis**: "Inner Product Distortion" (range: -0.15 to 0.15)
- **Y-axis (Top Row)**: Frequency (1e6 scale)
- **Y-axis (Bottom Row)**: TurboQuant_mse values (1e7 scale)
- **Legends**: Positioned in top-right corner of each subplot, showing:
- Mean (μ)
- Standard deviation (σ)
- Maximum value
- **Colors**:
- Bitwidth 1: Blue
- Bitwidth 2: Dark blue
- Bitwidth 3: Brown
- Bitwidth 4: Dark green
### Detailed Analysis
#### Bitwidth 1
- **TurboQuant_prod (a)**:
- Mean: -0.0002
- Std: 0.0192
- Max: 0.1056
- Distribution: Symmetric around -0.0002 with right-skewed tail
- **TurboQuant_mse (b)**:
- Mean: 0.0312
- Std: 0.0263
- Max: 0.3526
- Distribution: Peaks near 0.03 with gradual decline
#### Bitwidth 2
- **TurboQuant_prod (c)**:
- Mean: -0.0000
- Std: 0.0116
- Max: 0.0660
- Distribution: Narrower than Bitwidth 1, centered at 0
- **TurboQuant_mse (d)**:
- Mean: 0.0103
- Std: 0.0112
- Max: 0.1185
- Distribution: Tighter clustering around 0.01
#### Bitwidth 3
- **TurboQuant_prod (e)**:
- Mean: 0.0000
- Std: 0.0066
- Max: 0.0354
- Distribution: Very narrow peak at 0
- **TurboQuant_mse (f)**:
- Mean: 0.0030
- Std: 0.0052
- Max: 0.0515
- Distribution: Sharp peak at 0.003
#### Bitwidth 4
- **TurboQuant_prod (g)**:
- Mean: 0.0000
- Std: 0.0036
- Max: 0.0212
- Distribution: Extremely narrow peak at 0
- **TurboQuant_mse (h)**:
- Mean: 0.0008
- Std: 0.0026
- Max: 0.0180
- Distribution: Tightest distribution, centered at 0.0008
### Key Observations
1. **Bitwidth Correlation**: Higher bitwidths show progressively tighter distributions:
- Bitwidth 1: Broadest spread (σ=0.0192 for prod)
- Bitwidth 4: Narrowest spread (σ=0.0036 for prod)
2. **Mean Trends**:
- TurboQuant_prod means approach 0 as bitwidth increases
- TurboQuant_mse means decrease from 0.0312 (Bitwidth 1) to 0.0008 (Bitwidth 4)
3. **Y-axis Scaling**: Bottom row uses 1e7 scale to accommodate larger MSE values
4. **Symmetry**: All distributions are approximately symmetric around their means
### Interpretation
The data demonstrates that increasing bitwidth improves measurement precision:
- **Product Distortion**: Higher bitwidths reduce both mean error and variability (σ decreases by 80% from Bitwidth 1 to 4)
- **MSE**: Shows similar improvement, with Bitwidth 4 achieving 38x lower mean MSE than Bitwidth 1
- **Precision Tradeoff**: The sharpest peaks at Bitwidth 4 suggest near-perfect alignment but limited dynamic range
- **Practical Implication**: Bitwidth 3-4 achieves sub-0.01 distortion levels, suitable for high-precision applications
All histograms follow a bell-curve pattern, confirming normal-like distributions despite slight skews in lower bitwidths. The consistent legend placement and color coding enable direct comparison across bitwidths.
</details>
Figure 2: Distribution of Inner Product error for TurboQuant.
### 4.2 Quantization Efficiency
Following the TurboQuant paper, we use three datasets including GloVe-200 (200-dimensional) and two DBpedia Entities datasets (1536-dimensional and 3072-dimensional). Specifically, we sample 100,000 vectors from each dataset and quantize the sampled vectors with 4 bits per dimension.
For RaBitQ, we test four implementations, namely (1) RaBitQ: which is the default implementation with the faster_quant flag disabled and a random orthogonal matrix for vector rotation (consistent with TurboQuant), (2) RaBitQ ${}_fastOn-FHT$ , which is a faster implementation of RaBitQ with the faster_quant flag enabled and Fast Hadamard Transform (FHT) from the FFHT Library (Andoni et al., 2015) and ideas in Kac’s Walk (Jain et al., 2022) for faster vector rotation, (3) RaBitQ (GPU), which is a standalone GPU-based implementation of RaBitQ and (4) RaBitQ ${}_fastOn-FHT$ (GPU), which is the GPU version of RaBitQ with the faster_quant flag enabled and uses FHT and ideas in Kac’s Walk for faster vector rotation. For RaBitQ, we use it for reproducibility consideration since the TurboQuant paper implements a Python version of this implementation and uses it for evaluating the performance of RaBitQ. For RaBitQ (GPU), we use it for a more direct comparison with TurboQuant since the TurboQuant implementation runs on GPU. We collect the running time of the methods, with the time for rotating the vectors included. For GPU-based implementations, the data transfer time from main memory (host memory) to GPU memory (device memory) is excluded.
The results are shown in Table 2. We make the following observations.
RaBitQ is faster than TurboQuant on the same hardware.
When compared on the same hardware (i.e., GPU), RaBitQ is substantially faster than TurboQuant. The GPU implementation of RaBitQ outperforms TurboQuant across all three datasets by a large margin: it is approximately $1.2×$ , $1.8×$ , and $1.8×$ faster at $d=200$ , $d=1{,}536$ , and $d=3{,}072$ , respectively. Moreover, with faster_quant flag enabled and FHT, the advances of RaBitQ are more dominant.
RaBitQ on CPU is competitive with TurboQuant on GPU.
Even the CPU implementation of RaBitQ (RaBitQ ${}_fastOn-FHT$ ), which runs on a standard multi-core server without GPU, achieves quantization times within the same order of magnitude as TurboQuant running on an A100 GPU, despite the significant hardware gap.
Discrepancy with reported RaBitQ results in the TurboQuant paper.
The quantization times we observe for RaBitQ differ substantially from those reported in the TurboQuant paper (Zandieh et al., 2025a). This discrepancy is explained by the asymmetric experimental conditions used in the TurboQuant paper. According to our private correspondence with the TurboQuant authors The second author of TurboQuant, Majid Daliri, stated in email correspondence that “we were using a single-core CPU instance, and multiprocessing was indeed disabled […] we weren’t fully utilizing parallelism, which explains why it was significantly slower”., their experiments evaluated RaBitQ on a single-core CPU with multi-threading disabled, while evaluating TurboQuant on an A100 GPU. The TurboQuant paper also implements a Python version of RaBitQ for the evaluation. These asymmetric setups were not disclosed in the TurboQuant paper.
Discrepancy with reported TurboQuant results in the TurboQuant paper.
The quantization times we observe for TurboQuant also differ substantially from those reported in (Zandieh et al., 2025a), and the nature of this discrepancy is different. Even when we evaluate TurboQuant using the officially released implementation on the same A100 GPU hardware reported in the paper, we observe quantization times up to approximately two orders of magnitude slower than those reported in (Zandieh et al., 2025a). This suggests that the quantization times reported in the TurboQuant paper are not reproducible from the released implementation under the stated hardware configuration.
| RaBitQ (CPU) RaBitQ ${}_fastOn-FHT$ (CPU) RaBitQ (GPU) | 0.125 0.085 0.009 | 1.003 0.143 0.065 | 4.176 0.218 0.152 |
| --- | --- | --- | --- |
| RaBitQ ${}_fastOn-FHT$ (GPU) | 0.003 | 0.008 | 0.013 |
| TurboQuant (GPU) | 0.011 | 0.114 | 0.276 |
Table 2: Quantization time (in seconds) for different approaches across various dimensions using 4-bit quantization.
### 4.3 Nearest Neighbor Search
Following the TurboQuant paper, we use three datasets, namely GloVe- $200$ , OpenAI3- $1536$ , and OpenAI3- $3072$ . For each dataset, we construct a base set and a query set. For OpenAI3- $1536$ and OpenAI3- $3072$ , the base set has $100{,}000$ vectors and the query set contains $1{,}000$ vectors. For GloVe- $200$ , we sample a subset of $100{,}000$ vectors from the original corpus as the base set and use the provided query set of $10{,}000$ vectors. Following the TurboQuant paper, for all three datasets, we use the inner product of normalized vectors as the metric for nearest neighbor search.
We compare RaBitQ, namely RaBitQ prod, with the two TurboQuant variants, namely TurboQuant prod and TurboQuant mse. Note that we exclude RaBitQ mse from this comparison as it is not designed for inner-product estimation, which is the objective underlying nearest neighbor search. On the other hand, we include both variants of TurboQuant in the comparison for transparency as the TurboQuant paper did not specify the version they used in the experiment. For each method, we first quantize the vectors in the base set and then find for each query vector in the query set, the $k$ vectors, whose quantized vectors have the largest estimated inner products with the query vector. We vary the bit-width $B$ in $\{2,4\}$ . We report Recall@1@ $k$ for $k∈\{1,2,4,8,16,32,64\}$ . Let $g(q)$ denote the exact top-1 nearest neighbor of query $q$ (i.e., the one with the largest inner product), and let $A_k(q)$ denote the approximate top- $k$ result set returned by a method. Then
$$
Recall@1@k=\frac{1}{|Q|}∑_q∈ Q1≤ft[g(q)∈ A_k(q)\right].
$$
Note that in the open-sourced code of TurboQuant, the evaluation script for the two OpenAI datasets is available, but that for the GloVe- $200$ data is not. Therefore, for the OpenAI datasets, we use the provided evaluation script directly; and for GloVe- $200$ , we use a thin wrapper that calls the same TurboQuant core routines for random rotation generation and quantization; thus, the underlying TurboQuant quantizer itself is unchanged.
In addition, we note that both RaBitQ and TurboQuant involve randomness through their sampled rotation matrices. As a result, recall curves from a single run may exhibit mild run-to-run variation. To obtain a more stable comparison, we repeat each configuration, defined by method, bit-width, and dataset, 10 times using the full query set. We plot the mean recall over these runs as the main curve, and use the shaded band to represent one standard deviation around the mean.
The results are shown in Figure 3. We make the following observations.
Overall comparison.
Across all three datasets and both bit widths, RaBitQ consistently achieves higher recall than both TurboQuant variants. The advantage is most pronounced at small $k$ and at the lower bit width of 2 bits, where the methods are most differentiated. As $k$ increases, all methods converge toward perfect recall and the differences diminish accordingly.
TurboQuant mse outperforms TurboQuant prod on recall.
We observe that TurboQuant mse consistently achieves higher recall than TurboQuant prod across all settings. This is a notable finding because TurboQuant prod is the variant specifically designed for inner-product estimation, which is the objective directly relevant to nearest neighbor search. The fact that the reconstruction-oriented variant yields better recall performance raises questions about which variant should be used in practice for this task, and about the theoretical guarantees that support TurboQuant prod in this setting. We note that TurboQuant mse does not guarantee unbiased inner-product estimation. The TurboQuant paper does not clearly specify which variant is used in its reported recall results.
Discrepancy with results reported in the TurboQuant paper.
We note that the recall values we obtain for RaBitQ differ from those reported in the TurboQuant paper (Zandieh et al., 2025a). Specifically, the RaBitQ results reported therein fall below the one-standard-deviation band we measure across 10 repeated runs, each using the full query set, with different random seeds. The TurboQuant paper does not describe how run-to-run variation due to random rotation is handled in their reported RaBitQ results, making it difficult to assess the source of this discrepancy. Our results, by contrast, are averaged over 10 independent runs with standard deviations reported, and are fully reproducible from the code provided in our repository. These reproduced results do not support the TurboQuant paper’s conclusion that TurboQuant consistently outperforms RaBitQ in nearest neighbor search.
<details>
<summary>2604.19528v1/content/figures/recall_at1_three_panel.png Details</summary>
### Visual Description
## Line Graphs: Algorithm Performance Comparison Across Datasets
### Overview
Three line graphs compare algorithm performance (Recall@1@k) across different datasets (GloVe-d=200, OpenAI3-d=1536, OpenAI3-d=3072) as Top-k values increase from 1 to 64. Each graph shows five algorithms with varying bit configurations, with performance metrics plotted against Top-k values.
### Components/Axes
- **X-axis**: Top-k (logarithmic scale from 1 to 64)
- **Y-axis**: Recall@1@k (linear scale from 0.5 to 1.0 for GloVe, 0.85 to 1.0 for OpenAI3-d=1536, 0.85 to 1.0 for OpenAI3-d=3072)
- **Legends**: Positioned at bottom-right of each graph, with color-coded labels:
- **Blue**: TurboQuant_mise 2 bits
- **Dark Blue**: TurboQuant_mise 4 bits
- **Light Blue**: TurboQuant_prod 2 bits
- **Brown**: TurboQuant_prod 4 bits
- **Pink**: RaBitQ 4 bits
### Detailed Analysis
#### (a) GloVe-d=200
- **Trend**: All lines converge near Top-k=64, with RaBitQ 4 bits consistently highest (0.98-1.0). TurboQuant_prod 2 bits starts lowest (0.55 at Top-k=1) but improves sharply.
- **Key Data Points**:
- TurboQuant_mise 2 bits: 0.5 (Top-k=1) → 0.98 (Top-k=64)
- RaBitQ 4 bits: 0.85 (Top-k=1) → 1.0 (Top-k=64)
#### (b) OpenAI3-d=1536
- **Trend**: Lines diverge initially but converge at Top-k=64. RaBitQ 4 bits maintains lead (0.99-1.0). TurboQuant_prod 2 bits starts lowest (0.875 at Top-k=1).
- **Key Data Points**:
- TurboQuant_prod 4 bits: 0.89 (Top-k=1) → 0.99 (Top-k=64)
- RaBitQ 4 bits: 0.97 (Top-k=1) → 1.0 (Top-k=64)
#### (c) OpenAI3-d=3072
- **Trend**: Similar convergence pattern. RaBitQ 4 bits dominates (0.99-1.0). TurboQuant_prod 2 bits starts at 0.875 (Top-k=1).
- **Key Data Points**:
- TurboQuant_mise 4 bits: 0.97 (Top-k=1) → 0.99 (Top-k=64)
- RaBitQ 4 bits: 0.97 (Top-k=1) → 1.0 (Top-k=64)
### Key Observations
1. **Convergence**: All algorithms show diminishing performance differences at higher Top-k values.
2. **RaBitQ 4 bits**: Consistently outperforms others across all datasets.
3. **Bit Configuration Impact**: 4-bit configurations generally outperform 2-bit versions.
4. **Dataset Sensitivity**: OpenAI3-d=3072 shows the most pronounced performance gaps at low Top-k values.
### Interpretation
The data demonstrates that:
- **Algorithm Efficiency**: RaBitQ 4 bits achieves highest recall across all datasets, suggesting superior design for sparse retrieval tasks.
- **Precision Tradeoffs**: TurboQuant_prod 2 bits sacrifices initial performance for better scalability at low Top-k values.
- **Dataset Complexity**: Larger datasets (OpenAI3-d=3072) amplify performance differences between algorithms, particularly at low Top-k values.
- **Bit Depth Impact**: 4-bit configurations consistently outperform 2-bit versions, indicating that higher precision improves recall in sparse vector spaces.
The convergence patterns suggest that while algorithmic differences matter at scale, system-level optimizations (like Top-k tuning) can mitigate performance gaps in practical applications.
</details>
Figure 3: Recall comparison on different datasets
## 5 Conclusion
This note has examined the relationship between RaBitQ and TurboQuant across three dimensions: methodology, theoretical guarantees, and empirical performance.
At the method level, both RaBitQ and TurboQuant apply a random rotation as their first step and exploit the resulting distributional properties to design their respective quantization schemes as well as analyzing the unbiasedness and error bounds for inner product estimation.
At the theoretical level, RaBitQ provably achieves the asymptotically optimal space-distortion trade-off established by Alon and Klartag (Alon and Klartag, 2017), with a bit-width that grows with the failure probability $δ$ at the rate of $\log\log(1/δ)$ . TurboQuant, by contrast, provides only a variance guarantee on its estimator. Converting this to a tail bound via Chebyshev’s inequality yields a dependence that grows as $\log(1/δ)$ , which is exponentially worse than the optimal rate.
At the experimental level, our reproducible evaluation shows that TurboQuant offers no clear and consistent advantage over RaBitQ in directly comparable settings. In quantization accuracy, RaBitQ prod matches or outperforms TurboQuant prod across all tested bit widths. In quantization efficiency, RaBitQ is substantially faster than TurboQuant on the same hardware, and its CPU implementation is competitive with TurboQuant on an A100 GPU. In nearest neighbor search, RaBitQ consistently achieves higher recall than both TurboQuant variants across all datasets and bit widths. Furthermore, we find that the runtime and recall results reported in the TurboQuant paper could not be reproduced from the released implementation under the stated hardware configuration.
We hope this note serves as a useful and citable reference for researchers working on vector quantization, and that the symmetric comparison framework presented here contributes to a more accurate understanding of the relationship between the two methods.
## References
- N. Alon and B. Klartag (2017) Optimal compression of approximate inner products and dimension reduction. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pp. 639–650. Cited by: §3, §3, §5.
- A. Andoni, P. Indyk, T. Laarhoven, I. Razenshteyn, and L. Schmidt (2015) Practical and optimal lsh for angular distance. In Proceedings of the 29th International Conference on Neural Information Processing Systems - Volume 1, NIPS’15, Cambridge, MA, USA, pp. 1225–1233. Cited by: §4.2.
- F. André, A. Kermarrec, and N. Le Scouarnec (2017) Accelerated nearest neighbor search with quick adc. In Proceedings of the 2017 ACM on International Conference on Multimedia Retrieval, ICMR ’17, New York, NY, USA, pp. 159–166. External Links: ISBN 9781450347013, Link, Document Cited by: §4.
- R. Durrett (2010) Probability: theory and examples. 4th edition, Cambridge University Press, USA. External Links: ISBN 0521765390 Cited by: Lemma 3.1.
- J. Gao, Y. Gou, Y. Xu, J. Shi, Z. Yang, and C. Long (2025a) The rabitq library. In The 1st Workshop on Vector Databases, Cited by: §1, 3rd item.
- J. Gao, Y. Gou, Y. Xu, Y. Yang, C. Long, and R. C. Wong (2025b) Practical and asymptotically optimal quantization of high-dimensional vectors in euclidean space for approximate nearest neighbor search. Proceedings of the ACM on Management of Data 3 (3), pp. 1–26. Cited by: §1, §1, 1st item, §2.2.3, §3, §4.
- J. Gao and C. Long (2024) Rabitq: quantizing high-dimensional vectors with a theoretical error bound for approximate nearest neighbor search. Proceedings of the ACM on Management of Data 2 (3), pp. 1–27. Cited by: §1, §1, §2.2.3, §4.
- V. Jain, N. S. Pillai, A. Sah, M. Sawhney, and A. Smith (2022) Fast and memory-optimal dimension reduction using Kac’s walk. The Annals of Applied Probability 32 (5), pp. 4038 – 4064. External Links: Document, Link Cited by: §4.2.
- W. B. Johnson and J. Lindenstrauss (1984) Extensions of lipschitz mappings into a hilbert space 26. Contemporary mathematics 26, pp. 28. Cited by: §2.2.1.
- V. I. Khokhlov (2006) The uniform distribution on a sphere in ${\bf R}^S$ . properties of projections. i. Theory of Probability & Its Applications 50 (3), pp. 386–399. External Links: Document, Link, https://doi.org/10.1137/S0040585X97981846 Cited by: §2.2.4.
- J. Shi, J. Gao, J. Xia, T. B. Fehér, and C. Long (2026) GPU-native approximate nearest neighbor search with ivf-rabitq: fast index build and search. arXiv preprint arXiv:2602.23999. Cited by: §1, 2nd item.
- S. Vargaftik, R. B. Basat, A. Portnoy, G. Mendelson, Y. B. Itzhak, and M. Mitzenmacher (2022) EDEN: communication-efficient and robust distributed mean estimation for federated learning. In Proceedings of the 39th International Conference on Machine Learning, K. Chaudhuri, S. Jegelka, L. Song, C. Szepesvari, G. Niu, and S. Sabato (Eds.), Proceedings of Machine Learning Research, Vol. 162, pp. 21984–22014. External Links: Link Cited by: footnote 2.
- S. Vargaftik, R. Ben-Basat, A. Portnoy, G. Mendelson, Y. Ben-Itzhak, and M. Mitzenmacher (2021) DRIVE: one-bit distributed mean estimation. In Advances in Neural Information Processing Systems, M. Ranzato, A. Beygelzimer, Y. Dauphin, P.S. Liang, and J. W. Vaughan (Eds.), Vol. 34, pp. 362–377. External Links: Link Cited by: footnote 2.
- A. Zandieh, M. Daliri, M. Hadian, and V. Mirrokni (2025a) TurboQuant: online vector quantization with near-optimal distortion rate. External Links: 2504.19874, Link Cited by: §1, §2.2.5, §4.2, §4.2, §4.3.
- A. Zandieh, M. Daliri, and I. Han (2025b) QJL: 1-bit quantized jl transform for kv cache quantization with zero overhead. In Proceedings of the Thirty-Ninth AAAI Conference on Artificial Intelligence and Thirty-Seventh Conference on Innovative Applications of Artificial Intelligence and Fifteenth Symposium on Educational Advances in Artificial Intelligence, AAAI’25/IAAI’25/EAAI’25. External Links: ISBN 978-1-57735-897-8, Link, Document Cited by: §2.2.4, §2.2.5.
- A. Zandieh and V. Mirrokni (2026) TurboQuant: redefining AI efficiency with extreme compression. Note: Google Research BlogMarch 24 External Links: Link Cited by: §1, §3.