src/sage/quadratic_forms: Use \cdot for multiplication

Author: Matthias Koeppe

src/sage/quadratic_forms/qfsolve.py

@@ -89,12 +89,12 @@ def qfparam(G, sol):
     - ``G`` -- a `3 \times 3`-matrix over `\QQ`
 
     - ``sol`` -- a triple of rational numbers providing a solution
-      to sol*G*sol^t = 0
+      to `x\cdot G\cdot x^t = 0`
 
     OUTPUT:
 
     A triple of polynomials that parametrizes all solutions of
-    `x*G*x^t = 0` up to scaling.
+    `x\cdot G\cdot x^t = 0` up to scaling.
 
     ALGORITHM:
 

src/sage/quadratic_forms/quadratic_form.py

@@ -105,7 +105,7 @@ def quadratic_form_from_invariants(F, rk, det, P, sminus):
         Quadratic form in 2 variables over Rational Field with coefficients:
         [ 5 0 ]
         [ * -3 ]
-        sage: all(q.hasse_invariant(p)==-1 for p in P)
+        sage: all(q.hasse_invariant(p) == -1 for p in P)
         True
 
     TESTS:
@@ -768,8 +768,8 @@ def _latex_(self):
         return out_str
 
     def __getitem__(self, ij):
-        """
-        Return the coefficient `a_{ij}` of `x_i * x_j`.
+        r"""
+        Return the coefficient `a_{ij}` of `x_i\cdot x_j`.
 
         EXAMPLES::
 
@@ -794,8 +794,8 @@ def __getitem__(self, ij):
         return self.__coeffs[i*self.__n - i*(i-1)//2 + j - i]
 
     def __setitem__(self, ij, coeff):
-        """
-        Set the coefficient `a_{ij}` in front of `x_i * x_j`.
+        r"""
+        Set the coefficient `a_{ij}` in front of `x_i\cdot x_j`.
 
         EXAMPLES::
 
@@ -968,15 +968,15 @@ def sum_by_coefficients_with(self, right):
 # =========================================================================================================================
 
     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:
 
         .. MATH::
-                Q' = v^t * Q * v.
+                Q' = v^t\cdot Q\cdot v.
 
 
         EXAMPLES:
@@ -1147,8 +1147,8 @@ def _is_even_symmetric_matrix_(self, A, R=None):
 # =====================================================================================================
 
     def matrix(self):
-        """
-        Return the Hessian matrix `A` for which `Q(X) = (1/2) * X^t * A * X`.
+        r"""
+        Return the Hessian matrix `A` for which `Q(X) = (1/2) X^t\cdot A\cdot X`.
 
         EXAMPLES::
 
@@ -1162,8 +1162,8 @@ def matrix(self):
         return self.Hessian_matrix()
 
     def Hessian_matrix(self):
-        """
-        Return the Hessian matrix `A` for which `Q(X) = (1/2) * X^t * A * X`.
+        r"""
+        Return the Hessian matrix `A` for which `Q(X) = (1/2) X^t\cdot A\cdot X`.
 
         EXAMPLES::
 
@@ -1189,13 +1189,13 @@ def Hessian_matrix(self):
         return matrix(self.base_ring(), self.dim(), self.dim(), mat_entries)
 
     def Gram_matrix_rational(self):
-        """
+        r"""
         Return a (symmetric) Gram matrix `A` for the quadratic form `Q`,
         meaning that
 
         .. MATH::
 
-            Q(x) = x^t * A * x,
+            Q(x) = x^t\cdot A\cdot x,
 
         defined over the fraction field of the base ring.
 
@@ -1214,13 +1214,13 @@ def Gram_matrix_rational(self):
         return (ZZ(1) / ZZ(2)) * self.matrix()
 
     def Gram_matrix(self):
-        """
+        r"""
         Return a (symmetric) Gram matrix `A` for the quadratic form `Q`,
         meaning that
 
         .. MATH::
 
-            Q(x) = x^t * A * x,
+            Q(x) = x^t\cdot A\cdot x,
 
         defined over the base ring of `Q`.  If this is not possible,
         then a :class:`TypeError` is raised.
@@ -1251,7 +1251,7 @@ def Gram_matrix(self):
         raise TypeError("this form does not have an integral Gram matrix")
 
     def has_integral_Gram_matrix(self):
-        """
+        r"""
         Return whether the quadratic form has an integral Gram matrix (with respect to its base ring).
 
         A warning is issued if the form is defined over a field, since in that case the return is trivially true.
@@ -1484,7 +1484,7 @@ def base_ring(self):
         return self.__base_ring
 
     def coefficients(self):
-        """
+        r"""
         Return the matrix of upper triangular coefficients,
         by reading across the rows from the main diagonal.
 
@@ -1497,8 +1497,8 @@ def coefficients(self):
         return self.__coeffs
 
     def det(self):
-        """
-        Return the determinant of the Gram matrix of `2*Q`, or
+        r"""
+        Return the determinant of the Gram matrix of `2\cdot Q`, or
         equivalently the determinant of the Hessian matrix of `Q`.
 
         .. NOTE:
@@ -1525,7 +1525,7 @@ def det(self):
             return new_det
 
     def Gram_det(self):
-        """
+        r"""
         Return the determinant of the Gram matrix of `Q`.
 
         .. NOTE::
@@ -1590,8 +1590,8 @@ def change_ring(self, R):
     def level(self):
         r"""
         Determines the level of the quadratic form over a PID, which is a
-        generator for the smallest ideal `N` of `R` such that N * (the matrix of
-        2*Q)^(-1) is in `R` with diagonal in `2R`.
+        generator for the smallest ideal `N` of `R` such that `N\cdot (` the matrix of
+        `2*Q` `)^{(-1)}` is in `R` with diagonal in `2R`.
 
         Over `\ZZ` this returns a non-negative number.
 
@@ -1658,9 +1658,9 @@ def level(self):
             return lvl
 
     def level_ideal(self):
-        """
-        Determines the level of the quadratic form (over `R`), which is the
-        smallest ideal `N` of `R` such that N * (the matrix of 2*Q)^(-1) is
+        r"""
+        Determine the level of the quadratic form (over `R`), which is the
+        smallest ideal `N` of `R` such that `N \cdot (` the matrix of `2Q` `)^{(-1)}` is
         in `R` with diagonal in `2R`.
         (Caveat: This always returns the principal ideal when working over a field!)
 

src/sage/quadratic_forms/quadratic_form__evaluate.pyx

@@ -2,7 +2,7 @@
 
 
 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
@@ -11,7 +11,7 @@ def QFEvaluateVector(Q, v):
 
     .. MATH::
 
-            Q' = v^t * Q * v.
+            Q' = v^t\cdot Q\cdot v.
 
     .. NOTE::
 
@@ -45,7 +45,7 @@ def QFEvaluateVector(Q, v):
 
 
 cdef QFEvaluateVector_cdef(Q, v):
-    """
+    r"""
     Routine to quickly evaluate a quadratic form `Q` on a vector `v`.  See
     the Python wrapper function :meth:`QFEvaluate` above for details.
 
@@ -72,7 +72,7 @@ def QFEvaluateMatrix(Q, M, Q2):
 
     .. MATH::
 
-            Q_2 = M^t * Q * M.
+            Q_2 = M^t\cdot Q\cdot M.
 
     .. NOTE::
 
@@ -113,7 +113,7 @@ def QFEvaluateMatrix(Q, M, Q2):
 
 
 cdef QFEvaluateMatrix_cdef(Q, M, Q2):
-    """
+    r"""
     Routine to quickly evaluate a quadratic form `Q` on a matrix `M`.  See
     the Python wrapper function :func:`QFEvaluateMatrix` above for details.
 

src/sage/quadratic_forms/quadratic_form__genus.py

@@ -59,7 +59,7 @@ def local_genus_symbol(self, p):
     This is defined (in the class
     :class:`~sage.quadratic_forms.genera.genus.Genus_Symbol_p_adic_ring`)
     to be a list of tuples (one for each Jordan component
-    `p^m*A` at `p`, where `A` is a unimodular symmetric matrix with
+    `p^m\cdot A` at `p`, where `A` is a unimodular symmetric matrix with
     coefficients the `p`-adic integers) of the following form:
 
     - If `p>2`, then return triples of the form [`m`, `n`, `d`] where
@@ -68,15 +68,15 @@ def local_genus_symbol(self, p):
 
       - `n` = rank of `A`
 
-      - `d` = det(`A`) in {1,`u`} for normalized quadratic non-residue `u`.
+      - `d` = det(`A`) in {1, `u`} for normalized quadratic non-residue `u`.
 
     - If `p=2`, then return quintuples of the form [`m`, `n`, `s`, `d`, `o`] where
 
       - `m` = valuation of the component
 
       - `n` = rank of `A`
 
-      - `d` = det(`A`) in {1,3,5,7}
+      - `d` = det(`A`) in {1, 3, 5, 7}
 
       - `s` = 0 (or 1) if `A` is even (or odd)
 

src/sage/quadratic_forms/quadratic_form__local_field_invariants.py

@@ -470,7 +470,7 @@ def hasse_invariant__OMeara(self, p):
 
     .. MATH::
 
-        c_p = \prod_{i <= j} (a_i, a_j)_p
+        c_p = \prod_{i \leq j} (a_i, a_j)_p
 
     where `(a,b)_p` is the Hilbert symbol at `p`.
 

src/sage/quadratic_forms/quadratic_form__local_representation_conditions.py

@@ -622,7 +622,7 @@ def local_representation_conditions(self, recompute_flag=False, silent_flag=Fals
     unless `p=2`).  The first element is always the prime `p` where the
     local obstruction occurs, and the next 8 (or 4) entries represent
     square-classes in the `p`-adic integers `\ZZ_p`, and are labeled by the
-    `\QQ_p` square-classes `t*(\QQ_p)^2` with `t` given as follows:
+    `\QQ_p` square-classes `t\cdot (\QQ_p)^2` with `t` given as follows:
 
     - for `p > 2`, ``[ *  1  u  p  u p  *  *  *  * ]``,
 
@@ -632,18 +632,18 @@ def local_representation_conditions(self, recompute_flag=False, silent_flag=Fals
     number needs to be in that square-class in order to be locally
     represented by `Q`.  A negative number indicates that the entire `\QQ_p`
     square-class is not represented, while a positive number `x` indicates
-    that `t*p^{(2*x)} (\ZZ_p)^2` is locally represented but `t*p^{(2*(x-1))}`
+    that `t\cdot p^{(2\cdot x)} (\ZZ_p)^2` is locally represented but `t\cdot p^{(2\cdot (x-1))}`
     `(\ZZ_p)^2` is not.
 
     As an example, the vector ``[2  3  0  0  0  0  2  0  infinity]``
     tells us that all positive integers are locally represented at `p=2`
     except those of the forms:
 
-    - `2^6 * u * r^2` with `u = 1` (mod 8)
+    - `2^6\cdot u\cdot r^2` with `u = 1` (mod 8)
 
-    - `2^5 * u * r^2` with `u = 3` (mod 8)
+    - `2^5\cdot u\cdot r^2` with `u = 3` (mod 8)
 
-    - `2 * u * r^2` with `u = 7` (mod 8)
+    - `2\cdot u\cdot r^2` with `u = 7` (mod 8)
 
     At the real numbers, the vector which looks like ``[infinity, 0, infinity, None, None, None, None, None, None]``
     means that `Q` is negative definite (i.e., the 0 tells us all

src/sage/quadratic_forms/quadratic_form__reduction_theory.py

@@ -140,9 +140,9 @@ def minkowski_reduction(self):
 
     .. MATH::
 
-            Q(v_k) \leq Q(s_1 * v_1 + ... + s_n * v_n)
+            Q(v_k) \leq Q(s_1\cdot v_1 + ... + s_n\cdot v_n)
 
-    for all `s_i` where GCD`(s_k, ... s_n) = 1`.
+    for all `s_i` where `\gcd(s_k, ... s_n) = 1`.
 
     .. NOTE::
 
@@ -270,7 +270,7 @@ def minkowski_reduction_for_4vars__SP(self):
 
     .. MATH::
 
-        Q(v_k) \leq Q(s_1 * v_1 + ... + s_n * v_n)
+        Q(v_k) \leq Q(s_1\cdot v_1 + ... + s_n\cdot v_n)
 
     for all `s_i` where GCD(`s_k, ... s_n`) = 1.
 

src/sage/quadratic_forms/quadratic_form__split_local_covering.py

@@ -364,7 +364,7 @@ def split_local_cover(self):
 
     .. MATH::
 
-        d*x^2 + T(y,z,w)
+        d\cdot x^2 + T(y,z,w)
 
     where `d > 0` is as small as possible.
 

src/sage/quadratic_forms/quadratic_form__ternary_Tornaria.py

@@ -187,7 +187,7 @@ def is_adjoint(self) -> bool:
 
 
 def reciprocal(self):
-    """
+    r"""
     This gives the reciprocal quadratic form associated to the given form.
     This is defined as the multiple of the primitive adjoint with the same
     content as the given form.
@@ -213,7 +213,7 @@ def reciprocal(self):
 
 
 def omega(self):
-    """
+    r"""
     This is the content of the adjoint of the primitive associated quadratic form.
 
     Ref: See Dickson's "Studies in Number Theory".
@@ -229,7 +229,7 @@ def omega(self):
 
 
 def delta(self):
-    """
+    r"""
     This is the omega of the adjoint form,
     which is the same as the omega of the reciprocal form.
 
@@ -243,14 +243,14 @@ def delta(self):
 
 
 def level__Tornaria(self):
-    """
+    r"""
     Return the level of the quadratic form,
     defined as
 
-    - level(B)    for even dimension,
-    - level(B)/4  for odd dimension,
+    - level(`B`)    for even dimension,
+    - level(`B`)/4  for odd dimension,
 
-    where `2Q(x) = x^t * B * x`.
+    where `2Q(x) = x^t\cdot B\cdot x`.
 
     This agrees with the usual level for even dimension...
 
@@ -269,7 +269,7 @@ def level__Tornaria(self):
 
 
 def discrec(self):
-    """
+    r"""
     Return the discriminant of the reciprocal form.
 
     EXAMPLES::