φ-Selmer
group.
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.
> 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.
> 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 FieldAlternatively, 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 theorem states that for an elliptic curve E defined over Q, the set E(Q) of points on E with Q-rational coordinates forms a finitely generated abelian group, known as the Mordell--Weil group.
To compute Mordell--Weil groups in Magma, there are several ways to proceed:
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 given elliptic curve E over Q. The tools used include 2-descent, 4-descent, Cassels-Tate pairings, 3-descent, and also analytic routines (rank and Heegner points) when the conductor of E is not too large. The information is progressively refined as the tools are applied (in order of their estimated cost), 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 (modulo the torsion subgroup) 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.
By default, the routine attempts to determine the rank and generators, and returns whenever it succeeds in determining them. When RankOnly is set to true, it returns as soon as the Mordell-Weil rank has been determined. When ShaInfo is set to true, it additionally probes the structure of Sha(E) using all available tools.
> E := EllipticCurve("389a1");
> time rank, gens, sha := MordellWeilShaInformation(E);
Torsion Subgroup is trivial
Analytic rank = 2
The 2-Selmer group has rank 2
Found a point of infinite order.
Found 2 independent points.
After 2-descent:
2 <= Rank(E) <= 2
Sha(E)[2] is trivial
(Searched up to height 100 on the 2-coverings.)
Time: 0.280
We now take a curve of conductor 571, which has rank 0 and
nontrivial Tate-Shafarevich group:
> E := EllipticCurve("571a1");
> time rank, gens, sha :=MordellWeilShaInformation(E);
Torsion Subgroup is trivial
Analytic rank = 0
==> Rank(E) = 0
Time: 0.010
We must specify that we want information about the Tate-Shafarevich group:
> time rank, gens, sha :=MordellWeilShaInformation(E : ShaInfo);
Torsion Subgroup is trivial
Analytic rank = 0
==> Rank(E) = 0
The 2-Selmer group has rank 2
After 2-descent:
0 <= Rank(E) <= 0
(Z/2)^2 <= Sha(E)[2] <= (Z/2)^2
(Searched up to height 10000 on the 2-coverings.)
The Cassels-Tate pairing on Sel(2,E)/E[2] is
[0 1]
[1 0]
After using Cassels-Tate:
0 <= Rank(E) <= 0
(Z/2)^2 <= Sha(E)[4] <= (Z/2)^2
The 3-Selmer group has rank 0
After 3-descent:
0 <= Rank(E) <= 0
(Z/2)^2 <= Sha(E)[12] <= (Z/2)^2
Time: 0.840
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.
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.
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.
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).
As explained above for Rank, the computed rank may be less than the actual rank. In cases where the rank is not proven, a warning message is printed (the first time). The best way to check whether the rank has been proven is to use RankBounds.
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 the elliptic curve E; this is simply the length of the sequence returned by Generators(E).
TorsionFree: BoolElt Default: false
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 TorsionFree is set to {tt true}, torsion points are omitted from the result (that is, the result contains independent generators modulo torsion). If Check is set to false, the input sequence of points are assumed to be independent modulo torsion.
> 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)
> E := EllipticCurve([0, 0, 0, -9217, 300985]); > T, h := TorsionSubgroup(E); > T; Abelian Group of order 1 > time RankBounds(E); 7 7 Time: 0.070This 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 3The 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.
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|}.
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:
Check: BoolElt Default: false
Renormalization: BoolElt Default: false
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. The Check vararg determines whether to check if the second argument is prime. The Renormalization vararg changes what definition of heights is used. Without this flag, a factor of (1/6)log Δv is added at every place.
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.
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éron-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éron-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.655035947159686182497278069814 > LocalHeight(P2, 5077); // 0 + Log(5077)/6 1.42207930249123238829272871637 > LocalHeight(P2, 0 : Renormalization); 0.767043355331546205795450646552 > LocalHeight(P2, 5077 : Renormalization); 0.000000000000000000000000000000 > Height(P2); 0.7670433553315462057954506466The above shows that the local height at a bad prime may still be zero, at least in the renormalised value.
Given an elliptic curve E over Q with integral coefficients, this function returns the Silverman bound B of E. For any point P on E we will have NaiveHeight(P) - Height(P) ≤B.
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) ≤B. 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).
> 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
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.
> 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.
> 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 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.
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.
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.
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.
This computes a minimal model of the quartic polynomial q over the rationals or a univariate rational function field.Three objects are returned: the minimised quartic, the transformation matrix, and the scaling factor.
For further explanation see Chapter MODELS OF GENUS ONE CURVES. The algorithm can be found in [CFS10].
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).
> 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.
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).
> D := CremonaDatabase(); > E := EllipticCurve(D, 571, 1, 1); > time td := TwoDescent(E); Time: 2.500 > #td; 3There 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.
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.
Given a pair of symmetric 4 x 4 matrices F, this function returns the associated quadric intersection in P = P3.
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.
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.
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 + 172The 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 genus one normal curves of degree 8 in P8. They are minimised and reduced, so are useful in searching for points on E.
The algorithm and implementation (from Magma 2.17) are due to Tom Fisher; this implementation partly incorporates and partly replaces an earlier one by Sebastian Stamminger.
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 a number field of degree 4 (and sometimes also 8). 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.
SetVerbose("Selmer", n): Maximum: 3
This performs a full 3-descent, returning models for the nontrivial inverse pairs in the 3-Selmer group and maps to E making them into 3-coverings. The only difference with ThreeDescent is that the computation is by first and second 3-isogeny descents. This restricts the number fields used to cubic extensions, rather than the sextic fields which may be needed for the generic ThreeDescent routine. The advantage is noticeable for larger examples.
> E := EllipticCurve([0,0,0,0,131241]); > G,m := TorsionSubgroup(E); > #G; 1 > Rank(E); 2 > S1,_,S2 := ThreeIsogenyDescent(E); > #S1,#S2; 0 4
This shows that there is nontrivial 3-torsion in Sha on some isogenous curve. Without computing the full 3-Selmer group of E it is impossible to tell if there is any nontrivial 3-torsion in Sha(E/Q).
> time Sel3 := ThreeDescentByIsogeny(E); Time: 5.280 > #Sel3*2+1; 9This shows that Sha(E/Q)[3] = 0 (since we know the rank is 2). Alternatively one could get the same by calling ThreeDescent. This would require computing class and unit group information in the sextic field below (and would be much slower).
> E3reps := ThreeTorsionPoints(E); > Parent(E3reps[2,1]); Number Field with defining polynomial x^6 + 14174028 over the Rational Field
> time Sel3_slow := ThreeDescent(E); forever!
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.
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.
If a 3-descent has been performed, the results can be used in conjunction with a 2-descent or a 4-descent to obtain coverings of degree 6 or 12 respectively. These "combined" coverings can be useful for finding Mordell-Weil generators of large height on the underlying elliptic curve.
The coverings are given as genus one normal curves (of degree 6 in P5, and of degree 12 in P11, respectively).
The algorithms are described in [Fis08].
Given a 2-covering and a 3-covering of an elliptic curve E (either as curves or as genus one models), this returns the 6-covering that represents their sum in the 6-Selmer group. The covering map C6 -> C3 is also returned.
Given a 3-covering and a 4-covering of an elliptic curve E (either as curves or as genus one models), this returns the two 12-coverings that represent their sum and difference in the 12-Selmer group. The covering maps to C12 -> C4 are also returned.
A nine-descent is performed on an everywhere locally solvable plane cubic curve. The cubic represents a class in the 3-Selmer group of its Jacobian (up to sign). A nine-descent computes the fibre above this class under the map from the 9-Selmer group to the 3-Selmer group induced by multiplication by 3. This fibre is the set of everywhere locally solvable 3-coverings of the cubic. These coverings are given as intersections of 27 quadrics in P8. As with four-descents the terminology "nine-descent" is slightly incorrect, as Magma performs a second 3-descent on a specific 3-covering and does not try to combine such information from all 3-coverings to form the 9-Selmer group.
The algorithm was developed in the PhD thesis of Brendan Creutz [Cre10]. Typically most of the computation time is spent on class group and unit group computations in the constituent fields of the degree 9 etale algebra associated to the flex points on the cubic. The primary use is to obtain information on the 3-primary part of the Shafarevich--Tate group. It is only in very rare circumstances that a nine descent is required (in addition to the other descent machinery) to determine the Mordell--Weil rank (e.g. if there were elements of order 24 in Sha).
ExtraReduction: RngIntElt Default: 10
SetVerbose("Selmer", n): Maximum: 3
SetVerbose("ComputeL", n): Maximum: 2
Given a plane cubic curve C over Q this returns a sequence of curves in P8 defined by 27 quadrics and a list of degree 9 maps making these curves into 3-coverings of C. This is the 3-Selmer set of C (i.e. the set of everywhere locally solvable 3-coverings of C). If there are no coverings, then C(Q) = emptyset and the class of C in the Shafarevich-Tate group of its Jacobian is not divisible by 3. Otherwise the coverings returned are lifts of C to the 9-Selmer group.The coverings returned are minimised and reduced in an ad hoc fashion. If ExtraReduction is set to a larger value, more time will be spent reducing possibly resulting in smaller models. The current implementation requires that Galois act transitively on the flex points. If this is not the case, then one can use pIsogenyDescent instead.
Computes the 3-rank of the 3-Selmer set of plane cubic curve C defined over Q. The value -1 is returned when the 3-Selmer set is empty. In this case C(Q) = emptyset and the class of C in the Shafarevich-Tate group of its Jacobian is not divisible by 3. If the 3-Selmer set is nonempty, its 3-rank is the same as that of the 3-Selmer group of the Jacobian. In this case the class of C in the Shafarevich-Tate group of the Jacobian is divisible by 3.
Given an isogeny φ: E1 -> E2 of elliptic curves, one may define the φ-Selmer group of E2 to be the set of everywhere locally solvable φ-coverings of E2. Given a genus one curve C with Jacobian E2, one may define its φ-Selmer set to be the set of everywhere locally solvable φ-coverings of C. A φ-isogeny descent computes the φ-Selmer group (or φ-Selmer set).
We denote the dual isogeny by φv. In the case of elliptic curves, performing φ- and φv-descents can be used to bound the Mordell-Weil rank and get information on Sha. For general genus one curves descent by isogeny can be used to rule out divisibility in Sha and consequently prove that there are no rational points.
In practice it is often easier to compute a `fake' Selmer set. This is a set parameterising everywhere locally solvable unions of φ-coverings, with the property that every φ-covering lies in exactly one such union. Any locally soluble φ-covering gives rise to a locally soluble union, hence there is a map from the Selmer set to the fake Selmer set. In general this map may be neither surjective nor injective. However, if the fake Selmer set is empty, then this is also true of the Selmer set.
Current functionality allows one to compute φ-Selmer groups for an isogeny φof prime degree in a number of situations. For isogenies of degree 2 or 3, they may be computed using TwoIsogenyDescent and ThreeIsogenyDescent. When φis the quotient by a subgroup generated by a Q-rational point of order p ∈{5, 7} the dimensions of the φ- and φv-Selmer groups can be computed using an algorithm of Fisher [Fis00] and [Fis01]. This method also produces models for the everywhere locally solvable φv-coverings of E.
Given a genus one normal curve C of prime degree p produced by a φ-isogeny
descent on an elliptic curve, the φv-Selmer set of C can be computed
using an algorithm of Creutz described in [Cre10] and [CM12].
Computing the φv-Selmer sets of all elements in the φ-Selmer group
yields information that is equivalent to that given by the φvφ-Selmer
group.
Current functionality allows one to perform these second isogeny descents when φhas degree p = 3 or when p ∈{ 5, 7} and the flex points of C lie on the coordinate hyperplanes in Pp - 1. If the kernel of the isogeny is generated by a Q-rational point of order p, then such a model always exists. Moreover, the models returned by the algorithm of Fisher have this property. For p = 7, computation of the coverings is not practical and only a `fake'-Selmer set can be computed (see [CM12]).
This performs a φ-descent on an elliptic curve over Q using the algorithm of Fisher. The descent requires an isogeny φwhose kernel is generated by a Q-rational point of order p ∈{5, 7}.The input can be specified in one of three ways: (1) by giving an elliptic curve and a point of order p on the curve; (2) by giving an elliptic curve containing a point of order p and specifying p; or (3) by specifying p and a Q-rational point on the modular curve X1(p ). In the final case the choice for the coordinate λon X1(p )(Q) is as described in [Fis00].
The return values are the p-ranks of the φ- and φv-Selmer groups, a sequence of genus one normal curves of degree p representing the inverse pairs of nontrivial elements of the φv-Selmer group modulo the image of the subgroup generated by the p-torsion point, and the isogenous elliptic curve. If the input is a coordinate on X1(p ), the curve E is also returned.
SetVerbose("Selmer", n): Maximum: 3
This performs an isogeny descent on the genus one normal curve C of degree p ∈{3, 5} as described in [CM12]. C must be a projective plane cubic (in case p = 3) or an intersection of 5 quadrics in P4, with the additional requirement that the flex points of C lie on the coordinate hyperplanes. For the descent one must specify: (1) the isogeny φ; (2) the domain E1 and the codomain E2 of the isogeny; or (3) a Q-rational point P of order p on an elliptic curve E which generates the kernel of the isogeny.The return values are a sequence consisting of genus one normal curves of degree p representing the elements of the φ-Selmer set and a list of maps making these into φ-coverings of C.
SetVerbose("Selmer", n): Maximum: 3
This determines the Fp-dimension of the `fake'-φ-Selmer set of the genus one normal curve C of degree p ∈{3, 5, 7} (see [CM12] for the definition). By convention the empty set has dimension -1. The input is exactly as for pIsogenyDescent, however coverings are not produced. This makes the computations feasible as well for p = 7.
> lambda := 48/5;
> r_phiSel,r_phidualSel,Sha,E1,E2 := pIsogenyDescent(lambda,5);
> CremonaReference(E1);
570l1
> CremonaReference(E2);
570l3
> TorsionSubgroup(E1);
Abelian Group isomorphic to Z/10
Defined on 1 generator
Relations:
10*$.1 = 0
> r_phiSel;
0
> r_phidualSel;
3
This shows that E2(Q)/φ(E1(Q)) simeq 0, while the φv-Selmer group gives an exact sequence: 0 -> E2(Q)/φv(E1(Q)) ⊂(Z/5Z)3 -> Sha(E2/Q)[φv] -> 0. From this we conclude that the rank (for both curves) is 0, and so Sha(E2/Q)[φv] has F5-dimension 2. Representatives for the inverse pairs of nontrivial elements are given by the third return value.
> #Sha*2 + 1; 25 > C := Sha[1]; > CremonaReference(Jacobian(GenusOneModel(C))); 570l3
The above computation does not conclusively show that Sha(E1/Q) has no nontrivial 5-torsion. For this we need a second isogeny descent. Namely we show that the C is not divisible by φin Sha.
> time DimSelC := FakeIsogenySelmerSet(C,E1,E2); Time: 2.950 > DimSelC; -1
> r1,r2,SelModTors,E,EE := pIsogenyDescent(326/467,5);
> r1,r2;
0 2
> E5,m := TorsionSubgroup(E);
> E5;
Abelian Group isomorphic to Z/5
Defined on 1 generator
Relations:
5*E5.1 = 0
> time ConjecturalRegulator(E);
242.013813460415708000138268958 1
Time: 70.180
> Conductor(E);
271976526950
> ThreeTorsionType(E);
Generic
This shows that E(Q) simeq Z x Z/5Z and that (assuming
Sha(E/Q) is trivial) that the regulator is 242.01... This means
one probably needs more than a 4-descent to find the generator. The
conductor is too large for Heegner point techniques and the 3-torsion
on E is generic, meaning 6- or 12-descent will be very slow (even
if they are performed nonrigorously). We can do a further isogeny
descent to obtain a full 5-covering.
> P := m(E5.1); > C := Curve(Minimize(GenusOneModel(SelModTors[2]))); > time Ds,Pis := pIsogenyDescent(C,P); 7.880 > D := Ds[1]; > pi := Pis[1]; > time rp := PointSearch(D,10^10 : > Dimension := 1, OnlyOne := true, Nonsingular := true); Time: 39.410 > Q := rp[1]; > Q; (-11610740223/2573365369 : 1350220049/2573365369 : -110993809/2573365369 : -3970329088/2573365369 : 1) > piQ := pi(Q); // gives the point on C > Dnew,Enew,FiveCovering := nCovering(GenusOneModel(D)); > Qnew := Dnew(Rationals())!Eltseq(Q); > Ecan,EnewtoEcan := MinimalModel(Enew); > P2 := EnewtoEcan(FiveCovering(Qnew)); > P2; (18742046893875394386310714878805837118945751672332464430219783625592 23533610794664163106345898123969229661/991466716729115905824131485387 000945412007497180441812893340644055454270710030810641619997008843128 1 : 71245662543288432230853647434377610311616709098508077082874898143 715069493690489458124709392518651254352942841744887961253603235705564 184725054480767436761578/98722742040021206194215985208166099089985806 405143789926209543140373470096170812446567353837866650186446834616709 6101096776119973657047069330277618071 : 1) > CanonicalHeight(P2); 242.013813460415708000138268957
> E1 := EllipticCurve("254a1");
> E2 := EllipticCurve("254a2");
> bool, phi := IsIsogenous(E1,E2);
> phicoveringsofE2,_,phidualcoveringsofE1,_,phi := ThreeIsogenyDescent(E1);
> C := phicoveringsofE2[1];
> C;
x^3 - x^2*y - x^2*z - 2*x*y^2 + 3*x*y*z - 2*x*z^2 + 2*y^2*z
> phidual := DualIsogeny(phi);
> MinimalModel(Codomain(phidual)) eq MinimalModel(Jacobian(C));
true
> time FakeIsogenySelmerSet(C,phidual);
2
Time: 0.620
> time SelC := pIsogenyDescent(C,phidual);
Time: 1.160
> Ilog(3,#SelC);
1
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.
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.
Traces: SeqEnum Default: []
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
> 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
> 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)); trueThe 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. There is some functionality for elliptic curves over number fields, though the exact normalisation is not always given.
Epsilon: FldReElt Default: 0.001
Given two complex numbers ω1, ω2 such that ω2/ω1 is in the upper half-plane that correspond to an integral model of an elliptic curve over ( Q), return such a minimal model of such a curve. This uses the classical Eisenstein series, with the vararg Epsilon indicating how close to integers the computed -27c4 and -54c6 need to be.
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.
> 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 an elliptic curve E defined over Q. This is equal to the sign in 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.
> 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 FieldWe can compute the modular degree of this using modular symbols.
> time ModularDegree(ModularSymbols(f)); 40 Time: 0.200Or via the algorithm based on elliptic curves.
> time ModularDegree(E); 40 Time: 0.000The 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
Let E be an elliptic curve defined over the rational numbers Q and denote by S={p1, ..., ps - 1, ∞} a finite set of primes containing the prime at infinity. There are only finitely many S-integral points on E. (That is, points where the denominators of the coordinates are only supported by primes in S.) Note that the point at infinity on E is never returned, since it is supported at every prime.
The following algorithms use the technique of linear forms in complex and p-adic elliptic logarithms.
The main routine here is (S)IntegralPoints for an elliptic curves. The functions listed afterwards, for determining integral points on various other kinds of genus one curves, are applications of the main routine.
FBasis: [ PtEll ] Default:
SafetyFactor: RngIntElt Default:
Given an elliptic curve E over the Q, this returns a sequence containing all the integral points on E, modulo negation. Secondly, a sequence is returned containing representations of the same points in terms of a fixed basis of the Mordell-Weil group (each such representation is a sequence of tuples of the form [< (Pi, ni) >]).The algorithm involves first computing generators of the Mordell-Weil group, by calling MordellWeilShaInformation which accesses the appropriate tools available in Magma. Alternatively, the user may precompute generators and pass them to IntegralPoints as the optional parameter FBasis. This should be a sequence of points on E that are independent modulo torsion (for instance, as returned by ReducedBasis). IntegralPoints will then find all integral points on E that are in the group generated by FBasis and torsion.
If the optional argument SafetyFactor is specified, the search phase at the final step is extended as a safety check. (The height bound is increased in such a way that the search region expands by roughly the specified factor.)
FBasis: [ PtEll ] Default:
SafetyFactor: RngIntElt Default:
Given an elliptic curve E over the rationals and a set S of finite primes, returns the sequence of all S-integral points, modulo negation. The second return value, and the optional arguments FBasis and SafetyFactor, are the same as in IntegralPoints.
> E := EllipticCurve([0, 17]);
> Q, reps := IntegralPoints(E);
> Q;
[ (-2 : -3 : 1), (8 : 23 : 1), (43 : -282 : 1), (4 : 9 : 1),
(2 : -5 : 1), (-1 : 4 : 1), (52 : -375 : 1), (5234 : 378661 : 1) ]
> reps;
[
[ <(-2 : -3 : 1), 1> ],
[ <(-2 : -3 : 1), 2> ],
[ <(-2 : -3 : 1), 1>, <(4 : -9 : 1), -2> ],
[ <(4 : -9 : 1), -1> ],
[ <(-2 : -3 : 1), 1>, <(4 : -9 : 1), -1> ],
[ <(-2 : -3 : 1), 1>, <(4 : -9 : 1), 1> ],
[ <(-2 : -3 : 1), 2>, <(4 : -9 : 1), 1> ],
[ <(-2 : -3 : 1), 1>, <(4 : -9 : 1), 3> ]
]
We see here that the chosen basis consists of the points
( - 2 : - 3 : 1) and (4 : - 9 : 1), and that coefficients which are
zero are omitted.
> E := EllipticCurve([-228, 848]); > Q := SIntegralPoints(E, [2, 3, 5, 7]); > for P in Q do P; end for; // Print one per line (4 : 0 : 1) (-11 : 45 : 1) (16 : 36 : 1) (97/4 : -783/8 : 1) (-44/9 : -1160/27 : 1) (857/4 : -25027/8 : 1) (6361/400 : -282141/8000 : 1) (534256 : -390502764 : 1) (946/49 : -20700/343 : 1) (-194/25 : -5796/125 : 1) (34/9 : 172/27 : 1) (814 : 23220 : 1) (13 : 9 : 1) (-16 : 20 : 1) (1/4 : -225/8 : 1) (52 : -360 : 1) (53 : 371 : 1) (16/49 : 9540/343 : 1) (-16439/1024 : -631035/32768 : 1) (34 : 180 : 1) (-2 : 36 : 1) (-14 : -36 : 1) (14 : -20 : 1) (754 : -20700 : 1) (94/25 : -828/125 : 1) (2 : 20 : 1) (94 : 900 : 1) (-818/49 : 468/343 : 1) (49/16 : -855/64 : 1) (196 : -2736 : 1) (629/25 : 13133/125 : 1) (1534/81 : -42020/729 : 1) (8516/117649 : -1163623840/40353607 : 1)
If Q is a sequence of five integers [a, b, c, d, e] where e is a square, this function returns all integral points (modulo negation) on the curve y2=ax4 + bx3 + cx2 + dx + e.
If Q is a list of five integers [a, b, c, d, e] defining the hyperelliptic quartic y2=ax4 + bx3 + cx2 + dx + e and P is a sequence representing a rational point [x, y], this function returns all integral points on Q.
Given a sequence of integers Q = [a, b, c, d, e] where a is a square, this function returns all S-integral points on the quartic curve y2 = ax4 + bx3 + cx2 + dx + e for the set S of finite primes.
> IntegralQuarticPoints([1, 0, -8, 8, 1]);
[
[ 2, -1 ],
[ -6, 31 ],
[ 0, 1 ]
]
Given a sequence of integers Q = [a, b, c, d], this function returns all S-integral points on the curve C: ay2 = bx4 + cx2 + d for the set S of finite primes, provided that C is nonsingular.
Given a sequence of integers Q = [a, b, c, d], this function returns all S-integral points on C: ay3 + bx3 + cxy + d=0 for the set S of finite primes, provided that C is nonsingular.
> S := [2, 3, 5, 7];
> SIntegralDesbovesPoints([9, 2, 1, 8], S);
[
[ 1, -1 ],
[ -94/7, 172/21 ],
[ -11/7, 2/7 ],
[ 5, -3 ],
[ 2, -4/3 ],
[ 2/7, -20/21 ],
[ -8/5, -2/15 ]
]
Magma includes John Cremona's database of all elliptic curves over Q of small conductor (up to 200 000 as of December 2011). This section defines the interface to that database.
For each conductor in the range stored in the database the curves with that conductor are stored in a number of isogeny classes. Each curve in an isogeny class is isogenous (but not isomorphic) to the other curves in that class. Isogeny classes are referred to by number rather than the alphabetic form given in the Cremona tables.
All of the stored curves are global minimal models.
BufferSize: RngIntElt Default: 10000
This function returns a database object which contains information about the elliptic curve database and is used in the functions which access it. The optional parameter BufferSize controls the size of an internal buffer --- see the description of SetBufferSize for more information.
The elliptic curve database D uses an internal buffer to cache disk reads; if the buffer is large enough then the entire file can be cached and will not need to be read from the disk more than once. On the other hand, if only a few curves will be accessed then a large buffer is not especially useful. SetBufferSize can be used to set the size n (in bytes) of this buffer. There are well defined useful minimum and maximum sizes for this buffer, and values outside this range will be treated as the nearest useful value.
Returns the largest conductor of any elliptic curve stored in the database. It is an error to attempt to refer to larger conductors in the database.
Returns the smallest and largest conductors stored in the database. It is an error to attempt to refer to conductors outside of this range.
Returns the number of elliptic curves stored in the database.
Returns the number of elliptic curves stored in the database for conductor N.
Returns the number of elliptic curves stored in the database in the i-th isogeny class for conductor N.
Returns the number of isogeny classes stored in the database for conductor N.
Returns the J-th elliptic curve of the I-th isogeny class of conductor N from the database. I may be specified either as an integer (first form) or as a label like "A" (second form).
Returns a representative elliptic curve with label S (e.g., "101a" or "101a1") from the specified database (or if not specified, from the Cremona database).
Returns a random curve from the database.
Returns the database reference to the minimal model for E (e.g., "101a1"). E must be defined over Q and its conductor must lie within the range of the database. The second form of this function must open the database for each call, so if it is being used many times the database should be created once and the first form used instead.
> D := CremonaDatabase(); > #D; 847550 > minC, maxC := ConductorRange(D); > minC, maxC; 1 130000 > &+[ NumberOfCurves(D, C) : C in [ minC .. maxC ] ]; 847550These numbers agree (which is nice). The conductor in that range with the most curves is 100800.
> S := [ NumberOfCurves(D, C) : C in [ minC .. maxC ] ]; > cond := maxval + minC - 1 where _,maxval := Max(S); > cond; 100800 > NumberOfCurves(D, cond); 924 > NumberOfIsogenyClasses(D, cond); 418The unique curve of conductor 5077 has rank 3.
> NumberOfCurves(D, 5077); 1 > E := EllipticCurve(D, 5077, 1, 1); > E; Elliptic Curve defined by y^2 + y = x^3 - 7*x + 6 over Rational Field > CremonaReference(D, E); 5077a1 > Rank(E); 3
Returns the sequence of elliptic curves in the I-th isogeny class for conductor N from the database. I may be specified either as an integer (first form) or as a label like "A" (second form).
The sequence of elliptic curves for conductor N from the database.
The sequence of elliptic curves with label S from the database. S may specify just a conductor (like "101"), or both a conductor and an isogeny class (like "101A").
The sequence of elliptic curves stored in the database. Note: this function is extremely slow due to the number of curves involved. Where possible it would be much better to iterate through the database instead (see example).
> D := CremonaDatabase(); 25508696848625044861003843159331265666415824 Time: 21.130 > sum := 0; > time for E in D do sum +:= Discriminant(E); end for; > sum; 25508696848625044861003843159331265666415824 Time: 20.060Now we create a random curve and find the other curves in its isogeny class.
> E := Random(D);
> E;
Elliptic Curve defined by y^2 = x^3 - 225*x over Rational Field
> Conductor(E);
7200
> CremonaReference(E);
7200bg1
> EllipticCurves(D, "7200bg");
[
Elliptic Curve defined by y^2 = x^3 - 225*x over Rational Field,
Elliptic Curve defined by y^2 = x^3 - 2475*x - 47250 over Rational Field,
Elliptic Curve defined by y^2 = x^3 - 2475*x + 47250 over Rational Field,
Elliptic Curve defined by y^2 = x^3 + 900*x over Rational Field
]