# sage_setup: distribution = sagemath-combinat
r"""
Ordered set partitions

AUTHORS:

- Mike Hansen
- MuPAD-Combinat developers (for algorithms and design inspiration)
- Travis Scrimshaw (2013-02-28): Removed ``CombinatorialClass`` and added
  entry point through :class:`OrderedSetPartition`.
"""
# ****************************************************************************
#       Copyright (C) 2007 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 itertools import product

from sage.arith.misc import factorial, multinomial
from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
from sage.combinat.combinat import stirling_number2
from sage.combinat.combinatorial_map import combinatorial_map
from sage.combinat.composition import Composition, Compositions
from sage.combinat.words.finite_word import FiniteWord_class
from sage.combinat.words.words import Words
from sage.misc.inherit_comparison import InheritComparisonClasscallMetaclass
from sage.misc.persist import register_unpickle_override
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
from sage.sets.set import Set, Set_generic
from sage.structure.list_clone import ClonableArray
from sage.structure.element import parent
from sage.structure.parent import Parent
from sage.structure.richcmp import richcmp
from sage.structure.unique_representation import UniqueRepresentation


class OrderedSetPartition(ClonableArray,
                          metaclass=InheritComparisonClasscallMetaclass):
    r"""
    An ordered partition of a set.

    An ordered set partition `p` of a set `s` is a list of pairwise
    disjoint nonempty subsets of `s` such that the union of these
    subsets is `s`. These subsets are called the parts of the partition.

    We represent an ordered set partition as a list of sets. By
    extension, an ordered set partition of a nonnegative integer `n` is
    the set partition of the integers from `1` to `n`. The number of
    ordered set partitions of `n` is called the `n`-th ordered Bell
    number.

    There is a natural integer composition associated with an ordered
    set partition, that is the sequence of sizes of all its parts in
    order.

    The number `T_n` of ordered set partitions of
    `\{ 1, 2, \ldots, n \}` is the so-called `n`-th *Fubini number*
    (also known as the `n`-th ordered Bell number; see
    :wikipedia:`Ordered Bell number`). Its exponential generating
    function is

    .. MATH::

        \sum_n \frac{T_n}{n!} x^n = \frac{1}{2-e^x}.

    (See sequence :oeis:`A000670` in OEIS.)

    INPUT:

    - ``parts`` -- an object or iterable that defines an ordered set partition
      (e.g., a list of pairwise disjoint sets) or a packed word (e.g., a list
      of letters on some alphabet). If there is ambiguity and if the input should
      be treated as a packed word, the keyword ``from_word`` should be used.

    EXAMPLES:

    There are 13 ordered set partitions of `\{1,2,3\}`::

        sage: OrderedSetPartitions(3).cardinality()
        13

    Here is the list of them::

        sage: OrderedSetPartitions(3).list()
        [[{1}, {2}, {3}],
         [{1}, {3}, {2}],
         [{2}, {1}, {3}],
         [{3}, {1}, {2}],
         [{2}, {3}, {1}],
         [{3}, {2}, {1}],
         [{1}, {2, 3}],
         [{2}, {1, 3}],
         [{3}, {1, 2}],
         [{1, 2}, {3}],
         [{1, 3}, {2}],
         [{2, 3}, {1}],
         [{1, 2, 3}]]

    There are 12 ordered set partitions of `\{1,2,3,4\}` whose underlying
    composition is `[1,2,1]`::

        sage: OrderedSetPartitions(4,[1,2,1]).list()
        [[{1}, {2, 3}, {4}],
         [{1}, {2, 4}, {3}],
         [{1}, {3, 4}, {2}],
         [{2}, {1, 3}, {4}],
         [{2}, {1, 4}, {3}],
         [{3}, {1, 2}, {4}],
         [{4}, {1, 2}, {3}],
         [{3}, {1, 4}, {2}],
         [{4}, {1, 3}, {2}],
         [{2}, {3, 4}, {1}],
         [{3}, {2, 4}, {1}],
         [{4}, {2, 3}, {1}]]

    Since :issue:`14140`, we can create an ordered set partition directly by
    :class:`OrderedSetPartition` which creates the parent object by taking the
    union of the partitions passed in. However it is recommended and
    (marginally) faster to create the parent first and then create the ordered
    set partition from that. ::

        sage: s = OrderedSetPartition([[1,3],[2,4]]); s
        [{1, 3}, {2, 4}]
        sage: s.parent()
        Ordered set partitions of {1, 2, 3, 4}

    We can construct the ordered set partition from a word,
    which we consider as packed::

        sage: OrderedSetPartition([2,4,1,2])
        [{3}, {1, 4}, {2}]
        sage: OrderedSetPartition(from_word=[2,4,1,2])
        [{3}, {1, 4}, {2}]
        sage: OrderedSetPartition(from_word='bdab')
        [{3}, {1, 4}, {2}]

    .. WARNING::

        The elements of the underlying set should be hashable.

    REFERENCES:

    :wikipedia:`Ordered_partition_of_a_set`
    """
    @staticmethod
    def __classcall_private__(cls, parts=None, from_word=None, check=True):
        """
        Create a set partition from ``parts`` with the appropriate parent.

        EXAMPLES::

            sage: s = OrderedSetPartition([[1,3],[2,4]]); s
            [{1, 3}, {2, 4}]
            sage: s.parent()
            Ordered set partitions of {1, 2, 3, 4}
            sage: t = OrderedSetPartition([[2,4],[1,3]]); t
            [{2, 4}, {1, 3}]
            sage: s != t
            True
            sage: OrderedSetPartition()
            []
            sage: OrderedSetPartition([])
            []
            sage: OrderedSetPartition('')
            []
            sage: OrderedSetPartition('bdab') == OrderedSetPartition(from_word='bdab')
            True
            sage: OrderedSetPartition('bdab') == OrderedSetPartition(Word('bdab'))
            True
        """
        if parts is None and from_word is None:
            P = OrderedSetPartitions([])
            return P.element_class(P, [])
        W = Words(infinite=False)
        if from_word:
            return OrderedSetPartitions().from_finite_word(W(from_word))
        # if `parts` looks like a sequence of "letters" then treat it like a word.
        if parts in W or (parts and (parts[0] in ZZ or isinstance(parts[0], str))):
            return OrderedSetPartitions().from_finite_word(W(parts))
        P = OrderedSetPartitions(set(x for p in parts for x in p))
        return P.element_class(P, parts, check=check)

    def __init__(self, parent, s, check=True):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: OS = OrderedSetPartitions(4)
            sage: s = OS([[1, 3], [2, 4]])
            sage: TestSuite(s).run()
        """
        ClonableArray.__init__(self, parent,
                               [frozenset(part) for part in s], check=check)

    def _repr_(self):
        """
        Return a string representation of ``self``.

        .. TODO::

            Sort the repr output of Sage's :class:`Set` and remove
            this method.

        EXAMPLES::

            sage: OrderedSetPartition([[1,3],[2,4]])
            [{1, 3}, {2, 4}]
        """
        return '[' + ', '.join('{' + repr(sorted(x))[1:-1] + '}' for x in self) + ']'

    def check(self):
        """
        Check that we are a valid ordered set partition.

        EXAMPLES::

            sage: OS = OrderedSetPartitions(4)
            sage: s = OS([[1, 3], [2, 4]])
            sage: s.check()
        """
        par = parent(self)
        assert self in par, "%s not in %s" % (self, par)

    def base_set(self):
        """
        Return the base set of ``self``.

        This is the union of all parts of ``self``.

        EXAMPLES::

            sage: OrderedSetPartition([[1], [2,3], [4]]).base_set()
            frozenset({1, 2, 3, 4})
            sage: OrderedSetPartition([[1,2,3,4]]).base_set()
            frozenset({1, 2, 3, 4})
            sage: OrderedSetPartition([]).base_set()
            frozenset()

        TESTS::

            sage: S = OrderedSetPartitions()
            sage: x = S([['a', 'c', 'e'], ['b', 'd']])
            sage: x.base_set()
            frozenset({'a', 'b', 'c', 'd', 'e'})
        """
        try:
            return parent(self)._set
        except AttributeError:  # in OrderedSetPartitions_all
            return frozenset(x for part in self for x in part)

    def base_set_cardinality(self):
        """
        Return the cardinality of the base set of ``self``.

        This is the sum of the sizes of the parts of ``self``.

        This is also known as the *size* (sometimes the *weight*) of
        an ordered set partition.

        EXAMPLES::

            sage: OrderedSetPartition([[1], [2,3], [4]]).base_set_cardinality()
            4
            sage: OrderedSetPartition([[1,2,3,4]]).base_set_cardinality()
            4

        TESTS::

            sage: S = OrderedSetPartitions()
            sage: S([[1,4],[3],[2]]).base_set_cardinality()
            4
        """
        try:
            return len(parent(self)._set)
        except AttributeError:  # in OrderedSetPartitions_all
            return sum(len(part) for part in self)

    size = base_set_cardinality

    def length(self):
        r"""
        Return the number of parts of ``self``.

        EXAMPLES::

            sage: OS = OrderedSetPartitions(4)
            sage: s = OS([[1, 3], [2, 4]])
            sage: s.length()
            2
        """
        return len(self)

    @combinatorial_map(name='to composition')
    def to_composition(self):
        r"""
        Return the integer composition whose parts are the sizes of the sets
        in ``self``.

        EXAMPLES::

            sage: S = OrderedSetPartitions(5)
            sage: x = S([[3,5,4], [1, 2]])
            sage: x.to_composition()
            [3, 2]
            sage: y = S([[3,1], [2], [5,4]])
            sage: y.to_composition()
            [2, 1, 2]
        """
        return Composition([len(p) for p in self])

    @staticmethod
    def sum(osps):
        """
        Return the concatenation of the given ordered set partitions
        ``osps`` (provided they have no elements in common).

        INPUT:

        - ``osps`` -- list (or iterable) of ordered set partitions

        EXAMPLES::

            sage: OrderedSetPartition.sum([OrderedSetPartition([[4, 1], [3]]), OrderedSetPartition([[7], [2]]), OrderedSetPartition([[5, 6]])])
            [{1, 4}, {3}, {7}, {2}, {5, 6}]

        Any iterable can be provided as input::

            sage: OrderedSetPartition.sum([OrderedSetPartition([[2*i,2*i+1]]) for i in [4,1,3]])
            [{8, 9}, {2, 3}, {6, 7}]

        Empty inputs are handled gracefully::

            sage: OrderedSetPartition.sum([]) == OrderedSetPartition([])
            True

        TESTS::

            sage: A = OrderedSetPartitions(3)([[2], [1, 3]])
            sage: B = OrderedSetPartitions([5])([[5]])
            sage: C = OrderedSetPartition.sum([A, B]); C
            [{2}, {1, 3}, {5}]
            sage: C.parent()
            Ordered set partitions of {1, 2, 3, 5}
        """
        lset = set(x for osp in osps for x in osp.base_set())
        return OrderedSetPartitions(lset)(sum((list(i) for i in osps), []))

    def reversed(self):
        r"""
        Return the reversal of the ordered set partition ``self``.

        The *reversal* of an ordered set partition
        `(P_1, P_2, \ldots, P_k)` is defined to be the ordered
        set partition `(P_k, P_{k-1}, \ldots, P_1)`.

        EXAMPLES::

            sage: OrderedSetPartition([[1, 3], [2]]).reversed()
            [{2}, {1, 3}]
            sage: OrderedSetPartition([[1, 5], [2, 4]]).reversed()
            [{2, 4}, {1, 5}]
            sage: OrderedSetPartition([[-1], [-2], [3, 4], [0]]).reversed()
            [{0}, {3, 4}, {-2}, {-1}]
            sage: OrderedSetPartition([]).reversed()
            []
        """
        par = parent(self)
        return par(list(reversed(self)))

    def complement(self):
        r"""
        Return the complement of the ordered set partition ``self``.

        This assumes that ``self`` is an ordered set partition of
        an interval of `\ZZ`.

        Let `(P_1, P_2, \ldots, P_k)` be an ordered set partition
        of some interval `I` of `\ZZ`. Let `\omega` be the unique
        strictly decreasing bijection `I \to I`. Then, the
        *complement* of `(P_1, P_2, \ldots, P_k)` is defined to be
        the ordered set partition
        `(\omega(P_1), \omega(P_2), \ldots, \omega(P_k))`.

        EXAMPLES::

            sage: OrderedSetPartition([[1, 2], [3]]).complement()
            [{2, 3}, {1}]
            sage: OrderedSetPartition([[1, 3], [2]]).complement()
            [{1, 3}, {2}]
            sage: OrderedSetPartition([[2, 3]]).complement()
            [{2, 3}]
            sage: OrderedSetPartition([[1, 5], [2, 3], [4]]).complement()
            [{1, 5}, {3, 4}, {2}]
            sage: OrderedSetPartition([[-1], [-2], [1, 2], [0]]).complement()
            [{1}, {2}, {-2, -1}, {0}]
            sage: OrderedSetPartition([]).complement()
            []
        """
        if len(self) <= 1:
            return self
        base_set = self.base_set()
        m = min(base_set)
        M = max(base_set)
        mM = m + M
        par = parent(self)
        return par([[mM - i for i in part] for part in self])

    def finer(self):
        """
        Return the set of ordered set partitions which are finer
        than ``self``.

        See :meth:`is_finer` for the definition of "finer".

        EXAMPLES::

            sage: C = OrderedSetPartition([[1, 3], [2]]).finer()
            sage: C.cardinality()
            3
            sage: C.list()
            [[{1}, {3}, {2}], [{3}, {1}, {2}], [{1, 3}, {2}]]

            sage: OrderedSetPartition([]).finer()
            {[]}

            sage: W = OrderedSetPartition([[4, 9], [-1, 2]])
            sage: W.finer().list()
            [[{9}, {4}, {2}, {-1}],
             [{9}, {4}, {-1}, {2}],
             [{9}, {4}, {-1, 2}],
             [{4}, {9}, {2}, {-1}],
             [{4}, {9}, {-1}, {2}],
             [{4}, {9}, {-1, 2}],
             [{4, 9}, {2}, {-1}],
             [{4, 9}, {-1}, {2}],
             [{4, 9}, {-1, 2}]]
        """
        par = parent(self)
        if not self:
            return FiniteEnumeratedSet([self])
        return FiniteEnumeratedSet([par(sum((list(i) for i in C), []))
                                    for C in product(*[OrderedSetPartitions(X) for X in self])])

    def is_finer(self, co2):
        """
        Return ``True`` if the ordered set partition ``self`` is finer
        than the ordered set partition ``co2``; otherwise, return ``False``.

        If `A` and `B` are two ordered set partitions of the same set,
        then `A` is said to be *finer* than `B` if `B` can be obtained
        from `A` by (repeatedly) merging consecutive parts.
        In this case, we say that `B` is *fatter* than `A`.

        EXAMPLES::

            sage: A = OrderedSetPartition([[1, 3], [2]])
            sage: B = OrderedSetPartition([[1], [3], [2]])
            sage: A.is_finer(B)
            False
            sage: B.is_finer(A)
            True
            sage: C = OrderedSetPartition([[3], [1], [2]])
            sage: A.is_finer(C)
            False
            sage: C.is_finer(A)
            True
            sage: OrderedSetPartition([[2], [5], [1], [4]]).is_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            True
            sage: OrderedSetPartition([[5], [2], [1], [4]]).is_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            True
            sage: OrderedSetPartition([[2], [1], [5], [4]]).is_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            False
            sage: OrderedSetPartition([[2, 5, 1], [4]]).is_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            False
        """
        co1 = self
        if co1.base_set() != co2.base_set():
            raise ValueError("ordered set partitions self (= %s) and co2 (= %s) must be of the same set" % (self, co2))

        i1 = 0
        for j2 in co2:
            sum1 = set()
            while len(sum1) < len(j2):
                sum1 = sum1.union(co1[i1])
                i1 += 1
            if not sum1.issubset(j2):
                return False

        return True

    def fatten(self, grouping):
        r"""
        Return the ordered set partition fatter than ``self``, obtained
        by grouping together consecutive parts according to the integer
        composition ``grouping``.

        See :meth:`finer` for the definition of "fatter".

        INPUT:

        - ``grouping`` -- a composition whose sum is the length of ``self``

        EXAMPLES:

        Let us start with the ordered set partition::

            sage: c = OrderedSetPartition([[2, 5], [1], [3, 4]])

        With ``grouping`` equal to `(1, \ldots, 1)`, `c` is left unchanged::

            sage: c.fatten(Composition([1,1,1]))
            [{2, 5}, {1}, {3, 4}]

        With ``grouping`` equal to `(\ell)` where `\ell` is the length of
        `c`, this yields the coarsest ordered set partition above `c`::

            sage: c.fatten(Composition([3]))
            [{1, 2, 3, 4, 5}]

        Other values for ``grouping`` yield (all the) other ordered
        set partitions coarser than `c`::

            sage: c.fatten(Composition([2,1]))
            [{1, 2, 5}, {3, 4}]
            sage: c.fatten(Composition([1,2]))
            [{2, 5}, {1, 3, 4}]

        TESTS::

            sage: OrderedSetPartition([]).fatten(Composition([]))
            []
            sage: c.fatten(Composition([2,1])).__class__ == c.__class__
            True
        """
        result = [None] * len(grouping)
        j = 0
        for i in range(len(grouping)):
            result[i] = set().union(*self[j:j + grouping[i]])
            j += grouping[i]
        return parent(self)(result)

    def fatter(self):
        """
        Return the set of ordered set partitions which are fatter
        than ``self``.

        See :meth:`finer` for the definition of "fatter".

        EXAMPLES::

            sage: C = OrderedSetPartition([[2, 5], [1], [3, 4]]).fatter()
            sage: C.cardinality()
            4
            sage: sorted(C)
            [[{2, 5}, {1}, {3, 4}],
             [{2, 5}, {1, 3, 4}],
             [{1, 2, 5}, {3, 4}],
             [{1, 2, 3, 4, 5}]]

            sage: OrderedSetPartition([[4, 9], [-1, 2]]).fatter().list()
            [[{4, 9}, {-1, 2}], [{-1, 2, 4, 9}]]

        Some extreme cases::

            sage: list(OrderedSetPartition([[5]]).fatter())
            [[{5}]]
            sage: list(Composition([]).fatter())
            [[]]
            sage: sorted(OrderedSetPartition([[1], [2], [3], [4]]).fatter())
            [[{1}, {2}, {3}, {4}],
             [{1}, {2}, {3, 4}],
             [{1}, {2, 3}, {4}],
             [{1}, {2, 3, 4}],
             [{1, 2}, {3}, {4}],
             [{1, 2}, {3, 4}],
             [{1, 2, 3}, {4}],
             [{1, 2, 3, 4}]]
        """
        return Compositions(len(self)).map(self.fatten)

    @staticmethod
    def bottom_up_osp(X, comp):
        r"""
        Return the ordered set partition obtained by listing the
        elements of the set ``X`` in increasing order, and
        placing bars between some of them according to the
        integer composition ``comp`` (namely, the bars are placed
        in such a way that the lengths of the resulting blocks are
        exactly the entries of ``comp``).

        INPUT:

        - ``X`` -- a finite set (or list or tuple)

        - ``comp`` -- a composition whose sum is the size of ``X``
          (can be given as a list or tuple or composition)

        EXAMPLES::

            sage: buo = OrderedSetPartition.bottom_up_osp
            sage: buo(Set([1, 4, 7, 9]), [2, 1, 1])
            [{1, 4}, {7}, {9}]
            sage: buo(Set([1, 4, 7, 9]), [1, 3])
            [{1}, {4, 7, 9}]
            sage: buo(Set([1, 4, 7, 9]), [1, 1, 1, 1])
            [{1}, {4}, {7}, {9}]
            sage: buo(range(8), [1, 4, 2, 1])
            [{0}, {1, 2, 3, 4}, {5, 6}, {7}]
            sage: buo([], [])
            []

        TESTS::

            sage: buo = OrderedSetPartition.bottom_up_osp
            sage: parent(buo(Set([1, 4, 7, 9]), [2, 1, 1]))
            Ordered set partitions of {1, 4, 9, 7}
            sage: buo((3, 5, 6), (2, 1))
            [{3, 5}, {6}]
            sage: buo([3, 5, 6], Composition([1, 2]))
            [{3}, {5, 6}]
        """
        xs = sorted(X)
        result = [None] * len(comp)
        j = 0
        for i in range(len(comp)):
            result[i] = set(xs[j:j + comp[i]])
            j += comp[i]
        return OrderedSetPartitions(X)(result)

    def strongly_finer(self):
        """
        Return the set of ordered set partitions which are strongly
        finer than ``self``.

        See :meth:`is_strongly_finer` for the definition of "strongly
        finer".

        EXAMPLES::

            sage: C = OrderedSetPartition([[1, 3], [2]]).strongly_finer()
            sage: C.cardinality()
            2
            sage: C.list()
            [[{1}, {3}, {2}], [{1, 3}, {2}]]

            sage: OrderedSetPartition([]).strongly_finer()
            {[]}

            sage: W = OrderedSetPartition([[4, 9], [-1, 2]])
            sage: W.strongly_finer().list()
            [[{4}, {9}, {-1}, {2}],
             [{4}, {9}, {-1, 2}],
             [{4, 9}, {-1}, {2}],
             [{4, 9}, {-1, 2}]]
        """
        par = parent(self)
        if not self:
            return FiniteEnumeratedSet([self])
        buo = OrderedSetPartition.bottom_up_osp
        return FiniteEnumeratedSet([par(sum((list(P) for P in C), []))
                                    for C in product(*[[buo(X, comp) for comp in Compositions(len(X))] for X in self])])

    def is_strongly_finer(self, co2):
        r"""
        Return ``True`` if the ordered set partition ``self`` is strongly
        finer than the ordered set partition ``co2``; otherwise, return
        ``False``.

        If `A` and `B` are two ordered set partitions of the same set,
        then `A` is said to be *strongly finer* than `B` if `B` can be
        obtained from `A` by (repeatedly) merging consecutive parts,
        provided that every time we merge two consecutive parts `C_i`
        and `C_{i+1}`, we have `\max C_i < \min C_{i+1}`.
        In this case, we say that `B` is *strongly fatter* than `A`.

        EXAMPLES::

            sage: A = OrderedSetPartition([[1, 3], [2]])
            sage: B = OrderedSetPartition([[1], [3], [2]])
            sage: A.is_strongly_finer(B)
            False
            sage: B.is_strongly_finer(A)
            True
            sage: C = OrderedSetPartition([[3], [1], [2]])
            sage: A.is_strongly_finer(C)
            False
            sage: C.is_strongly_finer(A)
            False
            sage: OrderedSetPartition([[2], [5], [1], [4]]).is_strongly_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            True
            sage: OrderedSetPartition([[5], [2], [1], [4]]).is_strongly_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            False
            sage: OrderedSetPartition([[2], [1], [5], [4]]).is_strongly_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            False
            sage: OrderedSetPartition([[2, 5, 1], [4]]).is_strongly_finer(OrderedSetPartition([[2, 5], [1, 4]]))
            False
        """
        co1 = self
        if co1.base_set() != co2.base_set():
            raise ValueError("ordered set partitions self (= %s) and co2 (= %s) must be of the same set" % (self, co2))

        i1 = 0
        for j2 in co2:
            sum1 = set()
            while len(sum1) < len(j2):
                next = co1[i1]
                if sum1 and max(sum1) >= min(next):
                    return False
                sum1 = sum1.union(next)
                i1 += 1
            if not sum1.issubset(j2):
                return False

        return True

    def strongly_fatter(self):
        """
        Return the set of ordered set partitions which are strongly fatter
        than ``self``.

        See :meth:`strongly_finer` for the definition of "strongly fatter".

        EXAMPLES::

            sage: C = OrderedSetPartition([[2, 5], [1], [3, 4]]).strongly_fatter()
            sage: C.cardinality()
            2
            sage: sorted(C)
            [[{2, 5}, {1}, {3, 4}], [{2, 5}, {1, 3, 4}]]

            sage: OrderedSetPartition([[4, 9], [-1, 2]]).strongly_fatter().list()
            [[{4, 9}, {-1, 2}]]

        Some extreme cases::

            sage: list(OrderedSetPartition([[5]]).strongly_fatter())
            [[{5}]]
            sage: list(OrderedSetPartition([]).strongly_fatter())
            [[]]
            sage: sorted(OrderedSetPartition([[1], [2], [3], [4]]).strongly_fatter())
            [[{1}, {2}, {3}, {4}],
             [{1}, {2}, {3, 4}],
             [{1}, {2, 3}, {4}],
             [{1}, {2, 3, 4}],
             [{1, 2}, {3}, {4}],
             [{1, 2}, {3, 4}],
             [{1, 2, 3}, {4}],
             [{1, 2, 3, 4}]]
            sage: sorted(OrderedSetPartition([[1], [3], [2], [4]]).strongly_fatter())
            [[{1}, {3}, {2}, {4}],
             [{1}, {3}, {2, 4}],
             [{1, 3}, {2}, {4}],
             [{1, 3}, {2, 4}]]
            sage: sorted(OrderedSetPartition([[4], [1], [5], [3]]).strongly_fatter())
            [[{4}, {1}, {5}, {3}], [{4}, {1, 5}, {3}]]
        """
        c = [sorted(X) for X in self]
        l = len(c) - 1
        g = [-1] + [i for i in range(l) if c[i][-1] > c[i + 1][0]] + [l]
        # g lists the positions of the blocks that cannot be merged
        # with their right neighbors.
        subcomps = [OrderedSetPartition(c[g[i] + 1: g[i + 1] + 1])
                    for i in range(len(g) - 1)]
        # Now, self is the concatenation of the entries of subcomps.
        # We can fatten each of the ordered set partitions setcomps
        # arbitrarily, and then concatenate the results.
        fattenings = [list(subcomp.fatter()) for subcomp in subcomps]
        return FiniteEnumeratedSet([OrderedSetPartition(sum([list(gg) for gg in fattening], []))
            for fattening in product(*fattenings)])

    @combinatorial_map(name='to packed word')
    def to_packed_word(self):
        r"""
        Return the packed word on alphabet `\{1,2,3,\ldots\}`
        corresponding to ``self``.

        A *packed word* on alphabet `\{1,2,3,\ldots\}` is any word whose
        maximum letter is the same as its total number of distinct letters.
        Let `P` be an ordered set partition of a set `X`.
        The corresponding packed word `w_1 w_2 \cdots w_n` is constructed
        by having letter `w_i = j` if the `i`-th smallest entry in `X`
        occurs in the `j`-th block of `P`.

        .. SEEALSO::

            :meth:`Word.to_ordered_set_partition`

        .. WARNING::

            This assumes there is a total order on the underlying
            set.

        EXAMPLES::

            sage: S = OrderedSetPartitions()
            sage: x = S([[3,5], [2], [1,4,6]])
            sage: x.to_packed_word()
            word: 321313

            sage: x = S([['a', 'c', 'e'], ['b', 'd']])
            sage: x.to_packed_word()
            word: 12121
        """
        X = sorted(self.base_set())
        out = {}
        for i in range(len(self)):
            for letter in self[i]:
                out[letter] = i
        W = Words(infinite=False)
        return W([out[letter] + 1 for letter in X])

    def number_of_inversions(self):
        r"""
        Return the number of inversions in ``self``.

        An inversion of an ordered set partition with blocks
        `[B_1,B_2, \ldots, B_k]` is a pair of letters `i` and `j` with `i < j`
        such that `i` is minimal in `B_m`, `j \in B_l`, and `l < m`.

        REFERENCES:

        - [Wilson2016]_

        EXAMPLES::

            sage: OrderedSetPartition([{2,5},{4,6},{1,3}]).number_of_inversions()
            5
            sage: OrderedSetPartition([{1,3,8},{2,4},{5,6,7}]).number_of_inversions()
            3

        TESTS::

            sage: OrderedSetPartition([{1,3,8},{2,4},{5,6,7}]).number_of_inversions().parent()
            Integer Ring
        """
        num_invs = 0
        for m, part in enumerate(self):
            i = min(part)
            for ell in range(m):
                num_invs += sum(1 for j in self[ell] if i < j)
        return ZZ(num_invs)


class OrderedSetPartitions(UniqueRepresentation, Parent):
    """
    Return the combinatorial class of ordered set partitions of ``s``.

    The optional argument ``c``, if specified, restricts the parts of
    the partition to have certain sizes (the entries of ``c``).

    EXAMPLES::

        sage: OS = OrderedSetPartitions([1,2,3,4]); OS
        Ordered set partitions of {1, 2, 3, 4}
        sage: OS.cardinality()
        75
        sage: OS.first()
        [{1}, {2}, {3}, {4}]
        sage: OS.last()
        [{1, 2, 3, 4}]
        sage: OS.random_element().parent() is OS
        True

    ::

        sage: OS = OrderedSetPartitions([1,2,3,4], [2,2]); OS
        Ordered set partitions of {1, 2, 3, 4} into parts of size [2, 2]
        sage: OS.cardinality()
        6
        sage: OS.first()
        [{1, 2}, {3, 4}]
        sage: OS.last()
        [{3, 4}, {1, 2}]
        sage: OS.list()
        [[{1, 2}, {3, 4}],
         [{1, 3}, {2, 4}],
         [{1, 4}, {2, 3}],
         [{2, 3}, {1, 4}],
         [{2, 4}, {1, 3}],
         [{3, 4}, {1, 2}]]

    ::

        sage: OS = OrderedSetPartitions("cat")
        sage: OS  # random
        Ordered set partitions of {'a', 't', 'c'}
        sage: sorted(OS.list(), key=str)
        [[{'a', 'c', 't'}],
         [{'a', 'c'}, {'t'}],
         [{'a', 't'}, {'c'}],
         [{'a'}, {'c', 't'}],
         [{'a'}, {'c'}, {'t'}],
         [{'a'}, {'t'}, {'c'}],
         [{'c', 't'}, {'a'}],
         [{'c'}, {'a', 't'}],
         [{'c'}, {'a'}, {'t'}],
         [{'c'}, {'t'}, {'a'}],
         [{'t'}, {'a', 'c'}],
         [{'t'}, {'a'}, {'c'}],
         [{'t'}, {'c'}, {'a'}]]

    TESTS::

        sage: S = OrderedSetPartitions()
        sage: x = S([[3,5], [2], [1,4,6]])
        sage: x.parent()
        Ordered set partitions
    """
    @staticmethod
    def __classcall_private__(cls, s=None, c=None):
        """
        Choose the correct parent based upon input.

        EXAMPLES::

            sage: OrderedSetPartitions(4)
            Ordered set partitions of {1, 2, 3, 4}
            sage: OrderedSetPartitions(4, [1, 2, 1])
            Ordered set partitions of {1, 2, 3, 4} into parts of size [1, 2, 1]
        """
        if s is None:
            if c is not None:
                raise NotImplementedError("cannot specify 'c' without specifying 's'")
            return OrderedSetPartitions_all()
        if isinstance(s, (int, Integer)):
            if s < 0:
                raise ValueError("s must be nonnegative")
            s = frozenset(range(1, s + 1))
        else:
            s = frozenset(s)

        if c is None:
            return OrderedSetPartitions_s(s)

        if isinstance(c, (int, Integer)):
            return OrderedSetPartitions_sn(s, c)
        if c not in Compositions(len(s)):
            raise ValueError("c must be a composition of %s" % len(s))
        return OrderedSetPartitions_scomp(s, Composition(c))

    def __init__(self, s):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: OS = OrderedSetPartitions(4)
            sage: TestSuite(OS).run()
        """
        self._set = s
        Parent.__init__(self, category=FiniteEnumeratedSets())

    def _element_constructor_(self, s):
        """
        Construct an element of ``self`` from ``s``.

        EXAMPLES::

            sage: OS = OrderedSetPartitions(4)
            sage: x = OS([[1,3],[2,4]]); x
            [{1, 3}, {2, 4}]
            sage: x.parent()
            Ordered set partitions of {1, 2, 3, 4}
        """
        if isinstance(s, OrderedSetPartition):
            raise ValueError("cannot convert %s into an element of %s" % (s, self))
        return self.element_class(self, list(s))  # HERE the parent "self" is not good

    Element = OrderedSetPartition

    def __contains__(self, x):
        """
        TESTS::

            sage: OS = OrderedSetPartitions([1,2,3,4])
            sage: all(sp in OS for sp in OS)
            True
            sage: [[1,2], [], [3,4]] in OS
            False
            sage: [Set([1,2]), Set([3,4])] in OS
            True
            sage: [set([1,2]), set([3,4])] in OS
            True

        Make sure the set really matches::

            sage: [set([5,6]), set([3,4])] in OS
            False
        """
        # x must be a list
        if not isinstance(x, (OrderedSetPartition, list, tuple)):
            return False

        # The total number of elements in the list
        # should be the same as the number is self._set
        if sum(map(len, x)) != len(self._set):
            return False

        # Check to make sure each element of the list
        # is a nonempty set
        u = set()
        for s in x:
            if not s or not isinstance(s, (set, frozenset, Set_generic)):
                return False
            u = u.union(s)

        # Make sure that the union of all the
        # sets is the original set
        if len(u) != len(self._set):
            return False
        return frozenset(u) == self._set

    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`.

        .. SEEALSO::

            :meth:`Word.to_ordered_set_partition`

        EXAMPLES::

            sage: A = OrderedSetPartitions().from_finite_word('abcabcabd'); A
            [{1, 4, 7}, {2, 5, 8}, {3, 6}, {9}]
            sage: B = OrderedSetPartitions().from_finite_word([1,2,3,1,2,3,1,2,4])
            sage: A == B
            True

        TESTS::

            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)
            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}")


class OrderedSetPartitions_s(OrderedSetPartitions):
    """
    Class of ordered partitions of a set `S`.
    """

    def _repr_(self):
        """
        TESTS::

            sage: OrderedSetPartitions([1,2,3,4])
            Ordered set partitions of {1, 2, 3, 4}
        """
        return "Ordered set partitions of %s" % Set(self._set)

    def cardinality(self):
        """
        EXAMPLES::

            sage: OrderedSetPartitions(0).cardinality()
            1
            sage: OrderedSetPartitions(1).cardinality()
            1
            sage: OrderedSetPartitions(2).cardinality()
            3
            sage: OrderedSetPartitions(3).cardinality()
            13
            sage: OrderedSetPartitions([1,2,3]).cardinality()
            13
            sage: OrderedSetPartitions(4).cardinality()
            75
            sage: OrderedSetPartitions(5).cardinality()
            541
        """
        N = len(self._set)
        return sum(factorial(k) * stirling_number2(N, k)
                   for k in range(N + 1))

    def __iter__(self):
        """
        EXAMPLES::

            sage: list(OrderedSetPartitions([1,2,3]))
            [[{1}, {2}, {3}],
             [{1}, {3}, {2}],
             [{2}, {1}, {3}],
             [{3}, {1}, {2}],
             [{2}, {3}, {1}],
             [{3}, {2}, {1}],
             [{1}, {2, 3}],
             [{2}, {1, 3}],
             [{3}, {1, 2}],
             [{1, 2}, {3}],
             [{1, 3}, {2}],
             [{2, 3}, {1}],
             [{1, 2, 3}]]

        TESTS:

        Test for :issue:`35654`::

            sage: OrderedSetPartitions(set(),[0,0,0]).list()
            [[{}, {}, {}]]
        """
        for x in Compositions(len(self._set)):
            for z in OrderedSetPartitions(self._set, x):
                yield self.element_class(self, z, check=False)


class OrderedSetPartitions_sn(OrderedSetPartitions):
    def __init__(self, s, n):
        """
        TESTS::

            sage: OS = OrderedSetPartitions([1,2,3,4], 2)
            sage: OS == loads(dumps(OS))
            True
        """
        OrderedSetPartitions.__init__(self, s)
        self.n = n

    def __contains__(self, x):
        """
        TESTS::

            sage: OS = OrderedSetPartitions([1,2,3,4], 2)
            sage: all(sp in OS for sp in OS)
            True
            sage: OS.cardinality()
            14
            sage: len([x for x in OrderedSetPartitions([1,2,3,4]) if x in OS])
            14
        """
        return OrderedSetPartitions.__contains__(self, x) and len(x) == self.n

    def __repr__(self):
        """
        TESTS::

            sage: OrderedSetPartitions([1,2,3,4], 2)
            Ordered set partitions of {1, 2, 3, 4} into 2 parts
        """
        return "Ordered set partitions of %s into %s parts" % (Set(self._set),
                                                               self.n)

    def cardinality(self):
        """
        Return the cardinality of ``self``.

        The number of ordered partitions of a set of size `n` into `k`
        parts is equal to `k! S(n,k)` where `S(n,k)` denotes the Stirling
        number of the second kind.

        EXAMPLES::

            sage: OrderedSetPartitions(4,2).cardinality()
            14
            sage: OrderedSetPartitions(4,1).cardinality()
            1
        """
        return factorial(self.n) * stirling_number2(len(self._set), self.n)

    def __iter__(self):
        """
        EXAMPLES::

            sage: [ p for p in OrderedSetPartitions([1,2,3,4], 2) ]
            [[{1, 2, 3}, {4}],
             [{1, 2, 4}, {3}],
             [{1, 3, 4}, {2}],
             [{2, 3, 4}, {1}],
             [{1, 2}, {3, 4}],
             [{1, 3}, {2, 4}],
             [{1, 4}, {2, 3}],
             [{2, 3}, {1, 4}],
             [{2, 4}, {1, 3}],
             [{3, 4}, {1, 2}],
             [{1}, {2, 3, 4}],
             [{2}, {1, 3, 4}],
             [{3}, {1, 2, 4}],
             [{4}, {1, 2, 3}]]
        """
        for x in Compositions(len(self._set), length=self.n):
            for z in OrderedSetPartitions_scomp(self._set, x):
                yield self.element_class(self, z, check=False)


class OrderedSetPartitions_scomp(OrderedSetPartitions):
    def __init__(self, s, comp):
        """
        TESTS::

            sage: OS = OrderedSetPartitions([1,2,3,4], [2,1,1])
            sage: OS == loads(dumps(OS))
            True
        """
        OrderedSetPartitions.__init__(self, s)
        self.c = Composition(comp)

    def __repr__(self):
        """
        TESTS::

            sage: OrderedSetPartitions([1,2,3,4], [2,1,1])
            Ordered set partitions of {1, 2, 3, 4} into parts of size [2, 1, 1]
        """
        return "Ordered set partitions of %s into parts of size %s" % (Set(self._set), self.c)

    def __contains__(self, x):
        """
        TESTS::

            sage: OS = OrderedSetPartitions([1,2,3,4], [2,1,1])
            sage: all(sp in OS for sp in OS)
            True
            sage: OS.cardinality()
            12
            sage: len([x for x in OrderedSetPartitions([1,2,3,4]) if x in OS])
            12
        """
        return OrderedSetPartitions.__contains__(self, x) and [len(z) for z in x] == self.c

    def cardinality(self):
        r"""
        Return the cardinality of ``self``.

        The number of ordered set partitions of a set of length `k` with
        composition shape `\mu` is equal to

        .. MATH::

            \frac{k!}{\prod_{\mu_i \neq 0} \mu_i!}.

        EXAMPLES::

            sage: OrderedSetPartitions(5,[2,3]).cardinality()
            10
            sage: OrderedSetPartitions(0, []).cardinality()
            1
            sage: OrderedSetPartitions(0, [0]).cardinality()
            1
            sage: OrderedSetPartitions(0, [0,0]).cardinality()
            1
            sage: OrderedSetPartitions(5, [2,0,3]).cardinality()
            10
        """
        return multinomial(self.c)

    def __iter__(self):
        """
        TESTS::

            sage: [ p for p in OrderedSetPartitions([1,2,3,4], [2,1,1]) ]
            [[{1, 2}, {3}, {4}],
             [{1, 2}, {4}, {3}],
             [{1, 3}, {2}, {4}],
             [{1, 4}, {2}, {3}],
             [{1, 3}, {4}, {2}],
             [{1, 4}, {3}, {2}],
             [{2, 3}, {1}, {4}],
             [{2, 4}, {1}, {3}],
             [{3, 4}, {1}, {2}],
             [{2, 3}, {4}, {1}],
             [{2, 4}, {3}, {1}],
             [{3, 4}, {2}, {1}]]

            sage: len(OrderedSetPartitions([1,2,3,4], [1,1,1,1]))
            24

            sage: [ x for x in OrderedSetPartitions([1,4,7], [3]) ]
            [[{1, 4, 7}]]

            sage: [ x for x in OrderedSetPartitions([1,4,7], [1,2]) ]
            [[{1}, {4, 7}], [{4}, {1, 7}], [{7}, {1, 4}]]

            sage: [ p for p in OrderedSetPartitions([], []) ]
            [[]]

            sage: [ p for p in OrderedSetPartitions([1], [1]) ]
            [[{1}]]

        Let us check that it works for large size (:issue:`16646`)::

            sage: OrderedSetPartitions(42).first()
            [{1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12},
            {13}, {14}, {15}, {16}, {17}, {18}, {19}, {20}, {21}, {22}, {23},
            {24}, {25}, {26}, {27}, {28}, {29}, {30}, {31}, {32}, {33}, {34},
            {35}, {36}, {37}, {38}, {39}, {40}, {41}, {42}]

        EXAMPLES::

            sage: list(OrderedSetPartitions(range(5), [2,1,2]))
            [[{0, 1}, {2}, {3, 4}],
             [{0, 1}, {3}, {2, 4}],
            ...
             [{2, 4}, {3}, {0, 1}],
             [{3, 4}, {2}, {0, 1}]]
        """
        part_sizes = self.c
        N = len(part_sizes)
        if not N:
            yield self.element_class(self, [], check=False)
            return

        l = []
        lset = list(self._set)
        for i, j in enumerate(part_sizes):
            l.extend([i] * j)

        pi = multiset_permutation_to_ordered_set_partition(l, N)
        converted = [frozenset(lset[i] for i in part) for part in pi]
        yield self.element_class(self, converted, check=False)

        while multiset_permutation_next_lex(l):
            pi = multiset_permutation_to_ordered_set_partition(l, N)
            converted = [frozenset(lset[i] for i in part) for part in pi]
            yield self.element_class(self, converted, check=False)


def multiset_permutation_to_ordered_set_partition(l, m):
    r"""
    Convert a multiset permutation to an ordered set partition.

    INPUT:

    - ``l`` -- a multiset permutation
    - ``m`` -- number of parts

    EXAMPLES::

        sage: from sage.combinat.set_partition_ordered import multiset_permutation_to_ordered_set_partition
        sage: l = [0, 0, 1, 1, 2]
        sage: multiset_permutation_to_ordered_set_partition(l, 3)
        [[0, 1], [2, 3], [4]]
    """
    p = [[] for _ in range(m)]
    for i, j in enumerate(l):
        p[j].append(i)
    return p


def multiset_permutation_next_lex(l):
    r"""
    Return the next multiset permutation after ``l``.

    EXAMPLES::

        sage: from sage.combinat.set_partition_ordered import multiset_permutation_next_lex
        sage: l = [0, 0, 1, 1, 2]
        sage: while multiset_permutation_next_lex(l):
        ....:     print(l)
        [0, 0, 1, 2, 1]
        [0, 0, 2, 1, 1]
        [0, 1, 0, 1, 2]
        [0, 1, 0, 2, 1]
        [0, 1, 1, 0, 2]
        [0, 1, 1, 2, 0]
        ...
        [1, 1, 2, 0, 0]
        [1, 2, 0, 0, 1]
        [1, 2, 0, 1, 0]
        [1, 2, 1, 0, 0]
        [2, 0, 0, 1, 1]
        [2, 0, 1, 0, 1]
        [2, 0, 1, 1, 0]
        [2, 1, 0, 0, 1]
        [2, 1, 0, 1, 0]
        [2, 1, 1, 0, 0]

    TESTS:

    Test for :issue:`35654`::

        sage: multiset_permutation_next_lex([])
        0
    """
    i = len(l) - 2
    while i >= 0 and l[i] >= l[i + 1]:
        i -= 1
    if i <= -1:
        return 0
    j = len(l) - 1
    while l[j] <= l[i]:
        j -= 1
    l[i], l[j] = l[j], l[i]
    l[i + 1:] = l[:i:-1]
    return 1


class OrderedSetPartitions_all(OrderedSetPartitions):
    r"""
    Ordered set partitions of `\{1, \ldots, n\}` for all
    `n \in \ZZ_{\geq 0}`.
    """

    def __init__(self):
        """
        Initialize ``self``.

        EXAMPLES::

            sage: OS = OrderedSetPartitions()
            sage: TestSuite(OS).run()  # long time
        """
        Parent.__init__(self, category=InfiniteEnumeratedSets())

    def subset(self, size=None, **kwargs):
        """
        Return the subset of ordered set partitions of a given
        size and additional keyword arguments.

        EXAMPLES::

            sage: P = OrderedSetPartitions()
            sage: P.subset(4)
            Ordered set partitions of {1, 2, 3, 4}
        """
        if size is None:
            return self
        return OrderedSetPartitions(size, **kwargs)

    def __iter__(self):
        """
        Iterate over ``self``.

        EXAMPLES::

            sage: it = iter(OrderedSetPartitions())
            sage: [next(it) for _ in range(10)]
            [[], [{1}], [{1}, {2}], [{2}, {1}], [{1, 2}],
             [{1}, {2}, {3}], [{1}, {3}, {2}], [{2}, {1}, {3}],
             [{3}, {1}, {2}], [{2}, {3}, {1}]]
        """
        n = 0
        while True:
            for X in OrderedSetPartitions(n):
                yield self.element_class(self, list(X), check=False)
            n += 1

    def _element_constructor_(self, s):
        """
        Construct an element of ``self`` from ``s``.

        EXAMPLES::

            sage: OS = OrderedSetPartitions()
            sage: OS([[1,3],[2,4]])
            [{1, 3}, {2, 4}]
        """
        if isinstance(s, OrderedSetPartition):
            gset = s.parent()._set
            if gset == frozenset(range(1, len(gset) + 1)):
                return self.element_class(self, list(s))
            raise ValueError("cannot convert %s into an element of %s" % (s, self))
        return self.element_class(self, list(s))

    def __contains__(self, x):
        """
        TESTS::

            sage: OS = OrderedSetPartitions([1,2,3,4])
            sage: AOS = OrderedSetPartitions()
            sage: all(sp in AOS for sp in OS)
            True
            sage: AOS.__contains__([[1,3], [4], [5,2]])
            True
            sage: AOS.__contains__([Set([1,3]), Set([4]), Set([5,2])])
            True
            sage: [Set([1,4]), Set([3])] in AOS
            False
            sage: [Set([1,3]), Set([4,2]), Set([2,5])] in AOS
            False
            sage: [Set([1,2]), Set()] in AOS
            False
        """
        if isinstance(x, OrderedSetPartition):
            if x.parent() is self:
                return True
            gset = x.parent()._set
            return gset == frozenset(range(1, len(gset) + 1))

        # x must be a list or a tuple
        if not isinstance(x, (list, tuple)):
            return False

        # Check to make sure each element of the list is a nonempty set
        if not all(s and isinstance(s, (set, frozenset, list, tuple, Set_generic)) for s in x):
            return False

        if not all(isinstance(s, (set, frozenset, Set_generic)) or len(s) == len(set(s)) for s in x):
            return False
        X = set(y for p in x for y in p)
        return len(X) == sum(len(s) for s in x) and X == frozenset(range(1, len(X) + 1))

    def _coerce_map_from_(self, X):
        """
        Return ``True`` if there is a coercion map from ``X``.

        EXAMPLES::

            sage: OSP = OrderedSetPartitions()
            sage: OSP._coerce_map_from_(OrderedSetPartitions(3))
            True
            sage: OSP._coerce_map_from_(OrderedSetPartitions(['a','b']))
            False
        """
        if X is self:
            return True
        if isinstance(X, OrderedSetPartitions):
            return X._set == frozenset(range(1, len(X._set) + 1))
        return super()._coerce_map_from_(X)

    def _repr_(self):
        """
        TESTS::

            sage: OrderedSetPartitions()
            Ordered set partitions
        """
        return "Ordered set partitions"

    class Element(OrderedSetPartition):
        def _richcmp_(self, other, op):
            """
            TESTS::

                sage: OSP = OrderedSetPartitions()
                sage: el1 = OSP([[1,3], [4], [2]])
                sage: el2 = OSP([[3,1], [2], [4]])
                sage: el1 == el1, el2 == el2, el1 == el2    # indirect doctest
                (True, True, False)
                sage: el1 <= el2, el1 >= el2, el2 <= el1    # indirect doctest
                (False, True, True)
            """
            return richcmp([sorted(s) for s in self],
                           [sorted(s) for s in other], op)

##########################################################
# Deprecations


class SplitNK(OrderedSetPartitions_scomp):
    def __setstate__(self, state):
        r"""
        For unpickling old ``SplitNK`` objects.

        TESTS::

            sage: loads(b"x\x9ck`J.NLO\xd5K\xce\xcfM\xca\xccK,\xd1+.\xc8\xc9,"
            ....:   b"\x89\xcf\xcb\xe6\n\x061\xfc\xbcA\xccBF\xcd\xc6B\xa6\xda"
            ....:   b"Bf\x8dP\xa6\xf8\xbcB\x16\x88\x96\xa2\xcc\xbc\xf4b\xbd\xcc"
            ....:   b"\xbc\x92\xd4\xf4\xd4\"\xae\xdc\xc4\xec\xd4x\x18\xa7\x905"
            ....:   b"\x94\xd1\xb45\xa8\x90\r\xa8>\xbb\x90=\x03\xc85\x02r9J\x93"
            ....:   b"\xf4\x00\xb4\xc6%f")
            Ordered set partitions of {0, 1, 2, 3, 4} into parts of size [2, 3]
        """
        self.__class__ = OrderedSetPartitions_scomp
        n = state['_n']
        k = state['_k']
        OrderedSetPartitions_scomp.__init__(self, range(state['_n']), (k, n - k))


register_unpickle_override("sage.combinat.split_nk", "SplitNK_nk", SplitNK)
