gh-40331: remove unused variables in rings/
    
as suggested by cython-lint

### 📝 Checklist

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

Author: Release Manager

src/sage/rings/bernoulli_mod_p.pyx

@@ -145,7 +145,6 @@ def bernoulli_mod_p(int p):
     g = primitive_root(p)
     gInv = arith_int.c_inverse_mod_int(g, p)
     gSqr = ((<llong> g) * g) % p
-    gInvSqr = ((<llong> gInv) * gInv) % p
     isOdd = ((p-1)/2) % 2
 
     # STEP 1: compute the polynomials G(X) and J(X)

src/sage/rings/complex_interval.pyx

@@ -1165,7 +1165,6 @@ cdef class ComplexIntervalFieldElement(FieldElement):
 
         - [RL1971]_
         """
-        cdef ComplexIntervalFieldElement result
         x = self._new()
 
         if mpfi_nan_p(self.__re) or mpfi_nan_p(self.__im):

src/sage/rings/function_field/khuri_makdisi.pyx

@@ -153,11 +153,9 @@ cdef class KhuriMakdisi_base(object):
         """
         cdef Matrix mat, perp, vmu
         cdef FreeModuleElement v
-        cdef Py_ssize_t nd, ne, nde, r
+        cdef Py_ssize_t ne, r
 
         ne = we.ncols()
-        nde = wde.ncols()
-        nd = nde - ne
 
         perp = wde.right_kernel_matrix()
         mat = matrix(0, mu_mat.nrows())

src/sage/rings/polynomial/multi_polynomial.pyx

@@ -2948,7 +2948,7 @@ cdef class MPolynomial(CommutativePolynomial):
             (2*x^2 - 3*x - 5*y, -1)
         """
         lc = self.leading_coefficient()
-        n, u = lc.canonical_associate()
+        _, u = lc.canonical_associate()
         return (u.inverse_of_unit() * self, u)
 
 

src/sage/rings/polynomial/polynomial_element.pyx

@@ -74,9 +74,7 @@ import sage.rings.fraction_field_element
 import sage.rings.infinity as infinity
 from sage.misc.latex import latex
 from sage.arith.power cimport generic_power
-from sage.arith.misc import crt
 from sage.arith.long cimport pyobject_to_long
-from sage.misc.mrange import cartesian_product_iterator
 from sage.structure.factorization import Factorization
 from sage.structure.richcmp cimport (richcmp, richcmp_item,
         rich_to_bool, rich_to_bool_sgn)
@@ -6299,7 +6297,7 @@ cdef class Polynomial(CommutativePolynomial):
             (2*x^2 - 3*x - 5, -1)
         """
         lc = self.leading_coefficient()
-        n, u = lc.canonical_associate()
+        _, u = lc.canonical_associate()
         return (u.inverse_of_unit() * self, u)
 
     def lm(self):

src/sage/rings/rational.pyx

@@ -586,7 +586,6 @@ cdef class Rational(sage.structure.element.FieldElement):
     cdef __set_value(self, x, unsigned int base):
         cdef int n
         cdef Rational temp_rational
-        cdef integer.Integer a, b
 
         if isinstance(x, Rational):
             set_from_Rational(self, x)
@@ -610,7 +609,6 @@ cdef class Rational(sage.structure.element.FieldElement):
                 xstr = x.str(base, truncate=(base == 10))
                 if '.' in xstr:
                     exp = (len(xstr) - (xstr.index('.') +1))
-                    p = base**exp
                     pstr = '1'+'0'*exp
                     s = xstr.replace('.','') +'/'+pstr
                     n = mpq_set_str(self.value, str_to_bytes(s), base)
@@ -1880,7 +1878,7 @@ cdef class Rational(sage.structure.element.FieldElement):
             return self
         a = self
         for p in S:
-            e, a = a.val_unit(p)
+            _, a = a.val_unit(p)
         return a
 
     def sqrt(self, prec=None, extend=True, all=False):
@@ -2044,10 +2042,9 @@ cdef class Rational(sage.structure.element.FieldElement):
             sage: RealField(200)(x)                                                     # needs sage.rings.real_mpfr
             3.1415094339622641509433962264150943396226415094339622641509
         """
-        cdef unsigned int alpha, beta
         d = self.denominator()
-        alpha, d = d.val_unit(2)
-        beta, d  = d.val_unit(5)
+        d = d.val_unit(2)[1]
+        d = d.val_unit(5)[1]
         from sage.rings.finite_rings.integer_mod import Mod
         return Mod(10, d).multiplicative_order()
 
@@ -2810,7 +2807,7 @@ cdef class Rational(sage.structure.element.FieldElement):
             ...
             ArithmeticError: The inverse of 0 modulo 17 is not defined.
         """
-        cdef unsigned int num, den, a
+        cdef unsigned int num, den
 
         # Documentation from GMP manual:
         # "For the ui variants the return value is the remainder, and

src/sage/rings/ring_extension.pyx

@@ -479,16 +479,16 @@ class RingExtensionFactory(UniqueFactory):
             sage: RingExtension.create_object((8,9,0), key, **extra_args)
             Rational Field over its base
         """
-        defining_morphism, gens, names = key
+        defining_morphism = key[0]
         constructors = extra_args['constructors']
         if len(constructors) == 0:
             raise NotImplementedError("no constructor available for this extension")
-        for (constructor, kwargs) in constructors[:-1]:
+        for constructor, kwargs in constructors[:-1]:
             try:
                 return constructor(defining_morphism, **kwargs)
             except (NotImplementedError, ValueError, TypeError):
                 pass
-        (constructor, kwargs) = constructors[-1]
+        constructor, kwargs = constructors[-1]
         return constructor(defining_morphism, **kwargs)
 
 

src/sage/rings/ring_extension_morphism.pyx

@@ -835,20 +835,20 @@ cdef class MapRelativeRingToFreeModule(Map):
         # We compute the matrix of our isomorphism (over base)
         from sage.rings.ring_extension import common_base
         base = common_base(K, L, False)
-        EK, iK, jK = K.free_module(base, map=True)
-        EL, iL, jL = L.free_module(base, map=True)
+        EK, iK, _ = K.free_module(base, map=True)
+        jL = L.free_module(base, map=True)[2]
 
         self._dimK = EK.dimension()
         self._iK = iK
         self._jL = jL
 
-        M = [ ]
+        M = []
         for x in self._basis:
             for v in EK.basis():
                 y = x * f(iK(v))
                 M.append(jL(y))
         from sage.matrix.matrix_space import MatrixSpace
-        self._matrix = MatrixSpace(base,len(M))(M).inverse_of_unit()
+        self._matrix = MatrixSpace(base, len(M))(M).inverse_of_unit()
 
     def is_injective(self):
         r"""

src/sage/rings/tate_algebra_element.pyx

@@ -1170,8 +1170,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             sage: A(x + 2*x^2 + x^3, prec=5)
             ...00001*x^3 + ...00001*x + ...00010*x^2 + O(2^5 * <x, y>)
         """
-        base = self._parent.base_ring()
-        nvars = self._parent.ngens()
         vars = self._parent.variable_names()
         s = ""
         for t in self._terms_c():
@@ -1229,9 +1227,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             sage: f._latex_()
             '...0000000001x^{3} + ...0000000001x + ...00000000010x^{2}'
         """
-        base = self._parent.base_ring()
-        nvars = self._parent.ngens()
-        vars = self._parent.variable_names()
         s = ""
         for t in self.terms():
             if t.valuation() >= self._prec:
@@ -1246,7 +1241,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
         if self._prec is not Infinity:
             if s != "":
                 s += " + "
-            sv = ",".join(vars)
             if self._prec == 0:
                 s += "O\\left(%s\\right)" % self._parent.integer_ring()._latex_()
             elif self._prec == 1:
@@ -1968,16 +1962,15 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
         parent = self._parent
         base = parent.base_ring()
         if base.is_field():
-            for (e,c) in self._poly.__repn.items():
+            for e, c in self._poly.__repn.items():
                 coeffs[e] = c << n
             ans._prec = self._prec + n
         else:
             field = base.fraction_field()
-            ngens = parent.ngens()
-            for (e,c) in self._poly.__repn.items():
+            for e, c in self._poly.__repn.items():
                 minval = ZZ(e.dotprod(<ETuple>parent._log_radii)).ceil()
                 coeffs[e] = field(base(c) >> (minval-n)) << minval
-            ans._prec = max(ZZ(0), self._prec + n)
+            ans._prec = max(ZZ.zero(), self._prec + n)
         ans._poly = PolyDict(coeffs, None)
         return ans
 
@@ -2453,12 +2446,10 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             sage: f.valuation()
             -4
         """
-        cdef TateAlgebraTerm t
         cdef list terms = self._terms_c()
         if terms:
             return min(terms[0].valuation(), self._prec)
-        else:
-            return self._prec
+        return self._prec
 
     def precision_relative(self):
         """
@@ -3244,7 +3235,6 @@ cdef class TateAlgebraElement(CommutativeAlgebraElement):
             divisors = [divisors]
             onedivisor = True
         A = _pushout_family(divisors, self._parent)
-        f = A(self)
         divisors = [A(d) for d in divisors]
         q, r = (<TateAlgebraElement>self)._quo_rem_c(divisors, quo, rem, False)
         if quo and onedivisor:

src/sage/rings/tate_algebra_ideal.pyx

@@ -390,7 +390,7 @@ class TateAlgebraIdeal(Ideal_generic):
         if self.ring().base_ring().is_field():
             return self
         gb = self.groebner_basis()
-        gens = [ g.monic() for g in gb ]
+        gens = [g.monic() for g in gb]
         return self.ring().ideal(gens)
 
 
@@ -432,14 +432,14 @@ def groebner_basis_buchberger(I, prec, py_integral):
          ...0000000001*x^2*y + ...1210121020 + O(3^10 * <x, y>),
          ...000000001*y^2 + ...210121020*x + O(3^9 * <x, y>)]
     """
-    cdef list gb, rgb, indices, ts, S = [ ]
+    cdef list gb, rgb, indices, S = []
     cdef int i, j, l
     cdef TateAlgebraTerm ti, tj, t
     cdef TateAlgebraElement f, g, r, s
     cdef bint do_reduce = True
     cdef bint integral = py_integral
 
-    gb = [ ]
+    gb = []
     l = 0
     for f in I.gens():
         if not f:
@@ -550,9 +550,10 @@ def groebner_basis_buchberger(I, prec, py_integral):
                 rgb[i] = g._positive_lshift_c(1)
                 _, rgb[i] = g._quo_rem_c(rgb, False, True, True)
         else:
-            rgb = [ g.monic() for g in rgb ]
+            rgb = [g.monic() for g in rgb]
     else:
-        rgb = [ g * base(g.leading_coefficient().unit_part()).inverse_of_unit() for g in rgb ]
+        rgb = [g * base(g.leading_coefficient().unit_part()).inverse_of_unit()
+               for g in rgb]
 
     rgb.sort(reverse=True)
     return rgb
@@ -638,11 +639,10 @@ cdef TateAlgebraElement regular_reduce(sgb, TateAlgebraTerm s, TateAlgebraElemen
     cdef dict coeffs = { }
     cdef TateAlgebraElement f
     cdef TateAlgebraTerm lt, factor
-    cdef list ltds = [ (<TateAlgebraElement>(d[1]))._terms_c()[0] for d in sgb ]
+    cdef list ltds = [(<TateAlgebraElement>(d[1]))._terms_c()[0] for d in sgb]
     cdef list terms = v._terms_c()
     cdef int index = 0
     cdef int i
-    cdef bint in_rem
 
     f = v._new_c()
     f._poly = PolyDict(v._poly.__repn, None)
@@ -712,7 +712,7 @@ cdef TateAlgebraElement reduce(gb, TateAlgebraElement v, stopval):
     cdef dict coeffs = { }
     cdef TateAlgebraElement f
     cdef TateAlgebraTerm lt, factor
-    cdef list ltds = [ (<TateAlgebraElement>d)._terms_c()[0] for d in gb ]
+    cdef list ltds = [(<TateAlgebraElement>d)._terms_c()[0] for d in gb]
     cdef list terms = v._terms_c()
     cdef int index = 0
     cdef int i
@@ -855,7 +855,7 @@ def groebner_basis_pote(I, prec, verbose=0):
     cdef TateAlgebraTerm term_one = I.ring().monoid_of_terms().one()
     cdef bint integral = not I.ring().base_ring().is_field()
 
-    gb = [ ]
+    gb = []
 
     for f in sorted(I.gens()):
         sig_check()
@@ -870,11 +870,10 @@ def groebner_basis_pote(I, prec, verbose=0):
             print("new generator: %s + ..." % f.leading_term())
         # Initial strong Grobner basis:
         # we add signatures
-        sgb = [ (None, g) for g in gb if g ]
+        sgb = [(None, g) for g in gb if g]
         # We compute initial J-pairs
-        l = len(sgb)
         p = (term_one, f.add_bigoh(prec))
-        Jpairs = [ ]
+        Jpairs = []
         for P in sgb:
             sig_check()
             J = Jpair(p, P)
@@ -883,7 +882,7 @@ def groebner_basis_pote(I, prec, verbose=0):
         sgb.append(p)
 
         # For the syzygy criterium
-        gb0 = [ g.leading_term() for g in gb ]
+        gb0 = [g.leading_term() for g in gb]
 
         if verbose > 1:
             print("%s initial J-pairs" % len(Jpairs))
@@ -1005,7 +1004,7 @@ def groebner_basis_pote(I, prec, verbose=0):
                 print("| %s" % g)
 
     if not integral:
-        gb = [ f.monic() for f in gb ]
+        gb = [f.monic() for f in gb]
     gb.sort(reverse=True)
     return gb
 
@@ -1100,9 +1099,9 @@ def groebner_basis_vapote(I, prec, verbose=0, interrupt_red_with_val=False, inte
     cdef list terms
     cdef bint do_reduce, integral
     term_one = I.ring().monoid_of_terms().one()
-    gb = [ ]
+    gb = []
 
-    gens = [ ]
+    gens = []
     for f in I.gens():
         if f:
             val = f.valuation()
@@ -1157,19 +1156,18 @@ def groebner_basis_vapote(I, prec, verbose=0, interrupt_red_with_val=False, inte
 
         # Initial strong Grobner basis:
         # we add signatures
-        sgb = [ (None, g) for g in gb if g ]
+        sgb = [(None, g) for g in gb if g]
         # We compute initial J-pairs
-        l = len(sgb)
         p = (term_one, f.add_bigoh(prec))
-        Jpairs = [ ]
+        Jpairs = []
         for P in sgb:
             J = Jpair(p, P)
             if J is not None:
                 heappush(Jpairs, J)
         sgb.append(p)
 
         # For the syzygy criterium
-        gb0 = [ g.leading_term() for g in gb ]
+        gb0 = [g.leading_term() for g in gb]
 
         if verbose > 1:
             print("%s initial J-pairs" % len(Jpairs))
@@ -1257,8 +1255,8 @@ def groebner_basis_vapote(I, prec, verbose=0, interrupt_red_with_val=False, inte
                 sgb.append(p)
 
         # We forget signatures
-        # gb = [ v.monic() for (s,v) in sgb ]
-        gb = [ v for (s,v) in sgb ]
+        # gb = [v.monic() for s, v in sgb]
+        gb = [v for s, v in sgb]
         if verbose > 1:
             print("%s elements in GB before minimization" % len(gb))
         if verbose > 3:
@@ -1300,7 +1298,7 @@ def groebner_basis_vapote(I, prec, verbose=0, interrupt_red_with_val=False, inte
         for g in gb:
             print("| %s" % g)
     if not integral:
-        gb = [ f.monic() for f in gb ]
+        gb = [f.monic() for f in gb]
     gb.sort(reverse=True)
 
     return gb