Being more careful with the parent in from_finite_word().

Author: tscrim

src/sage/combinat/chas/wqsym.py

@@ -69,9 +69,12 @@ def __init__(self, alg, graded=True):
             sage: M = algebras.WQSym(QQ).M()
             sage: TestSuite(M).run()  # long time
         """
+        def sorting_key(X):
+            return (sum(map(len, X)), X)
         CombinatorialFreeModule.__init__(self, alg.base_ring(),
                                          OrderedSetPartitions(),
                                          category=WQSymBases(alg, graded),
+                                         sorting_key=sorting_key,
                                          bracket="", prefix=self._prefix)
 
     def _repr_term(self, osp):
@@ -2224,7 +2227,7 @@ def algebraic_complement(self):
                 sage: M[[1,4],[2,5],[3,6]].algebraic_complement()
                 M[{3, 6}, {2, 5}, {1, 4}]
                 sage: (3*M[[1]] - 4*M[[]] + 5*M[[1],[2]]).algebraic_complement()
-                3*M[{1}] - 4*M[] + 5*M[{2}, {1}]
+                -4*M[] + 3*M[{1}] + 5*M[{2}, {1}]
                 sage: X = WQSym.X()
                 sage: X[[1,3],[2]].algebraic_complement()
                 X[{2}, {1, 3}]
@@ -2389,7 +2392,7 @@ def coalgebraic_complement(self):
                 sage: M[[1,4],[2,5],[3,6]].coalgebraic_complement()
                 M[{3, 6}, {2, 5}, {1, 4}]
                 sage: (3*M[[1]] - 4*M[[]] + 5*M[[1],[2]]).coalgebraic_complement()
-                3*M[{1}] - 4*M[] + 5*M[{2}, {1}]
+                -4*M[] + 3*M[{1}] + 5*M[{2}, {1}]
                 sage: X = WQSym.X()
                 sage: X[[1,3],[2]].coalgebraic_complement()
                 X[{1, 3}, {2}]
@@ -2500,7 +2503,7 @@ def star_involution(self):
                 sage: M[[1,4],[2,5],[3,6]].star_involution()
                 M[{1, 4}, {2, 5}, {3, 6}]
                 sage: (3*M[[1]] - 4*M[[]] + 5*M[[1],[2]]).star_involution()
-                3*M[{1}] - 4*M[] + 5*M[{1}, {2}]
+                -4*M[] + 3*M[{1}] + 5*M[{1}, {2}]
                 sage: X = WQSym.X()
                 sage: X[[1,3],[2]].star_involution()
                 X[{2}, {1, 3}]

src/sage/combinat/set_partition_ordered.py

@@ -1030,7 +1030,7 @@ def __contains__(self, x):
         # sets is the original set
         return len(u) == len(self._set)
 
-    def from_finite_word(self, w):
+    def from_finite_word(self, w, check=True):
         r"""
         Return the unique ordered set partition of `\{1, 2, \ldots, n\}` corresponding
         to a word `w` of length `n`.
@@ -1051,14 +1051,24 @@ def from_finite_word(self, w):
 
             sage: A = OrderedSetPartitions().from_finite_word('abcabca')
             sage: A.parent()
+            Ordered set partitions
+
+            sage: A = OrderedSetPartitions(7).from_finite_word('abcabca')
+            sage: A.parent()
             Ordered set partitions of {1, 2, 3, 4, 5, 6, 7}
         """
         # TODO: fix this if statement.
         #       In fact, what we need is for the underlying alphabet to be sortable.
         if isinstance(w, (list, tuple, str, FiniteWord_class)):
             W = Words(infinite=False)
-            s = frozenset(range(1, len(w) + 1))
-            return self.element_class(self.subset(s), W(w).to_ordered_set_partition())
+            if check:
+                try:
+                    X = self._set
+                    if len(X) != len(w) or X != frozenset(range(1, len(w) + 1)):
+                        raise ValueError(f"result not in {self}")
+                except AttributeError:
+                    pass
+            return self.element_class(self, W(w).to_ordered_set_partition())
         raise TypeError(f"`from_finite_word` expects an object of type list/tuple/str/Word "
                         f"representing a finite word, received {w}")