passagemath-graphs 10.6.1rc1__cp310-cp310-musllinux_1_2_aarch64.whl

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) -> int:
+        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) -> str:
+        """
+        TESTS::
+
+            sage: Poset([[1,2],[4],[3],[4],[]], facade = False)(0)._repr_()
+            '0'
+        """
+        return "%s" % str(self.element)
+
+    def _latex_(self) -> str:
+        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 not all(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]