Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.bz2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f2af67ea667c1f5315ddcab06bfa447005863c1c0fd88bb7e04a0b8acb9a54b
+size 1021

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py34_np19.pkl.xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04d7e68907e978b56975f9309492b8849e42a60974beb795c9e93273977f3cd3
+size 752

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.10.0_pickle_py35_np19.pkl.xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02cf30d8b196c303662b2dd035d2a58caeb762ae3a82345ffd1274961e7f5aa0
+size 752

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py33_np18.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3d4cbc690d3ce9e5323a714ea546f32c01ab1710285c420184f6cdf4b26fc25
+size 691

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py33_np18.pkl_02.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c1cf36cb781fbcc21b953bb0a0b45df092da0eae0e765882e5963ccd70105b1
+size 120

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py33_np18.pkl_04.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ecbe244294ba93e08479b16c1b9a9411e3569ff660ed0459dca1d241381df05
+size 104

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py34_np19.pkl_03.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ede9a64a52b25d7db30950956c978ec0b3932b7d14acd5abc63216e64babde7
+size 307

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py35_np19.pkl_02.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c1cf36cb781fbcc21b953bb0a0b45df092da0eae0e765882e5963ccd70105b1
+size 120

env-llmeval/lib/python3.10/site-packages/joblib/test/data/joblib_0.9.2_pickle_py35_np19.pkl_04.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ecbe244294ba93e08479b16c1b9a9411e3569ff660ed0459dca1d241381df05
+size 104

env-llmeval/lib/python3.10/site-packages/sympy/calculus/tests/test_euler.py

@@ -0,0 +1,74 @@
+from sympy.core.function import (Derivative as D, Function)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import raises
+from sympy.calculus.euler import euler_equations as euler
+
+
+def test_euler_interface():
+    x = Function('x')
+    y = Symbol('y')
+    t = Symbol('t')
+    raises(TypeError, lambda: euler())
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [x(t), y]))
+    raises(ValueError, lambda: euler(D(x(t), t)*x(y), [x(t), x(y)]))
+    raises(TypeError, lambda: euler(D(x(t), t)**2, x(0)))
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [t]))
+    assert euler(D(x(t), t)**2/2, {x(t)}) == [Eq(-D(x(t), t, t), 0)]
+    assert euler(D(x(t), t)**2/2, x(t), {t}) == [Eq(-D(x(t), t, t), 0)]
+
+
+def test_euler_pendulum():
+    x = Function('x')
+    t = Symbol('t')
+    L = D(x(t), t)**2/2 + cos(x(t))
+    assert euler(L, x(t), t) == [Eq(-sin(x(t)) - D(x(t), t, t), 0)]
+
+
+def test_euler_henonheiles():
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = sum(D(z(t), t)**2/2 - z(t)**2/2 for z in [x, y])
+    L += -x(t)**2*y(t) + y(t)**3/3
+    assert euler(L, [x(t), y(t)], t) == [Eq(-2*x(t)*y(t) - x(t) -
+                                            D(x(t), t, t), 0),
+                                         Eq(-x(t)**2 + y(t)**2 -
+                                            y(t) - D(y(t), t, t), 0)]
+
+
+def test_euler_sineg():
+    psi = Function('psi')
+    t = Symbol('t')
+    x = Symbol('x')
+    L = D(psi(t, x), t)**2/2 - D(psi(t, x), x)**2/2 + cos(psi(t, x))
+    assert euler(L, psi(t, x), [t, x]) == [Eq(-sin(psi(t, x)) -
+                                              D(psi(t, x), t, t) +
+                                              D(psi(t, x), x, x), 0)]
+
+
+def test_euler_high_order():
+    # an example from hep-th/0309038
+    m = Symbol('m')
+    k = Symbol('k')
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = (m*D(x(t), t)**2/2 + m*D(y(t), t)**2/2 -
+         k*D(x(t), t)*D(y(t), t, t) + k*D(y(t), t)*D(x(t), t, t))
+    assert euler(L, [x(t), y(t)]) == [Eq(2*k*D(y(t), t, t, t) -
+                                         m*D(x(t), t, t), 0),
+                                      Eq(-2*k*D(x(t), t, t, t) -
+                                         m*D(y(t), t, t), 0)]
+
+    w = Symbol('w')
+    L = D(x(t, w), t, w)**2/2
+    assert euler(L) == [Eq(D(x(t, w), t, t, w, w), 0)]
+
+def test_issue_18653():
+    x, y, z = symbols("x y z")
+    f, g, h = symbols("f g h", cls=Function, args=(x, y))
+    f, g, h = f(), g(), h()
+    expr2 = f.diff(x)*h.diff(z)
+    assert euler(expr2, (f,), (x, y)) == []

env-llmeval/lib/python3.10/site-packages/sympy/calculus/tests/test_singularities.py

@@ -0,0 +1,103 @@
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.calculus.singularities import (
+    singularities,
+    is_increasing,
+    is_strictly_increasing,
+    is_decreasing,
+    is_strictly_decreasing,
+    is_monotonic
+)
+from sympy.sets import Interval, FiniteSet
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+
+def test_singularities():
+    x = Symbol('x')
+    assert singularities(x**2, x) == S.EmptySet
+    assert singularities(x/(x**2 + 3*x + 2), x) == FiniteSet(-2, -1)
+    assert singularities(1/(x**2 + 1), x) == FiniteSet(I, -I)
+    assert singularities(x/(x**3 + 1), x) == \
+        FiniteSet(-1, (1 - sqrt(3) * I) / 2, (1 + sqrt(3) * I) / 2)
+    assert singularities(1/(y**2 + 2*I*y + 1), y) == \
+        FiniteSet(-I + sqrt(2)*I, -I - sqrt(2)*I)
+
+    x = Symbol('x', real=True)
+    assert singularities(1/(x**2 + 1), x) == S.EmptySet
+    assert singularities(exp(1/x), x, S.Reals) == FiniteSet(0)
+    assert singularities(exp(1/x), x, Interval(1, 2)) == S.EmptySet
+    assert singularities(log((x - 2)**2), x, Interval(1, 3)) == FiniteSet(2)
+    raises(NotImplementedError, lambda: singularities(x**-oo, x))
+
+
+def test_is_increasing():
+    """Test whether is_increasing returns correct value."""
+    a = Symbol('a', negative=True)
+
+    assert is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert is_increasing(-x**2, Interval(-oo, 0))
+    assert not is_increasing(-x**2, Interval(0, oo))
+    assert not is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    assert is_increasing(x**2 + y, Interval(1, oo), x)
+    assert is_increasing(-x**2*a, Interval(1, oo), x)
+    assert is_increasing(1)
+
+    assert is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3)) is False
+
+
+def test_is_strictly_increasing():
+    """Test whether is_strictly_increasing returns correct value."""
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    assert not is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    assert not is_strictly_increasing(-x**2, Interval(0, oo))
+    assert not is_strictly_decreasing(1)
+
+    assert is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3)) is False
+
+
+def test_is_decreasing():
+    """Test whether is_decreasing returns correct value."""
+    b = Symbol('b', positive=True)
+
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_decreasing(-x**2*b, Interval(-oo, 0), x)
+
+
+def test_is_strictly_decreasing():
+    """Test whether is_strictly_decreasing returns correct value."""
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_strictly_decreasing(
+        1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_strictly_decreasing(1)
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+
+
+def test_is_monotonic():
+    """Test whether is_monotonic returns correct value."""
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert not is_monotonic(-x**2, S.Reals)
+    assert is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    raises(NotImplementedError, lambda: is_monotonic(x**2 + y + 1))
+
+
+def test_issue_23401():
+    x = Symbol('x')
+    expr = (x + 1)/(-1.0e-3*x**2 + 0.1*x + 0.1)
+    assert is_increasing(expr, Interval(1,2), x)

env-llmeval/lib/python3.10/site-packages/sympy/combinatorics/__init__.py

@@ -0,0 +1,43 @@
+from sympy.combinatorics.permutations import Permutation, Cycle
+from sympy.combinatorics.prufer import Prufer
+from sympy.combinatorics.generators import cyclic, alternating, symmetric, dihedral
+from sympy.combinatorics.subsets import Subset
+from sympy.combinatorics.partitions import (Partition, IntegerPartition,
+    RGS_rank, RGS_unrank, RGS_enum)
+from sympy.combinatorics.polyhedron import (Polyhedron, tetrahedron, cube,
+    octahedron, dodecahedron, icosahedron)
+from sympy.combinatorics.perm_groups import PermutationGroup, Coset, SymmetricPermutationGroup
+from sympy.combinatorics.group_constructs import DirectProduct
+from sympy.combinatorics.graycode import GrayCode
+from sympy.combinatorics.named_groups import (SymmetricGroup, DihedralGroup,
+    CyclicGroup, AlternatingGroup, AbelianGroup, RubikGroup)
+from sympy.combinatorics.pc_groups import PolycyclicGroup, Collector
+from sympy.combinatorics.free_groups import free_group
+
+__all__ = [
+    'Permutation', 'Cycle',
+
+    'Prufer',
+
+    'cyclic', 'alternating', 'symmetric', 'dihedral',
+
+    'Subset',
+
+    'Partition', 'IntegerPartition', 'RGS_rank', 'RGS_unrank', 'RGS_enum',
+
+    'Polyhedron', 'tetrahedron', 'cube', 'octahedron', 'dodecahedron',
+    'icosahedron',
+
+    'PermutationGroup', 'Coset', 'SymmetricPermutationGroup',
+
+    'DirectProduct',
+
+    'GrayCode',
+
+    'SymmetricGroup', 'DihedralGroup', 'CyclicGroup', 'AlternatingGroup',
+    'AbelianGroup', 'RubikGroup',
+
+    'PolycyclicGroup', 'Collector',
+
+    'free_group',
+]

env-llmeval/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

env-llmeval/lib/python3.10/site-packages/sympy/combinatorics/fp_groups.py

@@ -0,0 +1,1348 @@
+"""Finitely Presented Groups and its algorithms. """
+
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.combinatorics.free_groups import (FreeGroup, FreeGroupElement,
+                                                free_group)
+from sympy.combinatorics.rewritingsystem import RewritingSystem
+from sympy.combinatorics.coset_table import (CosetTable,
+                                             coset_enumeration_r,
+                                             coset_enumeration_c)
+from sympy.combinatorics import PermutationGroup
+from sympy.matrices.normalforms import invariant_factors
+from sympy.matrices import Matrix
+from sympy.polys.polytools import gcd
+from sympy.printing.defaults import DefaultPrinting
+from sympy.utilities import public
+from sympy.utilities.magic import pollute
+
+from itertools import product
+
+
+@public
+def fp_group(fr_grp, relators=()):
+    _fp_group = FpGroup(fr_grp, relators)
+    return (_fp_group,) + tuple(_fp_group._generators)
+
+@public
+def xfp_group(fr_grp, relators=()):
+    _fp_group = FpGroup(fr_grp, relators)
+    return (_fp_group, _fp_group._generators)
+
+# Does not work. Both symbols and pollute are undefined. Never tested.
+@public
+def vfp_group(fr_grpm, relators):
+    _fp_group = FpGroup(symbols, relators)
+    pollute([sym.name for sym in _fp_group.symbols], _fp_group.generators)
+    return _fp_group
+
+
+def _parse_relators(rels):
+    """Parse the passed relators."""
+    return rels
+
+
+###############################################################################
+#                           FINITELY PRESENTED GROUPS                         #
+###############################################################################
+
+
+class FpGroup(DefaultPrinting):
+    """
+    The FpGroup would take a FreeGroup and a list/tuple of relators, the
+    relators would be specified in such a way that each of them be equal to the
+    identity of the provided free group.
+
+    """
+    is_group = True
+    is_FpGroup = True
+    is_PermutationGroup = False
+
+    def __init__(self, fr_grp, relators):
+        relators = _parse_relators(relators)
+        self.free_group = fr_grp
+        self.relators = relators
+        self.generators = self._generators()
+        self.dtype = type("FpGroupElement", (FpGroupElement,), {"group": self})
+
+        # CosetTable instance on identity subgroup
+        self._coset_table = None
+        # returns whether coset table on identity subgroup
+        # has been standardized
+        self._is_standardized = False
+
+        self._order = None
+        self._center = None
+
+        self._rewriting_system = RewritingSystem(self)
+        self._perm_isomorphism = None
+        return
+
+    def _generators(self):
+        return self.free_group.generators
+
+    def make_confluent(self):
+        '''
+        Try to make the group's rewriting system confluent
+
+        '''
+        self._rewriting_system.make_confluent()
+        return
+
+    def reduce(self, word):
+        '''
+        Return the reduced form of `word` in `self` according to the group's
+        rewriting system. If it's confluent, the reduced form is the unique normal
+        form of the word in the group.
+
+        '''
+        return self._rewriting_system.reduce(word)
+
+    def equals(self, word1, word2):
+        '''
+        Compare `word1` and `word2` for equality in the group
+        using the group's rewriting system. If the system is
+        confluent, the returned answer is necessarily correct.
+        (If it is not, `False` could be returned in some cases
+        where in fact `word1 == word2`)
+
+        '''
+        if self.reduce(word1*word2**-1) == self.identity:
+            return True
+        elif self._rewriting_system.is_confluent:
+            return False
+        return None
+
+    @property
+    def identity(self):
+        return self.free_group.identity
+
+    def __contains__(self, g):
+        return g in self.free_group
+
+    def subgroup(self, gens, C=None, homomorphism=False):
+        '''
+        Return the subgroup generated by `gens` using the
+        Reidemeister-Schreier algorithm
+        homomorphism -- When set to True, return a dictionary containing the images
+                     of the presentation generators in the original group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.fp_groups import FpGroup
+        >>> from sympy.combinatorics import free_group
+        >>> 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]
+        >>> K, T = f.subgroup(H, homomorphism=True)
+        >>> T(K.generators)
+        [x*y, x**-1*y**2*x**-1]
+
+        '''
+
+        if not all(isinstance(g, FreeGroupElement) for g in gens):
+            raise ValueError("Generators must be `FreeGroupElement`s")
+        if not all(g.group == self.free_group for g in gens):
+                raise ValueError("Given generators are not members of the group")
+        if homomorphism:
+            g, rels, _gens = reidemeister_presentation(self, gens, C=C, homomorphism=True)
+        else:
+            g, rels = reidemeister_presentation(self, gens, C=C)
+        if g:
+            g = FpGroup(g[0].group, rels)
+        else:
+            g = FpGroup(free_group('')[0], [])
+        if homomorphism:
+            from sympy.combinatorics.homomorphisms import homomorphism
+            return g, homomorphism(g, self, g.generators, _gens, check=False)
+        return g
+
+    def coset_enumeration(self, H, strategy="relator_based", max_cosets=None,
+                                                        draft=None, incomplete=False):
+        """
+        Return an instance of ``coset table``, when Todd-Coxeter algorithm is
+        run over the ``self`` with ``H`` as subgroup, using ``strategy``
+        argument as strategy. The returned coset table is compressed but not
+        standardized.
+
+        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.
+
+        """
+        if not max_cosets:
+            max_cosets = CosetTable.coset_table_max_limit
+        if strategy == 'relator_based':
+            C = coset_enumeration_r(self, H, max_cosets=max_cosets,
+                                                    draft=draft, incomplete=incomplete)
+        else:
+            C = coset_enumeration_c(self, H, max_cosets=max_cosets,
+                                                    draft=draft, incomplete=incomplete)
+        if C.is_complete():
+            C.compress()
+        return C
+
+    def standardize_coset_table(self):
+        """
+        Standardized the coset table ``self`` and makes the internal variable
+        ``_is_standardized`` equal to ``True``.
+
+        """
+        self._coset_table.standardize()
+        self._is_standardized = True
+
+    def coset_table(self, H, strategy="relator_based", max_cosets=None,
+                                                 draft=None, incomplete=False):
+        """
+        Return the mathematical coset table of ``self`` in ``H``.
+
+        """
+        if not H:
+            if self._coset_table is not None:
+                if not self._is_standardized:
+                    self.standardize_coset_table()
+            else:
+                C = self.coset_enumeration([], strategy, max_cosets=max_cosets,
+                                            draft=draft, incomplete=incomplete)
+                self._coset_table = C
+                self.standardize_coset_table()
+            return self._coset_table.table
+        else:
+            C = self.coset_enumeration(H, strategy, max_cosets=max_cosets,
+                                            draft=draft, incomplete=incomplete)
+            C.standardize()
+            return C.table
+
+    def order(self, strategy="relator_based"):
+        """
+        Returns the order of the finitely presented group ``self``. It uses
+        the coset enumeration with identity group as subgroup, i.e ``H=[]``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup
+        >>> F, x, y = free_group("x, y")
+        >>> f = FpGroup(F, [x, y**2])
+        >>> f.order(strategy="coset_table_based")
+        2
+
+        """
+        if self._order is not None:
+            return self._order
+        if self._coset_table is not None:
+            self._order = len(self._coset_table.table)
+        elif len(self.relators) == 0:
+            self._order = self.free_group.order()
+        elif len(self.generators) == 1:
+            self._order = abs(gcd([r.array_form[0][1] for r in self.relators]))
+        elif self._is_infinite():
+            self._order = S.Infinity
+        else:
+            gens, C = self._finite_index_subgroup()
+            if C:
+                ind = len(C.table)
+                self._order = ind*self.subgroup(gens, C=C).order()
+            else:
+                self._order = self.index([])
+        return self._order
+
+    def _is_infinite(self):
+        '''
+        Test if the group is infinite. Return `True` if the test succeeds
+        and `None` otherwise
+
+        '''
+        used_gens = set()
+        for r in self.relators:
+            used_gens.update(r.contains_generators())
+        if not set(self.generators) <= used_gens:
+            return True
+        # Abelianisation test: check is the abelianisation is infinite
+        abelian_rels = []
+        for rel in self.relators:
+            abelian_rels.append([rel.exponent_sum(g) for g in self.generators])
+        m = Matrix(Matrix(abelian_rels))
+        if 0 in invariant_factors(m):
+            return True
+        else:
+            return None
+
+
+    def _finite_index_subgroup(self, s=None):
+        '''
+        Find the elements of `self` that generate a finite index subgroup
+        and, if found, return the list of elements and the coset table of `self` by
+        the subgroup, otherwise return `(None, None)`
+
+        '''
+        gen = self.most_frequent_generator()
+        rels = list(self.generators)
+        rels.extend(self.relators)
+        if not s:
+            if len(self.generators) == 2:
+                s = [gen] + [g for g in self.generators if g != gen]
+            else:
+                rand = self.free_group.identity
+                i = 0
+                while ((rand in rels or rand**-1 in rels or rand.is_identity)
+                        and i<10):
+                    rand = self.random()
+                    i += 1
+                s = [gen, rand] + [g for g in self.generators if g != gen]
+        mid = (len(s)+1)//2
+        half1 = s[:mid]
+        half2 = s[mid:]
+        draft1 = None
+        draft2 = None
+        m = 200
+        C = None
+        while not C and (m/2 < CosetTable.coset_table_max_limit):
+            m = min(m, CosetTable.coset_table_max_limit)
+            draft1 = self.coset_enumeration(half1, max_cosets=m,
+                                 draft=draft1, incomplete=True)
+            if draft1.is_complete():
+                C = draft1
+                half = half1
+            else:
+                draft2 = self.coset_enumeration(half2, max_cosets=m,
+                                 draft=draft2, incomplete=True)
+                if draft2.is_complete():
+                    C = draft2
+                    half = half2
+            if not C:
+                m *= 2
+        if not C:
+            return None, None
+        C.compress()
+        return half, C
+
+    def most_frequent_generator(self):
+        gens = self.generators
+        rels = self.relators
+        freqs = [sum([r.generator_count(g) for r in rels]) for g in gens]
+        return gens[freqs.index(max(freqs))]
+
+    def random(self):
+        import random
+        r = self.free_group.identity
+        for i in range(random.randint(2,3)):
+            r = r*random.choice(self.generators)**random.choice([1,-1])
+        return r
+
+    def index(self, H, strategy="relator_based"):
+        """
+        Return the index of subgroup ``H`` in group ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup
+        >>> F, x, y = free_group("x, y")
+        >>> f = FpGroup(F, [x**5, y**4, y*x*y**3*x**3])
+        >>> f.index([x])
+        4
+
+        """
+        # TODO: use |G:H| = |G|/|H| (currently H can't be made into a group)
+        # when we know |G| and |H|
+
+        if H == []:
+            return self.order()
+        else:
+            C = self.coset_enumeration(H, strategy)
+            return len(C.table)
+
+    def __str__(self):
+        if self.free_group.rank > 30:
+            str_form = "<fp group with %s generators>" % self.free_group.rank
+        else:
+            str_form = "<fp group on the generators %s>" % str(self.generators)
+        return str_form
+
+    __repr__ = __str__
+
+#==============================================================================
+#                       PERMUTATION GROUP METHODS
+#==============================================================================
+
+    def _to_perm_group(self):
+        '''
+        Return an isomorphic permutation group and the isomorphism.
+        The implementation is dependent on coset enumeration so
+        will only terminate for finite groups.
+
+        '''
+        from sympy.combinatorics import Permutation
+        from sympy.combinatorics.homomorphisms import homomorphism
+        if self.order() is S.Infinity:
+            raise NotImplementedError("Permutation presentation of infinite "
+                                                  "groups is not implemented")
+        if self._perm_isomorphism:
+            T = self._perm_isomorphism
+            P = T.image()
+        else:
+            C = self.coset_table([])
+            gens = self.generators
+            images = [[C[i][2*gens.index(g)] for i in range(len(C))] for g in gens]
+            images = [Permutation(i) for i in images]
+            P = PermutationGroup(images)
+            T = homomorphism(self, P, gens, images, check=False)
+            self._perm_isomorphism = T
+        return P, T
+
+    def _perm_group_list(self, method_name, *args):
+        '''
+        Given the name of a `PermutationGroup` method (returning a subgroup
+        or a list of subgroups) and (optionally) additional arguments it takes,
+        return a list or a list of lists containing the generators of this (or
+        these) subgroups in terms of the generators of `self`.
+
+        '''
+        P, T = self._to_perm_group()
+        perm_result = getattr(P, method_name)(*args)
+        single = False
+        if isinstance(perm_result, PermutationGroup):
+            perm_result, single = [perm_result], True
+        result = []
+        for group in perm_result:
+            gens = group.generators
+            result.append(T.invert(gens))
+        return result[0] if single else result
+
+    def derived_series(self):
+        '''
+        Return the list of lists containing the generators
+        of the subgroups in the derived series of `self`.
+
+        '''
+        return self._perm_group_list('derived_series')
+
+    def lower_central_series(self):
+        '''
+        Return the list of lists containing the generators
+        of the subgroups in the lower central series of `self`.
+
+        '''
+        return self._perm_group_list('lower_central_series')
+
+    def center(self):
+        '''
+        Return the list of generators of the center of `self`.
+
+        '''
+        return self._perm_group_list('center')
+
+
+    def derived_subgroup(self):
+        '''
+        Return the list of generators of the derived subgroup of `self`.
+
+        '''
+        return self._perm_group_list('derived_subgroup')
+
+
+    def centralizer(self, other):
+        '''
+        Return the list of generators of the centralizer of `other`
+        (a list of elements of `self`) in `self`.
+
+        '''
+        T = self._to_perm_group()[1]
+        other = T(other)
+        return self._perm_group_list('centralizer', other)
+
+    def normal_closure(self, other):
+        '''
+        Return the list of generators of the normal closure of `other`
+        (a list of elements of `self`) in `self`.
+
+        '''
+        T = self._to_perm_group()[1]
+        other = T(other)
+        return self._perm_group_list('normal_closure', other)
+
+    def _perm_property(self, attr):
+        '''
+        Given an attribute of a `PermutationGroup`, return
+        its value for a permutation group isomorphic to `self`.
+
+        '''
+        P = self._to_perm_group()[0]
+        return getattr(P, attr)
+
+    @property
+    def is_abelian(self):
+        '''
+        Check if `self` is abelian.
+
+        '''
+        return self._perm_property("is_abelian")
+
+    @property
+    def is_nilpotent(self):
+        '''
+        Check if `self` is nilpotent.
+
+        '''
+        return self._perm_property("is_nilpotent")
+
+    @property
+    def is_solvable(self):
+        '''
+        Check if `self` is solvable.
+
+        '''
+        return self._perm_property("is_solvable")
+
+    @property
+    def elements(self):
+        '''
+        List the elements of `self`.
+
+        '''
+        P, T = self._to_perm_group()
+        return T.invert(P._elements)
+
+    @property
+    def is_cyclic(self):
+        """
+        Return ``True`` if group is Cyclic.
+
+        """
+        if len(self.generators) <= 1:
+            return True
+        try:
+            P, T = self._to_perm_group()
+        except NotImplementedError:
+            raise NotImplementedError("Check for infinite Cyclic group "
+                                      "is not implemented")
+        return P.is_cyclic
+
+    def abelian_invariants(self):
+        """
+        Return Abelian Invariants of a group.
+        """
+        try:
+            P, T = self._to_perm_group()
+        except NotImplementedError:
+            raise NotImplementedError("abelian invariants is not implemented"
+                                      "for infinite group")
+        return P.abelian_invariants()
+
+    def composition_series(self):
+        """
+        Return subnormal series of maximum length for a group.
+        """
+        try:
+            P, T = self._to_perm_group()
+        except NotImplementedError:
+            raise NotImplementedError("composition series is not implemented"
+                                      "for infinite group")
+        return P.composition_series()
+
+
+class FpSubgroup(DefaultPrinting):
+    '''
+    The class implementing a subgroup of an FpGroup or a FreeGroup
+    (only finite index subgroups are supported at this point). This
+    is to be used if one wishes to check if an element of the original
+    group belongs to the subgroup
+
+    '''
+    def __init__(self, G, gens, normal=False):
+        super().__init__()
+        self.parent = G
+        self.generators = list({g for g in gens if g != G.identity})
+        self._min_words = None #for use in __contains__
+        self.C = None
+        self.normal = normal
+
+    def __contains__(self, g):
+
+        if isinstance(self.parent, FreeGroup):
+            if self._min_words is None:
+                # make _min_words - a list of subwords such that
+                # g is in the subgroup if and only if it can be
+                # partitioned into these subwords. Infinite families of
+                # subwords are presented by tuples, e.g. (r, w)
+                # stands for the family of subwords r*w**n*r**-1
+
+                def _process(w):
+                    # this is to be used before adding new words
+                    # into _min_words; if the word w is not cyclically
+                    # reduced, it will generate an infinite family of
+                    # subwords so should be written as a tuple;
+                    # if it is, w**-1 should be added to the list
+                    # as well
+                    p, r = w.cyclic_reduction(removed=True)
+                    if not r.is_identity:
+                        return [(r, p)]
+                    else:
+                        return [w, w**-1]
+
+                # make the initial list
+                gens = []
+                for w in self.generators:
+                    if self.normal:
+                        w = w.cyclic_reduction()
+                    gens.extend(_process(w))
+
+                for w1 in gens:
+                    for w2 in gens:
+                        # if w1 and w2 are equal or are inverses, continue
+                        if w1 == w2 or (not isinstance(w1, tuple)
+                                                        and w1**-1 == w2):
+                            continue
+
+                        # if the start of one word is the inverse of the
+                        # end of the other, their multiple should be added
+                        # to _min_words because of cancellation
+                        if isinstance(w1, tuple):
+                            # start, end
+                            s1, s2 = w1[0][0], w1[0][0]**-1
+                        else:
+                            s1, s2 = w1[0], w1[len(w1)-1]
+
+                        if isinstance(w2, tuple):
+                            # start, end
+                            r1, r2 = w2[0][0], w2[0][0]**-1
+                        else:
+                            r1, r2 = w2[0], w2[len(w1)-1]
+
+                        # p1 and p2 are w1 and w2 or, in case when
+                        # w1 or w2 is an infinite family, a representative
+                        p1, p2 = w1, w2
+                        if isinstance(w1, tuple):
+                            p1 = w1[0]*w1[1]*w1[0]**-1
+                        if isinstance(w2, tuple):
+                            p2 = w2[0]*w2[1]*w2[0]**-1
+
+                        # add the product of the words to the list is necessary
+                        if r1**-1 == s2 and not (p1*p2).is_identity:
+                            new = _process(p1*p2)
+                            if new not in gens:
+                                gens.extend(new)
+
+                        if r2**-1 == s1 and not (p2*p1).is_identity:
+                            new = _process(p2*p1)
+                            if new not in gens:
+                                gens.extend(new)
+
+                self._min_words = gens
+
+            min_words = self._min_words
+
+            def _is_subword(w):
+                # check if w is a word in _min_words or one of
+                # the infinite families in it
+                w, r = w.cyclic_reduction(removed=True)
+                if r.is_identity or self.normal:
+                    return w in min_words
+                else:
+                    t = [s[1] for s in min_words if isinstance(s, tuple)
+                                                                and s[0] == r]
+                    return [s for s in t if w.power_of(s)] != []
+
+            # store the solution of words for which the result of
+            # _word_break (below) is known
+            known = {}
+
+            def _word_break(w):
+                # check if w can be written as a product of words
+                # in min_words
+                if len(w) == 0:
+                    return True
+                i = 0
+                while i < len(w):
+                    i += 1
+                    prefix = w.subword(0, i)
+                    if not _is_subword(prefix):
+                        continue
+                    rest = w.subword(i, len(w))
+                    if rest not in known:
+                        known[rest] = _word_break(rest)
+                    if known[rest]:
+                        return True
+                return False
+
+            if self.normal:
+                g = g.cyclic_reduction()
+            return _word_break(g)
+        else:
+            if self.C is None:
+                C = self.parent.coset_enumeration(self.generators)
+                self.C = C
+            i = 0
+            C = self.C
+            for j in range(len(g)):
+                i = C.table[i][C.A_dict[g[j]]]
+            return i == 0
+
+    def order(self):
+        if not self.generators:
+            return S.One
+        if isinstance(self.parent, FreeGroup):
+            return S.Infinity
+        if self.C is None:
+            C = self.parent.coset_enumeration(self.generators)
+            self.C = C
+        # This is valid because `len(self.C.table)` (the index of the subgroup)
+        # will always be finite - otherwise coset enumeration doesn't terminate
+        return self.parent.order()/len(self.C.table)
+
+    def to_FpGroup(self):
+        if isinstance(self.parent, FreeGroup):
+            gen_syms = [('x_%d'%i) for i in range(len(self.generators))]
+            return free_group(', '.join(gen_syms))[0]
+        return self.parent.subgroup(C=self.C)
+
+    def __str__(self):
+        if len(self.generators) > 30:
+            str_form = "<fp subgroup with %s generators>" % len(self.generators)
+        else:
+            str_form = "<fp subgroup on the generators %s>" % str(self.generators)
+        return str_form
+
+    __repr__ = __str__
+
+
+###############################################################################
+#                           LOW INDEX SUBGROUPS                               #
+###############################################################################
+
+def low_index_subgroups(G, N, Y=()):
+    """
+    Implements the Low Index Subgroups algorithm, i.e find all subgroups of
+    ``G`` upto a given index ``N``. This implements the method described in
+    [Sim94]. This procedure involves a backtrack search over incomplete Coset
+    Tables, rather than over forced coincidences.
+
+    Parameters
+    ==========
+
+    G: An FpGroup < X|R >
+    N: positive integer, representing the maximum index value for subgroups
+    Y: (an optional argument) specifying a list of subgroup generators, such
+    that each of the resulting subgroup contains the subgroup generated by Y.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, low_index_subgroups
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**4])
+    >>> L = low_index_subgroups(f, 4)
+    >>> for coset_table in L:
+    ...     print(coset_table.table)
+    [[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]]
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of Computational Group Theory"
+           Section 5.4
+
+    .. [2] Marston Conder and Peter Dobcsanyi
+           "Applications and Adaptions of the Low Index Subgroups Procedure"
+
+    """
+    C = CosetTable(G, [])
+    R = G.relators
+    # length chosen for the length of the short relators
+    len_short_rel = 5
+    # elements of R2 only checked at the last step for complete
+    # coset tables
+    R2 = {rel for rel in R if len(rel) > len_short_rel}
+    # elements of R1 are used in inner parts of the process to prune
+    # branches of the search tree,
+    R1 = {rel.identity_cyclic_reduction() for rel in set(R) - R2}
+    R1_c_list = C.conjugates(R1)
+    S = []
+    descendant_subgroups(S, C, R1_c_list, C.A[0], R2, N, Y)
+    return S
+
+
+def descendant_subgroups(S, C, R1_c_list, x, R2, N, Y):
+    A_dict = C.A_dict
+    A_dict_inv = C.A_dict_inv
+    if C.is_complete():
+        # if C is complete then it only needs to test
+        # whether the relators in R2 are satisfied
+        for w, alpha in product(R2, C.omega):
+            if not C.scan_check(alpha, w):
+                return
+        # relators in R2 are satisfied, append the table to list
+        S.append(C)
+    else:
+        # find the first undefined entry in Coset Table
+        for alpha, x in product(range(len(C.table)), C.A):
+            if C.table[alpha][A_dict[x]] is None:
+                # this is "x" in pseudo-code (using "y" makes it clear)
+                undefined_coset, undefined_gen = alpha, x
+                break
+        # for filling up the undefine entry we try all possible values
+        # of beta in Omega or beta = n where beta^(undefined_gen^-1) is undefined
+        reach = C.omega + [C.n]
+        for beta in reach:
+            if beta < N:
+                if beta == C.n or C.table[beta][A_dict_inv[undefined_gen]] is None:
+                    try_descendant(S, C, R1_c_list, R2, N, undefined_coset, \
+                            undefined_gen, beta, Y)
+
+
+def try_descendant(S, C, R1_c_list, R2, N, alpha, x, beta, Y):
+    r"""
+    Solves the problem of trying out each individual possibility
+    for `\alpha^x.
+
+    """
+    D = C.copy()
+    if beta == D.n and beta < N:
+        D.table.append([None]*len(D.A))
+        D.p.append(beta)
+    D.table[alpha][D.A_dict[x]] = beta
+    D.table[beta][D.A_dict_inv[x]] = alpha
+    D.deduction_stack.append((alpha, x))
+    if not D.process_deductions_check(R1_c_list[D.A_dict[x]], \
+            R1_c_list[D.A_dict_inv[x]]):
+        return
+    for w in Y:
+        if not D.scan_check(0, w):
+            return
+    if first_in_class(D, Y):
+        descendant_subgroups(S, D, R1_c_list, x, R2, N, Y)
+
+
+def first_in_class(C, Y=()):
+    """
+    Checks whether the subgroup ``H=G1`` corresponding to the Coset Table
+    could possibly be the canonical representative of its conjugacy class.
+
+    Parameters
+    ==========
+
+    C: CosetTable
+
+    Returns
+    =======
+
+    bool: True/False
+
+    If this returns False, then no descendant of C can have that property, and
+    so we can abandon C. If it returns True, then we need to process further
+    the node of the search tree corresponding to C, and so we call
+    ``descendant_subgroups`` recursively on C.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, CosetTable, first_in_class
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**4])
+    >>> C = CosetTable(f, [])
+    >>> C.table = [[0, 0, None, None]]
+    >>> first_in_class(C)
+    True
+    >>> C.table = [[1, 1, 1, None], [0, 0, None, 1]]; C.p = [0, 1]
+    >>> first_in_class(C)
+    True
+    >>> C.table = [[1, 1, 2, 1], [0, 0, 0, None], [None, None, None, 0]]
+    >>> C.p = [0, 1, 2]
+    >>> first_in_class(C)
+    False
+    >>> C.table = [[1, 1, 1, 2], [0, 0, 2, 0], [2, None, 0, 1]]
+    >>> first_in_class(C)
+    False
+
+    # TODO:: Sims points out in [Sim94] that performance can be improved by
+    # remembering some of the information computed by ``first_in_class``. If
+    # the ``continue alpha`` statement is executed at line 14, then the same thing
+    # will happen for that value of alpha in any descendant of the table C, and so
+    # the values the values of alpha for which this occurs could profitably be
+    # stored and passed through to the descendants of C. Of course this would
+    # make the code more complicated.
+
+    # The code below is taken directly from the function on page 208 of [Sim94]
+    # nu[alpha]
+
+    """
+    n = C.n
+    # lamda is the largest numbered point in Omega_c_alpha which is currently defined
+    lamda = -1
+    # for alpha in Omega_c, nu[alpha] is the point in Omega_c_alpha corresponding to alpha
+    nu = [None]*n
+    # for alpha in Omega_c_alpha, mu[alpha] is the point in Omega_c corresponding to alpha
+    mu = [None]*n
+    # mutually nu and mu are the mutually-inverse equivalence maps between
+    # Omega_c_alpha and Omega_c
+    next_alpha = False
+    # For each 0!=alpha in [0 .. nc-1], we start by constructing the equivalent
+    # standardized coset table C_alpha corresponding to H_alpha
+    for alpha in range(1, n):
+        # reset nu to "None" after previous value of alpha
+        for beta in range(lamda+1):
+            nu[mu[beta]] = None
+        # we only want to reject our current table in favour of a preceding
+        # table in the ordering in which 1 is replaced by alpha, if the subgroup
+        # G_alpha corresponding to this preceding table definitely contains the
+        # given subgroup
+        for w in Y:
+            # TODO: this should support input of a list of general words
+            # not just the words which are in "A" (i.e gen and gen^-1)
+            if C.table[alpha][C.A_dict[w]] != alpha:
+                # continue with alpha
+                next_alpha = True
+                break
+        if next_alpha:
+            next_alpha = False
+            continue
+        # try alpha as the new point 0 in Omega_C_alpha
+        mu[0] = alpha
+        nu[alpha] = 0
+        # compare corresponding entries in C and C_alpha
+        lamda = 0
+        for beta in range(n):
+            for x in C.A:
+                gamma = C.table[beta][C.A_dict[x]]
+                delta = C.table[mu[beta]][C.A_dict[x]]
+                # if either of the entries is undefined,
+                # we move with next alpha
+                if gamma is None or delta is None:
+                    # continue with alpha
+                    next_alpha = True
+                    break
+                if nu[delta] is None:
+                    # delta becomes the next point in Omega_C_alpha
+                    lamda += 1
+                    nu[delta] = lamda
+                    mu[lamda] = delta
+                if nu[delta] < gamma:
+                    return False
+                if nu[delta] > gamma:
+                    # continue with alpha
+                    next_alpha = True
+                    break
+            if next_alpha:
+                next_alpha = False
+                break
+    return True
+
+#========================================================================
+#                    Simplifying Presentation
+#========================================================================
+
+def simplify_presentation(*args, change_gens=False):
+    '''
+    For an instance of `FpGroup`, return a simplified isomorphic copy of
+    the group (e.g. remove redundant generators or relators). Alternatively,
+    a list of generators and relators can be passed in which case the
+    simplified lists will be returned.
+
+    By default, the generators of the group are unchanged. If you would
+    like to remove redundant generators, set the keyword argument
+    `change_gens = True`.
+
+    '''
+    if len(args) == 1:
+        if not isinstance(args[0], FpGroup):
+            raise TypeError("The argument must be an instance of FpGroup")
+        G = args[0]
+        gens, rels = simplify_presentation(G.generators, G.relators,
+                                              change_gens=change_gens)
+        if gens:
+            return FpGroup(gens[0].group, rels)
+        return FpGroup(FreeGroup([]), [])
+    elif len(args) == 2:
+        gens, rels = args[0][:], args[1][:]
+        if not gens:
+            return gens, rels
+        identity = gens[0].group.identity
+    else:
+        if len(args) == 0:
+            m = "Not enough arguments"
+        else:
+            m = "Too many arguments"
+        raise RuntimeError(m)
+
+    prev_gens = []
+    prev_rels = []
+    while not set(prev_rels) == set(rels):
+        prev_rels = rels
+        while change_gens and not set(prev_gens) == set(gens):
+            prev_gens = gens
+            gens, rels = elimination_technique_1(gens, rels, identity)
+        rels = _simplify_relators(rels, identity)
+
+    if change_gens:
+        syms = [g.array_form[0][0] for g in gens]
+        F = free_group(syms)[0]
+        identity = F.identity
+        gens = F.generators
+        subs = dict(zip(syms, gens))
+        for j, r in enumerate(rels):
+            a = r.array_form
+            rel = identity
+            for sym, p in a:
+                rel = rel*subs[sym]**p
+            rels[j] = rel
+    return gens, rels
+
+def _simplify_relators(rels, identity):
+    """Relies upon ``_simplification_technique_1`` for its functioning. """
+    rels = rels[:]
+
+    rels = list(set(_simplification_technique_1(rels)))
+    rels.sort()
+    rels = [r.identity_cyclic_reduction() for r in rels]
+    try:
+        rels.remove(identity)
+    except ValueError:
+        pass
+    return rels
+
+# Pg 350, section 2.5.1 from [2]
+def elimination_technique_1(gens, rels, identity):
+    rels = rels[:]
+    # the shorter relators are examined first so that generators selected for
+    # elimination will have shorter strings as equivalent
+    rels.sort()
+    gens = gens[:]
+    redundant_gens = {}
+    redundant_rels = []
+    used_gens = set()
+    # examine each relator in relator list for any generator occurring exactly
+    # once
+    for rel in rels:
+        # don't look for a redundant generator in a relator which
+        # depends on previously found ones
+        contained_gens = rel.contains_generators()
+        if any(g in contained_gens for g in redundant_gens):
+            continue
+        contained_gens = list(contained_gens)
+        contained_gens.sort(reverse = True)
+        for gen in contained_gens:
+            if rel.generator_count(gen) == 1 and gen not in used_gens:
+                k = rel.exponent_sum(gen)
+                gen_index = rel.index(gen**k)
+                bk = rel.subword(gen_index + 1, len(rel))
+                fw = rel.subword(0, gen_index)
+                chi = bk*fw
+                redundant_gens[gen] = chi**(-1*k)
+                used_gens.update(chi.contains_generators())
+                redundant_rels.append(rel)
+                break
+    rels = [r for r in rels if r not in redundant_rels]
+    # eliminate the redundant generators from remaining relators
+    rels = [r.eliminate_words(redundant_gens, _all = True).identity_cyclic_reduction() for r in rels]
+    rels = list(set(rels))
+    try:
+        rels.remove(identity)
+    except ValueError:
+        pass
+    gens = [g for g in gens if g not in redundant_gens]
+    return gens, rels
+
+def _simplification_technique_1(rels):
+    """
+    All relators are checked to see if they are of the form `gen^n`. If any
+    such relators are found then all other relators are processed for strings
+    in the `gen` known order.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import _simplification_technique_1
+    >>> F, x, y = free_group("x, y")
+    >>> w1 = [x**2*y**4, x**3]
+    >>> _simplification_technique_1(w1)
+    [x**-1*y**4, x**3]
+
+    >>> w2 = [x**2*y**-4*x**5, x**3, x**2*y**8, y**5]
+    >>> _simplification_technique_1(w2)
+    [x**-1*y*x**-1, x**3, x**-1*y**-2, y**5]
+
+    >>> w3 = [x**6*y**4, x**4]
+    >>> _simplification_technique_1(w3)
+    [x**2*y**4, x**4]
+
+    """
+    rels = rels[:]
+    # dictionary with "gen: n" where gen^n is one of the relators
+    exps = {}
+    for i in range(len(rels)):
+        rel = rels[i]
+        if rel.number_syllables() == 1:
+            g = rel[0]
+            exp = abs(rel.array_form[0][1])
+            if rel.array_form[0][1] < 0:
+                rels[i] = rels[i]**-1
+                g = g**-1
+            if g in exps:
+                exp = gcd(exp, exps[g].array_form[0][1])
+            exps[g] = g**exp
+
+    one_syllables_words = exps.values()
+    # decrease some of the exponents in relators, making use of the single
+    # syllable relators
+    for i in range(len(rels)):
+        rel = rels[i]
+        if rel in one_syllables_words:
+            continue
+        rel = rel.eliminate_words(one_syllables_words, _all = True)
+        # if rels[i] contains g**n where abs(n) is greater than half of the power p
+        # of g in exps, g**n can be replaced by g**(n-p) (or g**(p-n) if n<0)
+        for g in rel.contains_generators():
+            if g in exps:
+                exp = exps[g].array_form[0][1]
+                max_exp = (exp + 1)//2
+                rel = rel.eliminate_word(g**(max_exp), g**(max_exp-exp), _all = True)
+                rel = rel.eliminate_word(g**(-max_exp), g**(-(max_exp-exp)), _all = True)
+        rels[i] = rel
+    rels = [r.identity_cyclic_reduction() for r in rels]
+    return rels
+
+
+###############################################################################
+#                           SUBGROUP PRESENTATIONS                            #
+###############################################################################
+
+# Pg 175 [1]
+def define_schreier_generators(C, homomorphism=False):
+    '''
+    Parameters
+    ==========
+
+    C -- Coset table.
+    homomorphism -- When set to True, return a dictionary containing the images
+                     of the presentation generators in the original group.
+    '''
+    y = []
+    gamma = 1
+    f = C.fp_group
+    X = f.generators
+    if homomorphism:
+        # `_gens` stores the elements of the parent group to
+        # to which the schreier generators correspond to.
+        _gens = {}
+        # compute the schreier Traversal
+        tau = {}
+        tau[0] = f.identity
+    C.P = [[None]*len(C.A) for i in range(C.n)]
+    for alpha, x in product(C.omega, C.A):
+        beta = C.table[alpha][C.A_dict[x]]
+        if beta == gamma:
+            C.P[alpha][C.A_dict[x]] = "<identity>"
+            C.P[beta][C.A_dict_inv[x]] = "<identity>"
+            gamma += 1
+            if homomorphism:
+                tau[beta] = tau[alpha]*x
+        elif x in X and C.P[alpha][C.A_dict[x]] is None:
+            y_alpha_x = '%s_%s' % (x, alpha)
+            y.append(y_alpha_x)
+            C.P[alpha][C.A_dict[x]] = y_alpha_x
+            if homomorphism:
+                _gens[y_alpha_x] = tau[alpha]*x*tau[beta]**-1
+    grp_gens = list(free_group(', '.join(y)))
+    C._schreier_free_group = grp_gens.pop(0)
+    C._schreier_generators = grp_gens
+    if homomorphism:
+        C._schreier_gen_elem = _gens
+    # replace all elements of P by, free group elements
+    for i, j in product(range(len(C.P)), range(len(C.A))):
+        # if equals "<identity>", replace by identity element
+        if C.P[i][j] == "<identity>":
+            C.P[i][j] = C._schreier_free_group.identity
+        elif isinstance(C.P[i][j], str):
+            r = C._schreier_generators[y.index(C.P[i][j])]
+            C.P[i][j] = r
+            beta = C.table[i][j]
+            C.P[beta][j + 1] = r**-1
+
+def reidemeister_relators(C):
+    R = C.fp_group.relators
+    rels = [rewrite(C, coset, word) for word in R for coset in range(C.n)]
+    order_1_gens = {i for i in rels if len(i) == 1}
+
+    # remove all the order 1 generators from relators
+    rels = list(filter(lambda rel: rel not in order_1_gens, rels))
+
+    # replace order 1 generators by identity element in reidemeister relators
+    for i in range(len(rels)):
+        w = rels[i]
+        w = w.eliminate_words(order_1_gens, _all=True)
+        rels[i] = w
+
+    C._schreier_generators = [i for i in C._schreier_generators
+                    if not (i in order_1_gens or i**-1 in order_1_gens)]
+
+    # Tietze transformation 1 i.e TT_1
+    # remove cyclic conjugate elements from relators
+    i = 0
+    while i < len(rels):
+        w = rels[i]
+        j = i + 1
+        while j < len(rels):
+            if w.is_cyclic_conjugate(rels[j]):
+                del rels[j]
+            else:
+                j += 1
+        i += 1
+
+    C._reidemeister_relators = rels
+
+
+def rewrite(C, alpha, w):
+    """
+    Parameters
+    ==========
+
+    C: CosetTable
+    alpha: A live coset
+    w: A word in `A*`
+
+    Returns
+    =======
+
+    rho(tau(alpha), w)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.fp_groups import FpGroup, CosetTable, define_schreier_generators, rewrite
+    >>> from sympy.combinatorics import free_group
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**6])
+    >>> C = CosetTable(f, [])
+    >>> C.table = [[1, 1, 2, 3], [0, 0, 4, 5], [4, 4, 3, 0], [5, 5, 0, 2], [2, 2, 5, 1], [3, 3, 1, 4]]
+    >>> C.p = [0, 1, 2, 3, 4, 5]
+    >>> define_schreier_generators(C)
+    >>> rewrite(C, 0, (x*y)**6)
+    x_4*y_2*x_3*x_1*x_2*y_4*x_5
+
+    """
+    v = C._schreier_free_group.identity
+    for i in range(len(w)):
+        x_i = w[i]
+        v = v*C.P[alpha][C.A_dict[x_i]]
+        alpha = C.table[alpha][C.A_dict[x_i]]
+    return v
+
+# Pg 350, section 2.5.2 from [2]
+def elimination_technique_2(C):
+    """
+    This technique eliminates one generator at a time. Heuristically this
+    seems superior in that we may select for elimination the generator with
+    shortest equivalent string at each stage.
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r, \
+            reidemeister_relators, define_schreier_generators, elimination_technique_2
+    >>> 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]
+    >>> C = coset_enumeration_r(f, H)
+    >>> C.compress(); C.standardize()
+    >>> define_schreier_generators(C)
+    >>> reidemeister_relators(C)
+    >>> elimination_technique_2(C)
+    ([y_1, y_2], [y_2**-3, y_2*y_1*y_2*y_1*y_2*y_1, y_1**2])
+
+    """
+    rels = C._reidemeister_relators
+    rels.sort(reverse=True)
+    gens = C._schreier_generators
+    for i in range(len(gens) - 1, -1, -1):
+        rel = rels[i]
+        for j in range(len(gens) - 1, -1, -1):
+            gen = gens[j]
+            if rel.generator_count(gen) == 1:
+                k = rel.exponent_sum(gen)
+                gen_index = rel.index(gen**k)
+                bk = rel.subword(gen_index + 1, len(rel))
+                fw = rel.subword(0, gen_index)
+                rep_by = (bk*fw)**(-1*k)
+                del rels[i]; del gens[j]
+                for l in range(len(rels)):
+                    rels[l] = rels[l].eliminate_word(gen, rep_by)
+                break
+    C._reidemeister_relators = rels
+    C._schreier_generators = gens
+    return C._schreier_generators, C._reidemeister_relators
+
+def reidemeister_presentation(fp_grp, H, C=None, homomorphism=False):
+    """
+    Parameters
+    ==========
+
+    fp_group: A finitely presented group, an instance of FpGroup
+    H: A subgroup whose presentation is to be found, given as a list
+    of words in generators of `fp_grp`
+    homomorphism: When set to True, return a homomorphism from the subgroup
+                    to the parent group
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, reidemeister_presentation
+    >>> F, x, y = free_group("x, y")
+
+    Example 5.6 Pg. 177 from [1]
+    >>> f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    >>> H = [x*y, x**-1*y**-1*x*y*x]
+    >>> reidemeister_presentation(f, H)
+    ((y_1, y_2), (y_1**2, y_2**3, y_2*y_1*y_2*y_1*y_2*y_1))
+
+    Example 5.8 Pg. 183 from [1]
+    >>> f = FpGroup(F, [x**3, y**3, (x*y)**3])
+    >>> H = [x*y, x*y**-1]
+    >>> reidemeister_presentation(f, H)
+    ((x_0, y_0), (x_0**3, y_0**3, x_0*y_0*x_0*y_0*x_0*y_0))
+
+    Exercises Q2. Pg 187 from [1]
+    >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    >>> H = [x]
+    >>> reidemeister_presentation(f, H)
+    ((x_0,), (x_0**4,))
+
+    Example 5.9 Pg. 183 from [1]
+    >>> f = FpGroup(F, [x**3*y**-3, (x*y)**3, (x*y**-1)**2])
+    >>> H = [x]
+    >>> reidemeister_presentation(f, H)
+    ((x_0,), (x_0**6,))
+
+    """
+    if not C:
+        C = coset_enumeration_r(fp_grp, H)
+    C.compress(); C.standardize()
+    define_schreier_generators(C, homomorphism=homomorphism)
+    reidemeister_relators(C)
+    gens, rels = C._schreier_generators, C._reidemeister_relators
+    gens, rels = simplify_presentation(gens, rels, change_gens=True)
+
+    C.schreier_generators = tuple(gens)
+    C.reidemeister_relators = tuple(rels)
+
+    if homomorphism:
+        _gens = []
+        for gen in gens:
+            _gens.append(C._schreier_gen_elem[str(gen)])
+        return C.schreier_generators, C.reidemeister_relators, _gens
+
+    return C.schreier_generators, C.reidemeister_relators
+
+
+FpGroupElement = FreeGroupElement

env-llmeval/lib/python3.10/site-packages/sympy/combinatorics/free_groups.py

@@ -0,0 +1,1354 @@
+from __future__ import annotations
+
+from sympy.core import S
+from sympy.core.expr import Expr
+from sympy.core.symbol import Symbol, symbols as _symbols
+from sympy.core.sympify import CantSympify
+from sympy.printing.defaults import DefaultPrinting
+from sympy.utilities import public
+from sympy.utilities.iterables import flatten, is_sequence
+from sympy.utilities.magic import pollute
+from sympy.utilities.misc import as_int
+
+
+@public
+def free_group(symbols):
+    """Construct a free group returning ``(FreeGroup, (f_0, f_1, ..., f_(n-1))``.
+
+    Parameters
+    ==========
+
+    symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> F, x, y, z = free_group("x, y, z")
+    >>> F
+    <free group on the generators (x, y, z)>
+    >>> x**2*y**-1
+    x**2*y**-1
+    >>> type(_)
+    <class 'sympy.combinatorics.free_groups.FreeGroupElement'>
+
+    """
+    _free_group = FreeGroup(symbols)
+    return (_free_group,) + tuple(_free_group.generators)
+
+@public
+def xfree_group(symbols):
+    """Construct a free group returning ``(FreeGroup, (f_0, f_1, ..., f_(n-1)))``.
+
+    Parameters
+    ==========
+
+    symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import xfree_group
+    >>> F, (x, y, z) = xfree_group("x, y, z")
+    >>> F
+    <free group on the generators (x, y, z)>
+    >>> y**2*x**-2*z**-1
+    y**2*x**-2*z**-1
+    >>> type(_)
+    <class 'sympy.combinatorics.free_groups.FreeGroupElement'>
+
+    """
+    _free_group = FreeGroup(symbols)
+    return (_free_group, _free_group.generators)
+
+@public
+def vfree_group(symbols):
+    """Construct a free group and inject ``f_0, f_1, ..., f_(n-1)`` as symbols
+    into the global namespace.
+
+    Parameters
+    ==========
+
+    symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import vfree_group
+    >>> vfree_group("x, y, z")
+    <free group on the generators (x, y, z)>
+    >>> x**2*y**-2*z # noqa: F821
+    x**2*y**-2*z
+    >>> type(_)
+    <class 'sympy.combinatorics.free_groups.FreeGroupElement'>
+
+    """
+    _free_group = FreeGroup(symbols)
+    pollute([sym.name for sym in _free_group.symbols], _free_group.generators)
+    return _free_group
+
+
+def _parse_symbols(symbols):
+    if not symbols:
+        return ()
+    if isinstance(symbols, str):
+        return _symbols(symbols, seq=True)
+    elif isinstance(symbols, (Expr, FreeGroupElement)):
+        return (symbols,)
+    elif is_sequence(symbols):
+        if all(isinstance(s, str) for s in symbols):
+            return _symbols(symbols)
+        elif all(isinstance(s, Expr) for s in symbols):
+            return symbols
+    raise ValueError("The type of `symbols` must be one of the following: "
+                     "a str, Symbol/Expr or a sequence of "
+                     "one of these types")
+
+
+##############################################################################
+#                          FREE GROUP                                        #
+##############################################################################
+
+_free_group_cache: dict[int, FreeGroup] = {}
+
+class FreeGroup(DefaultPrinting):
+    """
+    Free group with finite or infinite number of generators. Its input API
+    is that of a str, Symbol/Expr or a sequence of one of
+    these types (which may be empty)
+
+    See Also
+    ========
+
+    sympy.polys.rings.PolyRing
+
+    References
+    ==========
+
+    .. [1] https://www.gap-system.org/Manuals/doc/ref/chap37.html
+
+    .. [2] https://en.wikipedia.org/wiki/Free_group
+
+    """
+    is_associative = True
+    is_group = True
+    is_FreeGroup = True
+    is_PermutationGroup = False
+    relators: list[Expr] = []
+
+    def __new__(cls, symbols):
+        symbols = tuple(_parse_symbols(symbols))
+        rank = len(symbols)
+        _hash = hash((cls.__name__, symbols, rank))
+        obj = _free_group_cache.get(_hash)
+
+        if obj is None:
+            obj = object.__new__(cls)
+            obj._hash = _hash
+            obj._rank = rank
+            # dtype method is used to create new instances of FreeGroupElement
+            obj.dtype = type("FreeGroupElement", (FreeGroupElement,), {"group": obj})
+            obj.symbols = symbols
+            obj.generators = obj._generators()
+            obj._gens_set = set(obj.generators)
+            for symbol, generator in zip(obj.symbols, obj.generators):
+                if isinstance(symbol, Symbol):
+                    name = symbol.name
+                    if hasattr(obj, name):
+                        setattr(obj, name, generator)
+
+            _free_group_cache[_hash] = obj
+
+        return obj
+
+    def _generators(group):
+        """Returns the generators of the FreeGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y, z = free_group("x, y, z")
+        >>> F.generators
+        (x, y, z)
+
+        """
+        gens = []
+        for sym in group.symbols:
+            elm = ((sym, 1),)
+            gens.append(group.dtype(elm))
+        return tuple(gens)
+
+    def clone(self, symbols=None):
+        return self.__class__(symbols or self.symbols)
+
+    def __contains__(self, i):
+        """Return True if ``i`` is contained in FreeGroup."""
+        if not isinstance(i, FreeGroupElement):
+            return False
+        group = i.group
+        return self == group
+
+    def __hash__(self):
+        return self._hash
+
+    def __len__(self):
+        return self.rank
+
+    def __str__(self):
+        if self.rank > 30:
+            str_form = "<free group with %s generators>" % self.rank
+        else:
+            str_form = "<free group on the generators "
+            gens = self.generators
+            str_form += str(gens) + ">"
+        return str_form
+
+    __repr__ = __str__
+
+    def __getitem__(self, index):
+        symbols = self.symbols[index]
+        return self.clone(symbols=symbols)
+
+    def __eq__(self, other):
+        """No ``FreeGroup`` is equal to any "other" ``FreeGroup``.
+        """
+        return self is other
+
+    def index(self, gen):
+        """Return the index of the generator `gen` from ``(f_0, ..., f_(n-1))``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> F.index(y)
+        1
+        >>> F.index(x)
+        0
+
+        """
+        if isinstance(gen, self.dtype):
+            return self.generators.index(gen)
+        else:
+            raise ValueError("expected a generator of Free Group %s, got %s" % (self, gen))
+
+    def order(self):
+        """Return the order of the free group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> F.order()
+        oo
+
+        >>> free_group("")[0].order()
+        1
+
+        """
+        if self.rank == 0:
+            return S.One
+        else:
+            return S.Infinity
+
+    @property
+    def elements(self):
+        """
+        Return the elements of the free group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> (z,) = free_group("")
+        >>> z.elements
+        {<identity>}
+
+        """
+        if self.rank == 0:
+            # A set containing Identity element of `FreeGroup` self is returned
+            return {self.identity}
+        else:
+            raise ValueError("Group contains infinitely many elements"
+                            ", hence cannot be represented")
+
+    @property
+    def rank(self):
+        r"""
+        In group theory, the `rank` of a group `G`, denoted `G.rank`,
+        can refer to the smallest cardinality of a generating set
+        for G, that is
+
+        \operatorname{rank}(G)=\min\{ |X|: X\subseteq G, \left\langle X\right\rangle =G\}.
+
+        """
+        return self._rank
+
+    @property
+    def is_abelian(self):
+        """Returns if the group is Abelian.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> f.is_abelian
+        False
+
+        """
+        return self.rank in (0, 1)
+
+    @property
+    def identity(self):
+        """Returns the identity element of free group."""
+        return self.dtype()
+
+    def contains(self, g):
+        """Tests if Free Group element ``g`` belong to self, ``G``.
+
+        In mathematical terms any linear combination of generators
+        of a Free Group is contained in it.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> f.contains(x**3*y**2)
+        True
+
+        """
+        if not isinstance(g, FreeGroupElement):
+            return False
+        elif self != g.group:
+            return False
+        else:
+            return True
+
+    def center(self):
+        """Returns the center of the free group `self`."""
+        return {self.identity}
+
+
+############################################################################
+#                          FreeGroupElement                                #
+############################################################################
+
+
+class FreeGroupElement(CantSympify, DefaultPrinting, tuple):
+    """Used to create elements of FreeGroup. It cannot be used directly to
+    create a free group element. It is called by the `dtype` method of the
+    `FreeGroup` class.
+
+    """
+    is_assoc_word = True
+
+    def new(self, init):
+        return self.__class__(init)
+
+    _hash = None
+
+    def __hash__(self):
+        _hash = self._hash
+        if _hash is None:
+            self._hash = _hash = hash((self.group, frozenset(tuple(self))))
+        return _hash
+
+    def copy(self):
+        return self.new(self)
+
+    @property
+    def is_identity(self):
+        if self.array_form == ():
+            return True
+        else:
+            return False
+
+    @property
+    def array_form(self):
+        """
+        SymPy provides two different internal kinds of representation
+        of associative words. The first one is called the `array_form`
+        which is a tuple containing `tuples` as its elements, where the
+        size of each tuple is two. At the first position the tuple
+        contains the `symbol-generator`, while at the second position
+        of tuple contains the exponent of that generator at the position.
+        Since elements (i.e. words) do not commute, the indexing of tuple
+        makes that property to stay.
+
+        The structure in ``array_form`` of ``FreeGroupElement`` is of form:
+
+        ``( ( symbol_of_gen, exponent ), ( , ), ... ( , ) )``
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> (x*z).array_form
+        ((x, 1), (z, 1))
+        >>> (x**2*z*y*x**2).array_form
+        ((x, 2), (z, 1), (y, 1), (x, 2))
+
+        See Also
+        ========
+
+        letter_repr
+
+        """
+        return tuple(self)
+
+    @property
+    def letter_form(self):
+        """
+        The letter representation of a ``FreeGroupElement`` is a tuple
+        of generator symbols, with each entry corresponding to a group
+        generator. Inverses of the generators are represented by
+        negative generator symbols.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b, c, d = free_group("a b c d")
+        >>> (a**3).letter_form
+        (a, a, a)
+        >>> (a**2*d**-2*a*b**-4).letter_form
+        (a, a, -d, -d, a, -b, -b, -b, -b)
+        >>> (a**-2*b**3*d).letter_form
+        (-a, -a, b, b, b, d)
+
+        See Also
+        ========
+
+        array_form
+
+        """
+        return tuple(flatten([(i,)*j if j > 0 else (-i,)*(-j)
+                    for i, j in self.array_form]))
+
+    def __getitem__(self, i):
+        group = self.group
+        r = self.letter_form[i]
+        if r.is_Symbol:
+            return group.dtype(((r, 1),))
+        else:
+            return group.dtype(((-r, -1),))
+
+    def index(self, gen):
+        if len(gen) != 1:
+            raise ValueError()
+        return (self.letter_form).index(gen.letter_form[0])
+
+    @property
+    def letter_form_elm(self):
+        """
+        """
+        group = self.group
+        r = self.letter_form
+        return [group.dtype(((elm,1),)) if elm.is_Symbol \
+                else group.dtype(((-elm,-1),)) for elm in r]
+
+    @property
+    def ext_rep(self):
+        """This is called the External Representation of ``FreeGroupElement``
+        """
+        return tuple(flatten(self.array_form))
+
+    def __contains__(self, gen):
+        return gen.array_form[0][0] in tuple([r[0] for r in self.array_form])
+
+    def __str__(self):
+        if self.is_identity:
+            return "<identity>"
+
+        str_form = ""
+        array_form = self.array_form
+        for i in range(len(array_form)):
+            if i == len(array_form) - 1:
+                if array_form[i][1] == 1:
+                    str_form += str(array_form[i][0])
+                else:
+                    str_form += str(array_form[i][0]) + \
+                                    "**" + str(array_form[i][1])
+            else:
+                if array_form[i][1] == 1:
+                    str_form += str(array_form[i][0]) + "*"
+                else:
+                    str_form += str(array_form[i][0]) + \
+                                    "**" + str(array_form[i][1]) + "*"
+        return str_form
+
+    __repr__ = __str__
+
+    def __pow__(self, n):
+        n = as_int(n)
+        group = self.group
+        if n == 0:
+            return group.identity
+
+        if n < 0:
+            n = -n
+            return (self.inverse())**n
+
+        result = self
+        for i in range(n - 1):
+            result = result*self
+        # this method can be improved instead of just returning the
+        # multiplication of elements
+        return result
+
+    def __mul__(self, other):
+        """Returns the product of elements belonging to the same ``FreeGroup``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> x*y**2*y**-4
+        x*y**-2
+        >>> z*y**-2
+        z*y**-2
+        >>> x**2*y*y**-1*x**-2
+        <identity>
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                    "be multiplied")
+        if self.is_identity:
+            return other
+        if other.is_identity:
+            return self
+        r = list(self.array_form + other.array_form)
+        zero_mul_simp(r, len(self.array_form) - 1)
+        return group.dtype(tuple(r))
+
+    def __truediv__(self, other):
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                    "be multiplied")
+        return self*(other.inverse())
+
+    def __rtruediv__(self, other):
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                    "be multiplied")
+        return other*(self.inverse())
+
+    def __add__(self, other):
+        return NotImplemented
+
+    def inverse(self):
+        """
+        Returns the inverse of a ``FreeGroupElement`` element
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> x.inverse()
+        x**-1
+        >>> (x*y).inverse()
+        y**-1*x**-1
+
+        """
+        group = self.group
+        r = tuple([(i, -j) for i, j in self.array_form[::-1]])
+        return group.dtype(r)
+
+    def order(self):
+        """Find the order of a ``FreeGroupElement``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y = free_group("x y")
+        >>> (x**2*y*y**-1*x**-2).order()
+        1
+
+        """
+        if self.is_identity:
+            return S.One
+        else:
+            return S.Infinity
+
+    def commutator(self, other):
+        """
+        Return the commutator of `self` and `x`: ``~x*~self*x*self``
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise ValueError("commutator of only FreeGroupElement of the same "
+                    "FreeGroup exists")
+        else:
+            return self.inverse()*other.inverse()*self*other
+
+    def eliminate_words(self, words, _all=False, inverse=True):
+        '''
+        Replace each subword from the dictionary `words` by words[subword].
+        If words is a list, replace the words by the identity.
+
+        '''
+        again = True
+        new = self
+        if isinstance(words, dict):
+            while again:
+                again = False
+                for sub in words:
+                    prev = new
+                    new = new.eliminate_word(sub, words[sub], _all=_all, inverse=inverse)
+                    if new != prev:
+                        again = True
+        else:
+            while again:
+                again = False
+                for sub in words:
+                    prev = new
+                    new = new.eliminate_word(sub, _all=_all, inverse=inverse)
+                    if new != prev:
+                        again = True
+        return new
+
+    def eliminate_word(self, gen, by=None, _all=False, inverse=True):
+        """
+        For an associative word `self`, a subword `gen`, and an associative
+        word `by` (identity by default), return the associative word obtained by
+        replacing each occurrence of `gen` in `self` by `by`. If `_all = True`,
+        the occurrences of `gen` that may appear after the first substitution will
+        also be replaced and so on until no occurrences are found. This might not
+        always terminate (e.g. `(x).eliminate_word(x, x**2, _all=True)`).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y = free_group("x y")
+        >>> w = x**5*y*x**2*y**-4*x
+        >>> w.eliminate_word( x, x**2 )
+        x**10*y*x**4*y**-4*x**2
+        >>> w.eliminate_word( x, y**-1 )
+        y**-11
+        >>> w.eliminate_word(x**5)
+        y*x**2*y**-4*x
+        >>> w.eliminate_word(x*y, y)
+        x**4*y*x**2*y**-4*x
+
+        See Also
+        ========
+        substituted_word
+
+        """
+        if by is None:
+            by = self.group.identity
+        if self.is_independent(gen) or gen == by:
+            return self
+        if gen == self:
+            return by
+        if gen**-1 == by:
+            _all = False
+        word = self
+        l = len(gen)
+
+        try:
+            i = word.subword_index(gen)
+            k = 1
+        except ValueError:
+            if not inverse:
+                return word
+            try:
+                i = word.subword_index(gen**-1)
+                k = -1
+            except ValueError:
+                return word
+
+        word = word.subword(0, i)*by**k*word.subword(i+l, len(word)).eliminate_word(gen, by)
+
+        if _all:
+            return word.eliminate_word(gen, by, _all=True, inverse=inverse)
+        else:
+            return word
+
+    def __len__(self):
+        """
+        For an associative word `self`, returns the number of letters in it.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> len(w)
+        13
+        >>> len(a**17)
+        17
+        >>> len(w**0)
+        0
+
+        """
+        return sum(abs(j) for (i, j) in self)
+
+    def __eq__(self, other):
+        """
+        Two  associative words are equal if they are words over the
+        same alphabet and if they are sequences of the same letters.
+        This is equivalent to saying that the external representations
+        of the words are equal.
+        There is no "universal" empty word, every alphabet has its own
+        empty word.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, swapnil0, swapnil1 = free_group("swapnil0 swapnil1")
+        >>> f
+        <free group on the generators (swapnil0, swapnil1)>
+        >>> g, swap0, swap1 = free_group("swap0 swap1")
+        >>> g
+        <free group on the generators (swap0, swap1)>
+
+        >>> swapnil0 == swapnil1
+        False
+        >>> swapnil0*swapnil1 == swapnil1/swapnil1*swapnil0*swapnil1
+        True
+        >>> swapnil0*swapnil1 == swapnil1*swapnil0
+        False
+        >>> swapnil1**0 == swap0**0
+        False
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            return False
+        return tuple.__eq__(self, other)
+
+    def __lt__(self, other):
+        """
+        The  ordering  of  associative  words is defined by length and
+        lexicography (this ordering is called short-lex ordering), that
+        is, shorter words are smaller than longer words, and words of the
+        same length are compared w.r.t. the lexicographical ordering induced
+        by the ordering of generators. Generators  are  sorted  according
+        to the order in which they were created. If the generators are
+        invertible then each generator `g` is larger than its inverse `g^{-1}`,
+        and `g^{-1}` is larger than every generator that is smaller than `g`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> b < a
+        False
+        >>> a < a.inverse()
+        False
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                             "be compared")
+        l = len(self)
+        m = len(other)
+        # implement lenlex order
+        if l < m:
+            return True
+        elif l > m:
+            return False
+        for i in range(l):
+            a = self[i].array_form[0]
+            b = other[i].array_form[0]
+            p = group.symbols.index(a[0])
+            q = group.symbols.index(b[0])
+            if p < q:
+                return True
+            elif p > q:
+                return False
+            elif a[1] < b[1]:
+                return True
+            elif a[1] > b[1]:
+                return False
+        return False
+
+    def __le__(self, other):
+        return (self == other or self < other)
+
+    def __gt__(self, other):
+        """
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> y**2 > x**2
+        True
+        >>> y*z > z*y
+        False
+        >>> x > x.inverse()
+        True
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                             "be compared")
+        return not self <= other
+
+    def __ge__(self, other):
+        return not self < other
+
+    def exponent_sum(self, gen):
+        """
+        For an associative word `self` and a generator or inverse of generator
+        `gen`, ``exponent_sum`` returns the number of times `gen` appears in
+        `self` minus the number of times its inverse appears in `self`. If
+        neither `gen` nor its inverse occur in `self` then 0 is returned.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w = x**2*y**3
+        >>> w.exponent_sum(x)
+        2
+        >>> w.exponent_sum(x**-1)
+        -2
+        >>> w = x**2*y**4*x**-3
+        >>> w.exponent_sum(x)
+        -1
+
+        See Also
+        ========
+
+        generator_count
+
+        """
+        if len(gen) != 1:
+            raise ValueError("gen must be a generator or inverse of a generator")
+        s = gen.array_form[0]
+        return s[1]*sum([i[1] for i in self.array_form if i[0] == s[0]])
+
+    def generator_count(self, gen):
+        """
+        For an associative word `self` and a generator `gen`,
+        ``generator_count`` returns the multiplicity of generator
+        `gen` in `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w = x**2*y**3
+        >>> w.generator_count(x)
+        2
+        >>> w = x**2*y**4*x**-3
+        >>> w.generator_count(x)
+        5
+
+        See Also
+        ========
+
+        exponent_sum
+
+        """
+        if len(gen) != 1 or gen.array_form[0][1] < 0:
+            raise ValueError("gen must be a generator")
+        s = gen.array_form[0]
+        return s[1]*sum([abs(i[1]) for i in self.array_form if i[0] == s[0]])
+
+    def subword(self, from_i, to_j, strict=True):
+        """
+        For an associative word `self` and two positive integers `from_i` and
+        `to_j`, `subword` returns the subword of `self` that begins at position
+        `from_i` and ends at `to_j - 1`, indexing is done with origin 0.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.subword(2, 6)
+        a**3*b
+
+        """
+        group = self.group
+        if not strict:
+            from_i = max(from_i, 0)
+            to_j = min(len(self), to_j)
+        if from_i < 0 or to_j > len(self):
+            raise ValueError("`from_i`, `to_j` must be positive and no greater than "
+                    "the length of associative word")
+        if to_j <= from_i:
+            return group.identity
+        else:
+            letter_form = self.letter_form[from_i: to_j]
+            array_form = letter_form_to_array_form(letter_form, group)
+            return group.dtype(array_form)
+
+    def subword_index(self, word, start = 0):
+        '''
+        Find the index of `word` in `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**2*b*a*b**3
+        >>> w.subword_index(a*b*a*b)
+        1
+
+        '''
+        l = len(word)
+        self_lf = self.letter_form
+        word_lf = word.letter_form
+        index = None
+        for i in range(start,len(self_lf)-l+1):
+            if self_lf[i:i+l] == word_lf:
+                index = i
+                break
+        if index is not None:
+            return index
+        else:
+            raise ValueError("The given word is not a subword of self")
+
+    def is_dependent(self, word):
+        """
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**4*y**-3).is_dependent(x**4*y**-2)
+        True
+        >>> (x**2*y**-1).is_dependent(x*y)
+        False
+        >>> (x*y**2*x*y**2).is_dependent(x*y**2)
+        True
+        >>> (x**12).is_dependent(x**-4)
+        True
+
+        See Also
+        ========
+
+        is_independent
+
+        """
+        try:
+            return self.subword_index(word) is not None
+        except ValueError:
+            pass
+        try:
+            return self.subword_index(word**-1) is not None
+        except ValueError:
+            return False
+
+    def is_independent(self, word):
+        """
+
+        See Also
+        ========
+
+        is_dependent
+
+        """
+        return not self.is_dependent(word)
+
+    def contains_generators(self):
+        """
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y, z = free_group("x, y, z")
+        >>> (x**2*y**-1).contains_generators()
+        {x, y}
+        >>> (x**3*z).contains_generators()
+        {x, z}
+
+        """
+        group = self.group
+        gens = set()
+        for syllable in self.array_form:
+            gens.add(group.dtype(((syllable[0], 1),)))
+        return set(gens)
+
+    def cyclic_subword(self, from_i, to_j):
+        group = self.group
+        l = len(self)
+        letter_form = self.letter_form
+        period1 = int(from_i/l)
+        if from_i >= l:
+            from_i -= l*period1
+            to_j -= l*period1
+        diff = to_j - from_i
+        word = letter_form[from_i: to_j]
+        period2 = int(to_j/l) - 1
+        word += letter_form*period2 + letter_form[:diff-l+from_i-l*period2]
+        word = letter_form_to_array_form(word, group)
+        return group.dtype(word)
+
+    def cyclic_conjugates(self):
+        """Returns a words which are cyclic to the word `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w = x*y*x*y*x
+        >>> w.cyclic_conjugates()
+        {x*y*x**2*y, x**2*y*x*y, y*x*y*x**2, y*x**2*y*x, x*y*x*y*x}
+        >>> s = x*y*x**2*y*x
+        >>> s.cyclic_conjugates()
+        {x**2*y*x**2*y, y*x**2*y*x**2, x*y*x**2*y*x}
+
+        References
+        ==========
+
+        .. [1] https://planetmath.org/cyclicpermutation
+
+        """
+        return {self.cyclic_subword(i, i+len(self)) for i in range(len(self))}
+
+    def is_cyclic_conjugate(self, w):
+        """
+        Checks whether words ``self``, ``w`` are cyclic conjugates.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w1 = x**2*y**5
+        >>> w2 = x*y**5*x
+        >>> w1.is_cyclic_conjugate(w2)
+        True
+        >>> w3 = x**-1*y**5*x**-1
+        >>> w3.is_cyclic_conjugate(w2)
+        False
+
+        """
+        l1 = len(self)
+        l2 = len(w)
+        if l1 != l2:
+            return False
+        w1 = self.identity_cyclic_reduction()
+        w2 = w.identity_cyclic_reduction()
+        letter1 = w1.letter_form
+        letter2 = w2.letter_form
+        str1 = ' '.join(map(str, letter1))
+        str2 = ' '.join(map(str, letter2))
+        if len(str1) != len(str2):
+            return False
+
+        return str1 in str2 + ' ' + str2
+
+    def number_syllables(self):
+        """Returns the number of syllables of the associative word `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, swapnil0, swapnil1 = free_group("swapnil0 swapnil1")
+        >>> (swapnil1**3*swapnil0*swapnil1**-1).number_syllables()
+        3
+
+        """
+        return len(self.array_form)
+
+    def exponent_syllable(self, i):
+        """
+        Returns the exponent of the `i`-th syllable of the associative word
+        `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.exponent_syllable( 2 )
+        2
+
+        """
+        return self.array_form[i][1]
+
+    def generator_syllable(self, i):
+        """
+        Returns the symbol of the generator that is involved in the
+        i-th syllable of the associative word `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.generator_syllable( 3 )
+        b
+
+        """
+        return self.array_form[i][0]
+
+    def sub_syllables(self, from_i, to_j):
+        """
+        `sub_syllables` returns the subword of the associative word `self` that
+        consists of syllables from positions `from_to` to `to_j`, where
+        `from_to` and `to_j` must be positive integers and indexing is done
+        with origin 0.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a, b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.sub_syllables(1, 2)
+        b
+        >>> w.sub_syllables(3, 3)
+        <identity>
+
+        """
+        if not isinstance(from_i, int) or not isinstance(to_j, int):
+            raise ValueError("both arguments should be integers")
+        group = self.group
+        if to_j <= from_i:
+            return group.identity
+        else:
+            r = tuple(self.array_form[from_i: to_j])
+            return group.dtype(r)
+
+    def substituted_word(self, from_i, to_j, by):
+        """
+        Returns the associative word obtained by replacing the subword of
+        `self` that begins at position `from_i` and ends at position `to_j - 1`
+        by the associative word `by`. `from_i` and `to_j` must be positive
+        integers, indexing is done with origin 0. In other words,
+        `w.substituted_word(w, from_i, to_j, by)` is the product of the three
+        words: `w.subword(0, from_i)`, `by`, and
+        `w.subword(to_j len(w))`.
+
+        See Also
+        ========
+
+        eliminate_word
+
+        """
+        lw = len(self)
+        if from_i >= to_j or from_i > lw or to_j > lw:
+            raise ValueError("values should be within bounds")
+
+        # otherwise there are four possibilities
+
+        # first if from=1 and to=lw then
+        if from_i == 0 and to_j == lw:
+            return by
+        elif from_i == 0:  # second if from_i=1 (and to_j < lw) then
+            return by*self.subword(to_j, lw)
+        elif to_j == lw:   # third if to_j=1 (and from_i > 1) then
+            return self.subword(0, from_i)*by
+        else:              # finally
+            return self.subword(0, from_i)*by*self.subword(to_j, lw)
+
+    def is_cyclically_reduced(self):
+        r"""Returns whether the word is cyclically reduced or not.
+        A word is cyclically reduced if by forming the cycle of the
+        word, the word is not reduced, i.e a word w = `a_1 ... a_n`
+        is called cyclically reduced if `a_1 \ne a_n^{-1}`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**2*y**-1*x**-1).is_cyclically_reduced()
+        False
+        >>> (y*x**2*y**2).is_cyclically_reduced()
+        True
+
+        """
+        if not self:
+            return True
+        return self[0] != self[-1]**-1
+
+    def identity_cyclic_reduction(self):
+        """Return a unique cyclically reduced version of the word.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**2*y**2*x**-1).identity_cyclic_reduction()
+        x*y**2
+        >>> (x**-3*y**-1*x**5).identity_cyclic_reduction()
+        x**2*y**-1
+
+        References
+        ==========
+
+        .. [1] https://planetmath.org/cyclicallyreduced
+
+        """
+        word = self.copy()
+        group = self.group
+        while not word.is_cyclically_reduced():
+            exp1 = word.exponent_syllable(0)
+            exp2 = word.exponent_syllable(-1)
+            r = exp1 + exp2
+            if r == 0:
+                rep = word.array_form[1: word.number_syllables() - 1]
+            else:
+                rep = ((word.generator_syllable(0), exp1 + exp2),) + \
+                        word.array_form[1: word.number_syllables() - 1]
+            word = group.dtype(rep)
+        return word
+
+    def cyclic_reduction(self, removed=False):
+        """Return a cyclically reduced version of the word. Unlike
+        `identity_cyclic_reduction`, this will not cyclically permute
+        the reduced word - just remove the "unreduced" bits on either
+        side of it. Compare the examples with those of
+        `identity_cyclic_reduction`.
+
+        When `removed` is `True`, return a tuple `(word, r)` where
+        self `r` is such that before the reduction the word was either
+        `r*word*r**-1`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**2*y**2*x**-1).cyclic_reduction()
+        x*y**2
+        >>> (x**-3*y**-1*x**5).cyclic_reduction()
+        y**-1*x**2
+        >>> (x**-3*y**-1*x**5).cyclic_reduction(removed=True)
+        (y**-1*x**2, x**-3)
+
+        """
+        word = self.copy()
+        g = self.group.identity
+        while not word.is_cyclically_reduced():
+            exp1 = abs(word.exponent_syllable(0))
+            exp2 = abs(word.exponent_syllable(-1))
+            exp = min(exp1, exp2)
+            start = word[0]**abs(exp)
+            end = word[-1]**abs(exp)
+            word = start**-1*word*end**-1
+            g = g*start
+        if removed:
+            return word, g
+        return word
+
+    def power_of(self, other):
+        '''
+        Check if `self == other**n` for some integer n.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> ((x*y)**2).power_of(x*y)
+        True
+        >>> (x**-3*y**-2*x**3).power_of(x**-3*y*x**3)
+        True
+
+        '''
+        if self.is_identity:
+            return True
+
+        l = len(other)
+        if l == 1:
+            # self has to be a power of one generator
+            gens = self.contains_generators()
+            s = other in gens or other**-1 in gens
+            return len(gens) == 1 and s
+
+        # if self is not cyclically reduced and it is a power of other,
+        # other isn't cyclically reduced and the parts removed during
+        # their reduction must be equal
+        reduced, r1 = self.cyclic_reduction(removed=True)
+        if not r1.is_identity:
+            other, r2 = other.cyclic_reduction(removed=True)
+            if r1 == r2:
+                return reduced.power_of(other)
+            return False
+
+        if len(self) < l or len(self) % l:
+            return False
+
+        prefix = self.subword(0, l)
+        if prefix == other or prefix**-1 == other:
+            rest = self.subword(l, len(self))
+            return rest.power_of(other)
+        return False
+
+
+def letter_form_to_array_form(array_form, group):
+    """
+    This method converts a list given with possible repetitions of elements in
+    it. It returns a new list such that repetitions of consecutive elements is
+    removed and replace with a tuple element of size two such that the first
+    index contains `value` and the second index contains the number of
+    consecutive repetitions of `value`.
+
+    """
+    a = list(array_form[:])
+    new_array = []
+    n = 1
+    symbols = group.symbols
+    for i in range(len(a)):
+        if i == len(a) - 1:
+            if a[i] == a[i - 1]:
+                if (-a[i]) in symbols:
+                    new_array.append((-a[i], -n))
+                else:
+                    new_array.append((a[i], n))
+            else:
+                if (-a[i]) in symbols:
+                    new_array.append((-a[i], -1))
+                else:
+                    new_array.append((a[i], 1))
+            return new_array
+        elif a[i] == a[i + 1]:
+            n += 1
+        else:
+            if (-a[i]) in symbols:
+                new_array.append((-a[i], -n))
+            else:
+                new_array.append((a[i], n))
+            n = 1
+
+
+def zero_mul_simp(l, index):
+    """Used to combine two reduced words."""
+    while index >=0 and index < len(l) - 1 and l[index][0] == l[index + 1][0]:
+        exp = l[index][1] + l[index + 1][1]
+        base = l[index][0]
+        l[index] = (base, exp)
+        del l[index + 1]
+        if l[index][1] == 0:
+            del l[index]
+            index -= 1

env-llmeval/lib/python3.10/site-packages/sympy/combinatorics/galois.py

@@ -0,0 +1,611 @@
+r"""
+Construct transitive subgroups of symmetric groups, useful in Galois theory.
+
+Besides constructing instances of the :py:class:`~.PermutationGroup` class to
+represent the transitive subgroups of $S_n$ for small $n$, this module provides
+*names* for these groups.
+
+In some applications, it may be preferable to know the name of a group,
+rather than receive an instance of the :py:class:`~.PermutationGroup`
+class, and then have to do extra work to determine which group it is, by
+checking various properties.
+
+Names are instances of ``Enum`` classes defined in this module. With a name in
+hand, the name's ``get_perm_group`` method can then be used to retrieve a
+:py:class:`~.PermutationGroup`.
+
+The names used for groups in this module are taken from [1].
+
+References
+==========
+
+.. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
+
+"""
+
+from collections import defaultdict
+from enum import Enum
+import itertools
+
+from sympy.combinatorics.named_groups import (
+    SymmetricGroup, AlternatingGroup, CyclicGroup, DihedralGroup,
+    set_symmetric_group_properties, set_alternating_group_properties,
+)
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.permutations import Permutation
+
+
+class S1TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S1.
+    """
+    S1 = "S1"
+
+    def get_perm_group(self):
+        return SymmetricGroup(1)
+
+
+class S2TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S2.
+    """
+    S2 = "S2"
+
+    def get_perm_group(self):
+        return SymmetricGroup(2)
+
+
+class S3TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S3.
+    """
+    A3 = "A3"
+    S3 = "S3"
+
+    def get_perm_group(self):
+        if self == S3TransitiveSubgroups.A3:
+            return AlternatingGroup(3)
+        elif self == S3TransitiveSubgroups.S3:
+            return SymmetricGroup(3)
+
+
+class S4TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S4.
+    """
+    C4 = "C4"
+    V = "V"
+    D4 = "D4"
+    A4 = "A4"
+    S4 = "S4"
+
+    def get_perm_group(self):
+        if self == S4TransitiveSubgroups.C4:
+            return CyclicGroup(4)
+        elif self == S4TransitiveSubgroups.V:
+            return four_group()
+        elif self == S4TransitiveSubgroups.D4:
+            return DihedralGroup(4)
+        elif self == S4TransitiveSubgroups.A4:
+            return AlternatingGroup(4)
+        elif self == S4TransitiveSubgroups.S4:
+            return SymmetricGroup(4)
+
+
+class S5TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S5.
+    """
+    C5 = "C5"
+    D5 = "D5"
+    M20 = "M20"
+    A5 = "A5"
+    S5 = "S5"
+
+    def get_perm_group(self):
+        if self == S5TransitiveSubgroups.C5:
+            return CyclicGroup(5)
+        elif self == S5TransitiveSubgroups.D5:
+            return DihedralGroup(5)
+        elif self == S5TransitiveSubgroups.M20:
+            return M20()
+        elif self == S5TransitiveSubgroups.A5:
+            return AlternatingGroup(5)
+        elif self == S5TransitiveSubgroups.S5:
+            return SymmetricGroup(5)
+
+
+class S6TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S6.
+    """
+    C6 = "C6"
+    S3 = "S3"
+    D6 = "D6"
+    A4 = "A4"
+    G18 = "G18"
+    A4xC2 = "A4 x C2"
+    S4m = "S4-"
+    S4p = "S4+"
+    G36m = "G36-"
+    G36p = "G36+"
+    S4xC2 = "S4 x C2"
+    PSL2F5 = "PSL2(F5)"
+    G72 = "G72"
+    PGL2F5 = "PGL2(F5)"
+    A6 = "A6"
+    S6 = "S6"
+
+    def get_perm_group(self):
+        if self == S6TransitiveSubgroups.C6:
+            return CyclicGroup(6)
+        elif self == S6TransitiveSubgroups.S3:
+            return S3_in_S6()
+        elif self == S6TransitiveSubgroups.D6:
+            return DihedralGroup(6)
+        elif self == S6TransitiveSubgroups.A4:
+            return A4_in_S6()
+        elif self == S6TransitiveSubgroups.G18:
+            return G18()
+        elif self == S6TransitiveSubgroups.A4xC2:
+            return A4xC2()
+        elif self == S6TransitiveSubgroups.S4m:
+            return S4m()
+        elif self == S6TransitiveSubgroups.S4p:
+            return S4p()
+        elif self == S6TransitiveSubgroups.G36m:
+            return G36m()
+        elif self == S6TransitiveSubgroups.G36p:
+            return G36p()
+        elif self == S6TransitiveSubgroups.S4xC2:
+            return S4xC2()
+        elif self == S6TransitiveSubgroups.PSL2F5:
+            return PSL2F5()
+        elif self == S6TransitiveSubgroups.G72:
+            return G72()
+        elif self == S6TransitiveSubgroups.PGL2F5:
+            return PGL2F5()
+        elif self == S6TransitiveSubgroups.A6:
+            return AlternatingGroup(6)
+        elif self == S6TransitiveSubgroups.S6:
+            return SymmetricGroup(6)
+
+
+def four_group():
+    """
+    Return a representation of the Klein four-group as a transitive subgroup
+    of S4.
+    """
+    return PermutationGroup(
+        Permutation(0, 1)(2, 3),
+        Permutation(0, 2)(1, 3)
+    )
+
+
+def M20():
+    """
+    Return a representation of the metacyclic group M20, a transitive subgroup
+    of S5 that is one of the possible Galois groups for polys of degree 5.
+
+    Notes
+    =====
+
+    See [1], Page 323.
+
+    """
+    G = PermutationGroup(Permutation(0, 1, 2, 3, 4), Permutation(1, 2, 4, 3))
+    G._degree = 5
+    G._order = 20
+    G._is_transitive = True
+    G._is_sym = False
+    G._is_alt = False
+    G._is_cyclic = False
+    G._is_dihedral = False
+    return G
+
+
+def S3_in_S6():
+    """
+    Return a representation of S3 as a transitive subgroup of S6.
+
+    Notes
+    =====
+
+    The representation is found by viewing the group as the symmetries of a
+    triangular prism.
+
+    """
+    G = PermutationGroup(Permutation(0, 1, 2)(3, 4, 5), Permutation(0, 3)(2, 4)(1, 5))
+    set_symmetric_group_properties(G, 3, 6)
+    return G
+
+
+def A4_in_S6():
+    """
+    Return a representation of A4 as a transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(Permutation(0, 4, 5)(1, 3, 2), Permutation(0, 1, 2)(3, 5, 4))
+    set_alternating_group_properties(G, 4, 6)
+    return G
+
+
+def S4m():
+    """
+    Return a representation of the S4- transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(Permutation(1, 4, 5, 3), Permutation(0, 4)(1, 5)(2, 3))
+    set_symmetric_group_properties(G, 4, 6)
+    return G
+
+
+def S4p():
+    """
+    Return a representation of the S4+ transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(Permutation(0, 2, 4, 1)(3, 5), Permutation(0, 3)(4, 5))
+    set_symmetric_group_properties(G, 4, 6)
+    return G
+
+
+def A4xC2():
+    """
+    Return a representation of the (A4 x C2) transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(0, 4, 5)(1, 3, 2), Permutation(0, 1, 2)(3, 5, 4),
+        Permutation(5)(2, 4))
+
+
+def S4xC2():
+    """
+    Return a representation of the (S4 x C2) transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(1, 4, 5, 3), Permutation(0, 4)(1, 5)(2, 3),
+        Permutation(1, 4)(3, 5))
+
+
+def G18():
+    """
+    Return a representation of the group G18, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with C2.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2), Permutation(3, 4, 5),
+        Permutation(0, 4)(1, 5)(2, 3))
+
+
+def G36m():
+    """
+    Return a representation of the group G36-, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with C2^2.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2), Permutation(3, 4, 5),
+        Permutation(1, 2)(3, 5), Permutation(0, 4)(1, 5)(2, 3))
+
+
+def G36p():
+    """
+    Return a representation of the group G36+, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with C4.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2), Permutation(3, 4, 5),
+        Permutation(0, 5, 2, 3)(1, 4))
+
+
+def G72():
+    """
+    Return a representation of the group G72, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with D4.
+
+    Notes
+    =====
+
+    See [1], Page 325.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2),
+        Permutation(0, 4, 1, 3)(2, 5), Permutation(0, 3)(1, 4)(2, 5))
+
+
+def PSL2F5():
+    r"""
+    Return a representation of the group $PSL_2(\mathbb{F}_5)$, as a transitive
+    subgroup of S6, isomorphic to $A_5$.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(
+        Permutation(0, 4, 5)(1, 3, 2), Permutation(0, 4, 3, 1, 5))
+    set_alternating_group_properties(G, 5, 6)
+    return G
+
+
+def PGL2F5():
+    r"""
+    Return a representation of the group $PGL_2(\mathbb{F}_5)$, as a transitive
+    subgroup of S6, isomorphic to $S_5$.
+
+    Notes
+    =====
+
+    See [1], Page 325.
+
+    """
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3, 4), Permutation(0, 5)(1, 2)(3, 4))
+    set_symmetric_group_properties(G, 5, 6)
+    return G
+
+
+def find_transitive_subgroups_of_S6(*targets, print_report=False):
+    r"""
+    Search for certain transitive subgroups of $S_6$.
+
+    The symmetric group $S_6$ has 16 different transitive subgroups, up to
+    conjugacy. Some are more easily constructed than others. For example, the
+    dihedral group $D_6$ is immediately found, but it is not at all obvious how
+    to realize $S_4$ or $S_5$ *transitively* within $S_6$.
+
+    In some cases there are well-known constructions that can be used. For
+    example, $S_5$ is isomorphic to $PGL_2(\mathbb{F}_5)$, which acts in a
+    natural way on the projective line $P^1(\mathbb{F}_5)$, a set of order 6.
+
+    In absence of such special constructions however, we can simply search for
+    generators. For example, transitive instances of $A_4$ and $S_4$ can be
+    found within $S_6$ in this way.
+
+    Once we are engaged in such searches, it may then be easier (if less
+    elegant) to find even those groups like $S_5$ that do have special
+    constructions, by mere search.
+
+    This function locates generators for transitive instances in $S_6$ of the
+    following subgroups:
+
+    * $A_4$
+    * $S_4^-$ ($S_4$ not contained within $A_6$)
+    * $S_4^+$ ($S_4$ contained within $A_6$)
+    * $A_4 \times C_2$
+    * $S_4 \times C_2$
+    * $G_{18}   = C_3^2 \rtimes C_2$
+    * $G_{36}^- = C_3^2 \rtimes C_2^2$
+    * $G_{36}^+ = C_3^2 \rtimes C_4$
+    * $G_{72}   = C_3^2 \rtimes D_4$
+    * $A_5$
+    * $S_5$
+
+    Note: Each of these groups also has a dedicated function in this module
+    that returns the group immediately, using generators that were found by
+    this search procedure.
+
+    The search procedure serves as a record of how these generators were
+    found. Also, due to randomness in the generation of the elements of
+    permutation groups, it can be called again, in order to (probably) get
+    different generators for the same groups.
+
+    Parameters
+    ==========
+
+    targets : list of :py:class:`~.S6TransitiveSubgroups` values
+        The groups you want to find.
+
+    print_report : bool (default False)
+        If True, print to stdout the generators found for each group.
+
+    Returns
+    =======
+
+    dict
+        mapping each name in *targets* to the :py:class:`~.PermutationGroup`
+        that was found
+
+    References
+    ==========
+
+    .. [2] https://en.wikipedia.org/wiki/Projective_linear_group#Exceptional_isomorphisms
+    .. [3] https://en.wikipedia.org/wiki/Automorphisms_of_the_symmetric_and_alternating_groups#PGL(2,5)
+
+    """
+    def elts_by_order(G):
+        """Sort the elements of a group by their order. """
+        elts = defaultdict(list)
+        for g in G.elements:
+            elts[g.order()].append(g)
+        return elts
+
+    def order_profile(G, name=None):
+        """Determine how many elements a group has, of each order. """
+        elts = elts_by_order(G)
+        profile = {o:len(e) for o, e in elts.items()}
+        if name:
+            print(f'{name}: ' + ' '.join(f'{len(profile[r])}@{r}' for r in sorted(profile.keys())))
+        return profile
+
+    S6 = SymmetricGroup(6)
+    A6 = AlternatingGroup(6)
+    S6_by_order = elts_by_order(S6)
+
+    def search(existing_gens, needed_gen_orders, order, alt=None, profile=None, anti_profile=None):
+        """
+        Find a transitive subgroup of S6.
+
+        Parameters
+        ==========
+
+        existing_gens : list of Permutation
+            Optionally empty list of generators that must be in the group.
+
+        needed_gen_orders : list of positive int
+            Nonempty list of the orders of the additional generators that are
+            to be found.
+
+        order: int
+            The order of the group being sought.
+
+        alt: bool, None
+            If True, require the group to be contained in A6.
+            If False, require the group not to be contained in A6.
+
+        profile : dict
+            If given, the group's order profile must equal this.
+
+        anti_profile : dict
+            If given, the group's order profile must *not* equal this.
+
+        """
+        for gens in itertools.product(*[S6_by_order[n] for n in needed_gen_orders]):
+            if len(set(gens)) < len(gens):
+                continue
+            G = PermutationGroup(existing_gens + list(gens))
+            if G.order() == order and G.is_transitive():
+                if alt is not None and G.is_subgroup(A6) != alt:
+                    continue
+                if profile and order_profile(G) != profile:
+                    continue
+                if anti_profile and order_profile(G) == anti_profile:
+                    continue
+                return G
+
+    def match_known_group(G, alt=None):
+        needed = [g.order() for g in G.generators]
+        return search([], needed, G.order(), alt=alt, profile=order_profile(G))
+
+    found = {}
+
+    def finish_up(name, G):
+        found[name] = G
+        if print_report:
+            print("=" * 40)
+            print(f"{name}:")
+            print(G.generators)
+
+    if S6TransitiveSubgroups.A4 in targets or S6TransitiveSubgroups.A4xC2 in targets:
+        A4_in_S6 = match_known_group(AlternatingGroup(4))
+        finish_up(S6TransitiveSubgroups.A4, A4_in_S6)
+
+    if S6TransitiveSubgroups.S4m in targets or S6TransitiveSubgroups.S4xC2 in targets:
+        S4m_in_S6 = match_known_group(SymmetricGroup(4), alt=False)
+        finish_up(S6TransitiveSubgroups.S4m, S4m_in_S6)
+
+    if S6TransitiveSubgroups.S4p in targets:
+        S4p_in_S6 = match_known_group(SymmetricGroup(4), alt=True)
+        finish_up(S6TransitiveSubgroups.S4p, S4p_in_S6)
+
+    if S6TransitiveSubgroups.A4xC2 in targets:
+        A4xC2_in_S6 = search(A4_in_S6.generators, [2], 24, anti_profile=order_profile(SymmetricGroup(4)))
+        finish_up(S6TransitiveSubgroups.A4xC2, A4xC2_in_S6)
+
+    if S6TransitiveSubgroups.S4xC2 in targets:
+        S4xC2_in_S6 = search(S4m_in_S6.generators, [2], 48)
+        finish_up(S6TransitiveSubgroups.S4xC2, S4xC2_in_S6)
+
+    # For the normal factor N = C3^2 in any of the G_n subgroups, we take one
+    # obvious instance of C3^2 in S6:
+    N_gens = [Permutation(5)(0, 1, 2), Permutation(5)(3, 4, 5)]
+
+    if S6TransitiveSubgroups.G18 in targets:
+        G18_in_S6 = search(N_gens, [2], 18)
+        finish_up(S6TransitiveSubgroups.G18, G18_in_S6)
+
+    if S6TransitiveSubgroups.G36m in targets:
+        G36m_in_S6 = search(N_gens, [2, 2], 36, alt=False)
+        finish_up(S6TransitiveSubgroups.G36m, G36m_in_S6)
+
+    if S6TransitiveSubgroups.G36p in targets:
+        G36p_in_S6 = search(N_gens, [4], 36, alt=True)
+        finish_up(S6TransitiveSubgroups.G36p, G36p_in_S6)
+
+    if S6TransitiveSubgroups.G72 in targets:
+        G72_in_S6 = search(N_gens, [4, 2], 72)
+        finish_up(S6TransitiveSubgroups.G72, G72_in_S6)
+
+    # The PSL2(F5) and PGL2(F5) subgroups are isomorphic to A5 and S5, resp.
+
+    if S6TransitiveSubgroups.PSL2F5 in targets:
+        PSL2F5_in_S6 = match_known_group(AlternatingGroup(5))
+        finish_up(S6TransitiveSubgroups.PSL2F5, PSL2F5_in_S6)
+
+    if S6TransitiveSubgroups.PGL2F5 in targets:
+        PGL2F5_in_S6 = match_known_group(SymmetricGroup(5))
+        finish_up(S6TransitiveSubgroups.PGL2F5, PGL2F5_in_S6)
+
+    # There is little need to "search" for any of the groups C6, S3, D6, A6,
+    # or S6, since they all have obvious realizations within S6. However, we
+    # support them here just in case a random representation is desired.
+
+    if S6TransitiveSubgroups.C6 in targets:
+        C6 = match_known_group(CyclicGroup(6))
+        finish_up(S6TransitiveSubgroups.C6, C6)
+
+    if S6TransitiveSubgroups.S3 in targets:
+        S3 = match_known_group(SymmetricGroup(3))
+        finish_up(S6TransitiveSubgroups.S3, S3)
+
+    if S6TransitiveSubgroups.D6 in targets:
+        D6 = match_known_group(DihedralGroup(6))
+        finish_up(S6TransitiveSubgroups.D6, D6)
+
+    if S6TransitiveSubgroups.A6 in targets:
+        A6 = match_known_group(A6)
+        finish_up(S6TransitiveSubgroups.A6, A6)
+
+    if S6TransitiveSubgroups.S6 in targets:
+        S6 = match_known_group(S6)
+        finish_up(S6TransitiveSubgroups.S6, S6)
+
+    return found

env-llmeval/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

env-llmeval/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)

env-llmeval/lib/python3.10/site-packages/sympy/combinatorics/group_numbers.py

@@ -0,0 +1,118 @@
+from sympy.core import Integer, Pow, Mod
+from sympy import factorint
+
+
+def is_nilpotent_number(n):
+    """
+    Check whether `n` is a nilpotent number. A number `n` is said to be
+    nilpotent if and only if every finite group of order `n` is nilpotent.
+    For more information see [1]_.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import is_nilpotent_number
+    >>> from sympy import randprime
+    >>> is_nilpotent_number(21)
+    False
+    >>> is_nilpotent_number(randprime(1, 30)**12)
+    True
+
+    References
+    ==========
+
+    .. [1] Pakianathan, J., Shankar, K., *Nilpotent Numbers*,
+            The American Mathematical Monthly, 107(7), 631-634.
+
+
+    """
+    if n <= 0 or int(n) != n:
+        raise ValueError("n must be a positive integer, not %i" % n)
+
+    n = Integer(n)
+    prime_factors = list(factorint(n).items())
+    is_nilpotent = True
+    for p_j, a_j in prime_factors:
+        for p_i, a_i in prime_factors:
+            if any([Mod(Pow(p_i, k), p_j) == 1 for k in range(1, a_i + 1)]):
+                is_nilpotent = False
+                break
+        if not is_nilpotent:
+            break
+
+    return is_nilpotent
+
+
+def is_abelian_number(n):
+    """
+    Check whether `n` is an abelian number. A number `n` is said to be abelian
+    if and only if every finite group of order `n` is abelian. For more
+    information see [1]_.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import is_abelian_number
+    >>> from sympy import randprime
+    >>> is_abelian_number(4)
+    True
+    >>> is_abelian_number(randprime(1, 2000)**2)
+    True
+    >>> is_abelian_number(60)
+    False
+
+    References
+    ==========
+
+    .. [1] Pakianathan, J., Shankar, K., *Nilpotent Numbers*,
+            The American Mathematical Monthly, 107(7), 631-634.
+
+
+    """
+    if n <= 0 or int(n) != n:
+        raise ValueError("n must be a positive integer, not %i" % n)
+
+    n = Integer(n)
+    if not is_nilpotent_number(n):
+        return False
+
+    prime_factors = list(factorint(n).items())
+    is_abelian = all(a_i < 3 for p_i, a_i in prime_factors)
+    return is_abelian
+
+
+def is_cyclic_number(n):
+    """
+    Check whether `n` is a cyclic number. A number `n` is said to be cyclic
+    if and only if every finite group of order `n` is cyclic. For more
+    information see [1]_.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import is_cyclic_number
+    >>> from sympy import randprime
+    >>> is_cyclic_number(15)
+    True
+    >>> is_cyclic_number(randprime(1, 2000)**2)
+    False
+    >>> is_cyclic_number(4)
+    False
+
+    References
+    ==========
+
+    .. [1] Pakianathan, J., Shankar, K., *Nilpotent Numbers*,
+            The American Mathematical Monthly, 107(7), 631-634.
+
+    """
+    if n <= 0 or int(n) != n:
+        raise ValueError("n must be a positive integer, not %i" % n)
+
+    n = Integer(n)
+    if not is_nilpotent_number(n):
+        return False
+
+    prime_factors = list(factorint(n).items())
+    is_cyclic = all(a_i < 2 for p_i, a_i in prime_factors)
+    return is_cyclic