def zeta_zeros():
r"""
List of the imaginary parts of the first 2,001,052 zeros of the
Riemann zeta function, accurate to within 4e-9.
In order to use ``zeta_zeros()``, you will need to
install the optional Odlyzko database package::
sage -i database_odlyzko_zeta
You can see a list of all available optional packages with
``sage --optional``.
REFERENCES:
- http://www.dtc.umn.edu/~odlyzko/zeta_tables/index.html
EXAMPLES:
The following example prints the imaginary part of the 13th
nontrivial zero of the Riemann zeta function::
sage: zz = zeta_zeros() # optional - database_odlyzko_zeta
sage: zz[12] # optional - database_odlyzko_zeta
59.347044003
sage: len(zz) # optional - database_odlyzko_zeta
2001052
"""
sobj = os.path.join(SAGE_SHARE, 'odlyzko', 'zeros.sobj')
verbose("Loading Odlyzko database from " + sobj)
return load(sobj)
def derivative(self, s, k=1):
r"""
Return the `k`-th derivative of the `L`-series at
`s`.
.. warning::
If `k` is greater than the order of vanishing of
`L` at `s` you may get nonsense.
EXAMPLES::
sage: E = EllipticCurve('389a')
sage: L = E.lseries().dokchitser()
sage: L.derivative(1,E.rank())
1.51863300057685
"""
self.__check_init()
s = self.__CC(s)
k = Integer(k)
z = self.gp().eval('L(%s,,%s)'%(s,k))
if 'pole' in z:
raise ArithmeticError(z)
elif 'Warning' in z:
i = z.rfind('\n')
msg = z[:i].replace('digits','decimal digits')
verbose(msg, level=-1)
return self.__CC(z[i:])
return self.__CC(z)
def cuspidal_submodule_q_expansion_basis(self, weight, prec=None):
r"""
Calculate a basis of `q`-expansions for the space of cusp forms of
weight ``weight`` for this group.
INPUT:
- ``weight`` (integer) -- the weight
- ``prec`` (integer or None) -- precision of `q`-expansions to return
ALGORITHM: Uses the method :meth:`cuspidal_ideal_generators` to
calculate generators of the ideal of cusp forms inside this ring. Then
multiply these up to weight ``weight`` using the generators of the
whole modular form space returned by :meth:`q_expansion_basis`.
EXAMPLES::
sage: R = ModularFormsRing(Gamma0(3))
sage: R.cuspidal_submodule_q_expansion_basis(20)
[q - 8532*q^6 - 88442*q^7 + O(q^8), q^2 + 207*q^6 + 24516*q^7 + O(q^8), q^3 + 456*q^6 + O(q^8), q^4 - 135*q^6 - 926*q^7 + O(q^8), q^5 + 18*q^6 + 135*q^7 + O(q^8)]
We compute a basis of a space of very large weight, quickly (using this
module) and slowly (using modular symbols), and verify that the answers
are the same. ::
sage: A = R.cuspidal_submodule_q_expansion_basis(80, prec=30) # long time (1s on sage.math, 2013)
sage: B = R.modular_forms_of_weight(80).cuspidal_submodule().q_expansion_basis(prec=30) # long time (19s on sage.math, 2013)
sage: A == B # long time
True
"""
d = self.modular_forms_of_weight(weight).cuspidal_submodule().dimension()
if d == 0: return []
minprec = self.modular_forms_of_weight(weight).sturm_bound()
if prec is None:
prec = working_prec = minprec
else:
working_prec = max(prec, minprec)
gen_weight = min(6, weight)
while True:
verbose("Trying to generate the %s-dimensional cuspidal submodule at weight %s using generators of weight up to %s" % (d, weight, gen_weight))
G = self.cuspidal_ideal_generators(maxweight=gen_weight, prec=working_prec)
flist = []
for (j, f, F) in G:
for g in self.q_expansion_basis(weight - j, prec=working_prec):
flist.append(g*f)
A = self.base_ring() ** working_prec
W = A.span([A(f.padded_list(working_prec)) for f in flist])
if W.rank() == d and (self.base_ring().is_field() or W.index_in_saturation() == 1):
break
else:
gen_weight += 1
verbose("Need more generators: trying again with generators of weight up to %s" % gen_weight)
R = G[0][1].parent()
return [R(list(x), prec=prec) for x in W.gens()]
def taylor_series(self, a=0, k=6, var='z'):
r"""
Return the first `k` terms of the Taylor series expansion
of the `L`-series about `a`.
This is returned as a series in ``var``, where you
should view ``var`` as equal to `s-a`. Thus
this function returns the formal power series whose coefficients
are `L^{(n)}(a)/n!`.
INPUT:
- ``a`` -- complex number (default: 0); point about
which to expand
- ``k`` -- integer (default: 6), series is
`O(``var``^k)`
- ``var`` -- string (default: 'z'), variable of power
series
EXAMPLES::
sage: L = Dokchitser(conductor=1, gammaV=[0], weight=1, eps=1, poles=[1], residues=[-1], init='1')
sage: L.taylor_series(2, 3)
1.64493406684823 - 0.937548254315844*z + 0.994640117149451*z^2 + O(z^3)
sage: E = EllipticCurve('37a')
sage: L = E.lseries().dokchitser()
sage: L.taylor_series(1)
0.000000000000000 + 0.305999773834052*z + 0.186547797268162*z^2 - 0.136791463097188*z^3 + 0.0161066468496401*z^4 + 0.0185955175398802*z^5 + O(z^6)
We compute a Taylor series where each coefficient is to high
precision. ::
sage: E = EllipticCurve('389a')
sage: L = E.lseries().dokchitser(200)
sage: L.taylor_series(1,3)
-9.094...e-82 + (5.1538...e-82)*z + 0.75931650028842677023019260789472201907809751649492435158581*z^2 + O(z^3)
"""
self.__check_init()
a = self.__CC(a)
k = Integer(k)
try:
z = self._gp_call_inst('Lseries', a, '', k - 1)
z = self.gp()('Vec(%s)' % z)
except TypeError as msg:
raise RuntimeError("%s\nUnable to compute Taylor expansion (try lowering the number of terms)" % msg)
r = repr(z)
if 'pole' in r:
raise ArithmeticError(r)
elif 'Warning' in r:
i = r.rfind('\n')
msg = r[:i].replace('digits', 'decimal digits')
verbose(msg, level=-1)
v = list(z)
K = self.__CC
v = [K(repr(x)) for x in v]
R = self.__CC[[var]]
return R(v, len(v))
def __call__(self, args):
"""
Used to call sympow with given args
"""
cmd = "sympow %s" % args
v = os.popen(cmd).read().strip()
verbose(v, level=2)
return v
def _delta_poly(prec=10):
"""
Return the q-expansion of Delta as a FLINT polynomial. Used internally by
the :func:`~delta_qexp` function. See the docstring of :func:`~delta_qexp`
for more information.
INPUT:
- ``prec`` -- integer; the absolute precision of the output
OUTPUT:
the q-expansion of Delta to precision ``prec``, as a FLINT
:class:`~sage.libs.flint.fmpz_poly.Fmpz_poly` object.
EXAMPLES::
sage: from sage.modular.modform.vm_basis import _delta_poly
sage: _delta_poly(7)
7 0 1 -24 252 -1472 4830 -6048
"""
if prec <= 0:
raise ValueError("prec must be positive")
v = [0] * prec
# Let F = \sum_{n >= 0} (-1)^n (2n+1) q^(floor(n(n+1)/2)).
# Then delta is F^8.
# First compute F^2 directly by naive polynomial multiplication,
# since F is very sparse.
stop = int((-1+math.sqrt(1+8*prec))/2.0)
# make list of index/value pairs for the sparse poly
values = [(n*(n+1)//2, ((-2*n-1) if (n & 1) else (2*n+1))) \
for n in xrange(stop+1)]
for (i1, v1) in values:
for (i2, v2) in values:
try:
v[i1 + i2] += v1 * v2
except IndexError:
break
f = Fmpz_poly(v)
t = verbose('made series')
f = f*f
f._unsafe_mutate_truncate(prec)
t = verbose('squared (2 of 3)', t)
f = f*f
f._unsafe_mutate_truncate(prec - 1)
t = verbose('squared (3 of 3)', t)
f = f.left_shift(1)
t = verbose('shifted', t)
return f
def _delta_poly_modulo(N, prec=10):
"""
Return the q-expansion of `\Delta` modulo `N`. Used internally by
the :func:`~delta_qexp` function. See the docstring of :func:`~delta_qexp`
for more information.
INPUT:
- `N` -- positive integer modulo which we want to compute `\Delta`
- ``prec`` -- integer; the absolute precision of the output
OUTPUT:
the polynomial of degree ``prec``-1 which is the truncation
of `\Delta` modulo `N`, as an element of the polynomial
ring in `q` over the integers modulo `N`.
EXAMPLES::
sage: from sage.modular.modform.vm_basis import _delta_poly_modulo
sage: _delta_poly_modulo(5, 7)
2*q^6 + 3*q^4 + 2*q^3 + q^2 + q
sage: _delta_poly_modulo(10, 12)
2*q^11 + 7*q^9 + 6*q^7 + 2*q^6 + 8*q^4 + 2*q^3 + 6*q^2 + q
"""
if prec <= 0:
raise ValueError( "prec must be positive" )
v = [0] * prec
# Let F = \sum_{n >= 0} (-1)^n (2n+1) q^(floor(n(n+1)/2)).
# Then delta is F^8.
stop = int((-1+math.sqrt(8*prec))/2.0)
for n in xrange(stop+1):
v[n*(n+1)//2] = ((N-1)*(2*n+1) if (n & 1) else (2*n+1))
from sage.rings.all import Integers
P = PolynomialRing(Integers(N), 'q')
f = P(v)
t = verbose('made series')
# fast way of computing f*f truncated at prec
f = f._mul_trunc(f, prec)
t = verbose('squared (1 of 3)', t)
f = f._mul_trunc(f, prec)
t = verbose('squared (2 of 3)', t)
f = f._mul_trunc(f, prec - 1)
t = verbose('squared (3 of 3)', t)
f = f.shift(1)
t = verbose('shifted', t)
return f
def load(self):
"""
Load the entire encyclopedia into memory from a file. This is done
automatically if the user tries to perform a lookup or a search.
"""
if self.__loaded__ == True:
return
try:
file_seq = bz2.BZ2File(self.__file__, "r")
except IOError:
raise IOError(
"The Sloane Encyclopedia database must be installed. Use e.g. 'SloaneEncyclopedia.install()' to download and install it."
)
self.__data__ = {}
tm = verbose("Loading Sloane encyclopedia from disk")
entry = re.compile(r"A(?P<num>\d{6}) ,(?P<body>.*),$")
for L in file_seq:
if len(L) == 0:
continue
m = entry.search(L)
if m:
seqnum = int(m.group("num"))
msg = m.group("body").strip()
self.__data__[seqnum] = [seqnum, None, "," + msg + ",", None]
file_seq.close()
try:
file_names = bz2.BZ2File(self.__file_names__, "r")
entry = re.compile(r"A(?P<num>\d{6}) (?P<body>.*)$")
for L in file_names:
if len(L) == 0:
continue
m = entry.search(L)
if m:
seqnum = int(m.group("num"))
self.__data__[seqnum][3] = m.group("body").strip()
file_names.close()
self.__loaded_names__ = True
except KeyError:
### Some sequence in the names file isn't in the database
raise KeyError(
"Sloane OEIS sequence and name files do not match. Try reinstalling, e.g. SloaneEncyclopedia.install(overwrite=True)."
)
except IOError as msg:
### The names database is not installed
self.__loaded_names__ = False
verbose("Finished loading", tm)
self.__loaded__ = True
def install(self, oeis_url="http://oeis.org/stripped.gz", names_url="http://oeis.org/names.gz", overwrite=False):
"""
Download and install the online encyclopedia, raising an IOError if
either step fails.
INPUT:
- ``oeis_url`` - string (default: "http://oeis.org...")
The URL of the stripped.gz encyclopedia file.
- ``names_url`` - string (default: "http://oeis.org...")
The URL of the names.gz encyclopedia file. If you do not want to
download this file, set names_url=None.
- ``overwrite`` - boolean (default: False) If the encyclopedia is
already installed and overwrite=True, download and install the latest
version over the installed one.
"""
### See if the encyclopedia already exists
if not overwrite and os.path.exists(self.__file__):
raise IOError("Sloane encyclopedia is already installed")
tm = verbose("Downloading stripped version of Sloane encyclopedia")
try:
fname, _ = urllib.urlretrieve(oeis_url)
except IOError as msg:
raise IOError(
"%s\nError fetching the following website:\n %s\nTry checking your internet connection."
% (msg, oeis_url)
)
if not names_url is None:
try:
nname, _ = urllib.urlretrieve(names_url)
except IOError as msg:
raise IOError(
"%s\nError fetching the following website:\n %s\nTry checking your internet connection."
% (msg, names_url)
)
else:
nname = None
verbose("Finished downloading", tm)
self.install_from_gz(fname, nname, overwrite)
# Delete the temporary downloaded files
os.remove(fname)
if not nname is None:
os.remove(nname)
def install(self, oeis_url="http://oeis.org/classic/stripped.gz", names_url="http://oeis.org/classic/names.gz", overwrite=False):
"""
Download and install the online encyclopedia, raising an IOError if
either step fails.
INPUT:
- ``oeis_url`` - string (default: "http://www.research.att.com...")
The URL of the stripped.gz encyclopedia file.
- ``names_url`` - string (default: "http://www.research.att.com...")
The URL of the names.gz encyclopedia file. If you do not want to
download this file, set names_url=None.
- ``overwrite`` - boolean (default: False) If the encyclopedia is
already installed and overwrite=True, download and install the latest
version over the installed one.
"""
### See if the encyclopedia already exists
if not overwrite and os.path.exists(self.__file__):
raise IOError, "Sloane encyclopedia is already installed"
tm = verbose("Downloading stripped version of Sloane encyclopedia")
try:
fname, _ = urllib.urlretrieve(oeis_url);
except IOError, msg:
raise IOError, "%s\nError fetching the following website:\n %s\nTry checking your internet connection."%(msg, oeis_url)
def __scale_by_periods_only__(self):
r"""
If we fail to scale with ``_find_scaling_L_ratio``, we drop here
to try and find the scaling by the quotient of the
periods to the `X_0`-optimal curve. The resulting ``_scaling``
is not guaranteed to be correct, but could well be.
EXAMPLES::
sage: E = EllipticCurve('19a1')
sage: m = E.modular_symbol(sign=+1)
sage: m.__scale_by_periods_only__()
Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1, 2 or -2.
sage: m._scaling
1
sage: E = EllipticCurve('19a2')
sage: m = E.modular_symbol(sign=+1)
sage: m._scaling
3/2
sage: m.__scale_by_periods_only__()
Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1, 2 or -2.
sage: m._scaling
3
"""
# we only do this inside the cremona-tables.
try :
crla = parse_cremona_label(self._E.label())
except RuntimeError: # raised when curve is outside of the table
print("Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by a rational number.")
self._scaling = 1
else :
print("Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1, 2 or -2.")
cr0 = Integer(crla[0]).str() + crla[1] + '1'
E0 = EllipticCurve(cr0)
if self._sign == 1:
q = E0.period_lattice().basis()[0]/self._E.period_lattice().basis()[0]
else:
q = E0.period_lattice().basis()[1].imag()/self._E.period_lattice().basis()[1].imag()
if E0.real_components() == 1:
q *= 2
if self._E.real_components() == 1:
q /= 2
q = ZZ(int(round(q*200)))/200
verbose('scale modular symbols by %s'%q)
self._scaling = q
def _find_scaling_period(self):
r"""
Uses the integral period map of the modular symbol implementation in sage
in order to determine the scaling. The resulting modular symbol is correct
only for the `X_0`-optimal curve, at least up to a possible factor +-1 or +-2.
EXAMPLES::
sage: E = EllipticCurve('11a1')
sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
sage: m._e
(1/5, 1)
sage: E = EllipticCurve('11a2')
sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
sage: m._e
(1, 5)
sage: E = EllipticCurve('121b2')
sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
sage: m._e
(0, 11/2, 0, 11/2, 11/2, 0, 0, -3, 2, 1/2, -1, 3/2)
"""
P = self._modsym.integral_period_mapping()
self._e = P.matrix().transpose().row(0)
self._e /= 2
E = self._E
try :
crla = parse_cremona_label(E.label())
except RuntimeError: # raised when curve is outside of the table
self._scaling = 1
else :
cr0 = Integer(crla[0]).str() + crla[1] + '1'
E0 = EllipticCurve(cr0)
if self._sign == 1:
q = E0.period_lattice().basis()[0]/E.period_lattice().basis()[0]
else:
q = E0.period_lattice().basis()[1].imag()/E.period_lattice().basis()[1].imag()
if E0.real_components() == 1:
q *= 2
if E.real_components() == 1:
q /= 2
q = QQ(int(round(q*200)))/200
verbose('scale modular symbols by %s'%q)
self._scaling = q
self._e *= self._scaling
def __call__(self, s, c=None):
r"""
INPUT:
- ``s`` - complex number
.. note::
Evaluation of the function takes a long time, so each
evaluation is cached. Call ``self._clear_value_cache()`` to
clear the evaluation cache.
EXAMPLES::
sage: E = EllipticCurve('5077a')
sage: L = E.lseries().dokchitser(100)
sage: L(1)
0.00000000000000000000000000000
sage: L(1+I)
-1.3085436607849493358323930438 + 0.81298000036784359634835412129*I
"""
self.__check_init()
s = self.__CC(s)
try:
return self.__values[s]
except AttributeError:
self.__values = {}
except KeyError:
pass
z = self.gp().eval('L(%s)'%s)
if 'pole' in z:
print(z)
raise ArithmeticError
elif '***' in z:
print(z)
raise RuntimeError
elif 'Warning' in z:
i = z.rfind('\n')
msg = z[:i].replace('digits','decimal digits')
verbose(msg, level=-1)
ans = self.__to_CC(z[i+1:])
self.__values[s] = ans
return ans
ans = self.__to_CC(z)
self.__values[s] = ans
return ans
def new_decomposition(self):
"""
Return complete irreducible Hecke decomposition of "new"
subspace of self.
OUTPUT:
- sorted Sequence of subspaces of self
EXAMPLES::
sage: from sage.modular.hilbert.sqrt5_hmf import F, QuaternionicModule
sage: H = QuaternionicModule(3 * F.prime_above(31)); H
Quaternionic module of dimension 6, level 15*a-6 (of norm 279=3^2*31) over QQ(sqrt(5))
sage: H.new_decomposition()
[
Subspace of dimension 1 ...,
Subspace of dimension 1 ...,
Subspace of dimension 1 ...,
Subspace of dimension 1 ...
]
"""
V = self.degeneracy_matrix().kernel()
primes = PrimesCoprimeTo(self.level())
p = primes.next()
T = self.hecke_matrix(p)
D = T.decomposition_of_subspace(V)
while len([X for X in D if not X[1]]) > 0:
p = primes.next()
verbose('Norm(p) = %s'%p.norm())
T = self.hecke_matrix(p)
D2 = []
for X in D:
if X[1]:
D2.append(X)
else:
for Z in T.decomposition_of_subspace(X[0]):
D2.append(Z)
D = D2
D = [self.subspace(X[0]) for X in D]
D.sort()
S = Sequence(D, immutable=True, cr=True, universe=int, check=False)
return S
def __lalg__(self,D):
r"""
For positive `D`, this function evaluates the quotient
`L(E_D,1)\cdot \sqrt(D)/\Omega_E` where `E_D` is the twist of
`E` by `D`, `\Omega_E` is the least positive period of `E`.
For negative `E`, it is the quotient
`L(E_D,1)\cdot \sqrt(-D)/\Omega^{-}_E`
where `\Omega^{-}_E` is the least positive imaginary part of a
non-real period of `E`.
EXAMPLES::
sage: E = EllipticCurve('11a1')
sage: m = E.modular_symbol(sign=+1, implementation='sage')
sage: m.__lalg__(1)
1/5
sage: m.__lalg__(3)
5/2
"""
from sage.functions.all import sqrt
# the computation of the L-value could take a lot of time,
# but then the conductor is so large
# that the computation of modular symbols for E took even longer
E = self._E
ED = E.quadratic_twist(D)
lv = ED.lseries().L_ratio() # this is L(ED,1) divided by the Néron period omD of ED
lv *= ED.real_components() # now it is by the least positive period
omD = ED.period_lattice().basis()[0]
if D > 0 :
om = E.period_lattice().basis()[0]
q = sqrt(D)*omD/om * 8
else :
om = E.period_lattice().basis()[1].imag()
if E.real_components() == 1:
om *= 2
q = sqrt(-D)*omD/om*8
# see padic_lseries.pAdicLeries._quotient_of_periods_to_twist
# for the explanation of the second factor
verbose('real approximation is %s'%q)
return lv/8 * QQ(int(round(q)))
def __init__(self, ambient_space):
"""
Return the Eisenstein submodule of the given space.
EXAMPLES::
sage: E = ModularForms(23,4).eisenstein_subspace() ## indirect doctest
sage: E
Eisenstein subspace of dimension 2 of Modular Forms space of dimension 7 for Congruence Subgroup Gamma0(23) of weight 4 over Rational Field
sage: E == loads(dumps(E))
True
"""
verbose('creating eisenstein submodule of %s'%ambient_space)
d = ambient_space._dim_eisenstein()
V = ambient_space.module()
n = V.dimension()
self._start_position = int(n - d)
S = V.submodule([V.gen(i) for i in range(n-d,n)], check=False,
already_echelonized=True)
submodule.ModularFormsSubmodule.__init__(self, ambient_space, S)
def __init__(self, ambient_space):
"""
The cuspidal submodule of an ambient space of modular forms.
EXAMPLES::
sage: S = CuspForms(SL2Z,12); S
Cuspidal subspace of dimension 1 of Modular Forms space of dimension 2 for
Modular Group SL(2,Z) of weight 12 over Rational Field
sage: S.basis()
[
q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 + O(q^6)
]
sage: S = CuspForms(Gamma0(33),2); S
Cuspidal subspace of dimension 3 of Modular Forms space of dimension 6 for
Congruence Subgroup Gamma0(33) of weight 2 over Rational Field
sage: S.basis()
[
q - q^5 + O(q^6),
q^2 - q^4 - q^5 + O(q^6),
q^3 + O(q^6)
]
sage: S = CuspForms(Gamma1(3),6); S
Cuspidal subspace of dimension 1 of Modular Forms space of dimension 3 for
Congruence Subgroup Gamma1(3) of weight 6 over Rational Field
sage: S.basis()
[
q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6)
]
sage: S == loads(dumps(S))
True
"""
verbose("creating cuspidal submodule of %s" % ambient_space)
d = ambient_space._dim_cuspidal()
V = ambient_space.module()
G = [V.gen(i) for i in range(d)]
S = V.submodule(G, check=False, already_echelonized=True)
submodule.ModularFormsSubmodule.__init__(self, ambient_space, S)
def zeta_zeros():
r"""
List of the imaginary parts of the first 100,000 nontrivial zeros
of the Riemann zeta function. Andrew Odlyzko computed these to
precision within `3\cdot 10^{-9}`.
In order to use ``zeta_zeros()``, you will need to
install the optional Odlyzko database package: ``sage -i
database_odlyzko_zeta``. You can see a list of all
available optional packages with ``sage --optional``.
REFERENCES:
- http://www.dtc.umn.edu/~odlyzko/zeta_tables/
EXAMPLES:
The following example prints the imaginary part of the 13th
nontrivial zero of the Riemann zeta function. Note that only the
first 9 digits after the decimal come from the database. Subsequent
digits are the result of the inherent imprecision of a binary
representation of decimal numbers.
::
sage: zz = zeta_zeros() # optional - database_odlyzko_zeta
sage: zz[12] # optional - database_odlyzko_zeta
59.347044003...
"""
path = os.path.join(SAGE_SHARE,'odlyzko')
file = os.path.join(path,'zeros1')
if os.path.exists(file+".pickle"):
verbose("Loading Odlyzko database from " + file + ".pickle")
return db.load(file+".pickle")
verbose("Creating Odlyzko Database.")
F = [eval(x) for x in open(file).read().split()]
db.save(F, file+".pickle")
return F
def _quotient_of_periods_to_twist(self,D):
r"""
For a fundamental discriminant `D` of a quadratic number field
this computes the constant `\eta` such that
`\sqrt{D}\cdot\Omega_{E_D}^{+} =\eta\cdot
\Omega_E^{sign(D)}`. As in [MTT]_ page 40. This is either 1
or 2 unless the condition on the twist is not satisfied,
e.g. if we are 'twisting back' to a semi-stable curve.
REFERENCES:
- [MTT] B. Mazur, J. Tate, and J. Teitelbaum,
On `p`-adic analogues of the conjectures of Birch and
Swinnerton-Dyer, Invertiones mathematicae 84, (1986), 1-48.
.. note: No check on precision is made, so this may fail for huge `D`.
EXAMPLES::
"""
from sage.functions.all import sqrt
# This funciton does not depend on p and could be moved out of this file but it is needed only here
# Note that the number of real components does not change by twisting.
if D == 1:
return 1
if D > 1:
Et = self._E.quadratic_twist(D)
qt = Et.period_lattice().basis()[0]/self._E.period_lattice().basis()[0]
qt *= sqrt(qt.parent()(D))
else:
Et = self._E.quadratic_twist(D)
qt = Et.period_lattice().basis()[0]/self._E.period_lattice().basis()[1].imag()
qt *= sqrt(qt.parent()(-D))
verbose('the real approximation is %s'%qt)
# we know from MTT that the result has a denominator 1
return QQ(int(round(8*qt)))/8
def _find_generators(self, maxweight, start_gens, start_weight):
r"""
For internal use. This function is called by :meth:`generators` and
:meth:`gen_forms`: it returns a list of triples `(k, f, F)` where `F`
is a modular form of weight `k` and `f` is its `q`-expansion coerced
into the base ring of self.
INPUT:
- maxweight: maximum weight to try
- start_weight: minimum weight to try
- start_gens: a sequence of tuples of the form `(k, f, F)`, where `F` is a
modular form of weight `k` and `f` is its `q`-expansion coerced into
``self.base_ring()`. Either (but not both) of `f` and `F` may be
None.
OUTPUT:
a list of tuples, formatted as with ``start_gens``.
EXAMPLES::
sage: R = ModularFormsRing(Gamma1(4))
sage: R._find_generators(8, (), 2)
[(2, 1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^9), 1 + 24*q^2 + 24*q^4 + O(q^6)), (2, q + 4*q^3 + 6*q^5 + 8*q^7 + O(q^9), q + 4*q^3 + 6*q^5 + O(q^6)), (3, 1 + 12*q^2 + 64*q^3 + 60*q^4 + 160*q^6 + 384*q^7 + 252*q^8 + O(q^9), 1 + 12*q^2 + 64*q^3 + 60*q^4 + O(q^6)), (3, q + 4*q^2 + 8*q^3 + 16*q^4 + 26*q^5 + 32*q^6 + 48*q^7 + 64*q^8 + O(q^9), q + 4*q^2 + 8*q^3 + 16*q^4 + 26*q^5 + O(q^6))]
"""
default_params = (start_gens == () and start_weight == 2)
if default_params and self.__cached_maxweight != -1:
verbose("Already know generators up to weight %s -- using those" %
self.__cached_maxweight)
if self.__cached_maxweight >= maxweight:
return [(k, f, F) for k, f, F in self.__cached_gens
if k <= maxweight]
start_gens = self.__cached_gens
start_weight = self.__cached_maxweight + 1
if self.group().is_even():
increment = 2
else:
increment = 1
working_prec = self.modular_forms_of_weight(maxweight).sturm_bound()
# parse the list of start gens
G = []
for x in start_gens:
k, f, F = x
if F is None and f.prec() < working_prec:
raise ValueError("Need start gens to precision at least %s" %
working_prec)
elif f is None or f.prec() < working_prec:
f = F.qexp(working_prec).change_ring(self.base_ring())
G.append((k, f, F))
k = start_weight
if increment == 2 and (k % 2) == 1: k += 1
while k <= maxweight:
if self.modular_forms_of_weight(k).dimension() == 0:
k += increment
continue
verbose('Looking at k = %s' % k)
M = self.modular_forms_of_weight(k)
# 1. Multiply together all forms in G that give an element
# of M.
if G != []:
F = _span_of_forms_in_weight(G, k, M.sturm_bound(), None,
False)
else:
F = (self.base_ring()**M.sturm_bound()).zero_submodule()
# 2. If the dimension of the span of the result is equal
# to the dimension of M, increment k.
if F.rank() == M.dimension():
if self.base_ring().is_field() or F.index_in_saturation() == 1:
# TODO: Do something clever if the submodule's of the right
# rank but not saturated -- avoid triggering needless
# modular symbol computations.
verbose('Nothing new in weight %s' % k)
k += increment
continue
# 3. If the dimension is less, compute a basis for G, and
# try adding basis elements of M into G.
verbose(
"Known generators span a subspace of dimension %s of space of dimension %s"
% (F.dimension(), M.dimension()))
if self.base_ring() == ZZ:
verbose("saturation index is %s" % F.index_in_saturation())
t = verbose("Computing more modular forms at weight %s" % k)
kprec = M.sturm_bound()
if self.base_ring() == QQ:
B = M.q_echelon_basis(working_prec)
else:
B = M.q_integral_basis(working_prec)
t = verbose("done computing forms", t)
V = F.ambient_module().submodule_with_basis(
[f.padded_list(kprec) for f in B])
Q = V / F
for q in Q.gens():
try:
qc = V.coordinates(Q.lift(q))
except AttributeError:
# work around a silly free module bug
qc = V.coordinates(q.lift())
qcZZ = [ZZ(_) for _ in qc] # lift to ZZ so we can define F
f = sum([B[i] * qcZZ[i] for i in range(len(B))])
F = M(f)
G.append((k, f.change_ring(self.base_ring()), F))
verbose('added %s new generators' % Q.ngens(), t)
k += increment
if default_params:
self.__cached_maxweight = maxweight
self.__cached_gens = G
return G
def cuspidal_ideal_generators(self, maxweight=8, prec=None):
r"""
Calculate generators for the ideal of cuspidal forms in this ring, as a
module over the whole ring.
EXAMPLES::
sage: ModularFormsRing(Gamma0(3)).cuspidal_ideal_generators(maxweight=12)
[(6, q - 6*q^2 + 9*q^3 + 4*q^4 + O(q^5), q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6))]
sage: [k for k,f,F in ModularFormsRing(13, base_ring=ZZ).cuspidal_ideal_generators(maxweight=14)]
[4, 4, 4, 6, 6, 12]
"""
working_prec = self.modular_forms_of_weight(maxweight).sturm_bound()
if self.__cached_cusp_maxweight > -1:
k = self.__cached_cusp_maxweight + 1
verbose("Already calculated cusp gens up to weight %s -- using those" % (k-1))
# we may need to increase the precision of the cached cusp
# generators
G = []
for j,f,F in self.__cached_cusp_gens:
if f.prec() >= working_prec:
f = F.qexp(working_prec).change_ring(self.base_ring())
G.append( (j,f,F) )
else:
k = 2
G = []
while k <= maxweight:
t = verbose("Looking for cusp generators in weight %s" % k)
kprec = self.modular_forms_of_weight(k).sturm_bound()
flist = []
for (j, f, F) in G:
for g in self.q_expansion_basis(k - j, prec=kprec):
flist.append(g*f)
A = self.base_ring() ** kprec
W = A.span([A(f.padded_list(kprec)) for f in flist])
S = self.modular_forms_of_weight(k).cuspidal_submodule()
if (W.rank() == S.dimension()
and (self.base_ring().is_field() or W.index_in_saturation() == 1)):
verbose("Nothing new in weight %s" % k, t)
k += 1
continue
t = verbose("Known cusp generators span a submodule of dimension %s of space of dimension %s" % (W.rank(), S.dimension()), t)
B = S.q_integral_basis(prec=working_prec)
V = A.span([A(f.change_ring(self.base_ring()).padded_list(kprec)) for f in B])
Q = V/W
for q in Q.gens():
try:
qc = V.coordinates(Q.lift(q))
except AttributeError:
# work around a silly free module bug
qc = V.coordinates(q.lift())
qcZZ = [ZZ(_) for _ in qc] # lift to ZZ so we can define F
f = sum([B[i] * qcZZ[i] for i in range(len(B))])
F = S(f)
G.append((k, f.change_ring(self.base_ring()), F))
verbose('added %s new generators' % Q.ngens(), t)
k += 1
self.__cached_cusp_maxweight = maxweight
self.__cached_cusp_gens = G
if prec is None:
return G
elif prec <= working_prec:
return [ (k, f.truncate_powerseries(prec), F) for k,f,F in G]
else:
# user wants increased precision, so we may as well cache that
Gnew = [ (k, F.qexp(prec).change_ring(self.base_ring()), F) for k,f,F in G]
self.__cached_cusp_gens = Gnew
return Gnew
def q_expansion_basis(self, weight, prec=None, use_random=True):
r"""
Calculate a basis of q-expansions for the space of modular forms of the
given weight for this group, calculated using the ring generators given
by ``find_generators``.
INPUT:
- ``weight`` (integer) -- the weight
- ``prec`` (integer or ``None``, default: ``None``) -- power series
precision. If ``None``, the precision defaults to the Sturm bound for
the requested level and weight.
- ``use_random`` (boolean, default: True) -- whether or not to use a
randomized algorithm when building up the space of forms at the given
weight from known generators of small weight.
EXAMPLES::
sage: m = ModularFormsRing(Gamma0(4))
sage: m.q_expansion_basis(2,10)
[1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^10),
q + 4*q^3 + 6*q^5 + 8*q^7 + 13*q^9 + O(q^10)]
sage: m.q_expansion_basis(3,10)
[]
sage: X = ModularFormsRing(SL2Z)
sage: X.q_expansion_basis(12, 10)
[1 + 196560*q^2 + 16773120*q^3 + 398034000*q^4 + 4629381120*q^5 + 34417656000*q^6 + 187489935360*q^7 + 814879774800*q^8 + 2975551488000*q^9 + O(q^10),
q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + 84480*q^8 - 113643*q^9 + O(q^10)]
We calculate a basis of a massive modular forms space, in two ways.
Using this module is about twice as fast as Sage's generic code. ::
sage: A = ModularFormsRing(11).q_expansion_basis(30, prec=40) # long time (5s)
sage: B = ModularForms(Gamma0(11), 30).q_echelon_basis(prec=40) # long time (9s)
sage: A == B # long time
True
Check that absurdly small values of ``prec`` don't mess things up::
sage: ModularFormsRing(11).q_expansion_basis(10, prec=5)
[1 + O(q^5), q + O(q^5), q^2 + O(q^5), q^3 + O(q^5), q^4 + O(q^5), O(q^5), O(q^5), O(q^5), O(q^5), O(q^5)]
"""
d = self.modular_forms_of_weight(weight).dimension()
if d == 0: return []
if prec is None:
prec=self.modular_forms_of_weight(weight).sturm_bound()
working_prec = max(prec, self.modular_forms_of_weight(weight).sturm_bound())
gen_weight = min(6, weight)
while True:
verbose("Trying to generate the %s-dimensional space at weight %s using generators of weight up to %s" % (d, weight, gen_weight))
G = self.generators(maxweight=gen_weight, prec=working_prec)
V = _span_of_forms_in_weight(G, weight, prec=working_prec, use_random=use_random, stop_dim=d)
if V.rank() == d and (self.base_ring().is_field() or V.index_in_saturation() == 1):
break
else:
gen_weight += 1
verbose("Need more generators: trying again with generators of weight up to %s" % gen_weight)
R = G[0][1].parent()
return [R(list(x), prec=prec) for x in V.gens()]
def _find_generators(self, maxweight, start_gens, start_weight):
r"""
For internal use. This function is called by :meth:`generators` and
:meth:`gen_forms`: it returns a list of triples `(k, f, F)` where `F`
is a modular form of weight `k` and `f` is its `q`-expansion coerced
into the base ring of self.
INPUT:
- maxweight: maximum weight to try
- start_weight: minimum weight to try
- start_gens: a sequence of tuples of the form `(k, f, F)`, where `F` is a
modular form of weight `k` and `f` is its `q`-expansion coerced into
``self.base_ring()`. Either (but not both) of `f` and `F` may be
None.
OUTPUT:
a list of tuples, formatted as with ``start_gens``.
EXAMPLES::
sage: R = ModularFormsRing(Gamma1(4))
sage: R._find_generators(8, (), 2)
[(2, 1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^9), 1 + 24*q^2 + 24*q^4 + O(q^6)), (2, q + 4*q^3 + 6*q^5 + 8*q^7 + O(q^9), q + 4*q^3 + 6*q^5 + O(q^6)), (3, 1 + 12*q^2 + 64*q^3 + 60*q^4 + 160*q^6 + 384*q^7 + 252*q^8 + O(q^9), 1 + 12*q^2 + 64*q^3 + 60*q^4 + O(q^6)), (3, q + 4*q^2 + 8*q^3 + 16*q^4 + 26*q^5 + 32*q^6 + 48*q^7 + 64*q^8 + O(q^9), q + 4*q^2 + 8*q^3 + 16*q^4 + 26*q^5 + O(q^6))]
"""
default_params = (start_gens == () and start_weight == 2)
if default_params and self.__cached_maxweight != -1:
verbose("Already know generators up to weight %s -- using those" % self.__cached_maxweight)
if self.__cached_maxweight >= maxweight:
return [(k, f, F) for k, f, F in self.__cached_gens if k <= maxweight]
start_gens = self.__cached_gens
start_weight = self.__cached_maxweight + 1
if self.group().is_even():
increment = 2
else:
increment = 1
working_prec = self.modular_forms_of_weight(maxweight).sturm_bound()
# parse the list of start gens
G = []
for x in start_gens:
k, f, F = x
if F is None and f.prec() < working_prec:
raise ValueError("Need start gens to precision at least %s" % working_prec)
elif f is None or f.prec() < working_prec:
f = F.qexp(working_prec).change_ring(self.base_ring())
G.append((k, f, F))
k = start_weight
if increment == 2 and (k % 2) == 1: k += 1
while k <= maxweight:
if self.modular_forms_of_weight(k).dimension() == 0:
k += increment
continue
verbose('Looking at k = %s'%k)
M = self.modular_forms_of_weight(k)
# 1. Multiply together all forms in G that give an element
# of M.
if G != []:
F = _span_of_forms_in_weight(G, k, M.sturm_bound(), None, False)
else:
F = (self.base_ring() ** M.sturm_bound()).zero_submodule()
# 2. If the dimension of the span of the result is equal
# to the dimension of M, increment k.
if F.rank() == M.dimension():
if self.base_ring().is_field() or F.index_in_saturation() == 1:
# TODO: Do something clever if the submodule's of the right
# rank but not saturated -- avoid triggering needless
# modular symbol computations.
verbose('Nothing new in weight %s' % k)
k += increment
continue
# 3. If the dimension is less, compute a basis for G, and
# try adding basis elements of M into G.
verbose("Known generators span a subspace of dimension %s of space of dimension %s" % (F.dimension(), M.dimension()))
if self.base_ring() == ZZ: verbose("saturation index is %s" % F.index_in_saturation())
t = verbose("Computing more modular forms at weight %s" % k)
kprec = M.sturm_bound()
if self.base_ring() == QQ:
B = M.q_echelon_basis(working_prec)
else:
B = M.q_integral_basis(working_prec)
t = verbose("done computing forms", t)
V = F.ambient_module().submodule_with_basis([f.padded_list(kprec) for f in B])
Q = V / F
for q in Q.gens():
try:
qc = V.coordinates(Q.lift(q))
except AttributeError:
# work around a silly free module bug
qc = V.coordinates(q.lift())
qcZZ = [ZZ(_) for _ in qc] # lift to ZZ so we can define F
f = sum([B[i] * qcZZ[i] for i in range(len(B))])
F = M(f)
G.append((k, f.change_ring(self.base_ring()), F))
verbose('added %s new generators' % Q.ngens(), t)
k += increment
if default_params:
self.__cached_maxweight = maxweight
self.__cached_gens = G
return G
def _span_of_forms_in_weight(forms, weight, prec, stop_dim=None, use_random=False):
r"""
Utility function. Given a nonempty list of pairs ``(k,f)``, where `k` is an
integer and `f` is a power series, and a weight l, return all weight l
forms obtained by multiplying together the given forms.
INPUT:
- ``forms`` -- list of pairs `(k, f)` with k an integer and f a power
series (all over the same base ring)
- ``weight`` -- an integer
- ``prec`` -- an integer (less than or equal to the precision of all the
forms in ``forms``) -- precision to use in power series computations.
- ``stop_dim`` -- an integer: stop as soon as we have enough forms to span
a submodule of this rank (a saturated one if the base ring is `\ZZ`).
Ignored if ``use_random`` is False.
- ``use_random`` -- which algorithm to use. If True, tries random products
of the generators of the appropriate weight until a large enough
submodule is found (determined by ``stop_dim``). If False, just tries
everything.
Note that if the given forms do generate the whole space, then
``use_random=True`` will often be quicker (particularly if the weight is
large); but if the forms don't generate, the randomized algorithm is no
help and will actually be substantially slower, because it needs to do
repeated echelon form calls to check if vectors are in a submodule, while
the non-randomized algorithm just echelonizes one enormous matrix at the
end.
EXAMPLES::
sage: import sage.modular.modform.find_generators as f
sage: forms = [(4, 240*eisenstein_series_qexp(4,5)), (6,504*eisenstein_series_qexp(6,5))]
sage: f._span_of_forms_in_weight(forms, 12, prec=5)
Vector space of degree 5 and dimension 2 over Rational Field
Basis matrix:
[ 1 0 196560 16773120 398034000]
[ 0 1 -24 252 -1472]
sage: f._span_of_forms_in_weight(forms, 24, prec=5)
Vector space of degree 5 and dimension 3 over Rational Field
Basis matrix:
[ 1 0 0 52416000 39007332000]
[ 0 1 0 195660 12080128]
[ 0 0 1 -48 1080]
sage: ModularForms(1, 24).q_echelon_basis(prec=5)
[
1 + 52416000*q^3 + 39007332000*q^4 + O(q^5),
q + 195660*q^3 + 12080128*q^4 + O(q^5),
q^2 - 48*q^3 + 1080*q^4 + O(q^5)
]
Test the alternative randomized algorithm::
sage: f._span_of_forms_in_weight(forms, 24, prec=5, use_random=True, stop_dim=3)
Vector space of degree 5 and dimension 3 over Rational Field
Basis matrix:
[ 1 0 0 52416000 39007332000]
[ 0 1 0 195660 12080128]
[ 0 0 1 -48 1080]
"""
t = verbose('multiplying forms up to weight %s'%weight)
# Algorithm: run through the monomials of the appropriate weight, and build
# up the vector space they span.
n = len(forms)
R = forms[0][1].base_ring()
V = R ** prec
W = V.zero_submodule()
shortforms = [f[1].truncate_powerseries(prec) for f in forms]
# List of weights
from sage.combinat.integer_vector_weighted import WeightedIntegerVectors
wts = list(WeightedIntegerVectors(weight, [f[0] for f in forms]))
t = verbose("calculated weight list", t)
N = len(wts)
if use_random:
if stop_dim is None:
raise ValueError("stop_dim must be provided if use_random is True")
shuffle(wts)
for c in range(N):
w = V(prod(shortforms[i]**wts[c][i] for i in range(n)).padded_list(prec))
if w in W: continue
W = V.span(list(W.gens()) + [w])
if stop_dim and W.rank() == stop_dim:
if R != ZZ or W.index_in_saturation() == 1:
verbose("Succeeded after %s of %s" % (c, N), t)
return W
verbose("Nothing worked", t)
return W
else:
G = [V(prod(forms[i][1]**c[i] for i in range(n)).padded_list(prec)) for c in wts]
t = verbose('found %s candidates' % N, t)
W = V.span(G)
verbose('span has dimension %s' % W.rank(), t)
return W
def q_expansion_basis(self, weight, prec=None, use_random=True):
r"""
Calculate a basis of q-expansions for the space of modular forms of the
given weight for this group, calculated using the ring generators given
by ``find_generators``.
INPUT:
- ``weight`` (integer) -- the weight
- ``prec`` (integer or ``None``, default: ``None``) -- power series
precision. If ``None``, the precision defaults to the Sturm bound for
the requested level and weight.
- ``use_random`` (boolean, default: True) -- whether or not to use a
randomized algorithm when building up the space of forms at the given
weight from known generators of small weight.
EXAMPLES::
sage: m = ModularFormsRing(Gamma0(4))
sage: m.q_expansion_basis(2,10)
[1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^10),
q + 4*q^3 + 6*q^5 + 8*q^7 + 13*q^9 + O(q^10)]
sage: m.q_expansion_basis(3,10)
[]
sage: X = ModularFormsRing(SL2Z)
sage: X.q_expansion_basis(12, 10)
[1 + 196560*q^2 + 16773120*q^3 + 398034000*q^4 + 4629381120*q^5 + 34417656000*q^6 + 187489935360*q^7 + 814879774800*q^8 + 2975551488000*q^9 + O(q^10),
q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + 84480*q^8 - 113643*q^9 + O(q^10)]
We calculate a basis of a massive modular forms space, in two ways.
Using this module is about twice as fast as Sage's generic code. ::
sage: A = ModularFormsRing(11).q_expansion_basis(30, prec=40) # long time (5s)
sage: B = ModularForms(Gamma0(11), 30).q_echelon_basis(prec=40) # long time (9s)
sage: A == B # long time
True
Check that absurdly small values of ``prec`` don't mess things up::
sage: ModularFormsRing(11).q_expansion_basis(10, prec=5)
[1 + O(q^5), q + O(q^5), q^2 + O(q^5), q^3 + O(q^5), q^4 + O(q^5), O(q^5), O(q^5), O(q^5), O(q^5), O(q^5)]
"""
d = self.modular_forms_of_weight(weight).dimension()
if d == 0: return []
if prec is None:
prec = self.modular_forms_of_weight(weight).sturm_bound()
working_prec = max(prec,
self.modular_forms_of_weight(weight).sturm_bound())
gen_weight = min(6, weight)
while True:
verbose(
"Trying to generate the %s-dimensional space at weight %s using generators of weight up to %s"
% (d, weight, gen_weight))
G = self.generators(maxweight=gen_weight, prec=working_prec)
V = _span_of_forms_in_weight(G,
weight,
prec=working_prec,
use_random=use_random,
stop_dim=d)
if V.rank() == d and (self.base_ring().is_field()
or V.index_in_saturation() == 1):
break
else:
gen_weight += 1
verbose(
"Need more generators: trying again with generators of weight up to %s"
% gen_weight)
R = G[0][1].parent()
return [R(list(x), prec=prec) for x in V.gens()]
def points(self, **kwds):
r"""
Return some or all rational points of an affine scheme.
For dimension 0 subschemes points are determined through a groebner
basis calculation. For schemes or subschemes with dimension greater than 1
points are determined through enumeration up to the specified bound.
Over a finite field, all points are returned. Over an infinite field, all points satisfying the bound
are returned. For a zero-dimensional subscheme, all points are returned regardless of whether the field
is infinite or not.
For number fields, this uses the
Doyle-Krumm algorithm 4 (algorithm 5 for imaginary quadratic) for
computing algebraic numbers up to a given height [Doyle-Krumm]_.
The algorithm requires floating point arithmetic, so the user is
allowed to specify the precision for such calculations.
Additionally, due to floating point issues, points
slightly larger than the bound may be returned. This can be controlled
by lowering the tolerance.
INPUT:
kwds:
- ``bound`` - real number (optional, default: 0). The bound for the
height of the coordinates. Only used for subschemes with
dimension at least 1.
- ``zero_tolerance`` - positive real number (optional, default=10^(-10)).
For numerically inexact fields, points are on the subscheme if they
satisfy the equations to within tolerance.
- ``tolerance`` - a rational number in (0,1] used in doyle-krumm algorithm-4
for enumeration over number fields.
- ``precision`` - the precision to use for computing the elements of
bounded height of number fields.
OUTPUT:
- a list of rational points of a affine scheme
.. WARNING::
For numerically inexact fields such as ComplexField or RealField the
list of points returned is very likely to be incomplete. It may also
contain repeated points due to tolerance.
EXAMPLES: The bug reported at #11526 is fixed::
sage: A2 = AffineSpace(ZZ, 2)
sage: F = GF(3)
sage: A2(F).points()
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
::
sage: A.<x,y> = ZZ[]
sage: I = A.ideal(x^2-y^2-1)
sage: V = AffineSpace(ZZ, 2)
sage: X = V.subscheme(I)
sage: M = X(ZZ)
sage: M.points(bound=1)
[(-1, 0), (1, 0)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: A.<x,y> = AffineSpace(K, 2)
sage: len(A(K).points(bound=2))
1849
::
sage: A.<x,y> = AffineSpace(QQ, 2)
sage: E = A.subscheme([x^2 + y^2 - 1, y^2 - x^3 + x^2 + x - 1])
sage: E(A.base_ring()).points()
[(-1, 0), (0, -1), (0, 1), (1, 0)]
::
sage: A.<x,y> = AffineSpace(CC, 2)
sage: E = A.subscheme([y^3 - x^3 - x^2, x*y])
sage: E(A.base_ring()).points()
verbose 0 (124: affine_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.
[(-1.00000000000000, 0.000000000000000),
(0.000000000000000, 0.000000000000000)]
::
sage: A.<x1,x2> = AffineSpace(CDF, 2)
sage: E = A.subscheme([x1^2 + x2^2 + x1*x2, x1 + x2])
sage: E(A.base_ring()).points()
verbose 0 (124: affine_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.
[(0.0, 0.0)]
"""
from sage.schemes.affine.affine_space import is_AffineSpace
X = self.codomain()
if not is_AffineSpace(X) and X.base_ring() in Fields():
if hasattr(X.base_ring(), 'precision'):
numerical = True
verbose(
"Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.",
level=0)
zero_tol = RR(kwds.pop('zero_tolerance', 10**(-10)))
if zero_tol <= 0:
raise ValueError("tolerance must be positive")
else:
numerical = False
# Then X must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 0: # no points
return []
if dim_ideal == 0: # if X zero-dimensional
rat_points = []
AS = X.ambient_space()
N = AS.dimension_relative()
BR = X.base_ring()
#need a lexicographic ordering for elimination
R = PolynomialRing(BR, N, AS.gens(), order='lex')
I = R.ideal(X.defining_polynomials())
I0 = R.ideal(0)
#Determine the points through elimination
#This is much faster than using the I.variety() function on each affine chart.
G = I.groebner_basis()
if G != [1]:
P = {}
points = [P]
#work backwards from solving each equation for the possible
#values of the next coordinate
for i in range(len(G) - 1, -1, -1):
new_points = []
good = 0
for P in points:
#substitute in our dictionary entry that has the values
#of coordinates known so far. This results in a single
#variable polynomial (by elimination)
L = G[i].substitute(P)
if R(L).degree() > 0:
if numerical:
for pol in L.univariate_polynomial().roots(
multiplicities=False):
r = L.variables()[0]
varindex = R.gens().index(r)
P.update({R.gen(varindex): pol})
new_points.append(copy(P))
good = 1
else:
L = L.factor()
#the linear factors give the possible rational values of
#this coordinate
for pol, pow in L:
if pol.degree() == 1 and len(
pol.variables()) == 1:
good = 1
r = pol.variables()[0]
varindex = R.gens().index(r)
#add this coordinates information to
#each dictionary entry
P.update({
R.gen(varindex):
-pol.constant_coefficient() /
pol.monomial_coefficient(r)
})
new_points.append(copy(P))
else:
new_points.append(P)
good = 1
if good:
points = new_points
#the dictionary entries now have values for all coordinates
#they are the rational solutions to the equations
#make them into affine points
for i in range(len(points)):
if numerical:
if len(points[i]) == N:
S = AS([points[i][R.gen(j)] for j in range(N)])
if all(
g(list(S)) < zero_tol
for g in X.defining_polynomials()):
rat_points.append(S)
else:
if len(points[i]) == N and I.subs(points[i]) == I0:
S = X([points[i][R.gen(j)] for j in range(N)])
rat_points.append(S)
rat_points = sorted(rat_points)
return rat_points
R = self.value_ring()
B = kwds.pop('bound', 0)
tol = kwds.pop('tolerance', 1e-2)
prec = kwds.pop('precision', 53)
if is_RationalField(R) or R == ZZ:
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
from sage.schemes.affine.affine_rational_point import enum_affine_rational_field
return enum_affine_rational_field(self, B)
if R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
from sage.schemes.affine.affine_rational_point import enum_affine_number_field
return enum_affine_number_field(self,
bound=B,
tolerance=tol,
precision=prec)
elif is_FiniteField(R):
from sage.schemes.affine.affine_rational_point import enum_affine_finite_field
return enum_affine_finite_field(self)
else:
raise TypeError("unable to enumerate points over %s" % R)
def _find_scaling_period(self):
r"""
Uses the integral period map of the modular symbol implementation in sage
in order to determine the scaling. The resulting modular symbol is correct
only for the `X_0`-optimal curve, at least up to a possible factor +- a
power of 2.
EXAMPLES::
sage: E = EllipticCurve('11a1')
sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
sage: m._e
(1/5, 1)
sage: E = EllipticCurve('11a2')
sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
sage: m._e
(1, 5)
sage: E = EllipticCurve('121b2')
sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
sage: m._e
(0, 11/2, 0, 11/2, 11/2, 0, 0, -3, 2, 1/2, -1, 3/2)
TESTS::
sage: E = EllipticCurve('19a1')
sage: m = E.modular_symbol(sign=+1, implementation='sage', normalize='none')
sage: m._find_scaling_period()
sage: m._scaling
1
sage: E = EllipticCurve('19a2')
sage: m = E.modular_symbol(sign=+1, implementation='sage', normalize='none')
sage: m._scaling
1
sage: m._find_scaling_period()
sage: m._scaling
3
"""
P = self._modsym.integral_period_mapping()
self._e = P.matrix().transpose().row(0)
self._e /= 2
E = self._E
try:
crla = parse_cremona_label(E.label())
except RuntimeError: # raised when curve is outside of the table
print(
"Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by a rational number."
)
self._scaling = 1
else:
cr0 = Integer(crla[0]).str() + crla[1] + '1'
E0 = EllipticCurve(cr0)
if self._sign == 1:
q = E0.period_lattice().basis()[0] / E.period_lattice().basis(
)[0]
else:
q = E0.period_lattice().basis()[1].imag() / E.period_lattice(
).basis()[1].imag()
if E0.real_components() == 1:
q *= 2
if E.real_components() == 1:
q /= 2
q = QQ(int(round(q * 200))) / 200
verbose('scale modular symbols by %s' % q)
self._scaling = q
c = self(0) # required, to change base point from oo to 0
if c < 0:
c *= -1
self._scaling *= -1
self._at_zero = c
self._e *= self._scaling
def an_padic(self, p, prec=0, use_twists=True):
r"""
Returns the conjectural order of `Sha(E/\QQ)`,
according to the `p`-adic analogue of the Birch
and Swinnerton-Dyer conjecture as formulated
in [MTT]_ and [BP]_.
REFERENCES:
.. [MTT] \B. Mazur, J. Tate, and J. Teitelbaum, On `p`-adic
analogues of the conjectures of Birch and Swinnerton-Dyer,
Inventiones mathematicae 84, (1986), 1-48.
.. [BP] Dominique Bernardi and Bernadette Perrin-Riou,
Variante `p`-adique de la conjecture de Birch et
Swinnerton-Dyer (le cas supersingulier),
C. R. Acad. Sci. Paris, Sér I. Math., 317 (1993), no. 3,
227-232.
INPUT:
- ``p`` - a prime > 3
- ``prec`` (optional) - the precision used in the computation of the
`p`-adic L-Series
- ``use_twists`` (default = ``True``) - If ``True`` the algorithm may
change to a quadratic twist with minimal conductor to do the modular
symbol computations rather than using the modular symbols of the
curve itself. If ``False`` it forces the computation using the
modular symbols of the curve itself.
OUTPUT: `p`-adic number - that conjecturally equals `\# Sha(E/\QQ)`.
If ``prec`` is set to zero (default) then the precision is set so that
at least the first `p`-adic digit of conjectural `\# Sha(E/\QQ)` is
determined.
EXAMPLES:
Good ordinary examples::
sage: EllipticCurve('11a1').sha().an_padic(5) # rank 0
1 + O(5^22)
sage: EllipticCurve('43a1').sha().an_padic(5) # rank 1
1 + O(5)
sage: EllipticCurve('389a1').sha().an_padic(5,4) # rank 2, long time (2s on sage.math, 2011)
1 + O(5^3)
sage: EllipticCurve('858k2').sha().an_padic(7) # rank 0, non trivial sha, long time (10s on sage.math, 2011)
7^2 + O(7^24)
sage: EllipticCurve('300b2').sha().an_padic(3) # 9 elements in sha, long time (2s on sage.math, 2011)
3^2 + O(3^24)
sage: EllipticCurve('300b2').sha().an_padic(7, prec=6) # long time
2 + 7 + O(7^8)
Exceptional cases::
sage: EllipticCurve('11a1').sha().an_padic(11) # rank 0
1 + O(11^22)
sage: EllipticCurve('130a1').sha().an_padic(5) # rank 1
1 + O(5)
Non-split, but rank 0 case (:trac:`7331`)::
sage: EllipticCurve('270b1').sha().an_padic(5) # rank 0, long time (2s on sage.math, 2011)
1 + O(5^22)
The output has the correct sign::
sage: EllipticCurve('123a1').sha().an_padic(41) # rank 1, long time (3s on sage.math, 2011)
1 + O(41)
Supersingular cases::
sage: EllipticCurve('34a1').sha().an_padic(5) # rank 0
1 + O(5^22)
sage: EllipticCurve('53a1').sha().an_padic(5) # rank 1, long time (11s on sage.math, 2011)
1 + O(5)
Cases that use a twist to a lower conductor::
sage: EllipticCurve('99a1').sha().an_padic(5)
1 + O(5)
sage: EllipticCurve('240d3').sha().an_padic(5) # sha has 4 elements here
4 + O(5)
sage: EllipticCurve('448c5').sha().an_padic(7,prec=4, use_twists=False) # long time (2s on sage.math, 2011)
2 + 7 + O(7^6)
sage: EllipticCurve([-19,34]).sha().an_padic(5) # see trac #6455, long time (4s on sage.math, 2011)
1 + O(5)
Test for :trac:`15737`::
sage: E = EllipticCurve([-100,0])
sage: s = E.sha()
sage: s.an_padic(13)
1 + O(13^20)
"""
try:
return self.__an_padic[(p,prec)]
except AttributeError:
self.__an_padic = {}
except KeyError:
pass
E = self.Emin
tam = E.tamagawa_product()
tors = E.torsion_order()**2
r = E.rank()
if r > 0 :
reg = E.padic_regulator(p)
else:
if E.is_supersingular(p):
reg = vector([ Qp(p,20)(1), 0 ])
else:
reg = Qp(p,20)(1)
if use_twists and p > 2:
Et, D = E.minimal_quadratic_twist()
# trac 6455 : we have to assure that the twist back is allowed
D = ZZ(D)
if D % p == 0:
D = ZZ(D/p)
for ell in D.prime_divisors():
if ell % 2 == 1:
if Et.conductor() % ell**2 == 0:
D = ZZ(D/ell)
ve = valuation(D,2)
de = ZZ( (D/2**ve).abs() )
if de % 4 == 3:
de = -de
Et = E.quadratic_twist(de)
# now check individually if we can twist by -1 or 2 or -2
Nmin = Et.conductor()
Dmax = de
for DD in [-4*de,8*de,-8*de]:
Et = E.quadratic_twist(DD)
if Et.conductor() < Nmin and valuation(Et.conductor(),2) <= valuation(DD,2):
Nmin = Et.conductor()
Dmax = DD
D = Dmax
Et = E.quadratic_twist(D)
lp = Et.padic_lseries(p)
else :
lp = E.padic_lseries(p)
D = 1
if r == 0 and D == 1:
# short cut for rank 0 curves, we do not
# to compute the p-adic L-function, the leading
# term will be the L-value divided by the Neron
# period.
ms = E.modular_symbol(sign=+1, normalize='L_ratio')
lstar = ms(0)/E.real_components()
bsd = tam/tors
if prec == 0:
#prec = valuation(lstar/bsd, p)
prec = 20
shan = Qp(p,prec=prec+2)(lstar/bsd)
elif E.is_ordinary(p):
K = reg.parent()
lg = log(K(1+p))
if (E.is_good(p) or E.ap(p) == -1):
if not E.is_good(p):
eps = 2
else:
eps = (1-arith.kronecker_symbol(D,p)/lp.alpha())**2
# according to the p-adic BSD this should be equal to the leading term of the p-adic L-series divided by sha:
bsdp = tam * reg * eps/tors/lg**r
else:
r += 1 # exceptional zero
eq = E.tate_curve(p)
Li = eq.L_invariant()
# according to the p-adic BSD (Mazur-Tate-Teitelbaum)
# this should be equal to the leading term of the p-adic L-series divided by sha:
bsdp = tam * reg * Li/tors/lg**r
v = bsdp.valuation()
if v > 0:
verbose("the prime is irregular for this curve.")
# determine how much prec we need to prove at least the
# triviality of the p-primary part of Sha
if prec == 0:
n = max(v,2)
bounds = lp._prec_bounds(n,r+1)
while bounds[r] <= v:
n += 1
bounds = lp._prec_bounds(n,r+1)
verbose("set precision to %s"%n)
else:
n = max(2,prec)
not_yet_enough_prec = True
while not_yet_enough_prec:
lps = lp.series(n,quadratic_twist=D,prec=r+1)
lstar = lps[r]
if (lstar != 0) or (prec != 0):
not_yet_enough_prec = False
else:
n += 1
verbose("increased precision to %s"%n)
shan = lstar/bsdp
elif E.is_supersingular(p):
K = reg[0].parent()
lg = log(K(1+p))
# according to the p-adic BSD this should be equal to the leading term of the D_p - valued
# L-series :
bsdp = tam /tors/lg**r * reg
# note this is an element in Q_p^2
verbose("the algebraic leading terms : %s"%bsdp)
v = [bsdp[0].valuation(),bsdp[1].valuation()]
if prec == 0:
n = max(min(v)+2,3)
else:
n = max(3,prec)
verbose("...computing the p-adic L-series")
not_yet_enough_prec = True
while not_yet_enough_prec:
lps = lp.Dp_valued_series(n,quadratic_twist=D,prec=r+1)
lstar = [lps[0][r],lps[1][r]]
verbose("the leading terms : %s"%lstar)
if (lstar[0] != 0 or lstar[1] != 0) or ( prec != 0):
not_yet_enough_prec = False
else:
n += 1
verbose("increased precision to %s"%n)
verbose("...putting things together")
if bsdp[0] != 0:
shan0 = lstar[0]/bsdp[0]
else:
shan0 = 0 # this should actually never happen
if bsdp[1] != 0:
shan1 = lstar[1]/bsdp[1]
else:
shan1 = 0 # this should conjecturally only happen when the rank is 0
verbose("the two values for Sha : %s"%[shan0,shan1])
# check consistency (the first two are only here to avoid a bug in the p-adic L-series
# (namely the coefficients of zero-relative precision are treated as zero)
if shan0 != 0 and shan1 != 0 and shan0 - shan1 != 0:
raise RuntimeError("There must be a bug in the supersingular routines for the p-adic BSD.")
#take the better
if shan1 == 0 or shan0.precision_relative() > shan1.precision_relative():
shan = shan0
else:
shan = shan1
else:
raise ValueError("The curve has to have semi-stable reduction at p.")
self.__an_padic[(p,prec)] = shan
return shan
def _span_of_forms_in_weight(forms,
weight,
prec,
stop_dim=None,
use_random=False):
r"""
Utility function. Given a nonempty list of pairs ``(k,f)``, where `k` is an
integer and `f` is a power series, and a weight l, return all weight l
forms obtained by multiplying together the given forms.
INPUT:
- ``forms`` -- list of pairs `(k, f)` with k an integer and f a power
series (all over the same base ring)
- ``weight`` -- an integer
- ``prec`` -- an integer (less than or equal to the precision of all the
forms in ``forms``) -- precision to use in power series computations.
- ``stop_dim`` -- an integer: stop as soon as we have enough forms to span
a submodule of this rank (a saturated one if the base ring is `\ZZ`).
Ignored if ``use_random`` is False.
- ``use_random`` -- which algorithm to use. If True, tries random products
of the generators of the appropriate weight until a large enough
submodule is found (determined by ``stop_dim``). If False, just tries
everything.
Note that if the given forms do generate the whole space, then
``use_random=True`` will often be quicker (particularly if the weight is
large); but if the forms don't generate, the randomized algorithm is no
help and will actually be substantially slower, because it needs to do
repeated echelon form calls to check if vectors are in a submodule, while
the non-randomized algorithm just echelonizes one enormous matrix at the
end.
EXAMPLES::
sage: import sage.modular.modform.find_generators as f
sage: forms = [(4, 240*eisenstein_series_qexp(4,5)), (6,504*eisenstein_series_qexp(6,5))]
sage: f._span_of_forms_in_weight(forms, 12, prec=5)
Vector space of degree 5 and dimension 2 over Rational Field
Basis matrix:
[ 1 0 196560 16773120 398034000]
[ 0 1 -24 252 -1472]
sage: f._span_of_forms_in_weight(forms, 24, prec=5)
Vector space of degree 5 and dimension 3 over Rational Field
Basis matrix:
[ 1 0 0 52416000 39007332000]
[ 0 1 0 195660 12080128]
[ 0 0 1 -48 1080]
sage: ModularForms(1, 24).q_echelon_basis(prec=5)
[
1 + 52416000*q^3 + 39007332000*q^4 + O(q^5),
q + 195660*q^3 + 12080128*q^4 + O(q^5),
q^2 - 48*q^3 + 1080*q^4 + O(q^5)
]
Test the alternative randomized algorithm::
sage: f._span_of_forms_in_weight(forms, 24, prec=5, use_random=True, stop_dim=3)
Vector space of degree 5 and dimension 3 over Rational Field
Basis matrix:
[ 1 0 0 52416000 39007332000]
[ 0 1 0 195660 12080128]
[ 0 0 1 -48 1080]
"""
t = verbose('multiplying forms up to weight %s' % weight)
# Algorithm: run through the monomials of the appropriate weight, and build
# up the vector space they span.
n = len(forms)
R = forms[0][1].base_ring()
V = R**prec
W = V.zero_submodule()
shortforms = [f[1].truncate_powerseries(prec) for f in forms]
# List of weights
from sage.combinat.integer_vector_weighted import WeightedIntegerVectors
wts = list(WeightedIntegerVectors(weight, [f[0] for f in forms]))
t = verbose("calculated weight list", t)
N = len(wts)
if use_random:
if stop_dim is None:
raise ValueError("stop_dim must be provided if use_random is True")
shuffle(wts)
for c in range(N):
w = V(
prod(shortforms[i]**wts[c][i]
for i in range(n)).padded_list(prec))
if w in W: continue
W = V.span(list(W.gens()) + [w])
if stop_dim and W.rank() == stop_dim:
if R != ZZ or W.index_in_saturation() == 1:
verbose("Succeeded after %s of %s" % (c, N), t)
return W
verbose("Nothing worked", t)
return W
else:
G = [
V(prod(forms[i][1]**c[i] for i in range(n)).padded_list(prec))
for c in wts
]
t = verbose('found %s candidates' % N, t)
W = V.span(G)
verbose('span has dimension %s' % W.rank(), t)
return W
def cuspidal_submodule_q_expansion_basis(self, weight, prec=None):
r"""
Calculate a basis of `q`-expansions for the space of cusp forms of
weight ``weight`` for this group.
INPUT:
- ``weight`` (integer) -- the weight
- ``prec`` (integer or None) -- precision of `q`-expansions to return
ALGORITHM: Uses the method :meth:`cuspidal_ideal_generators` to
calculate generators of the ideal of cusp forms inside this ring. Then
multiply these up to weight ``weight`` using the generators of the
whole modular form space returned by :meth:`q_expansion_basis`.
EXAMPLES::
sage: R = ModularFormsRing(Gamma0(3))
sage: R.cuspidal_submodule_q_expansion_basis(20)
[q - 8532*q^6 - 88442*q^7 + O(q^8), q^2 + 207*q^6 + 24516*q^7 + O(q^8), q^3 + 456*q^6 + O(q^8), q^4 - 135*q^6 - 926*q^7 + O(q^8), q^5 + 18*q^6 + 135*q^7 + O(q^8)]
We compute a basis of a space of very large weight, quickly (using this
module) and slowly (using modular symbols), and verify that the answers
are the same. ::
sage: A = R.cuspidal_submodule_q_expansion_basis(80, prec=30) # long time (1s on sage.math, 2013)
sage: B = R.modular_forms_of_weight(80).cuspidal_submodule().q_expansion_basis(prec=30) # long time (19s on sage.math, 2013)
sage: A == B # long time
True
"""
d = self.modular_forms_of_weight(
weight).cuspidal_submodule().dimension()
if d == 0: return []
minprec = self.modular_forms_of_weight(weight).sturm_bound()
if prec is None:
prec = working_prec = minprec
else:
working_prec = max(prec, minprec)
gen_weight = min(6, weight)
while True:
verbose(
"Trying to generate the %s-dimensional cuspidal submodule at weight %s using generators of weight up to %s"
% (d, weight, gen_weight))
G = self.cuspidal_ideal_generators(maxweight=gen_weight,
prec=working_prec)
flist = []
for (j, f, F) in G:
for g in self.q_expansion_basis(weight - j, prec=working_prec):
flist.append(g * f)
A = self.base_ring()**working_prec
W = A.span([A(f.padded_list(working_prec)) for f in flist])
if W.rank() == d and (self.base_ring().is_field()
or W.index_in_saturation() == 1):
break
else:
gen_weight += 1
verbose(
"Need more generators: trying again with generators of weight up to %s"
% gen_weight)
R = G[0][1].parent()
return [R(list(x), prec=prec) for x in W.gens()]
def splitting_field(poly,
name,
map=False,
degree_multiple=None,
abort_degree=None,
simplify=True,
simplify_all=False):
r"""
Compute the splitting field of a given polynomial, defined over a
number field.
INPUT:
- ``poly`` -- a monic polynomial over a number field
- ``name`` -- a variable name for the number field
- ``map`` -- (default: ``False``) also return an embedding of
``poly`` into the resulting field. Note that computing this
embedding might be expensive.
- ``degree_multiple`` -- a multiple of the absolute degree of
the splitting field. If ``degree_multiple`` equals the actual
degree, this can enormously speed up the computation.
- ``abort_degree`` -- abort by raising a :class:`SplittingFieldAbort`
if it can be determined that the absolute degree of the splitting
field is strictly larger than ``abort_degree``.
- ``simplify`` -- (default: ``True``) during the algorithm, try
to find a simpler defining polynomial for the intermediate
number fields using PARI's ``polred()``. This usually speeds
up the computation but can also considerably slow it down.
Try and see what works best in the given situation.
- ``simplify_all`` -- (default: ``False``) If ``True``, simplify
intermediate fields and also the resulting number field.
OUTPUT:
If ``map`` is ``False``, the splitting field as an absolute number
field. If ``map`` is ``True``, a tuple ``(K, phi)`` where ``phi``
is an embedding of the base field in ``K``.
EXAMPLES::
sage: R.<x> = PolynomialRing(QQ)
sage: K.<a> = (x^3 + 2).splitting_field(); K
Number Field in a with defining polynomial x^6 + 3*x^5 + 6*x^4 + 11*x^3 + 12*x^2 - 3*x + 1
sage: K.<a> = (x^3 - 3*x + 1).splitting_field(); K
Number Field in a with defining polynomial x^3 - 3*x + 1
The ``simplify`` and ``simplify_all`` flags usually yield
fields defined by polynomials with smaller coefficients.
By default, ``simplify`` is True and ``simplify_all`` is False.
::
sage: (x^4 - x + 1).splitting_field('a', simplify=False)
Number Field in a with defining polynomial x^24 - 2780*x^22 + 2*x^21 + 3527512*x^20 - 2876*x^19 - 2701391985*x^18 + 945948*x^17 + 1390511639677*x^16 + 736757420*x^15 - 506816498313560*x^14 - 822702898220*x^13 + 134120588299548463*x^12 + 362240696528256*x^11 - 25964582366880639486*x^10 - 91743672243419990*x^9 + 3649429473447308439427*x^8 + 14310332927134072336*x^7 - 363192569823568746892571*x^6 - 1353403793640477725898*x^5 + 24293393281774560140427565*x^4 + 70673814899934142357628*x^3 - 980621447508959243128437933*x^2 - 1539841440617805445432660*x + 18065914012013502602456565991
sage: (x^4 - x + 1).splitting_field('a', simplify=True)
Number Field in a with defining polynomial x^24 + 8*x^23 - 32*x^22 - 310*x^21 + 540*x^20 + 4688*x^19 - 6813*x^18 - 32380*x^17 + 49525*x^16 + 102460*x^15 - 129944*x^14 - 287884*x^13 + 372727*x^12 + 150624*x^11 - 110530*x^10 - 566926*x^9 + 1062759*x^8 - 779940*x^7 + 863493*x^6 - 1623578*x^5 + 1759513*x^4 - 955624*x^3 + 459975*x^2 - 141948*x + 53919
sage: (x^4 - x + 1).splitting_field('a', simplify_all=True)
Number Field in a with defining polynomial x^24 - 3*x^23 + 2*x^22 - x^20 + 4*x^19 + 32*x^18 - 35*x^17 - 92*x^16 + 49*x^15 + 163*x^14 - 15*x^13 - 194*x^12 - 15*x^11 + 163*x^10 + 49*x^9 - 92*x^8 - 35*x^7 + 32*x^6 + 4*x^5 - x^4 + 2*x^2 - 3*x + 1
Reducible polynomials also work::
sage: pol = (x^4 - 1)*(x^2 + 1/2)*(x^2 + 1/3)
sage: pol.splitting_field('a', simplify_all=True)
Number Field in a with defining polynomial x^8 - x^4 + 1
Relative situation::
sage: R.<x> = PolynomialRing(QQ)
sage: K.<a> = NumberField(x^3 + 2)
sage: S.<t> = PolynomialRing(K)
sage: L.<b> = (t^2 - a).splitting_field()
sage: L
Number Field in b with defining polynomial t^6 + 2
With ``map=True``, we also get the embedding of the base field
into the splitting field::
sage: L.<b>, phi = (t^2 - a).splitting_field(map=True)
sage: phi
Ring morphism:
From: Number Field in a with defining polynomial x^3 + 2
To: Number Field in b with defining polynomial t^6 + 2
Defn: a |--> b^2
sage: (x^4 - x + 1).splitting_field('a', simplify_all=True, map=True)[1]
Ring morphism:
From: Rational Field
To: Number Field in a with defining polynomial x^24 - 3*x^23 + 2*x^22 - x^20 + 4*x^19 + 32*x^18 - 35*x^17 - 92*x^16 + 49*x^15 + 163*x^14 - 15*x^13 - 194*x^12 - 15*x^11 + 163*x^10 + 49*x^9 - 92*x^8 - 35*x^7 + 32*x^6 + 4*x^5 - x^4 + 2*x^2 - 3*x + 1
Defn: 1 |--> 1
We can enable verbose messages::
sage: set_verbose(2)
sage: K.<a> = (x^3 - x + 1).splitting_field()
verbose 1 (...: splitting_field.py, splitting_field) Starting field: y
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to factor: [(3, 0)]
verbose 2 (...: splitting_field.py, splitting_field) Done factoring (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to handle: [(2, 2), (3, 3)]
verbose 1 (...: splitting_field.py, splitting_field) Bounds for absolute degree: [6, 6]
verbose 2 (...: splitting_field.py, splitting_field) Handling polynomial x^2 + 23
verbose 1 (...: splitting_field.py, splitting_field) New field before simplifying: x^2 + 23 (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) New field: y^2 - y + 6 (time = ...)
verbose 2 (...: splitting_field.py, splitting_field) Converted polynomials to new field (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to factor: []
verbose 2 (...: splitting_field.py, splitting_field) Done factoring (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to handle: [(3, 3)]
verbose 1 (...: splitting_field.py, splitting_field) Bounds for absolute degree: [6, 6]
verbose 2 (...: splitting_field.py, splitting_field) Handling polynomial x^3 - x + 1
verbose 1 (...: splitting_field.py, splitting_field) New field: y^6 + 3*y^5 + 19*y^4 + 35*y^3 + 127*y^2 + 73*y + 271 (time = ...)
sage: set_verbose(0)
Try all Galois groups in degree 4. We use a quadratic base field
such that ``polgalois()`` cannot be used::
sage: R.<x> = PolynomialRing(QuadraticField(-11))
sage: C2C2pol = x^4 - 10*x^2 + 1
sage: C2C2pol.splitting_field('x')
Number Field in x with defining polynomial x^8 + 24*x^6 + 608*x^4 + 9792*x^2 + 53824
sage: C4pol = x^4 + x^3 + x^2 + x + 1
sage: C4pol.splitting_field('x')
Number Field in x with defining polynomial x^8 - x^7 - 2*x^6 + 5*x^5 + x^4 + 15*x^3 - 18*x^2 - 27*x + 81
sage: D8pol = x^4 - 2
sage: D8pol.splitting_field('x')
Number Field in x with defining polynomial x^16 + 8*x^15 + 68*x^14 + 336*x^13 + 1514*x^12 + 5080*x^11 + 14912*x^10 + 35048*x^9 + 64959*x^8 + 93416*x^7 + 88216*x^6 + 41608*x^5 - 25586*x^4 - 60048*x^3 - 16628*x^2 + 12008*x + 34961
sage: A4pol = x^4 - 4*x^3 + 14*x^2 - 28*x + 21
sage: A4pol.splitting_field('x')
Number Field in x with defining polynomial x^24 - 20*x^23 + 290*x^22 - 3048*x^21 + 26147*x^20 - 186132*x^19 + 1130626*x^18 - 5913784*x^17 + 26899345*x^16 - 106792132*x^15 + 371066538*x^14 - 1127792656*x^13 + 2991524876*x^12 - 6888328132*x^11 + 13655960064*x^10 - 23000783036*x^9 + 32244796382*x^8 - 36347834476*x^7 + 30850889884*x^6 - 16707053128*x^5 + 1896946429*x^4 + 4832907884*x^3 - 3038258802*x^2 - 200383596*x + 593179173
sage: S4pol = x^4 + x + 1
sage: S4pol.splitting_field('x')
Number Field in x with defining polynomial x^48 ...
Some bigger examples::
sage: R.<x> = PolynomialRing(QQ)
sage: pol15 = chebyshev_T(31, x) - 1 # 2^30*(x-1)*minpoly(cos(2*pi/31))^2
sage: pol15.splitting_field('a')
Number Field in a with defining polynomial x^15 - x^14 - 14*x^13 + 13*x^12 + 78*x^11 - 66*x^10 - 220*x^9 + 165*x^8 + 330*x^7 - 210*x^6 - 252*x^5 + 126*x^4 + 84*x^3 - 28*x^2 - 8*x + 1
sage: pol48 = x^6 - 4*x^4 + 12*x^2 - 12
sage: pol48.splitting_field('a')
Number Field in a with defining polynomial x^48 ...
If you somehow know the degree of the field in advance, you
should add a ``degree_multiple`` argument. This can speed up the
computation, in particular for polynomials of degree >= 12 or
for relative extensions::
sage: pol15.splitting_field('a', degree_multiple=15)
Number Field in a with defining polynomial x^15 + x^14 - 14*x^13 - 13*x^12 + 78*x^11 + 66*x^10 - 220*x^9 - 165*x^8 + 330*x^7 + 210*x^6 - 252*x^5 - 126*x^4 + 84*x^3 + 28*x^2 - 8*x - 1
A value for ``degree_multiple`` which isn't actually a
multiple of the absolute degree of the splitting field can
either result in a wrong answer or the following exception::
sage: pol48.splitting_field('a', degree_multiple=20)
Traceback (most recent call last):
...
ValueError: inconsistent degree_multiple in splitting_field()
Compute the Galois closure as the splitting field of the defining polynomial::
sage: R.<x> = PolynomialRing(QQ)
sage: pol48 = x^6 - 4*x^4 + 12*x^2 - 12
sage: K.<a> = NumberField(pol48)
sage: L.<b> = pol48.change_ring(K).splitting_field()
sage: L
Number Field in b with defining polynomial x^48 ...
Try all Galois groups over `\QQ` in degree 5 except for `S_5`
(the latter is infeasible with the current implementation)::
sage: C5pol = x^5 + x^4 - 4*x^3 - 3*x^2 + 3*x + 1
sage: C5pol.splitting_field('x')
Number Field in x with defining polynomial x^5 + x^4 - 4*x^3 - 3*x^2 + 3*x + 1
sage: D10pol = x^5 - x^4 - 5*x^3 + 4*x^2 + 3*x - 1
sage: D10pol.splitting_field('x')
Number Field in x with defining polynomial x^10 - 28*x^8 + 216*x^6 - 681*x^4 + 902*x^2 - 401
sage: AGL_1_5pol = x^5 - 2
sage: AGL_1_5pol.splitting_field('x')
Number Field in x with defining polynomial x^20 + 10*x^19 + 55*x^18 + 210*x^17 + 595*x^16 + 1300*x^15 + 2250*x^14 + 3130*x^13 + 3585*x^12 + 3500*x^11 + 2965*x^10 + 2250*x^9 + 1625*x^8 + 1150*x^7 + 750*x^6 + 400*x^5 + 275*x^4 + 100*x^3 + 75*x^2 + 25
sage: A5pol = x^5 - x^4 + 2*x^2 - 2*x + 2
sage: A5pol.splitting_field('x')
Number Field in x with defining polynomial x^60 ...
We can use the ``abort_degree`` option if we don't want to compute
fields of too large degree (this can be used to check whether the
splitting field has small degree)::
sage: (x^5+x+3).splitting_field('b', abort_degree=119)
Traceback (most recent call last):
...
SplittingFieldAbort: degree of splitting field equals 120
sage: (x^10+x+3).splitting_field('b', abort_degree=60) # long time (10s on sage.math, 2014)
Traceback (most recent call last):
...
SplittingFieldAbort: degree of splitting field is a multiple of 180
Use the ``degree_divisor`` attribute to recover the divisor of the
degree of the splitting field or ``degree_multiple`` to recover a
multiple::
sage: from sage.rings.number_field.splitting_field import SplittingFieldAbort
sage: try: # long time (4s on sage.math, 2014)
....: (x^8+x+1).splitting_field('b', abort_degree=60, simplify=False)
....: except SplittingFieldAbort as e:
....: print(e.degree_divisor)
....: print(e.degree_multiple)
120
1440
TESTS::
sage: from sage.rings.number_field.splitting_field import splitting_field
sage: splitting_field(polygen(QQ), name='x', map=True, simplify_all=True)
(Number Field in x with defining polynomial x, Ring morphism:
From: Rational Field
To: Number Field in x with defining polynomial x
Defn: 1 |--> 1)
"""
from sage.misc.all import verbose, cputime
degree_multiple = Integer(degree_multiple or 0)
abort_degree = Integer(abort_degree or 0)
# Kpol = PARI polynomial in y defining the extension found so far
F = poly.base_ring()
if is_RationalField(F):
Kpol = pari("'y")
else:
Kpol = F.pari_polynomial("y")
# Fgen = the generator of F as element of Q[y]/Kpol
# (only needed if map=True)
if map:
Fgen = F.gen().__pari__()
verbose("Starting field: %s" % Kpol)
# L and Lred are lists of SplittingData.
# L contains polynomials which are irreducible over K,
# Lred contains polynomials which need to be factored.
L = []
Lred = [SplittingData(poly._pari_with_name(), degree_multiple)]
# Main loop, handle polynomials one by one
while True:
# Absolute degree of current field K
absolute_degree = Integer(Kpol.poldegree())
# Compute minimum relative degree of splitting field
rel_degree_divisor = Integer(1)
for splitting in L:
rel_degree_divisor = rel_degree_divisor.lcm(splitting.poldegree())
# Check for early aborts
abort_rel_degree = abort_degree // absolute_degree
if abort_rel_degree and rel_degree_divisor > abort_rel_degree:
raise SplittingFieldAbort(absolute_degree * rel_degree_divisor,
degree_multiple)
# First, factor polynomials in Lred and store the result in L
verbose("SplittingData to factor: %s" %
[s._repr_tuple() for s in Lred])
t = cputime()
for splitting in Lred:
m = splitting.dm.gcd(degree_multiple).gcd(
factorial(splitting.poldegree()))
if m == 1:
continue
factors = Kpol.nffactor(splitting.pol)[0]
for q in factors:
d = q.poldegree()
fac = factorial(d)
# Multiple of the degree of the splitting field of q,
# note that the degree equals fac iff the Galois group is S_n.
mq = m.gcd(fac)
if mq == 1:
continue
# Multiple of the degree of the splitting field of q
# over the field defined by adding square root of the
# discriminant.
# If the Galois group is contained in A_n, then mq_alt is
# also the degree multiple over the current field K.
# Here, we have equality if the Galois group is A_n.
mq_alt = mq.gcd(fac // 2)
# If we are over Q, then use PARI's polgalois() to compute
# these degrees exactly.
if absolute_degree == 1:
try:
G = q.polgalois()
except PariError:
pass
else:
mq = Integer(G[0])
mq_alt = mq // 2 if (G[1] == -1) else mq
# In degree 4, use the cubic resolvent to refine the
# degree bounds.
if d == 4 and mq >= 12: # mq equals 12 or 24
# Compute cubic resolvent
a0, a1, a2, a3, a4 = (q / q.pollead()).Vecrev()
assert a4 == 1
cubicpol = pari([
4 * a0 * a2 - a1 * a1 - a0 * a3 * a3, a1 * a3 - 4 * a0,
-a2, 1
]).Polrev()
cubicfactors = Kpol.nffactor(cubicpol)[0]
if len(cubicfactors) == 1: # A4 or S4
# After adding a root of the cubic resolvent,
# the degree of the extension defined by q
# is a factor 3 smaller.
L.append(SplittingData(cubicpol, 3))
rel_degree_divisor = rel_degree_divisor.lcm(3)
mq = mq // 3 # 4 or 8
mq_alt = 4
elif len(cubicfactors) == 2: # C4 or D8
# The irreducible degree 2 factor is
# equivalent to x^2 - q.poldisc().
discpol = cubicfactors[1]
L.append(SplittingData(discpol, 2))
mq = mq_alt = 4
else: # C2 x C2
mq = mq_alt = 4
if mq > mq_alt >= 3:
# Add quadratic resolvent x^2 - D to decrease
# the degree multiple by a factor 2.
discpol = pari([-q.poldisc(), 0, 1]).Polrev()
discfactors = Kpol.nffactor(discpol)[0]
if len(discfactors) == 1:
# Discriminant is not a square
L.append(SplittingData(discpol, 2))
rel_degree_divisor = rel_degree_divisor.lcm(2)
mq = mq_alt
L.append(SplittingData(q, mq))
rel_degree_divisor = rel_degree_divisor.lcm(q.poldegree())
if abort_rel_degree and rel_degree_divisor > abort_rel_degree:
raise SplittingFieldAbort(
absolute_degree * rel_degree_divisor, degree_multiple)
verbose("Done factoring", t, level=2)
if len(L) == 0: # Nothing left to do
break
# Recompute absolute degree multiple
new_degree_multiple = absolute_degree
for splitting in L:
new_degree_multiple *= splitting.dm
degree_multiple = new_degree_multiple.gcd(degree_multiple)
# Absolute degree divisor
degree_divisor = rel_degree_divisor * absolute_degree
# Sort according to degree to handle low degrees first
L.sort(key=lambda x: x.key())
verbose("SplittingData to handle: %s" % [s._repr_tuple() for s in L])
verbose("Bounds for absolute degree: [%s, %s]" %
(degree_divisor, degree_multiple))
# Check consistency
if degree_multiple % degree_divisor != 0:
raise ValueError(
"inconsistent degree_multiple in splitting_field()")
for splitting in L:
# The degree of the splitting field must be a multiple of
# the degree of the polynomial. Only do this check for
# SplittingData with minimal dm, because the higher dm are
# defined as relative degree over the splitting field of
# the polynomials with lesser dm.
if splitting.dm > L[0].dm:
break
if splitting.dm % splitting.poldegree() != 0:
raise ValueError(
"inconsistent degree_multiple in splitting_field()")
# Add a root of f = L[0] to construct the field N = K[x]/f(x)
splitting = L[0]
f = splitting.pol
verbose("Handling polynomial %s" % (f.lift()), level=2)
t = cputime()
Npol, KtoN, k = Kpol.rnfequation(f, flag=1)
# Make Npol monic integral primitive, store in Mpol
# (after this, we don't need Npol anymore, only Mpol)
Mdiv = pari(1)
Mpol = Npol
while True:
denom = Integer(Mpol.pollead())
if denom == 1:
break
denom = pari(denom.factor().radical_value())
Mpol = (Mpol * (denom**Mpol.poldegree())).subst(
"x",
pari([0, 1 / denom]).Polrev("x"))
Mpol /= Mpol.content()
Mdiv *= denom
# We are finished for sure if we hit the degree bound
finished = (Mpol.poldegree() >= degree_multiple)
if simplify_all or (simplify and not finished):
# Find a simpler defining polynomial Lpol for Mpol
verbose("New field before simplifying: %s" % Mpol, t)
t = cputime()
M = Mpol.polred(flag=3)
n = len(M[0]) - 1
Lpol = M[1][n].change_variable_name("y")
LtoM = M[0][n].change_variable_name("y").Mod(
Mpol.change_variable_name("y"))
MtoL = LtoM.modreverse()
else:
# Lpol = Mpol
Lpol = Mpol.change_variable_name("y")
MtoL = pari("'y")
NtoL = MtoL / Mdiv
KtoL = KtoN.lift().subst("x", NtoL).Mod(Lpol)
Kpol = Lpol # New Kpol (for next iteration)
verbose("New field: %s" % Kpol, t)
if map:
t = cputime()
Fgen = Fgen.lift().subst("y", KtoL)
verbose("Computed generator of F in K", t, level=2)
if finished:
break
t = cputime()
# Convert f and elements of L from K to L and store in L
# (if the polynomial is certain to remain irreducible) or Lred.
Lold = L[1:]
L = []
Lred = []
# First add f divided by the linear factor we obtained,
# mg is the new degree multiple.
mg = splitting.dm // f.poldegree()
if mg > 1:
g = [c.subst("y", KtoL).Mod(Lpol) for c in f.Vecrev().lift()]
g = pari(g).Polrev()
g /= pari([k * KtoL - NtoL, 1]).Polrev() # divide linear factor
Lred.append(SplittingData(g, mg))
for splitting in Lold:
g = [c.subst("y", KtoL) for c in splitting.pol.Vecrev().lift()]
g = pari(g).Polrev()
mg = splitting.dm
if Integer(g.poldegree()).gcd(
f.poldegree()) == 1: # linearly disjoint fields
L.append(SplittingData(g, mg))
else:
Lred.append(SplittingData(g, mg))
verbose("Converted polynomials to new field", t, level=2)
# Convert Kpol to Sage and construct the absolute number field
Kpol = PolynomialRing(RationalField(),
name=poly.variable_name())(Kpol / Kpol.pollead())
K = NumberField(Kpol, name)
if map:
return K, F.hom(Fgen, K)
else:
return K
def __find_eisen_chars(character, k):
"""
Find all triples `(\psi_1, \psi_2, t)` that give rise to an Eisenstein series of the given weight and character.
EXAMPLES::
sage: sage.modular.modform.eis_series.__find_eisen_chars(DirichletGroup(36).0, 4)
[]
sage: pars = sage.modular.modform.eis_series.__find_eisen_chars(DirichletGroup(36).0, 5)
sage: [(x[0].values_on_gens(), x[1].values_on_gens(), x[2]) for x in pars]
[((1, 1), (-1, 1), 1),
((1, 1), (-1, 1), 3),
((1, 1), (-1, 1), 9),
((1, -1), (-1, -1), 1),
((-1, 1), (1, 1), 1),
((-1, 1), (1, 1), 3),
((-1, 1), (1, 1), 9),
((-1, -1), (1, -1), 1)]
"""
N = character.modulus()
if character.is_trivial():
if k % 2 != 0:
return []
char_inv = ~character
V = [(character, char_inv, t) for t in divisors(N) if t > 1]
if k != 2:
V.insert(0, (character, char_inv, 1))
if is_squarefree(N):
return V
# Now include all pairs (chi,chi^(-1)) such that cond(chi)^2 divides N:
# TODO: Optimize -- this is presumably way too hard work below.
G = dirichlet.DirichletGroup(N)
for chi in G:
if not chi.is_trivial():
f = chi.conductor()
if N % (f**2) == 0:
chi = chi.minimize_base_ring()
chi_inv = ~chi
for t in divisors(N // (f**2)):
V.insert(0, (chi, chi_inv, t))
return V
eps = character
if eps(-1) != (-1)**k:
return []
eps = eps.maximize_base_ring()
G = eps.parent()
# Find all pairs chi, psi such that:
#
# (1) cond(chi)*cond(psi) divides the level, and
#
# (2) chi*psi == eps, where eps is the nebentypus character of self.
#
# See [Miyake, Modular Forms] Lemma 7.1.1.
K = G.base_ring()
C = {}
t0 = misc.cputime()
for e in G:
m = Integer(e.conductor())
if m in C:
C[m].append(e)
else:
C[m] = [e]
misc.verbose("Enumeration with conductors.", t0)
params = []
for L in divisors(N):
misc.verbose("divisor %s" % L)
if L not in C:
continue
GL = C[L]
for R in divisors(N / L):
if R not in C:
continue
GR = C[R]
for chi in GL:
for psi in GR:
if chi * psi == eps:
chi0, psi0 = __common_minimal_basering(chi, psi)
for t in divisors(N // (R * L)):
if k != 1 or ((psi0, chi0, t) not in params):
params.append((chi0, psi0, t))
return params
def splitting_field(poly, name, map=False, degree_multiple=None, abort_degree=None, simplify=True, simplify_all=False):
"""
Compute the splitting field of a given polynomial, defined over a
number field.
INPUT:
- ``poly`` -- a monic polynomial over a number field
- ``name`` -- a variable name for the number field
- ``map`` -- (default: ``False``) also return an embedding of
``poly`` into the resulting field. Note that computing this
embedding might be expensive.
- ``degree_multiple`` -- a multiple of the absolute degree of
the splitting field. If ``degree_multiple`` equals the actual
degree, this can enormously speed up the computation.
- ``abort_degree`` -- abort by raising a :class:`SplittingFieldAbort`
if it can be determined that the absolute degree of the splitting
field is strictly larger than ``abort_degree``.
- ``simplify`` -- (default: ``True``) during the algorithm, try
to find a simpler defining polynomial for the intermediate
number fields using PARI's ``polred()``. This usually speeds
up the computation but can also considerably slow it down.
Try and see what works best in the given situation.
- ``simplify_all`` -- (default: ``False``) If ``True``, simplify
intermediate fields and also the resulting number field.
OUTPUT:
If ``map`` is ``False``, the splitting field as an absolute number
field. If ``map`` is ``True``, a tuple ``(K, phi)`` where ``phi``
is an embedding of the base field in ``K``.
EXAMPLES::
sage: R.<x> = PolynomialRing(QQ)
sage: K.<a> = (x^3 + 2).splitting_field(); K
Number Field in a with defining polynomial x^6 + 3*x^5 + 6*x^4 + 11*x^3 + 12*x^2 - 3*x + 1
sage: K.<a> = (x^3 - 3*x + 1).splitting_field(); K
Number Field in a with defining polynomial x^3 - 3*x + 1
The ``simplify`` and ``simplify_all`` flags usually yield
fields defined by polynomials with smaller coefficients.
By default, ``simplify`` is True and ``simplify_all`` is False.
::
sage: (x^4 - x + 1).splitting_field('a', simplify=False)
Number Field in a with defining polynomial x^24 - 2780*x^22 + 2*x^21 + 3527512*x^20 - 2876*x^19 - 2701391985*x^18 + 945948*x^17 + 1390511639677*x^16 + 736757420*x^15 - 506816498313560*x^14 - 822702898220*x^13 + 134120588299548463*x^12 + 362240696528256*x^11 - 25964582366880639486*x^10 - 91743672243419990*x^9 + 3649429473447308439427*x^8 + 14310332927134072336*x^7 - 363192569823568746892571*x^6 - 1353403793640477725898*x^5 + 24293393281774560140427565*x^4 + 70673814899934142357628*x^3 - 980621447508959243128437933*x^2 - 1539841440617805445432660*x + 18065914012013502602456565991
sage: (x^4 - x + 1).splitting_field('a', simplify=True)
Number Field in a with defining polynomial x^24 + 8*x^23 - 32*x^22 - 310*x^21 + 540*x^20 + 4688*x^19 - 6813*x^18 - 32380*x^17 + 49525*x^16 + 102460*x^15 - 129944*x^14 - 287884*x^13 + 372727*x^12 + 150624*x^11 - 110530*x^10 - 566926*x^9 + 1062759*x^8 - 779940*x^7 + 863493*x^6 - 1623578*x^5 + 1759513*x^4 - 955624*x^3 + 459975*x^2 - 141948*x + 53919
sage: (x^4 - x + 1).splitting_field('a', simplify_all=True)
Number Field in a with defining polynomial x^24 - 3*x^23 + 2*x^22 - x^20 + 4*x^19 + 32*x^18 - 35*x^17 - 92*x^16 + 49*x^15 + 163*x^14 - 15*x^13 - 194*x^12 - 15*x^11 + 163*x^10 + 49*x^9 - 92*x^8 - 35*x^7 + 32*x^6 + 4*x^5 - x^4 + 2*x^2 - 3*x + 1
Reducible polynomials also work::
sage: pol = (x^4 - 1)*(x^2 + 1/2)*(x^2 + 1/3)
sage: pol.splitting_field('a', simplify_all=True)
Number Field in a with defining polynomial x^8 - x^4 + 1
Relative situation::
sage: R.<x> = PolynomialRing(QQ)
sage: K.<a> = NumberField(x^3 + 2)
sage: S.<t> = PolynomialRing(K)
sage: L.<b> = (t^2 - a).splitting_field()
sage: L
Number Field in b with defining polynomial t^6 + 2
With ``map=True``, we also get the embedding of the base field
into the splitting field::
sage: L.<b>, phi = (t^2 - a).splitting_field(map=True)
sage: phi
Ring morphism:
From: Number Field in a with defining polynomial x^3 + 2
To: Number Field in b with defining polynomial t^6 + 2
Defn: a |--> b^2
sage: (x^4 - x + 1).splitting_field('a', simplify_all=True, map=True)[1]
Ring morphism:
From: Rational Field
To: Number Field in a with defining polynomial x^24 - 3*x^23 + 2*x^22 - x^20 + 4*x^19 + 32*x^18 - 35*x^17 - 92*x^16 + 49*x^15 + 163*x^14 - 15*x^13 - 194*x^12 - 15*x^11 + 163*x^10 + 49*x^9 - 92*x^8 - 35*x^7 + 32*x^6 + 4*x^5 - x^4 + 2*x^2 - 3*x + 1
Defn: 1 |--> 1
We can enable verbose messages::
sage: set_verbose(2)
sage: K.<a> = (x^3 - x + 1).splitting_field()
verbose 1 (...: splitting_field.py, splitting_field) Starting field: y
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to factor: [(3, 0)]
verbose 2 (...: splitting_field.py, splitting_field) Done factoring (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to handle: [(2, 2), (3, 3)]
verbose 1 (...: splitting_field.py, splitting_field) Bounds for absolute degree: [6, 6]
verbose 2 (...: splitting_field.py, splitting_field) Handling polynomial x^2 + 23
verbose 1 (...: splitting_field.py, splitting_field) New field before simplifying: x^2 + 23 (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) New field: y^2 - y + 6 (time = ...)
verbose 2 (...: splitting_field.py, splitting_field) Converted polynomials to new field (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to factor: []
verbose 2 (...: splitting_field.py, splitting_field) Done factoring (time = ...)
verbose 1 (...: splitting_field.py, splitting_field) SplittingData to handle: [(3, 3)]
verbose 1 (...: splitting_field.py, splitting_field) Bounds for absolute degree: [6, 6]
verbose 2 (...: splitting_field.py, splitting_field) Handling polynomial x^3 - x + 1
verbose 1 (...: splitting_field.py, splitting_field) New field: y^6 + 3*y^5 + 19*y^4 + 35*y^3 + 127*y^2 + 73*y + 271 (time = ...)
sage: set_verbose(0)
Try all Galois groups in degree 4. We use a quadratic base field
such that ``polgalois()`` cannot be used::
sage: R.<x> = PolynomialRing(QuadraticField(-11))
sage: C2C2pol = x^4 - 10*x^2 + 1
sage: C2C2pol.splitting_field('x')
Number Field in x with defining polynomial x^8 + 24*x^6 + 608*x^4 + 9792*x^2 + 53824
sage: C4pol = x^4 + x^3 + x^2 + x + 1
sage: C4pol.splitting_field('x')
Number Field in x with defining polynomial x^8 - x^7 - 2*x^6 + 5*x^5 + x^4 + 15*x^3 - 18*x^2 - 27*x + 81
sage: D8pol = x^4 - 2
sage: D8pol.splitting_field('x')
Number Field in x with defining polynomial x^16 + 8*x^15 + 68*x^14 + 336*x^13 + 1514*x^12 + 5080*x^11 + 14912*x^10 + 35048*x^9 + 64959*x^8 + 93416*x^7 + 88216*x^6 + 41608*x^5 - 25586*x^4 - 60048*x^3 - 16628*x^2 + 12008*x + 34961
sage: A4pol = x^4 - 4*x^3 + 14*x^2 - 28*x + 21
sage: A4pol.splitting_field('x')
Number Field in x with defining polynomial x^24 - 20*x^23 + 290*x^22 - 3048*x^21 + 26147*x^20 - 186132*x^19 + 1130626*x^18 - 5913784*x^17 + 26899345*x^16 - 106792132*x^15 + 371066538*x^14 - 1127792656*x^13 + 2991524876*x^12 - 6888328132*x^11 + 13655960064*x^10 - 23000783036*x^9 + 32244796382*x^8 - 36347834476*x^7 + 30850889884*x^6 - 16707053128*x^5 + 1896946429*x^4 + 4832907884*x^3 - 3038258802*x^2 - 200383596*x + 593179173
sage: S4pol = x^4 + x + 1
sage: S4pol.splitting_field('x')
Number Field in x with defining polynomial x^48 ...
Some bigger examples::
sage: R.<x> = PolynomialRing(QQ)
sage: pol15 = chebyshev_T(31, x) - 1 # 2^30*(x-1)*minpoly(cos(2*pi/31))^2
sage: pol15.splitting_field('a')
Number Field in a with defining polynomial x^15 - x^14 - 14*x^13 + 13*x^12 + 78*x^11 - 66*x^10 - 220*x^9 + 165*x^8 + 330*x^7 - 210*x^6 - 252*x^5 + 126*x^4 + 84*x^3 - 28*x^2 - 8*x + 1
sage: pol48 = x^6 - 4*x^4 + 12*x^2 - 12
sage: pol48.splitting_field('a')
Number Field in a with defining polynomial x^48 ...
If you somehow know the degree of the field in advance, you
should add a ``degree_multiple`` argument. This can speed up the
computation, in particular for polynomials of degree >= 12 or
for relative extensions::
sage: pol15.splitting_field('a', degree_multiple=15)
Number Field in a with defining polynomial x^15 + x^14 - 14*x^13 - 13*x^12 + 78*x^11 + 66*x^10 - 220*x^9 - 165*x^8 + 330*x^7 + 210*x^6 - 252*x^5 - 126*x^4 + 84*x^3 + 28*x^2 - 8*x - 1
A value for ``degree_multiple`` which isn't actually a
multiple of the absolute degree of the splitting field can
either result in a wrong answer or the following exception::
sage: pol48.splitting_field('a', degree_multiple=20)
Traceback (most recent call last):
...
ValueError: inconsistent degree_multiple in splitting_field()
Compute the Galois closure as the splitting field of the defining polynomial::
sage: R.<x> = PolynomialRing(QQ)
sage: pol48 = x^6 - 4*x^4 + 12*x^2 - 12
sage: K.<a> = NumberField(pol48)
sage: L.<b> = pol48.change_ring(K).splitting_field()
sage: L
Number Field in b with defining polynomial x^48 ...
Try all Galois groups over `\QQ` in degree 5 except for `S_5`
(the latter is infeasible with the current implementation)::
sage: C5pol = x^5 + x^4 - 4*x^3 - 3*x^2 + 3*x + 1
sage: C5pol.splitting_field('x')
Number Field in x with defining polynomial x^5 + x^4 - 4*x^3 - 3*x^2 + 3*x + 1
sage: D10pol = x^5 - x^4 - 5*x^3 + 4*x^2 + 3*x - 1
sage: D10pol.splitting_field('x')
Number Field in x with defining polynomial x^10 - 28*x^8 + 216*x^6 - 681*x^4 + 902*x^2 - 401
sage: AGL_1_5pol = x^5 - 2
sage: AGL_1_5pol.splitting_field('x')
Number Field in x with defining polynomial x^20 + 10*x^19 + 55*x^18 + 210*x^17 + 595*x^16 + 1300*x^15 + 2250*x^14 + 3130*x^13 + 3585*x^12 + 3500*x^11 + 2965*x^10 + 2250*x^9 + 1625*x^8 + 1150*x^7 + 750*x^6 + 400*x^5 + 275*x^4 + 100*x^3 + 75*x^2 + 25
sage: A5pol = x^5 - x^4 + 2*x^2 - 2*x + 2
sage: A5pol.splitting_field('x')
Number Field in x with defining polynomial x^60 ...
We can use the ``abort_degree`` option if we don't want to compute
fields of too large degree (this can be used to check whether the
splitting field has small degree)::
sage: (x^5+x+3).splitting_field('b', abort_degree=119)
Traceback (most recent call last):
...
SplittingFieldAbort: degree of splitting field equals 120
sage: (x^10+x+3).splitting_field('b', abort_degree=60) # long time (10s on sage.math, 2014)
Traceback (most recent call last):
...
SplittingFieldAbort: degree of splitting field is a multiple of 180
Use the ``degree_divisor`` attribute to recover the divisor of the
degree of the splitting field or ``degree_multiple`` to recover a
multiple::
sage: from sage.rings.number_field.splitting_field import SplittingFieldAbort
sage: try: # long time (4s on sage.math, 2014)
....: (x^8+x+1).splitting_field('b', abort_degree=60, simplify=False)
....: except SplittingFieldAbort as e:
....: print(e.degree_divisor)
....: print(e.degree_multiple)
120
1440
TESTS::
sage: from sage.rings.number_field.splitting_field import splitting_field
sage: splitting_field(polygen(QQ), name='x', map=True, simplify_all=True)
(Number Field in x with defining polynomial x, Ring morphism:
From: Rational Field
To: Number Field in x with defining polynomial x
Defn: 1 |--> 1)
"""
from sage.misc.all import verbose, cputime
degree_multiple = Integer(degree_multiple or 0)
abort_degree = Integer(abort_degree or 0)
# Kpol = PARI polynomial in y defining the extension found so far
F = poly.base_ring()
if is_RationalField(F):
Kpol = pari("'y")
else:
Kpol = F.pari_polynomial("y")
# Fgen = the generator of F as element of Q[y]/Kpol
# (only needed if map=True)
if map:
Fgen = F.gen().__pari__()
verbose("Starting field: %s"%Kpol)
# L and Lred are lists of SplittingData.
# L contains polynomials which are irreducible over K,
# Lred contains polynomials which need to be factored.
L = []
Lred = [SplittingData(poly._pari_with_name(), degree_multiple)]
# Main loop, handle polynomials one by one
while True:
# Absolute degree of current field K
absolute_degree = Integer(Kpol.poldegree())
# Compute minimum relative degree of splitting field
rel_degree_divisor = Integer(1)
for splitting in L:
rel_degree_divisor = rel_degree_divisor.lcm(splitting.poldegree())
# Check for early aborts
abort_rel_degree = abort_degree//absolute_degree
if abort_rel_degree and rel_degree_divisor > abort_rel_degree:
raise SplittingFieldAbort(absolute_degree * rel_degree_divisor, degree_multiple)
# First, factor polynomials in Lred and store the result in L
verbose("SplittingData to factor: %s"%[s._repr_tuple() for s in Lred])
t = cputime()
for splitting in Lred:
m = splitting.dm.gcd(degree_multiple).gcd(factorial(splitting.poldegree()))
if m == 1:
continue
factors = Kpol.nffactor(splitting.pol)[0]
for q in factors:
d = q.poldegree()
fac = factorial(d)
# Multiple of the degree of the splitting field of q,
# note that the degree equals fac iff the Galois group is S_n.
mq = m.gcd(fac)
if mq == 1:
continue
# Multiple of the degree of the splitting field of q
# over the field defined by adding square root of the
# discriminant.
# If the Galois group is contained in A_n, then mq_alt is
# also the degree multiple over the current field K.
# Here, we have equality if the Galois group is A_n.
mq_alt = mq.gcd(fac//2)
# If we are over Q, then use PARI's polgalois() to compute
# these degrees exactly.
if absolute_degree == 1:
try:
G = q.polgalois()
except PariError:
pass
else:
mq = Integer(G[0])
mq_alt = mq//2 if (G[1] == -1) else mq
# In degree 4, use the cubic resolvent to refine the
# degree bounds.
if d == 4 and mq >= 12: # mq equals 12 or 24
# Compute cubic resolvent
a0, a1, a2, a3, a4 = (q/q.pollead()).Vecrev()
assert a4 == 1
cubicpol = pari([4*a0*a2 - a1*a1 -a0*a3*a3, a1*a3 - 4*a0, -a2, 1]).Polrev()
cubicfactors = Kpol.nffactor(cubicpol)[0]
if len(cubicfactors) == 1: # A4 or S4
# After adding a root of the cubic resolvent,
# the degree of the extension defined by q
# is a factor 3 smaller.
L.append(SplittingData(cubicpol, 3))
rel_degree_divisor = rel_degree_divisor.lcm(3)
mq = mq//3 # 4 or 8
mq_alt = 4
elif len(cubicfactors) == 2: # C4 or D8
# The irreducible degree 2 factor is
# equivalent to x^2 - q.poldisc().
discpol = cubicfactors[1]
L.append(SplittingData(discpol, 2))
mq = mq_alt = 4
else: # C2 x C2
mq = mq_alt = 4
if mq > mq_alt >= 3:
# Add quadratic resolvent x^2 - D to decrease
# the degree multiple by a factor 2.
discpol = pari([-q.poldisc(), 0, 1]).Polrev()
discfactors = Kpol.nffactor(discpol)[0]
if len(discfactors) == 1:
# Discriminant is not a square
L.append(SplittingData(discpol, 2))
rel_degree_divisor = rel_degree_divisor.lcm(2)
mq = mq_alt
L.append(SplittingData(q, mq))
rel_degree_divisor = rel_degree_divisor.lcm(q.poldegree())
if abort_rel_degree and rel_degree_divisor > abort_rel_degree:
raise SplittingFieldAbort(absolute_degree * rel_degree_divisor, degree_multiple)
verbose("Done factoring", t, level=2)
if len(L) == 0: # Nothing left to do
break
# Recompute absolute degree multiple
new_degree_multiple = absolute_degree
for splitting in L:
new_degree_multiple *= splitting.dm
degree_multiple = new_degree_multiple.gcd(degree_multiple)
# Absolute degree divisor
degree_divisor = rel_degree_divisor * absolute_degree
# Sort according to degree to handle low degrees first
L.sort(key=lambda x: x.key())
verbose("SplittingData to handle: %s"%[s._repr_tuple() for s in L])
verbose("Bounds for absolute degree: [%s, %s]"%(degree_divisor,degree_multiple))
# Check consistency
if degree_multiple % degree_divisor != 0:
raise ValueError("inconsistent degree_multiple in splitting_field()")
for splitting in L:
# The degree of the splitting field must be a multiple of
# the degree of the polynomial. Only do this check for
# SplittingData with minimal dm, because the higher dm are
# defined as relative degree over the splitting field of
# the polynomials with lesser dm.
if splitting.dm > L[0].dm:
break
if splitting.dm % splitting.poldegree() != 0:
raise ValueError("inconsistent degree_multiple in splitting_field()")
# Add a root of f = L[0] to construct the field N = K[x]/f(x)
splitting = L[0]
f = splitting.pol
verbose("Handling polynomial %s"%(f.lift()), level=2)
t = cputime()
Npol, KtoN, k = Kpol.rnfequation(f, flag=1)
# Make Npol monic integral primitive, store in Mpol
# (after this, we don't need Npol anymore, only Mpol)
Mdiv = pari(1)
Mpol = Npol
while True:
denom = Integer(Mpol.pollead())
if denom == 1:
break
denom = pari(denom.factor().radical_value())
Mpol = (Mpol*(denom**Mpol.poldegree())).subst("x", pari([0,1/denom]).Polrev("x"))
Mpol /= Mpol.content()
Mdiv *= denom
# We are finished for sure if we hit the degree bound
finished = (Mpol.poldegree() >= degree_multiple)
if simplify_all or (simplify and not finished):
# Find a simpler defining polynomial Lpol for Mpol
verbose("New field before simplifying: %s"%Mpol, t)
t = cputime()
M = Mpol.polred(flag=3)
n = len(M[0])-1
Lpol = M[1][n].change_variable_name("y")
LtoM = M[0][n].change_variable_name("y").Mod(Mpol.change_variable_name("y"))
MtoL = LtoM.modreverse()
else:
# Lpol = Mpol
Lpol = Mpol.change_variable_name("y")
MtoL = pari("'y")
NtoL = MtoL/Mdiv
KtoL = KtoN.lift().subst("x", NtoL).Mod(Lpol)
Kpol = Lpol # New Kpol (for next iteration)
verbose("New field: %s"%Kpol, t)
if map:
t = cputime()
Fgen = Fgen.lift().subst("y", KtoL)
verbose("Computed generator of F in K", t, level=2)
if finished:
break
t = cputime()
# Convert f and elements of L from K to L and store in L
# (if the polynomial is certain to remain irreducible) or Lred.
Lold = L[1:]
L = []
Lred = []
# First add f divided by the linear factor we obtained,
# mg is the new degree multiple.
mg = splitting.dm//f.poldegree()
if mg > 1:
g = [c.subst("y", KtoL).Mod(Lpol) for c in f.Vecrev().lift()]
g = pari(g).Polrev()
g /= pari([k*KtoL - NtoL, 1]).Polrev() # divide linear factor
Lred.append(SplittingData(g, mg))
for splitting in Lold:
g = [c.subst("y", KtoL) for c in splitting.pol.Vecrev().lift()]
g = pari(g).Polrev()
mg = splitting.dm
if Integer(g.poldegree()).gcd(f.poldegree()) == 1: # linearly disjoint fields
L.append(SplittingData(g, mg))
else:
Lred.append(SplittingData(g, mg))
verbose("Converted polynomials to new field", t, level=2)
# Convert Kpol to Sage and construct the absolute number field
Kpol = PolynomialRing(RationalField(), name=poly.variable_name())(Kpol/Kpol.pollead())
K = NumberField(Kpol, name)
if map:
return K, F.hom(Fgen, K)
else:
return K
def cuspidal_ideal_generators(self, maxweight=8, prec=None):
r"""
Calculate generators for the ideal of cuspidal forms in this ring, as a
module over the whole ring.
EXAMPLES::
sage: ModularFormsRing(Gamma0(3)).cuspidal_ideal_generators(maxweight=12)
[(6, q - 6*q^2 + 9*q^3 + 4*q^4 + O(q^5), q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6))]
sage: [k for k,f,F in ModularFormsRing(13, base_ring=ZZ).cuspidal_ideal_generators(maxweight=14)]
[4, 4, 4, 6, 6, 12]
"""
working_prec = self.modular_forms_of_weight(maxweight).sturm_bound()
if self.__cached_cusp_maxweight > -1:
k = self.__cached_cusp_maxweight + 1
verbose(
"Already calculated cusp gens up to weight %s -- using those" %
(k - 1))
# we may need to increase the precision of the cached cusp
# generators
G = []
for j, f, F in self.__cached_cusp_gens:
if f.prec() >= working_prec:
f = F.qexp(working_prec).change_ring(self.base_ring())
G.append((j, f, F))
else:
k = 2
G = []
while k <= maxweight:
t = verbose("Looking for cusp generators in weight %s" % k)
kprec = self.modular_forms_of_weight(k).sturm_bound()
flist = []
for (j, f, F) in G:
for g in self.q_expansion_basis(k - j, prec=kprec):
flist.append(g * f)
A = self.base_ring()**kprec
W = A.span([A(f.padded_list(kprec)) for f in flist])
S = self.modular_forms_of_weight(k).cuspidal_submodule()
if (W.rank() == S.dimension() and
(self.base_ring().is_field() or W.index_in_saturation() == 1)):
verbose("Nothing new in weight %s" % k, t)
k += 1
continue
t = verbose(
"Known cusp generators span a submodule of dimension %s of space of dimension %s"
% (W.rank(), S.dimension()), t)
B = S.q_integral_basis(prec=working_prec)
V = A.span([
A(f.change_ring(self.base_ring()).padded_list(kprec))
for f in B
])
Q = V / W
for q in Q.gens():
try:
qc = V.coordinates(Q.lift(q))
except AttributeError:
# work around a silly free module bug
qc = V.coordinates(q.lift())
qcZZ = [ZZ(_) for _ in qc] # lift to ZZ so we can define F
f = sum([B[i] * qcZZ[i] for i in range(len(B))])
F = S(f)
G.append((k, f.change_ring(self.base_ring()), F))
verbose('added %s new generators' % Q.ngens(), t)
k += 1
self.__cached_cusp_maxweight = maxweight
self.__cached_cusp_gens = G
if prec is None:
return G
elif prec <= working_prec:
return [(k, f.truncate_powerseries(prec), F) for k, f, F in G]
else:
# user wants increased precision, so we may as well cache that
Gnew = [(k, F.qexp(prec).change_ring(self.base_ring()), F)
for k, f, F in G]
self.__cached_cusp_gens = Gnew
return Gnew
def _find_scaling_L_ratio(self):
r"""
This function is use to set ``_scaling``, the factor used to adjust the
scalar multiple of the modular symbol.
If `[0]`, the modular symbol evaluated at 0, is non-zero, we can just scale
it with respect to the approximation of the L-value. It is known that
the quotient is a rational number with small denominator.
Otherwise we try to scale using quadratic twists.
``_scaling`` will be set to a rational non-zero multiple if we succeed and to 1 otherwise.
Even if we fail we scale at least to make up the difference between the periods
of the `X_0`-optimal curve and our given curve `E` in the isogeny class.
EXAMPLES::
sage: m = EllipticCurve('11a1').modular_symbol(implementation="sage")
sage: m._scaling
1/5
sage: m = EllipticCurve('11a2').modular_symbol(implementation="sage")
sage: m._scaling
1
sage: m = EllipticCurve('11a3').modular_symbol(implementation="sage")
sage: m._scaling
1/25
sage: m = EllipticCurve('37a1').modular_symbol(implementation="sage")
sage: m._scaling
1
sage: m = EllipticCurve('37a1').modular_symbol()
sage: m._scaling
1
sage: m = EllipticCurve('389a1').modular_symbol()
sage: m._scaling
1
sage: m = EllipticCurve('389a1').modular_symbol(implementation="sage")
sage: m._scaling
2
sage: m = EllipticCurve('196a1').modular_symbol(implementation="sage")
sage: m._scaling
1/2
Some harder cases fail::
sage: m = EllipticCurve('121b1').modular_symbol(implementation="sage")
Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1 and a power of 2
sage: m._scaling
1
TESTS::
sage: rk0 = ['11a1', '11a2', '15a1', '27a1', '37b1']
sage: for la in rk0: # long time (3s on sage.math, 2011)
....: E = EllipticCurve(la)
....: me = E.modular_symbol(implementation="eclib")
....: ms = E.modular_symbol(implementation="sage")
....: print("{} {} {}".format(E.lseries().L_ratio()*E.real_components(), me(0), ms(0)))
1/5 1/5 1/5
1 1 1
1/4 1/4 1/4
1/3 1/3 1/3
2/3 2/3 2/3
sage: rk1 = ['37a1','43a1','53a1', '91b1','91b2','91b3']
sage: [EllipticCurve(la).modular_symbol()(0) for la in rk1] # long time (1s on sage.math, 2011)
[0, 0, 0, 0, 0, 0]
sage: for la in rk1: # long time (8s on sage.math, 2011)
....: E = EllipticCurve(la)
....: m = E.modular_symbol()
....: lp = E.padic_lseries(5)
....: for D in [5,17,12,8]:
....: ED = E.quadratic_twist(D)
....: md = sum([kronecker(D,u)*m(ZZ(u)/D) for u in range(D)])
....: etaD = lp._quotient_of_periods_to_twist(D)
....: assert ED.lseries().L_ratio()*ED.real_components() * etaD == md
"""
E = self._E
self._scaling = 1 # initial value, may be changed later.
self._failed_to_scale = False
if self._sign == 1:
at0 = self(0)
if at0 != 0:
l1 = self.__lalg__(1)
if at0 != l1:
verbose('scale modular symbols by %s' % (l1 / at0))
self._scaling = l1 / at0
else:
# if [0] = 0, we can still hope to scale it correctly by considering twists of E
Dlist = [
5, 8, 12, 13, 17, 21, 24, 28, 29, 33, 37, 40, 41, 44, 53,
56, 57, 60, 61, 65, 69, 73, 76, 77, 85, 88, 89, 92, 93, 97
] # a list of positive fundamental discriminants
j = 0
at0 = 0
# computes [0]+ for the twist of E by D until one value is non-zero
while j < 30 and at0 == 0:
D = Dlist[j]
# the following line checks if the twist of the newform of E by D is a newform
# this is to avoid that we 'twist back'
if all(
valuation(E.conductor(), ell) <= valuation(D, ell)
for ell in prime_divisors(D)):
at0 = sum([
kronecker_symbol(D, u) * self(ZZ(u) / D)
for u in range(1, abs(D))
])
j += 1
if j == 30 and at0 == 0: # curves like "121b1", "225a1", "225e1", "256a1", "256b1", "289a1", "361a1", "400a1", "400c1", "400h1", "441b1", "441c1", "441d1", "441f1 .. will arrive here
print(
"Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1 and a power of 2"
)
self._failed_to_scale = True
else:
l1 = self.__lalg__(D)
if at0 != l1:
verbose('scale modular symbols by %s found at D=%s ' %
(l1 / at0, D),
level=2)
self._scaling = l1 / at0
else: # that is when sign = -1
Dlist = [
-3, -4, -7, -8, -11, -15, -19, -20, -23, -24, -31, -35, -39,
-40, -43, -47, -51, -52, -55, -56, -59, -67, -68, -71, -79,
-83, -84, -87, -88, -91
] # a list of negative fundamental discriminants
j = 0
at0 = 0
while j < 30 and at0 == 0:
# computes [0]+ for the twist of E by D until one value is non-zero
D = Dlist[j]
if all(
valuation(E.conductor(), ell) <= valuation(D, ell)
for ell in prime_divisors(D)):
at0 = -sum([
kronecker_symbol(D, u) * self(ZZ(u) / D)
for u in range(1, abs(D))
])
j += 1
if j == 30 and at0 == 0: # no more hope for a normalization
print(
"Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1 and a power of 2"
)
self._failed_to_scale = True
else:
l1 = self.__lalg__(D)
if at0 != l1:
verbose('scale modular symbols by %s' % (l1 / at0))
self._scaling = l1 / at0
def L_ratio(self):
r"""
Returns the ratio `L(E,1)/\Omega` as an exact rational
number. The result is *provably* correct if the Manin
constant of the associated optimal quotient is `\leq 2`. This
hypothesis on the Manin constant is true for all semistable
curves (i.e., squarefree conductor), by a theorem of Mazur
from his *Rational Isogenies of Prime Degree* paper.
EXAMPLES::
sage: E = EllipticCurve([0, -1, 1, -10, -20]) # 11A = X_0(11)
sage: E.lseries().L_ratio()
1/5
sage: E = EllipticCurve([0, -1, 1, 0, 0]) # X_1(11)
sage: E.lseries().L_ratio()
1/25
sage: E = EllipticCurve([0, 0, 1, -1, 0]) # 37A (rank 1)
sage: E.lseries().L_ratio()
0
sage: E = EllipticCurve([0, 1, 1, -2, 0]) # 389A (rank 2)
sage: E.lseries().L_ratio()
0
sage: E = EllipticCurve([0, 0, 1, -38, 90]) # 361A (CM curve))
sage: E.lseries().L_ratio()
0
sage: E = EllipticCurve([0,-1,1,-2,-1]) # 141C (13-isogeny)
sage: E.lseries().L_ratio()
1
sage: E = EllipticCurve(RationalField(), [1, 0, 0, 1/24624, 1/886464])
sage: E.lseries().L_ratio()
2
See :trac:`3651` and :trac:`15299`::
sage: EllipticCurve([0,0,0,-193^2,0]).sha().an()
4
sage: EllipticCurve([1, 0, 1, -131, 558]).sha().an() # long time
1.00000000000000
ALGORITHM: Compute the root number. If it is -1 then `L(E,s)`
vanishes to odd order at 1, hence vanishes. If it is +1, use
a result about modular symbols and Mazur's *Rational Isogenies*
paper to determine a provably correct bound (assuming Manin
constant is <= 2) so that we can determine whether `L(E,1) = 0`.
AUTHOR: William Stein, 2005-04-20.
"""
try:
return self.__lratio
except AttributeError:
pass
if not self.__E.is_minimal():
self.__lratio = self.__E.minimal_model().lseries().L_ratio()
return self.__lratio
QQ = RationalField()
if self.__E.root_number() == -1:
self.__lratio = QQ.zero()
return self.__lratio
# Even root number. Decide if L(E,1) = 0. If E is a modular
# *OPTIMAL* quotient of J_0(N) elliptic curve, we know that T *
# L(E,1)/omega is an integer n, where T is the order of the
# image of the rational torsion point (0)-(oo) in E(Q), and
# omega is the least real Neron period. (This is proved in my
# Ph.D. thesis, but is probably well known.) We can easily
# compute omega to very high precision using AGM. So to prove
# that L(E,1) = 0 we compute T/omega * L(E,1) to sufficient
# precision to determine it as an integer. If eps is the
# error in computation of L(E,1), then the error in computing
# the product is (2T/Omega_E) * eps, and we need this to be
# less than 0.5, i.e.,
# (2T/Omega_E) * eps < 0.5,
# so
# eps < 0.5 * Omega_E / (2T) = Omega_E / (4*T).
#
# Since in general E need not be optimal, we have to choose
# eps = Omega_E/(8*t*B), where t is the exponent of E(Q)_tor,
# and is a multiple of the degree of an isogeny between E
# and the optimal curve.
#
# NOTES: We *do* have to worry about the Manin constant, since
# we are using the Neron model to compute omega, not the
# newform. My theorem replaces the omega above by omega/c,
# where c is the Manin constant, and the bound must be
# correspondingly smaller. If the level is square free, then
# the Manin constant is 1 or 2, so there's no problem (since
# we took 8 instead of 4 in the denominator). If the level
# is divisible by a square, then the Manin constant could
# be a divisible by an arbitrary power of that prime, except
# that Edixhoven claims the primes that appear are <= 7.
t = self.__E.torsion_subgroup().order()
omega = self.__E.period_lattice().basis()[0]
d = self.__E._multiple_of_degree_of_isogeny_to_optimal_curve()
C = 8 * d * t
eps = omega / C
sqrtN = 2 * int(sqrt(self.__E.conductor()))
k = sqrtN + 10
while True:
L1, error_bound = self.at1(k)
if error_bound < eps:
n = int(round(L1 * C / omega))
quo = QQ((n, C))
self.__lratio = quo / self.__E.real_components()
return self.__lratio
k += sqrtN
misc.verbose("Increasing precision to %s terms." % k)
def _find_scaling_L_ratio(self):
r"""
This function is use to set ``_scaling``, the factor used to adjust the
scalar multiple of the modular symbol.
If `[0]`, the modular symbol evaluated at 0, is non-zero, we can just scale
it with respect to the approximation of the L-value. It is known that
the quotient is a rational number with small denominator.
Otherwise we try to scale using quadratic twists.
``_scaling`` will be set to a rational non-zero multiple if we succeed and to 1 otherwise.
Even if we fail we scale at least to make up the difference between the periods
of the `X_0`-optimal curve and our given curve `E` in the isogeny class.
EXAMPLES::
sage : m = EllipticCurve('11a1').modular_symbol(use_eclib=True)
sage : m._scaling
1
sage: m = EllipticCurve('11a2').modular_symbol(use_eclib=True)
sage: m._scaling
5/2
sage: m = EllipticCurve('11a3').modular_symbol(use_eclib=True)
sage: m._scaling
1/10
sage: m = EllipticCurve('11a1').modular_symbol(use_eclib=False)
sage: m._scaling
1/5
sage: m = EllipticCurve('11a2').modular_symbol(use_eclib=False)
sage: m._scaling
1
sage: m = EllipticCurve('11a3').modular_symbol(use_eclib=False)
sage: m._scaling
1/25
sage: m = EllipticCurve('37a1').modular_symbol(use_eclib=False)
sage: m._scaling
1
sage: m = EllipticCurve('37a1').modular_symbol(use_eclib=True)
sage: m._scaling
-1
sage: m = EllipticCurve('389a1').modular_symbol(use_eclib=True)
sage: m._scaling
-1/2
sage: m = EllipticCurve('389a1').modular_symbol(use_eclib=False)
sage: m._scaling
2
sage: m = EllipticCurve('196a1').modular_symbol(use_eclib=False)
sage: m._scaling
1/2
Some harder cases fail::
sage: m = EllipticCurve('121b1').modular_symbol(use_eclib=False)
Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1, 2 or -2.
sage: m._scaling
1
TESTS::
sage: rk0 = ['11a1', '11a2', '15a1', '27a1', '37b1']
sage: for la in rk0: # long time (3s on sage.math, 2011)
... E = EllipticCurve(la)
... me = E.modular_symbol(use_eclib = True)
... ms = E.modular_symbol(use_eclib = False)
... print E.lseries().L_ratio()*E.real_components(), me(0), ms(0)
1/5 1/5 1/5
1 1 1
1/4 1/4 1/4
1/3 1/3 1/3
2/3 2/3 2/3
sage: rk1 = ['37a1','43a1','53a1', '91b1','91b2','91b3']
sage: [EllipticCurve(la).modular_symbol(use_eclib=True)(0) for la in rk1] # long time (1s on sage.math, 2011)
[0, 0, 0, 0, 0, 0]
sage: for la in rk1: # long time (8s on sage.math, 2011)
... E = EllipticCurve(la)
... m = E.modular_symbol(use_eclib = True)
... lp = E.padic_lseries(5)
... for D in [5,17,12,8]:
... ED = E.quadratic_twist(D)
... md = sum([kronecker(D,u)*m(ZZ(u)/D) for u in range(D)])
... etaa = lp._quotient_of_periods_to_twist(D)
... assert ED.lseries().L_ratio()*ED.real_components()*etaa == md
"""
E = self._E
self._scaling = 1 # by now.
self._failed_to_scale = False
if self._sign == 1 :
at0 = self(0)
# print 'modular symbol evaluates to ',at0,' at 0'
if at0 != 0 :
l1 = self.__lalg__(1)
if at0 != l1:
verbose('scale modular symbols by %s'%(l1/at0))
self._scaling = l1/at0
else :
# if [0] = 0, we can still hope to scale it correctly by considering twists of E
Dlist = [5,8,12,13,17,21,24,28,29, 33, 37, 40, 41, 44, 53, 56, 57, 60, 61, 65, 69, 73, 76, 77, 85, 88, 89, 92, 93, 97] # a list of positive fundamental discriminants
j = 0
at0 = 0
# computes [0]+ for the twist of E by D until one value is non-zero
while j < 30 and at0 == 0 :
D = Dlist[j]
# the following line checks if the twist of the newform of E by D is a newform
# this is to avoid that we 'twist back'
if all( valuation(E.conductor(),ell)<= valuation(D,ell) for ell in prime_divisors(D) ) :
at0 = sum([kronecker_symbol(D,u) * self(ZZ(u)/D) for u in range(1,abs(D))])
j += 1
if j == 30 and at0 == 0: # curves like "121b1", "225a1", "225e1", "256a1", "256b1", "289a1", "361a1", "400a1", "400c1", "400h1", "441b1", "441c1", "441d1", "441f1 .. will arrive here
self.__scale_by_periods_only__()
else :
l1 = self.__lalg__(D)
if at0 != l1:
verbose('scale modular symbols by %s found at D=%s '%(l1/at0,D), level=2)
self._scaling = l1/at0
else : # that is when sign = -1
Dlist = [-3,-4,-7,-8,-11,-15,-19,-20,-23,-24, -31, -35, -39, -40, -43, -47, -51, -52, -55, -56, -59, -67, -68, -71, -79, -83, -84, -87, -88, -91] # a list of negative fundamental discriminants
j = 0
at0 = 0
while j < 30 and at0 == 0 :
# computes [0]+ for the twist of E by D until one value is non-zero
D = Dlist[j]
if all( valuation(E.conductor(),ell)<= valuation(D,ell) for ell in prime_divisors(D) ) :
at0 = - sum([kronecker_symbol(D,u) * self(ZZ(u)/D) for u in range(1,abs(D))])
j += 1
if j == 30 and at0 == 0: # no more hope for a normalization
# we do at least a scaling with the quotient of the periods
self.__scale_by_periods_only__()
else :
l1 = self.__lalg__(D)
if at0 != l1:
verbose('scale modular symbols by %s'%(l1/at0))
self._scaling = l1/at0
def bound_kolyvagin(self, D=0, regulator=None,
ignore_nonsurj_hypothesis=False):
r"""
Given a fundamental discriminant `D \neq -3,-4` that satisfies the
Heegner hypothesis for `E`, return a list of primes so that
Kolyvagin's theorem (as in Gross's paper) implies that any
prime divisor of `Sha` is in this list.
INPUT:
- ``D`` - (optional) a fundamental discriminant < -4 that satisfies
the Heegner hypothesis for `E`; if not given, use the first such `D`
- ``regulator`` -- (optional) regulator of `E(K)`; if not given, will
be computed (which could take a long time)
- ``ignore_nonsurj_hypothesis`` (optional: default ``False``) --
If ``True``, then gives the bound coming from Heegner point
index, but without any hypothesis on surjectivity
of the mod-`p` representation.
OUTPUT:
- list - a list of primes such that if `p` divides `Sha(E/K)`, then
`p` is in this list, unless `E/K` has complex multiplication or
analytic rank greater than 2 (in which case we return 0).
- index - the odd part of the index of the Heegner point in the full
group of `K`-rational points on E. (If `E` has CM, returns 0.)
REMARKS:
1) We do not have to assume that the Manin constant is 1
(or a power of 2). If the Manin constant were
divisible by a prime, that prime would get included in
the list of bad primes.
2) We assume the Gross-Zagier theorem is true under the
hypothesis that `gcd(N,D) = 1`, instead of the stronger
hypothesis `gcd(2\cdot N,D)=1` that is in the original
Gross-Zagier paper. That Gross-Zagier is true when
`gcd(N,D)=1` is "well-known" to the experts, but does not
seem to written up well in the literature.
3) Correctness of the computation is guaranteed using
interval arithmetic, under the assumption that the
regulator, square root, and period lattice are
computed to precision at least `10^{-10}`, i.e., they are
correct up to addition or a real number with absolute
value less than `10^{-10}`.
EXAMPLES::
sage: E = EllipticCurve('37a')
sage: E.sha().bound_kolyvagin()
([2], 1)
sage: E = EllipticCurve('141a')
sage: E.sha().an()
1
sage: E.sha().bound_kolyvagin()
([2, 7], 49)
We get no information when the curve has rank 2.::
sage: E = EllipticCurve('389a')
sage: E.sha().bound_kolyvagin()
(0, 0)
sage: E = EllipticCurve('681b')
sage: E.sha().an()
9
sage: E.sha().bound_kolyvagin()
([2, 3], 9)
"""
E = self.Emin
if E.has_cm():
return 0, 0
if D == 0:
D = -5
while not E.satisfies_heegner_hypothesis(D):
D -= 1
if not E.satisfies_heegner_hypothesis(D):
raise ArithmeticError("Discriminant (=%s) must be a fundamental discriminant that satisfies the Heegner hypothesis."%D)
if D == -3 or D == -4:
raise ArithmeticError("Discriminant (=%s) must not be -3 or -4."%D)
eps = E.root_number()
L1_vanishes = E.lseries().L1_vanishes()
if eps == 1 and L1_vanishes:
return 0, 0 # rank even hence >= 2, so Kolyvagin gives nothing.
alpha = sqrt(abs(D))/(2*E.period_lattice().complex_area())
F = E.quadratic_twist(D)
k_E = 2*sqrt(E.conductor()) + 10
k_F = 2*sqrt(F.conductor()) + 10
#k_E = 2
#k_F = 2
MIN_ERR = 1e-10 # we assume that regulator and
# discriminant, etc., computed to this accuracy.
tries = 0
while True:
tries += 1
if tries >= 6:
raise RuntimeError("Too many precision increases in bound_kolyvagin")
if eps == 1: # E has even rank
verbose("Conductor of twist = %s"%F.conductor())
LF1, err_F = F.lseries().deriv_at1(k_F)
LE1, err_E = E.lseries().at1(k_E)
err_F = max(err_F, MIN_ERR)
err_E = max(err_E, MIN_ERR)
if regulator is not None:
hZ = regulator/2
else:
hZ = F.regulator(use_database=True)/2
#print alpha * LE1 * LF1 / hZ
I = RIF(alpha) * RIF(LE1-err_E,LE1+err_E) * RIF(LF1-err_F,LF1+err_F) / hZ
#print I
else: # E has odd rank
if regulator is not None:
hZ = regulator/2
else:
hZ = E.regulator(use_database=True)/2
LE1, err_E = E.lseries().deriv_at1(k_E)
LF1, err_F = F.lseries().at1(k_F)
err_F = max(err_F, MIN_ERR)
err_E = max(err_E, MIN_ERR)
#I = alpha * LE1 * LF1 / hZ
I = RIF(alpha) * RIF(LE1-err_E,LE1+err_E) * RIF(LF1-err_F,LF1+err_F) / hZ
verbose('interval = %s'%I)
t, n = I.is_int()
if t:
break
elif I.absolute_diameter() < 1:
raise RuntimeError("Problem in bound_kolyvagin; square of index is not an integer -- D=%s, I=%s."%(D,I))
verbose("Doubling bounds")
k_E *= 2
k_F *= 2
# end while
# We include 2 since Kolyvagin (in Gross) says nothing there
if n == 0: return 0, 0 # no bound
F = factor(n)
B = [2]
for p, e in factor(n):
if p > 2:
if e%2 != 0:
raise RuntimeError("Problem in bound_kolyvagin; square of index is not a perfect square! D=%s, I=%s, n=%s, e=%s."%(D,I,n,e))
B.append(p)
else:
n /= 2**e # replace n by its odd part
if not ignore_nonsurj_hypothesis:
for p in E.galois_representation().non_surjective():
B.append(p)
B = sorted(set([int(x) for x in B]))
return B, n
def L_ratio(self):
r"""
Returns the ratio `L(E,1)/\Omega` as an exact rational
number. The result is \emph{provably} correct if the Manin
constant of the associated optimal quotient is `\leq 2`. This
hypothesis on the Manin constant is true for all semistable
curves (i.e., squarefree conductor), by a theorem of Mazur
from his \emph{Rational Isogenies of Prime Degree} paper.
EXAMPLES::
sage: E = EllipticCurve([0, -1, 1, -10, -20]) # 11A = X_0(11)
sage: E.lseries().L_ratio()
1/5
sage: E = EllipticCurve([0, -1, 1, 0, 0]) # X_1(11)
sage: E.lseries().L_ratio()
1/25
sage: E = EllipticCurve([0, 0, 1, -1, 0]) # 37A (rank 1)
sage: E.lseries().L_ratio()
0
sage: E = EllipticCurve([0, 1, 1, -2, 0]) # 389A (rank 2)
sage: E.lseries().L_ratio()
0
sage: E = EllipticCurve([0, 0, 1, -38, 90]) # 361A (CM curve))
sage: E.lseries().L_ratio()
0
sage: E = EllipticCurve([0,-1,1,-2,-1]) # 141C (13-isogeny)
sage: E.lseries().L_ratio()
1
sage: E = EllipticCurve(RationalField(), [1, 0, 0, 1/24624, 1/886464])
sage: E.lseries().L_ratio()
2
See :trac:`3651` and :trac:`15299`::
sage: EllipticCurve([0,0,0,-193^2,0]).sha().an()
4
sage: EllipticCurve([1, 0, 1, -131, 558]).sha().an() # long time
1.00000000000000
ALGORITHM: Compute the root number. If it is -1 then L(E,s)
vanishes to odd order at 1, hence vanishes. If it is +1, use
a result about modular symbols and Mazur's "Rational Isogenies"
paper to determine a provably correct bound (assuming Manin
constant is <= 2) so that we can determine whether L(E,1) = 0.
AUTHOR: William Stein, 2005-04-20.
"""
try:
return self.__lratio
except AttributeError:
pass
if not self.__E.is_minimal():
self.__lratio = self.__E.minimal_model().lseries().L_ratio()
return self.__lratio
QQ = RationalField()
if self.__E.root_number() == -1:
self.__lratio = QQ.zero()
return self.__lratio
# Even root number. Decide if L(E,1) = 0. If E is a modular
# *OPTIMAL* quotient of J_0(N) elliptic curve, we know that T *
# L(E,1)/omega is an integer n, where T is the order of the
# image of the rational torsion point (0)-(oo) in E(Q), and
# omega is the least real Neron period. (This is proved in my
# Ph.D. thesis, but is probably well known.) We can easily
# compute omega to very high precision using AGM. So to prove
# that L(E,1) = 0 we compute T/omega * L(E,1) to sufficient
# precision to determine it as an integer. If eps is the
# error in computation of L(E,1), then the error in computing
# the product is (2T/Omega_E) * eps, and we need this to be
# less than 0.5, i.e.,
# (2T/Omega_E) * eps < 0.5,
# so
# eps < 0.5 * Omega_E / (2T) = Omega_E / (4*T).
#
# Since in general E need not be optimal, we have to choose
# eps = Omega_E/(8*t*B), where t is the exponent of E(Q)_tor,
# and is a multiple of the degree of an isogeny between E
# and the optimal curve.
#
# NOTES: We *do* have to worry about the Manin constant, since
# we are using the Neron model to compute omega, not the
# newform. My theorem replaces the omega above by omega/c,
# where c is the Manin constant, and the bound must be
# correspondingly smaller. If the level is square free, then
# the Manin constant is 1 or 2, so there's no problem (since
# we took 8 instead of 4 in the denominator). If the level
# is divisible by a square, then the Manin constant could
# be a divisible by an arbitrary power of that prime, except
# that Edixhoven claims the primes that appear are <= 7.
t = self.__E.torsion_subgroup().order()
omega = self.__E.period_lattice().basis()[0]
d = self.__E._multiple_of_degree_of_isogeny_to_optimal_curve()
C = 8*d*t
eps = omega / C
sqrtN = 2*int(sqrt(self.__E.conductor()))
k = sqrtN + 10
while True:
L1, error_bound = self.at1(k)
if error_bound < eps:
n = int(round(L1*C/omega))
quo = QQ((n,C))
self.__lratio = quo / self.__E.real_components()
return self.__lratio
k += sqrtN
misc.verbose("Increasing precision to %s terms."%k)
raise IOError, "Sloane encyclopedia is already installed"
tm = verbose("Downloading stripped version of Sloane encyclopedia")
try:
fname, _ = urllib.urlretrieve(oeis_url);
except IOError, msg:
raise IOError, "%s\nError fetching the following website:\n %s\nTry checking your internet connection."%(msg, oeis_url)
if not names_url is None:
try:
nname, _ = urllib.urlretrieve(names_url);
except IOError, msg:
raise IOError, "%s\nError fetching the following website:\n %s\nTry checking your internet connection."%(msg, names_url)
else:
nname = None
verbose("Finished downloading", tm)
self.install_from_gz(fname, nname, overwrite)
# Delete the temporary downloaded files
os.remove(fname)
if not nname is None:
os.remove(nname)
def install_from_gz(self, stripped_file, names_file, overwrite=False):
"""
Install the online encyclopedia from a local stripped.gz file.
INPUT:
- ``stripped_file`` - string. The name of the stripped.gz OEIS file.
def series(self, n=2, quadratic_twist=+1, prec=5):
r"""
Returns the `n`-th approximation to the `p`-adic L-series as a
power series in `T` (corresponding to `\gamma-1` with
`\gamma=1+p` as a generator of `1+p\ZZ_p`). Each coefficient
is a `p`-adic number whose precision is provably correct.
Here the normalization of the `p`-adic L-series is chosen such
that `L_p(J,1) = (1-1/\alpha)^2 L(J,1)/\Omega_J` where
`\alpha` is the unit root
INPUT:
- ``n`` - (default: 2) a positive integer
- ``quadratic_twist`` - (default: +1) a fundamental
discriminant of a quadratic field, coprime to the
conductor of the curve
- ``prec`` - (default: 5) maximal number of terms of the
series to compute; to compute as many as possible just
give a very large number for ``prec``; the result will
still be correct.
ALIAS: power_series is identical to series.
EXAMPLES:
sage: J = J0(188)[0]
sage: p = 7
sage: L = J.padic_lseries(p)
sage: L.is_ordinary()
True
sage: f = L.series(2)
sage: f[0]
O(7^20)
sage: f[1].norm()
3 + 4*7 + 3*7^2 + 6*7^3 + 5*7^4 + 5*7^5 + 6*7^6 + 4*7^7 + 5*7^8 + 7^10 + 5*7^11 + 4*7^13 + 4*7^14 + 5*7^15 + 2*7^16 + 5*7^17 + 7^18 + 7^19 + O(7^20)
"""
n = ZZ(n)
if n < 1:
raise ValueError, "n (=%s) must be a positive integer"%n
if not self.is_ordinary():
raise ValueError, "p (=%s) must be an ordinary prime"%p
# check if the conditions on quadratic_twist are satisfied
D = ZZ(quadratic_twist)
if D != 1:
if D % 4 == 0:
d = D//4
if not d.is_squarefree() or d % 4 == 1:
raise ValueError, "quadratic_twist (=%s) must be a fundamental discriminant of a quadratic field"%D
else:
if not D.is_squarefree() or D % 4 != 1:
raise ValueError, "quadratic_twist (=%s) must be a fundamental discriminant of a quadratic field"%D
if gcd(D,self._p) != 1:
raise ValueError, "quadratic twist (=%s) must be coprime to p (=%s) "%(D,self._p)
if gcd(D,self._E.conductor())!= 1:
for ell in prime_divisors(D):
if valuation(self._E.conductor(),ell) > valuation(D,ell) :
raise ValueError, "can not twist a curve of conductor (=%s) by the quadratic twist (=%s)."%(self._E.conductor(),D)
p = self._p
if p == 2 and self._normalize :
print 'Warning : For p=2 the normalization might not be correct !'
#verbose("computing L-series for p=%s, n=%s, and prec=%s"%(p,n,prec))
# bounds = self._prec_bounds(n,prec)
# padic_prec = max(bounds[1:]) + 5
padic_prec = 10
# verbose("using p-adic precision of %s"%padic_prec)
res_series_prec = min(p**(n-1), prec)
verbose("using series precision of %s"%res_series_prec)
ans = self._get_series_from_cache(n, res_series_prec,D)
if not ans is None:
verbose("found series in cache")
return ans
K = QQ
gamma = K(1 + p)
R = PowerSeriesRing(K,'T',res_series_prec)
T = R(R.gen(),res_series_prec )
#L = R(0)
one_plus_T_factor = R(1)
gamma_power = K(1)
teich = self.teichmuller(padic_prec)
p_power = p**(n-1)
# F = Qp(p,padic_prec)
verbose("Now iterating over %s summands"%((p-1)*p_power))
verbose_level = get_verbose()
count_verb = 0
alphas = self.alpha()
#print len(alphas)
Lprod = []
self._emb = 0
if len(alphas) == 2:
split = True
else:
split = False
for alpha in alphas:
L = R(0)
self._emb = self._emb + 1
for j in range(p_power):
s = K(0)
if verbose_level >= 2 and j/p_power*100 > count_verb + 3:
verbose("%.2f percent done"%(float(j)/p_power*100))
count_verb += 3
for a in range(1,p):
if split:
# b = ((F.teichmuller(a)).lift() % ZZ(p**n))
b = (teich[a]) % ZZ(p**n)
b = b*gamma_power
else:
b = teich[a] * gamma_power
s += self.measure(b, n, padic_prec,D,alpha)
L += s * one_plus_T_factor
one_plus_T_factor *= 1+T
gamma_power *= gamma
Lprod = Lprod + [L]
if len(Lprod)==1:
return Lprod[0]
else:
return Lprod[0]*Lprod[1]
def __find_eisen_chars(character, k):
"""
Find all triples `(\psi_1, \psi_2, t)` that give rise to an Eisenstein series of the given weight and character.
EXAMPLES::
sage: sage.modular.modform.eis_series.__find_eisen_chars(DirichletGroup(36).0, 4)
[]
sage: pars = sage.modular.modform.eis_series.__find_eisen_chars(DirichletGroup(36).0, 5)
sage: [(x[0].values_on_gens(), x[1].values_on_gens(), x[2]) for x in pars]
[((1, 1), (-1, 1), 1),
((1, 1), (-1, 1), 3),
((1, 1), (-1, 1), 9),
((1, -1), (-1, -1), 1),
((-1, 1), (1, 1), 1),
((-1, 1), (1, 1), 3),
((-1, 1), (1, 1), 9),
((-1, -1), (1, -1), 1)]
"""
N = character.modulus()
if character.is_trivial():
if k%2 != 0:
return []
char_inv = ~character
V = [(character, char_inv, t) for t in divisors(N) if t>1]
if k != 2:
V.insert(0,(character, char_inv, 1))
if is_squarefree(N):
return V
# Now include all pairs (chi,chi^(-1)) such that cond(chi)^2 divides N:
# TODO: Optimize -- this is presumably way too hard work below.
G = dirichlet.DirichletGroup(N)
for chi in G:
if not chi.is_trivial():
f = chi.conductor()
if N % (f**2) == 0:
chi = chi.minimize_base_ring()
chi_inv = ~chi
for t in divisors(N//(f**2)):
V.insert(0, (chi, chi_inv, t))
return V
eps = character
if eps(-1) != (-1)**k:
return []
eps = eps.maximize_base_ring()
G = eps.parent()
# Find all pairs chi, psi such that:
#
# (1) cond(chi)*cond(psi) divides the level, and
#
# (2) chi*psi == eps, where eps is the nebentypus character of self.
#
# See [Miyake, Modular Forms] Lemma 7.1.1.
K = G.base_ring()
C = {}
t0 = misc.cputime()
for e in G:
m = Integer(e.conductor())
if m in C:
C[m].append(e)
else:
C[m] = [e]
misc.verbose("Enumeration with conductors.",t0)
params = []
for L in divisors(N):
misc.verbose("divisor %s"%L)
if L not in C:
continue
GL = C[L]
for R in divisors(N/L):
if R not in C:
continue
GR = C[R]
for chi in GL:
for psi in GR:
if chi*psi == eps:
chi0, psi0 = __common_minimal_basering(chi, psi)
for t in divisors(N//(R*L)):
if k != 1 or ((psi0, chi0, t) not in params):
params.append( (chi0,psi0,t) )
return params
def taylor_series(self, a=0, k=6, var='z'):
r"""
Return the first `k` terms of the Taylor series expansion
of the `L`-series about `a`.
This is returned as a series in ``var``, where you
should view ``var`` as equal to `s-a`. Thus
this function returns the formal power series whose coefficients
are `L^{(n)}(a)/n!`.
INPUT:
- ``a`` -- complex number (default: 0); point about
which to expand
- ``k`` -- integer (default: 6), series is
`O(``var``^k)`
- ``var`` -- string (default: 'z'), variable of power
series
EXAMPLES::
sage: L = Dokchitser(conductor=1, gammaV=[0], weight=1, eps=1, poles=[1], residues=[-1], init='1')
sage: L.taylor_series(2, 3)
1.64493406684823 - 0.937548254315844*z + 0.994640117149451*z^2 + O(z^3)
sage: E = EllipticCurve('37a')
sage: L = E.lseries().dokchitser(algorithm='gp')
sage: L.taylor_series(1)
0.000000000000000 + 0.305999773834052*z + 0.186547797268162*z^2 - 0.136791463097188*z^3 + 0.0161066468496401*z^4 + 0.0185955175398802*z^5 + O(z^6)
We compute a Taylor series where each coefficient is to high
precision. ::
sage: E = EllipticCurve('389a')
sage: L = E.lseries().dokchitser(200, algorithm='gp')
sage: L.taylor_series(1,3)
...e-82 + (...e-82)*z + 0.75931650028842677023019260789472201907809751649492435158581*z^2 + O(z^3)
Check that :trac:`25402` is fixed::
sage: L = EllipticCurve("24a1").modular_form().lseries()
sage: L.taylor_series(-1, 3)
0.000000000000000 - 0.702565506265199*z + 0.638929001045535*z^2 + O(z^3)
Check that :trac:`25965` is fixed::
sage: L2 = EllipticCurve("37a1").modular_form().lseries(); L2
L-series associated to the cusp form q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + O(q^6)
sage: L2.taylor_series(0,4)
0.000000000000000 - 0.357620466127498*z + 0.273373112603865*z^2 + 0.303362857047671*z^3 + O(z^4)
sage: L2.taylor_series(0,1)
O(z^1)
sage: L2(0)
0.000000000000000
"""
self.__check_init()
a = self.__CC(a)
k = Integer(k)
try:
z = self._gp_call_inst('Lseries', a, '', k - 1)
z = self.gp()('Vecrev(Pol(%s))' % z)
except TypeError as msg:
raise RuntimeError(
"%s\nUnable to compute Taylor expansion (try lowering the number of terms)"
% msg)
r = repr(z)
if 'pole' in r:
raise ArithmeticError(r)
elif 'Warning' in r:
i = r.rfind('\n')
msg = r[:i].replace('digits', 'decimal digits')
verbose(msg, level=-1)
v = list(z)
K = self.__CC
v = [K(repr(x)) for x in v]
R = self.__CC[[var]]
return R(v, k)