some changes in posets (ruff UP and PERF)

Author: fchapoton

src/sage/combinat/posets/cartesian_product.py

@@ -102,7 +102,7 @@ def __init__(self, sets, category, order=None, **kwargs):
             try:
                 self._le_ = getattr(self, 'le_' + order)
             except AttributeError:
-                raise ValueError("no order '%s' known" % (order,))
+                raise ValueError(f"no order '{order}' known")
         else:
             self._le_ = order
 

src/sage/combinat/posets/hasse_diagram.py

@@ -67,7 +67,7 @@ def __str__(self):
             sage: error.__str__()
             'no meet for 15 and 18'
         """
-        return "no {} for {} and {}".format(self.fail, self.x, self.y)
+        return f"no {self.fail} for {self.x} and {self.y}"
 
 
 class HasseDiagram(DiGraph):
@@ -792,8 +792,8 @@ def _rank(self):
         while not_found:
             y = not_found.pop()
             rank[y] = 0  # We set some vertex to have rank 0
-            component = set([y])
-            queue = set([y])
+            component = {y}
+            queue = {y}
             while queue:
                 # look at the neighbors of y and set the ranks;
                 # then look at the neighbors of the neighbors ...
@@ -1286,7 +1286,7 @@ def _leq_storage(self):
             [{0, 1, 2, 3, 4, 5, 6}, {1, 6}, {2, 6}, {3, 6}, {4, 6}, {5, 6}, {6}]
         """
         n = self.order()
-        greater_than = [set([i]) for i in range(n)]
+        greater_than = [{i} for i in range(n)]
         for i in range(n - 1, -1, -1):
             gt = greater_than[i]
             for j in self.neighbor_out_iterator(i):
@@ -2481,7 +2481,7 @@ def is_linear_interval(self, t_min, t_max) -> bool:
             return True
         return False
 
-    def diamonds(self):
+    def diamonds(self) -> tuple:
         r"""
         Return the list of diamonds of ``self``.
 
@@ -2525,8 +2525,7 @@ def diamonds(self):
                     zs = self.common_upper_covers([x, y])
                     if len(zs) != 1:
                         all_diamonds_completed = False
-                    for z in zs:
-                        diamonds.append((w, x, y, z))
+                    diamonds.extend((w, x, y, z) for z in zs)
         return (diamonds, all_diamonds_completed)
 
     def common_upper_covers(self, vertices):
@@ -2651,7 +2650,7 @@ def sublattices_iterator(self, elms, min_e):
             if e in elms:
                 continue
             current_set = set(elms)
-            gens = set([e])
+            gens = {e}
             while gens:
                 g = gens.pop()
                 if g < e and g not in elms:
@@ -2684,7 +2683,7 @@ def sublattice(elms, e):
             Helper function to get sublattice generated by list
             of elements.
             """
-            gens_remaining = set([e])
+            gens_remaining = {e}
             current_set = set(elms)
 
             while gens_remaining:
@@ -2700,7 +2699,7 @@ def sublattice(elms, e):
 
         N = self.cardinality()
         elms = [0]
-        sublats = [set([0])]
+        sublats = [{0}]
         result = []
         skip = -1
 
@@ -2981,7 +2980,7 @@ def neutral_elements(self):
             return set(range(n))
 
         todo = set(range(1, n - 1))
-        neutrals = set([0, n - 1])
+        neutrals = {0, n - 1}
         notneutrals = set()
         all_elements = set(range(n))
 
@@ -3242,7 +3241,7 @@ def fill_to_interval(S):
                 for v in fill_to_interval(c):
                     cong.union(r, v)
 
-        todo = set(cong.find(e) for part in parts for e in part)
+        todo = {cong.find(e) for part in parts for e in part}
 
         while todo:
 
@@ -3307,7 +3306,7 @@ def fill_to_interval(S):
                         d = jn[d, m]
 
             # This removes duplicates from todo.
-            todo = set(cong.find(x) for x in todo)
+            todo = {cong.find(x) for x in todo}
 
         return cong
 

src/sage/combinat/posets/lattices.py

@@ -3089,11 +3089,10 @@ def vertical_decomposition(self, elements_only=False):
                 self._hasse_diagram.vertical_decomposition(return_list=True) +
                 [self.cardinality() - 1])
         n = len(elms)
-        result = []
-        for i in range(n - 1):
-            result.append(LatticePoset(
-                self.subposet([self[e] for e in range(elms[i], elms[i + 1] + 1)])))
-        return result
+        return [LatticePoset(self.subposet([self[e]
+                                            for e in range(elms[i],
+                                                           elms[i + 1] + 1)]))
+                for i in range(n - 1)]
 
     def is_vertically_decomposable(self, certificate=False):
         r"""
@@ -3461,8 +3460,8 @@ def frattini_sublattice(self):
             sage: sorted(L.frattini_sublattice().list())
             [1, 2, 4, 10, 19, 22, 33]
         """
-        return LatticePoset(self.subposet([self[x] for x in
-                self._hasse_diagram.frattini_sublattice()]))
+        return LatticePoset(self.subposet([self[x]
+                for x in self._hasse_diagram.frattini_sublattice()]))
 
     def moebius_algebra(self, R):
         """
@@ -3634,9 +3633,9 @@ def adjunct(self, other, a, b):
         if not isinstance(other, FiniteLatticePoset):
             raise ValueError("other is not a finite lattice")
         if not self.is_greater_than(b, a):
-            raise ValueError("element %s is not greater than %s in the lattice" % (b, a))
+            raise ValueError(f"element {b} is not greater than {a} in the lattice")
         if self.covers(a, b):
-            raise ValueError("element %s covers element %s in the lattice" % (b, a))
+            raise ValueError(f"element {b} covers element {a} in the lattice")
 
         if other.cardinality() == 0:
             return self.relabel(lambda e: (0, e))

src/sage/combinat/posets/linear_extensions.py

@@ -141,7 +141,7 @@ def check(self):
         """
         P = self.parent().poset()
         if not P.is_linear_extension(self):
-            raise ValueError("%s is not a linear extension of %s" % (self, P))
+            raise ValueError(f"{self} is not a linear extension of {P}")
 
     def poset(self):
         r"""
@@ -625,7 +625,7 @@ def cardinality(self):
             while K[j]:
                 K.append([b for a in K[j] for b in Jup[a]])
                 j += 1
-            K = sorted(set(item for sublist in K for item in sublist))
+            K = sorted({item for sublist in K for item in sublist})
             for j in range(len(K)):
                 i = m + j + 1
                 Jup[i] = [m + K.index(a) + 1 for a in Jup[K[j]]]

src/sage/combinat/posets/moebius_algebra.py

@@ -123,7 +123,7 @@ def _repr_(self):
             sage: L.moebius_algebra(QQ)
             Moebius algebra of Finite lattice containing 16 elements over Rational Field
         """
-        return "Moebius algebra of {} over {}".format(self._lattice, self.base_ring())
+        return f"Moebius algebra of {self._lattice} over {self.base_ring()}"
 
     def a_realization(self):
         r"""
@@ -705,7 +705,7 @@ def _repr_(self):
             Category of bases of Moebius algebra of Finite lattice
              containing 16 elements over Rational Field
         """
-        return "Category of bases of {}".format(self.base())
+        return f"Category of bases of {self.base()}"
 
     def super_categories(self):
         r"""
@@ -738,7 +738,7 @@ def _repr_(self):
                 Moebius algebra of Finite lattice containing 16 elements
                  over Rational Field in the idempotent basis
             """
-            return "{} in the {} basis".format(self.realization_of(), self._basis_name)
+            return f"{self.realization_of()} in the {self._basis_name} basis"
 
         def product_on_basis(self, x, y):
             """

src/sage/combinat/posets/poset_examples.py

@@ -426,7 +426,7 @@ def DiamondPoset(n, facade=None):
         """
         n = check_int(n, 3)
         c = [[n - 1] for x in range(n)]
-        c[0] = [x for x in range(1, n - 1)]
+        c[0] = list(range(1, n - 1))
         c[n - 1] = []
         D = DiGraph({v: c[v] for v in range(n)}, format='dict_of_lists')
         return FiniteLatticePoset(hasse_diagram=D,
@@ -719,9 +719,9 @@ def ProductOfChains(chain_lengths, facade=None):
         try:
             l = [Integer(x) for x in chain_lengths]
         except TypeError:
-            raise TypeError("parameter chain_lengths must be a list of integers, not {0}".format(chain_lengths))
+            raise TypeError("parameter chain_lengths must be a list of integers, not {}".format(chain_lengths))
         if any(x < 0 for x in l):
-            raise TypeError("parameter chain_lengths must be a list of nonnegative integers, not {0}".format(l))
+            raise TypeError("parameter chain_lengths must be a list of nonnegative integers, not {}".format(l))
 
         # given the empty list, we expect the empty poset.
         if not chain_lengths:
@@ -781,9 +781,9 @@ def RandomPoset(n, p):
         try:
             p = float(p)
         except (TypeError, ValueError):
-            raise TypeError("probability must be a real number, not {0}".format(p))
+            raise TypeError(f"probability must be a real number, not {p}")
         if p < 0 or p > 1:
-            raise ValueError("probability must be between 0 and 1, not {0}".format(p))
+            raise ValueError(f"probability must be between 0 and 1, not {p}")
 
         D = DiGraph(loops=False, multiedges=False)
         D.add_vertices(range(n))
@@ -867,9 +867,9 @@ def RandomLattice(n, p, properties=None):
         try:
             p = float(p)
         except Exception:
-            raise TypeError("probability must be a real number, not {0}".format(p))
+            raise TypeError(f"probability must be a real number, not {p}")
         if p < 0 or p >= 1:
-            raise ValueError("probability must be a positive real number and below 1, not {0}".format(p))
+            raise ValueError("probability must be a positive real number and below 1, not {}".format(p))
 
         if properties is None:
             # Basic case, no special properties for lattice asked.
@@ -882,11 +882,11 @@ def RandomLattice(n, p, properties=None):
             return LatticePoset(D, cover_relations=True)
 
         if isinstance(properties, str):
-            properties = set([properties])
+            properties = {properties}
         else:
             properties = set(properties)
 
-        known_properties = set(['planar', 'dismantlable', 'distributive', 'stone'])
+        known_properties = {'planar', 'dismantlable', 'distributive', 'stone'}
         errors = properties.difference(known_properties)
         if errors:
             raise ValueError("unknown value %s for 'properties'" % errors.pop())
@@ -907,22 +907,22 @@ def RandomLattice(n, p, properties=None):
         if 'stone' in properties and len(properties) > 1:
             raise NotImplementedError("combining 'stone' with other properties is not implemented")
 
-        if properties == set(['planar']):
+        if properties == {'planar'}:
             D = _random_planar_lattice(n)
             D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D)
 
-        if properties == set(['dismantlable']):
+        if properties == {'dismantlable'}:
             D = _random_dismantlable_lattice(n)
             D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D)
 
-        if properties == set(['stone']):
+        if properties == {'stone'}:
             D = _random_stone_lattice(n)
             D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D)
 
-        if properties == set(['distributive']):
+        if properties == {'distributive'}:
             tmp = Poset(_random_distributive_lattice(n)).order_ideals_lattice(as_ideals=False)
             D = copy(tmp._hasse_diagram)
             D.relabel([i - 1 for i in Permutations(n).random_element()])
@@ -1106,18 +1106,17 @@ def SymmetricGroupBruhatIntervalPoset(start, end):
         start = Permutation(start)
         end = Permutation(end)
         if len(start) != len(end):
-            raise TypeError("start (%s) and end (%s) must have same length" % (start, end))
+            raise TypeError(f"start ({start}) and end ({end}) must have same length")
         if not start.bruhat_lequal(end):
-            raise TypeError("must have start (%s) <= end (%s) in Bruhat order" % (start, end))
+            raise TypeError(f"must have start ({start}) <= end ({end}) in Bruhat order")
         unseen = [start]
         nodes = {}
         while unseen:
             perm = unseen.pop(0)
             nodes[perm] = [succ_perm for succ_perm in perm.bruhat_succ()
                            if succ_perm.bruhat_lequal(end)]
-            for succ_perm in nodes[perm]:
-                if succ_perm not in nodes:
-                    unseen.append(succ_perm)
+            unseen.extend(succ_perm for succ_perm in nodes[perm]
+                          if succ_perm not in nodes)
         return Poset(nodes)
 
     @staticmethod
@@ -1393,9 +1392,9 @@ def UpDownPoset(n, m=1):
         try:
             m = Integer(m)
         except TypeError:
-            raise TypeError("parameter m must be an integer, not {0}".format(m))
+            raise TypeError(f"parameter m must be an integer, not {m}")
         if m < 1:
-            raise ValueError("parameter m must be positive, not {0}".format(m))
+            raise ValueError(f"parameter m must be positive, not {m}")
 
         covers = [[i, i + 1] if (i + 1) % (m + 1) else [i + 1, i]
                   for i in range(n - 1)]
@@ -1681,7 +1680,7 @@ def PermutationPatternInterval(bottom, top):
         top = P(top)
         bottom = P(bottom)
         if not top.has_pattern(bottom):
-            raise ValueError("{} doesn't contain {} as a pattern".format(top, bottom))
+            raise ValueError(f"{top} doesn't contain {bottom} as a pattern")
         # Make a list of lists of elements in the interval divided by rank.
         # List will be flattened at the end
         elem = [[top]]
@@ -1833,19 +1832,17 @@ def MobilePoset(ribbon, hangers, anchor=None):
         elements.extend(ribbon._elements)
 
         if anchor:
-            for cr in anchor[2].cover_relations():
-                cover_relations.append(((anchor[0], cr[0]), (anchor[0], cr[1])))
+            cover_relations.extend(((anchor[0], cr[0]), (anchor[0], cr[1]))
+                                   for cr in anchor[2].cover_relations())
             cover_relations.append((anchor[0], (anchor[0], anchor[1])))
 
-            for elmt in anchor[2]._elements:
-                elements.append((anchor[0], elmt))
+            elements.extend((anchor[0], elmt) for elmt in anchor[2]._elements)
 
         for r, hangs in hangers.items():
             for i, h in enumerate(hangs):
-                for v in h._elements:
-                    elements.append((r, i, v))
-                for cr in h.cover_relations():
-                    cover_relations.append(((r, i, cr[0]), (r, i, cr[1])))
+                elements.extend((r, i, v) for v in h._elements)
+                cover_relations.extend(((r, i, cr[0]), (r, i, cr[1]))
+                                       for cr in h.cover_relations())
                 cover_relations.append(((r, i, h.top()), r))
 
         return Mobile(DiGraph([elements, cover_relations]))
@@ -1896,7 +1893,7 @@ def _random_lattice(n, p):
     n = n - 1
     meets = [[None] * n for _ in range(n)]
     meets[0][0] = 0
-    maxs = set([0])
+    maxs = {0}
     lc_all = [[]]  # No lower covers for the bottom element.
 
     for i in range(1, n):