Add files using upload-large-folder tool

pllava/lib/python3.10/site-packages/sympy/combinatorics/coset_table.py

@@ -0,0 +1,1255 @@
+from sympy.combinatorics.free_groups import free_group
+from sympy.printing.defaults import DefaultPrinting
+
+from itertools import chain, product
+from bisect import bisect_left
+
+
+###############################################################################
+#                           COSET TABLE                                       #
+###############################################################################
+
+class CosetTable(DefaultPrinting):
+    # coset_table: Mathematically a coset table
+    #               represented using a list of lists
+    # alpha: Mathematically a coset (precisely, a live coset)
+    #       represented by an integer between i with 1 <= i <= n
+    #       alpha in c
+    # x: Mathematically an element of "A" (set of generators and
+    #   their inverses), represented using "FpGroupElement"
+    # fp_grp: Finitely Presented Group with < X|R > as presentation.
+    # H: subgroup of fp_grp.
+    # NOTE: We start with H as being only a list of words in generators
+    #       of "fp_grp". Since `.subgroup` method has not been implemented.
+
+    r"""
+
+    Properties
+    ==========
+
+    [1] `0 \in \Omega` and `\tau(1) = \epsilon`
+    [2] `\alpha^x = \beta \Leftrightarrow \beta^{x^{-1}} = \alpha`
+    [3] If `\alpha^x = \beta`, then `H \tau(\alpha)x = H \tau(\beta)`
+    [4] `\forall \alpha \in \Omega, 1^{\tau(\alpha)} = \alpha`
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of Computational Group Theory"
+
+    .. [2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+           Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490.
+           "Implementation and Analysis of the Todd-Coxeter Algorithm"
+
+    """
+    # default limit for the number of cosets allowed in a
+    # coset enumeration.
+    coset_table_max_limit = 4096000
+    # limit for the current instance
+    coset_table_limit = None
+    # maximum size of deduction stack above or equal to
+    # which it is emptied
+    max_stack_size = 100
+
+    def __init__(self, fp_grp, subgroup, max_cosets=None):
+        if not max_cosets:
+            max_cosets = CosetTable.coset_table_max_limit
+        self.fp_group = fp_grp
+        self.subgroup = subgroup
+        self.coset_table_limit = max_cosets
+        # "p" is setup independent of Omega and n
+        self.p = [0]
+        # a list of the form `[gen_1, gen_1^{-1}, ... , gen_k, gen_k^{-1}]`
+        self.A = list(chain.from_iterable((gen, gen**-1) \
+                for gen in self.fp_group.generators))
+        #P[alpha, x] Only defined when alpha^x is defined.
+        self.P = [[None]*len(self.A)]
+        # the mathematical coset table which is a list of lists
+        self.table = [[None]*len(self.A)]
+        self.A_dict = {x: self.A.index(x) for x in self.A}
+        self.A_dict_inv = {}
+        for x, index in self.A_dict.items():
+            if index % 2 == 0:
+                self.A_dict_inv[x] = self.A_dict[x] + 1
+            else:
+                self.A_dict_inv[x] = self.A_dict[x] - 1
+        # used in the coset-table based method of coset enumeration. Each of
+        # the element is called a "deduction" which is the form (alpha, x) whenever
+        # a value is assigned to alpha^x during a definition or "deduction process"
+        self.deduction_stack = []
+        # Attributes for modified methods.
+        H = self.subgroup
+        self._grp = free_group(', ' .join(["a_%d" % i for i in range(len(H))]))[0]
+        self.P = [[None]*len(self.A)]
+        self.p_p = {}
+
+    @property
+    def omega(self):
+        """Set of live cosets. """
+        return [coset for coset in range(len(self.p)) if self.p[coset] == coset]
+
+    def copy(self):
+        """
+        Return a shallow copy of Coset Table instance ``self``.
+
+        """
+        self_copy = self.__class__(self.fp_group, self.subgroup)
+        self_copy.table = [list(perm_rep) for perm_rep in self.table]
+        self_copy.p = list(self.p)
+        self_copy.deduction_stack = list(self.deduction_stack)
+        return self_copy
+
+    def __str__(self):
+        return "Coset Table on %s with %s as subgroup generators" \
+                % (self.fp_group, self.subgroup)
+
+    __repr__ = __str__
+
+    @property
+    def n(self):
+        """The number `n` represents the length of the sublist containing the
+        live cosets.
+
+        """
+        if not self.table:
+            return 0
+        return max(self.omega) + 1
+
+    # Pg. 152 [1]
+    def is_complete(self):
+        r"""
+        The coset table is called complete if it has no undefined entries
+        on the live cosets; that is, `\alpha^x` is defined for all
+        `\alpha \in \Omega` and `x \in A`.
+
+        """
+        return not any(None in self.table[coset] for coset in self.omega)
+
+    # Pg. 153 [1]
+    def define(self, alpha, x, modified=False):
+        r"""
+        This routine is used in the relator-based strategy of Todd-Coxeter
+        algorithm if some `\alpha^x` is undefined. We check whether there is
+        space available for defining a new coset. If there is enough space
+        then we remedy this by adjoining a new coset `\beta` to `\Omega`
+        (i.e to set of live cosets) and put that equal to `\alpha^x`, then
+        make an assignment satisfying Property[1]. If there is not enough space
+        then we halt the Coset Table creation. The maximum amount of space that
+        can be used by Coset Table can be manipulated using the class variable
+        ``CosetTable.coset_table_max_limit``.
+
+        See Also
+        ========
+
+        define_c
+
+        """
+        A = self.A
+        table = self.table
+        len_table = len(table)
+        if len_table >= self.coset_table_limit:
+            # abort the further generation of cosets
+            raise ValueError("the coset enumeration has defined more than "
+                    "%s cosets. Try with a greater value max number of cosets "
+                    % self.coset_table_limit)
+        table.append([None]*len(A))
+        self.P.append([None]*len(self.A))
+        # beta is the new coset generated
+        beta = len_table
+        self.p.append(beta)
+        table[alpha][self.A_dict[x]] = beta
+        table[beta][self.A_dict_inv[x]] = alpha
+        # P[alpha][x] = epsilon, P[beta][x**-1] = epsilon
+        if modified:
+            self.P[alpha][self.A_dict[x]] = self._grp.identity
+            self.P[beta][self.A_dict_inv[x]] = self._grp.identity
+            self.p_p[beta] = self._grp.identity
+
+    def define_c(self, alpha, x):
+        r"""
+        A variation of ``define`` routine, described on Pg. 165 [1], used in
+        the coset table-based strategy of Todd-Coxeter algorithm. It differs
+        from ``define`` routine in that for each definition it also adds the
+        tuple `(\alpha, x)` to the deduction stack.
+
+        See Also
+        ========
+
+        define
+
+        """
+        A = self.A
+        table = self.table
+        len_table = len(table)
+        if len_table >= self.coset_table_limit:
+            # abort the further generation of cosets
+            raise ValueError("the coset enumeration has defined more than "
+                    "%s cosets. Try with a greater value max number of cosets "
+                    % self.coset_table_limit)
+        table.append([None]*len(A))
+        # beta is the new coset generated
+        beta = len_table
+        self.p.append(beta)
+        table[alpha][self.A_dict[x]] = beta
+        table[beta][self.A_dict_inv[x]] = alpha
+        # append to deduction stack
+        self.deduction_stack.append((alpha, x))
+
+    def scan_c(self, alpha, word):
+        """
+        A variation of ``scan`` routine, described on pg. 165 of [1], which
+        puts at tuple, whenever a deduction occurs, to deduction stack.
+
+        See Also
+        ========
+
+        scan, scan_check, scan_and_fill, scan_and_fill_c
+
+        """
+        # alpha is an integer representing a "coset"
+        # since scanning can be in two cases
+        # 1. for alpha=0 and w in Y (i.e generating set of H)
+        # 2. alpha in Omega (set of live cosets), w in R (relators)
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        f = alpha
+        i = 0
+        r = len(word)
+        b = alpha
+        j = r - 1
+        # list of union of generators and their inverses
+        while i <= j and table[f][A_dict[word[i]]] is not None:
+            f = table[f][A_dict[word[i]]]
+            i += 1
+        if i > j:
+            if f != b:
+                self.coincidence_c(f, b)
+            return
+        while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+            b = table[b][A_dict_inv[word[j]]]
+            j -= 1
+        if j < i:
+            # we have an incorrect completed scan with coincidence f ~ b
+            # run the "coincidence" routine
+            self.coincidence_c(f, b)
+        elif j == i:
+            # deduction process
+            table[f][A_dict[word[i]]] = b
+            table[b][A_dict_inv[word[i]]] = f
+            self.deduction_stack.append((f, word[i]))
+        # otherwise scan is incomplete and yields no information
+
+    # alpha, beta coincide, i.e. alpha, beta represent the pair of cosets where
+    # coincidence occurs
+    def coincidence_c(self, alpha, beta):
+        """
+        A variation of ``coincidence`` routine used in the coset-table based
+        method of coset enumeration. The only difference being on addition of
+        a new coset in coset table(i.e new coset introduction), then it is
+        appended to ``deduction_stack``.
+
+        See Also
+        ========
+
+        coincidence
+
+        """
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        # behaves as a queue
+        q = []
+        self.merge(alpha, beta, q)
+        while len(q) > 0:
+            gamma = q.pop(0)
+            for x in A_dict:
+                delta = table[gamma][A_dict[x]]
+                if delta is not None:
+                    table[delta][A_dict_inv[x]] = None
+                    # only line of difference from ``coincidence`` routine
+                    self.deduction_stack.append((delta, x**-1))
+                    mu = self.rep(gamma)
+                    nu = self.rep(delta)
+                    if table[mu][A_dict[x]] is not None:
+                        self.merge(nu, table[mu][A_dict[x]], q)
+                    elif table[nu][A_dict_inv[x]] is not None:
+                        self.merge(mu, table[nu][A_dict_inv[x]], q)
+                    else:
+                        table[mu][A_dict[x]] = nu
+                        table[nu][A_dict_inv[x]] = mu
+
+    def scan(self, alpha, word, y=None, fill=False, modified=False):
+        r"""
+        ``scan`` performs a scanning process on the input ``word``.
+        It first locates the largest prefix ``s`` of ``word`` for which
+        `\alpha^s` is defined (i.e is not ``None``), ``s`` may be empty. Let
+        ``word=sv``, let ``t`` be the longest suffix of ``v`` for which
+        `\alpha^{t^{-1}}` is defined, and let ``v=ut``. Then three
+        possibilities are there:
+
+        1. If ``t=v``, then we say that the scan completes, and if, in addition
+        `\alpha^s = \alpha^{t^{-1}}`, then we say that the scan completes
+        correctly.
+
+        2. It can also happen that scan does not complete, but `|u|=1`; that
+        is, the word ``u`` consists of a single generator `x \in A`. In that
+        case, if `\alpha^s = \beta` and `\alpha^{t^{-1}} = \gamma`, then we can
+        set `\beta^x = \gamma` and `\gamma^{x^{-1}} = \beta`. These assignments
+        are known as deductions and enable the scan to complete correctly.
+
+        3. See ``coicidence`` routine for explanation of third condition.
+
+        Notes
+        =====
+
+        The code for the procedure of scanning `\alpha \in \Omega`
+        under `w \in A*` is defined on pg. 155 [1]
+
+        See Also
+        ========
+
+        scan_c, scan_check, scan_and_fill, scan_and_fill_c
+
+        Scan and Fill
+        =============
+
+        Performed when the default argument fill=True.
+
+        Modified Scan
+        =============
+
+        Performed when the default argument modified=True
+
+        """
+        # alpha is an integer representing a "coset"
+        # since scanning can be in two cases
+        # 1. for alpha=0 and w in Y (i.e generating set of H)
+        # 2. alpha in Omega (set of live cosets), w in R (relators)
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        f = alpha
+        i = 0
+        r = len(word)
+        b = alpha
+        j = r - 1
+        b_p = y
+        if modified:
+            f_p = self._grp.identity
+        flag = 0
+        while fill or flag == 0:
+            flag = 1
+            while i <= j and table[f][A_dict[word[i]]] is not None:
+                if modified:
+                    f_p = f_p*self.P[f][A_dict[word[i]]]
+                f = table[f][A_dict[word[i]]]
+                i += 1
+            if i > j:
+                if f != b:
+                    if modified:
+                        self.modified_coincidence(f, b, f_p**-1*y)
+                    else:
+                        self.coincidence(f, b)
+                return
+            while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+                if modified:
+                    b_p = b_p*self.P[b][self.A_dict_inv[word[j]]]
+                b = table[b][A_dict_inv[word[j]]]
+                j -= 1
+            if j < i:
+                # we have an incorrect completed scan with coincidence f ~ b
+                # run the "coincidence" routine
+                if modified:
+                    self.modified_coincidence(f, b, f_p**-1*b_p)
+                else:
+                    self.coincidence(f, b)
+            elif j == i:
+                # deduction process
+                table[f][A_dict[word[i]]] = b
+                table[b][A_dict_inv[word[i]]] = f
+                if modified:
+                    self.P[f][self.A_dict[word[i]]] = f_p**-1*b_p
+                    self.P[b][self.A_dict_inv[word[i]]] = b_p**-1*f_p
+                return
+            elif fill:
+                self.define(f, word[i], modified=modified)
+            # otherwise scan is incomplete and yields no information
+
+    # used in the low-index subgroups algorithm
+    def scan_check(self, alpha, word):
+        r"""
+        Another version of ``scan`` routine, described on, it checks whether
+        `\alpha` scans correctly under `word`, it is a straightforward
+        modification of ``scan``. ``scan_check`` returns ``False`` (rather than
+        calling ``coincidence``) if the scan completes incorrectly; otherwise
+        it returns ``True``.
+
+        See Also
+        ========
+
+        scan, scan_c, scan_and_fill, scan_and_fill_c
+
+        """
+        # alpha is an integer representing a "coset"
+        # since scanning can be in two cases
+        # 1. for alpha=0 and w in Y (i.e generating set of H)
+        # 2. alpha in Omega (set of live cosets), w in R (relators)
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        f = alpha
+        i = 0
+        r = len(word)
+        b = alpha
+        j = r - 1
+        while i <= j and table[f][A_dict[word[i]]] is not None:
+            f = table[f][A_dict[word[i]]]
+            i += 1
+        if i > j:
+            return f == b
+        while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+            b = table[b][A_dict_inv[word[j]]]
+            j -= 1
+        if j < i:
+            # we have an incorrect completed scan with coincidence f ~ b
+            # return False, instead of calling coincidence routine
+            return False
+        elif j == i:
+            # deduction process
+            table[f][A_dict[word[i]]] = b
+            table[b][A_dict_inv[word[i]]] = f
+        return True
+
+    def merge(self, k, lamda, q, w=None, modified=False):
+        """
+        Merge two classes with representatives ``k`` and ``lamda``, described
+        on Pg. 157 [1] (for pseudocode), start by putting ``p[k] = lamda``.
+        It is more efficient to choose the new representative from the larger
+        of the two classes being merged, i.e larger among ``k`` and ``lamda``.
+        procedure ``merge`` performs the merging operation, adds the deleted
+        class representative to the queue ``q``.
+
+        Parameters
+        ==========
+
+        'k', 'lamda' being the two class representatives to be merged.
+
+        Notes
+        =====
+
+        Pg. 86-87 [1] contains a description of this method.
+
+        See Also
+        ========
+
+        coincidence, rep
+
+        """
+        p = self.p
+        rep = self.rep
+        phi = rep(k, modified=modified)
+        psi = rep(lamda, modified=modified)
+        if phi != psi:
+            mu = min(phi, psi)
+            v = max(phi, psi)
+            p[v] = mu
+            if modified:
+                if v == phi:
+                    self.p_p[phi] = self.p_p[k]**-1*w*self.p_p[lamda]
+                else:
+                    self.p_p[psi] = self.p_p[lamda]**-1*w**-1*self.p_p[k]
+            q.append(v)
+
+    def rep(self, k, modified=False):
+        r"""
+        Parameters
+        ==========
+
+        `k \in [0 \ldots n-1]`, as for ``self`` only array ``p`` is used
+
+        Returns
+        =======
+
+        Representative of the class containing ``k``.
+
+        Returns the representative of `\sim` class containing ``k``, it also
+        makes some modification to array ``p`` of ``self`` to ease further
+        computations, described on Pg. 157 [1].
+
+        The information on classes under `\sim` is stored in array `p` of
+        ``self`` argument, which will always satisfy the property:
+
+        `p[\alpha] \sim \alpha` and `p[\alpha]=\alpha \iff \alpha=rep(\alpha)`
+        `\forall \in [0 \ldots n-1]`.
+
+        So, for `\alpha \in [0 \ldots n-1]`, we find `rep(self, \alpha)` by
+        continually replacing `\alpha` by `p[\alpha]` until it becomes
+        constant (i.e satisfies `p[\alpha] = \alpha`):w
+
+        To increase the efficiency of later ``rep`` calculations, whenever we
+        find `rep(self, \alpha)=\beta`, we set
+        `p[\gamma] = \beta \forall \gamma \in p-chain` from `\alpha` to `\beta`
+
+        Notes
+        =====
+
+        ``rep`` routine is also described on Pg. 85-87 [1] in Atkinson's
+        algorithm, this results from the fact that ``coincidence`` routine
+        introduces functionality similar to that introduced by the
+        ``minimal_block`` routine on Pg. 85-87 [1].
+
+        See Also
+        ========
+
+        coincidence, merge
+
+        """
+        p = self.p
+        lamda = k
+        rho = p[lamda]
+        if modified:
+            s = p[:]
+        while rho != lamda:
+            if modified:
+                s[rho] = lamda
+            lamda = rho
+            rho = p[lamda]
+        if modified:
+            rho = s[lamda]
+            while rho != k:
+                mu = rho
+                rho = s[mu]
+                p[rho] = lamda
+                self.p_p[rho] = self.p_p[rho]*self.p_p[mu]
+        else:
+            mu = k
+            rho = p[mu]
+            while rho != lamda:
+                p[mu] = lamda
+                mu = rho
+                rho = p[mu]
+        return lamda
+
+    # alpha, beta coincide, i.e. alpha, beta represent the pair of cosets
+    # where coincidence occurs
+    def coincidence(self, alpha, beta, w=None, modified=False):
+        r"""
+        The third situation described in ``scan`` routine is handled by this
+        routine, described on Pg. 156-161 [1].
+
+        The unfortunate situation when the scan completes but not correctly,
+        then ``coincidence`` routine is run. i.e when for some `i` with
+        `1 \le i \le r+1`, we have `w=st` with `s = x_1 x_2 \dots x_{i-1}`,
+        `t = x_i x_{i+1} \dots x_r`, and `\beta = \alpha^s` and
+        `\gamma = \alpha^{t-1}` are defined but unequal. This means that
+        `\beta` and `\gamma` represent the same coset of `H` in `G`. Described
+        on Pg. 156 [1]. ``rep``
+
+        See Also
+        ========
+
+        scan
+
+        """
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        # behaves as a queue
+        q = []
+        if modified:
+            self.modified_merge(alpha, beta, w, q)
+        else:
+            self.merge(alpha, beta, q)
+        while len(q) > 0:
+            gamma = q.pop(0)
+            for x in A_dict:
+                delta = table[gamma][A_dict[x]]
+                if delta is not None:
+                    table[delta][A_dict_inv[x]] = None
+                    mu = self.rep(gamma, modified=modified)
+                    nu = self.rep(delta, modified=modified)
+                    if table[mu][A_dict[x]] is not None:
+                        if modified:
+                            v = self.p_p[delta]**-1*self.P[gamma][self.A_dict[x]]**-1
+                            v = v*self.p_p[gamma]*self.P[mu][self.A_dict[x]]
+                            self.modified_merge(nu, table[mu][self.A_dict[x]], v, q)
+                        else:
+                            self.merge(nu, table[mu][A_dict[x]], q)
+                    elif table[nu][A_dict_inv[x]] is not None:
+                        if modified:
+                            v = self.p_p[gamma]**-1*self.P[gamma][self.A_dict[x]]
+                            v = v*self.p_p[delta]*self.P[mu][self.A_dict_inv[x]]
+                            self.modified_merge(mu, table[nu][self.A_dict_inv[x]], v, q)
+                        else:
+                            self.merge(mu, table[nu][A_dict_inv[x]], q)
+                    else:
+                        table[mu][A_dict[x]] = nu
+                        table[nu][A_dict_inv[x]] = mu
+                        if modified:
+                            v = self.p_p[gamma]**-1*self.P[gamma][self.A_dict[x]]*self.p_p[delta]
+                            self.P[mu][self.A_dict[x]] = v
+                            self.P[nu][self.A_dict_inv[x]] = v**-1
+
+    # method used in the HLT strategy
+    def scan_and_fill(self, alpha, word):
+        """
+        A modified version of ``scan`` routine used in the relator-based
+        method of coset enumeration, described on pg. 162-163 [1], which
+        follows the idea that whenever the procedure is called and the scan
+        is incomplete then it makes new definitions to enable the scan to
+        complete; i.e it fills in the gaps in the scan of the relator or
+        subgroup generator.
+
+        """
+        self.scan(alpha, word, fill=True)
+
+    def scan_and_fill_c(self, alpha, word):
+        """
+        A modified version of ``scan`` routine, described on Pg. 165 second
+        para. [1], with modification similar to that of ``scan_anf_fill`` the
+        only difference being it calls the coincidence procedure used in the
+        coset-table based method i.e. the routine ``coincidence_c`` is used.
+
+        See Also
+        ========
+
+        scan, scan_and_fill
+
+        """
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        r = len(word)
+        f = alpha
+        i = 0
+        b = alpha
+        j = r - 1
+        # loop until it has filled the alpha row in the table.
+        while True:
+            # do the forward scanning
+            while i <= j and table[f][A_dict[word[i]]] is not None:
+                f = table[f][A_dict[word[i]]]
+                i += 1
+            if i > j:
+                if f != b:
+                    self.coincidence_c(f, b)
+                return
+            # forward scan was incomplete, scan backwards
+            while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+                b = table[b][A_dict_inv[word[j]]]
+                j -= 1
+            if j < i:
+                self.coincidence_c(f, b)
+            elif j == i:
+                table[f][A_dict[word[i]]] = b
+                table[b][A_dict_inv[word[i]]] = f
+                self.deduction_stack.append((f, word[i]))
+            else:
+                self.define_c(f, word[i])
+
+    # method used in the HLT strategy
+    def look_ahead(self):
+        """
+        When combined with the HLT method this is known as HLT+Lookahead
+        method of coset enumeration, described on pg. 164 [1]. Whenever
+        ``define`` aborts due to lack of space available this procedure is
+        executed. This routine helps in recovering space resulting from
+        "coincidence" of cosets.
+
+        """
+        R = self.fp_group.relators
+        p = self.p
+        # complete scan all relators under all cosets(obviously live)
+        # without making new definitions
+        for beta in self.omega:
+            for w in R:
+                self.scan(beta, w)
+                if p[beta] < beta:
+                    break
+
+    # Pg. 166
+    def process_deductions(self, R_c_x, R_c_x_inv):
+        """
+        Processes the deductions that have been pushed onto ``deduction_stack``,
+        described on Pg. 166 [1] and is used in coset-table based enumeration.
+
+        See Also
+        ========
+
+        deduction_stack
+
+        """
+        p = self.p
+        table = self.table
+        while len(self.deduction_stack) > 0:
+            if len(self.deduction_stack) >= CosetTable.max_stack_size:
+                self.look_ahead()
+                del self.deduction_stack[:]
+                continue
+            else:
+                alpha, x = self.deduction_stack.pop()
+                if p[alpha] == alpha:
+                    for w in R_c_x:
+                        self.scan_c(alpha, w)
+                        if p[alpha] < alpha:
+                            break
+            beta = table[alpha][self.A_dict[x]]
+            if beta is not None and p[beta] == beta:
+                for w in R_c_x_inv:
+                    self.scan_c(beta, w)
+                    if p[beta] < beta:
+                        break
+
+    def process_deductions_check(self, R_c_x, R_c_x_inv):
+        """
+        A variation of ``process_deductions``, this calls ``scan_check``
+        wherever ``process_deductions`` calls ``scan``, described on Pg. [1].
+
+        See Also
+        ========
+
+        process_deductions
+
+        """
+        table = self.table
+        while len(self.deduction_stack) > 0:
+            alpha, x = self.deduction_stack.pop()
+            for w in R_c_x:
+                if not self.scan_check(alpha, w):
+                    return False
+            beta = table[alpha][self.A_dict[x]]
+            if beta is not None:
+                for w in R_c_x_inv:
+                    if not self.scan_check(beta, w):
+                        return False
+        return True
+
+    def switch(self, beta, gamma):
+        r"""Switch the elements `\beta, \gamma \in \Omega` of ``self``, used
+        by the ``standardize`` procedure, described on Pg. 167 [1].
+
+        See Also
+        ========
+
+        standardize
+
+        """
+        A = self.A
+        A_dict = self.A_dict
+        table = self.table
+        for x in A:
+            z = table[gamma][A_dict[x]]
+            table[gamma][A_dict[x]] = table[beta][A_dict[x]]
+            table[beta][A_dict[x]] = z
+            for alpha in range(len(self.p)):
+                if self.p[alpha] == alpha:
+                    if table[alpha][A_dict[x]] == beta:
+                        table[alpha][A_dict[x]] = gamma
+                    elif table[alpha][A_dict[x]] == gamma:
+                        table[alpha][A_dict[x]] = beta
+
+    def standardize(self):
+        r"""
+        A coset table is standardized if when running through the cosets and
+        within each coset through the generator images (ignoring generator
+        inverses), the cosets appear in order of the integers
+        `0, 1, \dots, n`. "Standardize" reorders the elements of `\Omega`
+        such that, if we scan the coset table first by elements of `\Omega`
+        and then by elements of A, then the cosets occur in ascending order.
+        ``standardize()`` is used at the end of an enumeration to permute the
+        cosets so that they occur in some sort of standard order.
+
+        Notes
+        =====
+
+        procedure is described on pg. 167-168 [1], it also makes use of the
+        ``switch`` routine to replace by smaller integer value.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r
+        >>> F, x, y = free_group("x, y")
+
+        # Example 5.3 from [1]
+        >>> f = FpGroup(F, [x**2*y**2, x**3*y**5])
+        >>> C = coset_enumeration_r(f, [])
+        >>> C.compress()
+        >>> C.table
+        [[1, 3, 1, 3], [2, 0, 2, 0], [3, 1, 3, 1], [0, 2, 0, 2]]
+        >>> C.standardize()
+        >>> C.table
+        [[1, 2, 1, 2], [3, 0, 3, 0], [0, 3, 0, 3], [2, 1, 2, 1]]
+
+        """
+        A = self.A
+        A_dict = self.A_dict
+        gamma = 1
+        for alpha, x in product(range(self.n), A):
+            beta = self.table[alpha][A_dict[x]]
+            if beta >= gamma:
+                if beta > gamma:
+                    self.switch(gamma, beta)
+                gamma += 1
+                if gamma == self.n:
+                    return
+
+    # Compression of a Coset Table
+    def compress(self):
+        """Removes the non-live cosets from the coset table, described on
+        pg. 167 [1].
+
+        """
+        gamma = -1
+        A = self.A
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        chi = tuple([i for i in range(len(self.p)) if self.p[i] != i])
+        for alpha in self.omega:
+            gamma += 1
+            if gamma != alpha:
+                # replace alpha by gamma in coset table
+                for x in A:
+                    beta = table[alpha][A_dict[x]]
+                    table[gamma][A_dict[x]] = beta
+                    table[beta][A_dict_inv[x]] == gamma
+        # all the cosets in the table are live cosets
+        self.p = list(range(gamma + 1))
+        # delete the useless columns
+        del table[len(self.p):]
+        # re-define values
+        for row in table:
+            for j in range(len(self.A)):
+                row[j] -= bisect_left(chi, row[j])
+
+    def conjugates(self, R):
+        R_c = list(chain.from_iterable((rel.cyclic_conjugates(), \
+                (rel**-1).cyclic_conjugates()) for rel in R))
+        R_set = set()
+        for conjugate in R_c:
+            R_set = R_set.union(conjugate)
+        R_c_list = []
+        for x in self.A:
+            r = {word for word in R_set if word[0] == x}
+            R_c_list.append(r)
+            R_set.difference_update(r)
+        return R_c_list
+
+    def coset_representative(self, coset):
+        '''
+        Compute the coset representative of a given coset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r
+        >>> F, x, y = free_group("x, y")
+        >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+        >>> C = coset_enumeration_r(f, [x])
+        >>> C.compress()
+        >>> C.table
+        [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]]
+        >>> C.coset_representative(0)
+        <identity>
+        >>> C.coset_representative(1)
+        y
+        >>> C.coset_representative(2)
+        y**-1
+
+        '''
+        for x in self.A:
+            gamma = self.table[coset][self.A_dict[x]]
+            if coset == 0:
+                return self.fp_group.identity
+            if gamma < coset:
+                return self.coset_representative(gamma)*x**-1
+
+    ##############################
+    #      Modified Methods      #
+    ##############################
+
+    def modified_define(self, alpha, x):
+        r"""
+        Define a function p_p from from [1..n] to A* as
+        an additional component of the modified coset table.
+
+        Parameters
+        ==========
+
+        \alpha \in \Omega
+        x \in A*
+
+        See Also
+        ========
+
+        define
+
+        """
+        self.define(alpha, x, modified=True)
+
+    def modified_scan(self, alpha, w, y, fill=False):
+        r"""
+        Parameters
+        ==========
+        \alpha \in \Omega
+        w \in A*
+        y \in (YUY^-1)
+        fill -- `modified_scan_and_fill` when set to True.
+
+        See Also
+        ========
+
+        scan
+        """
+        self.scan(alpha, w, y=y, fill=fill, modified=True)
+
+    def modified_scan_and_fill(self, alpha, w, y):
+        self.modified_scan(alpha, w, y, fill=True)
+
+    def modified_merge(self, k, lamda, w, q):
+        r"""
+        Parameters
+        ==========
+
+        'k', 'lamda' -- the two class representatives to be merged.
+        q -- queue of length l of elements to be deleted from `\Omega` *.
+        w -- Word in (YUY^-1)
+
+        See Also
+        ========
+
+        merge
+        """
+        self.merge(k, lamda, q, w=w, modified=True)
+
+    def modified_rep(self, k):
+        r"""
+        Parameters
+        ==========
+
+        `k \in [0 \ldots n-1]`
+
+        See Also
+        ========
+
+        rep
+        """
+        self.rep(k, modified=True)
+
+    def modified_coincidence(self, alpha, beta, w):
+        r"""
+        Parameters
+        ==========
+
+        A coincident pair `\alpha, \beta \in \Omega, w \in Y \cup Y^{-1}`
+
+        See Also
+        ========
+
+        coincidence
+
+        """
+        self.coincidence(alpha, beta, w=w, modified=True)
+
+###############################################################################
+#                           COSET ENUMERATION                                 #
+###############################################################################
+
+# relator-based method
+def coset_enumeration_r(fp_grp, Y, max_cosets=None, draft=None,
+                                    incomplete=False, modified=False):
+    """
+    This is easier of the two implemented methods of coset enumeration.
+    and is often called the HLT method, after Hazelgrove, Leech, Trotter
+    The idea is that we make use of ``scan_and_fill`` makes new definitions
+    whenever the scan is incomplete to enable the scan to complete; this way
+    we fill in the gaps in the scan of the relator or subgroup generator,
+    that's why the name relator-based method.
+
+    An instance of `CosetTable` for `fp_grp` can be passed as the keyword
+    argument `draft` in which case the coset enumeration will start with
+    that instance and attempt to complete it.
+
+    When `incomplete` is `True` and the function is unable to complete for
+    some reason, the partially complete table will be returned.
+
+    # TODO: complete the docstring
+
+    See Also
+    ========
+
+    scan_and_fill,
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r
+    >>> F, x, y = free_group("x, y")
+
+    # Example 5.1 from [1]
+    >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    >>> C = coset_enumeration_r(f, [x])
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [0, 0, 1, 2]
+    [1, 1, 2, 0]
+    [2, 2, 0, 1]
+    >>> C.p
+    [0, 1, 2, 1, 1]
+
+    # Example from exercises Q2 [1]
+    >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    >>> C = coset_enumeration_r(f, [])
+    >>> C.compress(); C.standardize()
+    >>> C.table
+    [[1, 2, 3, 4],
+    [5, 0, 6, 7],
+    [0, 5, 7, 6],
+    [7, 6, 5, 0],
+    [6, 7, 0, 5],
+    [2, 1, 4, 3],
+    [3, 4, 2, 1],
+    [4, 3, 1, 2]]
+
+    # Example 5.2
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**3])
+    >>> Y = [x*y]
+    >>> C = coset_enumeration_r(f, Y)
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [1, 1, 2, 1]
+    [0, 0, 0, 2]
+    [3, 3, 1, 0]
+    [2, 2, 3, 3]
+
+    # Example 5.3
+    >>> f = FpGroup(F, [x**2*y**2, x**3*y**5])
+    >>> Y = []
+    >>> C = coset_enumeration_r(f, Y)
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [1, 3, 1, 3]
+    [2, 0, 2, 0]
+    [3, 1, 3, 1]
+    [0, 2, 0, 2]
+
+    # Example 5.4
+    >>> F, a, b, c, d, e = free_group("a, b, c, d, e")
+    >>> f = FpGroup(F, [a*b*c**-1, b*c*d**-1, c*d*e**-1, d*e*a**-1, e*a*b**-1])
+    >>> Y = [a]
+    >>> C = coset_enumeration_r(f, Y)
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+    # example of "compress" method
+    >>> C.compress()
+    >>> C.table
+    [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
+
+    # Exercises Pg. 161, Q2.
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    >>> Y = []
+    >>> C = coset_enumeration_r(f, Y)
+    >>> C.compress()
+    >>> C.standardize()
+    >>> C.table
+    [[1, 2, 3, 4],
+    [5, 0, 6, 7],
+    [0, 5, 7, 6],
+    [7, 6, 5, 0],
+    [6, 7, 0, 5],
+    [2, 1, 4, 3],
+    [3, 4, 2, 1],
+    [4, 3, 1, 2]]
+
+    # John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+    # Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490
+    # from 1973chwd.pdf
+    # Table 1. Ex. 1
+    >>> F, r, s, t = free_group("r, s, t")
+    >>> E1 = FpGroup(F, [t**-1*r*t*r**-2, r**-1*s*r*s**-2, s**-1*t*s*t**-2])
+    >>> C = coset_enumeration_r(E1, [r])
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [0, 0, 0, 0, 0, 0]
+
+    Ex. 2
+    >>> F, a, b = free_group("a, b")
+    >>> Cox = FpGroup(F, [a**6, b**6, (a*b)**2, (a**2*b**2)**2, (a**3*b**3)**5])
+    >>> C = coset_enumeration_r(Cox, [a])
+    >>> index = 0
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         index += 1
+    >>> index
+    500
+
+    # Ex. 3
+    >>> F, a, b = free_group("a, b")
+    >>> B_2_4 = FpGroup(F, [a**4, b**4, (a*b)**4, (a**-1*b)**4, (a**2*b)**4, \
+            (a*b**2)**4, (a**2*b**2)**4, (a**-1*b*a*b)**4, (a*b**-1*a*b)**4])
+    >>> C = coset_enumeration_r(B_2_4, [a])
+    >>> index = 0
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         index += 1
+    >>> index
+    1024
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of computational group theory"
+
+    """
+    # 1. Initialize a coset table C for < X|R >
+    C = CosetTable(fp_grp, Y, max_cosets=max_cosets)
+    # Define coset table methods.
+    if modified:
+        _scan_and_fill = C.modified_scan_and_fill
+        _define = C.modified_define
+    else:
+        _scan_and_fill = C.scan_and_fill
+        _define = C.define
+    if draft:
+        C.table = draft.table[:]
+        C.p = draft.p[:]
+    R = fp_grp.relators
+    A_dict = C.A_dict
+    p = C.p
+    for i in range(len(Y)):
+        if modified:
+            _scan_and_fill(0, Y[i], C._grp.generators[i])
+        else:
+            _scan_and_fill(0, Y[i])
+    alpha = 0
+    while alpha < C.n:
+        if p[alpha] == alpha:
+            try:
+                for w in R:
+                    if modified:
+                        _scan_and_fill(alpha, w, C._grp.identity)
+                    else:
+                        _scan_and_fill(alpha, w)
+                    # if alpha was eliminated during the scan then break
+                    if p[alpha] < alpha:
+                        break
+                if p[alpha] == alpha:
+                    for x in A_dict:
+                        if C.table[alpha][A_dict[x]] is None:
+                            _define(alpha, x)
+            except ValueError as e:
+                if incomplete:
+                    return C
+                raise e
+        alpha += 1
+    return C
+
+def modified_coset_enumeration_r(fp_grp, Y, max_cosets=None, draft=None,
+                                    incomplete=False):
+    r"""
+    Introduce a new set of symbols y \in Y that correspond to the
+    generators of the subgroup. Store the elements of Y as a
+    word P[\alpha, x] and compute the coset table similar to that of
+    the regular coset enumeration methods.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup
+    >>> from sympy.combinatorics.coset_table import modified_coset_enumeration_r
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    >>> C = modified_coset_enumeration_r(f, [x])
+    >>> C.table
+    [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1], [None, 1, None, None], [1, 3, None, None]]
+
+    See Also
+    ========
+
+    coset_enumertation_r
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.,
+           "Handbook of Computational Group Theory",
+           Section 5.3.2
+    """
+    return coset_enumeration_r(fp_grp, Y, max_cosets=max_cosets, draft=draft,
+                             incomplete=incomplete, modified=True)
+
+# Pg. 166
+# coset-table based method
+def coset_enumeration_c(fp_grp, Y, max_cosets=None, draft=None,
+                                                incomplete=False):
+    """
+    >>> from sympy.combinatorics.free_groups import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_c
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    >>> C = coset_enumeration_c(f, [x])
+    >>> C.table
+    [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]]
+
+    """
+    # Initialize a coset table C for < X|R >
+    X = fp_grp.generators
+    R = fp_grp.relators
+    C = CosetTable(fp_grp, Y, max_cosets=max_cosets)
+    if draft:
+        C.table = draft.table[:]
+        C.p = draft.p[:]
+        C.deduction_stack = draft.deduction_stack
+        for alpha, x in product(range(len(C.table)), X):
+            if C.table[alpha][C.A_dict[x]] is not None:
+                C.deduction_stack.append((alpha, x))
+    A = C.A
+    # replace all the elements by cyclic reductions
+    R_cyc_red = [rel.identity_cyclic_reduction() for rel in R]
+    R_c = list(chain.from_iterable((rel.cyclic_conjugates(), (rel**-1).cyclic_conjugates()) \
+            for rel in R_cyc_red))
+    R_set = set()
+    for conjugate in R_c:
+        R_set = R_set.union(conjugate)
+    # a list of subsets of R_c whose words start with "x".
+    R_c_list = []
+    for x in C.A:
+        r = {word for word in R_set if word[0] == x}
+        R_c_list.append(r)
+        R_set.difference_update(r)
+    for w in Y:
+        C.scan_and_fill_c(0, w)
+    for x in A:
+        C.process_deductions(R_c_list[C.A_dict[x]], R_c_list[C.A_dict_inv[x]])
+    alpha = 0
+    while alpha < len(C.table):
+        if C.p[alpha] == alpha:
+            try:
+                for x in C.A:
+                    if C.p[alpha] != alpha:
+                        break
+                    if C.table[alpha][C.A_dict[x]] is None:
+                        C.define_c(alpha, x)
+                        C.process_deductions(R_c_list[C.A_dict[x]], R_c_list[C.A_dict_inv[x]])
+            except ValueError as e:
+                if incomplete:
+                    return C
+                raise e
+        alpha += 1
+    return C

pllava/lib/python3.10/site-packages/sympy/combinatorics/generators.py

@@ -0,0 +1,302 @@
+from sympy.combinatorics.permutations import Permutation
+from sympy.core.symbol import symbols
+from sympy.matrices import Matrix
+from sympy.utilities.iterables import variations, rotate_left
+
+
+def symmetric(n):
+    """
+    Generates the symmetric group of order n, Sn.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import symmetric
+    >>> list(symmetric(3))
+    [(2), (1 2), (2)(0 1), (0 1 2), (0 2 1), (0 2)]
+    """
+    for perm in variations(range(n), n):
+        yield Permutation(perm)
+
+
+def cyclic(n):
+    """
+    Generates the cyclic group of order n, Cn.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import cyclic
+    >>> list(cyclic(5))
+    [(4), (0 1 2 3 4), (0 2 4 1 3),
+     (0 3 1 4 2), (0 4 3 2 1)]
+
+    See Also
+    ========
+
+    dihedral
+    """
+    gen = list(range(n))
+    for i in range(n):
+        yield Permutation(gen)
+        gen = rotate_left(gen, 1)
+
+
+def alternating(n):
+    """
+    Generates the alternating group of order n, An.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import alternating
+    >>> list(alternating(3))
+    [(2), (0 1 2), (0 2 1)]
+    """
+    for perm in variations(range(n), n):
+        p = Permutation(perm)
+        if p.is_even:
+            yield p
+
+
+def dihedral(n):
+    """
+    Generates the dihedral group of order 2n, Dn.
+
+    The result is given as a subgroup of Sn, except for the special cases n=1
+    (the group S2) and n=2 (the Klein 4-group) where that's not possible
+    and embeddings in S2 and S4 respectively are given.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import dihedral
+    >>> list(dihedral(3))
+    [(2), (0 2), (0 1 2), (1 2), (0 2 1), (2)(0 1)]
+
+    See Also
+    ========
+
+    cyclic
+    """
+    if n == 1:
+        yield Permutation([0, 1])
+        yield Permutation([1, 0])
+    elif n == 2:
+        yield Permutation([0, 1, 2, 3])
+        yield Permutation([1, 0, 3, 2])
+        yield Permutation([2, 3, 0, 1])
+        yield Permutation([3, 2, 1, 0])
+    else:
+        gen = list(range(n))
+        for i in range(n):
+            yield Permutation(gen)
+            yield Permutation(gen[::-1])
+            gen = rotate_left(gen, 1)
+
+
+def rubik_cube_generators():
+    """Return the permutations of the 3x3 Rubik's cube, see
+    https://www.gap-system.org/Doc/Examples/rubik.html
+    """
+    a = [
+        [(1, 3, 8, 6), (2, 5, 7, 4), (9, 33, 25, 17), (10, 34, 26, 18),
+         (11, 35, 27, 19)],
+        [(9, 11, 16, 14), (10, 13, 15, 12), (1, 17, 41, 40), (4, 20, 44, 37),
+         (6, 22, 46, 35)],
+        [(17, 19, 24, 22), (18, 21, 23, 20), (6, 25, 43, 16), (7, 28, 42, 13),
+         (8, 30, 41, 11)],
+        [(25, 27, 32, 30), (26, 29, 31, 28), (3, 38, 43, 19), (5, 36, 45, 21),
+         (8, 33, 48, 24)],
+        [(33, 35, 40, 38), (34, 37, 39, 36), (3, 9, 46, 32), (2, 12, 47, 29),
+         (1, 14, 48, 27)],
+        [(41, 43, 48, 46), (42, 45, 47, 44), (14, 22, 30, 38),
+         (15, 23, 31, 39), (16, 24, 32, 40)]
+    ]
+    return [Permutation([[i - 1 for i in xi] for xi in x], size=48) for x in a]
+
+
+def rubik(n):
+    """Return permutations for an nxn Rubik's cube.
+
+    Permutations returned are for rotation of each of the slice
+    from the face up to the last face for each of the 3 sides (in this order):
+    front, right and bottom. Hence, the first n - 1 permutations are for the
+    slices from the front.
+    """
+
+    if n < 2:
+        raise ValueError('dimension of cube must be > 1')
+
+    # 1-based reference to rows and columns in Matrix
+    def getr(f, i):
+        return faces[f].col(n - i)
+
+    def getl(f, i):
+        return faces[f].col(i - 1)
+
+    def getu(f, i):
+        return faces[f].row(i - 1)
+
+    def getd(f, i):
+        return faces[f].row(n - i)
+
+    def setr(f, i, s):
+        faces[f][:, n - i] = Matrix(n, 1, s)
+
+    def setl(f, i, s):
+        faces[f][:, i - 1] = Matrix(n, 1, s)
+
+    def setu(f, i, s):
+        faces[f][i - 1, :] = Matrix(1, n, s)
+
+    def setd(f, i, s):
+        faces[f][n - i, :] = Matrix(1, n, s)
+
+    # motion of a single face
+    def cw(F, r=1):
+        for _ in range(r):
+            face = faces[F]
+            rv = []
+            for c in range(n):
+                for r in range(n - 1, -1, -1):
+                    rv.append(face[r, c])
+            faces[F] = Matrix(n, n, rv)
+
+    def ccw(F):
+        cw(F, 3)
+
+    # motion of plane i from the F side;
+    # fcw(0) moves the F face, fcw(1) moves the plane
+    # just behind the front face, etc...
+    def fcw(i, r=1):
+        for _ in range(r):
+            if i == 0:
+                cw(F)
+            i += 1
+            temp = getr(L, i)
+            setr(L, i, list(getu(D, i)))
+            setu(D, i, list(reversed(getl(R, i))))
+            setl(R, i, list(getd(U, i)))
+            setd(U, i, list(reversed(temp)))
+            i -= 1
+
+    def fccw(i):
+        fcw(i, 3)
+
+    # motion of the entire cube from the F side
+    def FCW(r=1):
+        for _ in range(r):
+            cw(F)
+            ccw(B)
+            cw(U)
+            t = faces[U]
+            cw(L)
+            faces[U] = faces[L]
+            cw(D)
+            faces[L] = faces[D]
+            cw(R)
+            faces[D] = faces[R]
+            faces[R] = t
+
+    def FCCW():
+        FCW(3)
+
+    # motion of the entire cube from the U side
+    def UCW(r=1):
+        for _ in range(r):
+            cw(U)
+            ccw(D)
+            t = faces[F]
+            faces[F] = faces[R]
+            faces[R] = faces[B]
+            faces[B] = faces[L]
+            faces[L] = t
+
+    def UCCW():
+        UCW(3)
+
+    # defining the permutations for the cube
+
+    U, F, R, B, L, D = names = symbols('U, F, R, B, L, D')
+
+    # the faces are represented by nxn matrices
+    faces = {}
+    count = 0
+    for fi in range(6):
+        f = []
+        for a in range(n**2):
+            f.append(count)
+            count += 1
+        faces[names[fi]] = Matrix(n, n, f)
+
+    # this will either return the value of the current permutation
+    # (show != 1) or else append the permutation to the group, g
+    def perm(show=0):
+        # add perm to the list of perms
+        p = []
+        for f in names:
+            p.extend(faces[f])
+        if show:
+            return p
+        g.append(Permutation(p))
+
+    g = []  # container for the group's permutations
+    I = list(range(6*n**2))  # the identity permutation used for checking
+
+    # define permutations corresponding to cw rotations of the planes
+    # up TO the last plane from that direction; by not including the
+    # last plane, the orientation of the cube is maintained.
+
+    # F slices
+    for i in range(n - 1):
+        fcw(i)
+        perm()
+        fccw(i)  # restore
+    assert perm(1) == I
+
+    # R slices
+    # bring R to front
+    UCW()
+    for i in range(n - 1):
+        fcw(i)
+        # put it back in place
+        UCCW()
+        # record
+        perm()
+        # restore
+        # bring face to front
+        UCW()
+        fccw(i)
+    # restore
+    UCCW()
+    assert perm(1) == I
+
+    # D slices
+    # bring up bottom
+    FCW()
+    UCCW()
+    FCCW()
+    for i in range(n - 1):
+        # turn strip
+        fcw(i)
+        # put bottom back on the bottom
+        FCW()
+        UCW()
+        FCCW()
+        # record
+        perm()
+        # restore
+        # bring up bottom
+        FCW()
+        UCCW()
+        FCCW()
+        # turn strip
+        fccw(i)
+    # put bottom back on the bottom
+    FCW()
+    UCW()
+    FCCW()
+    assert perm(1) == I
+
+    return g

pllava/lib/python3.10/site-packages/sympy/combinatorics/group_constructs.py

@@ -0,0 +1,61 @@
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.permutations import Permutation
+from sympy.utilities.iterables import uniq
+
+_af_new = Permutation._af_new
+
+
+def DirectProduct(*groups):
+    """
+    Returns the direct product of several groups as a permutation group.
+
+    Explanation
+    ===========
+
+    This is implemented much like the __mul__ procedure for taking the direct
+    product of two permutation groups, but the idea of shifting the
+    generators is realized in the case of an arbitrary number of groups.
+    A call to DirectProduct(G1, G2, ..., Gn) is generally expected to be faster
+    than a call to G1*G2*...*Gn (and thus the need for this algorithm).
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_constructs import DirectProduct
+    >>> from sympy.combinatorics.named_groups import CyclicGroup
+    >>> C = CyclicGroup(4)
+    >>> G = DirectProduct(C, C, C)
+    >>> G.order()
+    64
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.__mul__
+
+    """
+    degrees = []
+    gens_count = []
+    total_degree = 0
+    total_gens = 0
+    for group in groups:
+        current_deg = group.degree
+        current_num_gens = len(group.generators)
+        degrees.append(current_deg)
+        total_degree += current_deg
+        gens_count.append(current_num_gens)
+        total_gens += current_num_gens
+    array_gens = []
+    for i in range(total_gens):
+        array_gens.append(list(range(total_degree)))
+    current_gen = 0
+    current_deg = 0
+    for i in range(len(gens_count)):
+        for j in range(current_gen, current_gen + gens_count[i]):
+            gen = ((groups[i].generators)[j - current_gen]).array_form
+            array_gens[j][current_deg:current_deg + degrees[i]] = \
+                [x + current_deg for x in gen]
+        current_gen += gens_count[i]
+        current_deg += degrees[i]
+    perm_gens = list(uniq([_af_new(list(a)) for a in array_gens]))
+    return PermutationGroup(perm_gens, dups=False)

pllava/lib/python3.10/site-packages/sympy/combinatorics/named_groups.py

@@ -0,0 +1,332 @@
+from sympy.combinatorics.group_constructs import DirectProduct
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.permutations import Permutation
+
+_af_new = Permutation._af_new
+
+
+def AbelianGroup(*cyclic_orders):
+    """
+    Returns the direct product of cyclic groups with the given orders.
+
+    Explanation
+    ===========
+
+    According to the structure theorem for finite abelian groups ([1]),
+    every finite abelian group can be written as the direct product of
+    finitely many cyclic groups.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import AbelianGroup
+    >>> AbelianGroup(3, 4)
+    PermutationGroup([
+            (6)(0 1 2),
+            (3 4 5 6)])
+    >>> _.is_group
+    True
+
+    See Also
+    ========
+
+    DirectProduct
+
+    References
+    ==========
+
+    .. [1] https://groupprops.subwiki.org/wiki/Structure_theorem_for_finitely_generated_abelian_groups
+
+    """
+    groups = []
+    degree = 0
+    order = 1
+    for size in cyclic_orders:
+        degree += size
+        order *= size
+        groups.append(CyclicGroup(size))
+    G = DirectProduct(*groups)
+    G._is_abelian = True
+    G._degree = degree
+    G._order = order
+
+    return G
+
+
+def AlternatingGroup(n):
+    """
+    Generates the alternating group on ``n`` elements as a permutation group.
+
+    Explanation
+    ===========
+
+    For ``n > 2``, the generators taken are ``(0 1 2), (0 1 2 ... n-1)`` for
+    ``n`` odd
+    and ``(0 1 2), (1 2 ... n-1)`` for ``n`` even (See [1], p.31, ex.6.9.).
+    After the group is generated, some of its basic properties are set.
+    The cases ``n = 1, 2`` are handled separately.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import AlternatingGroup
+    >>> G = AlternatingGroup(4)
+    >>> G.is_group
+    True
+    >>> a = list(G.generate_dimino())
+    >>> len(a)
+    12
+    >>> all(perm.is_even for perm in a)
+    True
+
+    See Also
+    ========
+
+    SymmetricGroup, CyclicGroup, DihedralGroup
+
+    References
+    ==========
+
+    .. [1] Armstrong, M. "Groups and Symmetry"
+
+    """
+    # small cases are special
+    if n in (1, 2):
+        return PermutationGroup([Permutation([0])])
+
+    a = list(range(n))
+    a[0], a[1], a[2] = a[1], a[2], a[0]
+    gen1 = a
+    if n % 2:
+        a = list(range(1, n))
+        a.append(0)
+        gen2 = a
+    else:
+        a = list(range(2, n))
+        a.append(1)
+        a.insert(0, 0)
+        gen2 = a
+    gens = [gen1, gen2]
+    if gen1 == gen2:
+        gens = gens[:1]
+    G = PermutationGroup([_af_new(a) for a in gens], dups=False)
+
+    set_alternating_group_properties(G, n, n)
+    G._is_alt = True
+    return G
+
+
+def set_alternating_group_properties(G, n, degree):
+    """Set known properties of an alternating group. """
+    if n < 4:
+        G._is_abelian = True
+        G._is_nilpotent = True
+    else:
+        G._is_abelian = False
+        G._is_nilpotent = False
+    if n < 5:
+        G._is_solvable = True
+    else:
+        G._is_solvable = False
+    G._degree = degree
+    G._is_transitive = True
+    G._is_dihedral = False
+
+
+def CyclicGroup(n):
+    """
+    Generates the cyclic group of order ``n`` as a permutation group.
+
+    Explanation
+    ===========
+
+    The generator taken is the ``n``-cycle ``(0 1 2 ... n-1)``
+    (in cycle notation). After the group is generated, some of its basic
+    properties are set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import CyclicGroup
+    >>> G = CyclicGroup(6)
+    >>> G.is_group
+    True
+    >>> G.order()
+    6
+    >>> list(G.generate_schreier_sims(af=True))
+    [[0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 0], [2, 3, 4, 5, 0, 1],
+    [3, 4, 5, 0, 1, 2], [4, 5, 0, 1, 2, 3], [5, 0, 1, 2, 3, 4]]
+
+    See Also
+    ========
+
+    SymmetricGroup, DihedralGroup, AlternatingGroup
+
+    """
+    a = list(range(1, n))
+    a.append(0)
+    gen = _af_new(a)
+    G = PermutationGroup([gen])
+
+    G._is_abelian = True
+    G._is_nilpotent = True
+    G._is_solvable = True
+    G._degree = n
+    G._is_transitive = True
+    G._order = n
+    G._is_dihedral = (n == 2)
+    return G
+
+
+def DihedralGroup(n):
+    r"""
+    Generates the dihedral group `D_n` as a permutation group.
+
+    Explanation
+    ===========
+
+    The dihedral group `D_n` is the group of symmetries of the regular
+    ``n``-gon. The generators taken are the ``n``-cycle ``a = (0 1 2 ... n-1)``
+    (a rotation of the ``n``-gon) and ``b = (0 n-1)(1 n-2)...``
+    (a reflection of the ``n``-gon) in cycle rotation. It is easy to see that
+    these satisfy ``a**n = b**2 = 1`` and ``bab = ~a`` so they indeed generate
+    `D_n` (See [1]). After the group is generated, some of its basic properties
+    are set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> G = DihedralGroup(5)
+    >>> G.is_group
+    True
+    >>> a = list(G.generate_dimino())
+    >>> [perm.cyclic_form for perm in a]
+    [[], [[0, 1, 2, 3, 4]], [[0, 2, 4, 1, 3]],
+    [[0, 3, 1, 4, 2]], [[0, 4, 3, 2, 1]], [[0, 4], [1, 3]],
+    [[1, 4], [2, 3]], [[0, 1], [2, 4]], [[0, 2], [3, 4]],
+    [[0, 3], [1, 2]]]
+
+    See Also
+    ========
+
+    SymmetricGroup, CyclicGroup, AlternatingGroup
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Dihedral_group
+
+    """
+    # small cases are special
+    if n == 1:
+        return PermutationGroup([Permutation([1, 0])])
+    if n == 2:
+        return PermutationGroup([Permutation([1, 0, 3, 2]),
+               Permutation([2, 3, 0, 1]), Permutation([3, 2, 1, 0])])
+
+    a = list(range(1, n))
+    a.append(0)
+    gen1 = _af_new(a)
+    a = list(range(n))
+    a.reverse()
+    gen2 = _af_new(a)
+    G = PermutationGroup([gen1, gen2])
+    # if n is a power of 2, group is nilpotent
+    if n & (n-1) == 0:
+        G._is_nilpotent = True
+    else:
+        G._is_nilpotent = False
+    G._is_dihedral = True
+    G._is_abelian = False
+    G._is_solvable = True
+    G._degree = n
+    G._is_transitive = True
+    G._order = 2*n
+    return G
+
+
+def SymmetricGroup(n):
+    """
+    Generates the symmetric group on ``n`` elements as a permutation group.
+
+    Explanation
+    ===========
+
+    The generators taken are the ``n``-cycle
+    ``(0 1 2 ... n-1)`` and the transposition ``(0 1)`` (in cycle notation).
+    (See [1]). After the group is generated, some of its basic properties
+    are set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import SymmetricGroup
+    >>> G = SymmetricGroup(4)
+    >>> G.is_group
+    True
+    >>> G.order()
+    24
+    >>> list(G.generate_schreier_sims(af=True))
+    [[0, 1, 2, 3], [1, 2, 3, 0], [2, 3, 0, 1], [3, 1, 2, 0], [0, 2, 3, 1],
+    [1, 3, 0, 2], [2, 0, 1, 3], [3, 2, 0, 1], [0, 3, 1, 2], [1, 0, 2, 3],
+    [2, 1, 3, 0], [3, 0, 1, 2], [0, 1, 3, 2], [1, 2, 0, 3], [2, 3, 1, 0],
+    [3, 1, 0, 2], [0, 2, 1, 3], [1, 3, 2, 0], [2, 0, 3, 1], [3, 2, 1, 0],
+    [0, 3, 2, 1], [1, 0, 3, 2], [2, 1, 0, 3], [3, 0, 2, 1]]
+
+    See Also
+    ========
+
+    CyclicGroup, DihedralGroup, AlternatingGroup
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Symmetric_group#Generators_and_relations
+
+    """
+    if n == 1:
+        G = PermutationGroup([Permutation([0])])
+    elif n == 2:
+        G = PermutationGroup([Permutation([1, 0])])
+    else:
+        a = list(range(1, n))
+        a.append(0)
+        gen1 = _af_new(a)
+        a = list(range(n))
+        a[0], a[1] = a[1], a[0]
+        gen2 = _af_new(a)
+        G = PermutationGroup([gen1, gen2])
+    set_symmetric_group_properties(G, n, n)
+    G._is_sym = True
+    return G
+
+
+def set_symmetric_group_properties(G, n, degree):
+    """Set known properties of a symmetric group. """
+    if n < 3:
+        G._is_abelian = True
+        G._is_nilpotent = True
+    else:
+        G._is_abelian = False
+        G._is_nilpotent = False
+    if n < 5:
+        G._is_solvable = True
+    else:
+        G._is_solvable = False
+    G._degree = degree
+    G._is_transitive = True
+    G._is_dihedral = (n in [2, 3])  # cf Landau's func and Stirling's approx
+
+
+def RubikGroup(n):
+    """Return a group of Rubik's cube generators
+
+    >>> from sympy.combinatorics.named_groups import RubikGroup
+    >>> RubikGroup(2).is_group
+    True
+    """
+    from sympy.combinatorics.generators import rubik
+    if n <= 1:
+        raise ValueError("Invalid cube. n has to be greater than 1")
+    return PermutationGroup(rubik(n))

pllava/lib/python3.10/site-packages/sympy/combinatorics/tests/test_fp_groups.py

@@ -0,0 +1,257 @@
+from sympy.core.singleton import S
+from sympy.combinatorics.fp_groups import (FpGroup, low_index_subgroups,
+                                   reidemeister_presentation, FpSubgroup,
+                                           simplify_presentation)
+from sympy.combinatorics.free_groups import (free_group, FreeGroup)
+
+from sympy.testing.pytest import slow
+
+"""
+References
+==========
+
+[1] Holt, D., Eick, B., O'Brien, E.
+"Handbook of Computational Group Theory"
+
+[2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490.
+"Implementation and Analysis of the Todd-Coxeter Algorithm"
+
+[3] PROC. SECOND  INTERNAT. CONF. THEORY OF GROUPS, CANBERRA 1973,
+pp. 347-356. "A Reidemeister-Schreier program" by George Havas.
+http://staff.itee.uq.edu.au/havas/1973cdhw.pdf
+
+"""
+
+def test_low_index_subgroups():
+    F, x, y = free_group("x, y")
+
+    # Example 5.10 from [1] Pg. 194
+    f = FpGroup(F, [x**2, y**3, (x*y)**4])
+    L = low_index_subgroups(f, 4)
+    t1 = [[[0, 0, 0, 0]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 3, 3]],
+          [[0, 0, 1, 2], [2, 2, 2, 0], [1, 1, 0, 1]],
+          [[1, 1, 0, 0], [0, 0, 1, 1]]]
+    for i in range(len(t1)):
+        assert L[i].table == t1[i]
+
+    f = FpGroup(F, [x**2, y**3, (x*y)**7])
+    L = low_index_subgroups(f, 15)
+    t2 = [[[0, 0, 0, 0]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [4, 4, 5, 3], [6, 6, 3, 4], [5, 5, 6, 6]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [5, 5, 3, 4], [4, 4, 6, 6]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [9, 9, 6, 8], [12, 12, 11, 7], [8, 8, 7, 10],
+            [10, 10, 13, 14], [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [12, 12, 6, 8], [10, 10, 11, 7], [8, 8, 7, 10],
+            [9, 9, 13, 14], [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [12, 12, 6, 8], [13, 13, 11, 7], [8, 8, 7, 10],
+            [9, 9, 12, 12], [10, 10, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 3, 3], [2, 2, 5, 6]
+            , [7, 7, 6, 4], [8, 8, 4, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [11, 11, 12, 10], [13, 13, 10, 11],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 3, 3], [2, 2, 5, 6]
+            , [7, 7, 6, 4], [8, 8, 4, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [13, 13, 12, 10], [12, 12, 10, 11],
+            [11, 11, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 4, 4]
+            , [7, 7, 6, 3], [8, 8, 3, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [13, 13, 12, 10], [12, 12, 10, 11],
+            [11, 11, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [5, 5, 6, 3], [9, 9, 3, 5], [10, 10, 8, 4], [8, 8, 4, 7],
+            [6, 6, 10, 11], [7, 7, 11, 9], [12, 12, 9, 10], [11, 11, 13, 14],
+            [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [6, 6, 6, 3], [5, 5, 3, 5], [8, 8, 8, 4], [7, 7, 4, 7]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [6, 6, 3, 5], [10, 10, 8, 4], [11, 11, 4, 7],
+            [5, 5, 10, 12], [7, 7, 12, 9], [8, 8, 11, 11], [13, 13, 9, 10],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [6, 6, 3, 5], [10, 10, 8, 4], [11, 11, 4, 7],
+            [5, 5, 12, 11], [7, 7, 10, 10], [8, 8, 9, 12], [13, 13, 11, 9],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [7, 7, 8, 4], [11, 11, 4, 7],
+            [5, 5, 9, 9], [6, 6, 11, 12], [8, 8, 12, 10], [13, 13, 10, 11],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [7, 7, 8, 4], [11, 11, 4, 7],
+            [5, 5, 12, 11], [6, 6, 10, 10], [8, 8, 9, 12], [13, 13, 11, 9],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [11, 11, 8, 4], [12, 12, 4, 7],
+            [5, 5, 9, 9], [6, 6, 12, 13], [7, 7, 11, 11], [8, 8, 13, 10],
+            [13, 13, 10, 12]],
+           [[1, 1, 0, 0], [0, 0, 2, 3], [4, 4, 3, 1], [5, 5, 1, 2], [2, 2, 4, 4]
+            , [3, 3, 6, 7], [7, 7, 7, 5], [6, 6, 5, 6]]]
+    for i  in range(len(t2)):
+        assert L[i].table == t2[i]
+
+    f = FpGroup(F, [x**2, y**3, (x*y)**7])
+    L = low_index_subgroups(f, 10, [x])
+    t3 = [[[0, 0, 0, 0]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5], [4, 4, 5, 3],
+           [6, 6, 3, 4], [5, 5, 6, 6]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5], [6, 6, 5, 3],
+           [5, 5, 3, 4], [4, 4, 6, 6]],
+          [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8],
+           [6, 6, 6, 3], [5, 5, 3, 5], [8, 8, 8, 4], [7, 7, 4, 7]]]
+    for i in range(len(t3)):
+        assert L[i].table == t3[i]
+
+
+def test_subgroup_presentations():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    p1 = reidemeister_presentation(f, H)
+    assert str(p1) == "((y_1, y_2), (y_1**2, y_2**3, y_2*y_1*y_2*y_1*y_2*y_1))"
+
+    H = f.subgroup(H)
+    assert (H.generators, H.relators) == p1
+
+    f = FpGroup(F, [x**3, y**3, (x*y)**3])
+    H = [x*y, x*y**-1]
+    p2 = reidemeister_presentation(f, H)
+    assert str(p2) == "((x_0, y_0), (x_0**3, y_0**3, x_0*y_0*x_0*y_0*x_0*y_0))"
+
+    f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    H = [x]
+    p3 = reidemeister_presentation(f, H)
+    assert str(p3) == "((x_0,), (x_0**4,))"
+
+    f = FpGroup(F, [x**3*y**-3, (x*y)**3, (x*y**-1)**2])
+    H = [x]
+    p4 = reidemeister_presentation(f, H)
+    assert str(p4) == "((x_0,), (x_0**6,))"
+
+    # this presentation can be improved, the most simplified form
+    # of presentation is <a, b | a^11, b^2, (a*b)^3, (a^4*b*a^-5*b)^2>
+    # See [2] Pg 474 group PSL_2(11)
+    # This is the group PSL_2(11)
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**11, b**5, c**4, (b*c**2)**2, (a*b*c)**3, (a**4*c**2)**3, b**2*c**-1*b**-1*c, a**4*b**-1*a**-1*b])
+    H = [a, b, c**2]
+    gens, rels = reidemeister_presentation(f, H)
+    assert str(gens) == "(b_1, c_3)"
+    assert len(rels) == 18
+
+
+@slow
+def test_order():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert f.order() == 8
+
+    f = FpGroup(F, [x*y*x**-1*y**-1, y**2])
+    assert f.order() is S.Infinity
+
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**250, b**2, c*b*c**-1*b, c**4, c**-1*a**-1*c*a, a**-1*b**-1*a*b])
+    assert f.order() == 2000
+
+    F, x = free_group("x")
+    f = FpGroup(F, [])
+    assert f.order() is S.Infinity
+
+    f = FpGroup(free_group('')[0], [])
+    assert f.order() == 1
+
+def test_fp_subgroup():
+    def _test_subgroup(K, T, S):
+        _gens = T(K.generators)
+        assert all(elem in S for elem in _gens)
+        assert T.is_injective()
+        assert T.image().order() == S.order()
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    S = FpSubgroup(f, [x*y])
+    assert (x*y)**-3 in S
+    K, T = f.subgroup([x*y], homomorphism=True)
+    assert T(K.generators) == [y*x**-1]
+    _test_subgroup(K, T, S)
+
+    S = FpSubgroup(f, [x**-1*y*x])
+    assert x**-1*y**4*x in S
+    assert x**-1*y**4*x**2 not in S
+    K, T = f.subgroup([x**-1*y*x], homomorphism=True)
+    assert T(K.generators[0]**3) == y**3
+    _test_subgroup(K, T, S)
+
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    K, T = f.subgroup(H, homomorphism=True)
+    S = FpSubgroup(f, H)
+    _test_subgroup(K, T, S)
+
+def test_permutation_methods():
+    F, x, y = free_group("x, y")
+    # DihedralGroup(8)
+    G = FpGroup(F, [x**2, y**8, x*y*x**-1*y])
+    T = G._to_perm_group()[1]
+    assert T.is_isomorphism()
+    assert G.center() == [y**4]
+
+    # DiheadralGroup(4)
+    G = FpGroup(F, [x**2, y**4, x*y*x**-1*y])
+    S = FpSubgroup(G, G.normal_closure([x]))
+    assert x in S
+    assert y**-1*x*y in S
+
+    # Z_5xZ_4
+    G = FpGroup(F, [x*y*x**-1*y**-1, y**5, x**4])
+    assert G.is_abelian
+    assert G.is_solvable
+
+    # AlternatingGroup(5)
+    G = FpGroup(F, [x**3, y**2, (x*y)**5])
+    assert not G.is_solvable
+
+    # AlternatingGroup(4)
+    G = FpGroup(F, [x**3, y**2, (x*y)**3])
+    assert len(G.derived_series()) == 3
+    S = FpSubgroup(G, G.derived_subgroup())
+    assert S.order() == 4
+
+
+def test_simplify_presentation():
+    # ref #16083
+    G = simplify_presentation(FpGroup(FreeGroup([]), []))
+    assert not G.generators
+    assert not G.relators
+
+    # CyclicGroup(3)
+    # The second generator in <x, y | x^2, x^5, y^3> is trivial due to relators {x^2, x^5}
+    F, x, y = free_group("x, y")
+    G = simplify_presentation(FpGroup(F, [x**2, x**5, y**3]))
+    assert x in G.relators
+
+def test_cyclic():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x*y, x**-1*y**-1*x*y*x])
+    assert f.is_cyclic
+    f = FpGroup(F, [x*y, x*y**-1])
+    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]

pllava/lib/python3.10/site-packages/sympy/combinatorics/tests/test_generators.py

@@ -0,0 +1,105 @@
+from sympy.combinatorics.generators import symmetric, cyclic, alternating, \
+    dihedral, rubik
+from sympy.combinatorics.permutations import Permutation
+from sympy.testing.pytest import raises
+
+def test_generators():
+
+    assert list(cyclic(6)) == [
+        Permutation([0, 1, 2, 3, 4, 5]),
+        Permutation([1, 2, 3, 4, 5, 0]),
+        Permutation([2, 3, 4, 5, 0, 1]),
+        Permutation([3, 4, 5, 0, 1, 2]),
+        Permutation([4, 5, 0, 1, 2, 3]),
+        Permutation([5, 0, 1, 2, 3, 4])]
+
+    assert list(cyclic(10)) == [
+        Permutation([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        Permutation([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]),
+        Permutation([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]),
+        Permutation([3, 4, 5, 6, 7, 8, 9, 0, 1, 2]),
+        Permutation([4, 5, 6, 7, 8, 9, 0, 1, 2, 3]),
+        Permutation([5, 6, 7, 8, 9, 0, 1, 2, 3, 4]),
+        Permutation([6, 7, 8, 9, 0, 1, 2, 3, 4, 5]),
+        Permutation([7, 8, 9, 0, 1, 2, 3, 4, 5, 6]),
+        Permutation([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]),
+        Permutation([9, 0, 1, 2, 3, 4, 5, 6, 7, 8])]
+
+    assert list(alternating(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(symmetric(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([0, 2, 1]),
+        Permutation([1, 0, 2]),
+        Permutation([1, 2, 0]),
+        Permutation([2, 0, 1]),
+        Permutation([2, 1, 0])]
+
+    assert list(symmetric(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 1, 3, 2]),
+        Permutation([0, 2, 1, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([0, 3, 2, 1]),
+        Permutation([1, 0, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 2, 3, 0]),
+        Permutation([1, 3, 0, 2]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 0, 3, 1]),
+        Permutation([2, 1, 0, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([2, 3, 1, 0]),
+        Permutation([3, 0, 1, 2]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 1, 2, 0]),
+        Permutation([3, 2, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(1)) == [
+        Permutation([0, 1]), Permutation([1, 0])]
+
+    assert list(dihedral(2)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([2, 1, 0]),
+        Permutation([1, 2, 0]),
+        Permutation([0, 2, 1]),
+        Permutation([2, 0, 1]),
+        Permutation([1, 0, 2])]
+
+    assert list(dihedral(5)) == [
+        Permutation([0, 1, 2, 3, 4]),
+        Permutation([4, 3, 2, 1, 0]),
+        Permutation([1, 2, 3, 4, 0]),
+        Permutation([0, 4, 3, 2, 1]),
+        Permutation([2, 3, 4, 0, 1]),
+        Permutation([1, 0, 4, 3, 2]),
+        Permutation([3, 4, 0, 1, 2]),
+        Permutation([2, 1, 0, 4, 3]),
+        Permutation([4, 0, 1, 2, 3]),
+        Permutation([3, 2, 1, 0, 4])]
+
+    raises(ValueError, lambda: rubik(1))

pllava/lib/python3.10/site-packages/sympy/combinatorics/tests/test_graycode.py

@@ -0,0 +1,72 @@
+from sympy.combinatorics.graycode import (GrayCode, bin_to_gray,
+    random_bitstring, get_subset_from_bitstring, graycode_subsets,
+    gray_to_bin)
+from sympy.testing.pytest import raises
+
+def test_graycode():
+    g = GrayCode(2)
+    got = []
+    for i in g.generate_gray():
+        if i.startswith('0'):
+            g.skip()
+        got.append(i)
+    assert got == '00 11 10'.split()
+    a = GrayCode(6)
+    assert a.current == '0'*6
+    assert a.rank == 0
+    assert len(list(a.generate_gray())) == 64
+    codes = ['011001', '011011', '011010',
+    '011110', '011111', '011101', '011100', '010100', '010101', '010111',
+    '010110', '010010', '010011', '010001', '010000', '110000', '110001',
+    '110011', '110010', '110110', '110111', '110101', '110100', '111100',
+    '111101', '111111', '111110', '111010', '111011', '111001', '111000',
+    '101000', '101001', '101011', '101010', '101110', '101111', '101101',
+    '101100', '100100', '100101', '100111', '100110', '100010', '100011',
+    '100001', '100000']
+    assert list(a.generate_gray(start='011001')) == codes
+    assert list(
+        a.generate_gray(rank=GrayCode(6, start='011001').rank)) == codes
+    assert a.next().current == '000001'
+    assert a.next(2).current == '000011'
+    assert a.next(-1).current == '100000'
+
+    a = GrayCode(5, start='10010')
+    assert a.rank == 28
+    a = GrayCode(6, start='101000')
+    assert a.rank == 48
+
+    assert GrayCode(6, rank=4).current == '000110'
+    assert GrayCode(6, rank=4).rank == 4
+    assert [GrayCode(4, start=s).rank for s in
+            GrayCode(4).generate_gray()] == [0, 1, 2, 3, 4, 5, 6, 7, 8,
+                                             9, 10, 11, 12, 13, 14, 15]
+    a = GrayCode(15, rank=15)
+    assert a.current == '000000000001000'
+
+    assert bin_to_gray('111') == '100'
+
+    a = random_bitstring(5)
+    assert type(a) is str
+    assert len(a) == 5
+    assert all(i in ['0', '1'] for i in a)
+
+    assert get_subset_from_bitstring(
+        ['a', 'b', 'c', 'd'], '0011') == ['c', 'd']
+    assert get_subset_from_bitstring('abcd', '1001') == ['a', 'd']
+    assert list(graycode_subsets(['a', 'b', 'c'])) == \
+        [[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'],
+         ['a', 'c'], ['a']]
+
+    raises(ValueError, lambda: GrayCode(0))
+    raises(ValueError, lambda: GrayCode(2.2))
+    raises(ValueError, lambda: GrayCode(2, start=[1, 1, 0]))
+    raises(ValueError, lambda: GrayCode(2, rank=2.5))
+    raises(ValueError, lambda: get_subset_from_bitstring(['c', 'a', 'c'], '1100'))
+    raises(ValueError, lambda: list(GrayCode(3).generate_gray(start="1111")))
+
+
+def test_live_issue_117():
+    assert bin_to_gray('0100') == '0110'
+    assert bin_to_gray('0101') == '0111'
+    for bits in ('0100', '0101'):
+        assert gray_to_bin(bin_to_gray(bits)) == bits

pllava/lib/python3.10/site-packages/sympy/combinatorics/tests/test_homomorphisms.py

@@ -0,0 +1,114 @@
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.homomorphisms import homomorphism, group_isomorphism, is_isomorphic
+from sympy.combinatorics.free_groups import free_group
+from sympy.combinatorics.fp_groups import FpGroup
+from sympy.combinatorics.named_groups import AlternatingGroup, DihedralGroup, CyclicGroup
+from sympy.testing.pytest import raises
+
+def test_homomorphism():
+    # FpGroup -> PermutationGroup
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+
+    c = Permutation(3)(0, 1, 2)
+    d = Permutation(3)(1, 2, 3)
+    A = AlternatingGroup(4)
+    T = homomorphism(G, A, [a, b], [c, d])
+    assert T(a*b**2*a**-1) == c*d**2*c**-1
+    assert T.is_isomorphism()
+    assert T(T.invert(Permutation(3)(0, 2, 3))) == Permutation(3)(0, 2, 3)
+
+    T = homomorphism(G, AlternatingGroup(4), G.generators)
+    assert T.is_trivial()
+    assert T.kernel().order() == G.order()
+
+    E, e = free_group("e")
+    G = FpGroup(E, [e**8])
+    P = PermutationGroup([Permutation(0, 1, 2, 3), Permutation(0, 2)])
+    T = homomorphism(G, P, [e], [Permutation(0, 1, 2, 3)])
+    assert T.image().order() == 4
+    assert T(T.invert(Permutation(0, 2)(1, 3))) == Permutation(0, 2)(1, 3)
+
+    T = homomorphism(E, AlternatingGroup(4), E.generators, [c])
+    assert T.invert(c**2) == e**-1 #order(c) == 3 so c**2 == c**-1
+
+    # FreeGroup -> FreeGroup
+    T = homomorphism(F, E, [a], [e])
+    assert T(a**-2*b**4*a**2).is_identity
+
+    # FreeGroup -> FpGroup
+    G = FpGroup(F, [a*b*a**-1*b**-1])
+    T = homomorphism(F, G, F.generators, G.generators)
+    assert T.invert(a**-1*b**-1*a**2) == a*b**-1
+
+    # PermutationGroup -> PermutationGroup
+    D = DihedralGroup(8)
+    p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    P = PermutationGroup(p)
+    T = homomorphism(P, D, [p], [p])
+    assert T.is_injective()
+    assert not T.is_isomorphism()
+    assert T.invert(p**3) == p**3
+
+    T2 = homomorphism(F, P, [F.generators[0]], P.generators)
+    T = T.compose(T2)
+    assert T.domain == F
+    assert T.codomain == D
+    assert T(a*b) == p
+
+    D3 = DihedralGroup(3)
+    T = homomorphism(D3, D3, D3.generators, D3.generators)
+    assert T.is_isomorphism()
+
+
+def test_isomorphisms():
+
+    F, a, b = free_group("a, b")
+    E, c, d = free_group("c, d")
+    # Infinite groups with differently ordered relators.
+    G = FpGroup(F, [a**2, b**3])
+    H = FpGroup(F, [b**3, a**2])
+    assert is_isomorphic(G, H)
+
+    # Trivial Case
+    # FpGroup -> FpGroup
+    H = FpGroup(F, [a**3, b**3, (a*b)**2])
+    F, c, d = free_group("c, d")
+    G = FpGroup(F, [c**3, d**3, (c*d)**2])
+    check, T =  group_isomorphism(G, H)
+    assert check
+    assert T(c**3*d**2) == a**3*b**2
+
+    # FpGroup -> PermutationGroup
+    # FpGroup is converted to the equivalent isomorphic group.
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+    H = AlternatingGroup(4)
+    check, T = group_isomorphism(G, H)
+    assert check
+    assert T(b*a*b**-1*a**-1*b**-1) == Permutation(0, 2, 3)
+    assert T(b*a*b*a**-1*b**-1) == Permutation(0, 3, 2)
+
+    # PermutationGroup -> PermutationGroup
+    D = DihedralGroup(8)
+    p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    P = PermutationGroup(p)
+    assert not is_isomorphic(D, P)
+
+    A = CyclicGroup(5)
+    B = CyclicGroup(7)
+    assert not is_isomorphic(A, B)
+
+    # Two groups of the same prime order are isomorphic to each other.
+    G = FpGroup(F, [a, b**5])
+    H = CyclicGroup(5)
+    assert G.order() == H.order()
+    assert is_isomorphic(G, H)
+
+
+def test_check_homomorphism():
+    a = Permutation(1,2,3,4)
+    b = Permutation(1,3)
+    G = PermutationGroup([a, b])
+    raises(ValueError, lambda: homomorphism(G, G, [a], [a]))

pllava/lib/python3.10/site-packages/sympy/combinatorics/tests/test_perm_groups.py

@@ -0,0 +1,1243 @@
+from sympy.core.containers import Tuple
+from sympy.combinatorics.generators import rubik_cube_generators
+from sympy.combinatorics.homomorphisms import is_isomorphic
+from sympy.combinatorics.named_groups import SymmetricGroup, CyclicGroup,\
+    DihedralGroup, AlternatingGroup, AbelianGroup, RubikGroup
+from sympy.combinatorics.perm_groups import (PermutationGroup,
+    _orbit_transversal, Coset, SymmetricPermutationGroup)
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.polyhedron import tetrahedron as Tetra, cube
+from sympy.combinatorics.testutil import _verify_bsgs, _verify_centralizer,\
+    _verify_normal_closure
+from sympy.testing.pytest import skip, XFAIL, slow
+
+rmul = Permutation.rmul
+
+
+def test_has():
+    a = Permutation([1, 0])
+    G = PermutationGroup([a])
+    assert G.is_abelian
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    assert not G.is_abelian
+
+    G = PermutationGroup([a])
+    assert G.has(a)
+    assert not G.has(b)
+
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([0, 2, 1, 3, 4])
+    assert PermutationGroup(a, b).degree == \
+        PermutationGroup(a, b).degree == 6
+
+    g = PermutationGroup(Permutation(0, 2, 1))
+    assert Tuple(1, g).has(g)
+
+
+def test_generate():
+    a = Permutation([1, 0])
+    g = list(PermutationGroup([a]).generate())
+    assert g == [Permutation([0, 1]), Permutation([1, 0])]
+    assert len(list(PermutationGroup(Permutation((0, 1))).generate())) == 1
+    g = PermutationGroup([a]).generate(method='dimino')
+    assert list(g) == [Permutation([0, 1]), Permutation([1, 0])]
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    g = G.generate()
+    v1 = [p.array_form for p in list(g)]
+    v1.sort()
+    assert v1 == [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0,
+        1], [2, 1, 0]]
+    v2 = list(G.generate(method='dimino', af=True))
+    assert v1 == sorted(v2)
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    g = PermutationGroup([a, b]).generate(af=True)
+    assert len(list(g)) == 360
+
+
+def test_order():
+    a = Permutation([2, 0, 1, 3, 4, 5, 6, 7, 8, 9])
+    b = Permutation([2, 1, 3, 4, 5, 6, 7, 8, 9, 0])
+    g = PermutationGroup([a, b])
+    assert g.order() == 1814400
+    assert PermutationGroup().order() == 1
+
+
+def test_equality():
+    p_1 = Permutation(0, 1, 3)
+    p_2 = Permutation(0, 2, 3)
+    p_3 = Permutation(0, 1, 2)
+    p_4 = Permutation(0, 1, 3)
+    g_1 = PermutationGroup(p_1, p_2)
+    g_2 = PermutationGroup(p_3, p_4)
+    g_3 = PermutationGroup(p_2, p_1)
+    g_4 = PermutationGroup(p_1, p_2)
+
+    assert g_1 != g_2
+    assert g_1.generators != g_2.generators
+    assert g_1.equals(g_2)
+    assert g_1 != g_3
+    assert g_1.equals(g_3)
+    assert g_1 == g_4
+
+
+def test_stabilizer():
+    S = SymmetricGroup(2)
+    H = S.stabilizer(0)
+    assert H.generators == [Permutation(1)]
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    G = PermutationGroup([a, b])
+    G0 = G.stabilizer(0)
+    assert G0.order() == 60
+
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    G2 = G.stabilizer(2)
+    assert G2.order() == 6
+    G2_1 = G2.stabilizer(1)
+    v = list(G2_1.generate(af=True))
+    assert v == [[0, 1, 2, 3, 4, 5, 6, 7], [3, 1, 2, 0, 7, 5, 6, 4]]
+
+    gens = (
+        (1, 2, 0, 4, 5, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
+        (0, 1, 2, 3, 4, 5, 19, 6, 8, 9, 10, 11, 12, 13, 14,
+         15, 16, 7, 17, 18),
+        (0, 1, 2, 3, 4, 5, 6, 7, 9, 18, 16, 11, 12, 13, 14, 15, 8, 17, 10, 19))
+    gens = [Permutation(p) for p in gens]
+    G = PermutationGroup(gens)
+    G2 = G.stabilizer(2)
+    assert G2.order() == 181440
+    S = SymmetricGroup(3)
+    assert [G.order() for G in S.basic_stabilizers] == [6, 2]
+
+
+def test_center():
+    # the center of the dihedral group D_n is of order 2 for even n
+    for i in (4, 6, 10):
+        D = DihedralGroup(i)
+        assert (D.center()).order() == 2
+    # the center of the dihedral group D_n is of order 1 for odd n>2
+    for i in (3, 5, 7):
+        D = DihedralGroup(i)
+        assert (D.center()).order() == 1
+    # the center of an abelian group is the group itself
+    for i in (2, 3, 5):
+        for j in (1, 5, 7):
+            for k in (1, 1, 11):
+                G = AbelianGroup(i, j, k)
+                assert G.center().is_subgroup(G)
+    # the center of a nonabelian simple group is trivial
+    for i in(1, 5, 9):
+        A = AlternatingGroup(i)
+        assert (A.center()).order() == 1
+    # brute-force verifications
+    D = DihedralGroup(5)
+    A = AlternatingGroup(3)
+    C = CyclicGroup(4)
+    G.is_subgroup(D*A*C)
+    assert _verify_centralizer(G, G)
+
+
+def test_centralizer():
+    # the centralizer of the trivial group is the entire group
+    S = SymmetricGroup(2)
+    assert S.centralizer(Permutation(list(range(2)))).is_subgroup(S)
+    A = AlternatingGroup(5)
+    assert A.centralizer(Permutation(list(range(5)))).is_subgroup(A)
+    # a centralizer in the trivial group is the trivial group itself
+    triv = PermutationGroup([Permutation([0, 1, 2, 3])])
+    D = DihedralGroup(4)
+    assert triv.centralizer(D).is_subgroup(triv)
+    # brute-force verifications for centralizers of groups
+    for i in (4, 5, 6):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        C = CyclicGroup(i)
+        D = DihedralGroup(i)
+        for gp in (S, A, C, D):
+            for gp2 in (S, A, C, D):
+                if not gp2.is_subgroup(gp):
+                    assert _verify_centralizer(gp, gp2)
+    # verify the centralizer for all elements of several groups
+    S = SymmetricGroup(5)
+    elements = list(S.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(S, element)
+    A = AlternatingGroup(5)
+    elements = list(A.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(A, element)
+    D = DihedralGroup(7)
+    elements = list(D.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(D, element)
+    # verify centralizers of small groups within small groups
+    small = []
+    for i in (1, 2, 3):
+        small.append(SymmetricGroup(i))
+        small.append(AlternatingGroup(i))
+        small.append(DihedralGroup(i))
+        small.append(CyclicGroup(i))
+    for gp in small:
+        for gp2 in small:
+            if gp.degree == gp2.degree:
+                assert _verify_centralizer(gp, gp2)
+
+
+def test_coset_rank():
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    i = 0
+    for h in G.generate(af=True):
+        rk = G.coset_rank(h)
+        assert rk == i
+        h1 = G.coset_unrank(rk, af=True)
+        assert h == h1
+        i += 1
+    assert G.coset_unrank(48) is None
+    assert G.coset_unrank(G.coset_rank(gens[0])) == gens[0]
+
+
+def test_coset_factor():
+    a = Permutation([0, 2, 1])
+    G = PermutationGroup([a])
+    c = Permutation([2, 1, 0])
+    assert not G.coset_factor(c)
+    assert G.coset_rank(c) is None
+
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    g = PermutationGroup([a, b])
+    assert g.order() == 360
+    d = Permutation([1, 0, 2, 3, 4, 5])
+    assert not g.coset_factor(d.array_form)
+    assert not g.contains(d)
+    assert Permutation(2) in G
+    c = Permutation([1, 0, 2, 3, 5, 4])
+    v = g.coset_factor(c, True)
+    tr = g.basic_transversals
+    p = Permutation.rmul(*[tr[i][v[i]] for i in range(len(g.base))])
+    assert p == c
+    v = g.coset_factor(c)
+    p = Permutation.rmul(*v)
+    assert p == c
+    assert g.contains(c)
+    G = PermutationGroup([Permutation([2, 1, 0])])
+    p = Permutation([1, 0, 2])
+    assert G.coset_factor(p) == []
+
+
+def test_orbits():
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    g = PermutationGroup([a, b])
+    assert g.orbit(0) == {0, 1, 2}
+    assert g.orbits() == [{0, 1, 2}]
+    assert g.is_transitive() and g.is_transitive(strict=False)
+    assert g.orbit_transversal(0) == \
+        [Permutation(
+            [0, 1, 2]), Permutation([2, 0, 1]), Permutation([1, 2, 0])]
+    assert g.orbit_transversal(0, True) == \
+        [(0, Permutation([0, 1, 2])), (2, Permutation([2, 0, 1])),
+        (1, Permutation([1, 2, 0]))]
+
+    G = DihedralGroup(6)
+    transversal, slps = _orbit_transversal(G.degree, G.generators, 0, True, slp=True)
+    for i, t in transversal:
+        slp = slps[i]
+        w = G.identity
+        for s in slp:
+            w = G.generators[s]*w
+        assert w == t
+
+    a = Permutation(list(range(1, 100)) + [0])
+    G = PermutationGroup([a])
+    assert [min(o) for o in G.orbits()] == [0]
+    G = PermutationGroup(rubik_cube_generators())
+    assert [min(o) for o in G.orbits()] == [0, 1]
+    assert not G.is_transitive() and not G.is_transitive(strict=False)
+    G = PermutationGroup([Permutation(0, 1, 3), Permutation(3)(0, 1)])
+    assert not G.is_transitive() and G.is_transitive(strict=False)
+    assert PermutationGroup(
+        Permutation(3)).is_transitive(strict=False) is False
+
+
+def test_is_normal():
+    gens_s5 = [Permutation(p) for p in [[1, 2, 3, 4, 0], [2, 1, 4, 0, 3]]]
+    G1 = PermutationGroup(gens_s5)
+    assert G1.order() == 120
+    gens_a5 = [Permutation(p) for p in [[1, 0, 3, 2, 4], [2, 1, 4, 3, 0]]]
+    G2 = PermutationGroup(gens_a5)
+    assert G2.order() == 60
+    assert G2.is_normal(G1)
+    gens3 = [Permutation(p) for p in [[2, 1, 3, 0, 4], [1, 2, 0, 3, 4]]]
+    G3 = PermutationGroup(gens3)
+    assert not G3.is_normal(G1)
+    assert G3.order() == 12
+    G4 = G1.normal_closure(G3.generators)
+    assert G4.order() == 60
+    gens5 = [Permutation(p) for p in [[1, 2, 3, 0, 4], [1, 2, 0, 3, 4]]]
+    G5 = PermutationGroup(gens5)
+    assert G5.order() == 24
+    G6 = G1.normal_closure(G5.generators)
+    assert G6.order() == 120
+    assert G1.is_subgroup(G6)
+    assert not G1.is_subgroup(G4)
+    assert G2.is_subgroup(G4)
+    I5 = PermutationGroup(Permutation(4))
+    assert I5.is_normal(G5)
+    assert I5.is_normal(G6, strict=False)
+    p1 = Permutation([1, 0, 2, 3, 4])
+    p2 = Permutation([0, 1, 2, 4, 3])
+    p3 = Permutation([3, 4, 2, 1, 0])
+    id_ = Permutation([0, 1, 2, 3, 4])
+    H = PermutationGroup([p1, p3])
+    H_n1 = PermutationGroup([p1, p2])
+    H_n2_1 = PermutationGroup(p1)
+    H_n2_2 = PermutationGroup(p2)
+    H_id = PermutationGroup(id_)
+    assert H_n1.is_normal(H)
+    assert H_n2_1.is_normal(H_n1)
+    assert H_n2_2.is_normal(H_n1)
+    assert H_id.is_normal(H_n2_1)
+    assert H_id.is_normal(H_n1)
+    assert H_id.is_normal(H)
+    assert not H_n2_1.is_normal(H)
+    assert not H_n2_2.is_normal(H)
+
+
+def test_eq():
+    a = [[1, 2, 0, 3, 4, 5], [1, 0, 2, 3, 4, 5], [2, 1, 0, 3, 4, 5], [
+        1, 2, 0, 3, 4, 5]]
+    a = [Permutation(p) for p in a + [[1, 2, 3, 4, 5, 0]]]
+    g = Permutation([1, 2, 3, 4, 5, 0])
+    G1, G2, G3 = [PermutationGroup(x) for x in [a[:2], a[2:4], [g, g**2]]]
+    assert G1.order() == G2.order() == G3.order() == 6
+    assert G1.is_subgroup(G2)
+    assert not G1.is_subgroup(G3)
+    G4 = PermutationGroup([Permutation([0, 1])])
+    assert not G1.is_subgroup(G4)
+    assert G4.is_subgroup(G1, 0)
+    assert PermutationGroup(g, g).is_subgroup(PermutationGroup(g))
+    assert SymmetricGroup(3).is_subgroup(SymmetricGroup(4), 0)
+    assert SymmetricGroup(3).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+    assert not CyclicGroup(5).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+    assert CyclicGroup(3).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+
+
+def test_derived_subgroup():
+    a = Permutation([1, 0, 2, 4, 3])
+    b = Permutation([0, 1, 3, 2, 4])
+    G = PermutationGroup([a, b])
+    C = G.derived_subgroup()
+    assert C.order() == 3
+    assert C.is_normal(G)
+    assert C.is_subgroup(G, 0)
+    assert not G.is_subgroup(C, 0)
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    C = G.derived_subgroup()
+    assert C.order() == 12
+
+
+def test_is_solvable():
+    a = Permutation([1, 2, 0])
+    b = Permutation([1, 0, 2])
+    G = PermutationGroup([a, b])
+    assert G.is_solvable
+    G = PermutationGroup([a])
+    assert G.is_solvable
+    a = Permutation([1, 2, 3, 4, 0])
+    b = Permutation([1, 0, 2, 3, 4])
+    G = PermutationGroup([a, b])
+    assert not G.is_solvable
+    P = SymmetricGroup(10)
+    S = P.sylow_subgroup(3)
+    assert S.is_solvable
+
+def test_rubik1():
+    gens = rubik_cube_generators()
+    gens1 = [gens[-1]] + [p**2 for p in gens[1:]]
+    G1 = PermutationGroup(gens1)
+    assert G1.order() == 19508428800
+    gens2 = [p**2 for p in gens]
+    G2 = PermutationGroup(gens2)
+    assert G2.order() == 663552
+    assert G2.is_subgroup(G1, 0)
+    C1 = G1.derived_subgroup()
+    assert C1.order() == 4877107200
+    assert C1.is_subgroup(G1, 0)
+    assert not G2.is_subgroup(C1, 0)
+
+    G = RubikGroup(2)
+    assert G.order() == 3674160
+
+
+@XFAIL
+def test_rubik():
+    skip('takes too much time')
+    G = PermutationGroup(rubik_cube_generators())
+    assert G.order() == 43252003274489856000
+    G1 = PermutationGroup(G[:3])
+    assert G1.order() == 170659735142400
+    assert not G1.is_normal(G)
+    G2 = G.normal_closure(G1.generators)
+    assert G2.is_subgroup(G)
+
+
+def test_direct_product():
+    C = CyclicGroup(4)
+    D = DihedralGroup(4)
+    G = C*C*C
+    assert G.order() == 64
+    assert G.degree == 12
+    assert len(G.orbits()) == 3
+    assert G.is_abelian is True
+    H = D*C
+    assert H.order() == 32
+    assert H.is_abelian is False
+
+
+def test_orbit_rep():
+    G = DihedralGroup(6)
+    assert G.orbit_rep(1, 3) in [Permutation([2, 3, 4, 5, 0, 1]),
+    Permutation([4, 3, 2, 1, 0, 5])]
+    H = CyclicGroup(4)*G
+    assert H.orbit_rep(1, 5) is False
+
+
+def test_schreier_vector():
+    G = CyclicGroup(50)
+    v = [0]*50
+    v[23] = -1
+    assert G.schreier_vector(23) == v
+    H = DihedralGroup(8)
+    assert H.schreier_vector(2) == [0, 1, -1, 0, 0, 1, 0, 0]
+    L = SymmetricGroup(4)
+    assert L.schreier_vector(1) == [1, -1, 0, 0]
+
+
+def test_random_pr():
+    D = DihedralGroup(6)
+    r = 11
+    n = 3
+    _random_prec_n = {}
+    _random_prec_n[0] = {'s': 7, 't': 3, 'x': 2, 'e': -1}
+    _random_prec_n[1] = {'s': 5, 't': 5, 'x': 1, 'e': -1}
+    _random_prec_n[2] = {'s': 3, 't': 4, 'x': 2, 'e': 1}
+    D._random_pr_init(r, n, _random_prec_n=_random_prec_n)
+    assert D._random_gens[11] == [0, 1, 2, 3, 4, 5]
+    _random_prec = {'s': 2, 't': 9, 'x': 1, 'e': -1}
+    assert D.random_pr(_random_prec=_random_prec) == \
+        Permutation([0, 5, 4, 3, 2, 1])
+
+
+def test_is_alt_sym():
+    G = DihedralGroup(10)
+    assert G.is_alt_sym() is False
+    assert G._eval_is_alt_sym_naive() is False
+    assert G._eval_is_alt_sym_naive(only_alt=True) is False
+    assert G._eval_is_alt_sym_naive(only_sym=True) is False
+
+    S = SymmetricGroup(10)
+    assert S._eval_is_alt_sym_naive() is True
+    assert S._eval_is_alt_sym_naive(only_alt=True) is False
+    assert S._eval_is_alt_sym_naive(only_sym=True) is True
+
+    N_eps = 10
+    _random_prec = {'N_eps': N_eps,
+        0: Permutation([[2], [1, 4], [0, 6, 7, 8, 9, 3, 5]]),
+        1: Permutation([[1, 8, 7, 6, 3, 5, 2, 9], [0, 4]]),
+        2: Permutation([[5, 8], [4, 7], [0, 1, 2, 3, 6, 9]]),
+        3: Permutation([[3], [0, 8, 2, 7, 4, 1, 6, 9, 5]]),
+        4: Permutation([[8], [4, 7, 9], [3, 6], [0, 5, 1, 2]]),
+        5: Permutation([[6], [0, 2, 4, 5, 1, 8, 3, 9, 7]]),
+        6: Permutation([[6, 9, 8], [4, 5], [1, 3, 7], [0, 2]]),
+        7: Permutation([[4], [0, 2, 9, 1, 3, 8, 6, 5, 7]]),
+        8: Permutation([[1, 5, 6, 3], [0, 2, 7, 8, 4, 9]]),
+        9: Permutation([[8], [6, 7], [2, 3, 4, 5], [0, 1, 9]])}
+    assert S.is_alt_sym(_random_prec=_random_prec) is True
+
+    A = AlternatingGroup(10)
+    assert A._eval_is_alt_sym_naive() is True
+    assert A._eval_is_alt_sym_naive(only_alt=True) is True
+    assert A._eval_is_alt_sym_naive(only_sym=True) is False
+
+    _random_prec = {'N_eps': N_eps,
+        0: Permutation([[1, 6, 4, 2, 7, 8, 5, 9, 3], [0]]),
+        1: Permutation([[1], [0, 5, 8, 4, 9, 2, 3, 6, 7]]),
+        2: Permutation([[1, 9, 8, 3, 2, 5], [0, 6, 7, 4]]),
+        3: Permutation([[6, 8, 9], [4, 5], [1, 3, 7, 2], [0]]),
+        4: Permutation([[8], [5], [4], [2, 6, 9, 3], [1], [0, 7]]),
+        5: Permutation([[3, 6], [0, 8, 1, 7, 5, 9, 4, 2]]),
+        6: Permutation([[5], [2, 9], [1, 8, 3], [0, 4, 7, 6]]),
+        7: Permutation([[1, 8, 4, 7, 2, 3], [0, 6, 9, 5]]),
+        8: Permutation([[5, 8, 7], [3], [1, 4, 2, 6], [0, 9]]),
+        9: Permutation([[4, 9, 6], [3, 8], [1, 2], [0, 5, 7]])}
+    assert A.is_alt_sym(_random_prec=_random_prec) is False
+
+    G = PermutationGroup(
+        Permutation(1, 3, size=8)(0, 2, 4, 6),
+        Permutation(5, 7, size=8)(0, 2, 4, 6))
+    assert G.is_alt_sym() is False
+
+    # Tests for monte-carlo c_n parameter setting, and which guarantees
+    # to give False.
+    G = DihedralGroup(10)
+    assert G._eval_is_alt_sym_monte_carlo() is False
+    G = DihedralGroup(20)
+    assert G._eval_is_alt_sym_monte_carlo() is False
+
+    # A dry-running test to check if it looks up for the updated cache.
+    G = DihedralGroup(6)
+    G.is_alt_sym()
+    assert G.is_alt_sym() is False
+
+
+def test_minimal_block():
+    D = DihedralGroup(6)
+    block_system = D.minimal_block([0, 3])
+    for i in range(3):
+        assert block_system[i] == block_system[i + 3]
+    S = SymmetricGroup(6)
+    assert S.minimal_block([0, 1]) == [0, 0, 0, 0, 0, 0]
+
+    assert Tetra.pgroup.minimal_block([0, 1]) == [0, 0, 0, 0]
+
+    P1 = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    P2 = PermutationGroup(Permutation(0, 1, 2, 3, 4, 5), Permutation(1, 5)(2, 4))
+    assert P1.minimal_block([0, 2]) == [0, 1, 0, 1, 0, 1]
+    assert P2.minimal_block([0, 2]) == [0, 1, 0, 1, 0, 1]
+
+
+def test_minimal_blocks():
+    P = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    assert P.minimal_blocks() == [[0, 1, 0, 1, 0, 1], [0, 1, 2, 0, 1, 2]]
+
+    P = SymmetricGroup(5)
+    assert P.minimal_blocks() == [[0]*5]
+
+    P = PermutationGroup(Permutation(0, 3))
+    assert P.minimal_blocks() is False
+
+
+def test_max_div():
+    S = SymmetricGroup(10)
+    assert S.max_div == 5
+
+
+def test_is_primitive():
+    S = SymmetricGroup(5)
+    assert S.is_primitive() is True
+    C = CyclicGroup(7)
+    assert C.is_primitive() is True
+
+    a = Permutation(0, 1, 2, size=6)
+    b = Permutation(3, 4, 5, size=6)
+    G = PermutationGroup(a, b)
+    assert G.is_primitive() is False
+
+
+def test_random_stab():
+    S = SymmetricGroup(5)
+    _random_el = Permutation([1, 3, 2, 0, 4])
+    _random_prec = {'rand': _random_el}
+    g = S.random_stab(2, _random_prec=_random_prec)
+    assert g == Permutation([1, 3, 2, 0, 4])
+    h = S.random_stab(1)
+    assert h(1) == 1
+
+
+def test_transitivity_degree():
+    perm = Permutation([1, 2, 0])
+    C = PermutationGroup([perm])
+    assert C.transitivity_degree == 1
+    gen1 = Permutation([1, 2, 0, 3, 4])
+    gen2 = Permutation([1, 2, 3, 4, 0])
+    # alternating group of degree 5
+    Alt = PermutationGroup([gen1, gen2])
+    assert Alt.transitivity_degree == 3
+
+
+def test_schreier_sims_random():
+    assert sorted(Tetra.pgroup.base) == [0, 1]
+
+    S = SymmetricGroup(3)
+    base = [0, 1]
+    strong_gens = [Permutation([1, 2, 0]), Permutation([1, 0, 2]),
+                  Permutation([0, 2, 1])]
+    assert S.schreier_sims_random(base, strong_gens, 5) == (base, strong_gens)
+    D = DihedralGroup(3)
+    _random_prec = {'g': [Permutation([2, 0, 1]), Permutation([1, 2, 0]),
+                         Permutation([1, 0, 2])]}
+    base = [0, 1]
+    strong_gens = [Permutation([1, 2, 0]), Permutation([2, 1, 0]),
+                  Permutation([0, 2, 1])]
+    assert D.schreier_sims_random([], D.generators, 2,
+           _random_prec=_random_prec) == (base, strong_gens)
+
+
+def test_baseswap():
+    S = SymmetricGroup(4)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    assert base == [0, 1, 2]
+    deterministic = S.baseswap(base, strong_gens, 1, randomized=False)
+    randomized = S.baseswap(base, strong_gens, 1)
+    assert deterministic[0] == [0, 2, 1]
+    assert _verify_bsgs(S, deterministic[0], deterministic[1]) is True
+    assert randomized[0] == [0, 2, 1]
+    assert _verify_bsgs(S, randomized[0], randomized[1]) is True
+
+
+def test_schreier_sims_incremental():
+    identity = Permutation([0, 1, 2, 3, 4])
+    TrivialGroup = PermutationGroup([identity])
+    base, strong_gens = TrivialGroup.schreier_sims_incremental(base=[0, 1, 2])
+    assert _verify_bsgs(TrivialGroup, base, strong_gens) is True
+    S = SymmetricGroup(5)
+    base, strong_gens = S.schreier_sims_incremental(base=[0, 1, 2])
+    assert _verify_bsgs(S, base, strong_gens) is True
+    D = DihedralGroup(2)
+    base, strong_gens = D.schreier_sims_incremental(base=[1])
+    assert _verify_bsgs(D, base, strong_gens) is True
+    A = AlternatingGroup(7)
+    gens = A.generators[:]
+    gen0 = gens[0]
+    gen1 = gens[1]
+    gen1 = rmul(gen1, ~gen0)
+    gen0 = rmul(gen0, gen1)
+    gen1 = rmul(gen0, gen1)
+    base, strong_gens = A.schreier_sims_incremental(base=[0, 1], gens=gens)
+    assert _verify_bsgs(A, base, strong_gens) is True
+    C = CyclicGroup(11)
+    gen = C.generators[0]
+    base, strong_gens = C.schreier_sims_incremental(gens=[gen**3])
+    assert _verify_bsgs(C, base, strong_gens) is True
+
+
+def _subgroup_search(i, j, k):
+    prop_true = lambda x: True
+    prop_fix_points = lambda x: [x(point) for point in points] == points
+    prop_comm_g = lambda x: rmul(x, g) == rmul(g, x)
+    prop_even = lambda x: x.is_even
+    for i in range(i, j, k):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        C = CyclicGroup(i)
+        Sym = S.subgroup_search(prop_true)
+        assert Sym.is_subgroup(S)
+        Alt = S.subgroup_search(prop_even)
+        assert Alt.is_subgroup(A)
+        Sym = S.subgroup_search(prop_true, init_subgroup=C)
+        assert Sym.is_subgroup(S)
+        points = [7]
+        assert S.stabilizer(7).is_subgroup(S.subgroup_search(prop_fix_points))
+        points = [3, 4]
+        assert S.stabilizer(3).stabilizer(4).is_subgroup(
+            S.subgroup_search(prop_fix_points))
+        points = [3, 5]
+        fix35 = A.subgroup_search(prop_fix_points)
+        points = [5]
+        fix5 = A.subgroup_search(prop_fix_points)
+        assert A.subgroup_search(prop_fix_points, init_subgroup=fix35
+            ).is_subgroup(fix5)
+        base, strong_gens = A.schreier_sims_incremental()
+        g = A.generators[0]
+        comm_g = \
+            A.subgroup_search(prop_comm_g, base=base, strong_gens=strong_gens)
+        assert _verify_bsgs(comm_g, base, comm_g.generators) is True
+        assert [prop_comm_g(gen) is True for gen in comm_g.generators]
+
+
+def test_subgroup_search():
+    _subgroup_search(10, 15, 2)
+
+
+@XFAIL
+def test_subgroup_search2():
+    skip('takes too much time')
+    _subgroup_search(16, 17, 1)
+
+
+def test_normal_closure():
+    # the normal closure of the trivial group is trivial
+    S = SymmetricGroup(3)
+    identity = Permutation([0, 1, 2])
+    closure = S.normal_closure(identity)
+    assert closure.is_trivial
+    # the normal closure of the entire group is the entire group
+    A = AlternatingGroup(4)
+    assert A.normal_closure(A).is_subgroup(A)
+    # brute-force verifications for subgroups
+    for i in (3, 4, 5):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        D = DihedralGroup(i)
+        C = CyclicGroup(i)
+        for gp in (A, D, C):
+            assert _verify_normal_closure(S, gp)
+    # brute-force verifications for all elements of a group
+    S = SymmetricGroup(5)
+    elements = list(S.generate_dimino())
+    for element in elements:
+        assert _verify_normal_closure(S, element)
+    # small groups
+    small = []
+    for i in (1, 2, 3):
+        small.append(SymmetricGroup(i))
+        small.append(AlternatingGroup(i))
+        small.append(DihedralGroup(i))
+        small.append(CyclicGroup(i))
+    for gp in small:
+        for gp2 in small:
+            if gp2.is_subgroup(gp, 0) and gp2.degree == gp.degree:
+                assert _verify_normal_closure(gp, gp2)
+
+
+def test_derived_series():
+    # the derived series of the trivial group consists only of the trivial group
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert triv.derived_series()[0].is_subgroup(triv)
+    # the derived series for a simple group consists only of the group itself
+    for i in (5, 6, 7):
+        A = AlternatingGroup(i)
+        assert A.derived_series()[0].is_subgroup(A)
+    # the derived series for S_4 is S_4 > A_4 > K_4 > triv
+    S = SymmetricGroup(4)
+    series = S.derived_series()
+    assert series[1].is_subgroup(AlternatingGroup(4))
+    assert series[2].is_subgroup(DihedralGroup(2))
+    assert series[3].is_trivial
+
+
+def test_lower_central_series():
+    # the lower central series of the trivial group consists of the trivial
+    # group
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert triv.lower_central_series()[0].is_subgroup(triv)
+    # the lower central series of a simple group consists of the group itself
+    for i in (5, 6, 7):
+        A = AlternatingGroup(i)
+        assert A.lower_central_series()[0].is_subgroup(A)
+    # GAP-verified example
+    S = SymmetricGroup(6)
+    series = S.lower_central_series()
+    assert len(series) == 2
+    assert series[1].is_subgroup(AlternatingGroup(6))
+
+
+def test_commutator():
+    # the commutator of the trivial group and the trivial group is trivial
+    S = SymmetricGroup(3)
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert S.commutator(triv, triv).is_subgroup(triv)
+    # the commutator of the trivial group and any other group is again trivial
+    A = AlternatingGroup(3)
+    assert S.commutator(triv, A).is_subgroup(triv)
+    # the commutator is commutative
+    for i in (3, 4, 5):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        D = DihedralGroup(i)
+        assert S.commutator(A, D).is_subgroup(S.commutator(D, A))
+    # the commutator of an abelian group is trivial
+    S = SymmetricGroup(7)
+    A1 = AbelianGroup(2, 5)
+    A2 = AbelianGroup(3, 4)
+    triv = PermutationGroup([Permutation([0, 1, 2, 3, 4, 5, 6])])
+    assert S.commutator(A1, A1).is_subgroup(triv)
+    assert S.commutator(A2, A2).is_subgroup(triv)
+    # examples calculated by hand
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    assert S.commutator(A, S).is_subgroup(A)
+
+
+def test_is_nilpotent():
+    # every abelian group is nilpotent
+    for i in (1, 2, 3):
+        C = CyclicGroup(i)
+        Ab = AbelianGroup(i, i + 2)
+        assert C.is_nilpotent
+        assert Ab.is_nilpotent
+    Ab = AbelianGroup(5, 7, 10)
+    assert Ab.is_nilpotent
+    # A_5 is not solvable and thus not nilpotent
+    assert AlternatingGroup(5).is_nilpotent is False
+
+
+def test_is_trivial():
+    for i in range(5):
+        triv = PermutationGroup([Permutation(list(range(i)))])
+        assert triv.is_trivial
+
+
+def test_pointwise_stabilizer():
+    S = SymmetricGroup(2)
+    stab = S.pointwise_stabilizer([0])
+    assert stab.generators == [Permutation(1)]
+    S = SymmetricGroup(5)
+    points = []
+    stab = S
+    for point in (2, 0, 3, 4, 1):
+        stab = stab.stabilizer(point)
+        points.append(point)
+        assert S.pointwise_stabilizer(points).is_subgroup(stab)
+
+
+def test_make_perm():
+    assert cube.pgroup.make_perm(5, seed=list(range(5))) == \
+        Permutation([4, 7, 6, 5, 0, 3, 2, 1])
+    assert cube.pgroup.make_perm(7, seed=list(range(7))) == \
+        Permutation([6, 7, 3, 2, 5, 4, 0, 1])
+
+
+def test_elements():
+    from sympy.sets.sets import FiniteSet
+
+    p = Permutation(2, 3)
+    assert set(PermutationGroup(p).elements) == {Permutation(3), Permutation(2, 3)}
+    assert FiniteSet(*PermutationGroup(p).elements) \
+        == FiniteSet(Permutation(2, 3), Permutation(3))
+
+
+def test_is_group():
+    assert PermutationGroup(Permutation(1,2), Permutation(2,4)).is_group is True
+    assert SymmetricGroup(4).is_group is True
+
+
+def test_PermutationGroup():
+    assert PermutationGroup() == PermutationGroup(Permutation())
+    assert (PermutationGroup() == 0) is False
+
+
+def test_coset_transvesal():
+    G = AlternatingGroup(5)
+    H = PermutationGroup(Permutation(0,1,2),Permutation(1,2)(3,4))
+    assert G.coset_transversal(H) == \
+        [Permutation(4), Permutation(2, 3, 4), Permutation(2, 4, 3),
+         Permutation(1, 2, 4), Permutation(4)(1, 2, 3), Permutation(1, 3)(2, 4),
+         Permutation(0, 1, 2, 3, 4), Permutation(0, 1, 2, 4, 3),
+         Permutation(0, 1, 3, 2, 4), Permutation(0, 2, 4, 1, 3)]
+
+
+def test_coset_table():
+    G = PermutationGroup(Permutation(0,1,2,3), Permutation(0,1,2),
+         Permutation(0,4,2,7), Permutation(5,6), Permutation(0,7));
+    H = PermutationGroup(Permutation(0,1,2,3), Permutation(0,7))
+    assert G.coset_table(H) == \
+        [[0, 0, 0, 0, 1, 2, 3, 3, 0, 0], [4, 5, 2, 5, 6, 0, 7, 7, 1, 1],
+         [5, 4, 5, 1, 0, 6, 8, 8, 6, 6], [3, 3, 3, 3, 7, 8, 0, 0, 3, 3],
+         [2, 1, 4, 4, 4, 4, 9, 9, 4, 4], [1, 2, 1, 2, 5, 5, 10, 10, 5, 5],
+         [6, 6, 6, 6, 2, 1, 11, 11, 2, 2], [9, 10, 8, 10, 11, 3, 1, 1, 7, 7],
+         [10, 9, 10, 7, 3, 11, 2, 2, 11, 11], [8, 7, 9, 9, 9, 9, 4, 4, 9, 9],
+         [7, 8, 7, 8, 10, 10, 5, 5, 10, 10], [11, 11, 11, 11, 8, 7, 6, 6, 8, 8]]
+
+
+def test_subgroup():
+    G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3))
+    H = G.subgroup([Permutation(0,1,3)])
+    assert H.is_subgroup(G)
+
+
+def test_generator_product():
+    G = SymmetricGroup(5)
+    p = Permutation(0, 2, 3)(1, 4)
+    gens = G.generator_product(p)
+    assert all(g in G.strong_gens for g in gens)
+    w = G.identity
+    for g in gens:
+        w = g*w
+    assert w == p
+
+
+def test_sylow_subgroup():
+    P = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    S = P.sylow_subgroup(2)
+    assert S.order() == 4
+
+    P = DihedralGroup(12)
+    S = P.sylow_subgroup(3)
+    assert S.order() == 3
+
+    P = PermutationGroup(
+        Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5), Permutation(0, 2))
+    S = P.sylow_subgroup(3)
+    assert S.order() == 9
+    S = P.sylow_subgroup(2)
+    assert S.order() == 8
+
+    P = SymmetricGroup(10)
+    S = P.sylow_subgroup(2)
+    assert S.order() == 256
+    S = P.sylow_subgroup(3)
+    assert S.order() == 81
+    S = P.sylow_subgroup(5)
+    assert S.order() == 25
+
+    # the length of the lower central series
+    # of a p-Sylow subgroup of Sym(n) grows with
+    # the highest exponent exp of p such
+    # that n >= p**exp
+    exp = 1
+    length = 0
+    for i in range(2, 9):
+        P = SymmetricGroup(i)
+        S = P.sylow_subgroup(2)
+        ls = S.lower_central_series()
+        if i // 2**exp > 0:
+            # length increases with exponent
+            assert len(ls) > length
+            length = len(ls)
+            exp += 1
+        else:
+            assert len(ls) == length
+
+    G = SymmetricGroup(100)
+    S = G.sylow_subgroup(3)
+    assert G.order() % S.order() == 0
+    assert G.order()/S.order() % 3 > 0
+
+    G = AlternatingGroup(100)
+    S = G.sylow_subgroup(2)
+    assert G.order() % S.order() == 0
+    assert G.order()/S.order() % 2 > 0
+
+    G = DihedralGroup(18)
+    S = G.sylow_subgroup(p=2)
+    assert S.order() == 4
+
+    G = DihedralGroup(50)
+    S = G.sylow_subgroup(p=2)
+    assert S.order() == 4
+
+
+@slow
+def test_presentation():
+    def _test(P):
+        G = P.presentation()
+        return G.order() == P.order()
+
+    def _strong_test(P):
+        G = P.strong_presentation()
+        chk = len(G.generators) == len(P.strong_gens)
+        return chk and G.order() == P.order()
+
+    P = PermutationGroup(Permutation(0,1,5,2)(3,7,4,6), Permutation(0,3,5,4)(1,6,2,7))
+    assert _test(P)
+
+    P = AlternatingGroup(5)
+    assert _test(P)
+
+    P = SymmetricGroup(5)
+    assert _test(P)
+
+    P = PermutationGroup(
+        [Permutation(0,3,1,2), Permutation(3)(0,1), Permutation(0,1)(2,3)])
+    assert _strong_test(P)
+
+    P = DihedralGroup(6)
+    assert _strong_test(P)
+
+    a = Permutation(0,1)(2,3)
+    b = Permutation(0,2)(3,1)
+    c = Permutation(4,5)
+    P = PermutationGroup(c, a, b)
+    assert _strong_test(P)
+
+
+def test_polycyclic():
+    a = Permutation([0, 1, 2])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    assert G.is_polycyclic is True
+
+    a = Permutation([1, 2, 3, 4, 0])
+    b = Permutation([1, 0, 2, 3, 4])
+    G = PermutationGroup([a, b])
+    assert G.is_polycyclic is False
+
+
+def test_elementary():
+    a = Permutation([1, 5, 2, 0, 3, 6, 4])
+    G = PermutationGroup([a])
+    assert G.is_elementary(7) is False
+
+    a = Permutation(0, 1)(2, 3)
+    b = Permutation(0, 2)(3, 1)
+    G = PermutationGroup([a, b])
+    assert G.is_elementary(2) is True
+    c = Permutation(4, 5, 6)
+    G = PermutationGroup([a, b, c])
+    assert G.is_elementary(2) is False
+
+    G = SymmetricGroup(4).sylow_subgroup(2)
+    assert G.is_elementary(2) is False
+    H = AlternatingGroup(4).sylow_subgroup(2)
+    assert H.is_elementary(2) is True
+
+
+def test_perfect():
+    G = AlternatingGroup(3)
+    assert G.is_perfect is False
+    G = AlternatingGroup(5)
+    assert G.is_perfect is True
+
+
+def test_index():
+    G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3))
+    H = G.subgroup([Permutation(0,1,3)])
+    assert G.index(H) == 4
+
+
+def test_cyclic():
+    G = SymmetricGroup(2)
+    assert G.is_cyclic
+    G = AbelianGroup(3, 7)
+    assert G.is_cyclic
+    G = AbelianGroup(7, 7)
+    assert not G.is_cyclic
+    G = AlternatingGroup(3)
+    assert G.is_cyclic
+    G = AlternatingGroup(4)
+    assert not G.is_cyclic
+
+    # Order less than 6
+    G = PermutationGroup(Permutation(0, 1, 2), Permutation(0, 2, 1))
+    assert G.is_cyclic
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(0, 2)(1, 3)
+    )
+    assert G.is_cyclic
+    G = PermutationGroup(
+        Permutation(3),
+        Permutation(0, 1)(2, 3),
+        Permutation(0, 2)(1, 3),
+        Permutation(0, 3)(1, 2)
+    )
+    assert G.is_cyclic is False
+
+    # Order 15
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
+        Permutation(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13)
+    )
+    assert G.is_cyclic
+
+    # Distinct prime orders
+    assert PermutationGroup._distinct_primes_lemma([3, 5]) is True
+    assert PermutationGroup._distinct_primes_lemma([5, 7]) is True
+    assert PermutationGroup._distinct_primes_lemma([2, 3]) is None
+    assert PermutationGroup._distinct_primes_lemma([3, 5, 7]) is None
+    assert PermutationGroup._distinct_primes_lemma([5, 7, 13]) is True
+
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(0, 2)(1, 3))
+    assert G.is_cyclic
+    assert G._is_abelian
+
+    # Non-abelian and therefore not cyclic
+    G = PermutationGroup(*SymmetricGroup(3).generators)
+    assert G.is_cyclic is False
+
+    # Abelian and cyclic
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(4, 5, 6)
+    )
+    assert G.is_cyclic
+
+    # Abelian but not cyclic
+    G = PermutationGroup(
+        Permutation(0, 1),
+        Permutation(2, 3),
+        Permutation(4, 5, 6)
+    )
+    assert G.is_cyclic is False
+
+
+def test_dihedral():
+    G = SymmetricGroup(2)
+    assert G.is_dihedral
+    G = SymmetricGroup(3)
+    assert G.is_dihedral
+
+    G = AbelianGroup(2, 2)
+    assert G.is_dihedral
+    G = CyclicGroup(4)
+    assert not G.is_dihedral
+
+    G = AbelianGroup(3, 5)
+    assert not G.is_dihedral
+    G = AbelianGroup(2)
+    assert G.is_dihedral
+    G = AbelianGroup(6)
+    assert not G.is_dihedral
+
+    # D6, generated by two adjacent flips
+    G = PermutationGroup(
+        Permutation(1, 5)(2, 4),
+        Permutation(0, 1)(3, 4)(2, 5))
+    assert G.is_dihedral
+
+    # D7, generated by a flip and a rotation
+    G = PermutationGroup(
+        Permutation(1, 6)(2, 5)(3, 4),
+        Permutation(0, 1, 2, 3, 4, 5, 6))
+    assert G.is_dihedral
+
+    # S4, presented by three generators, fails due to having exactly 9
+    # elements of order 2:
+    G = PermutationGroup(
+        Permutation(0, 1), Permutation(0, 2),
+        Permutation(0, 3))
+    assert not G.is_dihedral
+
+    # D7, given by three generators
+    G = PermutationGroup(
+        Permutation(1, 6)(2, 5)(3, 4),
+        Permutation(2, 0)(3, 6)(4, 5),
+        Permutation(0, 1, 2, 3, 4, 5, 6))
+    assert G.is_dihedral
+
+
+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]
+    G = PermutationGroup(Permutation(0, 1, 2), Permutation(0, 2, 3))
+    assert G.abelian_invariants() == [3]
+    G = PermutationGroup([Permutation(0, 1), Permutation(0, 2, 4, 6)(1, 3, 5, 7)])
+    assert G.abelian_invariants() == [2, 4]
+    G = SymmetricGroup(30)
+    S = G.sylow_subgroup(2)
+    assert S.abelian_invariants() == [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+    S = G.sylow_subgroup(3)
+    assert S.abelian_invariants() == [3, 3, 3, 3]
+    S = G.sylow_subgroup(5)
+    assert S.abelian_invariants() == [5, 5, 5]
+
+
+def test_composition_series():
+    a = Permutation(1, 2, 3)
+    b = Permutation(1, 2)
+    G = PermutationGroup([a, b])
+    comp_series = G.composition_series()
+    assert comp_series == G.derived_series()
+    # The first group in the composition series is always the group itself and
+    # the last group in the series is the trivial group.
+    S = SymmetricGroup(4)
+    assert S.composition_series()[0] == S
+    assert len(S.composition_series()) == 5
+    A = AlternatingGroup(4)
+    assert A.composition_series()[0] == A
+    assert len(A.composition_series()) == 4
+
+    # the composition series for C_8 is C_8 > C_4 > C_2 > triv
+    G = CyclicGroup(8)
+    series = G.composition_series()
+    assert is_isomorphic(series[1], CyclicGroup(4))
+    assert is_isomorphic(series[2], CyclicGroup(2))
+    assert series[3].is_trivial
+
+
+def test_is_symmetric():
+    a = Permutation(0, 1, 2)
+    b = Permutation(0, 1, size=3)
+    assert PermutationGroup(a, b).is_symmetric is True
+
+    a = Permutation(0, 2, 1)
+    b = Permutation(1, 2, size=3)
+    assert PermutationGroup(a, b).is_symmetric is True
+
+    a = Permutation(0, 1, 2, 3)
+    b = Permutation(0, 3)(1, 2)
+    assert PermutationGroup(a, b).is_symmetric is False
+
+def test_conjugacy_class():
+    S = SymmetricGroup(4)
+    x = Permutation(1, 2, 3)
+    C = {Permutation(0, 1, 2, size = 4), Permutation(0, 1, 3),
+             Permutation(0, 2, 1, size = 4), Permutation(0, 2, 3),
+             Permutation(0, 3, 1), Permutation(0, 3, 2),
+             Permutation(1, 2, 3), Permutation(1, 3, 2)}
+    assert S.conjugacy_class(x) == C
+
+def test_conjugacy_classes():
+    S = SymmetricGroup(3)
+    expected = [{Permutation(size = 3)},
+         {Permutation(0, 1, size = 3), Permutation(0, 2), Permutation(1, 2)},
+         {Permutation(0, 1, 2), Permutation(0, 2, 1)}]
+    computed = S.conjugacy_classes()
+
+    assert len(expected) == len(computed)
+    assert all(e in computed for e in expected)
+
+def test_coset_class():
+    a = Permutation(1, 2)
+    b = Permutation(0, 1)
+    G = PermutationGroup([a, b])
+    #Creating right coset
+    rht_coset = G*a
+    #Checking whether it is left coset or right coset
+    assert rht_coset.is_right_coset
+    assert not rht_coset.is_left_coset
+    #Creating list representation of coset
+    list_repr = rht_coset.as_list()
+    expected = [Permutation(0, 2), Permutation(0, 2, 1), Permutation(1, 2),
+                Permutation(2), Permutation(2)(0, 1), Permutation(0, 1, 2)]
+    for ele in list_repr:
+        assert ele in expected
+    #Creating left coset
+    left_coset = a*G
+    #Checking whether it is left coset or right coset
+    assert not left_coset.is_right_coset
+    assert left_coset.is_left_coset
+    #Creating list representation of Coset
+    list_repr = left_coset.as_list()
+    expected = [Permutation(2)(0, 1), Permutation(0, 1, 2), Permutation(1, 2),
+    Permutation(2), Permutation(0, 2), Permutation(0, 2, 1)]
+    for ele in list_repr:
+        assert ele in expected
+
+    G = PermutationGroup(Permutation(1, 2, 3, 4), Permutation(2, 3, 4))
+    H = PermutationGroup(Permutation(1, 2, 3, 4))
+    g = Permutation(1, 3)(2, 4)
+    rht_coset = Coset(g, H, G, dir='+')
+    assert rht_coset.is_right_coset
+    list_repr = rht_coset.as_list()
+    expected = [Permutation(1, 2, 3, 4), Permutation(4), Permutation(1, 3)(2, 4),
+    Permutation(1, 4, 3, 2)]
+    for ele in list_repr:
+        assert ele in expected
+
+def test_symmetricpermutationgroup():
+    a = SymmetricPermutationGroup(5)
+    assert a.degree == 5
+    assert a.order() == 120
+    assert a.identity() == Permutation(4)