Trac #34619: fix some details in doc of charpoly_frobenius

and also pep8 standard for the code in this file

URL: https://trac.sagemath.org/34619
Reported by: chapoton
Ticket author(s): Frédéric Chapoton
Reviewer(s): David Coudert

Author: Release Manager

src/sage/categories/additive_magmas.py

@@ -730,7 +730,7 @@ def is_empty(self):
 
                 TESTS:
 
-                We check that the method `is_empty` is inherited from this
+                We check that the method ``is_empty`` is inherited from this
                 category in both examples above::
 
                     sage: A.is_empty.__module__

src/sage/categories/category.py

@@ -2236,7 +2236,7 @@ def _sort(categories):
 
         .. NOTE::
 
-            The auxiliary function `_flatten_categories` used in the test
+            The auxiliary function ``_flatten_categories`` used in the test
             below expects a second argument, which is a type such that
             instances of that type will be replaced by its super
             categories. Usually, this type is :class:`JoinCategory`.

src/sage/categories/coxeter_groups.py

@@ -668,7 +668,7 @@ def _test_reduced_word(self, **options):
 
         def simple_projection(self, i, side='right', length_increasing=True):
             r"""
-            Return the simple projection `\pi_i` (or `\overline\pi_i` if `length_increasing` is ``False``).
+            Return the simple projection `\pi_i` (or `\overline\pi_i` if ``length_increasing`` is ``False``).
 
             INPUT:
 

src/sage/categories/crystals.py

@@ -1563,7 +1563,9 @@ def to_highest_weight(self, index_set=None):
             r"""
             Return the highest weight element `u` and a list `[i_1,...,i_k]`
             such that `self = f_{i_1} ... f_{i_k} u`, where `i_1,...,i_k` are
-            elements in `index_set`. By default the index set is assumed to be
+            elements in ``index_set``.
+
+            By default the index set is assumed to be
             the full index set of self.
 
             EXAMPLES::
@@ -1602,8 +1604,10 @@ def to_lowest_weight(self, index_set=None):
             r"""
             Return the lowest weight element `u` and a list `[i_1,...,i_k]`
             such that `self = e_{i_1} ... e_{i_k} u`, where `i_1,...,i_k` are
-            elements in `index_set`. By default the index set is assumed to be
-            the full index set of self.
+            elements in ``index_set``.
+
+            By default the index set is assumed to be the full index
+            set of self.
 
             EXAMPLES::
 
@@ -1642,7 +1646,7 @@ def to_lowest_weight(self, index_set=None):
         def all_paths_to_highest_weight(self, index_set=None):
             r"""
             Iterate over all paths to the highest weight from ``self``
-            with respect to `index_set`.
+            with respect to ``index_set``.
 
             INPUT:
 

src/sage/coding/cyclic_code.py

@@ -47,6 +47,7 @@
 from sage.misc.cachefunc import cached_method
 from sage.rings.all import Zmod
 
+
 def find_generator_polynomial(code, check=True):
     r"""
     Returns a possible generator polynomial for ``code``.
@@ -334,7 +335,7 @@ def __init__(self, generator_pol=None, length=None, code=None, check=True,
             ...
             ValueError: The code is not cyclic.
 
-        If the `primitive_root` does not lie in an extension of `field`,
+        If the ``primitive_root`` does not lie in an extension of ``field``,
         or is not a primitive `n`-th root of unity, then
         an exception is raised::
 
@@ -1321,7 +1322,7 @@ def decoding_radius(self):
         return self._bch_decoder.decoding_radius()
 
 
-####################### registration ###############################
+# ###################### registration ##############################
 
 CyclicCode._registered_encoders["Polynomial"] = CyclicCodePolynomialEncoder
 CyclicCode._registered_encoders["Vector"] = CyclicCodeVectorEncoder

src/sage/crypto/block_cipher/present.py

@@ -838,7 +838,7 @@ def __getitem__(self, r):
         Computes the sub key for round ``r`` derived from initial master key.
 
         The key schedule object has to have been initialised with the
-        `master_key` argument.
+        ``master_key`` argument.
 
         INPUT:
 
@@ -860,7 +860,7 @@ def __getitem__(self, r):
     def __iter__(self):
         """
         Iterate over the ``self._rounds + 1`` PRESENT round keys, derived from
-        `master_key`
+        ``master_key``.
 
         EXAMPLES::
 

src/sage/dynamics/finite_dynamical_system_catalog.py

@@ -5,7 +5,7 @@
 dynamical systems.
 These are accessible through
 :mod:`sage.dynamics.finite_dynamical_system_catalog. <sage.dynamics.finite_dynamical_system_catalog>`
-or just through `finite_dynamical_systems.`
+or just through ``finite_dynamical_systems.``
 (type either of these in Sage and hit ``tab`` for a list).
 
 AUTHORS:

src/sage/graphs/weakly_chordal.pyx

@@ -53,7 +53,7 @@ cdef inline is_long_hole_free_process(g, short_digraph sd, bitset_t dense_graph,
                                       bint certificate,
                                       int a, int b, int c, int n):
     """
-    This method is part of method `is_long_hole_free`.
+    This method is part of method ``is_long_hole_free``.
 
     EXAMPLES::
 
@@ -285,7 +285,7 @@ cdef inline is_long_antihole_free_process(g, short_digraph sd, bitset_t dense_gr
                                           bint certificate,
                                           int a, int b, int c, int n):
     """
-    This method is part of method `is_long_antihole_free`.
+    This method is part of method ``is_long_antihole_free``.
 
     EXAMPLES::
 

src/sage/matrix/matrix_misc.py

@@ -39,10 +39,10 @@ def prm_mul(p1, p2, mask_free, prec):
 
     - `p1,p2` -- polynomials as dictionaries
 
-    - `mask_free` -- an integer mask that give the list of free variables
+    - ``mask_free`` -- an integer mask that give the list of free variables
       (the `i`-th variable is free if the `i`-th bit of ``mask_free`` is `1`)
 
-    - `prec` -- if `prec` is not None, truncate the product at precision `prec`
+    - ``prec`` -- if ``prec`` is not ``None``, truncate the product at precision ``prec``
 
     EXAMPLES::
 

src/sage/schemes/cyclic_covers/charpoly_frobenius.py

@@ -1,16 +1,11 @@
 r"""
-
 Computation of the Frobenius polynomial using Newton's identities
-
 """
-
-
 # *****************************************************************************
 #  Copyright (C) 2018 Edgar Costa <[email protected]>
 #  Distributed under the terms of the GNU General Public License (GPL)
 #                  https://www.gnu.org/licenses/
 # *****************************************************************************
-
 from sage.rings.integer_ring import ZZ
 from sage.functions.log import log
 
@@ -23,15 +18,15 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
 
     - ``frob_matrix`` -- a matrix representing the Frobenius matrix up to some precision
 
-    - ``charpoly_prec`` -- a vector ai, such that, `frob_matrix.change_ring(ZZ).charpoly()[i]`
-        will be correct mod `p^ai`, this can be easily deduced from the Hodge numbers and
-        knowing the q-adic precision of ``frob_matrix``
+    - ``charpoly_prec`` -- a vector ai, such that, ``frob_matrix.change_ring(ZZ).charpoly()[i]``
+      will be correct mod `p^ai`, this can be easily deduced from the
+      Hodge numbers and knowing the q-adic precision of ``frob_matrix``
 
     - ``p`` -- prime `p`
 
     - ``weight`` -- weight of the motive
 
-    - ``a`` -- `q = q^a`
+    - ``a`` -- `p = q^a`
 
     - ``known_factor`` -- the list of coefficients of the known factor
 
@@ -195,14 +190,12 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
         sage: F+= F.base_ring()(0).add_bigoh(6)*ones_matrix(*F.dimensions())
         sage: charpoly_frobenius(F, [6, 5, 4, 4], 17, 2)
         [-4913, -221, 13, 1]
-
-
     """
     assert known_factor[-1] == 1
     try:
         cp = frob_matrix.change_ring(ZZ).charpoly().list()
     except ValueError:
-        # the given matrix wasn't integral
+        # the given matrix was not integral
         cp = frob_matrix.charpoly().change_ring(ZZ).list()
     assert len(charpoly_prec) == len(cp) - (len(known_factor) - 1)
     assert cp[-1] == 1
@@ -216,7 +209,7 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
 
     # figure out the sign
     # i.e., if it is a reciprocal or an antireciprocal polynomial
-    if weight % 2 == 1:
+    if weight % 2:
         # for odd weight the sign is always 1
         # it's the charpoly of a USp matrix
         # and charpoly of a symplectic matrix is reciprocal
@@ -227,7 +220,7 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
             raise NotImplementedError()
         # we compare ith coefficient and  (degree - i)th coefficient to deduce the sign
         # note, if degree is even, the middle coefficient will not help us determine the sign
-        for i in range((degree + 1)//2):
+        for i in range((degree + 1) // 2):
             # Note: degree*weight is even
             p_power = p**min(
                 charpoly_prec[i],
@@ -248,19 +241,21 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
     # note, this includes the middle coefficient if degree is even
     halfdegree = degree // 2 + 1
 
-    cp[0] = sign * p**((a * degree * weight) // 2) # Note: degree*weight is even
+    cp[0] = sign * p**((a * degree * weight) // 2)
+    # Note: degree*weight is even
+
     # calculate the i-th power sum of the roots and correct cp along the way
     e = cp[-halfdegree:]
     e.reverse()
     for k in range(halfdegree):
-        if k % 2 != 0:
+        if k % 2:
             e[k] = -e[k] % mod[degree - k]
         # e[k] = cp[degree - k] if (k%2 ==0) else -cp[degree - k]
         if k > 0:
             # verify if p^charpoly_prec[degree - k] > 2*degree/k * q^(w*k/2)
             assert (
-                log(k) / log(p) + charpoly_prec[degree - k]
-                > log(2 * degree) / log(p) + a * 0.5 * weight * k
+                log(k, p) + charpoly_prec[degree - k]
+                > log(2 * degree, p) + a * 0.5 * weight * k
             ), (
                 "log(k)/log(p) + charpoly_prec[degree - k] <= log(2*degree)/log(p) + a*0.5*weight*k, k = %d"
                 % k
@@ -271,7 +266,7 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
     if len(fix_e) < halfdegree:
         fix_e.extend([0] * (halfdegree - len(fix_e)))
     for i in range(halfdegree):
-        if i % 2 != 0:
+        if i % 2:
             fix_e[i] *= -1
 
     # e[k] = \sum x_{i_1} x_{i_2} ... x_{i_k} # where x_* are eigenvalues
@@ -280,7 +275,9 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
     # s[k] = \sum x_i ^k for k>0
     s = [None] * (halfdegree)
     res = [None] * len(charpoly_prec)
-    res[0] = sign * p**((a * degree * weight) // 2) # Note: degree*weight is even
+    res[0] = sign * p**((a * degree * weight) // 2)
+    # Note: degree*weight is even
+
     res[-1] = 1
     e[1] -= fix_e[1]
     e[1] = e[1] % mod[degree - 1]
@@ -306,8 +303,9 @@ def charpoly_frobenius(frob_matrix, charpoly_prec, p, weight, a=1, known_factor=
         # (-1)^(k-1) s[k] - S = k*e[k]
         e[k] = (-S + (-1)**(k - 1) * s[k]) // k
         assert (-S + (-1)**(k - 1) * s[k]) % k == 0
-        res[degree - k] = e[k] if k % 2 == 0 else -e[k]
+        res[degree - k] = e[k] if not k % 2 else -e[k]
         # Note: degree*weight is even
+
         res[k] = sign * res[degree - k] * p**((a * (degree - 2 * k) * weight) // 2)
         # fix e[k + 1]
         if k + 1 < halfdegree: