Implement `minimum_generating_set` function for group theory #37481

RuchitJagodara · 2024-02-26T16:02:44Z

This patch is about implementing a minimum generating set function for group theory in Sage. The function implemented here operates in polynomial time, which makes it more interesting. Previously, we only knew of the trivial method, which was exponential in time. However, based on research paper, we can implement a
polynomial time algorithm for the minimum generating set function, and that's what this PR is about.

fixes #37362

📝 Checklist

The title is concise, informative, and self-explanatory.
The description explains in detail what this PR is about.
I have linked a relevant issue or discussion.
I have created tests covering the changes.
I have updated the documentation accordingly.

⌛ Dependencies

NA

Although I have implemented the final working function but some changes are still pending like changing the variables names, and optimising the code to improve the performance.

I have added the documentation of the function, additionally, renamed some variables. And added a method to convert the final answer to sage. But it is failing for some cases. So need to fix those.

The method minimum_generating_set will be available for gap objects also, if we define it inside gapelement class but it might create confusion that whether that is a method of gap.

RuchitJagodara · 2024-02-26T16:09:26Z

Below are some plots showing that the given algorithm runs in polynomial time.

RuchitJagodara · 2024-03-04T13:39:57Z

@tscrim, can you please review this PR?

tscrim

I don't understand the gap_based argument. At the end, everything you are doing only works for groups implemented in GAP. So I think you need to handle the case when a group does not have a working _libgap_ method more cleanly (e.g., Permutations(5)). I also don't see the utility in returning GAP objects; I think it should always return elements of the corresponding Sage group. This would also simplify the code (this could also be done by the method as a sort of "post-processing", with the function returning GAP objects in case someone does find a use for it).

Also, check for PEP8 spacing.

src/sage/groups/libgap_mixin.py

github-actions · 2024-04-09T14:30:58Z

Documentation preview for this PR (built with commit 047a071; changes) is ready! 🎉
This preview will update shortly after each push to this PR.

tscrim · 2024-04-15T04:19:18Z

src/sage/categories/groups.py

@@ -451,6 +451,54 @@ def conjugacy_class(self, g):
            from sage.groups.conjugacy_classes import ConjugacyClass
            return ConjugacyClass(self, g)

+        def minimum_generating_set(self):
+            """
+            Return a list of the minimum generating set of this group.


Suggested change

Return a list of the minimum generating set of this group.

Return a list of a minimum generating set of this group.

Since it is not necessarily unique.

What does "a list of a set" mean? Perhaps instead like this?

Suggested change

Return a list of the minimum generating set of this group.

Return a minimum generating set of this group.

If you want to emphasize that it returns a list object and not a set object, I'd be explicit about that, e.g. "a min. gen. set, represent by a list of group elements" (though IMHO that's unnecessary)

tscrim · 2024-04-15T04:20:18Z

src/sage/groups/libgap_mixin.py

+
+    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`).


Please use a proper reference [Doe2023]_, which your temp author should be replaced accordingly.

tscrim · 2024-04-15T04:20:48Z

src/sage/groups/libgap_mixin.py

+    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.
+
+    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.
+
+    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.
+
+    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.


Please use latex formatting for all of this, e.g.

`g_1, g_2, \ldots, g_n`

tscrim · 2024-04-15T04:22:54Z

src/sage/groups/libgap_mixin.py

+        for iter in product(N, repeat=lg):
+            yield [g[i] * iter[lg-i-1] for i in range(lg)]


Suggested change

for iter in product(N, repeat=lg):

yield [g[i] * iter[lg-i-1] for i in range(lg)]

for it in product(N, repeat=lg):

yield [g[i] * it[lg-i-1] for i in range(lg)]

Let's not use Python builtin functions as variable names.

tscrim · 2024-04-15T04:25:01Z

src/sage/groups/libgap_mixin.py

+        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]]


Suggested change

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]]

from itertools import combinations

for a, b in combinations(group_elements, 2):

if is_group_by_gens(G, [a, b]):

return [a, b]

This should be a bit faster of a check. At the very least, it is a bit shorter code.

tscrim · 2024-04-15T04:27:27Z

src/sage/groups/libgap_mixin.py

+        raise NotImplementedError("only implemented for finite groups")
+
+    def is_group_by_gens(group, gens):
+        return set(group.AsList()) == set(libgap.GroupByGenerators(gens).AsList())


This seems awfully slow. At the very least, we should cache the set of elements in the group. It might also be good to check some easier to compute things first, such as the cardinalities, before checking all elements. Some timings should be done.

tscrim · 2024-04-15T04:31:55Z

src/sage/groups/libgap_mixin.py

+                if is_group_by_gens(G, [group_elements[i], group_elements[j]]):
+                    return [group_elements[i], group_elements[j]]
+
+    N = G.MinimalNormalSubgroups()[0]


@RuchitJagodara, you should follow @fingolfin's advice. You should also profile your code to see where time is being spent. Right now, GAP's implementation is apparently completely beating yours, so it should be the preferred one unless you have data suggesting otherwise.

…gramming approach * Update groups.py * Update groups.py * Update libgap_mixin.py * Update libgap_mixin.py * Update groups.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update src/sage/groups/libgap_mixin.py Co-authored-by: Ruchit Jagodara <ruchit.jagodara@iitgn.ac.in> * Update src/sage/groups/libgap_mixin.py Co-authored-by: Ruchit Jagodara <ruchit.jagodara@iitgn.ac.in> * Update libgap_mixin.py * Update groups.py Removed the Example. * Update groups.py * Update src/sage/groups/libgap_mixin.py Co-authored-by: Ruchit Jagodara <ruchit.jagodara@iitgn.ac.in> * Update src/sage/groups/libgap_mixin.py Co-authored-by: Ruchit Jagodara <ruchit.jagodara@iitgn.ac.in> * Update src/sage/groups/libgap_mixin.py Co-authored-by: Ruchit Jagodara <ruchit.jagodara@iitgn.ac.in> * Update libgap_mixin.py * Update libgap_mixin.py * Update src/sage/categories/groups.py Co-authored-by: Ruchit Jagodara <ruchit.jagodara@iitgn.ac.in> * Update libgap_mixin.py * Update libgap_mixin.py --------- Co-authored-by: Ruchit Jagodara <ruchit.jagodara@iitgn.ac.in>

…hanges

RuchitJagodara · 2024-05-05T11:35:30Z

@fingolfin, can you please review the PR now? I have updated the algorithm, which now uses the chief series approach. The changes have made the algorithm very fast now, so thank you for your advice, and I also apologise for the delay.

Also, I am very thankful to @pranav-joshi-iitgn, who helped me with this PR.

RuchitJagodara · 2024-05-05T11:37:46Z

As, @tscrim told we have used latex format for documenting the algorithm but it is now showing some kind of linting error and also failing the build documentation test, so can you please help us with this?

pranav-joshi-iitgn

There can be a bit less of LaTeX in the ALGORITHM section. Something like this maybe ? :

    ALGORITHM:

    First we cover the cases when we can use the ``MinimalGeneratingSet``
    method of GAP directly. This happens when `G` is either Simple,
    or Solvable, or Nilpotent. Then, if ``libgap.MinimalGeneratingSet``
    fails, we proceed assuming that `G` is not a simple group.
    So, we are guaranteed to find a chief series of length at least 2.

    `S := ChiefSeries(G) = [G,G_1,G_2 ... G_l]` where `G_l = \{ e \}`

    Let `g` be the set of representatives of the minimum generating set
    of `G/G_1`. This can be found easily (since `G/G_1` is simple group)
    as ``g = libgap.MinimalGeneratingSet(GbyG1)``

    for k = 2 to `l` , compute `G/G_k` , `G_{k-1}/G_k` and set
    `g := lift( g, (G_{k-1}/G_k) , (G/G_k) )`

    return `g`

    `lift` function details:

    It computes the minimum generating set (as representative elements) of
    a quotient group `G/G_i` in a chief series, given the
    minimum generating set (as representatives) of `G/G_{i-1}`, namely `g`
    (what we are calling ``G_by_Gim1_mingen_reps`` in the code).
    the factor group `G_{i-1}/G_i` and the quotient group `G/G_i` itself.
    The function does these steps:

    First, we compute some essential quantities:

    `n :=\{ n_1,n_2 ... n_k \}`
    where `\{ n_1 G_i,n_2 G_i ... n_k G_i \}` is any generating set of
    `G_{i-1}/G_i` , i.e. it's the representative elements of any prefferably
    small, but not necessarily minimal generating set of `G_{i-1}/G_i`

    `N := \{ N_1,N_2 ... N_m \}` where
    `G_{i-1}/G_i = \{N_1 G_i,N_2 G_2 ... N_m G_m \}`.
    This is simply a list of representative elements of `G_{i-1}/G_i`.

    We wish to find the representatives of a minimum generating set of `G/G_i`.
    Here, we have two cases to consider.

    First, if `G_{i-1}/G_i` is abelian :

    if `<gG_i> = G/G_i`, return `g`

    for `0 < p < s+1`  and `n_j` in `n`, we calculate
    `g^* := \{ g_1,g_2 ... g_{p-1} ,g_p n_j,g_{p_1}, ... \}`.
    If `<g^* G_i> = G/G_i` , return `g^*`

    Second, if `G_{i-1}` is not abelian:

    First, for all combinations of (not necessarily distinct) elements
    `N_{i_1},N_{i_2}... N_{i_t}` in `N`, compute
    `g^* = \{g_1N_{i_1},g_{i_2}N_{i_3}... g_{i_t}N_t,g_{t+1}... g_s\}`
    (This is done using the ``gen_combinations`` generator).
    If `\{x G_i | x \in g^* \}` generates `G/G_i`, return `g^*`

    Then, for all combinations of (not necessarily distinct) elements
    `N_{i_1},N_{i_2}... N_{i_t} N_{i_{t+1}}` in `N`, compute
    `g^* = \{g_1N_{i_1},g_{i_2}N_{i_3}... g_{i_t}N_t,g_{t+1}... g_s\}`
    (This is done using the ``gen_combinations`` generator).
    If `\{x G_i | x \in g^* \}` generates `G/G_i`, return `g^*`

    By now, we must have exhausted our search.

pranav-joshi-iitgn · 2024-05-06T13:35:52Z

src/sage/groups/libgap_mixin.py

@@ -968,175 +968,171 @@ def is_isomorphic(self, H):
        """
        return self.gap().IsomorphismGroups(H.gap()) != libgap.fail

-def minimum_generating_set(G: GapElement) -> list:
-    r"""


Probably not a good idea to make it a normal string, rather than a raw string considering all the LaTeX in the docstring. It leads to linting errors like these :

./sage/groups/libgap_mixin.py:983:39: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:983:64: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:983:67: W605 invalid escape sequence '\}' ./sage/groups/libgap_mixin.py:986:64: W291 trailing whitespace ./sage/groups/libgap_mixin.py:1002:12: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:1002:21: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1002:30: W605 invalid escape sequence '\}' ./sage/groups/libgap_mixin.py:1002:41: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:1002:58: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1002:72: W605 invalid escape sequence '\}' ./sage/groups/libgap_mixin.py:1006:13: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:1006:22: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1006:31: W605 invalid escape sequence '\}' ./sage/groups/libgap_mixin.py:1006:56: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:1006:71: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1006:84: W605 invalid escape sequence '\}' ./sage/groups/libgap_mixin.py:1016:12: W605 invalid escape sequence '\l' ./sage/groups/libgap_mixin.py:1016:18: W605 invalid escape sequence '\l' ./sage/groups/libgap_mixin.py:1016:35: W605 invalid escape sequence '\i' ./sage/groups/libgap_mixin.py:1016:57: W291 trailing whitespace ./sage/groups/libgap_mixin.py:1017:13: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:1017:23: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1017:54: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1017:59: W605 invalid escape sequence '\}' ./sage/groups/libgap_mixin.py:1022:21: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1022:35: W605 invalid escape sequence '\i' ./sage/groups/libgap_mixin.py:1023:12: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:1023:39: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1023:63: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1023:72: W605 invalid escape sequence '\}' ./sage/groups/libgap_mixin.py:1027:21: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1027:47: W605 invalid escape sequence '\i' ./sage/groups/libgap_mixin.py:1028:12: W605 invalid escape sequence '\{' ./sage/groups/libgap_mixin.py:1028:39: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1028:63: W605 invalid escape sequence '\d' ./sage/groups/libgap_mixin.py:1028:72: W605 invalid escape sequence '\}'

I have converted the docstring from normal string to raw string; thank you for your suggestion!

But still doctests are failing, any idea why ?

fingolfin

Note that I am not a member of the SageMath team, and normally don't do reviews here (nor do my reviews here carry any weight), but since you asked, here is some feedback. Overall I found the explanation of the algorithm difficult to follow (and gave up trying to do so) as there were too many phrases I found confusing and unclear. Once you clarified you abundant use of "representative objects" and fixed the "a" vs "the" issues it hopefully will be better.

fingolfin · 2024-05-06T19:44:36Z

src/sage/categories/groups.py

@@ -451,6 +451,54 @@ def conjugacy_class(self, g):
            from sage.groups.conjugacy_classes import ConjugacyClass
            return ConjugacyClass(self, g)

+        def minimum_generating_set(self):
+            """
+            Return a list of the minimum generating set of this group.


What does "a list of a set" mean? Perhaps instead like this?

Suggested change

Return a list of the minimum generating set of this group.

Return a minimum generating set of this group.

If you want to emphasize that it returns a list object and not a set object, I'd be explicit about that, e.g. "a min. gen. set, represent by a list of group elements" (though IMHO that's unnecessary)

fingolfin · 2024-05-06T19:45:05Z

src/sage/groups/group.pyx

@@ -266,6 +266,7 @@ cdef class Group(Parent):
        """
        raise NotImplementedError

+


Suggested change

fingolfin · 2024-05-06T19:47:36Z

src/sage/groups/libgap_mixin.py

+    the minimum generating set problem" by Bireswar Das and Dhara Thakkar (:doi:`10.48550/arXiv.2305.08405`).
+
+    When group ``G`` is a simple, solvable or nilpotent then we directly use
+    the MinimalGeneratingSet funtion from GAP which gives us the minimum generating set


Suggested change

the MinimalGeneratingSet funtion from GAP which gives us the minimum generating set

the MinimalGeneratingSet function from GAP which gives us a minimum generating set

fingolfin · 2024-05-06T19:48:17Z

src/sage/groups/libgap_mixin.py

+    of that group.
+
+    If the MinimalGeneratingSet function of GAP gives any error, then it is guaranteed
+    that the group ``G`` is not a simple group and it will have a cheif series of length 2.


Suggested change

that the group ``G`` is not a simple group and it will have a cheif series of length 2.

that the group ``G`` is not a simple group and it will have a chief series of length at least 2.

fingolfin · 2024-05-06T19:49:29Z

src/sage/groups/libgap_mixin.py

+
+    `S := ChiefSeries(G) = [G,G_1,G_2 \dots G_l]` where `G_l = \{e\}`
+
+    Let `g` be the set of representatives of the minimum generating set of `G/G_1`.


"the" versus "a" everywhere, I won't mark it all, please go through the text yourself looking for that

fingolfin · 2024-05-06T19:50:51Z

src/sage/groups/libgap_mixin.py

+    We follow the algorithm described in the research paper "Algorithms for
+    the minimum generating set problem" by Bireswar Das and Dhara Thakkar (:doi:`10.48550/arXiv.2305.08405`).
+
+    When group ``G`` is a simple, solvable or nilpotent then we directly use


Note that nilpotent implies solvable so listing it in this sentence is redundant.

Suggested change

When group ``G`` is a simple, solvable or nilpotent then we directly use

When the group ``G`` is simple or solvable then we directly use

fingolfin · 2024-05-06T19:52:53Z

src/sage/groups/libgap_mixin.py

+    First, we compute some essential quantities:
+
+    `{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 , i.e. it's the representative elements of any prefferably small, but not


Suggested change

`G_{i-1}/G_i , i.e. it's the representative elements of any prefferably small, but not

`G_{i-1}/G_i , i.e. it is the representative elements of any preferably small, but not

Just a typo fix and a style suggestion, but even with that this sentence reads weird to me, and I don't like the expression "representative elements" (I don't know what really is meant by it)

fingolfin · 2024-05-06T19:53:34Z

src/sage/groups/libgap_mixin.py

+    necessarily minimal generating set of `G_{i-1}/G_i`
+
+    `{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\}`.
+    This is simply a list of representative elements of `G_{i-1}/G_i`.


What are "representative elements" of a quotient G/N ??

fingolfin · 2024-05-06T19:54:20Z

src/sage/groups/libgap_mixin.py

+        sage: s = minimum_generating_set(G); s
+        [(2,3), (1,3,2)(4,5)]
+        sage: s[0].parent()
+        C library interface to GAP


Why does it say that here?

RuchitJagodara · 2024-05-06T20:47:21Z

Thank you for your feedback, I will try to make it better.

tscrim · 2024-05-06T22:55:36Z

Note that I am not a member of the SageMath team, and normally don't do reviews here (nor do my reviews here carry any weight), but since you asked, here is some feedback. Overall I found the explanation of the algorithm difficult to follow (and gave up trying to do so) as there were too many phrases I found confusing and unclear. Once you clarified you abundant use of "representative objects" and fixed the "a" vs "the" issues it hopefully will be better.

Thank you for taking the time to look at this all the same. I am not an expert in computational group theory, so it is good to have someone who understands what parts to look at and where complexity can arise. Additionally, since we have a long standing policy of "anyone can review", your review carries the same weight as one from me.

If I had to guess, "representative objects" means coset representatives.

@RuchitJagodara You should compile the doc (unfortunately our CI is currently broken, so it cannot be done through here like before and must be done locally) and look at that. There are lots of missing commas and ill-formatted portions from what I can see. Also, I strong advise people to avoid \dots; it can be wrong and it is always better to be specific (e.g., \ldots, \cdots).

* Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py

* Update groups.py * Update libgap_mixin.py

RuchitJagodara · 2024-05-16T12:43:00Z

@tscrim, can you please help me with the failing build and test check, I am not able to understand what is the exact problem here.

tscrim · 2024-05-16T15:48:36Z

@tscrim, can you please help me with the failing build and test check, I am not able to understand what is the exact problem here.

The CI testing is currently broken.

RuchitJagodara · 2024-05-16T15:51:40Z

Oh, right! Can you please review the PR and tell me if it needs any further modifications?

pranav-joshi-iitgn · 2024-05-17T09:02:40Z

For anyone interested, I have implemented the same algorithm in GAP, which I felt is a better place to put it.

RuchitJagodara · 2024-05-28T04:58:30Z

@pranav-joshi-iitgn have you opened a pr or contributed your gap code into gap, if yes then I think it would be better to close this pr and if not then I request @tscrim to review this pr.

pranav-joshi-iitgn · 2024-05-28T20:40:35Z

@pranav-joshi-iitgn have you opened a pr or contributed your gap code into gap, if yes then I think it would be better to close this pr and if not then I request @tscrim to review this pr.

The code is still in the process of being reviewed.

Besides, the version of GAP that sage uses needs to be updated for the method MinimalGeneratingSet to be usable for any finite group, not just solvable or simple ones.

RuchitJagodara added 19 commits February 3, 2024 01:38

Implemented minimum_generating_set function for permutation groups

237367e

Fixed a bug occuring when making the group variable

59d1fd5

Changed the location of the function and made some changes

040c901

Although I have implemented the final working function but some changes are still pending like changing the variables names, and optimising the code to improve the performance.

Added the documentation and improved the code

749c8e9

I have added the documentation of the function, additionally, renamed some variables. And added a method to convert the final answer to sage. But it is failing for some cases. So need to fix those.

Corrected some linting errors

ecdfb37

Added a minimal_generating_set method for checking the function

1ae4902

Fixed a bug occuring in gen_combinations function

9411062

Fixed a bug in the minimum_generating_set

7e9dfad

Changed the way of converting gap elements into sage elements

60255bb

Corrected some linting errors and added a test

264b6ec

Added few test cases and examples

d9140be

Handle the case when the given group is a GAP based group

563c516

Improved the performance of the algorithm

38d7c2b

Made is_groupbygenerators function private

f8b8cc5

Reduced the space that function was using

b572a82

Added more examples and tests to cover all scenarios

68374ba

Add reference to the research paper and convert return type to set

33a805b

Add this method to GapElement class

0669c57

Removed the function from GapElement

04c3dc2

The method minimum_generating_set will be available for gap objects also, if we define it inside gapelement class but it might create confusion that whether that is a method of gap.

RuchitJagodara changed the title ~~Implement minimum generating set for groups~~ Implement minimum_generating_set function for group theory Feb 26, 2024

A minor fix

c7f44cf

mkoeppe added the c: group theory label Feb 26, 2024

RuchitJagodara added 5 commits February 27, 2024 10:24

Fix linting errors

c575344

Fixed a linting error in group.pyx

53d7168

Fixed a error in examples of minimum generating set

b3ccd39

Fix an error with importing minimum_generating_set in example

532f935

Changed return type to list according to discussion we had in zulip

54c8f83

tscrim requested changes Mar 6, 2024

View reviewed changes

RuchitJagodara added 2 commits April 9, 2024 13:15

Try computing minimum generating set with MinimalGeneratingSet

cdc561a

A minor change in the code style

f374fb8

tscrim requested changes Apr 15, 2024

View reviewed changes

RuchitJagodara force-pushed the patch2 branch from 28c4dfe to f374fb8 Compare May 1, 2024 19:52

RuchitJagodara closed this May 1, 2024

RuchitJagodara reopened this May 1, 2024

RuchitJagodara marked this pull request as draft May 1, 2024 19:53

pranav-joshi-iitgn and others added 2 commits May 5, 2024 16:53

Finalize the method and function with some test cases and codestyle c…

db46f00

…hanges

pranav-joshi-iitgn reviewed May 6, 2024

View reviewed changes

Made the docstring a raw string so that latex can work

77d289f

fingolfin reviewed May 6, 2024

View reviewed changes

Fixed Algorithm Description (#4)

b051877

* Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py * Update libgap_mixin.py

pranav-joshi-iitgn mentioned this pull request May 12, 2024

minimum_generating_set function for non-solvable groups #37990

Closed

4 tasks

pranav-joshi-iitgn added 2 commits May 12, 2024 20:48

Fix wrong answer of an example

9ace33c

* Update groups.py * Update libgap_mixin.py

Fix the answer of an example

047a071

pranav-joshi-iitgn mentioned this pull request May 17, 2024

Another method for minimum generating set for finite groups gap-system/gap#5716

Open

enriqueartal mentioned this pull request May 24, 2024

Save and load finitely presented groups coming from libgap groups #37128

Open

5 tasks

vbraun force-pushed the develop branch from eba5e19 to e5f42fa Compare June 3, 2024 22:15

	Return a list of the minimum generating set of this group.
	Return a list of a minimum generating set of this group.

	Return a list of the minimum generating set of this group.
	Return a minimum generating set of this group.


		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`).

		for iter in product(N, repeat=lg):
		yield [g[i] * iter[lg-i-1] for i in range(lg)]

		@@ -266,6 +266,7 @@ cdef class Group(Parent):
		"""
		raise NotImplementedError

	the MinimalGeneratingSet funtion from GAP which gives us the minimum generating set
	the MinimalGeneratingSet function from GAP which gives us a minimum generating set

	that the group ``G`` is not a simple group and it will have a cheif series of length 2.
	that the group ``G`` is not a simple group and it will have a chief series of length at least 2.


		`S := ChiefSeries(G) = [G,G_1,G_2 \dots G_l]` where `G_l = \{e\}`

		Let `g` be the set of representatives of the minimum generating set of `G/G_1`.

	When group ``G`` is a simple, solvable or nilpotent then we directly use
	When the group ``G`` is simple or solvable then we directly use

	`G_{i-1}/G_i , i.e. it's the representative elements of any prefferably small, but not
	`G_{i-1}/G_i , i.e. it is the representative elements of any preferably small, but not

Implement minimum_generating_set function for group theory #37481

Are you sure you want to change the base?

Implement minimum_generating_set function for group theory #37481

Conversation

RuchitJagodara commented Feb 26, 2024 • edited

📝 Checklist

⌛ Dependencies

RuchitJagodara commented Feb 26, 2024

RuchitJagodara commented Mar 4, 2024

tscrim left a comment

Choose a reason for hiding this comment

github-actions bot commented Apr 9, 2024 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

RuchitJagodara commented May 5, 2024

RuchitJagodara commented May 5, 2024

pranav-joshi-iitgn left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fingolfin left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

RuchitJagodara commented May 6, 2024

tscrim commented May 6, 2024

RuchitJagodara commented May 16, 2024

tscrim commented May 16, 2024

RuchitJagodara commented May 16, 2024

pranav-joshi-iitgn commented May 17, 2024 • edited

RuchitJagodara commented May 28, 2024

pranav-joshi-iitgn commented May 28, 2024 • edited

Implement `minimum_generating_set` function for group theory #37481

Implement `minimum_generating_set` function for group theory #37481

RuchitJagodara commented Feb 26, 2024 •

edited

github-actions bot commented Apr 9, 2024 •

edited

pranav-joshi-iitgn commented May 17, 2024 •

edited

pranav-joshi-iitgn commented May 28, 2024 •

edited