Implement a matrix representation in the Chevalley basis of Classical Lie algebras.

[DisneyHogg]

Problem Description

Following a comment made on sage-devel, and as discussed with @tscrim, it would be useful to have a matrix representation of classical Lie algebras in the Chevalley basis.

This ticket could be tracked at #14901, and would perhaps help with #25013.

Proposed Solution

Such representations are given in Gilmore, and may be directly implemented as current matrix representations are.

Alternatives Considered

There do not appear to be existing libraries which can easily provide this functionality.

Additional Information

No response

Is there an existing issue for this?

• I have searched the existing issues for a bug report that matches the one I want to file, without success.

[AyushVerma54]

i have proposed this solution please let me know if ur looking forward to implement . i am ready for the implementation just looking for the task to be assigned

def chevalley_basis_A(n):
"""
Construct the Chevalley basis matrices for Lie algebra of type A_n (sl_{n+1}).
Returns a dictionary with keys 'e', 'f', 'h' for positive root vectors, negative root vectors, and Cartan elements.
"""
from sage.matrix.constructor import matrix
from sage.rings.rational_field import QQ

dim = n + 1
e = {}
f = {}
h = {}

# Cartan elements h_i = E_{i,i} - E_{i+1,i+1}
for i in range(n):
    mat = matrix(QQ, dim)
    mat[i,i] = 1
    mat[i+1,i+1] = -1
    h[i+1] = mat

# Positive root vectors e_i = E_{i,i+1}
for i in range(n):
    mat = matrix(QQ, dim)
    mat[i,i+1] = 1
    e[i+1] = mat

# Negative root vectors f_i = E_{i+1,i}
for i in range(n):
    mat = matrix(QQ, dim)
    mat[i+1,i] = 1
    f[i+1] = mat

return {'e': e, 'f': f, 'h': h}

[tscrim]

A Chevalley basis should be indexed by the roots and simple coroots. So the final return format should match this.

Sort of a while-we-are-at-it kinda thing that I think would be really useful would be to just override the basis() method of the classical matrix Lie algebras (except for gl) to use the information that all root spaces are 1 dimensional when building the basis. This is more so for the exceptional types than the classical families.

Perhaps the best thing will be to hard-code the bases in each case using some standard presentation (i.e., choice of Cartan/maximal torus/Borel). In an ideal world, we could do this for any (skew-)symmetric bilinear form, but I think that would be a bit tricky (at least without running the full Cartan decomposition algorithm). Then we don't need to worry about implementing something that finds the correct scaling factor. On the other hand, it means a lot of specific cases and doesn't extend to the exceptional types.

It's quite possible just setting the leading coefficient (in the natural elementary matrix basis) to 1 will do the job. Another possibility, which is bad, would be this is impossible with matrices over $\mathbb{Z}$ (or at least $\mathbb{Q}$) because of, say, a $\sqrt{2}$ required.

One thing that comes to mind as a potential good solution is to have the basis() construct the root basis with the normalization by dividing by the gcd of all matrix entries (IMO easiest and fastest to implement and compute such that it is a root basis and structure coefficients will all be integers), and then have a chevalley_basis() method return the appropriate rescaled version.