gh-pr-34970: add is_supergreedy() to linear extensions
    
This is my pull request originally created on trac, which I thought
pushing on github.
Fixes #24700
    
URL: #34970
Reported by: Rohan Garg
Reviewer(s): Dima Pasechnik, Rohan Garg, Tobias Diez

Author: Release Manager

src/doc/en/reference/references/index.rst

@@ -3821,6 +3821,10 @@ REFERENCES:
              *Bethe ansatz and inverse scattering transform in a periodic
              box-ball system*, Nuclear Phys. B **747**, no. 3 (2006), 354--397.
 
+.. [KTZ1987] Kierstead, H.A., Trotter, W.T. & Zhou, B. Representing an ordered
+             set as the intersection of super greedy linear extensions. Order 4,
+             293-311 (1987).
+             :doi:`10.1007/BF00337892`
 .. [Kuh1987] \W. Kühnel, "Minimal triangulations of Kummer varieties",
              Abh. Math. Sem. Univ. Hamburg 57 (1987), 7-20.
 

src/sage/combinat/posets/linear_extensions.py

@@ -252,6 +252,73 @@ def is_greedy(self):
                         return False
         return True
 
+    def is_supergreedy(self):
+        r"""
+        Return ``True`` if the linear extension is supergreedy.
+        
+        A linear extension `[x_1<x_2<...<x_t]` of a finite ordered
+        set `P=(P, <)` is *super greedy* if it can be obtained using
+        the following procedure: Choose `x_1` to be a minimal
+        element of `P`; suppose `x_1,...,x_i` have been chosen;
+        define `p(x)` to be the largest `j\leq i` such that `x_j<x`
+        if such a `j` exists and 0 otherwise; choose `x_{i+1}`
+        to be a minimal element of `P-\{x_1,...,x_i\}` which
+        maximizes `p`.
+
+        Informally, a linear extension is supergreedy if it "always
+        goes up and receedes the least"; in other words, supergreedy
+        linear extensions are depth-first linear extensions.
+        For more details see [KTZ1987]_.
+
+        EXAMPLES::
+        
+            sage: X = [0,1,2,3,4,5,6]
+            sage: Y = [[0,5],[1,4],[1,5],[3,6],[4,3],[5,6],[6,2]]
+            sage: P = Poset((X,Y), cover_relations = True, facade=False)
+            sage: for l in P.linear_extensions():
+            ....:     if l.is_supergreedy():
+            ....:         print(l)
+            [1, 4, 3, 0, 5, 6, 2]
+            [0, 1, 4, 3, 5, 6, 2]
+            [0, 1, 5, 4, 3, 6, 2]
+
+            sage: Q = posets.PentagonPoset()
+            sage: for l in Q.linear_extensions():
+            ....:     if not l.is_supergreedy():
+            ....:         print(l)
+            [0, 2, 1, 3, 4]
+
+        TESTS::
+
+            sage: T = Poset()
+            sage: T.linear_extensions()[0].is_supergreedy()
+            True
+        """
+        P = self.poset()
+        H = P.hasse_diagram()
+
+        def next_elements(H, linext):
+            k = len(linext)
+            S = []
+            while not S:
+                if not k:
+                    S = [x for x in H.sources() if x not in linext]
+                else:
+                    S = [x for x in H.neighbor_out_iterator(linext[k-1]) if x not in linext and all(low in linext for low in H.neighbor_in_iterator(x))]
+                    k -= 1
+            return S
+        if not self:
+            return True
+        if self[0] not in H.sources():
+            return False
+        for i in range(len(self)-2):
+            X = next_elements(H,self[:i+1])
+            if self[i+1] in X:
+                continue
+            else:
+                return False
+        return True
+    
     def tau(self, i):
         r"""
         Return the operator `\tau_i` on linear extensions ``self`` of a poset.
@@ -855,6 +922,7 @@ class LinearExtensionsOfPosetWithHooks(LinearExtensionsOfPoset):
     Linear extensions such that the poset has well-defined
     hook lengths (i.e., d-complete).
     """
+
     def cardinality(self):
         r"""
         Count the number of linear extensions using a hook-length formula.
@@ -879,6 +947,7 @@ class LinearExtensionsOfForest(LinearExtensionsOfPoset):
     r"""
     Linear extensions such that the poset is a forest.
     """
+
     def cardinality(self):
         r"""
         Use Atkinson's algorithm to compute the number of linear extensions.
@@ -902,6 +971,7 @@ class LinearExtensionsOfMobile(LinearExtensionsOfPoset):
     r"""
     Linear extensions for a mobile poset.
     """
+
     def cardinality(self):
         r"""
         Return the number of linear extensions by using the determinant