CoCalc -- monoidpowerseries

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

4
AUTHOR :
5
    -- Martin Raum (2009 - 07 - 25) 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 sage.categories.commutative_additive_groups import CommutativeAdditiveGroups
28
from sage.categories.rings import Rings
29
from sage.categories.modules import Modules
30
from sage.categories.morphism import Morphism
31
from sage.categories.pushout import pushout, ConstructionFunctor
32
from sage.rings.ring import Ring
33
from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing
34

35
#===============================================================================
36
# MonoidPowerSeriesRingFunctor
37
#===============================================================================
38

39
class MonoidPowerSeriesRingFunctor ( ConstructionFunctor ) :
40
    r"""
41
    Functor mapping a coefficient ring to a monoid power series ring
42
    over a given monoid.
43
    """
44
    
45
    rank = 9
46
    
47
    def __init__(self, S) :
48
        r"""
49
        INPUT:
50
            - `S` -- A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`
51
        
52
        TESTS::
53
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor
54
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
55
            sage: F = MonoidPowerSeriesRingFunctor(NNMonoid(False))
56
        """
57
        self.__S = S
58
        
59
        ConstructionFunctor.__init__(self, Rings(), Rings())
60
        
61
    def monoid(self) :
62
        r"""
63
        Return the monoid associated to this functor.
64
        
65
        OUTPUT:
66
            A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
67
        
68
        TESTS::
69
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor
70
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
71
            sage: F = MonoidPowerSeriesRingFunctor(NNMonoid(False))
72
            sage: F.monoid()
73
            NN
74
        """
75
        return self.__S
76

77
    def __call__(self, A) :
78
        r"""
79
        Apply a ``self`` to a coefficient domain `A`.
80
        
81
        INPUT:
82
            - `A` -- A ring or module. The domain of coefficients for
83
                     a ring or module of monoid power series.
84
        
85
        OUTPUT:
86
            An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
87
            A ring if `A` is a ring, a module if `A` is a module.
88
        
89
        TESTS::
90
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor
91
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
92
            sage: F = MonoidPowerSeriesRingFunctor(NNMonoid(False))
93
            sage: mps = F(ZZ)
94
            sage: mps.monoid() == NNMonoid(False)
95
            True
96
            sage: mps.coefficient_domain()
97
            Integer Ring
98
        """
99
        from monoidpowerseries_ring import MonoidPowerSeriesRing
100

101
        return MonoidPowerSeriesRing(A, self.__S)
102
        
103
    def __cmp__(self, other) :
104
        r"""
105
        TESTS::
106
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor
107
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
108
            sage: F = MonoidPowerSeriesRingFunctor(NNMonoid(False))
109
            sage: F == MonoidPowerSeriesRingFunctor(NNMonoid(False))
110
            True
111
        """
112
        c = cmp(type(self), type(other))
113
    
114
        if c == 0 :
115
            c = cmp(self.__S, other.__S)
116
            
117
        return c
118

119
#===============================================================================
120
# MonoidPowerSeriesModuleFunctor
121
#===============================================================================
122

123
class MonoidPowerSeriesModuleFunctor ( ConstructionFunctor ) :
124
    r"""
125
    Functor mapping a coefficient module to a monoid power series module
126
    over a given monoid.
127
    """
128
    
129
    rank = 9
130
    
131
    def __init__(self, B, S) :
132
        r"""
133
        INPUT:
134
            - `B` -- A ring.
135
            - `S` -- A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`
136
        
137
        TESTS::
138
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesModuleFunctor
139
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
140
            sage: F = MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False))
141
        """
142
        self.__S = S
143
        
144
        ConstructionFunctor.__init__(self, Modules(B), CommutativeAdditiveGroups())
145
        
146
    def monoid(self) :
147
        r"""
148
        Return the monoid associated to this functor.
149
        
150
        OUTPUT:
151
            A monoid as in :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
152
        
153
        TESTS::
154
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesModuleFunctor
155
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
156
            sage: F = MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False))
157
            sage: F.monoid()
158
            NN
159
        """
160
        return self.__S
161

162
    def __call__(self, A) :
163
        r"""
164
        Apply a ``self`` to a coefficient domain `A`.
165
        
166
        INPUT:
167
            - `A` -- A ring or module. The domain of coefficients for
168
                     a ring or module of monoid power series.
169
        
170
        OUTPUT:
171
            An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
172
            A ring if `A` is a ring, a module if `A` is a module.
173
        
174
        TESTS::
175
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesModuleFunctor
176
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
177
            sage: F = MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False))
178
            sage: mps = F(FreeModule(ZZ, 1))
179
            sage: mps.monoid() == NNMonoid(False)
180
            True
181
            sage: mps.coefficient_domain()
182
            Ambient free module of rank 1 over the principal ideal domain Integer Ring
183
            sage: F(FreeModule(QQ, 3)).coefficient_domain()
184
            Vector space of dimension 3 over Rational Field
185
        """
186
        from monoidpowerseries_module import MonoidPowerSeriesModule
187
            
188
        return MonoidPowerSeriesModule(A, self.__S)
189
        
190
    def __cmp__(self, other) :
191
        r"""
192
        TESTS::
193
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesModuleFunctor
194
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
195
            sage: F = MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False))
196
            sage: F == MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False))
197
            True
198
            sage: F == MonoidPowerSeriesModuleFunctor(QQ, NNMonoid(False))
199
            False
200
        """
201
        c = cmp(type(self), type(other))
202
        
203
        if c == 0 :
204
            c = cmp(self.domain().base_ring(), other.domain().base_ring())
205
        if c == 0 :
206
            c = cmp(self.__S, other.__S)
207
            
208
        return c
209
    
210
#===============================================================================
211
# EquivariantMonoidPowerSeriesRingFunctor
212
#===============================================================================
213

214
class EquivariantMonoidPowerSeriesRingFunctor ( ConstructionFunctor ) :
215
    r"""
216
    Functor mapping a coefficient domain to a equivariant monoid power series
217
    ring or module over a given monoid action with character and representation.
218
    The representation will be extended by scalars if the coefficient domain's
219
    base ring is to big.
220
    """
221
    
222
    rank = 9
223
    
224
    def __init__(self, O, C, R) :
225
        r"""
226
        INPUT:
227
            - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`.
228
            - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`.
229
            - `R` -- A representation of `G` on some `K`-algebra or module `A`.
230
                     As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`.
231
        
232
        TESTS::
233
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor
234
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
235
            sage: F = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
236
        """
237
        if O.group() != C.group() :
238
            raise ValueError( "The action on S and the characters must have the same group" )
239
        if R.base_ring() != C.codomain() :
240
#            if C.codomain().has_coerce_map_from(R.base_ring()) :
241
#                pass
242
#            el
243
            if R.base_ring().has_coerce_map_from(C.codomain()) :
244
                pass
245
            else :
246
                raise ValueError( "character codomain and representation base ring must be coercible" )
247
        if not O.is_monoid_action() :
248
            raise ValueError( "monoid structure must be compatible with group action" )
249
        
250
        self.__O = O
251
        self.__C = C
252
        self.__R = R
253
        
254
        ConstructionFunctor.__init__(self, Rings(), Rings())
255

256
    def __call__(self, K) :
257
        r"""
258
        Apply a ``self`` to a coefficient domain `A`.
259
        
260
        INPUT:
261
            - `A` -- A ring or module. The domain of coefficients for
262
                     a ring or module of equivariant monoid power series.
263
        
264
        OUTPUT:
265
            An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.EquivariantMonoidPowerSeriesAmbient_abstract`.
266
            A ring if the representation's extension by `A` is a ring, a module if this extension is a module.
267
            
268
        TESTS::
269
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor
270
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
271
            sage: F = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
272
            sage: emps = F(QQ)
273
            sage: emps.action() == NNMonoid()
274
            True
275
            sage: emps.characters()
276
            Character monoid over Trivial monoid
277
            """
278
        if not self.__R.base_ring().has_coerce_map_from(K) : 
279
            R = self.__R.base_extend( pushout(self.__R.base_ring(), K) )
280
        else :
281
            R = self.__R
282
        
283
        from monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
284

285
        return EquivariantMonoidPowerSeriesRing( self.__O, self.__C, R )
286

287
    def __cmp__(self, other) :
288
        r"""
289
        TESTS::
290
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor
291
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
292
            sage: F = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
293
            sage: F == EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
294
            True
295
            sage: F == EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 3)))
296
            False
297
        """
298
        c = cmp(type(self), type(other))
299
        if c == 0 :
300
            c = cmp(self.__R, other.__R)
301
        if c == 0 :
302
            c = cmp(self.__O, other.__O)
303
        if c == 0 :
304
            c = cmp(self.__C, other.__C)
305
        
306
        return c
307
    
308
    def expand(self) :
309
        r"""
310
        An equivariant monoid power series can be constructed by first
311
        constructing a monoid power series and then symmetrising it with
312
        respect to the group action.
313
        
314
        OUTPUT:
315
            A list of functors.
316
        
317
        TESTS::
318
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor
319
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
320
            sage: F = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
321
            sage: F.expand()
322
            [MonoidPowerSeriesSymmetrisationRingFunctor, MonoidPowerSeriesRingFunctor]
323
        """
324
        return [ MonoidPowerSeriesSymmetrisationRingFunctor(self.__O, self.__C, self.__R),
325
                 MonoidPowerSeriesRingFunctor(self.__O.monoid()) ]
326
        
327
    def merge(self, other) :
328
        r"""
329
        TESTS::
330
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor
331
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
332
            sage: F = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
333
            sage: G = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
334
            sage: F.merge(G) == G
335
            True
336
            sage: G = EquivariantMonoidPowerSeriesRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 3)))
337
            sage: F.merge(G) is None
338
            True
339
        """
340
        if self == other :
341
            return self
342
        elif type(self) == type(other) and \
343
           self.__O == self.__O and \
344
           self.__C == self.__C :
345
            try :
346
                if self.__R.extends(other.__R) :
347
                    return self
348
                elif other.__R.extends(self.__R) :
349
                    return other
350
            except AttributeError :
351
                return None
352
        
353
        return None
354

355
#===============================================================================
356
# EquivariantMonoidPowerSeriesFunctor
357
#===============================================================================
358

359
class EquivariantMonoidPowerSeriesModuleFunctor ( ConstructionFunctor ) :
360
    r"""
361
    Functor mapping a coefficient domain to a equivariant monoid power series
362
    ring or module over a given monoid action with character and representation.
363
    The representation will be extended by scalars if the coefficient domain's
364
    base ring is to big.
365
    """
366
    
367
    rank = 9
368
    
369
    def __init__(self, O, C, R) :
370
        r"""
371
        INPUT:
372
            - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`.
373
            - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`.
374
            - `R` -- A representation of `G` on some `K`-algebra or module `A`.
375
                     As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`.
376
        
377
        TESTS::
378
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesModuleFunctor
379
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
380
            sage: F = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
381
        """
382
        if O.group() != C.group() :
383
            raise ValueError( "The action on S and the characters must have the same group" )
384
        if R.base_ring() != C.codomain() :
385
#            if C.codomain().has_coerce_map_from(R.base_ring()) :
386
#                pass
387
#            el
388
            if R.base_ring().has_coerce_map_from(C.codomain()) :
389
                pass
390
            else :
391
                raise ValueError( "character codomain and representation base ring must be coercible" )
392
        
393
        self.__O = O
394
        self.__C = C
395
        self.__R = R
396
        
397
        ConstructionFunctor.__init__(self, Modules(R.base_ring()), CommutativeAdditiveGroups())
398

399
    def __call__(self, K) :
400
        r"""
401
        Apply a ``self`` to a coefficient domain `A`.
402
        
403
        INPUT:
404
            - `A` -- A ring or module. The domain of coefficients for
405
                     a ring or module of equivariant monoid power series.
406
        
407
        OUTPUT:
408
            An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.EquivariantMonoidPowerSeriesAmbient_abstract`.
409
            A ring if the representation's extension by `A` is a ring, a module if this extension is a module.
410
            
411
        TESTS::
412
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesModuleFunctor
413
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
414
            sage: F = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
415
            sage: emps = F(QQ)
416
            sage: emps.action() == NNMonoid()
417
            True
418
            sage: emps.characters()
419
            Character monoid over Trivial monoid
420
            sage: F = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 3)))
421
            sage: emps = F(QQ)
422
            sage: emps.coefficient_domain()
423
            Vector space of dimension 3 over Rational Field
424
            """
425
        if not self.__R.base_ring().has_coerce_map_from(K) : 
426
            R = self.__R.base_extend( pushout(self.__R.base_ring(), K) )
427
        else :
428
            R = self.__R
429
        
430
        from monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
431

432
        return EquivariantMonoidPowerSeriesModule( self.__O, self.__C, R )
433

434
    def __cmp__(self, other) :
435
        r"""
436
        TESTS::
437
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesModuleFunctor
438
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
439
            sage: F = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
440
            sage: F == EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
441
            True
442
            sage: F == EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 3)))
443
            False
444
        """
445
        c = cmp(type(self), type(other))
446
        if c == 0 :
447
            c = cmp(self.__R, other.__R)
448
        if c == 0 :
449
            c = cmp(self.__O, other.__O)
450
        if c == 0 :
451
            c = cmp(self.__C, other.__C)
452
        
453
        return c
454
    
455
    def expand(self) :
456
        r"""
457
        An equivariant monoid power series can be constructed by first
458
        constructing a monoid power series and then symmetrising it with
459
        respect to the group action.
460
        
461
        OUTPUT:
462
            A list of functors.
463
        
464
        TESTS::
465
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesModuleFunctor
466
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
467
            sage: F = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
468
            sage: F.expand()
469
            [MonoidPowerSeriesSymmetrisationModuleFunctor, MonoidPowerSeriesModuleFunctor]
470
        """
471
        return [ MonoidPowerSeriesSymmetrisationModuleFunctor(self.__O, self.__C, self.__R),
472
                 MonoidPowerSeriesModuleFunctor(self.domain().base_ring(), self.__O.monoid()) ]
473
        
474
    def merge(self, other) :
475
        r"""
476
        TESTS::
477
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesModuleFunctor
478
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
479
            sage: F = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
480
            sage: G = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 1)))
481
            sage: F.merge(G) == G
482
            True
483
            sage: G = EquivariantMonoidPowerSeriesModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 3)))
484
            sage: F.merge(G) is None
485
            True
486
        """
487
        if self == other :
488
            return self
489
        elif type(self) == type(other) and \
490
           self.__O == self.__O and \
491
           self.__C == self.__C :
492
            try :
493
                if self.__R.extends(other.__R) :
494
                    return self
495
                elif other.__R.extends(self.__R) :
496
                    return other
497
            except AttributeError :
498
                return None
499
        
500
        return None
501

502
#===============================================================================
503
# MonoidPowerSeriesSymmetrisationRingFunctor
504
#===============================================================================
505

506
class MonoidPowerSeriesSymmetrisationRingFunctor ( ConstructionFunctor) :
507
    r"""
508
    A functor mapping rings or modules of monoid power series
509
    to a the an equivariant power series via symmetrisation.
510
    """
511
    
512
    rank = 9
513
    
514
    def __init__(self, O, C, R) :
515
        r"""
516
        INPUT:
517
            - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`.
518
            - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`.
519
            - `R` -- A representation of `G` on some `K`-algebra or module `A`.
520
                     As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`.
521
        
522
        TESTS::
523
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationRingFunctor
524
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
525
            sage: F = MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
526
        """
527
        if O.group() != C.group() :
528
            raise ValueError( "The action on S and the characters must have the same group" )
529
        if R.base_ring() != C.codomain() :
530
#            if C.codomain().has_coerce_map_from(R.base_ring()) :
531
#                pass
532
#            el
533
            if R.base_ring().has_coerce_map_from(C.codomain()) :
534
                pass
535
            else :
536
                raise ValueError( "character codomain and representation base ring must be coercible" )
537
        if not O.is_monoid_action() :
538
            raise ValueError( "monoid structure must be compatible with group action" )
539
        
540
        self.__O = O
541
        self.__C = C
542
        self.__R = R
543
        
544
        ConstructionFunctor.__init__(self, Rings(), Rings())
545
        
546
    def __call__(self, P) :
547
        r"""
548
        Map a monoid power series to a symmetrisation extending the associated representation.
549

550
        INPUT:
551
            - `P` -- An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
552
        
553
        TESTS::
554
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationRingFunctor, MonoidPowerSeriesRingFunctor
555
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
556
            sage: mps = MonoidPowerSeriesRingFunctor(NNMonoid(False))(QQ)
557
            sage: F = MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
558
            sage: emps = F(mps)
559
            sage: emps.representation() == TrivialRepresentation("1", QQ)
560
            True
561
            sage: mps = MonoidPowerSeriesRingFunctor(NNMonoid(False))(ZZ)
562
            sage: F = MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
563
            sage: emps = F(mps)
564
            sage: emps.representation() == TrivialRepresentation("1", QQ)
565
            True
566
        """
567
        if self.__O.monoid() != P.monoid() :
568
            raise ValueError( "Action has to be defined on the monoid associated to P." )
569
        
570
        PR = self.__R.from_module(P.coefficient_domain())
571
        
572
        if not self.__R.base_ring().has_coerce_map_from(PR.base_ring()) : 
573
            R = self.__R.base_extend( pushout(self.__R.base_ring(), PR.base_ring()) )
574
        else :
575
            R = self.__R
576
        
577
        from monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
578

579
        return EquivariantMonoidPowerSeriesRing( self.__O, self.__C, R )
580
        
581
    def __cmp__(self, other) :
582
        r"""
583
        TESTS::
584
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationRingFunctor
585
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
586
            sage: F = MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
587
            sage: F == MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
588
            True
589
            sage: F == MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
590
            False
591
        """
592
        c = cmp(type(self), type(other))
593
        if c == 0 :
594
            c = cmp(self.__R, other.__R)
595
        if c == 0 :
596
            c = cmp(self.__O, other.__O)
597
        if c == 0 :
598
            c = cmp(self.__C, other.__C)
599
           
600
        return c
601

602
    def merge(self, other) :
603
        r"""
604
        TESTS::
605
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationRingFunctor
606
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
607
            sage: F = MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ))
608
            sage: G = MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", QQ))
609
            sage: F.merge(G) == G
610
            True
611
            sage: G = MonoidPowerSeriesSymmetrisationRingFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 3)))
612
            sage: F.merge(G) is None
613
            True
614
        """
615
        if self == other :
616
            return self
617
        elif type(self) == type(other) and \
618
           self.__O == self.__O :
619
            try :
620
                if self.__C.extends(other.__C) and self.__R.extends(other.__R) :
621
                    return self
622
                elif other.__C.extends(self.__C) and other.__R.extends(self.__R) :
623
                    return other
624
            except AttributeError :
625
                return None
626
        
627
        return None
628

629
#===============================================================================
630
# MonoidPowerSeriesSymmetrisationModuleFunctor
631
#===============================================================================
632

633
class MonoidPowerSeriesSymmetrisationModuleFunctor ( ConstructionFunctor) :
634
    r"""
635
    A functor mapping rings or modules of monoid power series
636
    to a the an equivariant power series via symmetrisation.
637
    """
638
    
639
    rank = 9
640
    
641
    def __init__(self, O, C, R) :
642
        r"""
643
        INPUT:
644
            - `O` -- An action of a group `G` on a monoid as implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.NNMonoid`.
645
            - `C` -- A monoid of charcters `G -> K` for a ring `K`. As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.CharacterMonoid_class`.
646
            - `R` -- A representation of `G` on some `K`-algebra or module `A`.
647
                     As implemented in :class:`~fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basismonoids.TrivialRepresentation`.
648
        
649
        TESTS::
650
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationModuleFunctor
651
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
652
            sage: F = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
653
        """
654
        if O.group() != C.group() :
655
            raise ValueError, "The action on S and the characters must have the same group"
656
        if R.base_ring() != C.codomain() :
657
            if C.codomain().has_coerce_map_from(R.base_ring()) :
658
                pass
659
            elif R.base_ring().has_coerce_map_from(C.codomain()) :
660
                pass
661
            else :
662
                raise ValueError, "character codomain and representation base ring must be coercible"        
663
        
664
        self.__O = O
665
        self.__C = C
666
        self.__R = R
667
        
668
        ConstructionFunctor.__init__(self, CommutativeAdditiveGroups(), CommutativeAdditiveGroups())
669
        
670
    def __call__(self, P) :
671
        r"""
672
        Map a monoid power series to a symmetrisation extending the associated representation.
673

674
        INPUT:
675
            - `P` -- An instance of :class:`~from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient.MonoidPowerSeriesAmbient_abstract`.
676
        
677
        TESTS::
678
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationModuleFunctor, MonoidPowerSeriesModuleFunctor
679
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
680
            sage: mps = MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False))(FreeModule(QQ, 1))
681
            sage: F = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
682
            sage: emps = F(mps)
683
            sage: emps.representation() == TrivialRepresentation("1", FreeModule(QQ, 1))
684
            True
685
            sage: mps = MonoidPowerSeriesModuleFunctor(ZZ, NNMonoid(False))(FreeModule(ZZ, 1))
686
            sage: F = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 1)))
687
            sage: emps = F(mps)
688
            sage: emps.representation() == TrivialRepresentation("1", FreeModule(QQ, 1))
689
            True
690
        """
691
        if self.__O.monoid() != P.monoid() :
692
            raise ValueError( "Action has to be defined on the monoid associated to P." )
693
        
694
        PR = self.__R.from_module(P.coefficient_domain())
695
        
696
        if not self.__R.base_ring().has_coerce_map_from(PR.base_ring()) : 
697
            R = self.__R.base_extend( pushout(self.__R.base_ring(), PR.base_ring()) )
698
        else :
699
            R = self.__R
700
        
701
        from monoidpowerseries_module import EquivariantMonoidPowerSeriesModule
702

703
        return EquivariantMonoidPowerSeriesModule( self.__O, self.__C, R )
704

705
    def __cmp__(self, other) :
706
        r"""
707
        TESTS::
708
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationModuleFunctor
709
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
710
            sage: F = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
711
            sage: F == MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
712
            True
713
            sage: F == MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 1)))
714
            False
715
        """
716
        c = cmp(type(self), type(other))
717
        if c == 0 :
718
            c = cmp(self.__R, other.__R)
719
        if c == 0 :
720
            c = cmp(self.__O, other.__O)
721
        if c == 0 :
722
            c = cmp(self.__C, other.__C)
723
           
724
        return c
725

726
    def merge(self, other) :
727
        r"""
728
        TESTS::
729
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesSymmetrisationModuleFunctor
730
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid, TrivialRepresentation, TrivialCharacterMonoid
731
            sage: F = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(ZZ, 1)))
732
            sage: G = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 1)))
733
            sage: F.merge(G) == G
734
            True
735
            sage: G = MonoidPowerSeriesSymmetrisationModuleFunctor(NNMonoid(), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", FreeModule(QQ, 3)))
736
            sage: F.merge(G) is None
737
            True
738
        """
739
        if self == other :
740
            return self
741
        elif type(self) == type(other) and \
742
           self.__O == self.__O :
743
            try :
744
                if self.__C.extends(other.__C) and self.__R.extends(other.__R) :
745
                    return self
746
                elif other.__C.extends(self.__C) and other.__R.extends(self.__R) :
747
                    return other
748
            except AttributeError :
749
                return None
750
        
751
        return None
752
        
753
#===============================================================================
754
# MonoidPowerSeriesBaseRingInjection
755
#===============================================================================
756

757
class MonoidPowerSeriesBaseRingInjection ( Morphism ) :
758
    r"""
759
    The injection of the base ring into a (equivariant) monoid power
760
    series ring.
761
    """
762
    
763
    def __init__(self, domain, codomain) :
764
        r"""
765
        INPUT:
766
            - ``domain``   -- A ring; The base ring.
767
            - ``codomain`` -- A ring; The ring of monoid power series.
768
        
769
        TESTS::
770
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor, MonoidPowerSeriesModuleFunctor, MonoidPowerSeriesBaseRingInjection
771
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
772
            sage: mps = MonoidPowerSeriesRingFunctor(NNMonoid(False))(ZZ)
773
            sage: binj = MonoidPowerSeriesBaseRingInjection(ZZ, mps)
774
            sage: mps = MonoidPowerSeriesModuleFunctor(ZZ,NNMonoid(False))(FreeModule(ZZ, 1))
775
            sage: binj = MonoidPowerSeriesBaseRingInjection(ZZ, mps)
776

777
        """
778
        Morphism.__init__(self, domain, codomain)
779
        
780
        self._repr_type_str = "MonoidPowerSeries base injection"
781

782
    def _call_(self, x) :
783
        r"""
784
        Coerce an element into the ring of monoid power series.
785
        
786
        INPUT:
787
            - `x` -- An element of a ring; An element of the base ring.
788
        
789
        OUTPUT:
790
            An element of a ring. 
791
            
792
        TESTS::
793
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor, MonoidPowerSeriesBaseRingInjection
794
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
795
            sage: mps = MonoidPowerSeriesRingFunctor(NNMonoid(False))(ZZ)
796
            sage: binj = MonoidPowerSeriesBaseRingInjection(ZZ, mps)
797
            sage: binj(1)
798
            Monoid power series in Ring of monoid power series over NN
799
        """
800
        return self.codomain()._element_constructor_(x)
801
            
802
    def _call_with_args(self, x, *args, **kwds):
803
        r"""
804
        TESTS::
805
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor, MonoidPowerSeriesBaseRingInjection
806
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import NNMonoid
807
            sage: mps = MonoidPowerSeriesRingFunctor(NNMonoid(False))(ZZ)
808
            sage: binj = MonoidPowerSeriesBaseRingInjection(ZZ, mps)
809
            sage: binj._call_with_args(1)
810
            Monoid power series in Ring of monoid power series over NN
811
        """
812
        return self.codomain()._element_constructor_(x, *args, **kwds)
813

814
Product

Resources

Company
