Added method to calculate Abelian Invariants

sympy/combinatorics/fp_groups.py

@@ -527,6 +527,17 @@ def is_cyclic(self):
                                       "is not implemented")
         return P.is_cyclic
 
+    def abelian_invariants(self):
+        """
+        Returns Abelian Invariants of a group.
+        """
+        try:
+            P, T = self._to_perm_group()
+        except NotImplementedError:
+            raise NotImplementedError("abelian invariants is not implemented"
+                                      "for infinite group")
+        return P.abelian_invariants()
+
 
 class FpSubgroup(DefaultPrinting):
     '''

sympy/combinatorics/perm_groups.py

@@ -3,6 +3,7 @@
 from random import randrange, choice
 from math import log
 from sympy.ntheory import primefactors
+from sympy import multiplicity
 
 from sympy.combinatorics import Permutation
 from sympy.combinatorics.permutations import (_af_commutes_with, _af_invert,
@@ -116,6 +117,8 @@ class PermutationGroup(Basic):
 
     .. [13] http://www.math.colostate.edu/~hulpke/CGT/cgtnotes.pdf
 
+    .. [14] https://www.gap-system.org/Manuals/doc/ref/manual.pdf
+
     """
     is_group = True
 
@@ -1702,6 +1705,79 @@ def is_abelian(self):
                     return False
         return True
 
+    def abelian_invariants(self):
+        """
+        Returns the abelian invariants for the given group.
+        Let ``G`` be a nontrivial finite abelian group. Then G is isomorphic to
+        the direct product of finitely many nontrivial cyclic groups of
+        prime-power order.
+
+        The prime-powers that occur as the orders of the factors are uniquely
+        determined by G. More precisely, the primes that occur in the orders of the
+        factors in any such decomposition of ``G`` are exactly the primes that divide
+        ``|G|`` and for any such prime ``p``, if the orders of the factors that are
+        p-groups in one such decomposition of ``G`` are ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``,
+        then the orders of the factors that are p-groups in any such decomposition of ``G``
+        are ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``.
+
+        The uniquely determined integers ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``, taken
+        for all primes that divide ``|G|`` are called the invariants of the nontrivial
+        group ``G`` as suggested in ([14], p. 542).
+
+        Notes
+        =====
+
+        We adopt the convention that the invariants of a trivial group are [].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy.combinatorics.perm_groups import PermutationGroup
+        >>> a = Permutation([0, 2, 1])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.abelian_invariants()
+        [2]
+        >>> from sympy.combinatorics.named_groups import CyclicGroup
+        >>> G = CyclicGroup(7)
+        >>> G.abelian_invariants()
+        [7]
+
+        """
+        if self.is_trivial:
+            return []
+        gns = self.generators
+        inv = []
+        der = self.derived_subgroup()
+        G = self
+
+        for p in primefactors(G.order()):
+            ranks = []
+            r = 2
+            while r > 1:
+                H = der
+                l = []
+                for g in gns:
+                    elm = g**p
+                    if not H.contains(elm):
+                        l.append(elm)
+                H = PermutationGroup(H.generators + l)
+                r = G.order()//H.order()
+                G = H
+                gns = G.generators
+                if r != 1:
+                    ranks.append(multiplicity(p, r))
+
+            if ranks:
+                l = [1]*ranks[0]
+                for i in ranks:
+                    for j in range(0, i):
+                        l[j] = l[j]*p
+                inv.extend(l)
+        inv.sort()
+        return inv
+
     def is_elementary(self, p):
         """Return ``True`` if the group is elementary abelian. An elementary
         abelian group is a finite abelian group, where every nontrivial

sympy/combinatorics/tests/test_fp_groups.py

@@ -241,3 +241,13 @@ def test_cyclic():
     assert f.is_cyclic
     f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
     assert not f.is_cyclic
+
+
+def test_abelian_invariants():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x*y, x**-1*y**-1*x*y*x])
+    assert f.abelian_invariants() == []
+    f = FpGroup(F, [x*y, x*y**-1])
+    assert f.abelian_invariants() == [2]
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert f.abelian_invariants() == [2, 4]

sympy/combinatorics/tests/test_perm_groups.py

@@ -957,3 +957,22 @@ def test_cyclic():
     assert G.is_cyclic
     G = AlternatingGroup(4)
     assert not G.is_cyclic
+
+
+def test_abelian_invariants():
+    G = AbelianGroup(2,3,4)
+    assert G.abelian_invariants() == [2, 3, 4]
+    G=PermutationGroup([Permutation(1,2,3,4), Permutation(1,2), Permutation(5,6)])
+    assert G.abelian_invariants() == [2, 2]
+    G = AlternatingGroup(7)
+    assert G.abelian_invariants() == []
+    G = AlternatingGroup(4)
+    assert G.abelian_invariants() == [3]
+    G = DihedralGroup(4)
+    assert G.abelian_invariants() == [2, 2]
+
+    G = PermutationGroup([Permutation(1,2,3,4,5,6,7)])
+    assert G.abelian_invariants() == [7]
+    G = DihedralGroup(12)
+    S = G.sylow_subgroup(3)
+    assert S.abelian_invariants() == [3]