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 can be obtained using IntegralModel or, more usefully, MinimalModel.
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(Q_p) of the subgroup E^0(Q_p) 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 5-tuple, consisting of p, its multiplicity in the discriminant, its multiplicity in the conductor, the Tamagawa number at p and the Kodaira symbol.
Given an elliptic curve E this function returns a sequence of tuples, each of which contains the local information at a bad prime. The tuples consist of a bad prime p, its multiplicity in the discriminant, its multiplicity in the conductor, the Tamagawa number at p and the Kodaira symbol.
Returns a string describing the reduction type: the possibilities are "Good", "Additive", "Split multiplicative" or "Unsplit 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.
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.
> S := [ ];
> for n := 2 to 200 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> ]
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 this case a warning message will be printed the first time the rank of a particular curve is computed. The use of RankBounds below is recommended in such situations.
Bound: RngIntElt Default: 150
Given an elliptic curve E defined over Q, this 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.
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 Rank, above. This function will not generate the usual warning message if the upper and lower bounds are not equal.
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 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 be infeasible.
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 C_k (for k in {1..10} or 12) or C_2 x C_(2k) (for k in {1..4}). If there are two generators then the first generator returned in this case will have order 2.
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.
The number of generators of the group of rational points of 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>, <73, 3, 2, 2, III> ]
> 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), (657/4 : 16863/8 : 1) ]
> 2*m(G.1);
(0 : 1 : 0)
> E := EllipticCurve([0, 0, 0, -9217, 300985]); > T, h := TorsionSubgroup(E); > T; Abelian Group of order 1 > time RankBounds(E); 7 7 Time: 0.190This 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.090 > RankBounds(E); 2 4The 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. In cases like this higher level descents may provide a more definitive answer; these will be implemented in an upcoming version of Magma. 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; [ (-7 : 1 : 1), (-6 : 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); (-26478766/4405801 : 10120560101/9247776299 : 1) > 2*S[1] + 3*S[2]; (-26478766/4405801 : 10120560101/9247776299 : 1)As it turns out, 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.
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|}.
SmallPrimesBound: RngIntElt Default: 1000
Given a point P on an elliptic curve E defined over Q with integral coefficients, this function returns the canonical height of P. The parameter SmallPrimesBound is used to set the bound for an integer trial division used internally by the algorithm.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.
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.
SmallPrimesBound: RngIntElt Default: 1000
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. The parameter SmallPrimesBound is used to set the bound for an integer trial division used internally by the algorithm.
Given a sequence of points S on an elliptic curve E over Q, returns the determinant of the N'eron-Tate height pairing matrix of the sequence.
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]); > RankBounds(E); 3 3 > P1, P2, P3 := Explode(Generators(E)); > Height(P1); 0.9909063331530876261 > Abs(Height(2*P1) - 4*Height(P1)) lt 10^-9; 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; (-3 : 0 : 1) > LocalHeight(P2, 0); 1.501924536613018057 > LocalHeight(P2, 5077); 0.E-92 > Height(P2); 1.501924536613018057The above shows that the local height at a bad prime may still be zero.
Given an elliptic curve E over Q with integral coefficients, this returns the Silverman bound of E. For any point P on E we will have NaiveHeight(P) - Height(P) <= B, where B is this bound.
Torsion: BoolElt Default: false
Given an elliptic curve E over Q which is a minimal model, this returns the Siksek bound of E. For any point P on E we will have NaiveHeight(P) - Height(P) <= B, where B is this bound. In general, 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). This is the bound used internally during the group closure computation.
> 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.70818965430290161142481294545This 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.0309876231179839831829512652688Here 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
Returns true if and only if points P and Q independent (modulo torsion points) free elements of the group of rational points of an elliptic curve. If false, the function returns a vector v = (r, s) as a second value such that rP + sQ is a torsion point.
Returns true if and only if the sequence S of points is linearly independent (modulo torsion). If false, 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.
> 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); trueWe now demonstrate solving for a nontrivial linear dependence of points on an elliptic curve by constructing a singular matrix, form the corresponding linear combination of points, and establish 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 size 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: 50
Returns the sequence of periods of the Weierstrass wp-function associated to E, to Precision digits. The first element of the sequence is the real period.
Precision: RngIntElt Default: 50
Returns the real period of the Weierstrass wp-function associated to E to Precision digits.
Precision: RngIntElt Default: 50
Denote by omega_1, omega_2 the periods of the Weierstrass wp-function related to E. This function returns the elliptic logarithm phi(P), such that -omega_1/2 <= ((Re))(phi(P)) < omega_1/2 and -omega_2/2 <= ((Im))(phi(P)) < omega_2/2. The value is returned to Precision digits.
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.[Next][Prev] [Right] [Left] [Up] [Index] [Root]