15.3 Cremona's mwrank C++ library

Module: sage.libs.mwrank.all

Cremona's mwrank C++ library

Module-level Functions

mwrank_initprimes( filename, [verb=False])

mwrank_initprimes(filename, verb=False):

Input:

filename
- (string) the name of a file of primes
verb
- (bool: default False) verbose or not?

sage: file= SAGE_TMP + '/PRIMES'
sage: open(file,'w').write(' '.join([str(p) for p in prime_range(10^6)]))
sage: mwrank_initprimes(file, verb=False)

set_precision( n)

Set the global NTL real number precision. This has a massive effect on the speed of mwrank calculations. The default is n=15, but it might have to be increased if a computation fails. In this case, one must recreate the mwrank curve from scratch after resetting this precision.

NOTE - this change is global and affects all of SAGE.

Input:

n
- long

sage: mwrank_set_precision(20)

Class: mwrank_EllipticCurve

class mwrank_EllipticCurve
The mwrank_EllipticCurve class represents an MWRANK elliptic curve.
mwrank_EllipticCurve( self, ainvs, [verbose=False])

Create the mwrank elliptic curve with invariants a_invs, which is a list of $ \leq 5$ integers $ a_1$ , $ a_2$ , $ a_3$ , $ a_4$ , and $ a_6$ .

If strictly less than 5 invariants are given, then the first ones are set to 0, so, e.g., [3,4] means $ a_1=a_2=a_3=0$ and $ a_4=3$ , $ a_6=4$ .

Input:

ainvs
- a list of <= 5 integers
verbose
- if True, then all Selmer group computations will be verbose. (default: False).

We create the elliptic curve $ y^2 + y = x^3 + x^2 - 2x$ .

sage: e = mwrank_EllipticCurve([0, 1, 1, -2, 0])
sage: e.ainvs()
[0, 1, 1, -2, 0]

This example illustrates that omitted $ a$ -invariants default to 0 :

sage: e = mwrank_EllipticCurve([3, -4])
sage: e
y^2 = x^3 + 3*x - 4
sage: e.ainvs()
[0, 0, 0, 3, -4]

The entries of the input list are coerced to int. This has the effect that for float input, the integer parts of the input coefficients are taken.

sage: e = mwrank_EllipticCurve([3, float(-4.8)]); e
y^2 = x^3 + 3*x - 4

When you enter a singular model you get an exception:

sage: e = mwrank_EllipticCurve([0, 0])
Traceback (most recent call last):
...
ArithmeticError: Invariants (= [0, 0, 0, 0, 0]) do not describe an elliptic
curve.

Functions: ainvs,$ \,$ certain,$ \,$ conductor,$ \,$ CPS_height_bound,$ \,$ gens,$ \,$ isogeny_class,$ \,$ rank,$ \,$ regulator,$ \,$ saturate,$ \,$ selmer_rank_bound,$ \,$ set_verbose,$ \,$ silverman_bound,$ \,$ two_descent

certain( self)

True if the last two_descent call provably correctly computed the rank. If two_descent hasn't been called, then it is first called by certain using the default parameters.

A $ 2$ -descent does not determine $ E(\mathbf{Q})$ with certainty for the curve $ y^2 + y = x^3 - x^2 - 120x - 2183$ .

sage: E = mwrank_EllipticCurve([0, -1, 1, -120, -2183])
sage: E.two_descent(False)
...
sage: E.certain()
False
sage: E.rank()   
0

The rank of $ E$ is actually 0 (as one could see by computing the L-function), but $ {\mbox{{\fontencoding{OT2}\fontfamily{wncyr}\fontseries{m}\fontshape{n}\selectfont Sh}}}$ has order 4 and the $ 2$ -torsion is trivial, so mwrank does not conclusively determine the rank.

sage: E.selmer_rank_bound()
2

conductor( self)

Return the conductor of this curve, computed using Cremona's implementation of Tate's algorithm.

NOTE: This is independent of PARI's.

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

Note: We assume the model is minimal!

gens( self)

Return a list of the generators for the Mordell-Weil group.

rank( self)

Returns the rank of this curve, computed using 2-descent.

regulator( self)

Return the regulator of the saturated Mordell-Weil group.

sage: E = mwrank_EllipticCurve([0, 0, 1, -1, 0])
sage: E.regulator()
0.05111140823996884

saturate( self, [bound=-1])

Compute the saturation of the Mordell-Weil group at all primes up to bound.

Input:

bound
- int (default: -1) -1 saturate at *all* primes,
0
- do not saturate
n
- saturate at least at all primes <= n.

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 $ {\mbox{{\fontencoding{OT2}\fontfamily{wncyr}\fontseries{m}\fontshape{n}\selectfont Sh}}}(E)[2]$ (e.g., using a second descent or if there is a rational $ 2$ -torsion point, then there may be an isogeny to a curve with trivial $ {\mbox{{\fontencoding{OT2}\fontfamily{wncyr}\fontseries{m}\fontshape{n}\selectfont Sh}}}(E)$ ). In many cases, this is the actual rank of the curve, but in general it is just $ \geq$ the true rank.

The following is the curve 960D1, which has rank 0, but Sha of order 4.

sage: E = mwrank_EllipticCurve([0, -1, 0, -900, -10098])
sage: E.selmer_rank_bound()
0

In this case this was resolved using a second descent.

sage: E = mwrank_EllipticCurve([0, -1, 0, -900, -10098])
sage: E.two_descent(second_descent = False, verbose=False)
sage: E.selmer_rank_bound()
2

Above, the selmer_rank_bound gives 0 instead of 2, because it knows Sha is nontrivial. In contrast, for the curve 571A, also with rank 0 and $ {\mbox{{\fontencoding{OT2}\fontfamily{wncyr}\fontseries{m}\fontshape{n}\selectfont Sh}}}$ of order 4, we obtain a worse bound:

sage: E = mwrank_EllipticCurve([0, -1, 1, -929, -10595])
sage: E.selmer_rank_bound()
2
sage: E.rank()
0

set_verbose( self, verbose)

Set the verbosity of printing of output by the 2-descent and other functions. Input:

verbosity
- bool; if True print lots of output

silverman_bound( self)

Return the Silverman height bound. This is a 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: We assume the model is minimal!

two_descent( self, [verbose=True], [selmer_only=False], [first_limit=20], [second_limit=8], [n_aux=-1], [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: 5) 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

Special Functions: __init__,$ \,$ __reduce__,$ \,$ __repr__,$ \,$ _curve_data,$ \,$ _mwrank_EllipticCurve__two_descent_data

Class: mwrank_MordellWeil

class mwrank_MordellWeil
The mwrank_MordellWeil class represents a subgroup of a Mordell-Weil group. Use this class to saturate a specified list of points on an mwrank_EllipticCurve, or to search for points up to some bound.
mwrank_MordellWeil( self, curve, [verbose=True], [pp=1], [maxr=999])

Create a mwrank_MordellWeil instance.

Input:

curve
- mwrank_EllipticCurve instance
verbose
- bool
pp
- int
maxr
- int

Functions: points,$ \,$ process,$ \,$ rank,$ \,$ regulator,$ \,$ saturate,$ \,$ search

points( self)

Return a list of the generating points in this Mordell-Weil group.

process( self, v, [sat=0])

This function allows one to add points to a mwrank_MordellWeil object.

Process points in the list v, with saturation at primes up to sat. If sat = 0 (the default), then saturate at all primes.

Input:

v - a point (3-tuple of ints), or a list of 3-tuples of integers, which define points on the curve.

sat - int, saturate at primes up to sat, or at all primes if sat=0.

rank( self)

Return the rank of this subgroup of the Mordell-Weil group.

regulator( self)

Return the regulator of the points in this subgroup of the Mordell-Weil group.

saturate( self, [max_prime=-1], [odd_primes_only=False])

Saturate this subgroup of the Mordell-Weil group.

Input:

max_prime (int)
- (default: 97), saturation is performed for all primes up to max_prime

odd_primes_only (bool)
- only do saturation at odd primes

Output:
ok (bool)
- True if and only if the saturation is provably correct at all primes.
index (int)
- The index of the group generated by points in their saturation
saturation (list)
- list of points that form a basis for the saturation

Note: We emphasize that if this function returns True as the first return argument, then the points it found are saturated at all primes, i.e., saturating at the primes up to max_prime are sufficient to saturate at all primes. Note that the function might not have needed to saturate at all primes up to max_prime. It has worked out what prime you need to saturate up to, and that prime is $ \leq$ max_prime.

Note: Currently (July 2005), this does not remember the result of calling search. So calling search up to height 20 then calling saturate results in another search up to height 18.

search( self, [height_limit=18], [verbose=False])

Search for new points, and add them to this subgroup of the Mordell-Weil group.

Input:

height_limit
- float (default: 18) search up to this logarithmetic height. On 32-bit machines, h_lim MUST be < 21.48 else $ \exp(h_lim)>2^31$ and overflows.

Special Functions: __init__,$ \,$ __reduce__,$ \,$ __repr__

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