passagemath-schemes 10.5.44__cp313-cp313-musllinux_1_2_aarch64.whl → 10.6.42__cp313-cp313-musllinux_1_2_aarch64.whl

sage/schemes/elliptic_curves/period_lattice.py

@@ -109,15 +109,16 @@ AUTHORS:
 
 import sage.rings.abc
 
+from sage.categories.morphism import IdentityMorphism
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_import import lazy_import
 from sage.modules.free_module import FreeModule_generic_pid
-from sage.rings.complex_mpfr import ComplexField, ComplexNumber, ComplexField_class
+from sage.rings.complex_mpfr import ComplexField, ComplexNumber
 from sage.rings.infinity import Infinity
 from sage.rings.integer_ring import ZZ
 from sage.rings.qqbar import AA, QQbar
 from sage.rings.rational_field import QQ
-from sage.rings.real_mpfr import RealField, RealField_class, RealNumber
+from sage.rings.real_mpfr import RealField, RealNumber
 from sage.schemes.elliptic_curves.constructor import EllipticCurve
 from sage.structure.richcmp import richcmp_method, richcmp, richcmp_not_equal
 
@@ -234,14 +235,14 @@ class PeriodLattice_ell(PeriodLattice):
         # the given embedding:
 
         K = E.base_field()
-        self.is_approximate = isinstance(K, (RealField_class, ComplexField_class))
+        self._is_exact = K.is_exact()
         if embedding is None:
             if K in (AA, QQbar):
                 embedding = K.hom(QQbar)
                 real = K == AA
-            elif self.is_approximate:
-                embedding = K.hom(K)
-                real = isinstance(K, RealField_class)
+            elif not self._is_exact:
+                embedding = IdentityMorphism(K)
+                real = isinstance(K, (sage.rings.abc.RealField, sage.rings.abc.RealDoubleField))
             else:
                 embs = K.embeddings(AA)
                 real = len(embs) > 0
@@ -274,24 +275,24 @@ class PeriodLattice_ell(PeriodLattice):
         # The ei are used both for period computation and elliptic
         # logarithms.
 
-        if self.is_approximate:
-            self.f2 = self.E.two_division_polynomial()
-        else:
+        if self._is_exact:
             self.Ebar = self.E.change_ring(self.embedding)
             self.f2 = self.Ebar.two_division_polynomial()
+        else:
+            self.f2 = self.E.two_division_polynomial()
         if self.real_flag == 1: # positive discriminant
-            self._ei = self.f2.roots(K if self.is_approximate else AA,multiplicities=False)
+            self._ei = self.f2.roots(AA if self._is_exact else K, multiplicities=False)
             self._ei.sort()  # e1 < e2 < e3
             e1, e2, e3 = self._ei
         elif self.real_flag == -1: # negative discriminant
-            self._ei = self.f2.roots(ComplexField(K.precision()) if self.is_approximate else QQbar, multiplicities=False)
+            self._ei = self.f2.roots(QQbar if self._is_exact else ComplexField(K.precision()), multiplicities=False)
             self._ei = sorted(self._ei, key=lambda z: z.imag())
             e1, e3, e2 = self._ei # so e3 is real
-            if not self.is_approximate:
+            if self._is_exact:
                 e3 = AA(e3)
             self._ei = [e1, e2, e3]
         else:
-            self._ei = self.f2.roots(ComplexField(K.precision()) if self.is_approximate else QQbar, multiplicities=False)
+            self._ei = self.f2.roots(QQbar if self._is_exact else ComplexField(K.precision()), multiplicities=False)
             e1, e2, e3 = self._ei
 
         # The quantities sqrt(e_i-e_j) are cached (as elements of
@@ -354,7 +355,7 @@ class PeriodLattice_ell(PeriodLattice):
                Defn: a |--> 1.259921049894873?
         """
         K = self.E.base_field()
-        if K in (QQ, AA, QQbar) or isinstance(K, (RealField_class, ComplexField_class)):
+        if K in (QQ, AA, QQbar) or isinstance(self.embedding, IdentityMorphism):
             return "Period lattice associated to %s" % (self.E)
         return "Period lattice associated to %s with respect to the embedding %s" % (self.E, self.embedding)
 
@@ -667,7 +668,7 @@ class PeriodLattice_ell(PeriodLattice):
         r"""
         Internal function to compute the default precision to be used if nothing is passed in.
         """
-        return self.E.base_field().precision() if self.is_approximate else RealField().precision()
+        return RealField().precision() if self._is_exact else self.E.base_field().precision()
 
     @cached_method
     def _compute_periods_real(self, prec=None, algorithm='sage'):
@@ -715,7 +716,7 @@ class PeriodLattice_ell(PeriodLattice):
 
         if algorithm == 'pari':
             ainvs = self.E.a_invariants()
-            if self.E.base_field() is not QQ and not self.is_approximate:
+            if self.E.base_field() is not QQ and self._is_exact:
                 ainvs = [C(self.embedding(ai)).real() for ai in ainvs]
 
             # The precision for omega() is determined by ellinit()
@@ -727,7 +728,7 @@ class PeriodLattice_ell(PeriodLattice):
             raise ValueError("invalid value of 'algorithm' parameter")
 
         pi = R.pi()
-        # Up to now everything has been exact in AA or QQbar (unless self.is_approximate),
+        # Up to now everything has been exact in AA or QQbar (if self._is_exact),
         # but now we must go transcendental.  Only now is the desired precision used!
         if self.real_flag == 1: # positive discriminant
             a, b, c = (R(x) for x in self._abc)
@@ -799,7 +800,7 @@ class PeriodLattice_ell(PeriodLattice):
             prec = self._compute_default_prec()
         C = ComplexField(prec)
 
-        # Up to now everything has been exact in AA or QQbar (unless self.is_approximate),
+        # Up to now everything has been exact in AA or QQbar (if self._is_exact),
         # but now we must go transcendental.  Only now is the desired precision used!
         pi = C.pi()
         a, b, c = (C(x) for x in self._abc)
@@ -1188,6 +1189,38 @@ class PeriodLattice_ell(PeriodLattice):
         """
         return self.E
 
+    @property
+    def is_approximate(self):
+        """
+        ``self.is_approximate`` is deprecated, use ``not self.curve().is_exact()`` instead.
+
+        TESTS::
+
+            sage: E = EllipticCurve(ComplexField(100), [I, 3*I+4])
+            sage: L = E.period_lattice()
+            sage: L.is_approximate
+            doctest:...: DeprecationWarning: The attribute is_approximate for period lattice is deprecated,
+            use self.curve().is_exact() instead.
+            See https://github.com/sagemath/sage/issues/39212 for details.
+            True
+            sage: L.curve() is E
+            True
+            sage: E.is_exact()
+            False
+            sage: E = EllipticCurve(QQ, [0, 2])
+            sage: L = E.period_lattice()
+            sage: L.is_approximate
+            False
+            sage: L.curve() is E
+            True
+            sage: E.is_exact()
+            True
+        """
+        from sage.misc.superseded import deprecation
+        deprecation(39212, "The attribute is_approximate for period lattice is "
+                           "deprecated, use self.curve().is_exact() instead.")
+        return not self._is_exact
+
     def ei(self):
         r"""
         Return the x-coordinates of the 2-division points of the elliptic curve associated
@@ -1785,10 +1818,19 @@ class PeriodLattice_ell(PeriodLattice):
             sage: L.real_flag
             -1
             sage: P = E(3, 6)
-            sage: L.elliptic_logarithm(P)
+            sage: L.elliptic_logarithm(P)  # abs tol 1e-26
             2.4593388737550379526023682666
-            sage: L.elliptic_exponential(_)
+            sage: L.elliptic_exponential(_)  # abs tol 1e-26
             (3.0000000000000000000000000000 : 5.9999999999999999999999999999 : 1.0000000000000000000000000000)
+            sage: E = EllipticCurve(RDF, [1, 6])
+            sage: L = E.period_lattice()
+            sage: L.real_flag
+            -1
+            sage: P = E(3, 6)
+            sage: L.elliptic_logarithm(P)  # abs tol 1e-13
+            2.45933887375504
+            sage: L.elliptic_exponential(_)  # abs tol 1e-13
+            (3.00000000000000 : 6.00000000000001 : 1.00000000000000)
 
         Real approximate field, positive discriminant::
 
@@ -1797,9 +1839,9 @@ class PeriodLattice_ell(PeriodLattice):
             sage: L.real_flag
             1
             sage: P = E.lift_x(4)
-            sage: L.elliptic_logarithm(P)
+            sage: L.elliptic_logarithm(P)  # abs tol 1e-26
             0.51188849089267627141925354967
-            sage: L.elliptic_exponential(_)
+            sage: L.elliptic_exponential(_)  # abs tol 1e-26
             (4.0000000000000000000000000000 : -7.1414284285428499979993998114 : 1.0000000000000000000000000000)
 
         Complex approximate field::
@@ -1809,10 +1851,19 @@ class PeriodLattice_ell(PeriodLattice):
             sage: L.real_flag
             0
             sage: P = E.lift_x(4)
-            sage: L.elliptic_logarithm(P)
+            sage: L.elliptic_logarithm(P)  # abs tol 1e-26
             -1.1447032790074574712147458157 - 0.72429843602171875396186134806*I
-            sage: L.elliptic_exponential(_)
+            sage: L.elliptic_exponential(_)  # abs tol 1e-26
             (4.0000000000000000000000000000 + 1.2025589033682610849950210280e-30*I : -8.2570982991257407680322611854 - 0.42387771989714340809597881586*I : 1.0000000000000000000000000000)
+            sage: E = EllipticCurve(CDF, [I, 3*I+4])
+            sage: L = E.period_lattice()
+            sage: L.real_flag
+            0
+            sage: P = E.lift_x(4)
+            sage: L.elliptic_logarithm(P)  # abs tol 1e-13
+            -1.14470327900746 - 0.724298436021719*I
+            sage: L.elliptic_exponential(_)  # abs tol 1e-13
+            (4.00000000000000 - 0*I : -8.25709829912574 - 0.423877719897148*I : 1.00000000000000)
         """
         if P.curve() is not self.E:
             raise ValueError("Point is on the wrong curve")
@@ -2030,10 +2081,10 @@ class PeriodLattice_ell(PeriodLattice):
 
         if to_curve:
             K = x.parent()
-            if self.is_approximate:
-                v = self.embedding
-            else:
+            if self._is_exact:
                 v = refine_embedding(self.embedding, Infinity)
+            else:
+                v = self.embedding
             a1, a2, a3, a4, a6 = (K(v(a)) for a in self.E.ainvs())
             b2 = K(v(self.E.b2()))
             x = x - b2 / 12

sage/schemes/elliptic_curves/sha_tate.py

@@ -331,7 +331,7 @@ class Sha(SageObject):
             Traceback (most recent call last):
             ...
             RuntimeError: Unable to compute the rank, hence generators, with certainty
-            (lower bound=0, generators found=[]).  This could be because Sha(E/Q)[2] is
+            (lower bound=0, generators found=()).  This could be because Sha(E/Q)[2] is
             nontrivial. Try increasing descent_second_limit then trying this command again.
 
         You can increase the ``descent_second_limit`` (in the above example,

sage/schemes/elliptic_curves/weierstrass_morphism.py

@@ -630,7 +630,7 @@ class WeierstrassIsomorphism(EllipticCurveHom, baseWI):
         EXAMPLES::
 
             sage: # needs database_cremona_mini_ellcurve
-            sage: from sage.schemes.elliptic_curves.weierstrass_morphism import *
+            sage: from sage.schemes.elliptic_curves.weierstrass_morphism import WeierstrassIsomorphism
             sage: E = EllipticCurve('37a1')
             sage: w = WeierstrassIsomorphism(E,(2,3,4,5))
             sage: P = E(0,-1)
@@ -736,7 +736,7 @@ class WeierstrassIsomorphism(EllipticCurveHom, baseWI):
             sage: phi = E1.isogeny(E1(0,0))
             sage: E2 = phi.codomain()
             sage: psi = E2.isogeny(E2(0,0))
-            sage: w1._composition_impl(psi, phi)
+            sage: w1._composition_impl(psi, phi)                                        # needs database_cremona_mini_ellcurve
             NotImplemented
         """
         if isinstance(left, WeierstrassIsomorphism) and isinstance(right, WeierstrassIsomorphism):

sage/schemes/hyperelliptic_curves/hyperelliptic_generic.py

@@ -631,7 +631,7 @@ class HyperellipticCurve_generic(plane_curve.ProjectivePlaneCurve):
         from .constructor import HyperellipticCurve
         return HyperellipticCurve(fnew, 0, names=self._names, PP=self._PP)
 
-    def has_odd_degree_model(self):
+    def has_odd_degree_model(self) -> bool:
         r"""
         Return ``True`` if an odd degree model of ``self`` exists over the
         field of definition; ``False`` otherwise.

sage/schemes/hyperelliptic_curves/jacobian_endomorphism_utils.py

@@ -63,7 +63,7 @@ the LMFDB label of the curve is 169.a.169.1::
     sage: A.geometric_endomorphism_algebra_is_field()                                   # needs sage.groups
     False
 
-.. WARNING:
+.. WARNING::
 
     There is a very small chance that the algorithms return ``False`` for the
     two methods described above when in fact one or both of them are ``True``.

sage/schemes/hyperelliptic_curves/monsky_washnitzer.py

@@ -569,15 +569,10 @@ class SpecialCubicQuotientRing(UniqueRepresentation, Parent):
         """
         return self._poly_ring
 
-    def gens(self):
+    def gens(self) -> tuple:
         """
-        Return a list [x, T] where x and T are the generators of the ring
-        (as element *of this ring*).
-
-        .. NOTE::
-
-             I have no idea if this is compatible with the usual Sage
-             'gens' interface.
+        Return (x, T) where x and T are the generators of the ring
+        (as elements *of this ring*).
 
         EXAMPLES::
 
@@ -2545,7 +2540,7 @@ class SpecialHyperellipticQuotientRing(UniqueRepresentation, Parent):
         """
         return self.element_class(self, self._poly_ring.zero(), check=False)
 
-    def gens(self):
+    def gens(self) -> tuple:
         """
         Return the generators of ``self``.
 
@@ -2686,7 +2681,7 @@ class SpecialHyperellipticQuotientRing(UniqueRepresentation, Parent):
             mat_2[i] = self._precomputed_diff_coeffs[i][2]
         return mat_1.transpose(), mat_2.transpose()
 
-    def _precompute_monomial_diffs(self):
+    def _precompute_monomial_diffs(self) -> list:
         r"""
         Precompute coefficients of the basis representation of `d(x^iy^j)`
         for small `i`, `j`.
@@ -3818,6 +3813,7 @@ class MonskyWashnitzerDifferentialRing(UniqueRepresentation, Module):
             F.append(F_i)
         return F
 
+    @cached_method
     def helper_matrix(self):
         r"""
         We use this to solve for the linear combination of
@@ -3835,22 +3831,16 @@ class MonskyWashnitzerDifferentialRing(UniqueRepresentation, Module):
             [-100/2101 -125/2101 -625/8404  -64/2101  -80/2101]
             [ -80/2101 -100/2101 -125/2101 -625/8404  -64/2101]
         """
-        try:
-            return self._helper_matrix
-        except AttributeError:
-            pass
-
         # The smallest y term of (1/j) d(x^i y^j) is constant for all j.
         x, y = self.base_ring().gens()
         n = self.degree()
         L = [(y * x**i).diff().extract_pow_y(0) for i in range(n)]
         A = matrix(L).transpose()
         if A.base_ring() not in IntegralDomains():
-            # must be using integer_mod or something to approximate
-            self._helper_matrix = (~A.change_ring(QQ)).change_ring(A.base_ring())
-        else:
-            self._helper_matrix = ~A
-        return self._helper_matrix
+            # must be using integer_mod or something to approximate ?
+            return (~A.change_ring(QQ)).change_ring(A.base_ring())
+
+        return ~A
 
     def _element_constructor_(self, val=0, offset=0):
         r"""

sage/schemes/jacobians/abstract_jacobian.py

@@ -21,7 +21,7 @@ AUTHORS:
 
 from sage.categories.schemes import Jacobians
 from sage.categories.fields import Fields
-from sage.schemes.generic.scheme import Scheme, is_Scheme
+from sage.schemes.generic.scheme import Scheme
 from sage.structure.richcmp import richcmp_method, richcmp
 
 _Fields = Fields()

sage/schemes/plane_conics/con_field.py

@@ -71,8 +71,8 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
             Projective Conic Curve over Rational Field defined by x^2 + y^2 + z^2
         """
         super().__init__(A, f)
-        self._coefficients = [f[(2,0,0)], f[(1,1,0)], f[(1,0,1)],
-                                f[(0,2,0)], f[(0,1,1)], f[(0,0,2)]]
+        self._coefficients = [f[(2, 0, 0)], f[(1, 1, 0)], f[(1, 0, 1)],
+                              f[(0, 2, 0)], f[(0, 1, 1)], f[(0, 0, 2)]]
         self._parametrization = None
         self._diagonal_matrix = None
 
@@ -117,13 +117,13 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
                 return self
             if not S.has_coerce_map_from(B):
                 raise ValueError("No natural map from the base ring of self "
-                                  "(= %s) to S (= %s)" % (self, S))
+                                 "(= %s) to S (= %s)" % (self, S))
             from .constructor import Conic
             con = Conic([S(c) for c in self.coefficients()],
                         self.variable_names())
             if self._rational_point is not None:
                 pt = [S(c) for c in Sequence(self._rational_point)]
-                if not pt == [0,0,0]:
+                if not pt == [0, 0, 0]:
                     # The following line stores the point in the cache
                     # if (and only if) there is no point in the cache.
                     pt = con.point(pt)
@@ -285,26 +285,26 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
         """
         A = self.symmetric_matrix()
         B = self.base_ring()
-        basis = [vector(B,{2:0,i:1}) for i in range(3)]
+        basis = [vector(B, {2: 0, i: 1}) for i in range(3)]
         for i in range(3):
             zerovalue = (basis[i]*A*basis[i].column() == 0)
             if zerovalue:
-                for j in range(i+1,3):
+                for j in range(i+1, 3):
                     if basis[j]*A*basis[j].column() != 0:
                         b = basis[i]
                         basis[i] = basis[j]
                         basis[j] = b
                         zerovalue = False
             if zerovalue:
-                for j in range(i+1,3):
+                for j in range(i+1, 3):
                     if basis[i]*A*basis[j].column() != 0:
                         basis[i] = basis[i]+basis[j]
                         zerovalue = False
             if not zerovalue:
                 l = (basis[i]*A*basis[i].column())
-                for j in range(i+1,3):
+                for j in range(i+1, 3):
                     basis[j] = basis[j] - \
-                               (basis[i]*A*basis[j].column())/l * basis[i]
+                        (basis[i]*A*basis[j].column())/l * basis[i]
         T = matrix(basis).transpose()
         return T.transpose()*A*T, T
 
@@ -378,7 +378,7 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
         con = Conic(D, names=names)
         return con, con.hom(T, self), self.hom(T.inverse(), con)
 
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         Return the generators of the coordinate ring of ``self``.
 
@@ -538,24 +538,24 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
 
         if isinstance(B, sage.rings.abc.ComplexField):
             if point:
-                [_,_,_,d,e,f] = self._coefficients
+                _, _, _, d, e, f = self._coefficients
                 if d == 0:
-                    return True, self.point([0,1,0])
+                    return True, self.point([0, 1, 0])
                 return True, self.point([0, ((e**2-4*d*f).sqrt()-e)/(2*d), 1],
                                         check=False)
             return True
         if isinstance(B, sage.rings.abc.RealField):
             D, T = self.diagonal_matrix()
-            [a, b, c] = [D[0,0], D[1,1], D[2,2]]
+            a, b, c = [D[0, 0], D[1, 1], D[2, 2]]
             if a == 0:
-                ret = True, self.point(T*vector([1,0,0]), check=False)
+                ret = True, self.point(T*vector([1, 0, 0]), check=False)
             elif a*c <= 0:
-                ret = True, self.point(T*vector([(-c/a).sqrt(),0,1]),
+                ret = True, self.point(T*vector([(-c/a).sqrt(), 0, 1]),
                                        check=False)
             elif b == 0:
-                ret = True, self.point(T*vector([0,1,0]), check=False)
+                ret = True, self.point(T*vector([0, 1, 0]), check=False)
             elif b*c <= 0:
-                ret = True, self.point(T*vector([0,(-c/b).sqrt(),0,1]),
+                ret = True, self.point(T*vector([0, (-c/b).sqrt(), 0, 1]),
                                        check=False)
             else:
                 ret = False, None
@@ -618,16 +618,16 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
             return ret[0]
         B = self.base_ring()
         if B.characteristic() == 2:
-            [a,b,c,d,e,f] = self.coefficients()
+            a, b, c, d, e, f = self.coefficients()
             if b == 0 and c == 0 and e == 0:
                 for i in range(3):
                     if [a, d, f][i] == 0:
-                        return True, self.point(vector(B, {2:0, i:1}))
+                        return True, self.point(vector(B, {2: 0, i: 1}))
                 if hasattr(a/f, 'is_square') and hasattr(a/f, 'sqrt'):
                     if (a/f).is_square():
-                        return True, self.point([1,0,(a/f).sqrt()])
+                        return True, self.point([1, 0, (a/f).sqrt()])
                     if (d/f).is_square():
-                        return True, self.point([0,1,(d/f).sqrt()])
+                        return True, self.point([0, 1, (d/f).sqrt()])
                 raise NotImplementedError("Sorry, find singular point on conics not implemented over all fields of characteristic 2.")
             pt = [e, c, b]
             if self.defining_polynomial()(pt) == 0:
@@ -761,7 +761,7 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
             True
         """
         if self.base_ring().characteristic() == 2:
-            [a,b,c,d,e,f] = self.coefficients()
+            a, b, c, d, e, f = self.coefficients()
             if b == 0 and c == 0 and e == 0:
                 return False
             return self.defining_polynomial()([e, c, b]) != 0
@@ -804,7 +804,7 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
         kmn = magma(self.base_ring())._ref()
         coeffs = self.coefficients()
         magma_coeffs = [coeffs[i]._magma_init_(magma) for i in [0, 3, 5, 1, 4, 2]]
-        return 'Conic([%s|%s])' % (kmn,','.join(magma_coeffs))
+        return 'Conic([%s|%s])' % (kmn, ','.join(magma_coeffs))
 
     def matrix(self):
         r"""
@@ -869,7 +869,7 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
             sage: set(f(p) for p in f.domain())
             {(0 : 0 : 1), (0 : 1 : 1), (1 : 0 : 1)}
 
-        Verfication of the example ::
+        Verification of the example ::
 
             sage: # needs sage.libs.pari
             sage: h = g*f; h
@@ -946,28 +946,28 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
             point = Sequence(point)
             B = self.base_ring()
             Q = PolynomialRing(B, 'x,y')
-            [x, y] = Q.gens()
+            x, y = Q.gens()
             gens = self.ambient_space().gens()
             P = PolynomialRing(B, 4, ['X', 'Y', 'T0', 'T1'])
-            [X, Y, T0, T1] = P.gens()
-            c3 = [j for j in range(2,-1,-1) if point[j] != 0][0]
-            c1 = [j for j in range(3) if j != c3][0]
-            c2 = [j for j in range(3) if j != c3 and j != c1][0]
-            L = [0,0,0]
-            L[c1] = Y*T1*point[c1] + Y*T0
-            L[c2] = Y*T1*point[c2] + X*T0
-            L[c3] = Y*T1*point[c3]
+            X, Y, T0, T1 = P.gens()
+            c3 = next(j for j in range(2, -1, -1) if point[j] != 0)
+            c1 = next(j for j in range(3) if j != c3)
+            c2 = next(j for j in range(3) if j != c3 and j != c1)
+            L = [0, 0, 0]
+            L[c1] = Y * T1 * point[c1] + Y * T0
+            L[c2] = Y * T1 * point[c2] + X * T0
+            L[c3] = Y * T1 * point[c3]
             bezout = P(self.defining_polynomial()(L) / T0)
-            t = [bezout([x,y,0,-1]),bezout([x,y,1,0])]
-            par = (tuple([Q(p([x,y,t[0],t[1]])/y) for p in L]),
-                   tuple([gens[m]*point[c3]-gens[c3]*point[m]
-                       for m in [c2,c1]]))
+            t = [bezout([x, y, 0, -1]), bezout([x, y, 1, 0])]
+            par = (tuple([Q(p([x, y, t[0], t[1]]) / y) for p in L]),
+                   tuple([gens[m] * point[c3] - gens[c3] * point[m]
+                          for m in [c2, c1]]))
             if self._parametrization is None:
                 self._parametrization = par
         if not morphism:
             return par
         P1 = ProjectiveSpace(self.base_ring(), 1, 'x,y')
-        return P1.hom(par[0],self), self.Hom(P1)(par[1], check=False)
+        return P1.hom(par[0], self), self.Hom(P1)(par[1], check=False)
 
     def point(self, v, check=True):
         r"""
@@ -1266,10 +1266,10 @@ class ProjectiveConic_field(ProjectivePlaneCurve_field):
             x^2 + 2*x*y + y^2 + 3*x*z + z^2
         """
         from sage.matrix.constructor import matrix
-        [a,b,c,d,e,f] = self.coefficients()
-        return matrix([[ a, b, c ],
-                       [ 0, d, e ],
-                       [ 0, 0, f ]])
+        a, b, c, d, e, f = self.coefficients()
+        return matrix([[a, b, c],
+                       [0, d, e],
+                       [0, 0, f]])
 
     def variable_names(self):
         r"""

sage/schemes/plane_conics/con_rational_field.py

@@ -387,7 +387,7 @@ class ProjectiveConic_rational_field(ProjectiveConic_number_field):
                 point = self.rational_point()
             point = Sequence(point)
             Q = PolynomialRing(QQ, 'x,y')
-            [x, y] = Q.gens()
+            x, y = Q.gens()
             gens = self.ambient_space().gens()
             M = self.symmetric_matrix()
             M *= lcm([t.denominator() for t in M.list()])

sage/schemes/riemann_surfaces/riemann_surface.py

@@ -115,7 +115,7 @@ The initial version of this code was developed alongside [BSZ2019]_.
 
 from scipy.spatial import Voronoi
 from sage.arith.functions import lcm
-from sage.arith.misc import GCD, algdep
+from sage.arith.misc import GCD, algebraic_dependency
 from sage.ext.fast_callable import fast_callable
 from sage.graphs.graph import Graph
 from sage.groups.matrix_gps.finitely_generated import MatrixGroup
@@ -618,7 +618,7 @@ class RiemannSurface:
         sage: f = Y^2+X*Y+phi*Y-(X^3-X^2-2*phi*X+phi)
         sage: S = RiemannSurface(f,prec=prec, differentials=[1])
         sage: tau = S.riemann_matrix()[0, 0]
-        sage: tau.algdep(6).degree() == 2
+        sage: tau.algebraic_dependency(6).degree() == 2
         True
     """
 
@@ -2294,7 +2294,7 @@ class RiemannSurface:
             sage: m = S.matrix_of_integral_values(B)
             sage: parent(m)
             Full MatrixSpace of 1 by 2 dense matrices over Complex Field with 53 bits of precision
-            sage: (m[0,0]/m[0,1]).algdep(3).degree() # curve is CM, so the period is quadratic
+            sage: (m[0,0]/m[0,1]).algebraic_dependency(3).degree() # curve is CM, so the period is quadratic
             2
 
         .. NOTE::
@@ -2414,7 +2414,7 @@ class RiemannSurface:
 
             sage: x = polygen(QQ)
             sage: K.<a> = NumberField(x^2 - x + 2)
-            sage: all(len(m.algdep(6).roots(K)) > 0 for m in M.list())
+            sage: all(len(m.algebraic_dependency(6).roots(K)) > 0 for m in M.list())
             True
         """
         PeriodMatrix = self.period_matrix()
@@ -2691,7 +2691,7 @@ class RiemannSurface:
             d = 1
             while True:
                 d += 1
-                dep = algdep(alpha, d, height_bound=10**d)
+                dep = algebraic_dependency(alpha, d, height_bound=10**d)
                 if dep and dep(alpha) < epscomp:
                     return dep
 
@@ -2974,7 +2974,7 @@ class RiemannSurface:
         mp_list = [reparameterize_differential_minpoly(mp, z_start) for mp in mp_list]
 
         # Depending on whether we have reparameterized about infinity or not,
-        # we initialise some values we will need in the calculation, inclduing
+        # we initialise some values we will need in the calculation, including
         # the function `initalize', which at a given value of zbar, calculates
         # the starting value for the i-th differential so it can be iterated
         # from via homotopy continuation.
@@ -3871,8 +3871,8 @@ class RiemannSurface:
                 ys = []
                 for gi in gis:
                     # This test is a bit clunky, it surely can be made more efficient.
-                    if len(ys):
-                        ers = min([gi(y, r).abs() for y in ys])
+                    if ys:
+                        ers = min(gi(y, r).abs() for y in ys)
                     else:
                         ers = 1