On Tuesday, July 26, 2016 at 3:07:04 PM UTC-5, Joseph Hundley wrote:
>
> I recently looked at Computing in Groups of Lie Type  
> <http://www.google.com/url?q=http%3A%2F%2Fwww.win.tue.nl%2F~amc%2Fpub%2Fpapers%2Fcmt.pdf&sa=D&sntz=1&usg=AFQjCNEK0V9M1i2uGHXlVWVU-HgDTokI9w>by
>  
> Cohen, Murray and Taylor. The basic approach to representation and 
> calculation which is taken there is essentially the one I had in mind. Plus 
> they've worked a number of details I thought I would have to work out. It 
> appears that this article was written as the algorithms in question were 
> being implemented in Magma. I wonder firstly whether it would be considered 
> "kosher" to reimplement them in Sage, and secondly whether it would be 
> considered desirable.
>

Yes and possibly yes. It depends on how much of the algorithms depends on 
doing linear algebra (or other aspects of Sage). If the answer is very 
little to none, I would do it as a separate package in C++ for the speed 
and then construct an iterface to it using Sage. Although we can always do 
it in Sage and extract things out afterwards.
 

> Naively, it seems to me that the article would not have been written if 
> the algorithms were to be treated as protected intellectual property. And 
> I'd already stumbled across quite a bit of it independently by following my 
> nose. Still I'm fairly new to programming and have not yet learned the 
> ethos around such things. 
>

Its a published research paper, so we (i.e., anyone) are free to provide 
our own implementation.

>
> If I were going forward with this, I think a reasonable first step would 
> be to equip root systems with the ability to compute a few key integral 
> invariants of roots and pairs of roots. Including: 
> (1) the (normalized integral) norm square (always 1 for short roots, 2 or 
> three for long...)
>

This is essentially already in Sage; you just need to divide by 2:

sage: al = RootSystem(['B',4]).root_lattice().simple_roots()
sage: al[1].norm_squared()
4
sage: al[4].norm_squared()
2
sage: al = RootSystem(['G',2]).root_lattice().simple_roots()
sage: al[1].norm_squared()
2
sage: al[2].norm_squared()
6
 

> (2) the largest integer k (given roots a and b) such that a+kb is a root.
> (3) the smallest integer k (given roots a and b) such that a+kb is a root.
>

I've done these ad-hoc for the classical Lie algebras (see #16821), but it 
would be good to have these as general methods.
 

> (4) integral structure constants of the Chevalley presentation. These are 
> not uniquely determined by the system, but there is a fairly standard way 
> of selecting them-- described for example in Cohen Murray Taylor or a 1988 
> article of Gilkey and Seitz-- which depends only on the system, and 
> therefore seems to me like a method which should live in class "root 
> system."
>

If I am understanding what you want, see the structure coefficients for the 
classical groups in #16821. We can probably extract that out as separate 
functions, but I would not have them be a method of a root system since it 
is specialized for Lie algebras and groups of Lie type.

We might be better at this point moving the discussion to a trac ticket.

Best,
Travis


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

Reply via email to