def _latex_(self):
r"""
Return a LaTeX string representing this Mumford divisor.
EXAMPLES::
sage: F.<alpha> = GF(7^2)
sage: x = F['x'].gen()
sage: f = x^7 + x^2 + alpha
sage: H = HyperellipticCurve(f, 2*x)
sage: J = H.jacobian()(F)
::
sage: Q = J(0); print(latex(Q)) # indirect doctest
\left(1\right)
sage: Q = J(H.lift_x(F(1))); print(latex(Q)) # indirect doctest
\left(x + 6, y + 2 \alpha + 2\right)
::
sage: print(latex(Q + Q))
\left(x^{2} + 5 x + 1, y + 3 \alpha x + 6 \alpha + 2\right)
"""
if self.is_zero():
return "\\left(1\\right)"
a, b = self._printing_polys()
return "\\left(%s, %s\\right)" % (latex(a), latex(b))
def _latex_(self):
r"""
Return a LaTeX string representing this Mumford divisor.
EXAMPLES::
sage: F.<alpha> = GF(7^2)
sage: x = F['x'].gen()
sage: f = x^7 + x^2 + alpha
sage: H = HyperellipticCurve(f, 2*x)
sage: J = H.jacobian()(F)
::
sage: Q = J(0); print latex(Q) # indirect doctest
\left(1\right)
sage: Q = J(H.lift_x(F(1))); print latex(Q) # indirect doctest
\left(x + 6, y + 2 \alpha + 2\right)
::
sage: print latex(Q + Q)
\left(x^{2} + 5 x + 1, y + 3 \alpha x + 6 \alpha + 2\right)
"""
if self.is_zero():
return "\\left(1\\right)"
a, b = self._printing_polys()
return "\\left(%s, %s\\right)" % (latex(a), latex(b))
def _latex_(self):
r"""Latex string of self.
EXAMPLES::
sage: A = GroupAlgebra(KleinFourGroup(), ZZ)
sage: latex(A) # indirect doctest
\Bold{Z}[\langle (3,4), (1,2) \rangle]
"""
from sage.misc.all import latex
return "%s[%s]" % (latex(self.base_ring()), latex(self.group()))
def _latex_(self):
r"""
Return the latex representation of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S._latex_()
'\\texttt{Algebra of Siegel modular forms of degree }2\\texttt{ and even weights on Sp(4,Z) over }\\Bold{Q}'
"""
from sage.misc.all import latex
return r'\texttt{Algebra of Siegel modular forms of degree }%s\texttt{ and %s weights on %s over }%s' % (
latex(self.__degree), self.__weights, self.__group,
latex(self.__coeff_ring))
def _latex_(self):
r"""
Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: R.<x, y> = ZZ[]
sage: S = Spec(R)
sage: from sage.schemes.generic.divisor import Divisor_generic
sage: from sage.schemes.generic.divisor_group import DivisorGroup
sage: Div = DivisorGroup(S)
sage: D = Divisor_generic([(4, x), (-5, y), (1, x+2*y)], Div)
sage: D._latex_()
'\\mathrm{V}\\left(x + 2 y\\right)
+ 4\\mathrm{V}\\left(x\\right)
- 5\\mathrm{V}\\left(y\\right)'
"""
# The code is copied from _repr_ with latex adjustments
terms = list(self)
# We sort the terms by variety. The order is "reversed" to keep it
# straight - as the test above demonstrates, it results in the first
# generator being in front of the second one
terms.sort(key=lambda x: x[1], reverse=True)
return repr_lincomb([(r"\mathrm{V}\left(%s\right)" % latex(v), c)
for c, v in terms],
is_latex=True)
def _latex_(self):
r"""
Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: R.<x, y> = ZZ[]
sage: S = Spec(R)
sage: from sage.schemes.generic.divisor import Divisor_generic
sage: from sage.schemes.generic.divisor_group import DivisorGroup
sage: Div = DivisorGroup(S)
sage: D = Divisor_generic([(4, x), (-5, y), (1, x+2*y)], Div)
sage: D._latex_()
'\\mathrm{V}\\left(x + 2 y\\right)
+ 4\\mathrm{V}\\left(x\\right)
+ \\left(-5\\right)\\mathrm{V}\\left(y\\right)'
"""
# The code is copied from _repr_ with latex adjustments
terms = list(self)
# We sort the terms by variety. The order is "reversed" to keep it
# straight - as the test above demonstrates, it results in the first
# generator being in front of the second one
terms.sort(key=lambda x: x[1], reverse=True)
return repr_lincomb([(r"\mathrm{V}\left(%s\right)" % latex(v), c) for c,v in terms],
is_latex=True)
def co(coeff):
pol = coeff.polynomial()
mons = pol.monomials()
n = len(mons)
if n == 0:
return ""
if n > 1:
return r"+\left({}\right)".format(latex(coeff))
# now we have a numerical coefficient times a power of the generator
if coeff == 1:
return "+"
if coeff == -1:
return "-"
co = pol.monomial_coefficient(mons[0])
s = "+" if co > 0 else ""
return "{}{}".format(s, latex(coeff))
def _latex_(self):
r"""
Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: N = ToricLattice(3)
sage: Ns = N.submodule([N(2,4,0), N(9,12,0)])
sage: Q = N/Ns
sage: print Q._latex_()
N / \left\langle\left(1,\,8,\,0\right)_{N}, \left(0,\,12,\,0\right)_{N}\right\rangle
sage: Ns = N.submodule([N(1,4,0)])
sage: Q = N/Ns
sage: print Q._latex_()
N / \left\langle\left(1,\,4,\,0\right)_{N}\right\rangle
"""
return "%s / %s" % (latex(self.V()), latex(self.W()))
def _latex_(self):
r"""
Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: N = ToricLattice(3)
sage: Ns = N.submodule([N(2,4,0), N(9,12,0)])
sage: Q = N/Ns
sage: print Q._latex_()
N / \left\langle\left(1,\,8,\,0\right)_{N}, \left(0,\,12,\,0\right)_{N}\right\rangle
sage: Ns = N.submodule([N(1,4,0)])
sage: Q = N/Ns
sage: print Q._latex_()
N / \left\langle\left(1,\,4,\,0\right)_{N}\right\rangle
"""
return "%s / %s" % (latex(self.V()), latex(self.W()))
def print_data():
if show_seq.value:
pretty_print("Mutation sequence: ", seq)
if show_vars.value and kind == 'seed':
pretty_print("Cluster variables:")
table = "\\begin{align*}\n"
for i in range(self._n):
table += "\tv_{%s} &= " % i + latex(self.cluster_variable(i)) + "\\\\ \\\\\n"
table += "\\end{align*}"
pretty_print(table)
if show_matrix.value:
pretty_print("B-Matrix: ", self._M)
def _latex_(self):
"""
EXAMPLES:
sage: x,y,z = PolynomialRing(QQ, 3, names='x,y,z').gens()
sage: C = Curve(y^2*z - x^3 - 17*x*z^2 + y*z^2)
sage: latex(C)
- x^{3} + y^{2} z - 17 x z^{2} + y z^{2}
sage: A2 = AffineSpace(2, QQ, names=['x','y'])
sage: x, y = A2.coordinate_ring().gens()
sage: C = Curve(y^2 - x^3 - 17*x + y)
sage: latex(C)
- x^{3} + y^{2} - 17 x + y
"""
return latex(self.defining_polynomial())
def _latex_(self):
r"""
Return a LaTeX representation of this affine space.
EXAMPLES::
sage: print latex(AffineSpace(1, ZZ, 'x'))
\mathbf{A}_{\Bold{Z}}^1
TESTS::
sage: AffineSpace(3, Zp(5), 'y')._latex_()
'\\mathbf{A}_{\\ZZ_{5}}^3'
"""
return "\\mathbf{A}_{%s}^%s"%(latex(self.base_ring()), self.dimension_relative())
def print_data():
if show_seq.value:
pretty_print("Mutation sequence: ", seq)
if show_vars.value and kind == 'seed':
pretty_print("Cluster variables:")
table = "\\begin{align*}\n"
for i in range(self._n):
table += "\tv_{%s} &= " % i + latex(
self.cluster_variable(i)) + "\\\\ \\\\\n"
table += "\\end{align*}"
pretty_print(table)
if show_matrix.value:
pretty_print("B-Matrix: ", self._M)
def _latex_(self):
"""
EXAMPLES:
sage: x,y,z = PolynomialRing(QQ, 3, names='x,y,z').gens()
sage: C = Curve(y^2*z - x^3 - 17*x*z^2 + y*z^2)
sage: latex(C)
- x^{3} + y^{2} z - 17 x z^{2} + y z^{2}
sage: A2 = AffineSpace(2, QQ, names=['x','y'])
sage: x, y = A2.coordinate_ring().gens()
sage: C = Curve(y^2 - x^3 - 17*x + y)
sage: latex(C)
- x^{3} + y^{2} - 17 x + y
"""
return latex(self.defining_polynomial())
def _latex_(self):
r"""
Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: N = ToricLattice(3)
sage: Ns = N.submodule([N(2,4,0), N(9,12,0)])
sage: Q = N/Ns
sage: print Q.gen(0)._latex_()
\left[0,\,1,\,0\right]_{N}
"""
return latex(self.lift()).replace("(", "[", 1).replace(")", "]", 1)
def _latex_(self):
r"""
Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: N = ToricLattice(3)
sage: Ns = N.submodule([N(2,4,0), N(9,12,0)])
sage: Q = N/Ns
sage: print Q.gen(0)._latex_()
\left[0,\,1,\,0\right]_{N}
"""
return latex(self.lift()).replace("(", "[", 1).replace(")", "]", 1)
def _latex_generic_point(self, v=None):
"""
Return a LaTeX representation of the generic point
corresponding to the list of polys on this projective space.
If polys is None, the representation of the generic point of
the projective space is returned.
EXAMPLES::
sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)
sage: P._latex_generic_point([z*y-x^2])
'\\left(- x^{2} + y z\\right)'
sage: P._latex_generic_point()
'\\left(x : y : z\\right)'
"""
if v is None:
v = self.gens()
return '\\left(%s\\right)' % (" : ".join([str(latex(f)) for f in v]))
def _latex_generic_point(self, v=None):
"""
Return a LaTeX representation of the generic point
corresponding to the list of polys on this projective space.
If polys is None, the representation of the generic point of
the projective space is returned.
EXAMPLES::
sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)
sage: P._latex_generic_point([z*y-x^2])
'\\left(- x^{2} + y z\\right)'
sage: P._latex_generic_point()
'\\left(x : y : z\\right)'
"""
if v is None:
v = self.gens()
return '\\left(%s\\right)'%(" : ".join([str(latex(f)) for f in v]))
def _latex_generic_point(self, v=None):
"""
Return a LaTeX representation of the generic point
corresponding to the list of polys on this affine space.
If polys is None, the representation of the generic point of
the affine space is returned.
EXAMPLES::
sage: A.<x, y> = AffineSpace(2, ZZ)
sage: A._latex_generic_point([y-x^2])
'\\left(- x^{2} + y\\right)'
sage: A._latex_generic_point()
'\\left(x, y\\right)'
"""
if v is None:
v = self.gens()
return '\\left(%s\\right)'%(", ".join([str(latex(f)) for f in v]))
def term(coeff, mon):
if not coeff:
return ""
if not mon:
return "+{}".format(latex(coeff)).replace("+-", "-")
return "{}{}".format(co(coeff), mon)
def web_point(P):
return '$\\left(%s\\right)$' % (" : ".join([str(latex(x)) for x in P]))
def _latex_(self):
r"""
Return the latex representation of this algebra.
EXAMPLES::
sage: S = SiegelModularFormsAlgebra(coeff_ring=QQ)
sage: S._latex_()
'\\texttt{Algebra of Siegel modular forms of degree }2\\texttt{ and even weights on Sp(4,Z) over }\\Bold{Q}'
"""
from sage.misc.all import latex
return r'\texttt{Algebra of Siegel modular forms of degree }%s\texttt{ and %s weights on %s over }%s' %(latex(self.__degree), self.__weights, self.__group, latex(self.__coeff_ring))
def pretty_ideal(I):
easy = True #I.number_field().degree()==2 or I.norm()==1
gens = I.gens_reduced() if easy else I.gens()
return r"\((" + ",".join([latex(g) for g in gens]) + r")\)"
def make_E(self):
#print("Creating ECNF object for {}".format(self.label))
#sys.stdout.flush()
K = self.field.K()
# a-invariants
self.ainvs = parse_ainvs(K, self.ainvs)
self.latex_ainvs = web_latex(self.ainvs)
self.numb = str(self.number)
# Conductor, discriminant, j-invariant
if self.conductor_norm == 1:
N = K.ideal(1)
else:
N = ideal_from_string(K, self.conductor_ideal)
# The following can trigger expensive computations!
#self.cond = web_latex(N)
self.cond = pretty_ideal(N)
self.cond_norm = web_latex(self.conductor_norm)
local_data = self.local_data
# NB badprimes is a list of primes which divide the
# discriminant of this model. At most one of these might
# actually be a prime of good reduction, if the curve has no
# global minimal model.
badprimes = [ideal_from_string(K, ld['p']) for ld in local_data]
badnorms = [ZZ(ld['normp']) for ld in local_data]
mindisc_ords = [ld['ord_disc'] for ld in local_data]
# Assumption: the curve models stored in the database are
# either global minimal models or minimal at all but one
# prime, so the list here has length 0 or 1:
self.non_min_primes = [ideal_from_string(K, P) for P in self.non_min_p]
self.is_minimal = (len(self.non_min_primes) == 0)
self.has_minimal_model = self.is_minimal
disc_ords = [ld['ord_disc'] for ld in local_data]
if not self.is_minimal:
Pmin = self.non_min_primes[0]
P_index = badprimes.index(Pmin)
self.non_min_prime = pretty_ideal(Pmin)
disc_ords[P_index] += 12
if self.conductor_norm == 1: # since the factorization of (1) displays as "1"
self.fact_cond = self.cond
self.fact_cond_norm = '1'
else:
Nfac = Factorization([(P, ld['ord_cond'])
for P, ld in zip(badprimes, local_data)])
self.fact_cond = web_latex_ideal_fact(Nfac)
Nnormfac = Factorization([(q, ld['ord_cond'])
for q, ld in zip(badnorms, local_data)])
self.fact_cond_norm = web_latex(Nnormfac)
# D is the discriminant ideal of the model
D = prod([P**e for P, e in zip(badprimes, disc_ords)], K.ideal(1))
self.disc = pretty_ideal(D)
Dnorm = D.norm()
self.disc_norm = web_latex(Dnorm)
if Dnorm == 1: # since the factorization of (1) displays as "1"
self.fact_disc = self.disc
self.fact_disc_norm = '1'
else:
Dfac = Factorization([(P, e)
for P, e in zip(badprimes, disc_ords)])
self.fact_disc = web_latex_ideal_fact(Dfac)
Dnormfac = Factorization([(q, e)
for q, e in zip(badnorms, disc_ords)])
self.fact_disc_norm = web_latex(Dnormfac)
if not self.is_minimal:
Dmin = ideal_from_string(K, self.minD)
self.mindisc = pretty_ideal(Dmin)
Dmin_norm = Dmin.norm()
self.mindisc_norm = web_latex(Dmin_norm)
if Dmin_norm == 1: # since the factorization of (1) displays as "1"
self.fact_mindisc = self.mindisc
self.fact_mindisc_norm = self.mindisc_norm
else:
Dminfac = Factorization(list(zip(badprimes, mindisc_ords)))
self.fact_mindisc = web_latex_ideal_fact(Dminfac)
Dminnormfac = Factorization(list(zip(badnorms, mindisc_ords)))
self.fact_mindisc_norm = web_latex(Dminnormfac)
j = self.field.parse_NFelt(self.jinv)
# if j:
# d = j.denominator()
# n = d * j # numerator exists for quadratic fields only!
# g = GCD(list(n))
# n1 = n / g
# self.j = web_latex(n1)
# if d != 1:
# if n1 > 1:
# # self.j = "("+self.j+")\(/\)"+web_latex(d)
# self.j = web_latex(r"\frac{%s}{%s}" % (self.j, d))
# else:
# self.j = web_latex(d)
# if g > 1:
# if n1 > 1:
# self.j = web_latex(g) + self.j
# else:
# self.j = web_latex(g)
self.j = web_latex(j)
self.fact_j = None
# See issue 1258: some j factorizations work but take too long
# (e.g. EllipticCurve/6.6.371293.1/1.1/a/1). Note that we do
# store the factorization of the denominator of j and display
# that, which is the most interesting part.
# The equation is stored in the database as a latex string.
# Some of these have extraneous double quotes at beginning and
# end, shich we fix here. We also strip out initial \( and \)
# (if present) which are added in the template.
self.equation = self.equation.replace('"', '').replace('\\(',
'').replace(
'\\)', '')
# Images of Galois representations
if not hasattr(self, 'galois_images'):
#print "No Galois image data"
self.galois_images = "?"
self.non_surjective_primes = "?"
self.galois_data = []
else:
self.galois_data = [{
'p': p,
'image': im
} for p, im in zip(self.non_surjective_primes, self.galois_images)]
# CM and End(E)
self.cm_bool = "no"
self.End = r"\(\Z\)"
if self.cm:
# When we switch to storing rational cm by having |D| in
# the column, change the following lines:
if self.cm > 0:
self.rational_cm = True
self.cm = -self.cm
else:
self.rational_cm = K(self.cm).is_square()
self.cm_sqf = ZZ(self.cm).squarefree_part()
self.cm_bool = r"yes (\(%s\))" % self.cm
if self.cm % 4 == 0:
d4 = ZZ(self.cm) // 4
self.End = r"\(\Z[\sqrt{%s}]\)" % (d4)
else:
self.End = r"\(\Z[(1+\sqrt{%s})/2]\)" % self.cm
# Galois images in CM case:
if self.cm and self.galois_images != '?':
self.cm_ramp = [
p for p in ZZ(self.cm).support()
if not p in self.non_surjective_primes
]
self.cm_nramp = len(self.cm_ramp)
if self.cm_nramp == 1:
self.cm_ramp = self.cm_ramp[0]
else:
self.cm_ramp = ", ".join([str(p) for p in self.cm_ramp])
# Sato-Tate:
# The lines below will need to change once we have curves over non-quadratic fields
# that contain the Hilbert class field of an imaginary quadratic field
if self.cm:
if self.signature == [0, 1] and ZZ(
-self.abs_disc * self.cm).is_square():
self.ST = st_link_by_name(1, 2, 'U(1)')
else:
self.ST = st_link_by_name(1, 2, 'N(U(1))')
else:
self.ST = st_link_by_name(1, 2, 'SU(2)')
# Q-curve / Base change
try:
qc = self.q_curve
if qc is True:
self.qc = "yes"
elif qc is False:
self.qc = "no"
else: # just in case
self.qc = "not determined"
except AttributeError:
self.qc = "not determined"
# Torsion
self.ntors = web_latex(self.torsion_order)
self.tr = len(self.torsion_structure)
if self.tr == 0:
self.tor_struct_pretty = "trivial"
if self.tr == 1:
self.tor_struct_pretty = r"\(\Z/%s\Z\)" % self.torsion_structure[0]
if self.tr == 2:
self.tor_struct_pretty = r"\(\Z/%s\Z\times\Z/%s\Z\)" % tuple(
self.torsion_structure)
self.torsion_gens = [
web_point(parse_point(K, P)) for P in self.torsion_gens
]
# BSD data
#
# We divide into 3 cases, based on rank_bounds [lb,ub],
# analytic_rank ar, (lb=ngens always). The flag
# self.bsd_status is set to one of the following:
#
# "unconditional"
# lb=ar=ub: we always have reg but in some cases over sextic fields we do not have omega, Lvalue, sha.
# i.e. [lb,ar,ub] = [r,r,r]
#
# "conditional"
# lb=ar<ub: we always have reg but in some cases over sextic fields we do not have omega, Lvalue, sha.
# e.g. [lb,ar,ub] = [0,0,2], [1,1,3]
#
# "missing_gens"
# lb<ar<=ub
# e.g. [lb,ar,ub] = [0,1,1], [0,2,2], [1,2,2], [0,1,3]
#
# "incomplete"
# ar not computed. (We can always set lb=0, ub=Infinity.)
# Rank and bounds
try:
self.rk = web_latex(self.rank)
except AttributeError:
self.rank = None
self.rk = "not available"
try:
self.rk_lb, self.rk_ub = self.rank_bounds
except AttributeError:
self.rk_lb = 0
self.rk_ub = Infinity
self.rank_bounds = "not available"
# Analytic rank
try:
self.ar = web_latex(self.analytic_rank)
except AttributeError:
self.analytic_rank = None
self.ar = "not available"
# for debugging:
assert self.rk == "not available" or (self.rk_lb == self.rank
and self.rank == self.rk_ub)
assert self.ar == "not available" or (self.rk_lb <= self.analytic_rank
and
self.analytic_rank <= self.rk_ub)
self.bsd_status = "incomplete"
if self.analytic_rank != None:
if self.rk_lb == self.rk_ub:
self.bsd_status = "unconditional"
elif self.rk_lb == self.analytic_rank:
self.bsd_status = "conditional"
else:
self.bsd_status = "missing_gens"
# Regulator only in conditional/unconditional cases, or when we know the rank:
if self.bsd_status in ["conditional", "unconditional"]:
if self.ar == 0:
self.reg = web_latex(1) # otherwise we only get 1.00000...
else:
try:
self.reg = web_latex(self.reg)
except AttributeError:
self.reg = "not available"
elif self.rk != "not available":
self.reg = web_latex(self.reg) if self.rank else web_latex(1)
else:
self.reg = "not available"
# Generators
try:
self.gens = [web_point(parse_point(K, P)) for P in self.gens]
except AttributeError:
self.gens = []
# Global period
try:
self.omega = web_latex(self.omega)
except AttributeError:
self.omega = "not available"
# L-value
try:
r = int(self.analytic_rank)
# lhs = "L(E,1) = " if r==0 else "L'(E,1) = " if r==1 else "L^{{({})}}(E,1)/{}! = ".format(r,r)
self.Lvalue = "\\(" + str(self.Lvalue) + "\\)"
except (TypeError, AttributeError):
self.Lvalue = "not available"
# Tamagawa product
tamagawa_numbers = [ZZ(_ld['cp']) for _ld in self.local_data]
cp_fac = [cp.factor() for cp in tamagawa_numbers]
cp_fac = [
latex(cp) if len(cp) < 2 else '(' + latex(cp) + ')'
for cp in cp_fac
]
if len(cp_fac) > 1:
self.tamagawa_factors = r'\cdot'.join(cp_fac)
else:
self.tamagawa_factors = None
self.tamagawa_product = web_latex(prod(tamagawa_numbers, 1))
# Analytic Sha
try:
self.sha = web_latex(self.sha) + " (rounded)"
except AttributeError:
self.sha = "not available"
# Local data
# Fix for Kodaira symbols, which in the database start and end
# with \( and \) and may have multiple backslashes. Note that
# to put a single backslash into a python string you have to
# use '\\' which will display as '\\' but only counts as one
# character in the string. which are added in the template.
def tidy_kod(kod):
while '\\\\' in kod:
kod = kod.replace('\\\\', '\\')
kod = kod.replace('\\(', '').replace('\\)', '')
return kod
for P, ld in zip(badprimes, local_data):
ld['p'] = web_latex(P)
ld['norm'] = P.norm()
ld['kod'] = tidy_kod(ld['kod'])
# URLs of self and related objects:
self.urls = {}
# It's useful to be able to use this class out of context, when calling url_for will fail:
try:
self.urls['curve'] = url_for(".show_ecnf",
nf=self.field_label,
conductor_label=quote(
self.conductor_label),
class_label=self.iso_label,
number=self.number)
except RuntimeError:
return
self.urls['class'] = url_for(".show_ecnf_isoclass",
nf=self.field_label,
conductor_label=quote(
self.conductor_label),
class_label=self.iso_label)
self.urls['conductor'] = url_for(".show_ecnf_conductor",
nf=self.field_label,
conductor_label=quote(
self.conductor_label))
self.urls['field'] = url_for(".show_ecnf1", nf=self.field_label)
# Isogeny information
self.one_deg = ZZ(self.class_deg).is_prime()
isodegs = [str(d) for d in self.isodeg if d > 1]
if len(isodegs) < 3:
self.isodeg = " and ".join(isodegs)
else:
self.isodeg = " and ".join([", ".join(isodegs[:-1]), isodegs[-1]])
sig = self.signature
totally_real = sig[1] == 0
imag_quadratic = sig == [0, 1]
if totally_real:
self.hmf_label = "-".join(
[self.field.label, self.conductor_label, self.iso_label])
self.urls['hmf'] = url_for('hmf.render_hmf_webpage',
field_label=self.field.label,
label=self.hmf_label)
lfun_url = url_for("l_functions.l_function_ecnf_page",
field_label=self.field_label,
conductor_label=self.conductor_label,
isogeny_class_label=self.iso_label)
origin_url = lfun_url.lstrip('/L/').rstrip('/')
if sig[0] <= 2 and db.lfunc_instances.exists({'url': origin_url}):
self.urls['Lfunction'] = lfun_url
elif self.abs_disc**2 * self.conductor_norm < 70000:
# we shouldn't trust the Lfun computed on the fly for large conductor
self.urls['Lfunction'] = url_for(
"l_functions.l_function_hmf_page",
field=self.field_label,
label=self.hmf_label,
character='0',
number='0')
if imag_quadratic:
self.bmf_label = "-".join(
[self.field.label, self.conductor_label, self.iso_label])
self.bmf_url = url_for('bmf.render_bmf_webpage',
field_label=self.field_label,
level_label=self.conductor_label,
label_suffix=self.iso_label)
lfun_url = url_for("l_functions.l_function_ecnf_page",
field_label=self.field_label,
conductor_label=self.conductor_label,
isogeny_class_label=self.iso_label)
origin_url = lfun_url.lstrip('/L/').rstrip('/')
if db.lfunc_instances.exists({'url': origin_url}):
self.urls['Lfunction'] = lfun_url
# most of this code is repeated in isog_class.py
# and should be refactored
self.friends = []
self.friends += [('Isogeny class ' + self.short_class_label,
self.urls['class'])]
self.friends += [('Twists',
url_for('ecnf.index',
field=self.field_label,
jinv=rename_j(j)))]
if totally_real and not 'Lfunction' in self.urls:
self.friends += [('Hilbert modular form ' + self.hmf_label,
self.urls['hmf'])]
if imag_quadratic:
if "CM" in self.label:
self.friends += [('Bianchi modular form is not cuspidal', '')]
elif not 'Lfunction' in self.urls:
if db.bmf_forms.label_exists(self.bmf_label):
self.friends += [
('Bianchi modular form %s' % self.bmf_label,
self.bmf_url)
]
else:
self.friends += [
('(Bianchi modular form %s)' % self.bmf_label, '')
]
self.properties = [('Label', self.label)]
# Plot
if K.signature()[0]:
self.plot = encode_plot(
EC_nf_plot(K, self.ainvs, self.field.generator_name()))
self.plot_link = '<a href="{0}"><img src="{0}" width="200" height="150"/></a>'.format(
self.plot)
self.properties += [(None, self.plot_link)]
self.properties += [('Base field', self.field.field_pretty())]
self.properties += [
('Conductor', self.cond),
('Conductor norm', self.cond_norm),
# See issue #796 for why this is hidden (can be very large)
# ('j-invariant', self.j),
('CM', self.cm_bool)
]
if self.base_change:
self.properties += [
('Base change',
'yes: %s' % ','.join([str(lab) for lab in self.base_change]))
]
else:
self.base_change = [] # in case it was False instead of []
self.properties += [('Base change', 'no')]
self.properties += [('Q-curve', self.qc)]
r = self.rk
if r == "?":
r = self.rk_bnds
self.properties += [
('Torsion order', self.ntors),
('Rank', r),
]
for E0 in self.base_change:
self.friends += [(r'Base change of %s /\(\Q\)' % E0,
url_for("ec.by_ec_label", label=E0))]
self._code = None # will be set if needed by get_code()
self.downloads = [('All stored data to text',
url_for(".download_ECNF_all",
nf=self.field_label,
conductor_label=quote(self.conductor_label),
class_label=self.iso_label,
number=self.number))]
for lang in [["Magma", "magma"], ["SageMath", "sage"], ["GP", "gp"]]:
self.downloads.append(
('Code to {}'.format(lang[0]),
url_for(".ecnf_code_download",
nf=self.field_label,
conductor_label=quote(self.conductor_label),
class_label=self.iso_label,
number=self.number,
download_type=lang[1])))
if 'Lfunction' in self.urls:
Lfun = get_lfunction_by_url(
self.urls['Lfunction'].lstrip('/L').rstrip('/'),
projection=['degree', 'trace_hash', 'Lhash'])
if Lfun is None:
self.friends += [('L-function not available', "")]
else:
instances = get_instances_by_Lhash_and_trace_hash(
Lfun['Lhash'], Lfun['degree'], Lfun.get('trace_hash'))
exclude = {
elt[1].rstrip('/').lstrip('/')
for elt in self.friends if elt[1]
}
self.friends += names_and_urls(instances, exclude=exclude)
self.friends += [('L-function', self.urls['Lfunction'])]
else:
self.friends += [('L-function not available', "")]
def make_name(N1, N2, use_latex=False):
if use_latex:
return latex(N1)+ ' \oplus ' +latex(N2)
else:
return N1._name+ '+' +N2._name
def make_name(N1, N2, use_latex=False):
if use_latex:
return latex(N1) + " \oplus " + latex(N2)
else:
return N1._name + "+" + N2._name
def pretty_ideal(I):
easy = I.number_field().degree()==2 or I.norm()==1
gens = I.gens_reduced() if easy else I.gens()
return "\((" + ",".join([latex(g) for g in gens]) + ")\)"
def web_point(P):
return '$\\left(%s\\right)$'%(" : ".join([str(latex(x)) for x in P]))
def make_name(N1, N2, use_latex=False):
if use_latex:
return latex(N1) + ' \oplus ' + latex(N2)
else:
return N1._name + '+' + N2._name
def make_E(self):
#print("Creating ECNF object for {}".format(self.label))
#sys.stdout.flush()
K = self.field.K()
Kgen = str(K.gen())
# a-invariants
# NB Here we construct the ai as elements of K, which are used as follows:
# (1) to compute the model discriminant (if not stored)
# (2) to compute the latex equation (if not stored)
# (3) to compute the plots under real embeddings of K
# Of these, (2) is not needed and (1) will soon be obsolete;
# for (3) it would be possible to rewrite the function EC_nf_plot() not to need this.
# Then we might also be able to avoid constructing the field K also.
self.ainvs = parse_ainvs(K, self.ainvs)
self.numb = str(self.number)
# Conductor, discriminant, j-invariant
self.cond_norm = web_latex(self.conductor_norm)
Dnorm = self.normdisc
self.disc = pretty_ideal(Kgen, self.disc)
local_data = self.local_data
local_data.sort(key=lambda ld: ld['normp'])
badprimes = [
pretty_ideal(Kgen, ld['p'], enclose=False) for ld in local_data
]
badnorms = [ld['normp'] for ld in local_data]
disc_ords = [ld['ord_disc'] for ld in local_data]
mindisc_ords = [ld['ord_disc'] for ld in local_data]
cond_ords = [ld['ord_cond'] for ld in local_data]
if self.conductor_norm == 1:
self.cond = r"\((1)\)"
self.fact_cond = self.cond
self.fact_cond_norm = '1'
else:
self.cond = pretty_ideal(Kgen, self.conductor_ideal)
self.fact_cond = latex_factorization(badprimes, cond_ords)
self.fact_cond_norm = latex_factorization(badnorms, cond_ords)
# Assumption: the curve models stored in the database are
# either global minimal models or minimal at all but one
# prime, so the list here has length 0 or 1:
self.is_minimal = (len(self.non_min_p) == 0)
self.has_minimal_model = self.is_minimal
if not self.is_minimal:
non_min_p = self.non_min_p[0]
self.non_min_prime = pretty_ideal(Kgen, non_min_p)
ip = [ld['p'] for ld in local_data].index(non_min_p)
disc_ords[ip] += 12
Dnorm_factor = local_data[ip]['normp']**12
self.disc_norm = web_latex(Dnorm)
signDnorm = 1 if Dnorm > 0 else -1
if Dnorm in [1, -1]: # since the factorization of (1) displays as "1"
self.fact_disc = self.disc
self.fact_disc_norm = str(Dnorm)
else:
self.fact_disc = latex_factorization(badprimes, disc_ords)
self.fact_disc_norm = latex_factorization(badnorms,
disc_ords,
sign=signDnorm)
if self.is_minimal:
Dmin_norm = Dnorm
self.mindisc = self.disc
else:
Dmin_norm = Dnorm // Dnorm_factor
self.mindisc = pretty_ideal(Kgen, self.minD)
self.mindisc_norm = web_latex(Dmin_norm)
if Dmin_norm in [1,
-1]: # since the factorization of (1) displays as "1"
self.fact_mindisc = self.mindisc
self.fact_mindisc_norm = self.mindisc_norm
else:
self.fact_mindisc = latex_factorization(badprimes, mindisc_ords)
self.fact_mindisc_norm = latex_factorization(badnorms,
mindisc_ords,
sign=signDnorm)
j = self.field.parse_NFelt(self.jinv)
self.j = web_latex(j)
self.fact_j = None
# See issue 1258: some j factorizations work but take too long
# (e.g. EllipticCurve/6.6.371293.1/1.1/a/1). Note that we do
# store the factorization of the denominator of j and display
# that, which is the most interesting part.
# When the equation is stored in the database as a latex string,
# it may have extraneous double quotes at beginning and
# end, which we fix here. We also strip out initial \( and \)
# (if present) which are added in the template.
try:
self.equation = self.equation.replace('"', '').replace(
r'\\(', '').replace(r'\\)', '')
except AttributeError:
self.equation = latex_equation(self.ainvs)
# Images of Galois representations
if not hasattr(self, 'galois_images'):
#print "No Galois image data"
self.galois_images = "?"
self.nonmax_primes = "?"
self.galois_data = []
else:
self.galois_data = [{
'p': p,
'image': im
} for p, im in zip(self.nonmax_primes, self.galois_images)]
# CM and End(E)
self.cm_bool = "no"
self.End = r"\(\Z\)"
self.rational_cm = self.cm_type > 0
if self.cm:
self.cm_sqf = integer_squarefree_part(ZZ(self.cm))
self.cm_bool = r"yes (\(%s\))" % self.cm
if self.cm % 4 == 0:
d4 = ZZ(self.cm) // 4
self.End = r"\(\Z[\sqrt{%s}]\)" % (d4)
else:
self.End = r"\(\Z[(1+\sqrt{%s})/2]\)" % self.cm
# Galois images in CM case:
if self.cm and self.galois_images != '?':
self.cm_ramp = [
p for p in ZZ(self.cm).support() if p not in self.nonmax_primes
]
self.cm_nramp = len(self.cm_ramp)
if self.cm_nramp == 1:
self.cm_ramp = self.cm_ramp[0]
else:
self.cm_ramp = ", ".join([str(p) for p in self.cm_ramp])
# Sato-Tate:
self.ST = st_display_knowl('1.2.A.1.1a' if not self.cm_type else (
'1.2.B.2.1a' if self.cm_type < 0 else '1.2.B.1.1a'))
# Q-curve / Base change
try:
qc = self.q_curve
if qc is True:
self.qc = "yes"
elif qc is False:
self.qc = "no"
else: # just in case
self.qc = "not determined"
except AttributeError:
self.qc = "not determined"
# Torsion
self.ntors = web_latex(self.torsion_order)
self.tr = len(self.torsion_structure)
if self.tr == 0:
self.tor_struct_pretty = "trivial"
if self.tr == 1:
self.tor_struct_pretty = r"\(\Z/%s\Z\)" % self.torsion_structure[0]
if self.tr == 2:
self.tor_struct_pretty = r"\(\Z/%s\Z\times\Z/%s\Z\)" % tuple(
self.torsion_structure)
self.torsion_gens = [
web_point(parse_point(K, P)) for P in self.torsion_gens
]
# BSD data
#
# We divide into 3 cases, based on rank_bounds [lb,ub],
# analytic_rank ar, (lb=ngens always). The flag
# self.bsd_status is set to one of the following:
#
# "unconditional"
# lb=ar=ub: we always have reg but in some cases over sextic fields we do not have omega, Lvalue, sha.
# i.e. [lb,ar,ub] = [r,r,r]
#
# "conditional"
# lb=ar<ub: we always have reg but in some cases over sextic fields we do not have omega, Lvalue, sha.
# e.g. [lb,ar,ub] = [0,0,2], [1,1,3]
#
# "missing_gens"
# lb<ar<=ub
# e.g. [lb,ar,ub] = [0,1,1], [0,2,2], [1,2,2], [0,1,3]
#
# "incomplete"
# ar not computed. (We can always set lb=0, ub=Infinity.)
# Rank and bounds
try:
self.rk = web_latex(self.rank)
except AttributeError:
self.rank = None
self.rk = "not available"
try:
self.rk_lb, self.rk_ub = self.rank_bounds
except AttributeError:
self.rk_lb = 0
self.rk_ub = Infinity
self.rank_bounds = "not available"
# Analytic rank
try:
self.ar = web_latex(self.analytic_rank)
except AttributeError:
self.analytic_rank = None
self.ar = "not available"
# for debugging:
assert self.rk == "not available" or (self.rk_lb == self.rank
and self.rank == self.rk_ub)
assert self.ar == "not available" or (self.rk_lb <= self.analytic_rank
and
self.analytic_rank <= self.rk_ub)
self.bsd_status = "incomplete"
if self.analytic_rank is not None:
if self.rk_lb == self.rk_ub:
self.bsd_status = "unconditional"
elif self.rk_lb == self.analytic_rank:
self.bsd_status = "conditional"
else:
self.bsd_status = "missing_gens"
# Regulator only in conditional/unconditional cases, or when we know the rank:
if self.bsd_status in ["conditional", "unconditional"]:
if self.ar == 0:
self.reg = web_latex(1) # otherwise we only get 1.00000...
else:
try:
self.reg = web_latex(self.reg)
except AttributeError:
self.reg = "not available"
elif self.rk != "not available":
self.reg = web_latex(self.reg) if self.rank else web_latex(1)
else:
self.reg = "not available"
# Generators
try:
self.gens = [web_point(parse_point(K, P)) for P in self.gens]
except AttributeError:
self.gens = []
# Global period
try:
self.omega = web_latex(self.omega)
except AttributeError:
self.omega = "not available"
# L-value
try:
r = int(self.analytic_rank)
# lhs = "L(E,1) = " if r==0 else "L'(E,1) = " if r==1 else "L^{{({})}}(E,1)/{}! = ".format(r,r)
self.Lvalue = web_latex(self.Lvalue)
except (TypeError, AttributeError):
self.Lvalue = "not available"
# Tamagawa product
tamagawa_numbers = [ZZ(_ld['cp']) for _ld in self.local_data]
cp_fac = [cp.factor() for cp in tamagawa_numbers]
cp_fac = [
latex(cp) if len(cp) < 2 else '(' + latex(cp) + ')'
for cp in cp_fac
]
if len(cp_fac) > 1:
self.tamagawa_factors = r'\cdot'.join(cp_fac)
else:
self.tamagawa_factors = None
self.tamagawa_product = web_latex(prod(tamagawa_numbers, 1))
# Analytic Sha
try:
self.sha = web_latex(self.sha) + " (rounded)"
except AttributeError:
self.sha = "not available"
# Local data
# The Kodaira symbol is stored as an int in pari encoding. The
# conversion to latex must take into account the bug (in Sage
# 9.2) for I_m^* when m has more than one digit.
def latex_kod(kod):
return latex(
KodairaSymbol(kod)) if kod > -14 else 'I_{%s}^{*}' % (-kod - 4)
for P, NP, ld in zip(badprimes, badnorms, local_data):
ld['p'] = P
ld['norm'] = NP
ld['kod'] = latex_kod(ld['kod'])
# URLs of self and related objects:
self.urls = {}
# It's useful to be able to use this class out of context, when calling url_for will fail:
try:
self.urls['curve'] = url_for(".show_ecnf",
nf=self.field_label,
conductor_label=quote(
self.conductor_label),
class_label=self.iso_label,
number=self.number)
except RuntimeError:
return
self.urls['class'] = url_for(".show_ecnf_isoclass",
nf=self.field_label,
conductor_label=quote(
self.conductor_label),
class_label=self.iso_label)
self.urls['conductor'] = url_for(".show_ecnf_conductor",
nf=self.field_label,
conductor_label=quote(
self.conductor_label))
self.urls['field'] = url_for(".show_ecnf1", nf=self.field_label)
# Isogeny information
self.one_deg = ZZ(self.class_deg).is_prime()
isodegs = [str(d) for d in self.isodeg if d > 1]
if len(isodegs) < 3:
self.isodeg = " and ".join(isodegs)
else:
self.isodeg = " and ".join([", ".join(isodegs[:-1]), isodegs[-1]])
sig = self.signature
totally_real = sig[1] == 0
imag_quadratic = sig == [0, 1]
if totally_real:
self.hmf_label = "-".join(
[self.field.label, self.conductor_label, self.iso_label])
self.urls['hmf'] = url_for('hmf.render_hmf_webpage',
field_label=self.field.label,
label=self.hmf_label)
lfun_url = url_for("l_functions.l_function_ecnf_page",
field_label=self.field_label,
conductor_label=self.conductor_label,
isogeny_class_label=self.iso_label)
origin_url = lfun_url.lstrip('/L/').rstrip('/')
if sig[0] <= 2 and db.lfunc_instances.exists({'url': origin_url}):
self.urls['Lfunction'] = lfun_url
elif self.abs_disc**2 * self.conductor_norm < 70000:
# we shouldn't trust the Lfun computed on the fly for large conductor
self.urls['Lfunction'] = url_for(
"l_functions.l_function_hmf_page",
field=self.field_label,
label=self.hmf_label,
character='0',
number='0')
if imag_quadratic:
self.bmf_label = "-".join(
[self.field.label, self.conductor_label, self.iso_label])
self.bmf_url = url_for('bmf.render_bmf_webpage',
field_label=self.field_label,
level_label=self.conductor_label,
label_suffix=self.iso_label)
lfun_url = url_for("l_functions.l_function_ecnf_page",
field_label=self.field_label,
conductor_label=self.conductor_label,
isogeny_class_label=self.iso_label)
origin_url = lfun_url.lstrip('/L/').rstrip('/')
if db.lfunc_instances.exists({'url': origin_url}):
self.urls['Lfunction'] = lfun_url
# most of this code is repeated in isog_class.py
# and should be refactored
self.friends = []
self.friends += [('Isogeny class ' + self.short_class_label,
self.urls['class'])]
self.friends += [('Twists',
url_for('ecnf.index',
field=self.field_label,
jinv=rename_j(j)))]
if totally_real and 'Lfunction' not in self.urls:
self.friends += [('Hilbert modular form ' + self.hmf_label,
self.urls['hmf'])]
if imag_quadratic:
if "CM" in self.label:
self.friends += [('Bianchi modular form is not cuspidal', '')]
elif 'Lfunction' not in self.urls:
if db.bmf_forms.label_exists(self.bmf_label):
self.friends += [
('Bianchi modular form %s' % self.bmf_label,
self.bmf_url)
]
else:
self.friends += [
('(Bianchi modular form %s)' % self.bmf_label, '')
]
self.properties = [('Label', self.label)]
# Plot
if K.signature()[0]:
self.plot = encode_plot(
EC_nf_plot(K, self.ainvs, self.field.generator_name()))
self.plot_link = '<a href="{0}"><img src="{0}" width="200" height="150"/></a>'.format(
self.plot)
self.properties += [(None, self.plot_link)]
self.properties += [('Base field', self.field.field_pretty())]
self.properties += [
('Conductor', self.cond),
('Conductor norm', self.cond_norm),
# See issue #796 for why this is hidden (can be very large)
# ('j-invariant', self.j),
('CM', self.cm_bool)
]
if self.base_change:
self.base_change = [
lab for lab in self.base_change if '?' not in lab
]
self.properties += [
('Base change',
'yes: %s' % ','.join([str(lab) for lab in self.base_change]))
]
else:
self.base_change = [] # in case it was False instead of []
self.properties += [('Base change', 'no')]
self.properties += [('Q-curve', self.qc)]
r = self.rk
if r == "?":
r = self.rk_bnds
self.properties += [
('Torsion order', self.ntors),
('Rank', r),
]
for E0 in self.base_change:
self.friends += [(r'Base change of %s /\(\Q\)' % E0,
url_for("ec.by_ec_label", label=E0))]
self._code = None # will be set if needed by get_code()
self.downloads = [('All stored data to text',
url_for(".download_ECNF_all",
nf=self.field_label,
conductor_label=quote(self.conductor_label),
class_label=self.iso_label,
number=self.number))]
for lang in [["Magma", "magma"], ["GP", "gp"], ["SageMath", "sage"]]:
self.downloads.append(
('Code to {}'.format(lang[0]),
url_for(".ecnf_code_download",
nf=self.field_label,
conductor_label=quote(self.conductor_label),
class_label=self.iso_label,
number=self.number,
download_type=lang[1])))
self.downloads.append(
('Underlying data', url_for(".ecnf_data", label=self.label)))
if 'Lfunction' in self.urls:
Lfun = get_lfunction_by_url(
self.urls['Lfunction'].lstrip('/L').rstrip('/'),
projection=['degree', 'trace_hash', 'Lhash'])
if Lfun is None:
self.friends += [('L-function not available', "")]
else:
instances = get_instances_by_Lhash_and_trace_hash(
Lfun['Lhash'], Lfun['degree'], Lfun.get('trace_hash'))
exclude = {
elt[1].rstrip('/').lstrip('/')
for elt in self.friends if elt[1]
}
self.friends += names_and_urls(instances, exclude=exclude)
self.friends += [('L-function', self.urls['Lfunction'])]
else:
self.friends += [('L-function not available', "")]
def latex_kod(kod):
return latex(
KodairaSymbol(kod)) if kod > -14 else 'I_{%s}^{*}' % (-kod - 4)
