full pep8 for modular/hecke

Author: fchapoton

src/sage/modular/hecke/algebra.py

@@ -43,7 +43,7 @@
 
 def is_HeckeAlgebra(x):
     r"""
-    Return True if x is of type HeckeAlgebra.
+    Return ``True`` if x is of type HeckeAlgebra.
 
     EXAMPLES::
 
@@ -210,7 +210,7 @@ def __call__(self, x, check=True):
         In the last case, the parameter ``check`` controls whether or
         not to check that this element really does lie in the
         appropriate algebra. At present, setting ``check=True`` raises
-        a NotImplementedError unless x is a scalar (or a diagonal
+        a :class:`NotImplementedError` unless x is a scalar (or a diagonal
         matrix).
 
         EXAMPLES::
@@ -320,7 +320,7 @@ def ngens(self):
 
     def is_noetherian(self):
         """
-        Return True if this Hecke algebra is Noetherian as a ring. This is true
+        Return ``True`` if this Hecke algebra is Noetherian as a ring. This is true
         if and only if the base ring is Noetherian.
 
         EXAMPLES::
@@ -649,7 +649,6 @@ def __richcmp__(self, other, op):
             False
             sage: A == A
             True
-
         """
         if not isinstance(other, HeckeAlgebra_anemic):
             return NotImplemented
@@ -675,9 +674,9 @@ def hecke_operator(self, n):
             raise IndexError("Hecke operator T_%s not defined in the anemic Hecke algebra" % n)
         return self.module()._hecke_operator_class()(self, n)
 
-    def is_anemic(self):
+    def is_anemic(self) -> bool:
         """
-        Return True, since this is the anemic Hecke algebra.
+        Return ``True``, since this is the anemic Hecke algebra.
 
         EXAMPLES::
 

src/sage/modular/hecke/ambient_module.py

@@ -388,12 +388,12 @@ def degeneracy_map(self, codomain, t=1):
             err = True
         if err:
             raise ValueError(("the level of self (=%s) must be a divisor or multiple of "
-                "level (=%s) and t (=%s) must be a divisor of the quotient") % (self.level(), level, t))
+                              "level (=%s) and t (=%s) must be a divisor of the quotient") % (self.level(), level, t))
 
         eps = self.character()
         if not (eps is None) and level % eps.conductor() != 0:
             raise ArithmeticError("the conductor of the character of this space "
-                "(=%s) must be divisible by the level (=%s)" % (eps.conductor(), level))
+                                  "(=%s) must be divisible by the level (=%s)" % (eps.conductor(), level))
 
         if M is None:
             M = self.hecke_module_of_level(level)

src/sage/modular/hecke/degenmap.py

@@ -2,7 +2,7 @@
 Degeneracy maps
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Sage: Open Source Mathematical Software
 #
 #       Copyright (C) 2005 William Stein <[email protected]>
@@ -16,12 +16,11 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
-
-
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 from . import morphism
 
+
 class DegeneracyMap(morphism.HeckeModuleMorphism_matrix):
     """
     A degeneracy map between Hecke modules of different levels.
@@ -93,8 +92,8 @@ def __init__(self, matrix, domain, codomain, t):
         if t == 1:
             pow = ""
         else:
-            pow = "^%s"%t
-        name = "degeneracy map corresponding to f(q) |--> f(q%s)"%(pow)
+            pow = "^%s" % t
+        name = "degeneracy map corresponding to f(q) |--> f(q%s)" % (pow)
         morphism.HeckeModuleMorphism_matrix.__init__(self, H, matrix, name)
 
     def t(self):

src/sage/modular/hecke/element.py

@@ -6,7 +6,7 @@
 - William Stein
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Sage: Open Source Mathematical Software
 #
 #       Copyright (C) 2005 William Stein <[email protected]>
@@ -20,15 +20,16 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.structure.richcmp import richcmp, op_NE
 from sage.structure.element import ModuleElement
 
+
 def is_HeckeModuleElement(x):
     """
-    Return True if x is a Hecke module element, i.e., of type HeckeModuleElement.
+    Return ``True`` if x is a Hecke module element, i.e., of type HeckeModuleElement.
 
     EXAMPLES::
 
@@ -39,6 +40,7 @@ def is_HeckeModuleElement(x):
     """
     return isinstance(x, HeckeModuleElement)
 
+
 class HeckeModuleElement(ModuleElement):
     """
     Element of a Hecke module.
@@ -180,7 +182,7 @@ def _lmul_(self, x):
             sage: BrandtModule(37)([0,1,-1])._lmul_(3)
             (0, 3, -3)
         """
-        return self.parent()(self.element()*x)
+        return self.parent()(self.element() * x)
 
     def _rmul_(self, x):
         """
@@ -218,9 +220,9 @@ def _sub_(self, right):
         """
         return self.parent()(self.element() - right.element())
 
-    def is_cuspidal(self):
+    def is_cuspidal(self) -> bool:
         r"""
-        Return True if this element is cuspidal.
+        Return ``True`` if this element is cuspidal.
 
         EXAMPLES::
 
@@ -247,14 +249,14 @@ def is_cuspidal(self):
             sage: N = next(S for S in M.decomposition(anemic=False) if S.hecke_matrix(3).trace()==-128844)
             sage: [g.is_cuspidal() for g in N.gens()]
             [True, True]
-
         """
-        return (self in self.parent().ambient().cuspidal_submodule())
+        return self in self.parent().ambient().cuspidal_submodule()
 
-    def is_eisenstein(self):
+    def is_eisenstein(self) -> bool:
         r"""
-        Return True if this element is Eisenstein. This makes sense for both
-        modular forms and modular symbols.
+        Return ``True`` if this element is Eisenstein.
+
+        This makes sense for both modular forms and modular symbols.
 
         EXAMPLES::
 
@@ -269,12 +271,13 @@ def is_eisenstein(self):
             sage: EllipticCurve('37a1').newform().element().is_eisenstein()
             False
         """
-        return (self in self.parent().ambient().eisenstein_submodule())
+        return self in self.parent().ambient().eisenstein_submodule()
 
-    def is_new(self, p=None):
+    def is_new(self, p=None) -> bool:
         r"""
-        Return True if this element is p-new. If p is None, return True if the
-        element is new.
+        Return ``True`` if this element is p-new.
+
+        If p is ``None``, return ``True`` if the element is new.
 
         EXAMPLES::
 
@@ -285,12 +288,13 @@ def is_new(self, p=None):
             sage: CuspForms(22, 2).0.is_new()
             False
         """
-        return (self in self.parent().new_submodule(p))
+        return self in self.parent().new_submodule(p)
 
-    def is_old(self, p=None):
+    def is_old(self, p=None) -> bool:
         r"""
-        Return True if this element is p-old. If p is None, return True if the
-        element is old.
+        Return ``True`` if this element is p-old.
+
+        If p is ``None``, return ``True`` if the element is old.
 
         EXAMPLES::
 
@@ -305,4 +309,4 @@ def is_old(self, p=None):
             sage: EisensteinForms(144, 2).1.is_old(2) # not implemented
             False
         """
-        return (self in self.parent().old_submodule(p))
+        return self in self.parent().old_submodule(p)

src/sage/modular/hecke/hecke_operator.py

@@ -27,7 +27,7 @@
 
 def is_HeckeOperator(x):
     r"""
-    Return True if x is of type HeckeOperator.
+    Return ``True`` if x is of type HeckeOperator.
 
     EXAMPLES::
 
@@ -40,9 +40,10 @@ def is_HeckeOperator(x):
     """
     return isinstance(x, HeckeOperator)
 
+
 def is_HeckeAlgebraElement(x):
     r"""
-    Return True if x is of type HeckeAlgebraElement.
+    Return ``True`` if x is of type HeckeAlgebraElement.
 
     EXAMPLES::
 
@@ -55,6 +56,7 @@ def is_HeckeAlgebraElement(x):
     """
     return isinstance(x, HeckeAlgebraElement)
 
+
 class HeckeAlgebraElement(AlgebraElement):
     r"""
     Base class for elements of Hecke algebras.
@@ -70,7 +72,7 @@ def __init__(self, parent):
             Generic element of a structure
         """
         if not algebra.is_HeckeAlgebra(parent):
-            raise TypeError("parent (=%s) must be a Hecke algebra"%parent)
+            raise TypeError("parent (=%s) must be a Hecke algebra" % parent)
         AlgebraElement.__init__(self, parent)
 
     def domain(self):
@@ -138,7 +140,7 @@ def hecke_module_morphism(self):
             M = self.domain()
             H = End(M)
             if isinstance(self, HeckeOperator):
-                name = "T_%s"%self.index()
+                name = "T_%s" % self.index()
             else:
                 name = ""
             self.__hecke_module_morphism = morphism.HeckeModuleMorphism_matrix(H, T, name)
@@ -244,7 +246,7 @@ def apply_sparse(self, x):
             24*(1,0) - 5*(1,9)
         """
         if x not in self.domain():
-            raise TypeError("x (=%s) must be in %s"%(x, self.domain()))
+            raise TypeError("x (=%s) must be in %s" % (x, self.domain()))
         # Generic implementation which doesn't actually do anything
         # special regarding sparseness.  Override this for speed.
         T = self.hecke_module_morphism()
@@ -300,7 +302,7 @@ def decomposition(self):
         except AttributeError:
             pass
         if isinstance(self, HeckeOperator) and \
-               arith.gcd(self.index(), self.domain().level()) == 1:
+           arith.gcd(self.index(), self.domain().level()) == 1:
             D = self.hecke_module_morphism().decomposition(is_diagonalizable=True)
         else:
             # TODO: There are other weaker hypotheses that imply diagonalizability.
@@ -463,7 +465,7 @@ def _richcmp_(self, other, op):
             if isinstance(other, HeckeOperator):
                 return richcmp(self, other.matrix_form(), op)
             else:
-                raise RuntimeError("Bug in coercion code") # can't get here
+                raise RuntimeError("Bug in coercion code")  # can't get here
 
         return richcmp(self.__matrix, other.__matrix, op)
 
@@ -636,7 +638,7 @@ def _richcmp_(self, other, op):
             if isinstance(other, HeckeAlgebraElement_matrix):
                 return richcmp(self.matrix_form(), other, op)
             else:
-                raise RuntimeError("Bug in coercion code") # can't get here
+                raise RuntimeError("Bug in coercion code")  # can't get here
 
         if self.__n == other.__n:
             return rich_to_bool(op, 0)
@@ -651,7 +653,7 @@ def _repr_(self):
             sage: ModularSymbols(Gamma0(7), 4).hecke_operator(6)._repr_()
             'Hecke operator T_6 on Modular Symbols space of dimension 4 for Gamma_0(7) of weight 4 with sign 0 over Rational Field'
         """
-        return "Hecke operator T_%s on %s"%(self.__n, self.domain())
+        return "Hecke operator T_%s on %s" % (self.__n, self.domain())
 
     def _latex_(self):
         r"""
@@ -662,15 +664,17 @@ def _latex_(self):
             sage: ModularSymbols(Gamma0(7), 4).hecke_operator(6)._latex_()
             'T_{6}'
         """
-        return "T_{%s}"%self.__n
+        return "T_{%s}" % self.__n
 
     def _mul_(self, other):
-        """
-        Multiply this Hecke operator by another element of the same algebra. If
-        the other element is of the form `T_m` for some m, we check whether the
-        product is equal to `T_{mn}` and return that; if the product is not
-        (easily seen to be) of the form `T_{mn}`, then we calculate the product
-        of the two matrices and return a Hecke algebra element defined by that.
+        r"""
+        Multiply this Hecke operator by another element of the same algebra.
+
+        If the other element is of the form `T_m` for some m, we check
+        whether the product is equal to `T_{mn}` and return that; if
+        the product is not (easily seen to be) of the form `T_{mn}`,
+        then we calculate the product of the two matrices and return a
+        Hecke algebra element defined by that.
 
         EXAMPLES: We create the space of modular symbols of level
         `11` and weight `2`, then compute `T_2`

src/sage/modular/hecke/homspace.py

@@ -1,7 +1,7 @@
 r"""
 Hom spaces between Hecke modules
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2005 William Stein <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -13,9 +13,8 @@
 #  See the GNU General Public License for more details; the full text
 #  is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
-
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 from sage.matrix.constructor import matrix
 from sage.matrix.matrix_space import MatrixSpace
 from sage.categories.homset import HomsetWithBase
@@ -25,7 +24,7 @@
 
 def is_HeckeModuleHomspace(x):
     r"""
-    Return True if x is a space of homomorphisms in the category of Hecke modules.
+    Return ``True`` if x is a space of homomorphisms in the category of Hecke modules.
 
     EXAMPLES::