Hey Andrew and Nicolas,
   I've probably mentioned this before, but I think we should figure out 
how we want to handle categories for representations in general. I would 
like this for Lie algebras (equiv. universal enveloping algebras), quantum 
groups, and general groups (equiv. group algebras). Something which would 
be benefit from having a category for Hecke algebra representations would 
be methods for constructing the Grothendieck group, a list of simples (up 
to isomorphism), and a canonical place to look for constructing examples 
(via ``an_element()``).

   So my thoughts (if you've heard this before, feel free to skip) on this 
would be to construct a category parameterized by a Hecke algebra ``H`` 
which is a subcategory of the category of modules over ``H.base_ring()``. 
For general representation categories, we'd have an abstract method 
``representation_action()`` (the name can change, I didn't think too hard 
about this) that the user must implement and which we use throughout the 
category and with some default implementation of ``get_action()`` which 
calls ``representation_action()`` when passed an element of ``H``. In this 
case specifically, we could define a generic ``representation_action()`` 
which converts an element to the T_i basis and calls ``T_action(i)`` 
(again, probably a better name out there).

   Although for now we can just have a base class for all Hecke algebra 
representations, and there is not a clear and obvious gain to me at present 
from defining such a category.

Best,
Travis


On Friday, November 21, 2014 4:16:13 PM UTC-8, Andrew wrote:
>
>
>
> On Saturday, 22 November 2014 10:24:43 UTC+11, Nicolas M. Thiery wrote:
>>
>>         Hi Andrew, 
>> Hmm, I haven't taken the time to think with a pen and paper, but I 
>> don't guarantee that the what the super call do is as straightforward 
>> as it ought to, given that the instance of A being initialized will 
>> end up being in a subclass A_with_category, and similarly for the 
>> others.  Does it work if instead you call explicitly A.__init__ in 
>> B.__init__, and so on? 
>>
>
> Hi Nicolas,
>
> I fixed my problem so the code is working now. It is possible that there 
> are some issues with the super calls but as far as I can tell it is working 
> as I expect.
>
> One question that I should ask you, however, is the following. I have a 
> suspicion that I should define a category for the Hecke algebra 
> representations, however, I don't know what the benefits are of doing this 
> or how to do it. Certainly the code seems to work without this (not that I 
> have added extensive tests yet or properly implemented the mathematics), 
> but if this is necessary, or desirable, I would like to understand what 
> this gives me over and above having a dedicated class for Hecke algebra 
> representations.
>
> Andrew
>
>  
>

-- 
You received this message because you are subscribed to the Google Groups 
"sage-combinat-devel" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to sage-combinat-devel+unsubscr...@googlegroups.com.
To post to this group, send email to sage-combinat-devel@googlegroups.com.
Visit this group at http://groups.google.com/group/sage-combinat-devel.
For more options, visit https://groups.google.com/d/optout.

Reply via email to