def __init__(self, group, base_ring, red_hom):
r"""
Return the graded ring of (Hecke) quasi meromorphic modular forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` - The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` - The base_ring (default: ``ZZ``).
- ``red_hom`` - If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the homogeneous spaces.
OUTPUT:
The corresponding graded ring of (Hecke) quasi meromorphic modular forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: MR = QMModularFormsRing(4, ZZ, 1)
sage: MR
QuasiMeromorphicModularFormsRing(n=4) over Integer Ring
sage: MR.analytic_type()
quasi meromorphic modular
sage: MR.category()
Category of commutative algebras over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
"""
FormsRing_abstract.__init__(self, group=group, base_ring=base_ring, red_hom=red_hom)
CommutativeAlgebra.__init__(self, base_ring=self.coeff_ring(), category=CommutativeAlgebras(self.coeff_ring()))
self._analytic_type = self.AT(["quasi", "mero"])
def __init__(self, group, base_ring, red_hom, n):
r"""
Return the graded ring of (Hecke) weakly holomorphic modular forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` -- The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` -- The base_ring (default: ``ZZ``).
- ``red_hom`` -- If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the spaces of homogeneous elements.
OUTPUT:
The corresponding graded ring of (Hecke) weakly holomorphic modular forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: from sage.modular.modform_hecketriangle.graded_ring import WeakModularFormsRing
sage: MR = WeakModularFormsRing(5, ZZ, 0)
sage: MR
WeakModularFormsRing(n=5) over Integer Ring
sage: MR.analytic_type()
weakly holomorphic modular
sage: MR.category()
Category of commutative algebras over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
"""
FormsRing_abstract.__init__(self, group=group, base_ring=base_ring, red_hom=red_hom, n=n)
CommutativeAlgebra.__init__(self, base_ring=self.coeff_ring(), category=CommutativeAlgebras(self.coeff_ring()))
self._analytic_type = self.AT(["weak"])
def __init__(self, group, base_ring, red_hom):
r"""
Return the graded ring of (Hecke) cusp forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` - The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` - The base_ring (default: ``ZZ``).
- ``red_hom`` - If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the homogeneous spaces.
OUTPUT:
The corresponding graded ring of (Hecke) cusp forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: MR = CuspFormsRing(5, CC, True)
sage: MR
CuspFormsRing(n=5) over Complex Field with 53 bits of precision
sage: MR.analytic_type()
cuspidal
sage: MR.category()
Category of commutative algebras over Fraction Field of Univariate Polynomial Ring in d over Complex Field with 53 bits of precision
"""
FormsRing_abstract.__init__(self, group=group, base_ring=base_ring, red_hom=red_hom)
CommutativeAlgebra.__init__(self, base_ring=self.coeff_ring(), category=CommutativeAlgebras(self.coeff_ring()))
self._analytic_type = self.AT(["cusp"])
def __init__(self, group, base_ring, red_hom, n):
r"""
Return the graded ring of (Hecke) modular forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` -- The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` -- The base_ring (default: ``ZZ``).
- ``red_hom`` -- If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the spaces of homogeneous elements.
OUTPUT:
The corresponding graded ring of (Hecke) modular forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: from sage.modular.modform_hecketriangle.graded_ring import ModularFormsRing
sage: MR = ModularFormsRing()
sage: MR
ModularFormsRing(n=3) over Integer Ring
sage: MR.analytic_type()
modular
sage: MR.category()
Category of commutative algebras over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
"""
FormsRing_abstract.__init__(self, group=group, base_ring=base_ring, red_hom=red_hom, n=n)
CommutativeAlgebra.__init__(self, base_ring=self.coeff_ring(), category=CommutativeAlgebras(self.coeff_ring()))
self._analytic_type = self.AT(["holo"])
def __init__(self, field, prec, log_radii, names, order, integral=False):
"""
Initialize the Tate algebra
TESTS::
sage: A.<x,y> = TateAlgebra(Zp(2), log_radii=1)
sage: TestSuite(A).run()
We check that univariate Tate algebras work correctly::
sage: B.<t> = TateAlgebra(Zp(3))
"""
from sage.misc.latex import latex_variable_name
from sage.rings.polynomial.polynomial_ring_constructor import _multi_variate
self.element_class = TateAlgebraElement
self._field = field
self._cap = prec
self._log_radii = ETuple(log_radii) # TODO: allow log_radii in QQ
self._names = names
self._latex_names = [latex_variable_name(var) for var in names]
uniformizer = field.change(print_mode='terse',
show_prec=False).uniformizer()
self._uniformizer_repr = uniformizer._repr_()
self._uniformizer_latex = uniformizer._latex_()
self._ngens = len(names)
self._order = order
self._integral = integral
if integral:
base = field.integer_ring()
else:
base = field
CommutativeAlgebra.__init__(self,
base,
names,
category=CommutativeAlgebras(base))
self._polynomial_ring = _multi_variate(field, names, order=order)
one = field(1)
self._parent_terms = TateTermMonoid(self)
self._oneterm = self._parent_terms(one, ETuple([0] * self._ngens))
if integral:
# This needs to be update if log_radii are allowed to be non-integral
self._gens = [
self((one << log_radii[i]) * self._polynomial_ring.gen(i))
for i in range(self._ngens)
]
self._integer_ring = self
else:
self._gens = [self(g) for g in self._polynomial_ring.gens()]
self._integer_ring = TateAlgebra_generic(field,
prec,
log_radii,
names,
order,
integral=True)
self._integer_ring._rational_ring = self._rational_ring = self
def __init__(self, group, base_ring, red_hom, n):
r"""
Return the graded ring of (Hecke) quasi meromorphic modular forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` -- The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` -- The base_ring (default: ``ZZ``).
- ``red_hom`` -- If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the spaces of homogeneous elements.
OUTPUT:
The corresponding graded ring of (Hecke) quasi meromorphic modular forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: from sage.modular.modform_hecketriangle.graded_ring import QuasiMeromorphicModularFormsRing
sage: MR = QuasiMeromorphicModularFormsRing(4, ZZ, 1)
sage: MR
QuasiMeromorphicModularFormsRing(n=4) over Integer Ring
sage: MR.analytic_type()
quasi meromorphic modular
sage: MR.category()
Category of commutative algebras over Integer Ring
sage: MR in MR.category()
True
sage: QuasiMeromorphicModularFormsRing(n=infinity)
QuasiMeromorphicModularFormsRing(n=+Infinity) over Integer Ring
"""
FormsRing_abstract.__init__(self,
group=group,
base_ring=base_ring,
red_hom=red_hom,
n=n)
CommutativeAlgebra.__init__(self,
base_ring=base_ring,
category=CommutativeAlgebras(base_ring))
self._analytic_type = self.AT(["quasi", "mero"])
def __init__(self, group, base_ring, red_hom, n):
r"""
Return the graded ring of (Hecke) cusp forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` -- The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` -- The base_ring (default: ``ZZ``).
- ``red_hom`` -- If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the spaces of homogeneous elements.
OUTPUT:
The corresponding graded ring of (Hecke) cusp forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: from sage.modular.modform_hecketriangle.graded_ring import CuspFormsRing
sage: MR = CuspFormsRing(5, CC, True)
sage: MR
CuspFormsRing(n=5) over Complex Field with 53 bits of precision
sage: MR.analytic_type()
cuspidal
sage: MR.category()
Category of commutative algebras over Complex Field with 53 bits of precision
sage: MR in MR.category()
True
sage: CuspFormsRing(n=infinity, base_ring=CC, red_hom=True)
CuspFormsRing(n=+Infinity) over Complex Field with 53 bits of precision
"""
FormsRing_abstract.__init__(self,
group=group,
base_ring=base_ring,
red_hom=red_hom,
n=n)
CommutativeAlgebra.__init__(self,
base_ring=base_ring,
category=CommutativeAlgebras(base_ring))
self._analytic_type = self.AT(["cusp"])
def __init__(self, M):
"""
Initialization.
EXAMPLES::
sage: from sage.modular.hecke.algebra import HeckeAlgebra_base
sage: type(HeckeAlgebra_base(CuspForms(1, 12)))
<class 'sage.modular.hecke.algebra.HeckeAlgebra_base_with_category'>
"""
if isinstance(M, tuple):
M = M[0]
from . import module
if not module.is_HeckeModule(M):
raise TypeError("M (=%s) must be a HeckeModule" % M)
self.__M = M
CommutativeAlgebra.__init__(self, M.base_ring())
def __init__(self, group, base_ring, red_hom, n):
r"""
Return the graded ring of (Hecke) quasi meromorphic modular forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` -- The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` -- The base_ring (default: ``ZZ``).
- ``red_hom`` -- If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the spaces of homogeneous elements.
OUTPUT:
The corresponding graded ring of (Hecke) quasi meromorphic modular forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: from sage.modular.modform_hecketriangle.graded_ring import QuasiMeromorphicModularFormsRing
sage: MR = QuasiMeromorphicModularFormsRing(4, ZZ, 1)
sage: MR
QuasiMeromorphicModularFormsRing(n=4) over Integer Ring
sage: MR.analytic_type()
quasi meromorphic modular
sage: MR.category()
Category of commutative algebras over Integer Ring
sage: MR in MR.category()
True
sage: QuasiMeromorphicModularFormsRing(n=infinity)
QuasiMeromorphicModularFormsRing(n=+Infinity) over Integer Ring
"""
FormsRing_abstract.__init__(self, group=group, base_ring=base_ring, red_hom=red_hom, n=n)
CommutativeAlgebra.__init__(self, base_ring=base_ring, category=CommutativeAlgebras(base_ring))
self._analytic_type = self.AT(["quasi", "mero"])
def __init__(self, group, base_ring, red_hom, n):
r"""
Return the graded ring of (Hecke) cusp forms
for the given ``group`` and ``base_ring``.
INPUT:
- ``group`` -- The Hecke triangle group (default: ``HeckeTriangleGroup(3)``)
- ``base_ring`` -- The base_ring (default: ``ZZ``).
- ``red_hom`` -- If True then results of binary operations are considered
homogeneous whenever it makes sense (default: False).
This is mainly used by the spaces of homogeneous elements.
OUTPUT:
The corresponding graded ring of (Hecke) cusp forms
for the given ``group`` and ``base_ring``.
EXAMPLES::
sage: from sage.modular.modform_hecketriangle.graded_ring import CuspFormsRing
sage: MR = CuspFormsRing(5, CC, True)
sage: MR
CuspFormsRing(n=5) over Complex Field with 53 bits of precision
sage: MR.analytic_type()
cuspidal
sage: MR.category()
Category of commutative algebras over Complex Field with 53 bits of precision
sage: MR in MR.category()
True
sage: CuspFormsRing(n=infinity, base_ring=CC, red_hom=True)
CuspFormsRing(n=+Infinity) over Complex Field with 53 bits of precision
"""
FormsRing_abstract.__init__(self, group=group, base_ring=base_ring, red_hom=red_hom, n=n)
CommutativeAlgebra.__init__(self, base_ring=base_ring, category=CommutativeAlgebras(base_ring))
self._analytic_type = self.AT(["cusp"])
