passagemath-gap 10.5.43__cp310-cp310-macosx_14_0_arm64.whl → 10.6.1rc2__cp310-cp310-macosx_14_0_arm64.whl

sage/groups/matrix_gps/binary_dihedral.py

@@ -83,7 +83,7 @@ class BinaryDihedralGroup(UniqueRepresentation, FinitelyGeneratedMatrixGroup_gap
 
         MS = MatrixSpace(R, 2)
         zero = R.zero()
-        gens = [ MS([zeta, zero, zero, ~zeta]), MS([zero, i, i, zero]) ]
+        gens = [MS([zeta, zero, zero, ~zeta]), MS([zero, i, i, zero])]
 
         from sage.libs.gap.libgap import libgap
         gap_gens = [libgap(matrix_gen) for matrix_gen in gens]

sage/groups/perm_gps/permgroup.py

@@ -383,13 +383,12 @@ def PermutationGroup(gens=None, *args, **kwds):
         ...
         TypeError: gens must be a tuple, list, or GapElement
 
-    This will raise an error after the deprecation period::
+    This now raises an error (:issue:`31510`)::
 
         sage: G = PermutationGroup([(1,2,3,4)], [(1,7,3,5)])
-        doctest:warning
+        Traceback (most recent call last):
         ...
-        DeprecationWarning: gap_group, domain, canonicalize, category will become keyword only
-        See https://github.com/sagemath/sage/issues/31510 for details.
+        ValueError: please use keywords gap_group=, domain=, canonicalize=, category= in the input
     """
     if not isinstance(gens, ExpectElement) and hasattr(gens, '_permgroup_'):
         return gens._permgroup_()
@@ -405,18 +404,7 @@ def PermutationGroup(gens=None, *args, **kwds):
             raise ValueError("you must specify the domain for an action")
         return PermutationGroup_action(gens, action, domain, gap_group=gap_group)
     if args:
-        from sage.misc.superseded import deprecation
-        deprecation(31510, "gap_group, domain, canonicalize, category will become keyword only")
-        if len(args) > 4:
-            raise ValueError("invalid input")
-        args = list(args)
-        gap_group = args.pop(0)
-        if args:
-            domain = args.pop(0)
-            if args:
-                canonicalize = args.pop(0)
-                if args:
-                    category = args.pop(0)
+        raise ValueError("please use keywords gap_group=, domain=, canonicalize=, category= in the input")
     return PermutationGroup_generic(gens=gens, gap_group=gap_group, domain=domain,
                                     canonicalize=canonicalize, category=category)
 
@@ -1073,7 +1061,7 @@ class PermutationGroup_generic(FiniteGroup):
         """
         return list(self)
 
-    def __contains__(self, item):
+    def __contains__(self, item) -> bool:
         """
         Return whether ``item`` is an element of this group.
 
@@ -1110,33 +1098,6 @@ class PermutationGroup_generic(FiniteGroup):
             return False
         return True
 
-    def has_element(self, item):
-        """
-        Return whether ``item`` is an element of this group -
-        however *ignores* parentage.
-
-        EXAMPLES::
-
-            sage: G = CyclicPermutationGroup(4)
-            sage: gens = G.gens()
-            sage: H = DihedralGroup(4)
-            sage: g = G([(1,2,3,4)]); g
-            (1,2,3,4)
-            sage: G.has_element(g)
-            doctest:warning
-            ...
-            DeprecationWarning: G.has_element(g) is deprecated; use :meth:`__contains__`, i.e., `g in G` instead
-            See https://github.com/sagemath/sage/issues/33831 for details.
-            True
-            sage: h = H([(1,2),(3,4)]); h
-            (1,2)(3,4)
-            sage: G.has_element(h)
-            False
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(33831, "G.has_element(g) is deprecated; use :meth:`__contains__`, i.e., `g in G` instead")
-        return item in self
-
     def __iter__(self):
         r"""
         Return an iterator going through all elements in ``self``.
@@ -1166,9 +1127,9 @@ class PermutationGroup_generic(FiniteGroup):
         """
         if len(self._gens) == 1:
             return self._iteration_monogen()
-        else:
-            # TODO: this is too slow for moderatly small permutation groups
-            return self.iteration(algorithm='SGS')
+
+        # TODO: this is too slow for moderately small permutation groups
+        return self.iteration(algorithm='SGS')
 
     def _iteration_monogen(self):
         r"""
@@ -3357,9 +3318,17 @@ class PermutationGroup_generic(FiniteGroup):
             Traceback (most recent call last):
             ...
             TypeError: junk is not a permutation group
+
+        TESTS:
+
+        Verify that :issue`39416` is fixed::
+
+            sage: G = PermutationGroup(gens=[(1,2), (2,4)], domain={1, 2, 4})
+            sage: G.commutator()
+            Permutation Group with generators [(1,2,4)]
         """
         if other is None:
-            return PermutationGroup(gap_group=libgap.DerivedSubgroup(self))
+            return PermutationGroup(gap_group=libgap.DerivedSubgroup(self), domain=self.domain())
         else:
             from sage.categories.finite_permutation_groups import FinitePermutationGroups
             if other not in FinitePermutationGroups():

sage/groups/perm_gps/permgroup_element.pyx

@@ -136,8 +136,8 @@ import sage.interfaces.abc
 
 from sage.libs.gap.libgap import libgap
 from sage.libs.gap.gap_includes cimport (UInt, UInt2, UInt4, T_PERM2, T_PERM4,
-        NEW_PERM2, TNUM_OBJ, DEG_PERM2, DEG_PERM4, CONST_ADDR_PERM2,
-        CONST_ADDR_PERM4, ADDR_PERM2)
+        NEW_PERM2, NEW_PERM4, TNUM_OBJ, DEG_PERM2, DEG_PERM4, CONST_ADDR_PERM2,
+        CONST_ADDR_PERM4, ADDR_PERM2, ADDR_PERM4)
 from sage.libs.gap.util cimport initialize
 from sage.libs.gap.element cimport (GapElement, GapElement_List,
         GapElement_String, GapElement_Permutation, make_GapElement_Permutation)
@@ -566,7 +566,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
             ('b','c')
         """
         cdef int i, j, vn = len(v)
-        assert(vn <= self.n)
+        assert vn <= self.n
         if convert:
             convert_dict = self._parent._domain_to_gap
             for i in range(len(v)):
@@ -891,16 +891,32 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
             sage: p = SymmetricGroup(0).an_element()
             sage: p._libgap_()
             ()
+
+        A minimal test that we handle permutations of degree larger than 2^16 :issue:`39998`::
+
+            sage: SymmetricGroup(2**16+1)((2**16,2**16+1))._libgap_() # long time (100 mb)
+            (65536,65537)
         """
         if self._libgap is not None:
             return self._libgap
         initialize()
 
-        cdef Obj res = NEW_PERM2(self.n)
-        cdef UInt2* p = ADDR_PERM2(res)
         cdef UInt i
-        for i in range(self.n):
-            p[i] = self.perm[i]
+        cdef Obj res
+        cdef UInt2* p2
+        cdef UInt4* p4
+        if self.n < 1<<16:
+            # make a new (small) permutation
+            res = NEW_PERM2(self.n)
+            p2 = ADDR_PERM2(res)
+            for i in range(self.n):
+                p2[i] = self.perm[i]
+        else:
+            # make a new (large) permutation
+            res = NEW_PERM4(self.n)
+            p4 = ADDR_PERM4(res)
+            for i in range(self.n):
+                p4[i] = self.perm[i]
         self._libgap = make_GapElement_Permutation(libgap, res)
         return self._libgap
 
@@ -1911,7 +1927,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
             from sage.combinat.partition import _Partitions
             return _Partitions(cycle_type)
 
-    def has_descent(self, i, side='right', positive=False):
+    def has_descent(self, i, side='right', positive=False) -> bool:
         r"""
         Return whether ``self`` has a left (resp. right) descent at
         position ``i``. If ``positive`` is ``True``, then test for a non
@@ -2116,7 +2132,7 @@ cdef class SymmetricGroupElement(PermutationGroupElement):
         from sage.combinat.permutation import Permutation
         return Permutation(self).absolute_length()
 
-    def has_left_descent(self, i):
+    def has_left_descent(self, i) -> bool:
         r"""
         Return whether `i` is a left descent of ``self``.
 

sage/interfaces/gap.py

@@ -681,6 +681,15 @@ class Gap_generic(ExtraTabCompletion, Expect):
             Restarting Gap and trying again
             sage: a
             3
+
+        Checks for :issue:`39906`::
+
+            sage: gap("a"*200)
+            Traceback (most recent call last):
+            ...
+            TypeError: Gap terminated unexpectedly while reading in a large line:
+            Gap produced error output
+            Error, Variable: 'aaaa...aaaa' must have a value executing Read("...");
         """
         expect_eof = self._quit_string() in line
 
@@ -739,7 +748,7 @@ class Gap_generic(ExtraTabCompletion, Expect):
                 else:
                     return ''
             else:
-                raise RuntimeError(exc)
+                raise exc
 
         except KeyboardInterrupt:
             self._keyboard_interrupt()
@@ -952,7 +961,7 @@ class GapElement_generic(ModuleElement, ExtraTabCompletion, ExpectElement):
             2
         """
         # This is just a copy of ExpectElement._add_ to fix the fact
-        # that the abtract method ModuleElement._add_ comes first in
+        # that the abstract method ModuleElement._add_ comes first in
         # the MRO.
         return self._operation("+", other)
 
@@ -1083,7 +1092,7 @@ class Gap(Gap_generic):
         # -p: enable "package output mode"; this confusingly named option
         #     causes GAP to output special control characters that are normally
         #     intended for communication with a window manager (i.e. for xgap)
-        #     but that we also use to control GAP with pexepect
+        #     but that we also use to control GAP with pexpect
         # -T: disable interactive break loop when encountering errors
         # -E: disable readline support
         cmd += " -b -p -T -E"

sage/libs/gap/gap_includes.pxd

@@ -1,5 +1,5 @@
 # sage_setup: distribution = sagemath-gap
-# distutils: libraries = gap gmp m
+# distutils: libraries = gap gmp M_LIBRARIES
 ###############################################################################
 #       Copyright (C) 2009, William Stein <wstein@gmail.com>
 #       Copyright (C) 2012, Volker Braun <vbraun.name@gmail.com>

sage/rings/species.py

@@ -35,6 +35,7 @@ AUTHORS:
 
 from itertools import accumulate, chain, product
 
+from sage.arith.misc import divisors
 from sage.categories.graded_algebras_with_basis import GradedAlgebrasWithBasis
 from sage.categories.modules import Modules
 from sage.categories.monoids import Monoids
@@ -43,15 +44,17 @@ from sage.categories.sets_with_grading import SetsWithGrading
 from sage.categories.tensor import tensor
 from sage.combinat.free_module import CombinatorialFreeModule
 from sage.combinat.integer_vector import IntegerVectors
+from sage.combinat.integer_vector_weighted import WeightedIntegerVectors
 from sage.combinat.partition import Partitions, _Partitions
 from sage.groups.perm_gps.constructor import PermutationGroupElement
 from sage.groups.perm_gps.permgroup import PermutationGroup, PermutationGroup_generic
 from sage.groups.perm_gps.permgroup_named import SymmetricGroup
 from sage.libs.gap.libgap import libgap
-from sage.misc.cachefunc import cached_method
+from sage.misc.cachefunc import cached_method, cached_function
 from sage.misc.fast_methods import WithEqualityById
 from sage.misc.inherit_comparison import InheritComparisonClasscallMetaclass
 from sage.misc.lazy_import import lazy_import
+from sage.misc.misc_c import prod
 from sage.modules.free_module_element import vector
 from sage.monoids.indexed_free_monoid import (IndexedFreeAbelianMonoid,
                                               IndexedFreeAbelianMonoidElement)
@@ -301,13 +304,13 @@ class AtomicSpeciesElement(WithEqualityById,
             sage: len(P.cover_relations())
             7
             sage: sorted(P.cover_relations(), key=str)
-            [[C_4, {((1,2)(3,4),)}],
+            [[C_4, E_2(X^2)],
+             [E_2(E_2), C_4],
+             [E_2(E_2), Pb_4],
+             [E_4, E_2(E_2)],
              [E_4, Eo_4],
-             [E_4, P_4],
              [Eo_4, Pb_4],
-             [P_4, C_4],
-             [P_4, Pb_4],
-             [Pb_4, {((1,2)(3,4),)}]]
+             [Pb_4, E_2(X^2)]]
 
         TESTS::
 
@@ -454,7 +457,7 @@ class AtomicSpecies(UniqueRepresentation, Parent):
 
             sage: G = PermutationGroup([[(1,3),(5,7)]], domain=[1,3,5,7])
             sage: A(G, ([1,3], [5,7]))
-            {((1,2)(3,4),): ({1, 2}, {3, 4})}
+            E_2(X*Y)
 
         Test that errors are raised on some possible misuses::
 
@@ -520,9 +523,9 @@ class AtomicSpecies(UniqueRepresentation, Parent):
             else:
                 raise ValueError("the assignment of sorts to the domain elements must be provided")
         elif not isinstance(pi, dict):
-            pi = {i: v for i, v in enumerate(pi)}
+            pi = dict(enumerate(pi))
         if check:
-            if not set(pi.keys()).issubset(range(self._arity)):
+            if not set(pi).issubset(range(self._arity)):
                 raise ValueError(f"keys of pi (={pi.keys()}) must be in range({self._arity})")
             if (sum(len(p) for p in pi.values()) != len(G.domain())
                 or set(chain.from_iterable(pi.values())) != set(G.domain())):
@@ -535,7 +538,7 @@ class AtomicSpecies(UniqueRepresentation, Parent):
 
     def _rename(self, n):
         r"""
-        Names for common species.
+        Give common species of degree `n` their traditional names.
 
         EXAMPLES::
 
@@ -550,9 +553,9 @@ class AtomicSpecies(UniqueRepresentation, Parent):
             sage: A(CyclicPermutationGroup(4), {1: range(1, 5)})
             C_4(Y)
             sage: A(DihedralGroup(4), {0: range(1, 5)})
-            P_4(X)
+            E_2(E_2(X))
             sage: A(DihedralGroup(4), {1: range(1, 5)})
-            P_4(Y)
+            E_2(E_2(Y))
             sage: A(AlternatingGroup(4), {0: range(1, 5)})
             Eo_4(X)
             sage: A(AlternatingGroup(4), {1: range(1, 5)})
@@ -593,6 +596,8 @@ class AtomicSpecies(UniqueRepresentation, Parent):
                         [(i, i+1) for i in range(1, n, 2)]]
                 self(PermutationGroup(gens), pi, check=False).rename(f"Pb_{n}" + sort)
 
+        _atomic_set_like_species(n, self._names)
+
     def __contains__(self, x):
         r"""
         Return whether ``x`` is in ``self``.
@@ -641,7 +646,7 @@ class AtomicSpecies(UniqueRepresentation, Parent):
             G, pi = x
         if not isinstance(G, PermutationGroup_generic):
             return False
-        if not set(pi.keys()).issubset(range(self._arity)):
+        if not set(pi).issubset(range(self._arity)):
             return False
         if (sum(len(p) for p in pi.values()) != len(G.domain())
             or set(chain.from_iterable(pi.values())) != set(G.domain())):
@@ -721,11 +726,7 @@ class AtomicSpecies(UniqueRepresentation, Parent):
 
             sage: A = AtomicSpecies("X, Y")
             sage: a = A.an_element(); a
-            {((1,2)(3,4),): ({1, 2}, {3, 4})}
-
-            sage: a.rename("E_2(XY)")
-            sage: a
-            E_2(XY)
+            E_2(X*Y)
         """
         G = PermutationGroup([[(2 * s + 1, 2 * s + 2) for s in range(self._arity)]])
         m = {s: [2 * s + 1, 2 * s + 2] for s in range(self._arity)}
@@ -849,7 +850,7 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
         sage: M = MolecularSpecies("X,Y")
         sage: G = PermutationGroup([[(1,2),(3,4)], [(5,6)]])
         sage: M(G, {0: [5,6], 1: [1,2,3,4]})
-        E_2(X)*{((1,2)(3,4),): ({}, {1, 2, 3, 4})}
+        E_2(X)*E_2(Y^2)
     """
     @staticmethod
     def __classcall__(cls, names):
@@ -944,11 +945,11 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
             sage: a = lambda g, x: SetPartition([[g(e) for e in b] for b in x])
             sage: X = SetPartitions(4, [2, 2])
             sage: M((X, a, 'left'), {0: X.base_set()})
-            P_4
+            E_2(E_2)
 
             sage: X = SetPartitions(8, [4, 2, 2])
             sage: M((X, a, 'left'), {0: X.base_set()}, check=False)
-            E_4*P_4
+            E_4*E_2(E_2)
 
         TESTS::
 
@@ -960,7 +961,7 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
 
             sage: G = PermutationGroup([[(2,3),(4,5)]], domain=[2,3,4,5])
             sage: M(G, {0: [2, 3], 1: [4, 5]})
-            E_2(XY)
+            E_2(X*Y)
 
             sage: X = SetPartitions(4, 2)
             sage: a = lambda g, x: SetPartition([[g(e) for e in b] for b in x])
@@ -971,7 +972,7 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
 
             sage: G = PermutationGroup([[(1,3),(5,7)]], domain=[1,3,5,7])
             sage: M(G, ([1,3], [5,7]))
-            E_2(XY)
+            E_2(X*Y)
 
             sage: G = PermutationGroup([[(1,2), (3,4,5,6)]])
             sage: a = M(G, {0:[1,2], 1:[3,4,5,6]})
@@ -1036,7 +1037,7 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
                 else:
                     raise ValueError("the assignment of sorts to the domain elements must be provided")
             elif not isinstance(pi, dict):
-                pi = {i: v for i, v in enumerate(pi)}
+                pi = dict(enumerate(pi))
             domain = [e for p in pi.values() for e in p]
             if check and len(domain) != len(set(domain)) or set(G.domain()) != set(domain):
                 raise ValueError(f"values of pi (={pi.values()}) must partition the domain of G (={G.domain()})")
@@ -1180,23 +1181,23 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
                 sage: len(P.cover_relations())
                 17
                 sage: sorted(P.cover_relations(), key=str)
-                [[C_4, {((1,2)(3,4),)}],
+                [[C_4, E_2(X^2)],
+                 [E_2(E_2), C_4],
+                 [E_2(E_2), E_2^2],
+                 [E_2(E_2), Pb_4],
+                 [E_2(X^2), X^4],
+                 [E_2^2, E_2(X^2)],
                  [E_2^2, X^2*E_2],
-                 [E_2^2, {((1,2)(3,4),)}],
+                 [E_4, E_2(E_2)],
                  [E_4, Eo_4],
-                 [E_4, P_4],
                  [E_4, X*E_3],
                  [Eo_4, Pb_4],
                  [Eo_4, X*C_3],
-                 [P_4, C_4],
-                 [P_4, E_2^2],
-                 [P_4, Pb_4],
-                 [Pb_4, {((1,2)(3,4),)}],
+                 [Pb_4, E_2(X^2)],
                  [X*C_3, X^4],
                  [X*E_3, X*C_3],
                  [X*E_3, X^2*E_2],
-                 [X^2*E_2, X^4],
-                 [{((1,2)(3,4),)}, X^4]]
+                 [X^2*E_2, X^4]]
 
             TESTS::
 
@@ -1253,7 +1254,7 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
                 sage: M = MolecularSpecies("X,Y")
                 sage: G = PermutationGroup([[(1,2),(3,4)], [(5,6)]])
                 sage: A = M(G, {0: [5,6], 1: [1,2,3,4]}); A
-                E_2(X)*{((1,2)(3,4),): ({}, {1, 2, 3, 4})}
+                E_2(X)*E_2(Y^2)
                 sage: A.permutation_group()
                 (Permutation Group with generators [(3,4)(5,6), (1,2)],
                  (frozenset({1, 2}), frozenset({3, 4, 5, 6})))
@@ -1278,7 +1279,7 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
                 sage: G = PermutationGroup([[(1,2),(3,4)], [(5,6)]])
                 sage: A = M(G, {0: [5,6], 1: [1,2,3,4]})
                 sage: A * B
-                E_2(X)*C_3(X)*{((1,2)(3,4),): ({}, {1, 2, 3, 4})}
+                E_2(X)*C_3(X)*E_2(Y^2)
                 sage: (A*B).permutation_group()
                 (Permutation Group with generators [(6,7)(8,9), (3,4,5), (1,2)],
                  (frozenset({1, 2, 3, 4, 5}), frozenset({6, 7, 8, 9})))
@@ -1443,7 +1444,7 @@ class MolecularSpecies(IndexedFreeAbelianMonoid):
                 sage: X(E2)
                 E_2
                 sage: E2(E2)
-                P_4
+                E_2(E_2)
 
                 sage: M = MolecularSpecies(["X","Y"])
                 sage: X = M(SymmetricGroup(1), {0: [1]})
@@ -1641,22 +1642,22 @@ class PolynomialSpeciesElement(CombinatorialFreeModule.Element):
             sage: P = PolynomialSpecies(QQ, "X")
             sage: sortkey = lambda x: (len(x[1]), sum(x[1].coefficients()), str(x[0]))
             sage: n=4; table(sorted([(m, P.monomial(m).tilde()) for m in M.subset(n)], key=sortkey))
-            X^4               X^4
-            X^2*E_2           2*X^2*E_2
-            {((1,2)(3,4),)}   2*{((1,2)(3,4),)}
-            X*C_3             3*X*C_3
-            C_4               4*C_4
-            E_2^2             4*E_2^2
-            Pb_4              4*Pb_4
-            X*E_3             X*E_3 + X^2*E_2 + X*C_3
-            Eo_4              Eo_4 + 2*X*C_3 + Pb_4
-            P_4               2*P_4 + E_2^2 + Pb_4 + C_4
-            E_4               E_4 + E_2^2 + X*C_3 + P_4 + C_4
+            X^4        X^4
+            E_2(X^2)   2*E_2(X^2)
+            X^2*E_2    2*X^2*E_2
+            X*C_3      3*X*C_3
+            C_4        4*C_4
+            E_2^2      4*E_2^2
+            Pb_4       4*Pb_4
+            X*E_3      X*E_3 + X^2*E_2 + X*C_3
+            Eo_4       Eo_4 + 2*X*C_3 + Pb_4
+            E_2(E_2)   2*E_2(E_2) + E_2^2 + Pb_4 + C_4
+            E_4        E_4 + E_2^2 + X*C_3 + E_2(E_2) + C_4
 
             sage: P.<X,Y> = PolynomialSpecies(QQ)
             sage: E2 = PolynomialSpecies(QQ, "X")(SymmetricGroup(2))
             sage: E2(X*Y).tilde()
-            2*E_2(XY)
+            2*E_2(X*Y)
         """
         P = self.parent()
         M = P._indices
@@ -1780,7 +1781,7 @@ class PolynomialSpeciesElement(CombinatorialFreeModule.Element):
             sage: P = PolynomialSpecies(ZZ, "X")
             sage: C4 = P(CyclicPermutationGroup(4))
             sage: C4._compose_with_singletons("X, Y", [[2, 2]])
-            E_2(XY) + X^2*Y^2
+            E_2(X*Y) + X^2*Y^2
 
             sage: P = PolynomialSpecies(ZZ, ["X", "Y"])
             sage: F = P(PermutationGroup([[(1,2,3), (4,5,6)]]), {0: [1,2,3], 1: [4,5,6]})
@@ -1868,12 +1869,12 @@ class PolynomialSpeciesElement(CombinatorialFreeModule.Element):
 
             sage: C4 = P(CyclicPermutationGroup(4))
             sage: C4._compose_with_weighted_singletons(["X"], [-1], [[4]])
-            -C_4 + {((1,2)(3,4),)}
+            -C_4 + E_2(X^2)
 
         Exercise (2.5.17) in [BLL1998]_::
 
             sage: C4._compose_with_weighted_singletons(["X", "Y"], [1, 1], [[2, 2]])
-            E_2(XY) + X^2*Y^2
+            E_2(X*Y) + X^2*Y^2
             sage: C4._compose_with_weighted_singletons(["X", "Y"], [1, 1], [[3, 1]])
             X^3*Y
             sage: C4._compose_with_weighted_singletons(["X", "Y"], [1, 1], [[4, 0]])
@@ -1882,7 +1883,7 @@ class PolynomialSpeciesElement(CombinatorialFreeModule.Element):
         Equation (4.60) in [ALL2002]_::
 
             sage: C4._compose_with_weighted_singletons(["X", "Y"], [1, -1], [[2, 2]])
-            -E_2(XY) + 2*X^2*Y^2
+            -E_2(X*Y) + 2*X^2*Y^2
 
         A bivariate example::
 
@@ -1898,7 +1899,7 @@ class PolynomialSpeciesElement(CombinatorialFreeModule.Element):
         TESTS::
 
             sage: (C4+E2^2)._compose_with_weighted_singletons(["X"], [-1], [[4]])
-            -C_4 + E_2^2 + {((1,2)(3,4),)} - 2*X^2*E_2 + X^4
+            -C_4 + E_2^2 + E_2(X^2) - 2*X^2*E_2 + X^4
 
             sage: C4._compose_with_weighted_singletons(["X"], [-1, 0], [[4]])
             Traceback (most recent call last):
@@ -1971,10 +1972,10 @@ class PolynomialSpeciesElement(CombinatorialFreeModule.Element):
             sage: E2(-X)
             -E_2 + X^2
             sage: E2(X^2)
-            {((1,2)(3,4),)}
+            E_2(X^2)
 
             sage: E2(X + X^2)
-            E_2 + X^3 + {((1,2)(3,4),)}
+            E_2 + X^3 + E_2(X^2)
 
             sage: P2 = PolynomialSpecies(QQ, ["X", "Y"])
             sage: X = P2(SymmetricGroup(1), {0: [1]})
@@ -1983,7 +1984,7 @@ class PolynomialSpeciesElement(CombinatorialFreeModule.Element):
             E_2(X) + X*Y + E_2(Y)
 
             sage: E2(X*Y)(E2(X), E2(Y))
-            {((7,8), (5,6), (3,4), (1,2), (1,3)(2,4)(5,7)(6,8)): ({1, 2, 3, 4}, {5, 6, 7, 8})}
+            E_2(E_2(X)*E_2(Y))
 
             sage: R.<q> = QQ[]
             sage: P = PolynomialSpecies(R, ["X"])
@@ -2192,13 +2193,13 @@ class PolynomialSpecies(CombinatorialFreeModule):
             sage: X = SetPartitions(4, 2)
             sage: a = lambda g, x: SetPartition([[g(e) for e in b] for b in x])
             sage: P((X, a, 'left'), {0: [1,2], 1: [3,4]})
-            E_2(X)*E_2(Y) + X^2*E_2(Y) + E_2(XY) + Y^2*E_2(X)
+            E_2(X)*E_2(Y) + X^2*E_2(Y) + E_2(X*Y) + Y^2*E_2(X)
 
             sage: P = PolynomialSpecies(ZZ, ["X"])
             sage: X = SetPartitions(4, 2)
             sage: a = lambda g, x: SetPartition([[g(e) for e in b] for b in x])
             sage: P((X, a, 'left'), {0: [1,2,3,4]})
-            X*E_3 + P_4
+            X*E_3 + E_2(E_2)
 
         The species of permutation groups::
 
@@ -2210,7 +2211,7 @@ class PolynomialSpecies(CombinatorialFreeModule):
             ....:     H = S.subgroup(G.conjugate(pi).gens())
             ....:     return next(K for K in X if K == H)
             sage: P((X, act), {0: range(1, n+1)}, check=False)
-            4*E_4 + 4*P_4 + E_2^2 + 2*X*E_3
+            4*E_4 + 4*E_2(E_2) + E_2^2 + 2*X*E_3
 
         Create a multisort species given an action::
 
@@ -2285,7 +2286,7 @@ class PolynomialSpecies(CombinatorialFreeModule):
                     return self._from_dict({self._indices(G, check=check): ZZ.one()})
                 raise ValueError("the assignment of sorts to the domain elements must be provided")
             elif not isinstance(pi, dict):
-                pi = {i: v for i, v in enumerate(pi)}
+                pi = dict(enumerate(pi))
             return self._from_dict({self._indices(G, pi, check=check): ZZ.one()})
 
         raise ValueError(f"{G} must be an element of the base ring, a permutation group or a pair (X, a) specifying a group action of the symmetric group on pi={pi}")
@@ -2509,3 +2510,58 @@ class PolynomialSpecies(CombinatorialFreeModule):
                          for s in range(self._arity))
 
     Element = PolynomialSpeciesElement
+
+
+@cached_function
+def _atomic_set_like_species(n, names):
+    r"""
+    Return a list of the atomic set like species of degree `n`,
+    and provide their traditional names.
+
+    INPUT:
+
+    - ``n`` -- positive integer, the degree
+    - ``names`` -- an iterable of strings for the sorts of the species
+
+    EXAMPLES::
+
+        sage: from sage.rings.species import _atomic_set_like_species
+        sage: _atomic_set_like_species(6, "X")
+        (E_2(E_3), E_2(X*E_2), E_2(X^3), E_3(E_2), E_3(X^2), E_6)
+
+        sage: l = [len(_atomic_set_like_species(n, "X")) for n in range(12)]
+        sage: l
+        [0, 1, 1, 1, 3, 1, 6, 1, 10, 4, 12, 1]
+        sage: oeis(l)                                                           # optional - internet
+        0: A007650: Number of set-like atomic species of degree n.
+
+        sage: _atomic_set_like_species(4, "U, V")
+        (E_2(E_2(V)), E_2(E_2(U)), E_2(V^2), E_2(U*V), E_2(U^2), E_4(U), E_4(V))
+    """
+    if not n:
+        return ()
+    M1 = MolecularSpecies("X")
+    M = MolecularSpecies(names)
+    if n == 1:
+        return tuple([M(SymmetricGroup(1), {s: [1]}) for s in range(M._arity)])
+    result = []
+    for d in divisors(n):
+        if d == 1:
+            continue
+        if d == n:
+            result.extend(M(SymmetricGroup(n), {s: range(1, n+1)})
+                          for s in range(M._arity))
+            continue
+        E_d = M1(SymmetricGroup(d))
+        l = []
+        w = []
+        for degree in range(1, n // d + 1):
+            a_degree = _atomic_set_like_species(degree, names)
+            l.extend(a_degree)
+            w.extend([degree]*len(a_degree))
+        for a in WeightedIntegerVectors(n // d, w):
+            G = prod(F ** e for F, e in zip(l, a))
+            F = E_d(G)
+            F.support()[0].rename(f"E_{d}({G})")
+            result.append(F)
+    return tuple(result)