Numeric Canonicalization Techniques

• Numeric canonicalization is the process of converting mathematical objects into unique minimal representatives using specific equivalence relations and lexicographic ordering.
• It applies to structures like matrices over finite fields and batched Einstein summations, enabling efficient equivalence testing, optimization, and reuse of computation.
• The methodology includes recursive row/column sorting and graph-based canonical labeling, which have been shown to yield significant speedups in high-performance numerical computing.

Numeric canonicalization is the process of mapping mathematical objects—such as matrices with integer entries modulo $p$, or sets of indexed tensor operations (e.g., batched Einstein summations)—to unique, minimal representatives under a specified equivalence relation. This is typically achieved via a total ordering (often lexicographic) that allows algorithmic identification, comparison, and optimization across equivalence classes. Numeric canonicalization serves as a foundation for equivalence testing, code transformation, and reuse of computational work in symbolic, algebraic, and high-performance numerical computing.

1. Equivalence Relations and Canonical Representatives

The core of numeric canonicalization is defining an equivalence relation $\sim$ under which objects are considered "the same" for computational or structural purposes. For $n\times m$ matrices with entries in $[p]=\{0,1,\dots,p-1\}$, the relevant equivalence is simultaneous row and column permutation: $$A \sim B \iff \exists X \in \mathcal{P}_n, Y \in \mathcal{P}_m$$ such that $A = X B Y$, where $\mathcal{P}_k$ is the group of $k \times k$ permutation matrices. Canonicalization then selects, from each equivalence class, a unique representative—typically the minimal one under lexicographic order on an encoding of the object (Yordzhev, 2021).

For batched Einstein summation expressions, equivalence is defined by index renaming, batch and operand permutations, and algebraic symmetries (commutativity and associativity of products). The absence of a canonical form impedes reuse and fusion of computational results; deriving a unique normal form enables systematized optimization (Kulkarni et al., 18 Jan 2026).

2. Matrix Canonicalization Over $[p]$: Methods and Characterization

Given $A\in\mathcal{M}_{n\times m}^p$, each matrix is uniquely represented by its row-tuple $r(A) = \langle x_1, x_2, \dots, x_n \rangle$, where $x_i = \sum_{j=1}^m a_{ij}\,p^{m-j}$. Lexicographic ordering on row-tuples imposes a total order on matrices. The canonical matrix in the equivalence class $[A]$ is the unique representative with minimal row-tuple, i.e., $r(A) = \min_{\textrm{lex}}\{ r(B) : B \sim A \}$ (Yordzhev, 2021).

A matrix $A$ is canonical if and only if it satisfies six conditions (Theorem 4.1): (1) nondecreasing row-tuple; (2) first-row size bound; (3) nondecreasing last-$s$ columns (for $s=\nu_1(A)$, the number of nonzero entries in the first row); (4) row-weight monotonicity; (5) local minimality under certain row/column swap operations; (6) recursive canonicity of a lower-dimensional submatrix arising from deleting certain rows and columns.

The canonical form is algorithmically computed by recursively sorting rows and appropriate columns and applying these necessary and sufficient criteria, ensuring uniqueness within each equivalence class.

3. Batched Einstein Summation Canonicalization

In the context of tensor algebra, equivalence of batched Einstein summations is complicated by multiple sources of symmetry: index names, order of operands, factor permutations in products, and batch arrangements. To render equivalence checking tractable and canonicalization practical, each batched einsum is encoded as a vertex-colored, directed graph $G(e)$. This graph captures all operand, index, positional, and batch symmetries using appropriately colored node classes and edges that encode access patterns and operand structure (Kulkarni et al., 18 Jan 2026).

Mature graph-canonicalization algorithms (e.g., nauty, bliss) are applied to $G(e)$, producing a canonical labeling of its nodes. This labeling is then inverted to yield the canonical batched-einsum tuple $C(e)$. Equivalence testing becomes a single comparison of canonical forms: $e_1 \simeq e_2 \iff C(e_1) = C(e_2)$.

4. Algorithmic Procedures and Pseudocode

Matrix Canonicalization

The canonicalization of $A\in\mathcal{M}_{n\times m}^p$ follows a recursive, stepwise algorithm:

1. Row Sorting: Sort rows to put $r(A)$ in nondecreasing order.
2. Column Sorting: If last $s$ columns are not nondecreasing, reorder them; if this lowers the row-tuple, $A$ is non-canonical.
3. Row-Weight Check: All rows below must have at least as many nonzero entries as the first.
4. Local Minimality: For each candidate block swap, ensure that it does not yield a lexicographically smaller row-tuple.
5. Recursion: On remaining submatrix, apply steps 1–4. Canonicalization is complete when no swap or submatrix operation can further decrease $r(A)$.

Batched Einsum Canonicalization

The process comprises:

1. Graph Construction: Build the colored graph $G(e)$ representing the batched einsum’s structural elements and dependencies.
2. Canonical Relabeling: Apply a black-box canonicalizer to obtain node relabeling.
3. Permutation and Reconstruction: Map the permuted graph back to a batched-einsum form.
4. Substitution Map Construction: Derive argument and index name substitutions.
5. Return: The canonicalized form and substitution maps.

Algorithmic complexity is linear or quadratic in the number of nodes ($N=O(b n \text{Dim})$), and practical instances complete canonicalization in under 1 ms (Kulkarni et al., 18 Jan 2026).

5. Functional and Optimization Aspects

For batched Einstein summations, arrays can be symbolic, given as functional operands $M(A): \text{dom}(A) \to \text{codomain}(A)$. The canonicalization process remains valid whether the operands are concrete buffers or arbitrary pointwise functions, provided the induced memory-access pattern is unchanged. This allows reuse of performance tuning and code transformation knowledge across broad classes of equivalent tensor operations, as performance is primarily determined by the pattern of data access rather than the precise functional form (Kulkarni et al., 18 Jan 2026).

Transforms and optimizations tuned for the canonical form are "transferred back" to the user's original expression via inverse substitution maps. Thus, high-performance code for one canonical pattern is automatically specialized and applied to all computationally equivalent variants, including those differing by automatic code generation or user-level naming.

6. Applications and Empirical Results

Numeric canonicalization underpins code transformation, optimization, and benchmarking workflows in numerical linear algebra, finite element methods, computational chemistry, and related high-performance fields.

For matrices over $[p]$, the canonical form simplifies classification problems, isomorphism testing, and object tabulation.

For batched einsums, canonicalization enables substantial performance improvements:

• DG-FEM macro kernels achieved speedups up to $100\times$, typically $5$–$20\times$ for polynomial order $P\geq2$, due to fusion and reduced memory loads.
• In the TCCG tensor-contraction suite, using canonical forms led to a geometric-mean throughput speedup of $2.1\times$ (up to $3.6\times$ for the memory-bound subset) over JAX/cuBLAS implementations.
• Canonicalization overhead is negligible relative to kernel generation times, remaining below $1$ ms in all observed cases (Kulkarni et al., 18 Jan 2026).

7. Representative Examples and Interpretive Remarks

A nontrivial instance of $p=3$ and $n=m=4$ for matrix canonicalization demonstrates that canonicalization correctly identifies the unique minimal matrix in its equivalence class, even when the original is in semi-canonical form but not minimal. In the batched einsum context, colored graph encodings and their canonical forms allow detection, fusion, and recognition of equivalent computation patterns at scale.

This suggests that numeric canonicalization is a key enabler for scalable, automated, and architecture-portable computation in domains where structural symmetry, data reuse, and symbolic manipulation are intertwined. The rigorous, algorithmically explicit approaches described provide the basis for both theoretical analysis and practical system design in contemporary numerical computing (Yordzhev, 2021, Kulkarni et al., 18 Jan 2026).