Trac #15476: Involutions on NSym and QSym part I

This got much longer than I expected it to be because there are three
"classical" involution on each of NSym and QSym and each can be computed
on various bases. I ended up implementing only two of the involutions
(star=rho and psi), leaving out omega (which is just a rescaled
antipode) for part II.

The patch also speeds up NSym's Verschiebung on certain bases, fixes
some doc, moves a reference, and changes various invocations of
`Composition(spam)` to `Compositions()(spam)` for speed reasons (when
`spam` really is just a list). Could a `_Compositions` (akin to
`_Partitions`) be of use?

URL: http://trac.sagemath.org/15476
Reported by: darij
Ticket author(s): Darij Grinberg
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/combinat/composition.py

@@ -195,18 +195,35 @@ def __setstate__(self, state):
             self._set_parent(state[0])
             self.__dict__ = state[1]
 
-    @combinatorial_map(name='conjugate')
+    @combinatorial_map(order=2, name='conjugate')
     def conjugate(self):
         r"""
         Return the conjugate of the composition ``self``.
 
-        Algorithm from mupad-combinat.
+        The conjugate of a composition `I` is defined as the
+        complement (see :meth:`complement`) of the reverse composition
+        (see :meth:`reversed`) of `I`.
+
+        An equivalent definition of the conjugate goes by saying that
+        the ribbon shape of the conjugate of a composition `I` is the
+        conjugate of the ribbon shape of `I`. (The ribbon shape of a
+        composition is returned by :meth:`to_skew_partition`.)
+
+        This implementation uses the algorithm from mupad-combinat.
 
         EXAMPLES::
 
             sage: Composition([1, 1, 3, 1, 2, 1, 3]).conjugate()
             [1, 1, 3, 3, 1, 3]
 
+        The ribbon shape of the conjugate of `I` is the conjugate of
+        the ribbon shape of `I`::
+
+            sage: all( I.conjugate().to_skew_partition()
+            ....:      == I.to_skew_partition().conjugate()
+            ....:      for I in Compositions(4) )
+            True
+
         TESTS::
 
             sage: parent(list(Compositions(1))[0].conjugate())
@@ -227,23 +244,40 @@ def conjugate(self):
 
         return self.parent()([cocjg[0]] + [cocjg[i]-cocjg[i-1]+1 for i in range(1,len(cocjg))])
 
-    @combinatorial_map(name='reversed')
+    @combinatorial_map(order=2, name='reversed')
     def reversed(self):
-        """
+        r"""
         Return the reverse composition of ``self``.
 
+        The reverse composition of a composition `(i_1, i_2, \ldots, i_k)`
+        is defined as the composition `(i_k, i_{k-1}, \ldots, i_1)`.
+
         EXAMPLES::
 
             sage: Composition([1, 1, 3, 1, 2, 1, 3]).reversed()
             [3, 1, 2, 1, 3, 1, 1]
         """
         return self.parent()(reversed(self))
 
-    @combinatorial_map(name = 'complement')
+    @combinatorial_map(order=2, name='complement')
     def complement(self):
-        """
-        Return the complement composition of ``self``. The complement is the
-        reverse of the conjugate composition of ``self``.
+        r"""
+        Return the complement of the composition ``self``.
+
+        The complement of a composition `I` is defined as follows:
+
+        If `I` is the empty composition, then the complement is the empty
+        composition as well. Otherwise, let `S` be the descent set of `I`
+        (that is, the subset
+        `\{ i_1, i_1 + i_2, \ldots, i_1 + i_2 + \cdots + i_{k-1} \}`
+        of `\{ 1, 2, \ldots, |I|-1 \}`, where `I` is written as
+        `(i_1, i_2, \ldots, i_k)`). Then, the complement of `I` is
+        defined as the composition of size `|I|` whose descent set is
+        `\{ 1, 2, \ldots, |I|-1 \} \setminus S`.
+
+        The complement of a composition `I` also is the reverse
+        composition (:meth:`reversed`) of the conjugate
+        (:meth:`conjugate`) of `I`.
 
         EXAMPLES::
 
@@ -268,7 +302,7 @@ def __add__(self, other):
             sage: Composition([]) + Composition([]) == Composition([])
             True
         """
-        return Composition(list(self)+list(other))
+        return Compositions()(list(self)+list(other))
 
     def size(self):
         """
@@ -305,7 +339,7 @@ def sum(compositions):
             sage: Composition.sum([]) == Composition([])
             True
         """
-        return sum(compositions, Composition([]))
+        return sum(compositions, Compositions()([]))
 
     def near_concatenation(self, other):
         r"""
@@ -341,7 +375,7 @@ def near_concatenation(self, other):
         """
         if len(self) == 0 or len(other) == 0:
             return None
-        return Composition(list(self)[:-1] + [self[-1] + other[0]] + list(other)[1:])
+        return Compositions()(list(self)[:-1] + [self[-1] + other[0]] + list(other)[1:])
 
     def ribbon_decomposition(self, other, check=True):
         r"""
@@ -422,13 +456,6 @@ def ribbon_decomposition(self, other, check=True):
             ...
             ValueError: [3, 1, 1, 3, 1] is not the same size as [4, 3, 1]
 
-        REFERENCES:
-
-        .. [NCSF1] Israel Gelfand, D. Krob, Alain Lascoux, B. Leclerc,
-           V. S. Retakh, J.-Y. Thibon,
-           *Noncommutative symmetric functions*.
-           :arxiv:`hep-th/9407124v1`
-
         AUTHORS:
 
         - Darij Grinberg (2013-08-29)
@@ -452,7 +479,7 @@ def ribbon_decomposition(self, other, check=True):
                     try:
                         i = I_iter.next()
                     except StopIteration:
-                        factors.append(Composition(current_factor))
+                        factors.append(Compositions()(current_factor))
                         return (tuple(factors), tuple(signs))
                 if current_factor_size + i <= j:
                     current_factor.append(i)
@@ -465,7 +492,7 @@ def ribbon_decomposition(self, other, check=True):
                         current_factor.append(j - current_factor_size)
                         i -= j - current_factor_size
                         signs.append(1)
-                    factors.append(Composition(current_factor))
+                    factors.append(Compositions()(current_factor))
                     break
 
         return (tuple(factors), tuple(signs))
@@ -584,7 +611,7 @@ def join(self, other, check=True):
                     try:
                         i = I_iter.next()
                     except StopIteration:
-                        return Composition(factors)
+                        return Compositions()(factors)
                 if current_factor_size + i <= j:
                     factors.append(i)
                     current_factor_size += i
@@ -595,7 +622,7 @@ def join(self, other, check=True):
                         i -= j - current_factor_size
                     break
 
-        return Composition(factors)
+        return Compositions()(factors)
 
     sup = join
 
@@ -705,7 +732,7 @@ def meet(self, other, check=True):
                         i = I_iter.next()
                     except StopIteration:
                         factors.append(current_part)
-                        return Composition(factors)
+                        return Compositions()(factors)
                 if current_factor_size + i <= j:
                     current_part += i
                     current_factor_size += i
@@ -719,7 +746,7 @@ def meet(self, other, check=True):
                         current_part += j - current_factor_size
                     break
 
-        return Composition(factors)
+        return Compositions()(factors)
 
     inf = meet
 
@@ -816,7 +843,7 @@ def fatten(self, grouping):
         for i in range(len(grouping)):
             result[i] = sum(self[j:j+grouping[i]])
             j += grouping[i]
-        return Composition(result)
+        return Compositions()(result)
 
     def fatter(self):
         """
@@ -894,7 +921,7 @@ def refinement_splitting(self, J):
                 sum1 += new_comp[-1]
             if sum1 > sum2:
                 raise ValueError("composition J (= %s) does not refine self (= %s)"%(I, J))
-            decomp.append(Composition(new_comp))
+            decomp.append(Compositions()(new_comp))
         return decomp
 
     def refinement_splitting_lengths(self, J):
@@ -921,7 +948,7 @@ def refinement_splitting_lengths(self, J):
             ...
             ValueError: composition J (= [2, 1]) does not refine self (= [1, 2])
         """
-        return Composition(map(len,self.refinement_splitting(J)))
+        return Compositions()(map(len,self.refinement_splitting(J)))
 
     refinement = deprecated_function_alias(13243, refinement_splitting_lengths)
 
@@ -1685,6 +1712,11 @@ def from_subset(self, S, n):
             sage: Compositions().from_subset({2,1,5,9}, 12)
             [1, 1, 3, 4, 3]
 
+            sage: Compositions().from_subset([], 12)
+            [12]
+            sage: Compositions().from_subset([], 0)
+            []
+
         TESTS::
 
             sage: Compositions().from_subset([2,1,5,9],9)

src/sage/combinat/ncsf_qsym/generic_basis_code.py

@@ -29,7 +29,7 @@
 from sage.misc.cachefunc import cached_method
 from sage.categories.realizations import Category_realization_of_parent
 from sage.categories.modules_with_basis import ModulesWithBasis, ModuleMorphismByLinearity
-from sage.combinat.composition import Composition
+from sage.combinat.composition import Compositions, Composition
 from sage.combinat.partition import Partition
 from sage.combinat.permutation import Permutations
 from sage.rings.integer import Integer
@@ -114,9 +114,9 @@ def __getitem__(self, c, *rest):
                 assert len(rest) == 0
             else:
                 if len(rest) > 0 or isinstance(c, (int, Integer)):
-                    c = Composition([c] + list(rest))
+                    c = self._basis_keys([c] + list(rest))
                 else:
-                    c = Composition(list(c))
+                    c = self._basis_keys(list(c))
             return self.monomial(c)
 
         # could go to Algebras(...).Graded().Connected() or Modules(...).Graded().Connected()
@@ -137,7 +137,7 @@ def one_basis(self):
                 sage: parent(L).one_basis()
                 []
             """
-            return Composition([])
+            return Compositions()([])
 
         # Combinatorial rules
 
@@ -294,7 +294,7 @@ def sum_of_partition_rearrangements(self, par):
                 sage: elementary.sum_of_partition_rearrangements(Partition([]))
                 L[]
             """
-            return self.sum_of_monomials( Composition(comp) for comp in Permutations(par) )
+            return self.sum_of_monomials( self._basis_keys(comp) for comp in Permutations(par) )
 
         def _comp_to_par(self, comp):
             """
@@ -680,6 +680,61 @@ def counit_on_basis(self, I):
             else:
                 return self.base_ring().one()
 
+        def degree_negation(self, element):
+            r"""
+            Return the image of ``element`` under the degree negation
+            automorphism of ``self``.
+
+            The degree negation is the automorphism which scales every
+            homogeneous element of degree `k` by `(-1)^k` (for all `k`).
+
+            INPUT:
+
+            - ``element`` -- element of ``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: S.degree_negation(f)
+                -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: dI.degree_negation(f)
+                -2*dI[1] + 4*dI[2] + 3*dI[2, 1]
+
+            TESTS:
+
+            Using :meth:`degree_negation` on an element of a different
+            basis works correctly::
+
+                sage: NSym = NonCommutativeSymmetricFunctions(QQ)
+                sage: S = NSym.S()
+                sage: Phi = NSym.Phi()
+                sage: S.degree_negation(Phi[2])
+                -S[1, 1] + 2*S[2]
+                sage: S.degree_negation(Phi[3])
+                -S[1, 1, 1] + 3/2*S[1, 2] + 3/2*S[2, 1] - 3*S[3]
+                sage: Phi.degree_negation(S[3])
+                -1/6*Phi[1, 1, 1] - 1/4*Phi[1, 2] - 1/4*Phi[2, 1] - 1/3*Phi[3]
+
+            The zero element behaves well::
+
+                sage: a = Phi.degree_negation(S.zero()); a
+                0
+                sage: parent(a)
+                Non-Commutative Symmetric Functions over the Rational Field in the Phi basis
+
+            .. TODO::
+
+                Generalize this to all graded vector spaces?
+            """
+            return self.sum_of_terms([ (lam, (-1)**(sum(lam)%2) * a)
+                                       for lam, a in self(element) ])
+
     class ElementMethods:
 
         def duality_pairing(self, y):