Formal groups of elliptic curves¶

AUTHORS:

William Stein: original implementations
David Harvey: improved asymptotics of some methods
Nick Alexander: separation from ell_generic.py, bugfixes and docstrings

class sage.schemes.elliptic_curves.formal_group.EllipticCurveFormalGroup(E)[source]¶

Bases: SageObject

The formal group associated to an elliptic curve.

curve()[source]¶

Return the elliptic curve this formal group is associated to.

EXAMPLES:

Sage

sage: E = EllipticCurve("37a")
sage: F = E.formal_group()
sage: F.curve()
Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field

Python

>>> from sage.all import *
>>> E = EllipticCurve("37a")
>>> F = E.formal_group()
>>> F.curve()
Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field

Sage Live

E = EllipticCurve("37a")
F = E.formal_group()
F.curve()

differential(prec=20)[source]¶

Return the power series \(f(t) = 1 + \cdots\) such that \(f(t) dt\) is the usual invariant differential \(dx/(2y + a_1 x + a_3)\).

INPUT:

prec – nonnegative integer (default: 20), answer will be returned \(O(t^{\mathrm{prec}})\)

OUTPUT: a power series with given precision

Return the formal series

\[f(t) = 1 + a_1 t + ({a_1}^2 + a_2) t^2 + \cdots\]

to precision \(O(t^{prec})\) of page 113 of [Sil2009].

The result is cached, and a cached version is returned if possible.

Warning

The resulting series will have precision prec, but its parent PowerSeriesRing will have default precision 20 (or whatever the default default is).

EXAMPLES:

Sage

sage: EllipticCurve([-1, 1/4]).formal_group().differential(15)
 1 - 2*t^4 + 3/4*t^6 + 6*t^8 - 5*t^10 - 305/16*t^12 + 105/4*t^14 + O(t^15)
sage: EllipticCurve(Integers(53), [-1, 1/4]).formal_group().differential(15)
 1 + 51*t^4 + 14*t^6 + 6*t^8 + 48*t^10 + 24*t^12 + 13*t^14 + O(t^15)

Python

>>> from sage.all import *
>>> EllipticCurve([-Integer(1), Integer(1)/Integer(4)]).formal_group().differential(Integer(15))
 1 - 2*t^4 + 3/4*t^6 + 6*t^8 - 5*t^10 - 305/16*t^12 + 105/4*t^14 + O(t^15)
>>> EllipticCurve(Integers(Integer(53)), [-Integer(1), Integer(1)/Integer(4)]).formal_group().differential(Integer(15))
 1 + 51*t^4 + 14*t^6 + 6*t^8 + 48*t^10 + 24*t^12 + 13*t^14 + O(t^15)

Sage Live

EllipticCurve([-1, 1/4]).formal_group().differential(15)
EllipticCurve(Integers(53), [-1, 1/4]).formal_group().differential(15)

AUTHORS:

David Harvey (2006-09-10): factored out of log

group_law(prec=10)[source]¶

Return the formal group law.

INPUT:

prec – integer (default: 10)

OUTPUT: a power series with given precision in \(R[[t_1,t_2]]\), where the curve is defined over \(R\).

Return the formal power series

\[F(t_1, t_2) = t_1 + t_2 - a_1 t_1 t_2 - \cdots\]

to precision \(O(t_1,t_2)^{prec}\) of page 115 of [Sil2009].

The result is cached, and a cached version is returned if possible.

AUTHORS:

Nick Alexander: minor fixes, docstring
Francis Clarke (2012-08): modified to use two-variable power series ring

EXAMPLES:

Sage

sage: e = EllipticCurve([1, 2])
sage: e.formal_group().group_law(6)
t1 + t2 - 2*t1^4*t2 - 4*t1^3*t2^2 - 4*t1^2*t2^3 - 2*t1*t2^4 + O(t1, t2)^6

sage: e = EllipticCurve('14a1')
sage: ehat = e.formal()
sage: ehat.group_law(3)
t1 + t2 - t1*t2 + O(t1, t2)^3
sage: ehat.group_law(5)
t1 + t2 - t1*t2 - 2*t1^3*t2 - 3*t1^2*t2^2 - 2*t1*t2^3 + O(t1, t2)^5

sage: e = EllipticCurve(GF(7), [3, 4])
sage: ehat = e.formal()
sage: ehat.group_law(3)
t1 + t2 + O(t1, t2)^3
sage: F = ehat.group_law(7); F
t1 + t2 + t1^4*t2 + 2*t1^3*t2^2 + 2*t1^2*t2^3 + t1*t2^4 + O(t1, t2)^7

Python

>>> from sage.all import *
>>> e = EllipticCurve([Integer(1), Integer(2)])
>>> e.formal_group().group_law(Integer(6))
t1 + t2 - 2*t1^4*t2 - 4*t1^3*t2^2 - 4*t1^2*t2^3 - 2*t1*t2^4 + O(t1, t2)^6

>>> e = EllipticCurve('14a1')
>>> ehat = e.formal()
>>> ehat.group_law(Integer(3))
t1 + t2 - t1*t2 + O(t1, t2)^3
>>> ehat.group_law(Integer(5))
t1 + t2 - t1*t2 - 2*t1^3*t2 - 3*t1^2*t2^2 - 2*t1*t2^3 + O(t1, t2)^5

>>> e = EllipticCurve(GF(Integer(7)), [Integer(3), Integer(4)])
>>> ehat = e.formal()
>>> ehat.group_law(Integer(3))
t1 + t2 + O(t1, t2)^3
>>> F = ehat.group_law(Integer(7)); F
t1 + t2 + t1^4*t2 + 2*t1^3*t2^2 + 2*t1^2*t2^3 + t1*t2^4 + O(t1, t2)^7

Sage Live

e = EllipticCurve([1, 2])
e.formal_group().group_law(6)
e = EllipticCurve('14a1')
ehat = e.formal()
ehat.group_law(3)
ehat.group_law(5)
e = EllipticCurve(GF(7), [3, 4])
ehat = e.formal()
ehat.group_law(3)
F = ehat.group_law(7); F

inverse(prec=20)[source]¶

Return the formal group inverse law \(i(t)\), which satisfies \(F(t, i(t)) = 0\).

INPUT:

prec – integer (default: 20)

OUTPUT: a power series with given precision

Return the formal power series

\[i(t) = - t + a_1 t^2 + \cdots\]

to precision \(O(t^{prec})\) of page 114 of [Sil2009].

The result is cached, and a cached version is returned if possible.

Warning

The resulting power series will have precision prec, but its parent PowerSeriesRing will have default precision 20 (or whatever the default default is).

EXAMPLES:

Sage

sage: P.<a1, a2, a3, a4, a6> = ZZ[]
sage: E = EllipticCurve(list(P.gens()))
sage: i = E.formal_group().inverse(6); i
-t - a1*t^2 - a1^2*t^3 + (-a1^3 - a3)*t^4 + (-a1^4 - 3*a1*a3)*t^5 + O(t^6)
sage: F = E.formal_group().group_law(6)
sage: F(i.parent().gen(), i)
O(t^6)

Python

>>> from sage.all import *
>>> P = ZZ['a1, a2, a3, a4, a6']; (a1, a2, a3, a4, a6,) = P._first_ngens(5)
>>> E = EllipticCurve(list(P.gens()))
>>> i = E.formal_group().inverse(Integer(6)); i
-t - a1*t^2 - a1^2*t^3 + (-a1^3 - a3)*t^4 + (-a1^4 - 3*a1*a3)*t^5 + O(t^6)
>>> F = E.formal_group().group_law(Integer(6))
>>> F(i.parent().gen(), i)
O(t^6)

Sage Live

P.<a1, a2, a3, a4, a6> = ZZ[]
E = EllipticCurve(list(P.gens()))
i = E.formal_group().inverse(6); i
F = E.formal_group().group_law(6)
F(i.parent().gen(), i)

log(prec=20)[source]¶

Return the power series \(f(t) = t + \cdots\) which is an isomorphism to the additive formal group.

Generally this only makes sense in characteristic zero, although the terms before \(t^p\) may work in characteristic \(p\).

INPUT:

prec – nonnegative integer (default: 20)

OUTPUT: a power series with given precision

EXAMPLES:

Sage

sage: EllipticCurve([-1, 1/4]).formal_group().log(15)
 t - 2/5*t^5 + 3/28*t^7 + 2/3*t^9 - 5/11*t^11 - 305/208*t^13 + O(t^15)

Python

>>> from sage.all import *
>>> EllipticCurve([-Integer(1), Integer(1)/Integer(4)]).formal_group().log(Integer(15))
 t - 2/5*t^5 + 3/28*t^7 + 2/3*t^9 - 5/11*t^11 - 305/208*t^13 + O(t^15)

Sage Live

EllipticCurve([-1, 1/4]).formal_group().log(15)

AUTHORS:

David Harvey (2006-09-10): rewrote to use differential

mult_by_n(n, prec=10)[source]¶

Return the formal ‘multiplication by n’ endomorphism \([n]\).

INPUT:

prec – integer (default: 10)

OUTPUT: a power series with given precision

Return the formal power series

\[[n](t) = n t + \cdots\]

to precision \(O(t^{prec})\) of Proposition 2.3 of [Sil2009].

Warning

The resulting power series will have precision prec, but its parent PowerSeriesRing will have default precision 20 (or whatever the default default is).

AUTHORS:

Nick Alexander: minor fixes, docstring
David Harvey (2007-03): faster algorithm for char 0 field case
Hamish Ivey-Law (2009-06): double-and-add algorithm for non char 0 field case.
Tom Boothby (2009-06): slight improvement to double-and-add
Francis Clarke (2012-08): adjustments and simplifications using group_law code as modified to yield a two-variable power series.

EXAMPLES:

Sage

sage: e = EllipticCurve([1, 2, 3, 4, 6])
sage: e.formal_group().mult_by_n(0, 5)
 O(t^5)
sage: e.formal_group().mult_by_n(1, 5)
 t + O(t^5)

Python

>>> from sage.all import *
>>> e = EllipticCurve([Integer(1), Integer(2), Integer(3), Integer(4), Integer(6)])
>>> e.formal_group().mult_by_n(Integer(0), Integer(5))
 O(t^5)
>>> e.formal_group().mult_by_n(Integer(1), Integer(5))
 t + O(t^5)

Sage Live

e = EllipticCurve([1, 2, 3, 4, 6])
e.formal_group().mult_by_n(0, 5)
e.formal_group().mult_by_n(1, 5)

We verify an identity of low degree:

Sage

sage: none = e.formal_group().mult_by_n(-1, 5)
sage: two = e.formal_group().mult_by_n(2, 5)
sage: ntwo = e.formal_group().mult_by_n(-2, 5)
sage: ntwo - none(two)
 O(t^5)
sage: ntwo - two(none)
 O(t^5)

Python

>>> from sage.all import *
>>> none = e.formal_group().mult_by_n(-Integer(1), Integer(5))
>>> two = e.formal_group().mult_by_n(Integer(2), Integer(5))
>>> ntwo = e.formal_group().mult_by_n(-Integer(2), Integer(5))
>>> ntwo - none(two)
 O(t^5)
>>> ntwo - two(none)
 O(t^5)

Sage Live

none = e.formal_group().mult_by_n(-1, 5)
two = e.formal_group().mult_by_n(2, 5)
ntwo = e.formal_group().mult_by_n(-2, 5)
ntwo - none(two)
ntwo - two(none)

It’s quite fast:

Sage

sage: E = EllipticCurve("37a"); F = E.formal_group()
sage: F.mult_by_n(100, 20)
100*t - 49999950*t^4 + 3999999960*t^5 + 14285614285800*t^7 - 2999989920000150*t^8 + 133333325333333400*t^9 - 3571378571674999800*t^10 + 1402585362624965454000*t^11 - 146666057066712847999500*t^12 + 5336978000014213190385000*t^13 - 519472790950932256570002000*t^14 + 93851927683683567270392002800*t^15 - 6673787211563812368630730325175*t^16 + 320129060335050875009191524993000*t^17 - 45670288869783478472872833214986000*t^18 + 5302464956134111125466184947310391600*t^19 + O(t^20)

Python

>>> from sage.all import *
>>> E = EllipticCurve("37a"); F = E.formal_group()
>>> F.mult_by_n(Integer(100), Integer(20))
100*t - 49999950*t^4 + 3999999960*t^5 + 14285614285800*t^7 - 2999989920000150*t^8 + 133333325333333400*t^9 - 3571378571674999800*t^10 + 1402585362624965454000*t^11 - 146666057066712847999500*t^12 + 5336978000014213190385000*t^13 - 519472790950932256570002000*t^14 + 93851927683683567270392002800*t^15 - 6673787211563812368630730325175*t^16 + 320129060335050875009191524993000*t^17 - 45670288869783478472872833214986000*t^18 + 5302464956134111125466184947310391600*t^19 + O(t^20)

Sage Live

E = EllipticCurve("37a"); F = E.formal_group()
F.mult_by_n(100, 20)

sigma(prec=10)[source]¶

Return the Weierstrass sigma function as a formal power series solution to the differential equation

\[\frac{d^2 \log \sigma}{dz^2} = - \wp(z)\]

with initial conditions \(\sigma(O)=0\) and \(\sigma'(O)=1\), expressed in the variable \(t=\log_E(z)\) of the formal group.

INPUT:

prec – integer (default: 10)

OUTPUT: a power series with given precision

Other solutions can be obtained by multiplication with a function of the form \(\exp(c z^2)\). If the curve has good ordinary reduction at a prime \(p\) then there is a canonical choice of \(c\) that produces the canonical \(p\)-adic sigma function. To obtain that, please use E.padic_sigma(p) instead. See padic_sigma()

EXAMPLES:

Sage

sage: E = EllipticCurve('14a')
sage: F = E.formal_group()
sage: F.sigma(5)
t + 1/2*t^2 + 1/3*t^3 + 3/4*t^4 + O(t^5)

Python

>>> from sage.all import *
>>> E = EllipticCurve('14a')
>>> F = E.formal_group()
>>> F.sigma(Integer(5))
t + 1/2*t^2 + 1/3*t^3 + 3/4*t^4 + O(t^5)

Sage Live

E = EllipticCurve('14a')
F = E.formal_group()
F.sigma(5)

w(prec=20)[source]¶

Return the formal group power series \(w\).

INPUT:

prec – integer (default: 20)

OUTPUT: a power series with given precision

Return the formal power series

\[w(t) = t^3 + a_1 t^4 + (a_2 + a_1^2) t^5 + \cdots\]

to precision \(O(t^{prec})\) of Proposition IV.1.1 of [Sil2009]. This is the formal expansion of \(w = -1/y\) about the formal parameter \(t = -x/y\) at \(\infty\).

The result is cached, and a cached version is returned if possible.

Warning

The resulting power series will have precision prec, but its parent PowerSeriesRing will have default precision 20 (or whatever the default default is).

ALGORITHM: Uses Newton’s method to solve the elliptic curve equation at the origin. Complexity is roughly \(O(M(n))\) where \(n\) is the precision and \(M(n)\) is the time required to multiply polynomials of length \(n\) over the coefficient ring of \(E\).

AUTHORS:

David Harvey (2006-09-09): modified to use Newton’s method instead of a recurrence formula.

EXAMPLES:

Sage

sage: e = EllipticCurve([0, 0, 1, -1, 0])
sage: e.formal_group().w(10)
 t^3 + t^6 - t^7 + 2*t^9 + O(t^10)

Python

>>> from sage.all import *
>>> e = EllipticCurve([Integer(0), Integer(0), Integer(1), -Integer(1), Integer(0)])
>>> e.formal_group().w(Integer(10))
 t^3 + t^6 - t^7 + 2*t^9 + O(t^10)

Sage Live

e = EllipticCurve([0, 0, 1, -1, 0])
e.formal_group().w(10)

Check that caching works:

Sage

sage: e = EllipticCurve([3, 2, -4, -2, 5])
sage: e.formal_group().w(20)
 t^3 + 3*t^4 + 11*t^5 + 35*t^6 + 101*t^7 + 237*t^8 + 312*t^9 - 949*t^10 - 10389*t^11 - 57087*t^12 - 244092*t^13 - 865333*t^14 - 2455206*t^15 - 4366196*t^16 + 6136610*t^17 + 109938783*t^18 + 688672497*t^19 + O(t^20)
sage: e.formal_group().w(7)
 t^3 + 3*t^4 + 11*t^5 + 35*t^6 + O(t^7)
sage: e.formal_group().w(35)
 t^3 + 3*t^4 + 11*t^5 + 35*t^6 + 101*t^7 + 237*t^8 + 312*t^9 - 949*t^10 - 10389*t^11 - 57087*t^12 - 244092*t^13 - 865333*t^14 - 2455206*t^15 - 4366196*t^16 + 6136610*t^17 + 109938783*t^18 + 688672497*t^19 + 3219525807*t^20 + 12337076504*t^21 + 38106669615*t^22 + 79452618700*t^23 - 33430470002*t^24 - 1522228110356*t^25 - 10561222329021*t^26 - 52449326572178*t^27 - 211701726058446*t^28 - 693522772940043*t^29 - 1613471639599050*t^30 - 421817906421378*t^31 + 23651687753515182*t^32 + 181817896829144595*t^33 + 950887648021211163*t^34 + O(t^35)

Python

>>> from sage.all import *
>>> e = EllipticCurve([Integer(3), Integer(2), -Integer(4), -Integer(2), Integer(5)])
>>> e.formal_group().w(Integer(20))
 t^3 + 3*t^4 + 11*t^5 + 35*t^6 + 101*t^7 + 237*t^8 + 312*t^9 - 949*t^10 - 10389*t^11 - 57087*t^12 - 244092*t^13 - 865333*t^14 - 2455206*t^15 - 4366196*t^16 + 6136610*t^17 + 109938783*t^18 + 688672497*t^19 + O(t^20)
>>> e.formal_group().w(Integer(7))
 t^3 + 3*t^4 + 11*t^5 + 35*t^6 + O(t^7)
>>> e.formal_group().w(Integer(35))
 t^3 + 3*t^4 + 11*t^5 + 35*t^6 + 101*t^7 + 237*t^8 + 312*t^9 - 949*t^10 - 10389*t^11 - 57087*t^12 - 244092*t^13 - 865333*t^14 - 2455206*t^15 - 4366196*t^16 + 6136610*t^17 + 109938783*t^18 + 688672497*t^19 + 3219525807*t^20 + 12337076504*t^21 + 38106669615*t^22 + 79452618700*t^23 - 33430470002*t^24 - 1522228110356*t^25 - 10561222329021*t^26 - 52449326572178*t^27 - 211701726058446*t^28 - 693522772940043*t^29 - 1613471639599050*t^30 - 421817906421378*t^31 + 23651687753515182*t^32 + 181817896829144595*t^33 + 950887648021211163*t^34 + O(t^35)

Sage Live

e = EllipticCurve([3, 2, -4, -2, 5])
e.formal_group().w(20)
e.formal_group().w(7)
e.formal_group().w(35)

x(prec=20)[source]¶

Return the formal series \(x(t) = t/w(t)\) in terms of the local parameter \(t = -x/y\) at infinity.

INPUT:

prec – integer (default: 20)

OUTPUT: a Laurent series with given precision

Return the formal series

\[x(t) = t^{-2} - a_1 t^{-1} - a_2 - a_3 t - \cdots\]

to precision \(O(t^{prec})\) of page 113 of [Sil2009].

Warning

The resulting series will have precision prec, but its parent PowerSeriesRing will have default precision 20 (or whatever the default default is).

EXAMPLES:

Sage

sage: EllipticCurve([0, 0, 1, -1, 0]).formal_group().x(10)
 t^-2 - t + t^2 - t^4 + 2*t^5 - t^6 - 2*t^7 + 6*t^8 - 6*t^9 + O(t^10)

Python

>>> from sage.all import *
>>> EllipticCurve([Integer(0), Integer(0), Integer(1), -Integer(1), Integer(0)]).formal_group().x(Integer(10))
 t^-2 - t + t^2 - t^4 + 2*t^5 - t^6 - 2*t^7 + 6*t^8 - 6*t^9 + O(t^10)

Sage Live

EllipticCurve([0, 0, 1, -1, 0]).formal_group().x(10)

y(prec=20)[source]¶

Return the formal series \(y(t) = -1/w(t)\) in terms of the local parameter \(t = -x/y\) at infinity.

INPUT:

prec – integer (default: 20)

OUTPUT: a Laurent series with given precision

Return the formal series

\[y(t) = - t^{-3} + a_1 t^{-2} + a_2 t + a_3 + \cdots\]

to precision \(O(t^{prec})\) of page 113 of [Sil2009].

The result is cached, and a cached version is returned if possible.

Warning

The resulting series will have precision prec, but its parent PowerSeriesRing will have default precision 20 (or whatever the default default is).

EXAMPLES:

Sage

sage: EllipticCurve([0, 0, 1, -1, 0]).formal_group().y(10)
 -t^-3 + 1 - t + t^3 - 2*t^4 + t^5 + 2*t^6 - 6*t^7 + 6*t^8 + 3*t^9 + O(t^10)

Python

>>> from sage.all import *
>>> EllipticCurve([Integer(0), Integer(0), Integer(1), -Integer(1), Integer(0)]).formal_group().y(Integer(10))
 -t^-3 + 1 - t + t^3 - 2*t^4 + t^5 + 2*t^6 - 6*t^7 + 6*t^8 + 3*t^9 + O(t^10)

Sage Live

EllipticCurve([0, 0, 1, -1, 0]).formal_group().y(10)