Coverage for local/lib/python2.7/site-packages/sage/combinat/species/generating

Z_{F} \Box Z_{G} = \sum_{n \geq 0} \frac{1}{n!} \sum_{\sigma \in \mathfrak{S}_{n}} \operatorname{fix} F[ (G[\sigma])_{1}, (G[\sigma])_{2}, \dots ] \, p_{1}^{\sigma_{1}} p_{2}^{\sigma_{2}} \dots.

This method implements that operation on cycle index series.

EXAMPLES:

The species `G` of simple graphs can be expressed in terms of a functorial

composition: `G = \mathfrak{p} \Box \mathfrak{p}_{2}`, where

`\mathfrak{p}` is the :class:`~sage.combinat.species.subset_species.SubsetSpecies`.

This is how it is implemented in :meth:`~sage.combinat.species.library.SimpleGraphSpecies`::

sage: S = species.SimpleGraphSpecies()

sage: S.cycle_index_series().coefficients(5)

[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]]

"""

return self._new(partial(self._functorial_compose_gen, g), lambda a,b: 0, self, g)

def _functorial_compose_gen(self, g, ao):

"""

Return a generator for the coefficients of the functorial

composition of ``self`` with ``g``.

EXAMPLES::

sage: E = species.SetSpecies()

sage: E2 = species.SetSpecies(size=2)

sage: WP = species.SubsetSpecies()

sage: P2 = E2*E

sage: P2_cis = P2.cycle_index_series()

sage: WP_cis = WP.cycle_index_series()

sage: g = WP_cis._functorial_compose_gen(P2_cis,0)

sage: [next(g) for i in range(5)]

[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]]

"""

p = self.parent().base_ring()

n = 0

while True:

res = p(0)

for s in Partitions(n):

t = g._cycle_type(s)

q = self.count(t) / s.aut()

res += q*p(s)

yield res

n += 1

def arithmetic_product(self, g, check_input = True):

"""

Return the arithmetic product of ``self`` with ``g``.

For species `M` and `N` such that `M[\\varnothing] = N[\\varnothing] = \\varnothing`,

their arithmetic product is the species `M \\boxdot N` of "`M`-assemblies of cloned `N`-structures".

This operation is defined and several examples are given in [MM]_.

The cycle index series for `M \\boxdot N` can be computed in terms of the component series `Z_M` and `Z_N`,

as implemented in this method.

INPUT:

- ``g`` -- a cycle index series having the same parent as ``self``.

- ``check_input`` -- (default: ``True``) a Boolean which, when set

to ``False``, will cause input checks to be skipped.

OUTPUT:

The arithmetic product of ``self`` with ``g``. This is a cycle

index series defined in terms of ``self`` and ``g`` such that

if ``self`` and ``g`` are the cycle index series of two species

`M` and `N`, their arithmetic product is the cycle index series

of the species `M \\boxdot N`.

EXAMPLES:

For `C` the species of (oriented) cycles and `L_{+}` the species of nonempty linear orders, `C \\boxdot L_{+}` corresponds

to the species of "regular octopuses"; a `(C \\boxdot L_{+})`-structure is a cycle of some length, each of whose elements

is an ordered list of a length which is consistent for all the lists in the structure. ::

sage: C = species.CycleSpecies().cycle_index_series()

sage: Lplus = species.LinearOrderSpecies(min=1).cycle_index_series()

sage: RegularOctopuses = C.arithmetic_product(Lplus)

sage: RegOctSpeciesSeq = RegularOctopuses.generating_series().counts(8)

sage: RegOctSpeciesSeq

[0, 1, 3, 8, 42, 144, 1440, 5760]

It is shown in [MM]_ that the exponential generating function for regular octopuses satisfies

`(C \\boxdot L_{+}) (x) = \\sum_{n \geq 1} \\sigma (n) (n - 1)! \\frac{x^{n}}{n!}` (where `\\sigma (n)` is

the sum of the divisors of `n`). ::

sage: RegOctDirectSeq = [0] + [sum(divisors(i))*factorial(i-1) for i in range(1,8)]

sage: RegOctDirectSeq == RegOctSpeciesSeq

True

AUTHORS:

- Andrew Gainer-Dewar (2013)

REFERENCES:

.. [MM] \M. Maia and M. Mendez. "On the arithmetic product of combinatorial species".

Discrete Mathematics, vol. 308, issue 23, 2008, pp. 5407-5427.

:arXiv:`math/0503436v2`.

"""

from itertools import product, repeat, chain

p = self.base_ring()

if check_input:

assert self.coefficient(0) == p.zero()

assert g.coefficient(0) == p.zero()

# We first define an operation `\\boxtimes` on partitions as in Lemma 2.1 of [MM]_.

def arith_prod_of_partitions(l1, l2):

# Given two partitions `l_1` and `l_2`, we construct a new partition `l_1 \\boxtimes l_2` by

# the following procedure: each pair of parts `a \\in l_1` and `b \\in l_2` contributes

# `\\gcd (a, b)`` parts of size `\\lcm (a, b)` to `l_1 \\boxtimes l_2`. If `l_1` and `l_2`

# are partitions of integers `n` and `m`, respectively, then `l_1 \\boxtimes l_2` is a

# partition of `nm`.

term_iterable = chain.from_iterable(repeat(lcm(pair), gcd(pair))

for pair in product(l1, l2))

return Partition(sorted(term_iterable, reverse=True))

# We then extend this to an operation on symmetric functions as per eq. (52) of [MM]_.

# (Maia and Mendez, in [MM]_, are talking about polynomials instead of symmetric

# functions, but this boils down to the same: Their x_i corresponds to the i-th power

# sum symmetric function.)

def arith_prod_sf(x, y):

ap_sf_wrapper = lambda l1, l2: p(arith_prod_of_partitions(l1, l2))

return p._apply_multi_module_morphism(x, y, ap_sf_wrapper)

# Sage stores cycle index series by degree.

# Thus, to compute the arithmetic product `Z_M \\boxdot Z_N` it is useful

# to compute all terms of a given degree `n` at once.

def arith_prod_coeff(n):

if n == 0:

res = p.zero()

else:

index_set = ((d, n // d) for d in divisors(n))

res = sum(arith_prod_sf(self.coefficient(i), g.coefficient(j)) for i,j in index_set)

# Build a list which has res in the `n`th slot and 0's before and after

# to feed to sum_generator

res_in_seq = [p.zero()]*n + [res, p.zero()]

return self.parent(res_in_seq)

# Finally, we use the sum_generator method to assemble these results into a single

# LazyPowerSeries object.

return self.parent().sum_generator(arith_prod_coeff(n) for n in _integers_from(0))

def _cycle_type(self, s):

"""

EXAMPLES::

sage: cis = species.PartitionSpecies().cycle_index_series()

sage: [cis._cycle_type(p) for p in Partitions(3)]

[[3, 1, 1], [2, 1, 1, 1], [1, 1, 1, 1, 1]]

sage: cis = species.PermutationSpecies().cycle_index_series()

sage: [cis._cycle_type(p) for p in Partitions(3)]

[[3, 1, 1, 1], [2, 2, 1, 1], [1, 1, 1, 1, 1, 1]]

sage: cis = species.SetSpecies().cycle_index_series()

sage: [cis._cycle_type(p) for p in Partitions(3)]

[[1], [1], [1]]

"""

if s == []:

return self._card(0)

res = []

for k in range(1, self._upper_bound_for_longest_cycle(s)+1):

e = 0

for d in divisors(k):

m = moebius(d)

if m == 0:

continue

u = s.power(k/d)

e += m*self.count(u)

res.extend([k]*int(e/k))

res.reverse()

return Partition(res)

def _upper_bound_for_longest_cycle(self, s):

"""

EXAMPLES::

sage: cis = species.PartitionSpecies().cycle_index_series()

sage: cis._upper_bound_for_longest_cycle([4])

sage: cis._upper_bound_for_longest_cycle([3,1])

sage: cis._upper_bound_for_longest_cycle([2,2])

sage: cis._upper_bound_for_longest_cycle([2,1,1])

sage: cis._upper_bound_for_longest_cycle([1,1,1,1])

"""

if s == []:

return 1

return min(self._card(sum(s)), lcm(list(s)))

def _card(self, n):

"""

Returns the number of structures on an underlying set of size n for

the species associated with self. This is just n! times the

coefficient of p[1]n in self.

EXAMPLES::

sage: cis = species.PartitionSpecies().cycle_index_series()

sage: cis._card(4)

"""

p = self.coefficient(n)

return factorial_stream[n]*p.coefficient([1]*n)

def _compose_gen(self, y, ao):

"""

Return a generator for the coefficients of the composition of this

cycle index series and the cycle index series ``y``. This overrides

the method defined in ``LazyPowerSeries``.

The notion "composition" means plethystic substitution here, as

defined in Section 2.2 of [BLL-Intro]_.

EXAMPLES::

sage: E = species.SetSpecies(); C = species.CycleSpecies()

sage: E_cis = E.cycle_index_series()

sage: g = E_cis._compose_gen(C.cycle_index_series(),0)

sage: [next(g) for i in range(4)]

[p[], p[1], p[1, 1] + p[2], p[1, 1, 1] + p[2, 1] + p[3]]

"""

assert y.coefficient(0) == 0

y_powers = Stream(y._power_gen())

parent = self.parent()

res = parent.sum_generator(self._compose_term(self.coefficient(i), y_powers)

for i in _integers_from(0))

for i in _integers_from(0):

yield res.coefficient(i)

def _compose_term(self, p, y_powers):

"""

Returns the composition of one term in self with y.

INPUT:

- ``p`` - a term in self

- ``y_powers`` - a stream for the powers of y

starting with y

EXAMPLES::

sage: from sage.combinat.species.stream import Stream

sage: E = species.SetSpecies(); C = species.CycleSpecies()

sage: E_cis = E.cycle_index_series()

sage: C_cis = C.cycle_index_series()

sage: c_powers = Stream(C_cis._power_gen())

sage: p2 = E_cis.coefficient(2); p2

1/2*p[1, 1] + 1/2*p[2]

sage: E_cis._compose_term(p2, c_powers).coefficients(4)

[0, 0, 1/2*p[1, 1] + 1/2*p[2], 1/2*p[1, 1, 1] + 1/2*p[2, 1]]

"""

parent = self.parent()

if p == 0:

return parent(0)

res = []

#Go through all the partition, coefficient pairs in the term p

for m, c in p:

res_t = parent.term(c, 0)

for e,v in enumerate(m.to_exp()):

if v == 0:

continue

res_t = res_t * y_powers[v-1].stretch(e+1)

res.append(res_t)

return parent.sum(res)

def weighted_composition(self, y_species):

"""

Returns the composition of this cycle index series with the cycle

index series of y_species where y_species is a weighted species.

Note that this is basically the same algorithm as composition

except we can not use the optimization that the powering of cycle

index series commutes with 'stretching'.

EXAMPLES::

sage: E = species.SetSpecies(); C = species.CycleSpecies()

sage: E_cis = E.cycle_index_series()

sage: E_cis.weighted_composition(C).coefficients(4)

[p[], p[1], p[1, 1] + p[2], p[1, 1, 1] + p[2, 1] + p[3]]

sage: E(C).cycle_index_series().coefficients(4)

[p[], p[1], p[1, 1] + p[2], p[1, 1, 1] + p[2, 1] + p[3]]

"""

base_ring = self.base_ring()

y = y_species.cycle_index_series(base_ring)

assert y.coefficient(0) == 0

return self._new(partial(self._weighted_compose_gen, y_species), lambda a,b:a*b, self, y)

def _weighted_compose_gen(self, y_species, ao):

"""

Returns an iterator for the composition of this cycle index series

and the cycle index series of the weighted species y_species.

EXAMPLES::

sage: E = species.SetSpecies(); C = species.CycleSpecies()

sage: E_cis = E.cycle_index_series()

sage: g = E_cis._weighted_compose_gen(C,0)

sage: [next(g) for i in range(4)]

[p[], p[1], p[1, 1] + p[2], p[1, 1, 1] + p[2, 1] + p[3]]

"""

parent = self.parent()

res = parent.sum_generator(self._weighted_compose_term(self.coefficient(i), y_species)

for i in _integers_from(0))

for i in _integers_from(0):

yield res.coefficient(i)

def _weighted_compose_term(self, p, y_species):

"""

Returns the weighted composition of one term in self with y.

INPUT:

- ``p`` - a term in self

- ``y_species`` - a species

EXAMPLES::

sage: E = species.SetSpecies(); C = species.CycleSpecies()

sage: E_cis = E.cycle_index_series()

sage: p2 = E_cis.coefficient(2); p2

1/2*p[1, 1] + 1/2*p[2]

sage: E_cis._weighted_compose_term(p2, C).coefficients(4)

[0, 0, 1/2*p[1, 1] + 1/2*p[2], 1/2*p[1, 1, 1] + 1/2*p[2, 1]]

"""

parent = self.parent()

if p == 0:

return parent(0)

base_ring = self.base_ring().base_ring()

res = []

#Go through all the partition, coefficient pairs in the term p

for m, c in p:

res_t = parent.term(c, 0)

for e,v in enumerate(m.to_exp()):

if v == 0:

continue

res_t = res_t * (y_species.weighted(y_species._weight**(e+1)).cycle_index_series(base_ring)**v).stretch(e+1)

res.append(res_t)

return parent.sum(res)

def compositional_inverse(self):

r"""

Return the compositional inverse of ``self`` if possible.

(Specifically, if ``self`` is of the form `0 + p_{1} + \dots`.)

The compositional inverse is the inverse with respect to

plethystic substitution. This is the operation on cycle index

series which corresponds to substitution, a.k.a. partitional

composition, on the level of species. See Section 2.2 of

[BLL]_ for a definition of this operation.

EXAMPLES::

sage: Eplus = species.SetSpecies(min=1).cycle_index_series()

sage: Eplus(Eplus.compositional_inverse()).coefficients(8)

[0, p[1], 0, 0, 0, 0, 0, 0]

TESTS::

sage: Eplus = species.SetSpecies(min=2).cycle_index_series()

sage: Eplus.compositional_inverse()

Traceback (most recent call last):

...

ValueError: not an invertible series

ALGORITHM:

Let `F` be a species satisfying `F = 0 + X + F_2 + F_3 + \dots` for `X` the species of singletons.

(Equivalently, `\lvert F[\varnothing] \rvert = 0` and `\lvert F[\{1\}] \rvert = 1`.)

Then there exists a (virtual) species `G` satisfying `F \circ G = G \circ F = X`.

It follows that `(F - X) \circ G = F \circ G - X \circ G = X - G`.

Rearranging, we obtain the recursive equation `G = X - (F - X) \circ G`, which can be

solved using iterative methods.

.. WARNING::

This algorithm is functional but can be very slow.

Use with caution!

.. SEEALSO::

The compositional inverse `\Omega` of the species `E_{+}`

of nonempty sets can be handled much more efficiently

using specialized methods. These are implemented in

:class:`~sage.combinat.species.combinatorial_logarithm.CombinatorialLogarithmSeries`.

AUTHORS:

- Andrew Gainer-Dewar

"""

cisr = self.parent()

sfa = cisr._base

X = cisr([0, sfa([1]), 0])

if self.coefficients(2) != X.coefficients(2):

raise ValueError('not an invertible series')

res = cisr()

res.define(X - (self - X).compose(res))

return res

def derivative(self, order=1):

r"""

Return the species-theoretic nth derivative of ``self``, where n is ``order``.

For a cycle index series `F (p_{1}, p_{2}, p_{3}, \dots)`, its derivative is the cycle index series

`F' = D_{p_{1}} F` (that is, the formal derivative of `F` with respect to the variable `p_{1}`).

If `F` is the cycle index series of a species `S` then `F'` is the cycle index series of an associated

species `S'` of `S`-structures with a "hole".

EXAMPLES:

The species `E` of sets satisfies the relationship `E' = E`::

sage: E = species.SetSpecies().cycle_index_series()

sage: E.coefficients(8) == E.derivative().coefficients(8)

True

The species `C` of cyclic orderings and the species `L` of linear orderings satisfy the relationship `C' = L`::

sage: C = species.CycleSpecies().cycle_index_series()

sage: L = species.LinearOrderSpecies().cycle_index_series()

sage: L.coefficients(8) == C.derivative().coefficients(8)

True

"""

# Make sure that order is integral

order = Integer(order)

if order < 0:

raise ValueError("Order must be a non-negative integer")

elif order == 0:

return self

elif order == 1:

parent = self.parent()

derivative_term = lambda n: parent.term(self.coefficient(n+1).derivative_with_respect_to_p1(), n)

return parent.sum_generator(derivative_term(i) for i in _integers_from(0))

else:

return self.derivative(order-1)

def pointing(self):

r"""

Return the species-theoretic pointing of ``self``.

For a cycle index `F`, its pointing is the cycle index series `F^{\bullet} = p_{1} \cdot F'`.

If `F` is the cycle index series of a species `S` then `F^{\bullet}` is the cycle index series of an associated

species `S^{\bullet}` of `S`-structures with a marked "root".

EXAMPLES:

The species `E^{\bullet}` of "pointed sets" satisfies `E^{\bullet} = X \cdot E`::

sage: E = species.SetSpecies().cycle_index_series()

sage: X = species.SingletonSpecies().cycle_index_series()

sage: E.pointing().coefficients(8) == (X*E).coefficients(8)

True

"""

p1 = self.base_ring()([1])

X = self.parent()([0, p1, 0])

return X*self.derivative()

def integral(self, *args):

"""

Given a cycle index `G`, it is not in general possible to recover a single cycle index `F`

such that `F' = G` (even up to addition of a constant term).

More broadly, it may be the case that there are many non-isomorphic species `S` such that

`S' = T` for a given species `T`.

For example, the species `3 C_{3}` of 3-cycles from three distinct classes

and the species `X^{3}` of 3-sets are not isomorphic, but `(3 C_{3})' = (X^{3})' = 3 X^{2}`.

EXAMPLES::

sage: C3 = species.CycleSpecies(size=3).cycle_index_series()

sage: X = species.SingletonSpecies().cycle_index_series()

sage: (3*C3).derivative().coefficients(8) == (3*X^2).coefficients(8)

True

sage: (X^3).derivative().coefficients(8) == (3*X^2).coefficients(8)

True

.. WARNING::

This method has no implementation and exists only to prevent you from doing something

strange. Calling it raises a ``NotImplementedError``!

"""

raise NotImplementedError

def exponential(self):

r"""

Return the species-theoretic exponential of ``self``.

For a cycle index `Z_{F}` of a species `F`, its exponential is the cycle index series

`Z_{E} \\circ Z_{F}`, where `Z_{E}` is the :meth:`~sage.combinat.species.generating_series.ExponentialCycleIndexSeries`.

The exponential `Z_{E} \circ Z_{F}` is then the cycle index series of the species `E \\circ F` of

"sets of `F`-structures".

EXAMPLES:

Let `BT` be the species of binary trees, `BF` the species of binary forests, and

`E` the species of sets. Then we have `BF = E \circ BT`::

sage: BT = species.BinaryTreeSpecies().cycle_index_series()

sage: BF = species.BinaryForestSpecies().cycle_index_series()

sage: BT.exponential().isotype_generating_series().coefficients(8) == BF.isotype_generating_series().coefficients(8)

True

"""

base_ring = self.parent().base_ring().base_ring()

E = ExponentialCycleIndexSeries(base_ring)

return E.compose(self)

def logarithm(self):

r"""

Return the combinatorial logarithm of ``self``.

For a cycle index `Z_{F}` of a species `F`, its logarithm is the cycle index series

`Z_{\Omega} \circ Z_{F}`, where `Z_{\Omega}` is the

:meth:`~sage.combinat.species.generating_series.LogarithmCycleIndexSeries`.

The logarithm `Z_{\Omega} \circ Z_{F}` is then the cycle index series of the (virtual) species

`\Omega \circ F` of "connected `F`-structures".

In particular, if `F = E^{+} \circ G` for `E^{+}` the species of nonempty sets and `G`

some other species, then `\Omega \circ F = G`.

EXAMPLES:

Let `G` be the species of nonempty graphs and `CG` be the species of nonempty connected

graphs. Then `G = E^{+} \circ CG`, so `CG = \Omega \circ G`::

sage: G = species.SimpleGraphSpecies().cycle_index_series() - 1

sage: from sage.combinat.species.generating_series import LogarithmCycleIndexSeries

sage: CG = LogarithmCycleIndexSeries().compose(G)

sage: CG.isotype_generating_series().coefficients(8)

[0, 1, 1, 2, 6, 21, 112, 853]

"""

base_ring = self.parent().base_ring().base_ring()

Omega = LogarithmCycleIndexSeries(base_ring)

return Omega.compose(self)

@cached_function

def _exp_term(n, R = RationalField()):

"""

Compute the order-n term of the cycle index series of the species `E` of sets.

EXAMPLES::

sage: from sage.combinat.species.generating_series import _exp_term

sage: [_exp_term(i) for i in range(4)]

[p[], p[1], 1/2*p[1, 1] + 1/2*p[2], 1/6*p[1, 1, 1] + 1/2*p[2, 1] + 1/3*p[3]]

"""

p = SymmetricFunctions(R)

res = sum(p(part)/part.aut() for part in Partitions(n))

return res

def _exp_gen(R = RationalField()):

"""

Produce a generator which yields the terms of the cycle index series of the species `E` of sets.

EXAMPLES::

sage: from sage.combinat.species.generating_series import _exp_gen

sage: g = _exp_gen()

sage: [next(g) for i in range(4)]

[p[], p[1], 1/2*p[1, 1] + 1/2*p[2], 1/6*p[1, 1, 1] + 1/2*p[2, 1] + 1/3*p[3]]

"""

return (_exp_term(i, R) for i in _integers_from(0))

@cached_function

def ExponentialCycleIndexSeries(R = RationalField()):

"""

Return the cycle index series of the species `E` of sets.

This cycle index satisfies

.. MATH::

Z_{E} = \\sum_{n \\geq 0} \\sum_{\\lambda \\vdash n} \\frac{p_{\\lambda}}{z_{\\lambda}}.

EXAMPLES::

sage: from sage.combinat.species.generating_series import ExponentialCycleIndexSeries

sage: ExponentialCycleIndexSeries().coefficients(5)

[p[], p[1], 1/2*p[1, 1] + 1/2*p[2], 1/6*p[1, 1, 1] + 1/2*p[2, 1] + 1/3*p[3], 1/24*p[1, 1, 1, 1] + 1/4*p[2, 1, 1] + 1/8*p[2, 2] + 1/3*p[3, 1] + 1/4*p[4]]

"""

CIS = CycleIndexSeriesRing(R)

return CIS(_exp_gen(R))

@cached_function

def _cl_term(n, R = RationalField()):

"""

Compute the order-n term of the cycle index series of the virtual species `\Omega`,

the compositional inverse of the species `E^{+}` of nonempty sets.

EXAMPLES::

sage: from sage.combinat.species.generating_series import _cl_term

sage: [_cl_term(i) for i in range(4)]

[0, p[1], -1/2*p[1, 1] - 1/2*p[2], 1/3*p[1, 1, 1] - 1/3*p[3]]

"""

n = Integer(n) #check that n is an integer

p = SymmetricFunctions(R).power()

res = p.zero()

if n == 1:

res = p([1])

elif n > 1:

res = 1/n * ((-1)**(n-1) * p([1])**n - sum(d * p([Integer(n/d)]).plethysm(_cl_term(d, R)) for d in divisors(n)[:-1]))

return res

def _cl_gen (R = RationalField()):

"""

Produce a generator which yields the terms of the cycle index series of the virtual species

`\Omega`, the compositional inverse of the species `E^{+}` of nonempty sets.

EXAMPLES::

sage: from sage.combinat.species.generating_series import _cl_gen

sage: g = _cl_gen()

sage: [next(g) for i in range(4)]

[0, p[1], -1/2*p[1, 1] - 1/2*p[2], 1/3*p[1, 1, 1] - 1/3*p[3]]

"""

return (_cl_term(i, R) for i in _integers_from(0))

@cached_function

def LogarithmCycleIndexSeries(R = RationalField()):

"""

Return the cycle index series of the virtual species `\Omega`, the compositional inverse

of the species `E^{+}` of nonempty sets.

The notion of virtual species is treated thoroughly in [BLL]_. The specific algorithm used

here to compute the cycle index of `\Omega` is found in [Labelle]_.

EXAMPLES:

The virtual species `\Omega` is 'properly virtual', in the sense that its cycle index

has negative coefficients::

sage: from sage.combinat.species.generating_series import LogarithmCycleIndexSeries

sage: LogarithmCycleIndexSeries().coefficients(4)

[0, p[1], -1/2*p[1, 1] - 1/2*p[2], 1/3*p[1, 1, 1] - 1/3*p[3]]

Its defining property is that `\Omega \circ E^{+} = E^{+} \circ \Omega = X` (that is, that

composition with `E^{+}` in both directions yields the multiplicative identity `X`)::

sage: Eplus = sage.combinat.species.set_species.SetSpecies(min=1).cycle_index_series()

sage: LogarithmCycleIndexSeries().compose(Eplus).coefficients(4)

[0, p[1], 0, 0]

REFERENCES:

.. [Labelle] \G. Labelle. "New combinatorial computational methods arising from pseudo-singletons." DMTCS Proceedings 1, 2008.

"""

CIS = CycleIndexSeriesRing(R)

return CIS(_cl_gen(R))

Coverage for local/lib/python2.7/site-packages/sage/combinat/species/generating_series.py : 70%

267 statements 188 run 79 missing 0 excluded