Opened 5 years ago

Last modified 5 years ago

#18230 new enhancement

Basic hierarchy of categories for representations of monoids, lie algebras, ...

Reported by: nthiery Owned by:
Priority: major Milestone: sage-6.7
Component: algebra Keywords:
Cc: tscrim Merged in:
Authors: Reviewers:
Report Upstream: N/A Work issues:
Branch: Commit:
Dependencies: Stopgaps:

Description (last modified by nthiery)

Draft in finite-semigroup-nt.patch in the Sage-Combinat queue.

Some notes:

class Semigroups.TransformationModules: # or .SetsWithAction
    """modules where the action is by discrete transformations"""

    class ParentMethods:
        def actor(): ?
        def semigroup(): ...
        # Design goal: be left/right agnostic whenever possible
        def action(self, x, s) or def action(self, s, x)

class Semigroups.Finite:
    class ParentMethods:
        G.simple_modules(QQ): shorthand for G.algebras(QQ).simple_modules(QQ)?

class Algebras.Modules:

    class ParentMethods:
         @abstract_method
         def simple_modules() -> return a family indexed by below:
         def simple_modules_index_set()

         def projective_indecomposable_modules()
         def cartan_matrix(self):
             pass

         def character(self):

         def brauer_character(self): # modular case; do we want to identify them?

         def character_value(self, s):
             return

         def class_function(self):
             return self.character_value

         # class_functions ? class_function_module? class_function_ring?
         # cyclic_homology?
         # trace_space Cyclic homology, second edition by Loday
         def character_ring(self):

     class FiniteDimensional:

         class ParentMethods:

             def representation():
                 Return the morphism S -> Hom(self, self)

             @abstract_method # in the finite dimensional case
             def representation_matrix(self, s):

             @abstract_method
             def isotypic_components():
                 """
                 Return the isotypic components of ``self``.

                 OUTPUT: a collection of submodules the internal direct
                 sum of which is ``self``.
                 """
             #
         induction / restriction

          M.induce(LargerAlgebra)  /  M.induced_module(LargerAlgebra)

          G.simple_modules(QQ): shorthand for G.algebras(QQ).simple_modules(QQ)

Question: how to handle the case where the base ring of the module does not match the base ring of the acting object? Example: complex representations of real lie algebras

  LieAlgebras(QQ).Modules(CC)
  LieAlgebras(QQ).ComplexModules()

Change History (3)

comment:1 Changed 5 years ago by nthiery

  • Description modified (diff)

comment:2 Changed 5 years ago by tscrim

  • Cc tscrim added

comment:3 Changed 5 years ago by nthiery

  • Description modified (diff)
Note: See TracTickets for help on using tickets.