passagemath-graphs 10.5.43__cp39-cp39-musllinux_1_2_aarch64.whl

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)
+
+        poset_hooks = {self._vertex_to_element(key): ZZ(value) for (key, value) in hooks.items()}
+        return poset_hooks
+
+    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):
+        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()))

sage/combinat/posets/elements.py

@@ -0,0 +1,273 @@
+# sage_setup: distribution = sagemath-graphs
+# sage.doctest: needs sage.modules
+r"""
+Elements of posets, lattices, semilattices, etc.
+"""
+# ****************************************************************************
+#       Copyright (C) 2008 Peter Jipsen <jipsen@chapman.edu>,
+#                          Franco Saliola <saliola@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 sage.structure.element import Element
+from sage.structure.element import have_same_parent
+
+
+class PosetElement(Element):
+
+    def __init__(self, poset, element, vertex) -> None:
+        r"""
+        Establish the parent-child relationship between ``poset``
+        and ``element``, where ``element`` is associated to the
+        vertex ``vertex`` of the Hasse diagram of the poset.
+
+        INPUT:
+
+        - ``poset`` -- a poset object
+
+        - ``element`` -- any object
+
+        - ``vertex`` -- a vertex of the Hasse diagram of the poset
+
+        TESTS::
+
+            sage: from sage.combinat.posets.elements import PosetElement
+            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)
+            sage: e = P(0)
+            sage: e.parent() is P
+            True
+            sage: TestSuite(e).run()
+        """
+        Element.__init__(self, poset)
+        if isinstance(element, self.parent().element_class):
+            self.element = element.element
+        else:
+            self.element = element
+        self.vertex = vertex
+
+    def __hash__(self):
+        r"""
+        TESTS::
+
+            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)
+            sage: e = P(0)
+            sage: hash(e)
+            0
+        """
+        return hash(self.element)
+
+    def _repr_(self):
+        """
+        TESTS::
+
+            sage: Poset([[1,2],[4],[3],[4],[]], facade = False)(0)._repr_()
+            '0'
+        """
+        return "%s" % str(self.element)
+
+    def _latex_(self):
+        r"""
+        Return the latex code of the poset element.
+
+        EXAMPLES::
+
+            sage: m = matrix(2, [1,2,3,4])
+            sage: m.set_immutable()
+            sage: P = Poset(([m],[]), facade=False)
+            sage: [e] = P
+            sage: type(e)
+            <class 'sage.combinat.posets.posets.FinitePoset_with_category.element_class'>
+            sage: latex(e)                 #indirect doctest
+            \left(\begin{array}{rr}
+            1 & 2 \\
+            3 & 4
+            \end{array}\right)
+        """
+        from sage.misc.latex import latex
+        return latex(self.element)
+
+    def __eq__(self, other):
+        """
+        TESTS::
+
+            sage: P = Poset([["a","b"],["d"],["c"],["d"],[]], facade = False)
+            sage: Q = Poset([["a","b"],["d"],["c"],[],[]], facade = False)
+            sage: P(0).__eq__(P(4))
+            False
+            sage: from sage.combinat.posets.elements import PosetElement
+            sage: PosetElement(P,0,"c") == PosetElement(P,0,"c")
+            True
+            sage: PosetElement(P,0,"c") == PosetElement(Q,0,"c")
+            False
+            sage: PosetElement(P,0,"b") == PosetElement(P,0,"c")
+            False
+
+        .. warning:: as an optimization, this only compares the parent
+           and vertex, using the invariant that, in a proper poset
+           element, ``self.element == other.element`` if and only
+           ``self.vertex == other.vertex``::
+
+            sage: PosetElement(P,1,"c") == PosetElement(P,0,"c")
+            True
+
+        Test that :issue:`12351` is fixed::
+
+            sage: P(0) == int(0)
+            False
+        """
+        # This should instead exploit unique representation, using
+        # self is other, or best inherit __eq__ from there. But there
+        # are issues around pickling and rich comparison functions.
+        return have_same_parent(self, other) \
+            and self.vertex == other.vertex
+
+    def __ne__(self, other):
+        r"""
+        TESTS::
+
+            sage: P = Poset([[1,2],[4],[3],[4],[]])
+            sage: P = Poset([["a","b"],["d"],["c"],["d"],[]])
+            sage: P(0).__ne__(P(4))
+            True
+            sage: from sage.combinat.posets.elements import PosetElement
+            sage: PosetElement(P,0,"c") != PosetElement(P,0,"c")
+            False
+            sage: PosetElement(P,0,"b") != PosetElement(P,0,"c")
+            True
+
+        For this one, see comment in :meth:`__eq__`::
+
+            sage: PosetElement(P,1,"c") != PosetElement(P,0,"c")
+            False
+        """
+        return not self == other
+
+    def _cmp(self, other):
+        """
+        TESTS::
+
+            sage: P = Poset([[1,2],[4],[3],[4],[]], facade = False)
+            sage: P(0)._cmp(P(4))
+            -1
+            sage: P(4)._cmp(P(0))
+            1
+            sage: P(0)._cmp(P(0))
+            0
+            sage: P(1)._cmp(P(2))
+        """
+        return self.parent().compare_elements(self, other)
+
+    def __lt__(self, other):
+        """
+        TESTS::
+
+            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})
+            sage: P = Poset(dag, facade = False)
+            sage: P(0) < P(1)
+            False
+            sage: P(4) < P(1)
+            False
+            sage: P(0) < P(0)
+            False
+        """
+        return self._cmp(other) == -1 or False
+
+    def __le__(self, other):
+        """
+        TESTS::
+
+            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})
+            sage: P = Poset(dag, facade = False)
+            sage: P(1) <= P(0)
+            False
+            sage: P(0) <= P(1)
+            False
+            sage: P(0) <= P(3)
+            True
+            sage: P(0) <= P(0)
+            True
+        """
+        return self == other or self._cmp(other) == -1 or False
+
+    def __gt__(self, other):
+        """
+        TESTS::
+
+            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})
+            sage: P = Poset(dag)
+            sage: P(0).__gt__(P(5))
+            False
+            sage: P(5).__gt__(P(0))
+            True
+            sage: P(0).__gt__(P(0))
+            False
+        """
+        return self._cmp(other) == 1 or False
+
+    def __ge__(self, other):
+        """
+        TESTS::
+
+            sage: dag = DiGraph({0:[2,3], 1:[3,4], 2:[5], 3:[5], 4:[5]})
+            sage: P = Poset(dag)
+            sage: P(0).__ge__(P(5))
+            False
+            sage: P(5).__ge__(P(0))
+            True
+            sage: P(0).__ge__(P(0))
+            True
+        """
+        return self == other or self._cmp(other) == 1 or False
+
+
+class MeetSemilatticeElement(PosetElement):
+    def __mul__(self, other):
+        r"""
+        Return the meet of ``self`` and ``other`` in the lattice.
+
+        EXAMPLES::
+
+            sage: D = posets.DiamondPoset(5, facade=False)
+            sage: D(1) * D(2)
+            0
+            sage: D(1) * D(1)
+            1
+            sage: D(1) * D(0)
+            0
+            sage: D(1) * D(4)
+            1
+        """
+        return self.parent().meet(self, other)
+
+
+class JoinSemilatticeElement(PosetElement):
+    def __add__(self, other):
+        r"""
+        Return the join of ``self`` and ``other`` in the lattice.
+
+        EXAMPLES::
+
+            sage: D = posets.DiamondPoset(5,facade=False)
+            sage: D(1) + D(2)
+            4
+            sage: D(1) + D(1)
+            1
+            sage: D(1) + D(4)
+            4
+            sage: D(1) + D(0)
+            1
+        """
+        return self.parent().join(self, other)
+
+
+class LatticePosetElement(MeetSemilatticeElement, JoinSemilatticeElement):
+    pass

sage/combinat/posets/forest.py

@@ -0,0 +1,30 @@
+# sage_setup: distribution = sagemath-graphs
+r"""
+Forest 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.combinat.posets.posets import FinitePoset
+from sage.combinat.posets.linear_extensions import LinearExtensionsOfForest
+
+
+class ForestPoset(FinitePoset):
+    r"""
+    A forest poset is a poset where the underlying Hasse diagram and is
+    directed acyclic graph.
+    """
+    _lin_ext_type = LinearExtensionsOfForest
+    _desc = 'Finite forest poset'

sage/combinat/posets/hasse_cython.pyx

@@ -0,0 +1,174 @@
+# sage_setup: distribution = sagemath-graphs
+# cython: binding=True
+r"""
+Some fast computations for finite posets
+"""
+# ****************************************************************************
+#       Copyright (C) 2020 Frédéric Chapoton <chapoton@unistra.fr>
+#
+# 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.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.misc.lazy_import import LazyImport
+from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet_forest
+
+coxeter_matrix_fast = LazyImport('sage.combinat.posets.hasse_cython_flint', 'coxeter_matrix_fast',
+                                 deprecation=35741)
+moebius_matrix_fast = LazyImport('sage.combinat.posets.hasse_cython_flint', 'moebius_matrix_fast',
+                                 deprecation=35741)
+
+
+class IncreasingChains(RecursivelyEnumeratedSet_forest):
+    r"""
+    The enumerated set of increasing chains.
+
+    INPUT:
+
+    - ``positions`` -- list of sets of integers describing the poset,
+      as given by the lazy attribute ``_leq_storage`` of Hasse diagrams
+
+    - ``element_constructor`` -- used to determine the type of chains,
+      for example :class:`list` or :class:`tuple`
+
+    - ``exclude`` -- list of integers that should not belong to the chains
+
+    - ``conversion`` -- (optional) list of elements of the poset
+
+    If ``conversion`` is provided, it is used to convert chain elements
+    to elements of this list.
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.hasse_cython import IncreasingChains
+        sage: D = IncreasingChains([{0,1},{1}], list, []); D
+        An enumerated set with a forest structure
+        sage: D.cardinality()
+        4
+        sage: list(D)
+        [[], [0], [0, 1], [1]]
+    """
+    def __init__(self, list positions, element_constructor,
+                 list exclude, conversion=None):
+        """
+        The enumerated set of increasing chains.
+
+        TESTS::
+
+            sage: from sage.combinat.posets.hasse_cython import IncreasingChains
+            sage: D = IncreasingChains([{0,1},{1}], list, [])
+            sage: TestSuite(D).run(skip='_test_pickling')
+        """
+        cdef int i
+        cdef Py_ssize_t n = len(positions)
+        self._n = n
+        if exclude is not None:
+            self._greater_than = [gti.difference(exclude) for gti in positions]
+            self._vertices = [u for u in range(n) if u not in exclude]
+        else:
+            self._greater_than = positions
+            self._vertices = list(range(n))
+
+        self._constructor = element_constructor
+        self._conversion = conversion
+        if conversion is not None:
+            self._from_poset = {elt: i for i, elt in enumerate(conversion)}
+
+        self._roots = (tuple(),)
+
+        RecursivelyEnumeratedSet_forest.__init__(self, algorithm='depth',
+                    category=FiniteEnumeratedSets())
+
+    def __contains__(self, tup):
+        """
+        Membership testing.
+
+        If ``conversion`` was provided, it first converts elements of ``tup``
+        to integers.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.posets.hasse_cython import IncreasingChains
+            sage: D = IncreasingChains([{0,1},{1}], list, [])
+            sage: all(x in D for x in D)
+            True
+            sage: [2] in D
+            False
+            sage: [1,1] in D
+            False
+
+            sage: P = Poset({'a':['b'],'b':[]})
+            sage: ['a'] in P.chains()
+            True
+
+        TESTS::
+
+            sage: from sage.combinat.posets.hasse_cython import IncreasingChains
+            sage: D = IncreasingChains([{0,1},{1}], list, [])
+            sage: all(tuple(x) in D for x in D)
+            True
+        """
+        cdef int k
+        cdef Py_ssize_t i, x, y
+        if not tup:
+            return True
+        if self._conversion is not None:
+            tup = [self._from_poset[elt] for elt in tup]
+        if any(not(0 <= i < self._n) for i in tup):
+            return False
+        y = tup[0]
+        for k in range(1, len(tup)):
+            x = y
+            y = tup[k]
+            if x == y or y not in self._greater_than[x]:
+                return False
+        return True
+
+    def post_process(self, chain):
+        """
+        Create a chain from the internal object.
+
+        If ``conversion`` was provided, it first converts elements of the
+        chain to elements of this list.
+
+        Then the given ``element_constructor`` is applied to the chain.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.posets.hasse_cython import IncreasingChains
+            sage: D = IncreasingChains([{0,1},{1}], list, [])
+            sage: D.post_process((0,1))
+            [0, 1]
+
+            sage: P = Poset({'a':['b'],'b':[]})
+            sage: list(P.chains())
+            [[], ['a'], ['a', 'b'], ['b']]
+        """
+        cdef Py_ssize_t i
+        if self._conversion is not None:
+            return self._constructor(self._conversion[i] for i in chain)
+        return self._constructor(chain)
+
+    def children(self, chain):
+        """
+        Return the children of a chain, by adding one largest element.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.posets.hasse_cython import IncreasingChains
+            sage: D = IncreasingChains([{0,1},{1}], list, [])
+            sage: D.children((0,))
+            [(0, 1)]
+
+            sage: P = Poset({'a':['b'],'b':[]})
+            sage: next(iter(P.chains()))
+            []
+        """
+        cdef Py_ssize_t x, y
+        if not chain:
+            return [(x,) for x in self._vertices]
+        x = chain[-1]
+        return [chain + (y,) for y in self._greater_than[x] if x != y]