passagemath-graphs 10.5.39__cp312-cp312-musllinux_1_2_aarch64.whl → 10.6.1rc1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/combinat/posets/linear_extensions.py

@@ -1,16 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Linear Extensions of Posets
-
-This module defines two classes:
-
-- :class:`LinearExtensionOfPoset`
-- :class:`LinearExtensionsOfPoset`
-- :class:`LinearExtensionsOfPosetWithHooks`
-- :class:`LinearExtensionsOfForest`
-
-Classes and methods
--------------------
+Linear extensions of posets
 """
 # ****************************************************************************
 #       Copyright (C) 2012 Anne Schilling <anne at math.ucdavis.edu>
@@ -131,7 +121,7 @@ class LinearExtensionOfPoset(ClonableArray,
             return linear_extension
         return LinearExtensionsOfPoset(poset)(linear_extension)
 
-    def check(self):
+    def check(self) -> None:
         r"""
         Check whether ``self`` is indeed a linear extension of the underlying poset.
 
@@ -162,7 +152,7 @@ class LinearExtensionOfPoset(ClonableArray,
         """
         return self.parent().poset()
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return the latex string for ``self``.
 
@@ -218,12 +208,12 @@ class LinearExtensionOfPoset(ClonableArray,
             True
         """
         P = self.parent().poset()
-        old = [P.unwrap(x) for x in self]
+        old = (P.unwrap(x) for x in self)
         new = [P.unwrap(x) for x in P]
         relabelling = dict(zip(old, new))
         return P.relabel(relabelling).with_linear_extension(new)
 
-    def is_greedy(self):
+    def is_greedy(self) -> bool:
         r"""
         Return ``True`` if the linear extension is greedy.
 
@@ -257,7 +247,7 @@ class LinearExtensionOfPoset(ClonableArray,
                         return False
         return True
 
-    def is_supergreedy(self):
+    def is_supergreedy(self) -> bool:
         r"""
         Return ``True`` if the linear extension is supergreedy.
 
@@ -431,7 +421,7 @@ class LinearExtensionOfPoset(ClonableArray,
                 self = self.tau(j)
         return self
 
-    def jump_count(self):
+    def jump_count(self) -> int:
         r"""
         Return the number of jumps in the linear extension.
 
@@ -551,7 +541,7 @@ class LinearExtensionsOfPoset(UniqueRepresentation, Parent):
             facade = (list,)
         Parent.__init__(self, category=FiniteEnumeratedSets(), facade=facade)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         TESTS::
 
@@ -710,7 +700,7 @@ class LinearExtensionsOfPoset(UniqueRepresentation, Parent):
         return (isinstance(obj, (list, tuple)) and
                 self.poset().is_linear_extension(obj))
 
-    def markov_chain_digraph(self, action='promotion', labeling='identity'):
+    def markov_chain_digraph(self, action='promotion', labeling='identity') -> DiGraph:
         r"""
         Return the digraph of the action of generalized promotion or tau on ``self``.
 
@@ -747,7 +737,6 @@ class LinearExtensionsOfPoset(UniqueRepresentation, Parent):
              ([2, 1, 3, 4], [1, 2, 4, 3], 1), ([2, 1, 3, 4], [2, 1, 3, 4], 4), ([2, 1, 3, 4], [2, 1, 4, 3], 2),
              ([2, 1, 3, 4], [2, 1, 4, 3], 3), ([2, 1, 4, 3], [1, 4, 2, 3], 1), ([2, 1, 4, 3], [2, 1, 3, 4], 2),
              ([2, 1, 4, 3], [2, 1, 3, 4], 3), ([2, 1, 4, 3], [2, 1, 4, 3], 4)]
-
             sage: G = L.markov_chain_digraph(labeling='source')
             sage: G.vertices(sort=True, key=repr)
             [[1, 2, 3, 4], [1, 2, 4, 3], [1, 4, 2, 3], [2, 1, 3, 4], [2, 1, 4, 3]]
@@ -909,11 +898,10 @@ class LinearExtensionsOfPoset(UniqueRepresentation, Parent):
             lst = list(lst)
         if not isinstance(lst, (list, tuple)):
             raise TypeError("input should be a list or tuple")
-        lst = [self._poset(_) for _ in lst]
+        lst = [self._poset(e) for e in lst]
         if self._is_facade:
             return lst
-        else:
-            return self.element_class(self, lst, check)
+        return self.element_class(self, lst, check)
 
     Element = LinearExtensionOfPoset
 

sage/combinat/posets/moebius_algebra.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.modules
 r"""
-Möbius Algebras
+Möbius algebras
 """
 # ****************************************************************************
 #       Copyright (C) 2014 Travis Scrimshaw <tscrim at ucdavis.edu>,
@@ -114,7 +114,7 @@ class MoebiusAlgebra(Parent, UniqueRepresentation):
         self._category = cat
         Parent.__init__(self, base=R, category=self._category.WithRealizations())
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -412,7 +412,7 @@ class QuantumMoebiusAlgebra(Parent, UniqueRepresentation):
         self._category = cat
         Parent.__init__(self, base=R, category=self._category.WithRealizations())
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -694,7 +694,7 @@ class MoebiusAlgebraBases(Category_realization_of_parent):
         sage: M.E() in bases
         True
     """
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return the representation of ``self``.
 
@@ -725,7 +725,7 @@ class MoebiusAlgebraBases(Category_realization_of_parent):
         return [self.base()._category, Realizations(self.base())]
 
     class ParentMethods:
-        def _repr_(self):
+        def _repr_(self) -> str:
             """
             Text representation of this basis of a Möbius algebra.
 

sage/combinat/posets/poset_examples.py

@@ -30,15 +30,17 @@ The infinite set of all posets can be used to find minimal examples::
 
     :meth:`~Posets.AntichainPoset` | Return an antichain on `n` elements.
     :meth:`~Posets.BooleanLattice` | Return the Boolean lattice on `2^n` elements.
+    :meth:`~Posets.BubblePoset` | Return the Bubble lattice for `(m,n)`.
     :meth:`~Posets.ChainPoset` | Return a chain on `n` elements.
     :meth:`~Posets.Crown` | Return the crown poset on `2n` elements.
     :meth:`~Posets.DexterSemilattice` | Return the Dexter semilattice.
     :meth:`~Posets.DiamondPoset` | Return the lattice of rank two on `n` elements.
     :meth:`~Posets.DivisorLattice` | Return the divisor lattice of an integer.
     :meth:`~Posets.DoubleTailedDiamond` | Return the double tailed diamond poset on `2n + 2` elements.
+    :meth:`~Posets.HochschildLattice` | Return the Hochschild lattice for `n`.
     :meth:`~Posets.IntegerCompositions` | Return the poset of integer compositions of `n`.
     :meth:`~Posets.IntegerPartitions` | Return the poset of integer partitions of ``n``.
-    :meth:`~Posets.IntegerPartitionsDominanceOrder` | Return the lattice of integer partitions on the integer `n` ordered by dominance.
+    :meth:`~Posets.IntegerPartitionsDominanceOrder` | Return the lattice of integer partitions of the integer `n` ordered by dominance.
     :meth:`~Posets.MobilePoset` | Return the mobile poset formed by the `ribbon` with `hangers` below and an `anchor` above.
     :meth:`~Posets.NoncrossingPartitions` | Return the poset of noncrossing partitions of a finite Coxeter group ``W``.
     :meth:`~Posets.PentagonPoset` | Return the Pentagon poset.
@@ -53,6 +55,7 @@ The infinite set of all posets can be used to find minimal examples::
     :meth:`~Posets.RestrictedIntegerPartitions` | Return the poset of integer partitions of `n`, ordered by restricted refinement.
     :meth:`~Posets.SetPartitions` | Return the poset of set partitions of the set `\{1,\dots,n\}`.
     :meth:`~Posets.ShardPoset` | Return the shard intersection order.
+    :meth:`~Posets.ShufflePoset` | Return the Shuffle lattice for `(m,n)`.
     :meth:`~Posets.SSTPoset` | Return the poset on semistandard tableaux of shape `s` and largest entry `f` that is ordered by componentwise comparison.
     :meth:`~Posets.StandardExample` | Return the standard example of a poset with dimension `n`.
     :meth:`~Posets.SymmetricGroupAbsoluteOrderPoset` | The poset of permutations with respect to absolute order.
@@ -100,6 +103,7 @@ from sage.misc.classcall_metaclass import ClasscallMetaclass
 import sage.categories.posets
 from sage.combinat.permutation import Permutations, Permutation, to_standard
 from sage.combinat.posets.posets import Poset, FinitePoset, FinitePosets_n
+from sage.combinat.posets import bubble_shuffle, hochschild_lattice
 from sage.combinat.posets.d_complete import DCompletePoset
 from sage.combinat.posets.mobile import MobilePoset as Mobile
 from sage.combinat.posets.lattices import (LatticePoset, MeetSemilattice,
@@ -281,6 +285,12 @@ class Posets(metaclass=ClasscallMetaclass):
                                   category=FiniteLatticePosets(),
                                   facade=facade)
 
+    BubblePoset = staticmethod(bubble_shuffle.BubblePoset)
+
+    ShufflePoset = staticmethod(bubble_shuffle.ShufflePoset)
+
+    HochschildLattice = staticmethod(hochschild_lattice.hochschild_lattice)
+
     @staticmethod
     def ChainPoset(n, facade=None):
         r"""
@@ -465,11 +475,11 @@ class Posets(metaclass=ClasscallMetaclass):
 
     @staticmethod
     def DivisorLattice(n, facade=None):
-        """
+        r"""
         Return the divisor lattice of an integer.
 
-        Elements of the lattice are divisors of `n` and `x < y` in the
-        lattice if `x` divides `y`.
+        Elements of the lattice are divisors of `n`, and we have
+        `x \leq y` in the lattice if `x` divides `y`.
 
         INPUT:
 
@@ -502,15 +512,52 @@ class Posets(metaclass=ClasscallMetaclass):
                                   category=FiniteLatticePosets())
 
     @staticmethod
-    def IntegerCompositions(n):
+    def HessenbergPoset(H):
+        r"""
+        Return the poset associated to a Hessenberg function ``H``.
+
+        A *Hessenberg function* (of length `n`) is a function `H: \{1,\ldots,n\}
+        \to \{1,\ldots,n\}` such that `\max(i, H(i-1)) \leq H(i) \leq n` for all
+        `i` (where `H(0) = 0` by convention). The corresponding poset is given
+        by `i < j` (in the poset) if and only if `H(i) < j` (as integers).
+        These posets correspond to the natural unit interval order posets.
+
+        INPUT:
+
+        - ``H`` -- list of the Hessenberg function values
+          (without `H(0)`)
+
+        EXAMPLES::
+
+            sage: P = posets.HessenbergPoset([2, 3, 5, 5, 5]); P
+            Finite poset containing 5 elements
+            sage: P.cover_relations()
+            [[2, 4], [2, 5], [1, 3], [1, 4], [1, 5]]
+
+        TESTS::
+
+            sage: P = posets.HessenbergPoset([2, 2, 6, 4, 5, 6])
+            Traceback (most recent call last):
+            ...
+            ValueError: [2, 2, 6, 4, 5, 6] is not a Hessenberg function
+            sage: P = posets.HessenbergPoset([]); P
+            Finite poset containing 0 elements
         """
+        n = len(H)
+        if not all(max(i+1, H[i-1]) <= H[i] for i in range(1, n)) or 0 < n < H[-1]:
+            raise ValueError(f"{H} is not a Hessenberg function")
+        return Poset((tuple(range(1, n+1)), lambda i, j: H[i-1] < j))
+
+    @staticmethod
+    def IntegerCompositions(n):
+        r"""
         Return the poset of integer compositions of the integer ``n``.
 
         A composition of a positive integer `n` is a list of positive
         integers that sum to `n`. The order is reverse refinement:
-        `[p_1,p_2,...,p_l] < [q_1,q_2,...,q_m]` if `q` consists
-        of an integer composition of `p_1`, followed by an integer
-        composition of `p_2`, and so on.
+        `p = [p_1,p_2,...,p_l] \leq q = [q_1,q_2,...,q_m]` if `q`
+        consists of an integer composition of `p_1`, followed by an
+        integer composition of `p_2`, and so on.
 
         EXAMPLES::
 
@@ -527,7 +574,7 @@ class Posets(metaclass=ClasscallMetaclass):
     @staticmethod
     def IntegerPartitions(n):
         """
-        Return the poset of integer partitions on the integer ``n``.
+        Return the poset of integer partitions of the integer ``n``.
 
         A partition of a positive integer `n` is a non-increasing list
         of positive integers that sum to `n`. If `p` and `q` are
@@ -566,7 +613,7 @@ class Posets(metaclass=ClasscallMetaclass):
     @staticmethod
     def RestrictedIntegerPartitions(n):
         """
-        Return the poset of integer partitions on the integer `n`
+        Return the poset of integer partitions of the integer `n`
         ordered by restricted refinement.
 
         That is, if `p` and `q` are integer partitions of `n`, then
@@ -605,12 +652,12 @@ class Posets(metaclass=ClasscallMetaclass):
     @staticmethod
     def IntegerPartitionsDominanceOrder(n):
         r"""
-        Return the lattice of integer partitions on the integer `n`
+        Return the lattice of integer partitions of the integer `n`
         ordered by dominance.
 
         That is, if `p=(p_1,\ldots,p_i)` and `q=(q_1,\ldots,q_j)` are
-        integer partitions of `n`, then `p` is greater than `q` if and
-        only if `p_1+\cdots+p_k > q_1+\cdots+q_k` for all `k`.
+        integer partitions of `n`, then `p \geq q` if and
+        only if `p_1+\cdots+p_k \geq q_1+\cdots+q_k` for all `k`.
 
         INPUT:
 
@@ -1433,16 +1480,16 @@ class Posets(metaclass=ClasscallMetaclass):
                 return ((a[0] == b[0] + 1 and a[1] == b[1]) or
                         (a[1] == b[1] + 1 and a[0] == b[0]))
             return JoinSemilattice((lam.cells(), cell_geq), cover_relations=True)
-        else:
-            def cell_leq(a, b):
-                """
-                Nested function that returns ``True`` if the cell `a` is
-                to the left or above
-                the cell `b` in the (English) Young diagram.
-                """
-                return ((a[0] == b[0] - 1 and a[1] == b[1]) or
-                        (a[1] == b[1] - 1 and a[0] == b[0]))
-            return MeetSemilattice((lam.cells(), cell_leq), cover_relations=True)
+
+        def cell_leq(a, b):
+            """
+            Nested function that returns ``True`` if the cell `a` is
+            to the left or above
+            the cell `b` in the (English) Young diagram.
+            """
+            return ((a[0] == b[0] - 1 and a[1] == b[1]) or
+                    (a[1] == b[1] - 1 and a[0] == b[0]))
+        return MeetSemilattice((lam.cells(), cell_leq), cover_relations=True)
 
     @staticmethod
     def YoungsLattice(n):