def __init__(self,
conductor,
gammaV,
weight,
eps,
poles=None,
residues='automatic',
prec=53,
init=None):
"""
Initialization of Dokchitser calculator EXAMPLES::
sage: L = Dokchitser(conductor=1, gammaV=[0], weight=1, eps=1, poles=[1], residues=[-1], init='1')
sage: L.num_coeffs()
4
"""
self.conductor = conductor
self.gammaV = gammaV
self.weight = weight
self.eps = eps
self.poles = poles if poles is not None else []
self.residues = residues
self.prec = prec
self.__CC = ComplexField(self.prec)
self.__RR = self.__CC._real_field()
self.__initialized = False
if init is not None:
self.init_coeffs(init)
def _do_sqrt(x, prec=None, extend=True, all=False):
r"""
Used internally to compute the square root of x.
INPUT:
- ``x`` - a number
- ``prec`` - None (default) or a positive integer
(bits of precision) If not None, then compute the square root
numerically to prec bits of precision.
- ``extend`` - bool (default: True); this is a place
holder, and is always ignored since in the symbolic ring everything
has a square root.
- ``extend`` - bool (default: True); whether to extend
the base ring to find roots. The extend parameter is ignored if
prec is a positive integer.
- ``all`` - bool (default: False); whether to return
a list of all the square roots of x.
EXAMPLES::
sage: from sage.functions.other import _do_sqrt
sage: _do_sqrt(3)
sqrt(3)
sage: _do_sqrt(3,prec=10)
1.7
sage: _do_sqrt(3,prec=100)
1.7320508075688772935274463415
sage: _do_sqrt(3,all=True)
[sqrt(3), -sqrt(3)]
Note that the extend parameter is ignored in the symbolic ring::
sage: _do_sqrt(3,extend=False)
sqrt(3)
"""
from sage.rings.all import RealField, ComplexField
if prec:
if x >= 0:
return RealField(prec)(x).sqrt(all=all)
else:
return ComplexField(prec)(x).sqrt(all=all)
if x == -1:
from sage.symbolic.pynac import I
z = I
else:
z = SR(x)**one_half
if all:
if z:
return [z, -z]
else:
return [z]
return z
def _evalf_(self, x, parent_d=None):
"""
EXAMPLES::
sage: arg(0.0)
0.000000000000000
sage: arg(3.0)
0.000000000000000
sage: arg(3.00000000000000000000000000)
0.00000000000000000000000000
sage: arg(3.00000000000000000000000000).prec()
90
sage: arg(ComplexIntervalField(90)(3)).prec()
90
sage: arg(ComplexIntervalField(90)(3)).parent()
Real Interval Field with 90 bits of precision
sage: arg(3.0r)
0.000000000000000
sage: arg(RDF(3))
0.0
sage: arg(RDF(3)).parent()
Real Double Field
sage: arg(-2.5)
3.14159265358979
sage: arg(2.0+3*i)
0.982793723247329
"""
try:
return x.arg()
except AttributeError:
pass
# try to find a parent that support .arg()
if parent_d is None:
parent_d = parent(x)
try:
parent_d = parent_d.complex_field()
except AttributeError:
from sage.rings.complex_field import ComplexField
try:
parent_d = ComplexField(x.prec())
except AttributeError:
parent_d = ComplexField()
return parent_d(x).arg()
def __init__(self, lfun, prec=None):
"""
Initialization of the L-function from a PARI L-function.
INPUT:
- lfun -- a PARI :pari:`lfun` object or an instance of :class:`lfun_generic`
- prec -- integer (default: 53) number of *bits* of precision
EXAMPLES::
sage: from sage.lfunctions.pari import lfun_generic, LFunction
sage: lf = lfun_generic(conductor=1, gammaV=[0], weight=1, eps=1, poles=[1], residues=[-1], v=pari('k->vector(k,n,1)'))
sage: L = LFunction(lf)
sage: L.num_coeffs()
4
"""
if isinstance(lfun, lfun_generic):
# preparation using motivic data
self._L = lfun.__pari__()
if prec is None:
prec = lfun.prec
elif isinstance(lfun, Gen):
# already some PARI lfun
self._L = lfun
else:
# create a PARI lfunction from other input data
self._L = pari.lfuncreate(lfun)
self._conductor = ZZ(self._L[4]) # needs check
self._weight = ZZ(self._L[3]) # needs check
if prec is None:
self.prec = 53
else:
self.prec = PyNumber_Index(prec)
self._RR = RealField(self.prec)
self._CC = ComplexField(self.prec)
# Complex field used for inputs, which ensures exact 1-to-1
# conversion to/from PARI. Since PARI objects have a precision
# in machine words (not bits), this is typically higher. For
# example, the default of 53 bits of precision would become 64.
self._CCin = ComplexField(pari.bitprecision(self._RR(1)))
def zeta_symmetric(s):
r"""
Completed function `\xi(s)` that satisfies
`\xi(s) = \xi(1-s)` and has zeros at the same points as the
Riemann zeta function.
INPUT:
- ``s`` - real or complex number
If s is a real number the computation is done using the MPFR
library. When the input is not real, the computation is done using
the PARI C library.
More precisely,
.. MATH::
xi(s) = \gamma(s/2 + 1) * (s-1) * \pi^{-s/2} * \zeta(s).
EXAMPLES::
sage: zeta_symmetric(0.7)
0.497580414651127
sage: zeta_symmetric(1-0.7)
0.497580414651127
sage: RR = RealField(200)
sage: zeta_symmetric(RR(0.7))
0.49758041465112690357779107525638385212657443284080589766062
sage: C.<i> = ComplexField()
sage: zeta_symmetric(0.5 + i*14.0)
0.000201294444235258 + 1.49077798716757e-19*I
sage: zeta_symmetric(0.5 + i*14.1)
0.0000489893483255687 + 4.40457132572236e-20*I
sage: zeta_symmetric(0.5 + i*14.2)
-0.0000868931282620101 + 7.11507675693612e-20*I
REFERENCE:
- I copied the definition of xi from
http://web.viu.ca/pughg/RiemannZeta/RiemannZetaLong.html
"""
if not (is_ComplexNumber(s) or is_RealNumber(s)):
s = ComplexField()(s)
R = s.parent()
if s == 1: # deal with poles, hopefully
return R(0.5)
return (s / 2 + 1).gamma() * (s - 1) * (R.pi()**(-s / 2)) * s.zeta()
def map_to_complex_numbers(self, z, prec=None):
"""
Evaluate ``self`` at a point `z \in X_0(N)` where `z` is given by
a representative in the upper half plane, returning a point in
the complex numbers.
All computations are done with ``prec`` bits
of precision. If ``prec`` is not given, use the precision of `z`.
Use self(z) to compute the image of z on the Weierstrass equation
of the curve.
EXAMPLES::
sage: E = EllipticCurve('37a'); phi = E.modular_parametrization()
sage: tau = (sqrt(7)*I - 17)/74
sage: z = phi.map_to_complex_numbers(tau); z
0.929592715285395 - 1.22569469099340*I
sage: E.elliptic_exponential(z)
(...e-16 - ...e-16*I : ...e-16 + ...e-16*I : 1.00000000000000)
sage: phi(tau)
(...e-16 - ...e-16*I : ...e-16 + ...e-16*I : 1.00000000000000)
"""
if prec is None:
try:
prec = z.parent().prec()
except AttributeError:
prec = 53
CC = ComplexField(prec)
if z in QQ:
raise NotImplementedError
z = CC(z)
if z.imag() <= 0:
raise ValueError("Point must be in the upper half plane")
# TODO: for very small imaginary part, maybe try to transform under
# \Gamma_0(N) to a better representative?
q = (2 * CC.gen() * CC.pi() * z).exp()
# nterms'th term is less than 2**-(prec+10) (c.f. eclib code)
nterms = (-(prec + 10) / q.abs().log2()).ceil()
# Use Horner's rule to sum the integral of the form
enumerated_an = list(enumerate(self._E.anlist(nterms)))[1:]
lattice_point = 0
for n, an in reversed(enumerated_an):
lattice_point += an / n
lattice_point *= q
return lattice_point
def _evalf_(self, x, y, parent=None, algorithm='mpmath'):
"""
EXAMPLES::
sage: gamma_inc_lower(3,2.)
0.646647167633873
sage: gamma_inc_lower(3,2).n(200)
0.646647167633873081060005050275155...
sage: gamma_inc_lower(0,2.)
+infinity
"""
R = parent or s_parent(x)
# C is the complex version of R
# prec is the precision of R
if R is float:
prec = 53
C = complex
else:
try:
prec = R.precision()
except AttributeError:
prec = 53
try:
C = R.complex_field()
except AttributeError:
C = R
if algorithm == 'pari':
try:
v = ComplexField(prec)(x).gamma() - ComplexField(prec)(
x).gamma_inc(y)
except AttributeError:
if not (is_ComplexNumber(x)):
if is_ComplexNumber(y):
C = y.parent()
else:
C = ComplexField()
x = C(x)
v = ComplexField(prec)(x).gamma() - ComplexField(prec)(
x).gamma_inc(y)
else:
import mpmath
v = ComplexField(prec)(mpmath_utils.call(mpmath.gammainc,
x,
0,
y,
parent=R))
if v.is_real():
return R(v)
else:
return C(v)
def _evalf_(self, x, y, parent=None):
"""
EXAMPLES::
sage: gamma_inc(0,2)
-Ei(-2)
sage: gamma_inc(0,2.)
0.0489005107080611
sage: gamma_inc(3,2).n()
1.35335283236613
"""
try:
return x.gamma_inc(y)
except AttributeError:
if not (is_ComplexNumber(x)):
if is_ComplexNumber(y):
C = y.parent()
else:
C = ComplexField()
x = C(x)
return x.gamma_inc(y)
def _evalf_(self, x, y, parent=None, algorithm='pari'):
"""
EXAMPLES::
sage: gamma_inc(0,2)
-Ei(-2)
sage: gamma_inc(0,2.)
0.0489005107080611
sage: gamma_inc(0,2).n(algorithm='pari')
0.0489005107080611
sage: gamma_inc(0,2).n(200)
0.048900510708061119567239835228...
sage: gamma_inc(3,2).n()
1.35335283236613
TESTS:
Check that :trac:`7099` is fixed::
sage: R = RealField(1024)
sage: gamma(R(9), R(10^-3)) # rel tol 1e-308
40319.99999999999999999999999999988898884344822911869926361916294165058203634104838326009191542490601781777105678829520585311300510347676330951251563007679436243294653538925717144381702105700908686088851362675381239820118402497959018315224423868693918493033078310647199219674433536605771315869983788442389633
sage: numerical_approx(gamma(9, 10^(-3)) - gamma(9), digits=40) # abs tol 1e-36
-1.110111598370794007949063502542063148294e-28
Check that :trac:`17328` is fixed::
sage: gamma_inc(float(-1), float(-1))
(-0.8231640121031085+3.141592653589793j)
sage: gamma_inc(RR(-1), RR(-1))
-0.823164012103109 + 3.14159265358979*I
sage: gamma_inc(-1, float(-log(3))) - gamma_inc(-1, float(-log(2))) # abs tol 1e-15
(1.2730972164471142+0j)
Check that :trac:`17130` is fixed::
sage: r = gamma_inc(float(0), float(1)); r
0.21938393439552029
sage: type(r)
<... 'float'>
"""
R = parent or s_parent(x)
# C is the complex version of R
# prec is the precision of R
if R is float:
prec = 53
C = complex
else:
try:
prec = R.precision()
except AttributeError:
prec = 53
try:
C = R.complex_field()
except AttributeError:
C = R
if algorithm == 'pari':
v = ComplexField(prec)(x).gamma_inc(y)
else:
import mpmath
v = ComplexField(prec)(mpmath_utils.call(mpmath.gammainc,
x,
y,
parent=R))
if v.is_real():
return R(v)
else:
return C(v)
def _coerce_map_from_(self, P):
r"""
Return whether ``P`` coerces into this symbolic subring.
INPUT:
- ``P`` -- a parent.
OUTPUT:
A boolean or ``None``.
TESTS::
sage: from sage.symbolic.subring import GenericSymbolicSubring
sage: GenericSymbolicSubring(vars=tuple()).has_coerce_map_from(SR) # indirect doctest # not tested see #19231
False
::
sage: from sage.symbolic.subring import SymbolicSubring
sage: C = SymbolicSubring(no_variables=True)
sage: C.has_coerce_map_from(ZZ) # indirect doctest
True
sage: C.has_coerce_map_from(QQ) # indirect doctest
True
sage: C.has_coerce_map_from(RR) # indirect doctest
True
sage: C.has_coerce_map_from(RIF) # indirect doctest
True
sage: C.has_coerce_map_from(CC) # indirect doctest
True
sage: C.has_coerce_map_from(CIF) # indirect doctest
True
sage: C.has_coerce_map_from(AA) # indirect doctest
True
sage: C.has_coerce_map_from(QQbar) # indirect doctest
True
sage: C.has_coerce_map_from(SR) # indirect doctest
False
"""
if P == SR:
# Workaround; can be deleted once #19231 is fixed
return False
from sage.rings.real_mpfr import mpfr_prec_min
from sage.rings.all import (ComplexField, RLF, CLF, AA, QQbar,
InfinityRing)
from sage.rings.real_mpfi import is_RealIntervalField
from sage.rings.complex_interval_field import is_ComplexIntervalField
if isinstance(P, type):
return SR._coerce_map_from_(P)
elif RLF.has_coerce_map_from(P) or \
CLF.has_coerce_map_from(P) or \
AA.has_coerce_map_from(P) or \
QQbar.has_coerce_map_from(P):
return True
elif (P is InfinityRing or is_RealIntervalField(P)
or is_ComplexIntervalField(P)):
return True
elif ComplexField(mpfr_prec_min()).has_coerce_map_from(P):
return P not in (RLF, CLF, AA, QQbar)
def hilbert_class_polynomial(D, algorithm=None):
r"""
Return the Hilbert class polynomial for discriminant `D`.
INPUT:
- ``D`` (int) -- a negative integer congruent to 0 or 1 modulo 4.
- ``algorithm`` (string, default None).
OUTPUT:
(integer polynomial) The Hilbert class polynomial for the
discriminant `D`.
ALGORITHM:
- If ``algorithm`` = "arb" (default): Use Arb's implementation which uses complex interval arithmetic.
- If ``algorithm`` = "sage": Use complex approximations to the roots.
- If ``algorithm`` = "magma": Call the appropriate Magma function (if available).
AUTHORS:
- Sage implementation originally by Eduardo Ocampo Alvarez and
AndreyTimofeev
- Sage implementation corrected by John Cremona (using corrected precision bounds from Andreas Enge)
- Magma implementation by David Kohel
EXAMPLES::
sage: hilbert_class_polynomial(-4)
x - 1728
sage: hilbert_class_polynomial(-7)
x + 3375
sage: hilbert_class_polynomial(-23)
x^3 + 3491750*x^2 - 5151296875*x + 12771880859375
sage: hilbert_class_polynomial(-37*4)
x^2 - 39660183801072000*x - 7898242515936467904000000
sage: hilbert_class_polynomial(-37*4, algorithm="magma") # optional - magma
x^2 - 39660183801072000*x - 7898242515936467904000000
sage: hilbert_class_polynomial(-163)
x + 262537412640768000
sage: hilbert_class_polynomial(-163, algorithm="sage")
x + 262537412640768000
sage: hilbert_class_polynomial(-163, algorithm="magma") # optional - magma
x + 262537412640768000
TESTS::
sage: all([hilbert_class_polynomial(d, algorithm="arb") == \
....: hilbert_class_polynomial(d, algorithm="sage") \
....: for d in range(-1,-100,-1) if d%4 in [0,1]])
True
"""
if algorithm is None:
algorithm = "arb"
D = Integer(D)
if D >= 0:
raise ValueError("D (=%s) must be negative" % D)
if not (D % 4 in [0, 1]):
raise ValueError("D (=%s) must be a discriminant" % D)
if algorithm == "arb":
import sage.libs.arb.arith
return sage.libs.arb.arith.hilbert_class_polynomial(D)
if algorithm == "magma":
magma.eval("R<x> := PolynomialRing(IntegerRing())")
f = str(magma.eval("HilbertClassPolynomial(%s)" % D))
return IntegerRing()['x'](f)
if algorithm != "sage":
raise ValueError("%s is not a valid algorithm" % algorithm)
from sage.quadratic_forms.binary_qf import BinaryQF_reduced_representatives
from sage.rings.all import RR, ComplexField
from sage.functions.all import elliptic_j
# get all primitive reduced quadratic forms, (necessary to exclude
# imprimitive forms when D is not a fundamental discriminant):
rqf = BinaryQF_reduced_representatives(D, primitive_only=True)
# compute needed precision
#
# NB: [https://arxiv.org/abs/0802.0979v1], quoting Enge (2006), is
# incorrect. Enge writes (2009-04-20 email to John Cremona) "The
# source is my paper on class polynomials
# [https://hal.inria.fr/inria-00001040] It was pointed out to me by
# the referee after ANTS that the constant given there was
# wrong. The final version contains a corrected constant on p.7
# which is consistent with your example. It says:
# "The logarithm of the absolute value of the coefficient in front
# of X^j is bounded above by
#
# log (2*k_2) * h + pi * sqrt(|D|) * sum (1/A_i)
#
# independently of j", where k_2 \approx 10.163.
h = len(rqf) # class number
c1 = 3.05682737291380 # log(2*10.63)
c2 = sum([1 / RR(qf[0]) for qf in rqf], RR(0))
prec = c2 * RR(3.142) * RR(D).abs().sqrt() + h * c1 # bound on log
prec = prec * 1.45 # bound on log_2 (1/log(2) = 1.44..)
prec = 10 + prec.ceil() # allow for rounding error
# set appropriate precision for further computing
Dsqrt = D.sqrt(prec=prec)
R = ComplexField(prec)['t']
t = R.gen()
pol = R(1)
for qf in rqf:
a, b, c = list(qf)
tau = (b + Dsqrt) / (a << 1)
pol *= (t - elliptic_j(tau))
coeffs = [cof.real().round() for cof in pol.coefficients(sparse=False)]
return IntegerRing()['x'](coeffs)
"""
Complex Elliptic Curve L-series
"""
from sage.structure.sage_object import SageObject
from sage.rings.all import (RealField, RationalField, ComplexField)
from math import sqrt, exp, ceil
import sage.functions.transcendental as transcendental
R = RealField()
Q = RationalField()
C = ComplexField()
import sage.misc.all as misc
class Lseries_ell(SageObject):
"""
An elliptic curve $L$-series.
EXAMPLES:
"""
def __init__(self, E):
"""
Create an elliptic curve $L$-series.
EXAMPLES:
sage: EllipticCurve([1..5]).lseries()
Complex L-series of the Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over Rational Field
"""
self.__E = E
