CoCalc -- monoidpowerseries

Harvard Workshop: Distribution of modular symbols and L-values
code / alex / psage / psage / modform / fourier_expansion_framework / monoidpowerseries / monoidpowerseries_ring.py
²⁴¹⁸⁵² views
1
r"""
2
Rings of monoid power series and rings 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 psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ambient import MonoidPowerSeriesAmbient_abstract, \
28
                                      EquivariantMonoidPowerSeriesAmbient_abstract
29
from sage.algebras.algebra import Algebra
30
from sage.rings.all import Integer
31
from sage.structure.element import Element
32
from sage.structure.parent import Parent
33

34
#===============================================================================
35
# MonoidPowerSeriesRing
36
#===============================================================================
37

38
_monoidpowerseries_ring_cache = dict()
39

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

49
    OUTPUT:
50
        An instance of :class:~`.MonoidPowerSeriesRing_generic`.
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_ring import MonoidPowerSeriesRing
55
        sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
56
        sage: mps is MonoidPowerSeriesRing(QQ, NNMonoid(False))
57
        True
58
    """
59
    global _monoidpowerseries_ring_cache
60
    key = (A, S)
61
    
62
    try :
63
        return _monoidpowerseries_ring_cache[key]
64
    except KeyError :
65
        P = MonoidPowerSeriesRing_generic(A, S)
66
        _monoidpowerseries_ring_cache[key] = P
67
        
68
        return P
69
    
70
#===============================================================================
71
# MonoidPowerSeriesRing_generic
72
#===============================================================================
73

74
class MonoidPowerSeriesRing_generic ( MonoidPowerSeriesAmbient_abstract, Algebra ) :
75
    r"""
76
    Given some `K` algebra `A` and a monoid `S` filtered over
77
    a net `\Lambda` construct a ring 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` algebra is implemented by this class.
82
    """
83
    
84
    def __init__(self, A, S) :
85
        r"""
86
        INPUT:
87
            - `A` -- A ring.
88
            - `S` -- A monoid as implemented in :class:~`fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids.NNMonoid`.
89

90
        TESTS::
91
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
92
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
93
            sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
94
            sage: mps = MonoidPowerSeriesRing_generic(ZZ, NNMonoid(False))
95
            sage: mps.base_ring()
96
            Integer Ring
97
            sage: (1 / 2) * mps.0
98
            Monoid power series in Ring of monoid power series over NN
99
        """
100
        Algebra.__init__(self, A)        
101
        MonoidPowerSeriesAmbient_abstract.__init__(self, A, S)
102

103
        self.__monoid_gens = \
104
          [ self._element_class(self, dict([(s, A.one_element())]),
105
                                    self.monoid().filter_all() )
106
            for s in S.gens() ]
107
    
108
        from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesBaseRingInjection
109

110
        self._populate_coercion_lists_(
111
          coerce_list = [MonoidPowerSeriesBaseRingInjection(self.base_ring(), self)] + \
112
                        ([S] if isinstance(S, Parent) else []) )
113
    
114
    def ngens(self) :
115
        r"""
116
        TESTS::
117
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
118
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
119
            sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
120
            sage: mps.ngens()
121
            1
122
        """
123
        return len(self.__monoid_gens)
124

125
    def gen(self, i = 0) :
126
        r"""
127
        TESTS::
128
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
129
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
130
            sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
131
            sage: mps.gen().coefficients()
132
            {1: 1}
133
        """
134
        return self.gens()[i]
135
    
136
    def gens(self) :
137
        r"""
138
        TESTS::
139
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
140
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
141
            sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
142
            sage: mps.gens()
143
            [Monoid power series in Ring of monoid power series over NN]
144
        """
145
        return self.__monoid_gens
146
    
147
    def construction(self) :
148
        r"""
149
        TESTS::
150
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
151
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
152
            sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
153
            sage: (f, a) = mps.construction()
154
            sage: (f, a)
155
            (MonoidPowerSeriesRingFunctor, Rational Field)
156
            sage: f(a) == mps
157
            True
158
        """
159
        from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesRingFunctor
160

161
        return MonoidPowerSeriesRingFunctor(self.monoid()), self.coefficient_domain()
162
    
163
    def _element_constructor_(self, x) :
164
        r"""
165
        TESTS::
166
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
167
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
168
            sage: mps = MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
169
            sage: h = mps(1) # indirect doctest
170
            sage: h = mps(mps.monoid().zero_element())
171
            sage: h = mps.zero_element()
172
            sage: K.<rho> = CyclotomicField(6)
173
            sage: mps = MonoidPowerSeriesRing_generic(K, NNMonoid(False))
174
            sage: h = mps(rho)
175
            sage: h = mps(1)
176
        """
177
        if isinstance(x, int) :
178
            x = Integer(x)
179
            
180
        if isinstance(x, Element) :
181
            P = x.parent()
182

183
            if P is self.coefficient_domain() :
184
                return self._element_class( self, {self.monoid().zero_element(): x},
185
                                                self.monoid().filter_all() )
186
            elif self.coefficient_domain().has_coerce_map_from(P) :
187
                return self._element_class( self, {self.monoid().zero_element(): self.coefficient_domain()(x)},
188
                                                self.monoid().filter_all() )
189
            elif P is self.monoid() :
190
                return self._element_class( self, {x: self.base_ring().one_element},
191
                                                self.monoid().filter_all() )
192
                
193
        return MonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
194
    
195
    def _repr_(self) :
196
        r"""
197
        TESTS::
198
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
199
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
200
            sage: MonoidPowerSeriesRing_generic(QQ, NNMonoid(False))
201
            Ring of monoid power series over NN
202
        """
203
        return "Ring of monoid power series over " + self.monoid()._repr_()
204

205
    def _latex_(self) :
206
        r"""
207
        TESTS::
208
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
209
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import MonoidPowerSeriesRing_generic
210
            sage: latex(MonoidPowerSeriesRing_generic(QQ, NNMonoid(False)))
211
            \text{Ring of monoid power series over }\Bold{N}
212
        """
213
        return r"\text{Ring of monoid power series over }" + self.monoid()._latex_()
214
    
215
###############################################################################
216
###############################################################################
217
###############################################################################
218

219
#===============================================================================
220
# EquivariantMonoidPowerSeriesRing
221
#===============================================================================
222

223
_equivariantmonoidpowerseries_ring_cache = dict()
224

225
def EquivariantMonoidPowerSeriesRing(O, C, R) :
226
    r"""
227
    Return the globally unique ring of equivariant monoid power
228
    over the monoid with action `O` with coefficients in the codomain `R`
229
    with a representation and a set of virtual characters `C`.
230
    
231
    INPUT:
232
        - `O` -- A monoid with an action of a group; As implemented in
233
                 :class:~`fourier_expansion_framework.monoidpowerseries.NNMonoid`.
234
        - `C` -- A monoid of characters; As implemented in ::class:~`fourier_expansion_framework.monoidpowerseries.CharacterMonoid_class`.
235
        - `R` -- A representation on an algebra; As implemented
236
                 in :class:~`fourier_expansion_framework.monoidpowerseries.TrivialRepresentation`.
237
        
238
    EXAMPLES::
239
        sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
240
        sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing
241
        sage: emps = EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
242
        sage: emps is EquivariantMonoidPowerSeriesRing(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
243
        True
244
    """
245

246
    ## TODO: Implement optional checking of the relations of the characters
247
    if O.group() != C.group() :
248
        raise ValueError, "The action on S and the characters must have the same group"
249
    if R.base_ring() != C.codomain() :
250
        if C.codomain().has_coerce_map_from(R.base_ring()) :
251
            K = C.codomain()
252
            R = R.base_extend(K)
253
        elif R.base_ring().has_coerce_map_from(C.codomain()) :
254
            K = R.base_ring()
255
        else :
256
            from sage.categories.pushout import pushout
257
            
258
            try :
259
                K = pushout(C.codomain(), R.base_ring())
260
                R = R.base_extend(K)
261
            except :
262
                raise ValueError, "character codomain and representation base ring have no common extension"
263
    
264
    global _equivariantmonoidpowerseries_ring_cache
265
    key = (O, C, R)
266
    
267
    try :
268
        return _equivariantmonoidpowerseries_ring_cache[key]
269
    except KeyError :
270
        P = EquivariantMonoidPowerSeriesRing_generic(O, C, R)
271
        _equivariantmonoidpowerseries_ring_cache[key] = P
272
        
273
        return P
274

275
#===============================================================================
276
# EquivariantMonoidPowerSeriesRing_generic
277
#===============================================================================
278

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

307
        EXAMPLES::
308
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
309
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
310
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ)) # indirect doctest
311
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", ZZ), TrivialRepresentation("1", ZZ)) # indirect doctest
312
            sage: emps.base_ring()
313
            Integer Ring
314
            sage: (1 / 2) * emps.0
315
            Equivariant monoid power series in Ring of equivariant monoid power series over NN
316
        """
317
        
318
        Algebra.__init__(self, R.base_ring())
319
        EquivariantMonoidPowerSeriesAmbient_abstract.__init__(self, O, C, R)
320
    
321
        self.__monoid_gens = \
322
          [self._element_class(self,
323
            dict([( C.one_element(), dict([(s, self.coefficient_domain().one_element())]) )]),
324
            self.monoid().filter_all() )
325
           for s in self.action().gens()]
326
        self.__character_gens = \
327
          [self._element_class(self,
328
            dict([( c, dict([(self.monoid().zero_element(), self.coefficient_domain().one_element())]) )]),
329
            self.monoid().filter_all() )
330
           for c in C.gens()]
331
        self.__coefficient_gens = \
332
          [self._element_class(self,
333
            dict([( C.one_element(), dict([(self.monoid().zero_element(), g)]))]),
334
            self.monoid().filter_all() )
335
           for g in self.coefficient_domain().gens()]
336
        
337
        from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import MonoidPowerSeriesBaseRingInjection
338

339
        self._populate_coercion_lists_(
340
          coerce_list = [MonoidPowerSeriesBaseRingInjection(R.codomain(), self)] ,
341
          convert_list = ([O.monoid()] if isinstance(O.monoid(), Parent) else []) )
342

343
    def ngens(self) :
344
        r"""
345
        TESTS::
346
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
347
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
348
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
349
            sage: emps.ngens()
350
            3
351
        """
352
        return len(self.__monoid_gens) + len(self.__character_gens) + len(self.__coefficient_gens)
353
    
354
    def gen(self, i = 0) :
355
        r"""
356
        TESTS::
357
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
358
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
359
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
360
            sage: emps.gen()
361
            Equivariant monoid power series in Ring of equivariant monoid power series over NN
362
        """
363
        return self.gens()[i]
364
  
365
    def gens(self) :
366
        r"""
367
        TESTS::
368
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
369
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
370
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
371
            sage: emps.gens()
372
            [Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN, Equivariant monoid power series in Ring of equivariant monoid power series over NN]
373
        """
374
        return self.__monoid_gens + self.__character_gens + self.__coefficient_gens
375

376
    def construction(self) :
377
        r"""
378
        TESTS::
379
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
380
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
381
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
382
            sage: (f, a) = emps.construction()
383
            sage: (f, a)
384
            (EquivariantMonoidPowerSeriesRingFunctor, Rational Field)
385
            sage: f(a) == emps
386
            True
387
        """
388
        from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_functor import EquivariantMonoidPowerSeriesRingFunctor
389

390
        return EquivariantMonoidPowerSeriesRingFunctor(self.action(), self.characters(), self.representation()), \
391
               self.coefficient_domain()
392

393
    def _element_constructor_(self, x) :
394
        r"""
395
        TESTS::
396
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
397
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
398
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
399
            sage: h = emps(1)
400
            sage: h = emps(emps.monoid().zero_element())
401
            sage: h = emps.zero_element()
402
            sage: K.<rho> = CyclotomicField(6)
403
            sage: emps = EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", K))
404
            sage: h = emps(rho)
405
            sage: h = emps(1)
406
        """
407
        if isinstance(x, int) :
408
            x = Integer(x)
409
        
410
        if isinstance(x, Element) :
411
            P = x.parent()
412

413
            if P is self.coefficient_domain() :
414
                return self._element_class( self,
415
                        {self.characters().one_element():
416
                                {self.monoid().zero_element(): x}},
417
                        self.action().filter_all() )
418
            elif self.coefficient_domain().has_coerce_map_from(P) :
419
                return self._element_class( self,
420
                        {self.characters().one_element():
421
                                {self.monoid().zero_element(): self.coefficient_domain()(x)}},
422
                        self.action().filter_all() )                
423
            elif P is self.monoid() :
424
                return self._element_class( self,
425
                        {self.characters().one_element():
426
                                {x: self.base_ring().one_element()}},
427
                        self.action().filter_all(),
428
                        symmetrise = True  )
429
            
430
        return EquivariantMonoidPowerSeriesAmbient_abstract._element_constructor_(self, x)
431

432
    def _cmp_(self, other) :
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 MonoidPowerSeriesRing
437
            sage: mps = MonoidPowerSeriesRing(QQ, NNMonoid(False))
438
            sage: mps2 = MonoidPowerSeriesRing(ZZ, NNMonoid(False))
439
            sage: mps == MonoidPowerSeriesRing(QQ, NNMonoid(False))
440
            True
441
            sage: mps == mps2
442
            False
443
        """
444
        c = cmp(type(self), type(other))
445
        
446
        if c == 0 :
447
            c = cmp(self.base_ring(), other.base_ring())
448
        if c == 0 :
449
            c = cmp(self.monoid(), other.monoid())
450
            
451
        return c
452

453
    def _repr_(self) :
454
        r"""
455
        TESTS::
456
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
457
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
458
            sage: EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ))
459
            Ring of equivariant monoid power series over NN
460
        """
461
        return "Ring of equivariant monoid power series over " + self.monoid()._repr_()
462

463
    def _latex_(self) :
464
        r"""
465
        TESTS::
466
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_basicmonoids import *
467
            sage: from psage.modform.fourier_expansion_framework.monoidpowerseries.monoidpowerseries_ring import EquivariantMonoidPowerSeriesRing_generic
468
            sage: latex(EquivariantMonoidPowerSeriesRing_generic(NNMonoid(True), TrivialCharacterMonoid("1", QQ), TrivialRepresentation("1", QQ)))
469
            \text{Ring of equivariant monoid power series over }\Bold{N}
470
        """
471
        return r"\text{Ring of equivariant monoid power series over }" + self.monoid()._latex_()
472

473
Product

Resources

Company
