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

[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()

CC: @tscrim

Component: algebra

Issue created by migration from https://trac.sagemath.org/ticket/18230

[nthiery]

Description changed:

--- 
+++ 
@@ -1 +1,70 @@
 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)
+```
+

[nthiery]

Description changed:

--- 
+++ 
@@ -68,3 +68,12 @@
           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()
+```
+