gh-36107: using mute variables in combinat
    
taking care of unused variables found by `pylint` in combinat

### 📝 Checklist

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
    
URL: #36107
Reported by: Frédéric Chapoton
Reviewer(s): David Coudert, Frédéric Chapoton, Martin Rubey, Matthias Köppe

Author: Release Manager

src/sage/combinat/affine_permutation.py

@@ -706,7 +706,7 @@ def maximal_cyclic_factor(self, typ='decreasing', side='right', verbose=False):
             y = self.clone().apply_simple_reflection(i,side)
             T = [i]
             j = i
-            for count in range(1, self.k):
+            for _ in range(1, self.k):
                 if (typ[0],side[0]) == ('d', 'r'):
                     j=(j+1)%(k+1)
                 if (typ[0],side[0]) == ('i', 'r'):

src/sage/combinat/bijectionist.py

@@ -2174,7 +2174,7 @@ def _preprocess_intertwining_relations(self):
         A = self._A
         P = self._P
         images = defaultdict(set)  # A^k -> A, a_1,...,a_k +-> {pi(a_1,...,a_k) for all pi}
-        for composition_index, pi_rho in enumerate(self._pi_rho):
+        for pi_rho in self._pi_rho:
             for a_tuple in itertools.product(*([A]*pi_rho.numargs)):
                 if pi_rho.domain is not None and not pi_rho.domain(*a_tuple):
                     continue

src/sage/combinat/binary_recurrence_sequences.py

@@ -126,9 +126,9 @@ def __init__(self, b, c, u0=0, u1=1):
         self.c = c
         self.u0 = u0
         self.u1 = u1
-        self._period_dict = {}    #dictionary to cache the period of a sequence for future lookup
-        self._PGoodness = {} #dictionary to cache primes that are "good" by some prime power
-        self._ell = 1 #variable that keeps track of the last prime power to be used as a goodness
+        self._period_dict = {}  # dictionary to cache the period of a sequence for future lookup
+        self._PGoodness = {}  # dictionary to cache primes that are "good" by some prime power
+        self._ell = 1  # variable that keeps track of the last prime power to be used as a goodness
 
     def __repr__(self):
         """
@@ -468,7 +468,7 @@ def period(self, m):
                     #expand the list of prime factors so every factor is with multiplicity 1
 
                     for i0, i1 in Mfac:
-                        for j in range(i1):
+                        for _ in range(i1):
                             C.append(i0)
 
                     Mfac = C
@@ -646,10 +646,10 @@ def pthpowers(self, p, Bound):
 
                 F = GF(ell)
                 a0 = F(self.u0)
-                a1 = F(self.u1) #a0 and a1 are variables for terms in sequence
+                a1 = F(self.u1)  # a0 and a1 are variables for terms in sequence
                 bf, cf = F(self.b), F(self.c)
 
-                for n in range(Bound): # n is the index of the a0
+                for n in range(Bound):  # n is the index of the a0
 
                     #Check whether a0 is a perfect power mod ell
                     if _is_p_power_mod(a0, p, ell):

src/sage/combinat/e_one_star.py

@@ -1508,7 +1508,7 @@ def __call__(self, patch, iterations=1) -> Patch:
             raise ValueError("iterations (=%s) must be >= 0" % iterations)
         else:
             old_faces = patch
-            for i in range(iterations):
+            for _ in range(iterations):
                 new_faces = []
                 for f in old_faces:
                     new_faces.extend(self._call_on_face(f, color=f.color()))

src/sage/combinat/finite_state_machine.py

@@ -5754,7 +5754,7 @@ def is_deterministic(self):
                 state.transitions,
                 key=lambda t: t.word_in)
 
-            for key, transition_class in transition_classes_by_word_in:
+            for _, transition_class in transition_classes_by_word_in:
                 if len(transition_class) > 1:
                     return False
         return True
@@ -6446,14 +6446,14 @@ def _iter_process_simple_(self, iterator):
                                    "'simple' iterator cannot be used "
                                    "here." %
                                    (len(current),))
-            pos, states = next(iter(current.items()))
+            _, states = next(iter(current.items()))
             if len(states) > 1:
                 raise RuntimeError("Process has branched "
                                    "(visiting %s states in branch). The "
                                    "'simple' iterator cannot be used "
                                    "here." %
                                    (len(states),))
-            state, branch = next(iter(states.items()))
+            _, branch = next(iter(states.items()))
             if len(branch.outputs) > 1:
                 raise RuntimeError("Process has branched. "
                                    "(%s different outputs in branch). The "
@@ -8216,7 +8216,7 @@ def function(transition1, transition2):
         for state_result in result.iter_states():
             state = state_result.label()[0]
             if state.is_final:
-                accept, state_to, output = self.process(
+                accept, _, output = self.process(
                     state.final_word_out,
                     initial_state=self.state(state_result.label()[1]))
                 if not accept:
@@ -11809,7 +11809,7 @@ def _process_convert_output_(self, output_data, **kwargs):
         if kwargs['always_include_output']:
             return super()._process_convert_output_(
                 output_data, **kwargs)
-        accept_input, current_state, output = output_data
+        accept_input, current_state, _ = output_data
         if kwargs['full_output']:
             return (accept_input, current_state)
         else:
@@ -13769,8 +13769,8 @@ def compare_to_tape(self, track_number, word):
             next(it_word)
 
         # check letters not already cached
-        for letter_in_word in it_word:
-            successful, letter_on_track = self.read(track_number)
+        for _ in it_word:
+            successful, _ = self.read(track_number)
             if not successful:
                 return False
         return True

src/sage/combinat/free_module.py

@@ -503,7 +503,7 @@ def change_ring(self, R):
             return self
         construction = self.construction()
         if construction is not None:
-            functor, arg = construction
+            functor, _ = construction
             from sage.categories.pushout import VectorFunctor
             if isinstance(functor, VectorFunctor):
                 return functor(R)

src/sage/combinat/fully_commutative_elements.py

@@ -607,13 +607,13 @@ def _still_reduced_fc_after_prepending(self, s):
 
         # Find the first letter in that doesn't commute with s.
         try:
-            (j, t) = next((i, x) for (i, x) in enumerate(self) if m[s, x] >= 3)
+            j, t = next((i, x) for i, x in enumerate(self) if m[s, x] >= 3)
         except StopIteration:
             return True
 
         u = self.clone()
         u._set_list(self[j:])
-        x, y = u.coset_decomposition({s, t})
+        x, _ = u.coset_decomposition({s, t})
         return len(x) != m[s, t] - 1
 
     ###########################################################################

src/sage/combinat/interval_posets.py

@@ -450,7 +450,7 @@ def plot(self, **kwds):
         c1 = 'red'    # self.latex_options()["color_decreasing"]
         G = self.poset().hasse_diagram()
         G.set_pos(self._find_node_positions())
-        for a, b, c in G.edges(sort=False):
+        for a, b in G.edges(sort=False, labels=False):
             if a < b:
                 G.set_edge_label(a, b, 0)
             else:

src/sage/combinat/knutson_tao_puzzles.py

@@ -1195,7 +1195,7 @@ def is_completed(self):
             sage: puzzle.is_completed()
             True
         """
-        (i, j) = self.kink_coordinates()
+        i, _ = self.kink_coordinates()
         return i == self._n + 1
 
     def south_labels(self):
@@ -1225,7 +1225,7 @@ def add_piece(self, piece):
             sage: P.add_piece(piece); P
             {(1, 4): 1/0\0}
         """
-        (i, j) = self.kink_coordinates()
+        i, j = self.kink_coordinates()
         self._squares[i, j] = piece
         if isinstance(piece, DeltaPiece):
             i += 1
@@ -1253,7 +1253,7 @@ def add_pieces(self, pieces):
             sage: P
             {(1, 4): 1/0\0, (2, 4): 1/0\0}
         """
-        (i, j) = self.kink_coordinates()
+        i, j = self.kink_coordinates()
         for piece in pieces:
             self._squares[i, j] = piece
             if isinstance(piece, DeltaPiece):
@@ -2178,7 +2178,7 @@ def _fill_puzzle_by_strips(self, lamda, mu):
         queue = [PuzzleFilling(lamda, mu)]
         while queue:
             PP = queue.pop()
-            (i, j) = PP.kink_coordinates()
+            i, _ = PP.kink_coordinates()
 
             # grab nw labels
             if i == 1:

src/sage/combinat/partition_kleshchev.py

@@ -994,7 +994,7 @@ def e(self, i):
         cell = self.good_cells(i)
         if cell is None:
             return None
-        r,c = cell
+        r, _ = cell
         mu = list(self)
         mu[r] -= 1
         return type(self)(P, mu)
@@ -1055,7 +1055,7 @@ def e(self, i):
         cell = self.good_cells(i)
         if cell is None:
             return None
-        k,r,c = cell
+        k, r, _ = cell
         mu = self.to_list()
         mu[k][r] -= 1
         return type(self)(P, mu)
@@ -1938,7 +1938,7 @@ def _is_regular(kpt, multicharge, convention):
     convention = convention[0] + 'G'
     cell = _a_good_cell(kpt, multicharge, convention)
     while cell is not None:
-        k,r,c = cell
+        k, r, _ = cell
         if kpt[k][r] == 1:
             kpt[k].pop()
         else:
@@ -1964,15 +1964,15 @@ def _is_restricted(kpt, multicharge, convention):
         sage: _is_restricted([[], []], [I3(0),I3(2)], 'RG')
         True
     """
-    if all(part == [] for part in kpt):
+    if all(not part for part in kpt):
         return True
     convention = convention[0] + 'S'
     cell = _a_good_cell(kpt, multicharge, convention)
     while cell is not None:
-        k,r,c = cell
+        k, r, _ = cell
         if kpt[k][r] == 1:
             kpt[k].pop()
         else:
             kpt[k][r] -= 1
         cell = _a_good_cell(kpt, multicharge, convention)
-    return all(part == [] for part in kpt)
+    return all(not part for part in kpt)