🔢 mathematics

Direction-Preserving Number Representations

This paper introduces a geometric framework to analyze and optimize low-precision scalar alphabets for vector direction representation, demonstrating that standard formats like two's complement and floating-point are suboptimal while validating that NVIDIA's NVFP4 E2M1 format closely approximates the theoretically optimal configuration for four-bit precision.

Original authors: Bardia Zadeh, George A. Constantinides

Published 2026-05-11

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Bardia Zadeh, George A. Constantinides

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to describe the direction a wind is blowing using a very limited set of words. You have a "dictionary" of numbers (like a finite alphabet) that you can use to build a vector. In modern machine learning, computers often use these tiny, low-precision dictionaries to save energy and speed up calculations.

This paper asks a simple but profound question: If we build our direction vectors using these limited dictionaries, how accurately can we actually point in the right direction?

Here is a breakdown of their findings using everyday analogies:

1. The Grid vs. The Globe (The Core Problem)

Imagine you are standing in the center of a giant room (a sphere) and you want to point at any spot on the walls.

The Ideal Way (Spherical Codes): You have a magical compass that can point to any spot on the wall with perfect precision. You can place your "points" exactly where you need them to cover the whole room evenly.
The Machine Learning Way (Product Codes): You are forced to build your points using a grid. You have a list of numbers for the "X" axis and the same list for the "Y" axis (and Z, etc.). You can only point to the intersections of these grid lines.

The Finding: The paper proves that a grid is fundamentally worse at covering a sphere than a magical, free-form arrangement. Just like a grid has awkward gaps between the lines where you can't point exactly, these standard number formats leave "blind spots" in the directions they can represent.

2. The "Harmonic Witness" (The Unbeatable Target)

To prove the grid is flawed, the authors invented a specific, tricky direction they call the "Harmonic Witness."

The Analogy: Imagine the grid lines are like a fishing net. The authors found a specific, slippery fish (the harmonic direction) that is shaped in such a way that it always slips right through the holes of the net, no matter how you try to tighten it.
The Result: As the dimensions get higher (more complex data), this "slippery fish" becomes harder and harder to catch with a grid-based system. The error in pointing direction grows, proving that standard formats are mathematically suboptimal.

3. The Standard Formats are "Good Enough," But Not "Best"

The paper looks at the number formats we currently use, like Two's Complement (standard integers), Fixed-Point, and Floating-Point (like the E2M1 format used by NVIDIA).

The Analogy: Think of these standard formats as different brands of pre-made shoe laces. They all work, but they are all cut from the same rigid template.
The Finding: The authors proved mathematically that none of these standard "laces" are the perfect fit for the job. They all leave larger gaps than necessary. There is a quantifiable "gap" between how well they work and how well they could work if we designed them specifically for pointing directions.

4. The Optimized Alphabet (The Custom Solution)

Since the standard formats aren't perfect, the authors used a computer to design a brand-new "dictionary" of numbers specifically to minimize those directional gaps.

The Result: They created a custom set of numbers (an "Optimized Alphabet") that fits the grid much better than the standard ones.
The Surprise: When they tested this, they found that NVIDIA's E2M1 format (a specific 4-bit floating-point format) is actually very close to their custom, mathematically perfect solution.
The Takeaway: This explains why NVIDIA's format works so well in low-precision AI. It wasn't just luck; their format accidentally (or cleverly) mimics the geometry of the optimal solution, even though it wasn't explicitly designed for this specific "direction" problem.

Summary

The paper argues that while we are stuck using "grid-like" number formats for efficiency, we should stop assuming the standard formats (like integers or standard floats) are the best we can do.

Grids are inherently worse at representing directions than free-form points.
Standard formats (like floating-point) are not the best possible grids; they leave unnecessary gaps.
We can do better by designing custom number lists specifically for direction.
NVIDIA's E2M1 is a "happy accident" that happens to be very close to this optimal design, which is why it performs so well in modern AI.

The authors have even released their math proofs and the code for these new, optimized number lists so others can use them.

Technical Summary: Direction-Preserving Number Representations

Problem Statement

Modern machine learning systems increasingly rely on low-precision number formats to improve efficiency in power consumption, resource utilization, and throughput. While scalar quantization maps real-valued vector elements to a discrete alphabet, creating a "product code" (the Cartesian product of the scalar alphabet), the geometric implications of this structure on vector direction are often overlooked.

Most existing work evaluates quantization via mean-squared error or norm-based metrics. However, the rise of block-based formats (e.g., block minifloat, MX formats, IEEE P3109) suggests that directional fidelity—the ability to accurately represent the direction of a vector—is a critical metric. The central problem addressed is the geometric limitation imposed by product-structured codes: the set of achievable directions is constrained by the scalar alphabet, potentially leading to significant gaps in angular coverage compared to unconstrained spherical codes. The paper investigates whether standard scalar formats (two's complement, fixed-point, floating-point) are suboptimal for preserving vector directions and if new alphabets can be designed to mitigate this.

Methodology

The authors employ a geometric framework to analyze the directional coverage of product-structured codes. The methodology combines rigorous theoretical analysis with numerical optimization and empirical evaluation.

Theoretical Framework

Definitions: The work defines a product code direction set $P_n(A)$ as the set of normalized vectors formed by the Cartesian product of a finite scalar alphabet $A$ . The performance metric is the spherical covering radius $F_n(A)$ , representing the maximum angular distance between any unit vector and its nearest representable direction in the code.
Lower Bounds (Harmonic Witness): To establish limits on product codes, the authors construct a specific "harmonic witness" direction using harmonic numbers. They prove that for any finite alphabet, there exist directions that are inherently difficult to align with product-structured vectors, providing an analytical lower bound on the worst-case angular error.
Upper Bounds (Spherical Codes): Using Wyner's theorem on random packings, the authors derive upper bounds for the covering radius of unconstrained spherical codes with the same number of points.
Asymptotic Analysis: The paper compares the asymptotic behavior of product codes versus spherical codes as dimension $n$ increases, proving a strict separation in coverage performance.
Standard Format Analysis: The authors analyze specific families of alphabets (floating-point, fixed-point, two's complement) to quantify their suboptimality gap relative to an optimal product code.

Experimental Approach

Numerical Optimization: A derivative-free optimization framework (combining Differential Evolution and Powell's method) is used to numerically search for scalar alphabets that minimize the worst-case angular error for a given bit-width and dimension.
Efficient Search: To evaluate the covering objective efficiently, the authors implement an extension of a nearest-neighbor search method that reduces the search space to a single dimension (scale) by optimizing over all possible vector scales for element-wise quantization.
Comparative Evaluation: The optimized alphabets are compared against standard 4-bit formats (specifically NVIDIA's NVFP4 E2M1, E3M0, and INT/E1M2) across dimensions $d=4$ to $d=64$ .

Key Contributions

The paper makes four primary contributions:

Analytical Proof of Suboptimality: The authors provide a rigorous proof that product-structured codes are strictly suboptimal compared to spherical codes for directional coverage. This holds in both low dimensions (specifically dimension 2, except for the antipodal binary case) and asymptotically in high dimensions.
Quantification of Standard Format Gaps: The work proves that standard formats—two's complement, fixed-point, and floating-point—are suboptimal within the class of product codes. The paper quantifies the "suboptimality gap" using a normalized orthogonality deficit, showing that these formats converge to the theoretical limit ( $\pi/2$ ) at a strictly worse rate than an optimal alphabet.
Optimized Direction-Preserving Alphabets: The paper presents a numerical optimization approach to derive scalar alphabets specifically designed for directional coverage. These optimized alphabets serve as a benchmark for evaluating existing formats.
Geometric Explanation of E2M1 Performance: Through log-space analysis, the authors demonstrate that NVIDIA's E2M1 format (used in NVFP4) closely approximates the theoretically optimized alphabet. This provides a geometric justification for its strong performance in low-precision machine learning workloads.

Results

Theoretical Results

Dimension 2: Product codes are strictly suboptimal relative to spherical codes unless the alphabet is the antipodal binary set $\{-a, a\}$ .
High Dimensions: For any fixed alphabet size $q$ , there exists a dimension $N$ beyond which spherical codes strictly outperform any product code. The gap is quantified by the difference between the product code lower bound (derived from harmonic witnesses) and the spherical code upper bound.
Standard Formats: For bit-widths $b \ge 3$ , standard floating-point and fixed-point formats are asymptotically suboptimal. The paper establishes a concrete constant-factor gap (e.g., a ratio of $\approx 1.528$ for 4-bit formats) between standard formats and the optimal product code.

Experimental Results

Optimization: Numerical optimization yielded sign-symmetric 4-bit alphabets that consistently outperformed standard formats across dimensions $d=4$ to $d=64$ .
E2M1 Alignment: The E2M1 format (2 exponent bits, 1 mantissa bit) achieved angular error rates very close to the optimized alphabet, significantly outperforming E3M0 and INT/E1M2.
Log-Space Analysis: Regression analysis revealed that E2M1 exhibits a near-isometry with the optimized alphabet, suggesting that E2M1 is effectively a specific rounding of the optimal direction-preserving structure to the constraints of a 4-bit floating-point family.

Significance and Claims

The paper claims to provide a geometric perspective on the design of low-precision number formats. Its significance lies in shifting the design focus from traditional dynamic range and precision metrics to directional preservation, which is critical for vector operations in machine learning.

The authors assert that while product codes are inherently limited compared to unconstrained spherical codes, the choice of scalar alphabet remains a critical factor. The work demonstrates that:

Standard formats are not optimal for direction preservation, even within the constraints of product structures.
There is a quantifiable gap between standard formats and an optimal product code.
Existing high-performance formats like E2M1 succeed not by chance, but because their structure aligns closely with the geometric requirements for optimal directional coverage.

The paper concludes that these findings motivate the development of new scalar formats specifically optimized for direction preservation and provide a theoretical framework for analyzing the limits of such representations. The authors have made the formal proofs (in Lean), experimental code, and optimized alphabets available as open-source resources.