Coverage for local/lib/python2.7/site-packages/sage/schemes/elliptic

(2527/17280*x^2 + 133/2160*x*y + 133/108000*y^2 + 133/2880*x*z + 931/18000*y*z - 3857/48000*z^2 : -6859/288*x^2 + 323/36*x*y + 359/1800*y^2 + 551/48*x*z + 2813/300*y*z + 24389/800*z^2 : -2352637/99532800000*x^2 - 2352637/124416000000*x*y - 2352637/622080000000*y^2 + 2352637/82944000000*x*z + 2352637/207360000000*y*z - 2352637/276480000000*z^2)

Note that the morphism returned cannot be evaluated directly at

the given point ``P=(1:-1:1)`` since the polynomials defining it

all vanish there::

sage: f([1,-1,1])

Traceback (most recent call last):

...

ValueError: [0, 0, 0] does not define a valid point since all entries are 0

Using the group law on the codomain elliptic curve, which has rank

1 and full 2-torsion, and the inverse morphism, we can find many

points on the cubic. First we find the preimages of multiples of

the generator::

sage: E = f.codomain()

sage: E.label()

'720e2'

sage: E.rank()

sage: R = E.gens()[0]; R

(-17280000/2527 : 9331200000/6859 : 1)

sage: finv = f.inverse()

sage: [finv(k*R) for k in range(1,10)]

[(-4 : 1 : 0),

(-1 : 4 : 1),

(-20 : -55/76 : 1),

(319/399 : -11339/7539 : 1),

(159919/14360 : -4078139/1327840 : 1),

(-27809119/63578639 : 1856146436/3425378659 : 1),

(-510646582340/56909753439 : 424000923715/30153806197284 : 1),

(-56686114363679/4050436059492161 : -2433034816977728281/1072927821085503881 : 1),

(650589589099815846721/72056273157352822480 : -347376189546061993109881/194127383495944026752320 : 1)]

The elliptic curve also has torsion, which we can map back::

sage: E.torsion_points()

[(-144000000/17689 : 3533760000000/2352637 : 1),

(-92160000/17689 : 2162073600000/2352637 : 1),

(-5760000/17689 : -124070400000/2352637 : 1),

(0 : 1 : 0)]

sage: [finv(Q) for Q in E.torsion_points() if Q]

[(9 : -9/4 : 1), (-9 : 0 : 1), (0 : 1 : 0)]

In this example, the given point ``P`` is not a flex but the cubic

does have a rational flex, ``(-4:0:1)``. We return a linear

isomorphism which maps this flex to the point at infinity on the

Weierstrass model::

sage: R.<a,b,c> = QQ[]

sage: cubic = a^3+7*b^3+64*c^3

sage: P = [2,2,-1]

sage: f = EllipticCurve_from_cubic(cubic, P, morphism=True)

sage: E = f.codomain(); E

Elliptic Curve defined by y^2 - 258048*y = x^3 - 22196256768 over Rational Field

sage: E.minimal_model()

Elliptic Curve defined by y^2 + y = x^3 - 331 over Rational Field

sage: f

Scheme morphism:

From: Projective Plane Curve over Rational Field defined by a^3 + 7*b^3 + 64*c^3

To: Elliptic Curve defined by y^2 - 258048*y = x^3 - 22196256768 over Rational Field

Defn: Defined on coordinates by sending (a : b : c) to

(b : -48*a : -1/5376*a - 1/1344*c)

sage: finv = f.inverse(); finv

Scheme morphism:

From: Elliptic Curve defined by y^2 - 258048*y = x^3 - 22196256768 over Rational Field

To: Projective Plane Curve over Rational Field defined by a^3 + 7*b^3 + 64*c^3

Defn: Defined on coordinates by sending (x : y : z) to

(-1/48*y : x : 1/192*y - 1344*z)

sage: cubic(finv.defining_polynomials()) * finv.post_rescaling()

-x^3 + y^2*z - 258048*y*z^2 + 22196256768*z^3

sage: E.defining_polynomial()(f.defining_polynomials()) * f.post_rescaling()

a^3 + 7*b^3 + 64*c^3

sage: f(P)

(5376 : -258048 : 1)

sage: f([-4,0,1])

(0 : 1 : 0)

It is possible to not provide a base point ``P`` provided that the

cubic has a rational flex. In this case the flexes will be found

and one will be used as a base point::

sage: R.<x,y,z> = QQ[]

sage: cubic = x^3+y^3+z^3

sage: f = EllipticCurve_from_cubic(cubic, morphism=True)

sage: f

Scheme morphism:

From: Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3

To: Elliptic Curve defined by y^2 - 9*y = x^3 - 27 over Rational Field

Defn: Defined on coordinates by sending (x : y : z) to

(y : -3*x : -1/3*x - 1/3*z)

An error will be raised if no point is given and there are no rational flexes::

sage: R.<x,y,z> = QQ[]

sage: cubic = 3*x^3+4*y^3+5*z^3

sage: EllipticCurve_from_cubic(cubic)

Traceback (most recent call last):

...

ValueError: A point must be given when the cubic has no rational flexes

An example over a finite field, using a flex::

sage: K = GF(17)

sage: R.<x,y,z> = K[]

sage: cubic = 2*x^3+3*y^3+4*z^3

sage: EllipticCurve_from_cubic(cubic,[0,3,1])

Scheme morphism:

From: Projective Plane Curve over Finite Field of size 17 defined by 2*x^3 + 3*y^3 + 4*z^3

To: Elliptic Curve defined by y^2 + 16*y = x^3 + 11 over Finite Field of size 17

Defn: Defined on coordinates by sending (x : y : z) to

(-x : 4*y : 4*y + 5*z)

An example in characteristic 3::

sage: K = GF(3)

sage: R.<x,y,z> = K[]

sage: cubic = x^3+y^3+z^3+x*y*z

sage: EllipticCurve_from_cubic(cubic,[0,1,-1])

Scheme morphism:

From: Projective Plane Curve over Finite Field of size 3 defined by x^3 + y^3 + x*y*z + z^3

To: Elliptic Curve defined by y^2 + x*y = x^3 + 1 over Finite Field of size 3

Defn: Defined on coordinates by sending (x : y : z) to

(y + z : -y : x)

An example over a number field, using a non-flex and where there are no rational flexes::

sage: K.<a> = QuadraticField(-3)

sage: R.<x,y,z> = K[]

sage: cubic = 2*x^3+3*y^3+5*z^3

sage: EllipticCurve_from_cubic(cubic,[1,1,-1])

Scheme morphism:

From: Projective Plane Curve over Number Field in a with defining polynomial x^2 + 3 defined by 2*x^3 + 3*y^3 + 5*z^3

To: Elliptic Curve defined by y^2 + 1754460/2053*x*y + 5226454388736000/8653002877*y = x^3 + (-652253285700/4214809)*x^2 over Number Field in a with defining polynomial x^2 + 3

Defn: Defined on coordinates by sending (x : y : z) to

(-16424/127575*x^2 - 231989/680400*x*y - 14371/64800*y^2 - 26689/81648*x*z - 10265/27216*y*z - 2053/163296*z^2 : 24496/315*x^2 + 119243/840*x*y + 4837/80*y^2 + 67259/504*x*z + 25507/168*y*z + 5135/1008*z^2 : 8653002877/2099914709760000*x^2 + 8653002877/699971569920000*x*y + 8653002877/933295426560000*y^2 + 8653002877/419982941952000*x*z + 8653002877/279988627968000*y*z + 8653002877/335986353561600*z^2)

An example over a function field, using a non-flex::

sage: K.<t> = FunctionField(QQ)

sage: R.<x,y,z> = K[]

sage: cubic = x^3+t*y^3+(1+t)*z^3

sage: EllipticCurve_from_cubic(cubic,[1,1,-1], morphism=False)

Elliptic Curve defined by y^2 + ((-236196*t^6-708588*t^5-1180980*t^4-1180980*t^3-708588*t^2-236196*t)/(-1458*t^6-17496*t^5+4374*t^4+29160*t^3+4374*t^2-17496*t-1458))*x*y + ((-459165024*t^14-5969145312*t^13-34207794288*t^12-113872925952*t^11-244304490582*t^10-354331909458*t^9-354331909458*t^8-244304490582*t^7-113872925952*t^6-34207794288*t^5-5969145312*t^4-459165024*t^3)/(-1458*t^14-58320*t^13-841266*t^12-5137992*t^11-11773350*t^10-7709904*t^9+12627738*t^8+25789104*t^7+12627738*t^6-7709904*t^5-11773350*t^4-5137992*t^3-841266*t^2-58320*t-1458))*y = x^3 + ((-118098*t^12-708588*t^11+944784*t^10+11219310*t^9+27871128*t^8+36374184*t^7+27871128*t^6+11219310*t^5+944784*t^4-708588*t^3-118098*t^2)/(-54*t^12-1296*t^11-7452*t^10+6048*t^9+25758*t^8-3888*t^7-38232*t^6-3888*t^5+25758*t^4+6048*t^3-7452*t^2-1296*t-54))*x^2 over Rational function field in t over Rational Field

TESTS:

Here is a test for :trac:`21092`::

sage: R.<x,y,z> = QQ[]

sage: cubic = -3*x^2*y + 3*x*y^2 + 4*x^2*z + 4*y^2*z - 3*x*z^2 + 3*y*z^2 - 8*z^3

sage: EllipticCurve_from_cubic(cubic, (-4/5, 4/5, 3/5) )

Scheme morphism:

From: Projective Plane Curve over Rational Field defined by -3*x^2*y + 3*x*y^2 + 4*x^2*z + 4*y^2*z - 3*x*z^2 + 3*y*z^2 - 8*z^3

To: Elliptic Curve defined by y^2 + 24*x*y + 3024*y = x^3 + 495*x^2 + 36288*x over Rational Field

Defn: Defined on coordinates by sending (x : y : z) to

(-1/3*z : 3*x : -1/1008*x + 1/1008*y + 1/378*z)

"""

from sage.schemes.curves.constructor import Curve

from sage.matrix.all import Matrix

from sage.modules.all import vector

from sage.schemes.elliptic_curves.weierstrass_transform import \

WeierstrassTransformationWithInverse

# check the input

R = F.parent()

K = R.base_ring()

if not is_MPolynomialRing(R):

raise TypeError('equation must be a polynomial')

if R.ngens() != 3 or F.nvariables() != 3:

raise TypeError('equation must be a polynomial in three variables')

if not F.is_homogeneous():

raise TypeError('equation must be a homogeneous polynomial')

C = Curve(F)

if P:

try:

CP = C(P)

except (TypeError, ValueError):

raise TypeError('{} does not define a point on a projective curve over {} defined by {}'.format(P,K,F))

x, y, z = R.gens()

# Test whether P is a flex; if not test whether there are any rational flexes:

hessian = Matrix([[F.derivative(v1, v2) for v1 in R.gens()] for v2 in R.gens()]).det()

if P and hessian(P)==0:

flex_point = P

else:

flexes = C.intersection(Curve(hessian)).rational_points()

if flexes:

flex_point = list(flexes[0])

if not P:

P = flex_point

CP = C(P)

else:

flex_point = None

if flex_point is not None: # first case: base point is a flex

P = flex_point

L = tangent_at_smooth_point(C,P)

dx, dy, dz = [L.coefficient(v) for v in R.gens()]

# find an invertible matrix M such that (0,1,0)M=P and

# ML'=(0,0,1)' where L=[dx,dy,dx]. Then the linea transform

# by M takes P to [0,1,0] and L to Z=0:

if P[0]:

Q1 = [0,-dz,dy]

Q2 = [0,1,0] if dy else [0,0,1]

elif P[1]:

Q1 = [dz,0,-dx]

Q2 = [1,0,0] if dx else [0,0,1]

else:

Q1 = [-dy,dx,0]

Q2 = [1,0,0] if dx else [0,1,0]

M = Matrix(K,[Q1,P,Q2])

# assert M.is_invertible()

# assert list(vector([0,1,0])*M) == P

# assert list(M*vector([dx,dy,dz]))[:2] == [0,0]

M = M.transpose()

F2 = R(M.act_on_polynomial(F))

# scale and dehomogenise

a = K(F2.coefficient(x**3))

b = K(F2.coefficient(y*y*z))

F3 = F2([-x, y/b, z*a*b]) / a

# assert F3.coefficient(x**3) == -1

# assert F3.coefficient(y*y*z) == 1

E = EllipticCurve(F3([x,y,1]))

if not morphism:

return E

# Construct the (linear) morphism

M = M * Matrix(K,[[-1,0,0],[0,1/b,0],[0,0,a*b]])

inv_defining_poly = [ M[i,0]*x + M[i,1]*y + M[i,2]*z for i in range(3) ]

inv_post = 1/a

M = M.inverse()

fwd_defining_poly = [ M[i,0]*x + M[i,1]*y + M[i,2]*z for i in range(3) ]

fwd_post = a

else: # Second case: no flexes

if not P:

raise ValueError('A point must be given when the cubic has no rational flexes')

L = tangent_at_smooth_point(C,P)

Qlist = [Q for Q in C.intersection(Curve(L)).rational_points() if C(Q)!=CP]

# assert Qlist

P2 = C(Qlist[0])

L2 = tangent_at_smooth_point(C,P2)

Qlist = [Q for Q in C.intersection(Curve(L2)).rational_points() if C(Q)!=P2]

# assert Qlist

P3 = C(Qlist[0])

# NB This construction of P3 relies on P2 not being a flex.

# If we want to use a non-flex as P when there are rational

# flexes this would be a problem. However, the only condition

# which P3 must satisfy is that it is on the tangent at P2, it

# need not lie on the cubic.

# send P, P2, P3 to (1:0:0), (0:1:0), (0:0:1) respectively

M = Matrix(K, [P, list(P2), list(P3)]).transpose()

F2 = M.act_on_polynomial(F)

xyzM = [ M[i,0]*x + M[i,1]*y + M[i,2]*z for i in range(3) ]

# assert F(xyzM)==F2

# substitute x = U^2, y = V*W, z = U*W, and rename (x,y,z)=(U,V,W)

T1 = [x*x,y*z,x*z]

S1 = x**2*z

F3 = F2(T1) // S1

xyzC = [ t(T1) for t in xyzM ]

# assert F3 == F(xyzC) // S1

# scale and dehomogenise

a = K(F3.coefficient(x**3))

b = K(F3.coefficient(y*y*z))

ab = a*b

T2 = [-x, y/b, ab*z]

F4 = F3(T2) / a

# assert F4.coefficient(x**3) == -1

# assert F4.coefficient(y*y*z) == 1

xyzW = [ t(T2) for t in xyzC ]

S2 = a*S1(T2)

# assert F4 == F(xyzW) // S2

E = EllipticCurve(F4([x,y,1]))

if not morphism:

return E

inv_defining_poly = xyzW

inv_post = 1/S2

# assert F4==F(inv_defining_poly)*inv_post

MI = M.inverse()

xyzI = [ (MI[i,0]*x + MI[i,1]*y + MI[i,2]*z) for i in range(3) ]

T1I = [x*z,x*y,z*z] # inverse of T1

xyzIC = [ t(xyzI) for t in T1I ]

T2I = [-x, b*y, z/ab] # inverse of T2

xyzIW = [ t(xyzIC) for t in T2I ]

fwd_defining_poly = xyzIW

fwd_post = a/(x*z*z)(xyzI)

# assert F4(fwd_defining_poly)*fwd_post == F

# Construct the morphism

return WeierstrassTransformationWithInverse(

C, E, fwd_defining_poly, fwd_post, inv_defining_poly, inv_post)

def tangent_at_smooth_point(C,P):

"""Return the tangent at the smooth point `P` of projective curve `C`.

INPUT:

- ``C`` -- a projective plane curve.

- ``P`` -- a 3-tuple `(x,y,z)` defining a projective point on `C`.

OUTPUT:

The linear form defining the tangent at `P` to `C`.

EXAMPLES::

sage: R.<x,y,z> = QQ[]

sage: from sage.schemes.elliptic_curves.constructor import tangent_at_smooth_point

sage: C = Curve(x^3+y^3+60*z^3)

sage: tangent_at_smooth_point(C, [1,-1,0])

x + y

sage: K.<t> = FunctionField(QQ)

sage: R.<x,y,z> = K[]

sage: C = Curve(x^3+2*y^3+3*z^3)

sage: from sage.schemes.elliptic_curves.constructor import tangent_at_smooth_point

sage: tangent_at_smooth_point(C,[1,1,-1])

3*x + 6*y + 9*z

"""

# Over function fields such as QQ(t) an error is raised with the

# default (factor=True). Note that factor=False returns the

# product of the tangents in case of a multiple point, while here

# `P` is assumed smooth so factorization is unnecessary, but over

# QQ (for example) including the factorization gives better

# results, for example returning x+y instead of 3x+3y in the

# doctest.

try:

return C.tangents(P)[0]

except NotImplementedError:

return C.tangents(P,factor=False)[0]

def chord_and_tangent(F, P):

"""Return the third point of intersection of a cubic with the tangent at one point.

INPUT:

- ``F`` -- a homogeneous cubic in three variables with rational

coefficients, as a polynomial ring element, defining a smooth

plane cubic curve.

- ``P`` -- a 3-tuple `(x,y,z)` defining a projective point on the

curve `F=0`.

OUTPUT:

A point ``Q`` such that ``F(Q)=0``, namely the third point of

intersection of the tangent at ``P`` with the curve ``F=0``, so

``Q=P`` if and only if ``P`` is a flex.

EXAMPLES::

sage: R.<x,y,z> = QQ[]

sage: from sage.schemes.elliptic_curves.constructor import chord_and_tangent

sage: F = x^3+y^3+60*z^3

sage: chord_and_tangent(F, [1,-1,0])

(-1 : 1 : 0)

sage: F = x^3+7*y^3+64*z^3

sage: p0 = [2,2,-1]

sage: p1 = chord_and_tangent(F, p0); p1

(5 : -3 : 1)

sage: p2 = chord_and_tangent(F, p1); p2

(-1265/314 : 183/314 : 1)

TESTS::

sage: F(list(p2))

sage: list(map(type, p2))

[<... 'sage.rings.rational.Rational'>,

<... 'sage.rings.rational.Rational'>,

<... 'sage.rings.rational.Rational'>]

See :trac:`16068`::

sage: F = x**3 - 4*x**2*y - 65*x*y**2 + 3*x*y*z - 76*y*z**2

sage: chord_and_tangent(F, [0, 1, 0])

(0 : 0 : 1)

"""

from sage.schemes.curves.constructor import Curve

# check the input

R = F.parent()

if not is_MPolynomialRing(R):

raise TypeError('equation must be a polynomial')

if R.ngens() != 3:

raise TypeError('{} is not a polynomial in three variables'.format(F))

if not F.is_homogeneous():

raise TypeError('{} is not a homogeneous polynomial'.format(F))

x, y, z = R.gens()

if len(P) != 3:

raise TypeError('{} is not a projective point'.format(P))

K = R.base_ring()

try:

C = Curve(F)

P = C(P)

except (TypeError, ValueError):

raise TypeError('{} does not define a point on a projective curve over {} defined by {}'.format(P,K,F))

L = Curve(tangent_at_smooth_point(C,P))

Qlist = [Q for Q in C.intersection(L).rational_points() if Q!=P]

if Qlist:

return Qlist[0]

return P

def projective_point(p):

"""

Return equivalent point with denominators removed

INPUT:

- ``P``, ``Q`` -- list/tuple of projective coordinates.

OUTPUT:

List of projective coordinates.

EXAMPLES::

sage: from sage.schemes.elliptic_curves.constructor import projective_point

sage: projective_point([4/5, 6/5, 8/5])

[2, 3, 4]

sage: F = GF(11)

sage: projective_point([F(4), F(8), F(2)])

[4, 8, 2]

"""

from sage.rings.integer import GCD_list

from sage.arith.functions import LCM_list

try:

p_gcd = GCD_list([x.numerator() for x in p])

p_lcm = LCM_list(x.denominator() for x in p)

except AttributeError:

return p

scale = p_lcm / p_gcd

return [scale * x for x in p]

def are_projectively_equivalent(P, Q, base_ring):

"""

Test whether ``P`` and ``Q`` are projectively equivalent.

INPUT:

- ``P``, ``Q`` -- list/tuple of projective coordinates.

- ``base_ring`` -- the base ring.

OUTPUT:

Boolean.

EXAMPLES::

sage: from sage.schemes.elliptic_curves.constructor import are_projectively_equivalent

sage: are_projectively_equivalent([0,1,2,3], [0,1,2,2], base_ring=QQ)

False

sage: are_projectively_equivalent([0,1,2,3], [0,2,4,6], base_ring=QQ)

True

"""

from sage.matrix.constructor import matrix

return matrix(base_ring, [P, Q]).rank() < 2

def EllipticCurve_from_plane_curve(C, P):

"""

Deprecated way to construct an elliptic curve.

Use :meth:`~sage.schemes.elliptic_curves.jacobian.Jacobian` instead.

EXAMPLES::

sage: R.<x,y,z> = QQ[]

sage: C = Curve(x^3+y^3+z^3)

sage: P = C(1,-1,0)

sage: E = EllipticCurve_from_plane_curve(C,P); E # long time (3s on sage.math, 2013)

doctest:...: DeprecationWarning: use Jacobian(C) instead

See http://trac.sagemath.org/3416 for details.

Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field

"""

from sage.misc.superseded import deprecation

deprecation(3416, 'use Jacobian(C) instead')

# Note: this function never used the rational point

from sage.schemes.elliptic_curves.jacobian import Jacobian

return Jacobian(C)

def EllipticCurves_with_good_reduction_outside_S(S=[], proof=None, verbose=False):

r"""

Returns a sorted list of all elliptic curves defined over `Q`

with good reduction outside the set `S` of primes.

INPUT:

- ``S`` - list of primes (default: empty list).

- ``proof`` - True/False (default True): the MW basis for

auxiliary curves will be computed with this proof flag.

- ``verbose`` - True/False (default False): if True, some details

of the computation will be output.

.. NOTE::

Proof flag: The algorithm used requires determining all

S-integral points on several auxiliary curves, which in turn

requires the computation of their generators. This is not

always possible (even in theory) using current knowledge.

The value of this flag is passed to the function which

computes generators of various auxiliary elliptic curves, in

order to find their S-integral points. Set to False if the

default (True) causes warning messages, but note that you can

then not rely on the set of curves returned being

complete.

EXAMPLES::

sage: EllipticCurves_with_good_reduction_outside_S([])

[]

sage: elist = EllipticCurves_with_good_reduction_outside_S([2])

sage: elist

[Elliptic Curve defined by y^2 = x^3 + 4*x over Rational Field,

Elliptic Curve defined by y^2 = x^3 - x over Rational Field,

...

Elliptic Curve defined by y^2 = x^3 - x^2 - 13*x + 21 over Rational Field]

sage: len(elist)

sage: ', '.join([e.label() for e in elist])

'32a1, 32a2, 32a3, 32a4, 64a1, 64a2, 64a3, 64a4, 128a1, 128a2, 128b1, 128b2, 128c1, 128c2, 128d1, 128d2, 256a1, 256a2, 256b1, 256b2, 256c1, 256c2, 256d1, 256d2'

Without ``Proof=False``, this example gives two warnings::

sage: elist = EllipticCurves_with_good_reduction_outside_S([11],proof=False) # long time (14s on sage.math, 2011)

sage: len(elist) # long time

sage: ', '.join([e.label() for e in elist]) # long time

'11a1, 11a2, 11a3, 121a1, 121a2, 121b1, 121b2, 121c1, 121c2, 121d1, 121d2, 121d3'

sage: elist = EllipticCurves_with_good_reduction_outside_S([2,3]) # long time (26s on sage.math, 2011)

sage: len(elist) # long time

752

sage: max([e.conductor() for e in elist]) # long time

62208

sage: [N.factor() for N in Set([e.conductor() for e in elist])] # long time

[2^7,

2^8,

2^3 * 3^4,

2^2 * 3^3,

2^8 * 3^4,

2^4 * 3^4,

2^3 * 3,

2^7 * 3,

2^3 * 3^5,

3^3,

2^8 * 3,

2^5 * 3^4,

2^4 * 3,

2 * 3^4,

2^2 * 3^2,

2^6 * 3^4,

2^6,

2^7 * 3^2,

2^4 * 3^5,

2^4 * 3^3,

2 * 3^3,

2^6 * 3^3,

2^6 * 3,

2^5,

2^2 * 3^4,

2^3 * 3^2,

2^5 * 3,

2^7 * 3^4,

2^2 * 3^5,

2^8 * 3^2,

2^5 * 3^2,

2^7 * 3^5,

2^8 * 3^5,

2^3 * 3^3,

2^8 * 3^3,

2^5 * 3^5,

2^4 * 3^2,

2 * 3^5,

2^5 * 3^3,

2^6 * 3^5,

2^7 * 3^3,

3^5,

2^6 * 3^2]

"""

from .ell_egros import (egros_from_jlist, egros_get_j)

return egros_from_jlist(egros_get_j(S, proof=proof, verbose=verbose), S)

Coverage for local/lib/python2.7/site-packages/sage/schemes/elliptic_curves/constructor.py : 81%

306 statements 247 run 59 missing 0 excluded