gh-36035: cython-lint : further fixes in quadratic forms
    
<!-- ^^^^^
Please provide a concise, informative and self-explanatory title.
Don't put issue numbers in there, do this in the PR body below.
For example, instead of "Fixes #1234" use "Introduce new method to
calculate 1+1"
-->
<!-- Describe your changes here in detail -->

This fixes some suggestions of `cython-lint` in `quadratic_forms`.

<!-- Why is this change required? What problem does it solve? -->
<!-- If this PR resolves an open issue, please link to it here. For
example "Fixes #12345". -->
<!-- If your change requires a documentation PR, please link it
appropriately. -->

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->
<!-- If your change requires a documentation PR, please link it
appropriately -->
<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
<!-- Feel free to remove irrelevant items. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #36035
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Matthias Köppe

Author: Release Manager

src/sage/quadratic_forms/count_local_2.pyx

@@ -2,7 +2,6 @@ r"""
 Optimized counting of congruence solutions
 """
 from sage.arith.misc import is_prime, kronecker as kronecker_symbol, valuation
-from sage.rings.finite_rings.integer_mod cimport IntegerMod_gmp
 from sage.rings.finite_rings.integer_mod import Mod
 from sage.rings.finite_rings.integer_mod_ring import IntegerModRing
 
@@ -73,16 +72,16 @@ def count_modp__by_gauss_sum(n, p, m, Qdet):
 
     # Compute the Gauss sum
     neg1 = -1
-    if not (m % p):
+    if not m % p:
         if n % 2:
-            count = (p**(n-1))
+            count = p**(n-1)
         else:
-            count = (p**(n-1)) + (p-1) * (p**((n-2)/2)) * kronecker_symbol(((neg1**(n/2)) * Qdet) % p, p)
+            count = p**(n-1) + (p-1) * (p**((n-2)//2)) * kronecker_symbol(((neg1**(n//2)) * Qdet) % p, p)
     else:
         if n % 2:
-            count = (p**(n-1)) + (p**((n-1)/2)) * kronecker_symbol(((neg1**((n-1)/2)) * Qdet * m) % p, p)
+            count = p**(n-1) + p**((n-1)//2) * kronecker_symbol(((neg1**((n-1)//2)) * Qdet * m) % p, p)
         else:
-            count = (p**(n-1)) - (p**((n-2)/2)) * kronecker_symbol(((neg1**(n/2)) * Qdet) % p, p)
+            count = p**(n-1) - p**((n-2)//2) * kronecker_symbol(((neg1**(n//2)) * Qdet) % p, p)
 
     # Return the result
     return count
@@ -103,11 +102,6 @@ cdef CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec):
     R = p ** k
     Q1 = Q.change_ring(IntegerModRing(R))
 
-    # Cython Variables
-    cdef IntegerMod_gmp zero, one
-    zero = IntegerMod_gmp(IntegerModRing(R), 0)
-    one = IntegerMod_gmp(IntegerModRing(R), 1)
-
     # Initialize the counting vector
     count_vector = [0 for i in range(6)]
 
@@ -119,7 +113,7 @@ cdef CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec):
     m1 = Mod(m, R)
 
     # Count the local solutions
-    for i from 0 <= i < R_n:
+    for i in range(R_n):
 
         # Perform a carry (when value = R-1) until we can increment freely
         ptr = len(v)
@@ -128,20 +122,20 @@ cdef CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec):
             ptr += -1
 
         # Only increment if we're not already at the zero vector =)
-        if (ptr > 0):
+        if ptr > 0:
             v[ptr-1] += 1
 
         # Evaluate Q(v) quickly
         tmp_val = Mod(0, R)
         for a from 0 <= a < n:
             for b from a <= b < n:
-                tmp_val += Q1[a,b] * v[a] * v[b]
+                tmp_val += Q1[a, b] * v[a] * v[b]
 
         # Sort the solution by it's type
-        #if (Q1(v) == m1):
-        if (tmp_val == m1):
+        # if Q1(v) == m1:
+        if tmp_val == m1:
             solntype = local_solution_type_cdef(Q1, p, v, zvec, nzvec)
-            if (solntype != 0):
+            if solntype != 0:
                 count_vector[solntype] += 1
 
     # Generate the Bad-type and Total counts
@@ -187,11 +181,6 @@ def CountAllLocalTypesNaive(Q, p, k, m, zvec, nzvec):
     return CountAllLocalTypesNaive_cdef(Q, p, k, m, zvec, nzvec)
 
 
-
-
-
-
-
 cdef local_solution_type_cdef(Q, p, w, zvec, nzvec):
     """
     Internal routine to check if a given solution vector `w` (of `Q(w) =
@@ -209,91 +198,87 @@ cdef local_solution_type_cdef(Q, p, w, zvec, nzvec):
 
     # Check if the solution satisfies the zvec "zero" congruence conditions
     # (either zvec is empty or its components index the zero vector mod p)
-    if (zvec is None) or (not zvec):
+    if zvec is None or not zvec:
         zero_flag = True
     else:
         zero_flag = False
         i = 0
-        while ( (i < len(zvec)) and ((w[zvec[i]] % p) == 0) ):  # Increment so long as our entry is zero (mod p)
+        while i < len(zvec) and not w[zvec[i]] % p:  # Increment so long as our entry is zero (mod p)
             i += 1
-        if (i == len(zvec)):      # If we make it through all entries then the solution is zero (mod p)
+        if i == len(zvec):      # If we make it through all entries then the solution is zero (mod p)
             zero_flag = True
 
-
     # DIAGNOSTIC
-    #print("IsLocalSolutionType: Finished the Zero congruence condition test \n")
+    # print("IsLocalSolutionType: Finished the Zero congruence condition test \n")
 
     if not zero_flag:
         return <long> 0
 
     # DIAGNOSTIC
-    #print("IsLocalSolutionType: Passed the Zero congruence condition test \n")
+    # print("IsLocalSolutionType: Passed the Zero congruence condition test \n")
 
     # Check if the solution satisfies the nzvec "nonzero" congruence conditions
     # (nzvec is non-empty and its components index a non-zero vector mod p)
-    if (nzvec is None):
+    if nzvec is None:
         nonzero_flag = True
-    elif (len(nzvec) == 0):
+    elif len(nzvec) == 0:
         nonzero_flag = False           # Trivially no solutions in this case!
     else:
         nonzero_flag = False
         i = 0
-        while ((not nonzero_flag) and (i < len(nzvec))):
-            if ((w[nzvec[i]] % p) != 0):
+        while not nonzero_flag and i < len(nzvec):
+            if w[nzvec[i]] % p:
                 nonzero_flag = True           # The non-zero condition is satisfied when we find one non-zero entry
             i += 1
 
     if not nonzero_flag:
         return <long> 0
 
-
     # Check if the solution has the appropriate (local) type:
     # -------------------------------------------------------
 
     # 1: Check Good-type
-    for i from 0 <= i < n:
-        if (((w[i] % p) != 0)  and ((Q[i,i] % p) != 0)):
+    for i in range(n):
+        if w[i] % p and Q[i, i] % p:
             return <long> 1
-    if (p == 2):
-        for i from 0 <= i < (n - 1):
-            if (((Q[i,i+1] % p) != 0) and (((w[i] % p) != 0) or ((w[i+1] % p) != 0))):
+    if p == 2:
+        for i in range(n - 1):
+            if Q[i, i+1] % p and (w[i] % p or w[i+1] % p):
                 return <long> 1
 
-
     # 2: Check Zero-type
     Zero_flag = True
-    for i from 0 <= i < n:
-        if ((w[i] % p) != 0):
+    for i in range(n):
+        if w[i] % p:
             Zero_flag = False
     if Zero_flag:
         return <long> 2
 
-
     # Check if wS1 is zero or not
     wS1_nonzero_flag = False
     for i from 0 <= i < n:
 
         # Compute the valuation of each index, allowing for off-diagonal terms
-        if (Q[i,i] == 0):
-            if (i == 0):
-                val = valuation(Q[i,i+1], p)    # Look at the term to the right
-            elif (i == n - 1):
-                val = valuation(Q[i-1,i], p)    # Look at the term above
+        if Q[i, i] == 0:
+            if i == 0:
+                val = valuation(Q[i, i+1], p)   # Look at the term to the right
+            elif i == n - 1:
+                val = valuation(Q[i-1, i], p)   # Look at the term above
             else:
-                val = valuation(Q[i,i+1] + Q[i-1,i], p)    # Finds the valuation of the off-diagonal term since only one isn't zero
+                val = valuation(Q[i, i+1] + Q[i-1, i], p)  # Finds the valuation of the off-diagonal term since only one isn't zero
         else:
-            val = valuation(Q[i,i], p)
+            val = valuation(Q[i, i], p)
 
         # Test each index
-        if ((val == 1) and ((w[i] % p) != 0)):
+        if val == 1 and w[i] % p:
             wS1_nonzero_flag = True
 
     # 4: Check Bad-type I
-    if (wS1_nonzero_flag is True):
+    if wS1_nonzero_flag:
         return <long> 4
 
     # 5: Check Bad-type II
-    if (wS1_nonzero_flag is False):
+    if not wS1_nonzero_flag:
         return <long> 5
 
     # Error if we get here! =o

src/sage/quadratic_forms/quadratic_form__evaluate.pyx

@@ -4,14 +4,15 @@
 def QFEvaluateVector(Q, v):
     r"""
     Evaluate this quadratic form `Q` on a vector or matrix of elements
-    coercible to the base ring of the quadratic form.  If a vector
-    is given, then the output will be the ring element `Q(v)`, but if a
-    matrix is given, then the output will be the quadratic form `Q'`
-    which in matrix notation is given by:
+    coercible to the base ring of the quadratic form.
+
+    If a vector is given, then the output will be the ring element
+    `Q(v)`, but if a matrix is given, then the output will be the
+    quadratic form `Q'` which in matrix notation is given by:
 
     .. MATH::
 
-            Q' = v^t\cdot Q\cdot v.
+        Q' = v^t\cdot Q\cdot v.
 
     .. NOTE::
 
@@ -43,7 +44,6 @@ def QFEvaluateVector(Q, v):
     return QFEvaluateVector_cdef(Q, v)
 
 
-
 cdef QFEvaluateVector_cdef(Q, v):
     r"""
     Routine to quickly evaluate a quadratic form `Q` on a vector `v`.  See
@@ -54,16 +54,15 @@ cdef QFEvaluateVector_cdef(Q, v):
     # (In matrix notation: A^t * Q * A)
     n = Q.dim()
 
-    tmp_val = Q.base_ring()(0)
-    for i from 0 <= i < n:
-        for j from i <= j < n:
-            tmp_val += Q[i,j] * v[i] * v[j]
+    tmp_val = Q.base_ring().zero()
+    for i in range(n):
+        for j in range(i, n):
+            tmp_val += Q[i, j] * v[i] * v[j]
 
     # Return the value (over R)
     return Q.base_ring().coerce(tmp_val)
 
 
-
 def QFEvaluateMatrix(Q, M, Q2):
     r"""
     Evaluate this quadratic form `Q` on a matrix `M` of elements coercible
@@ -72,7 +71,7 @@ def QFEvaluateMatrix(Q, M, Q2):
 
     .. MATH::
 
-            Q_2 = M^t\cdot Q\cdot M.
+        Q_2 = M^t\cdot Q\cdot M.
 
     .. NOTE::
 
@@ -125,14 +124,17 @@ cdef QFEvaluateMatrix_cdef(Q, M, Q2):
     # TODO: Check the dimensions of M are compatible with those of Q and Q2
 
     # Evaluate Q(M) into Q2
-    for k from 0 <= k < m:
-        for l from k <= l < m:
-            tmp_sum = Q2.base_ring()(0)
-            for i from 0 <= i < n:
-                for j from i <= j < n:
-                    if (k == l):
-                        tmp_sum += Q[i,j] * (M[i,k] * M[j,l])
-                    else:
-                        tmp_sum += Q[i,j] * (M[i,k] * M[j,l] + M[i,l] * M[j,k])
-            Q2[k,l] = tmp_sum
+    for k in range(m):
+        for l in range(k, m):
+            tmp_sum = Q2.base_ring().zero()
+            if k == l:
+                for i in range(n):
+                    for j in range(i, n):
+                        tmp_sum += Q[i, j] * (M[i, k] * M[j, l])
+            else:
+                for i in range(n):
+                    for j in range(i, n):
+                        tmp_sum += Q[i, j] * (M[i, k] * M[j, l] +
+                                              M[i, l] * M[j, k])
+            Q2[k, l] = tmp_sum
     return Q2