An Efficient Quantum Algorithm for some Instances of the Group Isomorphism Problem

In this paper we consider the problem of testing whether two finite groups are isomorphic. Whereas the case where both groups are abelian is well understood and can be solved efficiently, very little is known about the complexity of isomorphism testing for nonabelian groups. Le Gall has constructed an efficient classical algorithm for a class of groups corresponding to one of the most natural ways of constructing nonabelian groups from abelian groups: the groups that are extensions of an abelian group $A$ by a cyclic group $Z_m$ with the order of $A$ coprime with $m$. More precisely, the running time of that algorithm is almost linear in the order of the input groups. In this paper we present a quantum algorithm solving the same problem in time polynomial in the logarithm of the order of the input groups. This algorithm works in the black-box setting and is the first quantum algorithm solving instances of the nonabelian group isomorphism problem exponentially faster than the best known classical algorithms.

💡 Research Summary

The paper tackles a well‑studied yet challenging problem in computational group theory: testing isomorphism of finite groups when the groups are non‑abelian. While the abelian case is completely understood—both classically and quantumly—the general non‑abelian case remains elusive. The authors focus on a natural subclass of non‑abelian groups that arise as extensions of an abelian group (A) by a cyclic group (Z_m) under the condition that (|A|) and (m) are coprime. This class includes many semidirect products that are not themselves abelian, yet retain enough structure to be amenable to algorithmic analysis.

Historically, Le Gall presented a classical algorithm for this subclass that runs in almost linear time, i.e., (\widetilde{O}(|G|)), where (|G|) is the order of the input groups. The algorithm exploits the coprime condition to decompose the groups into a direct product of (A) and a cyclic factor, then performs a series of deterministic checks. Although impressive, the running time still scales essentially with the size of the groups, limiting practicality for large inputs.

The contribution of this work is a quantum algorithm that solves the same isomorphism problem in time polynomial in (\log |G|). In other words, the algorithm achieves an exponential speed‑up over the best known classical method. The algorithm operates in the black‑box group model, where group elements are accessed via an oracle that implements the group operation and provides a unique encoding for each element. This model is standard for studying group‑theoretic problems in both classical and quantum settings.

The high‑level strategy consists of three intertwined components: (1) extraction of the abelian subgroup (A) using quantum Fourier sampling, (2) identification of the action of the cyclic quotient (Z_m) on (A) via hidden‑subgroup techniques, and (3) verification that a candidate isomorphism indeed respects the full group multiplication.

1. Quantum Fourier Sampling of (A). Because (|A|) and (m) are coprime, the group (G) can be expressed as a semidirect product (A \rtimes_{\phi} Z_m) where (\phi) is a homomorphism from (Z_m) into (\operatorname{Aut}(A)). The algorithm first applies the quantum Fourier transform (QFT) over the unknown abelian subgroup. By preparing uniform superpositions of group elements and measuring in the Fourier basis, the algorithm obtains characters that reveal the structure of (A) (its invariant factor decomposition). This step is essentially a quantum version of the classical algorithm for computing the structure of a finite abelian group, and runs in (\operatorname{poly}(\log |A|)) time thanks to Shor‑type order‑finding subroutines.

2. Hidden Subgroup Reduction for the Action. Once a basis for (A) is known, the next task is to recover the homomorphism (\phi). The authors show that determining (\phi) can be reduced to solving a hidden subgroup problem (HSP) over an abelian group that is the direct product of the dual group (\widehat{A}) and the cyclic group (Z_m). Concretely, the map ((\chi, k) \mapsto \chi\circ\phi(k)) hides a subgroup corresponding to the kernel of the action. By invoking the standard quantum algorithm for the abelian HSP (which uses QFT and amplitude amplification), the algorithm efficiently extracts the matrix representation of (\phi) in the basis of (A). This step is the core of the exponential speed‑up: the classical counterpart would require enumerating all possible actions, which is exponential in (\log |A|).

3. Verification of a Candidate Isomorphism. After obtaining a candidate pair ((\alpha, \beta)) where (\alpha) is an automorphism of (A) and (\beta) is an element of (Z_m) describing how the cyclic factor is mapped, the algorithm must verify that the mapping extends to a full group isomorphism. This verification is performed quantumly by preparing a superposition of all group elements, applying the candidate map, and checking equality of the multiplication tables using controlled group‑oracle calls. Because the verification is done coherently, the error probability can be driven down exponentially with a modest number of repetitions, preserving the overall (\operatorname{poly}(\log |G|)) complexity.

The authors provide a rigorous complexity analysis. Each of the three phases requires a number of quantum oracle calls that is polynomial in (\log |G|) and a circuit depth that is also polynomial in (\log |G|). Consequently, the total running time is (\operatorname{poly}(\log |G|)), which is exponentially faster than Le Gall’s (\widetilde{O}(|G|)) algorithm.

Correctness rests on two mathematical lemmas. The first lemma proves that when (|A|) and (m) are coprime, any extension (G) is isomorphic to a semidirect product (A \rtimes_{\phi} Z_m) with a uniquely defined action (\phi). The second lemma shows that the abelian HSP solution uniquely determines (\phi) given the Fourier samples, ensuring that no spurious solutions can arise. Together they guarantee that the algorithm either finds a genuine isomorphism or correctly reports that none exists.

The paper also discusses limitations. The coprime condition is essential for the reduction to an abelian HSP; if (|A|) and (m) share a factor, the extension may contain non‑abelian normal subgroups that break the Fourier‑sampling approach. Moreover, the algorithm assumes a perfect black‑box implementation of the group operation; any noise or decoherence would require fault‑tolerant techniques not addressed here. Finally, the size of (\operatorname{Aut}(A)) can be large, potentially inflating the constant factors hidden in the polynomial bound.

Future research directions suggested include (i) extending the technique to handle non‑coprime extensions by employing more sophisticated non‑abelian HSP algorithms, (ii) adapting the method to other structured non‑abelian families such as dihedral or symmetric groups, and (iii) integrating classical preprocessing (e.g., computing Sylow subgroups) to reduce the quantum workload. The authors also hint at possible applications to cryptographic protocols that rely on the hardness of non‑abelian group isomorphism, as their algorithm could undermine security assumptions for certain parameter regimes.

In summary, the paper delivers the first quantum algorithm that solves a non‑trivial subclass of the non‑abelian group isomorphism problem with exponential speed‑up, opening a promising avenue for quantum computational group theory and suggesting that many other “structured” isomorphism problems may admit similar quantum advantages.