极大子群与分支规则

分支规则

如果 G 是一个谎言团体 H 是一个子群，人们常常需要知道 G 限制到 H . 不可约通常不限于不可约。在某些情况下，限制是规则的和可预测的，在另一些情况下是混乱的。在某些情况下，它遵循一个可以组合描述的规则，但是组合描述是微妙的。关于不可约分解为不可约的描述称为 分支规则 .

本主题的参考文献：

• [FauserEtAl2006]

• [King1975]

• [HoweEtAl2005]

• [McKayPatera1981]

Sage能计算出 G 仅限于 H . 它不是通过记忆组合规则来实现的，而是通过计算字符并将字符限制在 H . Sage所记住的（在一系列内置的编码规则中）是 G . 李群的最大子群在 [Dynkin1952]. 这种计算分支规则的方法有一个局限性：字符必须适合内存，并且可以由Sage的内部代码实时计算。

考虑以下情况就足够了 H 是的极大子群 G ，因为如果这是已知的，那么一个人可以通过一系列的子群，每个子群在其前辈中是最大的。因此，一个问题是理解李群中的极大子群，并给出每个子群的分支规则，本教程的目标是解释极大子群的嵌入。

Sage有一门课 BranchingRule 对于分支规则。功能 branching_rule 返回此类的元素。例如，自然嵌入 Sp(4) 进入之内 SL(4) 对应于我们可以创建的分支规则，如下所示：

sage: b=branching_rule("A3","C2",rule="symmetric"); b
symmetric branching rule A3 => C2

这个分支规则的名称“对称”将在后面进一步解释，但它意味着 Sp(4) 是对合的固定子群 Sl(4) . 在这里 A3 和 C2 是卡坦类型的群体吗 G=SL(4) 和 H=Sp(4) .

现在我们可以看看 SL(4) 当它们被限制在 Sp(4) ：：

sage: A3=WeylCharacterRing("A3",style="coroots")
sage: chi=A3(1,0,1); chi.degree()
15
sage: C2=WeylCharacterRing("C2",style="coroots")
sage: chi.branch(C2,rule=b)
C2(0,1) + C2(2,0)

或者，我们可以通过 chi 到 b 作为其分支方法的一个参数，其结果相同：

sage: b.branch(chi)
C2(0,1) + C2(2,0)

我们认为Sage的内建分枝规则足以处理所有的极大子群，当秩小于或等于8时，情况肯定是这样的。

但是，如果你想分支到不是最大的子组，你可能找不到内置的分支规则。我们可以构造分支规则来构建嵌入。例如，这里有两个不同的嵌入 Sp(4) 卡坦式 C2 在里面 Sp(8) ，卡坦式 C4 . 一个嵌入因子通过 Sp(4)times Sp(4) ，而其他因素 SL(4) . 为了检验嵌入不是共轭的，我们分支一个（随机选择的）表示。请注意，我们不必构建中间层 Weyl character rings .

sage: C4=WeylCharacterRing("C4",style="coroots")
sage: b1=branching_rule("C4","A3","levi")*branching_rule("A3","C2","symmetric"); b1
composite branching rule C4 => (levi) A3 => (symmetric) C2
sage: b2=branching_rule("C4","C2xC2","orthogonal_sum")*branching_rule("C2xC2","C2","proj1"); b2
composite branching rule C4 => (orthogonal_sum) C2xC2 => (proj1) C2
sage: C2=WeylCharacterRing("C2",style="coroots")
sage: C4=WeylCharacterRing("C4",style="coroots")
sage: [C4(2,0,0,1).branch(C2, rule=br) for br in [b1,b2]]
[4*C2(0,0) + 7*C2(0,1) + 15*C2(2,0) + 7*C2(0,2) + 11*C2(2,1) + C2(0,3) + 6*C2(4,0) + 3*C2(2,2),
 10*C2(0,0) + 40*C2(1,0) + 50*C2(0,1) + 16*C2(2,0) + 20*C2(1,1) + 4*C2(3,0) + 5*C2(2,1)]

分支规则是什么？

分支规则的本质是从 G 子群的权格 H ，通常实现为环境向量空间上的函数。实际上，我们可以共轭嵌入，使一个Cartan子代数 U 属于 H 包含在Cartan子代数中 T 属于 G . 因为 G 是 hbox{{Lie}}(T)^* ，我们得到地图 hbox{{Lie}}(T)^*tohbox{{Lie}}(U)^* ，这必须作为函数实现。对于速度，函数通常只返回一个列表，可以强制将其 hbox{{Lie}}(U)^* .

sage: b = branching_rule("A3","C2","symmetric")
sage: for r in RootSystem("A3").ambient_space().simple_roots():
....:     print("{} {}".format(r, b(r)))
(1, -1, 0, 0) [1, -1]
(0, 1, -1, 0) [0, 2]
(0, 0, 1, -1) [1, -1]

我们可以用Weyl群的一个元素共轭这个映射 G ，得到的映射将给出 G 变成不可还原的 H . 然而，选择映射是一个好主意，这样它就可以将主权重与主权重进行比较，并且尽可能简单地使用 G 变成了 H . 这有时包括仿射根 alpha_0 属于 G ，我们记得它是最高根的负数。

分支规则有一个 describe() 方法，该方法显示根（包括仿射根）如何限制。这是理解嵌入的一个有用的方法。你可以尝试用不同种类的分支规则， "extended" ， "symmetric" ， "levi" 等。

sage: b.describe()
<BLANKLINE>
0
O-------+
|       |
|       |
O---O---O
1   2   3
A3~
<BLANKLINE>
root restrictions A3 => C2:
<BLANKLINE>
O=<=O
1   2
C2
<BLANKLINE>
1 => 1
2 => 2
3 => 1
<BLANKLINE>
For more detailed information use verbose=True

扩展的Dynkin图 G 和普通的Dynkin图 H 以供参考，以及 3 => 1 意思是第三个单根 alpha_3 属于 G 限制为的第一个简单根 H . 在本例中，仿射根不限制为一个简单根，因此它从限制列表中省略。如果添加参数 verbose=true 您将看到所有简单根和仿射根的限制，以及基本权重的限制（在coroot表示法中）。

极大子群

Sage有一个数据库，包含每种简单Cartan类型的秩的极大子群 le 8 . 您可以使用 maximal_subgroups Weyl字符环的方法：

sage: E7=WeylCharacterRing("E7",style="coroots")
sage: E7.maximal_subgroups()
A7:branching_rule("E7","A7","extended")
E6:branching_rule("E7","E6","levi")
A2:branching_rule("E7","A2","miscellaneous")
A1:branching_rule("E7","A1","iii")
A1:branching_rule("E7","A1","iv")
A1xF4:branching_rule("E7","A1xF4","miscellaneous")
G2xC3:branching_rule("E7","G2xC3","miscellaneous")
A1xG2:branching_rule("E7","A1xG2","miscellaneous")
A1xA1:branching_rule("E7","A1xA1","miscellaneous")
A1xD6:branching_rule("E7","A1xD6","extended")
A5xA2:branching_rule("E7","A5xA2","extended")

应该理解，还有其他的嵌入方式 A_2=hbox{{SL}}(3) 加入谎言组 E_7 ，但只有一种方法可以作为极大子群。另一方面，只有一种方法可以将其嵌入为极大子群。下面将对嵌入进行解释。您可以获得如下分支规则，并使用它来确定 E_7 如下：

sage: b = E7.maximal_subgroup("A2"); b
miscellaneous branching rule E7 => A2
sage: [E7,A2]=[WeylCharacterRing(x,style="coroots") for x in ["E7","A2"]]
sage: E7(1,0,0,0,0,0,0).branch(A2,rule=b)
A2(1,1) + A2(4,4)

这提供了与将冒号右侧开始的行粘贴到命令行中相同的分支规则：

sage:branching_rule("E7","A2","miscellaneous")
miscellaneous branching rule E7 => A2

有两种不同的嵌入 A_1=hbox{{SL}}(2) 进入之内 E_7 作为极大子群，所以 maximal_subgroup 方法将返回规则列表：

sage: WeylCharacterRing("E7").maximal_subgroup("A1")
[iii branching rule E7 => A1, iv branching rule E7 => A1]

返回的最大子群的列表 maximal_subgroups 对于秩高达8的不可约Cartan型的方法被认为是直到外自同构的完备方法。您可能需要一个完整的列表，直到内部自同构。例如， E_6 有一个非平凡的Dynkin图自同构，所以它有一个外部自同构，而不是内部的：

sage: [E6,A2xG2]=[WeylCharacterRing(x,style="coroots") for x in ["E6","A2xG2"]]
sage: b=E6.maximal_subgroup("A2xG2"); b
miscellaneous branching rule E6 => A2xG2
sage: E6(1,0,0,0,0,0).branch(A2xG2,rule=b)
A2xG2(0,1,1,0) + A2xG2(2,0,0,0)
sage: E6(0,0,0,0,0,1).branch(A2xG2,rule=b)
A2xG2(1,0,1,0) + A2xG2(0,2,0,0)

因为我们看到两个27维不可约（被外部自同构交换）有不同的分支，所以 A_2times G_2 通过外自同构将子群转化为不同的子群。为了得到第二个分支规则，我们用这个自同构组合给定的规则：

sage: b1=branching_rule("E6","E6","automorphic")*b; b1
composite branching rule E6 => (automorphic) E6 => (miscellaneous) A2xG2

Levi子群

Levi子群可能是最大的，也可能不是最大的。它们很容易分类。如果一开始用的是 G 去掉一个节点，得到一个更小的Dynkin图，这是一个更小的子群的Dynkin图 H .

例如，以下是A3 Dynkin图：

sage: A3 = WeylCharacterRing("A3")
sage: A3.dynkin_diagram()
O---O---O
1   2   3
A3

我们看到我们可以移除节点3并获得 A_2 ，或节点2并获取 A_1 times A_1 . 它们对应于Levi子群 GL(3) 和 GL(2) times GL(2) 属于 GL(4) .

让我们构造 GL(4) 把它们分为 GL(3) 和 GL(2) times GL(2) ：：

sage: reps = [A3(v) for v in A3.fundamental_weights()]; reps
[A3(1,0,0,0), A3(1,1,0,0), A3(1,1,1,0)]
sage: A2 = WeylCharacterRing("A2")
sage: A1xA1 = WeylCharacterRing("A1xA1")
sage: [pi.branch(A2, rule="levi") for pi in reps]
[A2(0,0,0) + A2(1,0,0), A2(1,0,0) + A2(1,1,0), A2(1,1,0) + A2(1,1,1)]
sage: [pi.branch(A1xA1, rule="levi") for pi in reps]
[A1xA1(1,0,0,0) + A1xA1(0,0,1,0),
 A1xA1(1,1,0,0) + A1xA1(1,0,1,0) + A1xA1(0,0,1,1),
 A1xA1(1,1,1,0) + A1xA1(1,0,1,1)]

让我们用coroot符号重新计算。正如我们所解释的，coroot表示法不区分 GL(4) 有相同的限制 SL(4) ，所以实际上我们现在正在与这些团体合作 SL(4) 以及它的Levi子群 SL(3) 和 SL(2) times SL(2) ，它是其Levi子群的派生群：

sage: A3 = WeylCharacterRing("A3", style="coroots")
sage: reps = [A3(v) for v in A3.fundamental_weights()]; reps
[A3(1,0,0), A3(0,1,0), A3(0,0,1)]
sage: A2 = WeylCharacterRing("A2", style="coroots")
sage: A1xA1 = WeylCharacterRing("A1xA1", style="coroots")
sage: [pi.branch(A2, rule="levi") for pi in reps]
[A2(0,0) + A2(1,0), A2(0,1) + A2(1,0), A2(0,0) + A2(0,1)]
sage: [pi.branch(A1xA1, rule="levi") for pi in reps]
[A1xA1(1,0) + A1xA1(0,1), 2*A1xA1(0,0) + A1xA1(1,1), A1xA1(1,0) + A1xA1(0,1)]

现在我们可以观察到在分支

\[GL（4）至GL（2）乘以GL（2）\]

对战

\[SL（4）到SL（2）乘以SL（2）。\]

考虑一下表现 A3(0,1,0) ，这是一个六维的外部广场。在coroot表示法中，限制包含两个普通表示的副本， 2*A1xA1(0,0) . 另一方面，我们在限制中有三个不同的表示，即 A1xA1(1,1,0,0) 和 A1xA1(0,0,1,1) 也就是说， det otimes 1 和 1 otimes det .

列维子群 A1xA1 实际上不是最大值。实际上，我们可以考虑嵌入：

\[SL（2）乘以SL（2）至Sp（4）至SL（4）。\]

因此有分支规则 A3 -> C2 和 C2 -> A2 ，我们可以分两步完成分支，因此：

sage: A3 = WeylCharacterRing("A3", style="coroots")
sage: C2 = WeylCharacterRing("C2", style="coroots")
sage: B2 = WeylCharacterRing("B2", style="coroots")
sage: D2 = WeylCharacterRing("D2", style="coroots")
sage: A1xA1 = WeylCharacterRing("A1xA1", style="coroots")
sage: reps = [A3(fw) for fw in A3.fundamental_weights()]
sage: [pi.branch(C2, rule="symmetric").branch(B2, rule="isomorphic"). \
         branch(D2, rule="extended").branch(A1xA1, rule="isomorphic") for pi in reps]
[A1xA1(1,0) + A1xA1(0,1), 2*A1xA1(0,0) + A1xA1(1,1), A1xA1(1,0) + A1xA1(0,1)]

如您所见，我们使用分支规则，以这种方式相当迂回地重做了分支 A3 -> C2 和 B2 -> D2 ，和两个偶然的同构 C2 = B2 和 D2 = A1xA1 . 使用一步到位要容易得多 rule="levi" ，但让人放心的是我们得到了同样的答案！

用扩展Dynkin图分类的子群

如果我们从扩展的Dynkin图中去掉一个节点，我们就得到了一个子群的Dynkin图。例如：：

sage: G2 = WeylCharacterRing("G2", style="coroots")
sage: G2.extended_dynkin_diagram()
  3
O=<=O---O
1   2   0
G2~

通过移除1节点，我们可以得到 A_2 Dynkin图。因此，特殊群体 G_2 包含的副本 SL(3) . 我们将 G_2 与此副本的基本权重相对应 A_2 ：：

sage: G2 = WeylCharacterRing("G2", style="coroots")
sage: A2 = WeylCharacterRing("A2", style="coroots")
sage: [G2(f).degree() for f in G2.fundamental_weights()]
[7, 14]
sage: [G2(f).branch(A2, rule="extended") for f in G2.fundamental_weights()]
[A2(0,0) + A2(0,1) + A2(1,0), A2(0,1) + A2(1,0) + A2(1,1)]

的两个表示 G_2 ，分别为7度和14度，是对迹零的八分位数和伴随表示的作用。

对于这种类型的嵌入，子群的秩 H 与等级相同 G . 这与Levi类型的嵌入相反，其中 H 排名低于 G .

列维子群 G_2

特殊群体 G_2 有两个Levi子群 A_1 . 两者都不是最大的，正如我们从扩展的Dynkin图中看到的：子群 A_1times A_1 和 A_2 是极大的并且每个包含一个Levi子群。（实际上 A_1times A_1 只有包含短根的Levi子组被实现为 rule="levi" . 要获得另一个，请使用以下规则：

sage: branching_rule("G2","A2","extended")*branching_rule("A2","A1","levi")
composite branching rule G2 => (extended) A2 => (levi) A1

分支到 A_1 包含长根的Levi子群。

正交群与辛群的正交子群与辛子群

如果 G = hbox{{SO}}(n) 然后 G 有一个子组 hbox{{SO}}(n-1) . 取决于 n 是偶数还是奇数，我们有分支规则 ['D',r] 到 ['B',r-1] 或 ['B',r] 到 ['D',r] . 处理方法如下：

sage: branching_rule("B4","D4",rule="extended")
extended branching rule B4 => D4
sage: branching_rule("D4","B3",rule="symmetric")
symmetric branching rule D4 => B3

如果 G = hbox{{SO}}(r+s) 然后 G 有一个子组 hbox{{SO}}(r) times hbox{{SO}}(s) . 这提升到一个普遍覆盖群的嵌入

\[hbox{spin}（r）timeshbox{spin}（s）tohbox{spin}（r+s）。\]

有时这种嵌入是扩展类型的，有时不是。它是扩展型的，除非 r 和 s 都很奇怪。如果是扩展型，则可以使用 rule="extended" . 在任何情况下，您都可以使用 rule="orthogonal_sum" . 名称是指嵌入的起源 SO(r) times SO(s) to SO(r+s) 将二次空间分解为两个正交子空间的直和。

有四种情况取决于 r 和 s . 例如，如果 r = 2k 和 s = 2l 我们有一个嵌入：

['D',k] x ['D',l] --> ['D',k+l]

这是加长型的。因此考虑嵌入 D4xD3 -> D7 . 这是扩展的Dynkin图：

  0 O           O 7
    |           |
    |           |
O---O---O---O---O---O
1   2   3   4   5   6

删除4个顶点会导致断开连接的Dynkin图：

  0 O           O 7
    |           |
    |           |
O---O---O       O---O
1   2   3       5   6

这是 D4xD3 . 因此，使用“扩展”分支规则：

sage: D7 = WeylCharacterRing("D7", style="coroots")
sage: D4xD3 = WeylCharacterRing("D4xD3", style="coroots")
sage: spin = D7(D7.fundamental_weights()[7]); spin
D7(0,0,0,0,0,0,1)
sage: spin.branch(D4xD3, rule="extended")
D4xD3(0,0,1,0,0,1,0) + D4xD3(0,0,0,1,0,0,1)

但我们同样可以使用“正交”法则：

sage: spin.branch(D4xD3, rule="orthogonal_sum")
D4xD3(0,0,1,0,0,1,0) + D4xD3(0,0,0,1,0,0,1)

同样，我们有嵌入：

['D',k] x ['B',l] --> ['B',k+l]

这些也是扩展型的。例如，考虑嵌入 D3xB2 -> B5 . 这是 B5 扩展Dynkin图：

    O 0
    |
    |
O---O---O---O=>=O
1   2   3   4   5

移除3个节点后：

    O 0
    |
O---O       O=>=O
1   2       4   5

这是Dynkin图或者 D3xB2 . 对于这样的分支，我们再次使用 rule="extended" 或 rule="orthogonal_sum" .

最后，还有一个嵌入：

['B',k] x ['B',l] --> ['D',k+l+1]

这是 not 扩展类型，因此您不能使用 rule="extended" .你 must 使用 rule="orthogonal_sum" ：：

sage: D5 = WeylCharacterRing("D5",style="coroots")
sage: B2xB2 = WeylCharacterRing("B2xB2",style="coroots")
sage: [D5(v).branch(B2xB2,rule="orthogonal_sum") for v in D5.fundamental_weights()]
[B2xB2(1,0,0,0) + B2xB2(0,0,1,0),
 B2xB2(0,2,0,0) + B2xB2(1,0,1,0) + B2xB2(0,0,0,2),
 B2xB2(0,2,0,0) + B2xB2(0,2,1,0) + B2xB2(1,0,0,2) + B2xB2(0,0,0,2),
 B2xB2(0,1,0,1), B2xB2(0,1,0,1)]

非极大Levi子群与可约类型的投影

并非所有的Levi子群都是极大的。回想一下Levi子群的Dynkin图 H 属于 G 是通过从 G . 从的扩展Dynkin图中删除同一节点 G 一个亚群的Dynkin图的结果 G 这比 H . 然而，这个子群可能是适当的，也可能不是恰当的，因此Levi子群可能是也可能不是最大的。

如果Levi子群不是极大的，则分支规则可以在Sage中实现，也可以不实现。但是，如果它没有实现，它可以被构造成两个分支规则的组合。

例如，在Sage-6.1之前 branching_rule("E6","A5","levi") 返回一个未实现的错误，并将通知分支到 A5xA1 . 我们可以从扩展的Dynkin图中看到 E_6 确实如此 A_5 不是最大子群，因为从扩展的Dynkin图中删除节点2（见下文）可以得到 A5xA1 . 构造分支规则 A_5 我们可以这样做：

sage: b = branching_rule("E6","A5xA1","extended")*branching_rule("A5xA1","A5","proj1"); b
composite branching rule E6 => (extended) A5xA1 => (proj1) A5
sage: E6=WeylCharacterRing("E6",style="coroots")
sage: A5=WeylCharacterRing("A5",style="coroots")
sage: E6(0,1,0,0,0,0).branch(A5,rule=b)
3*A5(0,0,0,0,0) + 2*A5(0,0,1,0,0) + A5(1,0,0,0,1)
sage: b.describe()
<BLANKLINE>
        O 0
        |
        |
        O 2
        |
        |
O---O---O---O---O
1   3   4   5   6
E6~
root restrictions E6 => A5:
<BLANKLINE>
O---O---O---O---O
1   2   3   4   5
A5
<BLANKLINE>
0 => (zero)
1 => 1
3 => 2
4 => 3
5 => 4
6 => 5
<BLANKLINE>
For more detailed information use verbose=True

注意，没有必要为中间群构造Weyl字符环 A5xA1 .

最后一个例子说明了另一个常见问题：如何从可约根系统中提取一个组件。我们用了规则 "proj1" 提取第一个成分。我们同样可以使用 "proj2" 要获得第二个，或者更一般的任何组件组合：

sage: branching_rule("A2xB2xG2","A2xG2","proj13")
proj13 branching rule A2xB2xG2 => A2xG2

对称子群

如果 G 允许一个外自同构（通常为二阶），然后我们可以尝试找到固定子群的分支规则 H . 可以安排这种自同构映射最大环面 T 一个最大的圆环 U 属于 H 包含在 T .

假设Dynkin图 G 承认一个自同构。那么 G 它本身允许一个外部自同构。群的Dynkin图 H 不变量可以通过“折叠”的Dynkin图得到 G 沿着自同构。例外是分支规则 GL(2r) to SO(2r) .

以下是可以使用 rule="symmetric" .

G	H	卡坦类型
GL(2r)	Sp(2r)	['A',2r-1] => ['C',r]
GL(2r+1)	SO(2r+1)	['A',2r] => ['B',r]
GL(2r)	SO(2r)	['A',2r-1] => ['D',r]
SO(2r)	SO(2r-1)	['D',r] => ['B',r-1]
E_6	F_4	['E',6] => ['F',4]

张量积

如果 G_1 和 G_2 是谎言群，我们有表征 pi_1: G_1 to GL(n) 和 pi_2: G_2 to GL(m) 那么张量积是 G_1 times G_2 . 它有它的形象 GL(nm) 但有时这与 SO(nm) 或 Sp(nm) . 特别是我们有以下情况。

组	子组	卡坦类型
GL(rs)	GL(r)times GL(s)	['A', rs-1] => ['A',r-1] x ['A',s-1]
SO(4rs+2r+2s+1)	SO(2r+1)times SO(2s+1)	['B',2rs+r+s] => ['B',r] x ['B',s]
SO(4rs+2s)	SO(2r+1)times SO(2s)	['D',2rs+s] => ['B',r] x ['D',s]
SO(4rs)	SO(2r)times SO(2s)	['D',2rs] => ['D',r] x ['D',s]
SO(4rs)	Sp(2r)times Sp(2s)	['D',2rs] => ['C',r] x ['C',s]
Sp(4rs+2s)	SO(2r+1)times Sp(2s)	['C',2rs+s] => ['B',r] x ['C',s]
Sp(4rs)	Sp(2r)times SO(2s)	['C',2rs] => ['C',r] x ['D',s]

这些分支规则是通过 rule="tensor" .

对称幂

这个 k -对称外幂同态映射 GL(n) to GL left(binom{{n+k-1}}{{k}} right) 和 GL left(binom{{n}}{{k}} right) . 相应的分支规则没有实现，但有一种特殊情况。这个 k -对称幂同态 SL(2) to GL(k+1) 里面有它的形象 SO(2r+1) 如果 k = 2r 和里面 Sp(2r) 如果 k = 2r-1 . 因此有分支规则：

['B',r] => A1
['C',r] => A1

这些可以用 rule="symmetric_power" .

体积瘤

上面的分支规则对于大多数情况来说已经足够了，但是也有一些是在裂缝之间。大多数情况下，这些都涉及到秩很小的极大子群。

规则 rule="plethysm" 是一个功能强大的规则，它包含来自类型的任何分支规则 A ， B ， C 或 D 作为特例。因此，可以用它来代替上述规则，并给出相同的结果。但是，当从 G 极大子群 H 这样的话 rank(H) < rank(G)-1 .

我们考虑同态 H to G 在哪里？ G 是其中之一 SL(r+1) ， SO(2r+1) ， Sp(2r) 或 SO(2r) .功能 branching_rule_from_plethysm 生成相应的分支规则。主要成分是性格 chi 代表 H 这就是同态 GL(r+1) ， GL(2r+1) 或 GL(2r) .

让我们考虑 SL(2) . 以上由 rule="symmetric_power" ，但假设我们想使用 rule="plethysm" . 首先我们通过调用同态的特征来构造同态 chi ：：

sage: A1 = WeylCharacterRing("A1", style="coroots")
sage: chi = A1([5])
sage: chi.degree()
6
sage: chi.frobenius_schur_indicator()
-1

这证实了字符的阶数为6并且是辛的，因此它对应于同态 SL(2) to Sp(6) ，并且有相应的分支规则 C3 -> A1 ：：

sage: A1 = WeylCharacterRing("A1", style="coroots")
sage: C3 = WeylCharacterRing("C3", style="coroots")
sage: chi = A1([5])
sage: sym5rule = branching_rule_from_plethysm(chi, "C3")
sage: [C3(hwv).branch(A1, rule=sym5rule) for hwv in C3.fundamental_weights()]
[A1(5), A1(4) + A1(8), A1(3) + A1(9)]

这与我们使用 rule="symmetric_power" ：：

sage: A1 = WeylCharacterRing("A1", style="coroots")
sage: C3 = WeylCharacterRing("C3", style="coroots")
sage: [C3(v).branch(A1, rule="symmetric_power") for v in C3.fundamental_weights()]
[A1(5), A1(4) + A1(8), A1(3) + A1(9)]

但是下一个plethysm的例子给出了其他方法无法使用的分支规则：

sage: G2 = WeylCharacterRing("G2", style="coroots")
sage: D7 = WeylCharacterRing("D7", style="coroots")
sage: ad = G2.adjoint_representation(); ad.degree()
14
sage: ad.frobenius_schur_indicator()
1
sage: for r in D7.fundamental_weights():  # long time (1.29s)
....:    print(D7(r).branch(G2, rule=branching_rule_from_plethysm(ad, "D7")))
G2(0,1)
G2(0,1) + G2(3,0)
G2(0,0) + G2(2,0) + G2(3,0) + G2(0,2) + G2(4,0)
G2(0,1) + G2(2,0) + G2(1,1) + G2(0,2) + G2(2,1) + G2(4,0) + G2(3,1)
G2(1,0) + G2(0,1) + G2(1,1) + 2*G2(3,0) + 2*G2(2,1) + G2(1,2) + G2(3,1) + G2(5,0) + G2(0,3)
G2(1,1)
G2(1,1)

在这个例子中， ad 是特殊群的14维伴随表示 G_2 . 由于Frobenius-Schur指标为1，所以表示是正交的，并且因子通过 SO(14) 也就是说， D7 .

实际上，我们不必创建角色（或就此而言，它的环境WeylCharacterRing）才能创建分支规则：

sage: branching_rule("D4","A2.adjoint_representation()","plethysm")
plethysm (along A2(1,1)) branching rule D4 => A2

任何半单李群的伴随表示都是正交的，因此我们不需要计算Frobenius-Schur指示符。

其他子组

使用 rule="miscellaneous" 对于以下规则。每个极大子群 H 一个特殊的群体 G 不是在这五个里面，就是那五个 A_1 下一节中描述的子组，或者（如果 G 和 H 具有相同的等级）可用 rule="extended" .

\[将{alignd}BU 3&改为G G 2，\E E U 6&到A U 2，\E U 6&到G G G G G G U 2，\F F F U 4&到G G G G U 2 倍A U 1，\E E E U 6&到G G G U 2倍A U 2 2，\E E E U 7&到G U 44倍A U 1，\E E E E U 7&到FU 44倍A U 1，\E E E U 7&到A U 1U 1，\E E E U 7&到G U 2U 2 倍A U 1，\E E E U 7&U 7&到G G G G G G G G 2倍于A 1倍，7倍于2倍，8倍于2倍4倍。\从8到2乘以1。\E_8&到B_2结束{aligned}\]

第一个规则对应于嵌入 G_2 在里面 hbox{{SO}}(7) 在它对迹零八分位数的作用中。两个分支规则来自 E_6 到 G_2 或 A_2 如中所述 [Testerman1989]. 我们提醒读者，那篇文章的定理G.2，证明了在复数正特征上是错误的。另一方面，特征的假设 p 对于描述环面嵌入的定理G.1和A.1并不重要，因此包含了足够的信息来计算分支规则。还有其他的嵌入方式 G_2 或 A_2 进入之内 E_6 . 这些条件的特征是 E_6 不可还原地限制到 G_2 或 A_2 . 它们的图像是极大子群。

剩下的规则如下。让 G 是 F_4 ， E_6 ， E_7 或 E_8 ，让 H 是 G_2 ，否则（如果 G=E_7 ） F_4 . 我们嵌入 H 进入之内 G 以最明显的方式；也就是在子群链中

\[G_2子集F_4子集E_6子集E_7子集E_8\]

然后扶正器 H 是 A_1 ， A_2 ， C_3 ， F_4 （如果 H=G_2 或 A_1 （如果 G=E_7 和 H=F_4 ). 这给了我们五个案例。关于分支规则 E_6 to G_2 times A_2 ，鲁本塔勒 [Rubenthaler2008] 描述嵌入并以有趣的方式应用它。

嵌入 A_1times A_1 进入之内 E_7 具体如下。正在删除 E_7 Dynkin图给出了 A_4times A_2 ，所以这是一个Levi子群。我们嵌入 hbox{{SL}}(2) 通过表示进入这个Levi子群 [4]otimes[2] . 这嵌入了 A_1 . 其他的 A_1 是连接的扶正器。看到了吗 [Seitz1991], 尤其是（3.12）的证明。

嵌入如果 G_2times A_1 进入之内 E_7 具体如下。删除的2节点 E_7 Dynkin图给出了 A_6 Dynkin图，这是Levi子群 hbox{{SL}}(7) . 我们嵌入 G_2 进入之内 hbox{{SL}}(7) 通过不可约的七维表示 G_2 . 这个 A_1 是扶正器。

嵌入如果 A_2times A_1 进入之内 E_8 具体如下。删除的2节点 E_8 Dynkin图给出了 A_7 Dynkin图，这是Levi子群 hbox{{SL}}(8) . 我们嵌入 A_2 进入之内 hbox{{SL}}(8) 通过不可约的八维伴随表示 hbox{{SL}}(2) . 这个 A_1 是扶正器。

嵌入 A_2 进入之内 E_7 证明 [Seitz1991] （5.8）。特别是，他计算了 hbox{{SL}}(3) 环面 E_7 环面，这是实现分支规则所需要的。嵌入 B_2 进入之内 E_8 也建造在 [Seitz1991] （6.7）。嵌入 B_2 实现分支规则所需的Cartan子代数很容易从111页的（10）中推导出来。

例外群的极大A1子群

有七个嵌入 SL(2) 作为一个极大的子群加入一个例外的群：一个为 G_2 和 F_4 ，两个非结合嵌入 E_7 还有三个 E_8 这些都是在 [Testerman1992]. 创建相应的分支规则，如下所示。规则的名称是罗马数字，指的是Testerman定理1的七种情况：

sage: branching_rule("G2","A1","i")
i branching rule G2 => A1
sage: branching_rule("F4","A1","ii")
ii branching rule F4 => A1
sage: branching_rule("E7","A1","iii")
iii branching rule E7 => A1
sage: branching_rule("E7","A1","iv")
iv branching rule E7 => A1
sage: branching_rule("E8","A1","v")
v branching rule E8 => A1
sage: branching_rule("E8","A1","vi")
vi branching rule E8 => A1
sage: branching_rule("E8","A1","vii")
vii branching rule E8 => A1

嵌入的特征是其分支规则中的根限制：通常是环境组的简单根 G 限制为的唯一简单根 A_1 ，根除外 alpha_4 规则四，六，七，和根 alpha_6 对于根vii；这本质上是测试人员描述嵌入的方式，并且可以通过使用 describe() 分支规则的方法。因此：

sage: branching_rule("E8","A1","vii").describe()
<BLANKLINE>
        O 2
        |
        |
O---O---O---O---O---O---O---O
1   3   4   5   6   7   8   0
E8~
root restrictions E8 => A1:
<BLANKLINE>
O
1
A1
<BLANKLINE>
1 => 1
2 => 1
3 => 1
4 => (zero)
5 => 1
6 => (zero)
7 => 1
8 => 1
<BLANKLINE>
For more detailed information use verbose=True

编写自己的分支规则

Sage有许多内置的分支规则。实际上，对于所有极大子群的分支规则，至少达到8级（包括所有例外群）都是作为内置规则实现的，除了少数可以使用 branching_rule_from_plethysm . 这意味着所有的规则 [McKayPatera1981] Sage提供。

在本节中，我们还将介绍如何手工编写规则。正如我们已经解释过的，分支规则是来自 G 到的权重格 H ，如果您提供这个，您可以编写自己的分支规则。

作为一个例子，让我们考虑如何实现分支规则 A3 -> C2 . 在这里 H = C2 = Sp(4) 作为子组嵌入 A3 = GL(4) . 卡坦子代数 hbox{{Lie}}(U) 由具有特征值的对角矩阵组成 u1, u2, -u2, -u1 . 然后 C2.space() 是由线性泛函组成的二维向量空间 u1 和 u2 在 U . 另一方面 Lie(T) = mathbf{{R}}^4 . 查看限制的一个方便方法是将其视为映射的伴随项 [u1,u2] -> [u1,u2,-u2,-u1] 也就是说， [x0,x1,x2,x3] -> [x0-x3,x1-x2] . 因此，我们可以对规则进行编码：

def brule(x):
    return [x[0]-x[3], x[1]-x[2]]

或者简单地说：

brule = lambda x: [x[0]-x[3], x[1]-x[2]]

让我们检查一下这是否符合内置规则：

sage: A3 = WeylCharacterRing(['A', 3])
sage: C2 = WeylCharacterRing(['C', 2])
sage: brule = lambda x: [x[0]-x[3], x[1]-x[2]]
sage: A3(1,1,0,0).branch(C2, rule=brule)
C2(0,0) + C2(1,1)
sage: A3(1,1,0,0).branch(C2, rule="symmetric")
C2(0,0) + C2(1,1)

虽然这是可行的，但最好将规则作为 BranchingRule 类，如下所示。

sage: brule = BranchingRule("A3","C2",lambda x : [x[0]-x[3], x[1]-x[2]],"custom")
sage: A3(1,1,0,0).branch(C2, rule=brule)
C2(0,0) + C2(1,1)

自同构与三性

在什么情况下 G=H 可以看作是分支规则的一个特例。在大多数情况下，如果 G 有一个非平凡的外自同构，它有二阶，对应于Dynkin图的对称性。这种对合存在于案件中 A_r ， D_r ， E_6 .

所以自同构作用于 G ，并且可以使用分支规则代码计算其效果：

sage: A4 = WeylCharacterRing("A4",style="coroots")
sage: A4(1,0,1,0).degree()
45
sage: A4(0,1,0,1).degree()
45
sage: A4(1,0,1,0).branch(A4,rule="automorphic")
A4(0,1,0,1)

在特殊情况下 G=D4 ，Dynkin图具有额外的对称性，这些对称性对应于群的外部自同构。它们被实现为 "triality" 分支规则：

sage: branching_rule("D4","D4","triality").describe()
<BLANKLINE>
    O 4
    |
    |
O---O---O
1   |2  3
    |
    O 0
D4~
root restrictions D4 => D4:
<BLANKLINE>
    O 4
    |
    |
O---O---O
1   2   3
D4
<BLANKLINE>
1 => 3
2 => 2
3 => 4
4 => 1
<BLANKLINE>
For more detailed information use verbose=True

三位一体不是的自同构 SO(8) 但是它的双层封面 spin(8) . 注意 spin(8) 有三个8度的表示，即 SO(8) 以及两个八维自旋表示。这些都是由三位一体来排列的：

sage: D4=WeylCharacterRing("D4",style="coroots")
sage: D4(0,0,0,1).branch(D4,rule="triality")
D4(1,0,0,0)
sage: D4(0,0,0,1).branch(D4,rule="triality").branch(D4,rule="triality")
D4(0,0,1,0)
sage: D4(0,0,0,1).branch(D4,rule="triality").branch(D4,rule="triality").branch(D4,rule="triality")
D4(0,0,0,1)

相比之下， rule="automorphic" 简单地交换两个自旋表示，就像在类型中一样 D ：：

sage: D4(0,0,0,1).branch(D4,rule="automorphic")
D4(0,0,1,0)
sage: D4(0,0,1,0).branch(D4,rule="automorphic")
D4(0,0,0,1)