passagemath-graphs 10.6.1rc1__cp310-cp310-musllinux_1_2_aarch64.whl

sage/combinat/posets/cartesian_product.py

@@ -0,0 +1,493 @@
+# sage_setup: distribution = sagemath-graphs
+"""
+Cartesian products of posets
+
+AUTHORS:
+
+- Daniel Krenn (2015)
+"""
+# ****************************************************************************
+#  Copyright (C) 2015 Daniel Krenn <dev@danielkrenn.at>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.sets.cartesian_product import CartesianProduct
+
+
+class CartesianProductPoset(CartesianProduct):
+    r"""
+    A class implementing Cartesian products of posets (and elements
+    thereof). Compared to :class:`CartesianProduct` you are able to
+    specify an order for comparison of the elements.
+
+    INPUT:
+
+    - ``sets`` -- tuple of parents
+
+    - ``category`` -- a subcategory of ``Sets().CartesianProducts() & Posets()``
+
+    - ``order`` -- string or function specifying an order less or equal;
+      it can be one of the following:
+
+      - ``'native'`` -- elements are ordered by their native ordering,
+        i.e., the order the wrapped elements (tuples) provide
+
+      - ``'lex'`` -- elements are ordered lexicographically
+
+      - ``'product'`` -- an element is less or equal to another
+        element, if less or equal is true for all its components
+        (Cartesian projections)
+
+      - a function which performs the comparison `\leq`; it takes two
+        input arguments and outputs a boolean
+
+    Other keyword arguments (``kwargs``) are passed to the constructor
+    of :class:`CartesianProduct`.
+
+    EXAMPLES::
+
+        sage: P = Poset((srange(3), lambda left, right: left <= right))
+        sage: Cl = cartesian_product((P, P), order='lex')
+        sage: Cl((1, 1)) <= Cl((2, 0))
+        True
+        sage: Cp = cartesian_product((P, P), order='product')
+        sage: Cp((1, 1)) <= Cp((2, 0))
+        False
+        sage: def le_sum(left, right):
+        ....:     return (sum(left) < sum(right) or
+        ....:             sum(left) == sum(right) and left[0] <= right[0])
+        sage: Cs = cartesian_product((P, P), order=le_sum)
+        sage: Cs((1, 1)) <= Cs((2, 0))
+        True
+
+    TESTS::
+
+        sage: Cl.category()
+        Join of Category of finite posets and
+        Category of Cartesian products of finite enumerated sets
+        sage: TestSuite(Cl).run(skip=['_test_construction'])
+        sage: Cp.category()
+        Join of Category of finite posets and
+        Category of Cartesian products of finite enumerated sets
+        sage: TestSuite(Cp).run(skip=['_test_construction'])
+
+    .. SEEALSO::
+
+        :class:`CartesianProduct`
+    """
+
+    def __init__(self, sets, category, order=None, **kwargs) -> None:
+        r"""
+        See :class:`CartesianProductPoset` for details.
+
+        TESTS::
+
+            sage: P = Poset((srange(3), lambda left, right: left <= right))
+            sage: C = cartesian_product((P, P), order='notexisting')
+            Traceback (most recent call last):
+            ...
+            ValueError: no order 'notexisting' known
+            sage: C = cartesian_product((P, P), category=(Groups(),))
+            sage: C.category()
+            Join of Category of groups and Category of posets
+        """
+        if order is None:
+            self._le_ = self.le_product
+        elif isinstance(order, str):
+            try:
+                self._le_ = getattr(self, 'le_' + order)
+            except AttributeError:
+                raise ValueError(f"no order '{order}' known")
+        else:
+            self._le_ = order
+
+        from sage.categories.category import Category
+        from sage.categories.posets import Posets
+        if not isinstance(category, tuple):
+            category = (category,)
+        category = Category.join(category + (Posets(),))
+        super().__init__(sets, category, **kwargs)
+
+    def le(self, left, right):
+        r"""
+        Test whether ``left`` is less than or equal to ``right``.
+
+        INPUT:
+
+        - ``left`` -- an element
+
+        - ``right`` -- an element
+
+        OUTPUT: boolean
+
+        .. NOTE::
+
+            This method uses the order defined on creation of this
+            Cartesian product. See :class:`CartesianProductPoset`.
+
+        EXAMPLES::
+
+            sage: P = posets.ChainPoset(10)
+            sage: def le_sum(left, right):
+            ....:     return (sum(left) < sum(right) or
+            ....:             sum(left) == sum(right) and left[0] <= right[0])
+            sage: C = cartesian_product((P, P), order=le_sum)
+            sage: C.le(C((1, 6)), C((6, 1)))
+            True
+            sage: C.le(C((6, 1)), C((1, 6)))
+            False
+            sage: C.le(C((1, 6)), C((6, 6)))
+            True
+            sage: C.le(C((6, 6)), C((1, 6)))
+            False
+        """
+        return self._le_(left, right)
+
+    def le_lex(self, left, right):
+        r"""
+        Test whether ``left`` is lexicographically smaller or equal
+        to ``right``.
+
+        INPUT:
+
+        - ``left`` -- an element
+
+        - ``right`` -- an element
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: P = Poset((srange(2), lambda left, right: left <= right))
+            sage: Q = cartesian_product((P, P), order='lex')
+            sage: T = [Q((0, 0)), Q((1, 1)), Q((0, 1)), Q((1, 0))]
+            sage: for a in T:
+            ....:     for b in T:
+            ....:         assert Q.le(a, b) == (a <= b)
+            ....:         print('%s <= %s = %s' % (a, b, a <= b))
+            (0, 0) <= (0, 0) = True
+            (0, 0) <= (1, 1) = True
+            (0, 0) <= (0, 1) = True
+            (0, 0) <= (1, 0) = True
+            (1, 1) <= (0, 0) = False
+            (1, 1) <= (1, 1) = True
+            (1, 1) <= (0, 1) = False
+            (1, 1) <= (1, 0) = False
+            (0, 1) <= (0, 0) = False
+            (0, 1) <= (1, 1) = True
+            (0, 1) <= (0, 1) = True
+            (0, 1) <= (1, 0) = True
+            (1, 0) <= (0, 0) = False
+            (1, 0) <= (1, 1) = True
+            (1, 0) <= (0, 1) = False
+            (1, 0) <= (1, 0) = True
+
+        TESTS:
+
+        Check that :issue:`19999` is resolved::
+
+            sage: P = Poset((srange(2), lambda left, right: left <= right))
+            sage: Q = cartesian_product((P, P), order='product')
+            sage: R = cartesian_product((Q, P), order='lex')
+            sage: R(((1, 0), 0)) <= R(((0, 1), 0))
+            False
+            sage: R(((0, 1), 0)) <= R(((1, 0), 0))
+            False
+        """
+        for l, r, S in \
+                zip(left.value, right.value, self.cartesian_factors()):
+            if l == r:
+                continue
+            if S.le(l, r):
+                return True
+            if S.le(r, l):
+                return False
+            return False  # incomparable components
+        return True  # equal
+
+    def le_product(self, left, right):
+        r"""
+        Test whether ``left`` is component-wise smaller or equal
+        to ``right``.
+
+        INPUT:
+
+        - ``left`` -- an element
+
+        - ``right`` -- an element
+
+        OUTPUT: boolean
+
+        The comparison is ``True`` if the result of the
+        comparison in each component is ``True``.
+
+        EXAMPLES::
+
+            sage: P = Poset((srange(2), lambda left, right: left <= right))
+            sage: Q = cartesian_product((P, P), order='product')
+            sage: T = [Q((0, 0)), Q((1, 1)), Q((0, 1)), Q((1, 0))]
+            sage: for a in T:
+            ....:     for b in T:
+            ....:         assert Q.le(a, b) == (a <= b)
+            ....:         print('%s <= %s = %s' % (a, b, a <= b))
+            (0, 0) <= (0, 0) = True
+            (0, 0) <= (1, 1) = True
+            (0, 0) <= (0, 1) = True
+            (0, 0) <= (1, 0) = True
+            (1, 1) <= (0, 0) = False
+            (1, 1) <= (1, 1) = True
+            (1, 1) <= (0, 1) = False
+            (1, 1) <= (1, 0) = False
+            (0, 1) <= (0, 0) = False
+            (0, 1) <= (1, 1) = True
+            (0, 1) <= (0, 1) = True
+            (0, 1) <= (1, 0) = False
+            (1, 0) <= (0, 0) = False
+            (1, 0) <= (1, 1) = True
+            (1, 0) <= (0, 1) = False
+            (1, 0) <= (1, 0) = True
+        """
+        return all(
+            S.le(l, r)
+            for l, r, S in
+            zip(left.value, right.value, self.cartesian_factors()))
+
+    def le_native(self, left, right):
+        r"""
+        Test whether ``left`` is smaller or equal to ``right`` in the order
+        provided by the elements themselves.
+
+        INPUT:
+
+        - ``left`` -- an element
+
+        - ``right`` -- an element
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: P = Poset((srange(2), lambda left, right: left <= right))
+            sage: Q = cartesian_product((P, P), order='native')
+            sage: T = [Q((0, 0)), Q((1, 1)), Q((0, 1)), Q((1, 0))]
+            sage: for a in T:
+            ....:     for b in T:
+            ....:         assert Q.le(a, b) == (a <= b)
+            ....:         print('%s <= %s = %s' % (a, b, a <= b))
+            (0, 0) <= (0, 0) = True
+            (0, 0) <= (1, 1) = True
+            (0, 0) <= (0, 1) = True
+            (0, 0) <= (1, 0) = True
+            (1, 1) <= (0, 0) = False
+            (1, 1) <= (1, 1) = True
+            (1, 1) <= (0, 1) = False
+            (1, 1) <= (1, 0) = False
+            (0, 1) <= (0, 0) = False
+            (0, 1) <= (1, 1) = True
+            (0, 1) <= (0, 1) = True
+            (0, 1) <= (1, 0) = True
+            (1, 0) <= (0, 0) = False
+            (1, 0) <= (1, 1) = True
+            (1, 0) <= (0, 1) = False
+            (1, 0) <= (1, 0) = True
+        """
+        return left.value <= right.value
+
+    class Element(CartesianProduct.Element):
+
+        def _le_(self, other):
+            r"""
+            Return if this element is less or equal to ``other``.
+
+            INPUT:
+
+            - ``other`` -- an element
+
+            OUTPUT: boolean
+
+            .. NOTE::
+
+                This method calls :meth:`CartesianProductPoset.le`. Override
+                it in inherited class to change this.
+
+                It can be assumed that this element and ``other`` have
+                the same parent.
+
+            TESTS::
+
+                sage: from sage.combinat.posets.cartesian_product import CartesianProductPoset
+                sage: QQ.CartesianProduct = CartesianProductPoset  # needed until #19269 is fixed
+                sage: def le_sum(left, right):
+                ....:     return (sum(left) < sum(right) or
+                ....:             sum(left) == sum(right) and left[0] <= right[0])
+                sage: C = cartesian_product((QQ, QQ), order=le_sum)
+                sage: C((1/3, 2)) <= C((2, 1/3))  # indirect doctest
+                True
+                sage: C((1/3, 2)) <= C((2, 2))  # indirect doctest
+                True
+            """
+            return self.parent().le(self, other)
+
+        def __le__(self, other):
+            r"""
+            Return if this element is less than or equal to ``other``.
+
+            INPUT:
+
+            - ``other`` -- an element
+
+            OUTPUT: boolean
+
+            .. NOTE::
+
+                This method uses the coercion framework to find a
+                suitable common parent.
+
+                This method can be deleted once :issue:`10130` is fixed and
+                provides these methods automatically.
+
+            TESTS::
+
+                sage: from sage.combinat.posets.cartesian_product import CartesianProductPoset
+                sage: QQ.CartesianProduct = CartesianProductPoset  # needed until #19269 is fixed
+                sage: def le_sum(left, right):
+                ....:     return (sum(left) < sum(right) or
+                ....:             sum(left) == sum(right) and left[0] <= right[0])
+                sage: C = cartesian_product((QQ, QQ), order=le_sum)
+                sage: C((1/3, 2)) <= C((2, 1/3))
+                True
+                sage: C((1/3, 2)) <= C((2, 2))
+                True
+
+            The following example tests that the coercion gets involved in
+            comparisons; it can be simplified once :issue:`18182` is merged.
+            ::
+
+                sage: class MyCP(CartesianProductPoset):
+                ....:     def _coerce_map_from_(self, S):
+                ....:         if isinstance(S, self.__class__):
+                ....:             S_factors = S.cartesian_factors()
+                ....:             R_factors = self.cartesian_factors()
+                ....:             if len(S_factors) == len(R_factors):
+                ....:                 if all(r.has_coerce_map_from(s)
+                ....:                        for r,s in zip(R_factors, S_factors)):
+                ....:                     return True
+                sage: QQ.CartesianProduct = MyCP
+                sage: A = cartesian_product((QQ, ZZ), order=le_sum)
+                sage: B = cartesian_product((QQ, QQ), order=le_sum)
+                sage: A((1/2, 4)) <= B((1/2, 5))
+                True
+            """
+            from sage.structure.element import have_same_parent
+            if have_same_parent(self, other):
+                return self._le_(other)
+
+            from sage.structure.element import get_coercion_model
+            import operator
+            try:
+                return get_coercion_model().bin_op(self, other, operator.le)
+            except TypeError:
+                return False
+
+        def __ge__(self, other):
+            r"""
+            Return if this element is greater than or equal to ``other``.
+
+            INPUT:
+
+            - ``other`` -- an element
+
+            OUTPUT: boolean
+
+            .. NOTE::
+
+                This method uses the coercion framework to find a
+                suitable common parent.
+
+                This method can be deleted once :issue:`10130` is fixed and
+                provides these methods automatically.
+
+            TESTS::
+
+                sage: from sage.combinat.posets.cartesian_product import CartesianProductPoset
+                sage: QQ.CartesianProduct = CartesianProductPoset  # needed until #19269 is fixed
+                sage: def le_sum(left, right):
+                ....:     return (sum(left) < sum(right) or
+                ....:             sum(left) == sum(right) and left[0] <= right[0])
+                sage: C = cartesian_product((QQ, QQ), order=le_sum)
+                sage: C((1/3, 2)) >= C((2, 1/3))
+                False
+                sage: C((1/3, 2)) >= C((2, 2))
+                False
+            """
+            return other <= self
+
+        def __lt__(self, other):
+            r"""
+            Return if this element is less than ``other``.
+
+            INPUT:
+
+            - ``other`` -- an element
+
+            OUTPUT: boolean
+
+            .. NOTE::
+
+                This method uses the coercion framework to find a
+                suitable common parent.
+
+                This method can be deleted once :issue:`10130` is fixed and
+                provides these methods automatically.
+
+            TESTS::
+
+                sage: from sage.combinat.posets.cartesian_product import CartesianProductPoset
+                sage: QQ.CartesianProduct = CartesianProductPoset  # needed until #19269 is fixed
+                sage: def le_sum(left, right):
+                ....:     return (sum(left) < sum(right) or
+                ....:             sum(left) == sum(right) and left[0] <= right[0])
+                sage: C = cartesian_product((QQ, QQ), order=le_sum)
+                sage: C((1/3, 2)) < C((2, 1/3))
+                True
+                sage: C((1/3, 2)) < C((2, 2))
+                True
+            """
+            return not self == other and self <= other
+
+        def __gt__(self, other):
+            r"""
+            Return if this element is greater than ``other``.
+
+            INPUT:
+
+            - ``other`` -- an element
+
+            OUTPUT: boolean
+
+            .. NOTE::
+
+                This method uses the coercion framework to find a
+                suitable common parent.
+
+                This method can be deleted once :issue:`10130` is fixed and
+                provides these methods automatically.
+
+            TESTS::
+
+                sage: from sage.combinat.posets.cartesian_product import CartesianProductPoset
+                sage: QQ.CartesianProduct = CartesianProductPoset  # needed until #19269 is fixed
+                sage: def le_sum(left, right):
+                ....:     return (sum(left) < sum(right) or
+                ....:             sum(left) == sum(right) and left[0] <= right[0])
+                sage: C = cartesian_product((QQ, QQ), order=le_sum)
+                sage: C((1/3, 2)) > C((2, 1/3))
+                False
+                sage: C((1/3, 2)) > C((2, 2))
+                False
+            """
+            return not self == other and other <= self

sage/combinat/posets/d_complete.py

@@ -0,0 +1,182 @@
+# sage_setup: distribution = sagemath-graphs
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+D-complete posets
+
+AUTHORS:
+
+- Stefan Grosser (06-2020): initial implementation
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2020 Stefan Grosser <stefan.grosser1@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.misc.lazy_attribute import lazy_attribute
+from .linear_extensions import LinearExtensionsOfPosetWithHooks
+from .lattices import FiniteJoinSemilattice
+from collections import deque
+from sage.rings.integer_ring import ZZ
+from sage.misc.misc_c import prod
+
+
+class DCompletePoset(FiniteJoinSemilattice):
+    r"""
+    A d-complete poset.
+
+    D-complete posets are a class of posets introduced by Proctor
+    in [Proc1999]_. It includes common families such as shapes, shifted
+    shapes, and rooted forests. Proctor showed in [PDynk1999]_ that
+    d-complete posets have decompositions in *irreducible* posets,
+    and showed in [Proc2014]_ that d-complete posets admit a hook-length
+    formula (see :wikipedia:`Hook_length_formula`). A complete proof of
+    the hook-length formula can be found in [KY2019]_.
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.poset_examples import Posets
+        sage: P = Posets.DoubleTailedDiamond(2)
+        sage: TestSuite(P).run()
+    """
+    _lin_ext_type = LinearExtensionsOfPosetWithHooks
+    _desc = "Finite d-complete poset"
+
+    @lazy_attribute
+    def _hooks(self):
+        r"""
+        The hook lengths of the elements of the d-complete poset.
+
+        See [KY2019]_ for the definition of hook lengths for d-complete posets.
+
+        TESTS::
+
+            sage: from sage.combinat.posets.d_complete import DCompletePoset
+            sage: P = DCompletePoset(DiGraph({0: [1, 2], 1: [3], 2: [3], 3: []}))
+            sage: P._hooks
+            {0: 1, 1: 2, 2: 2, 3: 3}
+            sage: from sage.combinat.posets.poset_examples import Posets
+            sage: P = DCompletePoset(Posets.YoungDiagramPoset(Partition([3,2,1]))._hasse_diagram.reverse())
+            sage: P._hooks
+            {0: 5, 1: 3, 2: 1, 3: 3, 4: 1, 5: 1}
+        """
+        hooks = {}
+
+        min_diamond = {}  # Maps max of double-tailed diamond to min of double-tailed diamond
+        max_diamond = {}  # Maps min of double-tailed diamond to max of double-tailed diamond
+
+        H = self._hasse_diagram
+
+        diamonds, _ = H.diamonds()  # Tuples of four elements that are diamonds
+
+        diamond_index = {}  # Map max elmt of double tailed diamond to index of diamond
+
+        # Find all the double-tailed diamonds and map the mins and maxes
+        for index, d in enumerate(diamonds):
+            min_diamond[d[3]] = d[0]
+            max_diamond[d[0]] = d[3]
+            diamond_index[d[3]] = index
+
+            min_elmt = d[0]
+            max_elmt = d[3]
+
+            while True:
+                potential_min = H.neighbors_in(min_elmt)
+                potential_max = H.neighbors_out(max_elmt)
+
+                # Check if any of these make a longer double tailed diamond
+                found_diamond = False
+                for mx in potential_max:
+                    if H.in_degree(mx) != 1:
+                        continue
+                    for mn in potential_min:
+                        if len(H.all_paths(mn, mx)) == 2:
+                            # Success
+                            min_elmt = mn
+                            max_elmt = mx
+                            min_diamond[mx] = mn
+                            max_diamond[mn] = mx
+                            diamond_index[mx] = index
+                            found_diamond = True
+                            break
+                    if found_diamond:
+                        break
+                if not found_diamond:
+                    break
+        # Compute the hooks
+        queue = deque(H.sources())
+        enqueued = set()
+        while queue:
+            elmt = queue.popleft()
+            if elmt not in diamond_index:
+                hooks[elmt] = H.order_ideal_cardinality([elmt])
+            else:
+                diamond = diamonds[diamond_index[elmt]]
+                side1 = diamond[1]
+                side2 = diamond[2]
+                hooks[elmt] = hooks[side1] + hooks[side2] - hooks[min_diamond[elmt]]
+            enqueued.add(elmt)
+
+            for c in H.neighbors_out(elmt):
+                if c not in enqueued:
+                    queue.append(c)
+                    enqueued.add(c)
+
+        return {self._vertex_to_element(key): ZZ(value)
+                for (key, value) in hooks.items()}
+
+    def get_hook(self, elmt):
+        r"""
+        Return the hook length of the element ``elmt``.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.posets.d_complete import DCompletePoset
+            sage: P = DCompletePoset(DiGraph({0: [1], 1: [2]}))
+            sage: P.get_hook(1)
+            2
+        """
+        return self._hooks[elmt]
+
+    def get_hooks(self) -> dict:
+        r"""
+        Return all the hook lengths as a dictionary.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.posets.d_complete import DCompletePoset
+            sage: P = DCompletePoset(DiGraph({0: [1, 2], 1: [3], 2: [3], 3: []}))
+            sage: P.get_hooks()
+            {0: 1, 1: 2, 2: 2, 3: 3}
+            sage: from sage.combinat.posets.poset_examples import Posets
+            sage: YDP321 = Posets.YoungDiagramPoset(Partition([3,2,1]))
+            sage: P = DCompletePoset(YDP321._hasse_diagram.reverse())
+            sage: P.get_hooks()
+            {0: 5, 1: 3, 2: 1, 3: 3, 4: 1, 5: 1}
+        """
+        return dict(self._hooks)
+
+    def hook_product(self):
+        r"""
+        Return the hook product for the poset.
+
+        TESTS::
+
+            sage: from sage.combinat.posets.d_complete import DCompletePoset
+            sage: P = DCompletePoset(DiGraph({0: [1, 2], 1: [3], 2: [3], 3: []}))
+            sage: P.hook_product()
+            12
+            sage: P = DCompletePoset(posets.YoungDiagramPoset(Partition([3,2,1]),
+            ....:                    dual=True))
+            sage: P.hook_product()
+            45
+        """
+        if not self._hasse_diagram:
+            return ZZ.one()
+
+        return ZZ(prod(self._hooks.values()))