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 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): 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)