24.6 Elliptic curves over the rational numbers

Module: sage.schemes.elliptic_curves.ell_rational_field

Author Log:

Module-level Functions

cremona_curves( conductors)

Return iterator over all known curves (in database) with conductor in the list of conductors.

cremona_optimal_curves( conductors)

Return iterator over all known optimal curves (in database) with conductor in the list of conductors.

Class: EllipticCurve_rational_field

class EllipticCurve_rational_field
Elliptic curve over the Rational Field.
EllipticCurve_rational_field( self, ainvs, [extra=None])

Functions: an,$  $ analytic_rank,$  $ anlist,$  $ ap,$  $ aplist,$  $ complex_area,$  $ conductor,$  $ CPS_height_bound,$  $ cremona_label,$  $ database_curve,$  $ eval_modular_form,$  $ gens,$  $ gens_certain,$  $ has_cm,$  $ heegner_discriminants,$  $ heegner_discriminants_list,$  $ heegner_index,$  $ heegner_index_bound,$  $ heegner_point_height,$  $ is_good,$  $ is_integral,$  $ is_isomorphic,$  $ is_minimal,$  $ is_ordinary,$  $ is_semistable,$  $ is_supersingular,$  $ is_surjective,$  $ isogeny_class,$  $ kodaira_type,$  $ L1_vanishes,$  $ L_ratio,$  $ label,$  $ Lambda,$  $ Lseries,$  $ Lseries_at1,$  $ Lseries_deriv_at1,$  $ Lseries_dokchitser,$  $ Lseries_extended,$  $ Lseries_sympow,$  $ Lseries_sympow_derivs,$  $ Lseries_twist_values,$  $ Lseries_twist_zeros,$  $ Lseries_values_along_line,$  $ Lseries_zeros,$  $ Lseries_zeros_in_interval,$  $ minimal_model,$  $ modular_degree,$  $ modular_form,$  $ modular_parametrization,$  $ mwrank,$  $ mwrank_curve,$  $ newform,$  $ ngens,$  $ non_surjective,$  $ Np,$  $ omega,$  $ p_isogenous_curves,$  $ padic_E2,$  $ padic_height,$  $ padic_regulator,$  $ 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_an,$  $ shabound,$  $ shabound_kato,$  $ shabound_kolyvagin,$  $ sigma,$  $ silverman_height_bound,$  $ simon_two_descent,$  $ tamagawa_number,$  $ tamagawa_product,$  $ three_selmer_rank,$  $ torsion_order,$  $ torsion_subgroup,$  $ two_descent,$  $ two_descent_simon,$  $ two_selmer_shabound,$  $ two_torsion_rank,$  $ watkins_data,$  $ weierstrass_model

an( self, n)

The n-th Fourier coefficient of the modular form corresponding to this elliptic curve, where n is a positive integer.

analytic_rank( self, [algorithm=cremona])

Return an integer that is probably the analytic rank of this elliptic curve.

INPUT:
    algorithm:
        -- 'cremona' (default) --  Use the Buhler-Gross algorithm
            as implemented in GP by Tom Womack and John Cremona,
            who note that their implementation is practical for
            any rank and conductor $\leq 10^{10}$ in 10 minutes.

- 'ec' - use Watkins's program ec (this has bugs if more than a million terms of the L-series are required, i.e., only use this for conductor up to about $ 10^11$ ).

- '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 $ \geq 4$ .

sage: E = EllipticCurve('389a')
sage: E.analytic_rank(algorithm='cremona')
2
sage: E.analytic_rank(algorithm='ec')
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

anlist( self, n, [pari_ints=False])

The Fourier coefficients up to and including $ a_n$ of the modular form attached to this elliptic curve. The ith element of the return list is a[i].

INPUT:
    n -- integer
    pari_ints -- bool (default: False); if True return a list of
              PARI ints instead of SAGE integers; this can
              be much faster for large n.

OUTPUT:
    -- list of integers

If pari_ints is False, the result is cached.

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]

ap( self, p)

The p-th Fourier coefficient of the modular form corresponding to this elliptic curve, where p is prime.

aplist( self, pmax)

Return list of pairs (p, a_p(E)) for p up to pmax.

complex_area( self)

Return the area of a fundamental domain for the period lattice of the elliptic curve.

sage: E = EllipticCurve('37a')
sage: E.complex_area()
7.3381327407991845

conductor( self, [algorithm=pari])

Returns the conductor of the elliptic curve.

INPUT:
    algorithm -- str, (default: "pari")
           "pari"   -- use the PARI C-library ellglobalred
                       implementation of Tate's algorithm
           "mwrank" -- use Cremona's mwrank implementation of
                       Tate's algorithm; can be faster if the
                       curve has integer coefficients (TODO:
                       limited to small conductor until mwrank
                       gets integer factorization)
           "gp" -- use the GP interpreter.
           "all" -- use both implementations, verify that the
                    results are the same (or raise an error),
                    and output the common value.

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.

CPS_height_bound( 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.

cremona_label( 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.

database_curve( 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.

gens( self, [verbose=True], [rank1_search=mwrank_shell], [algorithm=10], [only_use_mwrank=False])

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.

TODO: Right now this function assumes that the input curve is in minimal Weierstrass form. This restriction will be removed in the near future. This function raises a NotImplementedError if a non-minimal curve is given as input.

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:
    verbose -- (default: None), if specified changes the
               verbosity of mwrank computations.
    rank1_search -- (default: 16), if the curve has analytic
               rank 1, try to find a generator by a direct
               search up to this logarithmic height.  If this
               fails the usual mwrank procedure is called.
    algorithm -- 'mwrank_shell' (default) -- call mwrank shell command
              -- 'mwrank_lib' -- call mwrank c library
OUTPUT:
    generators -- List of generators for the Mordell-Weil group.

IMPLEMENTATION: Uses Cremona's mwrank C library.

gens_certain( self)

Return True if the generators have been proven correct.

heegner_discriminants_list( self, n)

List of the first n Heegner discriminants for self.

heegner_index( self, D, [min_p=False], [prec=5], [verbose=3])

Returns the index of the Heegner point on the quadratic twist by D, as computed using the Gross-Zagier formula and/or a point search.

Return (an interval that contains) the square of the index of the Heegner point in the group of K-rational points *modulo torsion* on the twist of the elliptic curve by D.

WARNING: This function uses the Gross-Zagier formula. When E is 681b and D=-8 for some reason the returned index is 9/4 which is off by a factor of 4. Evidently the GZ formula must be modified in this case.

If 0 is in the interval of the height of the Heegner point computed to the given prec, then this function returns 0.

INPUT:
    D (int) -- Heegner discriminant
    min_p (int) -- (default: 3) only rule out primes >= min_p
                   dividing the index.  
    verbose (bool) -- (default: False); print lots of mwrank search status
                                        information when computing
regulator
    prec (int) -- (default: 5), use prec*sqrt(N) + 20 terms
                  of L-series in computations, where N is the
                  conductor.
                  
OUTPUT:
    an interval that contains the index

sage: E = EllipticCurve('11a')
sage: E.heegner_discriminants(50)
[-7, -8, -19, -24, -35, -39, -40, -43]
sage: E.heegner_index(-7)
[0.999993856229, 1.00000616632]

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)
[3.99999236227, 4.00000791569]

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.

heegner_index_bound( self, [D=21], [prec=True], [verbose=5], [max_height=0])

Assume self has rank 0.

Return a list v of primes such that if an odd prime p divides the index of the 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:
    D (int) -- (deault: 0) Heegner discriminant; if 0, use the
               first discriminant < -4 that satisfies the Heegner
hypothesis
    verbose (bool) -- (default: True)
    prec (int) -- (default: 5), use prec*sqrt(N) + 20 terms
                  of L-series in computations, where N is the
                  conductor.
    max_height (float) -- should be <= 21; bound on logarithmic naive
height
                          used in point searches.  Make smaller to make
this
                          function faster, at the expense of possibly
obtaining
                          a worse answer.  A good range is between 13 and
21.
                          
OUTPUT:
    v -- list or int (bad primes or 0 or -1)
    D -- the discriminant that was used (this is useful if D was
         automatically selected).

heegner_point_height( 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:
    D (int) -- fundamental discriminant (=/= -3, -4)
    prec (int) -- (default: 2), use prec*sqrt(N) + 20 terms
                  of L-series in computations, where N is the
                  conductor.

OUTPUT:
    Interval that contains the height of the Heegner point.

sage: E = EllipticCurve('11a')
sage: E.heegner_point_height(-7)
[0.222270926217, 0.222273662409]

is_good( self, p)

Return True if $ p$ is a prime of good reduction for $ E$ .

INPUT:
    p -- a prime

OUTPUT:
    bool

is_ordinary( self, p, [ell=None])

Return True precisely when the mod-p representation attached to this elliptic curve is ordinary at ell.

INPUT:
    p -- a prime
    ell - a prime (default: p)

OUTPUT:
    bool

is_supersingular( self, p, [ell=None])

Return True precisely when the mod-p representation attached to this elliptic curve is supersingular at ell.

INPUT:
    p -- a prime
    ell - a prime (default: p)

OUTPUT:
    bool

is_surjective( 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.

INPUT:
    p -- int (a prime number)
    A -- int (a bound on the number of a_p to use)

OUTPUT:
    a 2-tuple:
    -- surjective or (probably) not
    -- information about what it is if not surjective

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.

isogeny_class( self, [algorithm=False], [verbose=mwrank])

Return all curves over $ \mathbf{Q}$ in the isogeny class of this elliptic curve.

INPUT:
    algorithm -- string:
         "mwrank"   -- (default) use the mwrank C++ library
         "database" -- use the Cremona database (only works if
                       curve is isomorphic to a curve in the database)

OUTPUT:
    Returns the sorted list of the curves isogenous to self.
    If algorithm is "mwrank", also returns the isogeny matrix (otherwise
    returns None as second return value).

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 $ 37$ -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 $ 2$ -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.

kodaira_type( self, p)

Local Kodaira type of the elliptic curve at $ p$ .

1 means good reduction (type $ I_0$ ), 2, 3 and 4 mean types II, III and IV, respectively, $ 4 + \nu$ with $ \nu > 0$ means type $ I_{\nu}$ ; finally the opposite values -1, -2, etc. refer to the starred types $ I_0^*$ , $ II^*$ , etc.

sage: E = EllipticCurve('124a')
sage: E.kodaira_type(2)
'4'

L1_vanishes( self)

Returns whether or not L(E,1) = 0. The result is provably correct if the Manin constant of the associated optimal quotient is <= 2. This hypothesis on the Manin constant is true for all curves of conductor <= 40000 (by Cremona) and all semistable curves (i.e., squarefree conductor).

sage: E = EllipticCurve([0, -1, 1, -10, -20])   # 11A  = X_0(11)
sage: E.L1_vanishes()
False
sage: E = EllipticCurve([0, -1, 1, 0, 0])       # X_1(11)
sage: E.L1_vanishes()
False
sage: E = EllipticCurve([0, 0, 1, -1, 0])       # 37A  (rank 1)
sage: E.L1_vanishes()
True
sage: E = EllipticCurve([0, 1, 1, -2, 0])       # 389A (rank 2)
sage: E.L1_vanishes()
True
sage: E = EllipticCurve([0, 0, 1, -38, 90])     # 361A (CM curve))
sage: E.L1_vanishes()
True
sage: E = EllipticCurve([0,-1,1,-2,-1])         # 141C (13-isogeny)
sage: E.L1_vanishes()
False

WARNING: It's conceivable that machine floats are not large enough precision for the computation; if this could be the case a RuntimeError is raised. The curve's real period would have to be very small for this to occur.

ALGORITHM: Compute the root number. If it is -1 then L(E,s) vanishes to odd order at 1, hence vanishes. If it is +1, use a result about modular symbols and Mazur's "Rational Isogenies" paper to determine a provably correct bound (assuming Manin constant is <= 2) so that we can determine whether L(E,1) = 0.

Author: William Stein, 2005-04-20.

L_ratio( self)

Returns the ratio $ L(E,1)/\Omega$ as an exact rational number. The result is provably correct if the Manin constant of the associated optimal quotient is $ \leq 2$ . This hypothesis on the Manin constant is true for all semistable curves (i.e., squarefree conductor), by a theorem of Mazur from his Rational Isogenies of Prime Degree paper.

sage: E = EllipticCurve([0, -1, 1, -10, -20])   # 11A  = X_0(11)
sage: E.L_ratio()
1/5
sage: E = EllipticCurve([0, -1, 1, 0, 0])       # X_1(11)
sage: E.L_ratio()
1/25
sage: E = EllipticCurve([0, 0, 1, -1, 0])       # 37A  (rank 1)
sage: E.L_ratio()
0
sage: E = EllipticCurve([0, 1, 1, -2, 0])       # 389A (rank 2)
sage: E.L_ratio()
0
sage: E = EllipticCurve([0, 0, 1, -38, 90])     # 361A (CM curve))
sage: E.L_ratio()
0
sage: E = EllipticCurve([0,-1,1,-2,-1])         # 141C (13-isogeny)
sage: E.L_ratio()
1
sage: E = EllipticCurve(RationalField(), [1, 0, 0, 1/24624, 1/886464])
sage: E.L_ratio()
2

WARNING: It's conceivable that machine floats are not large enough precision for the computation; if this could be the case a RuntimeError is raised. The curve's real period would have to be very small for this to occur.

ALGORITHM: Compute the root number. If it is -1 then L(E,s) vanishes to odd order at 1, hence vanishes. If it is +1, use a result about modular symbols and Mazur's "Rational Isogenies" paper to determine a provably correct bound (assuming Manin constant is <= 2) so that we can determine whether L(E,1) = 0.

Author: William Stein, 2005-04-20.

Lambda( self, s, prec)

Returns the value of the Lambda-series of the elliptic curve E at s can be any complex number.

Uses prec terms of the power series.

sage: E = EllipticCurve('389a')
sage: E.Lambda(1.4+0.5*I, 50)
-0.35417268051555018 + 0.87451868171893621*I

Lseries( self, s)

Returns the value of the L-series of the elliptic curve E at s, where s must be a real number.

Use self.Lseries_extended for s complex.

Note: If the conductor of the curve is large, say $ >10^{12}$ , then this function will take a very long time, since it uses an $ O(\sqrt{N})$ algorithm.

sage: E = EllipticCurve([1,2,3,4,5])
sage: E.Lseries(1)
0.00000000000000000
sage: E.Lseries('1.1')       # long (!)
0.28549100767814833

TODO: Planned massive improvement - use Micheal Rubinstein's L-functions package and/or Tim Dokchitser's. Both are already available via other function calls. Note that Dokchitser's program is vastly faster than PARI, e.g., at computing E.Lseries(1.1) above, even with all the startup overhead, etc, e.g., 10 seconds versus 0.25 seconds.

Lseries_at1( self, [k=0])

Compute $ L(E,1)$ using $ k$ terms of the series for $ L(E,1)$ as explained on page 406 of Henri Cohen's book"A Course in Computational Algebraic Number Theory". If the argument $ k$ is not specified, then it defaults to $ \sqrt(N)$ , where $ N$ is the conductor.

The real precision used in each step of the computation is the precision of machine floats.

INPUT:
    k -- (optional) an integer, defaults to sqrt(N).
    
OUTPUT:
    float -- L(E,1)
    float -- a bound on the error in the approximation; this
             is a proveably correct upper bound on the sum
             of the tail end of the series used to compute L(E,1).

This function is disjoint from the PARI elllseries command, which is for a similar purpose. To use that command (via the PARI C library), simply type E.pari_mincurve().elllseries(1)

ALGORITHM:

  1. Compute the root number eps. If it is -1, return 0.

  2. Compute the Fourier coefficients a_n, for n up to and including k.

  3. Compute the sum

    $\displaystyle 2 * sum_{n=1}^{k} (a_n / n) * exp(-2*pi*n/Sqrt(N)),
$

    where N is the conductor of E.

  4. Compute a bound on the tail end of the series, which is

    $\displaystyle 2 * e^(-2 * pi * (k+1) / sqrt(N)) / (1 - e^(-2*pi/sqrt(N))).
$

    For a proof see [Grigov-Jorza-Patrascu-Patrikis-Stein].

sage: E = EllipticCurve('37b')
sage: E.Lseries_at1(100)
(0.72568106193600002,
0.0000000000000000000000000000000000000000000015243750228899999)

Lseries_deriv_at1( self, [k=0])

Compute $ L'(E,1)$ using$ k$ terms of the series for $ L'(E,1)$ .

The algorithm used is from page 406 of Henri Cohen's book ``A Course in Computational Algebraic Number Theory.''

The real precision of the computation is the precision of Python floats.

INPUT:
    k -- int; number of terms of the series

OUTPUT:
    real number -- an approximation for L'(E,1)
    real number -- a bound on the error in the approximation

ALGORITHM:

  1. Compute the root number eps. If it is 1, return 0.

  2. Compute the Fourier coefficients $ a_n$ , for $ n$ up to and including $ k$ .

  3. Compute the sum

    $\displaystyle 2 * \sum_{n=1}^{k} (a_n / n) * E_1(2 \pi n/\sqrt{N}),
$

    where $ N$ is the conductor of $ E$ , and $ E_1$ is the exponential integral function.

  4. Compute a bound on the tail end of the series, which is

    $\displaystyle 2 * e^{-2 \pi (k+1) / \sqrt{N}} / (1 - e^{-2  pi/\sqrt{N}}).
$

    For a proof see [Grigov-Jorza-Patrascu-Patrikis-Stein]. This is exactly the same as the bound for the approximation to $ L(E,1)$ produced by Lseries_at1.

sage: E = EllipticCurve('37a')
sage: E.Lseries_deriv_at1(100)
(0.30599977383499999,
 0.0000000000000000000000000000000000000000000015243750228899999)

Lseries_dokchitser( self, [prec=gp], [max_imaginary_part=40], [max_asymp_coeffs=0], [algorithm=53])

Return interface to Tim Dokchitser's program for computing with the L-series of this elliptic curve; this provides a way to compute Taylor expansions and higher derivatives of $ L$ -series.

INPUT:
    prec -- integer (bits precision)
    max_imaginary_part -- real number
    max_asymp_coeffs -- integer
    algorithm -- string: 'gp' or 'magma'

Note: If algorithm='magma', then the precision is in digits rather than bigs and the object returned is a Magma L-series, which has different functionality from the SAGE L-series.

sage: E = EllipticCurve('37a')
sage: L = E.Lseries_dokchitser()
sage: L(2)
0.38157540826071124
sage: L = E.Lseries_dokchitser(algorithm='magma')         # optional
sage: L.Evaluate(2)                                       # optional
0.38157540826071121129371040958008663667709753398892116

Lseries_extended( self, s, prec)

Returns the value of the L-series of the elliptic curve E at s can be any complex number using prec terms of the power series expansion.

INPUT:
    s -- complex number
    prec -- integer

sage: E = EllipticCurve('389a')
sage: E.Lseries_extended(1 + I, 50)
-0.63840995909825760 + 0.71549526219140858*I
sage: E.Lseries_extended(1 + 0.1*I, 50)
-0.0076121653876937805 + 0.00043488570464214908*I

NOTE: You might also want to use Tim Dokchitser's L-function calculator, which is available by typing L = E.Lseries_dokchitser(), then evaluating L. It gives the same information but is sometimes much faster.

Lseries_sympow( self, n, prec)

Return $ L(\Sym ^{(n)}(E,$   edge$ ))$ to prec digits of precision.

INPUT:
    n -- integer
    prec -- integer
    
OUTPUT:
    string -- real number to prec digits of precision as a string.

Note: Before using this function for the first time for a given $ n$ , you may have to type sympow('-new_data <n>'), where <n> is replaced by your value of $ n$ . This command takes a long time to run.

sage: E = EllipticCurve('37a')
sage: a = E.Lseries_sympow(2,16); a
'2.492262044273650E+00'
sage: RR(a)
2.4922620442736498

Lseries_sympow_derivs( self, n, prec, d)

Return 0 th to $ d$ th derivatives of $ L(\Sym ^{(n)}(E,$   edge$ ))$ to prec digits of precision.

INPUT:
    n -- integer
    prec -- integer
    d -- integer
    
OUTPUT:
    a string, exactly as output by sympow

Note: To use this function you may have to run a few commands like sympow('-new_data 1d2'), each which takes a few minutes. If this function fails it will indicate what commands have to be run.

sage: E = EllipticCurve('37a')
sage: E.Lseries_sympow_derivs(1,16,2)
...
1n0: 3.837774351482055E-01
1w0: 3.777214305638848E-01
1n1: 3.059997738340522E-01
1w1: 3.059997738340524E-01
1n2: 1.519054910249753E-01
1w2: 1.545605024269432E-01

Lseries_twist_values( self, s, dmin, dmax)

Return values of $ L(E, s, \chi_d)$ for each quadratic character $ \chi_d$ for $ d_{\min} \leq d \leq d_{\max}$ .

Note: The L-series is normalized so that the center of the critical strip is 1.

INPUT:
    s -- complex numbers
    dmin -- integer
    dmax -- integer

OUTPUT:
    list -- list of pairs (d, L(E, s,chi_d))

sage: E = EllipticCurve('37a')
sage: E.Lseries_twist_values(1, -12, -4)
[(-11, 1.4782434171), (-8, 0), (-7, 1.8530761916), (-4, 2.4513893817)]
sage: F = E.quadratic_twist(-8)
sage: F.rank()
1
sage: F = E.quadratic_twist(-7)
sage: F.rank()
0

Lseries_twist_zeros( self, n, dmin, dmax)

Return first $ n$ real parts of nontrivial zeros of $ L(E, s, \chi_d)$ for each quadratic character $ \chi_d$ with $ d_{\min} \leq d \leq d_{\max}$ .

Note: The L-series is normalized so that the center of the critical strip is 1.

INPUT:
    n -- integer
    dmin -- integer
    dmax -- integer

OUTPUT:
    dict -- keys are the discriminants $d$, and
            values are list of corresponding zeros.

sage: E = EllipticCurve('37a')
sage: E.Lseries_twist_zeros(3, -4, -3)         # long
{-4: [1.6081378292, 2.9614484031, 3.8975174744], -3: [2.0617089970,
3.4821688067, 4.4585321881]}

Lseries_values_along_line( self, s0, s1, number_samples)

Return values of $ L(E,s)$ at number_samples equally-spaced sample points along the line from $ s_0$ to $ s_1$ in the complex plane.

oteThe L-series is normalized so that the center of the critical strip is 1.

INPUT:
    s0, s1 -- complex numbers
    number_samples -- integer
    
OUTPUT:
    list -- list of pairs (s, zeta(s)), where the s are
            equally spaced sampled points on the line from
            s0 to s1.

sage: I = CC.0
sage: E = EllipticCurve('37a')
sage: E.Lseries_values_along_line(1, 0.5+20*I, 5)     # long
[(0.50000000000, 0), (0.40000000002 + 4.0000000000*I, 3.3192024464 -
2.6002805391*I), (0.30000000005 + 8.0000000000*I, -0.88634118531 -
0.42264033738*I), (0.20000000001 + 12.000000000*I, -3.5055893594 -
0.10853169035*I), (0.10000000001 + 16.000000000*I, -3.8704328826 -
1.8804941061*I)]

Lseries_zeros( self, n)

Return the imaginary parts of the first $ n$ nontrivial zeros on the critical line of the L-function in the upper half plane, as 32-bit reals.

sage: E = EllipticCurve('37a')
sage: E.Lseries_zeros(2)                  
[0.00000000000, 5.0031700134]

Author: Uses Rubinstein's L-functions calculator.

Lseries_zeros_in_interval( self, x, y, stepsize)

Return the imaginary parts of (most of) the nontrivial zeros on the critical line $ \Re(s)=1$ with positive imaginary part between $ x$ and $ y$ , along with a technical quantity for each.

INPUT:
    x, y, stepsize -- positive floating point numbers

OUTPUT:
    list of pairs (zero, S(T)).

Rubinstein writes: The first column outputs the imaginary part of the zero, the second column a quantity related to S(T) (it increases roughly by 2 whenever a sign change, i.e. pair of zeros, is missed). Higher up the critical strip you should use a smaller stepsize so as not to miss zeros.

sage: E = EllipticCurve('37a')
sage: E.Lseries_zeros_in_interval(6, 10, 0.1)      # long
[(6.8703912161, 0.24892278010), (8.0143308081, -0.14016853319),
(9.9330983534, -0.12994302920)]

minimal_model( self)

Return the unique minimal Weierstrass equation for this elliptic curve. This is the model with minimal discriminant and $ a_1,a_2,a_3 \in \{0,\pm 1\}$ .

modular_degree( 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:
   algorithm -- string:
      'sympow' -- (default) use Mark Watkin's (newer) C program sympow
      'ec' -- use Mark Watkins's C program ec
      'magma' -- requires that MAGMA be installed (also implemented
                 by Mark Watkins)

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 $ L$ -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 $ a_n$ 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 four having smallest (known) conductor:

sage: E = EllipticCurve([1, -1, 0, -79, 289])
sage: factor(E.conductor())
2 * 117223
sage: factor(E.modular_degree())
2^7 * 2617

modular_form( self)

Return the cuspidal modular form associated to this elliptic curve.

NOTE: If you just want the $ q$ -expansion, use self.q_expansion(prec).

modular_parametrization( self)

Computes and returns ...

mwrank( self, [options=])

Run Cremona's mwrank program on this elliptic curve and return the result as a string.

INPUT:
    options -- string; passed when starting mwrank.  The format is
q p<precision> v<verbosity> b<hlim_q> x<naux>  c<hlim_c> l t o s d>]

OUTPUT:
    string -- output of mwrank on this curve

newform( self)

Same as self.modular_form().

non_surjective( self, [A=1000])

Returns a list of primes p such that the mod-p representation $ \rho_{E,p}$ *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:
    A -- an integer
OUTPUT:
    list -- if curve has CM, returns [(0,"cm")].  Otherwise, returns a
            list of primes where mod-p representation very likely
            not surjective.   At any prime not in this list,
            the representation is definitely surjective.

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."

Np( 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

omega( self)

Returns the real period. This is the correct period in the BSD conjecture, i.e., it is the least real period * 2 when the period lattice is rectangular.

sage: E = EllipticCurve('37a')
sage: E.omega()
5.986917292463919259664019974            # 32-bit
5.986917292463919259664019958905016356   # 64-bit

p_isogenous_curves( self, [p=None])

Return a list of pairs $ (p, L)$ where $ p$ is a prime and $ L$ is a list of the elliptic curves over $ \mathbf{Q}$ that are $ p$ -isogenous to this elliptic curve.

INPUT:
    p -- prime or None (default: None); if a prime, returns
         a list of the p-isogenous curves.  Otherwise, returns
         a list of all prime-degree isogenous curves sorted
         by isogeny degree.

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 $ 5$ -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 $ 5$ -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]

padic_E2( self, p, [prec=20])

Return the value of the $ p$ -adic

padic_height( self, p, P, [prec=20])

Return the cyclotomic $ p$ -adic height of $ P$ , in the sense of Mazur and Tate.

oteThis function requires that Magma to be installed on your computer.

INPUT:
    p -- prime
    P -- point
    prec -- integer (default: 20) affects the precision; the
            precision is *not* guaranteed to be this high!
OUTPUT:
    p-adic number

padic_regulator( self, p, [prec=20])

Return the cyclotomic $ p$ -adic regulator of $ P$ , in the sense of Mazur and Tate.

oteThis function requires that Magma to be installed on your computer.

INPUT:
    p -- prime
    prec -- integer (default: 20) affects the precision; the
            precision is *not* guaranteed to be this high!
OUTPUT:
    p-adic number

pari_curve( self)

Return the PARI curve corresponding to this elliptic curve.

sage: E = EllipticCurve([0, 0,1,-1,0])
sage: e = E.pari_curve()
sage: type(e)
<type '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]

pari_mincurve( self)

Return the PARI curve corresponding to a minimal model for this elliptic curve.

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]

period_lattice( self)

Return a basis for the period lattice of the elliptic curve over $ \mathbf{Q}$ as a 2-tuple.

The basis has the form $ [\omega_1, \omega_2]$ , where $ \Im(\omega_1/\omega_2) > 0$ and $ \omega_1$ is real.

TODO: The precision is determined by the state of the PARI C library, which is not good.

INPUT:
    -- an elliptic curve
OUTPUT:
    omega_1 -- complex number
    omega_2 -- complex number

sage: E = EllipticCurve('37a')
sage: E.period_lattice ()
(2.993458646231959629832009987, 2.4513893819899999*I)     # 32-bit
(2.993458646231959629832009979452508178, 2.4513893819899999*I)   # 64-bit

point_search( self, height_limit, [verbose=True])

Search for points on a curve up to an input bound on the naive logarithmic height.

INPUT:
    height_limit (float) -- bound on naive height (at most 21, or mwrank
overflows)
    verbose  (bool) -- (default: True)

OUTPUT:
    points (list) -- list of points found

IMPLEMENTATION: Uses Cremona's mwrank package.

q_eigenform( self, prec)

Synonym for self.q_expansion(prec).

q_expansion( self, prec)

Return the q-expansion to precision prec of the newform attached to this elliptic curve.

INPUT:
    prec -- an integer

quadratic_twist( self, D)

Return the global minimal model of the quadratic twist of this curve by D.

rank( self, [use_database=mwrank_shell], [verbose=True], [only_use_mwrank=False], [algorithm=False])

Return the rank of this elliptic curve, assuming no conjectures.

If we fail to provably compute the rank, raises a RuntimeError exception.

INPUT:
    use_database (bool) -- (default: False), if True, try to
          look up the regulator in the Cremona database.
    verbose -- (default: None), if specified changes the
               verbosity of mwrank computations.
    algorithm -- 'mwrank_shell' -- call mwrank shell command
              -- 'mwrank_lib' -- call mwrank c library
    only_use_mwrank -- (default: True) if False try using
               analytic rank methods first.
    
OUTPUT:
    rank (int) -- the rank of the elliptic curve.

IMPLEMENTATION: Uses L-functions and mwrank.

real_components( 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

reducible_primes( self)

Returns a list of the primes $ p$ such that the mod $ p$ representation $ \rho_{E,p}$ 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]

regulator( self, [use_database=None], [verbose=False])

Returns the regulator of this curve, which must be defined over Q.

INPUT:
    use_database -- bool (default: False), if True, try to
          look up the regulator in the Cremona database.
    verbose -- (default: None), if specified changes the
          verbosity of mwrank computations.

sage: E = EllipticCurve([0, 0, 1, -1, 0])
sage: E.regulator()                           # long time (1 second)
0.051111408239968799

root_number( 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.

satisfies_heegner_hypothesis( self, D)

Returns True precisely when D is a fundamental discriminant that satisfies the Heegner hypothesis for this elliptic curve.

saturation( 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:
    points (list) -- list of points on E
    verbose  (bool) -- (default: False), if True, give verbose output
    max_prime (int) -- (default: 0), saturation is performed
                       for all primes up to max_prime.  If max_prime==0,
                       perform saturation at *all* primes, i.e., compute
                       the true saturation.
    odd_primes_only (bool) -- only do saturation at odd primes

OUTPUT:
    saturation (list) -- points that form a basis for the saturation
    index (int) -- the index of the group generated by points in their
saturation
    regulator (float) -- regulator of saturated points.

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.

sea( self, p, [early_abort=False])

Return the number of points on $ E$ over $ \mathbf{F}_p$ computed using the SEA algorithm, as implemented in PARI by Christophe Doche and Sylvain Duquesne.

INPUT:
    p -- a prime number
    early_abort -- bool (default: Falst); if True an early abort technique
               is used and the computation is interrupted as soon
               as a small divisor of the order is detected.

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

selmer_rank_bound( 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

sha_an( self, [use_database=False])

Returns the Birch and Swinnerton-Dyer conjectural order of Sha, unless the analytic rank is > 1, in which case this function returns 0.

This result is proved correct if the order of vanishing is 0 and the Manin constant is <= 2.

If the optional parameter use_database is True (default: False), this function returns the analytic order of Sha as listed in Cremona's tables, if this curve appears in Cremona's tables.

sage: E = EllipticCurve([0, -1, 1, -10, -20])   # 11A  = X_0(11)
sage: E.sha_an()
1
sage: E = EllipticCurve([0, -1, 1, 0, 0])       # X_1(11)
sage: E.sha_an()
1

The smallest conductor curve with nontrivial Sha:

sage: E = EllipticCurve([1,1,1,-352,-2689])     # 66B3
sage: E.sha_an()
4

The four optimal quotients with nontrivial Sha and conductor <= 1000:

sage: E = EllipticCurve([0, -1, 1, -929, -10595])       # 571A
sage: E.sha_an()
4
sage: E = EllipticCurve([1, 1, 0, -1154, -15345])       # 681B
sage: E.sha_an()
9
sage: E = EllipticCurve([0, -1, 0, -900, -10098])       # 960D
sage: E.sha_an()
4
sage: E = EllipticCurve([0, 1, 0, -20, -42])            # 960N
sage: E.sha_an()
4

The smallest conductor curve of rank > 1:

sage: E = EllipticCurve([0, 1, 1, -2, 0])       # 389A (rank 2)
sage: E.sha_an()
0

The following are examples that require computation of the Mordell-Weil group and regulator:

sage: E = EllipticCurve([0, 0, 1, -1, 0])                     # 37A  (rank 1)
sage: E.sha_an()
1

sage: E = EllipticCurve("1610f3")
sage: E.sha_an()
4

shabound( self)

Compute a provably correct bound on the order of the Shafarevich-Tate group of this curve. The bound is a either False (no bound) or a list B of primes such that any divisor of Sha is in this list.

shabound_kato( self)

Returns a list p of primes such tha theorems of Kato's and others (e.g., as explained in a paper/thesis of Grigor Grigorov) imply that if p divides $ \char93 Sha(E)$ then $ p$ is in the list.

If L(E,1) = 0, then Kato's theorem gives no information, so this function returns False.

THEOREM (Kato): Suppose p >= 5 is a prime so the p-adic representation rho_E,p is surjective. Then $ ord_p(\char93 Sha(E))$ divides $ ord_p(L(E,1)/Omega_E)$ .

sage: E = EllipticCurve([0, -1, 1, -10, -20])   # 11A  = X_0(11)
sage: E.shabound_kato()
[2, 3, 5]
sage: E = EllipticCurve([0, -1, 1, 0, 0])       # X_1(11)
sage: E.shabound_kato()
[2, 3, 5]
sage: E = EllipticCurve([1,1,1,-352,-2689])     # 66B3
sage: E.shabound_kato()
[2, 3]

For the following curve one really has 25 | $ \char93 Sha$ (by Grigorov-Stein paper):

sage: E = EllipticCurve([1, -1, 0, -332311, -73733731])   # 1058D1
sage: E.shabound_kato()                 # long time (about 1 second)
[2, 3, 5]
sage: E.non_surjective()                # long time (about 1 second)
[]

For this one, Sha is divisible by 7.

sage: E = EllipticCurve([0, 0, 0, -4062871, -3152083138])   # 3364C1
sage: E.shabound_kato()                 # long time (< 10 seconds)
[2, 3, 7]

No information about curves of rank > 0:

sage: E = EllipticCurve([0, 0, 1, -1, 0])       # 37A  (rank 1)
sage: E.shabound_kato()
False

shabound_kolyvagin( self, [D=False], [regulator=None], [ignore_nonsurj_hypothesis=0])

Given a fundamental discriminant D (=-3,-4) that satisfies the Heegner hypothesis, return a list of primes so that Kolyvagin's theorem (as in Gross's paper) implies that any prime divisor of $ \char93 Sha$ is in this list.

INPUT:
    D -- (optional) a fundamental discriminant < -4 that satisfies the
         Heegner hypothesis for E; if not given, use the first such D
         
    regulator -- (optional) regulator of E(K); if not given, will
                 be computed (which could take a long time)

                 
    ignore_nonsurj_hypothesis (optional: default False) --
              If True, then gives the bound coming from Heegner point
              index, but without any hypothesis on surjectivity
              of the mod-p representation.
              

OUTPUT:
    bound and index

More precisely:

0 - if E/K has complex multiplication or analytic rank >= 2 or B - list of primes such that if p divides Sha(E/K), then p is in B.

and

I - the odd part of the index of the Heegner point in the full group of K-rational points on E. (If E has CM, returns 0.)

REMARKS: (1) We do not have to assume that the Manin constant is 1 (or a power of 2). If the Manin constant were divisible by a prime, that prime would get included in the list of bad primes.

(2) We assume the Gross-Zagier theorem is True under the hypothesis that gcd(N,D) = 1, instead of the stronger hypothesis gcd(2*N,D)=1 that is in the original Gross-Zagier paper. That Gross-Zagier is true when gcd(N,D)=1 is"well-known" to the experts, but doesn't seem to written up well in the literature.

(3) Correctness of the computation is guaranteed using interval arithmetic, under the assumption that the regulator, square root, and period lattice are computed to precision at least $ 10^{-10}$ , i.e., they are correct up to addition or a real number with absolute value less than $ 10^{-10}$ .

sigma( self, z, [flag=0])

Returns the value of the Weierstrass sigma function of the lattice associated to this elliptic curve E.

INPUT:
    z -- a complex number
    flag -- 0 - default ???
            1 - computes an arbitrary determination of log(sigma(z))
            2, 3 - same using the product expansion instead of theta
series.
                   ???
OUTPUT:
    a complex number

NOTE: The reason for the ???'s above, is that the PARI documentation for ellsigma is very vague.

silverman_height_bound( self)

Return the Silverman 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.

Note that the CPS_height_bound is typically much better than the Silverman bound.

simon_two_descent( self, [verbose=30], [lim1=20], [lim3=10], [limtriv=50], [maxprob=5], [limbigprime=0])

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 Weierstrass model of self.

Note: The points are not translated back to self only because I haven't written code to do this yet.

INPUT:
    verbose -- integer, 0,1,2,3; (default: 0), the verbosity level
    lim1    -- (default: 5) limite des points triviaux sur les quartiques
    lim3    -- (default: 50) limite des points sur les quartiques ELS
    limtriv -- (default: 10) limite des points triviaux sur la
                             courbe elliptique
    maxprob -- (default: 20)
    limbigprime -- (default: 30)  pour distinguer un petit 1nombre premier
                             d'un grand utilise un test probabiliste pour
                             les grands si LIMBIGPRIME = 0, n'utilise
                             aucun test probabiliste
                    
OUTPUT:
    integer -- "probably" the rank of self
    integer -- the 2-rank of the Selmer group
    list    -- list of independent points on the Weierstrass model

IMPLEMENTATION: Uses Denis Simon's GP/PARI scripts from http://www.math.unicaen.fr/~simon/

We compute the ranks of the curves of lowest known conductor up to rank $ 8$ . Amazingly, each of these computations finishes almost instantly!

sage: E = EllipticCurve('11a1')
sage: E.simon_two_descent()
(0, 0, [])
sage: E = EllipticCurve('37a1')
sage: E.simon_two_descent()
(1, 1, [(0 : 108 : 1)])
sage: E = EllipticCurve('389a1')
sage: E.simon_two_descent()
(2, 2, [(57/4 : 621/8 : 1), (57 : 243 : 1)])
sage: E = EllipticCurve('5077a1')
sage: E.simon_two_descent()
(3, 3, [(9 : 459 : 1), (153/4 : 189/8 : 1), (100 : 620 : 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: 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: E.simon_two_descent()
(4, 4, [(8415/49 : 10800/343 : 1), (-9 : 3672 : 1), (207 : 432 : 1), (-369
: 432 : 1)])
sage: E = EllipticCurve([0, 0, 1, -79, 342])
sage: E.simon_two_descent()        # random output
(5, 5, [(0 : 3996 : 1), (-380 : 44 : 1), (52 : 3284 : 1), (110628/289 :
28166508/4913 : 1), (23364/25 : 3392388/125 : 1)]) 
sage: E = EllipticCurve([1, 1, 0, -2582, 48720])
sage: r, s, G = E.simon_two_descent(); r,s
(6, 6)
sage: E = EllipticCurve([0, 0, 0, -10012, 346900])
sage: r, s, G = E.simon_two_descent(); r,s
(7, 7)
sage: E = EllipticCurve([0, 0, 1, -23737, 960366])    
sage: r, s, G = E.simon_two_descent(); r,s            # long time (1 second)
(8, 8)

tamagawa_number( self, p)

The Tamagawa number of the elliptic curve at $ p$ .

sage: E = EllipticCurve('11a')
sage: E.tamagawa_number(11)
5
sage: E = EllipticCurve('37b')
sage: E.tamagawa_number(37)
3

tamagawa_product( self)

Returns the product of the Tamagawa numbers.

sage: E = EllipticCurve('54a')
sage: E.tamagawa_product ()
3

three_selmer_rank( self, [bound=2], [method=0])

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.

torsion_order( self)

Return the order of the torsion subgroup.

torsion_subgroup( self, [flag=0])

Returns the torsion subgroup of this elliptic curve.

The flag is passed onto PARI and has the same algorithm meaning as there. So: If flag = 0, use Doud's algorithm; if flag = 1, use Lutz-Nagell.

sage: EllipticCurve('11a').torsion_subgroup()
Multiplicative Abelian Group isomorphic to C5
sage: EllipticCurve('37b').torsion_subgroup()
Multiplicative Abelian Group isomorphic to C3

two_descent( self, [verbose=1], [selmer_only=-1], [first_limit=8], [second_limit=20], [n_aux=False], [second_descent=True])

Compute 2-descent data for this curve.

INPUT:
    verbose     -- (default: True) print what mwrank is doing
    selmer_only -- (default: False) selmer_only switch
    first_limit -- (default: 20) firstlim is bound on |x|+|z|
    second_limit-- (default: 8)  secondlim is bound on log max {|x|,|z| },
                                 i.e. logarithmic
    n_aux       -- (default: -1) n_aux only relevant for general
                   2-descent when 2-torsion trivial; n_aux=-1 causes
default
                   to be used (depends on method)
    second_descent -- (default: True) second_descent only relevant for
                   descent via 2-isogeny
OUTPUT:
    Nothing -- nothing is returned (though much is printed)

two_descent_simon( self, [verbose=30], [lim1=20], [lim3=10], [limtriv=50], [maxprob=5], [limbigprime=0])

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 Weierstrass model of self.

Note: The points are not translated back to self only because I haven't written code to do this yet.

INPUT:
    verbose -- integer, 0,1,2,3; (default: 0), the verbosity level
    lim1    -- (default: 5) limite des points triviaux sur les quartiques
    lim3    -- (default: 50) limite des points sur les quartiques ELS
    limtriv -- (default: 10) limite des points triviaux sur la
                             courbe elliptique
    maxprob -- (default: 20)
    limbigprime -- (default: 30)  pour distinguer un petit 1nombre premier
                             d'un grand utilise un test probabiliste pour
                             les grands si LIMBIGPRIME = 0, n'utilise
                             aucun test probabiliste
                    
OUTPUT:
    integer -- "probably" the rank of self
    integer -- the 2-rank of the Selmer group
    list    -- list of independent points on the Weierstrass model

IMPLEMENTATION: Uses Denis Simon's GP/PARI scripts from http://www.math.unicaen.fr/~simon/

We compute the ranks of the curves of lowest known conductor up to rank $ 8$ . Amazingly, each of these computations finishes almost instantly!

sage: E = EllipticCurve('11a1')
sage: E.simon_two_descent()
(0, 0, [])
sage: E = EllipticCurve('37a1')
sage: E.simon_two_descent()
(1, 1, [(0 : 108 : 1)])
sage: E = EllipticCurve('389a1')
sage: E.simon_two_descent()
(2, 2, [(57/4 : 621/8 : 1), (57 : 243 : 1)])
sage: E = EllipticCurve('5077a1')
sage: E.simon_two_descent()
(3, 3, [(9 : 459 : 1), (153/4 : 189/8 : 1), (100 : 620 : 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: 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: E.simon_two_descent()
(4, 4, [(8415/49 : 10800/343 : 1), (-9 : 3672 : 1), (207 : 432 : 1), (-369
: 432 : 1)])
sage: E = EllipticCurve([0, 0, 1, -79, 342])
sage: E.simon_two_descent()        # random output
(5, 5, [(0 : 3996 : 1), (-380 : 44 : 1), (52 : 3284 : 1), (110628/289 :
28166508/4913 : 1), (23364/25 : 3392388/125 : 1)]) 
sage: E = EllipticCurve([1, 1, 0, -2582, 48720])
sage: r, s, G = E.simon_two_descent(); r,s
(6, 6)
sage: E = EllipticCurve([0, 0, 0, -10012, 346900])
sage: r, s, G = E.simon_two_descent(); r,s
(7, 7)
sage: E = EllipticCurve([0, 0, 1, -23737, 960366])    
sage: r, s, G = E.simon_two_descent(); r,s            # long time (1 second)
(8, 8)

two_selmer_shabound( self)

Returns a bound on the dimension of Sha(E)[2], computed using a 2-descent.

two_torsion_rank( self)

Return the dimension of the 2-torsion subgroup of $ E(\mathbf{Q})$ .

watkins_data( self)

Return a dict of the data computed by Mark Watkins's ec program applied to this elliptic curve.

Special Functions: _EllipticCurve_rational_field__check_padic_hypotheses,$  $ _EllipticCurve_rational_field__pari_double_prec,$  $ _set_conductor,$  $ _set_cremona_label,$  $ _set_gens,$  $ _set_modular_degree,$  $ _set_rank,$  $ _set_torsion_order

See About this document... for information on suggesting changes.