Parallel Algorithms for Group Isomorphism via Code Equivalence

Abstract: In this paper, we exhibit $\textsf{AC}^{3}$ isomorphism tests for coprime extensions $H \ltimes N$ where $H$ is elementary Abelian and $N$ is Abelian; and groups where $\text{Rad}(G) = Z(G)$ is elementary Abelian and $G = \text{Soc}^{*}(G)$. The fact that isomorphism testing for these families is in $\textsf{P}$ was established respectively by Qiao, Sarma, and Tang (STACS 2011), and Grochow and Qiao (CCC 2014, SIAM J. Comput. 2017). The polynomial-time isomorphism tests for both of these families crucially leveraged small (size $O(\log |G|)$) instances of Linear Code Equivalence (Babai, SODA 2011). Here, we combine Luks' group-theoretic method for Graph Isomorphism (FOCS 1980, J. Comput. Syst. Sci. 1982) with the fact that $G$ is given by its multiplication table, to implement the corresponding instances of Linear Code Equivalence in $\textsf{AC}^{3}$. As a byproduct of our work, we show that isomorphism testing of arbitrary central-radical groups is decidable using $\textsf{AC}$ circuits of depth $O(\log^3 n)$ and size $n^{O(\log \log n)}$. This improves upon the previous bound of $n^{O(\log \log n)}$-time due to Grochow and Qiao (ibid.).

• The paper establishes AC³ parallel algorithms for isomorphism testing in special group classes like coprime extensions and central‐radical groups.
• The paper employs reductions to linear code equivalence and parallel linear algebra techniques to efficiently compute cohomology classes, permutation coset intersections, and irreducible representations.
• The paper bridges group theory, coding theory, and circuit complexity, paving the way for refined upper bounds and practical parallel implementations in computational group theory.

Parallel Algorithms for Group Isomorphism via Code Equivalence: Expert Analysis

Introduction and Motivation

The paper investigates the parallel computational complexity of the Group Isomorphism problem (GpI) for groups specified by their Cayley tables, focusing on substantial subclasses where polynomial-time algorithms are known. These include coprime extensions with elementary Abelian complements, and central-radical groups with elementary Abelian centers. By leveraging reductions to small instances of Linear Code Equivalence and the parallelizability of group-theoretic permutation algorithms, the work demonstrates $\mathsf{AC}^3$ parallel algorithms for isomorphism testing in these classes. This improves prior bounds and addresses foundational questions at the intersection of computational group theory, circuit complexity, and code equivalence.

Background and Context

GpI asks whether two given finite groups are isomorphic. When groups are input as full multiplication tables, the problem is in $\mathsf{NP} \cap \mathsf{coAM}$, but not $\mathsf{NP}$-complete under established evidence. Classical algorithms, notably generator enumeration, provide quasi-polynomial time in the general case. For special cases (e.g., Abelian, Fitting-free, solvable, or groups with tame extensions), polynomial-time algorithms exist, often exploiting cohomological invariants or structure-specific decompositions.

The relationship between GpI and Graph Isomorphism (GI) is central to complexity-theoretic discussion. GI admits recent quasipolynomial time solutions; GpI (in the Cayley model) is strictly easier via $\mathsf{AC}^0$ reductions. However, parallelization of GpI lags behind that of GI, motivating intricate circuit bounds for isomorphism testing in special group families.

Main Contributions

1. Coprime Extensions $\mathcal{H}(\mathcal{A},\mathcal{E})$

The class $\mathcal{H}(\mathcal{A},\mathcal{E})$ consists of coprime extensions $H \ltimes N$ where $H$ is elementary Abelian and $N$ is Abelian. Previous polynomial-time isomorphism tests depended crucially on small-size instances of Linear Code Equivalence. This work shows that these reductions are parallelizable in $\mathsf{AC}^3$ by combining Luks’ group-theoretic approach for GI with the rich suite of efficient permutation group algorithms applicable when the degree is $\mathsf{NP} \cap \mathsf{coAM}$0. The irreducible representation decomposition, permutation coset intersection, and code equivalence computations are efficiently implementable via bounded-depth circuits.

Claim: Uniform $\mathsf{NP} \cap \mathsf{coAM}$1 algorithms exist to decide membership in $\mathsf{NP} \cap \mathsf{coAM}$2 and to test isomorphism for groups therein.

2. Central-Radical Groups

For groups where the solvable radical equals the center and is elementary Abelian, and the quotient by the radical is a direct product of non-Abelian simple or bounded-order perfect groups, the polynomial-time algorithms of Grochow and Qiao are parallelized into $\mathsf{NP} \cap \mathsf{coAM}$3 algorithms. The proof builds on group extension and cohomological machinery, employing parallel linear algebra for cohomology class comparison and code equivalence for handling automorphic permutations of direct factors.

The work further extends to arbitrary central-radical groups, establishing isomorphism deciders using $\mathsf{NP} \cap \mathsf{coAM}$4 circuits of depth $\mathsf{NP} \cap \mathsf{coAM}$5 and size $\mathsf{NP} \cap \mathsf{coAM}$6, a meaningful theoretical enhancement over prior $\mathsf{NP} \cap \mathsf{coAM}$7-time bounds.

Claim: Isomorphism testing for these central-radical groups, and even coset computation of isomorphisms, can be done in $\mathsf{NP} \cap \mathsf{coAM}$8 given explicit multiplication tables.

3. Parallelization of Code Equivalence

A detailed reduction from Linear Code Equivalence (and its Generalized variant) to bounded-degree Graph Isomorphism is revisited and parallelized, exploiting the small domain ($\mathsf{NP} \cap \mathsf{coAM}$9) to construct efficient circuits. The key technical insight is that Gaussian elimination, code equivalence, and coset intersection algorithms are $\mathsf{NP}$0-computable at this scale, enabling practical circuit depth improvements for isomorphism tests of groups whose structure reduces to code equivalence.

4. Technical Infrastructure

The paper executes a thorough complexity analysis based on circuit depth and uniformity, critically exploiting the permutation group model and specialized representation theory results, including indexing tuples for irreducible representations and block decomposition techniques. Parallelization extends to cohomology computations, code equivalence, permutation group actions, and computation of direct product decompositions, with careful bottleneck analysis (e.g., factoring polynomials over finite fields).

Numerical Results and Strong Claims

• Circuit Depth Bounds: The central claims are quantifying isomorphism testing in special group families within $\mathsf{NP}$1, with explicit depth bounds for central-radical groups ($\mathsf{NP}$2).
• Efficiency of Subroutine Parallelization: All necessary subroutines—generator enumeration, code equivalence, coset computation, transversal selection—achieve $\mathsf{NP}$3 or $\mathsf{NP}$4 bounds for restricted parameters.
• Reduction of Generalized Code Equivalence: Instances with permutation group action restrictions are reducible to bounded-depth circuit computations.
• Non-trivial Coset Computation: The algorithms compute not just the existence but also the coset of isomorphisms—a highly non-trivial extension—within bounded-depth circuits.

Theoretical and Practical Implications

The results provide strong evidence that isomorphism testing for several structured classes of finite groups can be efficiently parallelized, moving beyond traditional serial implementations. The circuit-depth reductions achieved indicate that computational group theory inherits practical speedups from advances in parallel complexity, with implications for algebraic software systems and cryptographic group operations where group isomorphism and related equivalence testing are performance-critical.

Theoretically, this work tightens the connection between group extension theory, code equivalence, and circuit complexity, suggesting that several further complexity-theoretic reductions may be possible via code-based machinery. The refinements open avenues for sharper upper bounds, e.g., whether these problems reside in $\mathsf{NP}$5, and for broader parallelization of algebraic invariants and group-theoretic computations.

Future Directions

• Depth Reduction: Investigating if further reductions to $\mathsf{NP}$6 or $\mathsf{NP}$7 are possible for these classes, leveraging improved algorithms for transversal computation, block systems, and code equivalence.
• Polynomial Factoring Complexity: Steps rely on $\mathsf{NP}$8 complexity for factoring polynomials over finite fields; improvements to $\mathsf{NP}$9 would directly impact overall circuit depth.
• Generalization: Extending parallel bounds to broader classes, e.g., radical groups where the center is not elementary Abelian, or to permutation and matrix group input models.
• Algebraic Quasigroup Isomorphism: Extending these results to quasigroup isomorphism, especially non-group, non-polynomial cases.

Conclusion

This paper significantly advances the parallel complexity landscape for solving the group isomorphism problem in structured families, translating code equivalence and cohomology-based algorithms into uniform $\mathsf{AC}^0$0 circuits. The results sharply improve previous polynomial-time bounds, and by integrating group theory, coding theory, and circuit complexity, they lay foundational groundwork for further theoretical advances and practical parallelization in algebraic computation.