CoCalc -- gradedexpansion

Harvard Workshop: Distribution of modular symbols and L-values
code / alex / psage / psage / modform / fourier_expansion_framework / gradedexpansions / gradedexpansion_ambient.py
²⁴¹⁸⁴⁹ views
1
r"""
2
Ambients of elements with Fourier expansion and partially known relations.
3

4
AUTHOR :
5
    -- Martin Raum (2010 - 03 - 10) Initial version
6
"""
7

8
#===============================================================================
9
# 
10
# Copyright (C) 2010 Martin Raum
11
# 
12
# This program is free software; you can redistribute it and/or
13
# modify it under the terms of the GNU General Public License
14
# as published by the Free Software Foundation; either version 3
15
# of the License, or (at your option) any later version.
16
# 
17
# This program is distributed in the hope that it will be useful, 
18
# but WITHOUT ANY WARRANTY; without even the implied warranty of
19
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20
# General Public License for more details.
21
# 
22
# You should have received a copy of the GNU General Public License
23
# along with this program; if not, see <http://www.gnu.org/licenses/>.
24
#
25
#===============================================================================
26

27
from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_functor import \
28
            GradedExpansionFunctor, GradedExpansionEvaluationHomomorphism
29
from operator import xor
30
from sage.misc.cachefunc import cached_method
31
from sage.misc.flatten import flatten
32
from sage.misc.misc import prod
33
from sage.rings.all import Integer
34
from sage.structure.element import Element
35
from sage.structure.parent import Parent
36
from sage.structure.sequence import Sequence
37

38
## late import in GradedExpansionAmbient_abstract
39
GradedExpansionSubmodule = None 
40
GradedExpansionSubmodule_abstract = None
41

42
#===============================================================================
43
# GradedExpansionAmbient_abstract
44
#===============================================================================
45

46
class GradedExpansionAmbient_abstract :
47
    r"""
48
    A ring of graded expansions. This is a polynomial ring with relations
49
    and a mapping to an (equivariant) monoid power series. These should
50
    respect the given relations, but there can me more relations of the
51
    Fourier expansions that are stored for the polynomial ring.
52
    """
53
    
54
    def __init__ ( self, base_ring_generators, generators, relations,
55
                   grading, all_relations = True, reduce_before_evaluating = True) :
56
        r"""
57
        INPUT:
58
            - ``base_ring_generators``      -- A sequence of (equivariant) monoid power series with
59
                                               coefficient domain the base ring of the coefficient
60
                                               domain of the generators or ``None``.
61
            - ``generators``                -- A sequence of (equivariant) monoid power series; The generators
62
                                               of the ambient over the ring generated by the base ring
63
                                               generators.
64
            - ``relations``                 -- An ideal in a polynomial ring with ``len(base_ring_generators) + len(generators)``
65
                                               variables.
66
            - ``grading``                   -- A grading deriving from :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`;
67
                                               A grading for the polynomial ring of the relations.
68
            - ``all_relations``             -- A boolean (default: ``True``); If ``True`` the relations given
69
                                               for the polynomial ring are all relations that the Fourier
70
                                               expansion have.
71
            - ``reduce_before_evaluating``  -- A boolean (default: ``True``); If ``True`` any monomial
72
                                               will be Groebner reduced before the Fourier expansion
73
                                               is calculated.
74
        
75
        NOTE:
76
            The grading must respect the relations of the generators.
77
        
78
        EXAMPLES::
79
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
80
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
81
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
82
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
83
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
84
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
85
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,))) # indirect doctest
86
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2))) # indirect doctest
87
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), all_relations = False) # indirect doctest
88
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), reduce_before_evaluating = False) # indirect doctest
89
        """
90
        global GradedExpansionSubmodule, GradedExpansionSubmodule_abstract
91
        from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import GradedExpansionSubmodule
92
        from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule import GradedExpansionSubmodule_abstract
93

94
        self.__relations = relations
95
        self.__all_relations = all_relations
96
        self.__grading = grading
97
        
98
        if base_ring_generators is None :
99
            base_ring_generators = []
100
            base_ring_generators = Sequence([], universe = generators.universe().base_ring())
101
        self.__base_gens = \
102
          tuple([ self.base_ring()._element_class( self.base_ring(), self.base_ring().relations().ring()(g) )
103
                  for g in self.__relations.ring().gens()[:len(base_ring_generators)] ])
104
        self.__gens = \
105
         tuple([ self._element_class( self, g )
106
                 for g in self.__relations.ring().gens()[len(base_ring_generators):] ])
107

108
        # We expect the base ring generators to either admit coercion
109
        # into the universe of the generators or to act on it from the left 
110
        self.__base_gen_expansions = base_ring_generators
111
        self.__gen_expansions = generators
112
        self.__evaluation_hom = GradedExpansionEvaluationHomomorphism( self.__relations, self.__base_gen_expansions,
113
                                                                       self.__gen_expansions, self.__gen_expansions.universe(),
114
                                                                       reduce_before_evaluating )
115
        
116
        self.__graded_submodules = dict()
117
    
118
    def ngens(self) :
119
        r"""
120
        The number of generators of ``self`` over the base expansion ring.
121
        
122
        OUTPUT:
123
            An integer.
124
        
125
        EXAMPLES::
126
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
127
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
128
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
129
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
130
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
131
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
132
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
133
            sage: ger.ngens()
134
            1
135
        """
136
        return len(self.__gens)
137
    
138
    def gen(self, i = 0) :
139
        r"""
140
        The `i`-th generator of ``self`` over the base expansion ring.
141

142
        INPUT:
143
            - `i` -- An integer.
144
        
145
        OUTPUT:
146
            An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
147

148
        EXAMPLES::
149
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
150
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
151
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
152
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
153
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
154
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
155
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
156
            sage: ger.gen(0)
157
            Graded expansion a
158
        """
159
        return self.__gens[i]
160
    
161
    def gens(self) :
162
        r"""
163
        The generators of ``self`` over the base expansion ring.
164
        
165
        OUTPUT:
166
            A tuple of instances of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
167

168
        EXAMPLES::
169
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
170
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
171
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
172
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
173
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
174
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
175
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
176
            sage: ger.gens()
177
            (Graded expansion a,)
178
        """
179
        return self.__gens
180
    
181
    def nbasegens(self) :
182
        r"""
183
        Number of generators of the base expansion ring.
184
        
185
        OUTPUT:
186
            An integer.
187
        
188
        TESTS::
189
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
190
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
191
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
192
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
193
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
194
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
195
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
196
            sage: ger.nbasegens()
197
            0
198
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
199
            sage: ger.nbasegens()
200
            1
201
        """
202
        return len(self.__base_gens)
203
    
204
    def basegen(self, i) :
205
        r"""
206
        The `i`-th generator of the base expansion ring.
207
        
208
        INPUT:
209
            - `i` -- An integer.
210
            
211
        OUTPUT:
212
            An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
213
        
214
        TESTS::
215
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
216
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
217
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
218
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
219
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
220
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
221
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
222
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
223
            sage: ger.basegen(0)
224
            Graded expansion a
225
        """
226
        return self.__base_gens[i]
227
    
228
    def basegens(self) :
229
        r"""
230
        The generators of the base expansion ring.
231
        
232
        OUTPUT:
233
            A tuple of instances of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_element.GradedExpansion_abstract`.
234
        
235
        TESTS::
236
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
237
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
238
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
239
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
240
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
241
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
242
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
243
            sage: ger.basegens()
244
            (Graded expansion a,)
245
        """
246
        return self.__base_gens
247
    
248
    def is_field(self) :
249
        r"""
250
        OUTPUT:
251
            A boolean.
252
        
253
        TESTS::
254
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
255
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
256
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
257
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
258
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
259
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
260
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
261
            sage: ger.is_field()
262
            False
263
        """
264
        ## Never delete this. It is called during intialisation of deriving classes
265
        ## over number fields and and causes coercion to fail. 
266
        return False
267
    
268
    def grading(self) :
269
        r"""
270
        The grading imposed on this ring.
271
        
272
        OUTPUT:
273
            An isntance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_grading`.
274

275
        EXAMPLES::
276
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
277
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
278
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
279
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
280
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
281
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
282
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
283
            sage: ger.grading() == DegreeGrading((1,2))
284
            True
285
        """
286
        return self.__grading
287
    
288
    def relations(self) :
289
        r"""
290
        The relation of the generators of this ring with in the underlying
291
        polynomial ring.
292
        
293
        OUTPUT:
294
            An ideal in a polynomial ring.
295
        
296
        SEE:
297
            all_relations_known
298
        
299
        TESTS::
300
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
301
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
302
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
303
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
304
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
305
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
306
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
307
            sage: ger.relations()
308
            Principal ideal (0) of Univariate Polynomial Ring in a over Integer Ring
309
            sage: P.<a,b,c> = PolynomialRing(ZZ)
310
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), P.ideal(a*b - c), DegreeGrading((1,2)))
311
            sage: ger.relations()
312
            Ideal (a*b - c) of Multivariate Polynomial Ring in a, b, c over Integer Ring
313
        """
314
        return self.__relations
315
    
316
    def all_relations_known(self) :
317
        r"""
318
        If ``True`` is returned any relation of the Fourier expansions associated
319
        with elements of this ring - thought of as expansions with
320
        infinite precision - implies that the relation is also contained
321
        in ``self.relations()``.
322
        
323
        OUTPUT:
324
            A boolean.
325
        
326
        TESTS::
327
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
328
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
329
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
330
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
331
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
332
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
333
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
334
            sage: ger.all_relations_known()
335
            True
336
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), all_relations = False)
337
            sage: ger.all_relations_known()
338
            False
339
        """
340
        return self.__all_relations
341
    
342
    def has_relation_free_generators(self) :
343
        r"""
344
        If ``True`` is returned, there are no relations of the Fourier
345
        expansions - thought of as expansions with infinite precision.
346
        
347
        OUTPUT:
348
            A boolean.
349
            
350
        TESTS::
351
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
352
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
353
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
354
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
355
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
356
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
357
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,))) # indirect doctest
358
            sage: ger.has_relation_free_generators()
359
            True
360
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)), all_relations = False)
361
            sage: ger.has_relation_free_generators()
362
            False
363
            sage: P.<a,b,c> = PolynomialRing(ZZ)
364
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), P.ideal(a*b - c), DegreeGrading((1,2)))
365
            sage: ger.has_relation_free_generators()
366
            False
367
        """
368
        return self.__all_relations and self.__relations.is_zero()
369
    
370
    def _generator_expansions(self) :
371
        r"""
372
        The generators' Fourier expansion within a common parent.
373
        
374
        OUTPUT:
375
            A sequence of of (equivariant) monoid power series.
376
        
377
        TESTS::
378
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
379
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
380
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
381
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
382
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
383
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
384
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
385
            sage: ger._generator_expansions().universe()
386
            Ring of monoid power series over NN
387
            sage: ger._generator_expansions()[0].coefficients()
388
            {0: 1}
389
        """
390
        return self.__gen_expansions
391
    
392
    def _base_generator_expansions(self) :
393
        r"""
394
        The Fourier expansions of the generators of the base expansion ring.
395
        
396
        OUTPUT:
397
            A sequence of of (equivariant) monoid power series.
398
        
399
        TESTS::
400
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
401
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
402
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
403
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
404
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
405
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
406
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
407
            sage: ger._base_generator_expansions().universe()
408
            Rational Field
409
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
410
            sage: ger._base_generator_expansions()
411
            [Monoid power series in Ring of monoid power series over NN]
412
        """
413
        return self.__base_gen_expansions
414
    
415
    @cached_method
416
    def fourier_expansion_precision(self) :
417
        r"""
418
        A precision which is obtained by all expansions of any element.
419
        
420
        OUTPUT:
421
            A filter for the Fourier expansion ambient's monoid or action.
422
        
423
        TESTS::
424
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
425
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
426
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
427
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
428
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
429
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
430
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
431
            sage: ger.fourier_expansion_precision()
432
            Filtered NN up to +Infinity
433
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
434
            sage: ger.fourier_expansion_precision()
435
            Filtered NN up to 2
436
        """
437
        return min([ g.precision() for g in self.__gen_expansions + self.__base_gen_expansions])
438
    
439
    @cached_method
440
    def fourier_ring(self) :
441
        r"""
442
        The ring that Fourier expansions of all elements of this
443
        ring will be contained in.
444
        
445
        OUTPUT:
446
            An ambient of (equivariant) monoid power series.
447
        
448
        TESTS::
449
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
450
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
451
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
452
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
453
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
454
            sage: mps = MonoidPowerSeriesRing(ZZ, NNMonoid(False))
455
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(QQ, 'a').ideal(0), DegreeGrading((1,)))
456
            sage: ger.fourier_ring()
457
            Ring of monoid power series over NN
458
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
459
            sage: ger.fourier_ring()
460
            Ring of monoid power series over NN
461
        """
462
        if self.__gen_expansions.universe().base_ring() == self.base_ring() :
463
            return self.__gen_expansions.universe()
464
        else :
465
            from sage.categories.pushout import pushout
466
            
467
            if self.nbasegens() == 0 :
468
                scalar_ring = self.base_ring()
469
            else :
470
                scalar_ring = self.base_ring().base_ring()
471
            
472
            return pushout(self.__gen_expansions.universe(), scalar_ring) 
473
    
474
    #===========================================================================
475
    # def precision(self) :
476
    #    r"""
477
    #    Return the minimal precision of any fourier expansion in this ring.
478
    #    """
479
    #    return min([g.precision() for g in self._generator_expansions()])
480
    #===========================================================================
481

482
    def _set_evaluation_hom(self, hom) :
483
        r"""
484
        Set the homomorphism that maps every polynomial in the underlying
485
        polynomial ring to its expansion.
486
        
487
        INPUT:
488
            - ``hom`` -- A morphism with domain a polynomial ring and
489
                         domain an ambient of (equivariant) monoid power series.
490
        
491
        OUTPUT:
492
            ``None``.
493
        
494
        TESTS::
495
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
496
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
497
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
498
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
499
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
500
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
501
            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
502
            sage: ger2 = GradedExpansionRing_class(None, Sequence([mps(2)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
503
            sage: ger2._set_evaluation_hom(ger._GradedExpansionAmbient_abstract__evaluation_hom)
504
            sage: ger2.0.fourier_expansion().coefficients()
505
            {0: 1}
506
        """
507
        self.__evaluation_hom = hom
508
    
509
    def _fourier_expansion_of_element(self, e) :
510
        r"""
511
        The Fourier expansion of an element `e`.
512
        
513
        INPUT:
514
            - `e` -- An element of the ``self``.
515
        
516
        OUTPUT:
517
            A (equivariant) monoid power series.
518
        
519
        SEE:
520
            :class:~`.fourier_expansion_framework.gradedexpansions.fourierexpansionwrapper.FourierExpansionWrapper`.
521
        
522
        TESTS::
523
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
524
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
525
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
526
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
527
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
528
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
529
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 1}, mps.monoid().filter(2))]), Sequence([MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
530
            sage: ger.0.fourier_expansion() # indirect doctest
531
            Monoid power series in Ring of monoid power series over NN
532
            sage: (ger.basegens()[0]^2 * 2*ger.0).fourier_expansion() # indirect doctest
533
            Monoid power series in Ring of monoid power series over NN
534
            sage: (ger.basegens()[0] + 5*ger.0).fourier_expansion() # indirect doctest
535
            Monoid power series in Ring of monoid power series over NN
536
        """
537
        return self.__evaluation_hom(e.polynomial())
538
    
539
#===============================================================================
540
#    def graded_submodules_are_free(self) :
541
#        r"""
542
#        If ``True`` is returned, there are no relations within the module
543
#        formed by the Fourier expansions - thought of as expansions with
544
#        infinite precision - for a fixed grading value.
545
# 
546
#        OUTPUT:
547
#            A boolean.
548
#        
549
#        TESTS::
550
#            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
551
#            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
552
#            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
553
#            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
554
#            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
555
#            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
556
#            sage: ger = GradedExpansionRing_class(None, Sequence([mps(1)]), PolynomialRing(ZZ, 'a').ideal(0), DegreeGrading((1,)))
557
#            sage: ger.graded_submodules_are_free()
558
#            False
559
#        """
560
#        return False
561
#===============================================================================
562

563
    def _graded_monoms(self, index) :
564
        r"""
565
        Return all monoms in the generators that have a given grading index.
566
        
567
        INPUT:
568
            - ``index`` -- A grading values.
569
        
570
        OUTPUT:
571
            A list of elements of ``self``.
572
        
573
        TESTS::
574
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
575
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
576
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
577
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
578
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
579
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
580
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
581
            sage: GradedExpansionAmbient_abstract._graded_monoms(ger, 3)
582
            Traceback (most recent call last):
583
            ...
584
            NotImplementedError
585
        """        
586
        raise NotImplementedError
587

588
    def graded_submodule(self, indices, **kwds) :
589
        r"""
590
        The submodule which contains all elements of given 
591
        grading values.
592
        
593
        INPUT:
594
            - ``indices`` -- A list or tuple of grading values or a single grading value.
595
            - ``**kwds``  -- A dictionary of keywords; They will be passed to the
596
                             submodule constructor.
597
        
598
        OUTPUT:
599
            An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule.GradedExpansionSubmodule_abstract`.
600

601
        TESTS::
602
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
603
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
604
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
605
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
606
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
607
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
608
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
609
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
610
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
611
            sage: sm = ger.graded_submodule(2)
612
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all())]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
613
            sage: sm = ger.graded_submodule(3)
614
            sage: P.<a,b,c> = PolynomialRing(QQ)
615
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter_all()), MonoidPowerSeries(mps, {2 : 1, 3: 6, 4 : 9}, mps.monoid().filter_all())]), P.ideal(b^2 - c), DegreeGrading((1,2)))
616
            sage: sm = ger.graded_submodule(4)
617
            sage: m = FreeModule(QQ, 3)
618
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
619
            sage: mps = mpsm.base_ring()
620
            sage: ger = GradedExpansionModule_class(None, Sequence([MonoidPowerSeries(mpsm, {1 : m([1,2,3]), 2 : m([3,-3,2])}, mpsm.monoid().filter(4)), MonoidPowerSeries(mpsm, {1 : m([2,-1,-1]), 2 : m([1,0,0])}, mpsm.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
621
            sage: ger.graded_submodule(4).rank()
622
            0
623
        """
624
        #=======================================================================
625
        # if not self.graded_submodules_are_free() :
626
        #    raise ValueError( "Graded submodules of must be free." )
627
        #=======================================================================
628
        
629
        if indices in self.grading() :
630
            indices = tuple([indices])
631
        elif isinstance(indices, list) :
632
            indices = tuple(indices)
633
        elif not isinstance(indices, tuple) :
634
            raise TypeError( "Wrong type of indices." )
635
            
636
        try :
637
            return self.__graded_submodules[indices]
638
        except KeyError :
639
            pass
640

641
        module_gens = flatten(map(self._graded_monoms, indices), max_level = 1)        
642
        
643
        if self.has_relation_free_generators() :
644
            basis = module_gens
645
        else :
646
            module_gens_poly = map(lambda g: g.polynomial(), module_gens) 
647
            basis = list()
648
            
649
            I = self.relations().ring().zero_ideal()
650
            for i,g in enumerate(module_gens_poly) :
651
                rg = I.reduce(g)
652
                
653
                if not rg.is_zero() :
654
                    I = I.ring().ideal([rg] + list(I.gens_reduced()))
655
                    basis.append(module_gens[i])
656

657
        self.__graded_submodules[indices] = self._submodule(basis, grading_indices = indices, **kwds)
658
        
659
        return self.__graded_submodules[indices] 
660
    
661
    def _submodule(self, arg, *args, **kwds) :
662
        r"""
663
        Return a submodule of ``self``.
664
        
665
        INPUT:
666
            - `arg` -- A list of elements of ``self``.
667
        
668
        OUTPUT:
669
            An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_submodule.GradedExpansionSubmodule_abstract`.
670
        
671
        TESTS::
672
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
673
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
674
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
675
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
676
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
677
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
678
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(ZZ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
679
            sage: sm = ger.graded_submodule(2) # indirect doctest
680
        """
681
        if isinstance(arg, list) :
682
            return GradedExpansionSubmodule(self, arg)
683
        else :
684
            raise NotImplementedError
685

686
    def __cmp__(self, other) :
687
        r"""
688
        TESTS::
689
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
690
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
691
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
692
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
693
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
694
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
695
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
696
            sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
697
            True
698
            sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,3)))
699
            False
700
            sage: P.<a,b> = PolynomialRing(QQ)
701
            sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), P.ideal(a^2 - b), DegreeGrading((1,2)))
702
            False
703
            sage: ger == GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 4}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
704
            False
705
            sage: ger == GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1 : 4}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b', 'c']).ideal(0), DegreeGrading((1,2,2)))
706
            False
707
        """
708
        c = cmp(type(self), type(other))
709
        if c == 0 :
710
            c = cmp(self.__relations, other.__relations)
711
        if c == 0 :
712
            c = cmp(self.__all_relations, other.__all_relations)
713
        if c == 0 :
714
            c = cmp(self.__grading, other.__grading)
715
        if c == 0 :
716
            c = cmp(self.__base_gen_expansions, other.__base_gen_expansions)
717
        if c == 0 :
718
            c = cmp(self.__gen_expansions, other.__gen_expansions)
719
            
720
        return c
721
    
722
    def construction(self) :
723
        r"""
724
        TESTS::
725
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
726
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
727
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
728
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
729
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
730
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
731
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
732
            sage: (F, A) = ger.construction()
733
            sage: ger == F(A)
734
            True
735
        """
736
        return ( GradedExpansionFunctor(self.__base_gen_expansions, self.__gen_expansions,
737
                                        self.__relations, self.__grading, self.__all_relations ), \
738
                 self.base_ring() )
739

740
    def _element_constructor_(self, x) :
741
        r"""
742
        INPUT:
743
            - `x` -- An element of the underlying polynomial ring or
744
                     an element in a submodule of graded expansions.
745
        
746
        OUTPUT:
747
            An instance of the element class.
748
        
749
        TESTS::
750
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
751
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
752
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
753
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
754
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
755
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
756
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
757
            sage: ger = GradedExpansionRing_class(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)))
758
            sage: h = ger(PolynomialRing(QQ, ['a', 'b']).gen(0))
759
            sage: sm = ger.graded_submodule(3)
760
            sage: h = ger(sm.0)
761
            sage: m = FreeModule(QQ, 3)
762
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
763
            sage: mps = mpsm.base_ring()
764
            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)))
765
            sage: h = ger(PolynomialRing(QQ, ['a', 'b']).gen(1))
766
            sage: sm = ger.graded_submodule(3)
767
            sage: h = ger(sm.0)
768
        """
769
        if isinstance(x, Element) :
770
            P = x.parent()
771
            if P is self.relations().ring() :
772
                return self._element_class(self, x)
773
            elif isinstance(P, GradedExpansionSubmodule_abstract) :
774
                if self is P.graded_ambient() :
775
                    return P._graded_expansion_submodule_to_graded_ambient_(x)                
776
                elif self.has_coerce_map_from(P.graded_ambient()) :
777
                    return self(P.graded_ambient()(x))
778
            ## We cannot handle base extensions here, because we don't know anything
779
            ## about additional relations which may occur. So deriving classes have
780
            ## to care about this.
781
                   
782
        raise TypeError( "The element %s cannot be converted into %s," % (x, self) )
783

784
    def __hash__(self) :
785
        r"""
786
        TESTS::
787
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
788
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
789
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
790
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
791
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
792
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
793
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1 : 4, 2 : 3}, mps.monoid().filter(4)), MonoidPowerSeries(mps, {1 : 1, 2 : 3}, mps.monoid().filter(4))]), PolynomialRing(QQ, ['a', 'b']).ideal(0), DegreeGrading((1,2)))
794
            sage: hash(ger)
795
            921050467 # 32-bit
796
            3906772531912514915 # 64-bit
797
        """
798
        return reduce(xor, map(hash, [self.__grading, self.__relations,
799
                                      self.__all_relations, self.__base_gens, self.__gens]) )
800

801
Product

Resources

Company
