Trac #34320: fix E251 in schemes

about
{{{
E251 unexpected spaces around keyword / parameter equals
}}}

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

Author: Release Manager

src/sage/schemes/berkovich/berkovich_space.py

@@ -647,11 +647,11 @@ def __init__(self, base, ideal=None):
             ideal = None
             self._base_type = 'padic field'
         if base.dimension_relative() != 1:
-            raise ValueError("base of projective Berkovich space must be " + \
+            raise ValueError("base of projective Berkovich space must be "
                 "projective space of dimension 1 over Qp or a number field")
         self._p = prime
         self._ideal = ideal
-        Parent.__init__(self, base = base, category=TopologicalSpaces())
+        Parent.__init__(self, base=base, category=TopologicalSpaces())
 
     def base_ring(self):
         r"""

src/sage/schemes/curves/affine_curve.py

@@ -395,7 +395,7 @@ def local_coordinates(self, pt, n):
         y0 = F(pt[1])
         astr = ["a"+str(i) for i in range(1,2*n)]
         x,y = R.gens()
-        R0 = PolynomialRing(F,2*n+2,names = [str(x),str(y),"t"]+astr)
+        R0 = PolynomialRing(F, 2 * n + 2, names=[str(x), str(y), "t"] + astr)
         vars0 = R0.gens()
         t = vars0[2]
         yt = y0*t**0+add([vars0[i]*t**(i-2) for i in range(3,2*n+2)])
@@ -1932,15 +1932,13 @@ def rational_points(self, algorithm="enum"):
             return sorted(set(pnts))
 
         elif algorithm == "all":
-
-            S_enum = self.rational_points(algorithm = "enum")
-            S_bn = self.rational_points(algorithm = "bn")
+            S_enum = self.rational_points(algorithm="enum")
+            S_bn = self.rational_points(algorithm="bn")
             if S_enum != S_bn:
                 raise RuntimeError("Bug in rational_points -- different algorithms give different answers for curve %s!" % self)
             return S_enum
-
         else:
-            raise ValueError("No algorithm '%s' known"%algorithm)
+            raise ValueError("No algorithm '%s' known" % algorithm)
 
 
 class IntegralAffineCurve(AffineCurve_field):

src/sage/schemes/curves/projective_curve.py

@@ -703,7 +703,7 @@ def local_coordinates(self, pt, n):
         y0 = F(pt[1])
         astr = ["a"+str(i) for i in range(1,2*n)]
         x,y = R.gens()
-        R0 = PolynomialRing(F,2*n+2,names = [str(x),str(y),"t"]+astr)
+        R0 = PolynomialRing(F, 2 * n + 2, names=[str(x), str(y), "t"] + astr)
         vars0 = R0.gens()
         t = vars0[2]
         yt = y0*t**0 + add([vars0[i]*t**(i-2) for i in range(3,2*n+2)])
@@ -2147,8 +2147,8 @@ def rational_points(self, algorithm="enum", sort=True):
         if algorithm == "bn":
             return self._points_via_singular(sort=sort)
         elif algorithm == "all":
-            S_enum = self.rational_points(algorithm = "enum")
-            S_bn = self.rational_points(algorithm = "bn")
+            S_enum = self.rational_points(algorithm="enum")
+            S_bn = self.rational_points(algorithm="bn")
             if S_enum != S_bn:
                 raise RuntimeError("Bug in rational_points -- different\
                                      algorithms give different answers for\

src/sage/schemes/elliptic_curves/descent_two_isogeny.pyx

@@ -1045,10 +1045,10 @@ cdef int count(mpz_t c_mpz, mpz_t d_mpz, mpz_t *p_list, unsigned long p_list_len
     return 0
 
 def two_descent_by_two_isogeny(E,
-                int global_limit_small = 10,
-                int global_limit_large = 10000,
-                int verbosity = 0,
-                bint selmer_only = 0, bint proof = 1):
+                int global_limit_small=10,
+                int global_limit_large=10000,
+                int verbosity=0,
+                bint selmer_only=0, bint proof=1):
     """
     Given an elliptic curve E with a two-isogeny phi : E --> E' and dual isogeny
     phi', runs a two-isogeny descent on E, returning n1, n2, n1' and n2'. Here
@@ -1148,9 +1148,10 @@ def two_descent_by_two_isogeny(E,
     return two_descent_by_two_isogeny_work(c, d,
         global_limit_small, global_limit_large, verbosity, selmer_only, proof)
 
+
 def two_descent_by_two_isogeny_work(Integer c, Integer d,
-                int global_limit_small = 10, int global_limit_large = 10000,
-                int verbosity = 0, bint selmer_only = 0, bint proof = 1):
+                int global_limit_small=10, int global_limit_large=10000,
+                int verbosity=0, bint selmer_only=0, bint proof=1):
     """
     Do all the work in doing a two-isogeny descent.
 

src/sage/schemes/elliptic_curves/ell_rational_field.py

@@ -1095,7 +1095,7 @@ def _modular_symbol_normalize(self, sign, normalize, implementation, nap):
             raise ValueError("Implementation should be one of 'sage', 'num' or 'eclib'")
         return (sign, normalize, implementation, nap)
 
-    @cached_method(key = _modular_symbol_normalize)
+    @cached_method(key=_modular_symbol_normalize)
     def modular_symbol(self, sign=+1, normalize=None, implementation='eclib', nap=0):
         r"""
         Return the modular symbol map associated to this elliptic curve
@@ -1964,7 +1964,7 @@ def three_selmer_rank(self, algorithm='UseSUnits'):
         """
         from sage.interfaces.magma import magma
         E = magma(self)
-        return Integer(E.ThreeSelmerGroup(MethodForFinalStep = magma('"%s"'%algorithm)).Ngens())
+        return Integer(E.ThreeSelmerGroup(MethodForFinalStep=magma('"%s"' % algorithm)).Ngens())
 
     def rank(self, use_database=True, verbose=False,
              only_use_mwrank=True,
@@ -2301,8 +2301,8 @@ def _compute_gens(self, proof,
         if not only_use_mwrank:
             try:
                 verbose_verbose("Trying to compute rank.")
-                r = self.rank(only_use_mwrank = False)
-                verbose_verbose("Got r = %s."%r)
+                r = self.rank(only_use_mwrank=False)
+                verbose_verbose("Got r = %s." % r)
                 if r == 0:
                     verbose_verbose("Rank = 0, so done.")
                     return [], True
@@ -2438,7 +2438,7 @@ def ngens(self, proof=None):
             Generator 1 is [29604565304828237474403861024284371796799791624792913256602210:-256256267988926809388776834045513089648669153204356603464786949:490078023219787588959802933995928925096061616470779979261000]; height 95.98037...
             Regulator = 95.980...
         """
-        return len(self.gens(proof = proof))
+        return len(self.gens(proof=proof))
 
     def regulator(self, proof=None, precision=53, **kwds):
         r"""
@@ -2646,7 +2646,7 @@ def saturation(self, points, verbose=False, max_prime=-1, min_prime=2):
         from sage.libs.eclib.all import mwrank_MordellWeil
         mw = mwrank_MordellWeil(c, verbose)
         mw.process(v) # by default, this does no saturation yet
-        ok, index, unsat = mw.saturate(max_prime=max_prime, min_prime = min_prime)
+        ok, index, unsat = mw.saturate(max_prime=max_prime, min_prime=min_prime)
         if not ok:
             print("Failed to saturate failed at the primes {}".format(unsat))
         sat = [Emin(P) for P in mw.points()]
@@ -6630,7 +6630,7 @@ def S_integral_x_coords_with_abs_bounded_by(abs_bound):
         M = U.transpose()*M*U
 
         # NB "lambda" is a reserved word in Python!
-        lamda = min(M.charpoly(algorithm="hessenberg").roots(multiplicities = False))
+        lamda = min(M.charpoly(algorithm="hessenberg").roots(multiplicities=False))
         max_S = max(S)
         len_S += 1 #Counting infinity (always "included" in S)
         if verbose:

src/sage/schemes/elliptic_curves/heegner.py

@@ -3520,7 +3520,7 @@ def point_exact(self, prec=53, algorithm='lll', var='a', optimize=False):
             M = K.extension(gg, names='b')
             y = M.gen()/dd
             x = M(x)
-            L = M.absolute_field(names = var)
+            L = M.absolute_field(names=var)
             phi = L.structure()[1]
             x = phi(x)
             y = phi(y)
@@ -4364,13 +4364,9 @@ def mod(self, p, prec=53):
 
         # do actual calculation
         if self.conductor() == 1:
-
-            P = self._trace_exact_conductor_1(prec = prec)
+            P = self._trace_exact_conductor_1(prec=prec)
             return E.change_ring(GF(p))(P)
-
-        else:
-
-            raise NotImplementedError
+        raise NotImplementedError
 
 ##     def congruent_rational_point(self, n, prec=53):
 ##         r"""

src/sage/schemes/elliptic_curves/height.py

@@ -1216,7 +1216,7 @@ def S(self, xi1, xi2, v):
             ([0.0781194447253472, 0.0823423732016403] U [0.917657626798360, 0.921880555274653])
         """
         L = self.E.period_lattice(v)
-        w1, w2 = L.basis(prec = v.codomain().prec())
+        w1, w2 = L.basis(prec=v.codomain().prec())
         beta = L.elliptic_exponential(w1/2)[0]
         if xi2 < beta:
             return UnionOfIntervals([])

src/sage/schemes/elliptic_curves/isogeny_class.py

@@ -403,7 +403,7 @@ def graph(self):
         from sage.graphs.graph import Graph
 
         if not self.E.base_field() is QQ:
-            M = self.matrix(fill = False)
+            M = self.matrix(fill=False)
             n = len(self)
             G = Graph(M, format='weighted_adjacency_matrix')
             D = dict([(v,self.curves[v]) for v in G.vertices(sort=False)])
@@ -416,11 +416,10 @@ def graph(self):
             G.relabel(list(range(1, n + 1)))
             return G
 
-
-        M = self.matrix(fill = False)
+        M = self.matrix(fill=False)
         n = M.nrows() # = M.ncols()
         G = Graph(M, format='weighted_adjacency_matrix')
-        N = self.matrix(fill = True)
+        N = self.matrix(fill=True)
         D = dict([(v,self.curves[v]) for v in G.vertices(sort=False)])
         # The maximum degree classifies the shape of the isogeny
         # graph, though the number of vertices is often enough.
@@ -535,7 +534,8 @@ def reorder(self, order):
             return self
         if isinstance(order, str):
             if order == "lmfdb":
-                reordered_curves = sorted(self.curves, key = lambda E: E.a_invariants())
+                reordered_curves = sorted(self.curves,
+                                          key=lambda E: E.a_invariants())
             else:
                 reordered_curves = list(self.E.isogeny_class(algorithm=order))
         elif isinstance(order, (list, tuple, IsogenyClass_EC)):
@@ -1068,7 +1068,8 @@ def _compute(self):
                 raise RuntimeError("unable to find %s in the database" % self.E)
             # All curves will have the same conductor and isogeny class,
             # and there are most 8 of them, so lexicographic sorting is okay.
-            self.curves = tuple(sorted(curves, key = lambda E: E.cremona_label()))
+            self.curves = tuple(sorted(curves,
+                                       key=lambda E: E.cremona_label()))
             self._mat = None
         elif algorithm == "sage":
             curves = [self.E.minimal_model()]

src/sage/schemes/elliptic_curves/mod_sym_num.pyx

@@ -970,7 +970,7 @@ cdef class ModularSymbolNumerical:
         ans = self._evaluate_approx(ra, eps)
 
         if prec > self._om1.parent().prec():
-            L = self._E.period_lattice().basis(prec = prec)
+            L = self._E.period_lattice().basis(prec=prec)
             self._om1 = L[0]
             self._om2 = L[1].imag()
             cinf = self._E.real_components()
@@ -2156,10 +2156,8 @@ cdef class ModularSymbolNumerical:
             ans = su
         return CC(ans)
 
-
-
     def _from_r_to_rr_approx(self, Rational r, Rational rr, double eps,
-                             method = None, int use_partials=2):
+                             method=None, int use_partials=2):
         r"""
         Given a cusp `r` this computes the integral `\lambda(r\to r')`
         from `r` to `r'` to the given precision ``eps``.
@@ -2313,7 +2311,7 @@ cdef class ModularSymbolNumerical:
 
         if method == "indirect" or method == "both":
             verbose("  using the indirect integration from %s to %s "
-                    "with %s terms to sum"%(r, rr, T1+T2), level =2)
+                    "with %s terms to sum"%(r, rr, T1+T2), level=2)
             #self.nc_indirect += 1
             ans2 = ( self._from_ioo_to_r_approx(r, eps/2,
                                                 use_partials=use_partials)
@@ -2474,7 +2472,7 @@ cdef class ModularSymbolNumerical:
 
     # (key=lambda r,sign,use_partials:(r,sign)) lead to a compiler crash
     @cached_method
-    def _value_ioo_to_r(self, Rational r, int sign = 0,
+    def _value_ioo_to_r(self, Rational r, int sign=0,
                         int use_partials=2):
         r"""
         Return `[r]^+` or `[r]^-` for a rational `r`.
@@ -2532,7 +2530,7 @@ cdef class ModularSymbolNumerical:
         return self._round(lap, sign, True)
 
     @cached_method
-    def _value_r_to_rr(self, Rational r, Rational rr, int sign = 0,
+    def _value_r_to_rr(self, Rational r, Rational rr, int sign=0,
                        int use_partials=2):
         r"""
         Return the rational number `[r']^+ - [r]^+`. However the
@@ -2603,7 +2601,7 @@ cdef class ModularSymbolNumerical:
         return self._round(lap, sign, True)
 
     @cached_method
-    def transportable_symbol(self, Rational r, Rational rr, int sign = 0):
+    def transportable_symbol(self, Rational r, Rational rr, int sign=0):
         r"""
         Return the symbol `[r']^+ - [r]^+` where `r'=\gamma(r)` for some
         `\gamma\in\Gamma_0(N)`. These symbols can be computed by transporting
@@ -2860,8 +2858,7 @@ cdef class ModularSymbolNumerical:
                     res -= self._value_ioo_to_r(rr,sign, use_partials=2)
                 return res
 
-
-    def manin_symbol(self, llong u, llong v, int sign = 0):
+    def manin_symbol(self, llong u, llong v, int sign=0):
         r"""
         Given a pair `(u,v)` presenting a point in
         `\mathbb{P}^1(\mathbb{Z}/N\mathbb{Z})` and hence a coset of
@@ -3755,7 +3752,7 @@ def _test_against_table(range_of_conductors, other_implementation="sage", list_o
             Mr = M(r)
             M2r = M(r, sign=-1)
             if verb:
-                print("r={} : ({},{}),({}, {})".format(r,mr,m2r,Mr,M2r), end= "  ", flush=True)
+                print("r={} : ({},{}),({}, {})".format(r,mr,m2r,Mr,M2r), end="  ", flush=True)
             if mr != Mr or m2r != M2r:
                 print (("B u g : curve = {}, cusp = {}, sage's symbols"
                         + "({},{}), our symbols ({}, {})").format(C.label(), r,

src/sage/schemes/elliptic_curves/padic_lseries.py

@@ -143,7 +143,7 @@ class pAdicLseries(SageObject):
         sage: lp == loads(dumps(lp))
         True
     """
-    def __init__(self, E, p, implementation = 'eclib', normalize='L_ratio'):
+    def __init__(self, E, p, implementation='eclib', normalize='L_ratio'):
         r"""
         INPUT:
 
@@ -337,7 +337,7 @@ def modular_symbol(self, r, sign=+1, quadratic_twist=+1):
                 return -sum([kronecker_symbol(D, u) * m(r + ZZ(u) / D)
                              for u in range(1, -D)])
 
-    def measure(self, a, n, prec, quadratic_twist=+1, sign = +1):
+    def measure(self, a, n, prec, quadratic_twist=+1, sign=+1):
         r"""
         Return the measure on `\ZZ_p^{\times}` defined by
 
@@ -1550,9 +1550,9 @@ def __phi_bpr(self, prec=0):
             print("Warning: Very large value for the precision.")
         if prec == 0:
             prec = floor((log(10000)/log(p)))
-            verbose("prec set to %s"%prec)
+            verbose("prec set to %s" % prec)
         eh = E.formal()
-        om = eh.differential(prec = p**prec+3)
+        om = eh.differential(prec=p**prec+3)
         verbose("differential computed")
         xt = eh.x(prec=p**prec + 3)
         et = xt*om

src/sage/schemes/elliptic_curves/padics.py

@@ -98,8 +98,10 @@ def _normalize_padic_lseries(self, p, normalize, implementation, precision):
         raise ValueError("Implementation should be one of  'sage', 'eclib', 'num' or 'pollackstevens'")
     return (p, normalize, implementation, precision)
 
+
 @cached_method(key=_normalize_padic_lseries)
-def padic_lseries(self, p, normalize = None, implementation = 'eclib', precision = None):
+def padic_lseries(self, p, normalize=None, implementation='eclib',
+                  precision=None):
     r"""
     Return the `p`-adic `L`-series of self at
     `p`, which is an object whose approx method computes
@@ -209,16 +211,16 @@ def padic_lseries(self, p, normalize = None, implementation = 'eclib', precision
     if implementation in ['sage', 'eclib', 'num']:
         if self.ap(p) % p != 0:
             Lp = plseries.pAdicLseriesOrdinary(self, p,
-                                  normalize = normalize, implementation = implementation)
+                                  normalize=normalize, implementation=implementation)
         else:
             Lp = plseries.pAdicLseriesSupersingular(self, p,
-                                  normalize = normalize, implementation = implementation)
+                                  normalize=normalize, implementation=implementation)
     else:
         phi = self.pollack_stevens_modular_symbol(sign=0)
         if phi.parent().level() % p == 0:
-            Phi = phi.lift(p, precision, eigensymbol = True)
+            Phi = phi.lift(p, precision, eigensymbol=True)
         else:
-            Phi = phi.p_stabilize_and_lift(p, precision, eigensymbol = True)
+            Phi = phi.p_stabilize_and_lift(p, precision, eigensymbol=True)
         Lp = Phi.padic_lseries()  #mm TODO should this pass precision on too ?
         Lp._cinf = self.real_components()
     return Lp

src/sage/schemes/elliptic_curves/period_lattice.py

@@ -802,7 +802,7 @@ def is_rectangular(self):
             return self.real_flag == +1
         raise RuntimeError("Not defined for non-real lattices.")
 
-    def real_period(self, prec = None, algorithm='sage'):
+    def real_period(self, prec=None, algorithm='sage'):
         """
         Return the real period of this period lattice.
 
@@ -840,8 +840,9 @@ def real_period(self, prec = None, algorithm='sage'):
             return self.basis(prec,algorithm)[0]
         raise RuntimeError("Not defined for non-real lattices.")
 
-    def omega(self, prec = None, bsd_normalise = False):
-        r"""Return the real or complex volume of this period lattice.
+    def omega(self, prec=None, bsd_normalise=False):
+        r"""
+        Return the real or complex volume of this period lattice.
 
         INPUT:
 
@@ -1014,7 +1015,7 @@ def complex_area(self, prec=None):
         w1,w2 = self.basis(prec)
         return (w1*w2.conjugate()).imag().abs()
 
-    def sigma(self, z, prec = None, flag=0):
+    def sigma(self, z, prec=None, flag=0):
         r"""
         Return the value of the Weierstrass sigma function for this elliptic curve  period lattice.