#18034: symmetric_form weirdness for affine roots
------------------------------------------+------------------------
Reporter: bump | Owner:
Type: defect | Status: new
Priority: major | Milestone: sage-6.6
Component: combinatorics | 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.
>
> 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 Q with itself. It is defined as a pairing of the extended weight
> lattice p with itself, or of P with Q. 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.
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
essentially 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]
}}}
The symmetric form is twice the symmetric form defined by Kac (Infinite-
Dimensional Lie Algebras, third edition, (6.2.2) on page 81 but the
doubling is harmless for applications. So far so good.
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.
For affine Cartan types, the symmetric form works correctly as a pairing
of the root lattice Q with itself. It is defined as a pairing of the
extended weight lattice p with itself, or of P with Q. 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:7>
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.
