some details in ternary quadratic forms

Author: fchapoton

src/sage/quadratic_forms/ternary_qf.py

@@ -70,7 +70,8 @@ class TernaryQF(SageObject):
         sage: TestSuite(TernaryQF).run()
     """
 
-    __slots__ = ['_a', '_b', '_c', '_r', '_s', '_t', '_automorphisms', '_number_of_automorphisms']
+    __slots__ = ['_a', '_b', '_c', '_r', '_s', '_t',
+                 '_automorphisms', '_number_of_automorphisms']
 
     possible_automorphisms = None
 
@@ -90,17 +91,16 @@ def __init__(self, v):
             [1 2 3]
             [4 5 6]
         """
-
         if len(v) != 6:
             # Check we have six coefficients
             raise ValueError("Ternary quadratic form must be given by a list of six coefficients")
         self._a, self._b, self._c, self._r, self._s, self._t = (ZZ(x) for x in v)
         self._automorphisms = None
         self._number_of_automorphisms = None
 
-    def coefficients(self):
+    def coefficients(self) -> tuple:
         r"""
-        Return the list of coefficients of the ternary quadratic form.
+        Return the tuple of coefficients of the ternary quadratic form.
 
         EXAMPLES::
 
@@ -113,7 +113,7 @@ def coefficients(self):
         """
         return self._a, self._b, self._c, self._r, self._s, self._t
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         """
         Return a hash for ``self``.
 
@@ -124,7 +124,6 @@ def __hash__(self):
             5881802312257552497  # 64-bit
             1770036893           # 32-bit
         """
-
         return hash(self.coefficients())
 
     def coefficient(self, n):
@@ -166,7 +165,7 @@ def polynomial(self, names='x,y,z'):
         x, y, z = polygens(ZZ, names)
         return self._a * x**2 + self._b * y**2 + self._c * z**2 + self._t * x*y + self._s * x*z + self._r * y*z
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Display the quadratic form.
 
@@ -230,19 +229,19 @@ def __call__(self, v):
             # Check if v has 3 cols
             if v.ncols() == 3:
                 M = v.transpose() * self.matrix() * v
-                return TernaryQF([M[0, 0]//2, M[1, 1]//2, M[2, 2]//2,
+                return TernaryQF([M[0, 0] // 2, M[1, 1] // 2, M[2, 2] // 2,
                                   M[1, 2], M[0, 2], M[0, 1]])
-            else:
-                return QuadraticForm(ZZ, v.transpose() * self.matrix() * v)
-        elif isinstance(v, (Vector, list, tuple)):
+
+            return QuadraticForm(ZZ, v.transpose() * self.matrix() * v)
+        if isinstance(v, (Vector, list, tuple)):
             # Check that v has length 3
             if len(v) != 3:
                 raise TypeError("your vector needs to have length 3")
             v0, v1, v2 = v
             a, b, c, r, s, t = self.coefficients()
             return a*v0**2 + b*v1**2 + c*v2**2 + r*v1*v2 + s*v0*v2 + t*v0*v1
-        else:
-            raise TypeError("presently we can only evaluate a quadratic form on a list, tuple, vector or matrix")
+
+        raise TypeError("presently we can only evaluate a quadratic form on a list, tuple, vector or matrix")
 
     def quadratic_form(self):
         r"""
@@ -260,11 +259,13 @@ def quadratic_form(self):
             sage: bool(QF1 == QF2)
             True
         """
-        return QuadraticForm(ZZ, 3, [self._a, self._t, self._s, self._b, self._r, self._c])
+        return QuadraticForm(ZZ, 3, [self._a, self._t, self._s,
+                                     self._b, self._r, self._c])
 
     def matrix(self):
         r"""
         Return the Hessian matrix associated to the ternary quadratic form.
+
         That is, if `Q` is a ternary quadratic form, `Q(x,y,z) = a\cdot x^2 + b\cdot y^2 + c\cdot z^2 + r\cdot y\cdot z + s\cdot x\cdot z + t\cdot x\cdot y`,
         then the Hessian matrix associated to `Q` is
         ::
@@ -289,12 +290,15 @@ def matrix(self):
             sage: (v*M*v.column())[0]//2
             28
         """
-        M = matrix(ZZ, 3, [2*self._a, self._t, self._s, self._t, 2*self._b, self._r, self._s, self._r, 2*self._c])
-        return M
+        return matrix(ZZ, 3, 3, [2 * self._a, self._t, self._s,
+                                 self._t, 2 * self._b, self._r,
+                                 self._s, self._r, 2 * self._c])
 
     def disc(self):
         r"""
-        Return the discriminant of the ternary quadratic form, this is the determinant of the matrix divided by 2.
+        Return the discriminant of the ternary quadratic form.
+
+        This is the determinant of the matrix divided by 2.
 
         EXAMPLES::
 
@@ -324,28 +328,19 @@ def is_definite(self) -> bool:
         d1 = self._a
         if d1 == 0:
             return False
-        d2 = 4*self._a*self._b-self._t**2
+        d2 = 4 * self._a * self._b - self._t**2
         if d2 == 0:
             return False
         d3 = self.disc()
         if d3 == 0:
             return False
         if d1 > 0:
             if d2 > 0:
-                if d3 > 0:
-                    return True
-                else:
-                    return False
-            else:
-                return False
-        else:
-            if d2 > 0:
-                if d3 < 0:
-                    return True
-                else:
-                    return False
-            else:
-                return False
+                return d3 > 0
+            return False
+        if d2 > 0:
+            return d3 < 0
+        return False
 
     def is_positive_definite(self) -> bool:
         """
@@ -370,22 +365,13 @@ def is_positive_definite(self) -> bool:
         d1 = self._a
         if d1 == 0:
             return False
-        d2 = 4*self._a*self._b-self._t**2
+        d2 = 4 * self._a * self._b - self._t**2
         if d2 == 0:
             return False
         d3 = self.disc()
         if d3 == 0:
             return False
-        if d1 > 0:
-            if d2 > 0:
-                if d3 > 0:
-                    return True
-                else:
-                    return False
-            else:
-                return False
-        else:
-            return False
+        return d1 > 0 and d2 > 0 and d3 > 0
 
     def is_negative_definite(self) -> bool:
         """
@@ -405,22 +391,13 @@ def is_negative_definite(self) -> bool:
         d1 = self._a
         if d1 == 0:
             return False
-        d2 = 4*self._a*self._b-self._t**2
+        d2 = 4 * self._a * self._b - self._t**2
         if d2 == 0:
             return False
         d3 = self.disc()
         if d3 == 0:
             return False
-        if d1 < 0:
-            if d2 > 0:
-                if d3 < 0:
-                    return True
-                else:
-                    return False
-            else:
-                return False
-        else:
-            return False
+        return d1 < 0 and d2 > 0 and d3 < 0
 
     def __neg__(self):
         """
@@ -487,7 +464,7 @@ def primitive(self):
         """
         l = self.coefficients()
         g = gcd(l)
-        return TernaryQF([a//g for a in l])
+        return TernaryQF([a // g for a in l])
 
     def scale_by_factor(self, k):
         """
@@ -950,7 +927,6 @@ def find_p_neighbors(self, p, mat=False):
             sage: neig.count(Q2)
             3
         """
-
         z = self.find_zeros_mod_p(p)
         return [self.find_p_neighbor_from_vec(p, v, mat) for v in z]
 
@@ -964,7 +940,6 @@ def basic_lemma(self, p):
             sage: Q.basic_lemma(3)
             4
         """
-
         return _basic_lemma(self._a, self._b, self._c, self._r, self._s, self._t, p)
 
     def xi(self, p):
@@ -1085,20 +1060,15 @@ def automorphism_symmetries(self, A):
             sage: Q.automorphism_symmetries(identity_matrix(ZZ,3))
             []
         """
-
         if A == identity_matrix(3):
             return []
-        else:
-            bs = (A - 1).columns()
-            for b1 in bs:
-                if b1 != 0:
-                    break
-            A1 = self.symmetry(b1)*A
-            bs = (A1 - 1).columns()
-            for b2 in bs:
-                if b2 != 0:
-                    break
-            return [b1, b2]
+
+        bs = (A - 1).columns()
+        b1 = next(v for v in bs if v)
+        A1 = self.symmetry(b1) * A
+        bs = (A1 - 1).columns()
+        b2 = next(v for v in bs if v)
+        return [b1, b2]
 
     def automorphism_spin_norm(self, A):
         """
@@ -1117,14 +1087,15 @@ def automorphism_spin_norm(self, A):
         """
         if A == identity_matrix(ZZ, 3):
             return 1
-        bs = self.automorphism_symmetries(A)
-        s = self(bs[0]) * self(bs[1])
+        b1, b2 = self.automorphism_symmetries(A)
+        s = self(b1) * self(b2)
         return s.squarefree_part()
 
     def _border(self, n):
         """
         Auxiliary function to find the automorphisms of a positive definite ternary quadratic form.
-        It return a boolean whether the n-condition is true. If Q = TernaryQF([a,b,c,r,s,t]), the conditions are:
+
+        It returns a boolean whether the n-condition is true. If Q = TernaryQF([a,b,c,r,s,t]), the conditions are:
 
         1.  a = t, s = 2r.
         2.  a = s, t = 2r.
@@ -1194,7 +1165,6 @@ def _border(self, n):
             sage: Q16._border(16)
             True
         """
-
         a, b, c, r, s, t = self.coefficients()
         if n == 1:
             return (a == t) and (s == 2*r)
@@ -1307,7 +1277,6 @@ def _automorphisms_reduced_fast(self):
             sage: Q._automorphisms_reduced_fast()
             [(1, 0, 0, 0, 1, 0, 0, 0, 1)]
         """
-
         if self._border(1):
             if self._border(2):
                 if self._border(14):
@@ -1672,6 +1641,7 @@ def _automorphisms_reduced_fast(self):
     def _automorphisms_reduced_slow(self):
         """
         Return the automorphisms of the reduced ternary quadratic form.
+
         It searches over all 3x3 matrices with coefficients -1, 0, 1,
         determinant 1 and finite order, because Eisenstein reduced forms
         are Minkowski reduced. See Cassels.
@@ -2023,7 +1993,7 @@ def find_all_ternary_qf_by_level_disc(N, d):
         ...
         ValueError: There are no ternary forms of this level and discriminant
     """
-    return [TernaryQF(_) for _ in _find_all_ternary_qf_by_level_disc(N, d)]
+    return [TernaryQF(qf) for qf in _find_all_ternary_qf_by_level_disc(N, d)]
 
 
 def find_a_ternary_qf_by_level_disc(N, d):