search

sagemath / sage

Main repository of SageMath
https://www.sagemath.org
Other
1.33k stars 453 forks source link

symmetric_form weirdness for affine roots #18034

Open 6bbcde06-8197-41f1-b9a3-c998bb839000 opened 9 years ago

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago

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

CC: @sagetrac-sage-combinat @tscrim

Component: combinatorics

Keywords: days64, symmetric_form

Issue created by migration from https://trac.sagemath.org/ticket/18034

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago

Changed keywords from none to days64, symmetric_form

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago

Description changed:

--- 
+++ 
@@ -22,3 +22,7 @@
 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.
tscrim commented 9 years ago
comment:3

So do you think we should raise an error message when we have incompatible arguments, which would be a coroot with a weight/root, and coerce otherwise? Or should we use the av = 2 a / (a, a) identification to do the pairing? Also you'd be okay with the first would coerce move alpha[1] into the weight lattice?

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago
comment:4

So do you think we should raise an error message when we have incompatible arguments, which would be a coroot with a weight/root, and coerce otherwise?

Yes. We do have another pairing self.scalar(other) which I think we use for the pairing with the dual space.

Or should we use the av = 2 a / (a, a) identification to do the pairing?

I think the answer is no, since this will blow up on imaginary roots where e.g. (delta|delta)=0.

Also you'd be okay with the first would coerce move alpha[1] into the weight lattice?

Yes, if we coerce elements of the root lattice into the weight lattice to compute the symmetric form I think this will give the right answer.

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago

Description changed:

--- 
+++ 
@@ -26,3 +26,42 @@
 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.
+
6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago

Description changed:

--- 
+++ 
@@ -63,5 +63,5 @@
 [-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. +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.

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago

Description changed:

--- 
+++ 
@@ -28,7 +28,7 @@
 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:
+essentially correct behavior:

sage: RS = RootSystem(['B',3,1]) @@ -45,7 +45,8 @@ [-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.
+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()]) @@ -63,5 +64,7 @@ [-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.
+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.
6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago

Description changed:

--- 
+++ 
@@ -45,7 +45,8 @@
 [-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. +The symmetric form is twice the symmetric form defined by Kac (Infinite-Dimensional Lie Algebras, third edition, (6.2.2) on page 81). The doubling is harmless for applications. So far so good. + But the fundamental weights should be dual to the roots.

tscrim commented 9 years ago
comment:9

This doesn't seem to work for all non-simply-laced types (I've only checked some)

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago
comment:10

I'm writing some workarounds for #15806. It may be easier to fix the symmetric_form method after I'm done.

6bbcde06-8197-41f1-b9a3-c998bb839000 commented 9 years ago
comment:11

The methods _inner_qq, _inner_pq and _inner_qq in #15806 should make it possible to fix this by handling all three cases.