|
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
The functions in this section are only defined for elliptic curves
over Q. Some of them require the curve to have integral
coefficients; such a curve may be obtained by using IntegralModel
or, more usefully, MinimalModel.
Parts of the section on elliptic curves over number fields,
in particular the functionality for Selmer groups, may also
be of interest for curves over Q.
Subsections
The conductor of the elliptic curve E defined over Q.
Given an elliptic curve E defined over Q, return the sequence of
primes dividing the minimal discriminant of E.
These are the primes at which the minimal model for E has bad reduction;
note that there may be other primes dividing the discriminant of the given
model of E.
Given an elliptic curve E defined over Q and a prime number p,
this function returns the local Tamagawa number of E at p, which
is the index in E(Qp) of the subgroup E0(Qp) of points with
nonsingular reduction modulo p. For any prime p that is of good
reduction for E, this function returns 1.
Given an elliptic curve E defined over Q, this function returns
the sequence of Tamagawa numbers at each of the bad primes of E, as
defined above.
Given an elliptic curve E defined over Q and a prime number p,
this function returns the local information
at the prime p as a tuple of the form
<P, vpd, fp, cp, K, split>, consisting of p, its multiplicity
in the discriminant, its multiplicity in the conductor, the Tamagawa
number at p, the Kodaira symbol, and finally a boolean which is false iff
the curve has nonsplit multiplicative reduction. The second object returned
is a local minimal model for E at p.
Given an elliptic curve E this function returns a sequence of
tuples of the kind described above, for the primes dividing the
discriminant of E.
Returns a string describing the reduction type of E at p; the
possibilities are "Good", "Additive", "Split multiplicative"
or "Nonsplit multiplicative".
These correspond to the type of singularity (if any) on the reduced curve.
This function is necessary as the Kodaira symbols (see below) do not
distinguish between split and unsplit multiplicative reduction.
Given a rational elliptic curve E and a prime p, this function
provides an efficient way to directly compute the trace of Frobenius
(without having to create GF(p), coercing E into this field, etc).
The argument p is not checked to be prime.
The sequence of traces of Frobenius ap(E), of the reduction mod p of E,
for all primes p up to B. This function is very carefully optimised.
> E := EllipticCurve([ 0, 1, 1, 3, 5 ]);
> T := TracesOfFrobenius(E, 100); T;
[ 0, 1, -3, -2, -5, 1, -3, -1, 5, 6, 8, -1, -6, 7, -2, 1, 14, -1, -12,
16, -16, -7, 6, 12, 2 ]
> time T := TracesOfFrobenius(E, 10^6);
Time: 5.600
Kodaira symbols have their own type SymKod. Apart from the
two functions that determine symbols for elliptic curves, there is
a special creation function and a comparison operator to test
Kodaira symbols.
Given an elliptic curve E defined over Q and a prime number p,
this function returns the reduction type
of E modulo p in the form of a Kodaira symbol.
Given an elliptic curve E defined over Q,
this function returns the reduction types
of E modulo the bad primes in the form of a sequence of
Kodaira symbols.
Given a string s, return the Kodaira symbol it represents.
The values of s that are allowed are:
"I0", "I1", "I2", ..., "In", "II",
"III", "IV", and "I0*", "I1*",
"I2*", ..., "In*", "II*", "III*", "IV*".
The dots stand for "Ik" with k a positive integer.
The `generic' type "In" allows the matching of
types "In" for any integer n>0 (and similarly for "In*").
Given two Kodaira symbols h and k, this function returns true if
and only if either both are identical, or one is generic (of the form
"In", or "In*") and the other is specific of the same type:
"In" will compare equal with any of "I1", "I2",
"I3", etc., and "In*" will compare equal with any of
"I1*", "I2*", "I3*", etc.
Note however that "In" and "I3" are different from the
point of view of set creation.
The logical negation of eq.
We search for curves with a particular reduction type `I0*' in
a family of curves.
> S := [ ];
> for n := 2 to 100 do
> E := EllipticCurve([n, 0]);
> for p in BadPrimes(E) do
> if KodairaSymbol(E, p) eq KodairaSymbol("I0*") then
> Append(~S, <p, n>);
> end if;
> end for;
> end for;
> S;
[ <3, 9>, <3, 18>, <5, 25>, <3, 36>, <3, 45>, <7, 49>, <5, 50>,
<3, 63>, <3, 72>, <5, 75>, <3, 90>, <7, 98>, <3, 99>, <5, 100> ]
Given an elliptic curve E over the rationals (or a number field), the
function determines whether the curve has complex multiplication or not and,
if so, also returns the discriminant of the CM quadratic order.
The algorithm uses fairly straightforward analytic methods,
which are not suited to very high degree j-invariants with CM
by orders with discriminants more than a few thousand.
The set of curves Q-isogenous to a rational elliptic curve E.
The method used is to proceed prime-by-prime. Mazur's Theorem restricts
the possibilities to a short list, and j-invariant considerations leave
only p-isogenies for p = 2, 3, 5, 7, 13 to be considered. For p = 2
or 3, the method proceeds by finding the rational roots of the p-th
division polynomial for the curve E. From these roots, one can then
recover the isogenous curves. The question as to whether or not there
is a p-isogeny is entirely a
function of the j-invariant of the curve, and this idea is used for
p = 5, 7, 13. In these cases the algorithm first takes a minimal twist
of the elliptic curve, and then finds rational roots of the polynomial
of degree (p + 1) that comes from a fibre of X0(p). The isogenous curves
of the minimal twist corresponding to these roots are then computed,
and then these curves are twisted back to get the isogenous curves of E.
In all cases, if the conductor is squarefree, some small values of the
Frobenius traces are checked mod p to ensure the feasibility of a
p-isogeny. Other similar ideas involving checking congruences are
also used to try to eliminate the possibility of a p-isogeny without
finding roots. Tree-based methods are used to extend the isogeny tree
from (say) 2-isogenies to 4-isogenies to 8-isogenies, etc. The integer
returned as a second argument corresponds to the largest degree of a
cyclic isogeny between two curves in the isogeny class. The ordering
of the list of curves returned is well-defined; the first curve is
always the curve of minimal Faltings height, and the heights generically
increase upon going down the list. However, when there are isogenies
of two different prime degrees, a different ordering is used. In the
case where there is a 4-isogeny (or a certain type of 9-isogeny),
there is an arbitrary choice made on the bottom tree leaves in order
to make the ordering consistent.
Precision: RngIntElt Default:
Compute the Faltings height of a rational elliptic curve.
This is given by -(1/2)log( Vol)(E) where ( Vol)(E)
is the volume of the fundamental parallelogram.
First we compute isogenous curves using DivisionPolynomial;
in this special case we obtain the entire isogeny class by
considering only 3-isogenies directly from E.
> E:=EllipticCurve([1,-1,1,1,-1]);
> F:=Factorization(DivisionPolynomial(E,3));
> I:=IsogenyFromKernel(E,F[1][1]); I;
Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 29*x - 53 over Rational
Field
> I:=IsogenyFromKernel(E,F[2][1]); I;
Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 14*x + 29 over Rational
Field
Alternatively, we can get the IsogenousCurves directly.
Note that IsogenyFromKernel also returns the map between
the isogenous curves as a second argument.
> IsogenousCurves(E);
[
Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 + x - 1 over Rational
Field,
Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 29*x - 53 over
Rational Field,
Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 14*x + 29 over
Rational Field
]
9
The Mordell--Weil group of an elliptic curve E over the rationals is the
finitely generated group of points of E with rational coordinates.
As is customary in cases of this kind, the functions return an abstract
group together with a map from that group to the curve.
Like all group functions on elliptic curves, these intrinsics really apply
to a particular point set; the curve is identified with its base point
set for the purposes of these functions. To aid exposition only the
versions that take the curves are shown but an appropriate point set
(over Q) may be used instead.
Note: Because there is no guaranteed method of calculating the rank,
the rank computed in the functions below will be a lower bound but may not
be known to actually be the rank. In such cases a warning message
will be printed the first time the rank of a particular curve is computed.
The use of RankBounds instead of Rank is recommended for
this reason.
DescentInformation(E: parameters) : CrvEll -> [RngIntElt], [PtEll], [Tup]
RankOnly: BoolElt Default: false
ShaInfo: BoolElt Default: false
This is a special function which uses all relevant Magma machinery
to obtain as much information as possible about the Mordell-Weil group
and the Tate-Shafarevich group of the given elliptic curve E over Q.
The tools used include 2-descent, 4-descent, the Cassels-Tate pairing,
3-descent, and also analytic routines when the conductor of E is not
too large. The information is progressively refined as the various tools
are applied, in some appropriate order, and a summary is printed at each
stage. At the end, the collected information is returned in three sequences.
The first sequence returned contains lower and upper bounds on the Mordell-Weil
rank of E(Q), and the second is the sequence of independent generators
of the Mordell-Weil group (including torsion) that have been found. The
third sequence returned contains the information obtained about the
Tate-Shafarevich group Sha(E): letting rn denote the largest integer
such that Z/nZ is contained in Sha(E), the tuple <n, [l,u]>
would indicate that the computations prove l ≤rn ≤u.
When RankOnly is set to true, the routine will terminate as soon as
the Mordell-Weil rank has been determined, and will not attempt to find
Mordell-Weil generators or determine the structure of Sha(E). When
ShaInfo is set to true, the routine will probe the structure of
Sha(E) by all available means; otherwise (by default) it will terminate
as soon as the rank and generators of the Mordell-Weil group have been found.
Rank(E: parameters) : CrvEll -> RngIntElt
MordellWeilRank(H: parameters) : SetPtEll -> RngIntElt
MordellWeilRank(E: parameters) : CrvEll -> RngIntElt
Bound: RngIntElt Default: 150
Given an elliptic curve E defined over Q, this function returns the
rank of the Mordell--Weil group of E.
The general procedure to calculate the rank involves searching for
rational points on certain homogeneous spaces represented by equations
of the form y^2 = a*x^4 + b*x^3 + c*x^2 + d*x + e.
The parameter Bound is a bound on the numerator and denominator
of x that will be used when searching for such points.
RankBounds(E: parameters) : CrvEll -> RngIntElt, RngIntElt
MordellWeilRankBounds(H: parameters) : SetPtEll -> RngIntElt, RngIntElt
MordellWeilRankBounds(E: parameters) : CrvEll -> RngIntElt, RngIntElt
Bound: RngIntElt Default: 150
Given an elliptic curve E defined over Q, this computes and returns
lower and upper bounds on the rank of the Mordell--Weil group of E.
The parameter Bound is as described in the intrinsic Rank.
This function will not generate the usual warning message if the upper and
lower bounds are not equal.
AbelianGroup(E: parameters) : CrvEll -> GrpAb, Map
MordellWeilGroup(H: parameters) : SetPtEll -> GrpAb, Map
MordellWeilGroup(E: parameters) : CrvEll -> GrpAb, Map
Bound: RngIntElt Default: 150
HeightBound: RngIntElt Default: 15
The Mordell--Weil group of an elliptic curve E defined over Q.
The function returns two values: an abelian group A and a map m
from A to E. The map m provides an isomorphism between the
abstract group A and the Mordell--Weil group.
The parameter Bound is used during the rank computation part of
the algorithm, and has the same meaning as described in the intrinsic
Rank, above.
The group computation involves searching for points on E up to a certain
(naive) height. The parameter HeightBound is used to limit this
search as the rigorous bounds may not be feasible. When the HeightBound
is less than the rigorous bound, a warning message is printed. In this
situation, the user may wish to also use Saturation (see below).
OmitPrimes: [ RngIntElt ] Default: []
Check: BoolElt Default: true
Given a sequence of points on an elliptic curve E over the rationals,
and an integer n,
this function returns a sequence of points generating a subgroup
of E(Q) which contains the given points and which is p-saturated
for all primes p up to n. (A subgroup S is p-saturated in a
group G if there is no intermediate subgroup H for which the
index [H:S] is finite and divisible by p.)
If OmitPrimes is set to be a sequence of primes, then the group
is not checked to be p-saturated for those primes. If Check
is set to false, the given sequence of points are assumed to
be independent modulo torsion (equivalently, their height pairing
is assumed to be non-degenerate).
TorsionSubgroup(E) : CrvEll -> GrpAb, Map
Given an elliptic curve E defined over Q, this function
returns an abelian group A isomorphic to the torsion subgroup of
the Mordell--Weil group, and a map from this abstract group A to the
elliptic curve providing the isomorphism. By a theorem of Mazur, A
is either Ck (for k in {1..10} or 12) or
C2 x C2k (for k in {1..4}). If there are two generators
then the first generator returned in this case will have order 2.
Generators(E) : CrvEll -> [ PtEll ]
Given an elliptic curve E defined over Q,
this function returns generators for the Mordell--Weil group of E,
in the form of a sequence of points of E. The i-th element of
the sequence corresponds to the i-th generator of the group as
returned by the function MordellWeilGroup; the generators of
the torsion subgroup will come first (in the order described in
TorsionSubgroup), followed by the points of infinite order.
NumberOfGenerators(E) : CrvEll -> RngIntElt
Ngens(H) : SetPtEll -> RngIntElt
Ngens(E) : CrvEll -> RngIntElt
The number of generators of the group of rational points of the elliptic curve
E;
this is simply the length of the sequence returned by
Generators(E).
> E := EllipticCurve([73, 0]);
> E;
Elliptic Curve defined by y^2 = x^3 + 73*x over Rational Field
> Factorization(Integers() ! Discriminant(E));
[ <2, 6>, <73, 3> ]
> BadPrimes(E);
[ 2, 73 ]
> LocalInformation(E);
[ <2, 6, 6, 1, II, true>, <73, 3, 2, 2, III, true> ]
> G, m := MordellWeilGroup(E);
> G;
Abelian Group isomorphic to Z/2 + Z + Z
Defined on 3 generators
Relations:
2*G.1 = 0
> Generators(E);
[ (0 : 0 : 1), (36 : -222 : 1), (4/9 : 154/27 : 1) ]
> 2*m(G.1);
(0 : 1 : 0)
Here is a curve with moderately large rank; we do not attempt to compute
the full group since that would be quite time-consuming.
> E := EllipticCurve([0, 0, 0, -9217, 300985]);
> T, h := TorsionSubgroup(E);
> T;
Abelian Group of order 1
> time RankBounds(E);
7 7
Time: 0.070
This curve was well-behaved in that the computed lower and upper bounds
on the rank are the same, and so we know that we have computed the rank
exactly. Here is a curve where that is not the case:
> E := EllipticCurve([0, -1, 0, -140, -587]);
> time G, h := MordellWeilGroup(E);
Warning: rank computed (2) is only a lower bound
(It may still be correct, though)
Time: 0.250
> RankBounds(E);
2 3
The difficulty here is that the Tate--Shafarevich group of E is not
trivial, and this blocks the 2-descent process used to compute the
rank.
We can compute the AnalyticRank of the curve to be 2, but this
is only conjecturally equal to the rank.
In cases like this, higher level descents may provide a more
definitive answer;
the machinery for two- and four-descents described in the next two
sections can be used to confirm that the rank is indeed 2.
In any case, we can certainly get the group with rank
equal to the lower bound.
> G;
Abelian Group isomorphic to Z + Z
Defined on 2 generators (free)
> S := Generators(E);
> S;
[ (-6 : -1 : 1), (-7 : 1 : 1) ]
> [ Order(P) : P in S ];
[ 0, 0 ]
> h(G.1) eq S[1];
true
> h(G.2) eq S[2];
true
> h(2*G.1 + 3*G.2);
(-359741403/57729604 : 940675899883/438629531192 : 1)
> 2*S[1] + 3*S[2];
(-359741403/57729604 : 940675899883/438629531192 : 1)
As mentioned above, the rank of this curve is actually 2, so we have
computed generators for the full group of E.
These functions require that the corresponding elliptic curve
has integral coefficients.
WeilHeight(P) : PtEll -> FldPrElt
Given a point P=(a/b, c/d, 1) on an elliptic curve E defined over Q
with integral coefficients,
this function returns the naive (or Weil) height h(P)
whose definition is
h(P) = log max {|a|, |b|}.
CanonicalHeight(P: parameters) : PtEll -> NFldComElt
Precision: RngIntElt Default:
Given a point P on an elliptic curve E defined over Q
with integral coefficients,
this function returns the canonical height of P.
One definition of
the canonical height is the limit as n goes to infinity of h(2^n*P) / 4^n,
although this is of limited computational use.
A more useful computational definition is as the sum of local heights:
the canonical height of P = sum(h_p(P)),
where the sum ranges
over each prime p and the so-called `infinite prime'. Each of these
local heights can be evaluated fairly simply, and in fact most of them
are 0. The function always uses a minimal model for the elliptic
curve internally, as otherwise the local height computation could fail.
The computation at the infinite prime uses a slight improvement over the
σ-function methods given in Cohen, with the implementation being
based on an AGM-trick due to Mestre.
Precision: RngIntElt Default:
Given a point P on an elliptic curve E defined over Q
with integral coefficients,
this function returns
the local height of P at p as described in Height above.
The integer p must be either a prime number or 0; in
the latter case the height at the infinite prime is returned.
Precision: RngIntElt Default:
Given two points P, Q on the same elliptic curve defined over
Q with integral coefficients, this function returns the height pairing
of P and Q, which is defined by h(P, Q) = (h(P + Q) - h(P) - h(Q))/2, where h denotes the canonical height.
HeightPairingMatrix(E: parameters) : CrvEll -> AlgMat
Precision: RngIntElt Default:
Given a sequence of points on an elliptic curve
defined over Q with integral coefficients,
this function returns the height pairing matrix.
If an elliptic curve is passed to it, the corresponding matrix
for the Mordell--Weil generators is returned.
Precision: RngIntElt Default:
Given a sequence of points S on an elliptic curve E over Q,
this function returns the determinant of the N'eron-Tate height
pairing matrix of the sequence.
Precision: RngIntElt Default:
Given
an elliptic curve E
this function
returns the regulator of E; i.e., the determinant of the N'eron-Tate
height pairing matrix of a basis of the free quotient of the Mordell--Weil
group.
> E := EllipticCurve([0,0,1,-7,6]);
> P1, P2, P3 := Explode(Generators(E));
> Height(P1);
0.6682051656519279350331420509
> IsZero(Abs(Height(2*P1) - 4*Height(P1)));
true
> BadPrimes(E);
[ 5077 ]
The local height of a point P at a prime is 0 except possibly at the
bad primes of E, the `infinite' prime, and those primes dividing the
denominator of the x-coordinate of P. Since these generators have
denominator 1 we see that only two local heights need to be computed to
find the canonical heights of these points.
> P2;
(2 : 0 : 1)
> LocalHeight(P2, 0);
0.7670433553315462057954506466
> LocalHeight(P2, 5077);
0.0000000000000000000000000000
> Height(P2);
0.7670433553315462057954506466
The above shows that the local height at a bad prime may still be zero.
SilvermanBound(E) : CrvEll -> FldPrElt
Given an elliptic curve E over Q with integral coefficients,
this function returns the Silverman bound BSilv of E.
For any point P on E we will have NaiveHeight(P) - Height(P) ≤BSilv.
SiksekBound(E: parameters) : CrvEll -> FldPrElt
Torsion: BoolElt Default: false
Given an elliptic curve E over Q which is a minimal model,
this function returns a real number B such that for any point
P on E NaiveHeight(P) - Height(P) ≤BSiksek.
In many cases, the Siksek bound is much better than the Silverman bound.
If the parameter Torsion is true then a potentially
better bound B Tor is computed, such that for any point P on E
there exists a torsion point T so that NaiveHeight(P + T) - Height(P) ≤B Tor.
Note that Height(P + T) = Height(P).
We demonstrate the improvement of the Siksek bound over the Silverman
bound for the three example curves from Siksek's paper [Sik95].
> E := EllipticCurve([0, 0, 0, -73705, -7526231]);
> SilvermanBound(E);
13.00022113685530200655193
> SiksekBound(E);
0.82150471924479497959096194911
> E := EllipticCurve([0, 0, 1, -6349808647, 193146346911036]);
> SilvermanBound(E);
21.75416864448061105008
> SiksekBound(E);
0.617777290687848386342334921728509577480
> E := EllipticCurve([1, 0, 0, -5818216808130, 5401285759982786436]);
> SilvermanBound(E);
27.56255914401769757660
> SiksekBound(E);
15.70818965430290161142481294545
This last curve has a torsion point, so we can further improve the
bound:
> T := E![ 1402932, -701466 ];
> Order(T);
2
> SiksekBound(E : Torsion := true);
11.0309876231179839831829512652688
Here is a point which demonstrates the applicability of the modified
bound.
> P := E![ 14267166114 * 109, -495898392903126, 109^3 ];
> NaiveHeight(P) - Height(P);
12.193000709615680011116868901084
> NaiveHeight(P + T) - Height(P);
2.60218831527724007036
Given points P and Q on an elliptic curve E, this function
returns true if and only if P and Q are independent
free elements of the group of rational points of an elliptic
curve (modulo torsion points). If false, the function
returns a vector v = (r, s) as a second value such that
rP + sQ is a torsion point.
Given a sequence of points S belonging to an elliptic curve E,
this function returns true if and only if the points in S
are linearly independent (modulo torsion). If false, the
function returns a vector v in the kernel of the height pairing
matrix, i.e. giving a torsion point as a linear combination of
the points in S.
Given a sequence of points S belonging to an elliptic curve E
over the rationals, the function returns a sequence of points that
are independent modulo the torsion subgroup (equivalently,
they have non-degenerate height pairing), and which generate the
same subgroup of E(Q)/Etors(Q) as points of S.
We demonstrate the linear independence test on an example curve
with an 8-torsion point and four independent points. The torsion
point is easily recognized and we establish the independence of
the remaining points using the height function.
> E := EllipticCurve([0,1,0,-95549172512866864, 11690998742798553808334900]);
> P0 := E![ 39860582, 2818809365988 ];
> P1 := E![ 144658748, -946639447182 ];
> P2 := E![ 180065822, 569437198932 ];
> P3 := E![ -339374593, 2242867099638 ];
> P4 := E![ -3492442669/25, 590454479818404/125 ];
> S0 := [P0, P1, P2, P3, P4];
> IsLinearlyIndependent(S0);
false (1 0 0 0 0)
> Order(P0);
8
> S1 := [P1, P2, P3, P4];
> IsLinearlyIndependent(S1);
true
We now demonstrate the process of solving for a nontrivial linear
dependence among points on an elliptic curve by constructing a
singular matrix, forming the corresponding linear combination of
points, and establishing that the dependence is in the matrix kernel.
> M := Matrix(4, 4, [-3,-1,2,-1,3,3,3,-2,3,0,-1,-1,0,2,1,1]);
> Determinant(M);
0
> S2 := [ &+[ M[i, j]*S1[j] : j in [1..4] ] : i in [1..4] ];
> IsLinearlyIndependent(S2);
false ( 5 -3 8 7)
> Kernel(M);
RSpace of degree 4, dimension 1 over Integer Ring
Echelonized basis:
( 5 -3 8 7)
Despite the moderate size of the numbers which appear in the
matrix M, we note that height is a quadratic function in the
matrix coefficients. Since height is a logarithmic function of
the coefficient size of the points, we see that the sizes of the
points in this example are very large:
> [ RealField(16) | Height(P) : P in S2 ];
[ 137.376951049198, 446.51954933694, 52.724183282292, 59.091649046171 ]
> Q := S2[2];
> Log(Abs(Numerator(Q[1])));
467.6598587040659411808117253
> Log(Abs(Denominator(Q[1])));
449.2554587727840583949442765
Precision: RngIntElt Default: 0
E2: FldPadElt Default: 0
Given a point P on an elliptic curve defined on the rationals
and a prime p≥5 of good ordinary reduction, this function computes
the p-adic height of P to the desired precision.
The value of the EisensteinTwo function
for the curve can be passed as a parameter. The algorithm dates back
to [MT91] with improvements
due to [MST06] and [Har08].
The normalization is that of the last-named paper and is 2p
(or -2p in some cases) as large as in other papers.
Precision: RngIntElt Default: 0
E2: FldPadElt Default: 0
Given a set of points S on an elliptic curve defined over the rationals
and a prime p≥5 of good ordinary reduction, this function computes
the p-adic height regulator of S to the desired precision.
Here the normalization divides out a power of p from the individual heights.
Precision: RngIntElt Default: 0
Given an elliptic curve over the rationals
and a prime p≥5 of good ordinary reduction, this function computes the
value of the Eisenstein series E2 using the Monsky-Washnitzer techniques
via Kedlaya's algorithm. See pAdicHeight above for references.
We give examples for computing p-adic heights.
> E := EllipticCurve("5077a");
> P1 := E ! [2, 0];
> P2 := E ! [1, 0];
> P3 := E ! [-3, 0];
> assert P1+P2+P3 eq E!0; // the three points sum to zero
> for p in PrimesInInterval(5,30) do pAdicHeight(P1, p); end for;
4834874647277 + O(5^20)
5495832406058373*7 + O(7^20)
-12403985313704524674*11 + O(11^20)
616727731594753360389*13 + O(13^20)
53144975867434108754867*17 + O(17^20)
651478754033733420744924*19 + O(19^20)
1382894029404692415656094*23^2 + O(23^20)
-2615503441214747688800993518*29 + O(29^20)
> pAdicHeight(P1, 37); // 37 is not ordinary for this curve
>> pAdicHeight(P1, 37); // 37 is not ordinary for this curve
Runtime error in 'pAdicHeight': p cannot be supersingular
> for p in PrimesInInterval(5,30) do pAdicRegulator([P1, P2], p); end for;
-263182161797834*5^-2 + O(5^20)
-35022392779944725 + O(7^20)
-331747503271490921584 + O(11^20)
246446095809126124462 + O(13^20)
-1528527915797227515067270 + O(17^20)
333884275695653846729970*19 + O(19^20)
412978398356115570280760602 + O(23^20)
-45973362301048046561945193743 + O(29^20)
> pAdicRegulator([P1, P2, P3], 23); // dependent points
O(23^20)
> eisen_two := EisensteinTwo(E, 13 : Precision:=40); eisen_two;
25360291252705414983472710631099471724343012 + O(13^40)
> pAdicRegulator([P1, P2], 13 : Precision:=40, E2:=eisen_two);
85894629213918025547455609490608727790695215 + O(13^40)
The two-descent process determines the locally soluble
two-coverings of an elliptic curve defined over a number field K,
giving them as hyperelliptic curves C:y2 = f(x) with f of degree four.
To be practical, K must be of rather small degree,
and for various parts of 2-descent to run (particularly reduction),
K must have certain properties (such as being totally real).
Also, the algorithms over the rationals have now been revisited, and are
now faster than when using the general number field descent machinery.
A separate implementation is available for the case where E admits a
2-isogeny: this involves first computing the 2-coverings for the isogeny
and its dual (in this case the covering maps have degree 2 instead of
degree 4), and then lifting these to the level of a "full 2-descent".
This section also provides some tools for manipulating such curves,
including generators for some rings of invariants of quartic forms,
minimisation and reduction of such forms,
and the maps back to the associated elliptic curve.
This functionality overlaps with the package for genus one models
(see MODELS OF GENUS ONE CURVES). There is a straightforward interface to the
2-Selmer group machinery, which also works over number fields.
RemoveTorsion: BoolElt Default: false
RemoveGens: { PtEll } Default:
WithMaps: BoolElt Default: true
SetVerbose("TwoDescent", n): Maximum: 1
Given an elliptic curve E over the rationals
(or over a number field, which must be of small degree in practice),
2-descent can be used to construct a sequence of hyperelliptic curves
(quartics) representing the elements of the 2-Selmer group.
The group structure is not preserved by this function:
the intrinsic TwoSelmerGroup should be used if this is desired.
If RemoveTorsion is true, the generators of the
torsion subgroup are factored out from the set. If RemoveGens
is nonempty, the image of the specified points is factored out from the set.
If AppendMaps is true, then the maps from the covers to the curve
are appended as a second argument.
AssociatedEllipticCurve(C) : CrvHyp -> CrvEll, Map
E: CrvEll Default:
Gives the minimal model of the elliptic curve associated with a
two-covering given as a polynomial f or a hyperelliptic curve C,
along with a map from points [x, y] on the two-covering
to the curve.
If an elliptic curve is given as E, this must be isomorphic to the
Jacobian of C, and then the map returned will be a map to the given E.
> SetSeed(1); // results may depend slightly on the seed
> E := EllipticCurve([0, 1, 0, -7, 6]);
> S := TwoDescent(E);
> S;
[
Hyperelliptic Curve defined by y^2 = x^4 + 4*x^3 - 2*x^2 - 20*x + 9 over
Rational Field,
Hyperelliptic Curve defined by y^2 = x^4 - x^3 - 2*x^2 + 2*x + 1 over
Rational Field,
Hyperelliptic Curve defined by y^2 = 2*x^4 - 4*x^3 - 8*x^2 + 4*x + 10 over
Rational Field
]
E has three non-trivial two-descendants, hence its rank is at most 2.
The first two curves yield obvious rational points, so we can find
two independent points on E (and it has exact rank 2).
> pt_on_S1 := Points(S[1] : Bound:=10 )[1];
> pt_on_S1;
// We obtain the map from S[1] to E by
> _, phi := AssociatedEllipticCurve(S[1] : E:=E );
> phi( pt_on_S1 );
(1 : -1 : 1)
// Now do the same for the second curve.
> pt_on_S2 := Points(S[2] : Bound:=10 )[1];
> _, phi := AssociatedEllipticCurve(S[2] : E:=E );
> phi( pt_on_S2 );
(-3 : 3 : 1)
Isogeny: MapSch Default:
TwoTorsionPoint: PtEll Default:
Given an elliptic curve E over Q
admitting a 2-isogeny φ: E' to E,
this function computes 2-coverings representing
the nontrivial elements of the
Selmer groups of φand of the dual isogeny φ' : E to E'.
These coverings are given as hyperelliptic curves C : y2=quartic(x).
Six objects are returned:
(i) the sequence of coverings C of E for φ;
(ii) the corresponding list of maps C to E;
(iii) and (iv) the coverings C' and maps C' to E' for φ';
(v) and (vi) the isogenies φand φ' that were used.
It's advisable to give a model for E that is close to minimal.
TwoDescendantsOverTwoIsogenyDescendant(C) : CrvHyp -> SeqEnum[ CrvHyp ], List, MapSch
This routine performs a higher descent on curves arising in
TwoIsogenyDescent(E) on an elliptic curve E over Q.
The curves obtained are 2-coverings of E in the sense
of ordinary (full) TwoDescent; more precisely, they are exactly the
set of 2-coverings D for which the covering map D to E factors
through C.
Up to isomorphism,
they are a subset of the 2-coverings returned by TwoDescent(E).
The advantage of this approach is that it works entirely over the base field
of E, whereas TwoDescent will in general compute
a class group over a quadratic extension of the base field.
The example below explains how to recover all coverings
produced by TwoDescent(E) using the 2-isogeny approach.
This function accepts any curve C in the first sequence of curves
returned by TwoIsogenyDescent(E)
(these are the 2-isogeny-coverings of E).
More generally it accepts any hyperelliptic curve of the form
y2 = d1x4 + cx2 + d2.
A model for the associated elliptic curve E
is then y2 = x(x2 + cx + d1 d2).
The function returns three objects:
a sequence containing the covering curves D,
a list containing the corresponding maps D to C,
and lastly the covering map C to E from the given curve
to some model of its associated elliptic curve.
QuarticG4Covariant(q) : RngUPolElt -> RngUPolElt
QuarticHSeminvariant(q) : RngUPolElt -> RngIntElt
QuarticPSeminvariant(q) : RngUPolElt -> RngIntElt
QuarticQSeminvariant(q) : RngUPolElt -> RngIntElt
QuarticRSeminvariant(q) : RngUPolElt -> RngIntElt
Compute invariants, semivariants, and covariants, as in paper
[Cre01], of a given quartic polynomial q.
The G4 and G6 covariants are polynomials of degrees four and six
respectively;
the I and J invariants are integers that generate the ring of integer
invariants of the polynomial and satisfy J2 - 4I3 = 27 Δ(f).
The names H and P have been used for essentially the same
seminvariant in different papers; they are related by H= - P.
Using invariant theory, compute the number of real roots of a real
quartic polynomial q.
Given a quartic q, the algorithm of [SC02] is
applied to minimise q. Both the minimised quartic and the
matrix that minimised it are returned.
Given a quartic q, the algorithm of [Cre99] is
applied to find the reduced quartic and the matrix that
reduced it.
Determines if the quartics f and g are equivalent.
The Tate--Shafarevich group of any elliptic curve E admits an alternating
bilinear form on Sha()(E) with values in Q/Z,
known as the Cassels-Tate pairing.
The key property is that if Sha()(E) is finite (as conjectured),
the Cassels-Tate pairing is non-degenerate.
When restricted to the 2-torsion subgroup,
one obtains a non-degenerate alternating
bilinear form on Sha()(E)[2]/2Sha()(E)[4],
or equivalently on Sel2(E) modulo
the image of Sel4(E), with values in Z/2Z.
This means that if C and D are 2-coverings
of E and the pairing (C, D) has value 1,
then both C and D represent elements of order 2 in Sha()(E),
and moreover there are no locally solvable
4-coverings of E lying above them
(in other words, FourDescent(C) and FourDescent(D)
would both return an empty sequence).
In this sense the Cassels-Tate pairing provides the same information
as 4-descent, but is much easier to compute.
Similarly, for an element in Sha()(E)[4]/2Sha()(E)[8], the values of the pairing
between this element and all elements in Sha()(E)[2]/2Sha()(E)[4] provides the
same information as performing an 8-descent on C.
These elements may be represented by a 4-covering C to E and a 2-covering
D to E respectively.
In Magma the pairing between 2-coverings is implemented over Q
number fields, and rational function fields F(t) for F finite of odd characteristic.
The pairing between a 2-covering and a 4-covering is implemented over Q.
A new, very efficient implementation of pairing on 2-coverings over Q
was released in Magma V2.15.
The algorithms are due to Steve Donnelly and will be described in a forthcoming
paper, a draft of which is available on request.
For the pairing between 2-coverings, the only nontrivial computation is to solve
a conic over the base field of E, so over Q the pairing is easy to compute.
For the pairing between 2- and 4-coverings, the key step is to solve a conic defined
over a degree 4 field; this is also the case for performing 8-descent on the 4-covering,
however the advantage here is that there is considerable freedom to choose the field to have
small discriminant. Consequently it is more efficient to use the pairing than to apply
EightDescent.
To have information about the computation printed while it is running, one may use
SetVerbose("CasselsTate",n); with n = 1 (for fairly concise information) or n = 2.
SetVerbose("CasselsTate", n): Maximum: 2
This evaluates the Cassels-Tate pairing on 2-coverings of an elliptic curve over
Q, a number field, or a function field F(t) where F is a finite field of odd
characteristic.
The given curves C and D must be hyperelliptic curves of the form y2 = q(x)
where q(x) has degree 4, and they must admit 2-covering maps to the same
elliptic curve. In addition, they must both be locally solvable over all completions
of their base field (otherwise the pairing is not defined).
Typically the input curves C and D would be obtained using TwoDescent(E).
The pairing takes values in Z/2Z (returned as elements of Z).
SetVerbose("CasselsTate", n): Maximum: 2
This evaluates the Cassels-Tate pairing between a 4-covering C and a 2-covering
D of the same elliptic curve over Q. The arguments should be curves over Q,
with C an intersection of two quadrics in P3 (for instance, a curve obtained
from FourDescent), and D a hyperelliptic curve of the form y2 = q(x).
In addition, they must both be locally solvable over all completions of Q
(otherwise the pairing is not defined).
The pairing takes values in Z/2Z (returned as elements of Z).
We consider the first elliptic curve with trivial 2-torsion and nontrivial
Tate-Shafarevich group.
> E := EllipticCurve("571a1"); E;
Elliptic Curve defined by y^2 + y = x^3 - x^2 - 929*x - 10595 over Rational Field
> #TorsionSubgroup(E);
1
> time covers := TwoDescent(E); covers;
Time: 0.270
[
Hyperelliptic Curve defined by y^2 = -11*x^4 - 68*x^3 - 52*x^2 + 164*x - 64
over Rational Field,
Hyperelliptic Curve defined by y^2 = -19*x^4 + 112*x^3 - 142*x^2 - 68*x - 7
over Rational Field,
Hyperelliptic Curve defined by y^2 = -4*x^4 + 60*x^3 - 232*x^2 + 52*x - 3
over Rational Field
]
> time CasselsTatePairing(covers[1], covers[2]);
1
Time: 0.130
This proves that these two coverings both represent nontrivial elements in the
Tate-Shafarevich group; in fact our computations show that the 2-primary part
of Sha()(E) is precisely Z/2 x Z/2.
We could have reached the same conclusion using 4-descent:
> time FourDescent(covers[1]);
[]
Time: 0.460
In a 1996 paper [MSS96], Merriman, Siksek and Smart described a
four-descent algorithm for elliptic curves over Q. This section
describes the Magma implementation of that algorithm.
Another useful reference is Tom Womack's PhD thesis [Wom03].
Four-descent is performed on a two-cover, that is a hyperelliptic curve
defined by a polynomial of degree four, with the assumption that the
quartic of this descendant does not have a rational root.
The terminology "four-descent" is thus slightly incorrect;
Magma actually performs a second descent on a specific two-cover,
and does not try to combine such information from all two-covers
into the 4-Selmer group.
A four-covering F is a pair of symmetric 4 x 4 matrices,
defining an intersection of two quadrics in P3.
Associated to F is an elliptic curve E;
there is a rational map from F to E of degree 16.
The four-descent process takes a two-covering curve C (something of
the shape y2 = f(x) with f quartic, and possessing points over
Qp for all p), and returns a set of four-coverings that arise
from C.
In particular, if C represents an element of order two in the
Tate--Shafarevich group of E, then the four-descent process will
return the empty set.
If C represents an element of the Mordell--Weil group, at least one of
the four-coverings arising from C will have a rational point --- all
of them will do so if the Tate--Shafarevich group of E is trivial --- and
once found this point can be lifted to a point on E.
FourDescent(S : parameters) : SeqEnum -> [Crv]
FourDescent(C : parameters) : CrvHyp -> [Crv]
RemoveTorsion: BoolElt Default: false
IgnoreRealSolubility: BoolElt Default: false
RemoveTorsion: BoolElt Default: false
RemoveGensEC: { PtEll } Default:
RemoveGensHC: { PtHyp } Default:
SetVerbose("FourDescent", n): Maximum: 3
SetVerbose("LocalQuartic", n): Maximum: 2
SetVerbose("MinimiseFD", n): Maximum: 2
SetVerbose("QISearch", n): Maximum: 1
SetVerbose("ReduceFD", n): Maximum: 2
SetVerbose("QuotientFD", n): Maximum: 2
Performs a four-descent on the curve y2 = f(x), where f is a quartic.
Returns a set of four-coverings of size 2s - 1,
where s is the Selmer 2-rank of the curve.
If the verbose level of the main function is set to 3,
then the auxiliary verbose levels are all set to at least 1.
If RemoveTorsion is true, the generators of the
torsion subgroup are factored out from the set.
The optional argument RemoveGensHC performs a quotient by the
images of given points that are on the input quartic to FourDescent.
The optional argument RemoveGensEC forms a quotient by the
images of given points; these can be on any elliptic curve that is
isomorphic to the AssociatedEllipticCurve of the quartic
(though all given points must be on the same elliptic curve).
These options can be used together. It can be non-trivial to remove
torsion and generators, as points on the elliptic curve need not pull-back
to the given y2 = f(x) curve. The algorithm used exploits various primes
of good reduction, and attempts to determine whether the images under the
μp are the same. This in turn can be tricky, due to the Cassels
kernel, and even more so when there are extra automorphisms
(that is, when j=0, 1728 over ( F)p).
This example shows that a well-known curve has rank 0 and that the
2-torsion subgroup of its Tate--Shafarevich group is isomorphic
to (Z/2Z)2.
> D := CremonaDatabase();
> E := EllipticCurve(D, 571, 1, 1);
> time td := TwoDescent(E);
Time: 2.500
> #td;
3
There are three 2-covers, so the 2-Selmer group has order four
(since TwoDescent elides the trivial element).
> time [ FourDescent(t) : t in td ];
[
[],
[],
[]
]
Time: 3.290
So none of the two-covers have four-covers lying over them;
hence they all represent elements of Sha, and the Mordell--Weil rank
must be zero.
AssociatedHyperellipticCurve(qi) : Crv -> CrvHyp, Map
E: CrvEll Default:
Given an intersection of quadrics qi, return the associated elliptic
and hyperelliptic curves, respectively, together with maps to them.
If an elliptic curve is given as E, this must be isomorphic to the
Jacobian of the curve qi, and then the map returned will be a map
to the given E.
QuadricIntersection(P, F) : Prj, [AlgMatElt] -> Crv
Given a pair of symmetric 4 x 4 matrices F, this function returns
the associated quadric intersection in P = P3.
QuadricIntersection(C) : CrvHyp -> Crv, MapIsoSch
Given an elliptic curve E or a hyperelliptic curve C, write it
as an intersection of quadrics. The inverse map for the hyperelliptic
curve has problems due to difficulties with weighted projective space.
Given a curve C, determines if C is in P3 and has two defining
equations, both of which involve only quadrics. In the case where C
is a quadric intersection, the associated pair of matrices are also
returned.
OnlyOne: BoolElt Default: false
ExactBound: BoolElt Default: false
SetVerbose("QISearch", n): Maximum: 1
Given a quadric intersection C, this function searches,
by a reasonably efficient method due to Elkies [Elk00],
for a point on C of na{"{char"10}}ve height up to B;
the asymptotic running time is O(B2/3).
If OnlyOne is set to true, the search stops as soon as it finds
one point; however, the algorithm is p-adic and there is no guarantee
that points with small coordinates in Z will be found first.
If ExactBound is set to true, then points that are found with
height larger than B will be ignored.
TwoCoverPullback(f, pt) : RngUPolElt[FldRat], PtEll[FldRat] -> [PtHyp]
Given a two-covering of a rational elliptic curve (as either a
hyperelliptic curve or a quartic) and a point on the elliptic curve,
compute the pre-images on the two-covering. This is faster than using
the generic machinery.
FourCoverPullback(C, pt) : Crv[FldRat], PtHyp[FldRat] -> [Pt]
Given a four-covering of a rational elliptic curve as an intersection
of quadrics and a point either on the associated elliptic curve or the
associated hyperelliptic curve, this function computes the pre-images
on the covering. This is faster than using the generic machinery.
This example exhibits a four-descent computation, and manipulation of
points once they have been found, by mapping from the curve to its
two- and four-covers.
> P<x> := PolynomialRing(Integers());
> E := EllipticCurve([0, -1, 0, 203, -93]);
> f := P!Reverse([-7, 12, 20, -120, 172]);
> f;
-7*x^4 + 12*x^3 + 20*x^2 - 120*x + 172
The quartic given was obtained with mwrank;
the two-descent routine could have been used instead, although it
provides a different (but equivalent) quartic.
> time S := FourDescent(f);
Time: 4.280
> #S;
1
The single cover indicates that the curve E has Selmer rank 1,
though this was already known from the calculation that constructed f.
> _,m := AssociatedEllipticCurve(S[1] : E:=E );
> pts := PointsQI(S[1], 10^4);
> pts;
[ (-5/3 : 13/3 : -34/3 : 1) ]
We now map this point back to E.
> m(pts[1]);
(2346223045599488598/1033322524668523441 : 20326609223460937753264735467/1050397899358266605692672489 : 1)
> Height($1);
44.19679596739622477261983370
One may perform 8-descent (ie a further 2-descent) on curves
of the kind produced by a 4-descent on an elliptic curve E
over Q. These are nonsingular intersections of two quadrics
in P3 that are locally soluble. The 8-descent determines
whether such a curve has any 2-coverings (in the sense of
2-descent) that are locally soluble everywhere.
The routine can therefore be used to prove, in many cases, that
a given 4-covering of E is in fact an element of order 4 in
the Tate--Shafarevich group of E. It can also be used to find
8-coverings of E, and to verify these are elements of the
8-Selmer group.
The 8-coverings are given as intersections of three quartics in P3.
The models computed tend to have large coefficients (in contrast
with 4-descent and 3-descent), because reduction techniques are
not implemented. This means that the 8-coverings are not helpful
in searching for rational points on E.
The algorithm and (with slight modifications) the implementation
are due to Sebastian Stamminger (see [Sta05]).
BadPrimesHypothesis: BoolElt Default: false
DontTestLocalSolvabilityAt: { RngIntElt } Default:
StopWhenFoundPoint: BoolElt Default: false
SetVerbose("EightDescent", n): Maximum: 4
SetVerbose("LegendresMethod", n): Maximum: 3
For a curve C obtained from FourDescent on some elliptic
curve E over Q, this performs a further 2-descent on C.
It returns a sequence of curves D, together with a sequence
containing maps D to C from each of these curves to C. The curves
returned are precisely the 8-descendants of E that lie above C
and are locally soluble at all places.
When the optional argument StopWhenFoundPoint is set to true,
the computation will stop if it happens to find a rational point
on C, and immediately return the point instead of continuing
to computing the 8-coverings.
In some cases local solubility testing (at large primes which may arise due
to choices made in the algorithm) can be time-consuming.
Testing at specified primes may be skipped by setting the optional argument
DontTestLocalSolvabilityAt to the desired set of prime integers,
or by setting BadPrimesHypothesis to be true.
In that case, certain primes are omitted from the set of bad primes (namely
those primes at which the intersection of C with an auxiliary third quadric
has bad reduction, and which are not bad primes for any other reason).
The algorithm involves class group and unit computations in number fields
of degree 6. It is recommended to set the bounds to be used in all such
computations before calling EightDescent, via SetClassGroupBounds.
Verbose output: For a readable summary of the computation, set the
verbose level to 1 by entering SetVerbose("EightDescent",1).
For full information about all the time-consuming steps in the process, set
the verbose level to 3. For additional information about solving the conic,
set the verbose level for "LegendresMethod" to 2.
Three descent is implemented for elliptic curves over the rationals.
This involves computing the 3-Selmer group of the curve,
and then representing the elements as plane cubics.
There is also a separate implementation of "descent by three isogenies",
for elliptic curves over the rationals which admit a Q-rational isogeny
of degree 3.
The main application of full three-descent is in studying elements of order 3
in Tate--Shafarevich groups. For the problem of determining the Mordell--Weil
group, three-descent has no advantage over four descent except in special
cases: the cost is greater (three-descent
requires computing the class group and S-units in a degree 8 number field,
compared with degree 4 for four-descent),
and the reward is smaller (a point on a 3-coverings has height
1/6 as large as its image on the elliptic curve,
while with four-descent the ratio is 1/8).
However three-descent can be useful when
there are elements of order 4 in the Tate--Shafarevich group,
which four-descent cannot deal with.
On the other hand, for a curve with a Q-rational isogeny of degree 3,
descent by 3-isogenies is likely to be the most efficient way to
bound the Mordell--Weil rank, because it only
requires class group and S-unit computations in quadratic fields.
There are two steps to the 3-descent process: firstly, computing the
3-Selmer group as a subgroup of H1(Q, E[3]) (explicitly, as a subgroup
of A x /(A x )3 for a suitable algebra A), and secondly,
expressing the elements as genus one curves with covering maps to E.
The elements of the 3-Selmer group are given as plane cubics, and the process
of obtaining these cubics is far from trivial.
(Note that in general, an element of H1(Q, E[3])
can only be given as a curve of degree 9 rather than degree 3).
The main commands are ThreeSelmerGroup(E), which performs the first step,
and ThreeDescent(E), which performs both steps together,
while ThreeDescentCubic performs the second step
for a given element of 3-Selmer group.
The algorithm for the first step is presented in
[SS04], while the theory and algorithms for the second step
are developed in the forthcoming series of papers [CFO+08],
[CFO+09], [CFO+].
The bulk of the code was written by Michael Stoll and Tom Fisher
(however, responsibility for the final version rests with Steve Donnelly).
The following verbose flags provide information about various stages
of the three descent process: Selmer, ThreeDescent, CSAMaximalOrder,
Minimise and Reduce. For instance, to see what
ThreeSelmerGroup is doing while it is running, first enter
SetVerbose("Selmer",2);. The verbose levels range from 0 to 3.
Method: MonStgElt Default: "HessePencil"
SetVerbose("Selmer", n): Maximum: 3
SetVerbose("ThreeDescent", n): Maximum: 3
Given an elliptic curve over the rationals, this function
returns the elements of the 3-Selmer group as projective
plane cubic curves C, together with covering maps C to E.
Two objects are returned: a sequence containing one curve for each
inverse pair of nontrivial elements in the 3-Selmer group,
and a corresponding list of maps from these curves to E.
(Note that a pair of inverse elements in the 3-Selmer group both
correspond to the same cubic curve C, and their covering
maps C to E differ by composition with the negation map E to E.)
The function simply calls ThreeSelmerGroup(E),
and then ThreeDescentCubic on the Selmer elements.
Note that if ThreeSelmerGroup(E) has already been
computed, it will not be recomputed, because the results
are stored in the attribute E`ThreeSelmerGroup.
For more information see the description
of ThreeDescentCubic below.
Here is Selmer's famous example 3x3 + 4y3 + 5z3 = 0,
which is an element of order 3 in the Tate--Shafarevich group
of its Jacobian, the elliptic curve x3 + y3 + 60z3 = 0.
> Pr2<x,y,z> := ProjectiveSpace(Rationals(),2);
> J := x^3 + y^3 + 60*z^3;
> E := MinimalModel(EllipticCurve(Curve(Pr2,J)));
> cubics, mapstoE := ThreeDescent(E);
> cubics;
[
Curve over Rational Field defined by 2*x^3 + 30*y^3 - z^3,
Curve over Rational Field defined by x^3 + 5*y^3 - 12*z^3,
Curve over Rational Field defined by 6*x^3 + 5*y^3 - 2*z^3,
Curve over Rational Field defined by 3*x^3 + 5*y^3 - 4*z^3
]
The 3-Selmer group of E is isomorphic to Z/(3Z) direct-sum Z/(3Z),
and one element for each (nontrivial) inverse pair is returned.
(Note: 3x3 + 4y3 + 5z3 will not necessarily appear; due to
random choices in the program, an equivalent model may appear instead.)
The covering maps from these curves to E have degree 9,
and are given by forms of degree 9 in x, y, z. For example,
the map from the first curve 2x3 - 3y3 + 10z3 to E is given by:
> DefiningEquations(mapstoE[1]);
[
-1377495072000*x*y^7*z + 4591650240000*x*y^4*z^4 - 15305500800000*x*y*z^7,
24794911296000*y^9 - 123974556480000*y^6*z^3 - 413248521600000*y^3*z^6 +
918330048000000*z^9,
-4251528000*x^3*y^3*z^3
]
Since E has trivial Mordell--Weil group, we should not find any
rational points on these curves! (In fact they are all nontrivial
in the Tate--Shafarevich group.) Here we search for rational points
on the first cubic, up to height roughly 104:
> time PointSearch( cubics[1], 10^4);
[]
Time: 0.490
An extended example, concerning "visible" 3-torsion in a
Tate--Shafarevich group, can be found at the end of Chapter MODELS OF GENUS ONE CURVES.
ThreeTorsPts: Tup Default:
MethodForFinalStep: MonStgElt Default: "UseSUnits"
CompareMethods: BoolElt Default: false
SetVerbose("Selmer", n): Maximum: 3
Given an elliptic curve E over the rationals, this function returns
its 3-Selmer group as an abelian group, together with a map to the
natural affine algebra.
The parameter MethodForFinalStep can be either "Heuristic"
(which is usually much faster in large examples),
"FindCubeRoots", or "UseSUnits" (the default, which has the
advantage that it usually takes roughly the same amount of time
as the S-unit computation that has already been performed).
To try all three methods and compare the times, set
CompareMethods to true.
Most of the computation time is usually spent on
class group and unit group computations. These computations
can be speeded up by using non-rigorous bounds, and there are two
ways to control which bounds are used. The recommended way is to
preset them using one of the intrinsics SetClassGroupBounds
or SetClassGroupBoundMaps (see Section Setting the Class Group Bounds Globally).
The other way is to precompute the class groups of the fields involved,
setting the optional parameters in ClassGroup as desired.
(The relevant fields can be obtained as the fields over which the
points in ThreeTorsionPoints(E) are defined.)
The fields and their class group data would then be stored
internally, and automatically used when ThreeSelmerGroup(E)
is called (even when no optional parameters are provided).
When ThreeTorsPts is specified, it determines the fields used
in the computation, and the algebra used to express the answers.
ThreeTorsPts: Tup Default:
Method: MonStgElt Default: "HessePencil"
SetVerbose("ThreeDescent", n): Maximum: 3
Given an elliptic curve E over the rationals, and an element
αin the 3-Selmer group of E, the function returns a
projective plane cubic curve C, together with a map of schemes C to E.
The cubic is a principal homogeneous space for E, and the
covering map C to E represents the same Selmer element as either
αor 1/α(and αcan be recovered, up to inverse,
by calling ThreeSelmerElement of the cubic).
The 3-Selmer element αis given as an element of
the algebra associated to the 3-Selmer group (the algebra
is the codomain of the map returned by
ThreeSelmerGroup, as in S3, S3toA := ThreeSelmerGroup(E)).
In this situation,
where αis S3toA(s) for some s,
there is no need to specify the optional parameter ThreeTorsPts.
The algorithm comes from the series of papers cited in the introduction.
There are three alternative ways to perform the final step of computing
a ternary cubic. All three ways are implemented, and the optional parameter
Method may be "HessePencil" (default), "FlexAlgebra" or
"SegreEmbedding". However, the choice of Method is not
expected to make a big difference to the running time.
The optional parameter ThreeTorsPts is a tuple containing
one representative from each Galois orbit of E[3] - O.
Its purpose is to
fix an embedding of the 3-Selmer group in A x /(A x )3
(otherwise there is ambiguity when the fields involved
have nontrivial automorphisms, or occur more than once).
When ThreeTorsPts is not specified,
ThreeTorsionPoints(E) is called (its value
is stored internally and used throughout the Magma session).
Isog: MapSch Default:
SetVerbose("Selmer", n): Maximum: 3
SetVerbose("ThreeDescent", n): Maximum: 3
Given an elliptic curve E over Q that admits a Q-rational isogeny
E to E1 of degree 3,
the function performs "descent by 3-isogenies" on E. This involves
computing the Selmer groups attached to the isogeny and its dual,
and representing the elements of both Selmer groups as plane cubics,
with covering maps of degree 3 to E1 or E respectively.
One cubic is given for each nontrivial pair of inverse Selmer elements,
and one covering map is given for each cubic (the other covering map,
which can be obtained by composing with the negation map on
the elliptic curve, would correspond to the inverse Selmer element.)
There are five returned values, in the following order:
a list of curves for Sel(E to E1), a corresponding list
of covering maps to E1, a list of curves for the dual isogeny
Selmer group Sel(E1 to E), a corresponding list
of covering maps to E, and finally the isogeny E to E1.
This function works simply by calling ThreeIsogenySelmerGroups(E),
and then calling ThreeIsogenyDescentCubic for each Selmer element.
The isogeny E to E1 may be passed in as Isog. If Isog
is not specified, and E admits more than one such isogeny,
then this is chosen at random.
Isog: MapSch Default:
SetVerbose("Selmer", n): Maximum: 3
Given an elliptic curve E over the rationals that admits a Q-rational
isogeny E to E1 of degree 3, the function computes the Selmer groups
associated to the isogeny, and to its dual isogeny E1 to E. The Selmer
groups are returned as abstract groups, together with maps to the relevant
algebra. There are five returned values, in the following order: the group,
and the map, for E to E1, the group, and the map, for E1 to E,
and finally the isogeny E to E1.
A bound for the rank of E(Q) can be deduced, by taking the
sum of the ranks of the Selmer groups for the two isogenies, and subtracting
1 if the kernel of one of the isogenies consists of rational points.
The isogeny E to E1 may be passed in as Isog. If Isog
is not specified, and E admits more than one such isogeny,
then this is chosen at random.
The algebra in which the Selmer group of a particular
isogeny is exhibited is the etale algebra corresponding to the nontrivial
points in the kernel of the dual isogeny; it is either a quadratic field,
or a Cartesian product of two copies of Q.
SetVerbose("ThreeDescent", n): Maximum: 3
Given an isogeny φof degree 3 between elliptic curves over Q,
and any element αof H1(Q, E[φ]),
this function returns a plane cubic curve C
representing α, together with a covering map C to E of degree 3.
The element αis given as an element in the algebra A associated to
the Selmer group of φ; the algebra can be obtained from
ThreeIsogenySelmerGroups. H1(Q, E[φ]) is represented as the
subgroup of A x /(A x )3
consisting of elements whose norm is a cube.
Given the equation of a nonsingular projective plane cubic curve C
over the rationals, this function returns the Jacobian of C (over the
rationals) as an elliptic curve. Note that C will be a principal
homogeneous space of E.
ThreeSelmerElement(E, C) : CrvEll, Crv -> Tup
ThreeSelmerElement(C) : RngMPolElt -> Tup
ThreeSelmerElement(C) : Crv -> Tup
Given an elliptic curve E over the rationals,
and a plane cubic C with the same invariants as E
(for instance, with E equal to Jacobian(C))
the function returns an element αin the
algebra A associated to the 3-Selmer group of E.
This αrepresents the same element of H1(Q, E[3])
that is represented by a covering C to E that takes the flex points
of C to O. Note that αis only determined up to
inverse in H1(Q, E[3]).
In particular, if we have computed S3, S3toA := ThreeSelmerGroup(E),
and if C is an everywhere locally soluble covering corresponding to the
element s in S3, then αequals either S3toA(s)
or S3toA(-s) in A x /(A x )3.
E: CrvEll Default:
ReturnBoth: BoolElt Default: false
Given equations of two plane cubics over the rationals
with the same invariants
(in other words, they are homogeneous spaces for the same
elliptic curve E, which is their Jacobian, over the rationals),
the function computes the sum of the corresponding elements
of H1(Q, E[3]). The sum is returned as another
plane cubic, if possible (and otherwise an error results).
An element of H1(Q, E[3]) may be expressed as a plane cubic
when it has index 3, equivalently when the so-called "obstruction"
is trivial.
This is always the case for elements that are everywhere locally soluble.
In particular, the function will always succeed when the two given
cubics are everywhere locally soluble (in other words,
when they belong to the 3-Selmer group).
The computation is done by converting the cubics to elements
of H1(Q, E[3]) as given by ThreeSelmerElement,
adding the cocycles, and then converting the result to a cubic.
Note that a cubic only determines an element of H1(Q, E[3])
up to taking inverse, so the sum is not well defined; if
the function is called with ReturnBoth := true,
it returns both of the possible cubics.
For an elliptic curve E over the rationals,
this function classifies the Galois action on E[3].
The possibilities are "Generic", "2Sylow", "Dihedral",
"Generic3Isogeny", "Z/3Z-nonsplit", "mu3-nonsplit",
"Diagonal" and "mu3+Z/3Z".
OptimisedRep: BoolElt Default: true
For an elliptic curve E over the rationals,
this function returns a tuple containing one
representative point from each set of Galois
conjugates in E[3] - O.
Each point belongs to a point set E(L),
where L is the field generated by the
coordinates of that point.
If OptimisedRep is set to false, then
optimised representations of the fields will not
be computed, in general.
Given an elliptic curve E over the rationals,
and a plane cubic with the same invariants as E
(in other words, a principal homogeneous space for E of index 3),
the function returns a tuple of matrices.
The matrices Mi correspond to the points Ti in
ThreeTorsionPoints(E), and have the corresponding base fields.
Each matrix describes the action-by-translation on C
of the corresponding point: the action of Pi on C is the
restriction to C of the
automorphism of the ambient projective space P2
given by the image of Mi in PGL3.
Note that only the images in PGL3 of the matrices are
well-determined.
For an elliptic curve of rank 1, it is possible to compute the
generator by an analytic process; the elliptic logarithm of some
multiple nP of the generator is the sum of the values of the modular
parameterization at a series of points in the upper half-plane
corresponding to a full set of class representatives for an
appropriately-chosen quadratic field.
There is no such thing as a free lunch, sadly; the calculation
requires computing O(hN) terms to a precision of O(h) digits, so in
practice it works best for curves contrived to have small conductors.
The calculation proceeds in three stages: choosing the quadratic field
Q(Sqrt( - d)), evaluating the modular parameterization, and recovering
the generator from the elliptic logarithm value.
Essentially, this is an implementation of the method of Gross and Zagier
[GZ86]; Elkies performed some substantial
computations using this method in 1994, and much of the work required
to produce this implementation was done by Cremona and Womack.
An array of tricks have been added, and are described to some extent
in some notes of Watkins.
NaiveSearch: RngIntElt Default: 1000
Discriminant: RngIntElt Default:
Cover: Crv Default:
DescentPossible: BoolElt Default: true
IsogenyPossible: BoolElt Default: true
Traces: SeqEnum Default: []
SetVerbose("Heegner", n): Maximum: 1
Attempts to find a point on a rank 1 rational elliptic curve E using the
method of Heegner points, returning true and the point if it finds one,
otherwise false. The parameter NaiveSearch indicates to what height
the algorithm will first do a search (using Points) before turning
to the analytic method. The Discriminant parameter allows the user to
specify an auxiliary discriminant; this must satisfy the Heegner hypothesis,
and the corresponding quadratic twist must have rank 0. The Cover
option allows the user to specify a 2-cover or 4-cover (perhaps obtained
from TwoDescent or FourDescent) to speed the calculation.
This should be either a hyperelliptic curve or a quadric intersection,
and there must be a map from the cover to the given elliptic curve.
If the DescentPossible option is true, then the algorithm might
perform such a descent in any case. If the IsogenyPossible option
is true, then the algorithm will first try to guess the best isogenous
curve on which to do the calculation --- if a Cover is passed to
the algorithm, it will be ignored if E is not the best isogenous curve.
The Traces option takes an array of integers which correspond to
the first however-many traces of Frobenius for the elliptic curve,
thus saving having to recompute them.
The algorithm assumes that the Manin constant of the given elliptic curve
is 1 (which is conjectured in this case), and does not return a generator
for the Mordell--Weil group, but a point whose height is that given by
a conjectural extension of the Gross--Zagier formula. This should be
Sqrt(Sha) times a generator.
HeegnerPoint(f : parameters) : RngUPolElt -> BoolElt, PtHyp
HeegnerPoint(C : parameters) : Crv -> BoolElt, Pt
NaiveSearch: RngIntElt Default: 10000
Discriminant: RngIntElt Default:
Traces: SeqEnum Default: []
SetVerbose("Heegner", n): Maximum: 3
These are utility functions for the above.
The input is either a hyperelliptic curve given by a polynomial
of degree 4, or this quartic polynomial --- in both
cases the quartic should have no rational roots --- or
a nonsingular intersection of two quadrics in P3.
These functions call HeegnerPoint on the underlying elliptic curve.
They then map the computed point back to the given covering curve.
The rational reconstruction step of the HeegnerPoint algorithm
can be quite time-consuming for some coverings, especially if the
index is large. Also, if a cover corresponds to an element of the
Tate--Shafarevich group, the algorithm will likely enter an infinite loop.
These functions have not been as extensively tested as the ordinary
HeegnerPoint function, and thus occasionally might fail due to
unforeseen problems.
ModularParametrisation(E, z, B : parameters) : CrvEll[FldRat], FldComElt, RngIntElt -> FldComElt
ModularParametrization(E, z : parameters) : CrvEll[FldRat], FldComElt, RngIntElt -> FldComElt
ModularParametrisation(E, z : parameters) : CrvEll[FldRat], FldComElt, RngIntElt -> FldComElt
ModularParametrization(E, Z, B : parameters) : CrvEll[FldRat], [FldComElt], RngIntElt -> [FldComElt]
ModularParametrisation(E, Z, B : parameters) : CrvEll[FldRat], [FldComElt], RngIntElt -> [FldComElt]
ModularParametrization(E, Z : parameters) : CrvEll[FldRat], [FldComElt], RngIntElt -> [FldComElt]
ModularParametrisation(E, Z : parameters) : CrvEll[FldRat], [FldComElt], RngIntElt -> [FldComElt]
Traces: SeqEnum Default: []
ModularParametrization(E, f, B : parameters) : CrvEll[FldRat], QuadBinElt, RngIntElt -> FldComElt
ModularParametrisation(E, f, B : parameters) : CrvEll[FldRat], QuadBinElt, RngIntElt -> FldComElt
ModularParametrization(E, f : parameters) : CrvEll[FldRat], QuadBinElt, RngIntElt -> FldComElt
ModularParametrisation(E, f : parameters) : CrvEll[FldRat], QuadBinElt, RngIntElt -> FldComElt
ModularParametrization(E, F, B : parameters) : CrvEll[FldRat], [QuadBinElt], RngIntElt -> [FldComElt]
ModularParametrisation(E, F, B : parameters) : CrvEll[FldRat], [QuadBinElt], RngIntElt -> [FldComElt]
ModularParametrization(E, F : parameters) : CrvEll[FldRat], [QuadBinElt], RngIntElt -> [FldComElt]
ModularParametrisation(E, F : parameters) : CrvEll[FldRat], [QuadBinElt], RngIntElt -> [FldComElt]
Traces: SeqEnum Default: []
Precision: RngIntElt Default:
Given a rational elliptic curve E and a point z in the upper-half-plane,
compute the modular parametrization intz^∞fE(τ) dτwhere fE is the modular form associated to E. The version with a
bound B uses the first B terms of the q-expansion, while the other
version determines how many terms are needed. The optional parameter
Traces allows the user to pass the first however-many traces
of Frobenius. There are also versions which take an array Z of complex
points, and versions which take positive definite binary quadratic forms f
(or an array F) rather than points in
the upper-half-plane (a Precision can be specified with the latter).
Fundamental: BoolElt Default: false
Strong: BoolElt Default: false
Given a rational elliptic curve and a range from lo to hi, compute
the negative fundamental discriminant in this range that satisfies the
Heegner hypothesis for the curve. The Fundamental option restricts
to fundamental discriminants. The Strong option restricts to discriminants
that satisfy a stronger Heegner hypothesis, namely that ap= - 1 for all
primes p that divide gcd(D, N).
UsePairing: BoolElt Default: false
UseAtkinLehner: BoolElt Default: true
Use_wQ: BoolElt Default: true
IgnoreTorsion: BoolElt Default: false
Given a rational elliptic curve of conductor N
and a negative discriminant that meets the Heegner hypothesis for N,
the function computes representatives for
the complex multiplication points on X0(N).
In general the return value is a sequence of 3-tuples (Q, m, T)
where Q is a quadratic form, m is a multiplicity,
and T is a torsion point on E.
Letting φbe the modular parametrization map,
the sum on E of the values m(φ(Q) + T) is a Heegner point in E(Q).
When the number of these values equals the class number h=h(D)
(and the multiplicities are all 1 or -1) then they are actually
the images on E of the CM points on X0(N).
(They all correspond to a single choice of square root of D modulo 4N.)
If UsePairing is added, then CM points that give conjugate values
under the modular parametrisation map are combined.
If UseAtkinLehner is added, then more than one
square root of D modulo 4N can be used.
If Use_wQ is added, then forms can appear with extra multiplicity,
due to primes that divide the GCD of the conductor and the fundamental
discriminant.
If IgnoreTorsion is added, then the fact that Atkin-Lehner can
change the result by a torsion point will be ignored. The UsePairing
option requires that IgnoreTorsion be true.
This function requires (so as not to confuse the user) that the
ManinConstant of the curve be equal to 1.
AtkinLehner: [RngIntElt] Default: []
Given a level N and a discriminant that meets the Heegner hypothesis
for the level, the function returns a sequence of binary quadratic
forms which correspond to the Heegner points. The Atkin-Lehner option
takes a sequence of q with gcd(q, N/q)=1 and has the effect of
allowing more than one square root of D modulo 4N to be used.
Compute the Manin constant of a rational elliptic curve. This is in most
cases simply a conjectural value (and most often just 1).
Given a rational elliptic curve and an integer Q corresponding to
an Atkin-Lehner involution (so that gcd(Q, N/Q)=1), this function
computes the torsion point on the curve corresponding to the period
given by the integral from i∞ to wQ(i∞).
ReturnPoint: BoolElt Default: false
Precision: RngIntElt Default: 100
SetVerbose("Heegner", n): Maximum: 1
Given an elliptic curve E over Q, and a suitable discriminant D
(of a quadratic field)
this function computes the images on E under the modular parametrization
of the CM points on X0(N) associated to D.
It returns a tuple < pD, m >,
where pD is an irreducible polynomial
whose roots are the x-coordinates of these images,
and where m is the multiplicity of each of these images
(the number of CM points on X0(N) mapping to a given point on E).
These x-coordinates lie in the ring class field of Q(Sqrt(D)), and
the class number h(D) must equal either m deg(pD) or 2m deg(pD).
The conductor of the order Q(Sqrt(D)) is required
to be coprime to the conductor of E.
The second object returned by the function is one of the conjugate points,
as an element of the point set E(H) where H is the field defined by pD,
or a quadratic extension of it. This step can be time consuming; if
ReturnPoint is set to false, the point is not computed.
WARNING: The computation is not rigorous,
as it involves computing over the complex numbers,
and then recognising the coefficients of the polynomial as rationals.
However, the program performs a heuristic check:
it checks that the polynomial has the correct splitting at
some small primes (sufficiently many to be sure that wrong answers
will not occur in practice).
> time HeegnerPoint(EllipticCurve([1,0,0,312,-3008])); //uses search
true (12 : -56 : 1)
Time: 0.240
> time HeegnerPoint(EllipticCurve([0,0,1,-22787553,-41873464535]));
true (11003637829478432203592984661004129/1048524607168660222036584535396 : -1004181871409718654255966342764883958203316448270339/10736628855783147946
99393270058310986889998056 : 1)
Time: 1.380
Here are some more complicated examples.
In the first one, the curve has a 163-isogenous curve, which the
algorithm uses to speed the computation. This occurs automatically,
with most of the time taken being in computing the isogeny map.
> E := EllipticCurve([0,0,1,-57772164980,-5344733777551611]);
> b, pt:= HeegnerPoint(E);
> Height(pt);
373.478661569142379884077480412
In this next example, we first use descent to get a covering on which
the desired point will have smaller height.
> E := EllipticCurve([0,-1,0,-71582788120,-7371563751267600]);
> T := TwoDescent(E : RemoveTorsion)[1];
> T;
Hyperelliptic Curve defined by y^2 = -2896*x^4 - 57928*x^3 - 202741*x^2
+ 868870*x - 651725 over Rational Field
> S := FourDescent(T : RemoveTorsion)[1];
> b, pt := HeegnerPoint(S);
> pt;
(-34940281640330765977951793/72963317481453011430052232 : 46087465795237503244048957/72963317481453011430052232 : 82501230298438806677528297/72963317481453011430052232 : 1)
We obtain a point on S, not on the original curve.
We map it to E using the descent machinery.
> _, m := AssociatedEllipticCurve(S);
> PT := m(pt);
> PT;
(26935643239674824824611869793601774003477303945223677741244455058753
924460587724041316046901475913814274843012625394997597714766923750555
669810857471061235926971161094484197799515212721830555528087646969545
65/837619099331786545303500955405701693904657590793269053332825491870
645799230089011267382251975387071464373622714525213870033427638236014
2288012504288439077587496501436920044109243898570190931925860244164 : 410189886613094359515065087530226951251222017120181558101276037601794
678635473792334597914052557787798899390943937170051840037860568689664
871351793404398352109768736545284569745952273382778021947446766526118
621612003004627401344216069791103330332004546699363266079516476593864
98538303998567379869974143259174395/766601839981278884919411893932635
388671474045058772153268571977045787439290021029065740244648077391646
579430077900352635000328805236464794479797855430820809227462762666048
009219642700664370632930446228302292313415544188481623273194456758440
446505454248062292834244615276350323795396202280072306278575288 : 1)
> Height(PT);
476.811182818720336949724781780
> ConjecturalRegulator(E : Precision := 5);
476.81 1
Finally, we do some Heegner point calculation with the curve 43A
and the discriminant -327. Note that the obtained trace down
to the rationals is 3-divisible, but the point over the Hilbert
class field is not.
> E := EllipticCurve([0,1,1,0,0]);
> HeegnerDiscriminants(E,-350,-300);
[ -347, -344, -340, -335, -331, -328, -327, -323, -319, -308, -303 ]
> HF := HeegnerForms(E,-327); HF;
[ <<43,19,4>, 1, (0 : 1 : 0)>, <<43,67,28>, 1, (0 : 1 : 0)>,
<<86,105,33>, 1, (0 : 1 : 0)>, <<86,153,69>, 1, (0 : 1 : 0)>,
<<129,105,22>, 1, (0 : 1 : 0)>, <<129,153,46>, 1, (0 : 1 : 0)>,
<<172,67,7>, 1, (0 : 1 : 0)>, <<258,363,128>, 1, (0 : 1 : 0)>,
<<258,411,164>, 1, (0 : 1 : 0)>, <<301,67,4>, 1, (0 : 1 : 0)>,
<<473,621,204>, 1, (0 : 1 : 0)>, <<473,841,374>, 1, (0 : 1 : 0)> ]
> H := [x[1] : x in HF]; mul := [x[2] : x in HF];
> params := ModularParametrization(E,H : Precision := 10);
> wparams := [ mul[i]*params[i] : i in [1..#H]];
> hgpt := EllipticExponential(E,&+wparams);
> hgpt;
[ 1.000000002 - 1.098466121E-9*I, 1.000000003 - 1.830776870E-9*I ]
> HeegnerPt := E![1,1];
> DivisionPoints(HeegnerPt, 3);
[ (0 : -1 : 1) ]
So the Heegner point is 3 times (0, - 1) in E(Q).
We now find algebraically one of the points (of which we took
the trace to get HeegnerPt). This point will be defined
over a subfield of the class field of Q(Sqrt( - 327)),
and will have degree dividing the class number.
The poly below is the minimal polynomial of the x-coordinate.
> ClassNumber(QuadraticField(-327));
12
> poly, pt := HeegnerPoints(E, -327 : ReturnPoint);
> poly;
<t^12 + 10*t^11 + 76*t^10 - 1150*t^9 + 475*t^8 - 4823*t^7 +
997*t^6 - 5049*t^5 - 2418*t^4 - 468*t^3 - 3006*t^2 + 405*t - 675, 1>
> pt;
(u : 1/16976844562625*(58475062076*u^11 + 568781661961*u^10 +
4238812569862*u^9 - 68932294336288*u^8 + 42534102728187*u^7 -
238141610215111*u^6 + 134503848441911*u^5 - 122884262733563*u^4 -
58148031982456*u^3 + 129014145075851*u^2 -
68190988248855*u + 40320643901175) : 1)
> DivisionPoints(pt,3);
[]
Here is another example of Heegner points over class fields.
> E := EllipticCurve([0,-1,0,-116,-520]);
> Conductor(E);
1460
> ConjecturalRegulator(E);
4.48887474770666173576726806264 1
> HeegnerDiscriminants(E,-200,-100);
[ -119, -111 ]
> P := HeegnerPoints(E,-119);
> P;
<1227609449333996689*t^10 - 106261506377143984603*t^9 +
2459826667693945203684*t^8 - 12539974356047058417320*t^7 -
298524708823654411408343*t^6 + 4440876684434597926161175*t^5 +
7573549099120618979833241*t^4 - 393938048860406386108113130*t^3 -
215318107135691628298668863*t^2 + 13958289016298162706904004974*t
+ 38624559371249968900024945369, 1>
The function automatically performs a heuristic check that the polynomial
has the right properties, using reduction mod small primes.
A more expensive check is the following.
> G := GaloisGroup( P[1] );
> IsIsomorphic(G,DihedralGroup(10));
true
The extension of Q( - 119) defined by the polynomial
is the class field. We now obtain a nice representation of it,
and use this to compute the height of the point (which is
a bit quicker than computing the height directly).
> K<u> := NumberField(P[1]);
> L<v>, m := OptimizedRepresentation(K);
> _<y> := PolynomialRing(Rationals()); // use 'y' for printing
> DefiningPolynomial(L);
y^10 + 2*y^9 - y^8 - 7*y^7 - 7*y^6 + 10*y^5 + 13*y^4 - 9*y^3 - 5*y^2 +
5*y - 1
> PT := Points(ChangeRing(E,L),m(u))[1]; // y-coord is defined over L
> Height(PT);
6.97911761109714376876370533
Precision: RngIntElt Default:
Returns the sequence of periods of the Weierstrass wp-function
associated to the (rational) elliptic curve E, to Precision digits.
The first element of the sequence is the real period. The function
accepts a non-minimal model, and returns the periods corresponding
to that model. As with many algorithms involving analytic information
on elliptic curves, the implementation exploits an AGM-trick due to Mestre.
It is possible to handle curves over other number fields
(using various embeddings), but this is not yet implemented.
Precision: RngIntElt Default:
Returns the real period of the Weierstrass wp-function associated
to the elliptic curve E to Precision digits.
Given a rational elliptic curve E and a complex number z, the function
computes the pair [wp(z), wp'(z)] where wp(s) is the Weierstrass
wp-function.
The algorithm used is taken from [Coh93] for small precision, and
Newton iteration on EllipticLogarithm is used for for high precision.
The function returns a sequence rather than a point on the curve.
Given a rational elliptic curve E and a sequence S = [p, q], where
p and q are rational numbers, this function computes the elliptic
exponential of p times the RealPeriod and q times the imaginary
period.
Precision: RngIntElt Default:
Denote by ω1, ω2 the periods of the Weierstrass
wp-function related to E. This function returns the elliptic
logarithm φ(P) of the point P,
such that -ω1/2≤((Re))(φ(P))
< ω1/2 and -ω2/2≤((Im))(φ(P)) < ω2/2.
The value is returned to Precision digits. As with Periods,
a non-minimal model can be given, and the EllipticLogarithm will
be computed with respect to it. The algorithm is again an AGM-trick
due to Mestre.
Precision: RngIntElt Default:
Check: BoolElt Default: true
Given an elliptic curve E and a sequence S = [z1, z2], where
z1 and z2 are complex numbers approximating a point P on E,
this function returns the elliptic logarithm φ(P). For details see
the previous intrinsic.
When Check is false, z1 and z2 need not have any relation
to a point on the curve, in which case only the x-coordinate matters
up to (essentially) a choice of sign in the resulting logarithm.
Precision: RngIntElt Default: 50
For a point P on an elliptic curve E which is a minimal model and
a prime p, returns the p-adic elliptic logarithm of P to
Precision digits. The order of P must not be a power of p.
Verify that EllipticExponential and EllipticLogarithm are inverses.
> C<I>:=ComplexField(96);
> E:=EllipticCurve([0,1,1,0,0]);
> P:=EllipticExponential(E,0.571+0.221*I); P;
[ 1.656947605210186238868298175 + -1.785440180067681418618695947*I,
-2.417077284700315330385200257 + 3.894153792661208360153853530*I ]
> EllipticLogarithm(E,P);
0.5710000000000000000000000000 + 0.2210000000000000000000000000*I
Add points on a curve via Napier's method.
> E:=EllipticCurve([0,0,1,-7,6]);
> P1:=E![0,2]; P2:=E![2,0]; P3:=E![1,0];
> L:=EllipticLogarithm(E!P1)+EllipticLogarithm(E!P2)+EllipticLogarithm(E!P3);
> L;
0.521748219757790769853120197937 + 1.48054826824141499330733111064*i
> P:=EllipticExponential(E,L);
> [Round(Real(x)) : x in P];
[ 4, -7 ]
> P1+P2+P3;
(4 : -7 : 1)
Calculates the global root number of a rational elliptic curve E.
This is equal to the sign of the functional equation of the
L-series associated to the curve. The method used is to take
a product of local root numbers over the primes of bad reduction.
Calculates the local root number at a prime p of an elliptic curve E.
The method used is due to Halberstadt; for p > 3 it is a straightforward
calculation involving the valuation of the discriminant, while for p = 2, 3
it involves a more careful analysis of the reduction type.
SetVerbose("AnalyticRank", n): Maximum: 1
Precision: RngIntElt Default: 5
Determine the analytic rank of the rational elliptic curve E. The algorithm
used is heuristic, computing derivatives of the L-function L(E, s) at
s=1 until one appears to be nonzero. Local power series methods are
used to compute the special functions used for higher derivatives.
The function returns the first nonzero derivative L(r)(1)/r! as a
second argument. The precision is optional, and is taken to be 17 bits
if omitted; the time taken can increase dramatically if this is increased
much beyond 50 digits as the time to compute the special functions
then starts to dominate the running time.
Precision: RngIntElt Default:
Using the AnalyticRank function, this function calculates an
approximation, assuming that the Birch--Swinnerton-Dyer conjecture holds,
to the product of the regulator of the elliptic curve E and the order
of the Tate--Shafarevich group. The (assumed) analytic rank is returned
as a second value.
Given an elliptic curve E with L-function L(E, s) and the value v of
the first nonzero derivative L(r)(1)/r!, this function calculates an
approximation, assuming that the Birch--Swinnerton-Dyer conjecture holds,
to the product of the regulator of the elliptic curve E and the order
of its Tate--Shafarevich group.
> E:=EllipticCurve([1,1,0,-2582,48720]);
> time r, Lvalue := AnalyticRank(E : Precision:=9); r,Lvalue;
Time: 17.930
6 320.781164
> ConjecturalRegulator(E,Lvalue);
68.2713770
> time G, map := MordellWeilGroup(E : HeightBound := 8); G;
Time: 21.540
Abelian Group isomorphic to Z (6 copies)
Defined on 6 generators (free)
> Regulator([map(g): g in OrderedGenerators(G)]);
68.2713769
> ConjecturalRegulator(EllipticCurve([0,-1,1,0,0]) : Precision := 8);
1.0000000 0
> ConjecturalRegulator(EllipticCurve([0,-1,1,0,0]) : Precision := 21);
1.00000000000000000000 0
> ConjecturalRegulator(EllipticCurve([0,-1,1,0,0]) : Precision := 35);
1.0000000000000000000000000000000000 0
> ConjecturalRegulator(EllipticCurve([0,-1,1,0,0]) : Precision := 50);
1.0000000000000000000000000000000000000000000000000 0
SetVerbose("ModularDegree", n): Maximum: 1
Determine the modular degree of a rational elliptic curve E.
The algorithm used is described in [Wat02]. One computes
the special value L(Sym2 E, 2) of the motivic symmetric-square
L-function of the elliptic curve, and uses the formula
deg(phi)=L(Sym2 E, 2)/(2 * Pi * Ω) * (Nc2) * Ep(2)
where Ωis the area of the fundamental parallelogram of the
curve, N is the conductor, c is the Manin constant, and Ep(2)
is a product over primes whose square divides the conductor.
The Manin constant is assumed to be 1 except in the cases
described in [SW02], where it is conjectured
that the optimal curves for parameterizations from X1(N) and X0(N)
are different. A warning is given in these cases. The optimal curve
for parameterizations from X1(N) is assumed to be the curve in the
isogeny class of E that has minimal Faltings height (maximal Ω).
The algorithm is based upon a sequence of real-number approximations
converging to an integer --- the use of verbose printing
for ModularDegree allows the user to see the sequence of approximations.
First we define a space of ModularForms.
> M:=ModularForms(Gamma0(389),2);
The first of the newforms associated to M corresponds to an elliptic curve.
> f := Newform(M,1); f;
q - 2*q^2 - 2*q^3 + 2*q^4 - 3*q^5 + 4*q^6 - 5*q^7 + q^9 + 6*q^10 - 4*q^11 +
O(q^12)
> E := EllipticCurve(f); E;
Elliptic Curve defined by y^2 + y = x^3 + x^2 - 2*x over Rational Field
We can compute the modular degree of this using modular symbols.
> time ModularDegree(ModularSymbols(f));
40
Time: 0.200
Or via the algorithm based on elliptic curves.
> time ModularDegree(E);
40
Time: 0.000
The elliptic curve algorithm is capable of handling examples of high level,
particularly when bad primes have multiplicative reduction.
> E := EllipticCurve([0,0,0,0,-(10^4+9)]);
> Conductor(E);
14425931664
> time ModularDegree(E);
6035544576
Time: 3.100
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
