#18034: symmetric_form weirdness for affine roots
------------------------------------------+------------------------
Reporter: bump | Owner:
Type: defect | Status: new
Priority: major | Milestone: sage-6.6
Component: PLEASE CHANGE | Resolution:
Keywords: days64, symmetric_form | Merged in:
Authors: | Reviewers:
Report Upstream: N/A | Work issues:
Branch: | Commit:
Dependencies: | Stopgaps:
------------------------------------------+------------------------
Description changed by bump:
Old description:
> Affine weight lattices have a method called symmetric_form which
> implements the symmetric bilinear form on the weight lattice (or weight
> space) used extensively in representation theory. See Kac, *Infinite-
> dimensional Lie algebras* Chapter 2. It is an inner product, that is, a
> pairing of the space with itself. Here are some examples where it doesn't
> work right unless you coerce the root into the weight lattice.
>
> {{{
> sage: RS = RootSystem(['A',2,1])
> sage: P = RS.weight_lattice(extended=true)
> sage: Q = RS.root_lattice()
> sage: alpha = Q.simple_roots()
> sage: alphacheck = Q.simple_coroots()
> sage: omega = P.fundamental_weights()
> sage: [alpha[1].symmetric_form(omega[i]) for i in [0,1,2]]
> [-1, 2, -1]
> sage: [alpha[1].symmetric_form(alphacheck[i]) for i in [0,1,2]]
> [-1, 2, -1]
> sage: [P(alpha[1]).symmetric_form(alphacheck[i]) for i in [0,1,2]]
> [0, 1, 0]
> sage: [P(alpha[1]).symmetric_form(omega[i]) for i in [0,1,2]]
> [0, 1, 0]
> }}}
>
> The first three answers are (in my opinion) wrong for the following
> reasons.
> The last answer is correct. The first one is therefore wrong since
> the symmetric form should not depend on whether alpha is regarded as
> an element of Q or of P. The second two pairings should be undefined
> since
> alphacheck cannot be coerced into P.
>
> The pairing self.scalar(other) can be used to pair roots with coroots.
> The
> pairing self.symmetric_form(other) should then be defined for elements
> of the same space.
New description:
Affine weight lattices have a method called symmetric_form which
implements the symmetric bilinear form on the weight lattice (or weight
space) used extensively in representation theory. See Kac, *Infinite-
dimensional Lie algebras* Chapter 2. It is an inner product, that is, a
pairing of the space with itself. Here are some examples where it doesn't
work right unless you coerce the root into the weight lattice.
{{{
sage: RS = RootSystem(['A',2,1])
sage: P = RS.weight_lattice(extended=true)
sage: Q = RS.root_lattice()
sage: alpha = Q.simple_roots()
sage: alphacheck = Q.simple_coroots()
sage: omega = P.fundamental_weights()
sage: [alpha[1].symmetric_form(omega[i]) for i in [0,1,2]]
[-1, 2, -1]
sage: [alpha[1].symmetric_form(alphacheck[i]) for i in [0,1,2]]
[-1, 2, -1]
sage: [P(alpha[1]).symmetric_form(alphacheck[i]) for i in [0,1,2]]
[0, 1, 0]
sage: [P(alpha[1]).symmetric_form(omega[i]) for i in [0,1,2]]
[0, 1, 0]
}}}
The first three answers are (in my opinion) wrong for the following
reasons.
The last answer is correct. The first one is therefore wrong since
the symmetric form should not depend on whether alpha is regarded as
an element of Q or of P. The second two pairings should be undefined since
alphacheck cannot be coerced into P.
The pairing self.scalar(other) can be used to pair roots with coroots. The
pairing self.symmetric_form(other) should then be defined for elements
of the same space.
This seem to be wrong also in a different way for type ['B',3,1]. The
following is
probably correct behavior:
{{{
sage: RS = RootSystem(['B',3,1])
sage: Q = RS.root_lattice()
sage: P = RS.weight_lattice(extended=true)
sage: Matrix([[a.symmetric_form(b) for a in Q.simple_roots()] for b in
Q.simple_roots()])
[ 4 0 -2 0]
[ 0 4 -2 0]
[-2 -2 4 -2]
[ 0 0 -2 2]
sage: RS.cartan_matrix()
[ 2 0 -1 0]
[ 0 2 -1 0]
[-1 -1 2 -1]
[ 0 0 -2 2]
}}}
So far so good. The symmetric form implements the symmetrized Cartan
matrix. But the fundamental weights should be dual to the roots.
{{{
sage: Matrix([[a.symmetric_form(b) for a in Q.simple_roots()] for b in
P.fundamental_weights()])
[ 4 0 -2 0]
[ 0 4 -2 0]
[-2 -2 4 -2]
[ 0 0 -2 2]
}}}
For type A we can fix this by coercing a into P (as shown above). But for
type B this doesn't seem to work:
{{{
age: Matrix([[P(a).symmetric_form(b) for a in Q.simple_roots()] for b in
P.fundamental_weights()])
[ 1 0 0 0]
[-1 2 0 0]
[-2 0 2 0]
[-1 0 0 1]
}}}
I think this should be a diagonal matrix. It almost is, except the first
column. I think the following is the state of affairs. For affine Cartan
types, the symmetric form works correctly as a pairing of the root lattice
with itself. It is defined as a pairing of the extended weight lattice
with itself, or of the extended weight lattice with the root lattice.
These pairings should be the same, that is, coercing from Q to P should
not affect the result, but it does. For type A, we can get accurate
results by pairing the weight lattice with itself, so if we wish to pair
an element of Q with an element of P, we coerce the element of Q into P,
and then the pairing gives the right result. But this doesn't work with
Type B.
--
--
Ticket URL: <http://trac.sagemath.org/ticket/18034#comment:5>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica,
and MATLAB
--
You received this message because you are subscribed to the Google Groups
"sage-trac" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/d/optout.
