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