Spherical Leech Quantization (Λ₂₄-SQ)

• Spherical Leech Quantization (Λ₂₄-SQ) is a lookup-free method that leverages the 24-dimensional Leech lattice’s symmetry, optimal sphere-packing, and covering properties.
• It achieves near-optimal rate-distortion efficiency with efficient integer-only indexing and hardware-friendly parallel dequantization, benefiting applications like visual tokenization and LLM compression.
• The method provides a unified framework for high-dimensional quantization, outperforming scalar and lower-dimensional schemes through precise lattice coding and structured noise reduction.

Spherical Leech Quantization (Λ₂₄-SQ) is a non-parametric, codebook-free vector quantization technique that exploits the high symmetry, maximal sphere-packing density, and optimal covering properties of the Leech lattice in 24 dimensions. Designed for applications such as visual tokenization, LLM compression, and similarity search, Λ₂₄-SQ provides a unified, lookup-free quantization framework grounded in lattice coding and achieves near-optimal rate-distortion efficiency. It is characterized by a large implicit codebook (up to 196,560 points on $S^{23}$), efficient integer-only indexing, and hardware-friendly parallelization, with applications spanning deep learning autoencoders and high-throughput neural compression (Zhao et al., 16 Dec 2025, Ouderaa et al., 11 Mar 2026, Steiner et al., 2014).

1. Lattice Coding Foundations and Spherical Quantization Framework

Λ₂₄-SQ generalizes non-parametric, lookup-free quantization by interpreting each quantizer as selection of a generator matrix $G\in\mathbb{R}^{d\times N}$ and an associated lattice $$\Lambda = \{Gz\,:\,z\in\mathbb{Z}^N,\,h(\lambda)\leq c\}$$ subject to a constraint $h$. The quantizer $$Q_\Lambda(x) = \arg\min_{\lambda\in\Lambda}\|x-\lambda\|_2$$ assigns a point to its nearest lattice element. Notable special cases include LFQ (two-shell hypercube), FSQ (integer lattice quantization), BSQ (normalized binary hypercube constrained to the unit sphere), and RPQ (random projections) (Zhao et al., 16 Dec 2025).

In Λ₂₄-SQ, the lattice $\Lambda$ is the 24-dimensional Leech lattice $\Lambda_{24}\subset\mathbb{R}^{24}$. To construct a codebook constrained to the unit sphere, the first shell of minimal-norm Leech vectors (those with squared norm 32) is normalized, yielding $|C| = 196,\!560$ codewords, which are uniformly distributed on $S^{23}$ (Zhao et al., 16 Dec 2025). The quantization map for any $x\in\mathbb{R}^{24}$ is:

1. Normalize: $\tilde{x} = x/\|x\|_2$
2. Assign: $$Q(x) = \arg\min_{c_i\in C}\|\tilde{x}-c_i\|_2^2 = \arg\max_{c_i}\langle \tilde{x}, c_i\rangle$$.

This spherical quantization embeds inputs into a maximally separated discrete set on the unit hypersphere, exploiting the geometry of $\Lambda_{24}$ for superior rate-distortion tradeoff (Zhao et al., 16 Dec 2025, Ouderaa et al., 11 Mar 2026).

2. Structure and Coding Properties of the Leech Lattice

The Leech lattice $\Lambda_{24}$ is an even unimodular lattice of rank 24, admitting several explicit constructions, notably via the extended binary Golay code. Its minimal nonzero norm structure ensures absence of vectors of squared norm 2 and a minimal squared norm of 4. Shell decomposition allows the codebook to be extended by aggregating lattice vector shells of different radii. At each shell $m$, $Shell(m)=\{v \in \Lambda_{24} : \|v\|^2=2m\}$, and codebooks $C=\bigcup_{m=2}^M Shell(m)$ enable variable bitrate quantization (Ouderaa et al., 11 Mar 2026).

Λ₂₄-SQ takes advantage of the Leech lattice's maximal kissing number ($\tau(\Lambda_{24})=196,\!560$) and optimal packing density. The minimal inter-code angular distance (associated with the minimal Euclidean distance on $S^{23}$ after normalization) directly improves quantization error and minimal intra-codeword confusion under nearest-neighbor assignment.

Classifications of codewords by symmetry (orbit types) and highly structured indexing schemes via Golay code cosets, sign assignments, and permutations ensure efficient codeword access and fully integer-based implementation (Ouderaa et al., 11 Mar 2026).

3. Rate–Distortion and Error Analysis

Λ₂₄-SQ systematically outperforms scalar and lower-dimensional lattice quantization at fixed bitrate. For isotropic Gaussian sources at $R=2$ bits/dimension, Λ₂₄-SQ (shape-gain mode) achieves an MSE of 0.078, an SQNR of 1.84 bits, and 92.1% retention of the Shannon rate-distortion bound, outperforming E₈ and scalar schemes by >10% and closely tracking the information-theoretic optimum (Ouderaa et al., 11 Mar 2026).

In visual tokenization and image compression pipelines, Λ₂₄-SQ delivers improved rate-distortion metrics compared to BSQ. On ImageNet-1k (with a ViT backbone, $R\approx17.58$ bits):

Method	PSNR (dB)	LPIPS	rFID	SSIM
BSQ (18 bits)	25.36	.0761	1.14	.758
Λ₂₄-SQ	26.37	.0622	0.83	.793

On the Kodak dataset (BPP ≈ 0.275), Λ₂₄-SQ achieves PSNR = 29.63 and MS-SSIM = .9637, exceeding JPEG2000, WebP, and BSQ (Zhao et al., 16 Dec 2025).

Rate–distortion analysis shows that Λ₂₄-SQ's minimal inter-code angle (0.866, min angle ≈ 0.66 rad) versus BSQ’s 0.471 correlates with a 10–20% lower reconstruction error (Zhao et al., 16 Dec 2025).

4. Efficient Indexing, Decoding, and Hardware Scalability

A key property of Λ₂₄-SQ is hardware efficiency and scalability, achieved via codebook-free integer-only indexing and parallelizable dequantization. Each codeword is uniquely indexed using shell, class (based on canonical form under symmetry), and local symmetry parameters, all flattened into hardware-friendly indices without any explicit codebook storage or large lookup tables (Ouderaa et al., 11 Mar 2026). This enables simultaneous high-throughput decoding for large-scale implementations, matching or exceeding standard 8-bit dtype scatter-gather speeds (>200 GiB/s dequantization on GPUs).

Pseudocode for angular search over union of Leech lattice shells and dequantization fits direct mapping onto CUDA and SIMD kernels, due to strictly local computation and integer arithmetic (Ouderaa et al., 11 Mar 2026).

5. Practical Training and Pipeline Integration in Machine Learning

In autoencoder and image synthesis pipelines, training with Λ₂₄-SQ becomes notably simplified due to its high-symmetry code. Unlike BSQ and related methods, no entropy penalty or commitment loss is required:

• Objective: $$\mathcal{L} = \mathbb{E}_x[\|x-\hat{x}\|_1 + 0.1 L_{LPIPS}(x,\hat{x}) + 0.1 L_{GAN}(x,\hat{x}) ]$$.
• Effective codebook size of 196,560 tokens ($\sim 17.58$ bits).
• Integration into both autoencoding and autoregressive generation frameworks is direct; codewords can be treated as categorical tokens or as factorized multi-dimensional discrete variables (24 × 9-way, for values $-4, \dots, +4$).
• Training uses AdamW with cosine annealing, batch size = 32/GPU (no entropy/commitment regularization needed) (Zhao et al., 16 Dec 2025).

Autoregressive models employing Λ₂₄-SQ exhibit improved generation quality (ImageNet-1k, 1B parameter model):

Model	FID	Recall	IS
VAR-d24	2.09	.59	312.9
∞CC+BSQ	2.18	.59	312.9
∞CC+Λ₂₄-SQ	1.82	.64	333.4
Oracle	1.78	—	—

(Zhao et al., 16 Dec 2025) reports consistent improvements in all codebook-free quantizer benchmarks.

6. Broader Applications and Spherical Leech Quantization Variants

Λ₂₄-SQ principles extend naturally to shape–gain quantization (decomposing input into gain and shape components) as well as higher-dimensional wrapped spherical codes for similarity queries and flat-torus codes for group structure and decoding efficiency (Steiner et al., 2014, Torezzan et al., 2012). The approach is particularly effective for finite-blocklength similarity search, where Λ₂₄-based codes achieve error probabilities within approximately 1 bit of theoretical achievability, and for block quantization of high-dimensional models (e.g., LLM weights), providing both theoretical optimality and practical throughput (Ouderaa et al., 11 Mar 2026).

Key advantages across applications include:

• Minimum angular covering of $S^{23}$ for a given code size.
• Efficient integer encoding and decoding, independent of codebook size.
• Group-code structure enabling efficient storage, indexing, and decoding, scaling linearly or quadratically with dimension rather than exponentially in code size (Torezzan et al., 2012).
• Empirical improvement in rate-distortion and downstream performance metrics in both machine vision and large model compression.

7. Comparative and Asymptotic Properties

Λ₂₄-SQ sets a benchmark for lattice-based quantization schemes:

• Asymptotically, its mean squared error (MSE) approaches the Shannon lower bound for spherical quantization as codebook size increases. Packing density on $S^{23}$ matches the product of the best-known densities for $\Lambda_{24}$ and $\Lambda_{23}$ (Torezzan et al., 2012).
• At moderate codebook sizes, combinatorial symmetry enables larger covering radii and code sizes than “apple-peeling” or earlier wrapped/laminated constructions, with strictly lower computational complexity (O(1) in code size, O($d^2$) in dimension).
• For practical block sizes (e.g., $n=24$ or $n=25$), Λ₂₄-SQ matches or outperforms “genie-aided” bounds for shape-gain quantization and comes close to the asymptotic error-exponent (Steiner et al., 2014).

This demonstrates the enduring importance of the Leech lattice as a tool for quantization, with applicability from modern generative models to classical information-theoretic tasks in high dimensions.