Hi Mark,

On Thu, Mar 08, 2012 at 11:01:59PM -0500, msh...@math.vt.edu wrote:
> Unfortunately, in type A_{2n}^{(2)}, the implementation of the
> extended weight lattice is (slightly) incorrect.
>
> The usual definition of delta in general is the linear
> combination of simple roots whose coefficients are given by the
> unique relatively prime tuple of positive integers
> which give a linear dependence on the columns of the Cartan matrix
> (where the i,j-th entry is the pairing of alpha_i^\vee with alpha_j).
> 
> In type A_4^{(2)} we have
> 
> delta = 2 alpha_0 + 2 alpha_1 + alpha_2.
> 
> Therefore
> 
> alpha_0 = delta/2 - alpha_1 - 1/2 alpha_2
>    = delta/2 - 2 Lambda_0 - Lambda_1.
> 
> Note that the 1/2 alpha_2 is ok: other than delta/2
> you get no denominator.
> 
> In other words, in this unfortunate root system,
> the Z-basis of the "extended" weight lattice
> consists of the fundamental weights and delta/2.
> 
> In every other affine root system the extra generator is delta,
> that is, the coefficient of alpha_0 in delta is 1.
> 
> Awkward to fix (making delta/2 the
> basis element) but it is the standard notation.

The implementation is in fact correct (computationally speaking):

    sage: L=RootSystem(["A",4,2]).weight_lattice(extended=True)
    sage: L.null_root()
    2*delta

Granted, the output is suboptimal: naming "delta" the basis element
used to perturbate the simple root for the special node is a slight
abuse since, as you point out, in the literature, "delta" is instead
the null root. A trivial workaround would be to tweak _repr_monomial
and _latex_monomial to *output* that basis element as "delta/2" for
A_2n^(2). A better fix would be to choose a type free name for this
basis element, to be used for:

 - output
 - indexing the basis element (as in the current L.basis()["delta"])

A further guide for choosing that name is that we want it to admit
natural generalizations for Kac-Moody where we will need more basis
elements to perturbate more simple roots (something like delta_0,
delta_1, ...).

I do claim that their is strong value in keeping the code as type-free
as possible (it currently is completely type free up to a single
thing: the choice of the special node which is hard coded in the
predefined affine Cartan Type). By the way, as a personal opinion, the
literature would be far more accessible to newcomers if it was written
in a more type free way, without all those nitty-gritty type specific
details that are impossible to all keep in mind at once. But that's a
different discussion.

Now for the practical aspect: I have added the following warning to
the documentation:

    .. warning::

        By a slight notational abuse, the extra basis element used to
        extend the fundamental weights is called ``\delta`` in the
        current implementation. However, in the litterature,
        ``\delta`` usually denotes instead the null root. Most of the
        time, those two objects coincide, but not for type `BC` (aka.
        `A_{2n}^{(2)}). Therefore we currently have::

            sage: Q = RootSystem(["A",4,2]).weight_lattice(extended=True)
            sage: Q.simple_root(0)
            2*Lambda[0] - Lambda[1] + delta
            sage: Q.null_root()
            2*delta

        whereas, with the standard notations from the litterature, one
        would expect to get respectively `2\Lambda_0 -\Lambda_1 +1/2
        \delta` and `\delta`.

        Other than this notation glitch, the implementation remains
        correct for type `BC`.

        The notations may get improved in a subsequent version, which
        might require changing the index of the extra basis
        element. To guarantee backward compatibility in code not
        included in Sage, it is recommended to use the following idiom
        to get that index::

            sage: F = Q.basis_extension(); F
            Finite family {'delta': delta}
            sage: index = F.keys()[0]; index
            'delta'

        Then, for example, the coefficient of an element of the
        extended weight lattice on that basis element can be recovered
        with::

            sage: Q.null_root(0)[index]
            2

I don't currently need extended weight lattices myself, so I won't
work further in this direction. You are welcome to go ahead, either in
the coming days in a reviewer's patch for this ticket, or in a
subsequent ticket.

Best,
                                Nicolas
--
Nicolas M. ThiƩry "Isil" <nthi...@users.sf.net>
http://Nicolas.Thiery.name/

-- 
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.

Reply via email to