[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Curves over Number Fields

The functions in this section are for elliptic curves defined over number fields. For the most part, the functionality is a subset of that available for curves over Q, with functions having similar names and arguments.

The main items implemented are Tate's algorithm, 2-descent and descent by 2-isogenies, the Cassels-Tate pairing, height machinery, and analytic tools.

Subsections

Local Invariants

The routines listed here, when nontrivial, are based on an implementation of Tate's algorithm.

Conductor(E) : CrvEll -> RngOrdIdl
The conductor is part of the data computed by LocalInformation (described below).
BadPlaces(E) : CrvEll -> SeqEnum
Given an elliptic curve E defined over a number field K, returns the places of K of bad reduction for E. i.e., the places dividing the discriminant of E.
BadPlaces(E, L) : CrvEll -> SeqEnum
Given an elliptic curve E defined over a number field K and a number field L, such that K is a subfield of L, returns the places of L of bad reduction for E.
LocalInformation(E, P) : CrvEll, RngOrdIdl -> Tup, CrvEll
    UseGeneratorAsUniformiser: BoolElt  Default: false
Implements Tate's algorithm for the elliptic curve E over a number field. This intrinsic computes local reduction data at the prime ideal P, and a local minimal model. The model is not required to be integral on input. Output is < P, vp(d), fp, cp, K, s > and Emin where P is the prime ideal, vp(d) is the valuation of the local minimal discriminant, fp is the valuation of the conductor, cp is the Tamagawa number, K is the Kodaira Symbol, and s is false if the curve has non-split multiplicative reduction at P and true otherwise. Emin is a model of E (integral and) minimal at P.

When the optional parameter UseGeneratorAsUniformiser is set true, the computation checks whether P is principal, and if so, uses generator of P as the uniformiser. This means that at primes other that P, the returned model will still be integral or minimal if the given curve was.

LocalInformation(E) : CrvEll -> [ Tup ]
Return a sequence of the tuples returned by LocalInformation(E, P) for all prime ideals P in the decomposition of the discriminant of E in the maximal order of the number field the elliptic curve E is over.
Reduction(E, p) : CrvEll, RngOrdIdl -> CrvEll, Map
Given an elliptic curve E over a number field given by a model which is integral at p and has good reduction at p, returns an elliptic curve over the residue field of p which represents the reduction of E at p. The reduction map is also returned.

Complex Multiplication

HasComplexMultiplication(E) : CrvEll -> BoolElt, RngIntElt
Given an elliptic curve E over a number field, the function determines whether the curve has complex multiplication 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.

Mordell--Weil Groups

TorsionBound(E, n) : CrvEll, RngIntElt -> RngIntElt
Given an elliptic curve E defined over a number field, returns a bound on the size of the torsion subgroup of E by looking at the first n non-inert primes of sufficiently low ramification degree and good reduction.
pPowerTorsion(E, p) : CrvEll, RngIntElt -> GrpAb, Map
    Bound: RngIntElt                    Default: -1
Given an elliptic curve E defined over a number field or Q, returns the p-power torsion of E over its base field as an abelian group, together with the map from the group into the curve. One can specify a bound on the size of the p-power torsion, which may help the computation.
TorsionSubgroup(E) : CrvEll -> GrpAb, Map
Given an elliptic curve E defined over a number field, returns the torsion subgroup of E.

The algorithm involves using TorsionBound (described above).

MordellWeilShaInformation(E: parameters) : CrvEll -> [RngIntElt], [PtEll], [Tup]
DescentInformation(E: parameters) : CrvEll -> [RngIntElt], [PtEll], [Tup]
    RankOnly: BoolElt                   Default: false
    ShaInfo: BoolElt                    Default: false
    Silent: 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 elliptic curve E. The tools used include 2-descent and the Cassels-Tate pairing on the 2-Selmer group; analytic routines may also be used when the conductor has small norm.

The arguments and returned values are the same as for curves over Q, and are described in Section Mordell--Weil Group.

Note: The function PseudoMordellWeilGroup is obsolete and should not be used; this function should be used instead.

RankBound(E) : CrvEll -> RngIntElt
    Isogeny: Map                        Default: 
The upper bound on the rank of E(K), for an elliptic curve over a number field K (or Q), obtained by computing the Selmer group(s) associated to some isogeny on E. The isogeny is either multiplication by 2, or a 2-isogeny if any exist, and may be specified by the optional parameter Isogeny.

Heights

NaiveHeight(P) : PtEll -> FldPrElt
Given a point P on an elliptic curve over a number field K, the function returns the naive height of P; i.e., the absolute logarithmic height of the x-coordinate.
Height(P : parameters) : PtEll -> FldPrElt
    Precision: RngIntElt                Default: 27
    Extra: RngIntElt                    Default: 8
Given a point P on an elliptic curve defined over a number field K, returns the N{éron-Tate height of P . (This is based on the absolute logarithmic height of the x-coordinate.) The parameter Precision may be used to specify the desired precision of the output. The parameter Extra is used in the cases when one of the points 2n P gets too close to the point at infinity, in which case there is a huge loss in precision in the archimedean height and increasing Extra remedies that problem.
HeightPairingMatrix(P : parameters) : [PtEll] -> AlgMatElt
Compute the height pairing matrix for an array of points. Same parameters as above.
LocalHeight(P, Pl : parameters) : PtEll, PlcNumElt -> FldPrElt
    Precision: RngIntElt                Default: 0
    Extra: RngIntElt                    Default: 8
Given a point P on an elliptic curve defined over a number field K, and a place Pl (finite or infinite) of K, returns the local height λPl(P) of P at (Pl). The parameter Precision sets the precision of the output. A value of 0 takes the default precision.

When Pl is an infinite place, the parameter Extra can be used to remedy the huge loss in precision when one of the points 2n P gets too close to the point at infinity.

Two Descent

The functions here have similar syntax to the corresponding ones for curves over Q. The current implementation from 2011 is the first complete implementation of 2-descent over number fields. Previously there have been several implementations that are effective for computing rank bounds, but not for obtaining nice models of the 2-coverings which is necessary in order to search for points. Some of the key ingredients here are the routine for solving conics over number fields (see HasRationalPoint), and techniques for minimisation and reduction over number fields developed by Donnelly and Fisher.

TwoDescent(E: parameters) : CrvEll -> [CrvHyp] , [Map] , Map
    RemoveTorsion: BoolElt              Default: false
    RemoveGens: { PtEll }               Default: { }
    WithMaps: BoolElt                   Default: true
    MinRed: BoolElt                     Default: 
    SetVerbose("TwoDescent", n):        Maximum: 1
This function has the same arguments and return values as the corresponding function for curves over Q. It returns the 2-coverings as a sequence of hyperelliptic curves, and a corresponding list of maps.

Additionally, it returns a third object which specifies the group structure on the 2-coverings. This is a map (with inverse) from an abstract group to the sequence of 2-coverings; the abstract group is either TwoSelmerGroup(E), or the appropriate quotient in the case where RemoveTorsion or RemoveGens are specified.

Currently, there is an additional optional argument MinRed, which controls whether the coverings are minimised and reduced. (This may be expensive for various reasons, especially when the field discriminant is not small: for one thing, a large integer may need to be factored.)

TwoCover(e) : FldNumElt -> CrvHyp, Map
TwoCover(e) : RngUPolResElt -> CrvHyp, Map
The purpose of this function is to obtain 2-covers arising in TwoDescent individually rather than all together.

The argument e is an element of a cubic extension A/F, where F is a number field, and where A may be either a number field over F or an affine algebra over F. The element e determines a 2-cover of some elliptic curve over F (by the construction given in the description of DescentMaps in the next section).

Selmer Groups

First we give a short overview of the theory of Selmer groups. This enables us to fix the notation that is used in the naming of the Magma functions. For a more complete account, see [Sil86]. The actual algorithms to compute the Selmer groups are closer to the description in [Cas66].

Let E', E be elliptic curves over a number field K and let φ:E' to E be an isogeny. The only cases currently implemented are where φis a 2-isogeny, i.e., an isogeny of degree 2, and where E'=E and φis multiplication by 2.

Let E'[φ] be the kernel subscheme of φ. By taking Galois cohomology of the short exact sequence of schemes over K, 0to E'[φ]to E'to E to 0, we obtain E'(K)to E(K)to H1(K, E'[φ]) to H1(K, E'). For the middle map, we write μ:E(K)to H1(K, E'[φ]). Thus, E(K)/φ(E'(K)) injects in H1(K, E'[φ]) and the image consists exactly of the cocycles that vanish in H1(K, E').

As an approximation to this image, we define the φ-Selmer group of E over K to consist of those cocycles H1(K, E'[φ]) that vanish in all restrictions H1(Kp, E'), where p runs though all places of K. It fits in the exact sequence

0to S(φ)(E/K)to H1(K, E'[φ])to ∏p H1(Kp, E')

The main application of Selmer groups is that they provide the bound: #E(K)/φE'(K)≤# S(φ)(E/K). If φ^ * :E to E' is the isogeny dual to φ, then φφ^ * :E to E is multiplication by d=( Deg)(φ). Thus, one can use the φand φ^ * Selmer groups to provide a bound on #E(K)/dE(K) and thus on the Mordell--Weil rank of E(K).

Representation of H1(K, E'[φ]):

If φis a 2-isogeny, then H1(K, E'[φ])~K^ * /K * 2. Thus, we can represent elements by δ∈K^ *. In Magma, the map μcorresponds to a representation of the map E(K)to K^ *. The map μalso accepts just x-coordinates.

If φis multiplication-by-2 and E : y2=f(x), we write A=K[x]/(f(x)) then H1(K, E[2])~{δ∈A^ * /A * 2| NA/K(δ)∈K * 2}. In fact, the full set A^ * /A * 2 corresponds to H1(K, E[2] x {+- 1}).

The set H1(K, E'[φ]) also corresponds to the set of covers τδ:Tδto E over K, modulo isomorphy over K, that are isomorphic to φ:E'to E over the algebraic closure of K (see [Sil86], Theorem X.2.2). In this section, we write tor for the map δ|-> τδ.

DescentMaps(phi) : Map -> Map, Map
CasselsMap(phi) : Map -> Map, Map
    Fields: SetEnum                     Default: { }
Given an isogeny φ: E to E1 of elliptic curves over a number field K (or Q), the function returns the connecting homomorphism μ: E1(K) to H1(K, E[φ]), and a map τsending an element of H1(K, E[φ]) to the corresponding homogeneous space. Here elements of H1(K, E[φ]) are represented as elements of A^ * /(A^ * )2 (as described above). The maps are actually given as maps to, and from, A (rather than A^ * /(A^ * )2).

The isogeny φmust be either a 2-isogeny or multiplication--by--2.

When φis multiplication--by--two, then the computation of μinvolves a call to AbsoluteAlgebra. The optional parameter Fields is passed on to that. If the fields mentioned in this set are found to be of any use, then these will be used and whatever class group and unit data stored on the fields will be used in subsequent computations.

When φis multiplication--by--two, the second map τaccepts all elements δ∈A^ *. An element δ∈A^ * represents an element of H1(K, E[2]) if and only if δmust have square norm. In general, δ∈A^ * represents an element of H1(K, E[2] x {+- 1}), in which case τ(δ) is the corresponding covering Tδto( P)1. (This covering is a twist of the covering E to E to ( P)1 given by P |-> 2P |-> x(2P).)

SelmerGroup(phi) : Map -> GrpAb, Map, Map, SeqEnum, SetEnum
    Hints: SetEnum                      Default: { }
    Raw: BoolElt                        Default: false
    Bound: RngIntElt                    Default: -1
    SetVerbose("Selmer", n):            Maximum: 2

Given an isogeny φ: E to E1 defined over a number field K, computes the associated Selmer group Sel(φ) := Selφ(E/K).

The Selmer group is returned as a finite abelian group S, together with a map AtoS : A to S, where A is as in the introduction. This is a map only in the Magma sense; it is defined only on a finite subset of A. Its "inverse" S to A provides the mathematically meaningful injection S -> A^ * /(A^ * )2. The standard map E1(K) to E1(K)/φE(K) to Sel(φ) is given by the composition of μwith AtoS, where μ: E1(K) to H1(K, E[φ]) is the first map returned by DescentMaps.

If the optional parameter Hints is given, it is used as a list of x-coordinates to try first when determining local images. Supplying Hints does not change the outcome, but may speed up the computation.

The calculation of the Selmer group involves possibly expensive class group and unit group computations. If no such data has been precomputed, SelmerGroup will attempt to obtain this information unconditionally, unless Bound is positive. This bound is then passed on to any called ClassGroup. However, if such data is already stored, it will be used and subsequent results will be conditional on whatever assumptions were made while computing this information. If conditional results are desired (for instance, assuming GRH), one should precompute class group information on the codomain of CasselsMap(phi) prior to calling SelmerGroup(phi).

If Raw is true, then three technical items are also returned. The first two of these, toVec and FB, enable one to represent elements of the Selmer group in terms of a "factor base" FB consisting of elements of A that generate a relevant subgroup of A^ * /(A^ * )2. The map toVec sends an element of S to an exponent vector relative to FB. The map from S to A obtained by multiplying out the results is inverse to AtoS.

The final returned value (when Raw is true) is a set of Hints (just as in the optional parameter).

TwoSelmerGroup(E) : CrvEll -> GrpAb, Map, SetEnum, Map, SeqEnum
    Hints: SetEnum                      Default: { }
    Raw: BoolElt                        Default: false
    Bound: RngIntElt                    Default: -1
    SetVerbose("EllSelmer", n):         Maximum: 2
The 2-Selmer group of an elliptic curve defined over Q or a number field. The function simply calls SelmerGroup for the multiplication--by--two isogeny. The given model for E should be integral. The options and return values are the same as for SelmerGroup.

Example CrvEllQNF_selmer (H122E35)

In this example, we determine the rank of y2 = x3 + 9x2 - 10x + 1 by computing the 2-Selmer group.

> E := EllipticCurve([0,9,0,-10,1]);
> two := MultiplicationByMMap(E,2);
> mu, tor := DescentMaps(two);
The hard work: computing the Selmer group.

> S, AtoS := SelmerGroup(two);
> #S;
8
So the Selmer rank is 3. We deduce the following upper bound on the rank of E(Q), taking into account any 2-torsion.

> RankBound(E : Isogeny := two);
3
In fact, there are 3 points: (0, 1), (1, 1) and (2, 5).

> g1 := E![ 0, 1 ];
> g2 := E![ 1, 1 ];
> g3 := E![ 2, 5 ];
We now test these points for linear independence. It will follow that the points generate E(K)/2E(K), which means they are independent nontorsion points in E(K) (since we know there is no 2-torsion).

> IsLinearlyIndependent ([g1, g2, g3]);
true
Next we compute the homogeneous space associated to the point g1 + g2. It must have a rational point mapping to g1 + g2. Note that @@ always denotes "preimage" in Magma. The algebra for AtoS is not the same as the original cubic, so we must translate before applying the requisite map.

> K := NumberField(Modulus(Domain(AtoS)));
> L := NumberField(Polynomial([1,-10,9,1]));
> b, m := IsIsomorphic (K, L); assert b;
> theta := (Rationals()! (L.1 - m(K.1))) + Domain(AtoS).1;
> H, mp := TwoCover((g1+g2)[1] - theta : E:=E); H;
Hyperelliptic Curve defined by y^2 = 9*x^4 - 4*x^3 - 18*x^2 + 4*x + 13
The next command finds all Q-rational points in the preimage of the point g1 + g2 on E. (In Magma the preimage is constructed as a scheme.)

> RationalPoints( (g1+g2) @@ mp);
{@ (-1 : -2 : 1) @}

Example CrvEllQNF_selmer2 (H122E36)

We consider the elliptic curve E : y2 = dx(x + 1)(x + 3) where d is the product of the primes less than 50. Since E has full 2-torsion, we can carry out 2-isogeny descent in three non-equivalent ways, resulting in three different rank bounds.

> P<x> := PolynomialRing(Integers());
> d := &*[ p : p in [1..50] | IsPrime(p) ];
> E := EllipticCurve(HyperellipticCurve(d*x*(x + 1)*(x + 3)));
The nontrivial 2-torsion points in E(Q):

> A, mp := TorsionSubgroup(E);
> T := [ t : a in A | t ne E!0 where t := mp(a) ];
The corresponding 2-isogenies:

> phis := [ TwoIsogeny(t) : t in T ];
The rank bounds obtained from these isogenies:

> [ RankBound(E : Isogeny := phi) : phi in phis ];
[ 9, 5, 7 ]
We find [9, 5, 7]! Each descent gives a different rank bound. However, a full 2-descent gives:

> two := MultiplicationByMMap(E,2);
> RankBound(E : Isogeny := two);
1
Now doing full 2-descent on the three isogenous curves, we see where the obstacle for sharp rank bounds comes from.

> OtherTwos := [ MultiplicationByMMap(Codomain(phi), 2) : phi in phis ];
> [ RankBound(Domain(two) : Isogeny := two) : two in OtherTwos ];
[ 9, 5, 7 ]
We find [9, 5, 7] again.

Example CrvEllQNF_selmer3 (H122E37)

The next example is a classic one from [Kra81].

> E := EllipticCurve([0, 977, 0, 976, 0]);
> twoE := MultiplicationByMMap(E, 2);
> muE := CasselsMap(twoE);
> SE, toSE := SelmerGroup(twoE);
> rkEQ := RankBound(E);
> ptE := [ E | [-4, 108], [4, 140] ]; // ignore torsion
> IsLinearlyIndependent (ptE);
true
> // So E is really of rank 2
> d := 109;
> Ed := QuadraticTwist(E, d);
> Ed![ -976, -298656, 1];
(-976 : -298656 : 1)
> // So Ed is of rank at least 1
> rkEdQ := RankBound(Ed);
> _<x> := PolynomialRing(Rationals());
> K := NumberField(x^2 - d);
> EK := BaseChange(E, K);
> rkEK := RankBound(EK);
> rkEQ;
2
> rkEdQ;
3
> rkEK; 
3
We know that the rank of Ed(Q) must be the rank of E(K) minus the rank of E(Q); thus Ed(Q) has rank 1. This is smaller than the bound of 3 we get from a 2-descent on Ed alone.

Example CrvEllQNF_selmer4 (H122E38)

Here we give some examples of using TwoDescent, TwoSelmerGroup, and TwoCover.

> E := EllipticCurve( [ 0, 0, 1, -7, 6] ); // rank 3 curve
> T := TwoDescent(E);
> T[6];
Hyperelliptic Curve defined by y^2 = 3*x^4 - 10*x^3 + 10*x + 1 over
Rational Field
> G, m := TwoSelmerGroup(E);
> G.1 @@ m;
theta^2 - 12*theta + 33
> Parent($1); // Modulus has y^2 = modulus isomorphic to E
Univariate Quotient Polynomial Algebra in theta over Rational Field
with modulus theta^3 - 112*theta + 400
> TwoCover( (G.1 + G.2) @@ m);
Hyperelliptic Curve defined by y^2 = 3*x^4 - 10*x^3 + 10*x + 1 over
Rational Field
> TwoCover( Domain(m) ! 1 );
Hyperelliptic Curve defined by y^2 = 2*x^3 - 12*x^2 - 32*x + 196 over
Rational Field

The Cassels-Tate Pairing

The pairing between elements of the 2-Selmer group is implemented, in the same way as for curves over the rationals. This is described in Section The Cassels-Tate Pairing.

Elliptic Curve Chabauty

This refers to a method for finding the rational points on a curve, if the curve admits a suitable map to an elliptic curve over some extension field. The method was developed principally by Nils Bruin (see [Bru03] or [Bru04]). The first intrinsic follows a Mordell-Weil sieve based strategy, similar to that used in Chabauty for genus 2 curves (see [BS10]).

Chabauty(MWmap, Ecov) : Map, MapSch -> SetEnum, RngIntElt
    InertiaDegreeBound: RngIntElt       Default: 20
    SmoothBound: RngIntElt              Default: 50
    PrimeBound: RngIntElt               Default: 30
    IndexBound: RngIntElt               Default: -1
    InitialPrimes: RngIntElt            Default: 50
    SetVerbose("EllChab", n):           Maximum: 3
Let E be an elliptic curve defined over a number field K. This function attempts to determine the subset of E(K) consisting of those points that have a Q-rational image under a given map E to ( P)1.

The arguments are as follows:

a map MWmap: A to E from an abstract abelian group into E(K) (for instance, the map returned by PseudoMordellWeilGroup),
A map Ecov : E to( P)1 defined over K.

The returned values are a finite subset V of A and an integer R. The set V consists of all the points in the image of A in E(K) that have a Q-rational image under the given map Ecov. If the index of A in E(K) is finite and coprime to R then V consists of all points in E(K) with Q-rational image. Changing the various optional parameters can change the performance of this routine considerably. In general, it is not proven that this routine will return at all.

The parameter InertiaDegreeBound determines the maximum inertia degree of primes at which local information is obtained.

Only places at with the group order of the rational points on the reduction of E are SmoothBound-smooth are used.

The Mordell-Weil sieving process only uses information from E(K)/ B E(K), where B is PrimeBound-smooth.

If IndexBound is set to a value different from -1, then the returned value R will only contain prime divisors from IndexBound. Setting this parameter may make it impossible for the routine to return.

Chabauty(MWmap, Ecov, p) : Map, MapSch, RngIntElt -> RngIntElt, SetEnum, RngIntElt, Tup
    Cosets: Tup                         Default: 
    Aux: SetEnum                        Default: 
    Precision: RngIntElt                Default: 
    Bound: RngIntElt                    Default: 
    SetVerbose("EllChab", n):           Maximum: 3
Let E be an elliptic curve defined over a number field K. This function bounds the set of points in E(K) whose images under a given map E to ( P)1 are Q-rational.

The arguments are as follows:

a map MWmap : A to E from an abstract group into E(K) (for instance, the map returned by PseudoMordellWeilGroup),
a map of varieties Ecov : E to( P)1 defined over K, and
a rational prime p, such that E and the map Ecov have good reduction at primes above p.

The returned values are N, V, R and L as follows. Let G denote the image of A in E(K).
N is an upper bound for the number of points P ∈G such that ( Ecov)(P) ∈( P)1(Q) (note that N can be ∞).
V is a set of elements of A found by the program that have images in ( P)1(Q),
R is a number with the following property: if [E(K) : G] is finite and coprime to R, then N is also an upper bound for the number of points P ∈E(K) such that ( Ecov)(P) ∈( P)1(Q), and
L is a collection of cosets in A such that (bigcup L)∪V contains all elements of A that have images in ( P)1(Q).

If Cosets (<Cj>) are supplied (a coset collection of A), then the bounds and results are computed for A ∩(bigcup Cj).

If Aux is supplied (a set of rational primes), then the information at p is combined with the information at the other primes supplied.

If Precision is supplied, this is the p-adic precision used in the computations. If not, a generally safe default is used.

If Bound is supplied, this determines a search bound for finding V.

The algorithm used is based on [Bru03] and [Bru02].

For examples and a more elaborate discussion, see [Bru04].


Example CrvEllQNF_ECchabauty (H122E39)

This example is motivated and explained in great detail in [Bru04] (Section 7). Let E be the elliptic curve y2 = x3 + ( - 3ζ3 - ζ+ 1)dx2 + ( - ζ2 - ζ- 1)d2x, d = 2ζ3 - 2ζ2 - 2 over K := Q(ζ) where ζis a primitive 10th root of unity.

> _<z> := PolynomialRing(Rationals());
> K<zeta> := NumberField(z^4-z^3+z^2-z+1);
> OK := IntegerRing(K);
> d := 2*zeta^3-2*zeta^2-2;
> E<X,Y,Z> := EllipticCurve(
>         [ 0, (-3*zeta^3-zeta+1)*d, 0, (-zeta^2-zeta-1)*d^2, 0 ]);
Next we determine as much as possible of E(K), allowing Magma to choose the method.

> success, G, GtoEK := PseudoMordellWeilGroup(E);
> G;
Abelian Group isomorphic to Z/2 + Z/2 + Z + Z
Defined on 4 generators
Relations:
    2*G.1 = 0
    2*G.2 = 0
> success;
true
Here G is an abstract group and GtoEK injects it into E(K). Since the flag is true, this is a subgroup of finite, odd index in E(K). Next, we determine the points (X:Y:Z) in this subgroup for which the function u : E to ( P)1 : (X:Y:Z) to d ( - X + (ζ3 - 1) Z : X + d ( - ζ3 - ζ) Z) takes values in ( P)1(Q).

> P1 := ProjectiveSpace(Rationals(),1);
> u := map< E->P1 | [-X + (zeta^3 - 1)*d*Z, X+(-zeta^3-zeta)*d*Z] >;
> V, R := Chabauty( GtoEK, u);
> V;
{
    0,
    G.3 - G.4,
    -G.3 + G.4,
    G.3 + G.4,
    -G.3 - G.4
}
> R;
320
We see that the routine assumed that the image of GtoEK is 2- and 5-saturated in E(K). We can ask it to not assume anything outside 2.

> V2, R := Chabauty( GtoEK, u: IndexBound:= 2);
> V eq V2;
true
> R;
16
This means that we have found all points in E(K) that have a rational image under u. If one wants to find the images of these points then it is necessary in this example to first extend u (by finding alternative defining equations for it) so that it is defined on all the points.

> u := Extend(u);
> [ u( GtoEK(P) ) : P in V ];           
[ (-1 : 1), (-1/3 : 1), (-1/3 : 1), (-3 : 1), (-3 : 1) ]
Alternatively, we can apply Chabauty's method without Mordell-Weil sieving.

> N, V, R, C := Chabauty( GtoEK, u, 3);
> N;
5
> V;
{
    0,
    G.3 - G.4,
    -G.3 + G.4,
    G.3 + G.4,
    -G.3 - G.4
}
> R;
4
The Chabauty calculations prove that there are at most N elements in G whose image under u is Q-rational. Also, V is a set of elements with this property. Since here N = 5 = #V, these are the only such elements. Moreover, the calculations prove that if [E(K) : G] is coprime to R, then N is actually an upper bound on the number of elements in E(K) whose image under u is Q-rational. We know from the PseudoMordellWeilGroup computation that [E(K) : G] is odd. Therefore we have solved our problem for E(K), not just for G.

Auxiliary Functions for Etale Algebras

This section contains machinery for number fields (and more generally "etale algebras", i.e. algebras of the form Q[x]/p(x)), intended to perform the number field calculations that are involved in computing Selmer groups of geometric objects.

It has become conventional to refer to "the p-Selmer group" of a number field K (or, more generally, of an etale algebra) relative to a finite set S of K-primes. It means the finite subgroup K(S, p) of K^ * /(K^ * )p, consisting of those elements whose valuation at every prime outside S is a multiple of p.

AbsoluteAlgebra(A) : RngUPolRes -> SetCart, Map
    Fields: SetEnum                     Default: { }
    SetVerbose("EtaleAlg", n):          Maximum: 1
Given a separable commutative algebra over Q, an absolute number field or a finite field, the function returns the isomorphic direct sum of absolute fields as a cartesian product and the isomorphisms to and from this product. The optional parameter Fields enables the user to suggest representations of the absolute fields. If this function finds it needs a field isomorphic to one occurring in the supplied list, then it will use the given field. Otherwise it will construct a field itself. The isomorphism is returned as a second argument. If called twice on the same algebra, it will recompute if the Fields argument is given. Otherwise it will return the result computed the first time.
pSelmerGroup(A, p, S) : RngUPolRes, RngIntElt, SetEnum[RngOrdIdl] -> GrpAb, Map
    SetVerbose("EtaleAlg", n):          Maximum: 1
Returns the p-Selmer group of a semi-simple algebra A. The set S of ideals should be prime ideals of the underlying number field. The group returned is the direct sum of the p-Selmer groups of the irreducible summands of A and the map is the obvious embedding in the multiplicative group of A. An implied restriction is that BaseRing(A) be of type FldNum. See also pSelmerGroup. If an algebra over the rationals is required, create a degree 1 extension by

RationalsAsNumberField();

LocalTwoSelmerMap(P) : RngOrdIdl -> Map
Let K be the number field associated with the prime ideal P. The map returned is K^ * to KP^ * / KP * 2, where KP is the completion of K at P. The codomain is represented as a finite abelian group.
LocalTwoSelmerMap(A, P) : RngUPolRes, RngOrdIdl -> Map, SeqEnum
Let K be the base field of the commutative algebra A and let P be a prime ideal in K. Then this function returns a map A^ * to A^ * /A * 2 tensor KP, where KP is the completion of K at P. The codomain is represented as a finite abelian group.

This map is computed by using LocalTwoSelmerMap(Q) for the various extensions Q of P to the fields making up AbsoluteAlgebra(A). The map returned is essentially the direct sum of all these maps. For technical purposes, one may also wish to use the components of the map coming from each number field; these are given by the second return value, which is a sequence of records (ordered in the same way as the results are concatenated in the returned map). Each record contains items i, p, map and vmap. Here i is an index indicating which number field in AbsoluteAlgebra(A) the record corresponds to, p is an extension of P to a prime in that number field, map is LocalTwoSelmerMap(p), and vmap is the valuation map at p on that number field.


Example CrvEllQNF_selmer-etale (H122E40)

> P<x> := PolynomialRing(Rationals());
> A := quo<P | x^3 - 1>;
> AA := AbsoluteAlgebra(A);
> AA;
Cartesian Product
<Number Field with defining polynomial x - 1 over the Rational Field,
 Number Field with defining polynomial x^2 + x + 1 over the Rational Field>

Analytic Information

RootNumber(E, P) : CrvEll, RngOrdIdl -> RngIntElt
The local root number of the elliptic curve E (defined over a number field) at the prime ideal P. The formulae are due to Rohrlich, Halberstadt, Kobayashi and the Dokchitser brothers.
RootNumber(E) : CrvEll -> RngIntElt
Calculates the global root number of an elliptic curve E defined over a number field K. This is the product of local root numbers over all places of K (-1 from each infinite place), and is the (conjectural) sign in the functional equation relating L(E/K, s) to L(E/K, 2 - s).
AnalyticRank(E) : CrvEll -> RngIntElt, FldReElt
    Precision: RngIntElt                Default: 6
Determine the analytic rank of the elliptic curve E, which is defined over a number field K. The algorithm used is heuristic, computing derivatives of the L-function L(E/K, s) at s=1 until one appears to be nonzero; it also assumes the analytic continuation and the functional equation for the L-function. The function returns the first nonzero derivative L(r)(1)/r! as a second argument. The precision is optional, and is taken to be 6 digits if omitted.
ConjecturalRegulator(E) : CrvEll -> FldReElt, RngIntElt
    Precision: RngIntElt                Default: 10
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.
ConjecturalSha(E, Pts) : CrvEll, SeqEnum[PtEll] -> FldReElt
    Precision: RngIntElt                Default: 6
For an elliptic curve E defined over a number field K and a sequence of points in E(K) which purpotedly form its basis modulo torsion, computes the conjectural order of the Tate-Shafarevich group Sha(E/K). This function computes the product of the regulator and Sha from the Birch--Swinnerton-Dyer conjecture (using ConjecturalRegulator) and divides by the determinant of the height pairing matrix for the points supplied in Pts. It returns 0 if the points are linearly dependent or they generate a group of rank less than the analytic rank. If the points generated a subgroup of index n>1, it returns n2.|Sha|.

Elliptic Curves of Given Conductor

This section describes search routines for finding elliptic curves with given conductor, or with good reduction outside a given set of primes. The aim is not to provably find all such curves; in most cases, this would be a very difficult task using current algorirthms. Rather the aim is to efficiently search for these curves, using a variety of techniques, taking advantage of all available information, and taking advantage of all the tools available in Magma which can be applied to the problem.

The routine is particularly effective when some traces of Frobenius of the desired are specified. The obvious application here is to find an elliptic curve that matches a known modular form.

These functions can be used to find elliptic curves over Q, as well as number fields, by using RationalsAsNumberField().

EllipticCurveSearch(N, Effort) : RngOrdIdl, RngIntElt -> SeqEnum
EllipticCurveWithGoodReductionSearch(S, Effort) : Set, RngIntElt -> SeqEnum
EllipticCurveWithGoodReductionSearch(N, Effort) : Set, RngIntElt -> SeqEnum
    Full: BoolElt                       Default: false
    Max: RngIntElt                      Default: 
    Primes: SeqEnum                     Default: 
    Traces: SeqEnum                     Default: 
    SetVerbose("ECSearch", n):          Maximum: 2
These functions perform a search for elliptic curves with specified conductor(s). The first function finds curves with conductor equal to the given ideal N; the "good reduction" functions find curves with conductors divisible only by primes that belong to the given set S (or that divide the given ideal N). The functions return a sequence containing all such curves that were found. This sequence will not contain curves that are isomorphic to each other. It may contain isogenous curves, however no attempt is made to find full isogeny classes.

The second argument, Effort, is an integer which controls how much effort is used before returning; the running time depends on this variable in a roughly linear way, except with significant step-ups at values where an additional technique begins to be used. Currently, Effort := 400 is the smallest value which tries all available techniques (however this is subject to change).

There are two ways to specify an early stopping condition:

(i)
If the optional argument Max is set to some positive integer, the routine will return whenever this many non-isogenous curves have been found.

(ii)
The optional arguments Primes and Traces, which must correspond to eachother, may be used to specify some traces of Frobenius of the desired curve(s). Here Primes is a sequence of prime ideals coprime to the conductor(s), and Traces is a sequence of integers of the form [aP : P in (Primes) ]. Alternatively, to search for several curves with different traces, Traces may instead by a sequence of sequences of that form.

If an early stopping condition has been specified, the routine initially tries with lower effort, in order to succeed quickly for easier input; the effort is incremented exponentially up to the specified Effort level. (This strategy is desirable because the algorithm involves performing a large number of independent searches in alternation.) However if the option Full is set, the full specified Effort is used from the beginning.

If SetVerbose("ECSearch", 1) is used, information about the search is printed during computation. In particular, curves with the desired conductor are printed when they are found, so that they can be obtained without waiting for the routine to finish.

 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Wed Apr 24 15:09:57 EST 2013