Merge branch 'u/chapoton/29857' in 9.2.b2

Author: fchapoton

src/sage/combinat/posets/hasse_diagram.py

@@ -15,8 +15,6 @@
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
-from __future__ import print_function
-
 from sage.graphs.digraph import DiGraph
 from sage.matrix.constructor import matrix
 from sage.rings.integer_ring import ZZ
@@ -162,17 +160,16 @@ def greedy_rec(H, linext):
 
             S = []
             if linext:
-                S = [x for x in H.neighbors_out(linext[-1])
-                     if all(low in linext for low in H.neighbors_in(x))]
+                S = [x for x in H.neighbor_out_iterator(linext[-1])
+                     if all(low in linext for low in H.neighbor_in_iterator(x))]
             if not S:
                 S_ = set(self).difference(set(linext))
                 S = [x for x in S_
-                     if not any(low in S_ for low in self.neighbors_in(x))]
+                     if not any(low in S_
+                                for low in self.neighbor_in_iterator(x))]
 
             for e in S:
-                # Python3-todo: use yield from
-                for tmp in greedy_rec(H, linext + [e]):
-                    yield tmp
+                yield from greedy_rec(H, linext + [e])
 
         return greedy_rec(self, [])
 
@@ -228,16 +225,14 @@ def supergreedy_rec(H, linext):
                     if not k:  # Start from new minimal element
                         S = [x for x in self.sources() if x not in linext]
                     else:
-                        S = [x for x in self.neighbors_out(linext[k - 1])
+                        S = [x for x in self.neighbor_out_iterator(linext[k - 1])
                              if x not in linext and
                              all(low in linext
-                                 for low in self.neighbors_in(x))]
+                                 for low in self.neighbor_in_iterator(x))]
                         k -= 1
 
                 for e in S:
-                    # Python3-todo: use yield from
-                    for tmp in supergreedy_rec(H, linext + [e]):
-                        yield tmp
+                    yield from supergreedy_rec(H, linext + [e])
 
         return supergreedy_rec(self, [])
 
@@ -255,15 +250,10 @@ def is_linear_extension(self, lin_ext=None):
             False
         """
         if lin_ext is None or lin_ext == list(range(len(self))):
-            for x, y in self.cover_relations_iterator():
-                if not x < y:
-                    return False
-            return True
+            return all(x < y for x, y in self.cover_relations_iterator())
         else:
-            for x, y in self.cover_relations_iterator():
-                if not lin_ext.index(x) < lin_ext.index(y):
-                    return False
-            return True
+            return all(lin_ext.index(x) < lin_ext.index(y)
+                       for x, y in self.cover_relations_iterator())
 
     def cover_relations_iterator(self):
         r"""
@@ -276,8 +266,7 @@ def cover_relations_iterator(self):
             sage: list(H.cover_relations_iterator())
             [(0, 2), (0, 3), (1, 3), (1, 4), (2, 5), (3, 5), (4, 5)]
         """
-        for u, v, l in self.edge_iterator():
-            yield (u, v)
+        yield from self.edge_iterator(labels=False)
 
     def cover_relations(self):
         r"""
@@ -322,7 +311,7 @@ def is_lequal(self, i, j):
 
     def is_less_than(self, x, y):
         r"""
-        Return ``True`` if ``x`` is less than or equal to ``y`` in the
+        Return ``True`` if ``x`` is less than but not equal to ``y`` in the
         poset, and ``False`` otherwise.
 
         EXAMPLES::
@@ -599,13 +588,11 @@ def _precompute_intervals(self):
             True
         """
         n = self.order()
-
-        v_up = [frozenset(self.depth_first_search(v)) for v in range(n)]
+        v_up = (frozenset(self.depth_first_search(v)) for v in range(n))
         v_down = [frozenset(self.depth_first_search(v, neighbors=self.neighbors_in))
                   for v in range(n)]
         self._intervals = [[sorted(up.intersection(down)) for down in v_down]
                            for up in v_up]
-
         self.interval = self._alternate_interval
 
     def _alternate_interval(self, x, y):
@@ -628,7 +615,6 @@ def _alternate_interval(self, x, y):
             sage: P._hasse_diagram._precompute_intervals()
             sage: P.interval(1, 7)  # Uses this function
             [1, 3, 5, 7]
-
         """
         return self._intervals[x][y]
 
@@ -678,7 +664,7 @@ def open_interval(self, x, y):
             []
         """
         ci = self.interval(x, y)
-        if len(ci) == 0:
+        if not ci:
             return []
         else:
             return ci[1:-1]
@@ -785,12 +771,12 @@ def _rank(self):
                 # look at the neighbors of y and set the ranks;
                 # then look at the neighbors of the neighbors ...
                 y = queue.pop()
-                for x in self.neighbors_out(y):
+                for x in self.neighbor_out_iterator(y):
                     if rank[x] is None:
                         rank[x] = rank[y] + 1
                         queue.add(x)
                         component.add(x)
-                for x in self.neighbors_in(y):
+                for x in self.neighbor_in_iterator(y):
                     if rank[x] is None:
                         rank[x] = rank[y] - 1
                         queue.add(x)
@@ -1100,7 +1086,7 @@ def order_filter(self, elements):
             sage: H.order_filter([3,8])
             [3, 7, 8, 9, 10, 11, 12, 13, 14, 15]
         """
-        return sorted(list(self.depth_first_search(elements)))
+        return sorted(self.depth_first_search(elements))
 
     def principal_order_filter(self, i):
         """
@@ -1127,8 +1113,8 @@ def order_ideal(self, elements):
             sage: H.order_ideal([7,10])
             [0, 1, 2, 3, 4, 5, 6, 7, 8, 10]
         """
-        return sorted(list(
-            self.depth_first_search(elements, neighbors=self.neighbors_in)))
+        return sorted(self.depth_first_search(elements,
+                                              neighbors=self.neighbors_in))
 
     def principal_order_ideal(self, i):
         """
@@ -1159,7 +1145,7 @@ def _leq_storage(self):
         greater_than = [set([i]) for i in range(n)]
         for i in range(n - 1, -1, -1):
             gt = greater_than[i]
-            for j in self.neighbors_out(i):
+            for j in self.neighbor_out_iterator(i):
                 gt = gt.union(greater_than[j])
             greater_than[i] = gt
 
@@ -1968,13 +1954,12 @@ def recursive_fit(orthocomplements, unbinded):
                     new_unbinded = unbinded[1:]  # Remove next_to_fit
                     new_unbinded.remove(e)
 
-                    for i_want_python3_yield_from in recursive_fit(new_binded, new_unbinded):
-                        yield i_want_python3_yield_from
+                    yield from recursive_fit(new_binded, new_unbinded)
 
         start = [None] * n
         # A little optimization
         for e in range(n):
-            if len(comps[e]) == 0:  # Not any possible orthocomplement
+            if not comps[e]:  # Not any possible orthocomplement
                 return
             if len(comps[e]) == 1:  # Do not re-fit this every time
                 e_ = comps[e][0]
@@ -1989,8 +1974,7 @@ def recursive_fit(orthocomplements, unbinded):
                     start[e_] = e
         start_unbinded = [e for e in range(n) if start[e] is None]
 
-        for i_want_python3_yield_from in recursive_fit(start, start_unbinded):
-            yield i_want_python3_yield_from
+        yield from recursive_fit(start, start_unbinded)
 
     def find_nonsemimodular_pair(self, upper):
         """
@@ -2311,7 +2295,6 @@ def sublattices_iterator(self, elms, min_e):
             sage: next(it)
             {0}
         """
-        # Python3-note: "yield from" would be simpler.
         yield elms
         for e in range(min_e, self.cardinality()):
             if e in elms:
@@ -2329,8 +2312,7 @@ def sublattices_iterator(self, elms, min_e):
                     gens.add(self._join[x, g])
                 current_set.add(g)
             else:
-                for x in self.sublattices_iterator(current_set, e + 1):
-                    yield x
+                yield from self.sublattices_iterator(current_set, e + 1)
 
     def maximal_sublattices(self):
         """
@@ -2498,10 +2480,10 @@ def kappa_dual(self, a):
         if self.in_degree(uc) == 1:
             return uc
         lt_a = set(self.depth_first_search(a, neighbors=self.neighbors_in))
-        tmp = list(self.depth_first_search(uc, neighbors=lambda v: [v_ for v_ in self.neighbors_in(v) if v_ not in lt_a]))
+        tmp = list(self.depth_first_search(uc, neighbors=lambda v: [v_ for v_ in self.neighbor_in_iterator(v) if v_ not in lt_a]))
         result = None
         for e in tmp:
-            if all(x not in tmp for x in self.neighbors_in(e)):
+            if all(x not in tmp for x in self.neighbor_in_iterator(e)):
                 if result:
                     return None
                 result = e
@@ -2738,10 +2720,10 @@ def kappa(self, a):
         if self.out_degree(lc) == 1:
             return lc
         gt_a = set(self.depth_first_search(a))
-        tmp = list(self.depth_first_search(lc, neighbors=lambda v: [v_ for v_ in self.neighbors_out(v) if v_ not in gt_a]))
+        tmp = list(self.depth_first_search(lc, neighbors=lambda v: [v_ for v_ in self.neighbor_out_iterator(v) if v_ not in gt_a]))
         result = None
         for e in tmp:
-            if all(x not in tmp for x in self.neighbors_out(e)):
+            if all(x not in tmp for x in self.neighbor_out_iterator(e)):
                 if result:
                     return None
                 result = e

src/sage/combinat/posets/posets.py

@@ -719,7 +719,7 @@ def Poset(data=None, element_labels=None, cover_relations=False, linear_extensio
             vertices = sorted(set(x for item in data for x in item))
             if len(vertices) != len(data):
                 # by default, assuming vertices are the range 0..n
-                vertices = list(range(len(data)))
+                vertices = range(len(data))
             D = DiGraph({v: [u for u in cov if u != v]
                          for v, cov in zip(vertices, data)},
                         format="dict_of_lists")
@@ -1556,7 +1556,7 @@ def linear_extension(self, linear_extension=None, check=True):
     @cached_method
     def linear_extensions(self, facade=False):
         """
-        Return the enumerated set of all the linear extensions of this poset
+        Return the enumerated set of all the linear extensions of this poset.
 
         INPUT:
 
@@ -1776,7 +1776,7 @@ def atkinson(self, a):
 
     def is_linear_extension(self, l):
         """
-        Return whether ``l`` is a linear extension of ``self``
+        Return whether ``l`` is a linear extension of ``self``.
 
         INPUT:
 
@@ -3126,7 +3126,7 @@ def is_EL_labelling(self, f, return_raising_chains=False):
             if max_chains[0] != sorted(max_chains[0]) or any( max_chains[i] == sorted(max_chains[i]) for i in range(1,len(max_chains)) ):
                 return False
             elif return_raising_chains:
-                raising_chains[(a,b)] = max_chains[0]
+                raising_chains[(a, b)] = max_chains[0]
         if return_raising_chains:
             return raising_chains
         else:
@@ -5889,9 +5889,9 @@ def with_linear_extension(self, linear_extension):
                            category=self.category(),
                            facade=self._is_facade)
 
-    def graphviz_string(self,graph_string="graph",edge_string="--"):
+    def graphviz_string(self, graph_string="graph", edge_string="--"):
         r"""
-        Returns a representation in the DOT language, ready to render in
+        Return a representation in the DOT language, ready to render in
         graphviz.
 
         See http://www.graphviz.org/doc/info/lang.html for more information
@@ -6188,7 +6188,7 @@ def random_linear_extension(self):
             new = mins[new_index]
             result.append(new)
             mins = mins[:new_index]+mins[new_index+1:]
-            for u in H.neighbors_out(new):
+            for u in H.neighbor_out_iterator(new):
                 indegs[u] -= 1
                 if indegs[u] == 0:
                     mins.append(u)
@@ -6223,7 +6223,7 @@ def order_filter(self, elements):
             sage: C.order_filter([])
             []
         """
-        vertices = sorted(map(self._element_to_vertex,elements))
+        vertices = sorted(map(self._element_to_vertex, elements))
         of = self._hasse_diagram.order_filter(vertices)
         return [self._vertex_to_element(_) for _ in of]
 
@@ -6531,8 +6531,6 @@ def maximal_chains(self, partial=None):
         - ``partial`` -- list (optional); if present, find all maximal
           chains starting with the elements in partial
 
-        Returns list of the maximal chains of this poset.
-
         This is used in constructing the order complex for the poset.
 
         EXAMPLES::
@@ -8338,13 +8336,13 @@ def __contains__(self, P):
 
     def __iter__(self):
         """
-        Returns an iterator of representatives of the isomorphism classes
+        Return an iterator of representatives of the isomorphism classes
         of finite posets of a given size.
 
-        .. note::
+        .. NOTE::
 
-           This uses the DiGraph iterator as a backend to construct
-           transitively-reduced, acyclic digraphs.
+            This uses the DiGraph iterator as a backend to construct
+            transitively-reduced, acyclic digraphs.
 
         EXAMPLES::
 
@@ -8356,8 +8354,8 @@ def __iter__(self):
         for dig in DiGraphGenerators()(self._n, is_poset):
             # We need to relabel the digraph since range(self._n) must be a linear
             # extension. Too bad we need to compute this again. TODO: Fix this.
-            label_dict = dict(zip(dig.topological_sort(),range(dig.order())))
-            yield FinitePoset(dig.relabel(label_dict,inplace=False))
+            label_dict = dict(zip(dig.topological_sort(), range(dig.order())))
+            yield FinitePoset(dig.relabel(label_dict, inplace=False))
 
     def cardinality(self, from_iterator=False):
         r"""