Re: [sage-combinat-devel] [sage-devel] Re: post more

[Anne Schilling]

Dear Benjamin,

What is your code for demazure? It might also worth comparing with the
Demazure character already in sage:

sage: 2*rho
(3, 1)
sage: B = CrystalOfTableaux(['B',2], shape = [3,1])
sage: B.demazure_character([1,2,1,2], reduced_word = True)
x1^3*x2 + 2*x1^2*x2^2 + 3*x1*x2^3 + 2*x1^3 + 4*x1^2*x2 + 6*x1*x2^2 + 6*x1^2 + x1*x2 + 2*x2^2/x1 + x2 + 2*x2/x1 + 3/x1 + 2/x1^2 + 1/(x1*x2) + 1/x1^3 + x2^2 + x1 + x2^2/x1 + 2*x2 + x2/x1 + 1/x1 + 
x2/x1^2 + 1/x1^2 + 3*x2^3 + 5*x1*x2 + 6*x2^3/x1 + x2^2 + x1 + x2^2/x1 + 2*x2 + x1/x2 + 2*x2/x1 + x2^2/x1^2 + 1/x1 + 2*x2^3 + 3*x1^3/x2 + 3*x1*x2 + x2^3/x1 + 8*x2^2 + 2*x1^2/x2 + 3*x1 + x2^2/x1 + 2*x2 
+ x1^2/x2^2 + 3*x1/x2 + x2/x1 + 2*x1/x2^2 + x2/x1^2 + 4/x2 + x1/x2^3 + 3/(x1*x2) + x2/x1^3 + 3/x2^2 + 2/(x1*x2^2) + 2/(x1^2*x2) + 1/x2^3 + 1/(x1*x2^3) + 1/(x1^2*x2^2) + 1/(x1^3*x2) + 6


Best wishes,

Anne

On 1/29/11 11:29 AM, BFJ wrote:

Over the winter break I wrote some code in Sage for working with the
Demazure character formula with elements of WeightRing (the group ring
of the weight lattice for a semisimple finite dimensional Lie
algebra). There is an implementation of the Demazure operators as part
of the Crystal framework, but I think it's also useful to work
directly in the WeightRing.

I'd like some feedback about whether people think the following two
things would be a useful addition to the Sage library:

1. A function demazure() (or could be a method of WeightRingElement)
that applies a given list of Demazure operators corresponding to
simple roots to a WeightRingElement, returning the character of the
Demazure module. In particular, if we apply Demazure operators in the
order corresponding to the longest element of the Weyl group, we can
compare the Demazure character formula and the Weyl character formula:

# Check the Demazure character formula in B2
sage: A = WeylCharacterRing(['B',2])
sage: a = WeightRing(A)
sage: space = a.space()
sage: lam = space.fundamental_weights()
sage: rho = sum(list(lam))
sage: wch = A(2*rho) # character of the irreducible representation
sage: ch = a(2*rho)  # element in the weight ring
sage: dch = demazure(ch,[1,2,1,2]) # apply 4 Demazure operators
sage: sum([m for (wt,m) in dch.mlist()]) # degree should be 81
81
sage: sorted(wch.mlist()) == sorted(dch.mlist()) # Demazure and Weyl
characters agree!
True


2. A plot() method for WeightRingElement which plots finite characters
for the rank 2 irreducible root systems (type A2, B2, and G2). Here's
an example of the characters of 5 Demazure modules in type B2 building
up to the irreducible G-module V(2*rho)

https://bluedrive.uwstout.edu/users/facultystaff/jonesbe/B2_Demazure_Character.gif

--
Benjamin Jones
University of Wisconsin-Stout
jone...@uwstout.edu
benjaminfjo...@gmail.com


On Jan 28, 11:31 pm, William Steinwst...@gmail.com  wrote:

Hi Sage-Devel,

What are people working on?


--
You received this message because you are subscribed to the Google Groups 
sage-combinat-devel group.
To post to this group, send email to sage-combinat-devel@googlegroups.com.
To unsubscribe from this group, send email to 
sage-combinat-devel+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/sage-combinat-devel?hl=en.

[sage-combinat-devel] Re: [sage-devel] Re: post more

[bump]

I too needed some code to compute with Demazure characters using the
weight ring.
I agree that this is useful independent of the Demazure characters as
implemented
in the crystal code.

What we did was just to make a standalone program that did what we
needed, but it would make a good enhancement to sage.
I think the right way would be as a method of the weight ring.
So the syntax would be

ch.demazure_character(w)

where ch is a weight ring element and w is an element of the Weyl
group.
There could be a helper method

ch._demazure_character(i)

that would produce the operator corresponding to the i-th simple
reflection.
It would do something like this:

def _demazure(self, i):
a = self._parent.space().simple_coroots()[i]
ret = self._parent(0)
d = self._mdict
for t in d.keys():
k = t.inner_product(a)
if k = 0:
ret += d[t]*sum(self._parent(t-j*a) for j in range(k
+1))
else:
ret += -d[t]*sum(self._parent(t+j*a) for j in
range(1,k))
return ret

This helper method would then be called by the method demazure,
which would use the reduced_word method of Weyl group elements
to to produce a sequence of called to the helper method.

The plot method for WeightRingElements, just for rank two, would
also be very useful.

-- 
You received this message because you are subscribed to the Google Groups 
sage-combinat-devel group.
To post to this group, send email to sage-combinat-devel@googlegroups.com.
To unsubscribe from this group, send email to 
sage-combinat-devel+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/sage-combinat-devel?hl=en.