passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/combinat/species/library.py

@@ -0,0 +1,148 @@
+# sage_setup: distribution = sagemath-combinat
+"""
+Examples of combinatorial species
+"""
+# ****************************************************************************
+#       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>,
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from .set_species import SetSpecies
+from .partition_species import PartitionSpecies
+from .subset_species import SubsetSpecies
+from .recursive_species import CombinatorialSpecies
+from .characteristic_species import CharacteristicSpecies, SingletonSpecies, EmptySetSpecies
+from .cycle_species import CycleSpecies
+from .linear_order_species import LinearOrderSpecies
+from .permutation_species import PermutationSpecies
+from .empty_species import EmptySpecies
+from .sum_species import SumSpecies
+from .product_species import ProductSpecies
+from .composition_species import CompositionSpecies
+from .functorial_composition_species import FunctorialCompositionSpecies
+
+from sage.misc.cachefunc import cached_function
+
+
+@cached_function
+def SimpleGraphSpecies():
+    """
+    Return the species of simple graphs.
+
+    EXAMPLES::
+
+        sage: S = species.SimpleGraphSpecies()
+        sage: S.generating_series().counts(10)
+        [1, 1, 2, 8, 64, 1024, 32768, 2097152, 268435456, 68719476736]
+        sage: S.cycle_index_series()[:5]                                                # needs sage.libs.pari sage.modules
+        [p[],
+         p[1],
+         p[1, 1] + p[2],
+         4/3*p[1, 1, 1] + 2*p[2, 1] + 2/3*p[3],
+         8/3*p[1, 1, 1, 1] + 4*p[2, 1, 1] + 2*p[2, 2] + 4/3*p[3, 1] + p[4]]
+        sage: S.isotype_generating_series()[:6]                                         # needs sage.libs.pari sage.modules
+        [1, 1, 2, 4, 11, 34]
+
+    TESTS::
+
+        sage: seq = S.isotype_generating_series().counts(6)[1:]                         # needs sage.modules
+        sage: oeis(seq)[0]                              # optional - internet           # needs sage.modules
+        A000088: ...
+
+    ::
+
+        sage: seq = S.generating_series().counts(10)[1:]                                # needs sage.modules
+        sage: oeis(seq)[0]                              # optional - internet           # needs sage.modules
+        A006125: a(n) = 2^(n*(n-1)/2).
+    """
+    E = SetSpecies()
+    E2 = SetSpecies(size=2)
+    WP = SubsetSpecies()
+    P2 = E2 * E
+    return WP.functorial_composition(P2)
+
+
+@cached_function
+def BinaryTreeSpecies():
+    r"""
+    Return the species of binary trees on `n` leaves.
+
+    The species of binary trees `B` is defined by `B = X + B \cdot B`,
+    where `X` is the singleton species.
+
+    EXAMPLES::
+
+        sage: B = species.BinaryTreeSpecies()
+        sage: B.generating_series().counts(10)
+        [0, 1, 2, 12, 120, 1680, 30240, 665280, 17297280, 518918400]
+        sage: B.isotype_generating_series().counts(10)
+        [0, 1, 1, 2, 5, 14, 42, 132, 429, 1430]
+        sage: B._check()
+        True
+
+    ::
+
+        sage: B = species.BinaryTreeSpecies()
+        sage: a = B.structures([1,2,3,4,5])[187]; a
+        2*((5*3)*(4*1))
+        sage: a.automorphism_group()                                                    # needs sage.groups
+        Permutation Group with generators [()]
+
+    TESTS::
+
+        sage: seq = B.isotype_generating_series().counts(10)[1:]
+        sage: oeis(seq)[0]                              # optional -- internet
+        A000108: Catalan numbers: ...
+    """
+    B = CombinatorialSpecies(min=1)
+    X = SingletonSpecies()
+    B.define(X + B * B)
+    return B
+
+
+@cached_function
+def BinaryForestSpecies():
+    """
+    Return the species of binary forests.
+
+    Binary forests are defined as sets of binary trees.
+
+    EXAMPLES::
+
+        sage: F = species.BinaryForestSpecies()
+        sage: F.generating_series().counts(10)
+        [1, 1, 3, 19, 193, 2721, 49171, 1084483, 28245729, 848456353]
+        sage: F.isotype_generating_series().counts(10)                                  # needs sage.modules
+        [1, 1, 2, 4, 10, 26, 77, 235, 758, 2504]
+        sage: F.cycle_index_series()[:7]                                                # needs sage.modules
+        [p[],
+         p[1],
+         3/2*p[1, 1] + 1/2*p[2],
+         19/6*p[1, 1, 1] + 1/2*p[2, 1] + 1/3*p[3],
+         193/24*p[1, 1, 1, 1] + 3/4*p[2, 1, 1] + 5/8*p[2, 2] + 1/3*p[3, 1] + 1/4*p[4],
+         907/40*p[1, 1, 1, 1, 1] + 19/12*p[2, 1, 1, 1] + 5/8*p[2, 2, 1] + 1/2*p[3, 1, 1] + 1/6*p[3, 2] + 1/4*p[4, 1] + 1/5*p[5],
+         49171/720*p[1, 1, 1, 1, 1, 1] + 193/48*p[2, 1, 1, 1, 1] + 15/16*p[2, 2, 1, 1] + 61/48*p[2, 2, 2] + 19/18*p[3, 1, 1, 1] + 1/6*p[3, 2, 1] + 7/18*p[3, 3] + 3/8*p[4, 1, 1] + 1/8*p[4, 2] + 1/5*p[5, 1] + 1/6*p[6]]
+
+    TESTS::
+
+        sage: seq = F.isotype_generating_series().counts(10)[1:]                        # needs sage.modules
+        sage: oeis(seq)[0]                              # optional - internet           # needs sage.modules
+        A052854: Number of forests of ordered trees on n total nodes.
+    """
+    B = BinaryTreeSpecies()
+    S = SetSpecies()
+    F = S(B)
+    return F
+
+
+del cached_function  # so it doesn't get picked up by tab completion

sage/combinat/species/linear_order_species.py

@@ -0,0 +1,169 @@
+# sage_setup: distribution = sagemath-combinat
+"""
+Linear-order species
+"""
+# ****************************************************************************
+#       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>,
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+# ****************************************************************************
+from .species import GenericCombinatorialSpecies
+from .structure import GenericSpeciesStructure
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.combinat.species.misc import accept_size
+
+
+class LinearOrderSpeciesStructure(GenericSpeciesStructure):
+    def canonical_label(self):
+        """
+        EXAMPLES::
+
+            sage: P = species.LinearOrderSpecies()
+            sage: s = P.structures(["a", "b", "c"]).random_element()
+            sage: s.canonical_label()
+            ['a', 'b', 'c']
+        """
+        return self.__class__(self.parent(), self._labels, range(1, len(self._labels)+1))
+
+    def transport(self, perm):
+        """
+        Return the transport of this structure along the permutation
+        perm.
+
+        EXAMPLES::
+
+            sage: F = species.LinearOrderSpecies()
+            sage: a = F.structures(["a", "b", "c"])[0]; a
+            ['a', 'b', 'c']
+            sage: p = PermutationGroupElement((1,2))                                    # needs sage.groups
+            sage: a.transport(p)                                                        # needs sage.groups
+            ['b', 'a', 'c']
+        """
+        return LinearOrderSpeciesStructure(self.parent(), self._labels, [perm(i) for i in self._list])
+
+    def automorphism_group(self):
+        """
+        Return the group of permutations whose action on this structure
+        leave it fixed. For the species of linear orders, there is no
+        non-trivial automorphism.
+
+        EXAMPLES::
+
+            sage: F = species.LinearOrderSpecies()
+            sage: a = F.structures(["a", "b", "c"])[0]; a
+            ['a', 'b', 'c']
+            sage: a.automorphism_group()                                                # needs sage.groups
+            Symmetric group of order 1! as a permutation group
+        """
+        from sage.groups.perm_gps.permgroup_named import SymmetricGroup
+        return SymmetricGroup(1)
+
+
+class LinearOrderSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
+    @staticmethod
+    @accept_size
+    def __classcall__(cls, *args, **kwds):
+        r"""
+        EXAMPLES::
+
+            sage: L = species.LinearOrderSpecies(); L
+            Linear order species
+        """
+        return super().__classcall__(cls, *args, **kwds)
+
+    def __init__(self, min=None, max=None, weight=None):
+        """
+        Return the species of linear orders.
+
+        EXAMPLES::
+
+            sage: L = species.LinearOrderSpecies()
+            sage: L.generating_series()[0:5]
+            [1, 1, 1, 1, 1]
+
+            sage: L = species.LinearOrderSpecies()
+            sage: L._check()
+            True
+            sage: L == loads(dumps(L))
+            True
+        """
+        GenericCombinatorialSpecies.__init__(self, min=min, max=max, weight=None)
+        self._name = "Linear order species"
+
+    _default_structure_class = LinearOrderSpeciesStructure
+
+    def _structures(self, structure_class, labels):
+        """
+        EXAMPLES::
+
+            sage: L = species.LinearOrderSpecies()
+            sage: L.structures([1,2,3]).list()
+            [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
+        """
+        from sage.combinat.permutation import Permutations
+        for p in Permutations(len(labels)):
+            yield structure_class(self, labels, p._list)
+
+    def _isotypes(self, structure_class, labels):
+        """
+        EXAMPLES::
+
+            sage: L = species.LinearOrderSpecies()
+            sage: L.isotypes([1,2,3]).list()
+            [[1, 2, 3]]
+        """
+        yield structure_class(self, labels, range(1, len(labels)+1))
+
+    def _gs_list(self, base_ring, n):
+        r"""
+        The generating series for the species of linear orders is
+        `\frac{1}{1-x}`.
+
+        EXAMPLES::
+
+            sage: L = species.LinearOrderSpecies()
+            sage: g = L.generating_series()
+            sage: g[0:10]
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+        """
+        return base_ring.one()
+
+    def _itgs_list(self, base_ring, n):
+        r"""
+        The isomorphism type generating series is given by
+        `\frac{1}{1-x}`.
+
+        EXAMPLES::
+
+            sage: L = species.LinearOrderSpecies()
+            sage: g = L.isotype_generating_series()
+            sage: g[0:10]
+            [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+        """
+        return base_ring.one()
+
+    def _cis_callable(self, base_ring, n):
+        """
+        EXAMPLES::
+
+            sage: L = species.LinearOrderSpecies()
+            sage: g = L.cycle_index_series()                                            # needs sage.modules
+            sage: g[0:5]                                                                # needs sage.modules
+            [p[], p[1], p[1, 1], p[1, 1, 1], p[1, 1, 1, 1]]
+        """
+        from sage.combinat.sf.sf import SymmetricFunctions
+        p = SymmetricFunctions(base_ring).power()
+        return p([1]*n)
+
+
+#Backward compatibility
+LinearOrderSpecies_class = LinearOrderSpecies

sage/combinat/species/misc.py

@@ -0,0 +1,83 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.groups
+"""
+Miscellaneous functions
+"""
+# ****************************************************************************
+#       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>,
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+# ****************************************************************************
+
+from functools import wraps
+
+from sage.misc.misc_c import prod
+from sage.misc.lazy_import import lazy_import
+
+lazy_import('sage.groups.perm_gps.permgroup', ['PermutationGroup', 'PermutationGroup_generic'])
+lazy_import('sage.groups.perm_gps.constructor', 'PermutationGroupElement')
+lazy_import('sage.groups.perm_gps.permgroup_named', 'SymmetricGroup')
+
+
+def change_support(perm, support, change_perm=None):
+    """
+    Changes the support of a permutation defined on [1, ..., n] to
+    support.
+
+    EXAMPLES::
+
+        sage: from sage.combinat.species.misc import change_support
+        sage: p = PermutationGroupElement((1,2,3)); p
+        (1,2,3)
+        sage: change_support(p, [3,4,5])
+        (3,4,5)
+    """
+    if change_perm is None:
+        change_perm = prod([PermutationGroupElement((i+1, support[i]))
+                            for i in range(len(support))
+                            if i+1 != support[i]],
+                           PermutationGroupElement([], SymmetricGroup(support)))
+
+    if isinstance(perm, PermutationGroup_generic):
+        return PermutationGroup([change_support(g, support, change_perm) for g in perm.gens()])
+
+    return change_perm*perm*~change_perm
+
+
+def accept_size(f):
+    """
+    The purpose of this decorator is to change calls like
+    species.SetSpecies(size=1) to species.SetSpecies(min=1, max=2).
+    This is to make caching species easier and to restrict the number
+    of parameters that the lower level code needs to know about.
+
+    EXAMPLES::
+
+        sage: from sage.combinat.species.misc import accept_size
+        sage: def f(*args, **kwds):
+        ....:       print("{} {}".format(args, sorted(kwds.items())))
+        sage: f = accept_size(f)
+        sage: f(min=1)
+        () [('min', 1)]
+        sage: f(size=2)
+        () [('max', 3), ('min', 2)]
+    """
+    @wraps(f)
+    def new_func(*args, **kwds):
+        if 'size' in kwds:
+            if 'min' in kwds or 'max' in kwds:
+                raise ValueError("cannot specify both size and (min or max)")
+            kwds['min'] = kwds['size']
+            kwds['max'] = kwds['size'] + 1
+            del kwds['size']
+        return f(*args, **kwds)
+    return new_func

sage/combinat/species/partition_species.py

@@ -0,0 +1,290 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.libs.flint
+"""
+Partition species
+"""
+# ****************************************************************************
+#       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>,
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+# ****************************************************************************
+
+from .species import GenericCombinatorialSpecies
+from sage.arith.misc import factorial
+from .subset_species import SubsetSpeciesStructure
+from .set_species import SetSpecies
+from .structure import GenericSpeciesStructure
+from sage.combinat.species.misc import accept_size
+from functools import reduce
+
+
+class PartitionSpeciesStructure(GenericSpeciesStructure):
+    def __init__(self, parent, labels, list):
+        """
+        EXAMPLES::
+
+            sage: from sage.combinat.species.partition_species import PartitionSpeciesStructure
+            sage: P = species.PartitionSpecies()
+            sage: s = PartitionSpeciesStructure(P, ['a','b','c'], [[1,2],[3]]); s
+            {{'a', 'b'}, {'c'}}
+            sage: s == loads(dumps(s))
+            True
+        """
+        list = [SubsetSpeciesStructure(parent, labels, block) if not isinstance(block, SubsetSpeciesStructure) else block for block in list]
+        list.sort(key=lambda block:(-len(block), block))
+        GenericSpeciesStructure.__init__(self, parent, labels, list)
+
+    def __repr__(self):
+        """
+        EXAMPLES::
+
+            sage: S = species.PartitionSpecies()
+            sage: a = S.structures(["a","b","c"])[0]; a
+            {{'a', 'b', 'c'}}
+        """
+        s = GenericSpeciesStructure.__repr__(self)
+        return "{"+s[1:-1]+"}"
+
+    def canonical_label(self):
+        """
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: S = P.structures(["a", "b", "c"])
+            sage: [s.canonical_label() for s in S]
+            [{{'a', 'b', 'c'}},
+             {{'a', 'b'}, {'c'}},
+             {{'a', 'b'}, {'c'}},
+             {{'a', 'b'}, {'c'}},
+             {{'a'}, {'b'}, {'c'}}]
+        """
+        P = self.parent()
+        p = [len(block) for block in self._list]
+        return P._canonical_rep_from_partition(self.__class__, self._labels, p)
+
+    def transport(self, perm):
+        """
+        Return the transport of this set partition along the permutation
+        perm. For set partitions, this is the direct product of the
+        automorphism groups for each of the blocks.
+
+        EXAMPLES::
+
+            sage: p = PermutationGroupElement((2,3))
+            sage: from sage.combinat.species.partition_species import PartitionSpeciesStructure
+            sage: a = PartitionSpeciesStructure(None, [2,3,4], [[1,2],[3]]); a
+            {{2, 3}, {4}}
+            sage: a.transport(p)
+            {{2, 4}, {3}}
+        """
+        l = [block.transport(perm)._list for block in self._list]
+        l.sort(key=lambda block:(-len(block), block))
+        return PartitionSpeciesStructure(self.parent(), self._labels, l)
+
+    def automorphism_group(self):
+        """
+        Return the group of permutations whose action on this set
+        partition leave it fixed.
+
+        EXAMPLES::
+
+            sage: p = PermutationGroupElement((2,3))
+            sage: from sage.combinat.species.partition_species import PartitionSpeciesStructure
+            sage: a = PartitionSpeciesStructure(None, [2,3,4], [[1,2],[3]]); a
+            {{2, 3}, {4}}
+            sage: a.automorphism_group()
+            Permutation Group with generators [(1,2)]
+        """
+        from sage.groups.perm_gps.permgroup_named import SymmetricGroup
+        return reduce(lambda a,b: a.direct_product(b, maps=False),
+                      [SymmetricGroup(block._list) for block in self._list])
+
+    def change_labels(self, labels):
+        """
+        Return a relabelled structure.
+
+        INPUT:
+
+        - ``labels`` -- list of labels
+
+        OUTPUT:
+
+        A structure with the `i`-th label of ``self`` replaced with the `i`-th
+        label of the list.
+
+        EXAMPLES::
+
+            sage: p = PermutationGroupElement((2,3))
+            sage: from sage.combinat.species.partition_species import PartitionSpeciesStructure
+            sage: a = PartitionSpeciesStructure(None, [2,3,4], [[1,2],[3]]); a
+            {{2, 3}, {4}}
+            sage: a.change_labels([1,2,3])
+            {{1, 2}, {3}}
+        """
+        return PartitionSpeciesStructure(self.parent(), labels, [block.change_labels(labels) for block in self._list])
+
+
+class PartitionSpecies(GenericCombinatorialSpecies):
+    @staticmethod
+    @accept_size
+    def __classcall__(cls, *args, **kwds):
+        """
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies(); P
+            Partition species
+        """
+        return super().__classcall__(cls, *args, **kwds)
+
+    def __init__(self, min=None, max=None, weight=None):
+        """
+        Return the species of partitions.
+
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: P.generating_series()[0:5]
+            [1, 1, 1, 5/6, 5/8]
+            sage: P.isotype_generating_series()[0:5]
+            [1, 1, 2, 3, 5]
+
+            sage: P = species.PartitionSpecies()
+            sage: P._check()
+            True
+            sage: P == loads(dumps(P))
+            True
+        """
+        GenericCombinatorialSpecies.__init__(self, min=min, max=max, weight=weight)
+        self._name = "Partition species"
+
+    _default_structure_class = PartitionSpeciesStructure
+
+    def _structures(self, structure_class, labels):
+        """
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: P.structures([1,2,3]).list()
+            [{{1, 2, 3}}, {{1, 3}, {2}}, {{1, 2}, {3}}, {{2, 3}, {1}}, {{1}, {2}, {3}}]
+        """
+        from sage.combinat.restricted_growth import RestrictedGrowthArrays
+        n = len(labels)
+
+        if n == 0:
+            yield structure_class(self, labels, [])
+            return
+
+        u = list(range(n, 0, -1))
+        s0 = u.pop()
+
+        # Reconstruct the set partitions from
+        # restricted growth arrays
+        for a in RestrictedGrowthArrays(n):
+            m = a.pop(0)
+            r = [[] for _ in range(m)]
+            i = n
+            for i, z in enumerate(u):
+                r[a[i]].append(z)
+            r[0].append(s0)
+
+            for sp in r:
+                sp.reverse()
+
+            r.sort(key=len, reverse=True)
+
+            yield structure_class(self, labels, r)
+
+    def _isotypes(self, structure_class, labels):
+        """
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: P.isotypes([1,2,3,4]).list()
+            [{{1, 2, 3, 4}},
+             {{1, 2, 3}, {4}},
+             {{1, 2}, {3, 4}},
+             {{1, 2}, {3}, {4}},
+             {{1}, {2}, {3}, {4}}]
+        """
+        from sage.combinat.partition import Partitions
+        for p in Partitions(len(labels)):
+            yield self._canonical_rep_from_partition(structure_class, labels, p)
+
+    def _canonical_rep_from_partition(self, structure_class, labels, p):
+        """
+        Return the canonical representative corresponding to the partition
+        p.
+
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: P._canonical_rep_from_partition(P._default_structure_class,[1,2,3],[2,1])
+            {{1, 2}, {3}}
+        """
+        breaks = [sum(p[:i]) for i in range(len(p) + 1)]
+        return structure_class(self, labels, [list(range(breaks[i]+1, breaks[i+1]+1)) for i in range(len(p))])
+
+    def _gs_callable(self, base_ring, n):
+        r"""
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: g = P.generating_series()
+            sage: [g.coefficient(i) for i in range(5)]
+            [1, 1, 1, 5/6, 5/8]
+        """
+        from sage.combinat.combinat import bell_number
+        return self._weight * base_ring(bell_number(n) / factorial(n))
+
+    def _itgs_callable(self, base_ring, n):
+        r"""
+        The isomorphism type generating series is given by
+        `\frac{1}{1-x}`.
+
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: g = P.isotype_generating_series()
+            sage: [g.coefficient(i) for i in range(10)]
+            [1, 1, 2, 3, 5, 7, 11, 15, 22, 30]
+        """
+        from sage.combinat.partition import number_of_partitions
+        return self._weight*base_ring(number_of_partitions(n))
+
+    def _cis(self, series_ring, base_ring):
+        r"""
+        The cycle index series for the species of partitions is given by.
+
+        .. MATH::
+
+             exp \sum_{n \ge 1} \frac{1}{n} \left( exp \left( \sum_{k \ge 1} \frac{x_{kn}}{k} \right) -1 \right).
+
+        EXAMPLES::
+
+            sage: P = species.PartitionSpecies()
+            sage: g = P.cycle_index_series()                                            # needs sage.modules
+            sage: g[0:5]                                                                # needs sage.modules
+            [p[],
+             p[1],
+             p[1, 1] + p[2],
+             5/6*p[1, 1, 1] + 3/2*p[2, 1] + 2/3*p[3],
+             5/8*p[1, 1, 1, 1] + 7/4*p[2, 1, 1] + 7/8*p[2, 2] + p[3, 1] + 3/4*p[4]]
+        """
+        ciset = SetSpecies().cycle_index_series(base_ring)
+        res = ciset(ciset - 1)
+        if self.is_weighted():
+            res *= self._weight
+        return res
+
+
+#Backward compatibility
+PartitionSpecies_class = PartitionSpecies