def generators(self, K, precision) :
if K is QQ or K in NumberFields() :
return Sequence( [ jacobi_form_by_taylor_expansion(i, self.__index, self.__weight, precision)
for i in xrange(self._rank(K)) ],
universe = JacobiD1NNFourierExpansionModule(QQ, self.__index) )
raise NotImplementedError
def weak_jacbi_form_by_taylor_expansion(fs,
precision,
is_integral=False,
weight=None,
factory=None):
if factory is None:
factory = JacobiFormD1NNFactory(precision, len(fs) - 1)
if is_integral:
expansion_ring = JacobiD1NNFourierExpansionModule(
ZZ,
len(fs) - 1, True)
else:
expansion_ring = JacobiD1NNFourierExpansionModule(
QQ,
len(fs) - 1, True)
f_exps = list()
for (i, f) in enumerate(fs):
if f == 0:
f_exps.append(lambda p: 0)
elif isinstance(f, ModularFormElement):
f_exps.append(f.qexp)
if weight is None:
weight = f.weight() - 2 * i
else:
if not weight == f.weight() - 2 * i:
ValueError("Weight of the i-th form must be k + 2*i.")
if i != 0 and not f.is_cuspidal():
ValueError("All but the first form must be cusp forms.")
else:
f_exps.append(f)
if weight is None:
raise ValueError("Either one element of fs must be a modular form or " + \
"the weight must be passed.")
coefficients_factory = DelayedFactory_JacobiFormD1NN_taylor_expansion_weak(
factory, f_exps, weight)
return EquivariantMonoidPowerSeries_lazy(
expansion_ring,
expansion_ring.monoid().filter(precision),
coefficients_factory.getcoeff)
def jacobi_form_by_taylor_expansion(i, index, weight, precision):
r"""
We first lift an echelon basis of elliptic modular forms to weak Jacobi forms.
Then we return an echelon basis with respect enumeration of this first echelon
basis of the '\ZZ'-submodule of Jacobi forms.
"""
expansion_ring = JacobiD1NNFourierExpansionModule(ZZ, index)
coefficients_factory = DelayedFactory_JacobiFormD1NN_taylor_expansion(
i, index, weight, precision)
return EquivariantMonoidPowerSeries_lazy(expansion_ring, precision,
coefficients_factory.getcoeff)