Match each vector-compression scheme to its core mechanism.

Vector compression is the trick that makes billion-scale retrieval affordable. Raw float32 embeddings are 4 bytes per dimension, so a 1024-dim vector is 4096 bytes. At a billion vectors, that is 4TB of RAM you almost certainly cannot afford. Compression schemes shrink each vector to tens of bytes, sometimes even single-digit bytes, at the price of a small recall hit. **PQ (Product Quantization)** splits each vector into a small number of sub-vectors (say 16 chunks of 64 dimensions each). For each chunk position, k-means learns 256 centroid sub-vectors. Each chunk in your data is then stored as the 1-byte index of its closest centroid. A 1024-dim vector becomes 16 bytes. **OPQ (Optimized PQ)** is the same idea with one extra step: before running PQ, learn a rotation matrix that spreads the variance evenly across all sub-spaces. Better balance, lower quantization error, same byte budget. **SQ (Scalar Quantization)** is the simplest scheme. For each dimension independently, find the min and max across the corpus and divide the range into 256 (8-bit) or 16 (4-bit) uniform buckets. Store each dim as the bucket index. No training, no codebook. **BQ (Binary Quantization)** is the most aggressive: store only the sign bit of each dimension. A 1024-dim vector becomes 128 bytes. Distance becomes Hamming distance, which on modern CPUs is just popcount(XOR), the fastest distance kernel in computing.

**Four compression schemes, two distinct mechanisms.** `PQ` is the codebook scheme. Split each vector into `pq_m` sub-vectors of `d / pq_m` dimensions. Run k-means with 256 centers on each sub-space across the training corpus, producing one codebook per sub-space. Encode each sub-vector as the 1-byte index of its closest centroid. A 1024-dim float32 vector (4096 bytes) becomes `pq_m` bytes, typically 16 to 64. Distance to a query is computed via a lookup table per sub-space. Reference: Jegou, Douze, Schmid (2011). `OPQ` is PQ with a pre-rotation. PQ's recall is sensitive to how variance is distributed across the sub-spaces; if one sub-space carries most of the variance, its centroids cannot represent the data well. OPQ learns an orthogonal rotation matrix R that decorrelates the dimensions before PQ encoding. The encoded form is `PQ(Rx)` instead of `PQ(x)`. Same byte budget, materially lower quantization error. `SQ` is per-dimension uniform bucketing. For each dimension, take the min and max across the corpus, divide the range into 256 (int8) or 16 (int4) uniform bins. Store each dim as a bin index. No training, no codebook, instant build, and the distance computation can run in SIMD int8 arithmetic. Recall drop is small at int8, more noticeable at int4. `BQ` is the extreme: 1 bit per dimension, the sign. A vector becomes a packed bitstring. Distance between two BQ vectors is `popcount(a XOR b)`, a single CPU instruction over each 64-bit word. The recall drop is real (vectors must be reasonably well-separated), but the speed and storage wins are enormous. Qdrant and Weaviate both ship it as a first-class option in 2026; some embedding models are even trained to be binary quantization friendly. The pairing reflects the mechanism: PQ codebook lookup, OPQ rotate then codebook, SQ uniform bin per dim, BQ sign bit and popcount.