passagemath-schemes 10.5.48__cp312-cp312-musllinux_1_2_aarch64.whl → 10.6.47__cp312-cp312-musllinux_1_2_aarch64.whl

sage/schemes/elliptic_curves/ell_field.py

@@ -10,7 +10,7 @@ This module defines the class :class:`EllipticCurve_field`, based on
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # *****************************************************************************
 
 import sage.rings.abc
@@ -31,7 +31,7 @@ from . import ell_generic
 
 class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurve_field):
 
-    def __init__(self, R, data, category=None):
+    def __init__(self, R, data, category=None) -> None:
         r"""
         Constructor for elliptic curves over fields.
 
@@ -67,7 +67,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
     # j=0=1728, but I have never worked them out or seen them used!
     #
 
-    def genus(self):
+    def genus(self) -> Integer:
         """
         Return 1 for elliptic curves.
 
@@ -210,19 +210,19 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
                 raise ValueError("twisting parameter D must be nonzero when characteristic is not 2")
 
         if char != 2:
-            b2,b4,b6,b8 = self.b_invariants()
+            b2, b4, b6, b8 = self.b_invariants()
             # E is isomorphic to  [0,b2,0,8*b4,16*b6]
-            return EllipticCurve(K,[0,b2*D,0,8*b4*D**2,16*b6*D**3])
+            return EllipticCurve(K, [0, b2*D, 0, 8*b4*D**2, 16*b6*D**3])
 
         # now char==2
-        if self.j_invariant() != 0: # iff a1!=0
-            a1,a2,a3,a4,a6 = self.ainvs()
-            E0 = self.change_weierstrass_model(a1,a3/a1,0,(a1**2*a4+a3**2)/a1**3)
+        if self.j_invariant() != 0:  # iff a1!=0
+            a1, a2, a3, a4, a6 = self.ainvs()
+            E0 = self.change_weierstrass_model(a1, a3/a1, 0, (a1**2*a4+a3**2)/a1**3)
             # which has the form = [1,A2,0,0,A6]
             assert E0.a1() == K(1)
             assert E0.a3() == K(0)
             assert E0.a4() == K(0)
-            return EllipticCurve(K,[1,E0.a2()+D,0,0,E0.a6()])
+            return EllipticCurve(K, [1, E0.a2() + D, 0, 0, E0.a6()])
         else:
             raise ValueError("Quadratic twist not implemented in char 2 when j=0")
 
@@ -262,7 +262,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
             2
         """
         f = self.division_polynomial(Integer(2))
-        n = len(f.roots())+1
+        n = len(f.roots()) + 1
         return Integer(n).ord(Integer(2))
 
     def quartic_twist(self, D):
@@ -304,10 +304,10 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         if D.is_zero():
             raise ValueError("quartic twist requires a nonzero argument")
 
-        c4,c6 = self.c_invariants()
+        c4, c6 = self.c_invariants()
         # E is isomorphic to  [0,0,0,-27*c4,0]
         assert c6 == 0
-        return EllipticCurve(K,[0,0,0,-27*c4*D,0])
+        return EllipticCurve(K, [0, 0, 0, -27 * c4 * D, 0])
 
     def sextic_twist(self, D):
         r"""
@@ -350,10 +350,10 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         if D.is_zero():
             raise ValueError("Sextic twist requires a nonzero argument")
 
-        c4,c6 = self.c_invariants()
+        c4, c6 = self.c_invariants()
         # E is isomorphic to  [0,0,0,0,-54*c6]
         assert c4 == 0
-        return EllipticCurve(K,[0,0,0,0,-54*c6*D])
+        return EllipticCurve(K, [0, 0, 0, 0, -54 * c6 * D])
 
     def is_quadratic_twist(self, other):
         r"""
@@ -474,12 +474,12 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         elif char == 3:
             if j == 0:
                 raise NotImplementedError("not implemented in characteristic 3 for curves of j-invariant 0")
-            D = E.b2()/F.b2()
+            D = E.b2() / F.b2()
 
         else:
             # now char!=2,3:
-            c4E,c6E = E.c_invariants()
-            c4F,c6F = F.c_invariants()
+            c4E, c6E = E.c_invariants()
+            c4F, c6F = F.c_invariants()
 
             if j == 0:
                 um = c6E/c6F
@@ -572,7 +572,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
             raise NotImplementedError("not implemented in characteristic 3")
         else:
             # now char!=2,3:
-            D = F.c4()/E.c4()
+            D = F.c4() / E.c4()
 
         if D.is_zero():
             return D
@@ -641,7 +641,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
             raise NotImplementedError("not implemented in characteristic 3")
         else:
             # now char!=2,3:
-            D = F.c6()/E.c6()
+            D = F.c6() / E.c6()
 
         if D.is_zero():
             return D
@@ -650,7 +650,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
 
         return D
 
-    def descend_to(self, K, f=None):
+    def descend_to(self, K, f=None) -> list:
         r"""
         Given an elliptic curve ``self`` defined over a field `L` and a
         subfield `K` of `L`, return all elliptic curves over `K` which
@@ -786,33 +786,33 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
             raise NotImplementedError("Not implemented in positive characteristic")
 
         if jK == 0:
-            t = -54*self.c6()
+            t = -54 * self.c6()
             try:
-                dlist = t.descend_mod_power(K,6)
+                dlist = t.descend_mod_power(K, 6)
                 # list of d in K such that t/d is in L*^6
             except AttributeError:
                 raise NotImplementedError("Not implemented over %s" % L)
-            Elist = [EllipticCurve([0,0,0,0,d]) for d in dlist]
+            Elist = [EllipticCurve([0, 0, 0, 0, d]) for d in dlist]
         elif jK == 1728:
-            t = -27*self.c4()
+            t = -27 * self.c4()
             try:
-                dlist = t.descend_mod_power(K,4)
+                dlist = t.descend_mod_power(K, 4)
                 # list of d in K such that t/d is in L*^4
             except AttributeError:
                 raise NotImplementedError("Not implemented over %s" % L)
-            Elist = [EllipticCurve([0,0,0,d,0]) for d in dlist]
+            Elist = [EllipticCurve([0, 0, 0, d, 0]) for d in dlist]
         else:
             c4, c6 = self.c_invariants()
-            t = c6/c4
+            t = c6 / c4
             try:
-                dlist = t.descend_mod_power(K,2)
+                dlist = t.descend_mod_power(K, 2)
                 # list of d in K such that t/d is in L*^2
             except AttributeError:
                 raise NotImplementedError("Not implemented over %s" % L)
-            c = -27*jK/(jK-1728) # =-27c4^3/c6^2
+            c = -27*jK/(jK-1728)  # =-27c4^3/c6^2
             a4list = [c*d**2 for d in dlist]
-            a6list = [2*a4*d for a4,d in zip(a4list,dlist)]
-            Elist = [EllipticCurve([0,0,0,a4,a6]) for a4,a6 in zip(a4list,a6list)]
+            a6list = [2*a4*d for a4, d in zip(a4list, dlist)]
+            Elist = [EllipticCurve([0, 0, 0, a4, a6]) for a4, a6 in zip(a4list, a6list)]
 
         if K is QQ:
             Elist = [E.minimal_model() for E in Elist]
@@ -1098,7 +1098,8 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         # The Galois group of the X-coordinates is a subgroup of GL(2,n)/{-1,+1}.
         if F in NumberFields():
             from sage.misc.misc_c import prod
-            deg_mult = F.degree() * prod(l * (l+1) * (l-1)**2 * l**(4*(e-1)) for l,e in n.factor()) // 2
+            deg_mult = F.degree() * prod(l * (l+1) * (l-1)**2 * l**(4*(e-1))
+                                         for l, e in n.factor()) // 2
             K, F_to_K = f.splitting_field(names, degree_multiple=deg_mult, map=True, **kwds)
         elif F in FiniteFields():
             K, F_to_K = f.splitting_field('u', map=True, **kwds)
@@ -1554,10 +1555,14 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
             Period lattice associated to Elliptic Curve defined by y^2 = x^3 + x + 6 over Rational Field
             sage: EllipticCurve(RR, [1, 6]).period_lattice()
             Period lattice associated to Elliptic Curve defined by y^2 = x^3 + 1.00000000000000*x + 6.00000000000000 over Real Field with 53 bits of precision
+            sage: EllipticCurve(RDF, [1, 6]).period_lattice()
+            Period lattice associated to Elliptic Curve defined by y^2 = x^3 + 1.0*x + 6.0 over Real Double Field
             sage: EllipticCurve(RealField(100), [1, 6]).period_lattice()
             Period lattice associated to Elliptic Curve defined by y^2 = x^3 + 1.0000000000000000000000000000*x + 6.0000000000000000000000000000 over Real Field with 100 bits of precision
             sage: EllipticCurve(CC, [1, 6]).period_lattice()
             Period lattice associated to Elliptic Curve defined by y^2 = x^3 + 1.00000000000000*x + 6.00000000000000 over Complex Field with 53 bits of precision
+            sage: EllipticCurve(CDF, [1, 6]).period_lattice()
+            Period lattice associated to Elliptic Curve defined by y^2 = x^3 + 1.0*x + 6.0 over Complex Double Field
             sage: EllipticCurve(ComplexField(100), [1, 6]).period_lattice()
             Period lattice associated to Elliptic Curve defined by y^2 = x^3 + 1.0000000000000000000000000000*x + 6.0000000000000000000000000000 over Complex Field with 100 bits of precision
             sage: EllipticCurve(AA, [1, 6]).period_lattice()
@@ -1589,7 +1594,8 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         Given a point `P` on this curve which generates a rational subgroup,
         return the kernel polynomial of that subgroup as a polynomial over
         the base field of the curve.
-        (The point `P` itself may be defined over an extension.)
+
+        The point `P` itself may be defined over an extension.
 
         EXAMPLES::
 
@@ -1772,8 +1778,12 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
 
         from sage.schemes.elliptic_curves.isogeny_small_degree import _least_semi_primitive
         a = _least_semi_primitive(l)
-        mul_a = lambda x: self._multiple_x_numerator(a, x=x) / self._multiple_x_denominator(a, x=x)
-        x_mod = lambda g: g.parent().quotient(g).gen()
+
+        def mul_a(x):
+            return self._multiple_x_numerator(a, x=x) / self._multiple_x_denominator(a, x=x)
+
+        def x_mod(g):
+            return g.parent().quotient(g).gen()
 
         fs = [f]
         m = l//2//f.degree()
@@ -1786,7 +1796,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
 
         return prod(fs)
 
-    def isogenies_prime_degree(self, l=None, max_l=31):
+    def isogenies_prime_degree(self, l=None, max_l=31) -> list:
         """
         Return a list of all separable isogenies (up to post-composition with
         isomorphisms) of given prime degree(s) with domain equal to ``self``,
@@ -2111,6 +2121,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
 
         ::
 
+            sage: # needs sage.symbolic
             sage: E = EllipticCurve(GF(next_prime(2^32)), j=1728)
             sage: sorted([phi.codomain().j_invariant() for phi in E.isogenies_degree(11 * 17 * 19^2)])
             [1348157279, 1348157279, 1713365879, 1713365879, 3153894341, 3153894341,
@@ -2124,6 +2135,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         not use a ``set`` or any hash-based data structure, as hashing
         isogenies is slow::
 
+            sage: # needs sage.symbolic
             sage: import itertools
             sage: all_distinct = lambda arr: all(x != y for x, y in itertools.combinations(arr, 2))
             sage: K.<z> = GF((19, 2))
@@ -2183,7 +2195,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
                To:   Elliptic Curve defined by y^2 = x^3 + 4294967267*x + 112 over Finite Field of size 4294967311]
             sage: all(isog.domain() is E for isog in _)
             True
-            sage: all(isog.domain() is E for isog in E.isogenies_degree(2^5, _intermediate=True))
+            sage: all(isog.domain() is E for isog in E.isogenies_degree(2^5, _intermediate=True))   # needs sage.symbolic
             True
 
         The following curve has no degree-`53` isogenies, so the code is quick::
@@ -2243,7 +2255,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
                     # self -> E2
                     yield psi
 
-    def is_isogenous(self, other, field=None):
+    def is_isogenous(self, other, field=None) -> bool:
         """
         Return whether or not ``self`` is isogenous to ``other``.
 
@@ -2569,7 +2581,6 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
             sage: G3.vertices(sort=True)
             ['0', '0*', '1', '1*']
         """
-
         from warnings import warn
         from sage.matrix.constructor import Matrix
 
@@ -2586,7 +2597,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         Es = [self]  # list of curves in graph
         A = []  # adjacency matrix
         labels = []  # list of vertex labels
-        for (i, E) in enumerate(Es):
+        for i, E in enumerate(Es):
             if 0 < curve_max < len(Es):
                 warn('Isogeny graph contains more than '
                      + str(curve_max) + ' curves.')
@@ -2594,8 +2605,8 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
 
             r = [0] * len(Es)  # adjacency matrix row
             for C in [I.codomain() for I in E.isogenies_prime_degree(l)]:
-                j = next((k for (k, F) in enumerate(Es) if C.is_isomorphic(F)),
-                        -1)  # index of curve isomorphic to codomain of isogeny
+                j = next((k for k, F in enumerate(Es) if C.is_isomorphic(F)),
+                         -1)  # index of curve isomorphic to codomain of isogeny
                 if j >= 0:
                     r[j] += 1
                 else:
@@ -2610,7 +2621,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
             # regardless of the starting vertex.
             if not directed and E.j_invariant() in [0, 1728]:
                 m = len(E.automorphisms()) / 2  # multiplicity of out-edges
-                r = [v if k == i else v / m for (k, v) in enumerate(r)]
+                r = [v if k == i else v / m for k, v in enumerate(r)]
 
             A.append(r)
             if label_by_j:
@@ -2633,7 +2644,7 @@ class EllipticCurve_field(ell_generic.EllipticCurve_generic, ProjectivePlaneCurv
         GL = G.relabel(labels, inplace=False)
         return GL
 
-    def endomorphism_ring_is_commutative(self):
+    def endomorphism_ring_is_commutative(self) -> bool:
         r"""
         Check whether the endomorphism ring of this elliptic curve
         *over its base field* is commutative.
@@ -2800,12 +2811,12 @@ def point_of_order(E, n):
     if n == 1:
         return E(0)
 
-    l,m = n.is_prime_power(get_data=True)
+    l, m = n.is_prime_power(get_data=True)
     if not m:
         raise NotImplementedError('only prime-power orders are currently supported')
 
     xpoly = E.division_polynomial(n).radical()
-    xpoly //= E.division_polynomial(n//l).radical()
+    xpoly //= E.division_polynomial(n // l).radical()
     if xpoly.degree() < 1:  # supersingular and l == p
         raise ValueError('curve does not have any points of the specified order')
 

sage/schemes/elliptic_curves/ell_finite_field.py

@@ -683,27 +683,31 @@ class EllipticCurve_finite_field(EllipticCurve_field):
             This computes the curve cardinality, which may be
             time-consuming.
 
+        .. SEEALSO::
+
+            :meth:`endomorphism_order`
+
         EXAMPLES::
 
             sage: E = EllipticCurve(GF(11),[3,3])
             sage: E.frobenius_order()
-            Order of conductor 2 generated by phi
-             in Number Field in phi with defining polynomial x^2 - 4*x + 11
+            Order of conductor 2 generated by pi
+             in Number Field in pi with defining polynomial x^2 - 4*x + 11
 
-        For some supersingular curves, Frobenius is in Z and the Frobenius
-        order is Z::
+        For some supersingular curves, Frobenius is in `\ZZ` and the Frobenius
+        order is `\ZZ`::
 
             sage: # needs sage.rings.finite_rings
             sage: E = EllipticCurve(GF(25,'a'),[0,0,0,0,1])
             sage: R = E.frobenius_order()
             sage: R
             Order generated by []
-             in Number Field in phi with defining polynomial x + 5
+             in Number Field in pi with defining polynomial x + 5
             sage: R.degree()
             1
         """
         f = self.frobenius_polynomial().factor()[0][0]
-        return ZZ.extension(f,names='phi')
+        return ZZ.extension(f, names='pi')
 
     def frobenius(self):
         r"""
@@ -720,7 +724,7 @@ class EllipticCurve_finite_field(EllipticCurve_field):
 
             sage: E = EllipticCurve(GF(11),[3,3])
             sage: E.frobenius()
-            phi
+            pi
             sage: E.frobenius().minpoly()
             x^2 - 4*x + 11
 
@@ -1345,7 +1349,7 @@ class EllipticCurve_finite_field(EllipticCurve_field):
         """
         return not is_j_supersingular(self.j_invariant(), proof=proof)
 
-    def has_order(self, value, num_checks=8):
+    def has_order(self, value, num_checks=8) -> bool:
         r"""
         Return ``True`` if the curve has order ``value``.
 
@@ -1621,7 +1625,11 @@ class EllipticCurve_finite_field(EllipticCurve_field):
 
     def height_above_floor(self, ell, e):
         r"""
-        Return the height of the `j`-invariant of this ordinary elliptic curve on its `\ell`-volcano.
+        Return the height of the `j`-invariant of this elliptic curve on its `\ell`-volcano.
+
+        The curve must have a rational endomorphism ring of rank 2: This includes all
+        ordinary elliptic curves over finite fields as well as those supersingular
+        elliptic curves with Frobenius not in `\ZZ`.
 
         INPUT:
 
@@ -1632,12 +1640,12 @@ class EllipticCurve_finite_field(EllipticCurve_field):
 
         .. NOTE::
 
-            For an ordinary `E/\GF{q}`, and a prime `\ell`, the height
-            `e` of the `\ell`-volcano containing `j(E)` is the `\ell`-adic
+            For a suitable `E/\GF{q}`, and a prime `\ell`, the height
+            `e` of the `\ell`-volcano containing `E` is the `\ell`-adic
             valuation of the conductor of the order generated by the
-            Frobenius `\pi_E`; the height of `j(E)` on its
+            `\GF{q}`-Frobenius `\pi_E`; the height of `E` on its
             ell-volcano is the `\ell`-adic valuation of the conductor
-            of the order `\text{End}(E)`.
+            of the order `\text{End}_{\GF{q}}(E)`.
 
         ALGORITHM:
 
@@ -1654,10 +1662,51 @@ class EllipticCurve_finite_field(EllipticCurve_field):
             sage: E.height_above_floor(2,8)
             5
         """
+        pi = self.frobenius()
+        if pi in ZZ:
+            raise ValueError("{} has a (rational) endomorphism ring of rank 4".format(self))
+
+        e = ZZ(e)
+        if not e:
+            return ZZ.zero()
+
         if self.is_supersingular():
-            raise ValueError("{} is not ordinary".format(self))
-        if e == 0:
-            return 0
+            if ell == self.base_field().characteristic():
+                # In this (exceptional) case, the Frobenius can always be divided
+                # by the maximal possible power of the characteristic. The reason
+                # is that Frobenius must be of the form phi o [p^k] where phi is
+                # a purely inseparable isogeny of degree 1 or p, hence this [p^k]
+                # can always be divided out while retaining an endomorphism.
+                assert self.base_field().cardinality().valuation(ell) >= 2*e
+                return e
+
+            # In the supersingular case, the j-invariant alone does not determine
+            # the level in the volcano. (The underlying reason is that there can
+            # be multiple non-F_q-isomorphic curves with a given j-invariant in
+            # the isogeny graph.)
+            # Example: y^2 = x^3 ± x over F_p with p congruent to 3 modulo 4 have
+            # distinct (rational) endomorphism rings.
+            # Thus we run the "probing the depths" algorithm with F_q-isomorphism
+            # classes of curves instead.
+            E0 = [self] * 3
+            E1 = [phi.codomain() for phi in self.isogenies_prime_degree(ell)]
+            assert E1
+            if len(E1) == 1:
+                return ZZ.zero()
+            assert len(E1) == ell + 1
+            h = ZZ.one()
+            while True:
+                for i in range(3):
+                    isogs = E1[i].isogenies_prime_degree(ell)
+                    try:
+                        step = next(phi for phi in isogs if not phi.codomain().is_isomorphic(E0[i]))
+                    except StopIteration:
+                        return h
+                    E0[i], E1[i] = step.domain(), step.codomain()
+                h += 1
+                assert h <= e
+            raise AssertionError('unreachable code -- this is a bug')
+
         j = self.j_invariant()
         if j in [0, 1728]:
             return e
@@ -1665,19 +1714,19 @@ class EllipticCurve_finite_field(EllipticCurve_field):
         x = polygen(F)
         from sage.rings.polynomial.polynomial_ring import polygens
         from sage.schemes.elliptic_curves.mod_poly import classical_modular_polynomial
-        X, Y = polygens(F, "X, Y", 2)
+        X, Y = polygens(F, 'X,Y')
         phi = classical_modular_polynomial(ell)(X, Y)
         j1 = phi([x,j]).roots(multiplicities=False)
         nj1 = len(j1)
         on_floor = self.two_torsion_rank() < 2 if ell == 2 else nj1 <= ell
         if on_floor:
-            return 0
+            return ZZ.zero()
         if e == 1 or nj1 != ell+1:  # double roots can only happen at the surface
             return e
         if nj1 < 3:
-            return 0
+            return ZZ.zero()
         j0 = [j,j,j]
-        h = 1
+        h = ZZ.one()
         while True:
             for i in range(3):
                 r = (phi([x,j1[i]])//(x-j0[i])).roots(multiplicities=False)
@@ -1762,6 +1811,69 @@ class EllipticCurve_finite_field(EllipticCurve_field):
                 return (v//cs[0])**2 * D0
         raise ValueError("Incorrect class number {}".format(h))
 
+    def endomorphism_order(self):
+        r"""
+        Return a quadratic order isomorphic to the endomorphism ring
+        of this elliptic curve, assuming the order has rank two.
+
+        .. NOTE::
+
+            In the future, this method will hopefully be extended to return a
+            :class:`~sage.algebras.quatalg.quaternion_algebra.QuaternionOrder`
+            object in the rank-4 case, but this has not been implemented yet.
+
+        .. SEEALSO::
+
+            :meth:`frobenius_order`
+
+        EXAMPLES::
+
+            sage: E = EllipticCurve(GF(11), [3,3])
+            sage: E.endomorphism_order()
+            Maximal Order generated by 1/2*pi + 1/2 in Number Field in pi with defining polynomial x^2 - 4*x + 11
+
+        It also works for supersingular elliptic curves provided that Frobenius
+        is not in `\ZZ`::
+
+            sage: E = EllipticCurve(GF(11), [1,0])
+            sage: E.is_supersingular()
+            True
+            sage: E.endomorphism_order()
+            Order of conductor 2 generated by pi in Number Field in pi with defining polynomial x^2 + 11
+
+        ::
+
+            sage: E = EllipticCurve(GF(11), [-1,0])
+            sage: E.is_supersingular()
+            True
+            sage: E.endomorphism_order()
+            Maximal Order generated by 1/2*pi + 1/2 in Number Field in pi with defining polynomial x^2 + 11
+
+        There are some exceptional cases where Frobenius itself is divisible
+        by the characteristic::
+
+            sage: EllipticCurve([GF(7^2).gen(), 0]).endomorphism_order()
+            Gaussian Integers generated by 1/7*pi in Number Field in pi with defining polynomial x^2 + 49
+            sage: EllipticCurve(GF(3^5), [1, 0]).endomorphism_order()
+            Order of conductor 2 generated by 1/9*pi in Number Field in pi with defining polynomial x^2 + 243
+            sage: EllipticCurve(GF(7^3), [-1, 0]).endomorphism_order()
+            Maximal Order generated by 1/14*pi + 1/2 in Number Field in pi with defining polynomial x^2 + 343
+        """
+        pi = self.frobenius()
+        if pi in ZZ:
+            raise NotImplementedError('the rank-4 case is not supported yet')
+
+        O = self.frobenius_order()
+        f0 = O.conductor()
+
+        f = 1
+        for l,e in f0.factor():
+            h = self.height_above_floor(l, e)
+            f *= l**(e-h)
+
+        K = O.number_field()
+        return K.order_of_conductor(f)
+
     def twists(self):
         r"""
         Return a list of `k`-isomorphism representatives of all
@@ -2704,7 +2816,7 @@ def special_supersingular_curve(F, q=None, *, endomorphism=False):
         sage: pi = E.frobenius_isogeny()
         sage: pi.codomain() is pi.domain() is E
         True
-        sage: pi * endo == -endo * pi
+        sage: pi * endo == -endo * pi                                                   # needs sage.symbolic
         True
 
     Also try it when `q` is given:
@@ -2733,7 +2845,7 @@ def special_supersingular_curve(F, q=None, *, endomorphism=False):
         sage: pi = E.frobenius_isogeny()
         sage: pi.codomain() is pi.domain() is E
         True
-        sage: pi * endo == -endo * pi
+        sage: pi * endo == -endo * pi                                                   # needs sage.symbolic
         True
 
     .. NOTE::
@@ -3175,13 +3287,13 @@ def EllipticCurve_with_prime_order(N):
 
     def abs_products_under(bound):
         """
-        This function returns an iterator of all numbers with absolute value not
-        exceeding ``bound`` expressable as product of distinct elements in ``S``
-        in ascending order.
+        This function returns an iterator of all numbers with absolute
+        value not exceeding ``bound`` expressible as product of
+        distinct elements in ``S`` in ascending order.
         """
         import heapq
         hq = [(1, 1, -1)]
-        while len(hq):
+        while hq:
             abs_n, n, idx = heapq.heappop(hq)
             yield n
             for nxt in range(idx + 1, len(S)):

sage/schemes/elliptic_curves/ell_local_data.py

@@ -532,7 +532,7 @@ class EllipticCurveLocalData(SageObject):
         """
         return self._reduction_type
 
-    def has_good_reduction(self):
+    def has_good_reduction(self) -> bool:
         r"""
         Return ``True`` if there is good reduction.
 
@@ -553,7 +553,7 @@ class EllipticCurveLocalData(SageObject):
         """
         return self._reduction_type is None
 
-    def has_bad_reduction(self):
+    def has_bad_reduction(self) -> bool:
         r"""
         Return ``True`` if there is bad reduction.
 
@@ -576,7 +576,7 @@ class EllipticCurveLocalData(SageObject):
         """
         return self._reduction_type is not None
 
-    def has_multiplicative_reduction(self):
+    def has_multiplicative_reduction(self) -> bool:
         r"""
         Return ``True`` if there is multiplicative reduction.
 
@@ -601,9 +601,9 @@ class EllipticCurveLocalData(SageObject):
             sage: [(p,E.local_data(p).has_multiplicative_reduction()) for p in [P17a,P17b]]
             [(Fractional ideal (4*a^2 - 2*a + 1), False), (Fractional ideal (2*a + 1), False)]
         """
-        return self._reduction_type in (-1,+1)
+        return self._reduction_type in (-1, 1)
 
-    def has_split_multiplicative_reduction(self):
+    def has_split_multiplicative_reduction(self) -> bool:
         r"""
         Return ``True`` if there is split multiplicative reduction.
 
@@ -626,9 +626,9 @@ class EllipticCurveLocalData(SageObject):
             [(Fractional ideal (4*a^2 - 2*a + 1), False),
              (Fractional ideal (2*a + 1), False)]
         """
-        return self._reduction_type == +1
+        return self._reduction_type == 1
 
-    def has_nonsplit_multiplicative_reduction(self):
+    def has_nonsplit_multiplicative_reduction(self) -> bool:
         r"""
         Return ``True`` if there is non-split multiplicative reduction.
 
@@ -652,7 +652,7 @@ class EllipticCurveLocalData(SageObject):
         """
         return self._reduction_type == -1
 
-    def has_additive_reduction(self):
+    def has_additive_reduction(self) -> bool:
         r"""
         Return ``True`` if there is additive reduction.
 
@@ -679,7 +679,7 @@ class EllipticCurveLocalData(SageObject):
         r"""
         Tate's algorithm for an elliptic curve over a number field.
 
-        Computes both local reduction data at a prime ideal and a
+        This computes both local reduction data at a prime ideal and a
         local minimal model.
 
         The model is not required to be integral on input.  If `P` is