极大子群与分枝规则

分支规则

如果 G 是一个李群，并且 H 是一个子群，人们经常需要知道如何表示 G 限制为 H 。不可还原的通常不限于不可还原的。在某些情况下，限制是规则的和可预测的，在其他情况下，它是混乱的。在某些情况下，它遵循一个可以组合描述的规则，但组合描述是微妙的。对不可约物质如何分解成不可约物质的描述称为 branching rule 。

本主题的参考资料：

• [FauserEtAl2006]

• [King1975]

• [HoweEtAl2005]

• [McKayPatera1981]

智者可以计算出一个角色如何 G 仅限于 H 。要做到这一点，它不是通过记忆组合规则，而是通过计算字符并将字符限制在 H 。Sage记住的(在一系列内置编码规则中)是极大子群的极大环面的各种嵌入 G 。李群的极大子群在[1]中被确定 [Dynkin1952]. 这种计算分支规则的方法有一个限制：角色必须适合内存，并且可以由Sage的内部代码实时计算。

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

Sage有一门课 BranchingRule 用于分支规则。该功能 branching_rule 返回此类的元素。例如，自然嵌入 Sp(4) vt.进入，进入 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) 具有Cartan型 C2 在……里面 Sp(8) ，具有Cartan类型 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)]

分支规则中有什么？

The essence of the branching rule is a function from the weight lattice of G to the weight lattice of the subgroup H, usually implemented as a function on the ambient vector spaces. Indeed, we may conjugate the embedding so that a Cartan subalgebra U of H is contained in a Cartan subalgebra T of G. Since the ambient vector space of the weight lattice of G is hbox{Lie}(T)^*, we get map hbox{Lie}(T)^*tohbox{Lie}(U)^*, and this must be implemented as a function. For speed, the function usually just returns a list, which can be coerced into 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

图的扩展动态图 G 和普通的动态图 H 以供参考，以及 3 => 1 意味着第三个简单的根 alpha_3 的 G 的第一个简单根。 H 。在本例中，仿射根不限于简单根，因此从限制列表中将其省略。如果将参数添加到 verbose=true 您将看到所有单根和仿射根的限制，以及基本权的限制(以cooot记法表示)。

极大子群

对于每个简单Cartan类型的等级，SAGE都有一个极大子群的数据库 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) 进入Lie群 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) vt.进入，进入 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 有一个非平凡的动态图自同构，所以它有一个不是内部的外自同构：：

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 去掉一个结点，得到一个更小的动态金图，这是一个更小的子群的动态金图 H 。

例如，下面是A3动态金图：

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

Let us redo this calculation in coroot notation. As we have explained, coroot notation does not distinguish between representations of GL(4) that have the same restriction to SL(4), so in effect we are now working with the groups SL(4) and its Levi subgroups SL(3) and SL(2) times SL(2), which is the derived group of its Levi subgroup:

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

现在我们可以观察到在分支方面的区别

\[总帐(4)\总帐(2)\乘以总帐(2)\]

与

\[SL(4)\到SL(2)\乘以SL(2)。\]

Consider the representation A3(0,1,0), which is the six dimensional exterior square. In the coroot notation, the restriction contained two copies of the trivial representation, 2*A1xA1(0,0). The other way, we had instead three distinct representations in the restriction, namely A1xA1(1,1,0,0) and A1xA1(0,0,1,1), that is, det otimes 1 and 1 otimes det.

Levi子群 A1xA1 实际上并不是最大的。事实上，我们可以将嵌入因素考虑在内：

\[SL(2)\乘以SL(2)\to Sp(4)\to 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" ，但令人欣慰的是，我们得到了相同的答案！

用扩展动态图对子群进行分类

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

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

通过删除我们获得的1个节点进行观察 A_2 动态金图。因此，这一特殊群体 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 ，分别是迹零的八元数上的作用量和伴随表示。

对于此类型的嵌入，子群的秩为 H 与…的排名相同 G 。这与Levi类型的嵌入形成对比，其中 H 排名比 G 。

李维子群 G_2

杰出的群体 G_2 有两个Levi子群 A_1 。两者都不是极大的，正如我们可以从扩展的动态图中看到的：子群 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

If G = hbox{SO}(r+s) then G has a subgroup hbox{SO}(r) times hbox{SO}(s). This lifts to an embedding of the universal covering groups

\[\hbox{spin}(r) \times \hbox{spin}(s) \to \hbox{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 。以下是扩展的动态图：

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

删除4个顶点将生成断开连接的动态关系图：

  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)

但是我们同样可以使用“CONTROUTIC_SUM”规则：：

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 扩展的动态图：：

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

删除3个节点可实现：

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

这是动态金图或 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子群的动态图 H 的 G 的动态关系图中删除一个节点即可获得 G 。从扩展的动态图中删除相同的节点 G 的一个子群的动态图中的结果 G 这一数字严格大于 H 。然而，这个子群可能是适当的，也可能不是，因此Levi子群可能是最大的，也可能不是最大的。

如果Levi子群不是最大的，分支规则可能在Sage中实现，也可能不在Sage中实现。但是，如果没有实现，则可以将其构建为两个分支规则的组合。

例如，在SAGE-6.1之前 branching_rule("E6","A5","levi") 返回一个未实现的错误和分支到的建议 A5xA1 。我们可以从扩展的动态金图中看出 E_6 那确实是 A_5 不是极大子群，因为从扩展的动态图(见下文)中去掉节点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 它本身承认一种外自同构。群的动态金图 H 可以通过“折叠”不变量的动态图来获得 G 沿着自同构。分支规则是个例外 GL(2r) to SO(2r) 。

下面是可以使用以下命令获得的分支规则 rule="symmetric" 。

G	H	Cartan型
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]

张量积

If G_1 and G_2 are Lie groups, and we have representations pi_1: G_1 to GL(n) and pi_2: G_2 to GL(m) then the tensor product is a representation of G_1 times G_2. It has its image in GL(nm) but sometimes this is conjugate to a subgroup of SO(nm) or Sp(nm). In particular we have the following cases.

集团化	子群	Cartan型
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" 。

对称权

The k-th symmetric and exterior power homomorphisms map GL(n) to GL left(binom{n+k-1}{k} right) and GL left(binom{n}{k} right). The corresponding branching rules are not implemented but a special case is. The k-th symmetric power homomorphism SL(2) to GL(k+1) has its image inside of SO(2r+1) if k = 2r and inside of Sp(2r) if k = 2r-1. Hence there are branching rules:

['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)]

但下例给出了其他方法所不具备的分支规则：

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" 。

\[\begin{split}\begin{aligned} B_3 & \to G_2, \\ E_6 & \to A_2, \\ E_6 & \to G_2, \\ F_4 & \to G_2 \times A_1, \\ E_6 & \to G_2 \times A_2, \\ E_7 & \to G_2 \times C_3, \\ E_7 & \to F_4 \times A_1, \\ E_7 & \to A_1 \times A_1, \\ E_7 & \to G_2 \times A_1, \\ E_7 & \to A_2 \\ E_8 & \to G_2 \times F_4. \\ E_8 & \to A_2 \times A_1. \\ E_8 & \to B_2 \end{aligned}\end{split}\]

第一条规则对应于嵌入 G_2 在……里面 hbox{SO}(7) 在它对踪迹零八元离子的作用中。中的两个分支规则 E_6 至 G_2 或 A_2 中介绍了 [Testerman1989]. 我们提醒读者，那篇论文中的定理G.2，在正特征中被证明是关于复数的错误的。另一方面，特征的假设 p 对于描述环面嵌入的定理G.1和A.1来说并不重要，因此包含了足够的信息来计算分支规则。还有其他嵌入方式 G_2 或 A_2 vt.进入，进入 E_6 。这些嵌入可以由以下条件来表征： E_6 不折不扣地限制 G_2 或 A_2 。它们的像是极大子群。

其余规则如下所示。让我们 G BE F_4 ， E_6 ， E_7 或 E_8 ，并让 H BE G_2 ，否则(如果 G=E_7 ) F_4 。我们嵌入了 H vt.进入，进入 G 以最明显的方式；也就是在子群的链中

\[G_2\subset F_4\subset E_6 \subset E_7 \subset 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] 描述嵌入并以一种有趣的方式应用它。

The embedding of A_1times A_1 into E_7 is as follows. Deleting the 5 node of the E_7 Dynkin diagram gives the Dynkin diagram of A_4times A_2, so this is a Levi subgroup. We embed hbox{SL}(2) into this Levi subgroup via the representation [4]otimes[2]. This embeds the first copy of A_1. The other A_1 is the connected centralizer. See [Seitz1991], particularly the proof of (3.12).

嵌入IF G_2times A_1 vt.进入，进入 E_7 如下所示。删除的%2节点 E_7 动态金图给出了 A_6 Dykin图，它是Levi子群 hbox{SL}(7) 。我们嵌入了 G_2 vt.进入，进入 hbox{SL}(7) 通过不可约的七维表示 G_2 。这个 A_1 是居中的。

The embedding if A_2times A_1 into E_8 is as follows. Deleting the 2 node of the E_8 Dynkin diagram gives the A_7 Dynkin diagram, which is the Levi subgroup hbox{SL}(8). We embed A_2 into hbox{SL}(8) via the irreducible eight-dimensional adjoint representation of hbox{SL}(2). The A_1 is the centralizer.

嵌入 A_2 vt.进入，进入 E_7 已在 [Seitz1991] (5.8)。特别是，他计算 hbox{SL}(3) 环中的圆环 E_7 Torus，这是实现分支规则所需的。嵌入了 B_2 vt.进入，进入 E_8 也是构建在 [Seitz1991] (6.7)。嵌入 B_2 实现分支规则所需的Cartan子代数很容易从第111页的(10)中推导出来。

例外群的极大A1子群

有七个嵌入的 SL(2) 作为极大子群的例外群：每个子群 G_2 和 F_4 ，两个非共轭嵌入 E_7 还有三个是 E_8 这些都是在 [Testerman1992]. 创建相应的分支规则，如下所示。规则的名称是罗马数字，指的是泰斯特曼定理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；这基本上是Tester man描述嵌入的方式，并且该信息可以通过使用 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有许多内置的分支规则。实际上，除了少数可用来获得的规则之外，至少高达八阶(包括所有例外组)的到所有极大子群的分支规则被实现为内置规则 branching_rule_from_plethysm 。这意味着其中的所有规则 [McKayPatera1981] 均可在Sage中找到。

在这一节中，我们仍然包含手工编写规则的说明。正如我们已经解释过的，分支规则是来自的权格子的函数 G 到的权格子 H ，如果您提供此选项，则可以编写您自己的分支规则。

例如，让我们考虑如何实现分支规则 A3 -> C2 。这里 H = C2 = Sp(4) 作为子组嵌入在 A3 = GL(4) 。Cartan子代数 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 有一个非平凡的外自同构，它有二阶，对应于动态图的对称性。这样的卷曲存在于案件中。 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 ，动态图具有额外的对称性，这些对称性对应于群的外自同构。这些被实现为 "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

Triality His并不是 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)