some fixes for ruff SIM113

Author: fchapoton

src/sage/categories/enumerated_sets.py

@@ -785,12 +785,11 @@ def _rank_from_iterator(self, x):
                 2
                 sage: C.rank(5) # indirect doctest
             """
-            counter = 0
-            for u in self:
+            for counter, u in enumerate(self):
                 if u == x:
                     return counter
-                counter += 1
             return None
+
         rank = _rank_from_iterator
 
         def _iterator_from_list(self):
@@ -929,12 +928,11 @@ def _some_elements_from_iterator(self):
                 sage: list(C.some_elements()) # indirect doctest
                 [1, 2, 3]
             """
-            nb = 0
-            for i in self:
+            for nb, i in enumerate(self):
                 yield i
-                nb += 1
-                if nb >= 100:
+                if nb >= 99:
                     break
+
         some_elements = _some_elements_from_iterator
 
         def random_element(self):
@@ -1045,10 +1043,8 @@ def _test_enumerated_set_contains(self, **options):
                 of a finite enumerated set: {1,2,3}
             """
             tester = self._tester(**options)
-            i = 0
-            for w in self:
+            for i, w in enumerate(self, start=1):
                 tester.assertIn(w, self)
-                i += 1
                 if i > tester._max_runs:
                     return
 

src/sage/categories/regular_crystals.py

@@ -309,12 +309,10 @@ def _test_stembridge_local_axioms(self, index_set=None, verbose=False, complete=
             """
             tester = self._tester(**options)
             goodness = True
-            i = 0
-            for x in self:
+            for i, x in enumerate(self, start=1):
                 goodness = x._test_stembridge_local_axioms(index_set, verbose)
                 if not goodness and not complete:
                     tester.fail()
-                i += 1
                 if i > tester._max_runs:
                     return
             tester.assertTrue(goodness)

src/sage/combinat/dyck_word.py

@@ -926,11 +926,10 @@ def _repr_svg_(self) -> str:
         horizontal = "<line x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\"/>"
         hori_lines = []
         path = ['<polyline points=\"0,0']
-        x, y = 0, 0
+        y = 0
         max_y = 0
         last_seen_level = [0]
-        for e in self:
-            x += 1
+        for x, e in enumerate(self, start=1):
             if e == open_symbol:
                 y += 1
                 last_seen_level.append(x - 1)

src/sage/combinat/finite_state_machine.py

@@ -4720,8 +4720,7 @@ def label_rotation(angle, both_directions):
             accepting_show_empty = False
 
         result = "\\begin{tikzpicture}[%s]\n" % ", ".join(options)
-        j = 0
-        for vertex in self.iter_states():
+        for j, vertex in enumerate(self.iter_states()):
             if not hasattr(vertex, "coordinates"):
                 vertex.coordinates = (3*cos(2*pi*j/len(self.states())),
                                       3*sin(2*pi*j/len(self.states())))
@@ -4762,8 +4761,6 @@ def label_rotation(angle, both_directions):
                     self.format_transition_label(vertex.final_word_out),
                     angle, accepting_distance)
 
-            j += 1
-
         def key_function(s):
             return (s.from_state, s.to_state)
         # We use an OrderedDict instead of a dict in order to have a

src/sage/combinat/gray_codes.py

@@ -69,19 +69,18 @@ def product(m):
         ....:     assert sum(1 for _ in product(t)) == prod(t)-1
     """
     # n is the length of the element (we ignore sets of size 1)
-    n = k = 0
+    n = 0
 
     new_m = []   # will be the set of upper bounds m_i different from 1
     mm = []      # index of each set (we skip sets of cardinality 1)
-    for i in m:
+    for k, i in enumerate(m):
         i = int(i)
         if i <= 0:
             raise ValueError("accept only positive integers")
         if i > 1:
-            new_m.append(i-1)
+            new_m.append(i - 1)
             mm.append(k)
             n += 1
-        k += 1
 
     m = new_m
     f = list(range(n + 1))  # focus pointer

src/sage/combinat/ncsf_qsym/qsym.py

@@ -3536,26 +3536,20 @@ def _precompute_cache(self, n, to_self_cache, from_self_cache, transition_matric
 
             # For every composition I of size n, expand self[I] in terms
             # of the monomial basis M.
-            i = 0
-            for I in compositions_n:
+            for i, I in enumerate(compositions_n):
                 # M_coeffs will be M(self[I])._monomial_coefficients
                 M_coeffs = {}
 
                 self_I_in_M_basis = M.prod([from_self_gen_function(self._indices(list(J)))
                                             for J in Word(I).lyndon_factorization()])
 
-                j = 0
-
-                for J in compositions_n:
+                for j, J in enumerate(compositions_n):
                     if J in self_I_in_M_basis._monomial_coefficients:
                         sp = self_I_in_M_basis._monomial_coefficients[J]
                         M_coeffs[J] = sp
-                        transition_matrix_n[i,j] = sp
-
-                    j += 1
+                        transition_matrix_n[i, j] = sp
 
                 from_self_cache[I] = M_coeffs
-                i += 1
 
             # Save the transition matrix
             inverse_transition_matrices[n] = transition_matrix_n

src/sage/combinat/plane_partition.py

@@ -139,7 +139,7 @@ def __init__(self, parent, pp, check=True):
                 self._max_y = 0
                 self._max_z = 0
         else:
-            (self._max_x, self._max_y, self._max_z) = self.parent()._box
+            self._max_x, self._max_y, self._max_z = self.parent()._box
 
     def __richcmp__(self, other, op):
         r"""
@@ -1098,17 +1098,14 @@ def to_order_ideal(self):
             [(0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 0, 0)]
         """
         from sage.combinat.posets.poset_examples import posets
-        (a, b, c) = (self._max_x, self._max_y, self._max_z)
+        a, b, c = (self._max_x, self._max_y, self._max_z)
         Q = posets.ProductOfChains([a, b, c])
-        count = 0
         generate = []
         for i, row in enumerate(self):
             for j, val in enumerate(row):
                 if val > 0:
-                    generate.append((i, j, val-1))
-            count += 1
-        oi = Q.order_ideal(generate)
-        return oi
+                    generate.append((i, j, val - 1))
+        return Q.order_ideal(generate)
 
     def maximal_boxes(self) -> list:
         r"""

src/sage/combinat/posets/poset_examples.py

@@ -1273,10 +1273,8 @@ def TetrahedralPoset(n, *colors, **labels):
         elem_labels = {}
         if 'labels' in labels:
             if labels['labels'] == 'integers':
-                labelcount = 0
-                for i, j, k in elem:
-                    elem_labels[(i, j, k)] = labelcount
-                    labelcount += 1
+                for labelcount, ijk in enumerate(elem):
+                    elem_labels[ijk] = labelcount
         for c in colors:
             for i, j, k in elem:
                 if i + j + k < n - 1:

src/sage/combinat/sf/dual.py

@@ -394,16 +394,14 @@ def _precompute(self, n):
 
             # For every partition p of size n, compute self(p) in
             # terms of the dual basis using the scalar product.
-            i = 0
-            for s_part in partitions_n:
+            for i, s_part in enumerate(partitions_n):
                 # s_part corresponds to self(dual_basis(part))
                 # s_mcs  corresponds to self(dual_basis(part))._monomial_coefficients
                 s_mcs = {}
 
                 # We need to compute the scalar product of d[s_part] and
                 # all of the d[p_part]'s
-                j = 0
-                for p_part in partitions_n:
+                for j, p_part in enumerate(partitions_n):
                     # Compute the scalar product of d[s_part] and d[p_part]
                     sp = zero
                     for ds_part in d[s_part]:
@@ -413,10 +411,7 @@ def _precompute(self, n):
                         s_mcs[p_part] = sp
                         transition_matrix_n[i,j] = sp
 
-                    j += 1
-
                 self._to_self_cache[ s_part ] = s_mcs
-                i += 1
 
         else:
             # Now the other case. Note that just being in this case doesn't

src/sage/combinat/words/paths.py

@@ -1197,16 +1197,14 @@ def is_simple(self) -> bool:
             sage: P('aabdee').is_simple()
             False
         """
-        n = 0
         s = set()
         include_last = not self.is_closed()
-        for p in self.points(include_last=include_last):
+        for n, p in enumerate(self.points(include_last=include_last), start=1):
             # We need the elements to have a common parent,
             # so we convert the points to immutable vectors.
             v = vector(p)
             v.set_immutable()
             s.add(v)
-            n += 1
             if len(s) != n:
                 return False
         return True