|
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.
Note that functions related to Mordell--Weil groups and descent
are in Section Mordell--Weil Groups and Descent Methods rather than this section.
The routines listed here, when nontrivial, are based on an implementation
of Tate's algorithm.
The conductor is part of the data computed by LocalInformation
(described below).
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.
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.
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.
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.
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.
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.
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.
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.
Compute the height pairing matrix for an array of points.
Same parameters as above.
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.
HeightDifferenceLowerBound(E) : CrvEll -> FldReElt
HeightDifferenceUpperBound(E) : CrvEll -> FldReElt
These functions return bounds for the difference between the
naive and canonical heights on the elliptic curve E.
Here all heights are absolute logarithmic heights with respect to
the x-coordinate on E.
The functions return real numbers l and u such that
l ≤ NaiveHeight(P) - Height(P) ≤u
for all points P ∈E(K), where K is the base field of E.
Note that the lower bound l is negative.
The bounds are the strongest available, choosing between the
Cremona--Prickett--Siksek bounds and the Silverman bounds.
The Cremona--Prickett--Siksek bounds for the height difference.
The Silverman bounds for the height difference.
FBasis: [ PtEll ] Default:
SafetyFactor: RngIntElt Default: 2
Given an elliptic curve E over a number field which is a direct extension of the rational field, this intrinsic returns a sequence containing
all integral points on the given model of E, up to sign (only one of P and -P
is listed).
The parameters FBasis and SafetyFactor have exactly the same meaning
as in the function IntegralPoints for curves over Q.
Currently, FBasis must be specified: it must be a (nonempty) sequence
of points in the Mordell--Weil group of E. The routine finds all integral points
in the group generated by the given points.
The base field of E must also current be totally real and E must have nontrivial torsion.
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 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]).
InertiaDegreeBound: RngIntElt Default: 20
SmoothBound: RngIntElt Default: 50
PrimeBound: RngIntElt Default: 30
IndexBound: RngIntElt Default:
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 -> (P)1.
The arguments are:
 - a map MWmap: A -> E from an abstract abelian group into E(K),
- a map Ecov : E -> (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 for which the group order of the rational points on the reduction of E is
smooth relative to SmoothBound are used.
The Mordell--Weil sieving process only uses information from E(K)/ B E(K), where B is
smooth relative to PrimeBound.
If IndexBound is specified, then the returned value R will only contain prime divisors
from IndexBound. Setting this parameter may make it impossible for the routine to terminate.
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 -> (P)1 are Q-rational.
The arguments are as follows:
- a map MWmap : A -> E from an abstract group into E(K)
(as returned by MordellWeilGroup),
- a map of varieties Ecov : E -> (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].
Further examples and discussion can be found in [Bru04].
This example is motivated and explained in 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 -> (P) 1 : (X:Y:Z) -> 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.
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.
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.
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();
Let K be the number field associated with the prime ideal P.
The map returned is
K * -> KP * / KP * 2, where KP is the completion of K at P.
The codomain is represented as a finite abelian group.
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 * -> 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.
> 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>
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.
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).
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.
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.
Precision: RngIntElt Default: 6
For an elliptic curve E defined over a number field K
and a sequence of points in E(K) which purportedly 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|.
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 algorithms.
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 very much more effective when some traces of Frobenius
are known for the desired curve. The principal application of this is
for finding elliptic curves that match known modular forms.
These functions are effective for finding elliptic curves over Q,
as well as over number fields. For this, one must create Q using
RationalsAsNumberField().
EllipticCurveWithGoodReductionSearch(S, Effort) : Set, RngIntElt -> SeqEnum
EllipticCurveWithGoodReductionSearch(N, Effort) : RngOrdIdl, 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 aim to find as many distinct isogeny classes as possible
(or Max classes, if Max is specified). A sequence is returned
containing all curves found that have the specified conductor(s).
It will not return more than one curve in the same isomorphism class.
It may return several curves in the same isogeny class, although no attempt
is made to find all isogenous curves.
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 where all available techniques are used. (This may
be changed in the future.)
There are two ways to specify an early stopping condition:
- (i)
- If the optional argument Max is set to some positive integer, the
routine terminates as soon as Max non-isogenous curves are found.
- (ii)
- The optional arguments Primes and Traces may be used together
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 ∈(Primes) ].
Alternatively, Traces may be a sequence of sequences of that form.
The routine aims to find curves whose traces match the specified sequences,
and terminates as soon as one curve of each kind has been found. The algorithm
uses the trace information to cut down the search by a large factor.
Warning: ALL curves found during the search are returned
(possibly including curves whose traces do not match the specified data).
If an early stopping condition has been specified, the routine initially
tries with lower effort, so that it will succeed quickly for easier input.
The effort is incremented exponentially up to the specified Effort.
(This is a breadth-first search strategy. The algorithm involves doing a
large number of independent searches, and each elliptic curve can be found
in only one of these searches, so it is necessary to alternate between them.
There is no way to reliably predict how much effort will be needed, but the
search usually takes far longer when the effort is larger than necessary.)
To override this behaviour and begin with the full specified Effort,
the option Full should be used. (This is intended for the case
where the same search has already been done with a lower Effort).
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]
|