def __init__(self, group, base_ring, k, ep, n):
        r"""
        Return the Module of (Hecke) cusp forms
        of weight ``k`` with multiplier ``ep`` for the given ``group`` and ``base_ring``.

        EXAMPLES::

            sage: from sage.modular.modform_hecketriangle.space import CuspForms
            sage: MF = CuspForms(6, ZZ, 6, 1)
            sage: MF
            CuspForms(n=6, k=6, ep=1) over Integer Ring
            sage: MF.analytic_type()
            cuspidal
            sage: MF.category()
            Category of modules over Integer Ring
            sage: MF in MF.category()
            True
            sage: MF.module()
            Vector space of dimension 1 over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: MF.ambient_module() == MF.module()
            True
            sage: MF.is_ambient()
            True
        """

        FormsSpace_abstract.__init__(self, group=group, base_ring=base_ring, k=k, ep=ep, n=n)
        Module.__init__(self, base=base_ring)
        self._analytic_type=self.AT(["cusp"])
        self._module = FreeModule(self.coeff_ring(), self.dimension())

 def __init__(self, surface, base_ring=ZZ):
     self._base_ring=base_ring
     if not isinstance(surface,SimilaritySurface):
         raise ValueError("RelativeHomology only defined for SimilaritySurfaces (and better).")
     self._s=surface
     self._cached_edges=dict()
     Module.__init__(self, base_ring)

    def __init__(self, O, C, R) :
        """
        INPUT:
            - `O` -- A monoid with an action of a group; As implemented in
                     :class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
            - `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
            - `R` -- A representation on a module; As implemented
                     in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.

        EXAMPLES::
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2))) # indirect doctest
        """
        
        # If the representation O respects the monoid structure of S
        # the base ring should be the associated power series ring.
        if O.is_monoid_action() :
            Module.__init__(self, EquivariantMonoidPowerSeriesRing(O,C,TrivialRepresentation(R.group(), R.base_ring())))
        else :
            Module.__init__(self, R.codomain())
        EquivariantMonoidPowerSeriesAmbient_abstract.__init__(self, O, C, R)        
        
        self.__coeff_gens = \
          [self._element_class( self,
            dict([( C.one_element(), dict([(self.monoid().zero_element(), a)]) )]),
            self.monoid().filter_all() )
           for a in self.coefficient_domain().gens()]

 def __init__(self,domain,U,prec = None,t = None,R = None,overconvergent = False):
     if(R is None):
         if not isinstance(U,Integer):
             self._R = U.base_ring()
         else:
             if prec is None:
                 prec = 20
             self._R = Qp(domain._p,prec)
     else:
         self._R = R
     #U is a CoefficientModuleSpace
     if isinstance(U,Integer):
         if t is None:
             if overconvergent:
                 t = prec-U+1
             else:
                 t = 0
         self._U = OCVn(U-2,self._R,U-1+t)
     else:
         self._U = U
     self._source = domain
     self._list = self._source.get_list() # Contains also the opposite edges
     self._prec = self._R.precision_cap()
     self._n = self._U.weight()
     self._p = self._source._p
     Module.__init__(self,base = self._R)
     self._populate_coercion_lists_()

    def __init__(self, group, coefficients, sign=0):
        r"""
        INPUT:

            See :class:`PSModularSymbolSpace`

        EXAMPLES::

            sage: D = Distributions(2, 11)
            sage: M = PSModularSymbols(Gamma0(2), coefficients=D)
            sage: type(M)
            <class 'sage.modular.pollack_stevens.space.PSModularSymbolSpace_with_category'>
            sage: TestSuite(M).run()

        """
        Module.__init__(self, coefficients.base_ring())
        if sign not in [0,-1,1]:
            # sign must be be 0, -1 or 1
            raise ValueError, "sign must be 0, -1, or 1"
        self._group = group
        self._coefficients = coefficients
        if coefficients.is_symk():
            self.Element = PSModularSymbolElement_symk
        else:
            self.Element = PSModularSymbolElement_dist
        self._sign = sign
        # should distingish between Gamma0 and Gamma1...
        self._source = ManinRelations(group.level())
        # We have to include the first action so that scaling by Z doesn't try to pass through matrices
        actions = [PSModSymAction(ZZ, self), PSModSymAction(M2ZSpace, self)]
        self._populate_coercion_lists_(action_list=actions)

 def __init__(self,X,U,prec=None,t=None,R=None,overconvergent=False):
     if(R is None):
         if(not isinstance(U,Integer)):
             self._R=U.base_ring()
         else:
             if(prec is None):
                 prec=100
             self._R=Qp(X._p,prec)
     else:
         self._R=R
     #U is a CoefficientModuleSpace
     if(isinstance(U,Integer)):
         if(t is None):
             if(overconvergent):
                 t=prec-U+1
             else:
                 t=0
         self._U=OCVn(U-2,self._R,U-1+t)
     else:
         self._U=U
     self._X=X
     self._V=self._X.get_vertex_list()
     self._E=self._X.get_edge_list()
     self._prec=self._R.precision_cap()
     self._n=self._U.weight()
     Module.__init__(self,base=self._R)
     self._populate_coercion_lists_()

    def __init__(self, group, base_ring, k, ep):
        r"""
        Return the Module of (Hecke) modular forms
        of weight ``k`` with multiplier ``ep`` for the given ``group`` and ``base_ring``.

        EXAMPLES::

            sage: MF = ModularForms()
            sage: MF
            ModularForms(n=3, k=0, ep=1) over Integer Ring
            sage: MF.analytic_type()
            modular
            sage: MF.category()
            Category of vector spaces over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: MF.module()
            Vector space of dimension 1 over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: MF.ambient_module() == MF.module()
            True
            sage: MF.is_ambient()
            True
        """

        FormsSpace_abstract.__init__(self, group=group, base_ring=base_ring, k=k, ep=ep)
        Module.__init__(self, base=self.coeff_ring())
        self._analytic_type = self.AT(["holo"])
        self._module = FreeModule(self.coeff_ring(), self.dimension())

 def __init__(self,p,depth):
     Module.__init__(self,base = ZZ)
     self._R = ZZ
     self._p = p
     self._Rmod = ZpCA(p,depth - 1)
     self._depth = depth
     self._pN = self._p**(depth - 1)
     self._PowerSeries = PowerSeriesRing(self._Rmod, default_prec = self._depth,name='z')
     self._cache_powers = dict()
     self._unset_coercions_used()
     self._Sigma0 = Sigma0(self._p, base_ring = self._Rmod, adjuster = our_adjuster())
     self.register_action(Sigma0Action(self._Sigma0,self))
     self._populate_coercion_lists_()

    def _coerce_map_from_(self, other) :
        """
        TESTS::
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
            sage: m = FreeModule(QQ, 3)
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
            sage: mps = mpsm.base_ring()
            sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
            sage: ger._coerce_map_from_(ZZ)
        """
        if other is self.relations().ring() :
            from sage.structure.coerce_maps import CallableConvertMap
            
            return CallableConvertMap(other, self, self._element_constructor_)
        
        if isinstance(other, GradedExpansionSubmodule_abstract) :
            if other.graded_ambient() is self \
              or self.has_coerce_map_from(other.graded_ambient()) :
                from sage.structure.coerce_maps import CallableConvertMap

                return CallableConvertMap(other, self, other._graded_expansion_submodule_to_graded_ambient_)

        return Module._coerce_map_from_(self, other)

    def __init__(self, abvar):
        """
        Group of all torsion points over the algebraic closure on an
        abelian variety.

        INPUT:


        -  ``abvar`` - an abelian variety


        EXAMPLES::

            sage: A = J0(23)
            sage: A.qbar_torsion_subgroup()
            Group of all torsion points in QQbar on Abelian variety J0(23) of dimension 2
        """
        self.__abvar = abvar
        Module.__init__(self, ZZ)

    def __init__(self,n,R,depth=None,basis=None):
        Module.__init__(self,base=R)
        if basis is not None:
            self._basis=copy(basis)
        self._n=n
        self._R=R
        if R.is_exact():
            self._Rmod=self._R
        else:
            self._Rmod=Zmod(self._R.prime()**(self._R.precision_cap()))

        if depth is None:
            depth=n+1
        if depth != n+1:
            if R.is_exact(): raise ValueError, "Trying to construct an over-convergent module with exact coefficients, how do you store p-adics ??"
        self._depth=depth
        self._PowerSeries=PowerSeriesRing(self._Rmod,default_prec=self._depth,name='z')
        self._powers=dict()
        self._populate_coercion_lists_()

    def __init__(self, group, base_ring, k, ep, n):
        r"""
        Return the Module of (Hecke) meromorphic modular forms
        of weight ``k`` with multiplier ``ep`` for the given ``group`` and ``base_ring``.

        EXAMPLES::

            sage: from sage.modular.modform_hecketriangle.space import MeromorphicModularForms
            sage: MF = MeromorphicModularForms()
            sage: MF
            MeromorphicModularForms(n=3, k=0, ep=1) over Integer Ring
            sage: MF.analytic_type()
            meromorphic modular
            sage: MF.category()
            Category of vector spaces over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: MF.is_ambient()
            True
        """

        FormsSpace_abstract.__init__(self, group=group, base_ring=base_ring, k=k, ep=ep, n=n)
        Module.__init__(self, base=self.coeff_ring())
        self._analytic_type=self.AT(["jacobi", "mero"])

    def __init__(self, group, base_ring, k, ep, n):
        r"""
        Return the Module of (Hecke) quasi modular forms
        of weight ``k`` with multiplier ``ep`` for the given ``group`` and ``base_ring``.

        EXAMPLES::

            sage: from sage.modular.modform_hecketriangle.space import QuasiModularForms
            sage: MF = QuasiModularForms(5, ZZ, 20/3, 1)
            sage: MF
            QuasiModularForms(n=5, k=20/3, ep=1) over Integer Ring
            sage: MF.analytic_type()
            quasi modular
            sage: MF.category()
            Category of vector spaces over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: MF.is_ambient()
            True
        """

        FormsSpace_abstract.__init__(self, group=group, base_ring=base_ring, k=k, ep=ep, n=n)
        Module.__init__(self, base=self.coeff_ring())
        self._analytic_type=self.AT(["quasi", "holo"])
        self._module = FreeModule(self.coeff_ring(), self.dimension())

    def __init__(self, abvar, field_of_definition=QQ):
        """
        Initialize ``self``.

        TESTS::

            sage: A = J0(11)
            sage: G = A.torsion_subgroup(2)
            sage: TestSuite(G).run() # long time
        """
        from sage.categories.category import Category
        from sage.categories.fields import Fields
        from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
        from sage.categories.modules import Modules
        from .abvar import is_ModularAbelianVariety
        if field_of_definition not in Fields():
            raise TypeError("field_of_definition must be a field")
        if not is_ModularAbelianVariety(abvar):
            raise TypeError("abvar must be a modular abelian variety")
        category = Category.join((Modules(ZZ), FiniteEnumeratedSets()))
        Module.__init__(self, ZZ, category=category)
        self.__abvar = abvar
        self.__field_of_definition = field_of_definition

    def __init__(self, group, coefficients, sign=0):
        r"""
        INPUT:

            See :class:`PSModularSymbolSpace`

        EXAMPLES::

            sage: D = Distributions(2, 11)
            sage: M = PSModularSymbols(Gamma0(11), coefficients=D)
            sage: type(M)
            <class 'sage.modular.pollack_stevens.space.PSModularSymbolSpace_with_category'>
            sage: TestSuite(M).run()

        """
        Module.__init__(self, coefficients.base_ring())
        if sign not in [0,-1,1]:
            # sign must be be 0, -1 or 1
            raise ValueError, "sign must be 0, -1, or 1"
        self._group = group
        self._coefficients = coefficients
        if coefficients.is_symk():
            self.Element = PSModularSymbolElement_symk
        else:
            self.Element = PSModularSymbolElement_dist
        self._sign = sign
        # should distingish between Gamma0 and Gamma1...
        self._source = ManinRelations(group.level())

        # Register the action of 2x2 matrices on self. 
        
        if coefficients.is_symk():
            action = PSModSymAction(Sigma0(1), self)
        else:
            action = PSModSymAction(Sigma0(self.prime()), self)
            
        self._populate_coercion_lists_(action_list=[action])

 def __init__(self, surface, base_ring=ZZ):
     self._base_ring=base_ring
     self._s=surface
     self._cached_edges=dict()
     Module.__init__(self, base_ring)

    def __init__(self, ambient_space, basis):
        r"""
        Return the Submodule of (Hecke) forms in ``ambient_space`` for the given ``basis``.

        INPUT:

        - ``ambient_space``   - An ambient forms space.
        - ``basis```          - A tuple of linearly independent elements of ``ambient_space``.

        OUTPUT:

        The corresponding submodule.

        EXAMPLES::

            sage: from space import ModularForms
            sage: MF = ModularForms(group=6, k=20, ep=1)
            sage: MF
            ModularForms(n=6, k=20, ep=1) over Integer Ring
            sage: MF.dimension()
            4
            sage: subspace = MF.subspace([MF.Delta()*MF.E4()^2, MF.gen(0)])
            sage: subspace
            Subspace of dimension 2 of ModularForms(n=6, k=20, ep=1) over Integer Ring
            sage: subspace.analytic_type()
            modular
            sage: subspace.category()
            Category of vector spaces over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: subspace.module()
            Vector space of degree 4 and dimension 2 over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            Basis matrix:
            [            1             0             0             0]
            [            0             1     13/(18*d) 103/(432*d^2)]
            sage: subspace.ambient_module()
            Vector space of dimension 4 over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: subspace.ambient_module() == MF.module()
            True
            sage: subspace.ambient_space() == MF
            True
            sage: subspace.basis()
            [q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5), 1 + 360360*q^4 + O(q^5)]
            sage: subspace.basis()[0].parent() == MF
            True
            sage: subspace.gens()
            [q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5), 1 + 360360*q^4 + O(q^5)]
            sage: subspace.gens()[0].parent() == subspace
            True
            sage: subspace.is_ambient()
            False
        """

        FormsSpace_abstract.__init__(self, group=ambient_space.group(), base_ring=ambient_space.base_ring(), k=ambient_space.weight(), ep=ambient_space.ep())
        Module.__init__(self, base=self.coeff_ring())

        self._ambient_space = ambient_space
        self._basis = [v for v in basis]
        # self(v) instead would somehow mess up the coercion model
        self._gens = [self._element_constructor_(v) for v in basis]
        self._module = ambient_space._module.submodule([ambient_space.coordinate_vector(v) for v in basis])
        # TODO: get the analytic type from the basis
        #self._analytic_type=self.AT(["quasi", "mero"])
        self._analytic_type = ambient_space._analytic_type

    def __init__ ( self, base_ring_generators, generators, relations,
                   grading, all_relations = True, reduce_before_evaluating = True ) :
        r"""
        The degree one part of the monomials that correspond to generators over the
        base expansion ring will serve as the coordinates of the elements.
        
        INPUT:
            - ``base_ring_generators``      -- A list of (equivariant) monoid power series with
                                               coefficient domain the base ring of the coefficient
                                               domain of the generators or ``None``.
            - ``generators``                -- A list of (equivariant) monoid power series; The generators
                                               of the ambient over the ring generated by the base ring
                                               generators.
            - ``relations``                 -- An ideal in a polynomial ring with ``len(base_ring_generators) + len(generators)``
                                               variables.
            - ``grading``                   -- A grading deriving from :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`;
                                               A grading for the polynomial ring of the relations.
            - ``all_relations``             -- A boolean (default: ``True``); If ``True`` the relations given
                                               for the polynomial ring are all relations that the Fourier
                                               expansion have.
            - ``reduce_before_evaluating``  -- A boolean (default: ``True``); If ``True`` any monomial
                                               will be Groebner reduced before the Fourier expansion
                                               is calculated.

        NOTE:
            The grading must respect the relations of the generators.
        
        TESTS::
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
            sage: m = FreeModule(QQ, 3)
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
            sage: mps = mpsm.base_ring()
            sage: ger = GradedExpansionModule_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mpsm, {1: m([1,1,1]), 2: m([1,3,-3])}, mpsm.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
            sage: ger.base_ring()
            Graded expansion ring with generators a
        """
        if not hasattr(self, '_element_class') :
            self._element_class = GradedExpansionVector_class
        
        if hasattr(self, "_extended_base_ring") :
            Module.__init__(self, self._extended_base_ring)
        elif base_ring_generators is None or len(base_ring_generators) == 0 :
            Module.__init__(self, relations.base_ring())
        else :
            gb = filter( lambda p: all( all(a == 0 for a in list(e)[len(base_ring_generators):])
                                        for e in p.exponents() ),
                         relations.groebner_basis() )
            P = PolynomialRing( relations.base_ring(),
                                list(relations.ring().variable_names())[:len(base_ring_generators)] )
            base_relations = P.ideal(gb)
            R = GradedExpansionRing_class(None, base_ring_generators, base_relations,
                    grading.subgrading(xrange(len(base_ring_generators))), all_relations, reduce_before_evaluating)
            Module.__init__(self, R)

        GradedExpansionAmbient_abstract.__init__(self, base_ring_generators, generators, relations, grading, all_relations, reduce_before_evaluating)
        
        self._populate_coercion_lists_(
          convert_list = [self.relations().ring()],
          convert_method_name = "_graded_expansion_submodule_to_graded_ambient_" )

    def __init__(self, ambient_space, basis, check):
        r"""
        Return the Submodule of (Hecke) forms in ``ambient_space`` for the given ``basis``.

        INPUT:

        - ``ambient_space``  -- An ambient forms space.

        - ``basis``          -- A tuple of (not necessarily linearly independent)
                                elements of ``ambient_space``.

        - ``check``          -- If ``True`` (default) then a maximal linearly
                                independent subset of ``basis`` is choosen. Otherwise
                                it is assumed that ``basis`` is linearly independent.

        OUTPUT:

        The corresponding submodule.

        EXAMPLES::

            sage: from sage.modular.modform_hecketriangle.space import ModularForms, QuasiCuspForms
            sage: MF = ModularForms(n=6, k=20, ep=1)
            sage: MF
            ModularForms(n=6, k=20, ep=1) over Integer Ring
            sage: MF.dimension()
            4
            sage: subspace = MF.subspace([MF.Delta()*MF.E4()^2, MF.gen(0), 2*MF.gen(0)])
            sage: subspace
            Subspace of dimension 2 of ModularForms(n=6, k=20, ep=1) over Integer Ring
            sage: subspace.analytic_type()
            modular
            sage: subspace.category()
            Category of vector spaces over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: subspace.module()
            Vector space of degree 4 and dimension 2 over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            Basis matrix:
            [            1             0             0             0]
            [            0             1     13/(18*d) 103/(432*d^2)]
            sage: subspace.ambient_module()
            Vector space of dimension 4 over Fraction Field of Univariate Polynomial Ring in d over Integer Ring
            sage: subspace.ambient_module() == MF.module()
            True
            sage: subspace.ambient_space() == MF
            True
            sage: subspace.basis()
            [q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5), 1 + 360360*q^4 + O(q^5)]
            sage: subspace.basis()[0].parent() == MF
            True
            sage: subspace.gens()
            [q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5), 1 + 360360*q^4 + O(q^5)]
            sage: subspace.gens()[0].parent() == subspace
            True
            sage: subspace.is_ambient()
            False

            sage: MF = QuasiCuspForms(n=infinity, k=12, ep=1)
            sage: MF.dimension()
            4
            sage: subspace = MF.subspace([MF.Delta(), MF.E4()*MF.f_inf()*MF.E2()*MF.f_i(), MF.E4()*MF.f_inf()*MF.E2()^2, MF.E4()*MF.f_inf()*(MF.E4()-MF.E2()^2)])
            sage: subspace.default_prec(3)
            sage: subspace
            Subspace of dimension 3 of QuasiCuspForms(n=+Infinity, k=12, ep=1) over Integer Ring
            sage: subspace.gens()
            [q + 24*q^2 + O(q^3), q - 24*q^2 + O(q^3), q - 8*q^2 + O(q^3)]
        """

        FormsSpace_abstract.__init__(self, group=ambient_space.group(), base_ring=ambient_space.base_ring(), k=ambient_space.weight(), ep=ambient_space.ep(), n=ambient_space.hecke_n())
        Module.__init__(self, base=self.coeff_ring())

        self._ambient_space = ambient_space
        self._basis = [v for v in basis]
        # self(v) instead would somehow mess up the coercion model
        self._gens = [self._element_constructor_(v) for v in basis]
        self._module = ambient_space._module.submodule([ambient_space.coordinate_vector(v) for v in basis])
        # TODO: get the analytic type from the basis
        #self._analytic_type=self.AT(["quasi", "mero"])
        self._analytic_type = ambient_space._analytic_type