Linear Isomorphism Testing Problem

• Linear Isomorphism Testing Problem is a framework for determining if algebraic objects—such as polynomials, matrices, or algebras—are equivalent under invertible linear transformations.
• It employs algorithmic techniques like tensor reductions, block-gadget constructions, and canonical invariant methods to solve complex equivalence testing.
• The problem’s deep ties to Graph Isomorphism illustrate its challenging complexity landscape and significant implications for both average-case and worst-case algorithm design.

The Linear Isomorphism Testing Problem encompasses a rich spectrum of algorithmic, algebraic, and complexity-theoretic questions centered on deciding, often for structured algebraic objects, whether two instances are equivalent under a prescribed group of linear transformations. Linear isomorphism testing arises across multiple mathematical domains, including the equivalence of polynomials under linear change of variables, isometry of tuples of (skew-)symmetric or alternating matrices, isomorphism of finite-dimensional algebras, subspace-tuple equivalence, and code and matroid isomorphism. This concept further underpins testing isomorphism for algebraic structures in group theory, multilinear algebra, and combinatorics, with deep ties to graph isomorphism, module isomorphism, and property testing.

1. Formal Problem Statements and Mathematical Frameworks

The core Linear Isomorphism Testing Problem can be formalized, with domain-dependent refinements, as follows. Let $K$ be a finite field (or, in some contexts, any field), and suppose structures $A$ and $B$ (e.g., polynomials, matrix-tuples, algebras) are defined on $K^n$. The fundamental question is whether there exists an invertible $K$-linear transformation $g\in GL_n(K)$ such that $A$ and $B$ become equivalent under the induced action, sometimes up to additional symmetries (e.g., permutations, scaling, automorphisms of related groups) (Ivanyos et al., 2017, Li et al., 2017, Grochow et al., 2020, King et al., 2021, Kreuzer, 10 Nov 2025).

Key instantiations include:

• Polynomial isomorphism: For $f, g \in K[x_1,\ldots,x_n]$ (typically homogeneous of degree $d$), does there exist $A\in GL_n(K)$ with $g(x) = f(Ax)$?
• Tuples of forms (matrix or multilinear): For tuples $(B_1,\ldots,B_m), (C_1,\ldots,C_m)$ of (skew-)symmetric, alternating, or general matrices, is there an $A\in GL_n(K)$ such that $A^T B_i A = C_i$ $\forall i$?
• Graded algebras: Given algebras $A$, $B$ presented as graded vector spaces with bilinear products specified by structure constants, can one decide the existence of a graded algebra isomorphism (a collection of compatible linear maps on homogeneous components) (Brooksbank et al., 2017)?
• Subspace-tuple isomorphism: Given tuples $(V_1,\ldots,V_k)$, $(W_1,\ldots,W_k)$ of subspaces of $K^n$, does $g\in GL_n(K)$ exist with $g(V_i) = W_i$ for all $i$ (King et al., 2021)?
• Code and matroid isomorphism: For two generator matrices $G, G'$, does there exist $A\in GL_k(K)$, permutation $P$, and diagonal $D$ such that $G' = AGDP$ (Kreuzer, 10 Nov 2025, 0811.3859)?

The isomorphism type often includes "pseudo-isometries," allowing scaling (alternating/symmetric forms), or is more constrained depending on the algebraic structure.

2. Algorithmic Paradigms: Reductions, Gadget Constructions, and Canonical Forms

Central to recent advances are polynomial-time reductions and canonical form theory:

• Tensor Isomorphism (TI) and Linear-Length Reductions: Many isomorphism problems are polynomial-time equivalent under reductions that transform inputs to 3-tensors acted upon by groups of the form $GL(U)\times GL(V)\times GL(W)$, or to structured instantiations (e.g., symmetric or alternating forms). Grochow and Qiao established that cubic-form equivalence, algebra isomorphism, alternating matrix space isometry, general 3-tensor isomorphism, and related group-theoretic isomorphism tasks are all TI-complete and polynomial-time interreducible, with new "linear-length" gadgets ensuring that the blow-up in tensor dimension is only linear rather than quadratic (Grochow et al., 2023, Grochow et al., 2020).
• Block-Gadget Techniques: The linear-length gadget of Grochow–Qiao proceeds by appending well-structured blocks—rank-pinning alternating or symmetric matrices and carefully designed slices that force block structure—that ensure any admissible isomorphism must respect a prescribed partition or decomposition. This mechanism is essential for transferring algorithmic results across isomorphism problems.
• Canonical Invariants: In subspace-tuple isomorphism and matrix-tuple isometry, the construction of complete systems of invariants is achieved using trace identities (Specht–Wiegmann theorems), quiver representations, and $H^*$-algebra methods. These yield polynomial-time isomorphism tests whenever function stabilizers are trivial or can be efficiently characterized (King et al., 2021).
• Module Isomorphism and *-Algebra Factorizations: For tuples of (skew-)symmetric matrices, isomorphism testing reduces to $*$-symmetric decomposition in adjoint algebras, solvable (over fields of characteristic $\ne2$) via radical decomposition, lifting, and reduction to classical single-form isometry (Ivanyos et al., 2017). This underlies efficient solutions for quadratic IP1S, class-2 exponent-$p$ group isomorphism with small commutator subgroup, and certain polynomial identity testing tasks.

3. Complexity Landscape: Average-Case and Worst-Case Algorithms

The complexity of linear isomorphism testing exhibits sharp contrasts between average- and worst-case instances, and is deeply intertwined with the Graph Isomorphism (GI) problem.

• Average-Case Algorithms: For random cubic forms or random alternating matrix spaces, $q^{O(n)}$-time algorithms solve isomorphism with high probability. For random $m$-alternating spaces over $F_q^n$ with $m=cn$, a randomized individualization-and-refinement algorithm inspired by the Erdős–Rényi model and Babai–Erdős–Selkow's approach achieves $q^{O(n)}$ time except on a $q^{-\Omega(n)}$ fraction of pathological inputs (Grochow et al., 2020, Li et al., 2017).
• Worst-Case Algorithms & Reductions: In general, algebra isomorphism, cubic-form equivalence, matroid isomorphism, and related tasks are all at least as hard as Graph Isomorphism when the problem parameters (e.g., rank, degree) are unbounded. When parameters are bounded, LMI is polynomial-time equivalent to GI, via explicit constructions and reductions (e.g., Babai's $k$-truncation, graph-to-matroid and vice versa) (0811.3859).
  • The latest advances in TI-completeness and linear-length reductions yield $q^{O(n)}$-time algorithms for cubic-form equivalence and algebra-isomorphism, conditional on GI being in P (Grochow et al., 2023).
• Hardness and Completeness: Many linear isomorphism testing problems over bounded fields and bounded parameters (matroid rank, degree of forms) are polynomial-time equivalent to GI; over growing fields, linear matroid isomorphism is coNP-hard (0811.3859). Most isomorphism problems for polynomials of bounded degree, matrix tuples, and algebras are thus not expected to be NP-complete unless GI is.

4. Special Structures and Applications

• Graded Algebras: For finite $M$-graded $K$-algebras (e.g., graded nilpotent Lie algebras), the leading algorithms enumerate isotopisms between homogeneous "slices," then extend by compatibility through the grading, with pruning heuristics using projective-geometry invariants and subspace fingerprints (Brooksbank et al., 2017). Complexity is controlled by the size of automorphism and adjoint groups on homogeneous components.
• Boolean Functions: Linear isomorphism for Boolean functions $f,g:\mathbb{F}_2^n\to\{-1,1\}$ is deeply influenced by the (approximate) spectral norm. Function classes with small approximate spectral norm allow for efficient communication and property testing protocols; tolerant testers for more general finite Abelian groups rely on generalized implicit sieve algorithms leveraging Fourier sparsity and duality (Ghosh et al., 2023, Datta et al., 10 Jul 2025, Datta et al., 11 Jan 2026).
• Code and Point-Set Isomorphism: The Linear Code Equivalence problem can be reduced to polynomial isomorphism (PI) for homogeneous polynomials via projective point-set equivalence, algebra doubling, and Macaulay inverse-system theory. For indecomposable iso-dual codes, the reduction yields cubic PI instances, where specialized linear-algebraic attacks are efficient (Kreuzer, 10 Nov 2025).
• Subspace-Tuple Equivalence: For tuples of subspaces, robust polynomial-time algorithms exist based on complete invariants unless permutations are allowed, in which case the problem becomes GI-hard (King et al., 2021).

5. Extensions, Open Problems, and Theoretical Implications

• Group Theory: The isomorphism testing of $p$-groups (class $2$ and exponent $p$) is reduced to alternating matrix space isometry. Linear-length reductions further extend these to higher nilpotency class, preserving asymptotic efficiency (Grochow et al., 2023, Li et al., 2017).
• Module and Bilinear Form Isomorphism: Techniques from linear isomorphism testing suggest possible average-case efficient and refined algorithms for module isomorphism and various 3-tensor isomorphism types, paralleling advances for graphs.
• Automorphism Problems: For linear and graphic matroids, code, and algebraic structures, automorphism group computation reduces to corresponding isomorphism problems via coloring and stabilization arguments (0811.3859, Brooksbank et al., 2017).
• Open Directions: Key open directions include: closing the complexity gap for worst-case instances of TI-complete problems, derandomizing average-case algorithms, extending search- and counting-to-decision reductions, and refining block-gadget constructions. Investigating threshold phenomena and developing analogues of Weisfeiler–Leman partition refinement for matrix spaces are also prominent challenges (Grochow et al., 2023, Grochow et al., 2020, Li et al., 2017).

6. Connections with Graph Isomorphism and General Complexity Theory

Linear Isomorphism Testing problems repeatedly reveal deep analogies and reductions to GI:

Problem Domain	Equivalent to GI?	Reduction(s) Used
Linear Matroid Iso. (bounded rank)	Yes	$k$-truncation, bipartite graphs
Graphic Matroid Iso.	Yes, via Turing reduction	Canonical tree decomposition
Graded Algebra Iso.	TI-complete (GI-hard)	Tensor isomorphism reductions
Subspace-tuple Iso.	Yes (with permutations)	Graph encoding

In sum, linear isomorphism testing is a central unifying framework in computational algebra and combinatorics, providing a robust generalization of graph isomorphism and subsuming multiple natural algebraic equivalence and symmetry problems. Recent work leverages algebraic and tensorial structure, block-gadget design, and invariant theory to yield new algorithms and highlight profound complexity-theoretic interconnections.

References:

(Ivanyos et al., 2017, Li et al., 2017, Brooksbank et al., 2017, Grochow et al., 2020, King et al., 2021, Grochow et al., 2023, Ghosh et al., 2023, Lindeberg, 2024, Datta et al., 10 Jul 2025, Kreuzer, 10 Nov 2025, Datta et al., 11 Jan 2026, 0811.3859)