Exemple #1
0
    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"])
Exemple #2
0
    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"])
Exemple #3
0
    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"])
Exemple #4
0
    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"])
Exemple #5
0
    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
Exemple #6
0
    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"])
Exemple #7
0
    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"])
Exemple #8
0
    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())
Exemple #9
0
    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"])
Exemple #10
0
    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"])