def __init__(self, O, C, R): r""" INPUT: - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`. - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`. - `R` -- A representation of `G` on some `K`-algebra or module `A`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`. TESTS:: sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationModuleFunctor sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid sage: F = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1))) """ if O.group() != C.group(): raise ValueError, "The action on S and the characters must have the same group" if R.base_ring() != C.codomain(): if C.codomain().has_coerce_map_from(R.base_ring()): pass elif R.base_ring().has_coerce_map_from(C.codomain()): pass else: raise ValueError, "character codomain and representation base ring must be coercible" self.__O = O self.__C = C self.__R = R ConstructionFunctor.__init__(self, CommutativeAdditiveGroups(), CommutativeAdditiveGroups())
def __init__(self, O, C, R) : r""" INPUT: - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`. - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`. - `R` -- A representation of `G` on some `K`-algebra or module `A`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`. TESTS:: sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationModuleFunctor sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid sage: F = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1))) """ if O.group() != C.group() : raise ValueError, "The action on S and the characters must have the same group" if R.base_ring() != C.codomain() : if C.codomain().has_coerce_map_from(R.base_ring()) : pass elif R.base_ring().has_coerce_map_from(C.codomain()) : pass else : raise ValueError, "character codomain and representation base ring must be coercible" self.__O = O self.__C = C self.__R = R ConstructionFunctor.__init__(self, CommutativeAdditiveGroups(), CommutativeAdditiveGroups())
def __init__(self, O, C, R) : r""" INPUT: - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`. - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`. - `R` -- A representation of `G` on some `K`-algebra or module `A`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`. TESTS:: sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid sage: F = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ)) """ if O.group() != C.group() : raise ValueError( "The action on S and the characters must have the same group" ) if R.base_ring() != C.codomain() : # if C.codomain().has_coerce_map_from(R.base_ring()) : # pass # el if R.base_ring().has_coerce_map_from(C.codomain()) : pass else : raise ValueError( "character codomain and representation base ring must be coercible" ) if not O.is_monoid_action() : raise ValueError( "monoid structure must be compatible with group action" ) self.__O = O self.__C = C self.__R = R ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, O, C, R): r""" INPUT: - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`. - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`. - `R` -- A representation of `G` on some `K`-algebra or module `A`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`. TESTS:: sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid sage: F = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ)) """ if O.group() != C.group(): raise ValueError( "The action on S and the characters must have the same group") if R.base_ring() != C.codomain(): # if C.codomain().has_coerce_map_from(R.base_ring()) : # pass # el if R.base_ring().has_coerce_map_from(C.codomain()): pass else: raise ValueError( "character codomain and representation base ring must be coercible" ) if not O.is_monoid_action(): raise ValueError( "monoid structure must be compatible with group action") self.__O = O self.__C = C self.__R = R ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, base): """ Initialize ``self``. EXAMPLES:: sage: from sage.algebras.tensor_algebra import TensorAlgebraFunctor sage: F = TensorAlgebraFunctor(Rings()) sage: TestSuite(F).run() """ ConstructionFunctor.__init__(self, Modules(base), Algebras(base))
def __init__(self, field): """ TESTS:: sage: from sage.rings.function_field.differential import DifferentialsSpaceFunctor sage: K.<x> = FunctionField(QQ) sage: DifferentialsSpaceFunctor(K)(K) Space of differentials of Rational function field in x over Rational Field """ ConstructionFunctor.__init__(self, FunctionFields(), DifferentialsSpaces(field))
def __init__(self, S) : r""" INPUT: - `S` -- A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid` TESTS:: sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid sage: F = MonoidPowerSeriesRingFunctor(NNMonoid(False)) """ self.__S = S ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, S): r""" INPUT: - `S` -- A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid` TESTS:: sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid sage: F = MonoidPowerSeriesRingFunctor(NNMonoid(False)) """ self.__S = S ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, group): r""" See :class:`GroupAlgebraFunctor` for full documentation. EXAMPLES:: sage: from sage.categories.algebra_functor import GroupAlgebraFunctor sage: GroupAlgebra(SU(2, GF(4, 'a')), IntegerModRing(12)).category() Category of finite group algebras over Ring of integers modulo 12 """ self.__group = group from sage.categories.rings import Rings ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, group) : r""" See :class:`GroupAlgebraFunctor` for full documentation. EXAMPLES:: sage: from sage.algebras.group_algebra_new import GroupAlgebraFunctor sage: GroupAlgebra(SU(2, GF(4, 'a')), IntegerModRing(12)).category() Category of hopf algebras with basis over Ring of integers modulo 12 """ self.__group = group ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, B, S) : r""" INPUT: - `B` -- A ring. - `S` -- A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid` TESTS:: sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesModuleFunctor sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid sage: F = MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False)) """ self.__S = S ConstructionFunctor.__init__(self, Modules(B), CommutativeAdditiveGroups())
def __init__(self, relations): """ Initialization of ``self``. TESTS:: sage: from sage.modules.module_functors import QuotientModuleFunctor sage: B = (2/3)*ZZ^2 sage: F = QuotientModuleFunctor(B) sage: TestSuite(F).run() """ R = relations.category().base_ring() ConstructionFunctor.__init__(self, Modules(R), Modules(R)) self._relations = relations
def __init__(self, arguments): """ A functor which produces a CallableSymbolicExpressionRing from the SymbolicRing. EXAMPLES:: sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor sage: x,y = var('x,y') sage: f = CallableSymbolicExpressionFunctor((x,y)); f CallableSymbolicExpressionFunctor(x, y) sage: f(SR) Callable function ring with arguments (x, y) sage: loads(dumps(f)) CallableSymbolicExpressionFunctor(x, y) """ self._arguments = arguments from sage.categories.all import Rings self.rank = 3 ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, type, precision): """ A functor constructing a ring or module of modular forms. INPUT: - ``type`` -- A type of modular forms. - ``precision`` -- A precision. NOTE: This does not respect keyword and has to be extended as soon as subclasses of ModularFormsAmbient_abstract demand for it. TESTS:: sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_functor import * sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import * sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import * sage: F = ModularFormsFunctor( ModularFormTestType_scalar(), NNFilter(5) ) """ self.__type = type self.__precision = precision ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__(self, type, precision) : """ A functor constructing a ring or module of modular forms. INPUT: - ``type`` -- A type of modular forms. - ``precision`` -- A precision. NOTE: This does not respect keyword and has to be extended as soon as subclasses of ModularFormsAmbient_abstract demand for it. TESTS:: sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_functor import * sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import * sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import * sage: F = ModularFormsFunctor( ModularFormTestType_scalar(), NNFilter(5) ) """ self.__type = type self.__precision = precision ConstructionFunctor.__init__(self, Rings(), Rings())
def __init__( self, base_ring_generators, generators, relations, grading, all_relations = True, reduce_before_evaluating = True ) : r""" INPUT: - ``base_ring_generators`` -- A sequence of (equivariant) monoid power series with coefficient domain the base ring of the coefficient domain of the generators or ``None``. - ``generators`` -- A sequence 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_ring 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_functor import * sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False)) sage: funct = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2))) """ if grading.ngens() != relations.ring().ngens() : raise ValueError( "Grading must have the same number of variables as the relations' polynomial ring." ) self.__relations = relations self.__grading = grading self.__all_relations = all_relations self.__reduce_before_evaluating = reduce_before_evaluating self.__gen_expansions = Sequence(generators) if base_ring_generators is None : self.__base_gen_expansions = Sequence([], universe = self.__gen_expansions.universe().base_ring()) else : self.__base_gen_expansions = Sequence(base_ring_generators) if len(self.__base_gen_expansions) == 0 : scalar_ring = self.__gen_expansions.universe().base_ring() if self.__gen_expansions.universe().coefficient_domain() != self.__gen_expansions.universe().base_ring() : scalar_ring = self.__gen_expansions.universe().base_ring().base_ring() else : scalar_ring = self.__gen_expansions.universe().base_ring() else : scalar_ring = self.__base_gen_expansions.universe().base_ring() if not relations.base_ring().has_coerce_map_from(scalar_ring) : raise ValueError( "The generators must be defined over the base ring of relations" ) if not isinstance(self.__gen_expansions.universe(), Algebra) and \ not isinstance(self.__gen_expansions.universe(), Module) : raise TypeError( "The generators' universe must be an algebra or a module" ) ConstructionFunctor.__init__( self, Rings(), Rings() )
def __init__(self, base_ring_generators, generators, relations, grading, all_relations=True, reduce_before_evaluating=True): r""" INPUT: - ``base_ring_generators`` -- A sequence of (equivariant) monoid power series with coefficient domain the base ring of the coefficient domain of the generators or ``None``. - ``generators`` -- A sequence 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_ring 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_functor import * sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False)) sage: funct = GradedExpansionFunctor(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2))) """ if grading.ngens() != relations.ring().ngens(): raise ValueError( "Grading must have the same number of variables as the relations' polynomial ring." ) self.__relations = relations self.__grading = grading self.__all_relations = all_relations self.__reduce_before_evaluating = reduce_before_evaluating self.__gen_expansions = Sequence(generators) if base_ring_generators is None: self.__base_gen_expansions = Sequence( [], universe=self.__gen_expansions.universe().base_ring()) else: self.__base_gen_expansions = Sequence(base_ring_generators) if len(self.__base_gen_expansions) == 0: scalar_ring = self.__gen_expansions.universe().base_ring() if self.__gen_expansions.universe().coefficient_domain( ) != self.__gen_expansions.universe().base_ring(): scalar_ring = self.__gen_expansions.universe().base_ring( ).base_ring() else: scalar_ring = self.__gen_expansions.universe().base_ring() else: scalar_ring = self.__base_gen_expansions.universe().base_ring() if not relations.base_ring().has_coerce_map_from(scalar_ring): raise ValueError( "The generators must be defined over the base ring of relations" ) if not isinstance(self.__gen_expansions.universe(), Algebra) and \ not isinstance(self.__gen_expansions.universe(), Module) : raise TypeError( "The generators' universe must be an algebra or a module") ConstructionFunctor.__init__(self, Rings(), Rings())