Weyl群、Coxeter群和Bruhat序

经典和仿射Weyl群

您可以为任何根系统创建Weyl组和仿射Weyl组。有多种方法可供选择。其中一些方法适用于一般的Coxeter群体。

默认情况下,Weyl组的元素表示为矩阵:

sage: WeylGroup("A3").simple_reflection(1)
[0 1 0 0]
[1 0 0 0]
[0 0 1 0]
[0 0 0 1]

您可能更喜欢一种表示法,其中元素被写成简单反射的产物。为了实现这一点,您需要指定一个前缀,通常 "s" ::

sage: W = WeylGroup("A3",prefix="s")
sage: [s1,s2,s3] = W.simple_reflections()
sage: (s1*s2*s1).length()
3
sage: W.long_element()
s1*s2*s3*s1*s2*s1
sage: s1*s2*s3*s1*s2*s1 == s3*s2*s1*s3*s2*s3
True

Weyl群作用于根晶格的周围空间,通过该方法可以访问 domain . 为了说明这一点,回想一下如果 w_0 是长元素吗 alpha mapsto -w_0(alpha) 是简单根的排列。我们可以这样计算:

sage: W = WeylGroup("E6",prefix="s")
sage: w0 = W.long_element(); w0
s1*s3*s4*s5*s6*s2*s4*s5*s3*s4*s1*s3*s2*s4*s5*s6*s2*s4*s5*s3*s4*s1*s3*s2*s4*s5*s3*s4*s1*s3*s2*s4*s1*s3*s2*s1
sage: sr = W.domain().simple_roots().list(); sr
[(1/2, -1/2, -1/2, -1/2, -1/2, -1/2, -1/2, 1/2), (1, 1, 0, 0, 0, 0, 0, 0),
(-1, 1, 0, 0, 0, 0, 0, 0), (0, -1, 1, 0, 0, 0, 0, 0), (0, 0, -1, 1, 0, 0, 0, 0),
(0, 0, 0, -1, 1, 0, 0, 0)]
sage: [-w0.action(a) for a in sr]
[(0, 0, 0, -1, 1, 0, 0, 0), (1, 1, 0, 0, 0, 0, 0, 0), (0, 0, -1, 1, 0, 0, 0, 0),
(0, -1, 1, 0, 0, 0, 0, 0), (-1, 1, 0, 0, 0, 0, 0, 0),
(1/2, -1/2, -1/2, -1/2, -1/2, -1/2, -1/2, 1/2)]

我们可能会问这种排列何时无关紧要。如果它是非平凡的,它诱导了Dynkin图的一个自同构,因此当Dynkin图没有自同构时,它一定是非平凡的。但是,如果存在一个非平凡的自同构,那么置换可能是也可能不是微不足道的:

sage: def roots_not_permuted(ct):
....:     W = WeylGroup(ct)
....:     w0 = W.long_element()
....:     sr = W.domain().simple_roots()
....:     return all(a == -w0.action(a) for a in sr)
sage: for ct in [CartanType(['D', r]) for r in [2..8]]:
....:     print("{} {}".format(ct, roots_not_permuted(ct)))
['D', 2] True
['D', 3] False
['D', 4] True
['D', 5] False
['D', 6] True
['D', 7] False
['D', 8] True

如果 alpha 是根让 r_alpha 表示在与之正交的超平面上的反射 alpha . 我们保留批注 s_alpha 对于简单的反射,也就是说 alpha 是一个简单的根。反射只是简单反射的共轭。

反射是有限族中的值,它是python字典的包装器。键是正根,所以给定一个正根,就可以查找相应的反射。如果您想要一个所有反射的列表,您可以使用通常的方法来构造一个列表(例如,使用 list 函数)或使用方法 values 对于反射系:

sage: W = WeylGroup("B3",prefix="s")
sage: ref = W.reflections(); ref
Finite family {(1, -1, 0): s1, (0, 1, -1): s2, ...}
sage: [a1,a2,a3] = W.domain().simple_roots()
sage: a1+a2+a3
(1, 0, 0)
sage: ref[a1+a2+a3]
s1*s2*s3*s2*s1
sage: sorted(ref)
[s1*s2*s3*s2*s1,
 s2*s3*s1*s2*s3*s1*s2,
 s3*s1*s2*s3*s1,
 s1*s2*s1,
 s1,
 s2*s3*s2,
 s3*s2*s3,
 s2,
 s3]

如果您想要一个其键为反射且值为根的族,则可以使用反向族:

sage: from pprint import pprint
sage: W = WeylGroup("B3",prefix="s")
sage: [s1,s2,s3] = W.simple_reflections()
sage: altref = W.reflections().inverse_family()
sage: altref
Finite family {s1*s2*s3*s2*s1: (1, 0, 0),
 s2*s3*s1*s2*s3*s1*s2: (1, 1, 0),
 s3*s1*s2*s3*s1: (1, 0, 1),
 s1*s2*s1: (1, 0, -1),
 s1: (1, -1, 0),
 s2*s3*s2: (0, 1, 0),
 s3*s2*s3: (0, 1, 1),
 s2: (0, 1, -1),
 s3: (0, 0, 1)}
sage: altref[s3*s2*s3]
(0, 1, 1)

注解

这个函数的行为在 :trac:`20027` .

Weyl群被实现为一个间隙矩阵群。因此,可以显示其字符表。字符表以字符串形式返回,您可以打印:

sage: print(WeylGroup("D4").character_table())
CT1
<BLANKLINE>
      2  6  4  5  1  3  5  5  4  3  3  1  4  6
      3  1  .  .  1  .  .  .  .  .  .  1  .  1
<BLANKLINE>
        1a 2a 2b 6a 4a 2c 2d 2e 4b 4c 3a 4d 2f
<BLANKLINE>
X.1      1  1  1  1  1  1  1  1  1  1  1  1  1
X.2      1 -1  1  1 -1  1  1 -1 -1 -1  1  1  1
X.3      2  .  2 -1  .  2  2  .  .  . -1  2  2
X.4      3 -1 -1  .  1 -1  3 -1  1 -1  . -1  3
X.5      3 -1 -1  .  1  3 -1 -1 -1  1  . -1  3
X.6      3  1 -1  . -1 -1  3  1 -1  1  . -1  3
X.7      3  1 -1  . -1  3 -1  1  1 -1  . -1  3
X.8      3 -1  3  . -1 -1 -1 -1  1  1  . -1  3
X.9      3  1  3  .  1 -1 -1  1 -1 -1  . -1  3
X.10     4 -2  . -1  .  .  .  2  .  .  1  . -4
X.11     4  2  . -1  .  .  . -2  .  .  1  . -4
X.12     6  . -2  .  . -2 -2  .  .  .  .  2  6
X.13     8  .  .  1  .  .  .  .  .  . -1  . -8

仿射Weyl群

仿射Weyl群可以用同样的方法创建。您只需从仿射Cartan类型开始:

sage: W = WeylGroup(['A',2,1],prefix="s")
sage: W.cardinality()
+Infinity
sage: [s0,s1,s2] = W.simple_reflections()
sage: s0*s1*s2*s1*s0
s0*s1*s2*s1*s0

仿射Weyl群与经典的Weyl群不同,因为它是无限的。关联的经典Weyl群是一个子群,可以提取如下:

sage: W = WeylGroup(['A',2,1],prefix="s")
sage: W1 = W.classical(); W1
Parabolic Subgroup of the Weyl Group of type ['A', 2, 1] (as a matrix group
acting on the root space)
sage: W1.simple_reflections()
Finite family {1: s1, 2: s2}

虽然 W1 在这个例子中是同构的 WeylGroup("A2") 它有不同的矩阵实现:

sage: for s in WeylGroup(['A',2,1]).classical().simple_reflections():
....:     print(s)
....:     print("")
[ 1  0  0]
[ 1 -1  1]
[ 0  0  1]
<BLANKLINE>
[ 1  0  0]
[ 0  1  0]
[ 1  1 -1]

sage: for s in WeylGroup(['A',2]).simple_reflections():
....:     print(s)
....:     print("")
[0 1 0]
[1 0 0]
[0 0 1]
<BLANKLINE>
[1 0 0]
[0 0 1]
[0 1 0]

布鲁哈秩序

Weyl群上的Bruhat偏序可以定义如下。

如果 u,v in W ,找到 v 简单思考的产物: v = s_1 cdots s_n . (不假定 s_i 如果省略一些 s_i 给出一个代表 u 然后 u le v .

Bruhat阶作为Coxeter群的一种方法在Sage中实现,因此它适用于Weyl群,经典的或仿射的。

如果 uv in W 然后 u.bruhat_le(v) 收益率 True 如果 u le v 以布鲁哈秩序。

如果 u le v 然后 Bruhat间期 [u,v] 被定义为 t 这样的话 u le t le v . 可以尝试如下实现:

sage: W = WeylGroup("A2",prefix="s")
sage: [s1,s2] = W.simple_reflections()
sage: def bi(u,v) : return [t for t in W if u.bruhat_le(t) and t.bruhat_le(v)]
...
sage: bi(s1,s1*s2*s1)
[s1*s2, s2*s1, s1, s1*s2*s1]

这不是一个好的定义,因为如果 W 是仿射的,效率低下 W 很大。Sage有一个Bruhat区间方法:

sage: W = WeylGroup("A2",prefix="s")
sage: [s1,s2] = W.simple_reflections()
sage: W.bruhat_interval(s1,s1*s2*s1)
[s1*s2*s1, s2*s1, s1*s2, s1]

这甚至适用于仿射Weyl群。

Bruhat图

参考文献:

这个 Bruhat图 是Bruhat区间上的一个结构。假设如此 u le v . 图的顶点是 x 具有 u le x le v . 有一个顶点 x,y in [x,y] 如果 x = y cdot r 在哪里? r 是一种反映。如果这是真的,那么 x < yy < x .

如果 W 是一个经典的Weyl群,Bruhat图在Sage中实现:

sage: W = WeylGroup("A3",prefix="s")
sage: [s1,s2,s3] = W.simple_reflections()
sage: bg = W.bruhat_graph(s2,s2*s1*s3*s2); bg
Digraph on 10 vertices
sage: bg.show3d()

Bruhat图具有有趣的正则性,Carrell和Peterson研究了这些性质。如果两个Kazhdan-Lusztig多项式都是正则图 P_{{u,v}}P_{{w_0v,w_0u}} 是1,在哪里 w_0 是长Weyl群元素。它与 迪奥哈尔猜想 迪奥达尔、卡雷尔和彼得森、代尔和波罗证明了这一点。

迪奥达尔证明了如果 u < v 然后是Bruhat间期 [u,v] 包含奇数长度的元素和偶数长度的元素一样多。我们观察到,这一点通常可以得到加强:如果存在反射 r 左(或右)乘 r 以Bruhat间隔 [u,v] 对于它本身,这就给出了在中奇偶长度元素之间的显式双射 [u,v] .

让我们寻找这样的反思。将以下命令放入文件并加载该文件:

W = WeylGroup("A3",prefix="s")
[s1,s2,s3] = W.simple_reflections()
ref = W.reflections().keys()

def find_reflection(u,v):
    bi = W.bruhat_interval(u,v)
    ret = []
    for r in ref:
        if all( r*x in bi for x in bi):
            ret.append(r)
    return ret

for v in W:
    for u in W.bruhat_interval(1,v):
        if u != v:
            print((u,v,find_reflection(u,v)))

这表明Bruhat区间是由所有对的反射而稳定的 (u,v) 具有 u < v 除了以下两项: s_3s_1,s_1s_2s_3s_2s_1s_2,s_2s_3s_1s_2 . 现在这些正是对,这样 uprec v 以Kazhdan和Lusztig的符号表示 l(v)-l(u) > 1 . 我们不应轻率地假设这是对对的一般特征 (u,v) 因此没有反射稳定Bruhat区间,因为这不是真的。不过,这确实表明,这个问题值得进一步调查。