gh-36248: some care for unused variables in matrix/
    
partial care for unused variables in matrix folder, following
suggestions of cython-lint

### 📝 Checklist

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

Author: Release Manager

src/sage/matrix/args.pyx

@@ -739,7 +739,6 @@ cdef class MatrixArgs:
         """
         self.finalize()
 
-        cdef long i
         cdef list L
         if self.typ == MA_ENTRIES_SEQ_FLAT and not convert:
             # Try to re-use existing list
@@ -788,7 +787,6 @@ cdef class MatrixArgs:
         """
         self.finalize()
 
-        R = self.base
         cdef dict D = {}
         for t in self.iter(convert, True):
             se = <SparseEntry>t

src/sage/matrix/matrix_double_dense.pyx

@@ -1375,7 +1375,7 @@ cdef class Matrix_double_dense(Matrix_numpy_dense):
                 location = None
                 best_fit = tol
                 for i in range(len(ev_group)):
-                    s, m, avg = ev_group[i]
+                    _, m, avg = ev_group[i]
                     d = numpy.abs(avg - e)
                     if d < best_fit:
                         best_fit = d
@@ -1739,14 +1739,13 @@ cdef class Matrix_double_dense(Matrix_numpy_dense):
             import scipy
         import scipy.linalg
         X = self._new(self._ncols, B.ncols())
-        arr, resid, rank, s = scipy.linalg.lstsq(self._matrix_numpy, B.numpy())
+        arr = scipy.linalg.lstsq(self._matrix_numpy, B.numpy())[0]
         X._matrix_numpy = arr
         return X
 
-
     def determinant(self):
         """
-        Return the determinant of self.
+        Return the determinant of ``self``.
 
         ALGORITHM:
 
@@ -1808,7 +1807,6 @@ cdef class Matrix_double_dense(Matrix_numpy_dense):
             []
             sage: m.log_determinant()
             0.0
-
         """
         global numpy
         cdef Matrix_double_dense U
@@ -1819,7 +1817,7 @@ cdef class Matrix_double_dense(Matrix_numpy_dense):
         if not self.is_square():
             raise ArithmeticError("self must be a square matrix")
 
-        P, L, U = self.LU()
+        _, _, U = self.LU()
         if numpy is None:
             import numpy
 
@@ -2490,7 +2488,7 @@ cdef class Matrix_double_dense(Matrix_numpy_dense):
             return True
         if numpy is None:
             import numpy
-        cdef Py_ssize_t i, j
+        cdef Py_ssize_t i
         cdef Matrix_double_dense T
         # A matrix M is skew-hermitian iff I*M is hermitian
         T = self.__mul__(1j) if skew else self.__copy__()
@@ -2500,13 +2498,13 @@ cdef class Matrix_double_dense(Matrix_numpy_dense):
         hermitian = T._is_lower_triangular(tol)
         if hermitian:
             for i in range(T._nrows):
-                if abs(T.get_unsafe(i,i).imag()) > tol:
+                if abs(T.get_unsafe(i, i).imag()) > tol:
                     hermitian = False
                     break
         self.cache(key, hermitian)
         return hermitian
 
-    def is_hermitian(self, tol = 1e-12, algorithm = "naive"):
+    def is_hermitian(self, tol=1e-12, algorithm = "naive"):
         r"""
         Return ``True`` if the matrix is equal to its conjugate-transpose.
 

src/sage/matrix/matrix_gf2e_dense.pyx

@@ -804,7 +804,6 @@ cdef class Matrix_gf2e_dense(matrix_dense.Matrix_dense):
         cdef m4ri_word mask = (1<<(self._parent.base_ring().degree())) - 1
 
         cdef randstate rstate = current_randstate()
-        K = self._parent.base_ring()
 
         if self._ncols == 0 or self._nrows == 0:
             return
@@ -898,7 +897,7 @@ cdef class Matrix_gf2e_dense(matrix_dense.Matrix_dense):
             self.cache('pivots', [])
             return self
 
-        cdef int k, n, full
+        cdef int full
 
         full = int(reduced)
 

src/sage/matrix/matrix_gfpn_dense.pyx

@@ -730,7 +730,7 @@ cdef class Matrix_gfpn_dense(Matrix_dense):
         x = self.Data.Data
         cdef int nr = self.Data.Nor
         cdef int nc = self.Data.Noc
-        cdef int i, j, k
+        cdef int i, j
 
         FfSetField(fl)
         FfSetNoc(nc)
@@ -1392,15 +1392,13 @@ cdef class Matrix_gfpn_dense(Matrix_dense):
             True
             sage: M*int(-1)+M == 0
             True
-
         """
         if self.Data == NULL:
             raise ValueError("The matrix must not be empty")
-        cdef Matrix_gfpn_dense left
         FfSetField(self.Data.Field)
         cdef FEL r
         with cython.cdivision(False):
-            r = FfFromInt(n%FfChar)
+            r = FfFromInt(n % FfChar)
         sig_on()
         try:
             mat = MatDup(self.Data)

src/sage/matrix/matrix_integer_sparse.pyx

@@ -182,24 +182,21 @@ cdef class Matrix_integer_sparse(Matrix_sparse):
         return M
 
     cpdef _add_(self, right):
-        cdef Py_ssize_t i, j
-        cdef mpz_vector *self_row
-        cdef mpz_vector *M_row
+        cdef Py_ssize_t i
         cdef Matrix_integer_sparse M
 
         M = Matrix_integer_sparse.__new__(Matrix_integer_sparse, self._parent, None, None, None)
         cdef mpz_t mul
         mpz_init_set_si(mul,1)
-        for i from 0 <= i < self._nrows:
+        for i in range(self._nrows):
             mpz_vector_clear(&M._matrix[i])
-            add_mpz_vector_init(&M._matrix[i], &self._matrix[i], &(<Matrix_integer_sparse>right)._matrix[i], mul)
+            add_mpz_vector_init(&M._matrix[i], &self._matrix[i],
+                                &(<Matrix_integer_sparse>right)._matrix[i], mul)
         mpz_clear(mul)
         return M
 
     cpdef _sub_(self, right):
-        cdef Py_ssize_t i, j
-        cdef mpz_vector *self_row
-        cdef mpz_vector *M_row
+        cdef Py_ssize_t i
         cdef Matrix_integer_sparse M
 
         M = Matrix_integer_sparse.__new__(Matrix_integer_sparse, self._parent, None, None, None)
@@ -214,6 +211,7 @@ cdef class Matrix_integer_sparse(Matrix_sparse):
     def _dict(self):
         """
         Unsafe version of the dict method, mainly for internal use.
+
         This may return the dict of elements, but as an *unsafe*
         reference to the underlying dict of the object.  It might
         be dangerous if you change entries of the returned dict.
@@ -222,13 +220,13 @@ cdef class Matrix_integer_sparse(Matrix_sparse):
         if d is not None:
             return d
 
-        cdef Py_ssize_t i, j, k
+        cdef Py_ssize_t i, j
         d = {}
-        for i from 0 <= i < self._nrows:
-            for j from 0 <= j < self._matrix[i].num_nonzero:
+        for i in range(self._nrows):
+            for j in range(self._matrix[i].num_nonzero):
                 x = Integer()
                 mpz_set((<Integer>x).value, self._matrix[i].entries[j])
-                d[(int(i),int(self._matrix[i].positions[j]))] = x
+                d[(int(i), int(self._matrix[i].positions[j]))] = x
         self.cache('dict', d)
         return d
 

src/sage/matrix/matrix_rational_sparse.pyx

@@ -303,13 +303,13 @@ cdef class Matrix_rational_sparse(Matrix_sparse):
         if d is not None:
             return d
 
-        cdef Py_ssize_t i, j, k
+        cdef Py_ssize_t i, j
         d = {}
-        for i from 0 <= i < self._nrows:
-            for j from 0 <= j < self._matrix[i].num_nonzero:
+        for i in range(self._nrows):
+            for j in range(self._matrix[i].num_nonzero):
                 x = Rational()
                 mpq_set((<Rational>x).value, self._matrix[i].entries[j])
-                d[(int(i),int(self._matrix[i].positions[j]))] = x
+                d[(int(i), int(self._matrix[i].positions[j]))] = x
         self.cache('dict', d)
         return d
 
@@ -396,25 +396,23 @@ cdef class Matrix_rational_sparse(Matrix_sparse):
         return 0
 
     cdef int mpz_denom(self, mpz_t d) except -1:
-        mpz_set_si(d,1)
+        mpz_set_si(d, 1)
         cdef Py_ssize_t i, j
-        cdef mpq_vector *v
 
         sig_on()
-        for i from 0 <= i < self._nrows:
-            for j from 0 <= j < self._matrix[i].num_nonzero:
+        for i in range(self._nrows):
+            for j in range(self._matrix[i].num_nonzero):
                 mpz_lcm(d, d, mpq_denref(self._matrix[i].entries[j]))
         sig_off()
         return 0
 
-
     def denominator(self):
         """
         Return the denominator of this matrix.
 
         OUTPUT:
 
-            -- Sage Integer
+        - Sage Integer
 
         EXAMPLES::
 

src/sage/matrix/matrix_sparse.pyx

@@ -363,10 +363,10 @@ cdef class Matrix_sparse(matrix.Matrix):
         return data, version
 
     def _unpickle_generic(self, data, int version):
-        cdef Py_ssize_t i, j, k
+        cdef Py_ssize_t i, j
         if version == -1:
-            for ij, x in data.iteritems():
-                self.set_unsafe(ij[0], ij[1], x)
+            for (i, j), x in data.iteritems():
+                self.set_unsafe(i, j, x)
         else:
             raise RuntimeError("unknown matrix version (=%s)" % version)
 
@@ -929,7 +929,6 @@ cdef class Matrix_sparse(matrix.Matrix):
 
         cdef Py_ssize_t nrows, ncols,k,r,i,j
 
-        r = 0
         ncols = PyList_GET_SIZE(columns)
         nrows = PyList_GET_SIZE(rows)
         cdef Matrix_sparse A = self.new_matrix(nrows = nrows, ncols = ncols)
@@ -963,7 +962,7 @@ cdef class Matrix_sparse(matrix.Matrix):
             i = get_ij(nz, k, 0)
             j = get_ij(nz, k, 1)
             if i in row_map and j in col_map:
-                entry = self.get_unsafe(i,j)
+                entry = self.get_unsafe(i, j)
                 for new_row in row_map[i]:
                     for new_col in col_map[j]:
                         A.set_unsafe(new_row, new_col, entry)

src/sage/matrix/matrix_window.pyx

@@ -104,15 +104,14 @@ cdef class MatrixWindow:
 
     def __getitem__(self, ij):
         cdef Py_ssize_t i, j
-        cdef object x
 
         if isinstance(ij, tuple):
             # ij is a tuple, so we get i and j efficiently, construct corresponding integer entry.
             if PyTuple_Size(ij) != 2:
                 raise IndexError("index must be an integer or pair of integers")
             i = <object> PyTuple_GET_ITEM(ij, 0)
             j = <object> PyTuple_GET_ITEM(ij, 1)
-            if i<0 or i >= self._nrows or j<0 or j >= self._ncols:
+            if i < 0 or i >= self._nrows or j < 0 or j >= self._ncols:
                 raise IndexError("matrix index out of range")
             return self.get_unsafe(i, j)
         else:

src/sage/matrix/strassen.pyx

@@ -98,7 +98,6 @@ cdef strassen_window_multiply_c(MatrixWindow C, MatrixWindow A,
 
     cdef MatrixWindow S0, S1, S2, S3, T0, T1 ,T2, T3, P0, P1, P2, P3, P4, P5, P6, U0, U1, U2, U3, U4, U5, U6
     cdef MatrixWindow X, Y
-    cdef Py_ssize_t tmp_cols, start_row
     X = A.new_empty_window(A_sub_nrows, max(A_sub_ncols,B_sub_ncols))
     Y = B.new_empty_window(A_sub_ncols, B_sub_ncols)