Trac #33865: direct computation of .formal()[1] for elliptic-curve morphisms

Follow-up to #33216: We can compute `.formal()[1]` directly, i.e.,
without going through `.formal()`. This is beneficial as the latter uses
the rational maps, which can be very expensive.

* Composite isogenies have multiplicative `.formal()[1]`.
* Isogenies using Vélu's or Kohel's formulas are normalized, hence
`.formal()[1] == 1`. We only need to account for pre- and post-
isomorphism.
* Weierstrass isomorphisms `(u,r,s,t)` have `.formal()[1] == u`.

Same example as for #33216:
{{{#!sage
E = EllipticCurve(j=GF(431^2)(4))
phi = E.isogeny(2^99*E.gens()[0])
_ = phi.dual()
%timeit phi._EllipticCurveIsogeny__dual = None; phi.dual()
}}}

Sage 9.6:
{{{
537 ms ± 6.75 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
}}}

This branch:
{{{
294 ms ± 1.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
}}}

URL: https://trac.sagemath.org/33865
Reported by: lorenz
Ticket author(s): Lorenz Panny
Reviewer(s): John Cremona

Author: Release Manager

build/pkgs/configure/checksums.ini

@@ -1,4 +1,4 @@
 tarball=configure-VERSION.tar.gz
-sha1=f14a58dd08a2daa9d8613e366de9e4c5f19d1420
-md5=e13c6fdf0bea7b51d864405bd24685ca
-cksum=1164709658
+sha1=6d548fec179a7c4d71f327f409320a06e0d9d35e
+md5=7289e1187b21d5cd30a891838410fcd0
+cksum=1487266202

build/pkgs/configure/package-version.txt

@@ -1 +1 @@
-6b96f8af0e66b45a53984772dc68db8d4b2e3e04
+6b0fd1ca2d493aec6beadae8b15f926c19070098

src/sage/schemes/elliptic_curves/ell_curve_isogeny.py

@@ -2768,6 +2768,39 @@ def x_rational_map(self):
             self.__initialize_rational_maps()
         return self.__X_coord_rational_map
 
+    def scaling_factor(self):
+        r"""
+        Return the Weierstrass scaling factor associated to this
+        elliptic-curve isogeny.
+
+        The scaling factor is the constant `u` (in the base field)
+        such that `\varphi^* \omega_2 = u \omega_1`, where
+        `\varphi: E_1\to E_2` is this isogeny and `\omega_i` are
+        the standard Weierstrass differentials on `E_i` defined by
+        `\mathrm dx/(2y+a_1x+a_3)`.
+
+        EXAMPLES::
+
+            sage: E = EllipticCurve(GF(257^2), [0,1])
+            sage: phi = E.isogeny(E.lift_x(240))
+            sage: phi.degree()
+            43
+            sage: phi.scaling_factor()
+            1
+            sage: phi.dual().scaling_factor()
+            43
+
+        ALGORITHM: The "inner" isogeny is normalized by construction,
+        so we only need to account for the scaling factors of a pre-
+        and post-isomorphism.
+        """
+        sc = Integer(1)
+        if self.__pre_isomorphism is not None:
+            sc *= self.__pre_isomorphism.scaling_factor()
+        if self.__post_isomorphism is not None:
+            sc *= self.__post_isomorphism.scaling_factor()
+        return sc
+
     def kernel_polynomial(self):
         r"""
         Return the kernel polynomial of this isogeny.
@@ -3320,7 +3353,7 @@ def dual(self):
 
         # trac 7096
         # this should take care of the case when the isogeny is not normalized.
-        u = self.formal(prec=2)[1]
+        u = self.scaling_factor()
         isom = WeierstrassIsomorphism(E2pr, (u/F(d), 0, 0, 0))
 
         E2 = isom.codomain()
@@ -3343,7 +3376,7 @@ def dual(self):
         # the composition has the degree as a leading coefficient in
         # the formal expansion.
 
-        phihat_sc = phi_hat.formal(prec=2)[1]
+        phihat_sc = phi_hat.scaling_factor()
 
         sc = u * phihat_sc/F(d)
 

src/sage/schemes/elliptic_curves/hom.py

@@ -266,6 +266,36 @@ def x_rational_map(self):
         raise NotImplementedError('children must implement')
 
 
+    def scaling_factor(self):
+        r"""
+        Return the Weierstrass scaling factor associated to this
+        elliptic-curve morphism.
+
+        The scaling factor is the constant `u` (in the base field)
+        such that `\varphi^* \omega_2 = u \omega_1`, where
+        `\varphi: E_1\to E_2` is this morphism and `\omega_i` are
+        the standard Weierstrass differentials on `E_i` defined by
+        `\mathrm dx/(2y+a_1x+a_3)`.
+
+        Implemented by child classes. For examples, see:
+
+        - :meth:`EllipticCurveIsogeny.scaling_factor`
+        - :meth:`sage.schemes.elliptic_curves.weierstrass_morphism.WeierstrassIsomorphism.scaling_factor`
+        - :meth:`sage.schemes.elliptic_curves.hom_composite.EllipticCurveHom_composite.scaling_factor`
+
+        TESTS::
+
+            sage: from sage.schemes.elliptic_curves.hom import EllipticCurveHom
+            sage: EllipticCurveHom.scaling_factor(None)
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: ...
+        """
+        #TODO: could have a default implementation that simply
+        #      returns .formal()[1], but it seems safer to fail
+        #      visibly to make sure we would notice regressions
+        raise NotImplementedError('children must implement')
+
     def formal(self, prec=20):
         r"""
         Return the formal isogeny associated to this elliptic-curve
@@ -326,11 +356,6 @@ def is_normalized(self):
             `\omega_2` are the invariant differentials on `E_1` and
             `E_2` corresponding to the given equation.
 
-        ALGORITHM:
-
-        The method checks if the leading term of the formal series
-        associated to this isogeny equals `1`.
-
         EXAMPLES::
 
             sage: from sage.schemes.elliptic_curves.weierstrass_morphism import WeierstrassIsomorphism
@@ -393,9 +418,10 @@ def is_normalized(self):
             sage: phi = isom * phi
             sage: phi.is_normalized()
             True
+
+        ALGORITHM: We check if :meth:`scaling_factor` returns `1`.
         """
-        phi_formal = self.formal(prec=5)
-        return phi_formal[1] == 1
+        return self.scaling_factor() == 1
 
 
     def is_separable(self):

src/sage/schemes/elliptic_curves/hom_composite.py

@@ -765,6 +765,36 @@ def formal(self, prec=20):
             res = res(phi.formal(prec=prec))
         return res
 
+    def scaling_factor(self):
+        r"""
+        Return the Weierstrass scaling factor associated to this
+        composite morphism.
+
+        The scaling factor is the constant `u` (in the base field)
+        such that `\varphi^* \omega_2 = u \omega_1`, where
+        `\varphi: E_1\to E_2` is this morphism and `\omega_i` are
+        the standard Weierstrass differentials on `E_i` defined by
+        `\mathrm dx/(2y+a_1x+a_3)`.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.elliptic_curves.hom_composite import EllipticCurveHom_composite
+            sage: from sage.schemes.elliptic_curves.weierstrass_morphism import WeierstrassIsomorphism
+            sage: E = EllipticCurve(GF(65537), [1,2,3,4,5])
+            sage: P = E.lift_x(7321)
+            sage: phi = EllipticCurveHom_composite(E, P)
+            sage: phi = WeierstrassIsomorphism(phi.codomain(), [7,8,9,10]) * phi
+            sage: phi.formal()
+            7*t + 65474*t^2 + 511*t^3 + 61316*t^4 + 20548*t^5 + 45511*t^6 + 37285*t^7 + 48414*t^8 + 9022*t^9 + 24025*t^10 + 35986*t^11 + 55397*t^12 + 25199*t^13 + 18744*t^14 + 46142*t^15 + 9078*t^16 + 18030*t^17 + 47599*t^18 + 12158*t^19 + 50630*t^20 + 56449*t^21 + 43320*t^22 + O(t^23)
+            sage: phi.scaling_factor()
+            7
+
+        ALGORITHM: The scaling factor is multiplicative under
+        composition, so we return the product of the individual
+        scaling factors associated to each factor.
+        """
+        return prod(phi.scaling_factor() for phi in self._phis)
+
     def is_injective(self):
         """
         Determine whether this composite morphism has trivial kernel.

src/sage/schemes/elliptic_curves/weierstrass_morphism.py

@@ -898,3 +898,26 @@ def __neg__(self):
         w = baseWI(-1, 0, -a1, -a3)
         urst = baseWI.__mul__(self, w).tuple()
         return WeierstrassIsomorphism(self._domain, urst, self._codomain)
+
+    def scaling_factor(self):
+        r"""
+        Return the Weierstrass scaling factor associated to this
+        Weierstrass isomorphism.
+
+        The scaling factor is the constant `u` (in the base field)
+        such that `\varphi^* \omega_2 = u \omega_1`, where
+        `\varphi: E_1\to E_2` is this isomorphism and `\omega_i` are
+        the standard Weierstrass differentials on `E_i` defined by
+        `\mathrm dx/(2y+a_1x+a_3)`.
+
+        EXAMPLES::
+
+            sage: E = EllipticCurve(QQbar, [0,1])
+            sage: all(f.scaling_factor() == f.formal()[1] for f in E.automorphisms())
+            True
+
+        ALGORITHM: The scaling factor equals the `u` component of
+        the tuple `(u,r,s,t)` defining the isomorphism.
+        """
+        return self.u
+