CoCalc -- monoidpowerseries

Harvard Workshop: Distribution of modular symbols and L-values
code / alex / psage / psage / modform / fourier_expansion_framework / monoidpowerseries / monoidpowerseries_module.py
²⁴¹⁸⁵² views
1
r"""
2
Modules of monoid power series and modules of equivariant monoid power series.
3

4
AUTHOR :
5
    -- Martin Raum (2010 - 02 - 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.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract,\
28
                                      EquivariantMonoidPowerSeriesAmbient_abstract
29
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import TrivialRepresentation
30
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing, \
31
                                   EquivariantMonoidPowerSeriesRing
32
from sage.modules.module import Module
33
from sage.rings.integer import Integer
34
from sage.structure.element import Element
35

36
_monoidpowerseries_module_cache = dict()
37
_equivariantmonoidpowerseries_module_cache = dict()
38

39
#===============================================================================
40
# MonoidPowerSeriesModule
41
#===============================================================================
42

43
def MonoidPowerSeriesModule(A, S) :
44
    r"""
45
    Return the globally unique monoid power series ring with indices
46
    in the filtered monoid `S` and coefficients in `A`.
47
    
48
    INPUT:
49
        - `A` -- A module.
50
        - `S` -- A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
51

52
    EXAMPLES::
53
        sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
54
        sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule
55
        sage: mps = MonoidPowerSeriesModule(QQ, NNMonoid(False))
56
        sage: mps is MonoidPowerSeriesModule(QQ, NNMonoid(False))
57
        True
58
    """
59
    global _monoidpowerseries_module_cache
60
    key = (A, S)
61
    
62
    try :
63
        return _monoidpowerseries_module_cache[key]
64
    except KeyError :
65
        P = MonoidPowerSeriesModule_generic(A, S)
66
        _monoidpowerseries_module_cache[key] = P
67
        
68
        return P
69

70
#===============================================================================
71
# MonoidPowerSeriesModule_generic
72
#===============================================================================
73

74
class MonoidPowerSeriesModule_generic ( MonoidPowerSeriesAmbient_abstract, Module ) :
75
    r"""
76
    Given some `K` module `A` and a monoid `S` filtered over
77
    a net `\Lambda` construct a module of monoid power series.
78
    
79
    Set `R = B[S]`. Then the projective limit of `R / R_\lambda` for
80
    `\lambda \in \Lambda \rightarrow \infty` considered as a
81
    `K` module is implemented by this class.
82

83
    NOTE:
84
        The implementation respects left and right modules.
85
    """
86

87
    def __init__(self, A, S) :
88
        r"""
89
        INPUT:
90
            - `A` -- A module.
91
            - `S` -- A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
92

93
        TESTS::
94
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
95
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
96
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
97
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(ZZ,2), NNMonoid(False))
98
            sage: mps.base_ring()
99
            Ring of monoid power series over NN
100
            sage: (1 / 2) * mps.0
101
            Monoid power series in Module of monoid power series over NN
102
        """
103
        Module.__init__(self, MonoidPowerSeriesRing(A.base_ring(), S))
104
        MonoidPowerSeriesAmbient_abstract.__init__(self, A, S)
105
        
106
        self.__coeff_gens = \
107
          [ self._element_class(self, dict([(S.zero_element(), a)]),
108
                                    self.monoid().filter_all() )
109
            for a in A.gens() ]
110

111
    def ngens(self) :
112
        r"""
113
        TESTS::
114
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
115
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
116
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
117
            sage: mps.ngens()
118
            2
119
        """
120
        return len(self.__coeff_gens)
121
    
122
    def gen(self, i = 0) :
123
        r"""
124
        TESTS::
125
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
126
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
127
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
128
            sage: mps.gen()
129
            Monoid power series in Module of monoid power series over NN
130
        """
131
        return self.gens()[i]
132
        
133
    def gens(self) :
134
        r"""
135
        TESTS::
136
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
137
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
138
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
139
            sage: mps.gens()
140
            [Monoid power series in Module of monoid power series over NN, Monoid power series in Module of monoid power series over NN]
141
        """
142
        return self.__coeff_gens
143
    
144
    def construction(self) :
145
        r"""
146
        TESTS::
147
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
148
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
149
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
150
            sage: (f, a) = mps.construction()
151
            sage: (f, a)
152
            (MonoidPowerSeriesModuleFunctor, Vector space of dimension 2 over Rational Field)
153
            sage: f(a) == mps
154
            True
155
        """
156
        from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesModuleFunctor
157
        return MonoidPowerSeriesModuleFunctor(self.base_ring().coefficient_domain(), self.monoid()), self.coefficient_domain()
158

159
    def zero_element(self) :
160
        r"""
161
        TESTS::
162
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
163
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
164
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
165
            sage: h = mps.zero_element()
166
        """
167
        return self(0)
168
    
169
    def _element_constructor_(self, x) :
170
        r"""
171
        TESTS::
172
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
173
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
174
            sage: mps = MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
175
            sage: h = mps(0) # indirect doctest
176
            sage: h = mps(int(0)) # indirect doctest
177
        """
178
        if isinstance(x, int) and x == 0 :
179
            return self._element_class( self, dict(),
180
                        self.monoid().filter_all() )
181
        if isinstance(x, Element) and x.is_zero() :
182
            P = x.parent()
183

184
            if self.base_ring().base_ring().has_coerce_map_from(P) :
185
                return self._element_class( self, dict(),
186
                    self.monoid().filter_all() )
187
    
188
        return MonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
189
 
190
    def _repr_(self) :
191
        r"""
192
        TESTS::
193
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
194
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
195
            sage: MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False))
196
            Module of monoid power series over NN
197
        """
198
        return "Module of monoid power series over " + self.monoid()._repr_()
199

200
    def _latex_(self) :
201
        r"""
202
        TESTS::
203
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
204
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import MonoidPowerSeriesModule_generic
205
            sage: latex(MonoidPowerSeriesModule_generic(FreeModule(QQ,2), NNMonoid(False)))
206
            \text{Module of monoid power series over }\Bold{N}
207
        """
208
        return r"\text{Module of monoid power series over }" + self.monoid()._latex_()
209
    
210
###############################################################################
211
###############################################################################
212
###############################################################################
213

214
#===============================================================================
215
# EquivariantMonoidPowerSeriesModule
216
#===============================================================================
217

218
def EquivariantMonoidPowerSeriesModule(O, C, R) :
219
    r"""
220
    Return the globally unique module of equivariant monoid power
221
    over the monoid with action `O` with coefficients in the codomain `R`
222
    with a representation and a set of virtual characters `C`.
223

224
    INPUT:
225
        - `O` -- A monoid with an action of a group; As implemented in
226
                 :class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
227
        - `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
228
        - `R` -- A representation on a module; As implemented
229
                 in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
230
        
231
    EXAMPLES::
232
        sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
233
        sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
234
        sage: emps = EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
235
        sage: emps is EquivariantMonoidPowerSeriesModule(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
236
        True
237
    """
238

239
    ## TODO: Implement optional checking of the relation (*)
240
    if O.group() != C.group() :
241
        raise ValueError, "The action on S and the characters must have the same group"
242
    if R.base_ring() != C.codomain() :
243
        if C.codomain().has_coerce_map_from(R.base_ring()) :
244
            K = C.codomain()
245
            R = R.base_extend(K)
246
        elif R.base_ring().has_coerce_map_from(C.codomain()) :
247
            K = R.base_ring()
248
        else :
249
            from sage.categories.pushout import pushout
250
            
251
            try :
252
                K = pushout(C.codomain(), R.base_ring())
253
                R = R.base_extend(K)
254
            except :
255
                raise ValueError, "character codomain and representation base ring have no common extension"
256
    
257
    global _equivariantmonoidpowerseries_module_cache
258
    key = (O, C, R)
259
    
260
    try :
261
        return _equivariantmonoidpowerseries_module_cache[key]
262
    except KeyError :
263
        P = EquivariantMonoidPowerSeriesModule_generic(O, C, R)
264
        _equivariantmonoidpowerseries_module_cache[key] = P
265
        
266
        return P
267

268
#===============================================================================
269
# EquivariantMonoidPowerSeriesModule_generic
270
#===============================================================================
271

272
class EquivariantMonoidPowerSeriesModule_generic ( EquivariantMonoidPowerSeriesAmbient_abstract, Module ) :
273
    r"""
274
    Given some module `A`, a monoid `S` filtered over some originated
275
    net `\Lambda` such that all induced submonoids are finite, a group `G`, a
276
    semigroup `C` with a map `c \rightarrow \mathrm{Hom}(G, Aut_K(A))`, a
277
    homomorphism `\phi : G -> Aut(S)` and a homomorphism `\eta : G -> C`, where
278
    `K` is the base ring of `A`.
279
    
280
    Suppose for every `c, c'` in `C`, and `g` in `G`, and `a, a'` in `A` we have
281
      `(c c') (g) (a a') = c(g)(a) c'(g)(a')`. 
282
    Set `R = B[C][S]`. Then the projective limit of
283
      `R / R_\lambda` for `\lambda \in \Lambda \rightarrow \infinity` is a
284
      `K`-module.
285
      
286
    The set of generators is the set of generators of the underlying
287
    monoidal power series module and does not take into account the
288
    group action
289
    """
290
        
291
    def __init__(self, O, C, R) :
292
        r"""
293
        INPUT:
294
            - `O` -- A monoid with an action of a group; As implemented in
295
                     :class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
296
            - `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
297
            - `R` -- A representation on a module; As implemented
298
                     in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
299

300
        EXAMPLES::
301
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
302
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
303
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2))) # indirect doctest
304
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 2))) # indirect doctest
305
            sage: emps.base_ring()
306
            Ring of equivariant monoid power series over NN
307
            sage: (1 / 2) * emps.0
308
            Equivariant monoid power series in Module of equivariant monoid power series over NN
309
        """
310
        
311
        # If the representation O respects the monoid structure of S
312
        # the base ring should be the associated power series ring.
313
        if O.is_monoid_action() :
314
            Module.__init__(self, EquivariantMonoidPowerSeriesRing(O,C,TrivialRepresentation(R.group(), R.base_ring())))
315
        else :
316
            Module.__init__(self, R.codomain())
317
        EquivariantMonoidPowerSeriesAmbient_abstract.__init__(self, O, C, R)        
318
        
319
        self.__coeff_gens = \
320
          [self._element_class( self,
321
            dict([( C.one_element(), dict([(self.monoid().zero_element(), a)]) )]),
322
            self.monoid().filter_all() )
323
           for a in self.coefficient_domain().gens()]
324
          
325
    def ngens(self) :
326
        r"""
327
        TESTS::
328
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
329
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
330
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
331
            sage: emps.ngens()
332
            2
333
        """
334
        return len(self.__coeff_gens)
335
    
336
    def gen(self, i = 0) :
337
        r"""
338
        TESTS::
339
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
340
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
341
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
342
            sage: emps.gen()
343
            Equivariant monoid power series in Module of equivariant monoid power series over NN
344
        """
345
        return self.gens()[i]
346
    
347
    def gens(self) :
348
        r"""
349
        TESTS::
350
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
351
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
352
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
353
            sage: emps.gens()
354
            [Equivariant monoid power series in Module of equivariant monoid power series over NN, Equivariant monoid power series in Module of equivariant monoid power series over NN]
355
        """
356
        return self.__coeff_gens
357
    
358
    def construction(self) :
359
        r"""
360
        TESTS::
361
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
362
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
363
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
364
            sage: (f, a) = emps.construction()
365
            sage: (f, a)
366
            (EquivariantMonoidPowerSeriesModuleFunctor, Rational Field)
367
            sage: f(a) == emps
368
            True
369
        """
370
        from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesModuleFunctor
371

372
        return EquivariantMonoidPowerSeriesModuleFunctor(self.action(), self.characters(), self.representation()), \
373
               self.coefficient_domain().base_ring()
374
    
375
    def zero_element(self) :
376
        r"""
377
        TESTS::
378
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
379
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
380
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
381
            sage: h = emps.zero_element()
382
        """
383
        return self(0)
384
    
385
    def _element_constructor_(self, x) :
386
        r"""
387
        TESTS::
388
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
389
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
390
            sage: emps = EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
391
            sage: h = emps(0) # indirect doctest
392
            sage: h = emps(int(0)) # indirect doctest
393
        """
394
        if isinstance(x, int) and x == 0 :
395
            return self._element_class( self,
396
                dict( [(self.characters().one_element(), dict())] ),
397
                self.action().filter_all() )
398
        elif isinstance(x, Element) and x.is_zero() :
399
            P = x.parent()
400
            
401
            if self.action().is_monoid_action() and \
402
               self.base_ring().base_ring().has_coerce_map_from(P) or \
403
               not self.action().is_monoid_action() and \
404
               self.base_ring().has_coerce_map_from(P) :
405
                return self._element_class( self,
406
                    dict( [(self.characters().one_element(), dict())] ),
407
                    self.action().filter_all() )
408
    
409
        return EquivariantMonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
410

411
    def _repr_(self) :
412
        r"""
413
        TESTS::
414
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
415
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
416
            sage: EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2)))
417
            Module of equivariant monoid power series over NN
418
        """
419
        return "Module of equivariant monoid power series over " + self.monoid()._repr_()
420

421
    def _latex_(self) :
422
        r"""
423
        TESTS::
424
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
425
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_module import EquivariantMonoidPowerSeriesModule_generic
426
            sage: latex( EquivariantMonoidPowerSeriesModule_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", FreeModule(QQ, 2))) )
427
            \text{Module of equivariant monoid power series over }\Bold{N}
428
        """
429
        return r"\text{Module of equivariant monoid power series over }" + self.monoid()._latex_()
430

431
Product

Resources

Company
