a few more details

Author: fchapoton

src/sage/quadratic_forms/quadratic_form.py

@@ -125,7 +125,7 @@ def quadratic_form_from_invariants(F, rk, det, P, sminus):
     """
     from sage.arith.misc import hilbert_symbol
     # normalize input
-    if F!=QQ:
+    if F != QQ:
         raise NotImplementedError('base field must be QQ. If you want this over any field, implement weak approximation.')
     P = [ZZ(p) for p in P]
     rk = ZZ(rk)
@@ -153,33 +153,33 @@ def quadratic_form_from_invariants(F, rk, det, P, sminus):
             else:
                 a = ZZ(1)
         elif rk == 3:
-            Pprime = [p for p in P if hilbert_symbol(-1, -d, p)==1]
-            Pprime += [p for p in (2*d).prime_divisors()
-                       if hilbert_symbol(-1, -d, p)==-1 and p not in P]
+            Pprime = [p for p in P if hilbert_symbol(-1, -d, p) == 1]
+            Pprime += [p for p in (2 * d).prime_divisors()
+                       if hilbert_symbol(-1, -d, p) == -1 and p not in P]
             if sminus > 0:
                 a = ZZ(-1)
             else:
                 a = ZZ(1)
             for p in Pprime:
                 if d.valuation(p) % 2 == 0:
                     a *= p
-            assert all((a*d).valuation(p)%2==1 for p in Pprime)
+            assert all((a * d).valuation(p) % 2 == 1 for p in Pprime)
         elif rk == 2:
             S = P
             if sminus == 2:
                 S += [-1]
-            a = QQ.hilbert_symbol_negative_at_S(S,-d)
+            a = QQ.hilbert_symbol_negative_at_S(S, -d)
             a = ZZ(a)
         P = ([p for p in P if hilbert_symbol(a, -d, p) == 1]
-            +[p for p in (2*a*d).prime_divisors()
-              if hilbert_symbol(a, -d, p)==-1 and p not in P])
-        sminus = max(0, sminus-1)
+             + [p for p in (2 * a * d).prime_divisors()
+                if hilbert_symbol(a, -d, p) == -1 and p not in P])
+        sminus = max(0, sminus - 1)
         rk = rk - 1
-        d = a*d
+        d = a * d
         D.append(a.squarefree_part())
     d = d.squarefree_part()
     D.append(d)
-    return DiagonalQuadraticForm(QQ,D)
+    return DiagonalQuadraticForm(QQ, D)
 
 
 class QuadraticForm(SageObject):
@@ -606,10 +606,10 @@ def __init__(self, R, n=None, entries=None, unsafe_initialization=False, number_
             self.__coeffs = []
             for i in range(M.nrows()):
                 for j in range(i, M.nrows()):
-                    if (i == j):
-                        self.__coeffs += [ M_ring(M[i,j] / 2) ]
+                    if i == j:
+                        self.__coeffs += [M_ring(M[i, j] / 2)]
                     else:
-                        self.__coeffs += [ M_ring(M[i,j]) ]
+                        self.__coeffs += [M_ring(M[i, j])]
 
             return
 
@@ -649,8 +649,8 @@ def __init__(self, R, n=None, entries=None, unsafe_initialization=False, number_
             # Set the number of automorphisms
             if number_of_automorphisms is not None:
                 self.set_number_of_automorphisms(number_of_automorphisms)
-                #self.__number_of_automorphisms = number_of_automorphisms
-                #self.__external_initialization_list.append('number_of_automorphisms')
+                # self.__number_of_automorphisms = number_of_automorphisms
+                # self.__external_initialization_list.append('number_of_automorphisms')
 
             # Set the determinant
             if determinant is not None:
@@ -827,7 +827,7 @@ def __setitem__(self, ij, coeff):
 
         # Set the entry
         try:
-            self.__coeffs[i*self.__n - i*(i-1)//2 + j -i] = self.__base_ring(coeff)
+            self.__coeffs[i*self.__n - i*(i-1)//2 + j - i] = self.__base_ring(coeff)
         except Exception:
             raise RuntimeError("this coefficient cannot be coerced to an element of the base ring for the quadratic form")
 
@@ -934,47 +934,42 @@ def sum_by_coefficients_with(self, right):
         """
         if not isinstance(right, QuadraticForm):
             raise TypeError("cannot add these objects since they are not both quadratic forms")
-        elif (self.__n != right.__n):
+        elif self.__n != right.__n:
             raise TypeError("cannot add these since the quadratic forms do not have the same sizes")
-        elif (self.__base_ring != right.__base_ring):
+        elif self.__base_ring != right.__base_ring:
             raise TypeError("cannot add these since the quadratic forms do not have the same base rings")
-        return QuadraticForm(self.__base_ring, self.__n, [self.__coeffs[i] + right.__coeffs[i]  for i in range(len(self.__coeffs))])
-
-# ========================  CHANGE THIS TO A TENSOR PRODUCT?!?  Even in Characteristic 2?!?  =======================
-#    def __mul__(self, right):
-#        """
-#        Multiply (on the right) the quadratic form Q by an element of the ring that Q is defined over.
-#
-#        EXAMPLES::
-#
-#            sage: Q = QuadraticForm(ZZ, 2, [1,4,10])
-#            sage: Q*2
-#            Quadratic form in 2 variables over Integer Ring with coefficients:
-#            [ 2 8 ]
-#            [ * 20 ]
-#
-#            sage: Q+Q == Q*2
-#            True
-#
-#        """
-#        try:
-#            c = self.base_ring()(right)
-#        except Exception:
-#            raise TypeError, "Oh no! The multiplier cannot be coerced into the base ring of the quadratic form. =("
-#
-#        return QuadraticForm(self.base_ring(), self.dim(), [c * self.__coeffs[i]  for i in range(len(self.__coeffs))])
-
-    # =================================================================
+        return QuadraticForm(self.__base_ring, self.__n, [self.__coeffs[i] + right.__coeffs[i] for i in range(len(self.__coeffs))])
+
+    # ========================  CHANGE THIS TO A TENSOR PRODUCT?!?  Even in Characteristic 2?!?  =======================
+    #    def __mul__(self, right):
+    #        """
+    #        Multiply (on the right) the quadratic form Q by an element of the ring that Q is defined over.
+    #
+    #        EXAMPLES::
+    #
+    #            sage: Q = QuadraticForm(ZZ, 2, [1,4,10])
+    #            sage: Q*2
+    #            Quadratic form in 2 variables over Integer Ring with coefficients:
+    #            [ 2 8 ]
+    #            [ * 20 ]
+    #
+    #            sage: Q+Q == Q*2
+    #            True
+    #        """
+    #        try:
+    #            c = self.base_ring()(right)
+    #        except Exception:
+    #            raise TypeError("the multiplier cannot be coerced into the base ring of the quadratic form")
+    #        return QuadraticForm(self.base_ring(), self.dim(), [c * self.__coeffs[i]  for i in range(len(self.__coeffs))])
 
     def __call__(self, 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:
+        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::
 
@@ -1116,23 +1111,17 @@ def _is_even_symmetric_matrix_(self, A, R=None):
         if not isinstance(R, Ring):
             raise TypeError("R is not a ring.")
 
-        if not A.is_square():
+        if not (A.is_square() and A.is_symmetric()):
             return False
 
-        # Test that the matrix is symmetric
-        n = A.nrows()
-        for i in range(n):
-            for j in range(i+1, n):
-                if A[i,j] != A[j,i]:
-                    return False
-
         # Test that all entries coerce to R
+        n = A.nrows()
         if not ((A.base_ring() == R) or ring_coerce_test):
             try:
                 for i in range(n):
                     for j in range(i, n):
-                        R(A[i,j])
-            except Exception:
+                        R(A[i, j])
+            except (TypeError, ValueError):
                 return False
 
         # Test that the diagonal is even (if 1/2 isn't in R)
@@ -1180,10 +1169,10 @@ def Hessian_matrix(self):
         mat_entries = []
         for i in range(self.dim()):
             for j in range(self.dim()):
-                if (i == j):
-                    mat_entries += [ 2 * self[i,j] ]
+                if i == j:
+                    mat_entries += [2 * self[i, j]]
                 else:
-                    mat_entries += [ self[i,j] ]
+                    mat_entries += [self[i, j]]
 
         return matrix(self.base_ring(), self.dim(), self.dim(), mat_entries)
 
@@ -1384,11 +1373,11 @@ def from_polynomial(poly):
         if not isinstance(R, MPolynomialRing_base):
             raise TypeError(f'not a multivariate polynomial ring: {R}')
         if not all(mon.degree() == 2 for mon in poly.monomials()):
-            raise ValueError(f'polynomial has monomials of degree != 2')
+            raise ValueError('polynomial has monomials of degree != 2')
         base = R.base_ring()
         vs = R.gens()
         coeffs = []
-        for i,v in enumerate(vs):
+        for i, v in enumerate(vs):
             for w in vs[i:]:
                 coeffs.append(poly.monomial_coefficient(v*w))
         return QuadraticForm(base, len(vs), coeffs)
@@ -1625,7 +1614,7 @@ def level(self):
             # Warn the user if the form is defined over a field!
             if self.base_ring().is_field():
                 warn("Warning -- The level of a quadratic form over a field is always 1.  Do you really want to do this?!?")
-                #raise RuntimeError, "Warning -- The level of a quadratic form over a field is always 1.  Do you really want to do this?!?"
+                # raise RuntimeError("Warning -- The level of a quadratic form over a field is always 1.  Do you really want to do this?!?")
 
             # Check invertibility and find the inverse
             try:
@@ -1747,7 +1736,7 @@ def bilinear_map(self, v, w):
             raise TypeError("vectors must have length " + str(self.dim()))
         if self.base_ring().characteristic() == 2:
             raise TypeError("not defined for rings of characteristic 2")
-        return (self(v+w) - self(v) - self(w))/2
+        return (self(v + w) - self(v) - self(w)) / 2
 
 
 def DiagonalQuadraticForm(R, diag):

src/sage/schemes/elliptic_curves/ell_rational_field.py

@@ -6627,22 +6627,23 @@ def reduction_at(p):
                 raise RuntimeError('Unexpected intermediate result. Please try another Mordell-Weil base')
             d_L_0 = R(b1_norm**2 / c1_LLL)
 
-            #Reducing of upper bound
+            # Reducing of upper bound
             Q = r * H_q**2
             T = (1 + (Z(3)/2*r*H_q))/2
             if d_L_0 < R(T**2+Q):
                 d_L_0 = 10*(T**2*Q)
             low_bound = (R(d_L_0 - Q).sqrt() - T) / c
 
-            ##new bound according to low_bound and upper bound
-            ##[k5*k6 exp(-k7**H_q^2)]
+            # new bound according to low_bound and upper bound
+            # [k5*k6 exp(-k7**H_q^2)]
             if low_bound != 0:
                 H_q_infinity = R(((low_bound/(k6)).log()/(-k7)).sqrt())
-                return (H_q_infinity.ceil())
+                return H_q_infinity.ceil()
             else:
-                return (H_q)
-    #<-------------------------------------------------------------------------
-    #>-------------------------------------------------------------------------
+                return H_q
+
+        # --------------------------------------------------------------------
+        # --------------------------------------------------------------------
 
         def S_integral_points_with_bounded_mw_coeffs():
             r"""
@@ -6726,8 +6727,9 @@ def test_with_T(R):
                     Pi[i] = Pi[i-1] + mw_baseN[i]
 
             return xs
-    #<-------------------------------------------------------------------------
-    #>-------------------------------------------------------------------------
+
+        # --------------------------------------------------------------------
+        # --------------------------------------------------------------------
 
         def S_integral_x_coords_with_abs_bounded_by(abs_bound):
             r"""
@@ -6802,8 +6804,8 @@ def S_integral_x_coords_with_abs_bounded_by(abs_bound):
                                     xs += [-tmp]
 
                 return set(xs)
-    #<-------------------------------------------------------------------------
-        #End internal functions ###############################################
+        # -------------------------------------------------------------------
+        # End internal functions ############################################
         from sage.misc.mrange import cartesian_product_iterator
 
         E = self