Merge branch 'public/combinat/invol-nsym-2' of trac.sagemath.org:sage into public/combinat/invol-nsym-2

* 'public/combinat/invol-nsym-2' of trac.sagemath.org:sage:
  more bugfixes
  left-padded Kronecker product on Sym too, and fixes for my own bugs:
  fixes to reduced Kronecker product on Sym, and a new (fake-)reduced Kronecker product on NSym; also a bugfix for some operations on NSym needlessly extending the base ring by QQ
  implemented internal product on Psi using NCSF2 Lemma 5.10; not using it as default because of its ugly worstcase running time
  verschiebung on elementary basis of NSym
  omega involution on QSym
  omega involution on NSym; alias for omega involution on Sym (to have notations match); subtle changes in duality pairing to avoid unadorned sum([...]).
  immaculate functions for arbitrary integer vectors
  First (slow but functional) implementation of reduced Kronecker product; also, t-completion of a partition (the docstring is probably more useful than the code here), and (unrelatedly) an additional option (and improved doc) in the partitions-to-Dyck-paths method.

Author: Travis Scrimshaw

src/sage/combinat/ncsf_qsym/generic_basis_code.py

@@ -519,11 +519,20 @@ def duality_pairing(self, x, y):
                 0
                 sage: S.duality_pairing(S[1,1,1,1], F[4])
                 1
+
+            TESTS:
+
+            The result has the right parent even if the sum is empty::
+
+                sage: x = S.duality_pairing(S.zero(), F.zero()); x
+                0
+                sage: parent(x)
+                Rational Field
             """
             if hasattr(self, 'dual'):
                 x = self(x)
                 y = self.dual()(y)
-                return sum(coeff * y[I] for (I, coeff) in x)
+                return self.base_ring().sum(coeff * y[I] for (I, coeff) in x)
             else:
                 return self.duality_pairing_by_coercion(x, y)
 
@@ -541,8 +550,8 @@ def duality_pairing_by_coercion(self, x, y):
 
             OUTPUT:
 
-            - The result of pairing the function ``x`` from ``self`` with the function
-              ``y`` from the dual basis of ``self``
+            - The result of pairing the function ``x`` from ``self`` with
+              the function ``y`` from the dual basis of ``self``
 
             EXAMPLES::
 
@@ -556,11 +565,20 @@ def duality_pairing_by_coercion(self, x, y):
                 1
                 sage: F.duality_pairing_by_coercion(F[1,2], L[1,1,1])
                 1
+
+            TESTS:
+
+            The result has the right parent even if the sum is empty::
+
+                sage: x = F.duality_pairing_by_coercion(F.zero(), L.zero()); x
+                0
+                sage: parent(x)
+                Rational Field
             """
             a_realization = self.realization_of().a_realization()
             x = a_realization(x)
             y = a_realization.dual()(y)
-            return sum(coeff * y[I] for (I, coeff) in x)
+            return self.base_ring().sum(coeff * y[I] for (I, coeff) in x)
 
         def duality_pairing_matrix(self, basis, degree):
             r"""
@@ -574,8 +592,9 @@ def duality_pairing_matrix(self, basis, degree):
 
             OUTPUT:
 
-            - The matrix of scalar products between the basis ``self`` and the basis
-              ``basis`` in the dual Hopf algebra of degree ``degree``.
+            - The matrix of scalar products between the basis ``self``
+              and the basis ``basis`` in the dual Hopf algebra in
+              degree ``degree``.
 
             EXAMPLES:
 
@@ -733,10 +752,53 @@ def degree_negation(self, element):
                 Generalize this to all graded vector spaces?
             """
             return self.sum_of_terms([ (lam, (-1)**(sum(lam)%2) * a)
-                                       for lam, a in self(element) ])
+                                       for lam, a in self(element) ],
+                                     distinct=True)
 
     class ElementMethods:
 
+        def degree_negation(self):
+            r"""
+            Return the image of ``self`` under the degree negation
+            automorphism of the parent of ``self``.
+
+            The degree negation is the automorphism which scales every
+            homogeneous element of degree `k` by `(-1)^k` (for all `k`).
+
+            Calling ``degree_negation(self)`` is equivalent to calling
+            ``self.parent().degree_negation(self)``.
+
+            EXAMPLES::
+
+                sage: NSym = NonCommutativeSymmetricFunctions(ZZ)
+                sage: S = NSym.S()
+                sage: f = 2*S[2,1] + 4*S[1,1] - 5*S[1,2] - 3*S[[]]
+                sage: f.degree_negation()
+                -3*S[] + 4*S[1, 1] + 5*S[1, 2] - 2*S[2, 1]
+
+                sage: QSym = QuasiSymmetricFunctions(QQ)
+                sage: dI = QSym.dualImmaculate()
+                sage: f = -3*dI[2,1] + 4*dI[2] + 2*dI[1]
+                sage: f.degree_negation()
+                -2*dI[1] + 4*dI[2] + 3*dI[2, 1]
+
+            TESTS:
+
+            The zero element behaves well::
+
+                sage: a = S.zero().degree_negation(); a
+                0
+                sage: parent(a)
+                Non-Commutative Symmetric Functions over the Integer Ring in the Complete basis
+
+            .. TODO::
+
+                Generalize this to all graded vector spaces?
+            """
+            return self.parent().sum_of_terms([ (lam, (-1)**(sum(lam)%2) * a)
+                                                for lam, a in self ],
+                                              distinct=True)
+
         def duality_pairing(self, y):
             r"""
             The duality pairing between elements of `NSym` and elements
@@ -1131,7 +1193,68 @@ def internal_product(self, other):
                 \rangle \langle g, h^{\prime\prime}_i \rangle,
 
             where we write `\Delta^{\times}(h)` as `\sum_i h^{\prime}_i
-            \otimes h^{\prime\prime}_i`.
+            \otimes h^{\prime\prime}_i`. Here, `f * g` denotes the internal
+            product of the non-commutative symmetric functions `f` and `g`.
+
+            If `f` and `g` are two homogeneous elements of `NSym` having
+            distinct degrees, then the internal product `f * g` is zero.
+
+            Explicit formulas can be given for internal products of
+            elements of the complete and the Psi bases. First, the formula
+            for the complete basis ([NCSF1]_ Proposition 5.1): If `I` and
+            `J` are two compositions of lengths `p` and `q`, respectively,
+            then the corresponding complete homogeneous non-commutative
+            symmetric functions `S^I` and `S^J` have internal product
+
+            .. MATH::
+
+                S^I * S^J = \sum S^{\operatorname*{comp}M},
+
+            where the sum ranges over all `p \times q`-matrices
+            `M \in \NN^{p \times q}` (with nonnegative integers as
+            entries) whose row sum vector is `I` (that is, the sum of the
+            entries of the `r`-th row is the `r`-th part of `I` for all
+            `r`) and whose column sum vector is `J` (that is, the sum of
+            all entries of the `s`-th row is the `s`-th part of `J` for
+            all `s`). Here, for any `M \in \NN^{p \times q}`, we denote
+            by `\operatorname*{comp}M` the composition obtained by
+            reading the entries of the matrix `M` in the usual order
+            (row by row, proceeding left to right in each row,
+            traversing the rows from top to bottom).
+
+            The formula on the Psi basis ([NCSF2]_ Lemma 3.10) is more
+            complicated. Let `I` and `J` be two compositions of lengths
+            `p` and `q`, respectively, having the same size `|I| = |J|`.
+            We denote by `\Psi^K` the element of the Psi-basis
+            corresponding to any composition `K`.
+
+            - If `p > q`, then `\Psi^I * \Psi^J` is plainly `0`.
+
+            - Assume that `p = q`. Let `\widetilde{\delta}_{I, J}` denote
+              the integer `1` if the compositions `I` and `J` are
+              permutations of each other, and the integer `0` otherwise.
+              For every positive integer `i`, let `m_i` denote the number
+              of parts of `I` equal to `i`. Then, `\Psi^I * \Psi^J` equals
+              `\widetilde{\delta}_{I, J} \prod_{i>0} i^{m_i} m_i! \Psi^I`.
+
+            - Now assume that `p < q`. Write the composition `I` as
+              `I = (i_1, i_2, \ldots, i_p)`. For every nonempty
+              composition `K = (k_1, k_2, \ldots, k_s)`, denote by
+              `\Gamma_K` the non-commutative symmetric function
+              `k_1 [\ldots [[\Psi_{k_1}, \Psi_{k_2}], \Psi_{k_3}],
+              \ldots \Psi_{k_s}]`. For any subset `S` of
+              `\{ 1, 2, \ldots, q \}`, let `J_S` be the composition
+              obtained from `J` by removing the `r`-th parts for all
+              `r \notin S` (while keeping the `r`-th parts for all
+              `r \in S` in order). Then, `\Psi^I * \Psi^J` equals the
+              sum of `\Gamma_{J_{K_1}} \Gamma_{J_{K_2}} \cdots
+              \Gamma_{J_{K_p}}` over all ordered set partitions
+              `(K_1, K_2, \ldots, K_p)` of `\{ 1, 2, \ldots, q \}`
+              into `p` parts such that each `1 \leq k \leq p` satisfies
+              `|J_{K_k}| = i_k`.
+              (See
+              :meth:`~sage.combinat.set_partition_ordered.OrderedSetPartition`
+              for the meaning of "ordered set partition".)
 
             Aliases for :meth:`internal_product()` are :meth:`itensor()` and
             :meth:`kronecker_product()`.