Module: sage.schemes.elliptic_curves.ell_rational_field
Elliptic curves over the rational numbers
Author Log:
Module-level Functions
conductors) |
Return iterator over all known curves (in database) with conductor in the list of conductors.
sage: [(E.label(), E.rank()) for E in cremona_curves(srange(35,40))] [('35a1', 0), ('35a2', 0), ('35a3', 0), ('36a1', 0), ('36a2', 0), ('36a3', 0), ('36a4', 0), ('37a1', 1), ('37b1', 0), ('37b2', 0), ('37b3', 0), ('38a1', 0), ('38a2', 0), ('38a3', 0), ('38b1', 0), ('38b2', 0), ('39a1', 0), ('39a2', 0), ('39a3', 0), ('39a4', 0)]
conductors) |
Return iterator over all known optimal curves (in database) with conductor in the list of conductors.
sage: [(E.label(), E.rank()) for E in cremona_optimal_curves(srange(35,40))] [('35a1', 0), ('36a1', 0), ('37a1', 1), ('37b1', 0), ('38a1', 0), ('38b1', 0), ('39a1', 0)]
Class: EllipticCurve_rational_field
self, ainvs, [extra=None]) |
Functions: an,
analytic_rank,
anlist,
ap,
aplist,
cm_discriminant,
conductor,
CPS_height_bound,
cremona_label,
database_curve,
eval_modular_form,
gens,
gens_certain,
global_integral_model,
has_cm,
heegner_discriminants,
heegner_discriminants_list,
heegner_index,
heegner_index_bound,
heegner_point_height,
integral_model,
integral_weierstrass_model,
is_global_integral_model,
is_good,
is_integral,
is_irreducible,
is_local_integral_model,
is_minimal,
is_ordinary,
is_reducible,
is_semistable,
is_supersingular,
is_surjective,
isogeny_class,
isogeny_graph,
kodaira_type,
label,
Lambda,
local_integral_model,
lseries,
matrix_of_frobenius,
minimal_model,
mod5family,
modular_degree,
modular_form,
modular_parametrization,
modular_symbol,
modular_symbol_space,
mwrank,
mwrank_curve,
newform,
ngens,
non_surjective,
Np,
ordinary_primes,
p_isogenous_curves,
padic_E2,
padic_height,
padic_height_pairing_matrix,
padic_height_via_multiply,
padic_lseries,
padic_regulator,
padic_sigma,
padic_sigma_truncated,
pari_curve,
pari_mincurve,
period_lattice,
point_search,
q_eigenform,
q_expansion,
quadratic_twist,
rank,
real_components,
reducible_primes,
regulator,
root_number,
satisfies_heegner_hypothesis,
saturation,
sea,
selmer_rank_bound,
sha,
silverman_height_bound,
simon_two_descent,
supersingular_primes,
tamagawa_number,
tamagawa_numbers,
tamagawa_product,
tate_curve,
three_selmer_rank,
torsion_order,
torsion_subgroup,
two_descent,
two_descent_simon,
two_torsion_rank
self, n) |
The n-th Fourier coefficient of the modular form corresponding to this elliptic curve, where n is a positive integer.
sage: E=EllipticCurve('37a1') sage: [E.an(n) for n in range(20) if n>0] [1, -2, -3, 2, -2, 6, -1, 0, 6, 4, -5, -6, -2, 2, 6, -4, 0, -12, 0]
self, [algorithm=cremona]) |
Return an integer that is probably the analytic rank of this elliptic curve.
Input: algorithm:
- 'sympow' -use Watkins's program sympow
- 'rubinstein' - use Rubinstein's L-function C++ program lcalc.
- 'magma' - use MAGMA
- 'all' - compute with all other free algorithms, check that the answers agree, and return the common answer.
Note: If the curve is loaded from the large Cremona database, then the modular degree is taken from the database.
Of the three above, probably Rubinstein's is the most efficient (in some limited testing I've done).
Note:
It is an open problem to prove that any
particular elliptic curve has analytic rank
.
sage: E = EllipticCurve('389a') sage: E.analytic_rank(algorithm='cremona') 2 sage: E.analytic_rank(algorithm='rubinstein') 2 sage: E.analytic_rank(algorithm='sympow') 2 sage: E.analytic_rank(algorithm='magma') # optional 2 sage: E.analytic_rank(algorithm='all') 2
self, n, [python_ints=False]) |
The Fourier coefficients up to and including
of the
modular form attached to this elliptic curve. The ith element
of the return list is a[i].
Input:
sage: E = EllipticCurve([0, -1, 1, -10, -20]) sage: E.anlist(3) [0, 1, -2, -1]
sage: E = EllipticCurve([0,1]) sage: E.anlist(20) [0, 1, 0, 0, 0, 0, 0, -4, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 8, 0]
self, p) |
The p-th Fourier coefficient of the modular form corresponding to this elliptic curve, where p is prime.
sage: E=EllipticCurve('37a1') sage: [E.ap(p) for p in prime_range(50)] [-2, -3, -2, -1, -5, -2, 0, 0, 2, 6, -4, -1, -9, 2, -9]
self, n, [python_ints=False]) |
The Fourier coefficients
of the modular form attached to
this elliptic curve, for all primes
.
Input:
sage: e = EllipticCurve('37a') sage: e.aplist(1) [] sage: e.aplist(2) [-2] sage: e.aplist(10) [-2, -3, -2, -1] sage: v = e.aplist(13); v [-2, -3, -2, -1, -5, -2] sage: type(v[0]) <type 'sage.rings.integer.Integer'> sage: type(e.aplist(13, python_ints=True)[0]) <type 'int'>
self) |
Returns the associated quadratic discriminant if this elliptic curve has Complex Multiplication.
A ValueError is raised if the curve does not have CM (see the function has_cm())
sage: E=EllipticCurve('32a1') sage: E.cm_discriminant() -4 sage: E=EllipticCurve('121b1') sage: E.cm_discriminant() -11 sage: E=EllipticCurve('37a1') sage: E.cm_discriminant() Traceback (most recent call last): ... ValueError: Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field does not have CM
self, [algorithm=pari]) |
Returns the conductor of the elliptic curve.
Input:
sage: E = EllipticCurve([1, -1, 1, -29372, -1932937]) sage: E.conductor(algorithm="pari") 3006 sage: E.conductor(algorithm="mwrank") 3006 sage: E.conductor(algorithm="gp") 3006 sage: E.conductor(algorithm="all") 3006
NOTE: The conductor computed using each algorithm is cached separately. Thus calling E.conductor("pari"), then E.conductor("mwrank") and getting the same result checks that both systems compute the same answer.
self) |
Return the Cremona-Prickett-Siksek height bound. This is a floating point number B such that if P is a point on the curve, then the naive logarithmetic height of P is off from the canonical height by at most B.
sage: E = EllipticCurve("11a") sage: E.CPS_height_bound() 2.8774743273580445 sage: E = EllipticCurve("5077a") sage: E.CPS_height_bound() 0.0 sage: E = EllipticCurve([1,2,3,4,1]) sage: E.CPS_height_bound() Traceback (most recent call last): ... RuntimeError: curve must be minimal. sage: F = E.quadratic_twist(-19) sage: F Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 + 1376*x - 130 over Rational Field sage: F.CPS_height_bound() 0.65551583769728516
IMPLEMENTATION: Call the corresponding mwrank C++ library function.
self, [space=False]) |
Return the Cremona label associated to (the minimal model) of this curve, if it is known. If not, raise a RuntimeError exception.
sage: E=EllipticCurve('389a1') sage: E.cremona_label() '389a1'
The default database only contains conductors up to 10000, so any curve with conductor greater than that will cause an error to be raised:
sage: E=EllipticCurve([1,2,3,4,5]); sage: E.conductor() 10351 sage: E.cremona_label() Traceback (most recent call last): ... RuntimeError: Cremona label not known for Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over Rational Field.
self) |
Return the curve in the elliptic curve database isomorphic to this curve, if possible. Otherwise raise a RuntimeError exception.
sage: E = EllipticCurve([0,1,2,3,4]) sage: E.database_curve() Elliptic Curve defined by y^2 = x^3 + x^2 + 3*x + 5 over Rational Field
NOTES: The model of the curve in the database can be different than the Weierstrass model for this curve, e.g., database models are always minimal.
self, points, prec) |
Evaluate the L-series of this elliptic curve at points in CC
Input: points- a list of points in the half-plane of convergence prec- precision
Output: A list of values L(E,s) for s in points
NOTE: Better examples are welcome.
sage: E=EllipticCurve('37a1') sage: E.eval_modular_form([1.5+I,2.0+I,2.5+I],0.000001) [0, 0, 0]
self, [verbose=False], [rank1_search=10], [algorithm=mwrank_shell], [only_use_mwrank=True], [proof=None]) |
Compute and return generators for the Mordell-Weil group E(Q) *modulo* torsion.
HINT: If you would like to control the height bounds used in the 2-descent, first call the two_descent function with those height bounds. However that function, while it displays a lot of output, returns no values.
TODO: (1) Right now this function assumes that the input curve is in minimal Weierstrass form. This restriction will be removed in the future. This function raises a NotImplementedError if a non-minimal curve is given as input.
(2) Allow passing of command-line parameters to mwrank.
WARNING: If the program fails to give a provably correct result, it prints a warning message, but does not raise an exception. Use the gens_certain command to find out if this warning message was printed.
Input:
IMPLEMENTATION: Uses Cremona's mwrank C library.
sage: E = EllipticCurve('389a') sage: E.gens() # random output [(-1 : 1 : 1), (0 : 0 : 1)]
self) |
Return True if the generators have been proven correct.
sage: E=EllipticCurve('37a1') sage: E.gens() [(0 : -1 : 1)] sage: E.gens_certain() True
self) |
Return a model of self which is integral at all primes
sage: E = EllipticCurve([0, 0, 1/216, -7/1296, 1/7776]) sage: F = E.global_integral_model(); F Elliptic Curve defined by y^2 + y = x^3 - 7*x + 6 over Rational Field sage: F == EllipticCurve('5077a1') True
self) |
Returns True iff this elliptic curve has Complex Multiplication
sage: E=EllipticCurve('37a1') sage: E.has_cm() False sage: E=EllipticCurve('32a1') sage: E.has_cm() True sage: E.j_invariant() 1728
self, bound) |
Return the list of self's Heegner discriminants between -1 and -bound.
Input:
sage: E=EllipticCurve('11a') sage: E.heegner_discriminants(30) [-7, -8, -19, -24]
self, n) |
Return the list of self's first n Heegner discriminants smaller than -5.
Input:
sage: E=EllipticCurve('11a') sage: E.heegner_discriminants_list(4) [-7, -8, -19, -24]
self, D, [min_p=2], [prec=5], [verbose=False]) |
Return an interval that contains the index of the Heegner
point
in the group of K-rational points modulo torsion
on this elliptic curve, computed using the Gross-Zagier
formula and/or a point search, or the index divided by
.
NOTES: If min_p
is bigger than 2 then the index can be
off by any prime less than min_p
. This function
returns the index divided by
exactly when
has index
in
.
Input:
sage: E = EllipticCurve('11a') sage: E.heegner_discriminants(50) [-7, -8, -19, -24, -35, -39, -40, -43] sage: E.heegner_index(-7) [0.99999332 .. 1.0000077]
sage: E = EllipticCurve('37b') sage: E.heegner_discriminants(100) [-3, -4, -7, -11, -40, -47, -67, -71, -83, -84, -95] sage: E.heegner_index(-95) # long time (1 second) [1.9999923 .. 2.0000077]
Current discriminants -3 and -4 are not supported:
sage: E.heegner_index(-3) Traceback (most recent call last): ... ArithmeticError: Discriminant (=-3) must not be -3 or -4.
The curve 681b returns an interval that contains
.
This is because
is not saturated in
. The
true index is
:
sage: E = EllipticCurve('681b') sage: I = E.heegner_index(-8); I [1.4999942 .. 1.5000058] sage: 2*I [2.9999885 .. 3.0000115]
In fact, whenever the returned index has a denominator
of
, the true index is got by multiplying the returned
index by
. Unfortunately, this is not an if and only
if condition, i.e., sometimes the index must be multiplied
by
even though the denominator is not
.
self, [D=0], [prec=5], [verbose=True], [max_height=21]) |
Assume self has rank 0.
Return a list v of primes such that if an odd prime p divides the index of the Heegner point in the group of rational points *modulo torsion*, then p is in v.
If 0 is in the interval of the height of the Heegner point computed to the given prec, then this function returns v = 0. This does not mean that the Heegner point is torsion, just that it is very likely torsion.
If we obtain no information from a search up to max_height, e.g., if the Siksek et al. bound is bigger than max_height, then we return v = -1.
Input:
sage: E = EllipticCurve('11a1') sage: E.heegner_index_bound(verbose=False) ([2], -7)
self, D, [prec=2]) |
Use the Gross-Zagier formula to compute the Neron-Tate canonical height over K of the Heegner point corresponding to D, as an Interval (since it's computed to some precision using L-functions).
Input:
sage: E = EllipticCurve('11a') sage: E.heegner_point_height(-7) [0.22226977 ... 0.22227479]
self) |
Return a weierstrass model,
, of self with integral coefficients,
along with a morphism
of points on self to points on
.
sage: E = EllipticCurve([1/2,0,0,5,1/3]) sage: F, phi = E.integral_model() sage: F Elliptic Curve defined by y^2 + 3*x*y = x^3 + 6480*x + 15552 over Rational Field sage: phi Generic morphism: From: Abelian group of points on Elliptic Curve defined by y^2 + 1/2*x*y = x^3 + 5*x + 1/3 over Rational Field To: Abelian group of points on Elliptic Curve defined by y^2 + 3*x*y = x^3 + 6480*x + 15552 over Rational Field Via: (u,r,s,t) = (1/6, 0, 0, 0) sage: P = E([4/9,41/27]) sage: phi(P) (16 : 328 : 1) sage: phi(P) in F True
self) |
Return a model of the form
for this curve with
.
sage: E = EllipticCurve('17a1') sage: E.integral_weierstrass_model() Elliptic Curve defined by y^2 = x^3 - 11*x - 890 over Rational Field
self) |
Return true iff self is integral at all primes
sage: E=EllipticCurve([1/2,1/5,1/5,1/5,1/5]) sage: E.is_global_integral_model() False sage: Emin=E.global_integral_model() sage: Emin.is_global_integral_model() True
self, p, [check=True]) |
Return True if
is a prime of good reduction for
.
Input:
sage: e = EllipticCurve('11a') sage: e.is_good(-8) Traceback (most recent call last): ... ValueError: p must be prime sage: e.is_good(-8, check=False) True
self) |
Returns True if this elliptic curve has integral coefficients (in Z)
sage: E=EllipticCurve(QQ,[1,1]); E Elliptic Curve defined by y^2 = x^3 + x +1 over Rational Field sage: E.is_integral() True sage: E2=E.change_weierstrass_model(2,0,0,0); E2 Elliptic Curve defined by y^2 = x^3 + 1/16*x + 1/64 over Rational Field sage: E2.is_integral() False
self, p) |
Return True if the mod p represenation is irreducible.
sage: e = EllipticCurve('37b') sage: e.is_irreducible(2) True sage: e.is_irreducible(3) False sage: e.is_reducible(2) False sage: e.is_reducible(3) True
self) |
Tests if self is integral at the prime
, or at all the
primes if
is a list or tuple of primes
sage: E=EllipticCurve([1/2,1/5,1/5,1/5,1/5]) sage: [E.is_local_integral_model(p) for p in (2,3,5)] [False, True, False] sage: E.is_local_integral_model(2,3,5) False sage: Eint2=E.local_integral_model(2) sage: Eint2.is_local_integral_model(2) True
self) |
Return True iff this elliptic curve is a reduced minimal model.
the unique minimal Weierstrass equation for this
elliptic curve. This is the model with minimal discriminant
and
.
TO DO: This is not very efficient since it just computes the minimal model and compares. A better implementation using the Kraus conditions would be preferable.
sage: E=EllipticCurve([10,100,1000,10000,1000000]) sage: E.is_minimal() False sage: E=E.minimal_model() sage: E.is_minimal() True
self, p, [ell=None]) |
Return True precisely when the mod-p representation attached to this elliptic curve is ordinary at ell.
Input:
sage: E=EllipticCurve('37a1') sage: E.is_ordinary(37) True sage: E=EllipticCurve('32a1') sage: E.is_ordinary(2) False sage: [p for p in prime_range(50) if E.is_ordinary(p)] [5, 13, 17, 29, 37, 41]
self, p) |
Return True if the mod-p representation attached to E is reducible.
Input:
NOTE: The answer is cached.
sage: E = EllipticCurve('121a'); E Elliptic Curve defined by y^2 + x*y + y = x^3 + x^2 - 30*x - 76 over Rational Field sage: E.is_reducible(7) False sage: E.is_reducible(11) True sage: EllipticCurve('11a').is_reducible(5) True sage: e = EllipticCurve('11a2') sage: e.is_reducible(5) True sage: e.torsion_order() 1
self) |
Return True iff this elliptic curve is semi-stable at all primes.
sage: E=EllipticCurve('37a1') sage: E.is_semistable() True sage: E=EllipticCurve('90a1') sage: E.is_semistable() False
self, p, [ell=None]) |
Return True precisely when p is a prime of good reduction and the mod-p representation attached to this elliptic curve is supersingular at ell.
Input:
sage: E=EllipticCurve('37a1') sage: E.is_supersingular(37) False sage: E=EllipticCurve('32a1') sage: E.is_supersingular(2) False sage: E.is_supersingular(7) True sage: [p for p in prime_range(50) if E.is_supersingular(p)] [3, 7, 11, 19, 23, 31, 43, 47]
self, p, [A=1000]) |
Return True if the mod-p representation attached to E is surjective, False if it is not, or None if we were unable to determine whether it is or not.
NOTE: The answer is cached.
Input:
sage: e = EllipticCurve('37b') sage: e.is_surjective(2) (True, None) sage: e.is_surjective(3) (False, '3-torsion')
REMARKS:
1. If p >= 5 then the mod-p representation is surjective if and only if the p-adic representation is surjective. When p = 2, 3 there are counterexamples. See a very recent paper of Elkies for more details when p=3.
2. When p <= 3 this function always gives the correct result irregardless of A, since it explicitly determines the p-division polynomial.
self, [algorithm=mwrank], [verbose=False]) |
Return all curves over
in the isogeny class of this
elliptic curve.
Input:
Note: The result is not provably correct, in the sense that when the numbers are huge isogenies could be missed because of precision issues.
Note: The ordering depends on which algorithm is used.
sage: I, A = EllipticCurve('37b').isogeny_class('mwrank') sage: I # randomly ordered [Elliptic Curve defined by y^2 + y = x^3 + x^2 - 23*x - 50 over Rational Field, Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational Field, Elliptic Curve defined by y^2 + y = x^3 + x^2 - 3*x +1 over Rational Field] sage: A [0 3 3] [3 0 0] [3 0 0]
sage: I, _ = EllipticCurve('37b').isogeny_class('database'); I [Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational Field, Elliptic Curve defined by y^2 + y = x^3 + x^2 - 23*x - 50 over Rational Field, Elliptic Curve defined by y^2 + y = x^3 + x^2 - 3*x +1 over Rational Field]
This is an example of a curve with a
-isogeny:
sage: E = EllipticCurve([1,1,1,-8,6]) sage: E.isogeny_class () ([Elliptic Curve defined by y^2 + x*y + y = x^3 + x^2 - 8*x + 6 over Rational Field, Elliptic Curve defined by y^2 + x*y + y = x^3 + x^2 - 208083*x - 36621194 over Rational Field], [ 0 37] [37 0])
This curve had numerous
-isogenies:
sage: e=EllipticCurve([1,0,0,-39,90]) sage: e.isogeny_class () ([Elliptic Curve defined by y^2 + x*y = x^3 - 39*x + 90 over Rational Field, Elliptic Curve defined by y^2 + x*y = x^3 - 4*x -1 over Rational Field, Elliptic Curve defined by y^2 + x*y = x^3 + x over Rational Field, Elliptic Curve defined by y^2 + x*y = x^3 - 49*x - 136 over Rational Field, Elliptic Curve defined by y^2 + x*y = x^3 - 34*x - 217 over Rational Field, Elliptic Curve defined by y^2 + x*y = x^3 - 784*x - 8515 over Rational Field], [0 2 0 0 0 0] [2 0 2 2 0 0] [0 2 0 0 0 0] [0 2 0 0 2 2] [0 0 0 2 0 0] [0 0 0 2 0 0])
See http://modular.ucsd.edu/Tables/nature/ for more interesting examples of isogeny structures.
self) |
Returns a graph representing the isogeny class of this elliptic curve,
where the vertices are isogenous curves over
and the edges are
prime degree isogenies labeled by their degree.
sage: LL = [] sage: for e in cremona_optimal_curves(range(1, 38)): ... G = e.isogeny_graph() ... already = False ... for H in LL: ... if G.is_isomorphic(H): ... already = True ... break ... if not already: ... LL.append(G) ... sage: graphs_list.show_graphs(LL)
sage: E = EllipticCurve('195a') sage: G = E.isogeny_graph() sage: for v in G: print v, G.get_vertex(v) ... 0 Elliptic Curve defined by y^2 + x*y = x^3 - 110*x + 435 over Rational Field 1 Elliptic Curve defined by y^2 + x*y = x^3 - 115*x + 392 over Rational Field 2 Elliptic Curve defined by y^2 + x*y = x^3 + 210*x + 2277 over Rational Field 3 Elliptic Curve defined by y^2 + x*y = x^3 - 520*x - 4225 over Rational Field 4 Elliptic Curve defined by y^2 + x*y = x^3 + 605*x - 19750 over Rational Field 5 Elliptic Curve defined by y^2 + x*y = x^3 - 8125*x - 282568 over Rational Field 6 Elliptic Curve defined by y^2 + x*y = x^3 - 7930*x - 296725 over Rational Field 7 Elliptic Curve defined by y^2 + x*y = x^3 - 130000*x - 18051943 over Rational Field sage: G.plot(edge_labels=True).save('isogeny_graph.png')
self, p) |
Local Kodaira type of the elliptic curve at
.
Input:
sage: E = EllipticCurve('124a') sage: E.kodaira_type(2) IV
self, [space=False]) |
Return the Cremona label associated to (the minimal model) of this curve, if it is known. If not, raise a RuntimeError exception.
sage: E=EllipticCurve('389a1') sage: E.cremona_label() '389a1'
The default database only contains conductors up to 10000, so any curve with conductor greater than that will cause an error to be raised:
sage: E=EllipticCurve([1,2,3,4,5]); sage: E.conductor() 10351 sage: E.cremona_label() Traceback (most recent call last): ... RuntimeError: Cremona label not known for Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over Rational Field.
self, s, prec) |
Returns the value of the Lambda-series of the elliptic curve E at s, where s can be any complex number.
IMPLEMENTATION: Fairly *slow* computation using the definitions and implemented in Python.
Uses prec terms of the power series.
sage: E = EllipticCurve('389a') sage: E.Lambda(1.4+0.5*I, 50) -0.354172680517... + 0.874518681720...*I
self, p) |
Return a model of self which is integral at the prime
sage: E=EllipticCurve([0, 0, 1/216, -7/1296, 1/7776]) sage: E.local_integral_model(2) Elliptic Curve defined by y^2 + 1/27*y = x^3 - 7/81*x + 2/243 over Rational Field sage: E.local_integral_model(3) Elliptic Curve defined by y^2 + 1/8*y = x^3 - 7/16*x + 3/32 over Rational Field sage: E.local_integral_model(2).local_integral_model(3) == EllipticCurve('5077a1') True
self) |
Returns the L-series of this elliptic curve.
Further documentation is available for the functions which apply to the L-series.
sage: E=EllipticCurve('37a1') sage: E.lseries() Complex L-series of the Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
self, p, [prec=20], [check=False], [check_hypotheses=True], [algorithm=auto]) |
See the parameters and documentation for padic_E2.
self) |
Return the unique minimal Weierstrass equation for this
elliptic curve. This is the model with minimal discriminant
and
.
sage: E=EllipticCurve([10,100,1000,10000,1000000]) sage: E.minimal_model() Elliptic Curve defined by y^2 + x*y + y = x^3 + x^2 + x +1 over Rational Field
self) |
Return the family of all elliptic curves with the same mod-5 representation as self.
sage: E=EllipticCurve('32a1') sage: E.mod5family() Elliptic Curve defined by y^2 = x^3 + 4*x over Fraction Field of Univariate Polynomial Ring in t over Rational Field
self, [algorithm=sympow]) |
Return the modular degree of this elliptic curve.
The result is cached. Subsequence calls, even with a different algorithm, just returned the cached result.
Input:
Note: On 64-bit computers ec does not work, so Sage uses sympow even if ec is selected on a 64-bit computer.
The correctness of this function when called with algorithm "ec" is subject to the following three hypothesis:
Moreover for all algorithms, computing a certain value of an
-function ``uses a heuristic method that discerns when the
real-number approximation to the modular degree is within epsilon
[=0.01 for algorithm="sympow"] of the same integer for 3
consecutive trials (which occur maybe every 25000 coefficients
or so). Probably it could just round at some point. For
rigour, you would need to bound the tail by assuming
(essentially) that all the
are as large as possible, but
in practise they exhibit significant (square root)
cancellation. One difficulty is that it doesn't do the sum in
1-2-3-4 order; it uses 1-2-4-8--3-6-12-24-9-18- (Euler
product style) instead, and so you have to guess ahead of time
at what point to curtail this expansion.'' (Quote from an
email of Mark Watkins.)
Note: If the curve is loaded from the large Cremona database, then the modular degree is taken from the database.
sage: E = EllipticCurve([0, -1, 1, -10, -20]) sage: E Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field sage: E.modular_degree() 1 sage: E = EllipticCurve('5077a') sage: E.modular_degree() 1984 sage: factor(1984) 2^6 * 31
sage: EllipticCurve([0, 0, 1, -7, 6]).modular_degree() 1984 sage: EllipticCurve([0, 0, 1, -7, 6]).modular_degree(algorithm='sympow') 1984 sage: EllipticCurve([0, 0, 1, -7, 6]).modular_degree(algorithm='magma') # optional 1984
We compute the modular degree of the curve with rank 4 having smallest (known) conductor:
sage: E = EllipticCurve([1, -1, 0, -79, 289]) sage: factor(E.conductor()) # conductor is 234446 2 * 117223 sage: factor(E.modular_degree()) 2^7 * 2617
self) |
Return the cuspidal modular form associated to this elliptic curve.
sage: E = EllipticCurve('37a') sage: f = E.modular_form() sage: f q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + O(q^6)
If you need to see more terms in the
-expansion:
sage: f.q_expansion(20) q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + 6*q^6 - q^7 + 6*q^9 + 4*q^10 - 5*q^11 - 6*q^12 - 2*q^13 + 2*q^14 + 6*q^15 - 4*q^16 - 12*q^18 + O(q^20)
NOTE: If you just want the
-expansion, use
self.q_expansion(prec)
.
self) |
Computes and returns the modular parametrization of this elliptic curve.
The curve is converted to a minimal model.
Output: a list of two larent series [x(x),y(x)] of degrees -2,
-3 respectively, which satisfy the equation of the (minimal
model of the) elliptic curve. The are modular functions on
where
is the conductor.
X.deriv()/(2*Y+a1*X+a3) should equal f(q)dq/q where f is self.q_expansion().
sage: E=EllipticCurve('389a1') sage: X,Y=E.modular_parametrization() sage: X q^-2 + 2*q^-1 + 4 + 7*q + 13*q^2 + 18*q^3 + 31*q^4 + 49*q^5 + 74*q^6 + 111*q^7 + 173*q^8 + 251*q^9 + 379*q^10 + 560*q^11 + 824*q^12 + 1199*q^13 + 1773*q^14 + 2365*q^15 + 3463*q^16 + 4508*q^17 + O(q^18) sage: Y -q^-3 - 3*q^-2 - 8*q^-1 - 17 - 33*q - 61*q^2 - 110*q^3 - 186*q^4 - 320*q^5 - 528*q^6 - 861*q^7 - 1383*q^8 - 2218*q^9 - 3472*q^10 - 5451*q^11 - 8447*q^12 - 13020*q^13 - 20083*q^14 - 29512*q^15 - 39682*q^16 + O(q^17)
The following should give 0, but only approximately:
sage: q = X.parent().gen() sage: E.defining_polynomial()(X,Y,1) + O(q^11) == 0 True
Note that below we have to change variable from x to q
sage: a1,_,a3,_,_=E.a_invariants() sage: f=E.q_expansion(17) sage: q=f.parent().gen() sage: f/q == (X.derivative()/(2*Y+a1*X+a3)) True
self, [sign=1], [normalize=True]) |
Return the modular symbol associated to this elliptic curve, with given sign and base ring. This is the map that sends r/s to a fixed multiple of 2*pi*I*f(z)dz from oo to r/s, normalized so that all values of this map take values in QQ.
If sign=1, the normalization is such that the p-adic L-function associated to this modular symbol is correct. I.e., the normalization is the same as for the integral period mapping divided by 2.
Input:
sage: E=EllipticCurve('37a1') sage: M=E.modular_symbol(); M Modular symbol with sign 1 over Rational Field attached to Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field sage: M(1/2) 0 sage: M(1/5) 1/2
self, [sign=1], [base_ring=Rational Field], [bound=None]) |
Return the space of cuspidal modular symbols associated to this elliptic curve, with given sign and base ring.
Input:
sage: f = EllipticCurve('37b') sage: f.modular_symbol_space() Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(37) of weight 2 with sign 1 over Rational Field sage: f.modular_symbol_space(-1) Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2 for Gamma_0(37) of weight 2 with sign -1 over Rational Field sage: f.modular_symbol_space(0, bound=3) Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 5 for Gamma_0(37) of weight 2 with sign 0 over Rational Field
NOTE: If you just want the
-expansion, use
self.q_expansion(prec)
.
self, [options=]) |
Run Cremona's mwrank program on this elliptic curve and return the result as a string.
Input:
NOTE: The output is a raw string and completely illegible using automatic display, so it is recommended to use print for legible outout
sage: E = EllipticCurve('37a1') sage: E.mwrank() #random ... sage: print E.mwrank() Curve [0,0,1,-1,0] : Basic pair: I=48, J=-432 disc=255744 ... Generator 1 is [0:-1:1]; height 0.05111... Regulator = 0.05111... The rank and full Mordell-Weil basis have been determined unconditionally. ...
Options to mwrank can be passed:
sage: E = EllipticCurve([0,0,0,877,0])
Run mwrank with 'verbose' flag set to 0 but list generators if found
sage: print E.mwrank('-v0 -l') Curve [0,0,0,877,0] : 0 <= rank <= 1 Regulator = 1
Run mwrank again, this time with a higher bound for point searching on homogeneous spaces:
sage: print E.mwrank('-v0 -l -b11') Curve [0,0,0,877,0] : Rank = 1 Generator 1 is [29604565304828237474403861024284371796799791624792913256602 210:-256256267988926809388776834045513089648669153204356603464786949:490078 023219787588959802933995928925096061616470779979261000]; height 95.980371987964 Regulator = 95.980371987964
self, [verbose=False]) |
Construct an mwrank_EllipticCurve from this elliptic curve
The resulting mwrank_EllipticCurve has available methods from John Cremona's eclib library.
sage: E=EllipticCurve('11a1') sage: EE=E.mwrank_curve() sage: EE y^2+ y = x^3 - x^2 - 10*x - 20 sage: type(EE) <class 'sage.libs.mwrank.interface.mwrank_EllipticCurve'> sage: EE.isogeny_class() ([[0, -1, 1, -10, -20], [0, -1, 1, -7820, -263580], [0, -1, 1, 0, 0]], [[0, 5, 5], [5, 0, 0], [5, 0, 0]])
self) |
Same as self.modular_form()
.
sage: E=EllipticCurve('37a1') sage: E.newform() q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + O(q^6) sage: E.newform() == E.modular_form() True
self, [proof=None]) |
Return the number of generators of this elliptic curve.
NOTE: See gens() for further documentation. The function ngens() calls gens() if not already done, but only with default parameters. Better results may be obtained by calling mwrank() with carefully chosen parameters.
sage: E=EllipticCurve('37a1') sage: E.ngens() 1
TO DO: This example should not cause a run-time error.
sage: E=EllipticCurve([0,0,0,877,0]) sage: # E.ngens() ######## causes run-time error
sage: print E.mwrank('-v0 -b12 -l') Curve [0,0,0,877,0] : Rank = 1 Generator 1 is [29604565304828237474403861024284371796799791624792913256602 210:-256256267988926809388776834045513089648669153204356603464786949:490078 023219787588959802933995928925096061616470779979261000]; height 95.980371987964 Regulator = 95.980...
self, [A=1000]) |
Returns a list of primes p such that the mod-p representation
*might* not be surjective (this list usually
contains 2, because of shortcomings of the algorithm). If p
is not in the returned list, then rho_E,p is provably
surjective (see A. Cojocaru's paper). If the curve has CM
then infinitely many representations are not surjective, so we
simply return the sequence [(0,"cm")] and do no further computation.
Input:
sage: E = EllipticCurve([0, 0, 1, -38, 90]) # 361A sage: E.non_surjective() # CM curve [(0, 'cm')]
sage: E = EllipticCurve([0, -1, 1, 0, 0]) # X_1(11) sage: E.non_surjective() [(5, '5-torsion')]
sage: E = EllipticCurve([0, 0, 1, -1, 0]) # 37A sage: E.non_surjective() []
sage: E = EllipticCurve([0,-1,1,-2,-1]) # 141C sage: E.non_surjective() [(13, [1])]
ALGORITHM: When p<=3 use division polynomials. For 5 <= p <= B, where B is Cojocaru's bound, use the results in Section 2 of Serre's inventiones paper"Sur Les Representations Modulaires Deg Degre 2 de Galqbar Over Q."
self, p) |
The number of points on E modulo p, where p is a prime, not necessarily of good reduction. (When p is a bad prime, also counts the singular point.)
sage: E = EllipticCurve([0, -1, 1, -10, -20]) sage: E.Np(2) 5 sage: E.Np(3) 5 sage: E.conductor() 11 sage: E.Np(11) 11
self, B) |
Return a list of all ordinary primes for this elliptic curve up to and possibly including B.
sage: e = EllipticCurve('11a') sage: e.aplist(20) [-2, -1, 1, -2, 1, 4, -2, 0] sage: e.ordinary_primes(97) [3, 5, 7, 11, 13, 17, 23, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97] sage: e = EllipticCurve('49a') sage: e.aplist(20) [1, 0, 0, 0, 4, 0, 0, 0] sage: e.supersingular_primes(97) [3, 5, 13, 17, 19, 31, 41, 47, 59, 61, 73, 83, 89, 97] sage: e.ordinary_primes(97) [2, 11, 23, 29, 37, 43, 53, 67, 71, 79] sage: e.ordinary_primes(3) [2] sage: e.ordinary_primes(2) [2] sage: e.ordinary_primes(1) []
self, [p=None]) |
Return a list of pairs
where
is a prime and
is a list of the elliptic curves over
that are
-isogenous to this elliptic curve.
Input:
This is implemented using Cremona's GP script allisog.gp
.
sage: E = EllipticCurve([0,-1,0,-24649,1355209]) sage: E.p_isogenous_curves() [(2, [Elliptic Curve defined by y^2 = x^3 - x^2 - 91809*x - 9215775 over Rational Field, Elliptic Curve defined by y^2 = x^3 - x^2 - 383809*x + 91648033 over Rational Field, Elliptic Curve defined by y^2 = x^3 - x^2 + 1996*x + 102894 over Rational Field])]
The isogeny class of the curve 11a2 has three curves in it.
But p_isogenous_curves
only returns one curves, since
there is only one curve
-isogenous to 11a2.
sage: E = EllipticCurve('11a2') sage: E.p_isogenous_curves() [(5, [Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field])] sage: E.p_isogenous_curves(5) [Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field] sage: E.p_isogenous_curves(3) []
In contrast, the curve 11a1 admits two
-isogenies:
sage: E = EllipticCurve('11a1') sage: E.p_isogenous_curves(5) [Elliptic Curve defined by y^2 + y = x^3 - x^2 - 7820*x - 263580 over Rational Field, Elliptic Curve defined by y^2 + y = x^3 - x^2 over Rational Field]
self, p, [prec=20], [check=False], [check_hypotheses=True], [algorithm=auto]) |
Returns the value of the
-adic modular form
for
where
is the usual invariant differential
.
Input:
Note that if the "sqrtp" algorithm is used, a consistency check will automatically be applied, regardless of the setting of the "check" flag.
NOTES:
- If the discriminant of the curve has nonzero valuation at p,
then the result will not be returned mod
prec
, but
it still *will* have prec *digits* of precision.
TODO: - Once we have a better implementation of the "standard" algorithm, the algorithm selection strategy for "auto" needs to be revisited.
Author: David Harvey (2006-09-01): partly based on code written by Robert Bradshaw at the MSRI 2006 modular forms workshop
ACKNOWLEDGMENT: - discussion with Eyal Goren that led to the trace trick.
Here is the example discussed in the paper ``Computation of p-adic Heights and Log Convergence'' (Mazur, Stein, Tate):
sage: EllipticCurve([-1, 1/4]).padic_E2(5) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + 4*5^10 + 2*5^11 + 2*5^12 + 2*5^14 + 3*5^15 + 3*5^16 + 3*5^17 + 4*5^18 + 2*5^19 + O(5^20)
Let's try to higher precision (this is the same answer the MAGMA implementation gives):
sage: EllipticCurve([-1, 1/4]).padic_E2(5, 100) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + 4*5^10 + 2*5^11 + 2*5^12 + 2*5^14 + 3*5^15 + 3*5^16 + 3*5^17 + 4*5^18 + 2*5^19 + 4*5^20 + 5^21 + 4*5^22 + 2*5^23 + 3*5^24 + 3*5^26 + 2*5^27 + 3*5^28 + 2*5^30 + 5^31 + 4*5^33 + 3*5^34 + 4*5^35 + 5^36 + 4*5^37 + 4*5^38 + 3*5^39 + 4*5^41 + 2*5^42 + 3*5^43 + 2*5^44 + 2*5^48 + 3*5^49 + 4*5^50 + 2*5^51 + 5^52 + 4*5^53 + 4*5^54 + 3*5^55 + 2*5^56 + 3*5^57 + 4*5^58 + 4*5^59 + 5^60 + 3*5^61 + 5^62 + 4*5^63 + 5^65 + 3*5^66 + 2*5^67 + 5^69 + 2*5^70 + 3*5^71 + 3*5^72 + 5^74 + 5^75 + 5^76 + 3*5^77 + 4*5^78 + 4*5^79 + 2*5^80 + 3*5^81 + 5^82 + 5^83 + 4*5^84 + 3*5^85 + 2*5^86 + 3*5^87 + 5^88 + 2*5^89 + 4*5^90 + 4*5^92 + 3*5^93 + 4*5^94 + 3*5^95 + 2*5^96 + 4*5^97 + 4*5^98 + 2*5^99 + O(5^100)
Check it works at low precision too:
sage: EllipticCurve([-1, 1/4]).padic_E2(5, 1) 2 + O(5) sage: EllipticCurve([-1, 1/4]).padic_E2(5, 2) 2 + 4*5 + O(5^2) sage: EllipticCurve([-1, 1/4]).padic_E2(5, 3) 2 + 4*5 + O(5^3)
TODO: With the old(-er), i.e., <= sage-2.4 p-adics we
got
as output, i.e., relative precision 1, but
with the newer p-adics we get relative precision 0 and
absolute precision 1.
sage: EllipticCurve([1, 1, 1, 1, 1]).padic_E2(5, 1) O(5)
Check it works for different models of the same curve (37a), even when the discriminant changes by a power of p (note that E2 depends on the differential too, which is why it gets scaled in some of the examples below):
sage: X1 = EllipticCurve([-1, 1/4]) sage: X1.j_invariant(), X1.discriminant() (110592/37, 37) sage: X1.padic_E2(5, 10) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + O(5^10)
sage: X2 = EllipticCurve([0, 0, 1, -1, 0]) sage: X2.j_invariant(), X2.discriminant() (110592/37, 37) sage: X2.padic_E2(5, 10) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + O(5^10)
sage: X3 = EllipticCurve([-1*(2**4), 1/4*(2**6)]) sage: X3.j_invariant(), X3.discriminant() / 2**12 (110592/37, 37) sage: 2**(-2) * X3.padic_E2(5, 10) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + O(5^10)
sage: X4 = EllipticCurve([-1*(7**4), 1/4*(7**6)]) sage: X4.j_invariant(), X4.discriminant() / 7**12 (110592/37, 37) sage: 7**(-2) * X4.padic_E2(5, 10) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + O(5^10)
sage: X5 = EllipticCurve([-1*(5**4), 1/4*(5**6)]) sage: X5.j_invariant(), X5.discriminant() / 5**12 (110592/37, 37) sage: 5**(-2) * X5.padic_E2(5, 10) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + O(5^10)
sage: X6 = EllipticCurve([-1/(5**4), 1/4/(5**6)]) sage: X6.j_invariant(), X6.discriminant() * 5**12 (110592/37, 37) sage: 5**2 * X6.padic_E2(5, 10) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + O(5^10)
Test check=True vs check=False:
sage: EllipticCurve([-1, 1/4]).padic_E2(5, 1, check=False) 2 + O(5) sage: EllipticCurve([-1, 1/4]).padic_E2(5, 1, check=True) 2 + O(5) sage: EllipticCurve([-1, 1/4]).padic_E2(5, 30, check=False) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + 4*5^10 + 2*5^11 + 2*5^12 + 2*5^14 + 3*5^15 + 3*5^16 + 3*5^17 + 4*5^18 + 2*5^19 + 4*5^20 + 5^21 + 4*5^22 + 2*5^23 + 3*5^24 + 3*5^26 + 2*5^27 + 3*5^28 + O(5^30) sage: EllipticCurve([-1, 1/4]).padic_E2(5, 30, check=True) 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + 5^8 + 3*5^9 + 4*5^10 + 2*5^11 + 2*5^12 + 2*5^14 + 3*5^15 + 3*5^16 + 3*5^17 + 4*5^18 + 2*5^19 + 4*5^20 + 5^21 + 4*5^22 + 2*5^23 + 3*5^24 + 3*5^26 + 2*5^27 + 3*5^28 + O(5^30)
Here's one using the
algorithm:
sage: EllipticCurve([-1, 1/4]).padic_E2(3001, 3, algorithm="sqrtp") 1907 + 2819*3001 + 1124*3001^2 + O(3001^3)
self, p, [prec=20], [sigma=None], [check_hypotheses=True]) |
Computes the cyclotomic p-adic height.
The equation of the curve must be minimal at
.
Input:
Author Log:
sage: E = EllipticCurve("37a") sage: P = E.gens()[0] sage: h = E.padic_height(5, 10) sage: h(P) 4*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 5^6 + 4*5^8 + 3*5^9 + O(5^10)
An anomalous case:
sage: h = E.padic_height(53, 10) sage: h(P) 27*53^-1 + 22 + 32*53 + 5*53^2 + 42*53^3 + 20*53^4 + 43*53^5 + 30*53^6 + 17*53^7 + 22*53^8 + 35*53^9 + O(53^10)
Boundary case:
sage: E.padic_height(5, 3)(P) 4*5 + 3*5^2 + O(5^3)
A case that works the division polynomial code a little harder:
sage: E.padic_height(5, 10)(5*P) 4*5^3 + 3*5^4 + 3*5^5 + 4*5^6 + 4*5^7 + 5^8 + O(5^10)
Check that answers agree over a range of precisions:
sage: max_prec = 30 # make sure we get past p^2 # long time sage: full = E.padic_height(5, max_prec)(P) # long time sage: for prec in range(1, max_prec): # long time ... assert E.padic_height(5, prec)(P) == full # long time
A supersingular prime for a curve:
sage: E = EllipticCurve('37a') sage: E.is_supersingular(3) True sage: h = E.padic_height(3, 5) sage: h(E.gens()[0]) (2*3 + 2*3^2 + 3^3 + 2*3^4 + 2*3^5 + O(3^6), 3^2 + 3^3 + 3^4 + 3^5 + O(3^7)) sage: E.padic_regulator(5) 4*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 5^6 + 4*5^8 + 3*5^9 + 3*5^10 + 5^11 + 5^12 + 3*5^13 + 3*5^15 + 2*5^16 + 3*5^17 + 2*5^18 + O(5^20) sage: E.padic_regulator(3, 5) (2*3 + O(3^3), 2*3^2 + O(3^4))
A torsion point in both the good and supersingular cases:
sage: E = EllipticCurve('11a') sage: P = E.torsion_subgroup().gens()[0]; P (5 : 5 : 1) sage: h = E.padic_height(19, 5) sage: h(P) 0 sage: h = E.padic_height(5, 5) sage: h(P) 0
self, p, [prec=20], [height=None], [check_hypotheses=True]) |
Computes the cyclotomic
-adic height pairing matrix of this
curve with respect to the basis self.gens() for the
Mordell-Weil group for a given odd prime p of good ordinary reduction.
This curve must be in minimal weierstrass form.
Input:
TODO: - remove restriction that curve must be in minimal weierstrass form. This is currently required for E.gens().
Author Log:
sage: E = EllipticCurve("37a") sage: E.padic_height_pairing_matrix(5, 10) [4*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 5^6 + 4*5^8 + 3*5^9 + O(5^10)]
A rank two example:
sage: e =EllipticCurve('389a') sage: e._set_gens([e(-1, 1), e(1,0)]) # avoid platform dependent gens sage: e.padic_height_pairing_matrix(5,10) [2*5 + 2*5^2 + 4*5^3 + 3*5^4 + 3*5^5 + 4*5^6 + 3*5^7 + 4*5^8 + O(5^10) 4*5 + 3*5^3 + 2*5^4 + 5^5 + 3*5^7 + 3*5^8 + 2*5^9 + O(5^10)] [ 4*5 + 3*5^3 + 2*5^4 + 5^5 + 3*5^7 + 3*5^8 + 2*5^9 + O(5^10) 5 + 4*5^2 + 4*5^3 + 2*5^4 + 4*5^5 + 5^6 + 4*5^9 + O(5^10)]
An anomalous rank 3 example:
sage: e = EllipticCurve("5077a") sage: e._set_gens([e(-1,3), e(2,0), e(4,6)]) sage: e.padic_height_pairing_matrix(5,4) [ 1 + 5 + O(5^4) 1 + 4*5 + 2*5^3 + O(5^4) 2*5 + 3*5^3 + O(5^4)] [ 1 + 4*5 + 2*5^3 + O(5^4) 2 + 5^2 + 3*5^3 + O(5^4) 3 + 4*5^2 + 4*5^3 + O(5^4)] [ 2*5 + 3*5^3 + O(5^4) 3 + 4*5^2 + 4*5^3 + O(5^4) 4 + 5 + 3*5^2 + 3*5^3 + O(5^4)]
self, p, [prec=20], [E2=None], [check_hypotheses=True]) |
Computes the cyclotomic p-adic height.
The equation of the curve must be minimal at
.
Input:
Author: David Harvey (2008-01): based on the padic_height() function, using the algorithm of ``Computing p-adic heights via point multiplication''
sage: E = EllipticCurve("37a") sage: P = E.gens()[0] sage: h = E.padic_height_via_multiply(5, 10) sage: h(P) 4*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 5^6 + 4*5^8 + 3*5^9 + O(5^10)
An anomalous case:
sage: h = E.padic_height_via_multiply(53, 10) sage: h(P) 27*53^-1 + 22 + 32*53 + 5*53^2 + 42*53^3 + 20*53^4 + 43*53^5 + 30*53^6 + 17*53^7 + 22*53^8 + 35*53^9 + O(53^10)
Supply the value of E2 manually:
sage: E2 = E.padic_E2(5, 8) sage: E2 2 + 4*5 + 2*5^3 + 5^4 + 3*5^5 + 2*5^6 + O(5^8) sage: h = E.padic_height_via_multiply(5, 10, E2=E2) sage: h(P) 4*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 5^6 + 4*5^8 + 3*5^9 + O(5^10)
Boundary case:
sage: E.padic_height_via_multiply(5, 3)(P) 4*5 + 3*5^2 + O(5^3)
Check that answers agree over a range of precisions:
sage: max_prec = 30 # make sure we get past p^2 # long time sage: full = E.padic_height(5, max_prec)(P) # long time sage: for prec in range(2, max_prec): # long time ... assert E.padic_height_via_multiply(5, prec)(P) == full # long time
self, p, [normalize=True], [use_eclib=False]) |
Return the
-adic
-series of self at
, which is an object
whose approx method computes approximation to the true
-adic
-series to any deesired precision.
Input:
sage: E = EllipticCurve('37a') sage: L = E.padic_lseries(5); L 5-adic L-series of Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field sage: type(L) <class 'sage.schemes.elliptic_curves.padic_lseries.pAdicLseriesOrdinary'>
We compute the
-adic
-series of two curves of rank 0
and in each case verify the interpolation property for their
leading coefficient (i.e., value at 0):
sage: e = EllipticCurve('11a') sage: ms = e.modular_symbol() sage: [ms(1/11), ms(1/3), ms(0), ms(oo)] [0, -3/10, 1/5, 0] sage: ms(0) 1/5 sage: L = e.padic_lseries(3) sage: P = L.series(5) sage: P(0) 2 + 3 + 3^2 + 2*3^3 + 2*3^5 + 3^6 + O(3^7) sage: alpha = L.alpha(9); alpha 2 + 3^2 + 2*3^3 + 2*3^4 + 2*3^6 + 3^8 + O(3^9) sage: R.<x> = QQ[] sage: f = x^2 - e.ap(3)*x + 3 sage: f(alpha) O(3^9) sage: r = e.lseries().L_ratio(); r 1/5 sage: (1 - alpha^(-1))^2 * r 2 + 3 + 3^2 + 2*3^3 + 2*3^5 + 3^6 + 3^7 + O(3^9) sage: P(0) 2 + 3 + 3^2 + 2*3^3 + 2*3^5 + 3^6 + O(3^7)
Next consider the curve 37b:
sage: e = EllipticCurve('37b') sage: L = e.padic_lseries(3) sage: P = L.series(5) sage: alpha = L.alpha(9); alpha 1 + 2*3 + 3^2 + 2*3^5 + 2*3^7 + 3^8 + O(3^9) sage: r = e.lseries().L_ratio(); r 1/3 sage: (1 - alpha^(-1))^2 * r 3 + 3^2 + 2*3^4 + 2*3^5 + 2*3^6 + 3^7 + O(3^9) sage: P(0) 3 + 3^2 + 2*3^4 + 2*3^5 + O(3^6)
We can use eclib to compute the
-series. (but we don't normalize the result yet)
sage: e = EllipticCurve('11a') sage: L = e.padic_lseries(3,normalize=False,use_eclib=True) sage: P1 = L.series(5,10) sage: L = e.padic_lseries(3,normalize=False,use_eclib=False) sage: P2 = L.series(5,10) sage: P2*= P1(0) / P2(0) #rescale P2 such that the constant term agrees with P1 sage: T = P1.parent().gen() sage: Q = sum([O(3^5)*T^i for i in range(9)]) + O(T^9) #essentially zero sage: Q == Q + (P1 - P2) #check that every term agrees up to O(3^4) True
self, p, [prec=20], [height=None], [check_hypotheses=True]) |
Computes the cyclotomic p-adic regulator of this curve.
This curve must be in minimal weierstrass form.
Input:
If the rank is 0, we output 1.
TODO: - remove restriction that curve must be in minimal weierstrass form. This is currently required for E.gens().
Author Log:
sage: E = EllipticCurve("37a") sage: E.padic_regulator(5, 10) 4*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 5^6 + 4*5^8 + 3*5^9 + O(5^10)
An anomalous case:
sage: E.padic_regulator(53, 10) 27*53^-1 + 22 + 32*53 + 5*53^2 + 42*53^3 + 20*53^4 + 43*53^5 + 30*53^6 + 17*53^7 + 22*53^8 + O(53^9)
An anomalous case where the precision drops some:
sage: E = EllipticCurve("5077a") sage: E.padic_regulator(5, 10) 4*5 + 3*5^2 + 2*5^4 + 2*5^5 + 2*5^6 + 2*5^8 + 3*5^9 + O(5^10)
Check that answers agree over a range of precisions:
sage: max_prec = 30 # make sure we get past p^2 # long time sage: full = E.padic_regulator(5, max_prec) # long time sage: for prec in range(1, max_prec): # long time ... assert E.padic_regulator(5, prec) == full # long time
self, p, [N=20], [E2=None], [check=False], [check_hypotheses=True]) |
Computes the p-adic sigma function with respect to the standard
invariant differential
, as defined by
Mazur and Tate, as a power series in the usual uniformiser
at the
origin.
The equation of the curve must be minimal at
.
Input:
The output series will be truncated at
, and the
coefficient of
for
will be correct to precision
.
In practice this means the following. If
, where
is a
-adic unit with at least
digits of precision,
and
, then the returned series may be used to compute
correctly modulo
(i.e. with
correct
-adic digits).
ALGORITHM: Described in ``Efficient Computation of p-adic Heights'' (David Harvey), which is basically an optimised version of the algorithm from ``p-adic Heights and Log Convergence'' (Mazur, Stein, Tate).
Running time is soft-
, plus whatever time is
necessary to compute
.
Author Log:
sage: EllipticCurve([-1, 1/4]).padic_sigma(5, 10) O(5^11) + (1 + O(5^10))*t + O(5^9)*t^2 + (3 + 2*5^2 + 3*5^3 + 3*5^6 + 4*5^7 + O(5^8))*t^3 + O(5^7)*t^4 + (2 + 4*5^2 + 4*5^3 + 5^4 + 5^5 + O(5^6))*t^5 + O(5^5)*t^6 + (2 + 2*5 + 5^2 + 4*5^3 + O(5^4))*t^7 + O(5^3)*t^8 + (1 + 2*5 + O(5^2))*t^9 + O(5)*t^10 + O(t^11)
Run it with a consistency check:
sage: EllipticCurve("37a").padic_sigma(5, 10, check=True) O(5^11) + (1 + O(5^10))*t + O(5^9)*t^2 + (3 + 2*5^2 + 3*5^3 + 3*5^6 + 4*5^7 + O(5^8))*t^3 + (3 + 2*5 + 2*5^2 + 2*5^3 + 2*5^4 + 2*5^5 + 2*5^6 + O(5^7))*t^4 + (2 + 4*5^2 + 4*5^3 + 5^4 + 5^5 + O(5^6))*t^5 + (2 + 3*5 + 5^4 + O(5^5))*t^6 + (4 + 3*5 + 2*5^2 + O(5^4))*t^7 + (2 + 3*5 + 2*5^2 + O(5^3))*t^8 + (4*5 + O(5^2))*t^9 + (1 + O(5))*t^10 + O(t^11)
Boundary cases:
sage: EllipticCurve([1, 1, 1, 1, 1]).padic_sigma(5, 1) (1 + O(5))*t + O(t^2) sage: EllipticCurve([1, 1, 1, 1, 1]).padic_sigma(5, 2) (1 + O(5^2))*t + (3 + O(5))*t^2 + O(t^3)
Supply your very own value of E2:
sage: X = EllipticCurve("37a") sage: my_E2 = X.padic_E2(5, 8) sage: my_E2 = my_E2 + 5**5 # oops!!! sage: X.padic_sigma(5, 10, E2=my_E2) O(5^11) + (1 + O(5^10))*t + O(5^9)*t^2 + (3 + 2*5^2 + 3*5^3 + 4*5^5 + 2*5^6 + 3*5^7 + O(5^8))*t^3 + (3 + 2*5 + 2*5^2 + 2*5^3 + 2*5^4 + 2*5^5 + 2*5^6 + O(5^7))*t^4 + (2 + 4*5^2 + 4*5^3 + 5^4 + 3*5^5 + O(5^6))*t^5 + (2 + 3*5 + 5^4 + O(5^5))*t^6 + (4 + 3*5 + 2*5^2 + O(5^4))*t^7 + (2 + 3*5 + 2*5^2 + O(5^3))*t^8 + (4*5 + O(5^2))*t^9 + (1 + O(5))*t^10 + O(t^11)
Check that sigma is ``weight 1''.
sage: f = EllipticCurve([-1, 3]).padic_sigma(5, 10) sage: g = EllipticCurve([-1*(2**4), 3*(2**6)]).padic_sigma(5, 10) sage: t = f.parent().gen() sage: f(2*t)/2 (1 + O(5^10))*t + (4 + 3*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 3*5^6 + 5^7 + O(5^8))*t^3 + (3 + 3*5^2 + 5^4 + 2*5^5 + O(5^6))*t^5 + (4 + 5 + 3*5^3 + O(5^4))*t^7 + (4 + 2*5 + O(5^2))*t^9 + O(5)*t^10 + O(t^11) sage: g O(5^11) + (1 + O(5^10))*t + O(5^9)*t^2 + (4 + 3*5 + 3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 3*5^6 + 5^7 + O(5^8))*t^3 + O(5^7)*t^4 + (3 + 3*5^2 + 5^4 + 2*5^5 + O(5^6))*t^5 + O(5^5)*t^6 + (4 + 5 + 3*5^3 + O(5^4))*t^7 + O(5^3)*t^8 + (4 + 2*5 + O(5^2))*t^9 + O(5)*t^10 + O(t^11) sage: f(2*t)/2 -g O(t^11)
Test that it returns consistent results over a range of precision:
sage: max_N = 30 # get up to at least p^2 # long time sage: E = EllipticCurve([1, 1, 1, 1, 1]) # long time sage: p = 5 # long time sage: E2 = E.padic_E2(5, max_N) # long time sage: max_sigma = E.padic_sigma(p, max_N, E2=E2) # long time sage: for N in range(3, max_N): # long time ... sigma = E.padic_sigma(p, N, E2=E2) # long time ... assert sigma == max_sigma
self, p, [N=20], [lamb=0], [E2=None], [check_hypotheses=True]) |
Computes the p-adic sigma function with respect to the standard
invariant differential
, as defined by
Mazur and Tate, as a power series in the usual uniformiser
at the
origin.
The equation of the curve must be minimal at
.
This function differs from padic_sigma() in the precision profile of the returned power series; see OUTPUT below.
Input:
The coefficient of
for
will be correct to
precision
.
ALGORITHM: Described in ``Efficient Computation of p-adic Heights'' (David Harvey, to appear in LMS JCM), which is basically an optimised version of the algorithm from ``p-adic Heights and Log Convergence'' (Mazur, Stein, Tate), and ``Computing p-adic heights via point multiplication'' (David Harvey, still draft form).
Running time is soft-
, plus whatever time is
necessary to compute
.
Author: David Harvey (2008-01): wrote based on previous padic_sigma function
sage: E = EllipticCurve([-1, 1/4]) sage: E.padic_sigma_truncated(5, 10) O(5^11) + (1 + O(5^10))*t + O(5^9)*t^2 + (3 + 2*5^2 + 3*5^3 + 3*5^6 + 4*5^7 + O(5^8))*t^3 + O(5^7)*t^4 + (2 + 4*5^2 + 4*5^3 + 5^4 + 5^5 + O(5^6))*t^5 + O(5^5)*t^6 + (2 + 2*5 + 5^2 + 4*5^3 + O(5^4))*t^7 + O(5^3)*t^8 + (1 + 2*5 + O(5^2))*t^9 + O(5)*t^10 + O(t^11)
Note the precision of the
coefficient depends only on
, not on lamb:
sage: E.padic_sigma_truncated(5, 10, lamb=2) O(5^17) + (1 + O(5^14))*t + O(5^11)*t^2 + (3 + 2*5^2 + 3*5^3 + 3*5^6 + 4*5^7 + O(5^8))*t^3 + O(5^5)*t^4 + (2 + O(5^2))*t^5 + O(t^6)
Compare against plain padic_sigma() function over a dense range of N and lamb
sage: E = EllipticCurve([1, 2, 3, 4, 7]) # long time sage: E2 = E.padic_E2(5, 50) # long time sage: for N in range(2, 10): # long time ... for lamb in range(10): # long time ... correct = E.padic_sigma(5, N + 3*lamb, E2=E2) # long time ... compare = E.padic_sigma_truncated(5, N=N, lamb=lamb, E2=E2) # long time ... assert compare == correct # long time
self, [prec=None], [factor=1]) |
Return the PARI curve corresponding to this elliptic curve.
Input:
sage: E = EllipticCurve([0, 0,1,-1,0]) sage: e = E.pari_curve() sage: type(e) <type 'sage.libs.pari.gen.gen'> sage: e.type() 't_VEC' sage: e.ellan(10) [1, -2, -3, 2, -2, 6, -1, 0, 6, 4]
sage: E = EllipticCurve(RationalField(), ['1/3', '2/3']) sage: e = E.pari_curve() sage: e.type() 't_VEC' sage: e[:5] [0, 0, 0, 1/3, 2/3]
self, [prec=None]) |
Return the PARI curve corresponding to a minimal model for this elliptic curve.
Input:
sage: E = EllipticCurve(RationalField(), ['1/3', '2/3']) sage: e = E.pari_mincurve() sage: e[:5] [0, 0, 0, 27, 486] sage: E.conductor() 47232 sage: e.ellglobalred() [47232, [1, 0, 0, 0], 2]
self) |
Returns the period lattice of the elliptic curve.
sage: E = EllipticCurve('37a') sage: E.period_lattice() Period lattice associated to Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
self, height_limit, [verbose=True]) |
Search for points on a curve up to an input bound on the naive logarithmic height.
Input:
If True, report on each point as found together with linear relations between the points found and the saturation process.
If False, just return the result.
WARNING: height_limit is logarithmic, so increasing by 1 will cause the running time to increase by a factor of approximately 4.5 (=exp(1.5)). The limit of 21 is to prevent overflow, but in any case using height_limit=20 takes rather a long time!
IMPLEMENTATION: Uses Cremona's mwrank package. At the heart of this function is Cremona's port of Stoll's ratpoints program (version 1.4).
sage: E=EllipticCurve('389a1') sage: E.point_search(5, verbose=False) [(0 : -1 : 1), (-1 : 1 : 1)]
Increasing the height_limit takes longer, but finds no more points:
sage: E.point_search(10, verbose=False) [(0 : -1 : 1), (-1 : 1 : 1)]
In fact this curve has rank 2 so no more than 2 points will ever be output, but we are not using this fact.
sage: E.saturation(_) ([(0 : -1 : 1), (-1 : 1 : 1)], '1', 0.152460172772408)
What this shows is that if the rank is 2 then the points listed do generate the Mordell-Weil group (mod torsion). Finally,
sage: E.rank() 2
self, prec) |
Synonym for self.q_expansion(prec)
.
sage: E=EllipticCurve('37a1') sage: E.q_eigenform(10) q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + 6*q^6 - q^7 + 6*q^9 + O(q^10) sage: E.q_eigenform(10) == E.q_expansion(10) True
self, prec) |
Return the
-expansion to precision prec of the newform
attached to this elliptic curve.
Input:
NOTE: If you want the output to be a modular form and not just
a
-expansion, use
self.modular_form()
.
sage: E=EllipticCurve('37a1') sage: E.q_expansion(20) q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + 6*q^6 - q^7 + 6*q^9 + 4*q^10 - 5*q^11 - 6*q^12 - 2*q^13 + 2*q^14 + 6*q^15 - 4*q^16 - 12*q^18 + O(q^20)
self, D) |
Return the global minimal model of the quadratic twist of this curve by D.
sage: E=EllipticCurve('37a1') sage: E7=E.quadratic_twist(7); E7 Elliptic Curve defined by y^2 = x^3 - 784*x + 5488 over Rational Field sage: E7.conductor() 29008 sage: E7.quadratic_twist(7) == E True
self, [use_database=False], [verbose=False], [only_use_mwrank=True], [algorithm=mwrank_shell], [proof=None]) |
Return the rank of this elliptic curve, assuming no conjectures.
If we fail to provably compute the rank, raises a RuntimeError exception.
Input:
IMPLEMENTATION: Uses L-functions, mwrank, and databases.
sage: EllipticCurve('11a').rank() 0 sage: EllipticCurve('37a').rank() 1 sage: EllipticCurve('389a').rank() 2 sage: EllipticCurve('5077a').rank() 3 sage: EllipticCurve([1, -1, 0, -79, 289]).rank() # long time. This will use the default proof behavior of True. 4 sage: EllipticCurve([0, 0, 1, -79, 342]).rank(proof=False) # long time -- but under a minute 5 sage: EllipticCurve([0, 0, 1, -79, 342]).simon_two_descent()[0] # much faster -- almost instant. 5
Examples with denominators in defining equations:
sage: E = EllipticCurve( [0, 0, 0, 0, -675/4]) sage: E.rank() 0 sage: E = EllipticCurve( [0, 0, 1/2, 0, -1/5]) sage: E.rank() 1 sage: E.minimal_model().rank() 1
self) |
Returns 1 if there is 1 real component and 2 if there are 2.
sage: E = EllipticCurve('37a') sage: E.real_components () 2 sage: E = EllipticCurve('37b') sage: E.real_components () 2 sage: E = EllipticCurve('11a') sage: E.real_components () 1
self) |
Returns a list of the primes
such that the mod
representation
is reducible. For all other
primes the representation is irreducible.
NOTE - this is not provably correct in general.
See the documentation for self.isogeny_class
.
sage: E = EllipticCurve('225a') sage: E.reducible_primes() [3]
self, [use_database=True], [verbose=None], [proof=None]) |
Returns the regulator of this curve, which must be defined over Q.
Input:
sage: E = EllipticCurve([0, 0, 1, -1, 0]) sage: E.regulator() # long time (1 second) 0.0511114082399688 sage: EllipticCurve('11a').regulator() 1.00000000000000 sage: EllipticCurve('37a').regulator() 0.0511114082399688 sage: EllipticCurve('389a').regulator() 0.152460177943144 sage: EllipticCurve('5077a').regulator() # random low order bit 0.417143558758385 sage: EllipticCurve([1, -1, 0, -79, 289]).regulator() # long time (seconds) 1.50434488827528 sage: EllipticCurve([0, 0, 1, -79, 342]).regulator(proof=False) # long time (seconds) 14.7905275701310
self) |
Returns the root number of this elliptic curve.
This is 1 if the order of vanishing of the L-function L(E,s) at 1 is even, and -1 if it is odd.
sage: EllipticCurve('11a1').root_number() 1 sage: EllipticCurve('37a1').root_number() -1 sage: EllipticCurve('389a1').root_number() 1
self, D) |
Returns True precisely when D is a fundamental discriminant that satisfies the Heegner hypothesis for this elliptic curve.
sage: E = EllipticCurve('11a1') sage: E.satisfies_heegner_hypothesis(-7) True sage: E.satisfies_heegner_hypothesis(-11) False
self, points, [verbose=False], [max_prime=0], [odd_primes_only=False]) |
Given a list of rational points on E, compute the saturation in E(Q) of the subgroup they generate.
Input:
IMPLEMENTATION: Uses Cremona's mwrank package. With max_prime=0, we call mwrank with successively larger prime bounds until the full saturation is provably found. The results of saturation at the previous primes is stored in each case, so this should be reasonably fast.
sage: E=EllipticCurve('37a1') sage: P=E.gens()[0] sage: Q=5*P; Q (1/4 : -3/8 : 1) sage: E.saturation([Q]) ([(0 : -1 : 1)], '5', 0.0511114075779915)
self, p, [early_abort=False]) |
Return the number of points on
over
computed using
the SEA algorithm, as implemented in PARI by Christophe Doche
and Sylvain Duquesne.
Input:
Note: As of 2006-02-02 this function does not work on Microsoft Windows under Cygwin (though it works under vmware of course).
sage: E = EllipticCurve('37a') sage: E.sea(next_prime(10^30)) 1000000000000001426441464441649
self) |
Bound on the rank of the curve, computed using the 2-selmer group. This is the rank of the curve minus the rank of the 2-torsion, minus a number determined by whatever mwrank was able to determine related to Sha[2]. Thus in many cases, this is the actual rank of the curve.
The following is the curve 960D1, which has rank 0, but Sha of order 4.
sage: E = EllipticCurve([0, -1, 0, -900, -10098]) sage: E.selmer_rank_bound() 0
It gives 0 instead of 2, because it knows Sha is nontrivial. In contrast, for the curve 571A, also with rank 0 and Sha of order 4, we get a worse bound:
sage: E = EllipticCurve([0, -1, 1, -929, -10595]) sage: E.selmer_rank_bound() 2 sage: E.rank(only_use_mwrank=False) # uses L-function 0
self) |
Return an object of class 'sage.schemes.elliptic_curves.sha.Sha' attached to this elliptic curve.
This can be used in functions related to bounding the order of Sha (The Tate-Shafarevich group of the curve).
sage: E=EllipticCurve('37a1') sage: S=E.sha() sage: S <class 'sage.schemes.elliptic_curves.sha.Sha'> sage: S.bound_kolyvagin() ([2], 1)
self) |
where h(P) is the logarithmic height of
Note that the CPS_height_bound is often better (i.e. smaller) than the Silverman bound.
sage: E=EllipticCurve('37a1') sage: E.silverman_height_bound() 4.8254007581809182 sage: E.CPS_height_bound() 0.16397076103046915
self, [verbose=0], [lim1=5], [lim3=50], [limtriv=10], [maxprob=20], [limbigprime=30]) |
Given a curve with no 2-torsion, computes (probably) the rank of the Mordell-Weil group, with certainty the rank of the 2-Selmer group, and a list of independent points on the curve.
Input:
IMPLEMENTATION: Uses Denis Simon's GP/PARI scripts from http://www.math.unicaen.fr/~simon/
These computations use pseudo-random numbers, so we set the seed for reproducible testing.
We compute the ranks of the curves of lowest known conductor up to rank
.
Amazingly, each of these computations finishes almost instantly!
sage: E = EllipticCurve('11a1') sage: set_random_seed(0) sage: E.simon_two_descent() (0, 0, []) sage: E = EllipticCurve('37a1') sage: set_random_seed(0) sage: E.simon_two_descent() (1, 1, [(0 : 0 : 1)]) sage: E = EllipticCurve('389a1') sage: set_random_seed(0) sage: E.simon_two_descent() (2, 2, [(1 : 0 : 1), (-11/9 : -55/27 : 1)]) sage: E = EllipticCurve('5077a1') sage: set_random_seed(0) sage: E.simon_two_descent() (3, 3, [(1 : 0 : 1), (2 : -1 : 1), (0 : 2 : 1)])
In this example Simon's program does not find any points, though it does correctly compute the rank of the 2-Selmer group.
sage: E = EllipticCurve([1, -1, 0, -751055859, -7922219731979]) # long (0.6 seconds) sage: set_random_seed(0) sage: E.simon_two_descent () (1, 1, [])
The rest of these entries were taken from Tom Womack's page http://tom.womack.net/maths/conductors.htm
sage: E = EllipticCurve([1, -1, 0, -79, 289]) sage: set_random_seed(0) sage: E.simon_two_descent() (4, 4, [(6 : -5 : 1), (4 : 3 : 1), (5 : -3 : 1), (8 : -15 : 1)]) sage: E = EllipticCurve([0, 0, 1, -79, 342]) sage: set_random_seed(0) sage: E.simon_two_descent() (5, 5, [(5 : 8 : 1), (10 : 23 : 1), (3 : 11 : 1), (4 : -10 : 1), (0 : 18 : 1)]) sage: E = EllipticCurve([1, 1, 0, -2582, 48720]) sage: set_random_seed(0) sage: r, s, G = E.simon_two_descent(); r,s (6, 6) sage: E = EllipticCurve([0, 0, 0, -10012, 346900]) sage: set_random_seed(0) sage: r, s, G = E.simon_two_descent(); r,s (7, 7) sage: E = EllipticCurve([0, 0, 1, -23737, 960366]) sage: set_random_seed(0) sage: r, s, G = E.simon_two_descent(); r,s (8, 8)
self, B) |
Return a list of all supersingular primes for this elliptic curve up to and possibly including B.
sage: e = EllipticCurve('11a') sage: e.aplist(20) [-2, -1, 1, -2, 1, 4, -2, 0] sage: e.supersingular_primes(1000) [2, 19, 29, 199, 569, 809]
sage: e = EllipticCurve('27a') sage: e.aplist(20) [0, 0, 0, -1, 0, 5, 0, -7] sage: e.supersingular_primes(97) [2, 5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89] sage: e.ordinary_primes(97) [7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97] sage: e.supersingular_primes(3) [2] sage: e.supersingular_primes(2) [2] sage: e.supersingular_primes(1) []
self, p) |
The Tamagawa number of the elliptic curve at
.
sage: E = EllipticCurve('11a') sage: E.tamagawa_number(11) 5 sage: E = EllipticCurve('37b') sage: E.tamagawa_number(37) 3
self) |
Return a list of all Tamagawa numbers for all prime divisors of the conductor (in order).
sage: e = EllipticCurve('30a1') sage: e.tamagawa_numbers() [2, 3, 1] sage: vector(e.tamagawa_numbers()) (2, 3, 1)
self) |
Returns the product of the Tamagawa numbers.
sage: E = EllipticCurve('54a') sage: E.tamagawa_product () 3
self, p) |
Creates the Tate Curve over the
-adics associated to this elliptic curves.
This Tate curve a
-adic curve with split multiplicative
reduction of the form
which is
isomorphic to the given curve over the algebraic closure of
. Its points over
are isomorphic to
for a certain parameter
.
Input:
p - a prime where the curve has multiplicative reduction.
sage: e = EllipticCurve('130a1') sage: e.tate_curve(2) 2-adic Tate curve associated to the Elliptic Curve defined by y^2 + x*y + y = x^3 - 33*x + 68 over Rational Field
The input curve must have multiplicative reduction at the prime.
sage: e.tate_curve(3) Traceback (most recent call last): ... ValueError: The elliptic curve must have multiplicative reduction at 3
We compute with
:
sage: T = e.tate_curve(5); T 5-adic Tate curve associated to the Elliptic Curve defined by y^2 + x*y + y = x^3 - 33*x + 68 over Rational Field
We find the Tate parameter
:
sage: T.parameter(prec=5) 3*5^3 + 3*5^4 + 2*5^5 + 2*5^6 + 3*5^7 + O(5^8)
We compute the
-invariant of the curve:
sage: T.L_invariant(prec=10) 5^3 + 4*5^4 + 2*5^5 + 2*5^6 + 2*5^7 + 3*5^8 + 5^9 + O(5^10)
self, [bound=0], [method=2]) |
Return the 3-selmer rank of this elliptic curve, computed using Magma.
This is not implemented for all curves; a NotImplementedError exception is raised when this function is called on curves for which 3-descent isn't implemented.
Note:
Use a slightly modified version of Michael Stoll's MAGMA
file 3descent.m
. You must have Magma to use this
function.
sage: EllipticCurve('37a').three_selmer_rank() # optional \& long -- Magma 1
sage: EllipticCurve('14a1').three_selmer_rank() # optional Traceback (most recent call last): ... NotImplementedError: Currently, only the case with irreducible phi3 is implemented.
self) |
Return the order of the torsion subgroup.
sage: e = EllipticCurve('11a') sage: e.torsion_order() 5 sage: type(e.torsion_order()) <type 'sage.rings.integer.Integer'> sage: e = EllipticCurve([1,2,3,4,5]) sage: e.torsion_order() 1 sage: type(e.torsion_order()) <type 'sage.rings.integer.Integer'>
self, [flag=0]) |
Returns the torsion subgroup of this elliptic curve.
Input:
sage: EllipticCurve('11a').torsion_subgroup() Torsion Subgroup isomorphic to Multiplicative Abelian Group isomorphic to C5 associated to the Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field sage: EllipticCurve('37b').torsion_subgroup() Torsion Subgroup isomorphic to Multiplicative Abelian Group isomorphic to C3 associated to the Elliptic Curve defined by y^2 + y = x^3 + x^2 - 23*x - 50 over Rational Field
sage: e = EllipticCurve([-1386747,368636886]);e Elliptic Curve defined by y^2 = x^3 - 1386747*x + 368636886 over Rational Field sage: G = e.torsion_subgroup(); G Torsion Subgroup isomorphic to Multiplicative Abelian Group isomorphic to C8 x C2 associated to the Elliptic Curve defined by y^2 = x^3 - 1386747*x + 368636886 over Rational Field sage: G.0 (1227 : 22680 : 1) sage: G.1 (282 : 0 : 1) sage: list(G) [1, P1, P0, P0*P1, P0^2, P0^2*P1, P0^3, P0^3*P1, P0^4, P0^4*P1, P0^5, P0^5*P1, P0^6, P0^6*P1, P0^7, P0^7*P1]
self, [verbose=True], [selmer_only=False], [first_limit=20], [second_limit=8], [n_aux=-1], [second_descent=1]) |
Compute 2-descent data for this curve.
Input:
Nothing - nothing is returned (though much is printed unless verbose=False)
sage: E=EllipticCurve('37a1') sage: E.two_descent(verbose=False) # no output
self, [verbose=0], [lim1=5], [lim3=50], [limtriv=10], [maxprob=20], [limbigprime=30]) |
Given a curve with no 2-torsion, computes (probably) the rank of the Mordell-Weil group, with certainty the rank of the 2-Selmer group, and a list of independent points on the curve.
Input:
IMPLEMENTATION: Uses Denis Simon's GP/PARI scripts from http://www.math.unicaen.fr/~simon/
These computations use pseudo-random numbers, so we set the seed for reproducible testing.
We compute the ranks of the curves of lowest known conductor up to rank
.
Amazingly, each of these computations finishes almost instantly!
sage: E = EllipticCurve('11a1') sage: set_random_seed(0) sage: E.simon_two_descent() (0, 0, []) sage: E = EllipticCurve('37a1') sage: set_random_seed(0) sage: E.simon_two_descent() (1, 1, [(0 : 0 : 1)]) sage: E = EllipticCurve('389a1') sage: set_random_seed(0) sage: E.simon_two_descent() (2, 2, [(1 : 0 : 1), (-11/9 : -55/27 : 1)]) sage: E = EllipticCurve('5077a1') sage: set_random_seed(0) sage: E.simon_two_descent() (3, 3, [(1 : 0 : 1), (2 : -1 : 1), (0 : 2 : 1)])
In this example Simon's program does not find any points, though it does correctly compute the rank of the 2-Selmer group.
sage: E = EllipticCurve([1, -1, 0, -751055859, -7922219731979]) # long (0.6 seconds) sage: set_random_seed(0) sage: E.simon_two_descent () (1, 1, [])
The rest of these entries were taken from Tom Womack's page http://tom.womack.net/maths/conductors.htm
sage: E = EllipticCurve([1, -1, 0, -79, 289]) sage: set_random_seed(0) sage: E.simon_two_descent() (4, 4, [(6 : -5 : 1), (4 : 3 : 1), (5 : -3 : 1), (8 : -15 : 1)]) sage: E = EllipticCurve([0, 0, 1, -79, 342]) sage: set_random_seed(0) sage: E.simon_two_descent() (5, 5, [(5 : 8 : 1), (10 : 23 : 1), (3 : 11 : 1), (4 : -10 : 1), (0 : 18 : 1)]) sage: E = EllipticCurve([1, 1, 0, -2582, 48720]) sage: set_random_seed(0) sage: r, s, G = E.simon_two_descent(); r,s (6, 6) sage: E = EllipticCurve([0, 0, 0, -10012, 346900]) sage: set_random_seed(0) sage: r, s, G = E.simon_two_descent(); r,s (7, 7) sage: E = EllipticCurve([0, 0, 1, -23737, 960366]) sage: set_random_seed(0) sage: r, s, G = E.simon_two_descent(); r,s (8, 8)
self) |
Return the dimension of the 2-torsion subgroup of
.
This will be 0, 1 or 2.
NOTE: As s side-effect of calling this function, the full torsion subgroup of the curve is computed (if not already cached). A simpler implementation of this function would be possible (by counting the roots of the 2-division polynomial), but the full torsion subgroup computation is not expensive.
sage: EllipticCurve('11a1').two_torsion_rank() 0 sage: EllipticCurve('14a1').two_torsion_rank() 1 sage: EllipticCurve('15a1').two_torsion_rank() 2
Special Functions: __init__,
_EllipticCurve_rational_field__adjust_heegner_index,
_is_surjective,
_multiple_of_degree_of_isogeny_to_optimal_curve,
_set_conductor,
_set_cremona_label,
_set_gens,
_set_modular_degree,
_set_rank,
_set_torsion_order
self, a) |
Take the square root of the interval that contains the Heegner index.
sage: E = EllipticCurve('11a1') sage: a = RIF(sqrt(2))-1.4142135623730951 sage: E._EllipticCurve_rational_field__adjust_heegner_index(a) [0.0000000... .. 1.490116...e-8]
self) |
Internal function returning an integer m such that the degree of the isogeny between this curve and the optimal curve in its isogeny class is a divisor of m.
sage: E=EllipticCurve('11a1') sage: E._multiple_of_degree_of_isogeny_to_optimal_curve() 25 sage: E=EllipticCurve('11a2') sage: E._multiple_of_degree_of_isogeny_to_optimal_curve() 5 sage: E=EllipticCurve('11a3') sage: E._multiple_of_degree_of_isogeny_to_optimal_curve() 5
self, N) |
Internal function to set the cached conductor of this elliptic curve to N.
WARNING: No checking is done! Not intended for use by users. Setting to the wrong value will cause strange problems (see examples).
sage: E=EllipticCurve('37a1') sage: E._set_conductor(99) # bogus value -- not checked sage: E.conductor() # returns bogus cached value 99
This will not work since the conductor is used when searching the database:
sage: E._set_conductor(E.database_curve().conductor()) Traceback (most recent call last): ... RuntimeError: Elliptic curve ... not in the database. sage: E._set_conductor(EllipticCurve(E.a_invariants()).database_curve().conductor()) sage: E.conductor() # returns correct value 37
self, L) |
Internal function to set the cached label of this elliptic curve to L.
WARNING: No checking is done! Not intended for use by users.
sage: E=EllipticCurve('37a1') sage: E._set_cremona_label('bogus') sage: E.label() 'bogus' sage: E.database_curve().label() '37a1' sage: E.label() # no change 'bogus' sage: E._set_cremona_label(E.database_curve().label()) sage: E.label() # now it is correct '37a1'
self, gens) |
Internal function to set the cached generators of this elliptic curve to gens.
WARNING: No checking is done!
sage: E=EllipticCurve('5077a1') sage: E.rank() 3 sage: E.gens() # random [(-2 : 3 : 1), (-7/4 : 25/8 : 1), (1 : -1 : 1)] sage: E._set_gens([]) # bogus list sage: E.rank() # unchanged 3 sage: E._set_gens(E.database_curve().gens()) sage: E.gens() [(-2 : 3 : 1), (-7/4 : 25/8 : 1), (1 : -1 : 1)]
self, deg) |
Internal function to set the cached modular degree of this elliptic curve to deg.
WARNING: No checking is done!
sage: E=EllipticCurve('5077a1') sage: E.modular_degree() 1984 sage: E._set_modular_degree(123456789) sage: E.modular_degree() 123456789 sage: E._set_modular_degree(E.database_curve().modular_degree()) sage: E.modular_degree() 1984
self, r) |
Internal function to set the cached rank of this elliptic curve to r.
WARNING: No checking is done! Not intended for use by users.
sage: E=EllipticCurve('37a1') sage: E._set_rank(99) # bogus value -- not checked sage: E.rank() # returns bogus cached value 99 sage: E.gens() # causes actual rank to be computed [(0 : -1 : 1)] sage: E.rank() # the correct rank 1
self, t) |
Internal function to set the cached torsion order of this elliptic curve to t.
WARNING: No checking is done! Not intended for use by users.
sage: E=EllipticCurve('37a1') sage: E._set_torsion_order(99) # bogus value -- not checked sage: E.torsion_order() # returns bogus cached value 99 sage: T = E.torsion_subgroup() # causes actual torsion to be computed sage: E.torsion_order() # the correct value 1