Added dynamic programming approach using chief series

Dynamic Programming Algorithm to compute `minimum_generating_set`

Author: RuchitJagodara

src/sage/groups/libgap_mixin.py

@@ -969,131 +969,200 @@ def is_isomorphic(self, H):
         return self.gap().IsomorphismGroups(H.gap()) != libgap.fail
 
 
-def minimum_generating_set(G) -> list:
-    """
-    Return a list of the minimum generating set of ``G``.
-
+def minimum_generating_set(G)->list:
+    r"""
     INPUT:
 
-    - ``G`` -- a group
+        - ``G`` -- The group whose minimum generating set we want. This must be converted to a 'gap based' group first if it's not via ``G=G.gap()`` .
 
     OUTPUT:
 
-    A list of GAP objects that generate the group.
+        - minimum generating set of ``G``, which is the the set `g` of elements of `G` of smallest cardinality such that `G` is generated by `g`, i.e. `\braket{g}=G`
 
     .. SEEALSO::
 
         :meth:`sage.categories.groups.Groups.ParentMethods.minimum_generating_set`
 
+
     ALGORITHM:
 
-    We follow the algorithm described in the research paper "A New Algorithm for Finding the Minimum Generating Set of a Group" by John Doe (:doi:`10.1016/j.jalgebra.2023.11.012`).
+    First we cover the cases when the Chief series is of length 1, that is if `G` is simple. This case is handled by ``libgap.MinimalGeneratingSet`` , so we assume that ``libgap.MinimalGeneratingSet`` doesn't work (it only works for solvable and some other kinds of groups).
+    So, we are guaranteed to find a chief series of length at least 2, since `G` is not simple. Then we proceed as follows..
 
-    The algorithm checks two base cases:
+    `S := ChiefSeries(G)`
 
-    1. If G is a cyclic group, it returns the cyclic generator.
-    2. If G is a simple group, it returns a combination of two elements that generate G.
+    `l := len(S)-1` (this is index of last normal subgroup, namely `G_l=\{e\}`)
 
-    If the above two cases fail, the algorithm finds the minimal normal subgroup N of G.
-    It then finds the quotient group G/N and recursively finds the minimum generating set of G/N.
-    Let S be the minimum generating set of G/N. The algorithm finds representatives g of S in G.
+    Let `g` be the set of representatives of the minimum generating set of `G/S[1]` . (This can be found using ``libgap.MinimalGeneratingSet`` since `G/S[1]` is simple group)
 
-    If N is abelian, the algorithm checks if any case of the form g_1, g_2, ..., g_i*s_j, g_i+1, ..., g_lg
-    (where lg is the length of g) is able to generate G. If not, it uses the set g_1, g_2, ..., g_lg, s_j
-    as the minimum generating set of G.
+    for k = 2 to 'l':
 
-    If N is non-abelian, the algorithm checks if any case of the form g_1*n_1, g_2*n_2, ..., g_lg*n_lg
-    is able to generate G, where n_1, n_2, ..., n_lg can be any elements of N. If not, it checks if any
-    case of the form g_1*n_1, g_2*n_2, ..., g_lg*n_lg, n_lg+1 is able to generate G.
+        Compute ``GbyGk`` := `G/S[k]`
 
-    The algorithm guarantees that one of the above cases will generate G.
+        Compute ``GbyGkm1`` := `G/S[k-1]`
 
-    TESTS:
+        Compute ``Gkm1byGk`` := `S[k-1]/S[k]`
 
-    Test that the resultant list is able to generate the original group::
+        `g := lift(g,Gkm1byGk,Gkm1byGk,GbyGk)` . The lift function is discussed in the code.
 
-        sage: from sage.groups.libgap_mixin import minimum_generating_set
-        sage: p = libgap.eval("DirectProduct(AlternatingGroup(5),AlternatingGroup(5))")
-        sage: s = minimum_generating_set(p); s
-        [(1,2,3,4,5)(8,9,10), (3,4,5)(6,7,8)]
-        sage: set(p.AsList()) == set(libgap.GroupByGenerators(s).AsList())
-        True
+    return `g`
 
-    Test that elements of resultant list are GAP objects::
+    TESTS:
 
-        sage: from sage.groups.libgap_mixin import minimum_generating_set
-        sage: G = PermutationGroup([(1,2,3), (2,3), (4,5)])
-        sage: s = minimum_generating_set(G); s
-        [(2,3), (1,3,2)(4,5)]
-        sage: s[0].parent()
-        C library interface to GAP
+    1. `A_5^7`
+    ```
+    sage: def A_5_to_n(n):
+    ....:     A5 = AlternatingGroup(5).gap()
+    ....:     G = A5
+    ....:     for i in range(n-1):
+    ....:         G = G.DirectProduct(A5)
+    ....:     return G
+    ....: 
+    sage: G = A_5_to_n(7)
+    sage: g = minimum_generating_set(G)
+    sage: g
+    [(1,5,4,3,2)(8,9,10)(12,14,13)(17,19,18)(22,24,23)(27,29,28)(32,34,33),
+     (2,4,3)(6,8,10,7,9)(11,14,15,13,12)(16,19)(18,20)(21,25,24,22,23)(26,30,29,28,27)(31,35,34)]
+    sage: %timeit g = minimum_generating_set(G)
+    900 ms ± 90.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+    ```
+    2. `Z_3^10`
+    ```
+    sage: def Z_2_to_n(n):
+    ....:     Z_2 =  PermutationGroup([(1,2)]).gap()
+    ....:     G = Z_2
+    ....:     for i in range(1,n):
+    ....:         G = G.DirectProduct(Z_2)
+    ....:     return G
+    ....: 
+    sage: G = Z_2_to_n(10)
+    sage: g = minimum_generating_set(G)
+    sage: len(g)
+    10
+    sage: g
+    [(19,20),
+     (17,18),
+     (15,16),
+     (13,14),
+     (11,12),
+     (9,10),
+     (7,8),
+     (5,6),
+     (3,4),
+     (1,2)]
+    ```
     """
-    if not isinstance(G, GapElement):
-        try:
-            G = G.gap()
-        except (AttributeError, ValueError, TypeError):
-            raise NotImplementedError("only implemented for groups that can construct a gap group")
-
-    if not G.IsFinite().sage():
-        raise NotImplementedError("only implemented for finite groups")
-
-    def is_group_by_gens(group, gens):
-        return set(group.AsList()) == set(libgap.GroupByGenerators(gens).AsList())
-
-    group_elements = G.AsList()
-
-    if G.IsCyclic().sage():
-        for ele in group_elements:
-            if is_group_by_gens(G, [ele]):
-                return [ele]
-
-    if G.IsSimple().sage():
-        n = len(group_elements)
-        for i in range(n):
-            for j in range(i+1, n):
-                if is_group_by_gens(G, [group_elements[i], group_elements[j]]):
-                    return [group_elements[i], group_elements[j]]
-
-    N = G.MinimalNormalSubgroups()[0]
-    S = N.SmallGeneratingSet()
-
-    phi = G.NaturalHomomorphismByNormalSubgroup(N)
-    GbyN = phi.ImagesSource()
-    GbyN_mingenset = minimum_generating_set(GbyN)
-
-    g = [phi.PreImagesRepresentative(g) for g in GbyN_mingenset]
-    lg = len(g)
-
-    if N.IsAbelian().sage():
-        if is_group_by_gens(G, g):
-            return g
-
-        for i in range(lg):
-            for j in range(len(S)):
-                temp = g[i]
-                g[i] *= S[j]
-                if is_group_by_gens(G, g):
-                    return g
-                g[i] = temp
-
-        return g + [S[0]]
-
-    # A function to generate some combinations of the generators
-    # of the group according to the algorithm. Here it is considered that
-    # the first element of the group N is the identity element.
-    def gen_combinations(g, N, lg):
-        for iter in product(N, repeat=lg):
-            yield [g[i] * iter[lg-i-1] for i in range(lg)]
-
-    N_list = list(N.AsList())
-
-    for raw_gens in gen_combinations(g, N_list, lg):
-        if is_group_by_gens(G, raw_gens):
-            return raw_gens
-
-    for raw_gens in gen_combinations(g, N_list, lg):
-        for nl in N_list[1:]:
-            if is_group_by_gens(G, raw_gens+[nl]):
-                return raw_gens + [nl]
-
-    assert False, "The code should never reach here"
+    assert isinstance(G, GapElement)
+    if not G.IsFinite().sage(): raise NotImplementedError("only implemented for finite groups")
+    try:return list(libgap.MinimalGeneratingSet(G))
+    except:pass
+    def lift(G_by_Gim1_mingen_reps , Gim1_by_Gi , G_by_Gi , phi_G_by_Gi , phi_Gim1_by_Gi):
+        r"""
+        Note that G_k is the same as S[k] in the ``minimum_generating_set`` algorithm and cs[k] in its code. 
+
+        INPUT:
+
+            - ``G_by_Gim1_mingen_reps`` -- representative elements of the minimum generating set of `G/G_{i-1}`
+
+            - ``G_by_Gim1`` --  `G / G_{i-1}`  Quotient Group
+
+            - ``Gim1_by_Gi`` --  `G_{i-1} / G_{i}` Quotinet Group
+
+            - ``phi_G_by_Gi`` -- the homomorphism defining the cosets of `G_i` in `G`.
+
+            - ``phi_Gim1_by_Gi`` -- the homomorphism defining the cosets of `G_{i}` in `G_{i-1}`.
+
+        OUTPUT:
+
+            representative elements of the minimum generating set of `G / G_{i}`.
+
+        ALGORITHM:
+
+            The inputs:
+
+                `g = \{g_1,g_2,\dots g_l\}` is the set of representatives of the (supposed) minimum generating st of `G/G_{i-1}`, what we are calling ``G_by_Gim1_mingen_reps`` in the co
+
+                `\bold{n} =\{n_1,n_2\dots n_k\}` where `\{n_1 G_i,n_2G_i \dots n_kG_{i}\}` is any generating set of `G_{i-1}/G_i
+
+                `\bold{N} = \{N_1,N_2\dots N_m\}` where `G_{i-1}/G_i = \{N_1G_i,N_2G_2\dots N_m G_m\}` . 
+
+            We wish to find the representatives of minimum generating set of `G/G_i` , which can be done as follows:
+
+            if `G_{i-1}/G_i` is abelian :
+                
+                if `\braket{gG_i}= G/G_i` :
+
+                    return `g`
+
+            for `1 \le p \le l`  and `n_j \in \bold{n}` :
+                
+                `g^* = \{g_1,g_2\dots g_{p-1} ,g_p n_j,g_{p_1},\dots\}`
+
+                if `\braket{g^* G_i} = G/G_i` :
+                    
+                    return `g^*` 
+
+            else:
+
+                for any (not necessarily distinct) elements `N_{i_1},N_{i_2}\dots N_{i_t} \in \bold{N}` : 
+                    
+                    `g^* = \{g_1N_{i_1},g_{i_2}N_{i_3}\dots g_{i_t}N_t,g_{t+1}\dots g_l\}`
+
+                    if `\braket{g^*G_i}\; = G/G_i`:
+                        
+                        return `{g^*}`
+
+                for any (not necessarily distinct) elements `N_{i_1},N_{i_2}\dots N_{i_t} N_{i_{t+1}} \in \bold{N}` : 
+
+                    `g^* = \{g_1N_{i_1},g_{i_2}N_{i_3}\dots g_{i_t}N_t,g_{t+1}\dots g_l\}`
+
+                    if `\braket{g^*G_i}\; = G/G_i`:
+                        
+                        return `{g^*}`
+
+            By now, we must have exhausted our search.
+
+            """
+        def gen_combinations(g,N,l):
+            if l==0:
+                yield g
+                return
+            for gm in gen_combinations(g,N,l-1):
+                for n in N:
+                    old = gm[l-1]
+                    gm[l-1] = old * n
+                    yield gm
+                    gm[l-1] = old
+        l = len(G_by_Gim1_mingen_reps)
+        Gim1_by_Gi_L = list(Gim1_by_Gi.AsList())
+        Gim1_by_Gi_elem_reps = [phi_Gim1_by_Gi.PreImagesRepresentative(x) for x in Gim1_by_Gi_L]
+        Gim1_by_Gi_gen = list(libgap.SmallGeneratingSet(Gim1_by_Gi))
+        Gim1_by_Gi_gen_reps = [phi_Gim1_by_Gi.PreImagesRepresentative(x) for x in Gim1_by_Gi_gen]
+        if Gim1_by_Gi.IsAbelian().sage():
+            if (G_by_Gi == libgap.GroupByGenerators([phi_G_by_Gi.ImagesRepresentative(x) for x in G_by_Gim1_mingen_reps])): return G_by_Gim1_mingen_reps
+            for i in range(l):
+                for j in range(len(Gim1_by_Gi_gen_reps)):
+                    temp = G_by_Gim1_mingen_reps[i]
+                    G_by_Gim1_mingen_reps[i] = G_by_Gim1_mingen_reps[i]*Gim1_by_Gi_gen_reps[j]
+                    if (G_by_Gi == libgap.GroupByGenerators([phi_G_by_Gi.ImagesRepresentative(x) for x in G_by_Gim1_mingen_reps])): return G_by_Gim1_mingen_reps
+                    G_by_Gim1_mingen_reps[i] = temp
+            return G_by_Gim1_mingen_reps + [Gim1_by_Gi_gen_reps[0]]
+        for raw_gens in gen_combinations(G_by_Gim1_mingen_reps, Gim1_by_Gi_elem_reps, l):
+            if (G_by_Gi == libgap.GroupByGenerators([phi_G_by_Gi.ImagesRepresentative(x) for x in raw_gens])): return raw_gens
+        for raw_gens in gen_combinations(G_by_Gim1_mingen_reps+[Gim1_by_Gi_elem_reps[0]], Gim1_by_Gi_elem_reps, l+1):
+            if (G_by_Gi == libgap.GroupByGenerators([phi_G_by_Gi.ImagesRepresentative(x) for x in raw_gens])): return raw_gens
+    cs = G.ChiefSeries()
+    l = len(cs)-1
+    phi_GbyG1 = G.NaturalHomomorphismByNormalSubgroup(cs[1])
+    GbyG1 = phi_GbyG1.ImagesSource()
+    mingenset_k_reps = [phi_GbyG1.PreImagesRepresentative(x) for x in list(libgap.SmallGeneratingSet(GbyG1))] # k=1 initially
+    for k in range(2,l+1): 
+        mingenset_km1_reps = mingenset_k_reps
+        Gk,Gkm1 = cs[k], cs[k-1]
+        phi_GbyGk = G.NaturalHomomorphismByNormalSubgroup(Gk)
+        GbyGk = phi_GbyGk.ImagesSource()
+        phi_Gkm1byGk = Gkm1.NaturalHomomorphismByNormalSubgroup(Gk)
+        Gkm1byGk = phi_Gkm1byGk.ImagesSource()
+        mingenset_k_reps = lift(mingenset_km1_reps,Gkm1byGk,GbyGk,phi_GbyGk,phi_Gkm1byGk)
+    assert (G == libgap.GroupByGenerators(mingenset_k_reps))
+    return mingenset_k_reps