gh-36157: some pep for E30 and more in quadratic forms
    
pep8 cleanup for E302 and others in quadratic_forms

### 📝 Checklist

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

Author: Release Manager

src/sage/quadratic_forms/genera/genus.py

@@ -174,8 +174,8 @@ def _local_genera(p, rank, det_val, max_scale, even):
     """
     from sage.misc.mrange import cantor_product
     from sage.combinat.integer_lists.invlex import IntegerListsLex
-    scales_rks = [] # contains possibilities for scales and ranks
-    for rkseq in IntegerListsLex(rank, length=max_scale+1):   # rank sequences
+    scales_rks = []  # contains possibilities for scales and ranks
+    for rkseq in IntegerListsLex(rank, length=max_scale + 1):  # rank sequences
         # sum(rkseq) = rank
         # len(rkseq) = max_scale + 1
         # now assure that we get the right determinant
@@ -278,7 +278,7 @@ def _blocks(b, even_only=False):
         # odd case
         if not even_only:
             # format (det, oddity)
-            for s in [(1,2), (5,6), (1,6), (5,2), (7,0), (3,4)]:
+            for s in [(1, 2), (5, 6), (1, 6), (5, 2), (7, 0), (3, 4)]:
                 b1 = copy(b)
                 b1[2] = s[0]
                 b1[3] = 1
@@ -289,20 +289,20 @@ def _blocks(b, even_only=False):
         b1 = copy(b)
         b1[3] = 0
         b1[4] = 0
-        d = (-1)**(rk//2) % 8
+        d = (-1)**(rk // 2) % 8
         for det in [d, d * (-3) % 8]:
             b1 = copy(b1)
             b1[2] = det
             blocks.append(b1)
         # odd case
         if not even_only:
-            for s in [(1,2), (5,6), (1,6), (5,2), (7,0), (3,4)]:
+            for s in [(1, 2), (5, 6), (1, 6), (5, 2), (7, 0), (3, 4)]:
                 b1 = copy(b)
                 b1[2] = s[0]*(-1)**(rk//2 -1) % 8
                 b1[3] = 1
                 b1[4] = s[1]
                 blocks.append(b1)
-            for s in [(1,4), (5,0)]:
+            for s in [(1, 4), (5, 0)]:
                 b1 = copy(b)
                 b1[2] = s[0]*(-1)**(rk//2 - 2) % 8
                 b1[3] = 1
@@ -445,12 +445,14 @@ def is_GlobalGenus(G):
                 verbose(mesg="False in is_2_adic_genus(sym)", level=2)
                 return False
             if (a*b).kronecker(p) != 1:
-                verbose(mesg="False in (%s*%s).kronecker(%s)"%(a,b,p), level=2)
+                verbose(mesg="False in (%s*%s).kronecker(%s)" % (a, b, p),
+                        level=2)
                 return False
             oddity -= loc.excess()
         else:
             if a.kronecker(p) != b:
-                verbose(mesg="False in %s.kronecker(%s) != *%s"%(a,p,b), level=2)
+                verbose(mesg="False in %s.kronecker(%s) != *%s" % (a, p, b),
+                        level=2)
                 return False
             oddity += loc.excess()
     if oddity % 8 != 0:
@@ -586,6 +588,7 @@ def canonical_2_adic_compartments(genus_symbol_quintuple_list):
             i += 1
     return compartments
 
+
 def canonical_2_adic_trains(genus_symbol_quintuple_list, compartments=None):
     r"""
     Given a `2`-adic local symbol (as the underlying list of quintuples)
@@ -658,7 +661,7 @@ def canonical_2_adic_trains(genus_symbol_quintuple_list, compartments=None):
     # avoid a special case for the end of symbol
     # if a jordan component has rank zero it is considered even.
     symbol = genus_symbol_quintuple_list
-    symbol.append([symbol[-1][0]+1, 0, 1, 0, 0]) #We have just modified the input globally!
+    symbol.append([symbol[-1][0]+1, 0, 1, 0, 0])  # We have just modified the input globally!
     # Hence, we have to remove the last entry of symbol at the end.
     try:
 
@@ -684,9 +687,10 @@ def canonical_2_adic_trains(genus_symbol_quintuple_list, compartments=None):
         trains.append(new_train)
         return trains
     finally:
-        #revert the input list to its original state
+        # revert the input list to its original state
         symbol.pop()
 
+
 def canonical_2_adic_reduction(genus_symbol_quintuple_list):
     r"""
     Given a `2`-adic local symbol (as the underlying list of quintuples)
@@ -749,14 +753,14 @@ def canonical_2_adic_reduction(genus_symbol_quintuple_list):
     # Canonical determinants:
     for i in range(len(genus_symbol_quintuple_list)):
         d = genus_symbol_quintuple_list[i][2]
-        if d in (1,7):
+        if d in (1, 7):
             canonical_symbol[i][2] = 1
         else:
             canonical_symbol[i][2] = -1
     # Oddity fusion:
     compartments = canonical_2_adic_compartments(genus_symbol_quintuple_list)
     for compart in compartments:
-        oddity = sum([ genus_symbol_quintuple_list[i][4] for i in compart ]) % 8
+        oddity = sum([genus_symbol_quintuple_list[i][4] for i in compart]) % 8
         for i in compart:
             genus_symbol_quintuple_list[i][4] = 0
         genus_symbol_quintuple_list[compart[0]][4] = oddity
@@ -3425,16 +3429,17 @@ def _gram_from_jordan_block(p, block, discr_form=False):
         d = 2**(rk % 2)
         if Integer(d).kronecker(p) != det:
             u = ZZ(_min_nonsquare(p))
-            q[0,0] = u
+            q[0, 0] = u
         q = q * (2 / p**level)
     if p != 2 and not discr_form:
         q = matrix.identity(QQ, rk)
         if det != 1:
             u = ZZ(_min_nonsquare(p))
-            q[0,0] = u
+            q[0, 0] = u
         q = q * p**level
     return q
 
+
 # Helper functions for mass computations
 
 def M_p(species, p):

src/sage/quadratic_forms/qfsolve.py

@@ -16,16 +16,16 @@
 - Tyler Gaona (2015-11-14): added the `solve` method
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2008 Nick Alexander
 #       Copyright (C) 2014 Jeroen Demeyer
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
@@ -80,6 +80,7 @@ def qfsolve(G):
         return vector(QQ, ret)
     return ZZ(ret)
 
+
 def qfparam(G, sol):
     r"""
     Parametrize the conic defined by the matrix `G`.
@@ -220,8 +221,8 @@ def solve(self, c=0):
     N = Matrix(self.base_ring(), d+1, d+1)
     for i in range(d):
         for j in range(d):
-            N[i,j] = M[i,j]
-    N[d,d] = -c
+            N[i, j] = M[i, j]
+    N[d, d] = -c
 
     # Find a solution x to Q(x) = 0, using qfsolve()
     x = qfsolve(N)

src/sage/quadratic_forms/quadratic_form__neighbors.py

@@ -131,6 +131,7 @@ def find_primitive_p_divisible_vector__next(self, p, v=None):
         if a in ZZ and (a % p == 0):
             return w
 
+
 def find_p_neighbor_from_vec(self, p, y):
     r"""
     Return the `p`-neighbor of ``self`` defined by ``y``.
@@ -173,7 +174,7 @@ def find_p_neighbor_from_vec(self, p, y):
     """
     p = ZZ(p)
     if not p.divides(self(y)):
-        raise ValueError("y=%s must be of square divisible by p=%s"%(y,p))
+        raise ValueError("y=%s must be of square divisible by p=%s" % (y, p))
     if self.base_ring() not in [ZZ, QQ]:
         raise NotImplementedError("the base ring of this form must be the integers or the rationals")
 
@@ -197,14 +198,14 @@ def find_p_neighbor_from_vec(self, p, y):
                 z = (ZZ**n).gen(k)
                 break
         else:
-            raise ValueError("either y is not primitive or self is not maximal at %s"%p)
+            raise ValueError("either y is not primitive or self is not maximal at %s" % p)
         z *= (2*y*G*z).inverse_mod(p)
         y = y - b*z
         # assert y*G*y % p^2 == 0
     if p == 2:
         val = b.valuation(p)
         if val <= 1:
-            raise ValueError("y=%s must be of square divisible by 2"%y)
+            raise ValueError("y=%s must be of square divisible by 2" % y)
         if val == 2 and not odd:
             # modify it to have square 4
             for k in range(n):
@@ -348,14 +349,15 @@ def p_divisible_vectors(Q, max_neighbors):
                     break
 
     if len(isom_classes) >= max_classes:
-        warn("reached the maximum number of isometry classes=%s. Increase the optional argument max_classes to obtain more." %max_classes)
+        warn("reached the maximum number of isometry classes=%s. Increase the optional argument max_classes to obtain more." % max_classes)
 
     if mass is not None:
         assert mass_count <= mass
         if mass_count < mass:
             print("Warning: not all classes in the genus were found")
     return isom_classes
 
+
 def orbits_lines_mod_p(self, p):
     r"""
     Let `(L, q)` be a lattice. This returns representatives of the

src/sage/quadratic_forms/quadratic_form__siegel_product.py

@@ -3,13 +3,13 @@
 Siegel Products
 """
 
-#*****************************************************************************
+# ****************************************************************************
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.arith.misc import (bernoulli,
                              fundamental_discriminant,
@@ -21,16 +21,17 @@
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
 
-#/*!  \brief Computes the product of all local densities for comparison with independently computed Eisenstein coefficients.
+# /*!  \brief Computes the product of all local densities for comparison with independently computed Eisenstein coefficients.
 # *
 # *  \todo We fixed the generic factors to compensate for using the matrix of 2Q, but we need to document this better! =)
 # */
 
-#/////////////////////////////////////////////////////////////////
-#///
-#/////////////////////////////////////////////////////////////////
+# /////////////////////////////////////////////////////////////////
+# ///
+# /////////////////////////////////////////////////////////////////
+
+# mpq_class Matrix_mpz::siegel_product(mpz_class u) const {
 
-#mpq_class Matrix_mpz::siegel_product(mpz_class u) const {
 
 def siegel_product(self, u):
     """
@@ -124,15 +125,15 @@ def siegel_product(self, u):
         f = abs(d1)
 
         # DIAGNOSTIC
-        #cout << " mpz_class(-1)^m = " << (mpz_class(-1)^m) << " and d = " << d << endl;
-        #cout << " f = " << f << " and d1 = " << d1 << endl;
+        # cout << " mpz_class(-1)^m = " << (mpz_class(-1)^m) << " and d = " << d << endl;
+        # cout << " f = " << f << " and d1 = " << d1 << endl;
 
         genericfactor = m / QQ(sqrt(f*d)) \
             * ((u/2) ** (m-1)) * (f ** m) \
             / abs(QuadraticBernoulliNumber(m, d1)) \
             * (2 ** m)                                               # This last factor compensates for using the matrix of 2*Q
 
-    ##return genericfactor
+    # return genericfactor
 
     # Omit the generic factors in S and compute them separately
     omit = 1
@@ -141,9 +142,9 @@ def siegel_product(self, u):
     S_divisors = prime_divisors(S)
 
     # DIAGNOSTIC
-    #cout << "\n S is " << S << endl;
-    #cout << " The Prime divisors of S are :";
-    #PrintV(S_divisors);
+    # cout << "\n S is " << S << endl;
+    # cout << " The Prime divisors of S are :";
+    # PrintV(S_divisors);
 
     for p in S_divisors:
         Q_normal = self.local_normal_form(p)
@@ -158,36 +159,36 @@ def siegel_product(self, u):
         verbose(" Q_normal is \n" + str(Q_normal) + "\n")
         verbose(" Q_normal = \n" + str(Q_normal))
         verbose(" p = " + str(p) + "\n")
-        verbose(" u = " +str(u) + "\n")
+        verbose(" u = " + str(u) + "\n")
         verbose(" include = " + str(include) + "\n")
 
         include *= Q_normal.local_density(p, u)
 
         # DIAGNOSTIC
-        #cout << " Including the p = " << p << " factor: " << local_density(Q_normal, p, u) << endl;
+        # cout << " Including the p = " << p << " factor: " << local_density(Q_normal, p, u) << endl;
 
         # DIAGNOSTIC
         verbose("    ---  Exiting loop \n")
 
-    #// ****************  Important *******************
-    #// Additional fix (only included for n=4) to deal
-    #// with the power of 2 introduced at the real place
-    #// by working with Q instead of 2*Q.  This needs to
-    #// be done for all other n as well...
-    #/*
-    #if (n==4)
+    # // ****************  Important *******************
+    # // Additional fix (only included for n=4) to deal
+    # // with the power of 2 introduced at the real place
+    # // by working with Q instead of 2*Q.  This needs to
+    # // be done for all other n as well...
+    # /*
+    # if (n==4)
     #  genericfactor = 4 * genericfactor;
-    #*/
+    # */
 
     # DIAGNOSTIC
-    #cout << endl;
-    #cout << " generic factor = " << genericfactor << endl;
-    #cout << " omit = " << omit << endl;
-    #cout << " include = " << include << endl;
-    #cout << endl;
+    # cout << endl;
+    # cout << " generic factor = " << genericfactor << endl;
+    # cout << " omit = " << omit << endl;
+    # cout << " include = " << include << endl;
+    # cout << endl;
 
     # DIAGNOSTIC
-    #//  cout << "siegel_product Break 3. " << endl;
+    # //  cout << "siegel_product Break 3. " << endl;
 
     # Return the final factor (and divide by 2 if n=2)
     if n == 2:

src/sage/quadratic_forms/special_values.py

@@ -91,6 +91,7 @@ def gamma__exact(n):
 
     raise TypeError("you must give an integer or half-integer argument")
 
+
 # ------------- The Riemann Zeta Function  --------------
 
 def zeta__exact(n):
@@ -159,6 +160,7 @@ def zeta__exact(n):
     elif n == 0:
         return QQ((-1, 2))
 
+
 # ---------- Dirichlet L-functions with quadratic characters ----------
 
 def QuadraticBernoulliNumber(k, d):
@@ -232,7 +234,7 @@ def quadratic_L_function__exact(n, d):
     - [Was1997]_
     """
     if n <= 0:
-        return QuadraticBernoulliNumber(1-n,d)/(n-1)
+        return QuadraticBernoulliNumber(1-n, d)/(n-1)
     elif n >= 1:
         # Compute the kind of critical values (p10)
         if kronecker_symbol(fundamental_discriminant(d), -1) == 1:
@@ -255,7 +257,7 @@ def quadratic_L_function__exact(n, d):
             ans *= (2*pi/f)**n
             ans *= GS     # Evaluate the Gauss sum here! =0
             ans *= QQ.one()/(2 * I**delta)
-            ans *= QuadraticBernoulliNumber(n,d)/factorial(n)
+            ans *= QuadraticBernoulliNumber(n, d)/factorial(n)
             return ans
         else:
             if delta == 0:
@@ -314,6 +316,6 @@ def quadratic_L_function__numerical(n, d, num_terms=1000):
 
     d1 = fundamental_discriminant(d)
     ans = R.zero()
-    for i in range(1,num_terms):
-        ans += R(kronecker_symbol(d1,i) / R(i)**n)
+    for i in range(1, num_terms):
+        ans += R(kronecker_symbol(d1, i) / R(i)**n)
     return ans