CoCalc -- gradedexpansion

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

4
AUTHOR :
5
    -- Martin Raum (2009 - 07 - 27) Initial version
6
"""
7

8
#===============================================================================
9
# 
10
# Copyright (C) 2009 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.fourierexpansionwrapper import FourierExpansionWrapper
28
from itertools import groupby
29
from sage.algebras.algebra_element import AlgebraElement
30
from sage.misc.all import prod
31
from sage.misc.latex import latex
32
from sage.modules.module_element import ModuleElement
33
from sage.rings.infinity import infinity
34
import operator
35

36
#===============================================================================
37
# GradedExpansion_abstract
38
#===============================================================================
39

40
class GradedExpansion_abstract ( FourierExpansionWrapper ) :
41
    r"""
42
    An abstract graded expansion.
43
    """
44
    
45
    def __init__(self, parent, polynomial) :
46
        r"""
47
        INPUT:
48
            - ``parent``     -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ambient.GradedExpansionAmbient_abstract`.
49
            - ``polynomial`` -- A polynomial in the polynomial ring underlying the parent.
50
        
51
        TESTS::
52
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
53
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
54
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
55
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
56
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
57
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
58
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
59
            sage: P.<a,b> = QQ[]
60
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
61
            sage: h = GradedExpansion_abstract(ger, P(0))
62
            sage: h = GradedExpansion_abstract(ger, a*b)
63
        """
64
        self.__polynomial = polynomial
65
        
66
    def polynomial(self) :
67
        r"""
68
        The underlying polynomial.
69
        
70
        OUTPUT:
71
            A polynomial in the polynomial ring underlying the parent.
72
        
73
        NOTE:
74
            This polynomial might change by elements of the parent's
75
            relation ideal.
76
        
77
        TESTS::
78
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
79
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
80
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
81
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
82
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
83
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
84
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
85
            sage: P.<a,b> = QQ[]
86
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
87
            sage: h = GradedExpansion_abstract(ger, a * b)
88
            sage: h.polynomial()
89
            a*b
90
        """
91
        return self.__polynomial
92
    
93
    def _reduce_polynomial(self, set_polynomial = True) :
94
        r"""
95
        The Groebner reduced underlying polynomial.
96

97
        INPUT:
98
            - ``set_polynomial`` -- A boolean (default: ``True``); If ``True``
99
                                    the underlying polynomial will be set to the
100
                                    reduced polynomial.
101
        OUTPUT:
102
            A polynomial in the polynomial ring underlying the parent.
103
        
104
        TESTS::
105
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
106
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
107
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
108
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
109
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
110
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
111
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
112
            sage: P.<a,b> = QQ[]
113
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
114
            sage: h = GradedExpansion_class(ger, a - b)
115
            sage: h._reduce_polynomial(set_polynomial = False)
116
            0
117
            sage: h.polynomial()
118
            a - b
119
            sage: h._reduce_polynomial()
120
            0
121
            sage: h.polynomial()
122
            0
123
        """
124
        if set_polynomial :
125
            self.__polynomial = self.parent().relations().reduce(self.__polynomial)
126
        
127
            return self.__polynomial
128
        else :
129
            return self.parent().relations().reduce(self.__polynomial)
130
    
131
    def homogeneous_components(self) :
132
        r"""
133
        Split the underlying polynomial with respect to grading imposed on
134
        the parent.
135
        
136
        OUTPUT:
137
           A dictionary with key the grading values and values the polynomials.
138
        
139
        EXAMPLES::
140
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
141
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
142
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
143
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
144
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
145
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
146
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
147
            sage: P.<a,b> = QQ[]
148
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
149
            sage: h = GradedExpansion_class(ger, a - b)
150
            sage: h.homogeneous_components()
151
            {1: a, 2: -b}
152

153
        TESTS::
154
            sage: h = GradedExpansion_class(ger, P(0))
155
            sage: h.homogeneous_components()
156
            {}
157
        """
158
        if self.__polynomial.is_zero() :
159
            return dict()
160
        
161
        components = dict()
162
        grading = self.parent().grading().index
163
        if self.__polynomial.parent().ngens() == 1 :
164
            normalize = lambda e: (e,)
165
            var = self.__polynomial.parent().gen(0)
166
            monomial = lambda e: var**e
167
        else :
168
            normalize = lambda e: e
169
            vars = self.__polynomial.parent().gens()
170
            monomial = lambda e: prod( map(operator.pow, vars, e) )
171
             
172
        for e in self.__polynomial.exponents() :
173
            ne = normalize(e)
174
            m = monomial(e)
175
            try :
176
                components[grading(ne)] = components[grading(ne)] + m * self.__polynomial[e]
177
            except KeyError :
178
                components[grading(ne)] = m * self.__polynomial[e]
179
        
180
        return components
181

182
    def exponents(self) :
183
        r"""
184
        The exponents of the underlying polynomial.
185
        
186
        OUTPUT:
187
            A list of tuples.
188
        
189
        TESTS::
190
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
191
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
192
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
193
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
194
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
195
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
196
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
197
            sage: P.<a,b> = QQ[]
198
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
199
            sage: h = GradedExpansion_abstract(ger, a - b)
200
            sage: h.exponents()
201
            [(1, 0), (0, 1)]
202
            sage: P.<a> = QQ[]
203
            sage: ger = GradedExpansionRing_class(None, Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,)))
204
            sage: h = GradedExpansion_abstract(ger, a)
205
            sage: h.exponents()
206
            [(1,)]
207
        """
208
        if self.polynomial().parent().ngens() == 1 :
209
            return map(lambda e: (e,), self.polynomial().exponents())
210
        else :
211
            return map(tuple, self.polynomial().exponents())
212

213
    def grading_index(self) :
214
        r"""
215
        If ``self`` is homogeneous, return the index of ``self`` with respect to
216
        the grading imposed on the parent. Otherwise, a ``ValueError`` is raised.
217
        
218
        OUTPUT:
219
            A grading value.
220
        
221
        TESTS::
222
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
223
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
224
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
225
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
226
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
227
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
228
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
229
            sage: P.<a,b> = QQ[]
230
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
231
            sage: h = GradedExpansion_class(ger, a^2)
232
            sage: h.grading_index()
233
            2
234
            sage: h = GradedExpansion_class(ger, P(0))
235
            sage: h.grading_index()
236
            +Infinity
237
            sage: h = GradedExpansion_class(ger, a - b)
238
            sage: h.grading_index()
239
            Traceback (most recent call last):
240
            ...
241
            ValueError: No homogeneous weight.
242
        """
243
        cps = self.homogeneous_components()
244
        if len(cps) == 0 :
245
            return infinity
246
        elif len(cps) != 1 :
247
            raise ValueError( "No homogeneous weight." )
248
        
249
        return cps.keys()[0]
250
    
251
    def _add_(left, right) :
252
        r"""
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: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
260
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
261
            sage: P.<a,b> = QQ[]
262
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
263
            sage: h = GradedExpansion_class(ger, a^2)
264
            sage: l = GradedExpansion_class(ger, b)
265
            sage: (h + l).polynomial()
266
            a^2 + b
267
        """
268
        return left.__class__( left.parent(),
269
                left.polynomial() + right.polynomial() )
270
        
271
    def _lmul_(self, c) :
272
        r"""
273
        TESTS::
274
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
275
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
276
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
277
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
278
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
279
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
280
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
281
            sage: P.<a,b> = QQ[]
282
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
283
            sage: h = GradedExpansion_class(ger, a - b)
284
            sage: (h*ger.base_ring()(4)).polynomial()
285
            4*a - 4*b
286
        """
287
        if self.parent().nbasegens() != 0 :
288
            return self.__class__( self.parent(),
289
                    self.polynomial() * c.polynomial() )
290
        else :
291
            return self.__class__( self.parent(),
292
                    self.polynomial() * c )
293
        
294
    def _rmul_(self, c) :
295
        r"""
296
        TESTS::
297
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
298
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
299
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
300
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
301
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
302
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
303
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
304
            sage: P.<a,b> = QQ[]
305
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
306
            sage: h = GradedExpansion_class(ger, a^2)
307
            sage: (ger.base_ring()(4) * h).polynomial()
308
            4*a^2
309
        """
310
        if self.parent().nbasegens() != 0 :
311
            return self.__class__( self.parent(),
312
                    c.polynomial() * self.polynomial() )
313
        else :
314
            return self.__class__( self.parent(),
315
                    c * self.polynomial() )
316
            
317
    def __cmp__(self, other) :
318
        r"""
319
        TESTS::
320
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
321
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
322
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
323
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
324
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
325
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
326
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
327
            sage: P.<a,b> = QQ[]
328
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
329
            sage: h = GradedExpansion_class(ger, a^2)
330
            sage: h == GradedExpansion_class(ger, a^2)
331
            True
332
            sage: h == GradedExpansion_class(ger, a - b)
333
            False
334
            sage: h = GradedExpansion_class(ger, P(0))
335
            sage: h == GradedExpansion_class(ger, a - b)
336
            True
337
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(0), DegreeGrading((1,2)))
338
            sage: h = GradedExpansion_class(ger, a^2)
339
            sage: h == GradedExpansion_class(ger, a^2)
340
            True
341
            sage: h = GradedExpansion_class(ger, P(0))
342
            sage: h == GradedExpansion_class(ger, a - b)
343
            False
344
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)), all_relations = False)
345
            sage: h = GradedExpansion_class(ger, a^2)
346
            sage: h == GradedExpansion_class(ger, a^2)
347
            False
348
        """
349
        c = cmp(type(self), type(other))
350
        
351
        if c == 0 :
352
            if self.parent().all_relations_known() :
353
                if self.parent().has_relation_free_generators() :
354
                    c = cmp(self.polynomial(), other.polynomial())
355
                else :
356
                    c = cmp(self.parent().relations().reduce(self.polynomial() - other.polynomial()), 0)
357
            else :
358
                c = 1
359

360
        return c
361

362
#===============================================================================
363
# GradedExpansion_class
364
#===============================================================================
365

366
class GradedExpansion_class ( GradedExpansion_abstract, AlgebraElement ) :
367
    r"""
368
    A graded expansion which is element of an algebra.
369
    
370
    SEE:
371
        :class:`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
372
    """
373
    def __init__(self, parent, polynomial) :
374
        r"""
375
        INPUT:
376
            - ``parent``     -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_ring.GradedExpansionRing_class`.
377
            - ``polynomial`` -- A polynomial in the polynomial ring underlying the parent.
378
        
379
        TESTS::
380
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
381
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
382
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
383
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
384
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
385
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
386
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
387
            sage: P.<a,b> = QQ[]
388
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
389
            sage: h = GradedExpansion_class(ger, a^2)
390
        """
391
        AlgebraElement.__init__(self, parent)
392
        GradedExpansion_abstract.__init__(self, parent, polynomial)        
393
        
394
    def _mul_(left, right) :
395
        r"""
396
        TESTS::
397
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
398
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
399
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
400
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
401
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
402
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
403
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
404
            sage: P.<a,b> = QQ[]
405
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
406
            sage: h = GradedExpansion_class(ger, a^2)
407
            sage: (h * h).polynomial()
408
            a^4
409
        """
410
        return left.__class__( left.parent(),
411
                left.polynomial() * right.polynomial() )
412

413
    def __hash__(self) :
414
        r"""
415
        TESTS::
416
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
417
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
418
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
419
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
420
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
421
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
422
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
423
            sage: P.<a,b> = QQ[]
424
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
425
            sage: h = GradedExpansion_class(ger, a^2)
426
            sage: hash(h)
427
            -1239234133 # 32-bit
428
            12415370528999851 # 64-bit
429
        """
430
        return hash(self.polynomial())
431
    
432
    def _repr_(self) :
433
        r"""
434
        TESTS::
435
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
436
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
437
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
438
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
439
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
440
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
441
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
442
            sage: P.<a,b> = QQ[]
443
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
444
            sage: GradedExpansion_class(ger, a^2)
445
            Graded expansion a^2
446
        """
447
        return "Graded expansion %s" % (self.polynomial(),)
448
    
449
    def _latex_(self) :
450
        r"""
451
        TESTS::
452
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
453
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import *
454
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
455
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
456
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_ring import *
457
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
458
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
459
            sage: P.<a,b> = QQ[]
460
            sage: ger = GradedExpansionRing_class(Sequence([MonoidPowerSeries(mps, {1: 1}, mps.monoid().filter(4))]), Sequence([MonoidPowerSeries(mps, {1: 1, 2: 3}, mps.monoid().filter(4))]), P.ideal(a - b), DegreeGrading((1,2)))
461
            sage: latex( GradedExpansion_class(ger, a^2) )
462
            \text{Graded expansion }a^{2}
463
        """
464
        return r"\text{Graded expansion }%s" % latex(self.polynomial())
465

466
class GradedExpansionVector_class ( GradedExpansion_abstract, ModuleElement ) :
467
    r"""
468
    A graded expansion which is element of a module.
469
        
470
    SEE:
471
        :class:`fourier_expansion_framework.gradedexpansions.gradedexpansion_module.GradedExpansionModule_class`.
472
    """
473

474
    def __init__(self, parent, polynomial) :
475
        r"""
476
        INPUT:
477
            - ``parent``     -- An instance of :class:~`fourier_expansion_framework.gradedexpansions.gradedexpansion_module.GradedExpansionModule_class`.
478
            - ``polynomial`` -- A polynomial in the polynomial ring underlying the parent.
479
        
480
        TESTS::
481
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
482
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
483
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
484
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
485
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
486
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
487
            sage: m = FreeModule(QQ, 3)
488
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
489
            sage: mps = mpsm.base_ring()
490
            sage: P.<a,b> = QQ[]
491
            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))]), P.ideal(0), DegreeGrading((1,2)))
492
            sage: h = GradedExpansionVector_class(ger, a)
493
        """
494
        ModuleElement.__init__(self, parent)
495
        GradedExpansion_abstract.__init__(self, parent, polynomial)
496

497
    def __hash__(self) :
498
        r"""
499
        TESTS::
500
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
501
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
502
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
503
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
504
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
505
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
506
            sage: m = FreeModule(QQ, 3)
507
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
508
            sage: mps = mpsm.base_ring()
509
            sage: P.<a,b> = QQ[]
510
            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))]), P.ideal(0), DegreeGrading((1,2)))
511
            sage: h = GradedExpansionVector_class(ger, a)
512
            sage: hash(h)
513
            -1239234136 # 32-bit
514
            12415370528999848 # 64-bit
515
        """
516
        return hash(self.polynomial())
517
    
518
    def _repr_(self) :
519
        r"""
520
        TESTS::
521
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
522
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
523
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
524
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
525
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
526
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
527
            sage: m = FreeModule(QQ, 3)
528
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
529
            sage: mps = mpsm.base_ring()
530
            sage: P.<a,b> = QQ[]
531
            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))]), P.ideal(0), DegreeGrading((1,2)))
532
            sage: GradedExpansionVector_class(ger, a*b)
533
            Graded expansion vector (a,)
534
        """
535
        poly = self.polynomial()
536
        
537
        exps = poly.exponents()
538
        if poly.parent().ngens() == 1 :
539
            exps = map(lambda e: (e,), exps)
540
        exps = sorted(map(tuple, exps), reverse = True)
541
        
542
        coefficient_monomials = poly.parent().gens()[:self.parent().nbasegens()]
543
        exps = groupby(exps, lambda e: e[self.parent().nbasegens():])
544
        vector_repr = [poly.parent()(0) for _ in range(self.parent().ngens())]
545
        for v, es in exps :
546
            if v.count(1) != 1 :
547
                continue
548
            
549
            ind = v.index(1)
550
            c = 0
551
            for e in es :
552
                c += poly[e] * prod(map(operator.pow, coefficient_monomials, e[:self.parent().nbasegens()]))
553
            vector_repr[ind] += c
554
        
555
        return "Graded expansion vector %s" % (tuple(vector_repr),)
556
    
557
    def _latex_(self) :
558
        r"""
559
        TESTS::
560
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
561
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import *
562
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_element import *
563
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_grading import DegreeGrading
564
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_module import *
565
            sage: from psage.modform.fourier_expansion_framework.gradedexpansions.gradedexpansion_element import *
566
            sage: m = FreeModule(QQ, 3)
567
            sage: mpsm = MonoidPowerSeriesModule(m, NNMonoid(False))
568
            sage: mps = mpsm.base_ring()
569
            sage: P.<a,b> = QQ[]
570
            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))]), P.ideal(0), DegreeGrading((1,2)))
571
            sage: latex( GradedExpansionVector_class(ger, a*b) )
572
            \text{Graded expansion vector }\left(a\right)
573
        """
574
        poly = self.polynomial()
575
        
576
        exps = poly.exponents()
577
        if poly.parent().ngens() == 1 :
578
            exps = map(lambda e: (e,), exps)
579
        exps = sorted(map(tuple, exps), reverse = True)
580
        
581
        coefficient_monomials = poly.parent().gens()[:self.parent().nbasegens()]
582
        exps = groupby(exps, lambda e: e[self.parent().nbasegens():])
583
        vector_repr = [poly.parent()(0) for _ in range(self.parent().ngens())]
584
        for v, es in exps :
585
            if v.count(1) != 1 :
586
                continue
587
            
588
            ind = v.index(1)
589
            c = 0
590
            for e in es :
591
                c += poly[e] * prod(map(operator.pow, coefficient_monomials, e[:self.parent().nbasegens()]))
592
            vector_repr[ind] += c
593
                
594
        return r"\text{Graded expansion vector }%s" % (latex(tuple(vector_repr)),)
595
    
596

597
Product

Resources

Company
