Add files using upload-large-folder tool

.gitattributes

@@ -1084,3 +1084,5 @@ mantis_evalkit/lib/python3.10/site-packages/pyarrow/libarrow.so.1900 filter=lfs
 wemm/lib/python3.10/site-packages/nvfuser/_C.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 mgm/lib/python3.10/site-packages/torchvision/_C.so filter=lfs diff=lfs merge=lfs -text
 mgm/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/__pycache__/beam.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vila/lib/python3.10/site-packages/opencv_python.libs/libavcodec-402e4b05.so.59.37.100 filter=lfs diff=lfs merge=lfs -text
+mgm/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

mgm/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-310.pyc

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

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

@@ -0,0 +1,1354 @@
+"""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)
+
+    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):
+    """
+    Simplifies a set of relators. 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 _simplify_relators
+    >>> F, x, y = free_group("x, y")
+    >>> w1 = [x**2*y**4, x**3]
+    >>> _simplify_relators(w1)
+    [x**3, x**-1*y**4]
+
+    >>> w2 = [x**2*y**-4*x**5, x**3, x**2*y**8, y**5]
+    >>> _simplify_relators(w2)
+    [x**-1*y**-2, x**-1*y*x**-1, x**3, y**5]
+
+    >>> w3 = [x**6*y**4, x**4]
+    >>> _simplify_relators(w3)
+    [x**4, x**2*y**4]
+
+    >>> w4 = [x**2, x**5, y**3]
+    >>> _simplify_relators(w4)
+    [x, y**3]
+
+    """
+    rels = rels[:]
+
+    if not rels:
+        return []
+
+    identity = rels[0].group.identity
+
+    # build 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 = list(exps.values())
+    # decrease some of the exponents in relators, making use of the single
+    # syllable relators
+    for i, rel in enumerate(rels):
+        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]
+
+    rels += one_syllables_words # include one_syllable_words in the list of relators
+    rels = list(set(rels)) # get unique values in rels
+    rels.sort()
+
+    # remove <identity> entries 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
+
+###############################################################################
+#                           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

mgm/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%282,5%29
+
+    """
+    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

mgm/lib/python3.10/site-packages/sympy/combinatorics/homomorphisms.py

@@ -0,0 +1,549 @@
+import itertools
+from sympy.combinatorics.fp_groups import FpGroup, FpSubgroup, simplify_presentation
+from sympy.combinatorics.free_groups import FreeGroup
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.core.intfunc import igcd
+from sympy.functions.combinatorial.numbers import totient
+from sympy.core.singleton import S
+
+class GroupHomomorphism:
+    '''
+    A class representing group homomorphisms. Instantiate using `homomorphism()`.
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B. and O'Brien, E. (2005). Handbook of computational group theory.
+
+    '''
+
+    def __init__(self, domain, codomain, images):
+        self.domain = domain
+        self.codomain = codomain
+        self.images = images
+        self._inverses = None
+        self._kernel = None
+        self._image = None
+
+    def _invs(self):
+        '''
+        Return a dictionary with `{gen: inverse}` where `gen` is a rewriting
+        generator of `codomain` (e.g. strong generator for permutation groups)
+        and `inverse` is an element of its preimage
+
+        '''
+        image = self.image()
+        inverses = {}
+        for k in list(self.images.keys()):
+            v = self.images[k]
+            if not (v in inverses
+                    or v.is_identity):
+                inverses[v] = k
+        if isinstance(self.codomain, PermutationGroup):
+            gens = image.strong_gens
+        else:
+            gens = image.generators
+        for g in gens:
+            if g in inverses or g.is_identity:
+                continue
+            w = self.domain.identity
+            if isinstance(self.codomain, PermutationGroup):
+                parts = image._strong_gens_slp[g][::-1]
+            else:
+                parts = g
+            for s in parts:
+                if s in inverses:
+                    w = w*inverses[s]
+                else:
+                    w = w*inverses[s**-1]**-1
+            inverses[g] = w
+
+        return inverses
+
+    def invert(self, g):
+        '''
+        Return an element of the preimage of ``g`` or of each element
+        of ``g`` if ``g`` is a list.
+
+        Explanation
+        ===========
+
+        If the codomain is an FpGroup, the inverse for equal
+        elements might not always be the same unless the FpGroup's
+        rewriting system is confluent. However, making a system
+        confluent can be time-consuming. If it's important, try
+        `self.codomain.make_confluent()` first.
+
+        '''
+        from sympy.combinatorics import Permutation
+        from sympy.combinatorics.free_groups import FreeGroupElement
+        if isinstance(g, (Permutation, FreeGroupElement)):
+            if isinstance(self.codomain, FpGroup):
+                g = self.codomain.reduce(g)
+            if self._inverses is None:
+                self._inverses = self._invs()
+            image = self.image()
+            w = self.domain.identity
+            if isinstance(self.codomain, PermutationGroup):
+                gens = image.generator_product(g)[::-1]
+            else:
+                gens = g
+            # the following can't be "for s in gens:"
+            # because that would be equivalent to
+            # "for s in gens.array_form:" when g is
+            # a FreeGroupElement. On the other hand,
+            # when you call gens by index, the generator
+            # (or inverse) at position i is returned.
+            for i in range(len(gens)):
+                s = gens[i]
+                if s.is_identity:
+                    continue
+                if s in self._inverses:
+                    w = w*self._inverses[s]
+                else:
+                    w = w*self._inverses[s**-1]**-1
+            return w
+        elif isinstance(g, list):
+            return [self.invert(e) for e in g]
+
+    def kernel(self):
+        '''
+        Compute the kernel of `self`.
+
+        '''
+        if self._kernel is None:
+            self._kernel = self._compute_kernel()
+        return self._kernel
+
+    def _compute_kernel(self):
+        G = self.domain
+        G_order = G.order()
+        if G_order is S.Infinity:
+            raise NotImplementedError(
+                "Kernel computation is not implemented for infinite groups")
+        gens = []
+        if isinstance(G, PermutationGroup):
+            K = PermutationGroup(G.identity)
+        else:
+            K = FpSubgroup(G, gens, normal=True)
+        i = self.image().order()
+        while K.order()*i != G_order:
+            r = G.random()
+            k = r*self.invert(self(r))**-1
+            if k not in K:
+                gens.append(k)
+                if isinstance(G, PermutationGroup):
+                    K = PermutationGroup(gens)
+                else:
+                    K = FpSubgroup(G, gens, normal=True)
+        return K
+
+    def image(self):
+        '''
+        Compute the image of `self`.
+
+        '''
+        if self._image is None:
+            values = list(set(self.images.values()))
+            if isinstance(self.codomain, PermutationGroup):
+                self._image = self.codomain.subgroup(values)
+            else:
+                self._image = FpSubgroup(self.codomain, values)
+        return self._image
+
+    def _apply(self, elem):
+        '''
+        Apply `self` to `elem`.
+
+        '''
+        if elem not in self.domain:
+            if isinstance(elem, (list, tuple)):
+                return [self._apply(e) for e in elem]
+            raise ValueError("The supplied element does not belong to the domain")
+        if elem.is_identity:
+            return self.codomain.identity
+        else:
+            images = self.images
+            value = self.codomain.identity
+            if isinstance(self.domain, PermutationGroup):
+                gens = self.domain.generator_product(elem, original=True)
+                for g in gens:
+                    if g in self.images:
+                        value = images[g]*value
+                    else:
+                        value = images[g**-1]**-1*value
+            else:
+                i = 0
+                for _, p in elem.array_form:
+                    if p < 0:
+                        g = elem[i]**-1
+                    else:
+                        g = elem[i]
+                    value = value*images[g]**p
+                    i += abs(p)
+        return value
+
+    def __call__(self, elem):
+        return self._apply(elem)
+
+    def is_injective(self):
+        '''
+        Check if the homomorphism is injective
+
+        '''
+        return self.kernel().order() == 1
+
+    def is_surjective(self):
+        '''
+        Check if the homomorphism is surjective
+
+        '''
+        im = self.image().order()
+        oth = self.codomain.order()
+        if im is S.Infinity and oth is S.Infinity:
+            return None
+        else:
+            return im == oth
+
+    def is_isomorphism(self):
+        '''
+        Check if `self` is an isomorphism.
+
+        '''
+        return self.is_injective() and self.is_surjective()
+
+    def is_trivial(self):
+        '''
+        Check is `self` is a trivial homomorphism, i.e. all elements
+        are mapped to the identity.
+
+        '''
+        return self.image().order() == 1
+
+    def compose(self, other):
+        '''
+        Return the composition of `self` and `other`, i.e.
+        the homomorphism phi such that for all g in the domain
+        of `other`, phi(g) = self(other(g))
+
+        '''
+        if not other.image().is_subgroup(self.domain):
+            raise ValueError("The image of `other` must be a subgroup of "
+                    "the domain of `self`")
+        images = {g: self(other(g)) for g in other.images}
+        return GroupHomomorphism(other.domain, self.codomain, images)
+
+    def restrict_to(self, H):
+        '''
+        Return the restriction of the homomorphism to the subgroup `H`
+        of the domain.
+
+        '''
+        if not isinstance(H, PermutationGroup) or not H.is_subgroup(self.domain):
+            raise ValueError("Given H is not a subgroup of the domain")
+        domain = H
+        images = {g: self(g) for g in H.generators}
+        return GroupHomomorphism(domain, self.codomain, images)
+
+    def invert_subgroup(self, H):
+        '''
+        Return the subgroup of the domain that is the inverse image
+        of the subgroup ``H`` of the homomorphism image
+
+        '''
+        if not H.is_subgroup(self.image()):
+            raise ValueError("Given H is not a subgroup of the image")
+        gens = []
+        P = PermutationGroup(self.image().identity)
+        for h in H.generators:
+            h_i = self.invert(h)
+            if h_i not in P:
+                gens.append(h_i)
+                P = PermutationGroup(gens)
+            for k in self.kernel().generators:
+                if k*h_i not in P:
+                    gens.append(k*h_i)
+                    P = PermutationGroup(gens)
+        return P
+
+def homomorphism(domain, codomain, gens, images=(), check=True):
+    '''
+    Create (if possible) a group homomorphism from the group ``domain``
+    to the group ``codomain`` defined by the images of the domain's
+    generators ``gens``. ``gens`` and ``images`` can be either lists or tuples
+    of equal sizes. If ``gens`` is a proper subset of the group's generators,
+    the unspecified generators will be mapped to the identity. If the
+    images are not specified, a trivial homomorphism will be created.
+
+    If the given images of the generators do not define a homomorphism,
+    an exception is raised.
+
+    If ``check`` is ``False``, do not check whether the given images actually
+    define a homomorphism.
+
+    '''
+    if not isinstance(domain, (PermutationGroup, FpGroup, FreeGroup)):
+        raise TypeError("The domain must be a group")
+    if not isinstance(codomain, (PermutationGroup, FpGroup, FreeGroup)):
+        raise TypeError("The codomain must be a group")
+
+    generators = domain.generators
+    if not all(g in generators for g in gens):
+        raise ValueError("The supplied generators must be a subset of the domain's generators")
+    if not all(g in codomain for g in images):
+        raise ValueError("The images must be elements of the codomain")
+
+    if images and len(images) != len(gens):
+        raise ValueError("The number of images must be equal to the number of generators")
+
+    gens = list(gens)
+    images = list(images)
+
+    images.extend([codomain.identity]*(len(generators)-len(images)))
+    gens.extend([g for g in generators if g not in gens])
+    images = dict(zip(gens,images))
+
+    if check and not _check_homomorphism(domain, codomain, images):
+        raise ValueError("The given images do not define a homomorphism")
+    return GroupHomomorphism(domain, codomain, images)
+
+def _check_homomorphism(domain, codomain, images):
+    """
+    Check that a given mapping of generators to images defines a homomorphism.
+
+    Parameters
+    ==========
+    domain : PermutationGroup, FpGroup, FreeGroup
+    codomain : PermutationGroup, FpGroup, FreeGroup
+    images : dict
+        The set of keys must be equal to domain.generators.
+        The values must be elements of the codomain.
+
+    """
+    pres = domain if hasattr(domain, 'relators') else domain.presentation()
+    rels = pres.relators
+    gens = pres.generators
+    symbols = [g.ext_rep[0] for g in gens]
+    symbols_to_domain_generators = dict(zip(symbols, domain.generators))
+    identity = codomain.identity
+
+    def _image(r):
+        w = identity
+        for symbol, power in r.array_form:
+            g = symbols_to_domain_generators[symbol]
+            w *= images[g]**power
+        return w
+
+    for r in rels:
+        if isinstance(codomain, FpGroup):
+            s = codomain.equals(_image(r), identity)
+            if s is None:
+                # only try to make the rewriting system
+                # confluent when it can't determine the
+                # truth of equality otherwise
+                success = codomain.make_confluent()
+                s = codomain.equals(_image(r), identity)
+                if s is None and not success:
+                    raise RuntimeError("Can't determine if the images "
+                        "define a homomorphism. Try increasing "
+                        "the maximum number of rewriting rules "
+                        "(group._rewriting_system.set_max(new_value); "
+                        "the current value is stored in group._rewriting"
+                        "_system.maxeqns)")
+        else:
+            s = _image(r).is_identity
+        if not s:
+            return False
+    return True
+
+def orbit_homomorphism(group, omega):
+    '''
+    Return the homomorphism induced by the action of the permutation
+    group ``group`` on the set ``omega`` that is closed under the action.
+
+    '''
+    from sympy.combinatorics import Permutation
+    from sympy.combinatorics.named_groups import SymmetricGroup
+    codomain = SymmetricGroup(len(omega))
+    identity = codomain.identity
+    omega = list(omega)
+    images = {g: identity*Permutation([omega.index(o^g) for o in omega]) for g in group.generators}
+    group._schreier_sims(base=omega)
+    H = GroupHomomorphism(group, codomain, images)
+    if len(group.basic_stabilizers) > len(omega):
+        H._kernel = group.basic_stabilizers[len(omega)]
+    else:
+        H._kernel = PermutationGroup([group.identity])
+    return H
+
+def block_homomorphism(group, blocks):
+    '''
+    Return the homomorphism induced by the action of the permutation
+    group ``group`` on the block system ``blocks``. The latter should be
+    of the same form as returned by the ``minimal_block`` method for
+    permutation groups, namely a list of length ``group.degree`` where
+    the i-th entry is a representative of the block i belongs to.
+
+    '''
+    from sympy.combinatorics import Permutation
+    from sympy.combinatorics.named_groups import SymmetricGroup
+
+    n = len(blocks)
+
+    # number the blocks; m is the total number,
+    # b is such that b[i] is the number of the block i belongs to,
+    # p is the list of length m such that p[i] is the representative
+    # of the i-th block
+    m = 0
+    p = []
+    b = [None]*n
+    for i in range(n):
+        if blocks[i] == i:
+            p.append(i)
+            b[i] = m
+            m += 1
+    for i in range(n):
+        b[i] = b[blocks[i]]
+
+    codomain = SymmetricGroup(m)
+    # the list corresponding to the identity permutation in codomain
+    identity = range(m)
+    images = {g: Permutation([b[p[i]^g] for i in identity]) for g in group.generators}
+    H = GroupHomomorphism(group, codomain, images)
+    return H
+
+def group_isomorphism(G, H, isomorphism=True):
+    '''
+    Compute an isomorphism between 2 given groups.
+
+    Parameters
+    ==========
+
+    G : A finite ``FpGroup`` or a ``PermutationGroup``.
+        First group.
+
+    H : A finite ``FpGroup`` or a ``PermutationGroup``
+        Second group.
+
+    isomorphism : bool
+        This is used to avoid the computation of homomorphism
+        when the user only wants to check if there exists
+        an isomorphism between the groups.
+
+    Returns
+    =======
+
+    If isomorphism = False -- Returns a boolean.
+    If isomorphism = True  -- Returns a boolean and an isomorphism between `G` and `H`.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group, Permutation
+    >>> from sympy.combinatorics.perm_groups import PermutationGroup
+    >>> from sympy.combinatorics.fp_groups import FpGroup
+    >>> from sympy.combinatorics.homomorphisms import group_isomorphism
+    >>> from sympy.combinatorics.named_groups import DihedralGroup, AlternatingGroup
+
+    >>> D = DihedralGroup(8)
+    >>> p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    >>> P = PermutationGroup(p)
+    >>> group_isomorphism(D, P)
+    (False, None)
+
+    >>> F, a, b = free_group("a, b")
+    >>> G = FpGroup(F, [a**3, b**3, (a*b)**2])
+    >>> H = AlternatingGroup(4)
+    >>> (check, T) = group_isomorphism(G, H)
+    >>> check
+    True
+    >>> T(b*a*b**-1*a**-1*b**-1)
+    (0 2 3)
+
+    Notes
+    =====
+
+    Uses the approach suggested by Robert Tarjan to compute the isomorphism between two groups.
+    First, the generators of ``G`` are mapped to the elements of ``H`` and
+    we check if the mapping induces an isomorphism.
+
+    '''
+    if not isinstance(G, (PermutationGroup, FpGroup)):
+        raise TypeError("The group must be a PermutationGroup or an FpGroup")
+    if not isinstance(H, (PermutationGroup, FpGroup)):
+        raise TypeError("The group must be a PermutationGroup or an FpGroup")
+
+    if isinstance(G, FpGroup) and isinstance(H, FpGroup):
+        G = simplify_presentation(G)
+        H = simplify_presentation(H)
+        # Two infinite FpGroups with the same generators are isomorphic
+        # when the relators are same but are ordered differently.
+        if G.generators == H.generators and (G.relators).sort() == (H.relators).sort():
+            if not isomorphism:
+                return True
+            return (True, homomorphism(G, H, G.generators, H.generators))
+
+    #  `_H` is the permutation group isomorphic to `H`.
+    _H = H
+    g_order = G.order()
+    h_order = H.order()
+
+    if g_order is S.Infinity:
+        raise NotImplementedError("Isomorphism methods are not implemented for infinite groups.")
+
+    if isinstance(H, FpGroup):
+        if h_order is S.Infinity:
+            raise NotImplementedError("Isomorphism methods are not implemented for infinite groups.")
+        _H, h_isomorphism = H._to_perm_group()
+
+    if (g_order != h_order) or (G.is_abelian != H.is_abelian):
+        if not isomorphism:
+            return False
+        return (False, None)
+
+    if not isomorphism:
+        # Two groups of the same cyclic numbered order
+        # are isomorphic to each other.
+        n = g_order
+        if (igcd(n, totient(n))) == 1:
+            return True
+
+    # Match the generators of `G` with subsets of `_H`
+    gens = list(G.generators)
+    for subset in itertools.permutations(_H, len(gens)):
+        images = list(subset)
+        images.extend([_H.identity]*(len(G.generators)-len(images)))
+        _images = dict(zip(gens,images))
+        if _check_homomorphism(G, _H, _images):
+            if isinstance(H, FpGroup):
+                images = h_isomorphism.invert(images)
+            T =  homomorphism(G, H, G.generators, images, check=False)
+            if T.is_isomorphism():
+                # It is a valid isomorphism
+                if not isomorphism:
+                    return True
+                return (True, T)
+
+    if not isomorphism:
+        return False
+    return (False, None)
+
+def is_isomorphic(G, H):
+    '''
+    Check if the groups are isomorphic to each other
+
+    Parameters
+    ==========
+
+    G : A finite ``FpGroup`` or a ``PermutationGroup``
+        First group.
+
+    H : A finite ``FpGroup`` or a ``PermutationGroup``
+        Second group.
+
+    Returns
+    =======
+
+    boolean
+    '''
+    return group_isomorphism(G, H, isomorphism=False)

mgm/lib/python3.10/site-packages/sympy/combinatorics/permutations.py

@@ -0,0 +1,3115 @@
+import random
+from collections import defaultdict
+from collections.abc import Iterable
+from functools import reduce
+
+from sympy.core.parameters import global_parameters
+from sympy.core.basic import Atom
+from sympy.core.expr import Expr
+from sympy.core.numbers import int_valued
+from sympy.core.numbers import Integer
+from sympy.core.sympify import _sympify
+from sympy.matrices import zeros
+from sympy.polys.polytools import lcm
+from sympy.printing.repr import srepr
+from sympy.utilities.iterables import (flatten, has_variety, minlex,
+    has_dups, runs, is_sequence)
+from sympy.utilities.misc import as_int
+from mpmath.libmp.libintmath import ifac
+from sympy.multipledispatch import dispatch
+
+def _af_rmul(a, b):
+    """
+    Return the product b*a; input and output are array forms. The ith value
+    is a[b[i]].
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_rmul, Permutation
+
+    >>> a, b = [1, 0, 2], [0, 2, 1]
+    >>> _af_rmul(a, b)
+    [1, 2, 0]
+    >>> [a[b[i]] for i in range(3)]
+    [1, 2, 0]
+
+    This handles the operands in reverse order compared to the ``*`` operator:
+
+    >>> a = Permutation(a)
+    >>> b = Permutation(b)
+    >>> list(a*b)
+    [2, 0, 1]
+    >>> [b(a(i)) for i in range(3)]
+    [2, 0, 1]
+
+    See Also
+    ========
+
+    rmul, _af_rmuln
+    """
+    return [a[i] for i in b]
+
+
+def _af_rmuln(*abc):
+    """
+    Given [a, b, c, ...] return the product of ...*c*b*a using array forms.
+    The ith value is a[b[c[i]]].
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_rmul, Permutation
+
+    >>> a, b = [1, 0, 2], [0, 2, 1]
+    >>> _af_rmul(a, b)
+    [1, 2, 0]
+    >>> [a[b[i]] for i in range(3)]
+    [1, 2, 0]
+
+    This handles the operands in reverse order compared to the ``*`` operator:
+
+    >>> a = Permutation(a); b = Permutation(b)
+    >>> list(a*b)
+    [2, 0, 1]
+    >>> [b(a(i)) for i in range(3)]
+    [2, 0, 1]
+
+    See Also
+    ========
+
+    rmul, _af_rmul
+    """
+    a = abc
+    m = len(a)
+    if m == 3:
+        p0, p1, p2 = a
+        return [p0[p1[i]] for i in p2]
+    if m == 4:
+        p0, p1, p2, p3 = a
+        return [p0[p1[p2[i]]] for i in p3]
+    if m == 5:
+        p0, p1, p2, p3, p4 = a
+        return [p0[p1[p2[p3[i]]]] for i in p4]
+    if m == 6:
+        p0, p1, p2, p3, p4, p5 = a
+        return [p0[p1[p2[p3[p4[i]]]]] for i in p5]
+    if m == 7:
+        p0, p1, p2, p3, p4, p5, p6 = a
+        return [p0[p1[p2[p3[p4[p5[i]]]]]] for i in p6]
+    if m == 8:
+        p0, p1, p2, p3, p4, p5, p6, p7 = a
+        return [p0[p1[p2[p3[p4[p5[p6[i]]]]]]] for i in p7]
+    if m == 1:
+        return a[0][:]
+    if m == 2:
+        a, b = a
+        return [a[i] for i in b]
+    if m == 0:
+        raise ValueError("String must not be empty")
+    p0 = _af_rmuln(*a[:m//2])
+    p1 = _af_rmuln(*a[m//2:])
+    return [p0[i] for i in p1]
+
+
+def _af_parity(pi):
+    """
+    Computes the parity of a permutation in array form.
+
+    Explanation
+    ===========
+
+    The parity of a permutation reflects the parity of the
+    number of inversions in the permutation, i.e., the
+    number of pairs of x and y such that x > y but p[x] < p[y].
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_parity
+    >>> _af_parity([0, 1, 2, 3])
+    0
+    >>> _af_parity([3, 2, 0, 1])
+    1
+
+    See Also
+    ========
+
+    Permutation
+    """
+    n = len(pi)
+    a = [0] * n
+    c = 0
+    for j in range(n):
+        if a[j] == 0:
+            c += 1
+            a[j] = 1
+            i = j
+            while pi[i] != j:
+                i = pi[i]
+                a[i] = 1
+    return (n - c) % 2
+
+
+def _af_invert(a):
+    """
+    Finds the inverse, ~A, of a permutation, A, given in array form.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_invert, _af_rmul
+    >>> A = [1, 2, 0, 3]
+    >>> _af_invert(A)
+    [2, 0, 1, 3]
+    >>> _af_rmul(_, A)
+    [0, 1, 2, 3]
+
+    See Also
+    ========
+
+    Permutation, __invert__
+    """
+    inv_form = [0] * len(a)
+    for i, ai in enumerate(a):
+        inv_form[ai] = i
+    return inv_form
+
+
+def _af_pow(a, n):
+    """
+    Routine for finding powers of a permutation.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.combinatorics.permutations import _af_pow
+    >>> p = Permutation([2, 0, 3, 1])
+    >>> p.order()
+    4
+    >>> _af_pow(p._array_form, 4)
+    [0, 1, 2, 3]
+    """
+    if n == 0:
+        return list(range(len(a)))
+    if n < 0:
+        return _af_pow(_af_invert(a), -n)
+    if n == 1:
+        return a[:]
+    elif n == 2:
+        b = [a[i] for i in a]
+    elif n == 3:
+        b = [a[a[i]] for i in a]
+    elif n == 4:
+        b = [a[a[a[i]]] for i in a]
+    else:
+        # use binary multiplication
+        b = list(range(len(a)))
+        while 1:
+            if n & 1:
+                b = [b[i] for i in a]
+                n -= 1
+                if not n:
+                    break
+            if n % 4 == 0:
+                a = [a[a[a[i]]] for i in a]
+                n = n // 4
+            elif n % 2 == 0:
+                a = [a[i] for i in a]
+                n = n // 2
+    return b
+
+
+def _af_commutes_with(a, b):
+    """
+    Checks if the two permutations with array forms
+    given by ``a`` and ``b`` commute.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_commutes_with
+    >>> _af_commutes_with([1, 2, 0], [0, 2, 1])
+    False
+
+    See Also
+    ========
+
+    Permutation, commutes_with
+    """
+    return not any(a[b[i]] != b[a[i]] for i in range(len(a) - 1))
+
+
+class Cycle(dict):
+    """
+    Wrapper around dict which provides the functionality of a disjoint cycle.
+
+    Explanation
+    ===========
+
+    A cycle shows the rule to use to move subsets of elements to obtain
+    a permutation. The Cycle class is more flexible than Permutation in
+    that 1) all elements need not be present in order to investigate how
+    multiple cycles act in sequence and 2) it can contain singletons:
+
+    >>> from sympy.combinatorics.permutations import Perm, Cycle
+
+    A Cycle will automatically parse a cycle given as a tuple on the rhs:
+
+    >>> Cycle(1, 2)(2, 3)
+    (1 3 2)
+
+    The identity cycle, Cycle(), can be used to start a product:
+
+    >>> Cycle()(1, 2)(2, 3)
+    (1 3 2)
+
+    The array form of a Cycle can be obtained by calling the list
+    method (or passing it to the list function) and all elements from
+    0 will be shown:
+
+    >>> a = Cycle(1, 2)
+    >>> a.list()
+    [0, 2, 1]
+    >>> list(a)
+    [0, 2, 1]
+
+    If a larger (or smaller) range is desired use the list method and
+    provide the desired size -- but the Cycle cannot be truncated to
+    a size smaller than the largest element that is out of place:
+
+    >>> b = Cycle(2, 4)(1, 2)(3, 1, 4)(1, 3)
+    >>> b.list()
+    [0, 2, 1, 3, 4]
+    >>> b.list(b.size + 1)
+    [0, 2, 1, 3, 4, 5]
+    >>> b.list(-1)
+    [0, 2, 1]
+
+    Singletons are not shown when printing with one exception: the largest
+    element is always shown -- as a singleton if necessary:
+
+    >>> Cycle(1, 4, 10)(4, 5)
+    (1 5 4 10)
+    >>> Cycle(1, 2)(4)(5)(10)
+    (1 2)(10)
+
+    The array form can be used to instantiate a Permutation so other
+    properties of the permutation can be investigated:
+
+    >>> Perm(Cycle(1, 2)(3, 4).list()).transpositions()
+    [(1, 2), (3, 4)]
+
+    Notes
+    =====
+
+    The underlying structure of the Cycle is a dictionary and although
+    the __iter__ method has been redefined to give the array form of the
+    cycle, the underlying dictionary items are still available with the
+    such methods as items():
+
+    >>> list(Cycle(1, 2).items())
+    [(1, 2), (2, 1)]
+
+    See Also
+    ========
+
+    Permutation
+    """
+    def __missing__(self, arg):
+        """Enter arg into dictionary and return arg."""
+        return as_int(arg)
+
+    def __iter__(self):
+        yield from self.list()
+
+    def __call__(self, *other):
+        """Return product of cycles processed from R to L.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2)(2, 3)
+        (1 3 2)
+
+        An instance of a Cycle will automatically parse list-like
+        objects and Permutations that are on the right. It is more
+        flexible than the Permutation in that all elements need not
+        be present:
+
+        >>> a = Cycle(1, 2)
+        >>> a(2, 3)
+        (1 3 2)
+        >>> a(2, 3)(4, 5)
+        (1 3 2)(4 5)
+
+        """
+        rv = Cycle(*other)
+        for k, v in zip(list(self.keys()), [rv[self[k]] for k in self.keys()]):
+            rv[k] = v
+        return rv
+
+    def list(self, size=None):
+        """Return the cycles as an explicit list starting from 0 up
+        to the greater of the largest value in the cycles and size.
+
+        Truncation of trailing unmoved items will occur when size
+        is less than the maximum element in the cycle; if this is
+        desired, setting ``size=-1`` will guarantee such trimming.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> p = Cycle(2, 3)(4, 5)
+        >>> p.list()
+        [0, 1, 3, 2, 5, 4]
+        >>> p.list(10)
+        [0, 1, 3, 2, 5, 4, 6, 7, 8, 9]
+
+        Passing a length too small will trim trailing, unchanged elements
+        in the permutation:
+
+        >>> Cycle(2, 4)(1, 2, 4).list(-1)
+        [0, 2, 1]
+        """
+        if not self and size is None:
+            raise ValueError('must give size for empty Cycle')
+        if size is not None:
+            big = max([i for i in self.keys() if self[i] != i] + [0])
+            size = max(size, big + 1)
+        else:
+            size = self.size
+        return [self[i] for i in range(size)]
+
+    def __repr__(self):
+        """We want it to print as a Cycle, not as a dict.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2)
+        (1 2)
+        >>> print(_)
+        (1 2)
+        >>> list(Cycle(1, 2).items())
+        [(1, 2), (2, 1)]
+        """
+        if not self:
+            return 'Cycle()'
+        cycles = Permutation(self).cyclic_form
+        s = ''.join(str(tuple(c)) for c in cycles)
+        big = self.size - 1
+        if not any(i == big for c in cycles for i in c):
+            s += '(%s)' % big
+        return 'Cycle%s' % s
+
+    def __str__(self):
+        """We want it to be printed in a Cycle notation with no
+        comma in-between.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2)
+        (1 2)
+        >>> Cycle(1, 2, 4)(5, 6)
+        (1 2 4)(5 6)
+        """
+        if not self:
+            return '()'
+        cycles = Permutation(self).cyclic_form
+        s = ''.join(str(tuple(c)) for c in cycles)
+        big = self.size - 1
+        if not any(i == big for c in cycles for i in c):
+            s += '(%s)' % big
+        s = s.replace(',', '')
+        return s
+
+    def __init__(self, *args):
+        """Load up a Cycle instance with the values for the cycle.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2, 6)
+        (1 2 6)
+        """
+
+        if not args:
+            return
+        if len(args) == 1:
+            if isinstance(args[0], Permutation):
+                for c in args[0].cyclic_form:
+                    self.update(self(*c))
+                return
+            elif isinstance(args[0], Cycle):
+                for k, v in args[0].items():
+                    self[k] = v
+                return
+        args = [as_int(a) for a in args]
+        if any(i < 0 for i in args):
+            raise ValueError('negative integers are not allowed in a cycle.')
+        if has_dups(args):
+            raise ValueError('All elements must be unique in a cycle.')
+        for i in range(-len(args), 0):
+            self[args[i]] = args[i + 1]
+
+    @property
+    def size(self):
+        if not self:
+            return 0
+        return max(self.keys()) + 1
+
+    def copy(self):
+        return Cycle(self)
+
+
+class Permutation(Atom):
+    r"""
+    A permutation, alternatively known as an 'arrangement number' or 'ordering'
+    is an arrangement of the elements of an ordered list into a one-to-one
+    mapping with itself. The permutation of a given arrangement is given by
+    indicating the positions of the elements after re-arrangement [2]_. For
+    example, if one started with elements ``[x, y, a, b]`` (in that order) and
+    they were reordered as ``[x, y, b, a]`` then the permutation would be
+    ``[0, 1, 3, 2]``. Notice that (in SymPy) the first element is always referred
+    to as 0 and the permutation uses the indices of the elements in the
+    original ordering, not the elements ``(a, b, ...)`` themselves.
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy import init_printing
+    >>> init_printing(perm_cyclic=False, pretty_print=False)
+
+    Permutations Notation
+    =====================
+
+    Permutations are commonly represented in disjoint cycle or array forms.
+
+    Array Notation and 2-line Form
+    ------------------------------------
+
+    In the 2-line form, the elements and their final positions are shown
+    as a matrix with 2 rows:
+
+    [0    1    2     ... n-1]
+    [p(0) p(1) p(2)  ... p(n-1)]
+
+    Since the first line is always ``range(n)``, where n is the size of p,
+    it is sufficient to represent the permutation by the second line,
+    referred to as the "array form" of the permutation. This is entered
+    in brackets as the argument to the Permutation class:
+
+    >>> p = Permutation([0, 2, 1]); p
+    Permutation([0, 2, 1])
+
+    Given i in range(p.size), the permutation maps i to i^p
+
+    >>> [i^p for i in range(p.size)]
+    [0, 2, 1]
+
+    The composite of two permutations p*q means first apply p, then q, so
+    i^(p*q) = (i^p)^q which is i^p^q according to Python precedence rules:
+
+    >>> q = Permutation([2, 1, 0])
+    >>> [i^p^q for i in range(3)]
+    [2, 0, 1]
+    >>> [i^(p*q) for i in range(3)]
+    [2, 0, 1]
+
+    One can use also the notation p(i) = i^p, but then the composition
+    rule is (p*q)(i) = q(p(i)), not p(q(i)):
+
+    >>> [(p*q)(i) for i in range(p.size)]
+    [2, 0, 1]
+    >>> [q(p(i)) for i in range(p.size)]
+    [2, 0, 1]
+    >>> [p(q(i)) for i in range(p.size)]
+    [1, 2, 0]
+
+    Disjoint Cycle Notation
+    -----------------------
+
+    In disjoint cycle notation, only the elements that have shifted are
+    indicated.
+
+    For example, [1, 3, 2, 0] can be represented as (0, 1, 3)(2).
+    This can be understood from the 2 line format of the given permutation.
+    In the 2-line form,
+    [0    1    2   3]
+    [1    3    2   0]
+
+    The element in the 0th position is 1, so 0 -> 1. The element in the 1st
+    position is three, so 1 -> 3. And the element in the third position is again
+    0, so 3 -> 0. Thus, 0 -> 1 -> 3 -> 0, and 2 -> 2. Thus, this can be represented
+    as 2 cycles: (0, 1, 3)(2).
+    In common notation, singular cycles are not explicitly written as they can be
+    inferred implicitly.
+
+    Only the relative ordering of elements in a cycle matter:
+
+    >>> Permutation(1,2,3) == Permutation(2,3,1) == Permutation(3,1,2)
+    True
+
+    The disjoint cycle notation is convenient when representing
+    permutations that have several cycles in them:
+
+    >>> Permutation(1, 2)(3, 5) == Permutation([[1, 2], [3, 5]])
+    True
+
+    It also provides some economy in entry when computing products of
+    permutations that are written in disjoint cycle notation:
+
+    >>> Permutation(1, 2)(1, 3)(2, 3)
+    Permutation([0, 3, 2, 1])
+    >>> _ == Permutation([[1, 2]])*Permutation([[1, 3]])*Permutation([[2, 3]])
+    True
+
+        Caution: when the cycles have common elements between them then the order
+        in which the permutations are applied matters. This module applies
+        the permutations from *left to right*.
+
+        >>> Permutation(1, 2)(2, 3) == Permutation([(1, 2), (2, 3)])
+        True
+        >>> Permutation(1, 2)(2, 3).list()
+        [0, 3, 1, 2]
+
+        In the above case, (1,2) is computed before (2,3).
+        As 0 -> 0, 0 -> 0, element in position 0 is 0.
+        As 1 -> 2, 2 -> 3, element in position 1 is 3.
+        As 2 -> 1, 1 -> 1, element in position 2 is 1.
+        As 3 -> 3, 3 -> 2, element in position 3 is 2.
+
+        If the first and second elements had been
+        swapped first, followed by the swapping of the second
+        and third, the result would have been [0, 2, 3, 1].
+        If, you want to apply the cycles in the conventional
+        right to left order, call the function with arguments in reverse order
+        as demonstrated below:
+
+        >>> Permutation([(1, 2), (2, 3)][::-1]).list()
+        [0, 2, 3, 1]
+
+    Entering a singleton in a permutation is a way to indicate the size of the
+    permutation. The ``size`` keyword can also be used.
+
+    Array-form entry:
+
+    >>> Permutation([[1, 2], [9]])
+    Permutation([0, 2, 1], size=10)
+    >>> Permutation([[1, 2]], size=10)
+    Permutation([0, 2, 1], size=10)
+
+    Cyclic-form entry:
+
+    >>> Permutation(1, 2, size=10)
+    Permutation([0, 2, 1], size=10)
+    >>> Permutation(9)(1, 2)
+    Permutation([0, 2, 1], size=10)
+
+    Caution: no singleton containing an element larger than the largest
+    in any previous cycle can be entered. This is an important difference
+    in how Permutation and Cycle handle the ``__call__`` syntax. A singleton
+    argument at the start of a Permutation performs instantiation of the
+    Permutation and is permitted:
+
+    >>> Permutation(5)
+    Permutation([], size=6)
+
+    A singleton entered after instantiation is a call to the permutation
+    -- a function call -- and if the argument is out of range it will
+    trigger an error. For this reason, it is better to start the cycle
+    with the singleton:
+
+    The following fails because there is no element 3:
+
+    >>> Permutation(1, 2)(3)
+    Traceback (most recent call last):
+    ...
+    IndexError: list index out of range
+
+    This is ok: only the call to an out of range singleton is prohibited;
+    otherwise the permutation autosizes:
+
+    >>> Permutation(3)(1, 2)
+    Permutation([0, 2, 1, 3])
+    >>> Permutation(1, 2)(3, 4) == Permutation(3, 4)(1, 2)
+    True
+
+
+    Equality testing
+    ----------------
+
+    The array forms must be the same in order for permutations to be equal:
+
+    >>> Permutation([1, 0, 2, 3]) == Permutation([1, 0])
+    False
+
+
+    Identity Permutation
+    --------------------
+
+    The identity permutation is a permutation in which no element is out of
+    place. It can be entered in a variety of ways. All the following create
+    an identity permutation of size 4:
+
+    >>> I = Permutation([0, 1, 2, 3])
+    >>> all(p == I for p in [
+    ... Permutation(3),
+    ... Permutation(range(4)),
+    ... Permutation([], size=4),
+    ... Permutation(size=4)])
+    True
+
+    Watch out for entering the range *inside* a set of brackets (which is
+    cycle notation):
+
+    >>> I == Permutation([range(4)])
+    False
+
+
+    Permutation Printing
+    ====================
+
+    There are a few things to note about how Permutations are printed.
+
+    .. deprecated:: 1.6
+
+       Configuring Permutation printing by setting
+       ``Permutation.print_cyclic`` is deprecated. Users should use the
+       ``perm_cyclic`` flag to the printers, as described below.
+
+    1) If you prefer one form (array or cycle) over another, you can set
+    ``init_printing`` with the ``perm_cyclic`` flag.
+
+    >>> from sympy import init_printing
+    >>> p = Permutation(1, 2)(4, 5)(3, 4)
+    >>> p
+    Permutation([0, 2, 1, 4, 5, 3])
+
+    >>> init_printing(perm_cyclic=True, pretty_print=False)
+    >>> p
+    (1 2)(3 4 5)
+
+    2) Regardless of the setting, a list of elements in the array for cyclic
+    form can be obtained and either of those can be copied and supplied as
+    the argument to Permutation:
+
+    >>> p.array_form
+    [0, 2, 1, 4, 5, 3]
+    >>> p.cyclic_form
+    [[1, 2], [3, 4, 5]]
+    >>> Permutation(_) == p
+    True
+
+    3) Printing is economical in that as little as possible is printed while
+    retaining all information about the size of the permutation:
+
+    >>> init_printing(perm_cyclic=False, pretty_print=False)
+    >>> Permutation([1, 0, 2, 3])
+    Permutation([1, 0, 2, 3])
+    >>> Permutation([1, 0, 2, 3], size=20)
+    Permutation([1, 0], size=20)
+    >>> Permutation([1, 0, 2, 4, 3, 5, 6], size=20)
+    Permutation([1, 0, 2, 4, 3], size=20)
+
+    >>> p = Permutation([1, 0, 2, 3])
+    >>> init_printing(perm_cyclic=True, pretty_print=False)
+    >>> p
+    (3)(0 1)
+    >>> init_printing(perm_cyclic=False, pretty_print=False)
+
+    The 2 was not printed but it is still there as can be seen with the
+    array_form and size methods:
+
+    >>> p.array_form
+    [1, 0, 2, 3]
+    >>> p.size
+    4
+
+    Short introduction to other methods
+    ===================================
+
+    The permutation can act as a bijective function, telling what element is
+    located at a given position
+
+    >>> q = Permutation([5, 2, 3, 4, 1, 0])
+    >>> q.array_form[1] # the hard way
+    2
+    >>> q(1) # the easy way
+    2
+    >>> {i: q(i) for i in range(q.size)} # showing the bijection
+    {0: 5, 1: 2, 2: 3, 3: 4, 4: 1, 5: 0}
+
+    The full cyclic form (including singletons) can be obtained:
+
+    >>> p.full_cyclic_form
+    [[0, 1], [2], [3]]
+
+    Any permutation can be factored into transpositions of pairs of elements:
+
+    >>> Permutation([[1, 2], [3, 4, 5]]).transpositions()
+    [(1, 2), (3, 5), (3, 4)]
+    >>> Permutation.rmul(*[Permutation([ti], size=6) for ti in _]).cyclic_form
+    [[1, 2], [3, 4, 5]]
+
+    The number of permutations on a set of n elements is given by n! and is
+    called the cardinality.
+
+    >>> p.size
+    4
+    >>> p.cardinality
+    24
+
+    A given permutation has a rank among all the possible permutations of the
+    same elements, but what that rank is depends on how the permutations are
+    enumerated. (There are a number of different methods of doing so.) The
+    lexicographic rank is given by the rank method and this rank is used to
+    increment a permutation with addition/subtraction:
+
+    >>> p.rank()
+    6
+    >>> p + 1
+    Permutation([1, 0, 3, 2])
+    >>> p.next_lex()
+    Permutation([1, 0, 3, 2])
+    >>> _.rank()
+    7
+    >>> p.unrank_lex(p.size, rank=7)
+    Permutation([1, 0, 3, 2])
+
+    The product of two permutations p and q is defined as their composition as
+    functions, (p*q)(i) = q(p(i)) [6]_.
+
+    >>> p = Permutation([1, 0, 2, 3])
+    >>> q = Permutation([2, 3, 1, 0])
+    >>> list(q*p)
+    [2, 3, 0, 1]
+    >>> list(p*q)
+    [3, 2, 1, 0]
+    >>> [q(p(i)) for i in range(p.size)]
+    [3, 2, 1, 0]
+
+    The permutation can be 'applied' to any list-like object, not only
+    Permutations:
+
+    >>> p(['zero', 'one', 'four', 'two'])
+    ['one', 'zero', 'four', 'two']
+    >>> p('zo42')
+    ['o', 'z', '4', '2']
+
+    If you have a list of arbitrary elements, the corresponding permutation
+    can be found with the from_sequence method:
+
+    >>> Permutation.from_sequence('SymPy')
+    Permutation([1, 3, 2, 0, 4])
+
+    Checking if a Permutation is contained in a Group
+    =================================================
+
+    Generally if you have a group of permutations G on n symbols, and
+    you're checking if a permutation on less than n symbols is part
+    of that group, the check will fail.
+
+    Here is an example for n=5 and we check if the cycle
+    (1,2,3) is in G:
+
+    >>> from sympy import init_printing
+    >>> init_printing(perm_cyclic=True, pretty_print=False)
+    >>> from sympy.combinatorics import Cycle, Permutation
+    >>> from sympy.combinatorics.perm_groups import PermutationGroup
+    >>> G = PermutationGroup(Cycle(2, 3)(4, 5), Cycle(1, 2, 3, 4, 5))
+    >>> p1 = Permutation(Cycle(2, 5, 3))
+    >>> p2 = Permutation(Cycle(1, 2, 3))
+    >>> a1 = Permutation(Cycle(1, 2, 3).list(6))
+    >>> a2 = Permutation(Cycle(1, 2, 3)(5))
+    >>> a3 = Permutation(Cycle(1, 2, 3),size=6)
+    >>> for p in [p1,p2,a1,a2,a3]: p, G.contains(p)
+    ((2 5 3), True)
+    ((1 2 3), False)
+    ((5)(1 2 3), True)
+    ((5)(1 2 3), True)
+    ((5)(1 2 3), True)
+
+    The check for p2 above will fail.
+
+    Checking if p1 is in G works because SymPy knows
+    G is a group on 5 symbols, and p1 is also on 5 symbols
+    (its largest element is 5).
+
+    For ``a1``, the ``.list(6)`` call will extend the permutation to 5
+    symbols, so the test will work as well. In the case of ``a2`` the
+    permutation is being extended to 5 symbols by using a singleton,
+    and in the case of ``a3`` it's extended through the constructor
+    argument ``size=6``.
+
+    There is another way to do this, which is to tell the ``contains``
+    method that the number of symbols the group is on does not need to
+    match perfectly the number of symbols for the permutation:
+
+    >>> G.contains(p2,strict=False)
+    True
+
+    This can be via the ``strict`` argument to the ``contains`` method,
+    and SymPy will try to extend the permutation on its own and then
+    perform the containment check.
+
+    See Also
+    ========
+
+    Cycle
+
+    References
+    ==========
+
+    .. [1] Skiena, S. 'Permutations.' 1.1 in Implementing Discrete Mathematics
+           Combinatorics and Graph Theory with Mathematica.  Reading, MA:
+           Addison-Wesley, pp. 3-16, 1990.
+
+    .. [2] Knuth, D. E. The Art of Computer Programming, Vol. 4: Combinatorial
+           Algorithms, 1st ed. Reading, MA: Addison-Wesley, 2011.
+
+    .. [3] Wendy Myrvold and Frank Ruskey. 2001. Ranking and unranking
+           permutations in linear time. Inf. Process. Lett. 79, 6 (September 2001),
+           281-284. DOI=10.1016/S0020-0190(01)00141-7
+
+    .. [4] D. L. Kreher, D. R. Stinson 'Combinatorial Algorithms'
+           CRC Press, 1999
+
+    .. [5] Graham, R. L.; Knuth, D. E.; and Patashnik, O.
+           Concrete Mathematics: A Foundation for Computer Science, 2nd ed.
+           Reading, MA: Addison-Wesley, 1994.
+
+    .. [6] https://en.wikipedia.org/w/index.php?oldid=499948155#Product_and_inverse
+
+    .. [7] https://en.wikipedia.org/wiki/Lehmer_code
+
+    """
+
+    is_Permutation = True
+
+    _array_form = None
+    _cyclic_form = None
+    _cycle_structure = None
+    _size = None
+    _rank = None
+
+    def __new__(cls, *args, size=None, **kwargs):
+        """
+        Constructor for the Permutation object from a list or a
+        list of lists in which all elements of the permutation may
+        appear only once.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+
+        Permutations entered in array-form are left unaltered:
+
+        >>> Permutation([0, 2, 1])
+        Permutation([0, 2, 1])
+
+        Permutations entered in cyclic form are converted to array form;
+        singletons need not be entered, but can be entered to indicate the
+        largest element:
+
+        >>> Permutation([[4, 5, 6], [0, 1]])
+        Permutation([1, 0, 2, 3, 5, 6, 4])
+        >>> Permutation([[4, 5, 6], [0, 1], [19]])
+        Permutation([1, 0, 2, 3, 5, 6, 4], size=20)
+
+        All manipulation of permutations assumes that the smallest element
+        is 0 (in keeping with 0-based indexing in Python) so if the 0 is
+        missing when entering a permutation in array form, an error will be
+        raised:
+
+        >>> Permutation([2, 1])
+        Traceback (most recent call last):
+        ...
+        ValueError: Integers 0 through 2 must be present.
+
+        If a permutation is entered in cyclic form, it can be entered without
+        singletons and the ``size`` specified so those values can be filled
+        in, otherwise the array form will only extend to the maximum value
+        in the cycles:
+
+        >>> Permutation([[1, 4], [3, 5, 2]], size=10)
+        Permutation([0, 4, 3, 5, 1, 2], size=10)
+        >>> _.array_form
+        [0, 4, 3, 5, 1, 2, 6, 7, 8, 9]
+        """
+        if size is not None:
+            size = int(size)
+
+        #a) ()
+        #b) (1) = identity
+        #c) (1, 2) = cycle
+        #d) ([1, 2, 3]) = array form
+        #e) ([[1, 2]]) = cyclic form
+        #f) (Cycle) = conversion to permutation
+        #g) (Permutation) = adjust size or return copy
+        ok = True
+        if not args:  # a
+            return cls._af_new(list(range(size or 0)))
+        elif len(args) > 1:  # c
+            return cls._af_new(Cycle(*args).list(size))
+        if len(args) == 1:
+            a = args[0]
+            if isinstance(a, cls):  # g
+                if size is None or size == a.size:
+                    return a
+                return cls(a.array_form, size=size)
+            if isinstance(a, Cycle):  # f
+                return cls._af_new(a.list(size))
+            if not is_sequence(a):  # b
+                if size is not None and a + 1 > size:
+                    raise ValueError('size is too small when max is %s' % a)
+                return cls._af_new(list(range(a + 1)))
+            if has_variety(is_sequence(ai) for ai in a):
+                ok = False
+        else:
+            ok = False
+        if not ok:
+            raise ValueError("Permutation argument must be a list of ints, "
+                             "a list of lists, Permutation or Cycle.")
+
+        # safe to assume args are valid; this also makes a copy
+        # of the args
+        args = list(args[0])
+
+        is_cycle = args and is_sequence(args[0])
+        if is_cycle:  # e
+            args = [[int(i) for i in c] for c in args]
+        else:  # d
+            args = [int(i) for i in args]
+
+        # if there are n elements present, 0, 1, ..., n-1 should be present
+        # unless a cycle notation has been provided. A 0 will be added
+        # for convenience in case one wants to enter permutations where
+        # counting starts from 1.
+
+        temp = flatten(args)
+        if has_dups(temp) and not is_cycle:
+            raise ValueError('there were repeated elements.')
+        temp = set(temp)
+
+        if not is_cycle:
+            if temp != set(range(len(temp))):
+                raise ValueError('Integers 0 through %s must be present.' %
+                max(temp))
+            if size is not None and temp and max(temp) + 1 > size:
+                raise ValueError('max element should not exceed %s' % (size - 1))
+
+        if is_cycle:
+            # it's not necessarily canonical so we won't store
+            # it -- use the array form instead
+            c = Cycle()
+            for ci in args:
+                c = c(*ci)
+            aform = c.list()
+        else:
+            aform = list(args)
+        if size and size > len(aform):
+            # don't allow for truncation of permutation which
+            # might split a cycle and lead to an invalid aform
+            # but do allow the permutation size to be increased
+            aform.extend(list(range(len(aform), size)))
+
+        return cls._af_new(aform)
+
+    @classmethod
+    def _af_new(cls, perm):
+        """A method to produce a Permutation object from a list;
+        the list is bound to the _array_form attribute, so it must
+        not be modified; this method is meant for internal use only;
+        the list ``a`` is supposed to be generated as a temporary value
+        in a method, so p = Perm._af_new(a) is the only object
+        to hold a reference to ``a``::
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.permutations import Perm
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> a = [2, 1, 3, 0]
+        >>> p = Perm._af_new(a)
+        >>> p
+        Permutation([2, 1, 3, 0])
+
+        """
+        p = super().__new__(cls)
+        p._array_form = perm
+        p._size = len(perm)
+        return p
+
+    def copy(self):
+        return self.__class__(self.array_form)
+
+    def __getnewargs__(self):
+        return (self.array_form,)
+
+    def _hashable_content(self):
+        # the array_form (a list) is the Permutation arg, so we need to
+        # return a tuple, instead
+        return tuple(self.array_form)
+
+    @property
+    def array_form(self):
+        """
+        Return a copy of the attribute _array_form
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[2, 0], [3, 1]])
+        >>> p.array_form
+        [2, 3, 0, 1]
+        >>> Permutation([[2, 0, 3, 1]]).array_form
+        [3, 2, 0, 1]
+        >>> Permutation([2, 0, 3, 1]).array_form
+        [2, 0, 3, 1]
+        >>> Permutation([[1, 2], [4, 5]]).array_form
+        [0, 2, 1, 3, 5, 4]
+        """
+        return self._array_form[:]
+
+    def list(self, size=None):
+        """Return the permutation as an explicit list, possibly
+        trimming unmoved elements if size is less than the maximum
+        element in the permutation; if this is desired, setting
+        ``size=-1`` will guarantee such trimming.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation(2, 3)(4, 5)
+        >>> p.list()
+        [0, 1, 3, 2, 5, 4]
+        >>> p.list(10)
+        [0, 1, 3, 2, 5, 4, 6, 7, 8, 9]
+
+        Passing a length too small will trim trailing, unchanged elements
+        in the permutation:
+
+        >>> Permutation(2, 4)(1, 2, 4).list(-1)
+        [0, 2, 1]
+        >>> Permutation(3).list(-1)
+        []
+        """
+        if not self and size is None:
+            raise ValueError('must give size for empty Cycle')
+        rv = self.array_form
+        if size is not None:
+            if size > self.size:
+                rv.extend(list(range(self.size, size)))
+            else:
+                # find first value from rhs where rv[i] != i
+                i = self.size - 1
+                while rv:
+                    if rv[-1] != i:
+                        break
+                    rv.pop()
+                    i -= 1
+        return rv
+
+    @property
+    def cyclic_form(self):
+        """
+        This is used to convert to the cyclic notation
+        from the canonical notation. Singletons are omitted.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 3, 1, 2])
+        >>> p.cyclic_form
+        [[1, 3, 2]]
+        >>> Permutation([1, 0, 2, 4, 3, 5]).cyclic_form
+        [[0, 1], [3, 4]]
+
+        See Also
+        ========
+
+        array_form, full_cyclic_form
+        """
+        if self._cyclic_form is not None:
+            return list(self._cyclic_form)
+        array_form = self.array_form
+        unchecked = [True] * len(array_form)
+        cyclic_form = []
+        for i in range(len(array_form)):
+            if unchecked[i]:
+                cycle = []
+                cycle.append(i)
+                unchecked[i] = False
+                j = i
+                while unchecked[array_form[j]]:
+                    j = array_form[j]
+                    cycle.append(j)
+                    unchecked[j] = False
+                if len(cycle) > 1:
+                    cyclic_form.append(cycle)
+                    assert cycle == list(minlex(cycle))
+        cyclic_form.sort()
+        self._cyclic_form = cyclic_form[:]
+        return cyclic_form
+
+    @property
+    def full_cyclic_form(self):
+        """Return permutation in cyclic form including singletons.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 2, 1]).full_cyclic_form
+        [[0], [1, 2]]
+        """
+        need = set(range(self.size)) - set(flatten(self.cyclic_form))
+        rv = self.cyclic_form + [[i] for i in need]
+        rv.sort()
+        return rv
+
+    @property
+    def size(self):
+        """
+        Returns the number of elements in the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([[3, 2], [0, 1]]).size
+        4
+
+        See Also
+        ========
+
+        cardinality, length, order, rank
+        """
+        return self._size
+
+    def support(self):
+        """Return the elements in permutation, P, for which P[i] != i.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[3, 2], [0, 1], [4]])
+        >>> p.array_form
+        [1, 0, 3, 2, 4]
+        >>> p.support()
+        [0, 1, 2, 3]
+        """
+        a = self.array_form
+        return [i for i, e in enumerate(a) if a[i] != i]
+
+    def __add__(self, other):
+        """Return permutation that is other higher in rank than self.
+
+        The rank is the lexicographical rank, with the identity permutation
+        having rank of 0.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> I = Permutation([0, 1, 2, 3])
+        >>> a = Permutation([2, 1, 3, 0])
+        >>> I + a.rank() == a
+        True
+
+        See Also
+        ========
+
+        __sub__, inversion_vector
+
+        """
+        rank = (self.rank() + other) % self.cardinality
+        rv = self.unrank_lex(self.size, rank)
+        rv._rank = rank
+        return rv
+
+    def __sub__(self, other):
+        """Return the permutation that is other lower in rank than self.
+
+        See Also
+        ========
+
+        __add__
+        """
+        return self.__add__(-other)
+
+    @staticmethod
+    def rmul(*args):
+        """
+        Return product of Permutations [a, b, c, ...] as the Permutation whose
+        ith value is a(b(c(i))).
+
+        a, b, c, ... can be Permutation objects or tuples.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+
+        >>> a, b = [1, 0, 2], [0, 2, 1]
+        >>> a = Permutation(a); b = Permutation(b)
+        >>> list(Permutation.rmul(a, b))
+        [1, 2, 0]
+        >>> [a(b(i)) for i in range(3)]
+        [1, 2, 0]
+
+        This handles the operands in reverse order compared to the ``*`` operator:
+
+        >>> a = Permutation(a); b = Permutation(b)
+        >>> list(a*b)
+        [2, 0, 1]
+        >>> [b(a(i)) for i in range(3)]
+        [2, 0, 1]
+
+        Notes
+        =====
+
+        All items in the sequence will be parsed by Permutation as
+        necessary as long as the first item is a Permutation:
+
+        >>> Permutation.rmul(a, [0, 2, 1]) == Permutation.rmul(a, b)
+        True
+
+        The reverse order of arguments will raise a TypeError.
+
+        """
+        rv = args[0]
+        for i in range(1, len(args)):
+            rv = args[i]*rv
+        return rv
+
+    @classmethod
+    def rmul_with_af(cls, *args):
+        """
+        same as rmul, but the elements of args are Permutation objects
+        which have _array_form
+        """
+        a = [x._array_form for x in args]
+        rv = cls._af_new(_af_rmuln(*a))
+        return rv
+
+    def mul_inv(self, other):
+        """
+        other*~self, self and other have _array_form
+        """
+        a = _af_invert(self._array_form)
+        b = other._array_form
+        return self._af_new(_af_rmul(a, b))
+
+    def __rmul__(self, other):
+        """This is needed to coerce other to Permutation in rmul."""
+        cls = type(self)
+        return cls(other)*self
+
+    def __mul__(self, other):
+        """
+        Return the product a*b as a Permutation; the ith value is b(a(i)).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.permutations import _af_rmul, Permutation
+
+        >>> a, b = [1, 0, 2], [0, 2, 1]
+        >>> a = Permutation(a); b = Permutation(b)
+        >>> list(a*b)
+        [2, 0, 1]
+        >>> [b(a(i)) for i in range(3)]
+        [2, 0, 1]
+
+        This handles operands in reverse order compared to _af_rmul and rmul:
+
+        >>> al = list(a); bl = list(b)
+        >>> _af_rmul(al, bl)
+        [1, 2, 0]
+        >>> [al[bl[i]] for i in range(3)]
+        [1, 2, 0]
+
+        It is acceptable for the arrays to have different lengths; the shorter
+        one will be padded to match the longer one:
+
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> b*Permutation([1, 0])
+        Permutation([1, 2, 0])
+        >>> Permutation([1, 0])*b
+        Permutation([2, 0, 1])
+
+        It is also acceptable to allow coercion to handle conversion of a
+        single list to the left of a Permutation:
+
+        >>> [0, 1]*a # no change: 2-element identity
+        Permutation([1, 0, 2])
+        >>> [[0, 1]]*a # exchange first two elements
+        Permutation([0, 1, 2])
+
+        You cannot use more than 1 cycle notation in a product of cycles
+        since coercion can only handle one argument to the left. To handle
+        multiple cycles it is convenient to use Cycle instead of Permutation:
+
+        >>> [[1, 2]]*[[2, 3]]*Permutation([]) # doctest: +SKIP
+        >>> from sympy.combinatorics.permutations import Cycle
+        >>> Cycle(1, 2)(2, 3)
+        (1 3 2)
+
+        """
+        from sympy.combinatorics.perm_groups import PermutationGroup, Coset
+        if isinstance(other, PermutationGroup):
+            return Coset(self, other, dir='-')
+        a = self.array_form
+        # __rmul__ makes sure the other is a Permutation
+        b = other.array_form
+        if not b:
+            perm = a
+        else:
+            b.extend(list(range(len(b), len(a))))
+            perm = [b[i] for i in a] + b[len(a):]
+        return self._af_new(perm)
+
+    def commutes_with(self, other):
+        """
+        Checks if the elements are commuting.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> a = Permutation([1, 4, 3, 0, 2, 5])
+        >>> b = Permutation([0, 1, 2, 3, 4, 5])
+        >>> a.commutes_with(b)
+        True
+        >>> b = Permutation([2, 3, 5, 4, 1, 0])
+        >>> a.commutes_with(b)
+        False
+        """
+        a = self.array_form
+        b = other.array_form
+        return _af_commutes_with(a, b)
+
+    def __pow__(self, n):
+        """
+        Routine for finding powers of a permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([2, 0, 3, 1])
+        >>> p.order()
+        4
+        >>> p**4
+        Permutation([0, 1, 2, 3])
+        """
+        if isinstance(n, Permutation):
+            raise NotImplementedError(
+                'p**p is not defined; do you mean p^p (conjugate)?')
+        n = int(n)
+        return self._af_new(_af_pow(self.array_form, n))
+
+    def __rxor__(self, i):
+        """Return self(i) when ``i`` is an int.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation(1, 2, 9)
+        >>> 2^p == p(2) == 9
+        True
+        """
+        if int_valued(i):
+            return self(i)
+        else:
+            raise NotImplementedError(
+                "i^p = p(i) when i is an integer, not %s." % i)
+
+    def __xor__(self, h):
+        """Return the conjugate permutation ``~h*self*h` `.
+
+        Explanation
+        ===========
+
+        If ``a`` and ``b`` are conjugates, ``a = h*b*~h`` and
+        ``b = ~h*a*h`` and both have the same cycle structure.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation(1, 2, 9)
+        >>> q = Permutation(6, 9, 8)
+        >>> p*q != q*p
+        True
+
+        Calculate and check properties of the conjugate:
+
+        >>> c = p^q
+        >>> c == ~q*p*q and p == q*c*~q
+        True
+
+        The expression q^p^r is equivalent to q^(p*r):
+
+        >>> r = Permutation(9)(4, 6, 8)
+        >>> q^p^r == q^(p*r)
+        True
+
+        If the term to the left of the conjugate operator, i, is an integer
+        then this is interpreted as selecting the ith element from the
+        permutation to the right:
+
+        >>> all(i^p == p(i) for i in range(p.size))
+        True
+
+        Note that the * operator as higher precedence than the ^ operator:
+
+        >>> q^r*p^r == q^(r*p)^r == Permutation(9)(1, 6, 4)
+        True
+
+        Notes
+        =====
+
+        In Python the precedence rule is p^q^r = (p^q)^r which differs
+        in general from p^(q^r)
+
+        >>> q^p^r
+        (9)(1 4 8)
+        >>> q^(p^r)
+        (9)(1 8 6)
+
+        For a given r and p, both of the following are conjugates of p:
+        ~r*p*r and r*p*~r. But these are not necessarily the same:
+
+        >>> ~r*p*r == r*p*~r
+        True
+
+        >>> p = Permutation(1, 2, 9)(5, 6)
+        >>> ~r*p*r == r*p*~r
+        False
+
+        The conjugate ~r*p*r was chosen so that ``p^q^r`` would be equivalent
+        to ``p^(q*r)`` rather than ``p^(r*q)``. To obtain r*p*~r, pass ~r to
+        this method:
+
+        >>> p^~r == r*p*~r
+        True
+        """
+
+        if self.size != h.size:
+            raise ValueError("The permutations must be of equal size.")
+        a = [None]*self.size
+        h = h._array_form
+        p = self._array_form
+        for i in range(self.size):
+            a[h[i]] = h[p[i]]
+        return self._af_new(a)
+
+    def transpositions(self):
+        """
+        Return the permutation decomposed into a list of transpositions.
+
+        Explanation
+        ===========
+
+        It is always possible to express a permutation as the product of
+        transpositions, see [1]
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[1, 2, 3], [0, 4, 5, 6, 7]])
+        >>> t = p.transpositions()
+        >>> t
+        [(0, 7), (0, 6), (0, 5), (0, 4), (1, 3), (1, 2)]
+        >>> print(''.join(str(c) for c in t))
+        (0, 7)(0, 6)(0, 5)(0, 4)(1, 3)(1, 2)
+        >>> Permutation.rmul(*[Permutation([ti], size=p.size) for ti in t]) == p
+        True
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Transposition_%28mathematics%29#Properties
+
+        """
+        a = self.cyclic_form
+        res = []
+        for x in a:
+            nx = len(x)
+            if nx == 2:
+                res.append(tuple(x))
+            elif nx > 2:
+                first = x[0]
+                for y in x[nx - 1:0:-1]:
+                    res.append((first, y))
+        return res
+
+    @classmethod
+    def from_sequence(self, i, key=None):
+        """Return the permutation needed to obtain ``i`` from the sorted
+        elements of ``i``. If custom sorting is desired, a key can be given.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+
+        >>> Permutation.from_sequence('SymPy')
+        (4)(0 1 3)
+        >>> _(sorted("SymPy"))
+        ['S', 'y', 'm', 'P', 'y']
+        >>> Permutation.from_sequence('SymPy', key=lambda x: x.lower())
+        (4)(0 2)(1 3)
+        """
+        ic = list(zip(i, list(range(len(i)))))
+        if key:
+            ic.sort(key=lambda x: key(x[0]))
+        else:
+            ic.sort()
+        return ~Permutation([i[1] for i in ic])
+
+    def __invert__(self):
+        """
+        Return the inverse of the permutation.
+
+        A permutation multiplied by its inverse is the identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([[2, 0], [3, 1]])
+        >>> ~p
+        Permutation([2, 3, 0, 1])
+        >>> _ == p**-1
+        True
+        >>> p*~p == ~p*p == Permutation([0, 1, 2, 3])
+        True
+        """
+        return self._af_new(_af_invert(self._array_form))
+
+    def __iter__(self):
+        """Yield elements from array form.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> list(Permutation(range(3)))
+        [0, 1, 2]
+        """
+        yield from self.array_form
+
+    def __repr__(self):
+        return srepr(self)
+
+    def __call__(self, *i):
+        """
+        Allows applying a permutation instance as a bijective function.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[2, 0], [3, 1]])
+        >>> p.array_form
+        [2, 3, 0, 1]
+        >>> [p(i) for i in range(4)]
+        [2, 3, 0, 1]
+
+        If an array is given then the permutation selects the items
+        from the array (i.e. the permutation is applied to the array):
+
+        >>> from sympy.abc import x
+        >>> p([x, 1, 0, x**2])
+        [0, x**2, x, 1]
+        """
+        # list indices can be Integer or int; leave this
+        # as it is (don't test or convert it) because this
+        # gets called a lot and should be fast
+        if len(i) == 1:
+            i = i[0]
+            if not isinstance(i, Iterable):
+                i = as_int(i)
+                if i < 0 or i > self.size:
+                    raise TypeError(
+                        "{} should be an integer between 0 and {}"
+                        .format(i, self.size-1))
+                return self._array_form[i]
+            # P([a, b, c])
+            if len(i) != self.size:
+                raise TypeError(
+                    "{} should have the length {}.".format(i, self.size))
+            return [i[j] for j in self._array_form]
+        # P(1, 2, 3)
+        return self*Permutation(Cycle(*i), size=self.size)
+
+    def atoms(self):
+        """
+        Returns all the elements of a permutation
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 1, 2, 3, 4, 5]).atoms()
+        {0, 1, 2, 3, 4, 5}
+        >>> Permutation([[0, 1], [2, 3], [4, 5]]).atoms()
+        {0, 1, 2, 3, 4, 5}
+        """
+        return set(self.array_form)
+
+    def apply(self, i):
+        r"""Apply the permutation to an expression.
+
+        Parameters
+        ==========
+
+        i : Expr
+            It should be an integer between $0$ and $n-1$ where $n$
+            is the size of the permutation.
+
+            If it is a symbol or a symbolic expression that can
+            have integer values, an ``AppliedPermutation`` object
+            will be returned which can represent an unevaluated
+            function.
+
+        Notes
+        =====
+
+        Any permutation can be defined as a bijective function
+        $\sigma : \{ 0, 1, \dots, n-1 \} \rightarrow \{ 0, 1, \dots, n-1 \}$
+        where $n$ denotes the size of the permutation.
+
+        The definition may even be extended for any set with distinctive
+        elements, such that the permutation can even be applied for
+        real numbers or such, however, it is not implemented for now for
+        computational reasons and the integrity with the group theory
+        module.
+
+        This function is similar to the ``__call__`` magic, however,
+        ``__call__`` magic already has some other applications like
+        permuting an array or attaching new cycles, which would
+        not always be mathematically consistent.
+
+        This also guarantees that the return type is a SymPy integer,
+        which guarantees the safety to use assumptions.
+        """
+        i = _sympify(i)
+        if i.is_integer is False:
+            raise NotImplementedError("{} should be an integer.".format(i))
+
+        n = self.size
+        if (i < 0) == True or (i >= n) == True:
+            raise NotImplementedError(
+                "{} should be an integer between 0 and {}".format(i, n-1))
+
+        if i.is_Integer:
+            return Integer(self._array_form[i])
+        return AppliedPermutation(self, i)
+
+    def next_lex(self):
+        """
+        Returns the next permutation in lexicographical order.
+        If self is the last permutation in lexicographical order
+        it returns None.
+        See [4] section 2.4.
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([2, 3, 1, 0])
+        >>> p = Permutation([2, 3, 1, 0]); p.rank()
+        17
+        >>> p = p.next_lex(); p.rank()
+        18
+
+        See Also
+        ========
+
+        rank, unrank_lex
+        """
+        perm = self.array_form[:]
+        n = len(perm)
+        i = n - 2
+        while perm[i + 1] < perm[i]:
+            i -= 1
+        if i == -1:
+            return None
+        else:
+            j = n - 1
+            while perm[j] < perm[i]:
+                j -= 1
+            perm[j], perm[i] = perm[i], perm[j]
+            i += 1
+            j = n - 1
+            while i < j:
+                perm[j], perm[i] = perm[i], perm[j]
+                i += 1
+                j -= 1
+        return self._af_new(perm)
+
+    @classmethod
+    def unrank_nonlex(self, n, r):
+        """
+        This is a linear time unranking algorithm that does not
+        respect lexicographic order [3].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> Permutation.unrank_nonlex(4, 5)
+        Permutation([2, 0, 3, 1])
+        >>> Permutation.unrank_nonlex(4, -1)
+        Permutation([0, 1, 2, 3])
+
+        See Also
+        ========
+
+        next_nonlex, rank_nonlex
+        """
+        def _unrank1(n, r, a):
+            if n > 0:
+                a[n - 1], a[r % n] = a[r % n], a[n - 1]
+                _unrank1(n - 1, r//n, a)
+
+        id_perm = list(range(n))
+        n = int(n)
+        r = r % ifac(n)
+        _unrank1(n, r, id_perm)
+        return self._af_new(id_perm)
+
+    def rank_nonlex(self, inv_perm=None):
+        """
+        This is a linear time ranking algorithm that does not
+        enforce lexicographic order [3].
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.rank_nonlex()
+        23
+
+        See Also
+        ========
+
+        next_nonlex, unrank_nonlex
+        """
+        def _rank1(n, perm, inv_perm):
+            if n == 1:
+                return 0
+            s = perm[n - 1]
+            t = inv_perm[n - 1]
+            perm[n - 1], perm[t] = perm[t], s
+            inv_perm[n - 1], inv_perm[s] = inv_perm[s], t
+            return s + n*_rank1(n - 1, perm, inv_perm)
+
+        if inv_perm is None:
+            inv_perm = (~self).array_form
+        if not inv_perm:
+            return 0
+        perm = self.array_form[:]
+        r = _rank1(len(perm), perm, inv_perm)
+        return r
+
+    def next_nonlex(self):
+        """
+        Returns the next permutation in nonlex order [3].
+        If self is the last permutation in this order it returns None.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([2, 0, 3, 1]); p.rank_nonlex()
+        5
+        >>> p = p.next_nonlex(); p
+        Permutation([3, 0, 1, 2])
+        >>> p.rank_nonlex()
+        6
+
+        See Also
+        ========
+
+        rank_nonlex, unrank_nonlex
+        """
+        r = self.rank_nonlex()
+        if r == ifac(self.size) - 1:
+            return None
+        return self.unrank_nonlex(self.size, r + 1)
+
+    def rank(self):
+        """
+        Returns the lexicographic rank of the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.rank()
+        0
+        >>> p = Permutation([3, 2, 1, 0])
+        >>> p.rank()
+        23
+
+        See Also
+        ========
+
+        next_lex, unrank_lex, cardinality, length, order, size
+        """
+        if self._rank is not None:
+            return self._rank
+        rank = 0
+        rho = self.array_form[:]
+        n = self.size - 1
+        size = n + 1
+        psize = int(ifac(n))
+        for j in range(size - 1):
+            rank += rho[j]*psize
+            for i in range(j + 1, size):
+                if rho[i] > rho[j]:
+                    rho[i] -= 1
+            psize //= n
+            n -= 1
+        self._rank = rank
+        return rank
+
+    @property
+    def cardinality(self):
+        """
+        Returns the number of all possible permutations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.cardinality
+        24
+
+        See Also
+        ========
+
+        length, order, rank, size
+        """
+        return int(ifac(self.size))
+
+    def parity(self):
+        """
+        Computes the parity of a permutation.
+
+        Explanation
+        ===========
+
+        The parity of a permutation reflects the parity of the
+        number of inversions in the permutation, i.e., the
+        number of pairs of x and y such that ``x > y`` but ``p[x] < p[y]``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.parity()
+        0
+        >>> p = Permutation([3, 2, 0, 1])
+        >>> p.parity()
+        1
+
+        See Also
+        ========
+
+        _af_parity
+        """
+        if self._cyclic_form is not None:
+            return (self.size - self.cycles) % 2
+
+        return _af_parity(self.array_form)
+
+    @property
+    def is_even(self):
+        """
+        Checks if a permutation is even.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.is_even
+        True
+        >>> p = Permutation([3, 2, 1, 0])
+        >>> p.is_even
+        True
+
+        See Also
+        ========
+
+        is_odd
+        """
+        return not self.is_odd
+
+    @property
+    def is_odd(self):
+        """
+        Checks if a permutation is odd.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.is_odd
+        False
+        >>> p = Permutation([3, 2, 0, 1])
+        >>> p.is_odd
+        True
+
+        See Also
+        ========
+
+        is_even
+        """
+        return bool(self.parity() % 2)
+
+    @property
+    def is_Singleton(self):
+        """
+        Checks to see if the permutation contains only one number and is
+        thus the only possible permutation of this set of numbers
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0]).is_Singleton
+        True
+        >>> Permutation([0, 1]).is_Singleton
+        False
+
+        See Also
+        ========
+
+        is_Empty
+        """
+        return self.size == 1
+
+    @property
+    def is_Empty(self):
+        """
+        Checks to see if the permutation is a set with zero elements
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([]).is_Empty
+        True
+        >>> Permutation([0]).is_Empty
+        False
+
+        See Also
+        ========
+
+        is_Singleton
+        """
+        return self.size == 0
+
+    @property
+    def is_identity(self):
+        return self.is_Identity
+
+    @property
+    def is_Identity(self):
+        """
+        Returns True if the Permutation is an identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([])
+        >>> p.is_Identity
+        True
+        >>> p = Permutation([[0], [1], [2]])
+        >>> p.is_Identity
+        True
+        >>> p = Permutation([0, 1, 2])
+        >>> p.is_Identity
+        True
+        >>> p = Permutation([0, 2, 1])
+        >>> p.is_Identity
+        False
+
+        See Also
+        ========
+
+        order
+        """
+        af = self.array_form
+        return not af or all(i == af[i] for i in range(self.size))
+
+    def ascents(self):
+        """
+        Returns the positions of ascents in a permutation, ie, the location
+        where p[i] < p[i+1]
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([4, 0, 1, 3, 2])
+        >>> p.ascents()
+        [1, 2]
+
+        See Also
+        ========
+
+        descents, inversions, min, max
+        """
+        a = self.array_form
+        pos = [i for i in range(len(a) - 1) if a[i] < a[i + 1]]
+        return pos
+
+    def descents(self):
+        """
+        Returns the positions of descents in a permutation, ie, the location
+        where p[i] > p[i+1]
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([4, 0, 1, 3, 2])
+        >>> p.descents()
+        [0, 3]
+
+        See Also
+        ========
+
+        ascents, inversions, min, max
+        """
+        a = self.array_form
+        pos = [i for i in range(len(a) - 1) if a[i] > a[i + 1]]
+        return pos
+
+    def max(self) -> int:
+        """
+        The maximum element moved by the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([1, 0, 2, 3, 4])
+        >>> p.max()
+        1
+
+        See Also
+        ========
+
+        min, descents, ascents, inversions
+        """
+        a = self.array_form
+        if not a:
+            return 0
+        return max(_a for i, _a in enumerate(a) if _a != i)
+
+    def min(self) -> int:
+        """
+        The minimum element moved by the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 4, 3, 2])
+        >>> p.min()
+        2
+
+        See Also
+        ========
+
+        max, descents, ascents, inversions
+        """
+        a = self.array_form
+        if not a:
+            return 0
+        return min(_a for i, _a in enumerate(a) if _a != i)
+
+    def inversions(self):
+        """
+        Computes the number of inversions of a permutation.
+
+        Explanation
+        ===========
+
+        An inversion is where i > j but p[i] < p[j].
+
+        For small length of p, it iterates over all i and j
+        values and calculates the number of inversions.
+        For large length of p, it uses a variation of merge
+        sort to calculate the number of inversions.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3, 4, 5])
+        >>> p.inversions()
+        0
+        >>> Permutation([3, 2, 1, 0]).inversions()
+        6
+
+        See Also
+        ========
+
+        descents, ascents, min, max
+
+        References
+        ==========
+
+        .. [1] https://www.cp.eng.chula.ac.th/~prabhas//teaching/algo/algo2008/count-inv.htm
+
+        """
+        inversions = 0
+        a = self.array_form
+        n = len(a)
+        if n < 130:
+            for i in range(n - 1):
+                b = a[i]
+                for c in a[i + 1:]:
+                    if b > c:
+                        inversions += 1
+        else:
+            k = 1
+            right = 0
+            arr = a[:]
+            temp = a[:]
+            while k < n:
+                i = 0
+                while i + k < n:
+                    right = i + k * 2 - 1
+                    if right >= n:
+                        right = n - 1
+                    inversions += _merge(arr, temp, i, i + k, right)
+                    i = i + k * 2
+                k = k * 2
+        return inversions
+
+    def commutator(self, x):
+        """Return the commutator of ``self`` and ``x``: ``~x*~self*x*self``
+
+        If f and g are part of a group, G, then the commutator of f and g
+        is the group identity iff f and g commute, i.e. fg == gf.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([0, 2, 3, 1])
+        >>> x = Permutation([2, 0, 3, 1])
+        >>> c = p.commutator(x); c
+        Permutation([2, 1, 3, 0])
+        >>> c == ~x*~p*x*p
+        True
+
+        >>> I = Permutation(3)
+        >>> p = [I + i for i in range(6)]
+        >>> for i in range(len(p)):
+        ...     for j in range(len(p)):
+        ...         c = p[i].commutator(p[j])
+        ...         if p[i]*p[j] == p[j]*p[i]:
+        ...             assert c == I
+        ...         else:
+        ...             assert c != I
+        ...
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Commutator
+        """
+
+        a = self.array_form
+        b = x.array_form
+        n = len(a)
+        if len(b) != n:
+            raise ValueError("The permutations must be of equal size.")
+        inva = [None]*n
+        for i in range(n):
+            inva[a[i]] = i
+        invb = [None]*n
+        for i in range(n):
+            invb[b[i]] = i
+        return self._af_new([a[b[inva[i]]] for i in invb])
+
+    def signature(self):
+        """
+        Gives the signature of the permutation needed to place the
+        elements of the permutation in canonical order.
+
+        The signature is calculated as (-1)^<number of inversions>
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2])
+        >>> p.inversions()
+        0
+        >>> p.signature()
+        1
+        >>> q = Permutation([0,2,1])
+        >>> q.inversions()
+        1
+        >>> q.signature()
+        -1
+
+        See Also
+        ========
+
+        inversions
+        """
+        if self.is_even:
+            return 1
+        return -1
+
+    def order(self):
+        """
+        Computes the order of a permutation.
+
+        When the permutation is raised to the power of its
+        order it equals the identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([3, 1, 5, 2, 4, 0])
+        >>> p.order()
+        4
+        >>> (p**(p.order()))
+        Permutation([], size=6)
+
+        See Also
+        ========
+
+        identity, cardinality, length, rank, size
+        """
+
+        return reduce(lcm, [len(cycle) for cycle in self.cyclic_form], 1)
+
+    def length(self):
+        """
+        Returns the number of integers moved by a permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 3, 2, 1]).length()
+        2
+        >>> Permutation([[0, 1], [2, 3]]).length()
+        4
+
+        See Also
+        ========
+
+        min, max, support, cardinality, order, rank, size
+        """
+
+        return len(self.support())
+
+    @property
+    def cycle_structure(self):
+        """Return the cycle structure of the permutation as a dictionary
+        indicating the multiplicity of each cycle length.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation(3).cycle_structure
+        {1: 4}
+        >>> Permutation(0, 4, 3)(1, 2)(5, 6).cycle_structure
+        {2: 2, 3: 1}
+        """
+        if self._cycle_structure:
+            rv = self._cycle_structure
+        else:
+            rv = defaultdict(int)
+            singletons = self.size
+            for c in self.cyclic_form:
+                rv[len(c)] += 1
+                singletons -= len(c)
+            if singletons:
+                rv[1] = singletons
+            self._cycle_structure = rv
+        return dict(rv)  # make a copy
+
+    @property
+    def cycles(self):
+        """
+        Returns the number of cycles contained in the permutation
+        (including singletons).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 1, 2]).cycles
+        3
+        >>> Permutation([0, 1, 2]).full_cyclic_form
+        [[0], [1], [2]]
+        >>> Permutation(0, 1)(2, 3).cycles
+        2
+
+        See Also
+        ========
+        sympy.functions.combinatorial.numbers.stirling
+        """
+        return len(self.full_cyclic_form)
+
+    def index(self):
+        """
+        Returns the index of a permutation.
+
+        The index of a permutation is the sum of all subscripts j such
+        that p[j] is greater than p[j+1].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([3, 0, 2, 1, 4])
+        >>> p.index()
+        2
+        """
+        a = self.array_form
+
+        return sum(j for j in range(len(a) - 1) if a[j] > a[j + 1])
+
+    def runs(self):
+        """
+        Returns the runs of a permutation.
+
+        An ascending sequence in a permutation is called a run [5].
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([2, 5, 7, 3, 6, 0, 1, 4, 8])
+        >>> p.runs()
+        [[2, 5, 7], [3, 6], [0, 1, 4, 8]]
+        >>> q = Permutation([1,3,2,0])
+        >>> q.runs()
+        [[1, 3], [2], [0]]
+        """
+        return runs(self.array_form)
+
+    def inversion_vector(self):
+        """Return the inversion vector of the permutation.
+
+        The inversion vector consists of elements whose value
+        indicates the number of elements in the permutation
+        that are lesser than it and lie on its right hand side.
+
+        The inversion vector is the same as the Lehmer encoding of a
+        permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([4, 8, 0, 7, 1, 5, 3, 6, 2])
+        >>> p.inversion_vector()
+        [4, 7, 0, 5, 0, 2, 1, 1]
+        >>> p = Permutation([3, 2, 1, 0])
+        >>> p.inversion_vector()
+        [3, 2, 1]
+
+        The inversion vector increases lexicographically with the rank
+        of the permutation, the -ith element cycling through 0..i.
+
+        >>> p = Permutation(2)
+        >>> while p:
+        ...     print('%s %s %s' % (p, p.inversion_vector(), p.rank()))
+        ...     p = p.next_lex()
+        (2) [0, 0] 0
+        (1 2) [0, 1] 1
+        (2)(0 1) [1, 0] 2
+        (0 1 2) [1, 1] 3
+        (0 2 1) [2, 0] 4
+        (0 2) [2, 1] 5
+
+        See Also
+        ========
+
+        from_inversion_vector
+        """
+        self_array_form = self.array_form
+        n = len(self_array_form)
+        inversion_vector = [0] * (n - 1)
+
+        for i in range(n - 1):
+            val = 0
+            for j in range(i + 1, n):
+                if self_array_form[j] < self_array_form[i]:
+                    val += 1
+            inversion_vector[i] = val
+        return inversion_vector
+
+    def rank_trotterjohnson(self):
+        """
+        Returns the Trotter Johnson rank, which we get from the minimal
+        change algorithm. See [4] section 2.4.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.rank_trotterjohnson()
+        0
+        >>> p = Permutation([0, 2, 1, 3])
+        >>> p.rank_trotterjohnson()
+        7
+
+        See Also
+        ========
+
+        unrank_trotterjohnson, next_trotterjohnson
+        """
+        if self.array_form == [] or self.is_Identity:
+            return 0
+        if self.array_form == [1, 0]:
+            return 1
+        perm = self.array_form
+        n = self.size
+        rank = 0
+        for j in range(1, n):
+            k = 1
+            i = 0
+            while perm[i] != j:
+                if perm[i] < j:
+                    k += 1
+                i += 1
+            j1 = j + 1
+            if rank % 2 == 0:
+                rank = j1*rank + j1 - k
+            else:
+                rank = j1*rank + k - 1
+        return rank
+
+    @classmethod
+    def unrank_trotterjohnson(cls, size, rank):
+        """
+        Trotter Johnson permutation unranking. See [4] section 2.4.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> Permutation.unrank_trotterjohnson(5, 10)
+        Permutation([0, 3, 1, 2, 4])
+
+        See Also
+        ========
+
+        rank_trotterjohnson, next_trotterjohnson
+        """
+        perm = [0]*size
+        r2 = 0
+        n = ifac(size)
+        pj = 1
+        for j in range(2, size + 1):
+            pj *= j
+            r1 = (rank * pj) // n
+            k = r1 - j*r2
+            if r2 % 2 == 0:
+                for i in range(j - 1, j - k - 1, -1):
+                    perm[i] = perm[i - 1]
+                perm[j - k - 1] = j - 1
+            else:
+                for i in range(j - 1, k, -1):
+                    perm[i] = perm[i - 1]
+                perm[k] = j - 1
+            r2 = r1
+        return cls._af_new(perm)
+
+    def next_trotterjohnson(self):
+        """
+        Returns the next permutation in Trotter-Johnson order.
+        If self is the last permutation it returns None.
+        See [4] section 2.4. If it is desired to generate all such
+        permutations, they can be generated in order more quickly
+        with the ``generate_bell`` function.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([3, 0, 2, 1])
+        >>> p.rank_trotterjohnson()
+        4
+        >>> p = p.next_trotterjohnson(); p
+        Permutation([0, 3, 2, 1])
+        >>> p.rank_trotterjohnson()
+        5
+
+        See Also
+        ========
+
+        rank_trotterjohnson, unrank_trotterjohnson, sympy.utilities.iterables.generate_bell
+        """
+        pi = self.array_form[:]
+        n = len(pi)
+        st = 0
+        rho = pi[:]
+        done = False
+        m = n-1
+        while m > 0 and not done:
+            d = rho.index(m)
+            for i in range(d, m):
+                rho[i] = rho[i + 1]
+            par = _af_parity(rho[:m])
+            if par == 1:
+                if d == m:
+                    m -= 1
+                else:
+                    pi[st + d], pi[st + d + 1] = pi[st + d + 1], pi[st + d]
+                    done = True
+            else:
+                if d == 0:
+                    m -= 1
+                    st += 1
+                else:
+                    pi[st + d], pi[st + d - 1] = pi[st + d - 1], pi[st + d]
+                    done = True
+        if m == 0:
+            return None
+        return self._af_new(pi)
+
+    def get_precedence_matrix(self):
+        """
+        Gets the precedence matrix. This is used for computing the
+        distance between two permutations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation.josephus(3, 6, 1)
+        >>> p
+        Permutation([2, 5, 3, 1, 4, 0])
+        >>> p.get_precedence_matrix()
+        Matrix([
+        [0, 0, 0, 0, 0, 0],
+        [1, 0, 0, 0, 1, 0],
+        [1, 1, 0, 1, 1, 1],
+        [1, 1, 0, 0, 1, 0],
+        [1, 0, 0, 0, 0, 0],
+        [1, 1, 0, 1, 1, 0]])
+
+        See Also
+        ========
+
+        get_precedence_distance, get_adjacency_matrix, get_adjacency_distance
+        """
+        m = zeros(self.size)
+        perm = self.array_form
+        for i in range(m.rows):
+            for j in range(i + 1, m.cols):
+                m[perm[i], perm[j]] = 1
+        return m
+
+    def get_precedence_distance(self, other):
+        """
+        Computes the precedence distance between two permutations.
+
+        Explanation
+        ===========
+
+        Suppose p and p' represent n jobs. The precedence metric
+        counts the number of times a job j is preceded by job i
+        in both p and p'. This metric is commutative.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([2, 0, 4, 3, 1])
+        >>> q = Permutation([3, 1, 2, 4, 0])
+        >>> p.get_precedence_distance(q)
+        7
+        >>> q.get_precedence_distance(p)
+        7
+
+        See Also
+        ========
+
+        get_precedence_matrix, get_adjacency_matrix, get_adjacency_distance
+        """
+        if self.size != other.size:
+            raise ValueError("The permutations must be of equal size.")
+        self_prec_mat = self.get_precedence_matrix()
+        other_prec_mat = other.get_precedence_matrix()
+        n_prec = 0
+        for i in range(self.size):
+            for j in range(self.size):
+                if i == j:
+                    continue
+                if self_prec_mat[i, j] * other_prec_mat[i, j] == 1:
+                    n_prec += 1
+        d = self.size * (self.size - 1)//2 - n_prec
+        return d
+
+    def get_adjacency_matrix(self):
+        """
+        Computes the adjacency matrix of a permutation.
+
+        Explanation
+        ===========
+
+        If job i is adjacent to job j in a permutation p
+        then we set m[i, j] = 1 where m is the adjacency
+        matrix of p.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation.josephus(3, 6, 1)
+        >>> p.get_adjacency_matrix()
+        Matrix([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 1, 0],
+        [0, 0, 0, 0, 0, 1],
+        [0, 1, 0, 0, 0, 0],
+        [1, 0, 0, 0, 0, 0],
+        [0, 0, 0, 1, 0, 0]])
+        >>> q = Permutation([0, 1, 2, 3])
+        >>> q.get_adjacency_matrix()
+        Matrix([
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]])
+
+        See Also
+        ========
+
+        get_precedence_matrix, get_precedence_distance, get_adjacency_distance
+        """
+        m = zeros(self.size)
+        perm = self.array_form
+        for i in range(self.size - 1):
+            m[perm[i], perm[i + 1]] = 1
+        return m
+
+    def get_adjacency_distance(self, other):
+        """
+        Computes the adjacency distance between two permutations.
+
+        Explanation
+        ===========
+
+        This metric counts the number of times a pair i,j of jobs is
+        adjacent in both p and p'. If n_adj is this quantity then
+        the adjacency distance is n - n_adj - 1 [1]
+
+        [1] Reeves, Colin R. Landscapes, Operators and Heuristic search, Annals
+        of Operational Research, 86, pp 473-490. (1999)
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 3, 1, 2, 4])
+        >>> q = Permutation.josephus(4, 5, 2)
+        >>> p.get_adjacency_distance(q)
+        3
+        >>> r = Permutation([0, 2, 1, 4, 3])
+        >>> p.get_adjacency_distance(r)
+        4
+
+        See Also
+        ========
+
+        get_precedence_matrix, get_precedence_distance, get_adjacency_matrix
+        """
+        if self.size != other.size:
+            raise ValueError("The permutations must be of the same size.")
+        self_adj_mat = self.get_adjacency_matrix()
+        other_adj_mat = other.get_adjacency_matrix()
+        n_adj = 0
+        for i in range(self.size):
+            for j in range(self.size):
+                if i == j:
+                    continue
+                if self_adj_mat[i, j] * other_adj_mat[i, j] == 1:
+                    n_adj += 1
+        d = self.size - n_adj - 1
+        return d
+
+    def get_positional_distance(self, other):
+        """
+        Computes the positional distance between two permutations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 3, 1, 2, 4])
+        >>> q = Permutation.josephus(4, 5, 2)
+        >>> r = Permutation([3, 1, 4, 0, 2])
+        >>> p.get_positional_distance(q)
+        12
+        >>> p.get_positional_distance(r)
+        12
+
+        See Also
+        ========
+
+        get_precedence_distance, get_adjacency_distance
+        """
+        a = self.array_form
+        b = other.array_form
+        if len(a) != len(b):
+            raise ValueError("The permutations must be of the same size.")
+        return sum(abs(a[i] - b[i]) for i in range(len(a)))
+
+    @classmethod
+    def josephus(cls, m, n, s=1):
+        """Return as a permutation the shuffling of range(n) using the Josephus
+        scheme in which every m-th item is selected until all have been chosen.
+        The returned permutation has elements listed by the order in which they
+        were selected.
+
+        The parameter ``s`` stops the selection process when there are ``s``
+        items remaining and these are selected by continuing the selection,
+        counting by 1 rather than by ``m``.
+
+        Consider selecting every 3rd item from 6 until only 2 remain::
+
+            choices    chosen
+            ========   ======
+              012345
+              01 345   2
+              01 34    25
+              01  4    253
+              0   4    2531
+              0        25314
+                       253140
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation.josephus(3, 6, 2).array_form
+        [2, 5, 3, 1, 4, 0]
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Flavius_Josephus
+        .. [2] https://en.wikipedia.org/wiki/Josephus_problem
+        .. [3] https://web.archive.org/web/20171008094331/http://www.wou.edu/~burtonl/josephus.html
+
+        """
+        from collections import deque
+        m -= 1
+        Q = deque(list(range(n)))
+        perm = []
+        while len(Q) > max(s, 1):
+            for dp in range(m):
+                Q.append(Q.popleft())
+            perm.append(Q.popleft())
+        perm.extend(list(Q))
+        return cls(perm)
+
+    @classmethod
+    def from_inversion_vector(cls, inversion):
+        """
+        Calculates the permutation from the inversion vector.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> Permutation.from_inversion_vector([3, 2, 1, 0, 0])
+        Permutation([3, 2, 1, 0, 4, 5])
+
+        """
+        size = len(inversion)
+        N = list(range(size + 1))
+        perm = []
+        try:
+            for k in range(size):
+                val = N[inversion[k]]
+                perm.append(val)
+                N.remove(val)
+        except IndexError:
+            raise ValueError("The inversion vector is not valid.")
+        perm.extend(N)
+        return cls._af_new(perm)
+
+    @classmethod
+    def random(cls, n):
+        """
+        Generates a random permutation of length ``n``.
+
+        Uses the underlying Python pseudo-random number generator.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation.random(2) in (Permutation([1, 0]), Permutation([0, 1]))
+        True
+
+        """
+        perm_array = list(range(n))
+        random.shuffle(perm_array)
+        return cls._af_new(perm_array)
+
+    @classmethod
+    def unrank_lex(cls, size, rank):
+        """
+        Lexicographic permutation unranking.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> a = Permutation.unrank_lex(5, 10)
+        >>> a.rank()
+        10
+        >>> a
+        Permutation([0, 2, 4, 1, 3])
+
+        See Also
+        ========
+
+        rank, next_lex
+        """
+        perm_array = [0] * size
+        psize = 1
+        for i in range(size):
+            new_psize = psize*(i + 1)
+            d = (rank % new_psize) // psize
+            rank -= d*psize
+            perm_array[size - i - 1] = d
+            for j in range(size - i, size):
+                if perm_array[j] > d - 1:
+                    perm_array[j] += 1
+            psize = new_psize
+        return cls._af_new(perm_array)
+
+    def resize(self, n):
+        """Resize the permutation to the new size ``n``.
+
+        Parameters
+        ==========
+
+        n : int
+            The new size of the permutation.
+
+        Raises
+        ======
+
+        ValueError
+            If the permutation cannot be resized to the given size.
+            This may only happen when resized to a smaller size than
+            the original.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+
+        Increasing the size of a permutation:
+
+        >>> p = Permutation(0, 1, 2)
+        >>> p = p.resize(5)
+        >>> p
+        (4)(0 1 2)
+
+        Decreasing the size of the permutation:
+
+        >>> p = p.resize(4)
+        >>> p
+        (3)(0 1 2)
+
+        If resizing to the specific size breaks the cycles:
+
+        >>> p.resize(2)
+        Traceback (most recent call last):
+        ...
+        ValueError: The permutation cannot be resized to 2 because the
+        cycle (0, 1, 2) may break.
+        """
+        aform = self.array_form
+        l = len(aform)
+        if n > l:
+            aform += list(range(l, n))
+            return Permutation._af_new(aform)
+
+        elif n < l:
+            cyclic_form = self.full_cyclic_form
+            new_cyclic_form = []
+            for cycle in cyclic_form:
+                cycle_min = min(cycle)
+                cycle_max = max(cycle)
+                if cycle_min <= n-1:
+                    if cycle_max > n-1:
+                        raise ValueError(
+                            "The permutation cannot be resized to {} "
+                            "because the cycle {} may break."
+                            .format(n, tuple(cycle)))
+
+                    new_cyclic_form.append(cycle)
+            return Permutation(new_cyclic_form)
+
+        return self
+
+    # XXX Deprecated flag
+    print_cyclic = None
+
+
+def _merge(arr, temp, left, mid, right):
+    """
+    Merges two sorted arrays and calculates the inversion count.
+
+    Helper function for calculating inversions. This method is
+    for internal use only.
+    """
+    i = k = left
+    j = mid
+    inv_count = 0
+    while i < mid and j <= right:
+        if arr[i] < arr[j]:
+            temp[k] = arr[i]
+            k += 1
+            i += 1
+        else:
+            temp[k] = arr[j]
+            k += 1
+            j += 1
+            inv_count += (mid -i)
+    while i < mid:
+        temp[k] = arr[i]
+        k += 1
+        i += 1
+    if j <= right:
+        k += right - j + 1
+        j += right - j + 1
+        arr[left:k + 1] = temp[left:k + 1]
+    else:
+        arr[left:right + 1] = temp[left:right + 1]
+    return inv_count
+
+Perm = Permutation
+_af_new = Perm._af_new
+
+
+class AppliedPermutation(Expr):
+    """A permutation applied to a symbolic variable.
+
+    Parameters
+    ==========
+
+    perm : Permutation
+    x : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.combinatorics import Permutation
+
+    Creating a symbolic permutation function application:
+
+    >>> x = Symbol('x')
+    >>> p = Permutation(0, 1, 2)
+    >>> p.apply(x)
+    AppliedPermutation((0 1 2), x)
+    >>> _.subs(x, 1)
+    2
+    """
+    def __new__(cls, perm, x, evaluate=None):
+        if evaluate is None:
+            evaluate = global_parameters.evaluate
+
+        perm = _sympify(perm)
+        x = _sympify(x)
+
+        if not isinstance(perm, Permutation):
+            raise ValueError("{} must be a Permutation instance."
+                .format(perm))
+
+        if evaluate:
+            if x.is_Integer:
+                return perm.apply(x)
+
+        obj = super().__new__(cls, perm, x)
+        return obj
+
+
+@dispatch(Permutation, Permutation)
+def _eval_is_eq(lhs, rhs):
+    if lhs._size != rhs._size:
+        return None
+    return lhs._array_form == rhs._array_form

mgm/lib/python3.10/site-packages/sympy/combinatorics/prufer.py

@@ -0,0 +1,435 @@
+from sympy.core import Basic
+from sympy.core.containers import Tuple
+from sympy.tensor.array import Array
+from sympy.core.sympify import _sympify
+from sympy.utilities.iterables import flatten, iterable
+from sympy.utilities.misc import as_int
+
+from collections import defaultdict
+
+
+class Prufer(Basic):
+    """
+    The Prufer correspondence is an algorithm that describes the
+    bijection between labeled trees and the Prufer code. A Prufer
+    code of a labeled tree is unique up to isomorphism and has
+    a length of n - 2.
+
+    Prufer sequences were first used by Heinz Prufer to give a
+    proof of Cayley's formula.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/LabeledTree.html
+
+    """
+    _prufer_repr = None
+    _tree_repr = None
+    _nodes = None
+    _rank = None
+
+    @property
+    def prufer_repr(self):
+        """Returns Prufer sequence for the Prufer object.
+
+        This sequence is found by removing the highest numbered vertex,
+        recording the node it was attached to, and continuing until only
+        two vertices remain. The Prufer sequence is the list of recorded nodes.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]).prufer_repr
+        [3, 3, 3, 4]
+        >>> Prufer([1, 0, 0]).prufer_repr
+        [1, 0, 0]
+
+        See Also
+        ========
+
+        to_prufer
+
+        """
+        if self._prufer_repr is None:
+            self._prufer_repr = self.to_prufer(self._tree_repr[:], self.nodes)
+        return self._prufer_repr
+
+    @property
+    def tree_repr(self):
+        """Returns the tree representation of the Prufer object.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]).tree_repr
+        [[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]
+        >>> Prufer([1, 0, 0]).tree_repr
+        [[1, 2], [0, 1], [0, 3], [0, 4]]
+
+        See Also
+        ========
+
+        to_tree
+
+        """
+        if self._tree_repr is None:
+            self._tree_repr = self.to_tree(self._prufer_repr[:])
+        return self._tree_repr
+
+    @property
+    def nodes(self):
+        """Returns the number of nodes in the tree.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]).nodes
+        6
+        >>> Prufer([1, 0, 0]).nodes
+        5
+
+        """
+        return self._nodes
+
+    @property
+    def rank(self):
+        """Returns the rank of the Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> p = Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]])
+        >>> p.rank
+        778
+        >>> p.next(1).rank
+        779
+        >>> p.prev().rank
+        777
+
+        See Also
+        ========
+
+        prufer_rank, next, prev, size
+
+        """
+        if self._rank is None:
+            self._rank = self.prufer_rank()
+        return self._rank
+
+    @property
+    def size(self):
+        """Return the number of possible trees of this Prufer object.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([0]*4).size == Prufer([6]*4).size == 1296
+        True
+
+        See Also
+        ========
+
+        prufer_rank, rank, next, prev
+
+        """
+        return self.prev(self.rank).prev().rank + 1
+
+    @staticmethod
+    def to_prufer(tree, n):
+        """Return the Prufer sequence for a tree given as a list of edges where
+        ``n`` is the number of nodes in the tree.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> a.prufer_repr
+        [0, 0]
+        >>> Prufer.to_prufer([[0, 1], [0, 2], [0, 3]], 4)
+        [0, 0]
+
+        See Also
+        ========
+        prufer_repr: returns Prufer sequence of a Prufer object.
+
+        """
+        d = defaultdict(int)
+        L = []
+        for edge in tree:
+            # Increment the value of the corresponding
+            # node in the degree list as we encounter an
+            # edge involving it.
+            d[edge[0]] += 1
+            d[edge[1]] += 1
+        for i in range(n - 2):
+            # find the smallest leaf
+            for x in range(n):
+                if d[x] == 1:
+                    break
+            # find the node it was connected to
+            y = None
+            for edge in tree:
+                if x == edge[0]:
+                    y = edge[1]
+                elif x == edge[1]:
+                    y = edge[0]
+                if y is not None:
+                    break
+            # record and update
+            L.append(y)
+            for j in (x, y):
+                d[j] -= 1
+                if not d[j]:
+                    d.pop(j)
+            tree.remove(edge)
+        return L
+
+    @staticmethod
+    def to_tree(prufer):
+        """Return the tree (as a list of edges) of the given Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([0, 2], 4)
+        >>> a.tree_repr
+        [[0, 1], [0, 2], [2, 3]]
+        >>> Prufer.to_tree([0, 2])
+        [[0, 1], [0, 2], [2, 3]]
+
+        References
+        ==========
+
+        .. [1] https://hamberg.no/erlend/posts/2010-11-06-prufer-sequence-compact-tree-representation.html
+
+        See Also
+        ========
+        tree_repr: returns tree representation of a Prufer object.
+
+        """
+        tree = []
+        last = []
+        n = len(prufer) + 2
+        d = defaultdict(lambda: 1)
+        for p in prufer:
+            d[p] += 1
+        for i in prufer:
+            for j in range(n):
+            # find the smallest leaf (degree = 1)
+                if d[j] == 1:
+                    break
+            # (i, j) is the new edge that we append to the tree
+            # and remove from the degree dictionary
+            d[i] -= 1
+            d[j] -= 1
+            tree.append(sorted([i, j]))
+        last = [i for i in range(n) if d[i] == 1] or [0, 1]
+        tree.append(last)
+
+        return tree
+
+    @staticmethod
+    def edges(*runs):
+        """Return a list of edges and the number of nodes from the given runs
+        that connect nodes in an integer-labelled tree.
+
+        All node numbers will be shifted so that the minimum node is 0. It is
+        not a problem if edges are repeated in the runs; only unique edges are
+        returned. There is no assumption made about what the range of the node
+        labels should be, but all nodes from the smallest through the largest
+        must be present.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer.edges([1, 2, 3], [2, 4, 5]) # a T
+        ([[0, 1], [1, 2], [1, 3], [3, 4]], 5)
+
+        Duplicate edges are removed:
+
+        >>> Prufer.edges([0, 1, 2, 3], [1, 4, 5], [1, 4, 6]) # a K
+        ([[0, 1], [1, 2], [1, 4], [2, 3], [4, 5], [4, 6]], 7)
+
+        """
+        e = set()
+        nmin = runs[0][0]
+        for r in runs:
+            for i in range(len(r) - 1):
+                a, b = r[i: i + 2]
+                if b < a:
+                    a, b = b, a
+                e.add((a, b))
+        rv = []
+        got = set()
+        nmin = nmax = None
+        for ei in e:
+            got.update(ei)
+            nmin = min(ei[0], nmin) if nmin is not None else ei[0]
+            nmax = max(ei[1], nmax) if nmax is not None else ei[1]
+            rv.append(list(ei))
+        missing = set(range(nmin, nmax + 1)) - got
+        if missing:
+            missing = [i + nmin for i in missing]
+            if len(missing) == 1:
+                msg = 'Node %s is missing.' % missing.pop()
+            else:
+                msg = 'Nodes %s are missing.' % sorted(missing)
+            raise ValueError(msg)
+        if nmin != 0:
+            for i, ei in enumerate(rv):
+                rv[i] = [n - nmin for n in ei]
+            nmax -= nmin
+        return sorted(rv), nmax + 1
+
+    def prufer_rank(self):
+        """Computes the rank of a Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> a.prufer_rank()
+        0
+
+        See Also
+        ========
+
+        rank, next, prev, size
+
+        """
+        r = 0
+        p = 1
+        for i in range(self.nodes - 3, -1, -1):
+            r += p*self.prufer_repr[i]
+            p *= self.nodes
+        return r
+
+    @classmethod
+    def unrank(self, rank, n):
+        """Finds the unranked Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer.unrank(0, 4)
+        Prufer([0, 0])
+
+        """
+        n, rank = as_int(n), as_int(rank)
+        L = defaultdict(int)
+        for i in range(n - 3, -1, -1):
+            L[i] = rank % n
+            rank = (rank - L[i])//n
+        return Prufer([L[i] for i in range(len(L))])
+
+    def __new__(cls, *args, **kw_args):
+        """The constructor for the Prufer object.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+
+        A Prufer object can be constructed from a list of edges:
+
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> a.prufer_repr
+        [0, 0]
+
+        If the number of nodes is given, no checking of the nodes will
+        be performed; it will be assumed that nodes 0 through n - 1 are
+        present:
+
+        >>> Prufer([[0, 1], [0, 2], [0, 3]], 4)
+        Prufer([[0, 1], [0, 2], [0, 3]], 4)
+
+        A Prufer object can be constructed from a Prufer sequence:
+
+        >>> b = Prufer([1, 3])
+        >>> b.tree_repr
+        [[0, 1], [1, 3], [2, 3]]
+
+        """
+        arg0 = Array(args[0]) if args[0] else Tuple()
+        args = (arg0,) + tuple(_sympify(arg) for arg in args[1:])
+        ret_obj = Basic.__new__(cls, *args, **kw_args)
+        args = [list(args[0])]
+        if args[0] and iterable(args[0][0]):
+            if not args[0][0]:
+                raise ValueError(
+                    'Prufer expects at least one edge in the tree.')
+            if len(args) > 1:
+                nnodes = args[1]
+            else:
+                nodes = set(flatten(args[0]))
+                nnodes = max(nodes) + 1
+                if nnodes != len(nodes):
+                    missing = set(range(nnodes)) - nodes
+                    if len(missing) == 1:
+                        msg = 'Node %s is missing.' % missing.pop()
+                    else:
+                        msg = 'Nodes %s are missing.' % sorted(missing)
+                    raise ValueError(msg)
+            ret_obj._tree_repr = [list(i) for i in args[0]]
+            ret_obj._nodes = nnodes
+        else:
+            ret_obj._prufer_repr = args[0]
+            ret_obj._nodes = len(ret_obj._prufer_repr) + 2
+        return ret_obj
+
+    def next(self, delta=1):
+        """Generates the Prufer sequence that is delta beyond the current one.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> b = a.next(1) # == a.next()
+        >>> b.tree_repr
+        [[0, 2], [0, 1], [1, 3]]
+        >>> b.rank
+        1
+
+        See Also
+        ========
+
+        prufer_rank, rank, prev, size
+
+        """
+        return Prufer.unrank(self.rank + delta, self.nodes)
+
+    def prev(self, delta=1):
+        """Generates the Prufer sequence that is -delta before the current one.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [1, 2], [2, 3], [1, 4]])
+        >>> a.rank
+        36
+        >>> b = a.prev()
+        >>> b
+        Prufer([1, 2, 0])
+        >>> b.rank
+        35
+
+        See Also
+        ========
+
+        prufer_rank, rank, next, size
+
+        """
+        return Prufer.unrank(self.rank -delta, self.nodes)

mgm/lib/python3.10/site-packages/sympy/combinatorics/rewritingsystem.py

@@ -0,0 +1,453 @@
+from collections import deque
+from sympy.combinatorics.rewritingsystem_fsm import StateMachine
+
+class RewritingSystem:
+    '''
+    A class implementing rewriting systems for `FpGroup`s.
+
+    References
+    ==========
+    .. [1] Epstein, D., Holt, D. and Rees, S. (1991).
+           The use of Knuth-Bendix methods to solve the word problem in automatic groups.
+           Journal of Symbolic Computation, 12(4-5), pp.397-414.
+
+    .. [2] GAP's Manual on its KBMAG package
+           https://www.gap-system.org/Manuals/pkg/kbmag-1.5.3/doc/manual.pdf
+
+    '''
+    def __init__(self, group):
+        self.group = group
+        self.alphabet = group.generators
+        self._is_confluent = None
+
+        # these values are taken from [2]
+        self.maxeqns = 32767 # max rules
+        self.tidyint = 100 # rules before tidying
+
+        # _max_exceeded is True if maxeqns is exceeded
+        # at any point
+        self._max_exceeded = False
+
+        # Reduction automaton
+        self.reduction_automaton = None
+        self._new_rules = {}
+
+        # dictionary of reductions
+        self.rules = {}
+        self.rules_cache = deque([], 50)
+        self._init_rules()
+
+
+        # All the transition symbols in the automaton
+        generators = list(self.alphabet)
+        generators += [gen**-1 for gen in generators]
+        # Create a finite state machine as an instance of the StateMachine object
+        self.reduction_automaton = StateMachine('Reduction automaton for '+ repr(self.group), generators)
+        self.construct_automaton()
+
+    def set_max(self, n):
+        '''
+        Set the maximum number of rules that can be defined
+
+        '''
+        if n > self.maxeqns:
+            self._max_exceeded = False
+        self.maxeqns = n
+        return
+
+    @property
+    def is_confluent(self):
+        '''
+        Return `True` if the system is confluent
+
+        '''
+        if self._is_confluent is None:
+            self._is_confluent = self._check_confluence()
+        return self._is_confluent
+
+    def _init_rules(self):
+        identity = self.group.free_group.identity
+        for r in self.group.relators:
+            self.add_rule(r, identity)
+        self._remove_redundancies()
+        return
+
+    def _add_rule(self, r1, r2):
+        '''
+        Add the rule r1 -> r2 with no checking or further
+        deductions
+
+        '''
+        if len(self.rules) + 1 > self.maxeqns:
+            self._is_confluent = self._check_confluence()
+            self._max_exceeded = True
+            raise RuntimeError("Too many rules were defined.")
+        self.rules[r1] = r2
+        # Add the newly added rule to the `new_rules` dictionary.
+        if self.reduction_automaton:
+            self._new_rules[r1] = r2
+
+    def add_rule(self, w1, w2, check=False):
+        new_keys = set()
+
+        if w1 == w2:
+            return new_keys
+
+        if w1 < w2:
+            w1, w2 = w2, w1
+
+        if (w1, w2) in self.rules_cache:
+            return new_keys
+        self.rules_cache.append((w1, w2))
+
+        s1, s2 = w1, w2
+
+        # The following is the equivalent of checking
+        # s1 for overlaps with the implicit reductions
+        # {g*g**-1 -> <identity>} and {g**-1*g -> <identity>}
+        # for any generator g without installing the
+        # redundant rules that would result from processing
+        # the overlaps. See [1], Section 3 for details.
+
+        if len(s1) - len(s2) < 3:
+            if s1 not in self.rules:
+                new_keys.add(s1)
+                if not check:
+                    self._add_rule(s1, s2)
+            if s2**-1 > s1**-1 and s2**-1 not in self.rules:
+                new_keys.add(s2**-1)
+                if not check:
+                    self._add_rule(s2**-1, s1**-1)
+
+        # overlaps on the right
+        while len(s1) - len(s2) > -1:
+            g = s1[len(s1)-1]
+            s1 = s1.subword(0, len(s1)-1)
+            s2 = s2*g**-1
+            if len(s1) - len(s2) < 0:
+                if s2 not in self.rules:
+                    if not check:
+                        self._add_rule(s2, s1)
+                    new_keys.add(s2)
+            elif len(s1) - len(s2) < 3:
+                new = self.add_rule(s1, s2, check)
+                new_keys.update(new)
+
+        # overlaps on the left
+        while len(w1) - len(w2) > -1:
+            g = w1[0]
+            w1 = w1.subword(1, len(w1))
+            w2 = g**-1*w2
+            if len(w1) - len(w2) < 0:
+                if w2 not in self.rules:
+                    if not check:
+                        self._add_rule(w2, w1)
+                    new_keys.add(w2)
+            elif len(w1) - len(w2) < 3:
+                new = self.add_rule(w1, w2, check)
+                new_keys.update(new)
+
+        return new_keys
+
+    def _remove_redundancies(self, changes=False):
+        '''
+        Reduce left- and right-hand sides of reduction rules
+        and remove redundant equations (i.e. those for which
+        lhs == rhs). If `changes` is `True`, return a set
+        containing the removed keys and a set containing the
+        added keys
+
+        '''
+        removed = set()
+        added = set()
+        rules = self.rules.copy()
+        for r in rules:
+            v = self.reduce(r, exclude=r)
+            w = self.reduce(rules[r])
+            if v != r:
+                del self.rules[r]
+                removed.add(r)
+                if v > w:
+                    added.add(v)
+                    self.rules[v] = w
+                elif v < w:
+                    added.add(w)
+                    self.rules[w] = v
+            else:
+                self.rules[v] = w
+        if changes:
+            return removed, added
+        return
+
+    def make_confluent(self, check=False):
+        '''
+        Try to make the system confluent using the Knuth-Bendix
+        completion algorithm
+
+        '''
+        if self._max_exceeded:
+            return self._is_confluent
+        lhs = list(self.rules.keys())
+
+        def _overlaps(r1, r2):
+            len1 = len(r1)
+            len2 = len(r2)
+            result = []
+            for j in range(1, len1 + len2):
+                if (r1.subword(len1 - j, len1 + len2 - j, strict=False)
+                       == r2.subword(j - len1, j, strict=False)):
+                    a = r1.subword(0, len1-j, strict=False)
+                    a = a*r2.subword(0, j-len1, strict=False)
+                    b = r2.subword(j-len1, j, strict=False)
+                    c = r2.subword(j, len2, strict=False)
+                    c = c*r1.subword(len1 + len2 - j, len1, strict=False)
+                    result.append(a*b*c)
+            return result
+
+        def _process_overlap(w, r1, r2, check):
+                s = w.eliminate_word(r1, self.rules[r1])
+                s = self.reduce(s)
+                t = w.eliminate_word(r2, self.rules[r2])
+                t = self.reduce(t)
+                if s != t:
+                    if check:
+                        # system not confluent
+                        return [0]
+                    try:
+                        new_keys = self.add_rule(t, s, check)
+                        return new_keys
+                    except RuntimeError:
+                        return False
+                return
+
+        added = 0
+        i = 0
+        while i < len(lhs):
+            r1 = lhs[i]
+            i += 1
+            # j could be i+1 to not
+            # check each pair twice but lhs
+            # is extended in the loop and the new
+            # elements have to be checked with the
+            # preceding ones. there is probably a better way
+            # to handle this
+            j = 0
+            while j < len(lhs):
+                r2 = lhs[j]
+                j += 1
+                if r1 == r2:
+                    continue
+                overlaps = _overlaps(r1, r2)
+                overlaps.extend(_overlaps(r1**-1, r2))
+                if not overlaps:
+                    continue
+                for w in overlaps:
+                    new_keys = _process_overlap(w, r1, r2, check)
+                    if new_keys:
+                        if check:
+                            return False
+                        lhs.extend(new_keys)
+                        added += len(new_keys)
+                    elif new_keys == False:
+                        # too many rules were added so the process
+                        # couldn't complete
+                        return self._is_confluent
+
+                if added > self.tidyint and not check:
+                    # tidy up
+                    r, a = self._remove_redundancies(changes=True)
+                    added = 0
+                    if r:
+                        # reset i since some elements were removed
+                        i = min(lhs.index(s) for s in r)
+                    lhs = [l for l in lhs if l not in r]
+                    lhs.extend(a)
+                    if r1 in r:
+                        # r1 was removed as redundant
+                        break
+
+        self._is_confluent = True
+        if not check:
+            self._remove_redundancies()
+        return True
+
+    def _check_confluence(self):
+        return self.make_confluent(check=True)
+
+    def reduce(self, word, exclude=None):
+        '''
+        Apply reduction rules to `word` excluding the reduction rule
+        for the lhs equal to `exclude`
+
+        '''
+        rules = {r: self.rules[r] for r in self.rules if r != exclude}
+        # the following is essentially `eliminate_words()` code from the
+        # `FreeGroupElement` class, the only difference being the first
+        # "if" statement
+        again = True
+        new = word
+        while again:
+            again = False
+            for r in rules:
+                prev = new
+                if rules[r]**-1 > r**-1:
+                    new = new.eliminate_word(r, rules[r], _all=True, inverse=False)
+                else:
+                    new = new.eliminate_word(r, rules[r], _all=True)
+                if new != prev:
+                    again = True
+        return new
+
+    def _compute_inverse_rules(self, rules):
+        '''
+        Compute the inverse rules for a given set of rules.
+        The inverse rules are used in the automaton for word reduction.
+
+        Arguments:
+            rules (dictionary): Rules for which the inverse rules are to computed.
+
+        Returns:
+            Dictionary of inverse_rules.
+
+        '''
+        inverse_rules = {}
+        for r in rules:
+            rule_key_inverse = r**-1
+            rule_value_inverse = (rules[r])**-1
+            if (rule_value_inverse < rule_key_inverse):
+                inverse_rules[rule_key_inverse] = rule_value_inverse
+            else:
+                inverse_rules[rule_value_inverse] = rule_key_inverse
+        return inverse_rules
+
+    def construct_automaton(self):
+        '''
+        Construct the automaton based on the set of reduction rules of the system.
+
+        Automata Design:
+        The accept states of the automaton are the proper prefixes of the left hand side of the rules.
+        The complete left hand side of the rules are the dead states of the automaton.
+
+        '''
+        self._add_to_automaton(self.rules)
+
+    def _add_to_automaton(self, rules):
+        '''
+        Add new states and transitions to the automaton.
+
+        Summary:
+        States corresponding to the new rules added to the system are computed and added to the automaton.
+        Transitions in the previously added states are also modified if necessary.
+
+        Arguments:
+            rules (dictionary) -- Dictionary of the newly added rules.
+
+        '''
+        # Automaton variables
+        automaton_alphabet = []
+        proper_prefixes = {}
+
+        # compute the inverses of all the new rules added
+        all_rules = rules
+        inverse_rules = self._compute_inverse_rules(all_rules)
+        all_rules.update(inverse_rules)
+
+        # Keep track of the accept_states.
+        accept_states = []
+
+        for rule in all_rules:
+            # The symbols present in the new rules are the symbols to be verified at each state.
+            # computes the automaton_alphabet, as the transitions solely depend upon the new states.
+            automaton_alphabet += rule.letter_form_elm
+            # Compute the proper prefixes for every rule.
+            proper_prefixes[rule] = []
+            letter_word_array = list(rule.letter_form_elm)
+            len_letter_word_array = len(letter_word_array)
+            for i in range (1, len_letter_word_array):
+                letter_word_array[i] = letter_word_array[i-1]*letter_word_array[i]
+                # Add accept states.
+                elem = letter_word_array[i-1]
+                if elem not in self.reduction_automaton.states:
+                    self.reduction_automaton.add_state(elem, state_type='a')
+                    accept_states.append(elem)
+            proper_prefixes[rule] = letter_word_array
+            # Check for overlaps between dead and accept states.
+            if rule in accept_states:
+                self.reduction_automaton.states[rule].state_type = 'd'
+                self.reduction_automaton.states[rule].rh_rule = all_rules[rule]
+                accept_states.remove(rule)
+            # Add dead states
+            if rule not in self.reduction_automaton.states:
+                self.reduction_automaton.add_state(rule, state_type='d', rh_rule=all_rules[rule])
+
+        automaton_alphabet = set(automaton_alphabet)
+
+        # Add new transitions for every state.
+        for state in self.reduction_automaton.states:
+            current_state_name = state
+            current_state_type = self.reduction_automaton.states[state].state_type
+            # Transitions will be modified only when suffixes of the current_state
+            # belongs to the proper_prefixes of the new rules.
+            # The rest are ignored if they cannot lead to a dead state after a finite number of transisitons.
+            if current_state_type == 's':
+                for letter in automaton_alphabet:
+                    if letter in self.reduction_automaton.states:
+                        self.reduction_automaton.states[state].add_transition(letter, letter)
+                    else:
+                        self.reduction_automaton.states[state].add_transition(letter, current_state_name)
+            elif current_state_type == 'a':
+                # Check if the transition to any new state in possible.
+                for letter in automaton_alphabet:
+                    _next = current_state_name*letter
+                    while len(_next) and _next not in self.reduction_automaton.states:
+                        _next = _next.subword(1, len(_next))
+                    if not len(_next):
+                        _next = 'start'
+                    self.reduction_automaton.states[state].add_transition(letter, _next)
+
+        # Add transitions for new states. All symbols used in the automaton are considered here.
+        # Ignore this if `reduction_automaton.automaton_alphabet` = `automaton_alphabet`.
+        if len(self.reduction_automaton.automaton_alphabet) != len(automaton_alphabet):
+            for state in accept_states:
+                current_state_name = state
+                for letter in self.reduction_automaton.automaton_alphabet:
+                    _next = current_state_name*letter
+                    while len(_next) and _next not in self.reduction_automaton.states:
+                        _next = _next.subword(1, len(_next))
+                    if not len(_next):
+                        _next = 'start'
+                    self.reduction_automaton.states[state].add_transition(letter, _next)
+
+    def reduce_using_automaton(self, word):
+        '''
+        Reduce a word using an automaton.
+
+        Summary:
+        All the symbols of the word are stored in an array and are given as the input to the automaton.
+        If the automaton reaches a dead state that subword is replaced and the automaton is run from the beginning.
+        The complete word has to be replaced when the word is read and the automaton reaches a dead state.
+        So, this process is repeated until the word is read completely and the automaton reaches the accept state.
+
+        Arguments:
+            word (instance of FreeGroupElement) -- Word that needs to be reduced.
+
+        '''
+        # Modify the automaton if new rules are found.
+        if self._new_rules:
+            self._add_to_automaton(self._new_rules)
+            self._new_rules = {}
+
+        flag = 1
+        while flag:
+            flag = 0
+            current_state = self.reduction_automaton.states['start']
+            for i, s in enumerate(word.letter_form_elm):
+                next_state_name = current_state.transitions[s]
+                next_state = self.reduction_automaton.states[next_state_name]
+                if next_state.state_type == 'd':
+                    subst = next_state.rh_rule
+                    word = word.substituted_word(i - len(next_state_name) + 1, i+1, subst)
+                    flag = 1
+                    break
+                current_state = next_state
+        return word

mgm/lib/python3.10/site-packages/sympy/combinatorics/rewritingsystem_fsm.py

@@ -0,0 +1,60 @@
+class State:
+    '''
+    A representation of a state managed by a ``StateMachine``.
+
+    Attributes:
+        name (instance of FreeGroupElement or string) -- State name which is also assigned to the Machine.
+        transisitons (OrderedDict) -- Represents all the transitions of the state object.
+        state_type (string) -- Denotes the type (accept/start/dead) of the state.
+        rh_rule (instance of FreeGroupElement) -- right hand rule for dead state.
+        state_machine (instance of StateMachine object) -- The finite state machine that the state belongs to.
+    '''
+
+    def __init__(self, name, state_machine, state_type=None, rh_rule=None):
+        self.name = name
+        self.transitions = {}
+        self.state_machine = state_machine
+        self.state_type = state_type[0]
+        self.rh_rule = rh_rule
+
+    def add_transition(self, letter, state):
+        '''
+        Add a transition from the current state to a new state.
+
+        Keyword Arguments:
+            letter -- The alphabet element the current state reads to make the state transition.
+            state -- This will be an instance of the State object which represents a new state after in the transition after the alphabet is read.
+
+        '''
+        self.transitions[letter] = state
+
+class StateMachine:
+    '''
+    Representation of a finite state machine the manages the states and the transitions of the automaton.
+
+    Attributes:
+        states (dictionary) -- Collection of all registered `State` objects.
+        name (str) -- Name of the state machine.
+    '''
+
+    def __init__(self, name, automaton_alphabet):
+        self.name = name
+        self.automaton_alphabet = automaton_alphabet
+        self.states = {} # Contains all the states in the machine.
+        self.add_state('start', state_type='s')
+
+    def add_state(self, state_name, state_type=None, rh_rule=None):
+        '''
+        Instantiate a state object and stores it in the 'states' dictionary.
+
+        Arguments:
+            state_name (instance of FreeGroupElement or string) -- name of the new states.
+            state_type (string) -- Denotes the type (accept/start/dead) of the state added.
+            rh_rule (instance of FreeGroupElement) -- right hand rule for dead state.
+
+        '''
+        new_state = State(state_name, self, state_type, rh_rule)
+        self.states[state_name] = new_state
+
+    def __repr__(self):
+        return "%s" % (self.name)

mgm/lib/python3.10/site-packages/sympy/combinatorics/schur_number.py

@@ -0,0 +1,160 @@
+"""
+The Schur number S(k) is the largest integer n for which the interval [1,n]
+can be partitioned into k sum-free sets.(https://mathworld.wolfram.com/SchurNumber.html)
+"""
+import math
+from sympy.core import S
+from sympy.core.basic import Basic
+from sympy.core.function import Function
+from sympy.core.numbers import Integer
+
+
+class SchurNumber(Function):
+    r"""
+    This function creates a SchurNumber object
+    which is evaluated for `k \le 5` otherwise only
+    the lower bound information can be retrieved.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.schur_number import SchurNumber
+
+    Since S(3) = 13, hence the output is a number
+    >>> SchurNumber(3)
+    13
+
+    We do not know the Schur number for values greater than 5, hence
+    only the object is returned
+    >>> SchurNumber(6)
+    SchurNumber(6)
+
+    Now, the lower bound information can be retrieved using lower_bound()
+    method
+    >>> SchurNumber(6).lower_bound()
+    536
+
+    """
+
+    @classmethod
+    def eval(cls, k):
+        if k.is_Number:
+            if k is S.Infinity:
+                return S.Infinity
+            if k.is_zero:
+                return S.Zero
+            if not k.is_integer or k.is_negative:
+                raise ValueError("k should be a positive integer")
+            first_known_schur_numbers = {1: 1, 2: 4, 3: 13, 4: 44, 5: 160}
+            if k <= 5:
+                return Integer(first_known_schur_numbers[k])
+
+    def lower_bound(self):
+        f_ = self.args[0]
+        # Improved lower bounds known for S(6) and S(7)
+        if f_ == 6:
+            return Integer(536)
+        if f_ == 7:
+            return Integer(1680)
+        # For other cases, use general expression
+        if f_.is_Integer:
+            return 3*self.func(f_ - 1).lower_bound() - 1
+        return (3**f_ - 1)/2
+
+
+def _schur_subsets_number(n):
+
+    if n is S.Infinity:
+        raise ValueError("Input must be finite")
+    if n <= 0:
+        raise ValueError("n must be a non-zero positive integer.")
+    elif n <= 3:
+        min_k = 1
+    else:
+        min_k = math.ceil(math.log(2*n + 1, 3))
+
+    return Integer(min_k)
+
+
+def schur_partition(n):
+    """
+
+    This function returns the partition in the minimum number of sum-free subsets
+    according to the lower bound given by the Schur Number.
+
+    Parameters
+    ==========
+
+    n: a number
+        n is the upper limit of the range [1, n] for which we need to find and
+        return the minimum number of free subsets according to the lower bound
+        of schur number
+
+    Returns
+    =======
+
+    List of lists
+        List of the minimum number of sum-free subsets
+
+    Notes
+    =====
+
+    It is possible for some n to make the partition into less
+    subsets since the only known Schur numbers are:
+    S(1) = 1, S(2) = 4, S(3) = 13, S(4) = 44.
+    e.g for n = 44 the lower bound from the function above is 5 subsets but it has been proven
+    that can be done with 4 subsets.
+
+    Examples
+    ========
+
+    For n = 1, 2, 3 the answer is the set itself
+
+    >>> from sympy.combinatorics.schur_number import schur_partition
+    >>> schur_partition(2)
+    [[1, 2]]
+
+    For n > 3, the answer is the minimum number of sum-free subsets:
+
+    >>> schur_partition(5)
+    [[3, 2], [5], [1, 4]]
+
+    >>> schur_partition(8)
+    [[3, 2], [6, 5, 8], [1, 4, 7]]
+    """
+
+    if isinstance(n, Basic) and not n.is_Number:
+        raise ValueError("Input value must be a number")
+
+    number_of_subsets = _schur_subsets_number(n)
+    if n == 1:
+        sum_free_subsets = [[1]]
+    elif n == 2:
+        sum_free_subsets = [[1, 2]]
+    elif n == 3:
+        sum_free_subsets = [[1, 2, 3]]
+    else:
+        sum_free_subsets = [[1, 4], [2, 3]]
+
+    while len(sum_free_subsets) < number_of_subsets:
+        sum_free_subsets = _generate_next_list(sum_free_subsets, n)
+        missed_elements = [3*k + 1 for k in range(len(sum_free_subsets), (n-1)//3 + 1)]
+        sum_free_subsets[-1] += missed_elements
+
+    return sum_free_subsets
+
+
+def _generate_next_list(current_list, n):
+    new_list = []
+
+    for item in current_list:
+        temp_1 = [number*3 for number in item if number*3 <= n]
+        temp_2 = [number*3 - 1 for number in item if number*3 - 1 <= n]
+        new_item = temp_1 + temp_2
+        new_list.append(new_item)
+
+    last_list = [3*k + 1 for k in range(len(current_list)+1) if 3*k + 1 <= n]
+    new_list.append(last_list)
+    current_list = new_list
+
+    return current_list

mgm/lib/python3.10/site-packages/sympy/combinatorics/testutil.py

@@ -0,0 +1,357 @@
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.util import _distribute_gens_by_base
+
+rmul = Permutation.rmul
+
+
+def _cmp_perm_lists(first, second):
+    """
+    Compare two lists of permutations as sets.
+
+    Explanation
+    ===========
+
+    This is used for testing purposes. Since the array form of a
+    permutation is currently a list, Permutation is not hashable
+    and cannot be put into a set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import Permutation
+    >>> from sympy.combinatorics.testutil import _cmp_perm_lists
+    >>> a = Permutation([0, 2, 3, 4, 1])
+    >>> b = Permutation([1, 2, 0, 4, 3])
+    >>> c = Permutation([3, 4, 0, 1, 2])
+    >>> ls1 = [a, b, c]
+    >>> ls2 = [b, c, a]
+    >>> _cmp_perm_lists(ls1, ls2)
+    True
+
+    """
+    return {tuple(a) for a in first} == \
+           {tuple(a) for a in second}
+
+
+def _naive_list_centralizer(self, other, af=False):
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    """
+    Return a list of elements for the centralizer of a subgroup/set/element.
+
+    Explanation
+    ===========
+
+    This is a brute force implementation that goes over all elements of the
+    group and checks for membership in the centralizer. It is used to
+    test ``.centralizer()`` from ``sympy.combinatorics.perm_groups``.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.testutil import _naive_list_centralizer
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> D = DihedralGroup(4)
+    >>> _naive_list_centralizer(D, D)
+    [Permutation([0, 1, 2, 3]), Permutation([2, 3, 0, 1])]
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.centralizer
+
+    """
+    from sympy.combinatorics.permutations import _af_commutes_with
+    if hasattr(other, 'generators'):
+        elements = list(self.generate_dimino(af=True))
+        gens = [x._array_form for x in other.generators]
+        commutes_with_gens = lambda x: all(_af_commutes_with(x, gen) for gen in gens)
+        centralizer_list = []
+        if not af:
+            for element in elements:
+                if commutes_with_gens(element):
+                    centralizer_list.append(Permutation._af_new(element))
+        else:
+            for element in elements:
+                if commutes_with_gens(element):
+                    centralizer_list.append(element)
+        return centralizer_list
+    elif hasattr(other, 'getitem'):
+        return _naive_list_centralizer(self, PermutationGroup(other), af)
+    elif hasattr(other, 'array_form'):
+        return _naive_list_centralizer(self, PermutationGroup([other]), af)
+
+
+def _verify_bsgs(group, base, gens):
+    """
+    Verify the correctness of a base and strong generating set.
+
+    Explanation
+    ===========
+
+    This is a naive implementation using the definition of a base and a strong
+    generating set relative to it. There are other procedures for
+    verifying a base and strong generating set, but this one will
+    serve for more robust testing.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import AlternatingGroup
+    >>> from sympy.combinatorics.testutil import _verify_bsgs
+    >>> A = AlternatingGroup(4)
+    >>> A.schreier_sims()
+    >>> _verify_bsgs(A, A.base, A.strong_gens)
+    True
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.schreier_sims
+
+    """
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    strong_gens_distr = _distribute_gens_by_base(base, gens)
+    current_stabilizer = group
+    for i in range(len(base)):
+        candidate = PermutationGroup(strong_gens_distr[i])
+        if current_stabilizer.order() != candidate.order():
+            return False
+        current_stabilizer = current_stabilizer.stabilizer(base[i])
+    if current_stabilizer.order() != 1:
+        return False
+    return True
+
+
+def _verify_centralizer(group, arg, centr=None):
+    """
+    Verify the centralizer of a group/set/element inside another group.
+
+    This is used for testing ``.centralizer()`` from
+    ``sympy.combinatorics.perm_groups``
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+    ... AlternatingGroup)
+    >>> from sympy.combinatorics.perm_groups import PermutationGroup
+    >>> from sympy.combinatorics.permutations import Permutation
+    >>> from sympy.combinatorics.testutil import _verify_centralizer
+    >>> S = SymmetricGroup(5)
+    >>> A = AlternatingGroup(5)
+    >>> centr = PermutationGroup([Permutation([0, 1, 2, 3, 4])])
+    >>> _verify_centralizer(S, A, centr)
+    True
+
+    See Also
+    ========
+
+    _naive_list_centralizer,
+    sympy.combinatorics.perm_groups.PermutationGroup.centralizer,
+    _cmp_perm_lists
+
+    """
+    if centr is None:
+        centr = group.centralizer(arg)
+    centr_list = list(centr.generate_dimino(af=True))
+    centr_list_naive = _naive_list_centralizer(group, arg, af=True)
+    return _cmp_perm_lists(centr_list, centr_list_naive)
+
+
+def _verify_normal_closure(group, arg, closure=None):
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    """
+    Verify the normal closure of a subgroup/subset/element in a group.
+
+    This is used to test
+    sympy.combinatorics.perm_groups.PermutationGroup.normal_closure
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+    ... AlternatingGroup)
+    >>> from sympy.combinatorics.testutil import _verify_normal_closure
+    >>> S = SymmetricGroup(3)
+    >>> A = AlternatingGroup(3)
+    >>> _verify_normal_closure(S, A, closure=A)
+    True
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.normal_closure
+
+    """
+    if closure is None:
+        closure = group.normal_closure(arg)
+    conjugates = set()
+    if hasattr(arg, 'generators'):
+        subgr_gens = arg.generators
+    elif hasattr(arg, '__getitem__'):
+        subgr_gens = arg
+    elif hasattr(arg, 'array_form'):
+        subgr_gens = [arg]
+    for el in group.generate_dimino():
+        conjugates.update(gen ^ el for gen in subgr_gens)
+    naive_closure = PermutationGroup(list(conjugates))
+    return closure.is_subgroup(naive_closure)
+
+
+def canonicalize_naive(g, dummies, sym, *v):
+    """
+    Canonicalize tensor formed by tensors of the different types.
+
+    Explanation
+    ===========
+
+    sym_i symmetry under exchange of two component tensors of type `i`
+          None  no symmetry
+          0     commuting
+          1     anticommuting
+
+    Parameters
+    ==========
+
+    g : Permutation representing the tensor.
+    dummies : List of dummy indices.
+    msym : Symmetry of the metric.
+    v : A list of (base_i, gens_i, n_i, sym_i) for tensors of type `i`.
+        base_i, gens_i BSGS for tensors of this type
+        n_i  number of tensors of type `i`
+
+    Returns
+    =======
+
+    Returns 0 if the tensor is zero, else returns the array form of
+    the permutation representing the canonical form of the tensor.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.testutil import canonicalize_naive
+    >>> from sympy.combinatorics.tensor_can import get_symmetric_group_sgs
+    >>> from sympy.combinatorics import Permutation
+    >>> g = Permutation([1, 3, 2, 0, 4, 5])
+    >>> base2, gens2 = get_symmetric_group_sgs(2)
+    >>> canonicalize_naive(g, [2, 3], 0, (base2, gens2, 2, 0))
+    [0, 2, 1, 3, 4, 5]
+    """
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    from sympy.combinatorics.tensor_can import gens_products, dummy_sgs
+    from sympy.combinatorics.permutations import _af_rmul
+    v1 = []
+    for i in range(len(v)):
+        base_i, gens_i, n_i, sym_i = v[i]
+        v1.append((base_i, gens_i, [[]]*n_i, sym_i))
+    size, sbase, sgens = gens_products(*v1)
+    dgens = dummy_sgs(dummies, sym, size-2)
+    if isinstance(sym, int):
+        num_types = 1
+        dummies = [dummies]
+        sym = [sym]
+    else:
+        num_types = len(sym)
+    dgens = []
+    for i in range(num_types):
+        dgens.extend(dummy_sgs(dummies[i], sym[i], size - 2))
+    S = PermutationGroup(sgens)
+    D = PermutationGroup([Permutation(x) for x in dgens])
+    dlist = list(D.generate(af=True))
+    g = g.array_form
+    st = set()
+    for s in S.generate(af=True):
+        h = _af_rmul(g, s)
+        for d in dlist:
+            q = tuple(_af_rmul(d, h))
+            st.add(q)
+    a = list(st)
+    a.sort()
+    prev = (0,)*size
+    for h in a:
+        if h[:-2] == prev[:-2]:
+            if h[-1] != prev[-1]:
+                return 0
+        prev = h
+    return list(a[0])
+
+
+def graph_certificate(gr):
+    """
+    Return a certificate for the graph
+
+    Parameters
+    ==========
+
+    gr : adjacency list
+
+    Explanation
+    ===========
+
+    The graph is assumed to be unoriented and without
+    external lines.
+
+    Associate to each vertex of the graph a symmetric tensor with
+    number of indices equal to the degree of the vertex; indices
+    are contracted when they correspond to the same line of the graph.
+    The canonical form of the tensor gives a certificate for the graph.
+
+    This is not an efficient algorithm to get the certificate of a graph.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.testutil import graph_certificate
+    >>> gr1 = {0:[1, 2, 3, 5], 1:[0, 2, 4], 2:[0, 1, 3, 4], 3:[0, 2, 4], 4:[1, 2, 3, 5], 5:[0, 4]}
+    >>> gr2 = {0:[1, 5], 1:[0, 2, 3, 4], 2:[1, 3, 5], 3:[1, 2, 4, 5], 4:[1, 3, 5], 5:[0, 2, 3, 4]}
+    >>> c1 = graph_certificate(gr1)
+    >>> c2 = graph_certificate(gr2)
+    >>> c1
+    [0, 2, 4, 6, 1, 8, 10, 12, 3, 14, 16, 18, 5, 9, 15, 7, 11, 17, 13, 19, 20, 21]
+    >>> c1 == c2
+    True
+    """
+    from sympy.combinatorics.permutations import _af_invert
+    from sympy.combinatorics.tensor_can import get_symmetric_group_sgs, canonicalize
+    items = list(gr.items())
+    items.sort(key=lambda x: len(x[1]), reverse=True)
+    pvert = [x[0] for x in items]
+    pvert = _af_invert(pvert)
+
+    # the indices of the tensor are twice the number of lines of the graph
+    num_indices = 0
+    for v, neigh in items:
+        num_indices += len(neigh)
+    # associate to each vertex its indices; for each line
+    # between two vertices assign the
+    # even index to the vertex which comes first in items,
+    # the odd index to the other vertex
+    vertices = [[] for i in items]
+    i = 0
+    for v, neigh in items:
+        for v2 in neigh:
+            if pvert[v] < pvert[v2]:
+                vertices[pvert[v]].append(i)
+                vertices[pvert[v2]].append(i+1)
+                i += 2
+    g = []
+    for v in vertices:
+        g.extend(v)
+    assert len(g) == num_indices
+    g += [num_indices, num_indices + 1]
+    size = num_indices + 2
+    assert sorted(g) == list(range(size))
+    g = Permutation(g)
+    vlen = [0]*(len(vertices[0])+1)
+    for neigh in vertices:
+        vlen[len(neigh)] += 1
+    v = []
+    for i in range(len(vlen)):
+        n = vlen[i]
+        if n:
+            base, gens = get_symmetric_group_sgs(i)
+            v.append((base, gens, n, 0))
+    v.reverse()
+    dummies = list(range(num_indices))
+    can = canonicalize(g, dummies, 0, *v)
+    return can

mgm/lib/python3.10/site-packages/sympy/polys/dispersion.py

@@ -0,0 +1,212 @@
+from sympy.core import S
+from sympy.polys import Poly
+
+
+def dispersionset(p, q=None, *gens, **args):
+    r"""Compute the *dispersion set* of two polynomials.
+
+    For two polynomials `f(x)` and `g(x)` with `\deg f > 0`
+    and `\deg g > 0` the dispersion set `\operatorname{J}(f, g)` is defined as:
+
+    .. math::
+        \operatorname{J}(f, g)
+        & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\
+        &  = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\}
+
+    For a single polynomial one defines `\operatorname{J}(f) := \operatorname{J}(f, f)`.
+
+    Examples
+    ========
+
+    >>> from sympy import poly
+    >>> from sympy.polys.dispersion import dispersion, dispersionset
+    >>> from sympy.abc import x
+
+    Dispersion set and dispersion of a simple polynomial:
+
+    >>> fp = poly((x - 3)*(x + 3), x)
+    >>> sorted(dispersionset(fp))
+    [0, 6]
+    >>> dispersion(fp)
+    6
+
+    Note that the definition of the dispersion is not symmetric:
+
+    >>> fp = poly(x**4 - 3*x**2 + 1, x)
+    >>> gp = fp.shift(-3)
+    >>> sorted(dispersionset(fp, gp))
+    [2, 3, 4]
+    >>> dispersion(fp, gp)
+    4
+    >>> sorted(dispersionset(gp, fp))
+    []
+    >>> dispersion(gp, fp)
+    -oo
+
+    Computing the dispersion also works over field extensions:
+
+    >>> from sympy import sqrt
+    >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>')
+    >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>')
+    >>> sorted(dispersionset(fp, gp))
+    [2]
+    >>> sorted(dispersionset(gp, fp))
+    [1, 4]
+
+    We can even perform the computations for polynomials
+    having symbolic coefficients:
+
+    >>> from sympy.abc import a
+    >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x)
+    >>> sorted(dispersionset(fp))
+    [0, 1]
+
+    See Also
+    ========
+
+    dispersion
+
+    References
+    ==========
+
+    .. [1] [ManWright94]_
+    .. [2] [Koepf98]_
+    .. [3] [Abramov71]_
+    .. [4] [Man93]_
+    """
+    # Check for valid input
+    same = False if q is not None else True
+    if same:
+        q = p
+
+    p = Poly(p, *gens, **args)
+    q = Poly(q, *gens, **args)
+
+    if not p.is_univariate or not q.is_univariate:
+        raise ValueError("Polynomials need to be univariate")
+
+    # The generator
+    if not p.gen == q.gen:
+        raise ValueError("Polynomials must have the same generator")
+    gen = p.gen
+
+    # We define the dispersion of constant polynomials to be zero
+    if p.degree() < 1 or q.degree() < 1:
+        return {0}
+
+    # Factor p and q over the rationals
+    fp = p.factor_list()
+    fq = q.factor_list() if not same else fp
+
+    # Iterate over all pairs of factors
+    J = set()
+    for s, unused in fp[1]:
+        for t, unused in fq[1]:
+            m = s.degree()
+            n = t.degree()
+            if n != m:
+                continue
+            an = s.LC()
+            bn = t.LC()
+            if not (an - bn).is_zero:
+                continue
+            # Note that the roles of `s` and `t` below are switched
+            # w.r.t. the original paper. This is for consistency
+            # with the description in the book of W. Koepf.
+            anm1 = s.coeff_monomial(gen**(m-1))
+            bnm1 = t.coeff_monomial(gen**(n-1))
+            alpha = (anm1 - bnm1) / S(n*bn)
+            if not alpha.is_integer:
+                continue
+            if alpha < 0 or alpha in J:
+                continue
+            if n > 1 and not (s - t.shift(alpha)).is_zero:
+                continue
+            J.add(alpha)
+
+    return J
+
+
+def dispersion(p, q=None, *gens, **args):
+    r"""Compute the *dispersion* of polynomials.
+
+    For two polynomials `f(x)` and `g(x)` with `\deg f > 0`
+    and `\deg g > 0` the dispersion `\operatorname{dis}(f, g)` is defined as:
+
+    .. math::
+        \operatorname{dis}(f, g)
+        & := \max\{ J(f,g) \cup \{0\} \} \\
+        &  = \max\{ \{a \in \mathbb{N} | \gcd(f(x), g(x+a)) \neq 1\} \cup \{0\} \}
+
+    and for a single polynomial `\operatorname{dis}(f) := \operatorname{dis}(f, f)`.
+    Note that we make the definition `\max\{\} := -\infty`.
+
+    Examples
+    ========
+
+    >>> from sympy import poly
+    >>> from sympy.polys.dispersion import dispersion, dispersionset
+    >>> from sympy.abc import x
+
+    Dispersion set and dispersion of a simple polynomial:
+
+    >>> fp = poly((x - 3)*(x + 3), x)
+    >>> sorted(dispersionset(fp))
+    [0, 6]
+    >>> dispersion(fp)
+    6
+
+    Note that the definition of the dispersion is not symmetric:
+
+    >>> fp = poly(x**4 - 3*x**2 + 1, x)
+    >>> gp = fp.shift(-3)
+    >>> sorted(dispersionset(fp, gp))
+    [2, 3, 4]
+    >>> dispersion(fp, gp)
+    4
+    >>> sorted(dispersionset(gp, fp))
+    []
+    >>> dispersion(gp, fp)
+    -oo
+
+    The maximum of an empty set is defined to be `-\infty`
+    as seen in this example.
+
+    Computing the dispersion also works over field extensions:
+
+    >>> from sympy import sqrt
+    >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>')
+    >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>')
+    >>> sorted(dispersionset(fp, gp))
+    [2]
+    >>> sorted(dispersionset(gp, fp))
+    [1, 4]
+
+    We can even perform the computations for polynomials
+    having symbolic coefficients:
+
+    >>> from sympy.abc import a
+    >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x)
+    >>> sorted(dispersionset(fp))
+    [0, 1]
+
+    See Also
+    ========
+
+    dispersionset
+
+    References
+    ==========
+
+    .. [1] [ManWright94]_
+    .. [2] [Koepf98]_
+    .. [3] [Abramov71]_
+    .. [4] [Man93]_
+    """
+    J = dispersionset(p, q, *gens, **args)
+    if not J:
+        # Definition for maximum of empty set
+        j = S.NegativeInfinity
+    else:
+        j = max(J)
+    return j

mgm/lib/python3.10/site-packages/sympy/polys/domains/__init__.py

@@ -0,0 +1,57 @@
+"""Implementation of mathematical domains. """
+
+__all__ = [
+    'Domain', 'FiniteField', 'IntegerRing', 'RationalField', 'RealField',
+    'ComplexField', 'AlgebraicField', 'PolynomialRing', 'FractionField',
+    'ExpressionDomain', 'PythonRational',
+
+    'GF', 'FF', 'ZZ', 'QQ', 'ZZ_I', 'QQ_I', 'RR', 'CC', 'EX', 'EXRAW',
+]
+
+from .domain import Domain
+from .finitefield import FiniteField, FF, GF
+from .integerring import IntegerRing, ZZ
+from .rationalfield import RationalField, QQ
+from .algebraicfield import AlgebraicField
+from .gaussiandomains import ZZ_I, QQ_I
+from .realfield import RealField, RR
+from .complexfield import ComplexField, CC
+from .polynomialring import PolynomialRing
+from .fractionfield import FractionField
+from .expressiondomain import ExpressionDomain, EX
+from .expressionrawdomain import EXRAW
+from .pythonrational import PythonRational
+
+
+# This is imported purely for backwards compatibility because some parts of
+# the codebase used to import this from here and it's possible that downstream
+# does as well:
+from sympy.external.gmpy import GROUND_TYPES  # noqa: F401
+
+#
+# The rest of these are obsolete and provided only for backwards
+# compatibility:
+#
+
+from .pythonfinitefield import PythonFiniteField
+from .gmpyfinitefield import GMPYFiniteField
+from .pythonintegerring import PythonIntegerRing
+from .gmpyintegerring import GMPYIntegerRing
+from .pythonrationalfield import PythonRationalField
+from .gmpyrationalfield import GMPYRationalField
+
+FF_python = PythonFiniteField
+FF_gmpy = GMPYFiniteField
+
+ZZ_python = PythonIntegerRing
+ZZ_gmpy = GMPYIntegerRing
+
+QQ_python = PythonRationalField
+QQ_gmpy = GMPYRationalField
+
+__all__.extend((
+    'PythonFiniteField', 'GMPYFiniteField', 'PythonIntegerRing',
+    'GMPYIntegerRing', 'PythonRational', 'GMPYRationalField',
+
+    'FF_python', 'FF_gmpy', 'ZZ_python', 'ZZ_gmpy', 'QQ_python', 'QQ_gmpy',
+))

mgm/lib/python3.10/site-packages/sympy/polys/domains/algebraicfield.py

@@ -0,0 +1,607 @@
+"""Implementation of :class:`AlgebraicField` class. """
+
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.polys.domains.characteristiczero import CharacteristicZero
+from sympy.polys.domains.field import Field
+from sympy.polys.domains.simpledomain import SimpleDomain
+from sympy.polys.polyclasses import ANP
+from sympy.polys.polyerrors import CoercionFailed, DomainError, NotAlgebraic, IsomorphismFailed
+from sympy.utilities import public
+
+@public
+class AlgebraicField(Field, CharacteristicZero, SimpleDomain):
+    r"""Algebraic number field :ref:`QQ(a)`
+
+    A :ref:`QQ(a)` domain represents an `algebraic number field`_
+    `\mathbb{Q}(a)` as a :py:class:`~.Domain` in the domain system (see
+    :ref:`polys-domainsintro`).
+
+    A :py:class:`~.Poly` created from an expression involving `algebraic
+    numbers`_ will treat the algebraic numbers as generators if the generators
+    argument is not specified.
+
+    >>> from sympy import Poly, Symbol, sqrt
+    >>> x = Symbol('x')
+    >>> Poly(x**2 + sqrt(2))
+    Poly(x**2 + (sqrt(2)), x, sqrt(2), domain='ZZ')
+
+    That is a multivariate polynomial with ``sqrt(2)`` treated as one of the
+    generators (variables). If the generators are explicitly specified then
+    ``sqrt(2)`` will be considered to be a coefficient but by default the
+    :ref:`EX` domain is used. To make a :py:class:`~.Poly` with a :ref:`QQ(a)`
+    domain the argument ``extension=True`` can be given.
+
+    >>> Poly(x**2 + sqrt(2), x)
+    Poly(x**2 + sqrt(2), x, domain='EX')
+    >>> Poly(x**2 + sqrt(2), x, extension=True)
+    Poly(x**2 + sqrt(2), x, domain='QQ<sqrt(2)>')
+
+    A generator of the algebraic field extension can also be specified
+    explicitly which is particularly useful if the coefficients are all
+    rational but an extension field is needed (e.g. to factor the
+    polynomial).
+
+    >>> Poly(x**2 + 1)
+    Poly(x**2 + 1, x, domain='ZZ')
+    >>> Poly(x**2 + 1, extension=sqrt(2))
+    Poly(x**2 + 1, x, domain='QQ<sqrt(2)>')
+
+    It is possible to factorise a polynomial over a :ref:`QQ(a)` domain using
+    the ``extension`` argument to :py:func:`~.factor` or by specifying the domain
+    explicitly.
+
+    >>> from sympy import factor, QQ
+    >>> factor(x**2 - 2)
+    x**2 - 2
+    >>> factor(x**2 - 2, extension=sqrt(2))
+    (x - sqrt(2))*(x + sqrt(2))
+    >>> factor(x**2 - 2, domain='QQ<sqrt(2)>')
+    (x - sqrt(2))*(x + sqrt(2))
+    >>> factor(x**2 - 2, domain=QQ.algebraic_field(sqrt(2)))
+    (x - sqrt(2))*(x + sqrt(2))
+
+    The ``extension=True`` argument can be used but will only create an
+    extension that contains the coefficients which is usually not enough to
+    factorise the polynomial.
+
+    >>> p = x**3 + sqrt(2)*x**2 - 2*x - 2*sqrt(2)
+    >>> factor(p)                         # treats sqrt(2) as a symbol
+    (x + sqrt(2))*(x**2 - 2)
+    >>> factor(p, extension=True)
+    (x - sqrt(2))*(x + sqrt(2))**2
+    >>> factor(x**2 - 2, extension=True)  # all rational coefficients
+    x**2 - 2
+
+    It is also possible to use :ref:`QQ(a)` with the :py:func:`~.cancel`
+    and :py:func:`~.gcd` functions.
+
+    >>> from sympy import cancel, gcd
+    >>> cancel((x**2 - 2)/(x - sqrt(2)))
+    (x**2 - 2)/(x - sqrt(2))
+    >>> cancel((x**2 - 2)/(x - sqrt(2)), extension=sqrt(2))
+    x + sqrt(2)
+    >>> gcd(x**2 - 2, x - sqrt(2))
+    1
+    >>> gcd(x**2 - 2, x - sqrt(2), extension=sqrt(2))
+    x - sqrt(2)
+
+    When using the domain directly :ref:`QQ(a)` can be used as a constructor
+    to create instances which then support the operations ``+,-,*,**,/``. The
+    :py:meth:`~.Domain.algebraic_field` method is used to construct a
+    particular :ref:`QQ(a)` domain. The :py:meth:`~.Domain.from_sympy` method
+    can be used to create domain elements from normal SymPy expressions.
+
+    >>> K = QQ.algebraic_field(sqrt(2))
+    >>> K
+    QQ<sqrt(2)>
+    >>> xk = K.from_sympy(3 + 4*sqrt(2))
+    >>> xk  # doctest: +SKIP
+    ANP([4, 3], [1, 0, -2], QQ)
+
+    Elements of :ref:`QQ(a)` are instances of :py:class:`~.ANP` which have
+    limited printing support. The raw display shows the internal
+    representation of the element as the list ``[4, 3]`` representing the
+    coefficients of ``1`` and ``sqrt(2)`` for this element in the form
+    ``a * sqrt(2) + b * 1`` where ``a`` and ``b`` are elements of :ref:`QQ`.
+    The minimal polynomial for the generator ``(x**2 - 2)`` is also shown in
+    the :ref:`dup-representation` as the list ``[1, 0, -2]``. We can use
+    :py:meth:`~.Domain.to_sympy` to get a better printed form for the
+    elements and to see the results of operations.
+
+    >>> xk = K.from_sympy(3 + 4*sqrt(2))
+    >>> yk = K.from_sympy(2 + 3*sqrt(2))
+    >>> xk * yk  # doctest: +SKIP
+    ANP([17, 30], [1, 0, -2], QQ)
+    >>> K.to_sympy(xk * yk)
+    17*sqrt(2) + 30
+    >>> K.to_sympy(xk + yk)
+    5 + 7*sqrt(2)
+    >>> K.to_sympy(xk ** 2)
+    24*sqrt(2) + 41
+    >>> K.to_sympy(xk / yk)
+    sqrt(2)/14 + 9/7
+
+    Any expression representing an algebraic number can be used to generate
+    a :ref:`QQ(a)` domain provided its `minimal polynomial`_ can be computed.
+    The function :py:func:`~.minpoly` function is used for this.
+
+    >>> from sympy import exp, I, pi, minpoly
+    >>> g = exp(2*I*pi/3)
+    >>> g
+    exp(2*I*pi/3)
+    >>> g.is_algebraic
+    True
+    >>> minpoly(g, x)
+    x**2 + x + 1
+    >>> factor(x**3 - 1, extension=g)
+    (x - 1)*(x - exp(2*I*pi/3))*(x + 1 + exp(2*I*pi/3))
+
+    It is also possible to make an algebraic field from multiple extension
+    elements.
+
+    >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+    >>> K
+    QQ<sqrt(2) + sqrt(3)>
+    >>> p = x**4 - 5*x**2 + 6
+    >>> factor(p)
+    (x**2 - 3)*(x**2 - 2)
+    >>> factor(p, domain=K)
+    (x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3))
+    >>> factor(p, extension=[sqrt(2), sqrt(3)])
+    (x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3))
+
+    Multiple extension elements are always combined together to make a single
+    `primitive element`_. In the case of ``[sqrt(2), sqrt(3)]`` the primitive
+    element chosen is ``sqrt(2) + sqrt(3)`` which is why the domain displays
+    as ``QQ<sqrt(2) + sqrt(3)>``. The minimal polynomial for the primitive
+    element is computed using the :py:func:`~.primitive_element` function.
+
+    >>> from sympy import primitive_element
+    >>> primitive_element([sqrt(2), sqrt(3)], x)
+    (x**4 - 10*x**2 + 1, [1, 1])
+    >>> minpoly(sqrt(2) + sqrt(3), x)
+    x**4 - 10*x**2 + 1
+
+    The extension elements that generate the domain can be accessed from the
+    domain using the :py:attr:`~.ext` and :py:attr:`~.orig_ext` attributes as
+    instances of :py:class:`~.AlgebraicNumber`. The minimal polynomial for
+    the primitive element as a :py:class:`~.DMP` instance is available as
+    :py:attr:`~.mod`.
+
+    >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+    >>> K
+    QQ<sqrt(2) + sqrt(3)>
+    >>> K.ext
+    sqrt(2) + sqrt(3)
+    >>> K.orig_ext
+    (sqrt(2), sqrt(3))
+    >>> K.mod  # doctest: +SKIP
+    DMP_Python([1, 0, -10, 0, 1], QQ)
+
+    The `discriminant`_ of the field can be obtained from the
+    :py:meth:`~.discriminant` method, and an `integral basis`_ from the
+    :py:meth:`~.integral_basis` method. The latter returns a list of
+    :py:class:`~.ANP` instances by default, but can be made to return instances
+    of :py:class:`~.Expr` or :py:class:`~.AlgebraicNumber` by passing a ``fmt``
+    argument. The maximal order, or ring of integers, of the field can also be
+    obtained from the :py:meth:`~.maximal_order` method, as a
+    :py:class:`~sympy.polys.numberfields.modules.Submodule`.
+
+    >>> zeta5 = exp(2*I*pi/5)
+    >>> K = QQ.algebraic_field(zeta5)
+    >>> K
+    QQ<exp(2*I*pi/5)>
+    >>> K.discriminant()
+    125
+    >>> K = QQ.algebraic_field(sqrt(5))
+    >>> K
+    QQ<sqrt(5)>
+    >>> K.integral_basis(fmt='sympy')
+    [1, 1/2 + sqrt(5)/2]
+    >>> K.maximal_order()
+    Submodule[[2, 0], [1, 1]]/2
+
+    The factorization of a rational prime into prime ideals of the field is
+    computed by the :py:meth:`~.primes_above` method, which returns a list
+    of :py:class:`~sympy.polys.numberfields.primes.PrimeIdeal` instances.
+
+    >>> zeta7 = exp(2*I*pi/7)
+    >>> K = QQ.algebraic_field(zeta7)
+    >>> K
+    QQ<exp(2*I*pi/7)>
+    >>> K.primes_above(11)
+    [(11, _x**3 + 5*_x**2 + 4*_x - 1), (11, _x**3 - 4*_x**2 - 5*_x - 1)]
+
+    The Galois group of the Galois closure of the field can be computed (when
+    the minimal polynomial of the field is of sufficiently small degree).
+
+    >>> K.galois_group(by_name=True)[0]
+    S6TransitiveSubgroups.C6
+
+    Notes
+    =====
+
+    It is not currently possible to generate an algebraic extension over any
+    domain other than :ref:`QQ`. Ideally it would be possible to generate
+    extensions like ``QQ(x)(sqrt(x**2 - 2))``. This is equivalent to the
+    quotient ring ``QQ(x)[y]/(y**2 - x**2 + 2)`` and there are two
+    implementations of this kind of quotient ring/extension in the
+    :py:class:`~.QuotientRing` and :py:class:`~.MonogenicFiniteExtension`
+    classes.  Each of those implementations needs some work to make them fully
+    usable though.
+
+    .. _algebraic number field: https://en.wikipedia.org/wiki/Algebraic_number_field
+    .. _algebraic numbers: https://en.wikipedia.org/wiki/Algebraic_number
+    .. _discriminant: https://en.wikipedia.org/wiki/Discriminant_of_an_algebraic_number_field
+    .. _integral basis: https://en.wikipedia.org/wiki/Algebraic_number_field#Integral_basis
+    .. _minimal polynomial: https://en.wikipedia.org/wiki/Minimal_polynomial_(field_theory)
+    .. _primitive element: https://en.wikipedia.org/wiki/Primitive_element_theorem
+    """
+
+    dtype = ANP
+
+    is_AlgebraicField = is_Algebraic = True
+    is_Numerical = True
+
+    has_assoc_Ring = False
+    has_assoc_Field = True
+
+    def __init__(self, dom, *ext, alias=None):
+        r"""
+        Parameters
+        ==========
+
+        dom : :py:class:`~.Domain`
+            The base field over which this is an extension field.
+            Currently only :ref:`QQ` is accepted.
+
+        *ext : One or more :py:class:`~.Expr`
+            Generators of the extension. These should be expressions that are
+            algebraic over `\mathbb{Q}`.
+
+        alias : str, :py:class:`~.Symbol`, None, optional (default=None)
+            If provided, this will be used as the alias symbol for the
+            primitive element of the :py:class:`~.AlgebraicField`.
+            If ``None``, while ``ext`` consists of exactly one
+            :py:class:`~.AlgebraicNumber`, its alias (if any) will be used.
+        """
+        if not dom.is_QQ:
+            raise DomainError("ground domain must be a rational field")
+
+        from sympy.polys.numberfields import to_number_field
+        if len(ext) == 1 and isinstance(ext[0], tuple):
+            orig_ext = ext[0][1:]
+        else:
+            orig_ext = ext
+
+        if alias is None and len(ext) == 1:
+            alias = getattr(ext[0], 'alias', None)
+
+        self.orig_ext = orig_ext
+        """
+        Original elements given to generate the extension.
+
+        >>> from sympy import QQ, sqrt
+        >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+        >>> K.orig_ext
+        (sqrt(2), sqrt(3))
+        """
+
+        self.ext = to_number_field(ext, alias=alias)
+        """
+        Primitive element used for the extension.
+
+        >>> from sympy import QQ, sqrt
+        >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+        >>> K.ext
+        sqrt(2) + sqrt(3)
+        """
+
+        self.mod = self.ext.minpoly.rep
+        """
+        Minimal polynomial for the primitive element of the extension.
+
+        >>> from sympy import QQ, sqrt
+        >>> K = QQ.algebraic_field(sqrt(2))
+        >>> K.mod
+        DMP([1, 0, -2], QQ)
+        """
+
+        self.domain = self.dom = dom
+
+        self.ngens = 1
+        self.symbols = self.gens = (self.ext,)
+        self.unit = self([dom(1), dom(0)])
+
+        self.zero = self.dtype.zero(self.mod.to_list(), dom)
+        self.one = self.dtype.one(self.mod.to_list(), dom)
+
+        self._maximal_order = None
+        self._discriminant = None
+        self._nilradicals_mod_p = {}
+
+    def new(self, element):
+        return self.dtype(element, self.mod.to_list(), self.dom)
+
+    def __str__(self):
+        return str(self.dom) + '<' + str(self.ext) + '>'
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.dtype, self.dom, self.ext))
+
+    def __eq__(self, other):
+        """Returns ``True`` if two domains are equivalent. """
+        if isinstance(other, AlgebraicField):
+            return self.dtype == other.dtype and self.ext == other.ext
+        else:
+            return NotImplemented
+
+    def algebraic_field(self, *extension, alias=None):
+        r"""Returns an algebraic field, i.e. `\mathbb{Q}(\alpha, \ldots)`. """
+        return AlgebraicField(self.dom, *((self.ext,) + extension), alias=alias)
+
+    def to_alg_num(self, a):
+        """Convert ``a`` of ``dtype`` to an :py:class:`~.AlgebraicNumber`. """
+        return self.ext.field_element(a)
+
+    def to_sympy(self, a):
+        """Convert ``a`` of ``dtype`` to a SymPy object. """
+        # Precompute a converter to be reused:
+        if not hasattr(self, '_converter'):
+            self._converter = _make_converter(self)
+
+        return self._converter(a)
+
+    def from_sympy(self, a):
+        """Convert SymPy's expression to ``dtype``. """
+        try:
+            return self([self.dom.from_sympy(a)])
+        except CoercionFailed:
+            pass
+
+        from sympy.polys.numberfields import to_number_field
+
+        try:
+            return self(to_number_field(a, self.ext).native_coeffs())
+        except (NotAlgebraic, IsomorphismFailed):
+            raise CoercionFailed(
+                "%s is not a valid algebraic number in %s" % (a, self))
+
+    def from_ZZ(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_RealField(K1, a, K0):
+        """Convert a mpmath ``mpf`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        raise DomainError('there is no ring associated with %s' % self)
+
+    def is_positive(self, a):
+        """Returns True if ``a`` is positive. """
+        return self.dom.is_positive(a.LC())
+
+    def is_negative(self, a):
+        """Returns True if ``a`` is negative. """
+        return self.dom.is_negative(a.LC())
+
+    def is_nonpositive(self, a):
+        """Returns True if ``a`` is non-positive. """
+        return self.dom.is_nonpositive(a.LC())
+
+    def is_nonnegative(self, a):
+        """Returns True if ``a`` is non-negative. """
+        return self.dom.is_nonnegative(a.LC())
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        return a
+
+    def denom(self, a):
+        """Returns denominator of ``a``. """
+        return self.one
+
+    def from_AlgebraicField(K1, a, K0):
+        """Convert AlgebraicField element 'a' to another AlgebraicField """
+        return K1.from_sympy(K0.to_sympy(a))
+
+    def from_GaussianIntegerRing(K1, a, K0):
+        """Convert a GaussianInteger element 'a' to ``dtype``. """
+        return K1.from_sympy(K0.to_sympy(a))
+
+    def from_GaussianRationalField(K1, a, K0):
+        """Convert a GaussianRational element 'a' to ``dtype``. """
+        return K1.from_sympy(K0.to_sympy(a))
+
+    def _do_round_two(self):
+        from sympy.polys.numberfields.basis import round_two
+        ZK, dK = round_two(self, radicals=self._nilradicals_mod_p)
+        self._maximal_order = ZK
+        self._discriminant = dK
+
+    def maximal_order(self):
+        """
+        Compute the maximal order, or ring of integers, of the field.
+
+        Returns
+        =======
+
+        :py:class:`~sympy.polys.numberfields.modules.Submodule`.
+
+        See Also
+        ========
+
+        integral_basis
+
+        """
+        if self._maximal_order is None:
+            self._do_round_two()
+        return self._maximal_order
+
+    def integral_basis(self, fmt=None):
+        r"""
+        Get an integral basis for the field.
+
+        Parameters
+        ==========
+
+        fmt : str, None, optional (default=None)
+            If ``None``, return a list of :py:class:`~.ANP` instances.
+            If ``"sympy"``, convert each element of the list to an
+            :py:class:`~.Expr`, using ``self.to_sympy()``.
+            If ``"alg"``, convert each element of the list to an
+            :py:class:`~.AlgebraicNumber`, using ``self.to_alg_num()``.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, AlgebraicNumber, sqrt
+        >>> alpha = AlgebraicNumber(sqrt(5), alias='alpha')
+        >>> k = QQ.algebraic_field(alpha)
+        >>> B0 = k.integral_basis()
+        >>> B1 = k.integral_basis(fmt='sympy')
+        >>> B2 = k.integral_basis(fmt='alg')
+        >>> print(B0[1])  # doctest: +SKIP
+        ANP([mpq(1,2), mpq(1,2)], [mpq(1,1), mpq(0,1), mpq(-5,1)], QQ)
+        >>> print(B1[1])
+        1/2 + alpha/2
+        >>> print(B2[1])
+        alpha/2 + 1/2
+
+        In the last two cases we get legible expressions, which print somewhat
+        differently because of the different types involved:
+
+        >>> print(type(B1[1]))
+        <class 'sympy.core.add.Add'>
+        >>> print(type(B2[1]))
+        <class 'sympy.core.numbers.AlgebraicNumber'>
+
+        See Also
+        ========
+
+        to_sympy
+        to_alg_num
+        maximal_order
+        """
+        ZK = self.maximal_order()
+        M = ZK.QQ_matrix
+        n = M.shape[1]
+        B = [self.new(list(reversed(M[:, j].flat()))) for j in range(n)]
+        if fmt == 'sympy':
+            return [self.to_sympy(b) for b in B]
+        elif fmt == 'alg':
+            return [self.to_alg_num(b) for b in B]
+        return B
+
+    def discriminant(self):
+        """Get the discriminant of the field."""
+        if self._discriminant is None:
+            self._do_round_two()
+        return self._discriminant
+
+    def primes_above(self, p):
+        """Compute the prime ideals lying above a given rational prime *p*."""
+        from sympy.polys.numberfields.primes import prime_decomp
+        ZK = self.maximal_order()
+        dK = self.discriminant()
+        rad = self._nilradicals_mod_p.get(p)
+        return prime_decomp(p, ZK=ZK, dK=dK, radical=rad)
+
+    def galois_group(self, by_name=False, max_tries=30, randomize=False):
+        """
+        Compute the Galois group of the Galois closure of this field.
+
+        Examples
+        ========
+
+        If the field is Galois, the order of the group will equal the degree
+        of the field:
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> k = QQ.alg_field_from_poly(x**4 + 1)
+        >>> G, _ = k.galois_group()
+        >>> G.order()
+        4
+
+        If the field is not Galois, then its Galois closure is a proper
+        extension, and the order of the Galois group will be greater than the
+        degree of the field:
+
+        >>> k = QQ.alg_field_from_poly(x**4 - 2)
+        >>> G, _ = k.galois_group()
+        >>> G.order()
+        8
+
+        See Also
+        ========
+
+        sympy.polys.numberfields.galoisgroups.galois_group
+
+        """
+        return self.ext.minpoly_of_element().galois_group(
+            by_name=by_name, max_tries=max_tries, randomize=randomize)
+
+
+def _make_converter(K):
+    """Construct the converter to convert back to Expr"""
+    # Precompute the effect of converting to SymPy and expanding expressions
+    # like (sqrt(2) + sqrt(3))**2. Asking Expr to do the expansion on every
+    # conversion from K to Expr is slow. Here we compute the expansions for
+    # each power of the generator and collect together the resulting algebraic
+    # terms and the rational coefficients into a matrix.
+
+    gen = K.ext.as_expr()
+    todom = K.dom.from_sympy
+
+    # We'll let Expr compute the expansions. We won't make any presumptions
+    # about what this results in except that it is QQ-linear in some terms
+    # that we will call algebraics. The final result will be expressed in
+    # terms of those.
+    powers = [S.One, gen]
+    for n in range(2, K.mod.degree()):
+        powers.append((gen * powers[-1]).expand())
+
+    # Collect the rational coefficients and algebraic Expr that can
+    # map the ANP coefficients into an expanded SymPy expression
+    terms = [dict(t.as_coeff_Mul()[::-1] for t in Add.make_args(p)) for p in powers]
+    algebraics = set().union(*terms)
+    matrix = [[todom(t.get(a, S.Zero)) for t in terms] for a in algebraics]
+
+    # Create a function to do the conversion efficiently:
+
+    def converter(a):
+        """Convert a to Expr using converter"""
+        ai = a.to_list()[::-1]
+        tosympy = K.dom.to_sympy
+        coeffs_dom = [sum(mij*aj for mij, aj in zip(mi, ai)) for mi in matrix]
+        coeffs_sympy = [tosympy(c) for c in coeffs_dom]
+        res = Add(*(Mul(c, a) for c, a in zip(coeffs_sympy, algebraics)))
+        return res
+
+    return converter

mgm/lib/python3.10/site-packages/sympy/polys/domains/characteristiczero.py

@@ -0,0 +1,15 @@
+"""Implementation of :class:`CharacteristicZero` class. """
+
+
+from sympy.polys.domains.domain import Domain
+from sympy.utilities import public
+
+@public
+class CharacteristicZero(Domain):
+    """Domain that has infinite number of elements. """
+
+    has_CharacteristicZero = True
+
+    def characteristic(self):
+        """Return the characteristic of this domain. """
+        return 0

mgm/lib/python3.10/site-packages/sympy/polys/domains/compositedomain.py

@@ -0,0 +1,52 @@
+"""Implementation of :class:`CompositeDomain` class. """
+
+
+from sympy.polys.domains.domain import Domain
+from sympy.polys.polyerrors import GeneratorsError
+
+from sympy.utilities import public
+
+@public
+class CompositeDomain(Domain):
+    """Base class for composite domains, e.g. ZZ[x], ZZ(X). """
+
+    is_Composite = True
+
+    gens, ngens, symbols, domain = [None]*4
+
+    def inject(self, *symbols):
+        """Inject generators into this domain.  """
+        if not (set(self.symbols) & set(symbols)):
+            return self.__class__(self.domain, self.symbols + symbols, self.order)
+        else:
+            raise GeneratorsError("common generators in %s and %s" % (self.symbols, symbols))
+
+    def drop(self, *symbols):
+        """Drop generators from this domain. """
+        symset = set(symbols)
+        newsyms = tuple(s for s in self.symbols if s not in symset)
+        domain = self.domain.drop(*symbols)
+        if not newsyms:
+            return domain
+        else:
+            return self.__class__(domain, newsyms, self.order)
+
+    def set_domain(self, domain):
+        """Set the ground domain of this domain. """
+        return self.__class__(domain, self.symbols, self.order)
+
+    @property
+    def is_Exact(self):
+        """Returns ``True`` if this domain is exact. """
+        return self.domain.is_Exact
+
+    def get_exact(self):
+        """Returns an exact version of this domain. """
+        return self.set_domain(self.domain.get_exact())
+
+    @property
+    def has_CharacteristicZero(self):
+        return self.domain.has_CharacteristicZero
+
+    def characteristic(self):
+        return self.domain.characteristic()

mgm/lib/python3.10/site-packages/sympy/polys/domains/domain.py

@@ -0,0 +1,1372 @@
+"""Implementation of :class:`Domain` class. """
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core.numbers import AlgebraicNumber
+from sympy.core import Basic, sympify
+from sympy.core.sorting import ordered
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.polys.domains.domainelement import DomainElement
+from sympy.polys.orderings import lex
+from sympy.polys.polyerrors import UnificationFailed, CoercionFailed, DomainError
+from sympy.polys.polyutils import _unify_gens, _not_a_coeff
+from sympy.utilities import public
+from sympy.utilities.iterables import is_sequence
+
+
+@public
+class Domain:
+    """Superclass for all domains in the polys domains system.
+
+    See :ref:`polys-domainsintro` for an introductory explanation of the
+    domains system.
+
+    The :py:class:`~.Domain` class is an abstract base class for all of the
+    concrete domain types. There are many different :py:class:`~.Domain`
+    subclasses each of which has an associated ``dtype`` which is a class
+    representing the elements of the domain. The coefficients of a
+    :py:class:`~.Poly` are elements of a domain which must be a subclass of
+    :py:class:`~.Domain`.
+
+    Examples
+    ========
+
+    The most common example domains are the integers :ref:`ZZ` and the
+    rationals :ref:`QQ`.
+
+    >>> from sympy import Poly, symbols, Domain
+    >>> x, y = symbols('x, y')
+    >>> p = Poly(x**2 + y)
+    >>> p
+    Poly(x**2 + y, x, y, domain='ZZ')
+    >>> p.domain
+    ZZ
+    >>> isinstance(p.domain, Domain)
+    True
+    >>> Poly(x**2 + y/2)
+    Poly(x**2 + 1/2*y, x, y, domain='QQ')
+
+    The domains can be used directly in which case the domain object e.g.
+    (:ref:`ZZ` or :ref:`QQ`) can be used as a constructor for elements of
+    ``dtype``.
+
+    >>> from sympy import ZZ, QQ
+    >>> ZZ(2)
+    2
+    >>> ZZ.dtype  # doctest: +SKIP
+    <class 'int'>
+    >>> type(ZZ(2))  # doctest: +SKIP
+    <class 'int'>
+    >>> QQ(1, 2)
+    1/2
+    >>> type(QQ(1, 2))  # doctest: +SKIP
+    <class 'sympy.polys.domains.pythonrational.PythonRational'>
+
+    The corresponding domain elements can be used with the arithmetic
+    operations ``+,-,*,**`` and depending on the domain some combination of
+    ``/,//,%`` might be usable. For example in :ref:`ZZ` both ``//`` (floor
+    division) and ``%`` (modulo division) can be used but ``/`` (true
+    division) cannot. Since :ref:`QQ` is a :py:class:`~.Field` its elements
+    can be used with ``/`` but ``//`` and ``%`` should not be used. Some
+    domains have a :py:meth:`~.Domain.gcd` method.
+
+    >>> ZZ(2) + ZZ(3)
+    5
+    >>> ZZ(5) // ZZ(2)
+    2
+    >>> ZZ(5) % ZZ(2)
+    1
+    >>> QQ(1, 2) / QQ(2, 3)
+    3/4
+    >>> ZZ.gcd(ZZ(4), ZZ(2))
+    2
+    >>> QQ.gcd(QQ(2,7), QQ(5,3))
+    1/21
+    >>> ZZ.is_Field
+    False
+    >>> QQ.is_Field
+    True
+
+    There are also many other domains including:
+
+        1. :ref:`GF(p)` for finite fields of prime order.
+        2. :ref:`RR` for real (floating point) numbers.
+        3. :ref:`CC` for complex (floating point) numbers.
+        4. :ref:`QQ(a)` for algebraic number fields.
+        5. :ref:`K[x]` for polynomial rings.
+        6. :ref:`K(x)` for rational function fields.
+        7. :ref:`EX` for arbitrary expressions.
+
+    Each domain is represented by a domain object and also an implementation
+    class (``dtype``) for the elements of the domain. For example the
+    :ref:`K[x]` domains are represented by a domain object which is an
+    instance of :py:class:`~.PolynomialRing` and the elements are always
+    instances of :py:class:`~.PolyElement`. The implementation class
+    represents particular types of mathematical expressions in a way that is
+    more efficient than a normal SymPy expression which is of type
+    :py:class:`~.Expr`. The domain methods :py:meth:`~.Domain.from_sympy` and
+    :py:meth:`~.Domain.to_sympy` are used to convert from :py:class:`~.Expr`
+    to a domain element and vice versa.
+
+    >>> from sympy import Symbol, ZZ, Expr
+    >>> x = Symbol('x')
+    >>> K = ZZ[x]           # polynomial ring domain
+    >>> K
+    ZZ[x]
+    >>> type(K)             # class of the domain
+    <class 'sympy.polys.domains.polynomialring.PolynomialRing'>
+    >>> K.dtype             # class of the elements
+    <class 'sympy.polys.rings.PolyElement'>
+    >>> p_expr = x**2 + 1   # Expr
+    >>> p_expr
+    x**2 + 1
+    >>> type(p_expr)
+    <class 'sympy.core.add.Add'>
+    >>> isinstance(p_expr, Expr)
+    True
+    >>> p_domain = K.from_sympy(p_expr)
+    >>> p_domain            # domain element
+    x**2 + 1
+    >>> type(p_domain)
+    <class 'sympy.polys.rings.PolyElement'>
+    >>> K.to_sympy(p_domain) == p_expr
+    True
+
+    The :py:meth:`~.Domain.convert_from` method is used to convert domain
+    elements from one domain to another.
+
+    >>> from sympy import ZZ, QQ
+    >>> ez = ZZ(2)
+    >>> eq = QQ.convert_from(ez, ZZ)
+    >>> type(ez)  # doctest: +SKIP
+    <class 'int'>
+    >>> type(eq)  # doctest: +SKIP
+    <class 'sympy.polys.domains.pythonrational.PythonRational'>
+
+    Elements from different domains should not be mixed in arithmetic or other
+    operations: they should be converted to a common domain first.  The domain
+    method :py:meth:`~.Domain.unify` is used to find a domain that can
+    represent all the elements of two given domains.
+
+    >>> from sympy import ZZ, QQ, symbols
+    >>> x, y = symbols('x, y')
+    >>> ZZ.unify(QQ)
+    QQ
+    >>> ZZ[x].unify(QQ)
+    QQ[x]
+    >>> ZZ[x].unify(QQ[y])
+    QQ[x,y]
+
+    If a domain is a :py:class:`~.Ring` then is might have an associated
+    :py:class:`~.Field` and vice versa. The :py:meth:`~.Domain.get_field` and
+    :py:meth:`~.Domain.get_ring` methods will find or create the associated
+    domain.
+
+    >>> from sympy import ZZ, QQ, Symbol
+    >>> x = Symbol('x')
+    >>> ZZ.has_assoc_Field
+    True
+    >>> ZZ.get_field()
+    QQ
+    >>> QQ.has_assoc_Ring
+    True
+    >>> QQ.get_ring()
+    ZZ
+    >>> K = QQ[x]
+    >>> K
+    QQ[x]
+    >>> K.get_field()
+    QQ(x)
+
+    See also
+    ========
+
+    DomainElement: abstract base class for domain elements
+    construct_domain: construct a minimal domain for some expressions
+
+    """
+
+    dtype: type | None = None
+    """The type (class) of the elements of this :py:class:`~.Domain`:
+
+    >>> from sympy import ZZ, QQ, Symbol
+    >>> ZZ.dtype
+    <class 'int'>
+    >>> z = ZZ(2)
+    >>> z
+    2
+    >>> type(z)
+    <class 'int'>
+    >>> type(z) == ZZ.dtype
+    True
+
+    Every domain has an associated **dtype** ("datatype") which is the
+    class of the associated domain elements.
+
+    See also
+    ========
+
+    of_type
+    """
+
+    zero: Any = None
+    """The zero element of the :py:class:`~.Domain`:
+
+    >>> from sympy import QQ
+    >>> QQ.zero
+    0
+    >>> QQ.of_type(QQ.zero)
+    True
+
+    See also
+    ========
+
+    of_type
+    one
+    """
+
+    one: Any = None
+    """The one element of the :py:class:`~.Domain`:
+
+    >>> from sympy import QQ
+    >>> QQ.one
+    1
+    >>> QQ.of_type(QQ.one)
+    True
+
+    See also
+    ========
+
+    of_type
+    zero
+    """
+
+    is_Ring = False
+    """Boolean flag indicating if the domain is a :py:class:`~.Ring`.
+
+    >>> from sympy import ZZ
+    >>> ZZ.is_Ring
+    True
+
+    Basically every :py:class:`~.Domain` represents a ring so this flag is
+    not that useful.
+
+    See also
+    ========
+
+    is_PID
+    is_Field
+    get_ring
+    has_assoc_Ring
+    """
+
+    is_Field = False
+    """Boolean flag indicating if the domain is a :py:class:`~.Field`.
+
+    >>> from sympy import ZZ, QQ
+    >>> ZZ.is_Field
+    False
+    >>> QQ.is_Field
+    True
+
+    See also
+    ========
+
+    is_PID
+    is_Ring
+    get_field
+    has_assoc_Field
+    """
+
+    has_assoc_Ring = False
+    """Boolean flag indicating if the domain has an associated
+    :py:class:`~.Ring`.
+
+    >>> from sympy import QQ
+    >>> QQ.has_assoc_Ring
+    True
+    >>> QQ.get_ring()
+    ZZ
+
+    See also
+    ========
+
+    is_Field
+    get_ring
+    """
+
+    has_assoc_Field = False
+    """Boolean flag indicating if the domain has an associated
+    :py:class:`~.Field`.
+
+    >>> from sympy import ZZ
+    >>> ZZ.has_assoc_Field
+    True
+    >>> ZZ.get_field()
+    QQ
+
+    See also
+    ========
+
+    is_Field
+    get_field
+    """
+
+    is_FiniteField = is_FF = False
+    is_IntegerRing = is_ZZ = False
+    is_RationalField = is_QQ = False
+    is_GaussianRing = is_ZZ_I = False
+    is_GaussianField = is_QQ_I = False
+    is_RealField = is_RR = False
+    is_ComplexField = is_CC = False
+    is_AlgebraicField = is_Algebraic = False
+    is_PolynomialRing = is_Poly = False
+    is_FractionField = is_Frac = False
+    is_SymbolicDomain = is_EX = False
+    is_SymbolicRawDomain = is_EXRAW = False
+    is_FiniteExtension = False
+
+    is_Exact = True
+    is_Numerical = False
+
+    is_Simple = False
+    is_Composite = False
+
+    is_PID = False
+    """Boolean flag indicating if the domain is a `principal ideal domain`_.
+
+    >>> from sympy import ZZ
+    >>> ZZ.has_assoc_Field
+    True
+    >>> ZZ.get_field()
+    QQ
+
+    .. _principal ideal domain: https://en.wikipedia.org/wiki/Principal_ideal_domain
+
+    See also
+    ========
+
+    is_Field
+    get_field
+    """
+
+    has_CharacteristicZero = False
+
+    rep: str | None = None
+    alias: str | None = None
+
+    def __init__(self):
+        raise NotImplementedError
+
+    def __str__(self):
+        return self.rep
+
+    def __repr__(self):
+        return str(self)
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.dtype))
+
+    def new(self, *args):
+        return self.dtype(*args)
+
+    @property
+    def tp(self):
+        """Alias for :py:attr:`~.Domain.dtype`"""
+        return self.dtype
+
+    def __call__(self, *args):
+        """Construct an element of ``self`` domain from ``args``. """
+        return self.new(*args)
+
+    def normal(self, *args):
+        return self.dtype(*args)
+
+    def convert_from(self, element, base):
+        """Convert ``element`` to ``self.dtype`` given the base domain. """
+        if base.alias is not None:
+            method = "from_" + base.alias
+        else:
+            method = "from_" + base.__class__.__name__
+
+        _convert = getattr(self, method)
+
+        if _convert is not None:
+            result = _convert(element, base)
+
+            if result is not None:
+                return result
+
+        raise CoercionFailed("Cannot convert %s of type %s from %s to %s" % (element, type(element), base, self))
+
+    def convert(self, element, base=None):
+        """Convert ``element`` to ``self.dtype``. """
+
+        if base is not None:
+            if _not_a_coeff(element):
+                raise CoercionFailed('%s is not in any domain' % element)
+            return self.convert_from(element, base)
+
+        if self.of_type(element):
+            return element
+
+        if _not_a_coeff(element):
+            raise CoercionFailed('%s is not in any domain' % element)
+
+        from sympy.polys.domains import ZZ, QQ, RealField, ComplexField
+
+        if ZZ.of_type(element):
+            return self.convert_from(element, ZZ)
+
+        if isinstance(element, int):
+            return self.convert_from(ZZ(element), ZZ)
+
+        if GROUND_TYPES != 'python':
+            if isinstance(element, ZZ.tp):
+                return self.convert_from(element, ZZ)
+            if isinstance(element, QQ.tp):
+                return self.convert_from(element, QQ)
+
+        if isinstance(element, float):
+            parent = RealField(tol=False)
+            return self.convert_from(parent(element), parent)
+
+        if isinstance(element, complex):
+            parent = ComplexField(tol=False)
+            return self.convert_from(parent(element), parent)
+
+        if isinstance(element, DomainElement):
+            return self.convert_from(element, element.parent())
+
+        # TODO: implement this in from_ methods
+        if self.is_Numerical and getattr(element, 'is_ground', False):
+            return self.convert(element.LC())
+
+        if isinstance(element, Basic):
+            try:
+                return self.from_sympy(element)
+            except (TypeError, ValueError):
+                pass
+        else: # TODO: remove this branch
+            if not is_sequence(element):
+                try:
+                    element = sympify(element, strict=True)
+                    if isinstance(element, Basic):
+                        return self.from_sympy(element)
+                except (TypeError, ValueError):
+                    pass
+
+        raise CoercionFailed("Cannot convert %s of type %s to %s" % (element, type(element), self))
+
+    def of_type(self, element):
+        """Check if ``a`` is of type ``dtype``. """
+        return isinstance(element, self.tp) # XXX: this isn't correct, e.g. PolyElement
+
+    def __contains__(self, a):
+        """Check if ``a`` belongs to this domain. """
+        try:
+            if _not_a_coeff(a):
+                raise CoercionFailed
+            self.convert(a)  # this might raise, too
+        except CoercionFailed:
+            return False
+
+        return True
+
+    def to_sympy(self, a):
+        """Convert domain element *a* to a SymPy expression (Expr).
+
+        Explanation
+        ===========
+
+        Convert a :py:class:`~.Domain` element *a* to :py:class:`~.Expr`. Most
+        public SymPy functions work with objects of type :py:class:`~.Expr`.
+        The elements of a :py:class:`~.Domain` have a different internal
+        representation. It is not possible to mix domain elements with
+        :py:class:`~.Expr` so each domain has :py:meth:`~.Domain.to_sympy` and
+        :py:meth:`~.Domain.from_sympy` methods to convert its domain elements
+        to and from :py:class:`~.Expr`.
+
+        Parameters
+        ==========
+
+        a: domain element
+            An element of this :py:class:`~.Domain`.
+
+        Returns
+        =======
+
+        expr: Expr
+            A normal SymPy expression of type :py:class:`~.Expr`.
+
+        Examples
+        ========
+
+        Construct an element of the :ref:`QQ` domain and then convert it to
+        :py:class:`~.Expr`.
+
+        >>> from sympy import QQ, Expr
+        >>> q_domain = QQ(2)
+        >>> q_domain
+        2
+        >>> q_expr = QQ.to_sympy(q_domain)
+        >>> q_expr
+        2
+
+        Although the printed forms look similar these objects are not of the
+        same type.
+
+        >>> isinstance(q_domain, Expr)
+        False
+        >>> isinstance(q_expr, Expr)
+        True
+
+        Construct an element of :ref:`K[x]` and convert to
+        :py:class:`~.Expr`.
+
+        >>> from sympy import Symbol
+        >>> x = Symbol('x')
+        >>> K = QQ[x]
+        >>> x_domain = K.gens[0]  # generator x as a domain element
+        >>> p_domain = x_domain**2/3 + 1
+        >>> p_domain
+        1/3*x**2 + 1
+        >>> p_expr = K.to_sympy(p_domain)
+        >>> p_expr
+        x**2/3 + 1
+
+        The :py:meth:`~.Domain.from_sympy` method is used for the opposite
+        conversion from a normal SymPy expression to a domain element.
+
+        >>> p_domain == p_expr
+        False
+        >>> K.from_sympy(p_expr) == p_domain
+        True
+        >>> K.to_sympy(p_domain) == p_expr
+        True
+        >>> K.from_sympy(K.to_sympy(p_domain)) == p_domain
+        True
+        >>> K.to_sympy(K.from_sympy(p_expr)) == p_expr
+        True
+
+        The :py:meth:`~.Domain.from_sympy` method makes it easier to construct
+        domain elements interactively.
+
+        >>> from sympy import Symbol
+        >>> x = Symbol('x')
+        >>> K = QQ[x]
+        >>> K.from_sympy(x**2/3 + 1)
+        1/3*x**2 + 1
+
+        See also
+        ========
+
+        from_sympy
+        convert_from
+        """
+        raise NotImplementedError
+
+    def from_sympy(self, a):
+        """Convert a SymPy expression to an element of this domain.
+
+        Explanation
+        ===========
+
+        See :py:meth:`~.Domain.to_sympy` for explanation and examples.
+
+        Parameters
+        ==========
+
+        expr: Expr
+            A normal SymPy expression of type :py:class:`~.Expr`.
+
+        Returns
+        =======
+
+        a: domain element
+            An element of this :py:class:`~.Domain`.
+
+        See also
+        ========
+
+        to_sympy
+        convert_from
+        """
+        raise NotImplementedError
+
+    def sum(self, args):
+        return sum(args, start=self.zero)
+
+    def from_FF(K1, a, K0):
+        """Convert ``ModularInteger(int)`` to ``dtype``. """
+        return None
+
+    def from_FF_python(K1, a, K0):
+        """Convert ``ModularInteger(int)`` to ``dtype``. """
+        return None
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return None
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return None
+
+    def from_FF_gmpy(K1, a, K0):
+        """Convert ``ModularInteger(mpz)`` to ``dtype``. """
+        return None
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return None
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return None
+
+    def from_RealField(K1, a, K0):
+        """Convert a real element object to ``dtype``. """
+        return None
+
+    def from_ComplexField(K1, a, K0):
+        """Convert a complex element to ``dtype``. """
+        return None
+
+    def from_AlgebraicField(K1, a, K0):
+        """Convert an algebraic number to ``dtype``. """
+        return None
+
+    def from_PolynomialRing(K1, a, K0):
+        """Convert a polynomial to ``dtype``. """
+        if a.is_ground:
+            return K1.convert(a.LC, K0.dom)
+
+    def from_FractionField(K1, a, K0):
+        """Convert a rational function to ``dtype``. """
+        return None
+
+    def from_MonogenicFiniteExtension(K1, a, K0):
+        """Convert an ``ExtensionElement`` to ``dtype``. """
+        return K1.convert_from(a.rep, K0.ring)
+
+    def from_ExpressionDomain(K1, a, K0):
+        """Convert a ``EX`` object to ``dtype``. """
+        return K1.from_sympy(a.ex)
+
+    def from_ExpressionRawDomain(K1, a, K0):
+        """Convert a ``EX`` object to ``dtype``. """
+        return K1.from_sympy(a)
+
+    def from_GlobalPolynomialRing(K1, a, K0):
+        """Convert a polynomial to ``dtype``. """
+        if a.degree() <= 0:
+            return K1.convert(a.LC(), K0.dom)
+
+    def from_GeneralizedPolynomialRing(K1, a, K0):
+        return K1.from_FractionField(a, K0)
+
+    def unify_with_symbols(K0, K1, symbols):
+        if (K0.is_Composite and (set(K0.symbols) & set(symbols))) or (K1.is_Composite and (set(K1.symbols) & set(symbols))):
+            raise UnificationFailed("Cannot unify %s with %s, given %s generators" % (K0, K1, tuple(symbols)))
+
+        return K0.unify(K1)
+
+    def unify_composite(K0, K1):
+        """Unify two domains where at least one is composite."""
+        K0_ground = K0.dom if K0.is_Composite else K0
+        K1_ground = K1.dom if K1.is_Composite else K1
+
+        K0_symbols = K0.symbols if K0.is_Composite else ()
+        K1_symbols = K1.symbols if K1.is_Composite else ()
+
+        domain = K0_ground.unify(K1_ground)
+        symbols = _unify_gens(K0_symbols, K1_symbols)
+        order = K0.order if K0.is_Composite else K1.order
+
+        # E.g. ZZ[x].unify(QQ.frac_field(x)) -> ZZ.frac_field(x)
+        if ((K0.is_FractionField and K1.is_PolynomialRing or
+             K1.is_FractionField and K0.is_PolynomialRing) and
+             (not K0_ground.is_Field or not K1_ground.is_Field) and domain.is_Field
+             and domain.has_assoc_Ring):
+            domain = domain.get_ring()
+
+        if K0.is_Composite and (not K1.is_Composite or K0.is_FractionField or K1.is_PolynomialRing):
+            cls = K0.__class__
+        else:
+            cls = K1.__class__
+
+        # Here cls might be PolynomialRing, FractionField, GlobalPolynomialRing
+        # (dense/old Polynomialring) or dense/old FractionField.
+
+        from sympy.polys.domains.old_polynomialring import GlobalPolynomialRing
+        if cls == GlobalPolynomialRing:
+            return cls(domain, symbols)
+
+        return cls(domain, symbols, order)
+
+    def unify(K0, K1, symbols=None):
+        """
+        Construct a minimal domain that contains elements of ``K0`` and ``K1``.
+
+        Known domains (from smallest to largest):
+
+        - ``GF(p)``
+        - ``ZZ``
+        - ``QQ``
+        - ``RR(prec, tol)``
+        - ``CC(prec, tol)``
+        - ``ALG(a, b, c)``
+        - ``K[x, y, z]``
+        - ``K(x, y, z)``
+        - ``EX``
+
+        """
+        if symbols is not None:
+            return K0.unify_with_symbols(K1, symbols)
+
+        if K0 == K1:
+            return K0
+
+        if not (K0.has_CharacteristicZero and K1.has_CharacteristicZero):
+            # Reject unification of domains with different characteristics.
+            if K0.characteristic() != K1.characteristic():
+                raise UnificationFailed("Cannot unify %s with %s" % (K0, K1))
+
+            # We do not get here if K0 == K1. The two domains have the same
+            # characteristic but are unequal so at least one is composite and
+            # we are unifying something like GF(3).unify(GF(3)[x]).
+            return K0.unify_composite(K1)
+
+        # From here we know both domains have characteristic zero and it can be
+        # acceptable to fall back on EX.
+
+        if K0.is_EXRAW:
+            return K0
+        if K1.is_EXRAW:
+            return K1
+
+        if K0.is_EX:
+            return K0
+        if K1.is_EX:
+            return K1
+
+        if K0.is_FiniteExtension or K1.is_FiniteExtension:
+            if K1.is_FiniteExtension:
+                K0, K1 = K1, K0
+            if K1.is_FiniteExtension:
+                # Unifying two extensions.
+                # Try to ensure that K0.unify(K1) == K1.unify(K0)
+                if list(ordered([K0.modulus, K1.modulus]))[1] == K0.modulus:
+                    K0, K1 = K1, K0
+                return K1.set_domain(K0)
+            else:
+                # Drop the generator from other and unify with the base domain
+                K1 = K1.drop(K0.symbol)
+                K1 = K0.domain.unify(K1)
+                return K0.set_domain(K1)
+
+        if K0.is_Composite or K1.is_Composite:
+            return K0.unify_composite(K1)
+
+        def mkinexact(cls, K0, K1):
+            prec = max(K0.precision, K1.precision)
+            tol = max(K0.tolerance, K1.tolerance)
+            return cls(prec=prec, tol=tol)
+
+        if K1.is_ComplexField:
+            K0, K1 = K1, K0
+        if K0.is_ComplexField:
+            if K1.is_ComplexField or K1.is_RealField:
+                return mkinexact(K0.__class__, K0, K1)
+            else:
+                return K0
+
+        if K1.is_RealField:
+            K0, K1 = K1, K0
+        if K0.is_RealField:
+            if K1.is_RealField:
+                return mkinexact(K0.__class__, K0, K1)
+            elif K1.is_GaussianRing or K1.is_GaussianField:
+                from sympy.polys.domains.complexfield import ComplexField
+                return ComplexField(prec=K0.precision, tol=K0.tolerance)
+            else:
+                return K0
+
+        if K1.is_AlgebraicField:
+            K0, K1 = K1, K0
+        if K0.is_AlgebraicField:
+            if K1.is_GaussianRing:
+                K1 = K1.get_field()
+            if K1.is_GaussianField:
+                K1 = K1.as_AlgebraicField()
+            if K1.is_AlgebraicField:
+                return K0.__class__(K0.dom.unify(K1.dom), *_unify_gens(K0.orig_ext, K1.orig_ext))
+            else:
+                return K0
+
+        if K0.is_GaussianField:
+            return K0
+        if K1.is_GaussianField:
+            return K1
+
+        if K0.is_GaussianRing:
+            if K1.is_RationalField:
+                K0 = K0.get_field()
+            return K0
+        if K1.is_GaussianRing:
+            if K0.is_RationalField:
+                K1 = K1.get_field()
+            return K1
+
+        if K0.is_RationalField:
+            return K0
+        if K1.is_RationalField:
+            return K1
+
+        if K0.is_IntegerRing:
+            return K0
+        if K1.is_IntegerRing:
+            return K1
+
+        from sympy.polys.domains import EX
+        return EX
+
+    def __eq__(self, other):
+        """Returns ``True`` if two domains are equivalent. """
+        # XXX: Remove this.
+        return isinstance(other, Domain) and self.dtype == other.dtype
+
+    def __ne__(self, other):
+        """Returns ``False`` if two domains are equivalent. """
+        return not self == other
+
+    def map(self, seq):
+        """Rersively apply ``self`` to all elements of ``seq``. """
+        result = []
+
+        for elt in seq:
+            if isinstance(elt, list):
+                result.append(self.map(elt))
+            else:
+                result.append(self(elt))
+
+        return result
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        raise DomainError('there is no ring associated with %s' % self)
+
+    def get_field(self):
+        """Returns a field associated with ``self``. """
+        raise DomainError('there is no field associated with %s' % self)
+
+    def get_exact(self):
+        """Returns an exact domain associated with ``self``. """
+        return self
+
+    def __getitem__(self, symbols):
+        """The mathematical way to make a polynomial ring. """
+        if hasattr(symbols, '__iter__'):
+            return self.poly_ring(*symbols)
+        else:
+            return self.poly_ring(symbols)
+
+    def poly_ring(self, *symbols, order=lex):
+        """Returns a polynomial ring, i.e. `K[X]`. """
+        from sympy.polys.domains.polynomialring import PolynomialRing
+        return PolynomialRing(self, symbols, order)
+
+    def frac_field(self, *symbols, order=lex):
+        """Returns a fraction field, i.e. `K(X)`. """
+        from sympy.polys.domains.fractionfield import FractionField
+        return FractionField(self, symbols, order)
+
+    def old_poly_ring(self, *symbols, **kwargs):
+        """Returns a polynomial ring, i.e. `K[X]`. """
+        from sympy.polys.domains.old_polynomialring import PolynomialRing
+        return PolynomialRing(self, *symbols, **kwargs)
+
+    def old_frac_field(self, *symbols, **kwargs):
+        """Returns a fraction field, i.e. `K(X)`. """
+        from sympy.polys.domains.old_fractionfield import FractionField
+        return FractionField(self, *symbols, **kwargs)
+
+    def algebraic_field(self, *extension, alias=None):
+        r"""Returns an algebraic field, i.e. `K(\alpha, \ldots)`. """
+        raise DomainError("Cannot create algebraic field over %s" % self)
+
+    def alg_field_from_poly(self, poly, alias=None, root_index=-1):
+        r"""
+        Convenience method to construct an algebraic extension on a root of a
+        polynomial, chosen by root index.
+
+        Parameters
+        ==========
+
+        poly : :py:class:`~.Poly`
+            The polynomial whose root generates the extension.
+        alias : str, optional (default=None)
+            Symbol name for the generator of the extension.
+            E.g. "alpha" or "theta".
+        root_index : int, optional (default=-1)
+            Specifies which root of the polynomial is desired. The ordering is
+            as defined by the :py:class:`~.ComplexRootOf` class. The default of
+            ``-1`` selects the most natural choice in the common cases of
+            quadratic and cyclotomic fields (the square root on the positive
+            real or imaginary axis, resp. $\mathrm{e}^{2\pi i/n}$).
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, Poly
+        >>> from sympy.abc import x
+        >>> f = Poly(x**2 - 2)
+        >>> K = QQ.alg_field_from_poly(f)
+        >>> K.ext.minpoly == f
+        True
+        >>> g = Poly(8*x**3 - 6*x - 1)
+        >>> L = QQ.alg_field_from_poly(g, "alpha")
+        >>> L.ext.minpoly == g
+        True
+        >>> L.to_sympy(L([1, 1, 1]))
+        alpha**2 + alpha + 1
+
+        """
+        from sympy.polys.rootoftools import CRootOf
+        root = CRootOf(poly, root_index)
+        alpha = AlgebraicNumber(root, alias=alias)
+        return self.algebraic_field(alpha, alias=alias)
+
+    def cyclotomic_field(self, n, ss=False, alias="zeta", gen=None, root_index=-1):
+        r"""
+        Convenience method to construct a cyclotomic field.
+
+        Parameters
+        ==========
+
+        n : int
+            Construct the nth cyclotomic field.
+        ss : boolean, optional (default=False)
+            If True, append *n* as a subscript on the alias string.
+        alias : str, optional (default="zeta")
+            Symbol name for the generator.
+        gen : :py:class:`~.Symbol`, optional (default=None)
+            Desired variable for the cyclotomic polynomial that defines the
+            field. If ``None``, a dummy variable will be used.
+        root_index : int, optional (default=-1)
+            Specifies which root of the polynomial is desired. The ordering is
+            as defined by the :py:class:`~.ComplexRootOf` class. The default of
+            ``-1`` selects the root $\mathrm{e}^{2\pi i/n}$.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, latex
+        >>> K = QQ.cyclotomic_field(5)
+        >>> K.to_sympy(K([-1, 1]))
+        1 - zeta
+        >>> L = QQ.cyclotomic_field(7, True)
+        >>> a = L.to_sympy(L([-1, 1]))
+        >>> print(a)
+        1 - zeta7
+        >>> print(latex(a))
+        1 - \zeta_{7}
+
+        """
+        from sympy.polys.specialpolys import cyclotomic_poly
+        if ss:
+            alias += str(n)
+        return self.alg_field_from_poly(cyclotomic_poly(n, gen), alias=alias,
+                                        root_index=root_index)
+
+    def inject(self, *symbols):
+        """Inject generators into this domain. """
+        raise NotImplementedError
+
+    def drop(self, *symbols):
+        """Drop generators from this domain. """
+        if self.is_Simple:
+            return self
+        raise NotImplementedError  # pragma: no cover
+
+    def is_zero(self, a):
+        """Returns True if ``a`` is zero. """
+        return not a
+
+    def is_one(self, a):
+        """Returns True if ``a`` is one. """
+        return a == self.one
+
+    def is_positive(self, a):
+        """Returns True if ``a`` is positive. """
+        return a > 0
+
+    def is_negative(self, a):
+        """Returns True if ``a`` is negative. """
+        return a < 0
+
+    def is_nonpositive(self, a):
+        """Returns True if ``a`` is non-positive. """
+        return a <= 0
+
+    def is_nonnegative(self, a):
+        """Returns True if ``a`` is non-negative. """
+        return a >= 0
+
+    def canonical_unit(self, a):
+        if self.is_negative(a):
+            return -self.one
+        else:
+            return self.one
+
+    def abs(self, a):
+        """Absolute value of ``a``, implies ``__abs__``. """
+        return abs(a)
+
+    def neg(self, a):
+        """Returns ``a`` negated, implies ``__neg__``. """
+        return -a
+
+    def pos(self, a):
+        """Returns ``a`` positive, implies ``__pos__``. """
+        return +a
+
+    def add(self, a, b):
+        """Sum of ``a`` and ``b``, implies ``__add__``.  """
+        return a + b
+
+    def sub(self, a, b):
+        """Difference of ``a`` and ``b``, implies ``__sub__``.  """
+        return a - b
+
+    def mul(self, a, b):
+        """Product of ``a`` and ``b``, implies ``__mul__``.  """
+        return a * b
+
+    def pow(self, a, b):
+        """Raise ``a`` to power ``b``, implies ``__pow__``.  """
+        return a ** b
+
+    def exquo(self, a, b):
+        """Exact quotient of *a* and *b*. Analogue of ``a / b``.
+
+        Explanation
+        ===========
+
+        This is essentially the same as ``a / b`` except that an error will be
+        raised if the division is inexact (if there is any remainder) and the
+        result will always be a domain element. When working in a
+        :py:class:`~.Domain` that is not a :py:class:`~.Field` (e.g. :ref:`ZZ`
+        or :ref:`K[x]`) ``exquo`` should be used instead of ``/``.
+
+        The key invariant is that if ``q = K.exquo(a, b)`` (and ``exquo`` does
+        not raise an exception) then ``a == b*q``.
+
+        Examples
+        ========
+
+        We can use ``K.exquo`` instead of ``/`` for exact division.
+
+        >>> from sympy import ZZ
+        >>> ZZ.exquo(ZZ(4), ZZ(2))
+        2
+        >>> ZZ.exquo(ZZ(5), ZZ(2))
+        Traceback (most recent call last):
+            ...
+        ExactQuotientFailed: 2 does not divide 5 in ZZ
+
+        Over a :py:class:`~.Field` such as :ref:`QQ`, division (with nonzero
+        divisor) is always exact so in that case ``/`` can be used instead of
+        :py:meth:`~.Domain.exquo`.
+
+        >>> from sympy import QQ
+        >>> QQ.exquo(QQ(5), QQ(2))
+        5/2
+        >>> QQ(5) / QQ(2)
+        5/2
+
+        Parameters
+        ==========
+
+        a: domain element
+            The dividend
+        b: domain element
+            The divisor
+
+        Returns
+        =======
+
+        q: domain element
+            The exact quotient
+
+        Raises
+        ======
+
+        ExactQuotientFailed: if exact division is not possible.
+        ZeroDivisionError: when the divisor is zero.
+
+        See also
+        ========
+
+        quo: Analogue of ``a // b``
+        rem: Analogue of ``a % b``
+        div: Analogue of ``divmod(a, b)``
+
+        Notes
+        =====
+
+        Since the default :py:attr:`~.Domain.dtype` for :ref:`ZZ` is ``int``
+        (or ``mpz``) division as ``a / b`` should not be used as it would give
+        a ``float`` which is not a domain element.
+
+        >>> ZZ(4) / ZZ(2) # doctest: +SKIP
+        2.0
+        >>> ZZ(5) / ZZ(2) # doctest: +SKIP
+        2.5
+
+        On the other hand with `SYMPY_GROUND_TYPES=flint` elements of :ref:`ZZ`
+        are ``flint.fmpz`` and division would raise an exception:
+
+        >>> ZZ(4) / ZZ(2) # doctest: +SKIP
+        Traceback (most recent call last):
+        ...
+        TypeError: unsupported operand type(s) for /: 'fmpz' and 'fmpz'
+
+        Using ``/`` with :ref:`ZZ` will lead to incorrect results so
+        :py:meth:`~.Domain.exquo` should be used instead.
+
+        """
+        raise NotImplementedError
+
+    def quo(self, a, b):
+        """Quotient of *a* and *b*. Analogue of ``a // b``.
+
+        ``K.quo(a, b)`` is equivalent to ``K.div(a, b)[0]``. See
+        :py:meth:`~.Domain.div` for more explanation.
+
+        See also
+        ========
+
+        rem: Analogue of ``a % b``
+        div: Analogue of ``divmod(a, b)``
+        exquo: Analogue of ``a / b``
+        """
+        raise NotImplementedError
+
+    def rem(self, a, b):
+        """Modulo division of *a* and *b*. Analogue of ``a % b``.
+
+        ``K.rem(a, b)`` is equivalent to ``K.div(a, b)[1]``. See
+        :py:meth:`~.Domain.div` for more explanation.
+
+        See also
+        ========
+
+        quo: Analogue of ``a // b``
+        div: Analogue of ``divmod(a, b)``
+        exquo: Analogue of ``a / b``
+        """
+        raise NotImplementedError
+
+    def div(self, a, b):
+        """Quotient and remainder for *a* and *b*. Analogue of ``divmod(a, b)``
+
+        Explanation
+        ===========
+
+        This is essentially the same as ``divmod(a, b)`` except that is more
+        consistent when working over some :py:class:`~.Field` domains such as
+        :ref:`QQ`. When working over an arbitrary :py:class:`~.Domain` the
+        :py:meth:`~.Domain.div` method should be used instead of ``divmod``.
+
+        The key invariant is that if ``q, r = K.div(a, b)`` then
+        ``a == b*q + r``.
+
+        The result of ``K.div(a, b)`` is the same as the tuple
+        ``(K.quo(a, b), K.rem(a, b))`` except that if both quotient and
+        remainder are needed then it is more efficient to use
+        :py:meth:`~.Domain.div`.
+
+        Examples
+        ========
+
+        We can use ``K.div`` instead of ``divmod`` for floor division and
+        remainder.
+
+        >>> from sympy import ZZ, QQ
+        >>> ZZ.div(ZZ(5), ZZ(2))
+        (2, 1)
+
+        If ``K`` is a :py:class:`~.Field` then the division is always exact
+        with a remainder of :py:attr:`~.Domain.zero`.
+
+        >>> QQ.div(QQ(5), QQ(2))
+        (5/2, 0)
+
+        Parameters
+        ==========
+
+        a: domain element
+            The dividend
+        b: domain element
+            The divisor
+
+        Returns
+        =======
+
+        (q, r): tuple of domain elements
+            The quotient and remainder
+
+        Raises
+        ======
+
+        ZeroDivisionError: when the divisor is zero.
+
+        See also
+        ========
+
+        quo: Analogue of ``a // b``
+        rem: Analogue of ``a % b``
+        exquo: Analogue of ``a / b``
+
+        Notes
+        =====
+
+        If ``gmpy`` is installed then the ``gmpy.mpq`` type will be used as
+        the :py:attr:`~.Domain.dtype` for :ref:`QQ`. The ``gmpy.mpq`` type
+        defines ``divmod`` in a way that is undesirable so
+        :py:meth:`~.Domain.div` should be used instead of ``divmod``.
+
+        >>> a = QQ(1)
+        >>> b = QQ(3, 2)
+        >>> a               # doctest: +SKIP
+        mpq(1,1)
+        >>> b               # doctest: +SKIP
+        mpq(3,2)
+        >>> divmod(a, b)    # doctest: +SKIP
+        (mpz(0), mpq(1,1))
+        >>> QQ.div(a, b)    # doctest: +SKIP
+        (mpq(2,3), mpq(0,1))
+
+        Using ``//`` or ``%`` with :ref:`QQ` will lead to incorrect results so
+        :py:meth:`~.Domain.div` should be used instead.
+
+        """
+        raise NotImplementedError
+
+    def invert(self, a, b):
+        """Returns inversion of ``a mod b``, implies something. """
+        raise NotImplementedError
+
+    def revert(self, a):
+        """Returns ``a**(-1)`` if possible. """
+        raise NotImplementedError
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        raise NotImplementedError
+
+    def denom(self, a):
+        """Returns denominator of ``a``. """
+        raise NotImplementedError
+
+    def half_gcdex(self, a, b):
+        """Half extended GCD of ``a`` and ``b``. """
+        s, t, h = self.gcdex(a, b)
+        return s, h
+
+    def gcdex(self, a, b):
+        """Extended GCD of ``a`` and ``b``. """
+        raise NotImplementedError
+
+    def cofactors(self, a, b):
+        """Returns GCD and cofactors of ``a`` and ``b``. """
+        gcd = self.gcd(a, b)
+        cfa = self.quo(a, gcd)
+        cfb = self.quo(b, gcd)
+        return gcd, cfa, cfb
+
+    def gcd(self, a, b):
+        """Returns GCD of ``a`` and ``b``. """
+        raise NotImplementedError
+
+    def lcm(self, a, b):
+        """Returns LCM of ``a`` and ``b``. """
+        raise NotImplementedError
+
+    def log(self, a, b):
+        """Returns b-base logarithm of ``a``. """
+        raise NotImplementedError
+
+    def sqrt(self, a):
+        """Returns a (possibly inexact) square root of ``a``.
+
+        Explanation
+        ===========
+        There is no universal definition of "inexact square root" for all
+        domains. It is not recommended to implement this method for domains
+        other then :ref:`ZZ`.
+
+        See also
+        ========
+        exsqrt
+        """
+        raise NotImplementedError
+
+    def is_square(self, a):
+        """Returns whether ``a`` is a square in the domain.
+
+        Explanation
+        ===========
+        Returns ``True`` if there is an element ``b`` in the domain such that
+        ``b * b == a``, otherwise returns ``False``. For inexact domains like
+        :ref:`RR` and :ref:`CC`, a tiny difference in this equality can be
+        tolerated.
+
+        See also
+        ========
+        exsqrt
+        """
+        raise NotImplementedError
+
+    def exsqrt(self, a):
+        """Principal square root of a within the domain if ``a`` is square.
+
+        Explanation
+        ===========
+        The implementation of this method should return an element ``b`` in the
+        domain such that ``b * b == a``, or ``None`` if there is no such ``b``.
+        For inexact domains like :ref:`RR` and :ref:`CC`, a tiny difference in
+        this equality can be tolerated. The choice of a "principal" square root
+        should follow a consistent rule whenever possible.
+
+        See also
+        ========
+        sqrt, is_square
+        """
+        raise NotImplementedError
+
+    def evalf(self, a, prec=None, **options):
+        """Returns numerical approximation of ``a``. """
+        return self.to_sympy(a).evalf(prec, **options)
+
+    n = evalf
+
+    def real(self, a):
+        return a
+
+    def imag(self, a):
+        return self.zero
+
+    def almosteq(self, a, b, tolerance=None):
+        """Check if ``a`` and ``b`` are almost equal. """
+        return a == b
+
+    def characteristic(self):
+        """Return the characteristic of this domain. """
+        raise NotImplementedError('characteristic()')
+
+
+__all__ = ['Domain']

mgm/lib/python3.10/site-packages/sympy/polys/domains/domainelement.py

@@ -0,0 +1,38 @@
+"""Trait for implementing domain elements. """
+
+
+from sympy.utilities import public
+
+@public
+class DomainElement:
+    """
+    Represents an element of a domain.
+
+    Mix in this trait into a class whose instances should be recognized as
+    elements of a domain. Method ``parent()`` gives that domain.
+    """
+
+    __slots__ = ()
+
+    def parent(self):
+        """Get the domain associated with ``self``
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ, symbols
+        >>> x, y = symbols('x, y')
+        >>> K = ZZ[x,y]
+        >>> p = K(x)**2 + K(y)**2
+        >>> p
+        x**2 + y**2
+        >>> p.parent()
+        ZZ[x,y]
+
+        Notes
+        =====
+
+        This is used by :py:meth:`~.Domain.convert` to identify the domain
+        associated with a domain element.
+        """
+        raise NotImplementedError("abstract method")

mgm/lib/python3.10/site-packages/sympy/polys/domains/expressiondomain.py

@@ -0,0 +1,278 @@
+"""Implementation of :class:`ExpressionDomain` class. """
+
+
+from sympy.core import sympify, SympifyError
+from sympy.polys.domains.domainelement import DomainElement
+from sympy.polys.domains.characteristiczero import CharacteristicZero
+from sympy.polys.domains.field import Field
+from sympy.polys.domains.simpledomain import SimpleDomain
+from sympy.polys.polyutils import PicklableWithSlots
+from sympy.utilities import public
+
+eflags = {"deep": False, "mul": True, "power_exp": False, "power_base": False,
+              "basic": False, "multinomial": False, "log": False}
+
+@public
+class ExpressionDomain(Field, CharacteristicZero, SimpleDomain):
+    """A class for arbitrary expressions. """
+
+    is_SymbolicDomain = is_EX = True
+
+    class Expression(DomainElement, PicklableWithSlots):
+        """An arbitrary expression. """
+
+        __slots__ = ('ex',)
+
+        def __init__(self, ex):
+            if not isinstance(ex, self.__class__):
+                self.ex = sympify(ex)
+            else:
+                self.ex = ex.ex
+
+        def __repr__(f):
+            return 'EX(%s)' % repr(f.ex)
+
+        def __str__(f):
+            return 'EX(%s)' % str(f.ex)
+
+        def __hash__(self):
+            return hash((self.__class__.__name__, self.ex))
+
+        def parent(self):
+            return EX
+
+        def as_expr(f):
+            return f.ex
+
+        def numer(f):
+            return f.__class__(f.ex.as_numer_denom()[0])
+
+        def denom(f):
+            return f.__class__(f.ex.as_numer_denom()[1])
+
+        def simplify(f, ex):
+            return f.__class__(ex.cancel().expand(**eflags))
+
+        def __abs__(f):
+            return f.__class__(abs(f.ex))
+
+        def __neg__(f):
+            return f.__class__(-f.ex)
+
+        def _to_ex(f, g):
+            try:
+                return f.__class__(g)
+            except SympifyError:
+                return None
+
+        def __lt__(f, g):
+            return f.ex.sort_key() < g.ex.sort_key()
+
+        def __add__(f, g):
+            g = f._to_ex(g)
+
+            if g is None:
+                return NotImplemented
+            elif g == EX.zero:
+                return f
+            elif f == EX.zero:
+                return g
+            else:
+                return f.simplify(f.ex + g.ex)
+
+        def __radd__(f, g):
+            return f.simplify(f.__class__(g).ex + f.ex)
+
+        def __sub__(f, g):
+            g = f._to_ex(g)
+
+            if g is None:
+                return NotImplemented
+            elif g == EX.zero:
+                return f
+            elif f == EX.zero:
+                return -g
+            else:
+                return f.simplify(f.ex - g.ex)
+
+        def __rsub__(f, g):
+            return f.simplify(f.__class__(g).ex - f.ex)
+
+        def __mul__(f, g):
+            g = f._to_ex(g)
+
+            if g is None:
+                return NotImplemented
+
+            if EX.zero in (f, g):
+                return EX.zero
+            elif f.ex.is_Number and g.ex.is_Number:
+                return f.__class__(f.ex*g.ex)
+
+            return f.simplify(f.ex*g.ex)
+
+        def __rmul__(f, g):
+            return f.simplify(f.__class__(g).ex*f.ex)
+
+        def __pow__(f, n):
+            n = f._to_ex(n)
+
+            if n is not None:
+                return f.simplify(f.ex**n.ex)
+            else:
+                return NotImplemented
+
+        def __truediv__(f, g):
+            g = f._to_ex(g)
+
+            if g is not None:
+                return f.simplify(f.ex/g.ex)
+            else:
+                return NotImplemented
+
+        def __rtruediv__(f, g):
+            return f.simplify(f.__class__(g).ex/f.ex)
+
+        def __eq__(f, g):
+            return f.ex == f.__class__(g).ex
+
+        def __ne__(f, g):
+            return not f == g
+
+        def __bool__(f):
+            return not f.ex.is_zero
+
+        def gcd(f, g):
+            from sympy.polys import gcd
+            return f.__class__(gcd(f.ex, f.__class__(g).ex))
+
+        def lcm(f, g):
+            from sympy.polys import lcm
+            return f.__class__(lcm(f.ex, f.__class__(g).ex))
+
+    dtype = Expression
+
+    zero = Expression(0)
+    one = Expression(1)
+
+    rep = 'EX'
+
+    has_assoc_Ring = False
+    has_assoc_Field = True
+
+    def __init__(self):
+        pass
+
+    def __eq__(self, other):
+        if isinstance(other, ExpressionDomain):
+            return True
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash("EX")
+
+    def to_sympy(self, a):
+        """Convert ``a`` to a SymPy object. """
+        return a.as_expr()
+
+    def from_sympy(self, a):
+        """Convert SymPy's expression to ``dtype``. """
+        return self.dtype(a)
+
+    def from_ZZ(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_QQ(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_GaussianIntegerRing(K1, a, K0):
+        """Convert a ``GaussianRational`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_GaussianRationalField(K1, a, K0):
+        """Convert a ``GaussianRational`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_AlgebraicField(K1, a, K0):
+        """Convert an ``ANP`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_RealField(K1, a, K0):
+        """Convert a mpmath ``mpf`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_ComplexField(K1, a, K0):
+        """Convert a mpmath ``mpc`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_PolynomialRing(K1, a, K0):
+        """Convert a ``DMP`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_FractionField(K1, a, K0):
+        """Convert a ``DMF`` object to ``dtype``. """
+        return K1(K0.to_sympy(a))
+
+    def from_ExpressionDomain(K1, a, K0):
+        """Convert a ``EX`` object to ``dtype``. """
+        return a
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        return self  # XXX: EX is not a ring but we don't have much choice here.
+
+    def get_field(self):
+        """Returns a field associated with ``self``. """
+        return self
+
+    def is_positive(self, a):
+        """Returns True if ``a`` is positive. """
+        return a.ex.as_coeff_mul()[0].is_positive
+
+    def is_negative(self, a):
+        """Returns True if ``a`` is negative. """
+        return a.ex.could_extract_minus_sign()
+
+    def is_nonpositive(self, a):
+        """Returns True if ``a`` is non-positive. """
+        return a.ex.as_coeff_mul()[0].is_nonpositive
+
+    def is_nonnegative(self, a):
+        """Returns True if ``a`` is non-negative. """
+        return a.ex.as_coeff_mul()[0].is_nonnegative
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        return a.numer()
+
+    def denom(self, a):
+        """Returns denominator of ``a``. """
+        return a.denom()
+
+    def gcd(self, a, b):
+        return self(1)
+
+    def lcm(self, a, b):
+        return a.lcm(b)
+
+
+EX = ExpressionDomain()